-
Notifications
You must be signed in to change notification settings - Fork 298
/
Peer.h
188 lines (140 loc) · 4.64 KB
/
Peer.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
#pragma once
#include "FactoryExport.h"
#include <Core/Solver/SolverDefaultImplementation.h>
#include <Core/Utils/extension/measure_time.hpp>
/*****************************************************************************/
// Peer
// BDF-Verfahren für steife und nicht-steife ODEs
// Dokumentation siehe offizielle Peer Doku
/*****************************************************************************
Copyright (c) 2014, IWR TU Dresden, All rights reserved
*****************************************************************************/
#if defined(USE_MPI) || defined(USE_OPENMP)
class Peer
: public ISolver, public SolverDefaultImplementation
{
public:
Peer(IMixedSystem* system, ISolverSettings* settings);
virtual ~Peer();
// geerbt von Object (in SolverDefaultImplementation)
//---------------------------------------
/// Spezielle Solvereinstellungen setzten (default oder user defined)
virtual void initialize();
// geerbt von ISolver
//---------------------------------------
/// Setzen der Startzeit für die numerische Lösung
virtual void setStartTime(const double& time)
{
SolverDefaultImplementation::setStartTime(time);
};
/// Setzen der Endzeit für die numerische Lösung
virtual void setEndTime(const double& time)
{
SolverDefaultImplementation::setEndTime(time);
};
/// Setzen der initialen Schrittweite (z.B. auch nach Nullstelle)
virtual void setInitStepSize(const double& stepSize)
{
SolverDefaultImplementation::setInitStepSize(stepSize);
};
/// Berechung der numerischen Lösung innerhalb eines gegebenen Zeitintervalls
virtual void solve(const SOLVERCALL command = UNDEF_CALL);
/// Liefert den Status des Solvers nach Beendigung der Simulation
virtual ISolver::SOLVERSTATUS getSolverStatus()
{
return (SolverDefaultImplementation::getSolverStatus());
};
//// Ausgabe von statistischen Informationen (wird vom SimManager nach Abschluß der Simulation aufgerufen)
virtual void writeSimulationInfo();
virtual int reportErrorMessage(std::ostream& messageStream);
virtual bool stateSelection();
virtual void setTimeOut(unsigned int time_out);
virtual void stop();
private:
// Nulltellenfunktion
void writePeerOutput(const double &time,const double &h,const int &stp);
void evalJ(const double& t, const double* z, double* T, IContinuous *continuousSystem, ITime *timeSystem, double fac=1);
void evalF(const double& t, const double* z, double* f, IContinuous *continuousSystem, ITime *timeSystem);
void evalD(const double& t, const double* y, double* T, IContinuous *continuousSystem, ITime *timeSystem);
void setcycletime(double cycletime);
void ros2(double * y, double& tstart, double tend, IContinuous *continuousSystem, ITime *timeSystem);
ISolverSettings
*_peersettings; ///< Input - Solver settings
long int
_dimSys; ///< Input - (total) Dimension of system (=number of ODE)
int
_rstages,
_rank,
_size,
_reuseJacobi,
_numThreads;
long int
*_P;
double
*_G,
*_E,
*_Theta,
*_c,
*_F,
*_y,
*_Y1,
*_Y2,
*_Y3,
*_T,
_h,
_hOut;
// Variables for Coloured Jacobians
// int _sizeof_sparsePattern_colorCols;
// int* _sparsePattern_colorCols;
//
// int _sizeof_sparsePattern_leadindex;
// int* _sparsePattern_leadindex;
//
//
// int _sizeof_sparsePattern_index;
// int* _sparsePattern_index;
//
//
// int _sparsePattern_maxColors;
//
// bool _cvode_initialized;
// ISystemProperties* _properties;
IContinuous* _continuous_system[5];
// IEvent* _event_system;
// IMixedSystem* _mixed_system;
ITime* _time_system[5];
// std::vector<MeasureTimeData> measureTimeFunctionsArray;
// MeasureTimeValues *measuredFunctionStartValues, *measuredFunctionEndValues;
};
#else
class Peer : public ISolver, public SolverDefaultImplementation
{
public:
Peer(IMixedSystem* system, ISolverSettings* settings) : ISolver(), SolverDefaultImplementation(system, settings)
{
throw std::runtime_error("Peer solver is not available.");
}
virtual void setStartTime(const double& time)
{}
virtual void setEndTime(const double& time)
{}
virtual void setInitStepSize(const double& stepSize)
{}
virtual void initialize()
{}
virtual bool stateSelection()
{
throw std::runtime_error("Peer solver is not available.");
}
virtual void solve(const SOLVERCALL command = UNDEF_CALL)
{}
virtual SOLVERSTATUS getSolverStatus()
{ return UNDEF_STATUS; }
virtual void setTimeOut(unsigned int time_out)
{}
virtual void stop()
{}
virtual void writeSimulationInfo()
{}
};
#endif