void CVodesIntegrator::setMaxErrTestFails(int n) { m_maxErrTestFails = n; if (m_cvode_mem) { CVodeSetMaxErrTestFails(m_cvode_mem, n); } }
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 CVodesIntegrator::applyOptions() { if (m_type == DENSE + NOJAC) { sd_size_t N = static_cast<sd_size_t>(m_neq); #if SUNDIALS_USE_LAPACK CVLapackDense(m_cvode_mem, N); #else CVDense(m_cvode_mem, N); #endif } else if (m_type == DIAG) { CVDiag(m_cvode_mem); } else if (m_type == GMRES) { CVSpgmr(m_cvode_mem, PREC_NONE, 0); } else if (m_type == BAND + NOJAC) { sd_size_t N = static_cast<sd_size_t>(m_neq); long int nu = m_mupper; long int nl = m_mlower; #if SUNDIALS_USE_LAPACK CVLapackBand(m_cvode_mem, N, nu, nl); #else CVBand(m_cvode_mem, N, nu, nl); #endif } else { throw CanteraError("CVodesIntegrator::applyOptions", "unsupported option"); } if (m_maxord > 0) { CVodeSetMaxOrd(m_cvode_mem, m_maxord); } if (m_maxsteps > 0) { CVodeSetMaxNumSteps(m_cvode_mem, m_maxsteps); } if (m_hmax > 0) { CVodeSetMaxStep(m_cvode_mem, m_hmax); } if (m_hmin > 0) { CVodeSetMinStep(m_cvode_mem, m_hmin); } if (m_maxErrTestFails > 0) { CVodeSetMaxErrTestFails(m_cvode_mem, m_maxErrTestFails); } }
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; }