int CVodeGetEstLocalErrors(void *cvode_mem, N_Vector ele)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeGetEstLocalErrors", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
N_VScale(ONE, acor, ele);
return(CV_SUCCESS);
}
int CVodeSetMaxConvFails(void *cvode_mem, int maxncf)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeSetMaxConvFails", MSGCV_NO_MEM);
return (CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
cv_mem->cv_maxncf = maxncf;
return(CV_SUCCESS);
}
int CVodeGetNumGEvals(void *cvode_mem, long int *ngevals)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeGetNumGEvals", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
*ngevals = nge;
return(CV_SUCCESS);
}
int CVodeGetSensStats(void *cvode_mem, long int *nfSevals, long int *nfevalsS,
long int *nSetfails, long int *nlinsetupsS)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeGetSensStats", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (sensi==FALSE) {
cvProcessError(cv_mem, CV_NO_SENS, "CVODES", "CVodeGetSensStats", MSGCV_NO_SENSI);
return(CV_NO_SENS);
}
*nfSevals = nfSe;
*nfevalsS = nfeS;
*nSetfails = netfS;
*nlinsetupsS = nsetupsS;
return(CV_SUCCESS);
}
int CVodeSetNoInactiveRootWarn(void *cvode_mem)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeSetNoInactiveRootWarn", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
cv_mem->cv_mxgnull = 0;
return(CV_SUCCESS);
}
int CVodeSetSensMaxNonlinIters(void *cvode_mem, int maxcorS)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeSetSensMaxNonlinIters", MSGCV_NO_MEM);
return (CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
cv_mem->cv_maxcorS = maxcorS;
return(CV_SUCCESS);
}
int CVodeGetStgrSensNumNonlinSolvConvFails(void *cvode_mem, long int *nSTGR1ncfails)
{
CVodeMem cv_mem;
int is, Ns;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeGetStgrSensNumNonlinSolvConvFails", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
Ns = cv_mem->cv_Ns;
if (sensi==FALSE) {
cvProcessError(cv_mem, CV_NO_SENS, "CVODES", "CVodeGetStgrSensNumNonlinSolvConvFails", MSGCV_NO_SENSI);
return(CV_NO_SENS);
}
if(ism==CV_STAGGERED1)
for(is=0; is<Ns; is++) nSTGR1ncfails[is] = ncfnS1[is];
return(CV_SUCCESS);
}
int CVodeGetNumNonlinSolvConvFails(void *cvode_mem, long int *nncfails)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeGetNumNonlinSolvConvFails", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
*nncfails = ncfn;
return(CV_SUCCESS);
}
int CVodeGetSensErrWeights(void *cvode_mem, N_Vector *eSweight)
{
CVodeMem cv_mem;
int is, Ns;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeGetSensErrWeights", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (sensi==FALSE) {
cvProcessError(cv_mem, CV_NO_SENS, "CVODES", "CVodeGetSensErrWeights", MSGCV_NO_SENSI);
return(CV_NO_SENS);
}
Ns = cv_mem->cv_Ns;
for (is=0; is<Ns; is++)
N_VScale(ONE, ewtS[is], eSweight[is]);
return(CV_SUCCESS);
}
int CVodeGetErrWeights(void *cvode_mem, N_Vector eweight)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeGetErrWeights", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
N_VScale(ONE, ewt, eweight);
return(CV_SUCCESS);
}
int CVodeSetErrFile(void *cvode_mem, FILE *errfp)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeSetErrFile", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
cv_mem->cv_errfp = errfp;
return(CV_SUCCESS);
}
int CVodeSetNonlinConvCoef(void *cvode_mem, realtype nlscoef)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeSetNonlinConvCoef", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
cv_mem->cv_nlscoef = nlscoef;
return(CV_SUCCESS);
}
int CVSpilsSetPreconditioner(void *cvode_mem,
CVSpilsPrecSetupFn pset, CVSpilsPrecSolveFn psolve)
{
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;
return(CVSPILS_SUCCESS);
}
int CVBandPrecGetWorkSpace(void *cvode_mem, long int *lenrwBP, long int *leniwBP)
{
CVodeMem cv_mem;
CVSpilsMem cvspils_mem;
CVBandPrecData pdata;
long int N, ml, mu, smu;
if (cvode_mem == NULL) {
cvProcessError(NULL, CVSPILS_MEM_NULL, "CVBANDPRE", "CVBandPrecGetWorkSpace", 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", "CVBandPrecGetWorkSpace", 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", "CVBandPrecGetWorkSpace", MSGBP_PMEM_NULL);
return(CVSPILS_PMEM_NULL);
}
pdata = (CVBandPrecData) cvspils_mem->s_P_data;
N = pdata->N;
mu = pdata->mu;
ml = pdata->ml;
smu = SUNMIN( N-1, mu + ml);
*leniwBP = pdata->N;
*lenrwBP = N * ( 2*ml + smu + mu + 2 );
return(CVSPILS_SUCCESS);
}
int CVodeSetInitStep(void *cvode_mem, realtype hin)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeSetInitStep", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
cv_mem->cv_hin = hin;
return(CV_SUCCESS);
}
int CVodeSetMaxHnilWarns(void *cvode_mem, int mxhnil)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeSetMaxHnilWarns", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
cv_mem->cv_mxhnil = mxhnil;
return(CV_SUCCESS);
}
int CVodeSetUserData(void *cvode_mem, void *user_data)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeSetUserData", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
cv_mem->cv_user_data = user_data;
return(CV_SUCCESS);
}
int CVodeSetErrHandlerFn(void *cvode_mem, CVErrHandlerFn ehfun, void *eh_data)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeSetErrHandlerFn", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
cv_mem->cv_ehfun = ehfun;
cv_mem->cv_eh_data = eh_data;
return(CV_SUCCESS);
}
int CVodeGetWorkSpace(void *cvode_mem, long int *lenrw, long int *leniw)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeGetWorkSpace", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
*leniw = cv_mem->cv_liw;
*lenrw = cv_mem->cv_lrw;
return(CV_SUCCESS);
}
int CVDiagGetWorkSpace(void *cvode_mem, long int *lenrwLS, long int *leniwLS)
{
CVodeMem cv_mem;
/* Return immediately if cvode_mem is NULL */
if (cvode_mem == NULL) {
cvProcessError(NULL, CVDIAG_MEM_NULL, "CVDIAG", "CVDiagGetWorkSpace", MSGDG_CVMEM_NULL);
return(CVDIAG_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
*lenrwLS = 3*lrw1;
*leniwLS = 3*liw1;
return(CVDIAG_SUCCESS);
}
static int cvNlsLSolve(N_Vector ycor, N_Vector delta, void* cvode_mem)
{
CVodeMem cv_mem;
int retval;
if (cvode_mem == NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODE", "cvNlsLSolve", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
retval = cv_mem->cv_lsolve(cv_mem, delta, cv_mem->cv_ewt, cv_mem->cv_y, cv_mem->cv_ftemp);
if (retval < 0) return(CV_LSOLVE_FAIL);
if (retval > 0) return(SUN_NLS_CONV_RECVR);
return(CV_SUCCESS);
}
int CVodeGetRootInfo(void *cvode_mem, int *rootsfound)
{
CVodeMem cv_mem;
int i, nrt;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeGetRootInfo", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
nrt = cv_mem->cv_nrtfn;
for (i=0; i<nrt; i++) rootsfound[i] = cv_mem->cv_iroots[i];
return(CV_SUCCESS);
}
int CVodeGetNumStabLimOrderReds(void *cvode_mem, long int *nslred)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODE", "CVodeGetNumStabLimOrderReds", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
if (cv_mem->cv_sldeton==SUNFALSE)
*nslred = 0;
else
*nslred = cv_mem->cv_nor;
return(CV_SUCCESS);
}
static int CVSptfqmrSetup(CVodeMem cv_mem, int convfail, N_Vector ypred,
N_Vector fpred, booleantype *jcurPtr, N_Vector vtemp1,
N_Vector vtemp2, N_Vector vtemp3)
{
booleantype jbad, jok;
realtype dgamma;
int retval;
CVSpilsMem cvspils_mem;
cvspils_mem = (CVSpilsMem) lmem;
/* Use nst, gamma/gammap, and convfail to set J eval. flag jok */
dgamma = ABS((gamma/gammap) - ONE);
jbad = (nst == 0) || (nst > nstlpre + CVSPILS_MSBPRE) ||
((convfail == CV_FAIL_BAD_J) && (dgamma < CVSPILS_DGMAX)) ||
(convfail == CV_FAIL_OTHER);
*jcurPtr = jbad;
jok = !jbad;
/* Call pset routine and possibly reset jcur */
retval = pset(tn, ypred, fpred, jok, jcurPtr, gamma, P_data,
vtemp1, vtemp2, vtemp3);
if (retval < 0) {
cvProcessError(cv_mem, SPTFQMR_PSET_FAIL_UNREC, "CVSPTFQMR", "CVSptfqmrSetup", MSGS_PSET_FAILED);
last_flag = SPTFQMR_PSET_FAIL_UNREC;
}
if (retval > 0) {
last_flag = SPTFQMR_PSET_FAIL_REC;
}
if (jbad) *jcurPtr = TRUE;
/* If jcur = TRUE, increment npe and save nst value */
if (*jcurPtr) {
npe++;
nstlpre = nst;
}
last_flag = SPTFQMR_SUCCESS;
/* Return the same value that pset returned */
return(retval);
}
static int cvNlsConvTestSensStg1(SUNNonlinearSolver NLS,
N_Vector ycor, N_Vector delta,
realtype tol, N_Vector ewt, void* cvode_mem)
{
CVodeMem cv_mem;
int m, retval;
realtype del;
realtype dcon;
if (cvode_mem == NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES",
"cvNlsConvTestSensStg1", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
/* compute the norm of the state and sensitivity corrections */
del = N_VWrmsNorm(delta, ewt);
/* get the current nonlinear solver iteration count */
retval = SUNNonlinSolGetCurIter(NLS, &m);
if (retval != CV_SUCCESS) return(CV_MEM_NULL);
/* Test for convergence. If m > 0, an estimate of the convergence
rate constant is stored in crate, and used in the test.
*/
if (m > 0) {
cv_mem->cv_crateS = SUNMAX(CRDOWN * cv_mem->cv_crateS, del/cv_mem->cv_delp);
}
dcon = del * SUNMIN(ONE, cv_mem->cv_crateS) / tol;
/* check if nonlinear system was solved successfully */
if (dcon <= ONE) return(CV_SUCCESS);
/* check if the iteration seems to be diverging */
if ((m >= 1) && (del > RDIV*cv_mem->cv_delp)) return(SUN_NLS_CONV_RECVR);
/* Save norm of correction and loop again */
cv_mem->cv_delp = del;
/* Not yet converged */
return(SUN_NLS_CONTINUE);
}
int CVodeSetMaxNumSteps(void *cvode_mem, long int mxsteps)
{
CVodeMem cv_mem;
if (cvode_mem==NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES", "CVodeSetMaxNumSteps", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
/* Passing mxsteps=0 sets the default. Passing mxsteps<0 disables the test. */
if (mxsteps == 0)
cv_mem->cv_mxstep = MXSTEP_DEFAULT;
else
cv_mem->cv_mxstep = mxsteps;
return(CV_SUCCESS);
}
static int cvNlsLSetupSensStg1(N_Vector ycor, N_Vector res,
booleantype jbad, booleantype* jcur,
void* cvode_mem)
{
CVodeMem cv_mem;
int retval;
if (cvode_mem == NULL) {
cvProcessError(NULL, CV_MEM_NULL, "CVODES",
"cvNlsLSetupSensStg1", MSGCV_NO_MEM);
return(CV_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
/* if the nonlinear solver marked the Jacobian as bad update convfail */
if (jbad)
cv_mem->convfail = CV_FAIL_BAD_J;
/* setup the linear solver */
retval = cv_mem->cv_lsetup(cv_mem, cv_mem->convfail, cv_mem->cv_y,
cv_mem->cv_ftemp, &(cv_mem->cv_jcur),
cv_mem->cv_vtemp1, cv_mem->cv_vtemp2,
cv_mem->cv_vtemp3);
cv_mem->cv_nsetups++;
cv_mem->cv_nsetupsS++;
/* update Jacobian status */
*jcur = cv_mem->cv_jcur;
cv_mem->cv_gamrat = ONE;
cv_mem->cv_gammap = cv_mem->cv_gamma;
cv_mem->cv_crate = ONE;
cv_mem->cv_crateS = ONE;
cv_mem->cv_nstlp = cv_mem->cv_nst;
if (retval < 0) return(CV_LSETUP_FAIL);
if (retval > 0) return(SUN_NLS_CONV_RECVR);
return(CV_SUCCESS);
}
static int CVSpbcgInit(CVodeMem cv_mem)
{
CVSpilsMem cvspils_mem;
SpbcgMem spbcg_mem;
cvspils_mem = (CVSpilsMem) lmem;
spbcg_mem = (SpbcgMem) spils_mem;
/* Initialize counters */
npe = nli = nps = ncfl = nstlpre = 0;
njtimes = nfes = 0;
/* Check for legal combination pretype - psolve */
if ((pretype != PREC_NONE) && (psolve == NULL)) {
cvProcessError(cv_mem, -1, "CVSPBCG", "CVSpbcgInit", MSGS_PSOLVE_REQ);
last_flag = CVSPILS_ILL_INPUT;
return(-1);
}
/* Set setupNonNull = TRUE iff there is preconditioning
(pretype != PREC_NONE) and there is a preconditioning
setup phase (pset != NULL) */
setupNonNull = (pretype != PREC_NONE) && (pset != NULL);
/* Set Jacobian-related fields, based on jtimesDQ */
if (jtimesDQ) {
jtimes = CVSpilsDQJtimes;
j_data = cv_mem;
} else {
j_data = user_data;
}
/* Set maxl in the SPBCG memory in case it was changed by the user */
spbcg_mem->l_max = maxl;
last_flag = CVSPILS_SUCCESS;
return(0);
}
/* CVodeSetEpsLin specifies the nonlinear -> linear tolerance scale factor */
int CVodeSetEpsLin(void *cvode_mem, realtype eplifac)
{
CVodeMem cv_mem;
CVLsMem cvls_mem;
int retval;
/* access CVLsMem structure */
retval = cvLs_AccessLMem(cvode_mem, "CVodeSetEpsLin",
&cv_mem, &cvls_mem);
if (retval != CVLS_SUCCESS) return(retval);
/* Check for legal eplifac */
if(eplifac < ZERO) {
cvProcessError(cv_mem, CVLS_ILL_INPUT, "CVLS",
"CVodeSetEpsLin", MSG_LS_BAD_EPLIN);
return(CVLS_ILL_INPUT);
}
cvls_mem->eplifac = (eplifac == ZERO) ? CVLS_EPLIN : eplifac;
return(CVLS_SUCCESS);
}
static int cvKLUSolve(CVodeMem cv_mem, N_Vector b, N_Vector weight,
N_Vector ycur, N_Vector fcur)
{
int flag, lmm;
realtype gamrat;
CVSlsMem cvsls_mem;
KLUData klu_data;
SlsMat JacMat;
realtype *bd;
gamrat = cv_mem->cv_gamrat;
lmm = cv_mem->cv_lmm;
cvsls_mem = (CVSlsMem) cv_mem->cv_lmem;
JacMat = cvsls_mem->s_JacMat;
klu_data = (KLUData) cvsls_mem->s_solver_data;
bd = N_VGetArrayPointer(b);
/* Call KLU to solve the linear system */
flag = klu_data->sun_klu_solve(klu_data->s_Symbolic, klu_data->s_Numeric, JacMat->NP, 1, bd,
&(klu_data->s_Common));
if (flag == 0) {
cvProcessError(cv_mem, CVSLS_PACKAGE_FAIL, "CVSLS", "CVKLUSolve",
MSGSP_PACKAGE_FAIL);
return(CVSLS_PACKAGE_FAIL);
}
/* Scale the correction to account for change in gamma. */
if ((lmm == CV_BDF) && (gamrat != ONE)) {
N_VScale(TWO/(ONE + gamrat), b, b);
}
cvsls_mem->s_last_flag = CVSLS_SUCCESS;
return(CVSLS_SUCCESS);
}
