inline void cvodes_set_options(void* cvodes_mem,
double rel_tol, double abs_tol,
// NOLINTNEXTLINE(runtime/int)
long int max_num_steps) {
// forward CVode errors to noop error handler
CVodeSetErrHandlerFn(cvodes_mem, cvodes_silent_err_handler, 0);
// Initialize solver parameters
cvodes_check_flag(CVodeSStolerances(cvodes_mem, rel_tol, abs_tol),
"CVodeSStolerances");
cvodes_check_flag(CVodeSetMaxNumSteps(cvodes_mem, max_num_steps),
"CVodeSetMaxNumSteps");
double init_step = 0;
cvodes_check_flag(CVodeSetInitStep(cvodes_mem, init_step),
"CVodeSetInitStep");
long int max_err_test_fails = 20; // NOLINT(runtime/int)
cvodes_check_flag(CVodeSetMaxErrTestFails(cvodes_mem, max_err_test_fails),
"CVodeSetMaxErrTestFails");
long int max_conv_fails = 50; // NOLINT(runtime/int)
cvodes_check_flag(CVodeSetMaxConvFails(cvodes_mem, max_conv_fails),
"CVodeSetMaxConvFails");
}
void FCV_SETIIN(char key_name[], long int *ival, int *ier)
{
if (!strncmp(key_name,"MAX_ORD",7))
*ier = CVodeSetMaxOrd(CV_cvodemem, (int) *ival);
else if (!strncmp(key_name,"MAX_NSTEPS",10))
*ier = CVodeSetMaxNumSteps(CV_cvodemem, (long int) *ival);
else if (!strncmp(key_name,"MAX_ERRFAIL",11))
*ier = CVodeSetMaxErrTestFails(CV_cvodemem, (int) *ival);
else if (!strncmp(key_name,"MAX_NITERS",10))
*ier = CVodeSetMaxNonlinIters(CV_cvodemem, (int) *ival);
else if (!strncmp(key_name,"MAX_CONVFAIL",12))
*ier = CVodeSetMaxConvFails(CV_cvodemem, (int) *ival);
else if (!strncmp(key_name,"HNIL_WARNS",10))
*ier = CVodeSetMaxHnilWarns(CV_cvodemem, (int) *ival);
else if (!strncmp(key_name,"STAB_LIM",8))
*ier = CVodeSetStabLimDet(CV_cvodemem, (booleantype) *ival);
else {
*ier = -99;
fprintf(stderr, "FCVSETIIN: Unrecognized key.\n\n");
}
}
/*
** ========
** main MEX
** ========
*/
void mexFunction( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] )
{
/* variables */
double * return_status;
double * species_out;
double * observables_out;
double * parameters;
double * species_init;
double * timepoints;
size_t n_timepoints;
size_t i;
size_t j;
/* intermediate data vectors */
N_Vector expressions;
N_Vector observables;
N_Vector ratelaws;
/* array to hold pointers to data vectors */
N_Vector temp_data[3];
/* CVODE specific variables */
realtype reltol;
realtype abstol;
realtype time;
N_Vector species;
void * cvode_mem;
int flag;
/* check number of input/output arguments */
if (nlhs != 3)
{ mexErrMsgTxt("syntax: [err_flag, species_out, obsv_out] = network_mex( timepoints, species_init, params )"); }
if (nrhs != 3)
{ mexErrMsgTxt("syntax: [err_flag, species_out, obsv_out] = network_mex( timepoints, species_init, params )"); }
/* make sure timepoints has correct dimensions */
if ( (mxGetM(prhs[0]) < 2) || (mxGetN(prhs[0]) != 1) )
{ mexErrMsgTxt("TIMEPOINTS must be a column vector with 2 or more elements."); }
/* make sure species_init has correct dimensions */
if ( (mxGetM(prhs[1]) != 1) || (mxGetN(prhs[1]) != __N_SPECIES__) )
{ mexErrMsgTxt("SPECIES_INIT must be a row vector with 7 elements."); }
/* make sure params has correct dimensions */
if ( (mxGetM(prhs[2]) != 1) || (mxGetN(prhs[2]) != __N_PARAMETERS__) )
{ mexErrMsgTxt("PARAMS must be a column vector with 4 elements."); }
/* get pointers to input arrays */
timepoints = mxGetPr(prhs[0]);
species_init = mxGetPr(prhs[1]);
parameters = mxGetPr(prhs[2]);
/* get number of timepoints */
n_timepoints = mxGetM(prhs[0]);
/* Create an mxArray for output trajectories */
plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL );
plhs[1] = mxCreateDoubleMatrix(n_timepoints, __N_SPECIES__, mxREAL);
plhs[2] = mxCreateDoubleMatrix(n_timepoints, __N_OBSERVABLES__, mxREAL);
/* get pointers to output arrays */
return_status = mxGetPr(plhs[0]);
species_out = mxGetPr(plhs[1]);
observables_out = mxGetPr(plhs[2]);
/* initialize intermediate data vectors */
expressions = NULL;
expressions = N_VNew_Serial(__N_EXPRESSIONS__);
if (check_flag((void *)expressions, "N_VNew_Serial", 0))
{
return_status[0] = 1;
return;
}
observables = NULL;
observables = N_VNew_Serial(__N_OBSERVABLES__);
if (check_flag((void *)observables, "N_VNew_Serial", 0))
{
N_VDestroy_Serial(expressions);
return_status[0] = 1;
return;
}
ratelaws = NULL;
ratelaws = N_VNew_Serial(__N_RATELAWS__);
if (check_flag((void *)ratelaws, "N_VNew_Serial", 0))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
return_status[0] = 1;
return;
}
/* set up pointers to intermediate data vectors */
temp_data[0] = expressions;
temp_data[1] = observables;
temp_data[2] = ratelaws;
/* calculate expressions (expressions are constant, so only do this once!) */
calc_expressions( expressions, parameters );
/* SOLVE model equations! */
species = NULL;
cvode_mem = NULL;
/* Set the scalar relative tolerance */
reltol = 1e-06;
abstol = 1e-06;
/* Create serial vector for Species */
species = N_VNew_Serial(__N_SPECIES__);
if (check_flag((void *)species, "N_VNew_Serial", 0))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
return_status[0] = 1;
return;
}
for ( i = 0; i < __N_SPECIES__; i++ )
{ NV_Ith_S(species,i) = species_init[i]; }
/* write initial species populations into species_out */
for ( i = 0; i < __N_SPECIES__; i++ )
{ species_out[i*n_timepoints] = species_init[i]; }
/* write initial observables populations into species_out */
calc_observables( observables, species, expressions );
for ( i = 0; i < __N_OBSERVABLES__; i++ )
{ observables_out[i*n_timepoints] = NV_Ith_S(observables,i); }
/* Call CVodeCreate to create the solver memory:
* CV_ADAMS or CV_BDF is the linear multistep method
* CV_FUNCTIONAL or CV_NEWTON is the nonlinear solver iteration
* A pointer to the integrator problem memory is returned and stored in cvode_mem.
*/
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* Call CVodeInit to initialize the integrator memory:
* cvode_mem is the pointer to the integrator memory returned by CVodeCreate
* rhs_func is the user's right hand side function in y'=f(t,y)
* T0 is the initial time
* y is the initial dependent variable vector
*/
flag = CVodeInit(cvode_mem, calc_species_deriv, timepoints[0], species);
if (check_flag(&flag, "CVodeInit", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* Set scalar relative and absolute tolerances */
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSStolerances", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* pass params to rhs_func */
flag = CVodeSetUserData(cvode_mem, &temp_data);
if (check_flag(&flag, "CVodeSetFdata", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* select linear solver */
flag = CVDense(cvode_mem, __N_SPECIES__);
if (check_flag(&flag, "CVDense", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
flag = CVodeSetMaxNumSteps(cvode_mem, 2000);
if (check_flag(&flag, "CVodeSetMaxNumSteps", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
flag = CVodeSetMaxErrTestFails(cvode_mem, 7);
if (check_flag(&flag, "CVodeSetMaxErrTestFails", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
flag = CVodeSetMaxConvFails(cvode_mem, 10);
if (check_flag(&flag, "CVodeSetMaxConvFails", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
flag = CVodeSetMaxStep(cvode_mem, 0.0);
if (check_flag(&flag, "CVodeSetMaxStep", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* integrate to each timepoint */
for ( i=1; i < n_timepoints; i++ )
{
flag = CVode(cvode_mem, timepoints[i], species, &time, CV_NORMAL);
if (check_flag(&flag, "CVode", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* copy species output from nvector to matlab array */
for ( j = 0; j < __N_SPECIES__; j++ )
{ species_out[j*n_timepoints + i] = NV_Ith_S(species,j); }
/* copy observables output from nvector to matlab array */
calc_observables( observables, species, expressions );
for ( j = 0; j < __N_OBSERVABLES__; j++ )
{ observables_out[j*n_timepoints + i] = NV_Ith_S(observables,j); }
}
/* Free vectors */
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
/* Free integrator memory */
CVodeFree(&cvode_mem);
return;
}
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);
}
}
void FCV_MALLOC(realtype *t0, realtype *y0,
int *meth, int *itmeth, int *iatol,
realtype *rtol, realtype *atol,
int *optin, long int *iopt, realtype *ropt,
int *ier)
{
int lmm, iter, itol;
void *atolptr;
atolptr = NULL;
if(F2C_vec->ops->nvgetarraypointer == NULL ||
F2C_vec->ops->nvsetarraypointer == NULL) {
*ier = -1;
printf("A required vector operation is not implemented.\n\n");
return;
}
/* Save the data array in F2C_vec into data_F2C_vec and then
overwrite it with y0 */
data_F2C_vec = N_VGetArrayPointer(F2C_vec);
N_VSetArrayPointer(y0, F2C_vec);
lmm = (*meth == 1) ? CV_ADAMS : CV_BDF;
iter = (*itmeth == 1) ? CV_FUNCTIONAL : CV_NEWTON;
switch (*iatol) {
case 1:
F2C_atolvec = NULL;
itol = CV_SS;
atolptr = (void *) atol;
break;
case 2:
F2C_atolvec = N_VClone(F2C_vec);
data_F2C_atolvec = N_VGetArrayPointer(F2C_atolvec);
N_VSetArrayPointer(atol, F2C_atolvec);
itol = CV_SV;
atolptr = (void *) F2C_atolvec;
break;
case 3:
F2C_atolvec = NULL;
itol = CV_WF;
break;
}
/*
Call CVodeCreate, CVodeSet*, and CVodeMalloc to initialize CVODE:
lmm is the method specifier
iter is the iteration method specifier
CVf is the user's right-hand side function in y'=f(t,y)
*t0 is the initial time
F2C_vec is the initial dependent variable vector
itol specifies tolerance type
rtol is the scalar relative tolerance
atolptr is the absolute tolerance pointer (to scalar or vector or function)
A pointer to CVODE problem memory is createded and stored in CV_cvodemem.
*/
*ier = 0;
CV_cvodemem = CVodeCreate(lmm, iter);
if (CV_cvodemem == NULL) {
*ier = -1;
return;
}
if (*optin == 1) {
CV_optin = TRUE;
if (iopt[0] > 0) CVodeSetMaxOrd(CV_cvodemem, (int)iopt[0]);
if (iopt[1] > 0) CVodeSetMaxNumSteps(CV_cvodemem, iopt[1]);
if (iopt[2] > 0) CVodeSetMaxHnilWarns(CV_cvodemem, (int)iopt[2]);
if (iopt[13] > 0) CVodeSetStabLimDet(CV_cvodemem, TRUE);
if (iopt[21] > 0) CVodeSetMaxErrTestFails(CV_cvodemem, (int)iopt[21]);
if (iopt[22] > 0) CVodeSetMaxNonlinIters(CV_cvodemem, (int)iopt[22]);
if (iopt[23] > 0) CVodeSetMaxConvFails(CV_cvodemem, (int)iopt[23]);
if (ropt[0] != ZERO) CVodeSetInitStep(CV_cvodemem, ropt[0]);
if (ropt[1] > ZERO) CVodeSetMaxStep(CV_cvodemem, ropt[1]);
if (ropt[2] > ZERO) CVodeSetMinStep(CV_cvodemem, ropt[2]);
if (ropt[7] != ZERO) CVodeSetStopTime(CV_cvodemem, ropt[7]);
if (ropt[8] > ZERO) CVodeSetNonlinConvCoef(CV_cvodemem, ropt[8]);
} else {
CV_optin = FALSE;
}
*ier = CVodeMalloc(CV_cvodemem, FCVf, *t0, F2C_vec, itol, *rtol, atolptr);
/* reset data pointer into F2C_vec */
N_VSetArrayPointer(data_F2C_vec, F2C_vec);
/* destroy F2C_atolvec if allocated */
if (F2C_atolvec != NULL) {
N_VSetArrayPointer(data_F2C_atolvec, F2C_atolvec);
N_VDestroy(F2C_atolvec);
}
if(*ier != CV_SUCCESS) {
*ier = -1;
return;
}
/* Store the unit roundoff in ropt for user access */
ropt[9] = UNIT_ROUNDOFF;
CV_iopt = iopt;
CV_ropt = ropt;
return;
}
void FCV_REINIT(realtype *t0, realtype *y0, int *iatol, realtype *rtol,
realtype *atol, int *optin, long int *iopt,
realtype *ropt, int *ier)
{
int itol;
void *atolptr;
atolptr = NULL;
N_VSetArrayPointer(y0, F2C_vec);
switch (*iatol) {
case 1:
itol = CV_SS;
atolptr = (void *) atol;
break;
case 2:
F2C_atolvec = N_VClone(F2C_vec);
data_F2C_atolvec = N_VGetArrayPointer(F2C_atolvec);
N_VSetArrayPointer(atol, F2C_atolvec);
itol = CV_SV;
atolptr = (void *) F2C_atolvec;
break;
case 3:
itol = CV_WF;
}
/*
Call CVodeSet* and CVReInit to re-initialize CVODE:
CVf is the user's right-hand side function in y'=f(t,y)
t0 is the initial time
F2C_vec is the initial dependent variable vector
itol specifies tolerance type
rtol is the scalar relative tolerance
atolptr is the absolute tolerance pointer (to scalar or vector or function)
*/
if (*optin == 1) {
CV_optin = TRUE;
if (iopt[0] > 0) CVodeSetMaxOrd(CV_cvodemem, (int)iopt[0]);
if (iopt[1] > 0) CVodeSetMaxNumSteps(CV_cvodemem, iopt[1]);
if (iopt[2] > 0) CVodeSetMaxHnilWarns(CV_cvodemem, (int)iopt[2]);
if (iopt[13] > 0) CVodeSetStabLimDet(CV_cvodemem, TRUE);
if (iopt[21] > 0) CVodeSetMaxErrTestFails(CV_cvodemem, (int)iopt[21]);
if (iopt[22] > 0) CVodeSetMaxNonlinIters(CV_cvodemem, (int)iopt[22]);
if (iopt[23] > 0) CVodeSetMaxConvFails(CV_cvodemem, (int)iopt[23]);
if (ropt[0] != ZERO) CVodeSetInitStep(CV_cvodemem, ropt[0]);
if (ropt[1] > ZERO) CVodeSetMaxStep(CV_cvodemem, ropt[1]);
if (ropt[2] > ZERO) CVodeSetMinStep(CV_cvodemem, ropt[2]);
if (ropt[7] != ZERO) CVodeSetStopTime(CV_cvodemem, ropt[7]);
if (ropt[8] > ZERO) CVodeSetNonlinConvCoef(CV_cvodemem, ropt[8]);
} else {
CV_optin = FALSE;
}
*ier = CVodeReInit(CV_cvodemem, FCVf, *t0, F2C_vec, itol, *rtol, atolptr);
/* reset data pointer into F2C_vec */
N_VSetArrayPointer(data_F2C_vec, F2C_vec);
/* destroy F2C_atolvec if allocated */
if (F2C_atolvec != NULL) {
N_VSetArrayPointer(data_F2C_atolvec, F2C_atolvec);
N_VDestroy(F2C_atolvec);
}
if (*ier != CV_SUCCESS) {
*ier = -1;
return;
}
CV_iopt = iopt;
CV_ropt = ropt;
return;
}
