int CVodeReInitB(void *cvadj_mem, CVRhsFnB fB,
realtype tB0, N_Vector yB0,
int itolB, realtype reltolB, void *abstolB)
{
CVadjMem ca_mem;
void *cvode_mem;
int sign, flag;
if (cvadj_mem == NULL) return(CV_ADJMEM_NULL);
ca_mem = (CVadjMem) cvadj_mem;
sign = (tfinal - tinitial > ZERO) ? 1 : -1;
if ( (sign*(tB0-tinitial) < ZERO) || (sign*(tfinal-tB0) < ZERO) )
return(CV_BAD_TB0);
f_B = fB;
cvode_mem = (void *) ca_mem->cvb_mem;
flag = CVodeReInit(cvode_mem, CVArhs, tB0, yB0,
itolB, reltolB, abstolB);
if (flag != CV_SUCCESS) return(flag);
CVodeSetMaxHnilWarns(cvode_mem, -1);
CVodeSetFdata(cvode_mem, cvadj_mem);
return(CV_SUCCESS);
}
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");
}
}
Bloch_McConnell_CV_Model::Bloch_McConnell_CV_Model () {
m_world->solverSettings = new bmnvec;
/* for (int i=0;i<OPT_SIZE;i++) {m_iopt[i]=0; m_ropt[i]=0.0;}
m_iopt[MXSTEP] = 1000000;
m_ropt[HMAX] = 10000.0;// the maximum stepsize in msec of the integrator*/
m_reltol = RTOL;
//cvode2.5:
// create cvode memory pointer; no mallocs done yet.
// m_cvode_mem = CVodeCreate(CV_BDF,CV_NEWTON);
m_cvode_mem = CVodeCreate(CV_ADAMS,CV_FUNCTIONAL);
// cvode allocate memory.
// do CVodeMalloc with dummy values y0,abstol once here;
// -> CVodeReInit can later be used
//HACK
int pools = m_world->GetNoOfCompartments();
N_Vector y0,abstol;
y0 = N_VNew_Serial(NEQ*pools);
abstol = N_VNew_Serial(NEQ*pools);
((bmnvec*) (m_world->solverSettings))->abstol = N_VNew_Serial(pools*NEQ);
for(int i = 0; i< pools*NEQ; i+=NEQ){
NV_Ith_S(y0,AMPL+i) = 0.0; NV_Ith_S(y0,PHASE+i) = 0.0; NV_Ith_S(y0,ZC+i) = 0.0;
NV_Ith_S(abstol,AMPL+i) = ATOL1; NV_Ith_S(abstol,PHASE+i) = ATOL2; NV_Ith_S(abstol,ZC+i) = ATOL3;
}
#ifndef CVODE26
if(CVodeMalloc(m_cvode_mem,bloch,0,y0,CV_SV,m_reltol,abstol) != CV_SUCCESS ) {
cout << "CVodeMalloc failed! aborting..." << endl;exit (-1);
}
if(CVodeSetFdata(m_cvode_mem, (void *) m_world) !=CV_SUCCESS) {
cout << "CVode function data could not be set. Panic!" << endl;exit (-1);
}
#else
if(CVodeInit(m_cvode_mem,bloch,0,y0) != CV_SUCCESS ) {
cout << "CVodeInit failed! aborting..." << endl;exit (-1);
}
if(CVodeSVtolerances(m_cvode_mem, m_reltol, abstol)!= CV_SUCCESS){
cout << "CVodeSVtolerances failed! aborting..." << endl;exit (-1);
}
if(CVodeSetUserData(m_cvode_mem, (void *) m_world) !=CV_SUCCESS) {
cout << "CVode function data could not be set. Panic!" << endl;exit (-1);
}
#endif
/* int flag;
int blub = (3*pools);
flag = CVDense(m_cvode_mem, blub);
if (flag == CVDENSE_SUCCESS)
cout<< "great" <<endl;
else
cout<< "bad" <<endl;
*/
N_VDestroy_Serial(y0);
N_VDestroy_Serial(abstol);
/*if(CVodeSetFdata(m_cvode_mem, (void *) m_world) !=CV_SUCCESS) {
cout << "CVode function data could not be set. Panic!" << endl;
exit (-1);
}
// set CVODE initial step size
// CVodeSetInitStep(m_cvode_mem, 1e-4);
// set CVODE maximum step size
CVodeSetMaxErrTestFails(m_cvode_mem, 10);
// set CVODE minimum step size
CVodeSetMinStep(m_cvode_mem, 1e-15);
*/
CVodeSetMaxNumSteps(m_cvode_mem, 10000000);
// maximum number of warnings t+h = t (if number negative -> no warnings are issued )
CVodeSetMaxHnilWarns(m_cvode_mem,2);
}
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;
}
