void FCV_EWTSET(int *flag, int *ier)
{
CVodeMem cv_mem;
if (*flag != 0) {
cv_mem = (CVodeMem) CV_cvodemem;
*ier = CVodeWFtolerances(CV_cvodemem, FCVEwtSet);
}
}
int main(int argc, char *argv[])
{
void *cvode_mem;
UserData data;
realtype t, tout;
N_Vector y;
int iout, flag, nthreads, nnz;
realtype pbar[NS];
int is;
N_Vector *yS;
booleantype sensi, err_con;
int sensi_meth;
cvode_mem = NULL;
data = NULL;
y = NULL;
yS = NULL;
/* Process arguments */
ProcessArgs(argc, argv, &sensi, &sensi_meth, &err_con);
/* User data structure */
data = (UserData) malloc(sizeof *data);
if (check_flag((void *)data, "malloc", 2)) return(1);
data->p[0] = RCONST(0.04);
data->p[1] = RCONST(1.0e4);
data->p[2] = RCONST(3.0e7);
/* Initial conditions */
y = N_VNew_Serial(NEQ);
if (check_flag((void *)y, "N_VNew_Serial", 0)) return(1);
Ith(y,1) = Y1;
Ith(y,2) = Y2;
Ith(y,3) = Y3;
/* Call CVodeCreate to create the solver memory and specify the
Backward Differentiation Formula and the use of a Newton iteration */
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
/* Call CVodeInit to initialize the integrator memory and specify the
user's right hand side function in y'=f(t,y), the initial time T0, and
the initial dependent variable vector y. */
flag = CVodeInit(cvode_mem, f, T0, y);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
/* Call CVodeWFtolerances to specify a user-supplied function ewt that sets
the multiplicative error weights W_i for use in the weighted RMS norm */
flag = CVodeWFtolerances(cvode_mem, ewt);
if (check_flag(&flag, "CVodeSetEwtFn", 1)) return(1);
/* Attach user data */
flag = CVodeSetUserData(cvode_mem, data);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
/* Call CVKLU to specify the CVKLU sparse direct linear solver */
nthreads = 1; /* no. of threads to use when factoring the system*/
nnz = NEQ * NEQ; /* max no. of nonzeros entries in the Jac */
flag = CVSuperLUMT(cvode_mem, nthreads, NEQ, nnz);
if (check_flag(&flag, "CVSuperLUMT", 1)) return(1);
/* Set the Jacobian routine to Jac (user-supplied) */
flag = CVSlsSetSparseJacFn(cvode_mem, Jac);
if (check_flag(&flag, "CVSlsSetSparseJacFn", 1)) return(1);
printf("\n3-species chemical kinetics problem\n");
/* Sensitivity-related settings */
if (sensi) {
/* Set parameter scaling factor */
pbar[0] = data->p[0];
pbar[1] = data->p[1];
pbar[2] = data->p[2];
/* Set sensitivity initial conditions */
yS = N_VCloneVectorArray_Serial(NS, y);
if (check_flag((void *)yS, "N_VCloneVectorArray_Serial", 0)) return(1);
for (is=0;is<NS;is++) N_VConst(ZERO, yS[is]);
/* Call CVodeSensInit1 to activate forward sensitivity computations
and allocate internal memory for COVEDS related to sensitivity
calculations. Computes the right-hand sides of the sensitivity
ODE, one at a time */
flag = CVodeSensInit1(cvode_mem, NS, sensi_meth, fS, yS);
if(check_flag(&flag, "CVodeSensInit", 1)) return(1);
/* Call CVodeSensEEtolerances to estimate tolerances for sensitivity
variables based on the rolerances supplied for states variables and
the scaling factor pbar */
flag = CVodeSensEEtolerances(cvode_mem);
if(check_flag(&flag, "CVodeSensEEtolerances", 1)) return(1);
/* Set sensitivity analysis optional inputs */
/* Call CVodeSetSensErrCon to specify the error control strategy for
sensitivity variables */
flag = CVodeSetSensErrCon(cvode_mem, err_con);
if (check_flag(&flag, "CVodeSetSensErrCon", 1)) return(1);
/* Call CVodeSetSensParams to specify problem parameter information for
sensitivity calculations */
flag = CVodeSetSensParams(cvode_mem, NULL, pbar, NULL);
if (check_flag(&flag, "CVodeSetSensParams", 1)) return(1);
printf("Sensitivity: YES ");
if(sensi_meth == CV_SIMULTANEOUS)
printf("( SIMULTANEOUS +");
else
if(sensi_meth == CV_STAGGERED) printf("( STAGGERED +");
else printf("( STAGGERED1 +");
if(err_con) printf(" FULL ERROR CONTROL )");
else printf(" PARTIAL ERROR CONTROL )");
} else {
printf("Sensitivity: NO ");
}
/* In loop over output points, call CVode, print results, test for error */
printf("\n\n");
printf("===========================================");
printf("============================\n");
printf(" T Q H NST y1");
printf(" y2 y3 \n");
printf("===========================================");
printf("============================\n");
for (iout=1, tout=T1; iout <= NOUT; iout++, tout *= TMULT) {
flag = CVode(cvode_mem, tout, y, &t, CV_NORMAL);
if (check_flag(&flag, "CVode", 1)) break;
PrintOutput(cvode_mem, t, y);
/* Call CVodeGetSens to get the sensitivity solution vector after a
successful return from CVode */
if (sensi) {
flag = CVodeGetSens(cvode_mem, &t, yS);
if (check_flag(&flag, "CVodeGetSens", 1)) break;
PrintOutputS(yS);
}
printf("-----------------------------------------");
printf("------------------------------\n");
}
/* Print final statistics */
PrintFinalStats(cvode_mem, sensi);
/* Free memory */
N_VDestroy_Serial(y); /* Free y vector */
if (sensi) {
N_VDestroyVectorArray_Serial(yS, NS); /* Free yS vector */
}
free(data); /* Free user data */
CVodeFree(&cvode_mem); /* Free CVODES memory */
return(0);
}
int main(int argc, char *argv[])
{
UserData data;
SUNMatrix A, AB;
SUNLinearSolver LS, LSB;
void *cvode_mem;
realtype reltolQ, abstolQ;
N_Vector y, q, constraints;
int steps;
int indexB;
realtype reltolB, abstolB, abstolQB;
N_Vector yB, qB, constraintsB;
realtype time;
int retval, ncheck;
long int nst, nstB;
CVadjCheckPointRec *ckpnt;
data = NULL;
A = AB = NULL;
LS = LSB = NULL;
cvode_mem = NULL;
ckpnt = NULL;
y = yB = qB = NULL;
constraints = NULL;
constraintsB = NULL;
/* Print problem description */
printf("\nAdjoint Sensitivity Example for Chemical Kinetics\n");
printf("-------------------------------------------------\n\n");
printf("ODE: dy1/dt = -p1*y1 + p2*y2*y3\n");
printf(" dy2/dt = p1*y1 - p2*y2*y3 - p3*(y2)^2\n");
printf(" dy3/dt = p3*(y2)^2\n\n");
printf("Find dG/dp for\n");
printf(" G = int_t0^tB0 g(t,p,y) dt\n");
printf(" g(t,p,y) = y3\n\n\n");
/* User data structure */
data = (UserData) malloc(sizeof *data);
if (check_retval((void *)data, "malloc", 2)) return(1);
data->p[0] = RCONST(0.04);
data->p[1] = RCONST(1.0e4);
data->p[2] = RCONST(3.0e7);
/* Initialize y */
y = N_VNew_Serial(NEQ);
if (check_retval((void *)y, "N_VNew_Serial", 0)) return(1);
Ith(y,1) = RCONST(1.0);
Ith(y,2) = ZERO;
Ith(y,3) = ZERO;
/* Set constraints to all 1's for nonnegative solution values. */
constraints = N_VNew_Serial(NEQ);
if(check_retval((void *)constraints, "N_VNew_Serial", 0)) return(1);
N_VConst(ONE, constraints);
/* Initialize q */
q = N_VNew_Serial(1);
if (check_retval((void *)q, "N_VNew_Serial", 0)) return(1);
Ith(q,1) = ZERO;
/* Set the scalar realtive and absolute tolerances reltolQ and abstolQ */
reltolQ = RTOL;
abstolQ = ATOLq;
/* Create and allocate CVODES memory for forward run */
printf("Create and allocate CVODES memory for forward runs\n");
/* Call CVodeCreate to create the solver memory and specify the
Backward Differentiation Formula */
cvode_mem = CVodeCreate(CV_BDF);
if (check_retval((void *)cvode_mem, "CVodeCreate", 0)) return(1);
/* Call CVodeInit to initialize the integrator memory and specify the
user's right hand side function in y'=f(t,y), the initial time T0, and
the initial dependent variable vector y. */
retval = CVodeInit(cvode_mem, f, T0, y);
if (check_retval(&retval, "CVodeInit", 1)) return(1);
/* Call CVodeWFtolerances to specify a user-supplied function ewt that sets
the multiplicative error weights w_i for use in the weighted RMS norm */
retval = CVodeWFtolerances(cvode_mem, ewt);
if (check_retval(&retval, "CVodeWFtolerances", 1)) return(1);
/* Attach user data */
retval = CVodeSetUserData(cvode_mem, data);
if (check_retval(&retval, "CVodeSetUserData", 1)) return(1);
/* Call CVodeSetConstraints to initialize constraints */
retval = CVodeSetConstraints(cvode_mem, constraints);
if (check_retval(&retval, "CVODESetConstraints", 1)) return(1);
N_VDestroy(constraints);
/* Create dense SUNMatrix for use in linear solves */
A = SUNDenseMatrix(NEQ, NEQ);
if (check_retval((void *)A, "SUNDenseMatrix", 0)) return(1);
/* Create dense SUNLinearSolver object */
LS = SUNLinSol_Dense(y, A);
if (check_retval((void *)LS, "SUNLinSol_Dense", 0)) return(1);
/* Attach the matrix and linear solver */
retval = CVDlsSetLinearSolver(cvode_mem, LS, A);
if (check_retval(&retval, "CVDlsSetLinearSolver", 1)) return(1);
/* Set the user-supplied Jacobian routine Jac */
retval = CVDlsSetJacFn(cvode_mem, Jac);
if (check_retval(&retval, "CVDlsSetJacFn", 1)) return(1);
/* Call CVodeQuadInit to allocate initernal memory and initialize
quadrature integration*/
retval = CVodeQuadInit(cvode_mem, fQ, q);
if (check_retval(&retval, "CVodeQuadInit", 1)) return(1);
/* Call CVodeSetQuadErrCon to specify whether or not the quadrature variables
are to be used in the step size control mechanism within CVODES. Call
CVodeQuadSStolerances or CVodeQuadSVtolerances to specify the integration
tolerances for the quadrature variables. */
retval = CVodeSetQuadErrCon(cvode_mem, SUNTRUE);
if (check_retval(&retval, "CVodeSetQuadErrCon", 1)) return(1);
/* Call CVodeQuadSStolerances to specify scalar relative and absolute
tolerances. */
retval = CVodeQuadSStolerances(cvode_mem, reltolQ, abstolQ);
if (check_retval(&retval, "CVodeQuadSStolerances", 1)) return(1);
/* Allocate global memory */
/* Call CVodeAdjInit to update CVODES memory block by allocting the internal
memory needed for backward integration.*/
steps = STEPS; /* no. of integration steps between two consecutive ckeckpoints*/
retval = CVodeAdjInit(cvode_mem, steps, CV_HERMITE);
/*
retval = CVodeAdjInit(cvode_mem, steps, CV_POLYNOMIAL);
*/
if (check_retval(&retval, "CVodeAdjInit", 1)) return(1);
/* Perform forward run */
printf("Forward integration ... ");
/* Call CVodeF to integrate the forward problem over an interval in time and
saves checkpointing data */
retval = CVodeF(cvode_mem, TOUT, y, &time, CV_NORMAL, &ncheck);
if (check_retval(&retval, "CVodeF", 1)) return(1);
retval = CVodeGetNumSteps(cvode_mem, &nst);
if (check_retval(&retval, "CVodeGetNumSteps", 1)) return(1);
printf("done ( nst = %ld )\n",nst);
printf("\nncheck = %d\n\n", ncheck);
retval = CVodeGetQuad(cvode_mem, &time, q);
if (check_retval(&retval, "CVodeGetQuad", 1)) return(1);
printf("--------------------------------------------------------\n");
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf("G: %12.4Le \n",Ith(q,1));
#elif defined(SUNDIALS_DOUBLE_PRECISION)
printf("G: %12.4e \n",Ith(q,1));
#else
printf("G: %12.4e \n",Ith(q,1));
#endif
printf("--------------------------------------------------------\n\n");
/* Test check point linked list
(uncomment next block to print check point information) */
/*
{
int i;
printf("\nList of Check Points (ncheck = %d)\n\n", ncheck);
ckpnt = (CVadjCheckPointRec *) malloc ( (ncheck+1)*sizeof(CVadjCheckPointRec));
CVodeGetAdjCheckPointsInfo(cvode_mem, ckpnt);
for (i=0;i<=ncheck;i++) {
printf("Address: %p\n",ckpnt[i].my_addr);
printf("Next: %p\n",ckpnt[i].next_addr);
printf("Time interval: %le %le\n",ckpnt[i].t0, ckpnt[i].t1);
printf("Step number: %ld\n",ckpnt[i].nstep);
printf("Order: %d\n",ckpnt[i].order);
printf("Step size: %le\n",ckpnt[i].step);
printf("\n");
}
}
*/
/* Initialize yB */
yB = N_VNew_Serial(NEQ);
if (check_retval((void *)yB, "N_VNew_Serial", 0)) return(1);
Ith(yB,1) = ZERO;
Ith(yB,2) = ZERO;
Ith(yB,3) = ZERO;
/* Initialize qB */
qB = N_VNew_Serial(NP);
if (check_retval((void *)qB, "N_VNew", 0)) return(1);
Ith(qB,1) = ZERO;
Ith(qB,2) = ZERO;
Ith(qB,3) = ZERO;
/* Set the scalar relative tolerance reltolB */
reltolB = RTOL;
/* Set the scalar absolute tolerance abstolB */
abstolB = ATOLl;
/* Set the scalar absolute tolerance abstolQB */
abstolQB = ATOLq;
/* Set constraints to all 1's for nonnegative solution values. */
constraintsB = N_VNew_Serial(NEQ);
if(check_retval((void *)constraintsB, "N_VNew_Serial", 0)) return(1);
N_VConst(ONE, constraintsB);
/* Create and allocate CVODES memory for backward run */
printf("Create and allocate CVODES memory for backward run\n");
/* Call CVodeCreateB to specify the solution method for the backward
problem. */
retval = CVodeCreateB(cvode_mem, CV_BDF, &indexB);
if (check_retval(&retval, "CVodeCreateB", 1)) return(1);
/* Call CVodeInitB to allocate internal memory and initialize the
backward problem. */
retval = CVodeInitB(cvode_mem, indexB, fB, TB1, yB);
if (check_retval(&retval, "CVodeInitB", 1)) return(1);
/* Set the scalar relative and absolute tolerances. */
retval = CVodeSStolerancesB(cvode_mem, indexB, reltolB, abstolB);
if (check_retval(&retval, "CVodeSStolerancesB", 1)) return(1);
/* Attach the user data for backward problem. */
retval = CVodeSetUserDataB(cvode_mem, indexB, data);
if (check_retval(&retval, "CVodeSetUserDataB", 1)) return(1);
/* Call CVodeSetConstraintsB to initialize constraints */
retval = CVodeSetConstraintsB(cvode_mem, indexB, constraintsB);
if(check_retval(&retval, "CVodeSetConstraintsB", 1)) return(1);
N_VDestroy(constraintsB);
/* Create dense SUNMatrix for use in linear solves */
AB = SUNDenseMatrix(NEQ, NEQ);
if (check_retval((void *)AB, "SUNDenseMatrix", 0)) return(1);
/* Create dense SUNLinearSolver object */
LSB = SUNLinSol_Dense(yB, AB);
if (check_retval((void *)LSB, "SUNLinSol_Dense", 0)) return(1);
/* Attach the matrix and linear solver */
retval = CVDlsSetLinearSolverB(cvode_mem, indexB, LSB, AB);
if (check_retval(&retval, "CVDlsSetLinearSolverB", 1)) return(1);
/* Set the user-supplied Jacobian routine JacB */
retval = CVDlsSetJacFnB(cvode_mem, indexB, JacB);
if (check_retval(&retval, "CVDlsSetJacFnB", 1)) return(1);
/* Call CVodeQuadInitB to allocate internal memory and initialize backward
quadrature integration. */
retval = CVodeQuadInitB(cvode_mem, indexB, fQB, qB);
if (check_retval(&retval, "CVodeQuadInitB", 1)) return(1);
/* Call CVodeSetQuadErrCon to specify whether or not the quadrature variables
are to be used in the step size control mechanism within CVODES. Call
CVodeQuadSStolerances or CVodeQuadSVtolerances to specify the integration
tolerances for the quadrature variables. */
retval = CVodeSetQuadErrConB(cvode_mem, indexB, SUNTRUE);
if (check_retval(&retval, "CVodeSetQuadErrConB", 1)) return(1);
/* Call CVodeQuadSStolerancesB to specify the scalar relative and absolute tolerances
for the backward problem. */
retval = CVodeQuadSStolerancesB(cvode_mem, indexB, reltolB, abstolQB);
if (check_retval(&retval, "CVodeQuadSStolerancesB", 1)) return(1);
/* Backward Integration */
PrintHead(TB1);
/* First get results at t = TBout1 */
/* Call CVodeB to integrate the backward ODE problem. */
retval = CVodeB(cvode_mem, TBout1, CV_NORMAL);
if (check_retval(&retval, "CVodeB", 1)) return(1);
/* Call CVodeGetB to get yB of the backward ODE problem. */
retval = CVodeGetB(cvode_mem, indexB, &time, yB);
if (check_retval(&retval, "CVodeGetB", 1)) return(1);
/* Call CVodeGetAdjY to get the interpolated value of the forward solution
y during a backward integration. */
retval = CVodeGetAdjY(cvode_mem, TBout1, y);
if (check_retval(&retval, "CVodeGetAdjY", 1)) return(1);
PrintOutput1(time, TBout1, y, yB);
/* Then at t = T0 */
retval = CVodeB(cvode_mem, T0, CV_NORMAL);
if (check_retval(&retval, "CVodeB", 1)) return(1);
CVodeGetNumSteps(CVodeGetAdjCVodeBmem(cvode_mem, indexB), &nstB);
printf("Done ( nst = %ld )\n", nstB);
retval = CVodeGetB(cvode_mem, indexB, &time, yB);
if (check_retval(&retval, "CVodeGetB", 1)) return(1);
/* Call CVodeGetQuadB to get the quadrature solution vector after a
successful return from CVodeB. */
retval = CVodeGetQuadB(cvode_mem, indexB, &time, qB);
if (check_retval(&retval, "CVodeGetQuadB", 1)) return(1);
retval = CVodeGetAdjY(cvode_mem, T0, y);
if (check_retval(&retval, "CVodeGetAdjY", 1)) return(1);
PrintOutput(time, y, yB, qB);
/* Reinitialize backward phase (new tB0) */
Ith(yB,1) = ZERO;
Ith(yB,2) = ZERO;
Ith(yB,3) = ZERO;
Ith(qB,1) = ZERO;
Ith(qB,2) = ZERO;
Ith(qB,3) = ZERO;
printf("Re-initialize CVODES memory for backward run\n");
retval = CVodeReInitB(cvode_mem, indexB, TB2, yB);
if (check_retval(&retval, "CVodeReInitB", 1)) return(1);
retval = CVodeQuadReInitB(cvode_mem, indexB, qB);
if (check_retval(&retval, "CVodeQuadReInitB", 1)) return(1);
PrintHead(TB2);
/* First get results at t = TBout1 */
retval = CVodeB(cvode_mem, TBout1, CV_NORMAL);
if (check_retval(&retval, "CVodeB", 1)) return(1);
retval = CVodeGetB(cvode_mem, indexB, &time, yB);
if (check_retval(&retval, "CVodeGetB", 1)) return(1);
retval = CVodeGetAdjY(cvode_mem, TBout1, y);
if (check_retval(&retval, "CVodeGetAdjY", 1)) return(1);
PrintOutput1(time, TBout1, y, yB);
/* Then at t = T0 */
retval = CVodeB(cvode_mem, T0, CV_NORMAL);
if (check_retval(&retval, "CVodeB", 1)) return(1);
CVodeGetNumSteps(CVodeGetAdjCVodeBmem(cvode_mem, indexB), &nstB);
printf("Done ( nst = %ld )\n", nstB);
retval = CVodeGetB(cvode_mem, indexB, &time, yB);
if (check_retval(&retval, "CVodeGetB", 1)) return(1);
retval = CVodeGetQuadB(cvode_mem, indexB, &time, qB);
if (check_retval(&retval, "CVodeGetQuadB", 1)) return(1);
retval = CVodeGetAdjY(cvode_mem, T0, y);
if (check_retval(&retval, "CVodeGetAdjY", 1)) return(1);
PrintOutput(time, y, yB, qB);
/* Free memory */
printf("Free memory\n\n");
CVodeFree(&cvode_mem);
N_VDestroy(y);
N_VDestroy(q);
N_VDestroy(yB);
N_VDestroy(qB);
SUNLinSolFree(LS);
SUNMatDestroy(A);
SUNLinSolFree(LSB);
SUNMatDestroy(AB);
if (ckpnt != NULL) free(ckpnt);
free(data);
return(0);
}
int main()
{
realtype t, tout;
N_Vector y;
void *cvode_mem;
int flag, flagr, iout;
int rootsfound[2];
y = NULL;
cvode_mem = NULL;
/* Create serial vector of length NEQ for I.C. */
y = N_VNew_Serial(NEQ);
if (check_flag((void *)y, "N_VNew_Serial", 0)) return(1);
/* Initialize y */
Ith(y,1) = Y1;
Ith(y,2) = Y2;
Ith(y,3) = Y3;
/* Call CVodeCreate to create the solver memory and specify the
* Backward Differentiation Formula and the use of a Newton iteration */
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
/* Call CVodeInit to initialize the integrator memory and specify the
* user's right hand side function in y'=f(t,y), the inital time T0, and
* the initial dependent variable vector y. */
flag = CVodeInit(cvode_mem, f, T0, y);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
/* Use private function to compute error weights */
flag = CVodeWFtolerances(cvode_mem, ewt);
if (check_flag(&flag, "CVodeSetEwtFn", 1)) return(1);
/* Call CVodeRootInit to specify the root function g with 2 components */
flag = CVodeRootInit(cvode_mem, 2, g);
if (check_flag(&flag, "CVodeRootInit", 1)) return(1);
/* Call CVDense to specify the CVDENSE dense linear solver */
flag = CVDense(cvode_mem, NEQ);
if (check_flag(&flag, "CVDense", 1)) return(1);
/* Set the Jacobian routine to Jac (user-supplied) */
flag = CVDlsSetDenseJacFn(cvode_mem, Jac);
if (check_flag(&flag, "CVDlsSetDenseJacFn", 1)) return(1);
/* In loop, call CVode, print results, and test for error.
Break out of loop when NOUT preset output times have been reached. */
printf(" \n3-species kinetics problem\n\n");
iout = 0; tout = T1;
while(1) {
flag = CVode(cvode_mem, tout, y, &t, CV_NORMAL);
PrintOutput(t, Ith(y,1), Ith(y,2), Ith(y,3));
if (flag == CV_ROOT_RETURN) {
flagr = CVodeGetRootInfo(cvode_mem, rootsfound);
check_flag(&flagr, "CVodeGetRootInfo", 1);
PrintRootInfo(rootsfound[0],rootsfound[1]);
}
if (check_flag(&flag, "CVode", 1)) break;
if (flag == CV_SUCCESS) {
iout++;
tout *= TMULT;
}
if (iout == NOUT) break;
}
/* Print some final statistics */
PrintFinalStats(cvode_mem);
/* Free y vector */
N_VDestroy_Serial(y);
/* Free integrator memory */
CVodeFree(&cvode_mem);
return(0);
}
int main(int argc, char *argv[])
{
SUNMatrix A;
SUNLinearSolver LS;
void *cvode_mem;
UserData data;
realtype t, tout;
N_Vector y, constraints;
int iout, retval;
realtype pbar[NS];
int is;
N_Vector *yS;
booleantype sensi, err_con;
int sensi_meth;
cvode_mem = NULL;
data = NULL;
y = NULL;
yS = NULL;
A = NULL;
LS = NULL;
constraints = NULL;
/* Process arguments */
ProcessArgs(argc, argv, &sensi, &sensi_meth, &err_con);
/* User data structure */
data = (UserData) malloc(sizeof *data);
if (check_retval((void *)data, "malloc", 2)) return(1);
data->p[0] = RCONST(0.04);
data->p[1] = RCONST(1.0e4);
data->p[2] = RCONST(3.0e7);
/* Initial conditions */
y = N_VNew_Serial(NEQ);
if (check_retval((void *)y, "N_VNew_Serial", 0)) return(1);
Ith(y,1) = Y1;
Ith(y,2) = Y2;
Ith(y,3) = Y3;
/* Set constraints to all 1's for nonnegative solution values. */
constraints = N_VNew_Serial(NEQ);
if(check_retval((void *)constraints, "N_VNew_Serial", 0)) return(1);
N_VConst(ONE, constraints);
/* Create CVODES object */
cvode_mem = CVodeCreate(CV_BDF);
if (check_retval((void *)cvode_mem, "CVodeCreate", 0)) return(1);
/* Allocate space for CVODES */
retval = CVodeInit(cvode_mem, f, T0, y);
if (check_retval(&retval, "CVodeInit", 1)) return(1);
/* Use private function to compute error weights */
retval = CVodeWFtolerances(cvode_mem, ewt);
if (check_retval(&retval, "CVodeSetEwtFn", 1)) return(1);
/* Attach user data */
retval = CVodeSetUserData(cvode_mem, data);
if (check_retval(&retval, "CVodeSetUserData", 1)) return(1);
/* Call CVodeSetConstraints to initialize constraints */
retval = CVodeSetConstraints(cvode_mem, constraints);
if(check_retval(&retval, "CVodeSetConstraints", 1)) return(1);
N_VDestroy(constraints);
/* Create dense SUNMatrix */
A = SUNDenseMatrix(NEQ, NEQ);
if (check_retval((void *)A, "SUNDenseMatrix", 0)) return(1);
/* Create dense SUNLinearSolver */
LS = SUNLinSol_Dense(y, A);
if (check_retval((void *)LS, "SUNLinSol_Dense", 0)) return(1);
/* Attach the matrix and linear solver */
retval = CVDlsSetLinearSolver(cvode_mem, LS, A);
if (check_retval(&retval, "CVDlsSetLinearSolver", 1)) return(1);
/* Set the user-supplied Jacobian routine Jac */
retval = CVDlsSetJacFn(cvode_mem, Jac);
if (check_retval(&retval, "CVDlsSetJacFn", 1)) return(1);
printf("\n3-species chemical kinetics problem\n");
/* Sensitivity-related settings */
if (sensi) {
/* Set parameter scaling factor */
pbar[0] = data->p[0];
pbar[1] = data->p[1];
pbar[2] = data->p[2];
/* Set sensitivity initial conditions */
yS = N_VCloneVectorArray(NS, y);
if (check_retval((void *)yS, "N_VCloneVectorArray", 0)) return(1);
for (is=0;is<NS;is++) N_VConst(ZERO, yS[is]);
/* Call CVodeSensInit1 to activate forward sensitivity computations
and allocate internal memory for COVEDS related to sensitivity
calculations. Computes the right-hand sides of the sensitivity
ODE, one at a time */
retval = CVodeSensInit1(cvode_mem, NS, sensi_meth, fS, yS);
if(check_retval(&retval, "CVodeSensInit", 1)) return(1);
/* Call CVodeSensEEtolerances to estimate tolerances for sensitivity
variables based on the rolerances supplied for states variables and
the scaling factor pbar */
retval = CVodeSensEEtolerances(cvode_mem);
if(check_retval(&retval, "CVodeSensEEtolerances", 1)) return(1);
/* Set sensitivity analysis optional inputs */
/* Call CVodeSetSensErrCon to specify the error control strategy for
sensitivity variables */
retval = CVodeSetSensErrCon(cvode_mem, err_con);
if (check_retval(&retval, "CVodeSetSensErrCon", 1)) return(1);
/* Call CVodeSetSensParams to specify problem parameter information for
sensitivity calculations */
retval = CVodeSetSensParams(cvode_mem, NULL, pbar, NULL);
if (check_retval(&retval, "CVodeSetSensParams", 1)) return(1);
printf("Sensitivity: YES ");
if(sensi_meth == CV_SIMULTANEOUS)
printf("( SIMULTANEOUS +");
else
if(sensi_meth == CV_STAGGERED) printf("( STAGGERED +");
else printf("( STAGGERED1 +");
if(err_con) printf(" FULL ERROR CONTROL )");
else printf(" PARTIAL ERROR CONTROL )");
} else {
printf("Sensitivity: NO ");
}
/* In loop over output points, call CVode, print results, test for error */
printf("\n\n");
printf("===========================================");
printf("============================\n");
printf(" T Q H NST y1");
printf(" y2 y3 \n");
printf("===========================================");
printf("============================\n");
for (iout=1, tout=T1; iout <= NOUT; iout++, tout *= TMULT) {
retval = CVode(cvode_mem, tout, y, &t, CV_NORMAL);
if (check_retval(&retval, "CVode", 1)) break;
PrintOutput(cvode_mem, t, y);
/* Call CVodeGetSens to get the sensitivity solution vector after a
successful return from CVode */
if (sensi) {
retval = CVodeGetSens(cvode_mem, &t, yS);
if (check_retval(&retval, "CVodeGetSens", 1)) break;
PrintOutputS(yS);
}
printf("-----------------------------------------");
printf("------------------------------\n");
}
/* Print final statistics */
PrintFinalStats(cvode_mem, sensi);
/* Free memory */
N_VDestroy(y); /* Free y vector */
if (sensi) {
N_VDestroyVectorArray(yS, NS); /* Free yS vector */
}
free(data); /* Free user data */
CVodeFree(&cvode_mem); /* Free CVODES memory */
SUNLinSolFree(LS); /* Free the linear solver memory */
SUNMatDestroy(A); /* Free the matrix memory */
return(0);
}
int main(int argc, char *argv[])
{
UserData data;
void *cvode_mem;
realtype reltolQ, abstolQ;
N_Vector y, q;
int steps;
int indexB;
realtype reltolB, abstolB, abstolQB;
N_Vector yB, qB;
realtype time;
int flag, ncheck;
long int nst, nstB;
CVadjCheckPointRec *ckpnt;
data = NULL;
cvode_mem = NULL;
ckpnt = NULL;
y = yB = qB = NULL;
/* Print problem description */
printf("\nAdjoint Sensitivity Example for Chemical Kinetics\n");
printf("-------------------------------------------------\n\n");
printf("ODE: dy1/dt = -p1*y1 + p2*y2*y3\n");
printf(" dy2/dt = p1*y1 - p2*y2*y3 - p3*(y2)^2\n");
printf(" dy3/dt = p3*(y2)^2\n\n");
printf("Find dG/dp for\n");
printf(" G = int_t0^tB0 g(t,p,y) dt\n");
printf(" g(t,p,y) = y3\n\n\n");
/* User data structure */
data = (UserData) malloc(sizeof *data);
if (check_flag((void *)data, "malloc", 2)) return(1);
data->p[0] = RCONST(0.04);
data->p[1] = RCONST(1.0e4);
data->p[2] = RCONST(3.0e7);
/* Initialize y */
y = N_VNew_Serial(NEQ);
if (check_flag((void *)y, "N_VNew_Serial", 0)) return(1);
Ith(y,1) = RCONST(1.0);
Ith(y,2) = ZERO;
Ith(y,3) = ZERO;
/* Initialize q */
q = N_VNew_Serial(1);
if (check_flag((void *)q, "N_VNew_Serial", 0)) return(1);
Ith(q,1) = ZERO;
/* Set the scalar realtive and absolute tolerances reltolQ and abstolQ */
reltolQ = RTOL;
abstolQ = ATOLq;
/* Create and allocate CVODES memory for forward run */
printf("Create and allocate CVODES memory for forward runs\n");
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
flag = CVodeInit(cvode_mem, f, T0, y);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
flag = CVodeWFtolerances(cvode_mem, ewt);
if (check_flag(&flag, "CVodeWFtolerances", 1)) return(1);
flag = CVodeSetUserData(cvode_mem, data);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
flag = CVDense(cvode_mem, NEQ);
if (check_flag(&flag, "CVDense", 1)) return(1);
flag = CVDlsSetDenseJacFn(cvode_mem, Jac);
if (check_flag(&flag, "CVDlsSetDenseJacFn", 1)) return(1);
flag = CVodeQuadInit(cvode_mem, fQ, q);
if (check_flag(&flag, "CVodeQuadInit", 1)) return(1);
flag = CVodeQuadSStolerances(cvode_mem, reltolQ, abstolQ);
if (check_flag(&flag, "CVodeQuadSStolerances", 1)) return(1);
flag = CVodeSetQuadErrCon(cvode_mem, TRUE);
if (check_flag(&flag, "CVodeSetQuadErrCon", 1)) return(1);
/* Allocate global memory */
steps = STEPS;
flag = CVodeAdjInit(cvode_mem, steps, CV_HERMITE);
/*
flag = CVodeAdjInit(cvode_mem, steps, CV_POLYNOMIAL);
*/
if (check_flag(&flag, "CVodeAdjInit", 1)) return(1);
/* Perform forward run */
printf("Forward integration ... ");
flag = CVodeF(cvode_mem, TOUT, y, &time, CV_NORMAL, &ncheck);
if (check_flag(&flag, "CVodeF", 1)) return(1);
flag = CVodeGetNumSteps(cvode_mem, &nst);
if (check_flag(&flag, "CVodeGetNumSteps", 1)) return(1);
printf("done ( nst = %ld )\n",nst);
flag = CVodeGetQuad(cvode_mem, &time, q);
if (check_flag(&flag, "CVodeGetQuad", 1)) return(1);
printf("--------------------------------------------------------\n");
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf("G: %12.4Le \n",Ith(q,1));
#elif defined(SUNDIALS_DOUBLE_PRECISION)
printf("G: %12.4le \n",Ith(q,1));
#else
printf("G: %12.4e \n",Ith(q,1));
#endif
printf("--------------------------------------------------------\n\n");
/* Test check point linked list
(uncomment next block to print check point information) */
/*
{
int i;
printf("\nList of Check Points (ncheck = %d)\n\n", ncheck);
ckpnt = (CVadjCheckPointRec *) malloc ( (ncheck+1)*sizeof(CVadjCheckPointRec));
CVodeGetAdjCheckPointsInfo(cvode_mem, ckpnt);
for (i=0;i<=ncheck;i++) {
printf("Address: %p\n",ckpnt[i].my_addr);
printf("Next: %p\n",ckpnt[i].next_addr);
printf("Time interval: %le %le\n",ckpnt[i].t0, ckpnt[i].t1);
printf("Step number: %ld\n",ckpnt[i].nstep);
printf("Order: %d\n",ckpnt[i].order);
printf("Step size: %le\n",ckpnt[i].step);
printf("\n");
}
}
*/
/* Initialize yB */
yB = N_VNew_Serial(NEQ);
if (check_flag((void *)yB, "N_VNew_Serial", 0)) return(1);
Ith(yB,1) = ZERO;
Ith(yB,2) = ZERO;
Ith(yB,3) = ZERO;
/* Initialize qB */
qB = N_VNew_Serial(NP);
if (check_flag((void *)qB, "N_VNew", 0)) return(1);
Ith(qB,1) = ZERO;
Ith(qB,2) = ZERO;
Ith(qB,3) = ZERO;
/* Set the scalar relative tolerance reltolB */
reltolB = RTOL;
/* Set the scalar absolute tolerance abstolB */
abstolB = ATOLl;
/* Set the scalar absolute tolerance abstolQB */
abstolQB = ATOLq;
/* Create and allocate CVODES memory for backward run */
printf("Create and allocate CVODES memory for backward run\n");
flag = CVodeCreateB(cvode_mem, CV_BDF, CV_NEWTON, &indexB);
if (check_flag(&flag, "CVodeCreateB", 1)) return(1);
flag = CVodeInitB(cvode_mem, indexB, fB, TB1, yB);
if (check_flag(&flag, "CVodeInitB", 1)) return(1);
flag = CVodeSStolerancesB(cvode_mem, indexB, reltolB, abstolB);
if (check_flag(&flag, "CVodeSStolerancesB", 1)) return(1);
flag = CVodeSetUserDataB(cvode_mem, indexB, data);
if (check_flag(&flag, "CVodeSetUserDataB", 1)) return(1);
flag = CVDenseB(cvode_mem, indexB, NEQ);
if (check_flag(&flag, "CVDenseB", 1)) return(1);
flag = CVDlsSetDenseJacFnB(cvode_mem, indexB, JacB);
if (check_flag(&flag, "CVDlsSetDenseJacFnB", 1)) return(1);
flag = CVodeQuadInitB(cvode_mem, indexB, fQB, qB);
if (check_flag(&flag, "CVodeQuadInitB", 1)) return(1);
flag = CVodeQuadSStolerancesB(cvode_mem, indexB, reltolB, abstolQB);
if (check_flag(&flag, "CVodeQuadSStolerancesB", 1)) return(1);
flag = CVodeSetQuadErrConB(cvode_mem, indexB, TRUE);
if (check_flag(&flag, "CVodeSetQuadErrConB", 1)) return(1);
/* Backward Integration */
printf("Backward integration ... ");
flag = CVodeB(cvode_mem, T0, CV_NORMAL);
if (check_flag(&flag, "CVodeB", 1)) return(1);
CVodeGetNumSteps(CVodeGetAdjCVodeBmem(cvode_mem, indexB), &nstB);
printf("done ( nst = %ld )\n", nstB);
flag = CVodeGetB(cvode_mem, indexB, &time, yB);
if (check_flag(&flag, "CVodeGetB", 1)) return(1);
flag = CVodeGetQuadB(cvode_mem, indexB, &time, qB);
if (check_flag(&flag, "CVodeGetQuadB", 1)) return(1);
PrintOutput(TB1, yB, qB);
/* Reinitialize backward phase (new tB0) */
Ith(yB,1) = ZERO;
Ith(yB,2) = ZERO;
Ith(yB,3) = ZERO;
Ith(qB,1) = ZERO;
Ith(qB,2) = ZERO;
Ith(qB,3) = ZERO;
printf("Re-initialize CVODES memory for backward run\n");
flag = CVodeReInitB(cvode_mem, indexB, TB2, yB);
if (check_flag(&flag, "CVodeReInitB", 1)) return(1);
flag = CVodeQuadReInitB(cvode_mem, indexB, qB);
if (check_flag(&flag, "CVodeQuadReInitB", 1)) return(1);
printf("Backward integration ... ");
flag = CVodeB(cvode_mem, T0, CV_NORMAL);
if (check_flag(&flag, "CVodeB", 1)) return(1);
CVodeGetNumSteps(CVodeGetAdjCVodeBmem(cvode_mem, indexB), &nstB);
printf("done ( nst = %ld )\n", nstB);
flag = CVodeGetB(cvode_mem, indexB, &time, yB);
if (check_flag(&flag, "CVodeGetB", 1)) return(1);
flag = CVodeGetQuadB(cvode_mem, indexB, &time, qB);
if (check_flag(&flag, "CVodeGetQuadB", 1)) return(1);
PrintOutput(TB2, yB, qB);
/* Free memory */
printf("Free memory\n\n");
CVodeFree(&cvode_mem);
N_VDestroy_Serial(y);
N_VDestroy_Serial(q);
N_VDestroy_Serial(yB);
N_VDestroy_Serial(qB);
if (ckpnt != NULL) free(ckpnt);
free(data);
return(0);
}
