/
SimulationThread.cpp
117 lines (91 loc) · 3.76 KB
/
SimulationThread.cpp
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
#include <Core/ModelicaDefine.h>
#include <Core/Modelica.h>
#include <Core/SimController/threading/SimulationThread.h>
#include <Core/SimController/SimObjects.h>
SimulationThread::SimulationThread(Communicator* communicator)
:_communicator(communicator)
{
}
SimulationThread::~SimulationThread(void)
{
}
//void SimulationThread::setSimManager(shared_ptr<SimManager> simManager)
//{
// _simMgr = simManager;
//}
/**
Run method of the simulation thread in which the simulation is executed
*/
void SimulationThread::Run(shared_ptr<SimManager> simManager, shared_ptr<IGlobalSettings> global_settings, shared_ptr<IMixedSystem> system, shared_ptr<ISimObjects> sim_objects, string modelKey)
{
try
{
#ifdef RUNTIME_PROFILING
if (MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[0], simControllerInitializeHandler);
measuredFunctionStartValues->reset();
measuredFunctionEndValues->reset();
MEASURETIME_START(measuredFunctionStartValues, simControllerSolveInitialSystemHandler, "SolveInitialSystem");
}
#endif
_simManager = simManager;
bool starting = _communicator->waitForSimulationStarting(1);
if (starting)
{
_communicator->setSimStarted();
#ifdef RUNTIME_PROFILING
if (MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[1], simControllerSolveInitialSystemHandler);
MeasureTime::addResultContentBlock(mixedsystem->getModelName(), "simController", measureTimeFunctionsArray);
}
#endif
high_resolution_clock::time_point t_s = high_resolution_clock::now();
simManager->runSimulation();
high_resolution_clock::time_point t1 = high_resolution_clock::now();
seconds elapsed = duration_cast<std::chrono::seconds>(t1 - t_s);
cout << "time for simulation: " << elapsed.count();
if (global_settings->getOutputFormat() == BUFFER)
{
shared_ptr<IWriteOutput> writeoutput_system = dynamic_pointer_cast<IWriteOutput>(system);
shared_ptr<ISimData> simData = sim_objects->getSimData(modelKey);
simData->clearResults();
//get history object to query simulation results
shared_ptr<IHistory> history = writeoutput_system->getHistory();
//simulation results (output variables)
ublas::matrix<double> Ro;
//query simulation result outputs
history->getOutputResults(Ro);
vector<string> output_names;
history->getOutputNames(output_names);
int j = 0;
FOREACH(string & name, output_names)
{
ublas::vector<double> o_j;
o_j = ublas::row(Ro, j);
simData->addOutputResults(name, o_j);
j++;
}
vector<double> time_values = history->getTimeEntries();
simData->addTimeEntries(time_values);
}
_communicator->setSimStoped();
}
else
{
string error = string("Simulation failed for ") + modelKey;
throw ModelicaSimulationError(SIMMANAGER, error);
}
}
catch (ModelicaSimulationError& ex)
{
string error = add_error_info(string("Simulation failed for ") + modelKey, ex.what(), ex.getErrorID());
throw ModelicaSimulationError(SIMMANAGER, error, "", ex.isSuppressed());
}
}
void SimulationThread::Stop()
{
if (_simManager)
_simManager->stopSimulation();
}