void CVadjFree(void *cvadj_mem)
{
CVadjMem ca_mem;
ca_mem = (CVadjMem) cvadj_mem;
/* Delete check points one by one */
while (ca_mem->ck_mem != NULL) {
CVAckpntDelete(&(ca_mem->ck_mem));
}
/* Free vectors at each data point */
switch (interpType) {
case CV_HERMITE:
CVAhermiteFree(ca_mem->dt_mem, nsteps);
break;
}
free(ca_mem->dt_mem);
/* Free workspace vectors in ca_mem */
CVAfreeVectors(ca_mem);
/* Free CVODES memory for backward run */
CVodeFree(ca_mem->cvb_mem);
/* Free preconditioner data (the routines below check for non-NULL data) */
CVBandPrecFree(bp_data_B);
CVBBDPrecFree(bbd_data_B);
/* Free CVODEA memory */
free(ca_mem);
}
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);
}
void FCV_BPFREE(void)
{
CVBandPrecFree(&CVBP_Data);
}
