void CVodesIntegrator::setMinStepSize(doublereal hmin)
{
m_hmin = hmin;
if (m_cvode_mem) {
CVodeSetMinStep(m_cvode_mem, hmin);
}
}
void OpenSMOKE_CVODE_Sundials<T>::AnalyzeUserOptions()
{
/*
TODO
if (this->iSetMaximumNumberOfPrints_) iwork_[6] = this->maximumNumberOfPrints_;
if (this->iSetMaximumOrder_) iwork_[8] = this->maximumOrder_;
*/
if (this->iSetMaximumNumberOfSteps_)
{
int flag = CVodeSetMaxNumSteps(cvode_mem_, this->maximumNumberOfSteps_);
if (check_flag(&flag, std::string("CVodeSetMaxNumSteps"), 1)) exit(-1);
}
if (this->iSetMaximumStep_)
{
int flag = CVodeSetMaxStep(cvode_mem_, this->maximumStep_);
if (check_flag(&flag, std::string("CVodeSetMaxStep"), 1)) exit(-1);
}
if (this->iSetMinimumStep_)
{
int flag = CVodeSetMinStep(cvode_mem_, this->minimumStep_);
if (check_flag(&flag, std::string("CVodeSetMinStep"), 1)) exit(-1);
}
if (this->iSetFirstStep_)
{
int flag = CVodeSetInitStep(cvode_mem_, this->firstStep_);
if (check_flag(&flag, std::string("CVodeSetInitStep"), 1)) exit(-1);
}
}
void Cvode::minstep(double x) {
if (mem_) {
if (x > 0.) {
CVodeSetMinStep(mem_, x);
}else{
// CVodeSetMinStep requires x > 0 but
// HMIN_DEFAULT is ZERO in cvodes.c
((CVodeMem)mem_)->cv_hmin = 0.;
}
}
}
int CVodeSetMinStepB(void *cvadj_mem, realtype hminB)
{
CVadjMem ca_mem;
void *cvode_mem;
int flag;
ca_mem = (CVadjMem) cvadj_mem;
cvode_mem = (void *)ca_mem->cvb_mem;
flag = CVodeSetMinStep(cvode_mem, hminB);
return(flag);
}
int CVodeSetMinStepB(void *cvadj_mem, realtype hminB)
{
CVadjMem ca_mem;
void *cvode_mem;
int flag;
if (cvadj_mem == NULL) {
CVProcessError(NULL, CV_ADJMEM_NULL, "CVODEA", "CVodeSetMinStepB", MSGAM_NULL_CAMEM);
return(CV_ADJMEM_NULL);
}
ca_mem = (CVadjMem) cvadj_mem;
cvode_mem = (void *)ca_mem->cvb_mem;
flag = CVodeSetMinStep(cvode_mem, hminB);
return(flag);
}
void FCV_SETRIN(char key_name[], realtype *rval, int *ier)
{
if (!strncmp(key_name,"INIT_STEP",9))
*ier = CVodeSetInitStep(CV_cvodemem, *rval);
else if (!strncmp(key_name,"MAX_STEP",8))
*ier = CVodeSetMaxStep(CV_cvodemem, *rval);
else if (!strncmp(key_name,"MIN_STEP",8))
*ier = CVodeSetMinStep(CV_cvodemem, *rval);
else if (!strncmp(key_name,"STOP_TIME",9))
*ier = CVodeSetStopTime(CV_cvodemem, *rval);
else if (!strncmp(key_name,"NLCONV_COEF",11))
*ier = CVodeSetNonlinConvCoef(CV_cvodemem, *rval);
else {
*ier = -99;
fprintf(stderr, "FCVSETRIN: Unrecognized key.\n\n");
}
}
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);
}
}
int CVodeSetMinStepB(void *cvode_mem, int which, realtype hminB)
{
CVodeMem cv_mem;
CVadjMem ca_mem;
CVodeBMem cvB_mem;
void *cvodeB_mem;
int flag;
/* Check if cvode_mem exists */
if (cvode_mem == NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODEA", "CVodeSetMinStepB", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
/* Was ASA initialized? */
if (cv_mem->cv_adjMallocDone == FALSE) {
cvProcessError(cv_mem, CV_NO_ADJ, "CVODEA", "CVodeSetMinStepB", MSGCV_NO_ADJ);
return(CV_NO_ADJ);
}
ca_mem = cv_mem->cv_adj_mem;
/* Check which */
if ( which >= nbckpbs ) {
cvProcessError(cv_mem, CV_ILL_INPUT, "CVODEA", "CVodeSetMinStepB", MSGCV_BAD_WHICH);
return(CV_ILL_INPUT);
}
/* Find the CVodeBMem entry in the linked list corresponding to which */
cvB_mem = ca_mem->cvB_mem;
while (cvB_mem != NULL) {
if ( which == cvB_mem->cv_index ) break;
cvB_mem = cvB_mem->cv_next;
}
cvodeB_mem = (void *) (cvB_mem->cv_mem);
flag = CVodeSetMinStep(cvodeB_mem, hminB);
return(flag);
}
PetscErrorCode TSSetUp_Sundials(TS ts)
{
TS_Sundials *cvode = (TS_Sundials*)ts->data;
PetscErrorCode ierr;
PetscInt glosize,locsize,i,flag;
PetscScalar *y_data,*parray;
void *mem;
PC pc;
PCType pctype;
PetscBool pcnone;
PetscFunctionBegin;
/* get the vector size */
ierr = VecGetSize(ts->vec_sol,&glosize);CHKERRQ(ierr);
ierr = VecGetLocalSize(ts->vec_sol,&locsize);CHKERRQ(ierr);
/* allocate the memory for N_Vec y */
cvode->y = N_VNew_Parallel(cvode->comm_sundials,locsize,glosize);
if (!cvode->y) SETERRQ(PETSC_COMM_SELF,1,"cvode->y is not allocated");
/* initialize N_Vec y: copy ts->vec_sol to cvode->y */
ierr = VecGetArray(ts->vec_sol,&parray);CHKERRQ(ierr);
y_data = (PetscScalar*) N_VGetArrayPointer(cvode->y);
for (i = 0; i < locsize; i++) y_data[i] = parray[i];
ierr = VecRestoreArray(ts->vec_sol,NULL);CHKERRQ(ierr);
ierr = VecDuplicate(ts->vec_sol,&cvode->update);CHKERRQ(ierr);
ierr = VecDuplicate(ts->vec_sol,&cvode->ydot);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)ts,(PetscObject)cvode->update);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)ts,(PetscObject)cvode->ydot);CHKERRQ(ierr);
/*
Create work vectors for the TSPSolve_Sundials() routine. Note these are
allocated with zero space arrays because the actual array space is provided
by Sundials and set using VecPlaceArray().
*/
ierr = VecCreateMPIWithArray(PetscObjectComm((PetscObject)ts),1,locsize,PETSC_DECIDE,0,&cvode->w1);CHKERRQ(ierr);
ierr = VecCreateMPIWithArray(PetscObjectComm((PetscObject)ts),1,locsize,PETSC_DECIDE,0,&cvode->w2);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)ts,(PetscObject)cvode->w1);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)ts,(PetscObject)cvode->w2);CHKERRQ(ierr);
/* Call CVodeCreate to create the solver memory and the use of a Newton iteration */
mem = CVodeCreate(cvode->cvode_type, CV_NEWTON);
if (!mem) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"CVodeCreate() fails");
cvode->mem = mem;
/* Set the pointer to user-defined data */
flag = CVodeSetUserData(mem, ts);
if (flag) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVodeSetUserData() fails");
/* Sundials may choose to use a smaller initial step, but will never use a larger step. */
flag = CVodeSetInitStep(mem,(realtype)ts->time_step);
if (flag) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_LIB,"CVodeSetInitStep() failed");
if (cvode->mindt > 0) {
flag = CVodeSetMinStep(mem,(realtype)cvode->mindt);
if (flag) {
if (flag == CV_MEM_NULL) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_LIB,"CVodeSetMinStep() failed, cvode_mem pointer is NULL");
else if (flag == CV_ILL_INPUT) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_LIB,"CVodeSetMinStep() failed, hmin is nonpositive or it exceeds the maximum allowable step size");
else SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_LIB,"CVodeSetMinStep() failed");
}
}
if (cvode->maxdt > 0) {
flag = CVodeSetMaxStep(mem,(realtype)cvode->maxdt);
if (flag) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_LIB,"CVodeSetMaxStep() failed");
}
/* Call CVodeInit to initialize the integrator memory and specify the
* user's right hand side function in u'=f(t,u), the inital time T0, and
* the initial dependent variable vector cvode->y */
flag = CVodeInit(mem,TSFunction_Sundials,ts->ptime,cvode->y);
if (flag) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVodeInit() fails, flag %d",flag);
/* specifies scalar relative and absolute tolerances */
flag = CVodeSStolerances(mem,cvode->reltol,cvode->abstol);
if (flag) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVodeSStolerances() fails, flag %d",flag);
/* Specify max num of steps to be taken by cvode in its attempt to reach the next output time */
flag = CVodeSetMaxNumSteps(mem,ts->max_steps);
/* call CVSpgmr to use GMRES as the linear solver. */
/* setup the ode integrator with the given preconditioner */
ierr = TSSundialsGetPC(ts,&pc);CHKERRQ(ierr);
ierr = PCGetType(pc,&pctype);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)pc,PCNONE,&pcnone);CHKERRQ(ierr);
if (pcnone) {
flag = CVSpgmr(mem,PREC_NONE,0);
if (flag) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVSpgmr() fails, flag %d",flag);
} else {
flag = CVSpgmr(mem,PREC_LEFT,cvode->maxl);
if (flag) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVSpgmr() fails, flag %d",flag);
/* Set preconditioner and solve routines Precond and PSolve,
and the pointer to the user-defined block data */
flag = CVSpilsSetPreconditioner(mem,TSPrecond_Sundials,TSPSolve_Sundials);
if (flag) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVSpilsSetPreconditioner() fails, flag %d", flag);
}
flag = CVSpilsSetGSType(mem, MODIFIED_GS);
if (flag) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVSpgmrSetGSType() fails, flag %d",flag);
PetscFunctionReturn(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);
}
}
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;
}
void SundialsCvode::initialize()
{
int flag = 0;
if (_initialized) {
// Starting over with a new IC, but the same ODE
flag = CVodeReInit(sundialsMem, t0, y.forSundials());
if (check_flag(&flag, "CVodeReInit", 1)) {
throw DebugException("SundialsCvode::reInitialize: error in CVodeReInit");
}
CVodeSetMaxNumSteps(sundialsMem, maxNumSteps);
CVodeSetMinStep(sundialsMem, minStep);
return;
}
// On the first call to initialize, need to allocate and set up
// the Sundials solver, set tolerances and link the ODE functions
sundialsMem = CVodeCreate(linearMultistepMethod, nonlinearSolverMethod);
if (check_flag((void *)sundialsMem, "CVodeCreate", 0)) {
throw DebugException("SundialsCvode::initialize: error in CVodeCreate");
}
flag = CVodeInit(sundialsMem, f, t0, y.forSundials());
if (check_flag(&flag, "CVodeMalloc", 1)) {
throw DebugException("SundialsCvode::initialize: error in CVodeMalloc");
}
CVodeSVtolerances(sundialsMem, reltol, abstol.forSundials());
CVodeSetUserData(sundialsMem, theODE);
CVodeSetMaxNumSteps(sundialsMem, maxNumSteps);
CVodeSetMinStep(sundialsMem, minStep);
if (findRoots) {
rootsFound.resize(nRoots);
// Call CVodeRootInit to specify the root function g with nRoots components
flag = CVodeRootInit(sundialsMem, nRoots, g);
if (check_flag(&flag, "CVodeRootInit", 1)) {
throw DebugException("SundialsCvode::initialize: error in CVodeRootInit");
}
}
if (bandwidth_upper == -1 && bandwidth_lower == -1) {
// Call CVDense to specify the CVDENSE dense linear solver
flag = CVDense(sundialsMem, nEq);
if (check_flag(&flag, "CVDense", 1)) {
throw DebugException("SundialsCvode::initialize: error in CVDense");
}
// Set the Jacobian routine to denseJac (user-supplied)
flag = CVDlsSetDenseJacFn(sundialsMem, denseJac);
if (check_flag(&flag, "CVDlsSetDenseJacFn", 1)) {
throw DebugException("SundialsCvode::initialize: error in CVDlsSetDenseJacFn");
}
} else {
// Call CVDense to specify the CVBAND Banded linear solver
flag = CVBand(sundialsMem, nEq, bandwidth_upper, bandwidth_lower);
if (check_flag(&flag, "CVBand", 1)) {
throw DebugException("SundialsCvode::initialize: error in CVBand");
}
// Set the Jacobian routine to bandJac (user-supplied)
flag = CVDlsSetBandJacFn(sundialsMem, bandJac);
if (check_flag(&flag, "CVDlsSetBandJacFn", 1)) {
throw DebugException("SundialsCvode::initialize: error in CVDlsSetBandJacFn");
}
}
_initialized = true;
}
