int CVSpilsSetJacTimesVecFnB(void *cvadj_mem, CVSpilsJacTimesVecFnB jtimesB,
void *jac_dataB)
{
CVadjMem ca_mem;
CVSpilsMemB cvspilsB_mem;
CVodeMem cvB_mem;
int flag;
if (cvadj_mem == NULL) {
CVProcessError(NULL, CVSPILS_ADJMEM_NULL, "CVSPILS", "CVSpilsSetJacTimesVecFnB", MSGS_CAMEM_NULL);
return(CVSPILS_ADJMEM_NULL);
}
ca_mem = (CVadjMem) cvadj_mem;
cvB_mem = ca_mem->cvb_mem;
if (lmemB == NULL) {
CVProcessError(cvB_mem, CVSPILS_LMEMB_NULL, "CVSPILS", "CVSpilsSetJacTimesVecFnB", MSGS_LMEMB_NULL);
return(CVSPILS_LMEMB_NULL);
}
cvspilsB_mem = (CVSpilsMemB) lmemB;
jtimes_B = jtimesB;
jac_data_B = jac_dataB;
flag = CVSpilsSetJacTimesVecFn(cvB_mem, CVAspilsJacTimesVec, cvadj_mem);
return(flag);
}
int CVBBDPrecGetNumGfnEvals(void *cvode_mem, long int *ngevalsBBDP)
{
CVodeMem cv_mem;
CVSpilsMem cvspils_mem;
CVBBDPrecData pdata;
if (cvode_mem == NULL) {
CVProcessError(NULL, CVSPILS_MEM_NULL, "CVBBDPRE", "CVBBDPrecGetNumGfnEvals", MSGBBD_MEM_NULL);
return(CVSPILS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (cv_mem->cv_lmem == NULL) {
CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVBBDPRE", "CVBBDPrecGetNumGfnEvals", MSGBBD_LMEM_NULL);
return(CVSPILS_LMEM_NULL);
}
cvspils_mem = (CVSpilsMem) cv_mem->cv_lmem;
if (cvspils_mem->s_P_data == NULL) {
CVProcessError(cv_mem, CVSPILS_PMEM_NULL, "CVBBDPRE", "CVBBDPrecGetNumGfnEvals", MSGBBD_PMEM_NULL);
return(CVSPILS_PMEM_NULL);
}
pdata = (CVBBDPrecData) cvspils_mem->s_P_data;
*ngevalsBBDP = pdata->nge;
return(CVSPILS_SUCCESS);
}
int CVSpilsSetPreconditionerB(void *cvadj_mem, CVSpilsPrecSetupFnB psetB,
CVSpilsPrecSolveFnB psolveB, void *P_dataB)
{
CVadjMem ca_mem;
CVSpilsMemB cvspilsB_mem;
CVodeMem cvB_mem;
int flag;
if (cvadj_mem == NULL) {
CVProcessError(NULL, CVSPILS_ADJMEM_NULL, "CVSPILS", "CVSpilsSetPreconditionerB", MSGS_CAMEM_NULL);
return(CVSPILS_ADJMEM_NULL);
}
ca_mem = (CVadjMem) cvadj_mem;
cvB_mem = ca_mem->cvb_mem;
if (lmemB == NULL) {
CVProcessError(cvB_mem, CVSPILS_LMEMB_NULL, "CVSPILS", "CVSpilsSetPreconditonerB", MSGS_LMEMB_NULL);
return(CVSPILS_LMEMB_NULL);
}
cvspilsB_mem = (CVSpilsMemB) lmemB;
pset_B = psetB;
psolve_B = psolveB;
P_data_B = P_dataB;
flag = CVSpilsSetPreconditioner(cvB_mem, CVAspilsPrecSetup, CVAspilsPrecSolve, cvadj_mem);
return(flag);
}
int CVSpilsSetDelt(void *cvode_mem, realtype delt)
{
CVodeMem cv_mem;
CVSpilsMem cvspils_mem;
/* Return immediately if cvode_mem is NULL */
if (cvode_mem == NULL) {
CVProcessError(NULL, CVSPILS_MEM_NULL, "CVSPILS", "CVSpilsSetDelt", MSGS_CVMEM_NULL);
return(CVSPILS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (lmem == NULL) {
CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVSPILS", "CVSpilsSetDelt", MSGS_LMEM_NULL);
return(CVSPILS_LMEM_NULL);
}
cvspils_mem = (CVSpilsMem) lmem;
/* Check for legal delt */
if(delt < ZERO) {
CVProcessError(cv_mem, CVSPILS_ILL_INPUT, "CVSPILS", "CVSpilsSetDelt", MSGS_BAD_DELT);
return(CVSPILS_ILL_INPUT);
}
cvspils_mem->s_delt = (delt == ZERO) ? CVSPILS_DELT : delt;
return(CVSPILS_SUCCESS);
}
int CVSpilsSetPreconditioner(void *cvode_mem, CVSpilsPrecSetupFn pset,
CVSpilsPrecSolveFn psolve, void *P_data)
{
CVodeMem cv_mem;
CVSpilsMem cvspils_mem;
/* Return immediately if cvode_mem is NULL */
if (cvode_mem == NULL) {
CVProcessError(NULL, CVSPILS_MEM_NULL, "CVSPILS", "CVSpilsSetPreconditioner", MSGS_CVMEM_NULL);
return(CVSPILS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (lmem == NULL) {
CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVSPILS", "CVSpilsSetPreconditioner", MSGS_LMEM_NULL);
return(CVSPILS_LMEM_NULL);
}
cvspils_mem = (CVSpilsMem) lmem;
cvspils_mem->s_pset = pset;
cvspils_mem->s_psolve = psolve;
if (psolve != NULL) cvspils_mem->s_P_data = P_data;
return(CVSPILS_SUCCESS);
}
int CVSpilsSetGSType(void *cvode_mem, int gstype)
{
CVodeMem cv_mem;
CVSpilsMem cvspils_mem;
/* Return immediately if cvode_mem is NULL */
if (cvode_mem == NULL) {
CVProcessError(NULL, CVSPILS_MEM_NULL, "CVSPILS", "CVSpilsSetGSType", MSGS_CVMEM_NULL);
return(CVSPILS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (lmem == NULL) {
CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVSPILS", "CVSpilsSetGSType", MSGS_LMEM_NULL);
return(CVSPILS_LMEM_NULL);
}
cvspils_mem = (CVSpilsMem) lmem;
if (ils_type != SPILS_SPGMR) {
CVProcessError(cv_mem, CVSPILS_ILL_INPUT, "CVSPILS", "CVSpilsSetGSType", MSGS_BAD_LSTYPE);
return(CVSPILS_ILL_INPUT);
}
/* Check for legal gstype */
if ((gstype != MODIFIED_GS) && (gstype != CLASSICAL_GS)) {
CVProcessError(cv_mem, CVSPILS_ILL_INPUT, "CVSPILS", "CVSpilsSetGSType", MSGS_BAD_GSTYPE);
return(CVSPILS_ILL_INPUT);
}
cvspils_mem->s_gstype = gstype;
return(CVSPILS_SUCCESS);
}
int CVSpilsSetMaxl(void *cvode_mem, int maxl)
{
CVodeMem cv_mem;
CVSpilsMem cvspils_mem;
int mxl;
/* Return immediately if cvode_mem is NULL */
if (cvode_mem == NULL) {
CVProcessError(NULL, CVSPILS_MEM_NULL, "CVSPILS", "CVSpilsSetMaxl", MSGS_CVMEM_NULL);
return(CVSPILS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (lmem == NULL) {
CVProcessError(NULL, CVSPILS_LMEM_NULL, "CVSPILS", "CVSpilsSetMaxl", MSGS_LMEM_NULL);
return(CVSPILS_LMEM_NULL);
}
cvspils_mem = (CVSpilsMem) lmem;
if (ils_type == SPILS_SPGMR) {
CVProcessError(cv_mem, CVSPILS_ILL_INPUT, "CVSPILS", "CVSpilsSetMaxl", MSGS_BAD_LSTYPE);
return(CVSPILS_ILL_INPUT);
}
mxl = (maxl <= 0) ? CVSPILS_MAXL : maxl;
cvspils_mem->s_maxl = mxl;
/* spbcg_mem->l_max = mxl; */
return(CVSPILS_SUCCESS);
}
int CVBandPrecGetNumRhsEvals(void *cvode_mem, long int *nfevalsBP)
{
CVodeMem cv_mem;
CVSpilsMem cvspils_mem;
CVBandPrecData pdata;
if (cvode_mem == NULL) {
CVProcessError(NULL, CVSPILS_MEM_NULL, "CVBANDPRE", "CVBandPrecGetNumRhsEvals", MSGBP_MEM_NULL);
return(CVSPILS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (cv_mem->cv_lmem == NULL) {
CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVBANDPRE", "CVBandPrecGetNumRhsEvals", MSGBP_LMEM_NULL);
return(CVSPILS_LMEM_NULL);
}
cvspils_mem = (CVSpilsMem) cv_mem->cv_lmem;
if (cvspils_mem->s_P_data == NULL) {
CVProcessError(cv_mem, CVSPILS_PMEM_NULL, "CVBANDPRE", "CVBandPrecGetNumRhsEvals", MSGBP_PMEM_NULL);
return(CVSPILS_PMEM_NULL);
}
pdata = (CVBandPrecData) cvspils_mem->s_P_data;
*nfevalsBP = pdata->nfeBP;
return(CVSPILS_SUCCESS);
}
int CVadjGetDataPointPolynomial(void *cvadj_mem, long int which,
realtype *t, int *order, N_Vector y)
{
CVadjMem ca_mem;
DtpntMem *dt_mem;
PolynomialDataMem content;
if (cvadj_mem == NULL) {
CVProcessError(NULL, CV_ADJMEM_NULL, "CVODEA", "CVadjGetDataPointPolynomial", MSGAM_NULL_CAMEM);
return(CV_ADJMEM_NULL);
}
ca_mem = (CVadjMem) cvadj_mem;
dt_mem = ca_mem->dt_mem;
if (interpType != CV_POLYNOMIAL) {
CVProcessError(NULL, CV_ILL_INPUT, "CVODEA", "CVadjGetDataPointPolynomial", MSGAM_WRONG_INTERP);
return(CV_ILL_INPUT);
}
*t = dt_mem[which]->t;
content = (PolynomialDataMem) (dt_mem[which]->content);
if (y != NULL)
N_VScale(ONE, content->y, y);
*order = content->order;
return(CV_SUCCESS);
}
int CVadjGetDataPointHermite(void *cvadj_mem, long int which,
realtype *t, N_Vector y, N_Vector yd)
{
CVadjMem ca_mem;
DtpntMem *dt_mem;
HermiteDataMem content;
if (cvadj_mem == NULL) {
CVProcessError(NULL, CV_ADJMEM_NULL, "CVODEA", "CVadjGetDataPointHermite", MSGAM_NULL_CAMEM);
return(CV_ADJMEM_NULL);
}
ca_mem = (CVadjMem) cvadj_mem;
dt_mem = ca_mem->dt_mem;
if (interpType != CV_HERMITE) {
CVProcessError(NULL, CV_ILL_INPUT, "CVODEA", "CVadjGetDataPointHermite", MSGAM_WRONG_INTERP);
return(CV_ILL_INPUT);
}
*t = dt_mem[which]->t;
content = (HermiteDataMem) (dt_mem[which]->content);
if (y != NULL)
N_VScale(ONE, content->y, y);
if (yd != NULL)
N_VScale(ONE, content->yd, yd);
return(CV_SUCCESS);
}
int CVBBDPrecGetWorkSpace(void *cvode_mem, long int *lenrwBBDP, long int *leniwBBDP)
{
CVodeMem cv_mem;
CVSpilsMem cvspils_mem;
CVBBDPrecData pdata;
if (cvode_mem == NULL) {
CVProcessError(NULL, CVSPILS_MEM_NULL, "CVBBDPRE", "CVBBDPrecGetWorkSpace", MSGBBD_MEM_NULL);
return(CVSPILS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (cv_mem->cv_lmem == NULL) {
CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVBBDPRE", "CVBBDPrecGetWorkSpace", MSGBBD_LMEM_NULL);
return(CVSPILS_LMEM_NULL);
}
cvspils_mem = (CVSpilsMem) cv_mem->cv_lmem;
if (cvspils_mem->s_P_data == NULL) {
CVProcessError(cv_mem, CVSPILS_PMEM_NULL, "CVBBDPRE", "CVBBDPrecGetWorkSpace", MSGBBD_PMEM_NULL);
return(CVSPILS_PMEM_NULL);
}
pdata = (CVBBDPrecData) cvspils_mem->s_P_data;
*lenrwBBDP = pdata->rpwsize;
*leniwBBDP = pdata->ipwsize;
return(CVSPILS_SUCCESS);
}
int CVSpilsSetPrecType(void *cvode_mem, int pretype)
{
CVodeMem cv_mem;
CVSpilsMem cvspils_mem;
/* Return immediately if cvode_mem is NULL */
if (cvode_mem == NULL) {
CVProcessError(NULL, CVSPILS_MEM_NULL, "CVSPILS", "CVSpilsSetPrecType", MSGS_CVMEM_NULL);
return(CVSPILS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (lmem == NULL) {
CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVSPILS", "CVSpilsSetPrecType", MSGS_LMEM_NULL);
return(CVSPILS_LMEM_NULL);
}
cvspils_mem = (CVSpilsMem) lmem;
/* Check for legal pretype */
if ((pretype != PREC_NONE) && (pretype != PREC_LEFT) &&
(pretype != PREC_RIGHT) && (pretype != PREC_BOTH)) {
CVProcessError(cv_mem, CVSPILS_ILL_INPUT, "CVSPILS", "CVSpilsSetPrecType", MSGS_BAD_PRETYPE);
return(CVSPILS_ILL_INPUT);
}
cvspils_mem->s_pretype = pretype;
return(CVSPILS_SUCCESS);
}
int CVBandSetJacFnB(void *cvadj_mem, CVBandJacFnB bjacB, void *jac_dataB)
{
CVadjMem ca_mem;
CVBandMemB cvbandB_mem;
CVodeMem cvB_mem;
int flag;
if (cvadj_mem == NULL) {
CVProcessError(NULL, CVBAND_ADJMEM_NULL, "CVBAND", "CVBandSetJacFnB", MSGB_CAMEM_NULL);
return(CVBAND_ADJMEM_NULL);
}
ca_mem = (CVadjMem) cvadj_mem;
cvB_mem = ca_mem->cvb_mem;
if (lmemB == NULL) {
CVProcessError(cvB_mem, CVBAND_LMEMB_NULL, "CVBAND", "CVBandSetJacFnB", MSGB_LMEMB_NULL);
return(CVBAND_LMEMB_NULL);
}
cvbandB_mem = (CVBandMemB) lmemB;
bjac_B = bjacB;
jac_data_B = jac_dataB;
flag = CVBandSetJacFn(cvB_mem, CVAbandJac, cvadj_mem);
return(flag);
}
/*
* CVDlsGetWorkSpace returns the length of workspace allocated for the
* CVDLS linear solver.
*/
int CVDlsGetWorkSpace(void *cvode_mem, long int *lenrwLS, long int *leniwLS)
{
CVodeMem cv_mem;
CVDlsMem cvdls_mem;
/* Return immediately if cvode_mem is NULL */
if (cvode_mem == NULL) {
CVProcessError(NULL, CVDLS_MEM_NULL, "CVDLS", "CVDlsGetWorkSpace", MSGD_CVMEM_NULL);
return(CVDLS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (lmem == NULL) {
CVProcessError(cv_mem, CVDLS_LMEM_NULL, "CVDLS", "CVDlsGetWorkSpace", MSGD_LMEM_NULL);
return(CVDLS_LMEM_NULL);
}
cvdls_mem = (CVDlsMem) lmem;
if (mtype == SUNDIALS_DENSE) {
*lenrwLS = 2*n*n;
*leniwLS = n;
} else if (mtype == SUNDIALS_BAND) {
*lenrwLS = n*(smu + mu + 2*ml + 2);
*leniwLS = n;
}
return(CVDLS_SUCCESS);
}
int CVodeSetMaxStep(void *cvode_mem, realtype hmax)
{
realtype hmax_inv;
CVodeMem cv_mem;
if (cvode_mem==NULL) {
CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeSetMaxStep", MSGCV_NO_MEM);
return (CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (hmax < 0) {
CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetMaxStep", MSGCV_NEG_HMAX);
return(CV_ILL_INPUT);
}
/* Passing 0 sets hmax = infinity */
if (hmax == ZERO) {
cv_mem->cv_hmax_inv = HMAX_INV_DEFAULT;
return(CV_SUCCESS);
}
hmax_inv = ONE/hmax;
if (hmax_inv * cv_mem->cv_hmin > ONE) {
CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetMaxStep", MSGCV_BAD_HMIN_HMAX);
return(CV_ILL_INPUT);
}
cv_mem->cv_hmax_inv = hmax_inv;
return(CV_SUCCESS);
}
int CVodeSetStopTime(void *cvode_mem, realtype tstop)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeSetStopTime", MSGCV_NO_MEM);
return (CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
/* If CVode was called at least once, test if tstop is legal
* (i.e. if it was not already passed).
* If CVodeSetStopTime is called before the first call to CVode,
* tstop will be checked in CVode. */
if (cv_mem->cv_nst > 0) {
if ( (tstop - cv_mem->cv_tn) * cv_mem->cv_h < ZERO ) {
CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetStopTime", MSGCV_BAD_TSTOP, cv_mem->cv_tn);
return(CV_ILL_INPUT);
}
}
cv_mem->cv_tstop = tstop;
cv_mem->cv_tstopset = TRUE;
return(CV_SUCCESS);
}
/*
* CVDlsSetDenseJacFn specifies the dense Jacobian function.
*/
int CVDlsSetDenseJacFn(void *cvode_mem, CVDlsDenseJacFn jac)
{
CVodeMem cv_mem;
CVDlsMem cvdls_mem;
/* Return immediately if cvode_mem is NULL */
if (cvode_mem == NULL) {
CVProcessError(NULL, CVDLS_MEM_NULL, "CVDLS", "CVDlsSetDenseJacFn", MSGD_CVMEM_NULL);
return(CVDLS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (lmem == NULL) {
CVProcessError(cv_mem, CVDLS_LMEM_NULL, "CVDLS", "CVDlsSetDenseJacFn", MSGD_LMEM_NULL);
return(CVDLS_LMEM_NULL);
}
cvdls_mem = (CVDlsMem) lmem;
if (jac != NULL) {
jacDQ = FALSE;
djac = jac;
} else {
jacDQ = TRUE;
}
return(CVDLS_SUCCESS);
}
int CVodeSetMinStep(void *cvode_mem, realtype hmin)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeSetMinStep", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (hmin<0) {
CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetMinStep", MSGCV_NEG_HMIN);
return(CV_ILL_INPUT);
}
/* Passing 0 sets hmin = zero */
if (hmin == ZERO) {
cv_mem->cv_hmin = HMIN_DEFAULT;
return(CV_SUCCESS);
}
if (hmin * cv_mem->cv_hmax_inv > ONE) {
CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetMinStep", MSGCV_BAD_HMIN_HMAX);
return(CV_ILL_INPUT);
}
cv_mem->cv_hmin = hmin;
return(CV_SUCCESS);
}
int CVodeSetMaxOrd(void *cvode_mem, int maxord)
{
CVodeMem cv_mem;
int qmax_alloc;
if (cvode_mem==NULL) {
CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeSetMaxOrd", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (maxord <= 0) {
CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetMaxOrd", MSGCV_NEG_MAXORD);
return(CV_ILL_INPUT);
}
/* Cannot increase maximum order beyond the value that
was used when allocating memory */
qmax_alloc = cv_mem->cv_qmax_alloc;
if (maxord > qmax_alloc) {
CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetMaxOrd", MSGCV_BAD_MAXORD);
return(CV_ILL_INPUT);
}
cv_mem->cv_qmax = maxord;
return(CV_SUCCESS);
}
static int CVDiagSetup(CVodeMem cv_mem, int convfail, N_Vector ypred,
N_Vector fpred, booleantype *jcurPtr, N_Vector vtemp1,
N_Vector vtemp2, N_Vector vtemp3)
{
realtype r;
N_Vector ftemp, y;
booleantype invOK;
CVDiagMem cvdiag_mem;
int retval;
cvdiag_mem = (CVDiagMem) lmem;
/* Rename work vectors for use as temporary values of y and f */
ftemp = vtemp1;
y = vtemp2;
/* Form y with perturbation = FRACT*(func. iter. correction) */
r = FRACT * rl1;
N_VLinearSum(h, fpred, -ONE, zn[1], ftemp);
N_VLinearSum(r, ftemp, ONE, ypred, y);
/* Evaluate f at perturbed y */
retval = f(tn, y, M, f_data);
nfeDI++;
if (retval < 0) {
CVProcessError(cv_mem, CVDIAG_RHSFUNC_UNRECVR, "CVDIAG", "CVDiagSetup", MSGDG_RHSFUNC_FAILED);
last_flag = CVDIAG_RHSFUNC_UNRECVR;
return(-1);
}
if (retval > 0) {
last_flag = CVDIAG_RHSFUNC_RECVR;
return(1);
}
/* Construct M = I - gamma*J with J = diag(deltaf_i/deltay_i) */
N_VLinearSum(ONE, M, -ONE, fpred, M);
N_VLinearSum(FRACT, ftemp, -h, M, M);
N_VProd(ftemp, ewt, y);
/* Protect against deltay_i being at roundoff level */
N_VCompare(uround, y, bit);
N_VAddConst(bit, -ONE, bitcomp);
N_VProd(ftemp, bit, y);
N_VLinearSum(FRACT, y, -ONE, bitcomp, y);
N_VDiv(M, y, M);
N_VProd(M, bit, M);
N_VLinearSum(ONE, M, -ONE, bitcomp, M);
/* Invert M with test for zero components */
invOK = N_VInvTest(M, M);
if (!invOK) {
last_flag = CVDIAG_INV_FAIL;
return(1);
}
/* Set jcur = TRUE, save gamma in gammasv, and return */
*jcurPtr = TRUE;
gammasv = gamma;
last_flag = CVDIAG_SUCCESS;
return(0);
}
int CVodeGetIntegratorStats(void *cvode_mem, long int *nsteps, long int *nfevals,
long int *nlinsetups, long int *netfails, int *qlast,
int *qcur, realtype *hinused, realtype *hlast,
realtype *hcur, realtype *tcur)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeGetIntegratorStats", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
*nsteps = nst;
*nfevals = nfe;
*nlinsetups = nsetups;
*netfails = netf;
*qlast = qu;
*qcur = next_q;
*hinused = h0u;
*hlast = hu;
*hcur = next_h;
*tcur = tn;
return(CV_SUCCESS);
}
int CVAspilsJacTimesVec(N_Vector vB, N_Vector JvB, realtype t,
N_Vector yB, N_Vector fyB,
void *cvadj_mem, N_Vector tmpB)
{
CVadjMem ca_mem;
CVodeMem cvB_mem;
CVSpilsMemB cvspilsB_mem;
int retval, flag;
ca_mem = (CVadjMem) cvadj_mem;
cvB_mem = ca_mem->cvb_mem;
cvspilsB_mem = (CVSpilsMemB) lmemB;
/* Forward solution from interpolation */
flag = getY(ca_mem, t, ytmp);
if (flag != CV_SUCCESS) {
CVProcessError(cvB_mem, -1, "CVSPILS", "CVAspilsJacTimesVec", MSGS_BAD_T);
return(-1);
}
/* Call user's adjoint jtimesB routine */
retval = jtimes_B(vB, JvB, t, ytmp, yB, fyB, jac_data_B, tmpB);
return(retval);
}
static int CVAbandJac(long int nB, long int mupperB,
long int mlowerB, BandMat JB, realtype t,
N_Vector yB, N_Vector fyB, void *cvadj_mem,
N_Vector tmp1B, N_Vector tmp2B, N_Vector tmp3B)
{
CVadjMem ca_mem;
CVodeMem cvB_mem;
CVBandMemB cvbandB_mem;
int retval, flag;
ca_mem = (CVadjMem) cvadj_mem;
cvB_mem = ca_mem->cvb_mem;
cvbandB_mem = (CVBandMemB) lmemB;
/* Forward solution from interpolation */
flag = getY(ca_mem, t, ytmp);
if (flag != CV_SUCCESS) {
CVProcessError(cvB_mem, -1, "CVBAND", "CVAbandJac", MSGB_BAD_T);
return(-1);
}
/* Call user's adjoint band bjacB routine */
retval = bjac_B(nB, mupperB, mlowerB, JB, t, ytmp, yB, fyB, jac_data_B,
tmp1B, tmp2B, tmp3B);
return(retval);
}
int CVAspilsPrecSetup(realtype t, N_Vector yB,
N_Vector fyB, booleantype jokB,
booleantype *jcurPtrB, realtype gammaB,
void *cvadj_mem,
N_Vector tmp1B, N_Vector tmp2B, N_Vector tmp3B)
{
CVadjMem ca_mem;
CVodeMem cvB_mem;
CVSpilsMemB cvspilsB_mem;
int retval, flag;
ca_mem = (CVadjMem) cvadj_mem;
cvB_mem = ca_mem->cvb_mem;
cvspilsB_mem = (CVSpilsMemB) lmemB;
/* Forward solution from interpolation */
flag = getY(ca_mem, t, ytmp);
if (flag != CV_SUCCESS) {
CVProcessError(cvB_mem, -1, "CVSPILS", "CVAspilsPrecSetup", MSGS_BAD_T);
return(-1);
}
/* Call user's adjoint precondB routine */
retval = pset_B(t, ytmp, yB, fyB, jokB, jcurPtrB, gammaB,
P_data_B, tmp1B, tmp2B, tmp3B);
return(retval);
}
int CVadjGetCheckPointsInfo(void *cvadj_mem, CVadjCheckPointRec *ckpnt)
{
CVadjMem ca_mem;
CkpntMem ck_mem;
int i;
if (cvadj_mem == NULL) {
CVProcessError(NULL, CV_ADJMEM_NULL, "CVODEA", "CVadjGetCheckPointsInfo", MSGAM_NULL_CAMEM);
return(CV_ADJMEM_NULL);
}
ca_mem = (CVadjMem) cvadj_mem;
ck_mem = ca_mem->ck_mem;
i = 0;
while (ck_mem != NULL) {
ckpnt[i].my_addr = (void *) ck_mem;
ckpnt[i].next_addr = (void *) next_;
ckpnt[i].t0 = t0_;
ckpnt[i].t1 = t1_;
ckpnt[i].nstep = nst_;
ckpnt[i].order = q_;
ckpnt[i].step = h_;
ck_mem = next_;
i++;
}
return(CV_SUCCESS);
}
int CVAspilsPrecSolve(realtype t, N_Vector yB, N_Vector fyB,
N_Vector rB, N_Vector zB,
realtype gammaB, realtype deltaB,
int lrB, void *cvadj_mem, N_Vector tmpB)
{
CVadjMem ca_mem;
CVodeMem cvB_mem;
CVSpilsMemB cvspilsB_mem;
int retval, flag;
ca_mem = (CVadjMem) cvadj_mem;
cvB_mem = ca_mem->cvb_mem;
cvspilsB_mem = (CVSpilsMemB) lmemB;
/* Forward solution from interpolation */
flag = getY(ca_mem, t, ytmp);
if (flag != CV_SUCCESS) {
CVProcessError(cvB_mem, -1, "CVSPILS", "CVAspilsPrecSolve", MSGS_BAD_T);
return(-1);
}
/* Call user's adjoint psolveB routine */
retval = psolve_B(t, ytmp, yB, fyB, rB, zB, gammaB, deltaB,
lrB, P_data_B, tmpB);
return(retval);
}
int CVSpbcgB(void *cvadj_mem, int pretypeB, int maxlB)
{
CVadjMem ca_mem;
CVSpilsMemB cvspilsB_mem;
CVodeMem cvB_mem;
int flag;
if (cvadj_mem == NULL) {
CVProcessError(NULL, CVSPILS_ADJMEM_NULL, "CVSPBCG", "CVSpbcgB", MSGS_CAMEM_NULL);
return(CVSPILS_ADJMEM_NULL);
}
ca_mem = (CVadjMem) cvadj_mem;
cvB_mem = ca_mem->cvb_mem;
/* Get memory for CVSpilsMemRecB */
cvspilsB_mem = NULL;
cvspilsB_mem = (CVSpilsMemB) malloc(sizeof(CVSpilsMemRecB));
if (cvspilsB_mem == NULL) {
CVProcessError(cvB_mem, CVSPILS_MEM_FAIL, "CVSPBCG", "CVSpbcgB", MSGS_MEM_FAIL);
return(CVSPILS_MEM_FAIL);
}
pset_B = NULL;
psolve_B = NULL;
jtimes_B = NULL;
P_data_B = NULL;
jac_data_B = NULL;
/* attach lmemB and lfree */
lmemB = cvspilsB_mem;
lfreeB = CVSpbcgFreeB;
flag = CVSpbcg(cvB_mem, pretypeB, maxlB);
if (flag != CVSPILS_SUCCESS) {
free(cvspilsB_mem);
cvspilsB_mem = NULL;
}
return(flag);
}
int CVBBDPrecReInit(void *cvode_mem,
int mudq, int mldq,
realtype dqrely)
{
CVodeMem cv_mem;
CVSpilsMem cvspils_mem;
CVBBDPrecData pdata;
int Nlocal;
if (cvode_mem == NULL) {
CVProcessError(NULL, CVSPILS_MEM_NULL, "CVBBDPRE", "CVBBDPrecReInit", MSGBBD_MEM_NULL);
return(CVSPILS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
/* Test if one of the SPILS linear solvers has been attached */
if (cv_mem->cv_lmem == NULL) {
CVProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVBBDPRE", "CVBBDPrecReInit", MSGBBD_LMEM_NULL);
return(CVSPILS_LMEM_NULL);
}
cvspils_mem = (CVSpilsMem) cv_mem->cv_lmem;
/* Test if the preconditioner data is non-NULL */
if (cvspils_mem->s_P_data == NULL) {
CVProcessError(cv_mem, CVSPILS_PMEM_NULL, "CVBBDPRE", "CVBBDPrecReInit", MSGBBD_PMEM_NULL);
return(CVSPILS_PMEM_NULL);
}
pdata = (CVBBDPrecData) cvspils_mem->s_P_data;
/* Load half-bandwidths */
Nlocal = pdata->n_local;
pdata->mudq = MIN(Nlocal-1, MAX(0,mudq));
pdata->mldq = MIN(Nlocal-1, MAX(0,mldq));
/* Set pdata->dqrely based on input dqrely (0 implies default). */
pdata->dqrely = (dqrely > ZERO) ? dqrely : RSqrt(uround);
/* Re-initialize nge */
pdata->nge = 0;
return(CVSPILS_SUCCESS);
}
int CVodeSetStabLimDet(void *cvode_mem, booleantype sldet)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeSetStabLimDet", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if( sldet && (cv_mem->cv_lmm != CV_BDF) ) {
CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetStabLimDet", MSGCV_SET_SLDET);
return(CV_ILL_INPUT);
}
cv_mem->cv_sldeton = sldet;
return(CV_SUCCESS);
}
int CVodeSetIterType(void *cvode_mem, int iter)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
CVProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeSetIterType", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if ((iter != CV_FUNCTIONAL) && (iter != CV_NEWTON)) {
CVProcessError(cv_mem, CV_ILL_INPUT, "CVODE", "CVodeSetIterType", MSGCV_BAD_ITER);
return (CV_ILL_INPUT);
}
cv_mem->cv_iter = iter;
return(CV_SUCCESS);
}