int main(int argc, char *argv[])
{
realtype dx, reltol, abstol, t, tout;
N_Vector u;
UserData data;
void *cvode_mem;
int iout, flag, my_pe, npes;
long int local_N, nperpe, nrem, my_base;
realtype *pbar;
int is, *plist;
N_Vector *uS;
booleantype sensi, err_con;
int sensi_meth;
MPI_Comm comm;
u = NULL;
data = NULL;
cvode_mem = NULL;
pbar = NULL;
plist = NULL;
uS = NULL;
/* Get processor number, total number of pe's, and my_pe. */
MPI_Init(&argc, &argv);
comm = MPI_COMM_WORLD;
MPI_Comm_size(comm, &npes);
MPI_Comm_rank(comm, &my_pe);
/* Process arguments */
ProcessArgs(argc, argv, my_pe, &sensi, &sensi_meth, &err_con);
/* Set local vector length. */
nperpe = NEQ/npes;
nrem = NEQ - npes*nperpe;
local_N = (my_pe < nrem) ? nperpe+1 : nperpe;
my_base = (my_pe < nrem) ? my_pe*local_N : my_pe*nperpe + nrem;
/* USER DATA STRUCTURE */
data = (UserData) malloc(sizeof *data); /* Allocate data memory */
data->p = NULL;
if(check_flag((void *)data, "malloc", 2, my_pe)) MPI_Abort(comm, 1);
data->comm = comm;
data->npes = npes;
data->my_pe = my_pe;
data->p = (realtype *) malloc(NP * sizeof(realtype));
if(check_flag((void *)data->p, "malloc", 2, my_pe)) MPI_Abort(comm, 1);
dx = data->dx = XMAX/((realtype)(MX+1));
data->p[0] = RCONST(1.0);
data->p[1] = RCONST(0.5);
/* INITIAL STATES */
u = N_VNew_Parallel(comm, local_N, NEQ); /* Allocate u vector */
if(check_flag((void *)u, "N_VNew_Parallel", 0, my_pe)) MPI_Abort(comm, 1);
SetIC(u, dx, local_N, my_base); /* Initialize u vector */
/* TOLERANCES */
reltol = ZERO; /* Set the tolerances */
abstol = ATOL;
/* CVODE_CREATE & CVODE_MALLOC */
cvode_mem = CVodeCreate(CV_ADAMS, CV_FUNCTIONAL);
if(check_flag((void *)cvode_mem, "CVodeCreate", 0, my_pe)) MPI_Abort(comm, 1);
flag = CVodeSetUserData(cvode_mem, data);
if(check_flag(&flag, "CVodeSetUserData", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVodeInit(cvode_mem, f, T0, u);
if(check_flag(&flag, "CVodeInit", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
if(check_flag(&flag, "CVodeSStolerances", 1, my_pe)) MPI_Abort(comm, 1);
if (my_pe == 0) {
printf("\n1-D advection-diffusion equation, mesh size =%3d \n", MX);
printf("\nNumber of PEs = %3d \n",npes);
}
if(sensi) {
plist = (int *) malloc(NS * sizeof(int));
if(check_flag((void *)plist, "malloc", 2, my_pe)) MPI_Abort(comm, 1);
for(is=0; is<NS; is++)
plist[is] = is; /* sensitivity w.r.t. i-th parameter */
pbar = (realtype *) malloc(NS * sizeof(realtype));
if(check_flag((void *)pbar, "malloc", 2, my_pe)) MPI_Abort(comm, 1);
for(is=0; is<NS; is++) pbar[is] = data->p[plist[is]];
uS = N_VCloneVectorArray_Parallel(NS, u);
if(check_flag((void *)uS, "N_VCloneVectorArray_Parallel", 0, my_pe))
MPI_Abort(comm, 1);
for(is=0;is<NS;is++)
N_VConst(ZERO,uS[is]);
flag = CVodeSensInit1(cvode_mem, NS, sensi_meth, NULL, uS);
if(check_flag(&flag, "CVodeSensInit1", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVodeSensEEtolerances(cvode_mem);
if(check_flag(&flag, "CVodeSensEEtolerances", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVodeSetSensErrCon(cvode_mem, err_con);
if(check_flag(&flag, "CVodeSetSensErrCon", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVodeSetSensDQMethod(cvode_mem, CV_CENTERED, ZERO);
if(check_flag(&flag, "CVodeSetSensDQMethod", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVodeSetSensParams(cvode_mem, data->p, pbar, plist);
if(check_flag(&flag, "CVodeSetSensParams", 1, my_pe)) MPI_Abort(comm, 1);
if(my_pe == 0) {
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 {
if(my_pe == 0) printf("Sensitivity: NO ");
}
/* In loop over output points, call CVode, print results, test for error */
if(my_pe == 0) {
printf("\n\n");
printf("============================================================\n");
printf(" T Q H NST Max norm \n");
printf("============================================================\n");
}
for (iout=1, tout=T1; iout <= NOUT; iout++, tout += DTOUT) {
flag = CVode(cvode_mem, tout, u, &t, CV_NORMAL);
if(check_flag(&flag, "CVode", 1, my_pe)) break;
PrintOutput(cvode_mem, my_pe, t, u);
if (sensi) {
flag = CVodeGetSens(cvode_mem, &t, uS);
if(check_flag(&flag, "CVodeGetSens", 1, my_pe)) break;
PrintOutputS(my_pe, uS);
}
if (my_pe == 0)
printf("------------------------------------------------------------\n");
}
/* Print final statistics */
if (my_pe == 0)
PrintFinalStats(cvode_mem, sensi);
/* Free memory */
N_VDestroy(u); /* Free the u vector */
if (sensi)
N_VDestroyVectorArray(uS, NS); /* Free the uS vectors */
free(data->p); /* Free the p vector */
free(data); /* Free block of UserData */
CVodeFree(&cvode_mem); /* Free the CVODES problem memory */
free(pbar);
if(sensi) free(plist);
MPI_Finalize();
return(0);
}
int main(int argc, char *argv[])
{
void *cvode_mem;
UserData data;
realtype dx, reltol, abstol, t, tout;
N_Vector u;
int iout, flag;
realtype *pbar;
int is, *plist;
N_Vector *uS;
booleantype sensi, err_con;
int sensi_meth;
cvode_mem = NULL;
data = NULL;
u = NULL;
pbar = NULL;
plist = NULL;
uS = NULL;
/* Process arguments */
ProcessArgs(argc, argv, &sensi, &sensi_meth, &err_con);
/* Set user data */
data = (UserData) malloc(sizeof *data); /* Allocate data memory */
if(check_flag((void *)data, "malloc", 2)) return(1);
data->p = (realtype *) malloc(NP * sizeof(realtype));
dx = data->dx = XMAX/((realtype)(MX+1));
data->p[0] = RCONST(1.0);
data->p[1] = RCONST(0.5);
/* Allocate and set initial states */
u = N_VNew_Serial(NEQ);
if(check_flag((void *)u, "N_VNew_Serial", 0)) return(1);
SetIC(u, dx);
/* Set integration tolerances */
reltol = ZERO;
abstol = ATOL;
/* Create CVODES object */
cvode_mem = CVodeCreate(CV_ADAMS, CV_FUNCTIONAL);
if(check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
flag = CVodeSetUserData(cvode_mem, data);
if(check_flag(&flag, "CVodeSetUserData", 1)) return(1);
/* Allocate CVODES memory */
flag = CVodeInit(cvode_mem, f, T0, u);
if(check_flag(&flag, "CVodeInit", 1)) return(1);
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
if(check_flag(&flag, "CVodeSStolerances", 1)) return(1);
printf("\n1-D advection-diffusion equation, mesh size =%3d\n", MX);
/* Sensitivity-related settings */
if(sensi) {
plist = (int *) malloc(NS * sizeof(int));
if(check_flag((void *)plist, "malloc", 2)) return(1);
for(is=0; is<NS; is++) plist[is] = is;
pbar = (realtype *) malloc(NS * sizeof(realtype));
if(check_flag((void *)pbar, "malloc", 2)) return(1);
for(is=0; is<NS; is++) pbar[is] = data->p[plist[is]];
uS = N_VCloneVectorArray_Serial(NS, u);
if(check_flag((void *)uS, "N_VCloneVectorArray_Serial", 0)) return(1);
for(is=0;is<NS;is++)
N_VConst(ZERO, uS[is]);
flag = CVodeSensInit1(cvode_mem, NS, sensi_meth, NULL, uS);
if(check_flag(&flag, "CVodeSensInit1", 1)) return(1);
flag = CVodeSensEEtolerances(cvode_mem);
if(check_flag(&flag, "CVodeSensEEtolerances", 1)) return(1);
flag = CVodeSetSensErrCon(cvode_mem, err_con);
if(check_flag(&flag, "CVodeSetSensErrCon", 1)) return(1);
flag = CVodeSetSensDQMethod(cvode_mem, CV_CENTERED, ZERO);
if(check_flag(&flag, "CVodeSetSensDQMethod", 1)) return(1);
flag = CVodeSetSensParams(cvode_mem, data->p, pbar, plist);
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("============================================================\n");
printf(" T Q H NST Max norm \n");
printf("============================================================\n");
for (iout=1, tout=T1; iout <= NOUT; iout++, tout += DTOUT) {
flag = CVode(cvode_mem, tout, u, &t, CV_NORMAL);
if(check_flag(&flag, "CVode", 1)) break;
PrintOutput(cvode_mem, t, u);
if (sensi) {
flag = CVodeGetSens(cvode_mem, &t, uS);
if(check_flag(&flag, "CVodeGetSens", 1)) break;
PrintOutputS(uS);
}
printf("------------------------------------------------------------\n");
}
/* Print final statistics */
PrintFinalStats(cvode_mem, sensi);
/* Free memory */
N_VDestroy_Serial(u);
if (sensi) {
N_VDestroyVectorArray_Serial(uS, NS);
free(plist);
free(pbar);
}
free(data);
CVodeFree(&cvode_mem);
return(0);
}
int main(void)
{
realtype dx, dy, reltol, abstol, t, tout, umax;
N_Vector u;
UserData data;
void *cvode_mem;
int iout, flag;
long int nst;
u = NULL;
data = NULL;
cvode_mem = NULL;
/* Create a serial vector */
u = N_VNew_Serial(NEQ); /* Allocate u vector */
if(check_flag((void*)u, "N_VNew_Serial", 0)) return(1);
reltol = ZERO; /* Set the tolerances */
abstol = ATOL;
data = (UserData) malloc(sizeof *data); /* Allocate data memory */
if(check_flag((void *)data, "malloc", 2)) return(1);
dx = data->dx = XMAX/(MX+1); /* Set grid coefficients in data */
dy = data->dy = YMAX/(MY+1);
data->hdcoef = ONE/(dx*dx);
data->hacoef = HALF/(TWO*dx);
data->vdcoef = ONE/(dy*dy);
SetIC(u, data); /* Initialize u vector */
/* 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 u'=f(t,u), the inital time T0, and
* the initial dependent variable vector u. */
flag = CVodeInit(cvode_mem, f, T0, u);
if(check_flag(&flag, "CVodeInit", 1)) return(1);
/* Call CVodeSStolerances to specify the scalar relative tolerance
* and scalar absolute tolerance */
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSStolerances", 1)) return(1);
/* Set the pointer to user-defined data */
flag = CVodeSetUserData(cvode_mem, data);
if(check_flag(&flag, "CVodeSetUserData", 1)) return(1);
/* Call CVBand to specify the CVBAND band linear solver */
flag = CVBand(cvode_mem, NEQ, MY, MY);
if(check_flag(&flag, "CVBand", 1)) return(1);
/* Set the user-supplied Jacobian routine Jac */
flag = CVDlsSetBandJacFn(cvode_mem, Jac);
if(check_flag(&flag, "CVDlsSetBandJacFn", 1)) return(1);
/* In loop over output points: call CVode, print results, test for errors */
umax = N_VMaxNorm(u);
PrintHeader(reltol, abstol, umax);
for(iout=1, tout=T1; iout <= NOUT; iout++, tout += DTOUT) {
flag = CVode(cvode_mem, tout, u, &t, CV_NORMAL);
if(check_flag(&flag, "CVode", 1)) break;
umax = N_VMaxNorm(u);
flag = CVodeGetNumSteps(cvode_mem, &nst);
check_flag(&flag, "CVodeGetNumSteps", 1);
PrintOutput(t, umax, nst);
}
PrintFinalStats(cvode_mem); /* Print some final statistics */
N_VDestroy_Serial(u); /* Free the u vector */
CVodeFree(&cvode_mem); /* Free the integrator memory */
free(data); /* Free the user data */
return(0);
}
int main(int argc, char *argv[])
{
void *cvode_mem;
UserData data;
realtype abstol, reltol, t, tout;
N_Vector y;
int iout, flag;
realtype *pbar;
int is, *plist;
N_Vector *uS;
booleantype sensi, err_con;
int sensi_meth;
pbar = NULL;
plist = NULL;
uS = NULL;
y = NULL;
data = NULL;
cvode_mem = NULL;
/* Process arguments */
ProcessArgs(argc, argv, &sensi, &sensi_meth, &err_con);
/* Problem parameters */
data = AllocUserData();
if(check_flag((void *)data, "AllocUserData", 2)) return(1);
InitUserData(data);
/* Initial states */
y = N_VNew_Serial(NEQ);
if(check_flag((void *)y, "N_VNew_Serial", 0)) return(1);
SetInitialProfiles(y, data->dx, data->dz);
/* Tolerances */
abstol=ATOL;
reltol=RTOL;
/* Create CVODES object */
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if(check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
flag = CVodeSetUserData(cvode_mem, data);
if(check_flag(&flag, "CVodeSetUserData", 1)) return(1);
flag = CVodeSetMaxNumSteps(cvode_mem, 2000);
if(check_flag(&flag, "CVodeSetMaxNumSteps", 1)) return(1);
/* Allocate CVODES memory */
flag = CVodeInit(cvode_mem, f, T0, y);
if(check_flag(&flag, "CVodeInit", 1)) return(1);
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
if(check_flag(&flag, "CVodeSStolerances", 1)) return(1);
/* Attach CVSPGMR linear solver */
flag = CVSpgmr(cvode_mem, PREC_LEFT, 0);
if(check_flag(&flag, "CVSpgmr", 1)) return(1);
flag = CVSpilsSetPreconditioner(cvode_mem, Precond, PSolve);
if(check_flag(&flag, "CVSpilsSetPreconditioner", 1)) return(1);
printf("\n2-species diurnal advection-diffusion problem\n");
/* Forward sensitivity analysis */
if(sensi) {
plist = (int *) malloc(NS * sizeof(int));
if(check_flag((void *)plist, "malloc", 2)) return(1);
for(is=0; is<NS; is++) plist[is] = is;
pbar = (realtype *) malloc(NS * sizeof(realtype));
if(check_flag((void *)pbar, "malloc", 2)) return(1);
for(is=0; is<NS; is++) pbar[is] = data->p[plist[is]];
uS = N_VCloneVectorArray_Serial(NS, y);
if(check_flag((void *)uS, "N_VCloneVectorArray_Serial", 0)) return(1);
for(is=0;is<NS;is++)
N_VConst(ZERO,uS[is]);
flag = CVodeSensInit1(cvode_mem, NS, sensi_meth, NULL, uS);
if(check_flag(&flag, "CVodeSensInit", 1)) return(1);
flag = CVodeSensEEtolerances(cvode_mem);
if(check_flag(&flag, "CVodeSensEEtolerances", 1)) return(1);
flag = CVodeSetSensErrCon(cvode_mem, err_con);
if(check_flag(&flag, "CVodeSetSensErrCon", 1)) return(1);
flag = CVodeSetSensDQMethod(cvode_mem, CV_CENTERED, ZERO);
if(check_flag(&flag, "CVodeSetSensDQMethod", 1)) return(1);
flag = CVodeSetSensParams(cvode_mem, data->p, pbar, plist);
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("========================================================================\n");
printf(" T Q H NST Bottom left Top right \n");
printf("========================================================================\n");
for (iout=1, tout = TWOHR; iout <= NOUT; iout++, tout += TWOHR) {
flag = CVode(cvode_mem, tout, y, &t, CV_NORMAL);
if(check_flag(&flag, "CVode", 1)) break;
PrintOutput(cvode_mem, t, y);
if (sensi) {
flag = CVodeGetSens(cvode_mem, &t, uS);
if(check_flag(&flag, "CVodeGetSens", 1)) break;
PrintOutputS(uS);
}
printf("------------------------------------------------------------------------\n");
}
/* Print final statistics */
PrintFinalStats(cvode_mem, sensi);
/* Free memory */
N_VDestroy_Serial(y);
if (sensi) {
N_VDestroyVectorArray_Serial(uS, NS);
free(pbar);
free(plist);
}
FreeUserData(data);
CVodeFree(&cvode_mem);
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:
CV_BDF specifies the Backward Differentiation Formula
CV_NEWTON specifies a Newton iteration
A pointer to the integrator problem memory is returned and stored in cvode_mem.
*/
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
/*
Call CVodeMalloc to initialize the integrator memory:
cvode_mem is the pointer to the integrator memory returned by CVodeCreate
f is the user's right hand side function in y'=f(t,y)
T0 is the initial time
y is the initial dependent variable vector
CV_WF specifies scalar relative and vector absolute tolerances
reltol not needed (pass 0.0)
abstol not needed (pass NULL)
*/
flag = CVodeMalloc(cvode_mem, f, T0, y, CV_WF, 0.0, NULL);
if (check_flag(&flag, "CVodeMalloc", 1)) return(1);
/* Use private function to compute error weights */
flag = CVodeSetEwtFn(cvode_mem, ewt, NULL);
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, NULL);
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 = CVDenseSetJacFn(cvode_mem, Jac, NULL);
if (check_flag(&flag, "CVDenseSetJacFn", 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()
{
realtype abstol, reltol, t, tout;
N_Vector u;
UserData data;
void *bpdata;
void *cvode_mem;
int flag, ml, mu, iout, jpre;
u = NULL;
data = NULL;
bpdata = cvode_mem = NULL;
/* Allocate and initialize u, and set problem data and tolerances */
u = N_VNew_Serial(NEQ);
if(check_flag((void *)u, "N_VNew_Serial", 0)) return(1);
data = (UserData) malloc(sizeof *data);
if(check_flag((void *)data, "malloc", 2)) return(1);
InitUserData(data);
SetInitialProfiles(u, data->dx, data->dy);
abstol = ATOL;
reltol = RTOL;
/* Call CvodeCreate to create the solver memory
CV_BDF specifies the Backward Differentiation Formula
CV_NEWTON specifies a Newton iteration
A pointer to the integrator memory is returned and stored in cvode_mem. */
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if(check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
/* Set the pointer to user-defined data */
flag = CVodeSetFdata(cvode_mem, data);
if(check_flag(&flag, "CVodeSetFdata", 1)) return(1);
/* Call CVodeMalloc to initialize the integrator memory:
f is the user's right hand side function in u'=f(t,u)
T0 is the initial time
u is the initial dependent variable vector
CV_SS specifies scalar relative and absolute tolerances
reltol is the relative tolerance
&abstol is a pointer to the scalar absolutetolerance */
flag = CVodeMalloc(cvode_mem, f, T0, u, CV_SS, reltol, &abstol);
if(check_flag(&flag, "CVodeMalloc", 1)) return(1);
/* Call CVBandPreAlloc to initialize band preconditioner */
ml = mu = 2;
bpdata = CVBandPrecAlloc (cvode_mem, NEQ, mu, ml);
if(check_flag((void *)bpdata, "CVBandPrecAlloc", 0)) return(1);
/* Call CVBPSpgmr to specify the linear solver CVSPGMR
with left preconditioning and the maximum Krylov dimension maxl */
flag = CVBPSpgmr(cvode_mem, PREC_LEFT, 0, bpdata);
if(check_flag(&flag, "CVBPSpgmr", 1)) return(1);
PrintIntro(mu, ml);
/* Loop over jpre (= PREC_LEFT, PREC_RIGHT), and solve the problem */
for (jpre = PREC_LEFT; jpre <= PREC_RIGHT; jpre++) {
/* On second run, re-initialize u, the solver, and CVSPGMR */
if (jpre == PREC_RIGHT) {
SetInitialProfiles(u, data->dx, data->dy);
flag = CVodeReInit(cvode_mem, f, T0, u, CV_SS, reltol, &abstol);
if(check_flag(&flag, "CVodeReInit", 1)) return(1);
flag = CVSpilsSetPrecType(cvode_mem, PREC_RIGHT);
check_flag(&flag, "CVSpilsSetPrecType", 1);
printf("\n\n-------------------------------------------------------");
printf("------------\n");
}
printf("\n\nPreconditioner type is: jpre = %s\n\n",
(jpre == PREC_LEFT) ? "PREC_LEFT" : "PREC_RIGHT");
/* In loop over output points, call CVode, print results, test for error */
for (iout = 1, tout = TWOHR; iout <= NOUT; iout++, tout += TWOHR) {
flag = CVode(cvode_mem, tout, u, &t, CV_NORMAL);
check_flag(&flag, "CVode", 1);
PrintOutput(cvode_mem, u, t);
if (flag != CV_SUCCESS) {
break;
}
}
/* Print final statistics */
PrintFinalStats(cvode_mem, bpdata);
} /* End of jpre loop */
/* Free memory */
N_VDestroy_Serial(u);
free(data);
CVBandPrecFree(&bpdata);
CVodeFree(&cvode_mem);
return(0);
}
int main()
{
realtype abstol=ATOL, reltol=RTOL, t, tout;
N_Vector c;
WebData wdata;
void *cvode_mem;
booleantype firstrun;
int jpre, gstype, flag;
int ns, mxns, iout;
c = NULL;
wdata = NULL;
cvode_mem = NULL;
/* Initializations */
c = N_VNew_Serial(NEQ);
if(check_flag((void *)c, "N_VNew_Serial", 0)) return(1);
wdata = AllocUserData();
if(check_flag((void *)wdata, "AllocUserData", 2)) return(1);
InitUserData(wdata);
ns = wdata->ns;
mxns = wdata->mxns;
/* Print problem description */
PrintIntro();
/* Loop over jpre and gstype (four cases) */
for (jpre = PREC_LEFT; jpre <= PREC_RIGHT; jpre++) {
for (gstype = MODIFIED_GS; gstype <= CLASSICAL_GS; gstype++) {
/* Initialize c and print heading */
CInit(c, wdata);
PrintHeader(jpre, gstype);
/* Call CVodeMalloc or CVodeReInit, then CVSpgmr to set up problem */
firstrun = (jpre == PREC_LEFT) && (gstype == MODIFIED_GS);
if (firstrun) {
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if(check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
wdata->cvode_mem = cvode_mem;
flag = CVodeSetFdata(cvode_mem, wdata);
if(check_flag(&flag, "CVodeSetFdata", 1)) return(1);
flag = CVodeMalloc(cvode_mem, f, T0, c, CV_SS, reltol, &abstol);
if(check_flag(&flag, "CVodeMalloc", 1)) return(1);
flag = CVSpgmr(cvode_mem, jpre, MAXL);
if(check_flag(&flag, "CVSpgmr", 1)) return(1);
flag = CVSpilsSetGSType(cvode_mem, gstype);
if(check_flag(&flag, "CVSpilsSetGSType", 1)) return(1);
flag = CVSpilsSetDelt(cvode_mem, DELT);
if(check_flag(&flag, "CVSpilsSetDelt", 1)) return(1);
flag = CVSpilsSetPreconditioner(cvode_mem, Precond, PSolve, wdata);
if(check_flag(&flag, "CVSpilsSetPreconditioner", 1)) return(1);
} else {
flag = CVodeReInit(cvode_mem, f, T0, c, CV_SS, reltol, &abstol);
if(check_flag(&flag, "CVodeReInit", 1)) return(1);
flag = CVSpilsSetPrecType(cvode_mem, jpre);
check_flag(&flag, "CVSpilsSetPrecType", 1);
flag = CVSpilsSetGSType(cvode_mem, gstype);
if(check_flag(&flag, "CVSpilsSetGSType", 1)) return(1);
}
/* Print initial values */
if (firstrun) PrintAllSpecies(c, ns, mxns, T0);
/* Loop over output points, call CVode, print sample solution values. */
tout = T1;
for (iout = 1; iout <= NOUT; iout++) {
flag = CVode(cvode_mem, tout, c, &t, CV_NORMAL);
PrintOutput(cvode_mem, t);
if (firstrun && (iout % 3 == 0)) PrintAllSpecies(c, ns, mxns, t);
if(check_flag(&flag, "CVode", 1)) break;
if (tout > RCONST(0.9)) tout += DTOUT; else tout *= TOUT_MULT;
}
/* Print final statistics, and loop for next case */
PrintFinalStats(cvode_mem);
}
}
/* Free all memory */
CVodeFree(&cvode_mem);
N_VDestroy_Serial(c);
FreeUserData(wdata);
return(0);
}
real docollapse(real tl, real nl, real tr, real nr, real thresh)
/* Find the time of collapse, update the wave function and restart the integrator */
{
integer j, flag, k;
real tc, nc, temp, sum, t;
for (k=1;k<=5;k++) {
tc = tl + log(nl / thresh) / log(nl / nr) * (tr - tl);
flag = CVode1(cvode_mem, tc, y, &t, NORMAL);
if (flag != SUCCESS) {
sprintf(errmsg, "CVode failed, flag=%d.\n", flag);
fatal_error(errmsg);
}
nc = norm2(N_VDATA(y) - 1, N);
if (fabs(thresh - nc) < THRESHTOL * fabs(thresh))
break;
else if (nc < thresh) {
nr = nc;
tr = tc;
} else {
nl = nc;
tl = tc;
}
}
/* if (k>5) printf("\nWarning: Norm^2 of wavefunction does not attain threshold %f / %f\n"
"Increase accuracy of integrator.\n",nc,thresh);*/
/* Collapse occurs at tc, apply appropriate operator and restart
* integrator */
sum = 0.0;
for (j = 1; j <= ncollapses; j++) {
FSmul(&collapses[j], tc, N_VDATA(y) - 1, N_VDATA(q) - 1);
sum += (Cprobs[j] = norm2(N_VDATA(q) - 1, N));
}
thresh = genunf(0.0, 1.0); /* To determine which collapse occured */
for (j = 1; j <= ncollapses; j++) {
thresh -= Cprobs[j] / sum;
if (thresh <= 0)
break;
}
if (clrecflag) { /* Write out classical record */
fwrite(&tc, sizeof(real), 1, cp);
temp = j;
fwrite(&temp, sizeof(real), 1, cp);
}
/* Apply the collapse and normalize */
FSmul(&collapses[j], tc, N_VDATA(y) - 1, N_VDATA(q) - 1);
sum = sqrt(norm2(N_VDATA(q) - 1, N));
for (j = 1; j <= 2 * N; j++)
Ith(y, j) = Ith(q, j) / sum;
/* Replace the integrator, since we have a new initial condition */
CVodeFree(cvode_mem);
cvode_mem = CVodeMalloc(2 * N, derivs, tc, y,
(method == 0) ? ADAMS : BDF,
(itertype == 0) ? FUNCTIONAL : NEWTON,
(nabstol == 1) ? SS : SV,
&reltol, abstolp, NULL, NULL, TRUE, iopt, ropt, NULL);
if (cvode_mem == NULL) {
fatal_error("CVodeMalloc failed.\n");
}
/* Call CVDiag */
CVDiag(cvode_mem);
return tc;
}
void mcwfalg(integer itraj, integer ntraj)
{
integer i, N, exflag, flag;
real eps = 1.0e-6, t, temp;
real nl, nr, na, tl, tr, taim, thresh;
double sum = 0.0;
N = RHS.N;
for (i = 1; i <= 2 * N; i++)
Ith(y, i) = Ith(ystart, i);
/* Initialize ODE solver */
cvode_mem = CVodeMalloc(2 * N, derivs, Ith(tlist, 1), y,
(method == 0) ? ADAMS : BDF,
(itertype == 0) ? FUNCTIONAL : NEWTON,
(nabstol == 1) ? SS : SV,
&reltol, abstolp, NULL, NULL, TRUE, iopt, ropt, NULL);
if (cvode_mem == NULL) {
fatal_error("CVodeMalloc failed.\n");
}
/* Call CVDiag */
CVDiag(cvode_mem);
q = N_VNew(2 * N, NULL);
thresh = genunf(0.0, 1.0); /* Generate target value of norm^2 */
if (nopers == 0)
fwrite(&itraj, sizeof(integer), 1, op);
if (clrecflag) {
temp = itraj;
fwrite(&temp, sizeof(real), 1, cp);
temp = 0.0;
fwrite(&temp, sizeof(real), 1, cp);
}
tr = Ith(tlist, 1);
nr = norm2(N_VDATA(y) - 1, N);
if (nopers == 0)
fwrite(N_VDATA(y), sizeof(real), 2 * N, op);
else
operAccum(N_VDATA(y) - 1, N_VDATA(q) - 1, N, tr, 1);
for (i = 2; i <= ntimes;) {
taim = Ith(tlist, i);
tl = tr;
nl = nr;
flag = CVode1(cvode_mem, taim, y, &tr, ONE_STEP);
if (flag != SUCCESS) {
sprintf(errmsg, "CVode failed, flag=%d.\n", flag);
fatal_error(errmsg);
}
nr = norm2(N_VDATA(y) - 1, N);
for (; i <= ntimes;) {
if (tr < taim) {
if (nr < thresh) {
tr = docollapse(tl, nl, tr, nr, thresh); /* A collapse has
* occured */
nr = 1.0;
thresh = genunf(0.0, 1.0); /* Generate target value of
* norm^2 */
}
break;
} else {
flag = CVode1(cvode_mem, taim, y, &t, NORMAL); /* Interpolate */
if (flag != SUCCESS) {
sprintf(errmsg, "CVode failed, flag=%d.\n", flag);
fatal_error(errmsg);
}
na = norm2(N_VDATA(y) - 1, N);
if (na < thresh) {
tr = docollapse(tl, nl, taim, na, thresh); /* A collapse has
* occured */
nr = 1.0;
thresh = genunf(0.0, 1.0); /* Generate target value of
* norm^2 */
break;
} else { /* Write out results */
tl = taim;
nl = na;
if (nopers == 0)
fwrite(N_VDATA(y), sizeof(real), 2 * N, op);
else
operAccum(N_VDATA(y) - 1, N_VDATA(q) - 1, N, taim, i);
i += 1;
progress += NHASH;
while (progress >= (ntimes - 1) * ntraj) {
fprintf(stderr, "#");
progress -= (ntimes - 1) * ntraj;
}
taim = Ith(tlist, i);
}
}
}
}
CVodeFree(cvode_mem);
}
int main(int argc, char *argv[])
{
realtype abstol=ATOL, reltol=RTOL, t;
N_Vector c;
WebData wdata;
void *cvode_mem;
int flag;
void *cvadj_mem;
int ncheck;
realtype reltolB=RTOL, abstolB=ATOL;
N_Vector cB;
c = NULL;
cB = NULL;
wdata = NULL;
cvode_mem = NULL;
cvadj_mem = NULL;
/* Allocate and initialize user data */
wdata = AllocUserData();
if(check_flag((void *)wdata, "AllocUserData", 2)) return(1);
InitUserData(wdata);
/* Set-up forward problem */
/* Initializations */
c = N_VNew_Serial(NEQ+1);
if(check_flag((void *)c, "N_VNew_Serial", 0)) return(1);
CInit(c, wdata);
/* Call CVodeCreate/CVodeMalloc for forward run */
printf("\nCreate and allocate CVODE memory for forward run\n");
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if(check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
wdata->cvode_memF = cvode_mem; /* Used in Precond */
flag = CVodeSetFdata(cvode_mem, wdata);
if(check_flag(&flag, "CVodeSetFdata", 1)) return(1);
flag = CVodeMalloc(cvode_mem, f, T0, c, CV_SS, reltol, &abstol);
if(check_flag(&flag, "CVodeMalloc", 1)) return(1);
/* Call CVSpgmr for forward run */
flag = CVSpgmr(cvode_mem, PREC_LEFT, 0);
if(check_flag(&flag, "CVSpgmr", 1)) return(1);
flag = CVSpgmrSetPreconditioner(cvode_mem, Precond, PSolve, wdata);
if(check_flag(&flag, "CVSpgmrSetPreconditioner", 1)) return(1);
/* Set-up adjoint calculations */
printf("\nAllocate global memory\n");
cvadj_mem = CVadjMalloc(cvode_mem, NSTEPS);
if(check_flag((void *)cvadj_mem, "CVadjMalloc", 0)) return(1);
wdata->cvadj_mem = cvadj_mem;
/* Perform forward run */
printf("\nForward integration ... ");
flag = CVodeF(cvadj_mem, TOUT, c, &t, CV_NORMAL, &ncheck);
if(check_flag(&flag, "CVodeF", 1)) return(1);
printf("done (ncheck = %d)\n",ncheck);
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf("\n G = int_t int_x int_y c%d(t,x,y) dx dy dt = %Lf \n\n",
ISPEC, NV_DATA_S(c)[NEQ]);
#else
printf("\n G = int_t int_x int_y c%d(t,x,y) dx dy dt = %f \n\n",
ISPEC, NV_DATA_S(c)[NEQ]);
#endif
/* Set-up backward problem */
/* Allocate cB */
cB = N_VNew_Serial(NEQ);
if(check_flag((void *)cB, "N_VNew_Serial", 0)) return(1);
/* Initialize cB = 0 */
N_VConst(ZERO, cB);
/* Create and allocate CVODES memory for backward run */
printf("\nCreate and allocate CVODES memory for backward run\n");
flag = CVodeCreateB(cvadj_mem, CV_BDF, CV_NEWTON);
if(check_flag(&flag, "CVodeCreateB", 1)) return(1);
flag = CVodeSetFdataB(cvadj_mem, wdata);
if(check_flag(&flag, "CVodeSetFdataB", 1)) return(1);
flag = CVodeMallocB(cvadj_mem, fB, TOUT, cB, CV_SS, reltolB, &abstolB);
if(check_flag(&flag, "CVodeMallocB", 1)) return(1);
/* Call CVSpgmr */
flag = CVSpgmrB(cvadj_mem, PREC_LEFT, 0);
if(check_flag(&flag, "CVSpgmrB", 1)) return(1);
flag = CVSpgmrSetPreconditionerB(cvadj_mem, PrecondB, PSolveB, wdata);
if(check_flag(&flag, "CVSpgmrSetPreconditionerB", 1)) return(1);
/* Perform backward integration */
printf("\nBackward integration\n");
flag = CVodeB(cvadj_mem, T0, cB, &t, CV_NORMAL);
if(check_flag(&flag, "CVodeB", 1)) return(1);
PrintOutput(cB, NS, MXNS, wdata);
/* Free all memory */
CVodeFree(cvode_mem);
CVadjFree(cvadj_mem);
N_VDestroy_Serial(c);
N_VDestroy_Serial(cB);
FreeUserData(wdata);
return(0);
}
void CVodesIntegrator::initialize(double t0, FuncEval& func)
{
m_neq = func.neq();
m_t0 = t0;
m_time = t0;
if (m_y) {
N_VDestroy_Serial(m_y); // free solution vector if already allocated
}
m_y = N_VNew_Serial(static_cast<sd_size_t>(m_neq)); // allocate solution vector
N_VConst(0.0, m_y);
// check abs tolerance array size
if (m_itol == CV_SV && m_nabs < m_neq) {
throw CanteraError("CVodesIntegrator::initialize",
"not enough absolute tolerance values specified.");
}
func.getState(NV_DATA_S(m_y));
if (m_cvode_mem) {
CVodeFree(&m_cvode_mem);
}
//! Specify the method and the iteration type. Cantera Defaults:
//! CV_BDF - Use BDF methods
//! CV_NEWTON - use Newton's method
m_cvode_mem = CVodeCreate(m_method, m_iter);
if (!m_cvode_mem) {
throw CanteraError("CVodesIntegrator::initialize",
"CVodeCreate failed.");
}
int flag = CVodeInit(m_cvode_mem, cvodes_rhs, m_t0, m_y);
if (flag != CV_SUCCESS) {
if (flag == CV_MEM_FAIL) {
throw CanteraError("CVodesIntegrator::initialize",
"Memory allocation failed.");
} else if (flag == CV_ILL_INPUT) {
throw CanteraError("CVodesIntegrator::initialize",
"Illegal value for CVodeInit input argument.");
} else {
throw CanteraError("CVodesIntegrator::initialize",
"CVodeInit failed.");
}
}
CVodeSetErrHandlerFn(m_cvode_mem, &cvodes_err, this);
if (m_itol == CV_SV) {
flag = CVodeSVtolerances(m_cvode_mem, m_reltol, m_abstol);
} else {
flag = CVodeSStolerances(m_cvode_mem, m_reltol, m_abstols);
}
if (flag != CV_SUCCESS) {
if (flag == CV_MEM_FAIL) {
throw CanteraError("CVodesIntegrator::initialize",
"Memory allocation failed.");
} else if (flag == CV_ILL_INPUT) {
throw CanteraError("CVodesIntegrator::initialize",
"Illegal value for CVodeInit input argument.");
} else {
throw CanteraError("CVodesIntegrator::initialize",
"CVodeInit failed.");
}
}
flag = CVodeSetUserData(m_cvode_mem, &func);
if (flag != CV_SUCCESS) {
throw CanteraError("CVodesIntegrator::initialize",
"CVodeSetUserData failed.");
}
if (func.nparams() > 0) {
sensInit(t0, func);
flag = CVodeSetSensParams(m_cvode_mem, func.m_sens_params.data(),
func.m_paramScales.data(), NULL);
if (flag != CV_SUCCESS) {
throw CanteraError("CVodesIntegrator::initialize",
"CVodeSetSensParams failed.");
}
}
applyOptions();
}
int main(void)
{
realtype abstol, reltol, t, tout;
N_Vector u;
UserData data;
void *cvode_mem;
int linsolver, iout, flag;
u = NULL;
data = NULL;
cvode_mem = NULL;
/* Allocate memory, and set problem data, initial values, tolerances */
u = N_VNew_Serial(NEQ);
if(check_flag((void *)u, "N_VNew_Serial", 0)) return(1);
data = AllocUserData();
if(check_flag((void *)data, "AllocUserData", 2)) return(1);
InitUserData(data);
SetInitialProfiles(u, data->dx, data->dy);
abstol=ATOL;
reltol=RTOL;
/* Call CvodeCreate to create the solver memory
CV_BDF specifies the Backward Differentiation Formula
CV_NEWTON specifies a Newton iteration
A pointer to the integrator memory is returned and stored in cvode_mem. */
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if(check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
/* Set the pointer to user-defined data */
flag = CVodeSetFdata(cvode_mem, data);
if(check_flag(&flag, "CVodeSetFdata", 1)) return(1);
/* Call CVodeMalloc to initialize the integrator memory:
f is the user's right hand side function in u'=f(t,u)
T0 is the initial time
u is the initial dependent variable vector
CV_SS specifies scalar relative and absolute tolerances
reltol is the relative tolerance
&abstol is a pointer to the scalar absolute tolerance */
flag = CVodeMalloc(cvode_mem, f, T0, u, CV_SS, reltol, &abstol);
if(check_flag(&flag, "CVodeMalloc", 1)) return(1);
/* START: Loop through SPGMR, SPBCG and SPTFQMR linear solver modules */
for (linsolver = 0; linsolver < 3; ++linsolver) {
if (linsolver != 0) {
/* Re-initialize user data */
InitUserData(data);
SetInitialProfiles(u, data->dx, data->dy);
/* Re-initialize CVode for the solution of the same problem, but
using a different linear solver module */
flag = CVodeReInit(cvode_mem, f, T0, u, CV_SS, reltol, &abstol);
if (check_flag(&flag, "CVodeReInit", 1)) return(1);
}
/* Attach a linear solver module */
switch(linsolver) {
/* (a) SPGMR */
case(USE_SPGMR):
/* Print header */
printf(" -------");
printf(" \n| SPGMR |\n");
printf(" -------\n");
/* Call CVSpgmr to specify the linear solver CVSPGMR
with left preconditioning and the maximum Krylov dimension maxl */
flag = CVSpgmr(cvode_mem, PREC_LEFT, 0);
if(check_flag(&flag, "CVSpgmr", 1)) return(1);
/* Set modified Gram-Schmidt orthogonalization, preconditioner
setup and solve routines Precond and PSolve, and the pointer
to the user-defined block data */
flag = CVSpilsSetGSType(cvode_mem, MODIFIED_GS);
if(check_flag(&flag, "CVSpilsSetGSType", 1)) return(1);
flag = CVSpilsSetPreconditioner(cvode_mem, Precond, PSolve, data);
if(check_flag(&flag, "CVSpilsSetPreconditioner", 1)) return(1);
break;
/* (b) SPBCG */
case(USE_SPBCG):
/* Print header */
printf(" -------");
printf(" \n| SPBCG |\n");
printf(" -------\n");
/* Call CVSpbcg to specify the linear solver CVSPBCG
with left preconditioning and the maximum Krylov dimension maxl */
flag = CVSpbcg(cvode_mem, PREC_LEFT, 0);
if(check_flag(&flag, "CVSpbcg", 1)) return(1);
/* Set preconditioner setup and solve routines Precond and PSolve,
and the pointer to the user-defined block data */
flag = CVSpilsSetPreconditioner(cvode_mem, Precond, PSolve, data);
if(check_flag(&flag, "CVSpilsSetPreconditioner", 1)) return(1);
break;
/* (c) SPTFQMR */
case(USE_SPTFQMR):
/* Print header */
printf(" ---------");
printf(" \n| SPTFQMR |\n");
printf(" ---------\n");
/* Call CVSptfqmr to specify the linear solver CVSPTFQMR
with left preconditioning and the maximum Krylov dimension maxl */
flag = CVSptfqmr(cvode_mem, PREC_LEFT, 0);
if(check_flag(&flag, "CVSptfqmr", 1)) return(1);
/* Set preconditioner setup and solve routines Precond and PSolve,
and the pointer to the user-defined block data */
flag = CVSpilsSetPreconditioner(cvode_mem, Precond, PSolve, data);
if(check_flag(&flag, "CVSpilsSetPreconditioner", 1)) return(1);
break;
}
/* In loop over output points, call CVode, print results, test for error */
printf(" \n2-species diurnal advection-diffusion problem\n\n");
for (iout=1, tout = TWOHR; iout <= NOUT; iout++, tout += TWOHR) {
flag = CVode(cvode_mem, tout, u, &t, CV_NORMAL);
PrintOutput(cvode_mem, u, t);
if(check_flag(&flag, "CVode", 1)) break;
}
PrintFinalStats(cvode_mem, linsolver);
} /* END: Loop through SPGMR, SPBCG and SPTFQMR linear solver modules */
/* Free memory */
N_VDestroy_Serial(u);
FreeUserData(data);
CVodeFree(&cvode_mem);
return(0);
}
int main(int argc, char *argv[])
{
realtype dx, reltol, abstol, t, tout, umax;
N_Vector u;
UserData data;
void *cvode_mem;
int iout, flag, my_pe, npes;
long int local_N, nperpe, nrem, my_base, nst;
MPI_Comm comm;
u = NULL;
data = NULL;
cvode_mem = NULL;
/* Get processor number, total number of pe's, and my_pe. */
MPI_Init(&argc, &argv);
comm = MPI_COMM_WORLD;
MPI_Comm_size(comm, &npes);
MPI_Comm_rank(comm, &my_pe);
/* Set local vector length. */
nperpe = NEQ/npes;
nrem = NEQ - npes*nperpe;
local_N = (my_pe < nrem) ? nperpe+1 : nperpe;
my_base = (my_pe < nrem) ? my_pe*local_N : my_pe*nperpe + nrem;
data = (UserData) malloc(sizeof *data); /* Allocate data memory */
if(check_flag((void *)data, "malloc", 2, my_pe)) MPI_Abort(comm, 1);
data->comm = comm;
data->npes = npes;
data->my_pe = my_pe;
u = N_VNew_Parallel(comm, local_N, NEQ); /* Allocate u vector */
if(check_flag((void *)u, "N_VNew", 0, my_pe)) MPI_Abort(comm, 1);
reltol = ZERO; /* Set the tolerances */
abstol = ATOL;
dx = data->dx = XMAX/((realtype)(MX+1)); /* Set grid coefficients in data */
data->hdcoef = RCONST(1.0)/(dx*dx);
data->hacoef = RCONST(0.5)/(RCONST(2.0)*dx);
SetIC(u, dx, local_N, my_base); /* Initialize u vector */
/* Call CVodeCreate to create the solver memory and specify the
* Adams-Moulton LMM and the use of a functional iteration */
cvode_mem = CVodeCreate(CV_ADAMS, CV_FUNCTIONAL);
if(check_flag((void *)cvode_mem, "CVodeCreate", 0, my_pe)) MPI_Abort(comm, 1);
flag = CVodeSetUserData(cvode_mem, data);
if(check_flag(&flag, "CVodeSetUserData", 1, my_pe)) MPI_Abort(comm, 1);
/* 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 u. */
flag = CVodeInit(cvode_mem, f, T0, u);
if(check_flag(&flag, "CVodeInit", 1, my_pe)) return(1);
/* Call CVodeSStolerances to specify the scalar relative tolerance
* and scalar absolute tolerances */
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSStolerances", 1, my_pe)) return(1);
if (my_pe == 0) PrintIntro(npes);
umax = N_VMaxNorm(u);
if (my_pe == 0) {
t = T0;
PrintData(t, umax, 0);
}
/* In loop over output points, call CVode, print results, test for error */
for (iout=1, tout=T1; iout <= NOUT; iout++, tout += DTOUT) {
flag = CVode(cvode_mem, tout, u, &t, CV_NORMAL);
if(check_flag(&flag, "CVode", 1, my_pe)) break;
umax = N_VMaxNorm(u);
flag = CVodeGetNumSteps(cvode_mem, &nst);
check_flag(&flag, "CVodeGetNumSteps", 1, my_pe);
if (my_pe == 0) PrintData(t, umax, nst);
}
if (my_pe == 0)
PrintFinalStats(cvode_mem); /* Print some final statistics */
N_VDestroy_Parallel(u); /* Free the u vector */
CVodeFree(&cvode_mem); /* Free the integrator memory */
free(data); /* Free user data */
MPI_Finalize();
return(0);
}
int main(int argc, char *argv[])
{
UserData data;
void *cvode_mem;
N_Vector u;
realtype reltol, abstol;
int indexB;
N_Vector uB;
realtype dx, t, g_val;
int flag, my_pe, nprocs, npes, ncheck;
long int local_N=0, nperpe, nrem, my_base=-1;
MPI_Comm comm;
data = NULL;
cvode_mem = NULL;
u = uB = NULL;
/*------------------------------------------------------
Initialize MPI and get total number of pe's, and my_pe
------------------------------------------------------*/
MPI_Init(&argc, &argv);
comm = MPI_COMM_WORLD;
MPI_Comm_size(comm, &nprocs);
MPI_Comm_rank(comm, &my_pe);
npes = nprocs - 1; /* pe's dedicated to PDE integration */
if ( npes <= 0 ) {
if (my_pe == npes)
fprintf(stderr, "\nMPI_ERROR(%d): number of processes must be >= 2\n\n",
my_pe);
MPI_Finalize();
return(1);
}
/*-----------------------
Set local vector length
-----------------------*/
nperpe = NEQ/npes;
nrem = NEQ - npes*nperpe;
if (my_pe < npes) {
/* PDE vars. distributed to this proccess */
local_N = (my_pe < nrem) ? nperpe+1 : nperpe;
my_base = (my_pe < nrem) ? my_pe*local_N : my_pe*nperpe + nrem;
} else {
/* Make last process inactive for forward phase */
local_N = 0;
}
/*-------------------------------------
Allocate and load user data structure
-------------------------------------*/
data = (UserData) malloc(sizeof *data);
if (check_flag((void *)data , "malloc", 2, my_pe)) MPI_Abort(comm, 1);
data->p[0] = ONE;
data->p[1] = RCONST(0.5);
dx = data->dx = XMAX/((realtype)(MX+1));
data->hdcoef = data->p[0]/(dx*dx);
data->hacoef = data->p[1]/(TWO*dx);
data->comm = comm;
data->npes = npes;
data->my_pe = my_pe;
data->nperpe = nperpe;
data->nrem = nrem;
data->local_N = local_N;
/*-------------------------
Forward integration phase
-------------------------*/
/* Set relative and absolute tolerances for forward phase */
reltol = ZERO;
abstol = ATOL;
/* Allocate and initialize forward variables */
u = N_VNew_Parallel(comm, local_N, NEQ);
if (check_flag((void *)u, "N_VNew_Parallel", 0, my_pe)) MPI_Abort(comm, 1);
SetIC(u, dx, local_N, my_base);
/* Allocate CVODES memory for forward integration */
cvode_mem = CVodeCreate(CV_ADAMS, CV_FUNCTIONAL);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0, my_pe)) MPI_Abort(comm, 1);
flag = CVodeSetUserData(cvode_mem, data);
if (check_flag(&flag, "CVodeSetUserData", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVodeInit(cvode_mem, f, T0, u);
if (check_flag(&flag, "CVodeInit", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSStolerances", 1, my_pe)) MPI_Abort(comm, 1);
/* Allocate combined forward/backward memory */
flag = CVodeAdjInit(cvode_mem, STEPS, CV_HERMITE);
if (check_flag(&flag, "CVadjInit", 1, my_pe)) MPI_Abort(comm, 1);
/* Integrate to TOUT and collect check point information */
flag = CVodeF(cvode_mem, TOUT, u, &t, CV_NORMAL, &ncheck);
if (check_flag(&flag, "CVodeF", 1, my_pe)) MPI_Abort(comm, 1);
/*---------------------------
Compute and value of g(t_f)
---------------------------*/
g_val = Compute_g(u, data);
/*--------------------------
Backward integration phase
--------------------------*/
if (my_pe == npes) {
/* Activate last process for integration of the quadrature equations */
local_N = NP;
} else {
/* Allocate work space */
data->z1 = (realtype *)malloc(local_N*sizeof(realtype));
if (check_flag((void *)data->z1, "malloc", 2, my_pe)) MPI_Abort(comm, 1);
data->z2 = (realtype *)malloc(local_N*sizeof(realtype));
if (check_flag((void *)data->z2, "malloc", 2, my_pe)) MPI_Abort(comm, 1);
}
/* Allocate and initialize backward variables */
uB = N_VNew_Parallel(comm, local_N, NEQ+NP);
if (check_flag((void *)uB, "N_VNew_Parallel", 0, my_pe)) MPI_Abort(comm, 1);
SetICback(uB, my_base);
/* Allocate CVODES memory for the backward integration */
flag = CVodeCreateB(cvode_mem, CV_ADAMS, CV_FUNCTIONAL, &indexB);
if (check_flag(&flag, "CVodeCreateB", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVodeSetUserDataB(cvode_mem, indexB, data);
if (check_flag(&flag, "CVodeSetUserDataB", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVodeInitB(cvode_mem, indexB, fB, TOUT, uB);
if (check_flag(&flag, "CVodeInitB", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVodeSStolerancesB(cvode_mem, indexB, reltol, abstol);
if (check_flag(&flag, "CVodeSStolerancesB", 1, my_pe)) MPI_Abort(comm, 1);
/* Integrate to T0 */
flag = CVodeB(cvode_mem, T0, CV_NORMAL);
if (check_flag(&flag, "CVodeB", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVodeGetB(cvode_mem, indexB, &t, uB);
if (check_flag(&flag, "CVodeGetB", 1, my_pe)) MPI_Abort(comm, 1);
/* Print results (adjoint states and quadrature variables) */
PrintOutput(g_val, uB, data);
/* Free memory */
N_VDestroy_Parallel(u);
N_VDestroy_Parallel(uB);
CVodeFree(&cvode_mem);
if (my_pe != npes) {
free(data->z1);
free(data->z2);
}
free(data);
MPI_Finalize();
return(0);
}
int main()
{
realtype abstol, reltol, t, tout;
N_Vector u;
UserData data;
void *cvode_mem;
int iout, flag;
u = NULL;
data = NULL;
cvode_mem = NULL;
/* Allocate memory, and set problem data, initial values, tolerances */
u = N_VNew_Serial(NEQ);
if(check_flag((void *)u, "N_VNew_Serial", 0)) return(1);
data = AllocUserData();
if(check_flag((void *)data, "AllocUserData", 2)) return(1);
InitUserData(data);
SetInitialProfiles(u, data->dx, data->dy);
abstol=ATOL;
reltol=RTOL;
/* 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);
/* Set the pointer to user-defined data */
flag = CVodeSetUserData(cvode_mem, data);
if(check_flag(&flag, "CVodeSetUserData", 1)) return(1);
/* 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 u. */
flag = CVodeInit(cvode_mem, f, T0, u);
if(check_flag(&flag, "CVodeInit", 1)) return(1);
/* Call CVodeSStolerances to specify the scalar relative tolerance
* and scalar absolute tolerances */
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSStolerances", 1)) return(1);
/* Call CVSpgmr to specify the linear solver CVSPGMR
* with left preconditioning and the maximum Krylov dimension maxl */
flag = CVSpgmr(cvode_mem, PREC_LEFT, 0);
if(check_flag(&flag, "CVSpgmr", 1)) return(1);
/* set the JAcobian-times-vector function */
flag = CVSpilsSetJacTimesVecFn(cvode_mem, jtv);
if(check_flag(&flag, "CVSpilsSetJacTimesVecFn", 1)) return(1);
/* Set modified Gram-Schmidt orthogonalization */
flag = CVSpilsSetGSType(cvode_mem, MODIFIED_GS);
if(check_flag(&flag, "CVSpilsSetGSType", 1)) return(1);
/* Set the preconditioner solve and setup functions */
flag = CVSpilsSetPreconditioner(cvode_mem, Precond, PSolve);
if(check_flag(&flag, "CVSpilsSetPreconditioner", 1)) return(1);
/* In loop over output points, call CVode, print results, test for error */
printf(" \n2-species diurnal advection-diffusion problem\n\n");
for (iout=1, tout = TWOHR; iout <= NOUT; iout++, tout += TWOHR) {
flag = CVode(cvode_mem, tout, u, &t, CV_NORMAL);
PrintOutput(cvode_mem, u, t);
if(check_flag(&flag, "CVode", 1)) break;
}
PrintFinalStats(cvode_mem);
/* Free memory */
N_VDestroy_Serial(u);
FreeUserData(data);
CVodeFree(&cvode_mem);
return(0);
}
void CVodesIntegrator::initialize(double t0, FuncEval& func)
{
m_neq = func.neq();
m_t0 = t0;
m_time = t0;
if (m_y) {
N_VDestroy_Serial(m_y); // free solution vector if already allocated
}
m_y = N_VNew_Serial(static_cast<sd_size_t>(m_neq)); // allocate solution vector
for (size_t i = 0; i < m_neq; i++) {
NV_Ith_S(m_y, i) = 0.0;
}
// check abs tolerance array size
if (m_itol == CV_SV && m_nabs < m_neq) {
throw CVodesErr("not enough absolute tolerance values specified.");
}
func.getInitialConditions(m_t0, m_neq, NV_DATA_S(m_y));
if (m_cvode_mem) {
CVodeFree(&m_cvode_mem);
}
/*
* Specify the method and the iteration type:
* Cantera Defaults:
* CV_BDF - Use BDF methods
* CV_NEWTON - use Newton's method
*/
m_cvode_mem = CVodeCreate(m_method, m_iter);
if (!m_cvode_mem) {
throw CVodesErr("CVodeCreate failed.");
}
int flag = CVodeInit(m_cvode_mem, cvodes_rhs, m_t0, m_y);
if (flag != CV_SUCCESS) {
if (flag == CV_MEM_FAIL) {
throw CVodesErr("Memory allocation failed.");
} else if (flag == CV_ILL_INPUT) {
throw CVodesErr("Illegal value for CVodeInit input argument.");
} else {
throw CVodesErr("CVodeInit failed.");
}
}
CVodeSetErrHandlerFn(m_cvode_mem, &cvodes_err, this);
if (m_itol == CV_SV) {
flag = CVodeSVtolerances(m_cvode_mem, m_reltol, m_abstol);
} else {
flag = CVodeSStolerances(m_cvode_mem, m_reltol, m_abstols);
}
if (flag != CV_SUCCESS) {
if (flag == CV_MEM_FAIL) {
throw CVodesErr("Memory allocation failed.");
} else if (flag == CV_ILL_INPUT) {
throw CVodesErr("Illegal value for CVodeInit input argument.");
} else {
throw CVodesErr("CVodeInit failed.");
}
}
// pass a pointer to func in m_data
m_fdata.reset(new FuncData(&func, func.nparams()));
flag = CVodeSetUserData(m_cvode_mem, m_fdata.get());
if (flag != CV_SUCCESS) {
throw CVodesErr("CVodeSetUserData failed.");
}
if (func.nparams() > 0) {
sensInit(t0, func);
flag = CVodeSetSensParams(m_cvode_mem, m_fdata->m_pars.data(),
NULL, NULL);
}
applyOptions();
}
int main(int narg, char **args)
{
realtype reltol, t, tout;
N_Vector state, abstol;
void *cvode_mem;
int flag, flagr;
FILE *pout;
if(!(pout = fopen("Locke2008_Circadian_Clock.dat", "w"))){
fprintf(stderr, "Cannot open file Locke2008_Circadian_Clock.dat. Are you trying to write to a non-existent directory? Exiting...\n");
exit(1);
}
state = abstol = NULL;
cvode_mem = NULL;
state = N_VNew_Serial(NEQ);
if (check_flag((void *)state, "N_VNew_Serial", 0)) return(1);
abstol = N_VNew_Serial(NEQ);
if (check_flag((void *)abstol, "N_VNew_Serial", 0)) return(1);
realtype Kc = 4.8283;
realtype v_4 = 1.0841;
realtype v_6 = 4.6645;
realtype vc = 6.7924;
realtype v_1 = 6.8355;
realtype v_2 = 8.4297;
realtype K = 1.0;
realtype v_8 = 3.5216;
realtype L = 0.0;
realtype n = 5.6645;
realtype k3 = 0.1177;
realtype K2 = 0.291;
realtype K1 = 2.7266;
realtype k7 = 0.2282;
realtype K6 = 9.9849;
realtype k5 = 0.3352;
realtype K4 = 8.1343;
realtype K8 = 7.4519;
realtype init_X1 = 4.25;
realtype tscale = 1.0;
realtype init_Z1 = 2.25;
realtype init_Z2 = 0.0;
realtype init_V1 = 2.5;
realtype init_V2 = 0.0;
realtype init_X2 = 0.0;
realtype compartment = 1.0;
realtype init_Y1 = 3.25;
realtype init_Y2 = 0.0;
realtype p[] = {Kc, v_4, v_6, vc, v_1, v_2, K, v_8, L, n, k3, K2, K1, k7, K6, k5, K4, K8, init_X1, tscale, init_Z1, init_Z2, init_V1, init_V2, init_X2, compartment, init_Y1, init_Y2, };
realtype X1 = init_X1;
realtype X2 = init_X2;
realtype V1 = init_V1;
realtype V2 = init_V2;
realtype Y1 = init_Y1;
realtype Y2 = init_Y2;
realtype Z1 = init_Z1;
realtype Z2 = init_Z2;
NV_Ith_S(state, 0) = init_Y2;
NV_Ith_S(state, 1) = init_V1;
NV_Ith_S(state, 2) = init_Y1;
NV_Ith_S(state, 3) = init_V2;
NV_Ith_S(state, 4) = init_X2;
NV_Ith_S(state, 5) = init_X1;
NV_Ith_S(state, 6) = init_Z1;
NV_Ith_S(state, 7) = init_Z2;
reltol = RTOL;
NV_Ith_S(abstol,0) = ATOL0;
NV_Ith_S(abstol,1) = ATOL1;
NV_Ith_S(abstol,2) = ATOL2;
NV_Ith_S(abstol,3) = ATOL3;
NV_Ith_S(abstol,4) = ATOL4;
NV_Ith_S(abstol,5) = ATOL5;
NV_Ith_S(abstol,6) = ATOL6;
NV_Ith_S(abstol,7) = ATOL7;
/* Allocations and initializations */
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
flag = CVodeInit(cvode_mem, dstate_dt, T0, state);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
flag = CVodeSetUserData(cvode_mem, p);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
flag = CVodeSVtolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSVtolerances", 1)) return(1);
flag = CVDense(cvode_mem, NEQ);
if (check_flag(&flag, "CVDense", 1)) return(1);
printf(" \n Integrating Locke2008_Circadian_Clock_0 \n\n");
printf("#t Y2, V1, Y1, V2, X2, X1, Z1, Z2, \n");
PrintOutput(pout, t, state);
tout = DT;
while(1) {
flag = CVode(cvode_mem, tout, state, &t, CV_NORMAL);
{
PrintOutput(pout, t, state);
if(check_flag(&flag, "CVode", 1)) break;
if(flag == CV_SUCCESS) {
tout += DT;
}
if (t >= T1) break;
}
}
PrintFinalStats(cvode_mem);
N_VDestroy_Serial(state);
N_VDestroy_Serial(abstol);
CVodeFree(&cvode_mem);
fclose(pout);
return(0);
}
int main(void)
{
realtype abstol, reltol, t, tout;
N_Vector u;
UserData data;
SUNLinearSolver LS;
void *cvode_mem;
int linsolver, iout, retval;
u = NULL;
data = NULL;
LS = NULL;
cvode_mem = NULL;
/* Allocate memory, and set problem data, initial values, tolerances */
u = N_VNew_Serial(NEQ);
if(check_retval((void *)u, "N_VNew_Serial", 0)) return(1);
data = AllocUserData();
if(check_retval((void *)data, "AllocUserData", 2)) return(1);
InitUserData(data);
SetInitialProfiles(u, data->dx, data->dy);
abstol=ATOL;
reltol=RTOL;
/* 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);
/* Set the pointer to user-defined data */
retval = CVodeSetUserData(cvode_mem, data);
if(check_retval(&retval, "CVodeSetUserData", 1)) return(1);
/* 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 u. */
retval = CVodeInit(cvode_mem, f, T0, u);
if(check_retval(&retval, "CVodeInit", 1)) return(1);
/* Call CVodeSStolerances to specify the scalar relative tolerance
* and scalar absolute tolerances */
retval = CVodeSStolerances(cvode_mem, reltol, abstol);
if (check_retval(&retval, "CVodeSStolerances", 1)) return(1);
/* START: Loop through SPGMR, SPBCG and SPTFQMR linear solver modules */
for (linsolver = 0; linsolver < 3; ++linsolver) {
if (linsolver != 0) {
/* Re-initialize user data */
InitUserData(data);
SetInitialProfiles(u, data->dx, data->dy);
/* Re-initialize CVode for the solution of the same problem, but
using a different linear solver module */
retval = CVodeReInit(cvode_mem, T0, u);
if (check_retval(&retval, "CVodeReInit", 1)) return(1);
}
/* Free previous linear solver and attach a new linear solver module */
SUNLinSolFree(LS);
switch(linsolver) {
/* (a) SPGMR */
case(USE_SPGMR):
/* Print header */
printf(" -------");
printf(" \n| SPGMR |\n");
printf(" -------\n");
/* Call SUNLinSol_SPGMR to specify the linear solver SPGMR with
left preconditioning and the default maximum Krylov dimension */
LS = SUNLinSol_SPGMR(u, PREC_LEFT, 0);
if(check_retval((void *)LS, "SUNLinSol_SPGMR", 0)) return(1);
retval = CVodeSetLinearSolver(cvode_mem, LS, NULL);
if(check_retval(&retval, "CVodeSetLinearSolver", 1)) return 1;
break;
/* (b) SPBCG */
case(USE_SPBCG):
/* Print header */
printf(" -------");
printf(" \n| SPBCGS |\n");
printf(" -------\n");
/* Call SUNLinSol_SPBCGS to specify the linear solver SPBCGS with
left preconditioning and the default maximum Krylov dimension */
LS = SUNLinSol_SPBCGS(u, PREC_LEFT, 0);
if(check_retval((void *)LS, "SUNLinSol_SPBCGS", 0)) return(1);
retval = CVodeSetLinearSolver(cvode_mem, LS, NULL);
if(check_retval(&retval, "CVodeSetLinearSolver", 1)) return 1;
break;
/* (c) SPTFQMR */
case(USE_SPTFQMR):
/* Print header */
printf(" ---------");
printf(" \n| SPTFQMR |\n");
printf(" ---------\n");
/* Call SUNLinSol_SPTFQMR to specify the linear solver SPTFQMR with
left preconditioning and the default maximum Krylov dimension */
LS = SUNLinSol_SPTFQMR(u, PREC_LEFT, 0);
if(check_retval((void *)LS, "SUNLinSol_SPTFQMR", 0)) return(1);
retval = CVodeSetLinearSolver(cvode_mem, LS, NULL);
if(check_retval(&retval, "CVodeSetLinearSolver", 1)) return 1;
break;
}
/* Set preconditioner setup and solve routines Precond and PSolve,
and the pointer to the user-defined block data */
retval = CVodeSetPreconditioner(cvode_mem, Precond, PSolve);
if(check_retval(&retval, "CVodeSetPreconditioner", 1)) return(1);
/* In loop over output points, call CVode, print results, test for error */
printf(" \n2-species diurnal advection-diffusion problem\n\n");
for (iout=1, tout = TWOHR; iout <= NOUT; iout++, tout += TWOHR) {
retval = CVode(cvode_mem, tout, u, &t, CV_NORMAL);
PrintOutput(cvode_mem, u, t);
if(check_retval(&retval, "CVode", 1)) break;
}
PrintFinalStats(cvode_mem, linsolver);
} /* END: Loop through SPGMR, SPBCG and SPTFQMR linear solver modules */
/* Free memory */
N_VDestroy(u);
FreeUserData(data);
CVodeFree(&cvode_mem);
SUNLinSolFree(LS);
return(0);
}
