void Cvode::giveZeroVal(const double &t, const double *y, double *zeroValue)
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(cvodeEvalZeroHandler, "evaluateZeroFuncs");
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(measuredFunctionStartValues, cvodeEvalZeroHandler, "evaluateZeroFuncs");
}
#endif
_time_system->setTime(t);
_continuous_system->setContinuousStates(y);
// System aktualisieren
_continuous_system->evaluateZeroFuncs(IContinuous::DISCRETE);
_event_system->getZeroFunc(zeroValue);
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[3], cvodeEvalZeroHandler);
}
#endif
}
void Ida::giveZeroVal(const double &t, const double *y,const double *yp,double *zeroValue)
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(idaEvalZeroHandler, "evaluateZeroFuncs");
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(measuredFunctionStartValues, idaEvalZeroHandler, "evaluateZeroFuncs");
}
#endif
_time_system->setTime(t);
_continuous_system->setContinuousStates(y);
if(_dimAE>0)
{
_mixed_system->setAlgebraicDAEVars(y+_dimStates);
_continuous_system->setStateDerivatives(yp);
}
// System aktualisieren
_continuous_system->evaluateZeroFuncs(IContinuous::DISCRETE);
_event_system->getZeroFunc(zeroValue);
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[3], idaEvalZeroHandler);
}
#endif
}
void SolverDefaultImplementation::writeToFile(const int& stp, const double& t, const double& h)
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(writeFunctionStartValues, "solverWriteOutput");
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(writeFunctionStartValues, solverWriteOutputHandler, "solverWriteOutput");
}
#endif
if(_settings->getGlobalSettings()->getOutputFormat()!= EMPTY)
{
IWriteOutput* writeoutput_system = dynamic_cast<IWriteOutput*>(_system);
if(_outputCommand & IWriteOutput::WRITEOUT)
{
writeoutput_system->writeOutput(_outputCommand);
}
}
checkTimeout();
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(writeFunctionStartValues, writeFunctionEndValues, measureTimeFunctionsArray[0], solverWriteOutputHandler);
}
#endif
}
int Ida::calcFunction(const double& time, const double* y, double* f)
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(idaCalcFunctionHandler, "IDACalcFunction");
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(measuredFunctionStartValues, idaCalcFunctionHandler, "IDACalcFunction");
}
#endif
int returnValue = 0;
try
{
_time_system->setTime(time);
_continuous_system->setContinuousStates(y);
_continuous_system->evaluateODE(IContinuous::CONTINUOUS);
_continuous_system->getRHS(f);
} //workaround until exception can be catch from c- libraries
catch (std::exception& ex)
{
std::string error = ex.what();
cerr << "IDA integration error: " << error;
returnValue = -1;
}
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[0], idaCalcFunctionHandler);
}
#endif
return returnValue;
}
int Ida::calcFunction(const double& time, const double* y, double *yp,double* res)
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(idaCalcFunctionHandler, "IDACalcFunction");
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(measuredFunctionStartValues, idaCalcFunctionHandler, "IDACalcFunction");
}
#endif
int returnValue = 0;
try
{
if(_dimAE>0)
{
_time_system->setTime(time);
_continuous_system->setContinuousStates(y);
_continuous_system->setStateDerivatives(yp);
_mixed_system->setAlgebraicDAEVars(y+_dimStates);
_continuous_system->evaluateDAE(IContinuous::CONTINUOUS);
_mixed_system->getResidual(res);
}
else
{
_time_system->setTime(time);
_continuous_system->setContinuousStates(y);
_continuous_system->evaluateODE(IContinuous::CONTINUOUS);
_continuous_system->getRHS(res);
for(size_t i(0); i<_dimSys; ++i)
res[i]-=yp[i];
}
} //workaround until exception can be catch from c- libraries
catch (std::exception& ex)
{
std::string error = ex.what();
cerr << "IDA integration error: " << error;
returnValue = -1;
}
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[0], idaCalcFunctionHandler);
}
#endif
return returnValue;
}
void SimManager::runSimulation()
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(runSimHandler, "runSimulation");
if (MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(runSimStartValues, runSimHandler, "runSimulation");
}
#endif
try
{
Logger::write("SimManager: start simulation at t = " + boost::lexical_cast<std::string>(_tStart),LC_SOLV,LL_INFO);
runSingleProcess();
// Zeit messen, Ausgabe der SimInfos
ISolver::SOLVERSTATUS status = _solver->getSolverStatus();
if ((status & ISolver::DONE) || (status & ISolver::USER_STOP))
{
Logger::write("SimManager: simulation done at t = " + boost::lexical_cast<std::string>(_tEnd),LC_SOLV,LL_INFO);
Logger::write("SimManager: number of steps = " + boost::lexical_cast<std::string>(_totStps),LC_SOLV,LL_INFO);
writeProperties();
}
}
catch (std::exception & ex)
{
Logger::write("SimManager: simulation finish with errors at t = " + boost::lexical_cast<std::string>(_tEnd),LC_SOLV,LL_ERROR);
Logger::write("SimManager: number of steps = " + boost::lexical_cast<std::string>(_totStps),LC_SOLV,LL_INFO);
writeProperties();
Logger::write("SimManager: error = " + boost::lexical_cast<std::string>(ex.what()),LC_SOLV,LL_ERROR);
//ex << error_id(SIMMANAGER);
throw;
}
#ifdef RUNTIME_PROFILING
if (MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(runSimStartValues, runSimEndValues, measureTimeFunctionsArray[1], runSimHandler);
}
#endif
}
void SimManager::runSimulation()
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(runSimHandler, "runSimulation");
if (MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(runSimStartValues, runSimHandler, "runSimulation");
}
#endif
try
{
LOGGER_WRITE("SimManager: Start simulation at t = " + to_string(_tStart), LC_SOLV, LL_INFO);
runSingleProcess();
// Measure time; Output SimInfos
ISolver::SOLVERSTATUS status = _solver->getSolverStatus();
if ((status & ISolver::DONE) || (status & ISolver::USER_STOP))
{
//LOGGER_WRITE("SimManager: Simulation done at t = " + to_string(_tEnd), LC_SOLV, LL_INFO);
writeProperties();
}
}
catch (std::exception & ex)
{
LOGGER_WRITE("SimManager: Simulation finish with errors at t = " + to_string(_tEnd), LC_SOLV, LL_ERROR);
writeProperties();
LOGGER_WRITE("SimManager: Error = " + string(ex.what()), LC_SOLV, LL_ERROR);
//ex << error_id(SIMMANAGER);
throw;
}
#ifdef RUNTIME_PROFILING
if (MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(runSimStartValues, runSimEndValues, (*measureTimeFunctionsArray)[1], runSimHandler);
}
#endif
}
int Cvode::calcFunction(const double& time, const double* y, double* f)
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(cvodeCalcFunctionHandler, "CVodeCalcFunction");
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(measuredFunctionStartValues, cvodeCalcFunctionHandler, "CVodeCalcFunction");
}
#endif
int returnValue = 0;
try
{
f[0] = 0.0; // in case of dummy state
_time_system->setTime(time);
_continuous_system->setContinuousStates(y);
_continuous_system->evaluateODE(IContinuous::CONTINUOUS);
_continuous_system->getRHS(f);
_numberOfOdeEvaluations++;
} //workaround until exception can be catch from c- libraries
catch (std::exception & ex )
{
//cerr << "CVode integration error: " << diagnostic_information(ex);
returnValue = 1;
}
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[0], cvodeCalcFunctionHandler);
}
#endif
return returnValue;
}
void Ida::writeIDAOutput(const double &time, const double &h, const int &stp)
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(idaWriteOutputHandler, "IDAWriteOutput");
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(measuredFunctionStartValues, idaWriteOutputHandler, "IDAWriteOutput");
}
#endif
if (stp > 0)
{
if (_idasettings->getDenseOutput())
{
_bWritten = false;
double *oldValues = NULL;
//We have to find all output-points within the last solver step
while (_tLastWrite + dynamic_cast<ISolverSettings*>(_idasettings)->getGlobalSettings()->gethOutput() <= time)
{
if (!_bWritten)
{
//Rescue the calculated derivatives
oldValues = new double[_continuous_system->getDimRHS()];
_continuous_system->getRHS(oldValues);
}
_bWritten = true;
_tLastWrite = _tLastWrite + dynamic_cast<ISolverSettings*>(_idasettings)->getGlobalSettings()->gethOutput();
//Get the state vars at the output-point (interpolated)
_idid = IDAGetDky(_idaMem, _tLastWrite, 0, _CV_yWrite);
_time_system->setTime(_tLastWrite);
_continuous_system->setContinuousStates(NV_DATA_S(_CV_yWrite));
if(_dimAE>0)
{
_mixed_system->setAlgebraicDAEVars(NV_DATA_S(_CV_y)+_dimStates);
_idid = IDAGetDky(_idaMem, _tLastWrite, 1, _CV_ypWrite);
_continuous_system->setStateDerivatives(NV_DATA_S(_CV_ypWrite));
_continuous_system->evaluateDAE(IContinuous::CONTINUOUS);
}
else
{
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
}
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[2], idaWriteOutputHandler);
}
#endif
SolverDefaultImplementation::writeToFile(stp, _tLastWrite, h);
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(idaWriteOutputHandler, "IDAWriteOutput");
if(MeasureTime::getInstance() != NULL)
{
(*measureTimeFunctionsArray)[2]->_sumMeasuredValues->_numCalcs--;
MEASURETIME_START(measuredFunctionStartValues, idaWriteOutputHandler, "IDAWriteOutput");
}
#endif
} //end if time -_tLastWritten
if (_bWritten)
{
_time_system->setTime(time);
_continuous_system->setContinuousStates(_y);
_continuous_system->setStateDerivatives(oldValues);
if(_dimAE>0)
{
_mixed_system->setAlgebraicDAEVars(_y+_dimStates);
}
delete[] oldValues;
}
else if (time == _tEnd && _tLastWrite != time)
{
_idid = IDAGetDky(_idaMem, time, 0, _CV_y);
_idid = IDAGetDky(_idaMem, time, 1, _CV_yp);
_time_system->setTime(time);
_continuous_system->setContinuousStates(NV_DATA_S(_CV_y));
if(_dimAE>0)
{
_mixed_system->setAlgebraicDAEVars(NV_DATA_S(_CV_y)+_dimStates);
_continuous_system->setStateDerivatives(NV_DATA_S(_CV_yp));
_continuous_system->evaluateDAE(IContinuous::CONTINUOUS);
}
else
{
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
}
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[2], idaWriteOutputHandler);
}
#endif
SolverDefaultImplementation::writeToFile(stp, _tEnd, h);
}
}
else
{
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[2], idaWriteOutputHandler);
}
#endif
SolverDefaultImplementation::writeToFile(stp, time, h);
}
}
}
void Ida::IDACore()
{
_idid = IDAReInit(_idaMem, _tCurrent, _CV_y,_CV_yp);
_idid = IDASetStopTime(_idaMem, _tEnd);
_idid = IDASetInitStep(_idaMem, 1e-12);
if (_idid < 0)
throw std::runtime_error("IDA::ReInit");
bool writeEventOutput = (_settings->getGlobalSettings()->getOutputPointType() == OPT_ALL);
bool writeOutput = !(_settings->getGlobalSettings()->getOutputPointType() == OPT_NONE);
while ((_solverStatus & ISolver::CONTINUE) && !_interrupt )
{
_cv_rt = IDASolve(_idaMem, _tEnd, &_tCurrent, _CV_y, _CV_yp, IDA_ONE_STEP);
_idid = IDAGetNumSteps(_idaMem, &_locStps);
if (_idid != IDA_SUCCESS)
throw std::runtime_error("IDAGetNumSteps failed. The ida mem pointer is NULL");
_idid =IDAGetLastStep(_idaMem, &_h);
if (_idid != IDA_SUCCESS)
throw std::runtime_error("IDAGetLastStep failed. The ida mem pointer is NULL");
//Check if there was at least one output-point within the last solver interval
// -> Write output if true
if (writeOutput)
{
writeIDAOutput(_tCurrent, _h, _locStps);
}
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(idaStepCompletedHandler, "IDAStepCompleted");
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(measuredFunctionStartValues, idaStepCompletedHandler, "IDAStepCompleted");
}
#endif
//set completed step to system and check if terminate was called
if(_continuous_system->stepCompleted(_tCurrent))
_solverStatus = DONE;
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[5], idaStepCompletedHandler);
}
#endif
// Perform state selection
bool state_selection = stateSelection();
if (state_selection)
_continuous_system->getContinuousStates(_y);
_zeroFound = false;
// Check if step was successful
if (check_flag(&_cv_rt, "IDA", 1))
{
_solverStatus = ISolver::SOLVERERROR;
break;
}
// A root was found
if ((_cv_rt == IDA_ROOT_RETURN) && !isInterrupted())
{
// IDA is setting _tCurrent to the time where the first event occurred
double _abs = fabs(_tLastEvent - _tCurrent);
_zeroFound = true;
if ((_abs < 1e-3) && _event_n == 0)
{
_tLastEvent = _tCurrent;
_event_n++;
}
else if ((_abs < 1e-3) && (_event_n >= 1 && _event_n < 500))
{
_event_n++;
}
else if ((_abs >= 1e-3))
{
//restart event counter
_tLastEvent = _tCurrent;
_event_n = 0;
}
else
throw std::runtime_error("Number of events exceeded in time interval " + to_string(_abs) + " at time " + to_string(_tCurrent));
// IDA has interpolated the states at time 'tCurrent'
_time_system->setTime(_tCurrent);
// To get steep steps in the result file, two value points (P1 and P2) must be added
//
// Y | (P2) X...........
// | :
// | :
// |........X (P1)
// |---------------------------------->
// | ^ t
// _tCurrent
// Write the values of (P1)
if (writeEventOutput)
{
if(_dimAE>0)
{
_continuous_system->evaluateDAE(IContinuous::CONTINUOUS);
}
else
{
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
}
writeToFile(0, _tCurrent, _h);
}
_idid = IDAGetRootInfo(_idaMem, _zeroSign);
for (int i = 0; i < _dimZeroFunc; i++)
_events[i] = bool(_zeroSign[i]);
if (_mixed_system->handleSystemEvents(_events))
{
// State variables were reinitialized, thus we have to give these values to the ida-solver
// Take care about the memory regions, _z is the same like _CV_y
_continuous_system->getContinuousStates(_y);
if(_dimAE>0)
{
_mixed_system->getAlgebraicDAEVars(_y+_dimStates);
_continuous_system->getRHS(_yp);
}
calcFunction(_tCurrent, NV_DATA_S(_CV_y), NV_DATA_S(_CV_yp),_dae_res);
}
}
if ((_zeroFound || state_selection)&& !isInterrupted())
{
// Write the values of (P2)
if (writeEventOutput)
{
// If we want to write the event-results, we should evaluate the whole system again
if(_dimAE>0)
{
_continuous_system->evaluateDAE(IContinuous::CONTINUOUS);
}
else
{
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
}
writeToFile(0, _tCurrent, _h);
}
_idid = IDAReInit(_idaMem, _tCurrent, _CV_y,_CV_yp);
if (_idid < 0)
throw std::runtime_error("IDA::ReInit()");
// Der Eventzeitpunkt kann auf der Endzeit liegen (Time-Events). In diesem Fall wird der Solver beendet, da IDA sonst eine interne Warnung schmeißt
if (_tCurrent == _tEnd)
_cv_rt = IDA_TSTOP_RETURN;
}
// Zähler für die Anzahl der ausgegebenen Schritte erhöhen
++_outStps;
_tLastSuccess = _tCurrent;
if (_cv_rt == IDA_TSTOP_RETURN)
{
_time_system->setTime(_tEnd);
_continuous_system->setContinuousStates(NV_DATA_S(_CV_y));
if(_dimAE>0)
{
_mixed_system->setAlgebraicDAEVars(NV_DATA_S(_CV_y)+_dimStates);
_continuous_system->setStateDerivatives(NV_DATA_S(_CV_yp));
_continuous_system->evaluateDAE(IContinuous::CONTINUOUS);
}
else
{
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
}
if(writeOutput)
writeToFile(0, _tEnd, _h);
_accStps += _locStps;
_solverStatus = DONE;
}
}
}
void Ida::solve(const SOLVERCALL action)
{
bool writeEventOutput = (_settings->getGlobalSettings()->getOutputPointType() == OPT_ALL);
bool writeOutput = !(_settings->getGlobalSettings()->getOutputPointType() == OPT_NONE);
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(idaSolveFunctionHandler, "solve");
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(solveFunctionStartValues, idaSolveFunctionHandler, "solve");
}
#endif
if (_idasettings && _system)
{
// Solver und System für Integration vorbereiten
if ((action & RECORDCALL) && (action & FIRST_CALL))
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(idaInitializeHandler, "IDAInitialize");
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(measuredFunctionStartValues, idaInitializeHandler, "IDAInitialize");
}
#endif
initialize();
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[4], idaInitializeHandler);
}
#endif
if (writeOutput)
writeToFile(0, _tCurrent, _h);
_tLastWrite = 0;
return;
}
if ((action & RECORDCALL) && !(action & FIRST_CALL))
{
writeToFile(_accStps, _tCurrent, _h);
return;
}
// Nach einem TimeEvent wird der neue Zustand recorded
if (action & RECALL)
{
_firstStep = true;
if (writeEventOutput)
writeToFile(0, _tCurrent, _h);
if (writeOutput)
writeIDAOutput(_tCurrent, _h, _locStps);
_continuous_system->getContinuousStates(_y);
}
// Solver soll fortfahren
_solverStatus = ISolver::CONTINUE;
while ((_solverStatus & ISolver::CONTINUE) && !_interrupt )
{
// Zuvor wurde initialize aufgerufen und hat funktioniert => RESET IDID
if (_idid == 5000)
_idid = 0;
// Solveraufruf
if (_idid == 0)
{
// Zähler zurücksetzen
_accStps = 0;
_locStps = 0;
// Solverstart
IDACore();
}
// Integration war nicht erfolgreich und wurde auch nicht vom User unterbrochen
if (_idid != 0 && _idid != 1)
{
_solverStatus = ISolver::SOLVERERROR;
//throw std::invalid_argument(_idid,_tCurrent,"IDA::solve()");
throw std::invalid_argument("IDA::solve()");
}
// Abbruchkriterium (erreichen der Endzeit)
else if ((_tEnd - _tCurrent) <= dynamic_cast<ISolverSettings*>(_idasettings)->getEndTimeTol())
_solverStatus = DONE;
}
_firstCall = false;
}
else
{
throw std::invalid_argument("IDA::solve()");
}
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(solveFunctionStartValues, solveFunctionEndValues, (*measureTimeFunctionsArray)[1], idaSolveFunctionHandler);
long int nst, nfe, nsetups, netf, nni, ncfn;
int qlast, qcur;
realtype h0u, hlast, hcur, tcur;
int flag;
flag = IDAGetIntegratorStats(_idaMem, &nst, &nfe, &nsetups, &netf, &qlast, &qcur, &h0u, &hlast, &hcur, &tcur);
flag = IDAGetNonlinSolvStats(_idaMem, &nni, &ncfn);
MeasureTimeValuesSolver solverVals = MeasureTimeValuesSolver(nfe, netf);
(*measureTimeFunctionsArray)[6]->_sumMeasuredValues->_numCalcs += nst;
(*measureTimeFunctionsArray)[6]->_sumMeasuredValues->add(&solverVals);
}
#endif
}
void SimManager::initialize()
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(initSimHandler, "initializeSimulation");
if (MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(initSimStartValues, initSimHandler, "initializeSimulation");
}
#endif
_cont_system = dynamic_pointer_cast<IContinuous>(_mixed_system);
_timeevent_system = dynamic_pointer_cast<ITime>(_mixed_system);
_event_system = dynamic_pointer_cast<IEvent>(_mixed_system);
_step_event_system = dynamic_pointer_cast<IStepEvent>(_mixed_system);
// Check dynamic casts
if (!_event_system)
{
throw ModelicaSimulationError(SIMMANAGER,"Could not get event system.");
}
if (!_cont_system)
{
throw ModelicaSimulationError(SIMMANAGER,"Could not get continuous-event system.");
}
if (!_timeevent_system)
{
throw ModelicaSimulationError(SIMMANAGER,"Could not get time-event system.");
}
if (!_step_event_system)
{
throw ModelicaSimulationError(SIMMANAGER,"Could not get step-event system.");
}
LOGGER_WRITE("SimManager: Start initialization",LC_INIT,LL_DEBUG);
// Reset debug ID
_dbgId = 0;
try
{
// Build up system and update once
_initialization->initializeSystem();
}
catch (std::exception& ex)
{
//ex << error_id(SIMMANAGER);
throw ModelicaSimulationError(SIMMANAGER,"Could not initialize system.",string(ex.what()),false);
}
if (_timeevent_system)
{
_dimtimeevent = _timeevent_system->getDimTimeEvent();
if (_timeEventCounter)
delete[] _timeEventCounter;
_timeEventCounter = new int[_dimtimeevent];
memset(_timeEventCounter, 0, _dimtimeevent * sizeof(int));
// compute sampleCycles for RT simulation
if (_config->getGlobalSettings()->useEndlessSim())
{
if (_sampleCycles)
delete[] _sampleCycles;
_sampleCycles = new int[_dimtimeevent];
computeSampleCycles();
}
}
else
_dimtimeevent = 0;
_tStart = _config->getGlobalSettings()->getStartTime();
_tEnd = _config->getGlobalSettings()->getEndTime();
// Set flag for endless simulation (if solver returns)
_continueSimulation = _tEnd > _tStart;
// _solver->setTimeOut(_config->getGlobalSettings()->getAlarmTime());
_dimZeroFunc = _event_system->getDimZeroFunc();
_solverTask = ISolver::SOLVERCALL(ISolver::FIRST_CALL);
if (_dimZeroFunc == _event_system->getDimZeroFunc())
{
if (_events)
delete[] _events;
_events = new bool[_dimZeroFunc];
memset(_events, false, _dimZeroFunc * sizeof(bool));
}
LOGGER_WRITE("SimManager: Assemble completed",LC_INIT,LL_DEBUG);
//#if defined(__TRICORE__) || defined(__vxworks)
// Initialization for RT simulation
if (_config->getGlobalSettings()->useEndlessSim())
{
_cycleCounter = 0;
_resetCycle = _sampleCycles[0];
for (int i = 1; i < _dimtimeevent; i++)
_resetCycle *= _sampleCycles[i];
// All Events are updated every cycle. In order to have a change in timeEventCounter, the reset is set to two
if(_resetCycle == 1)
_resetCycle++;
_solver->initialize();
}
//#endif
#ifdef RUNTIME_PROFILING
if (MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(initSimStartValues, initSimEndValues, (*measureTimeFunctionsArray)[0], initSimHandler);
}
#endif
}
void Cvode::writeCVodeOutput(const double &time, const double &h, const int &stp)
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(cvodeWriteOutputHandler, "CVodeWriteOutput");
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(measuredFunctionStartValues, cvodeWriteOutputHandler, "CVodeWriteOutput");
}
#endif
if (stp > 0)
{
if (_cvodesettings->getDenseOutput())
{
_bWritten = false;
/* double *oldValues = NULL;*/
//We have to find all output-points within the last solver step
while (_tLastWrite + dynamic_cast<ISolverSettings*>(_cvodesettings)->getGlobalSettings()->gethOutput() <= time)
{
if (!_bWritten)
{
_continuous_system->restoreOldValues();
////Rescue the calculated derivatives
// oldValues = new double[_continuous_system->getDimRHS()];
// _continuous_system->getRHS(oldValues);
}
_bWritten = true;
_tLastWrite = _tLastWrite + dynamic_cast<ISolverSettings*>(_cvodesettings)->getGlobalSettings()->gethOutput();
//Get the state vars at the output-point (interpolated)
_idid = CVodeGetDky(_cvodeMem, _tLastWrite, 0, _CV_yWrite);
_time_system->setTime(_tLastWrite);
_continuous_system->setContinuousStates(NV_DATA_S(_CV_yWrite));
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
SolverDefaultImplementation::writeToFile(stp, _tLastWrite, h);
} //end if time -_tLastWritten
if (_bWritten)
{
_time_system->setTime(time);
_continuous_system->setContinuousStates(_z);
_continuous_system->restoreNewValues();
/* _continuous_system->setRHS(oldValues);
delete[] oldValues;*/
}
else if (time == _tEnd && _tLastWrite != time)
{
_idid = CVodeGetDky(_cvodeMem, time, 0, _CV_y);
_time_system->setTime(time);
_continuous_system->setContinuousStates(NV_DATA_S(_CV_y));
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
SolverDefaultImplementation::writeToFile(stp, _tEnd, h);
}
}
else
{
SolverDefaultImplementation::writeToFile(stp, time, h);
}
}
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[2], cvodeWriteOutputHandler);
}
#endif
}
void SimManager::initialize()
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(initSimHandler, "initializeSimulation");
if (MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(initSimStartValues, initSimHandler, "initializeSimulation");
}
#endif
_cont_system = boost::dynamic_pointer_cast<IContinuous>(_mixed_system);
_timeevent_system = boost::dynamic_pointer_cast<ITime>(_mixed_system);
_event_system = boost::dynamic_pointer_cast<IEvent>(_mixed_system);
_step_event_system = boost::dynamic_pointer_cast<IStepEvent>(_mixed_system);
//Check dynamic casts
if (!_event_system)
{
std::cerr << "Could not get event system" << std::endl;
return;
}
if (!_cont_system)
{
std::cerr << "Could not get continuous-event system" << std::endl;
return;
}
if (!_timeevent_system)
{
std::cerr << "Could not get time-event system" << std::endl;
return;
}
if (!_step_event_system)
{
std::cerr << "Could not get step-event system" << std::endl;
return;
}
Logger::write("SimManager start init",LC_INIT,LL_DEBUG);
// Flag für Endlossimulaton (wird gesetzt wenn Solver zurückkommt)
_continueSimulation = true;
// Reset debug ID
_idid = 0;
try
{
// System zusammenbauen und einmal updaten
_initialization->initializeSystem();
}
catch (std::exception& ex)
{
//ex << error_id(SIMMANAGER);
throw;
}
_totStps = 0;
_accStps = 0;
_rejStps = 0;
if (_timeevent_system)
{
_dimtimeevent = _timeevent_system->getDimTimeEvent();
if (_timeeventcounter)
delete[] _timeeventcounter;
_timeeventcounter = new int[_dimtimeevent];
memset(_timeeventcounter, 0, _dimtimeevent * sizeof(int));
// compute sampleCycles for RT simulation
if (_config->getGlobalSettings()->useEndlessSim())
{
if (_sampleCycles)
delete[] _sampleCycles;
_sampleCycles = new int[_dimtimeevent];
computeSampleCycles();
}
}
else
_dimtimeevent = 0;
_tStart = _config->getGlobalSettings()->getStartTime();
_tEnd = _config->getGlobalSettings()->getEndTime();
// _solver->setTimeOut(_config->getGlobalSettings()->getAlarmTime());
_dimZeroFunc = _event_system->getDimZeroFunc();
_solverTask = ISolver::SOLVERCALL(ISolver::FIRST_CALL);
if (_dimZeroFunc == _event_system->getDimZeroFunc())
{
if (_events)
delete[] _events;
_events = new bool[_dimZeroFunc];
memset(_events, false, _dimZeroFunc * sizeof(bool));
}
Logger::write("SimManager assemble completed",LC_INIT,LL_DEBUG);
//#if defined(__TRICORE__) || defined(__vxworks)
// Initialization for RT simulation
if (_config->getGlobalSettings()->useEndlessSim())
{
_cycleCounter = 0;
_resetCycle = _sampleCycles[0];
for (int i = 1; i < _dimtimeevent; i++)
_resetCycle *= _sampleCycles[i];
// All Events are updated every cycle. In order to have a change in timeEventCounter, the reset is set to two
if(_resetCycle == 1)
_resetCycle++;
_solver->initialize();
}
//#endif
#ifdef RUNTIME_PROFILING
if (MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(initSimStartValues, initSimEndValues, measureTimeFunctionsArray[0], initSimHandler);
}
#endif
}
void SimController::Start(SimSettings simsettings, string modelKey)
{
try
{
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(simControllerInitializeHandler, "SimControllerInitialize");
MEASURETIME_REGION_DEFINE(simControllerSolveInitialSystemHandler, "SimControllerSolveInitialSystem");
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(measuredFunctionStartValues, simControllerInitializeHandler, "CVodeWriteOutput");
}
#endif
boost::shared_ptr<IMixedSystem> mixedsystem = getSystem(modelKey).lock();
IGlobalSettings* global_settings = _config->getGlobalSettings();
global_settings->setStartTime(simsettings.start_time);
global_settings->setEndTime(simsettings.end_time);
global_settings->sethOutput(simsettings.step_size);
global_settings->setResultsFileName(simsettings.outputfile_name);
global_settings->setSelectedLinSolver(simsettings.linear_solver_name);
global_settings->setSelectedNonLinSolver(simsettings.nonlinear_solver_name);
global_settings->setSelectedSolver(simsettings.solver_name);
global_settings->setLogSettings(simsettings.logSettings);
global_settings->setAlarmTime(simsettings.timeOut);
global_settings->setOutputPointType(simsettings.outputPointType);
/*boost::shared_ptr<SimManager>*/ _simMgr = boost::shared_ptr<SimManager>(new SimManager(mixedsystem, _config.get()));
ISolverSettings* solver_settings = _config->getSolverSettings();
solver_settings->setLowerLimit(simsettings.lower_limit);
solver_settings->sethInit(simsettings.lower_limit);
solver_settings->setUpperLimit(simsettings.upper_limit);
solver_settings->setRTol(simsettings.tolerance);
solver_settings->setATol(simsettings.tolerance);
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, measureTimeFunctionsArray[0], simControllerInitializeHandler);
measuredFunctionStartValues = MeasureTime::getZeroValues();
measuredFunctionEndValues = MeasureTime::getZeroValues();
MEASURETIME_START(measuredFunctionStartValues, simControllerSolveInitialSystemHandler, "SolveInitialSystem");
}
#endif
_simMgr->initialize();
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, measureTimeFunctionsArray[1], simControllerSolveInitialSystemHandler);
MeasureTime::addResultContentBlock(mixedsystem->getModelName(),"simController",&measureTimeFunctionsArray);
}
#endif
_simMgr->runSimulation();
boost::shared_ptr<IWriteOutput> writeoutput_system = boost::dynamic_pointer_cast<IWriteOutput>(mixedsystem);
boost::shared_ptr<ISimData> simData = getSimData(modelKey).lock();
//get history object to query simulation results
IHistory* history = writeoutput_system->getHistory();
//simulation results (output variables)
ublas::matrix<double> Ro;
//query simulation result otuputs
history->getOutputResults(Ro);
vector<string> output_names;
history->getOutputNames(output_names);
string name;
int j=0;
BOOST_FOREACH(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);
}
