int main(int narg, char **args)
{
realtype reltol, t, tout;
N_Vector state, abstol;
void *cvode_mem;
int flag, flagr;
int rootsfound[NRF];
int rootdir[] = {1,1,1,};
FILE *pout;
pout = stdout;
state = abstol = NULL;
cvode_mem = NULL;
state = N_VNew_Serial(NEQ);
if (check_flag((void *)state, "N_VNew_Serial", 0)) return(1);
abstol = N_VNew_Serial(NEQ);
if (check_flag((void *)abstol, "N_VNew_Serial", 0)) return(1);
realtype a = 0.02;
realtype b = 0.2;
realtype c = -50;
realtype d = 2;
realtype I = 0;
realtype v0 = -70;
realtype p[] = {a, b, c, d, I, v0, };
realtype v = v0;
realtype u = b * v0;
NV_Ith_S(state, 0) = v0;
NV_Ith_S(state, 1) = b * v0;
reltol = RTOL;
NV_Ith_S(abstol,0) = ATOL0;
NV_Ith_S(abstol,1) = ATOL1;
/* Allocations and initializations */
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
flag = CVodeInit(cvode_mem, dstate_dt, T0, state);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
flag = CVodeSetUserData(cvode_mem, p);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
flag = CVodeSVtolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSVtolerances", 1)) return(1);
flag = CVodeRootInit(cvode_mem, NRF, root_functions);
if (check_flag(&flag, "CVodeRootInit", 1)) return(1);
CVodeSetRootDirection(cvode_mem, rootdir);
if (check_flag(&flag, "CVodeSetRootDirection", 1)) return(1);
flag = CVDense(cvode_mem, NEQ);
if (check_flag(&flag, "CVDense", 1)) return(1);
printf(" \n Integrating izhikevich_burster \n\n");
printf("#t v, u, \n");
PrintOutput(pout, t, state);
tout = DT;
while(1) {
flag = CVode(cvode_mem, tout, state, &t, CV_NORMAL);
if(flag == CV_ROOT_RETURN) {
/* Event detected */
flagr = CVodeGetRootInfo(cvode_mem, rootsfound);
if (check_flag(&flagr, "CVodeGetRootInfo", 1)) return(1);
PrintRootInfo(t, state, rootsfound);
if(rootsfound[0]){
//spike
v = NV_Ith_S(state, 0);
u = NV_Ith_S(state, 1);
NV_Ith_S(state, 0) = c;
NV_Ith_S(state, 1) = u + d;
}
if(rootsfound[1]){
//start_inj
I = 5;
p[0] = a;
p[1] = b;
p[2] = c;
p[3] = d;
p[4] = I;
p[5] = v0;
}
if(rootsfound[2]){
//end_inj
I = 0;
p[0] = a;
p[1] = b;
p[2] = c;
p[3] = d;
p[4] = I;
p[5] = v0;
}
/* Restart integration with event-corrected state */
flag = CVodeSetUserData(cvode_mem, p);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
CVodeReInit(cvode_mem, t, state);
//PrintRootInfo(t, state, rootsfound);
}
else
{
PrintOutput(pout, t, state);
if(check_flag(&flag, "CVode", 1)) break;
if(flag == CV_SUCCESS) {
tout += DT;
}
if (t >= T1) break;
}
}
PrintFinalStats(cvode_mem);
N_VDestroy_Serial(state);
N_VDestroy_Serial(abstol);
CVodeFree(&cvode_mem);
fclose(pout);
return(0);
}
int main(int narg, char **args)
{
realtype reltol, t, tout;
N_Vector state, abstol;
void *cvode_mem;
int flag, flagr;
int rootsfound[NRF];
int rootdir[] = {1,};
FILE *pout;
if(!(pout = fopen("results/iaf_v.dat", "w"))){
fprintf(stderr, "Cannot open file results/iaf_v.dat. Are you trying to write to a non-existent directory? Exiting...\n");
exit(1);
}
state = abstol = NULL;
cvode_mem = NULL;
state = N_VNew_Serial(NEQ);
if (check_flag((void *)state, "N_VNew_Serial", 0)) return(1);
abstol = N_VNew_Serial(NEQ);
if (check_flag((void *)abstol, "N_VNew_Serial", 0)) return(1);
realtype reset = -0.07;
realtype C = 3.2e-12;
realtype thresh = -0.055;
realtype gleak = 2e-10;
realtype eleak = -0.053;
realtype p[] = {reset, C, thresh, gleak, eleak, };
realtype v = reset;
NV_Ith_S(state, 0) = reset;
reltol = RTOL;
NV_Ith_S(abstol,0) = ATOL0;
/* Allocations and initializations */
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
flag = CVodeInit(cvode_mem, dstate_dt, T0, state);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
flag = CVodeSetUserData(cvode_mem, p);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
flag = CVodeSVtolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSVtolerances", 1)) return(1);
flag = CVodeRootInit(cvode_mem, NRF, root_functions);
if (check_flag(&flag, "CVodeRootInit", 1)) return(1);
CVodeSetRootDirection(cvode_mem, rootdir);
if (check_flag(&flag, "CVodeSetRootDirection", 1)) return(1);
flag = CVDense(cvode_mem, NEQ);
if (check_flag(&flag, "CVDense", 1)) return(1);
printf(" \n Integrating iaf \n\n");
printf("#t v, \n");
PrintOutput(pout, t, state);
tout = DT;
while(1) {
flag = CVode(cvode_mem, tout, state, &t, CV_NORMAL);
if(flag == CV_ROOT_RETURN) {
/* Event detected */
flagr = CVodeGetRootInfo(cvode_mem, rootsfound);
if (check_flag(&flagr, "CVodeGetRootInfo", 1)) return(1);
PrintRootInfo(t, state, rootsfound);
if(rootsfound[0]){
//condition_0
v = NV_Ith_S(state, 0);
NV_Ith_S(state, 0) = reset;
}
/* Restart integration with event-corrected state */
flag = CVodeSetUserData(cvode_mem, p);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
CVodeReInit(cvode_mem, t, state);
//PrintRootInfo(t, state, rootsfound);
}
else
{
PrintOutput(pout, t, state);
if(check_flag(&flag, "CVode", 1)) break;
if(flag == CV_SUCCESS) {
tout += DT;
}
if (t >= T1) break;
}
}
PrintFinalStats(cvode_mem);
N_VDestroy_Serial(state);
N_VDestroy_Serial(abstol);
CVodeFree(&cvode_mem);
fclose(pout);
return(0);
}
void Cvode::initialize()
{
_properties = dynamic_cast<ISystemProperties*>(_system);
_continuous_system = dynamic_cast<IContinuous*>(_system);
_event_system = dynamic_cast<IEvent*>(_system);
_mixed_system = dynamic_cast<IMixedSystem*>(_system);
_time_system = dynamic_cast<ITime*>(_system);
IGlobalSettings* global_settings = dynamic_cast<ISolverSettings*>(_cvodesettings)->getGlobalSettings();
// Kennzeichnung, dass initialize()() (vor der Integration) aufgerufen wurde
_idid = 5000;
_tLastEvent = 0.0;
_event_n = 0;
SolverDefaultImplementation::initialize();
_dimSys = _continuous_system->getDimContinuousStates();
_dimZeroFunc = _event_system->getDimZeroFunc();
if (_dimSys == 0)
_dimSys = 1; // introduce dummy state
if (_dimSys <= 0)
{
_idid = -1;
throw ModelicaSimulationError(SOLVER,"Cvode::initialize()");
}
else
{
// Allocate state vectors, stages and temporary arrays
if (_z)
delete[] _z;
if (_zInit)
delete[] _zInit;
if (_zWrite)
delete[] _zWrite;
if (_zeroSign)
delete[] _zeroSign;
if (_absTol)
delete[] _absTol;
if(_delta)
delete [] _delta;
if(_deltaInv)
delete [] _deltaInv;
if(_ysave)
delete [] _ysave;
_z = new double[_dimSys];
_zInit = new double[_dimSys];
_zWrite = new double[_dimSys];
_zeroSign = new int[_dimZeroFunc];
_absTol = new double[_dimSys];
_delta =new double[_dimSys];
_deltaInv =new double[_dimSys];
_ysave =new double[_dimSys];
memset(_z, 0, _dimSys * sizeof(double));
memset(_zInit, 0, _dimSys * sizeof(double));
memset(_ysave, 0, _dimSys * sizeof(double));
// Counter initialisieren
_outStps = 0;
if (_cvodesettings->getDenseOutput())
{
// Ausgabeschrittweite
_hOut = global_settings->gethOutput();
}
// Allocate memory for the solver
_cvodeMem = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void*) _cvodeMem, "CVodeCreate", 0))
{
_idid = -5;
throw ModelicaSimulationError(SOLVER,/*_idid,_tCurrent,*/"Cvode::initialize()");
}
//
// Make Cvode ready for integration
//
// Set initial values for CVODE
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
_continuous_system->getContinuousStates(_zInit);
memcpy(_z, _zInit, _dimSys * sizeof(double));
// Get nominal values
_absTol[0] = 1.0; // in case of dummy state
_continuous_system->getNominalStates(_absTol);
for (int i = 0; i < _dimSys; i++)
_absTol[i] *= dynamic_cast<ISolverSettings*>(_cvodesettings)->getATol();
_CV_y0 = N_VMake_Serial(_dimSys, _zInit);
_CV_y = N_VMake_Serial(_dimSys, _z);
_CV_yWrite = N_VMake_Serial(_dimSys, _zWrite);
_CV_absTol = N_VMake_Serial(_dimSys, _absTol);
if (check_flag((void*) _CV_y0, "N_VMake_Serial", 0))
{
_idid = -5;
throw ModelicaSimulationError(SOLVER,"Cvode::initialize()");
}
// Initialize Cvode (Initial values are required)
_idid = CVodeInit(_cvodeMem, CV_fCallback, _tCurrent, _CV_y0);
if (_idid < 0)
{
_idid = -5;
throw ModelicaSimulationError(SOLVER,"Cvode::initialize()");
}
// Set Tolerances
_idid = CVodeSVtolerances(_cvodeMem, dynamic_cast<ISolverSettings*>(_cvodesettings)->getRTol(), _CV_absTol); // RTOL and ATOL
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"CVode::initialize()");
// Set the pointer to user-defined data
_idid = CVodeSetUserData(_cvodeMem, _data);
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"Cvode::initialize()");
_idid = CVodeSetInitStep(_cvodeMem, 1e-6); // INITIAL STEPSIZE
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"Cvode::initialize()");
_idid = CVodeSetMaxOrd(_cvodeMem, 5); // Max Order
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"CVoder::initialize()");
_idid = CVodeSetMaxConvFails(_cvodeMem, 100); // Maximale Fehler im Konvergenztest
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"CVoder::initialize()");
_idid = CVodeSetStabLimDet(_cvodeMem, TRUE); // Stability Detection
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"CVoder::initialize()");
_idid = CVodeSetMinStep(_cvodeMem, dynamic_cast<ISolverSettings*>(_cvodesettings)->getLowerLimit()); // MINIMUM STEPSIZE
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"CVode::initialize()");
_idid = CVodeSetMaxStep(_cvodeMem, global_settings->getEndTime() / 10.0); // MAXIMUM STEPSIZE
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"CVode::initialize()");
_idid = CVodeSetMaxNonlinIters(_cvodeMem, 5); // Max number of iterations
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"CVode::initialize()");
_idid = CVodeSetMaxErrTestFails(_cvodeMem, 100);
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"CVode::initialize()");
_idid = CVodeSetMaxNumSteps(_cvodeMem, 1e3); // Max Number of steps
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,/*_idid,_tCurrent,*/"Cvode::initialize()");
// Initialize linear solver
#ifdef USE_SUNDIALS_LAPACK
_idid = CVLapackDense(_cvodeMem, _dimSys);
#else
_idid = CVDense(_cvodeMem, _dimSys);
#endif
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"Cvode::initialize()");
// Use own jacobian matrix
// Check if Colored Jacobians are worth to use
#if SUNDIALS_MAJOR_VERSION >= 2 || (SUNDIALS_MAJOR_VERSION == 2 && SUNDIALS_MINOR_VERSION >= 4)
_maxColors = _system->getAMaxColors();
if(_maxColors < _dimSys && _continuous_system->getDimContinuousStates() > 0)
{
// _idid = CVDlsSetDenseJacFn(_cvodeMem, &CV_JCallback);
// initializeColoredJac();
}
#endif
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"CVode::initialize()");
if (_dimZeroFunc)
{
_idid = CVodeRootInit(_cvodeMem, _dimZeroFunc, &CV_ZerofCallback);
memset(_zeroSign, 0, _dimZeroFunc * sizeof(int));
_idid = CVodeSetRootDirection(_cvodeMem, _zeroSign);
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,/*_idid,_tCurrent,*/"CVode::initialize()");
memset(_zeroSign, -1, _dimZeroFunc * sizeof(int));
memset(_zeroVal, -1, _dimZeroFunc * sizeof(int));
}
_cvode_initialized = true;
LOGGER_WRITE("Cvode: initialized",LC_SOLV,LL_DEBUG);
}
}
