inline void cvodes_set_options(void* cvodes_mem,
double rel_tol, double abs_tol,
// NOLINTNEXTLINE(runtime/int)
long int max_num_steps) {
// forward CVode errors to noop error handler
CVodeSetErrHandlerFn(cvodes_mem, cvodes_silent_err_handler, 0);
// Initialize solver parameters
cvodes_check_flag(CVodeSStolerances(cvodes_mem, rel_tol, abs_tol),
"CVodeSStolerances");
cvodes_check_flag(CVodeSetMaxNumSteps(cvodes_mem, max_num_steps),
"CVodeSetMaxNumSteps");
double init_step = 0;
cvodes_check_flag(CVodeSetInitStep(cvodes_mem, init_step),
"CVodeSetInitStep");
long int max_err_test_fails = 20; // NOLINT(runtime/int)
cvodes_check_flag(CVodeSetMaxErrTestFails(cvodes_mem, max_err_test_fails),
"CVodeSetMaxErrTestFails");
long int max_conv_fails = 50; // NOLINT(runtime/int)
cvodes_check_flag(CVodeSetMaxConvFails(cvodes_mem, max_conv_fails),
"CVodeSetMaxConvFails");
}
void ode_solver_init(ode_solver* solver, const double t0, double* y0, int lenY, double* p, int lenP ){
int i,flag;
/* Get parameters */
if (p != 0){
if (lenP != solver->odeModel->P) {
fprintf(stderr,"ode_solver_init: lenP must be equal %d, the number of parameters in the ode model.\n",solver->odeModel->P);
return ;
}
for(i = 0; i < solver->odeModel->P; i++)
solver->params[i] = p[i];
}
/* Get initial conditions */
if(y0 != 0){
if( lenY != solver->odeModel->N ){
fprintf(stderr,"ode_solver_init: lenY must be equal %d, the number of variables in the ode model.\n",solver->odeModel->N);
return ;
}
NV_DATA_S(solver->y) = y0;
}
/* initialise */
flag = CVodeInit(solver->cvode_mem, solver->odeModel->vf_eval, t0, solver->y);
flag = CVodeSetUserData(solver->cvode_mem, solver->params);
flag = CVDense(solver->cvode_mem, solver->odeModel->N);
flag = CVDlsSetDenseJacFn(solver->cvode_mem, solver->odeModel->vf_jac);
flag = CVodeSStolerances(solver->cvode_mem, ODE_SOLVER_REL_ERR, ODE_SOLVER_ABS_ERR);
flag = CVodeSetMaxNumSteps(solver->cvode_mem, ODE_SOLVER_MX_STEPS);
}
void FCV_REINIT(realtype *t0, realtype *y0,
int *iatol, realtype *rtol, realtype *atol,
int *ier)
{
N_Vector Vatol;
*ier = 0;
/* Initialize all pointers to NULL */
Vatol = NULL;
/* Set data in F2C_CVODE_vec to y0 */
N_VSetArrayPointer(y0, F2C_CVODE_vec);
/* Call CVReInit */
*ier = CVodeReInit(CV_cvodemem, *t0, F2C_CVODE_vec);
/* Reset data pointers */
N_VSetArrayPointer(NULL, F2C_CVODE_vec);
/* On failure, exit */
if (*ier != CV_SUCCESS) {
*ier = -1;
return;
}
/* Set tolerances */
switch (*iatol) {
case 1:
*ier = CVodeSStolerances(CV_cvodemem, *rtol, *atol);
break;
case 2:
Vatol = NULL;
Vatol = N_VCloneEmpty(F2C_CVODE_vec);
if (Vatol == NULL) {
*ier = -1;
return;
}
N_VSetArrayPointer(atol, Vatol);
*ier = CVodeSVtolerances(CV_cvodemem, *rtol, Vatol);
N_VDestroy(Vatol);
break;
}
/* On failure, exit */
if (*ier != CV_SUCCESS) {
*ier = -1;
return;
}
return;
}
void ode_solver_setErrTol(ode_solver* solver, const double rel_tol, double* abs_tol, const int abs_tol_len){
if( (abs_tol_len != 1) && (abs_tol_len != solver->odeModel->N)){
fprintf(stderr,"ode_solver_setErrTol: length of abs_tol must be 1 or equal to the number of variables in the ode model.\n");
return ;
}
/* set tollerances to the cvode_mem internal structure */
if ( abs_tol_len == 1 )
CVodeSStolerances(solver->cvode_mem, rel_tol, abs_tol[0]);
else{
N_Vector abs_tol_vec = N_VNewEmpty_Serial(abs_tol_len); /* alloc */
NV_DATA_S(abs_tol_vec) = abs_tol;
CVodeSVtolerances(solver->cvode_mem, rel_tol, abs_tol_vec);
N_VDestroy_Serial(abs_tol_vec); /* free */
}
}
cvode_mem *SOLVER(cvode, init, TARGET, SIMENGINE_STORAGE, solver_props *props){
cvode_mem *mem = (cvode_mem*) malloc(props->num_models*sizeof(cvode_mem));
unsigned int modelid;
// Only need to create this buffer in the first memory space as we are using this only for scratch
// and outside of the CVODE solver to compute the last outputs
mem[0].k1 = (CDATAFORMAT*)malloc(props->statesize*props->num_models*sizeof(CDATAFORMAT));
for(modelid=0; modelid<props->num_models; modelid++){
// Set the modelid on a per memory structure basis
mem[modelid].modelid = modelid;
// Store solver properties
mem[modelid].props = props;
// Create intial value vector
// This is done to avoid having the change the internal indexing within the flows and for the output_buffer
mem[modelid].y0 = N_VMake_Serial(props->statesize, &(props->model_states[modelid*props->statesize]));
// Create data structure for solver
mem[modelid].cvmem = CVodeCreate(CV_BDF, CV_NEWTON);
// Initialize CVODE
if(CVodeInit(mem[modelid].cvmem, user_fun_wrapper, props->starttime, ((N_Vector)(mem[modelid].y0))) != CV_SUCCESS){
fprintf(stderr, "Couldn't initialize CVODE");
}
// Set solver tolerances
if(CVodeSStolerances(mem[modelid].cvmem, props->reltol, props->abstol) != CV_SUCCESS){
fprintf(stderr, "Could not set CVODE tolerances");
}
// Set linear solver
if(CVDense(mem[modelid].cvmem, mem[modelid].props->statesize) != CV_SUCCESS){
fprintf(stderr, "Could not set CVODE linear solver");
}
// Set user data to contain pointer to memory structure for use in model_flows
if(CVodeSetUserData(mem[modelid].cvmem, &mem[modelid]) != CV_SUCCESS){
fprintf(stderr, "CVODE failed to initialize user data");
}
}
return mem;
}
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 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);
}
int main(int argc, char *argv[])
{
realtype abstol, reltol, t, tout;
N_Vector u;
UserData data;
void *cvode_mem;
int iout, flag, my_pe, npes;
long int neq, local_N;
MPI_Comm comm;
u = NULL;
data = NULL;
cvode_mem = NULL;
/* Set problem size neq */
neq = NVARS*MX*MY;
/* Get processor number and total number of pe's */
MPI_Init(&argc, &argv);
comm = MPI_COMM_WORLD;
MPI_Comm_size(comm, &npes);
MPI_Comm_rank(comm, &my_pe);
if (npes != NPEX*NPEY) {
if (my_pe == 0)
fprintf(stderr, "\nMPI_ERROR(0): npes = %d is not equal to NPEX*NPEY = %d\n\n",
npes,NPEX*NPEY);
MPI_Finalize();
return(1);
}
/* Set local length */
local_N = NVARS*MXSUB*MYSUB;
/* Allocate and load user data block; allocate preconditioner block */
data = (UserData) malloc(sizeof *data);
if (check_flag((void *)data, "malloc", 2, my_pe)) MPI_Abort(comm, 1);
InitUserData(my_pe, comm, data);
/* Allocate u, and set initial values and tolerances */
u = N_VNew_Parallel(comm, local_N, neq);
if (check_flag((void *)u, "N_VNew", 0, my_pe)) MPI_Abort(comm, 1);
SetInitialProfiles(u, data);
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, my_pe)) MPI_Abort(comm, 1);
/* Set the pointer to user-defined data */
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);
/* 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, my_pe)) MPI_Abort(comm, 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);
if (check_flag(&flag, "CVSpilsSetPreconditioner", 1, my_pe)) MPI_Abort(comm, 1);
if (my_pe == 0)
printf("\n2-species diurnal advection-diffusion problem\n\n");
/* 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);
if (check_flag(&flag, "CVode", 1, my_pe)) break;
PrintOutput(cvode_mem, my_pe, comm, u, t);
}
/* Print final statistics */
if (my_pe == 0) PrintFinalStats(cvode_mem);
/* Free memory */
N_VDestroy_Parallel(u);
FreeUserData(data);
CVodeFree(&cvode_mem);
MPI_Finalize();
return(0);
}
PetscErrorCode TSSetUp_Sundials(TS ts)
{
TS_Sundials *cvode = (TS_Sundials*)ts->data;
PetscErrorCode ierr;
PetscInt glosize,locsize,i,flag;
PetscScalar *y_data,*parray;
void *mem;
PC pc;
PCType pctype;
PetscBool pcnone;
PetscFunctionBegin;
/* get the vector size */
ierr = VecGetSize(ts->vec_sol,&glosize);CHKERRQ(ierr);
ierr = VecGetLocalSize(ts->vec_sol,&locsize);CHKERRQ(ierr);
/* allocate the memory for N_Vec y */
cvode->y = N_VNew_Parallel(cvode->comm_sundials,locsize,glosize);
if (!cvode->y) SETERRQ(PETSC_COMM_SELF,1,"cvode->y is not allocated");
/* initialize N_Vec y: copy ts->vec_sol to cvode->y */
ierr = VecGetArray(ts->vec_sol,&parray);CHKERRQ(ierr);
y_data = (PetscScalar*) N_VGetArrayPointer(cvode->y);
for (i = 0; i < locsize; i++) y_data[i] = parray[i];
ierr = VecRestoreArray(ts->vec_sol,NULL);CHKERRQ(ierr);
ierr = VecDuplicate(ts->vec_sol,&cvode->update);CHKERRQ(ierr);
ierr = VecDuplicate(ts->vec_sol,&cvode->ydot);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)ts,(PetscObject)cvode->update);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)ts,(PetscObject)cvode->ydot);CHKERRQ(ierr);
/*
Create work vectors for the TSPSolve_Sundials() routine. Note these are
allocated with zero space arrays because the actual array space is provided
by Sundials and set using VecPlaceArray().
*/
ierr = VecCreateMPIWithArray(PetscObjectComm((PetscObject)ts),1,locsize,PETSC_DECIDE,0,&cvode->w1);CHKERRQ(ierr);
ierr = VecCreateMPIWithArray(PetscObjectComm((PetscObject)ts),1,locsize,PETSC_DECIDE,0,&cvode->w2);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)ts,(PetscObject)cvode->w1);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)ts,(PetscObject)cvode->w2);CHKERRQ(ierr);
/* Call CVodeCreate to create the solver memory and the use of a Newton iteration */
mem = CVodeCreate(cvode->cvode_type, CV_NEWTON);
if (!mem) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_MEM,"CVodeCreate() fails");
cvode->mem = mem;
/* Set the pointer to user-defined data */
flag = CVodeSetUserData(mem, ts);
if (flag) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVodeSetUserData() fails");
/* Sundials may choose to use a smaller initial step, but will never use a larger step. */
flag = CVodeSetInitStep(mem,(realtype)ts->time_step);
if (flag) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_LIB,"CVodeSetInitStep() failed");
if (cvode->mindt > 0) {
flag = CVodeSetMinStep(mem,(realtype)cvode->mindt);
if (flag) {
if (flag == CV_MEM_NULL) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_LIB,"CVodeSetMinStep() failed, cvode_mem pointer is NULL");
else if (flag == CV_ILL_INPUT) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_LIB,"CVodeSetMinStep() failed, hmin is nonpositive or it exceeds the maximum allowable step size");
else SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_LIB,"CVodeSetMinStep() failed");
}
}
if (cvode->maxdt > 0) {
flag = CVodeSetMaxStep(mem,(realtype)cvode->maxdt);
if (flag) SETERRQ(PetscObjectComm((PetscObject)ts),PETSC_ERR_LIB,"CVodeSetMaxStep() failed");
}
/* 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 cvode->y */
flag = CVodeInit(mem,TSFunction_Sundials,ts->ptime,cvode->y);
if (flag) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVodeInit() fails, flag %d",flag);
/* specifies scalar relative and absolute tolerances */
flag = CVodeSStolerances(mem,cvode->reltol,cvode->abstol);
if (flag) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVodeSStolerances() fails, flag %d",flag);
/* Specify max num of steps to be taken by cvode in its attempt to reach the next output time */
flag = CVodeSetMaxNumSteps(mem,ts->max_steps);
/* call CVSpgmr to use GMRES as the linear solver. */
/* setup the ode integrator with the given preconditioner */
ierr = TSSundialsGetPC(ts,&pc);CHKERRQ(ierr);
ierr = PCGetType(pc,&pctype);CHKERRQ(ierr);
ierr = PetscObjectTypeCompare((PetscObject)pc,PCNONE,&pcnone);CHKERRQ(ierr);
if (pcnone) {
flag = CVSpgmr(mem,PREC_NONE,0);
if (flag) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVSpgmr() fails, flag %d",flag);
} else {
flag = CVSpgmr(mem,PREC_LEFT,cvode->maxl);
if (flag) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVSpgmr() fails, flag %d",flag);
/* Set preconditioner and solve routines Precond and PSolve,
and the pointer to the user-defined block data */
flag = CVSpilsSetPreconditioner(mem,TSPrecond_Sundials,TSPSolve_Sundials);
if (flag) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVSpilsSetPreconditioner() fails, flag %d", flag);
}
flag = CVSpilsSetGSType(mem, MODIFIED_GS);
if (flag) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_LIB,"CVSpgmrSetGSType() fails, flag %d",flag);
PetscFunctionReturn(0);
}
int main(int argc, char *argv[])
{
ProblemData d;
MPI_Comm comm;
int npes, npes_needed;
int myId;
long int neq, l_neq;
void *cvode_mem;
N_Vector y, q;
realtype abstol, reltol, abstolQ, reltolQ;
long int mudq, mldq, mukeep, mlkeep;
int indexB;
N_Vector yB, qB;
realtype abstolB, reltolB, abstolQB, reltolQB;
long int mudqB, mldqB, mukeepB, mlkeepB;
realtype tret, *qdata, G;
int ncheckpnt, flag;
booleantype output;
/* Initialize MPI and set Ids */
MPI_Init(&argc, &argv);
comm = MPI_COMM_WORLD;
MPI_Comm_rank(comm, &myId);
/* Check number of processes */
npes_needed = NPX * NPY;
#ifdef USE3D
npes_needed *= NPZ;
#endif
MPI_Comm_size(comm, &npes);
if (npes_needed != npes) {
if (myId == 0)
fprintf(stderr,"I need %d processes but I only got %d\n",
npes_needed, npes);
MPI_Abort(comm, EXIT_FAILURE);
}
/* Test if matlab output is requested */
if (argc > 1) output = TRUE;
else output = FALSE;
/* Allocate and set problem data structure */
d = (ProblemData) malloc(sizeof *d);
SetData(d, comm, npes, myId, &neq, &l_neq);
if (myId == 0) PrintHeader();
/*--------------------------
Forward integration phase
--------------------------*/
/* Allocate space for y and set it with the I.C. */
y = N_VNew_Parallel(comm, l_neq, neq);
N_VConst(ZERO, y);
/* Allocate and initialize qB (local contribution to cost) */
q = N_VNew_Parallel(comm, 1, npes);
N_VConst(ZERO, q);
/* Create CVODES object, attach user data, and allocate space */
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
flag = CVodeSetUserData(cvode_mem, d);
flag = CVodeInit(cvode_mem, f, ti, y);
abstol = ATOL;
reltol = RTOL;
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
/* attach linear solver */
flag = CVSpgmr(cvode_mem, PREC_LEFT, 0);
/* Attach preconditioner and linear solver modules */
mudq = mldq = d->l_m[0]+1;
mukeep = mlkeep = 2;
flag = CVBBDPrecInit(cvode_mem, l_neq, mudq, mldq,
mukeep, mlkeep, ZERO,
f_local, NULL);
/* Initialize quadrature calculations */
abstolQ = ATOL_Q;
reltolQ = RTOL_Q;
flag = CVodeQuadInit(cvode_mem, fQ, q);
flag = CVodeQuadSStolerances(cvode_mem, reltolQ, abstolQ);
flag = CVodeSetQuadErrCon(cvode_mem, TRUE);
/* Allocate space for the adjoint calculation */
flag = CVodeAdjInit(cvode_mem, STEPS, CV_HERMITE);
/* Integrate forward in time while storing check points */
if (myId == 0) printf("Begin forward integration... ");
flag = CVodeF(cvode_mem, tf, y, &tret, CV_NORMAL, &ncheckpnt);
if (myId == 0) printf("done. ");
/* Extract quadratures */
flag = CVodeGetQuad(cvode_mem, &tret, q);
qdata = NV_DATA_P(q);
MPI_Allreduce(&qdata[0], &G, 1, PVEC_REAL_MPI_TYPE, MPI_SUM, comm);
#if defined(SUNDIALS_EXTENDED_PRECISION)
if (myId == 0) printf(" G = %Le\n",G);
#elif defined(SUNDIALS_DOUBLE_PRECISION)
if (myId == 0) printf(" G = %e\n",G);
#else
if (myId == 0) printf(" G = %e\n",G);
#endif
/* Print statistics for forward run */
if (myId == 0) PrintFinalStats(cvode_mem);
/*--------------------------
Backward integration phase
--------------------------*/
/* Allocate and initialize yB */
yB = N_VNew_Parallel(comm, l_neq, neq);
N_VConst(ZERO, yB);
/* Allocate and initialize qB (gradient) */
qB = N_VNew_Parallel(comm, l_neq, neq);
N_VConst(ZERO, qB);
/* Create and allocate backward CVODE memory */
flag = CVodeCreateB(cvode_mem, CV_BDF, CV_NEWTON, &indexB);
flag = CVodeSetUserDataB(cvode_mem, indexB, d);
flag = CVodeInitB(cvode_mem, indexB, fB, tf, yB);
abstolB = ATOL_B;
reltolB = RTOL_B;
flag = CVodeSStolerancesB(cvode_mem, indexB, reltolB, abstolB);
/* Attach preconditioner and linear solver modules */
flag = CVSpgmrB(cvode_mem, indexB, PREC_LEFT, 0);
mudqB = mldqB = d->l_m[0]+1;
mukeepB = mlkeepB = 2;
flag = CVBBDPrecInitB(cvode_mem, indexB, l_neq, mudqB, mldqB,
mukeepB, mlkeepB, ZERO, fB_local, NULL);
/* Initialize quadrature calculations */
abstolQB = ATOL_QB;
reltolQB = RTOL_QB;
flag = CVodeQuadInitB(cvode_mem, indexB, fQB, qB);
flag = CVodeQuadSStolerancesB(cvode_mem, indexB, reltolQB, abstolQB);
flag = CVodeSetQuadErrConB(cvode_mem, indexB, TRUE);
/* Integrate backwards */
if (myId == 0) printf("Begin backward integration... ");
flag = CVodeB(cvode_mem, ti, CV_NORMAL);
if (myId == 0) printf("done.\n");
/* Extract solution */
flag = CVodeGetB(cvode_mem, indexB, &tret, yB);
/* Extract quadratures */
flag = CVodeGetQuadB(cvode_mem, indexB, &tret, qB);
/* Print statistics for backward run */
if (myId == 0) {
PrintFinalStats(CVodeGetAdjCVodeBmem(cvode_mem, indexB));
}
/* Process 0 collects the gradient components and prints them */
if (output) {
OutputGradient(myId, qB, d);
if (myId == 0) printf("Wrote matlab file 'grad.m'.\n");
}
/* Free memory */
N_VDestroy_Parallel(y);
N_VDestroy_Parallel(q);
N_VDestroy_Parallel(qB);
N_VDestroy_Parallel(yB);
CVodeFree(&cvode_mem);
MPI_Finalize();
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 nst;
HYPRE_Int local_N, nperpe, nrem, my_base;
HYPRE_ParVector Upar; /* Declare HYPRE parallel vector */
HYPRE_IJVector Uij; /* Declare "IJ" interface to HYPRE vector */
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 partitioning. */
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;
/* Allocate hypre vector */
HYPRE_IJVectorCreate(comm, my_base, my_base + local_N - 1, &Uij);
HYPRE_IJVectorSetObjectType(Uij, HYPRE_PARCSR);
HYPRE_IJVectorInitialize(Uij);
/* Allocate user defined data */
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;
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);
/* Initialize solutin vector. */
SetIC(Uij, dx, local_N, my_base);
HYPRE_IJVectorAssemble(Uij);
HYPRE_IJVectorGetObject(Uij, (void**) &Upar);
u = N_VMake_ParHyp(Upar); /* Create wrapper u around hypre vector */
if(check_flag((void *)u, "N_VNew", 0, my_pe)) MPI_Abort(comm, 1);
/* 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(u); /* Free hypre vector wrapper */
HYPRE_IJVectorDestroy(Uij); /* Free the underlying hypre vector */
CVodeFree(&cvode_mem); /* Free the integrator memory */
free(data); /* Free user data */
MPI_Finalize();
return(0);
}
int dynamixMain (int argc, char * argv[]) {
//// DECLARING VARIABLES
// Struct of parameters
PARAMETERS p;
// CVode variables
void * cvode_mem = NULL; // pointer to block of CVode memory
N_Vector y, yout; // arrays of populations
// arrays for energetic parameters
realtype ** V = NULL; // pointer to k-c coupling constants
realtype * Vbridge = NULL; // pointer to array of bridge coupling constants.
// first element [0] is Vkb1, last [Nb] is VcbN
realtype * Vnobridge = NULL; // coupling constant when there is no bridge
//// Setting defaults for parameters to be read from input
//// done setting defaults
int flag;
realtype * k_pops = NULL; // pointers to arrays of populations
realtype * l_pops = NULL;
realtype * c_pops = NULL;
realtype * b_pops = NULL;
realtype * ydata = NULL; // pointer to ydata (contains all populations)
realtype * wavefunction = NULL; // (initial) wavefunction
realtype * dm = NULL; // density matrix
realtype * dmt = NULL; // density matrix in time
realtype * wfnt = NULL; // density matrix in time
realtype * k_energies = NULL; // pointers to arrays of energies
realtype * c_energies = NULL;
realtype * b_energies = NULL;
realtype * l_energies = NULL;
realtype t0 = 0.0; // initial time
realtype t = 0;
realtype tret = 0; // time returned by the solver
time_t startRun; // time at start of log
time_t endRun; // time at end of log
struct tm * currentTime = NULL; // time structure for localtime
#ifdef DEBUG
FILE * realImaginary; // file containing real and imaginary parts of the wavefunction
#endif
FILE * log; // log file with run times
realtype * tkprob = NULL; // total probability in k, l, c, b states at each timestep
realtype * tlprob = NULL;
realtype * tcprob = NULL;
realtype * tbprob = NULL;
double ** allprob = NULL; // populations in all states at all times
realtype * times = NULL;
realtype * qd_est = NULL;
realtype * qd_est_diag = NULL;
std::string inputFile = "ins/parameters.in"; // name of input file
std::string cEnergiesInput = "ins/c_energies.in";
std::string cPopsInput = "ins/c_pops.in";
std::string bEnergiesInput = "ins/b_energies.in";
std::string VNoBridgeInput = "ins/Vnobridge.in";
std::string VBridgeInput = "ins/Vbridge.in";
std::map<const std::string, bool> outs; // map of output file names to bool
// default output directory
p.outputDir = "outs/";
double summ = 0; // sum variable
// ---- process command line flags ---- //
opterr = 0;
int c;
std::string insDir;
/* process command line options */
while ((c = getopt(argc, argv, "i:o:")) != -1) {
switch (c) {
case 'i':
// check that it ends in a slash
std::cerr << "[dynamix]: assigning input directory" << std::endl;
insDir = optarg;
if (strcmp(&(insDir.at(insDir.length() - 1)), "/")) {
std::cerr << "ERROR: option -i requires argument ("
<< insDir << ") to have a trailing slash (/)." << std::endl;
return 1;
}
else {
// ---- assign input files ---- //
inputFile = insDir + "parameters.in";
cEnergiesInput = insDir + "c_energies.in";
cPopsInput = insDir + "c_pops.in";
bEnergiesInput = insDir + "b_energies.in";
VNoBridgeInput = insDir + "Vnobridge.in";
VBridgeInput = insDir + "Vbridge.in";
}
break;
case 'o':
std::cerr << "[dynamix]: assigning output directory" << std::endl;
p.outputDir = optarg;
break;
case '?':
if (optopt == 'i') {
fprintf(stderr, "Option -%c requires a directory argument.\n", optopt);
}
else if (isprint(optopt)) {
fprintf(stderr, "Unknown option -%c.\n", optopt);
}
else {
fprintf(stderr, "Unknown option character `\\x%x'.\n", optopt);
}
return 1;
default:
continue;
}
}
optind = 1; // reset global variable counter for the next time this is run
std::cerr << "[dynamix]: ARGUMENTS" << std::endl;
for (int ii = 0; ii < argc; ii++) {
std::cerr << "[dynamix]: " << argv[ii] << std::endl;
}
//// ASSIGN PARAMETERS FROM INPUT FILE
// ---- TODO create output directory if it does not exist ---- //
flag = mkdir(p.outputDir.c_str(), 0755);
std::cerr << "Looking for inputs in all the " << inputFile << " places" << std::endl;
assignParams(inputFile.c_str(), &p);
// Decide which output files to make
#ifdef DEBUG
std::cout << "Assigning outputs as specified in " << inputFile << "\n";
#endif
assignOutputs(inputFile.c_str(), outs, &p);
#ifdef DEBUG
// print out which outputs will be made
for (std::map<const std::string, bool>::iterator it = outs.begin(); it != outs.end(); it++) {
std::cout << "Output file: " << it->first << " will be created.\n";
}
#endif
// OPEN LOG FILE; PUT IN START TIME //
if (isOutput(outs, "log.out")) {
log = fopen("log.out", "w"); // note that this file is closed at the end of the program
}
time(&startRun);
currentTime = localtime(&startRun);
if (isOutput(outs, "log.out")) {
fprintf(log, "Run started at %s\n", asctime(currentTime));
}
if (isOutput(outs, "log.out")) {
// make a note about the laser intensity.
fprintf(log,"The laser intensity is %.5e W/cm^2.\n\n",pow(p.pumpAmpl,2)*3.5094452e16);
}
//// READ DATA FROM INPUTS
p.Nc = numberOfValuesInFile(cEnergiesInput.c_str());
p.Nb = numberOfValuesInFile(bEnergiesInput.c_str());
k_pops = new realtype [p.Nk];
c_pops = new realtype [p.Nc];
b_pops = new realtype [p.Nb];
l_pops = new realtype [p.Nl];
k_energies = new realtype [p.Nk];
c_energies = new realtype [p.Nc];
b_energies = new realtype [p.Nb];
l_energies = new realtype [p.Nl];
if (numberOfValuesInFile(cPopsInput.c_str()) != p.Nc) {
fprintf(stderr, "ERROR [Inputs]: c_pops and c_energies not the same length.\n");
return -1;
}
readArrayFromFile(c_energies, cEnergiesInput.c_str(), p.Nc);
if (p.bridge_on) {
if (p.bridge_on && (p.Nb < 1)) {
std::cerr << "\nERROR: bridge_on but no bridge states. The file b_energies.in is probably empty.\n";
return -1;
}
p.Vbridge.resize(p.Nb+1);
readArrayFromFile(b_energies, bEnergiesInput.c_str(), p.Nb);
readVectorFromFile(p.Vbridge, VBridgeInput.c_str(), p.Nb + 1);
#ifdef DEBUG
std::cout << "COUPLINGS:";
for (int ii = 0; ii < p.Nb+1; ii++) {
std::cout << " " << p.Vbridge[ii];
}
std::cout << std::endl;
#endif
}
else {
p.Nb = 0;
p.Vnobridge.resize(1);
readVectorFromFile(p.Vnobridge, VNoBridgeInput.c_str(), 1);
}
#ifdef DEBUG
std::cout << "\nDone reading things from inputs.\n";
#endif
//// PREPROCESS DATA FROM INPUTS
// check torsion parameters, set up torsion spline
if (p.torsion) {
#ifdef DEBUG
std::cout << "Torsion is on." << std::endl;
#endif
// error checking
if (p.torsionSite > p.Nb) {
std::cerr << "ERROR: torsion site (" << p.torsionSite
<< ") is larger than number of bridge sites (" << p.Nb << ")." << std::endl;
exit(-1);
}
else if (p.torsionSite < 0) {
std::cerr << "ERROR: torsion site is less than zero." << std::endl;
exit(-1);
}
if (!fileExists(p.torsionFile)) {
std::cerr << "ERROR: torsion file " << p.torsionFile << " does not exist." << std::endl;
}
// create spline
p.torsionV = new Spline(p.torsionFile.c_str());
if (p.torsionV->getFirstX() != 0.0) {
std::cerr << "ERROR: time in " << p.torsionFile << " should start at 0.0." << std::endl;
exit(-1);
}
if (p.torsionV->getLastX() < p.tout) {
std::cerr << "ERROR: time in " << p.torsionFile << " should be >= tout." << std::endl;
exit(-1);
}
}
// set number of processors for OpenMP
//omp_set_num_threads(p.nproc);
mkl_set_num_threads(p.nproc);
p.NEQ = p.Nk+p.Nc+p.Nb+p.Nl; // total number of equations set
p.NEQ2 = p.NEQ*p.NEQ; // number of elements in DM
#ifdef DEBUG
std::cout << "\nTotal number of states: " << p.NEQ << std::endl;
std::cout << p.Nk << " bulk, " << p.Nc << " QD, " << p.Nb << " bridge, " << p.Nl << " bulk VB.\n";
#endif
tkprob = new realtype [p.numOutputSteps+1]; // total population on k, b, c at each timestep
tcprob = new realtype [p.numOutputSteps+1];
tbprob = new realtype [p.numOutputSteps+1];
tlprob = new realtype [p.numOutputSteps+1];
allprob = new double * [p.numOutputSteps+1];
for (int ii = 0; ii <= p.numOutputSteps; ii++) {
allprob[ii] = new double [p.NEQ];
}
// assign times.
p.times.resize(p.numOutputSteps+1);
for (int ii = 0; ii <= p.numOutputSteps; ii++) {
p.times[ii] = float(ii)/p.numOutputSteps*p.tout;
}
qd_est = new realtype [p.numOutputSteps+1];
qd_est_diag = new realtype [p.numOutputSteps+1];
p.Ik = 0; // set index start positions for each type of state
p.Ic = p.Nk;
p.Ib = p.Ic+p.Nc;
p.Il = p.Ib+p.Nb;
// assign bulk conduction and valence band energies
// for RTA, bulk and valence bands have parabolic energies
if (p.rta) {
buildParabolicBand(k_energies, p.Nk, p.kBandEdge, CONDUCTION, &p);
buildParabolicBand(l_energies, p.Nl, p.lBandTop, VALENCE, &p);
}
else {
buildContinuum(k_energies, p.Nk, p.kBandEdge, p.kBandTop);
buildContinuum(l_energies, p.Nl, p.kBandEdge - p.valenceBand - p.bulk_gap, p.kBandEdge - p.bulk_gap);
}
// calculate band width
p.kBandWidth = k_energies[p.Nk - 1] - k_energies[0];
//// BUILD INITIAL WAVEFUNCTION
// bridge states (empty to start)
initializeArray(b_pops, p.Nb, 0.0);
// coefficients in bulk and other states depend on input conditions in bulk
if (!p.rta) {
#ifdef DEBUG
std::cout << "\ninitializing k_pops\n";
#endif
if (p.bulk_constant) {
initializeArray(k_pops, p.Nk, 0.0);
#ifdef DEBUG
std::cout << "\ninitializing k_pops with constant probability in range of states\n";
#endif
initializeArray(k_pops+p.Nk_first-1, p.Nk_final-p.Nk_first+1, 1.0);
initializeArray(l_pops, p.Nl, 0.0); // populate l states (all 0 to start off)
initializeArray(c_pops, p.Nc, 0.0); // QD states empty to start
}
else if (p.bulk_Gauss) {
buildKPopsGaussian(k_pops, k_energies, p.kBandEdge,
p.bulkGaussSigma, p.bulkGaussMu, p.Nk); // populate k states with FDD
initializeArray(l_pops, p.Nl, 0.0); // populate l states (all 0 to start off)
initializeArray(c_pops, p.Nc, 0.0); // QD states empty to start
}
else if (p.qd_pops) {
readArrayFromFile(c_pops, cPopsInput.c_str(), p.Nc); // QD populations from file
initializeArray(l_pops, p.Nl, 0.0); // populate l states (all 0 to start off)
initializeArray(k_pops, p.Nk, 0.0); // populate k states (all zero to start off)
}
else {
initializeArray(k_pops, p.Nk, 0.0); // populate k states (all zero to start off)
initializeArray(l_pops, p.Nl, 1.0); // populate l states (all populated to start off)
initializeArray(c_pops, p.Nc, 0.0); // QD states empty to start
}
#ifdef DEBUG
std::cout << "\nThis is k_pops:\n";
for (int ii = 0; ii < p.Nk; ii++) {
std::cout << k_pops[ii] << std::endl;
}
std::cout << "\n";
#endif
}
// with RTA, use different set of switches
else {
// bulk valence band
if (p.VBPopFlag == POP_EMPTY) {
#ifdef DEBUG
std::cout << "Initializing empty valence band" << std::endl;
#endif
initializeArray(l_pops, p.Nl, 0.0);
}
else if (p.VBPopFlag == POP_FULL) {
#ifdef DEBUG
std::cout << "Initializing full valence band" << std::endl;
#endif
initializeArray(l_pops, p.Nl, 1.0);
}
else {
std::cerr << "ERROR: unrecognized VBPopFlag " << p.VBPopFlag << std::endl;
}
// bulk conduction band
if (p.CBPopFlag == POP_EMPTY) {
#ifdef DEBUG
std::cout << "Initializing empty conduction band" << std::endl;
#endif
initializeArray(k_pops, p.Nk, 0.0);
}
else if (p.CBPopFlag == POP_FULL) {
#ifdef DEBUG
std::cout << "Initializing full conduction band" << std::endl;
#endif
initializeArray(k_pops, p.Nk, 1.0);
}
else if (p.CBPopFlag == POP_CONSTANT) {
#ifdef DEBUG
std::cout << "Initializing constant distribution in conduction band" << std::endl;
#endif
initializeArray(k_pops, p.Nk, 0.0);
initializeArray(k_pops, p.Nk, 1e-1); // FIXME
initializeArray(k_pops+p.Nk_first-1, p.Nk_final-p.Nk_first+1, 1.0);
}
else if (p.CBPopFlag == POP_GAUSSIAN) {
#ifdef DEBUG
std::cout << "Initializing Gaussian in conduction band" << std::endl;
#endif
buildKPopsGaussian(k_pops, k_energies, p.kBandEdge,
p.bulkGaussSigma, p.bulkGaussMu, p.Nk);
}
else {
std::cerr << "ERROR: unrecognized CBPopFlag " << p.CBPopFlag << std::endl;
}
//// QD
if (p.QDPopFlag == POP_EMPTY) {
initializeArray(c_pops, p.Nc, 0.0);
}
else if (p.QDPopFlag == POP_FULL) {
initializeArray(c_pops, p.Nc, 1.0);
}
else {
std::cerr << "ERROR: unrecognized QDPopFlag " << p.QDPopFlag << std::endl;
}
}
// create empty wavefunction
wavefunction = new realtype [2*p.NEQ];
initializeArray(wavefunction, 2*p.NEQ, 0.0);
// assign real parts of wavefunction coefficients (imaginary are zero)
for (int ii = 0; ii < p.Nk; ii++) {
wavefunction[p.Ik + ii] = k_pops[ii];
}
for (int ii = 0; ii < p.Nc; ii++) {
wavefunction[p.Ic + ii] = c_pops[ii];
}
for (int ii = 0; ii < p.Nb; ii++) {
wavefunction[p.Ib + ii] = b_pops[ii];
}
for (int ii = 0; ii < p.Nl; ii++) {
wavefunction[p.Il + ii] = l_pops[ii];
}
if (isOutput(outs, "psi_start.out")) {
outputWavefunction(wavefunction, p.NEQ);
}
// Give all coefficients a random phase
if (p.random_phase) {
float phi;
// set the seed
if (p.random_seed == -1) { srand(time(NULL)); }
else { srand(p.random_seed); }
for (int ii = 0; ii < p.NEQ; ii++) {
phi = 2*3.1415926535*(float)rand()/(float)RAND_MAX;
wavefunction[ii] = wavefunction[ii]*cos(phi);
wavefunction[ii + p.NEQ] = wavefunction[ii + p.NEQ]*sin(phi);
}
}
#ifdef DEBUG
// print out details of wavefunction coefficients
std::cout << std::endl;
for (int ii = 0; ii < p.Nk; ii++) {
std::cout << "starting wavefunction: Re[k(" << ii << ")] = " << wavefunction[p.Ik + ii] << std::endl;
}
for (int ii = 0; ii < p.Nc; ii++) {
std::cout << "starting wavefunction: Re[c(" << ii << ")] = " << wavefunction[p.Ic + ii] << std::endl;
}
for (int ii = 0; ii < p.Nb; ii++) {
std::cout << "starting wavefunction: Re[b(" << ii << ")] = " << wavefunction[p.Ib + ii] << std::endl;
}
for (int ii = 0; ii < p.Nl; ii++) {
std::cout << "starting wavefunction: Re[l(" << ii << ")] = " << wavefunction[p.Il + ii] << std::endl;
}
for (int ii = 0; ii < p.Nk; ii++) {
std::cout << "starting wavefunction: Im[k(" << ii << ")] = " << wavefunction[p.Ik + ii + p.NEQ] << std::endl;
}
for (int ii = 0; ii < p.Nc; ii++) {
std::cout << "starting wavefunction: Im[c(" << ii << ")] = " << wavefunction[p.Ic + ii + p.NEQ] << std::endl;
}
for (int ii = 0; ii < p.Nb; ii++) {
std::cout << "starting wavefunction: Im[b(" << ii << ")] = " << wavefunction[p.Ib + ii + p.NEQ] << std::endl;
}
for (int ii = 0; ii < p.Nl; ii++) {
std::cout << "starting wavefunction: Im[l(" << ii << ")] = " << wavefunction[p.Il + ii + p.NEQ] << std::endl;
}
std::cout << std::endl;
summ = 0;
for (int ii = 0; ii < 2*p.NEQ; ii++) {
summ += pow(wavefunction[ii],2);
}
std::cout << "\nTotal population is " << summ << "\n\n";
#endif
//// ASSEMBLE ARRAY OF ENERGIES
// TODO TODO
p.energies.resize(p.NEQ);
for (int ii = 0; ii < p.Nk; ii++) {
p.energies[p.Ik + ii] = k_energies[ii];
}
for (int ii = 0; ii < p.Nc; ii++) {
p.energies[p.Ic + ii] = c_energies[ii];
}
for (int ii = 0; ii < p.Nb; ii++) {
p.energies[p.Ib + ii] = b_energies[ii];
}
for (int ii = 0; ii < p.Nl; ii++) {
p.energies[p.Il + ii] = l_energies[ii];
}
#ifdef DEBUG
for (int ii = 0; ii < p.NEQ; ii++) {
std::cout << "p.energies[" << ii << "] is " << p.energies[ii] << "\n";
}
#endif
//// ASSIGN COUPLING CONSTANTS
V = new realtype * [p.NEQ];
for (int ii = 0; ii < p.NEQ; ii++) {
V[ii] = new realtype [p.NEQ];
}
buildCoupling(V, &p, outs);
if (isOutput(outs, "log.out")) {
// make a note in the log about system timescales
double tau = 0; // fundamental system timescale
if (p.Nk == 1) {
fprintf(log, "\nThe timescale (tau) is undefined (Nk == 1).\n");
}
else {
if (p.bridge_on) {
if (p.scale_bubr) {
tau = 1.0/(2*p.Vbridge[0]*M_PI);
}
else {
tau = ((p.kBandTop - p.kBandEdge)/(p.Nk - 1))/(2*pow(p.Vbridge[0],2)*M_PI);
}
}
else {
if (p.scale_buqd) {
tau = 1.0/(2*p.Vnobridge[0]*M_PI);
}
else {
tau = ((p.kBandTop - p.kBandEdge)/(p.Nk - 1))/(2*pow(p.Vnobridge[0],2)*M_PI);
}
}
fprintf(log, "\nThe timescale (tau) is %.9e a.u.\n", tau);
}
}
//// CREATE DENSITY MATRIX
if (! p.wavefunction) {
// Create the initial density matrix
dm = new realtype [2*p.NEQ2];
initializeArray(dm, 2*p.NEQ2, 0.0);
#pragma omp parallel for
for (int ii = 0; ii < p.NEQ; ii++) {
// diagonal part
dm[p.NEQ*ii + ii] = pow(wavefunction[ii],2) + pow(wavefunction[ii + p.NEQ],2);
if (p.coherent) {
// off-diagonal part
for (int jj = 0; jj < ii; jj++) {
// real part of \rho_{ii,jj}
dm[p.NEQ*ii + jj] = wavefunction[ii]*wavefunction[jj] + wavefunction[ii+p.NEQ]*wavefunction[jj+p.NEQ];
// imaginary part of \rho_{ii,jj}
dm[p.NEQ*ii + jj + p.NEQ2] = wavefunction[ii]*wavefunction[jj+p.NEQ] - wavefunction[jj]*wavefunction[ii+p.NEQ];
// real part of \rho_{jj,ii}
dm[p.NEQ*jj + ii] = dm[p.NEQ*ii + jj];
// imaginary part of \rho_{jj,ii}
dm[p.NEQ*jj + ii + p.NEQ2] = -1*dm[p.NEQ*ii + jj + p.NEQ*p.NEQ];
}
}
}
// Create the array to store the density matrix in time
dmt = new realtype [2*p.NEQ2*(p.numOutputSteps+1)];
initializeArray(dmt, 2*p.NEQ2*(p.numOutputSteps+1), 0.0);
#ifdef DEBUG2
// print out density matrix
std::cout << "\nDensity matrix without normalization:\n\n";
for (int ii = 0; ii < p.NEQ; ii++) {
for (int jj = 0; jj < p.NEQ; jj++) {
fprintf(stdout, "(%+.1e,%+.1e) ", dm[p.NEQ*ii + jj], dm[p.NEQ*ii + jj + p.NEQ2]);
}
fprintf(stdout, "\n");
}
#endif
// Normalize the DM so that populations add up to 1.
// No normalization if RTA is on.
if (!p.rta) {
summ = 0.0;
for (int ii = 0; ii < p.NEQ; ii++) {
// assume here that diagonal elements are all real
summ += dm[p.NEQ*ii + ii];
}
if ( summ == 0.0 ) {
std::cerr << "\nFATAL ERROR [populations]: total population is 0!\n";
return -1;
}
if (summ != 1.0) {
// the variable 'summ' is now a multiplicative normalization factor
summ = 1.0/summ;
for (int ii = 0; ii < 2*p.NEQ2; ii++) {
dm[ii] *= summ;
}
}
#ifdef DEBUG
std::cout << "\nThe normalization factor for the density matrix is " << summ << "\n\n";
#endif
}
// Error checking for total population; recount population first
summ = 0.0;
for (int ii = 0; ii < p.NEQ; ii++) {
summ += dm[p.NEQ*ii + ii];
}
if ( fabs(summ-1.0) > 1e-12 && (!p.rta)) {
std::cerr << "\nWARNING [populations]: After normalization, total population is not 1, it is " << summ << "!\n";
}
#ifdef DEBUG
std::cout << "\nAfter normalization, the sum of the populations in the density matrix is " << summ << "\n\n";
#endif
// Add initial DM to parameters.
p.startDM.resize(2*p.NEQ2);
memcpy(&(p.startDM[0]), &(dm[0]), 2*p.NEQ2*sizeof(double));
}
// wavefunction
else {
// Create the array to store the wavefunction in time
wfnt = new realtype [2*p.NEQ*(p.numOutputSteps+1)];
initializeArray(wfnt, 2*p.NEQ*(p.numOutputSteps+1), 0.0);
// normalize
summ = 0.0;
for (int ii = 0; ii < p.NEQ; ii++) {
summ += pow(wavefunction[ii],2) + pow(wavefunction[ii+p.NEQ],2);
}
#ifdef DEBUG
std::cout << "Before normalization, the total population is " << summ << std::endl;
#endif
summ = 1.0/sqrt(summ);
for (int ii = 0; ii < 2*p.NEQ; ii++) {
wavefunction[ii] *= summ;
}
// check total population
summ = 0.0;
for (int ii = 0; ii < p.NEQ; ii++) {
summ += pow(wavefunction[ii],2) + pow(wavefunction[ii+p.NEQ],2);
}
#ifdef DEBUG
std::cout << "After normalization, the total population is " << summ << std::endl;
#endif
if (fabs(summ - 1.0) > 1e-12) {
std::cerr << "WARNING: wavefunction not normalized! Total density is " << summ << std::endl;
}
// Add initial wavefunction to parameters.
p.startWfn.resize(2*p.NEQ);
memcpy(&(p.startWfn[0]), &(wavefunction[0]), 2*p.NEQ*sizeof(double));
}
//// BUILD HAMILTONIAN
// //TODO TODO
#ifdef DEBUG
fprintf(stderr, "Building Hamiltonian.\n");
#endif
realtype * H = NULL;
H = new realtype [p.NEQ2];
for (int ii = 0; ii < p.NEQ2; ii++) {
H[ii] = 0.0;
}
buildHamiltonian(H, p.energies, V, &p);
// add Hamiltonian to p
p.H.resize(p.NEQ2);
for (int ii = 0; ii < p.NEQ2; ii++) {
p.H[ii] = H[ii];
}
// create sparse version of H
p.H_sp.resize(p.NEQ2);
p.H_cols.resize(p.NEQ2);
p.H_rowind.resize(p.NEQ2 + 1);
int job [6] = {0, 0, 0, 2, p.NEQ2, 1};
int info = 0;
mkl_ddnscsr(&job[0], &(p.NEQ), &(p.NEQ), &(p.H)[0], &(p.NEQ), &(p.H_sp)[0],
&(p.H_cols)[0], &(p.H_rowind)[0], &info);
//// SET UP CVODE VARIABLES
#ifdef DEBUG
std::cout << "\nCreating N_Vectors.\n";
if (p.wavefunction) {
std::cout << "\nProblem size is " << 2*p.NEQ << " elements.\n";
}
else {
std::cout << "\nProblem size is " << 2*p.NEQ2 << " elements.\n";
}
#endif
// Creates N_Vector y with initial populations which will be used by CVode//
if (p.wavefunction) {
y = N_VMake_Serial(2*p.NEQ, wavefunction);
}
else {
y = N_VMake_Serial(2*p.NEQ2, dm);
}
// put in t = 0 information
if (! p.wavefunction) {
updateDM(y, dmt, 0, &p);
}
else {
updateWfn(y, wfnt, 0, &p);
}
// the vector yout has the same dimensions as y
yout = N_VClone(y);
#ifdef DEBUG
realImaginary = fopen("real_imaginary.out", "w");
#endif
// Make plot files
makePlots(outs, &p);
// only do propagation if not just making plots
if (! p.justPlots) {
// Make outputs independent of time propagation
computeGeneralOutputs(outs, &p);
// create CVode object
// this is a stiff problem, I guess?
#ifdef DEBUG
std::cout << "\nCreating cvode_mem object.\n";
#endif
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
flag = CVodeSetUserData(cvode_mem, (void *) &p);
#ifdef DEBUG
std::cout << "\nInitializing CVode solver.\n";
#endif
// initialize CVode solver //
if (p.wavefunction) {
//flag = CVodeInit(cvode_mem, &RHS_WFN, t0, y);
flag = CVodeInit(cvode_mem, &RHS_WFN_SPARSE, t0, y);
}
else {
if (p.kinetic) {
flag = CVodeInit(cvode_mem, &RHS_DM_RELAX, t0, y);
}
else if (p.rta) {
flag = CVodeInit(cvode_mem, &RHS_DM_RTA, t0, y);
//flag = CVodeInit(cvode_mem, &RHS_DM_RTA_BLAS, t0, y);
}
else if (p.dephasing) {
flag = CVodeInit(cvode_mem, &RHS_DM_dephasing, t0, y);
}
else {
//flag = CVodeInit(cvode_mem, &RHS_DM, t0, y);
flag = CVodeInit(cvode_mem, &RHS_DM_BLAS, t0, y);
}
}
#ifdef DEBUG
std::cout << "\nSpecifying integration tolerances.\n";
#endif
// specify integration tolerances //
flag = CVodeSStolerances(cvode_mem, p.reltol, p.abstol);
#ifdef DEBUG
std::cout << "\nAttaching linear solver module.\n";
#endif
// attach linear solver module //
if (p.wavefunction) {
flag = CVDense(cvode_mem, 2*p.NEQ);
}
else {
// Diagonal approximation to the Jacobian saves memory for large systems
flag = CVDiag(cvode_mem);
}
//// CVODE TIME PROPAGATION
#ifdef DEBUG
std::cout << "\nAdvancing the solution in time.\n";
#endif
for (int ii = 1; ii <= p.numsteps; ii++) {
t = (p.tout*((double) ii)/((double) p.numsteps));
flag = CVode(cvode_mem, t, yout, &tret, 1);
#ifdef DEBUGf
std::cout << std::endl << "CVode flag at step " << ii << ": " << flag << std::endl;
#endif
if ((ii % (p.numsteps/p.numOutputSteps) == 0) || (ii == p.numsteps)) {
// show progress in stdout
if (p.progressStdout) {
fprintf(stdout, "\r%-.2lf percent done", ((double)ii/((double)p.numsteps))*100);
fflush(stdout);
}
// show progress in a file
if (p.progressFile) {
std::ofstream progressFile("progress.tmp");
progressFile << ((double)ii/((double)p.numsteps))*100 << " percent done." << std::endl;
progressFile.close();
}
if (p.wavefunction) {
updateWfn(yout, wfnt, ii*p.numOutputSteps/p.numsteps, &p);
}
else {
updateDM(yout, dmt, ii*p.numOutputSteps/p.numsteps, &p);
}
}
}
#ifdef DEBUG
fclose(realImaginary);
#endif
//// MAKE FINAL OUTPUTS
// finalize log file //
time(&endRun);
currentTime = localtime(&endRun);
if (isOutput(outs, "log.out")) {
fprintf(log, "Final status of 'flag' variable: %d\n\n", flag);
fprintf(log, "Run ended at %s\n", asctime(currentTime));
fprintf(log, "Run took %.3g seconds.\n", difftime(endRun, startRun));
fclose(log); // note that the log file is opened after variable declaration
}
if (p.progressStdout) {
printf("\nRun took %.3g seconds.\n", difftime(endRun, startRun));
}
// Compute density outputs.
#ifdef DEBUG
std::cout << "Computing outputs..." << std::endl;
#endif
if (p.wavefunction) {
computeWfnOutput(wfnt, outs, &p);
}
else {
computeDMOutput(dmt, outs, &p);
}
#ifdef DEBUG
std::cout << "done computing outputs" << std::endl;
#endif
// do analytical propagation
if (p.analytical && (! p.bridge_on)) {
computeAnalyticOutputs(outs, &p);
}
}
//// CLEAN UP
#ifdef DEBUG
fprintf(stdout, "Deallocating N_Vectors.\n");
#endif
// deallocate memory for N_Vectors //
N_VDestroy_Serial(y);
N_VDestroy_Serial(yout);
#ifdef DEBUG
fprintf(stdout, "Freeing CVode memory.\n");
#endif
// free solver memory //
CVodeFree(&cvode_mem);
#ifdef DEBUG
fprintf(stdout, "Freeing memory in main.\n");
#endif
// delete all these guys
delete [] tkprob;
delete [] tlprob;
delete [] tcprob;
delete [] tbprob;
for (int ii = 0; ii <= p.numOutputSteps; ii++) {
delete [] allprob[ii];
}
delete [] allprob;
delete [] k_pops;
delete [] c_pops;
delete [] b_pops;
delete [] l_pops;
if (p.bridge_on) {
delete [] Vbridge;
}
else {
delete [] Vnobridge;
}
delete [] k_energies;
delete [] c_energies;
delete [] b_energies;
delete [] l_energies;
delete [] wavefunction;
delete [] H;
for (int ii = 0; ii < p.NEQ; ii++) {
delete [] V[ii];
}
delete [] V;
if (p.wavefunction) {
delete [] wfnt;
}
else {
delete [] dm;
delete [] dmt;
}
delete [] times;
delete [] qd_est;
delete [] qd_est_diag;
std::cout << "whoo" << std::endl;
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);
}
void OpenSMOKE_CVODE_Sundials<T>::Solve(const double xend)
{
int flag;
this->x_ = this->x0_;
this->xend_ = xend;
for(int i=0;i<this->n_;i++)
NV_Ith_S(y0Sundials_,i) = this->y0_[i];
if (firstCall_ == true)
{
firstCall_ = false;
/* 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_, std::string("CVodeCreate"), 0)) exit(-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 y0Sundials_. */
flag = CVodeInit(cvode_mem_, this->odeSystem_->GetSystemFunctionsStatic, this->odeSystem_->GetWriteFunctionStatic, this->x0_, y0Sundials_);
if (check_flag(&flag, std::string("CVodeInit"), 1)) exit(-1);
/* Call CVodeSVtolerances to specify the scalar relative tolerance
* and vector absolute tolerances */
flag = CVodeSStolerances(cvode_mem_, this->relTolerance_[0], this->absTolerance_[0]);
if (check_flag(&flag, std::string("CVodeSVtolerances"), 1)) exit(-1);
/* Call Solver */
if (this->iUseLapack_ == false)
{
if (this->mUpper_ == 0 && this->mLower_ == 0)
{
// std::cout << "CVODE Solver: Dense Jacobian (without Lapack)..." << std::endl;
/* Create dense SUNMatrix for use in linear solves */
A = SUNDenseMatrix(this->n_, this->n_);
if (check_flag((void *)A, std::string("SUNDenseMatrix"), 0)) exit(-1);
/* Create SUNDenseLinearSolver solver object for use by CVode */
LS = SUNDenseLinearSolver(ySundials_, A);
if (check_flag((void *)LS, std::string("SUNDenseLinearSolver"), 0)) exit(-1);
}
else
{
// std::cout << "CVODE Solver: Band Jacobian (without Lapack)..." << std::endl;
/* Create banded SUNMatrix for use in linear solves -- since this will be factored,
set the storage bandwidth to be the sum of upper and lower bandwidths */
A = SUNBandMatrix(this->n_, this->mUpper_, this->mLower_, (this->mUpper_+this->mLower_) );
if (check_flag((void *)A, std::string("SUNBandMatrix"), 0)) exit(-1);
/* Create banded SUNLinearSolver object for use by CVode */
LS = SUNBandLinearSolver(ySundials_, A);
if (check_flag((void *)LS, std::string("SUNBandLinearSolver"), 0)) exit(-1);
}
}
else
{
if (this->mUpper_ == 0 && this->mLower_ == 0)
{
// std::cout << "CVODE Solver: Dense Jacobian (with Lapack)..." << std::endl;
/* Create dense SUNMatrix for use in linear solves */
A = SUNDenseMatrix(this->n_, this->n_);
if (check_flag((void *)A, std::string("SUNDenseMatrix"), 0)) exit(-1);
/* Create SUNLapackDense solver object for use by CVode */
LS = SUNLapackDense(ySundials_, A);
if (check_flag((void *)LS, std::string("SUNLapackDense"), 0)) exit(-1);
}
else
{
// std::cout << "CVODE Solver: Band Jacobian (with Lapack)..." << std::endl;
/* Create banded SUNMatrix for use in linear solves -- since this will be factored,
set the storage bandwidth to be the sum of upper and lower bandwidths */
A = SUNBandMatrix(this->n_, this->mUpper_, this->mLower_, (this->mUpper_ + this->mLower_));
if (check_flag((void *)A, std::string("SUNBandMatrix"), 0)) exit(-1);
/* Create banded SUNLapackBand solver object for use by CVode */
LS = SUNLapackBand(ySundials_, A);
if (check_flag((void *)LS, std::string("SUNLapackBand"), 0)) exit(-1);
}
}
/* Call CVDlsSetLinearSolver to attach the matrix and linear solver to CVode */
flag = CVDlsSetLinearSolver(cvode_mem_, LS, A);
if (check_flag(&flag, std::string("CVDlsSetLinearSolver"), 1)) exit(-1);
}
else
{
flag = CVodeReInit(cvode_mem_, this->x0_, y0Sundials_);
if (check_flag(&flag, std::string("CVodeReInit"), 1)) exit(-1);
}
AnalyzeUserOptions();
/* Solving */
this->tStart_ = this->GetClockTime();
flag = CVode(cvode_mem_, this->xend_, ySundials_, &this->x_, CV_NORMAL);
this->tEnd_ = this->GetClockTime();
this->x0_ = this->x_;
for(int i=0;i<this->n_;i++)
NV_Ith_S(y0Sundials_,i) = NV_Ith_S(ySundials_,i);
for(int i=0;i<this->n_;i++)
this->y_[i] = NV_Ith_S(ySundials_,i);
}
/*
** ========
** main MEX
** ========
*/
void mexFunction( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] )
{
/* variables */
double * return_status;
double * species_out;
double * observables_out;
double * parameters;
double * species_init;
double * timepoints;
size_t n_timepoints;
size_t i;
size_t j;
/* intermediate data vectors */
N_Vector expressions;
N_Vector observables;
N_Vector ratelaws;
/* array to hold pointers to data vectors */
N_Vector temp_data[3];
/* CVODE specific variables */
realtype reltol;
realtype abstol;
realtype time;
N_Vector species;
void * cvode_mem;
int flag;
/* check number of input/output arguments */
if (nlhs != 3)
{ mexErrMsgTxt("syntax: [err_flag, species_out, obsv_out] = network_mex( timepoints, species_init, params )"); }
if (nrhs != 3)
{ mexErrMsgTxt("syntax: [err_flag, species_out, obsv_out] = network_mex( timepoints, species_init, params )"); }
/* make sure timepoints has correct dimensions */
if ( (mxGetM(prhs[0]) < 2) || (mxGetN(prhs[0]) != 1) )
{ mexErrMsgTxt("TIMEPOINTS must be a column vector with 2 or more elements."); }
/* make sure species_init has correct dimensions */
if ( (mxGetM(prhs[1]) != 1) || (mxGetN(prhs[1]) != __N_SPECIES__) )
{ mexErrMsgTxt("SPECIES_INIT must be a row vector with 7 elements."); }
/* make sure params has correct dimensions */
if ( (mxGetM(prhs[2]) != 1) || (mxGetN(prhs[2]) != __N_PARAMETERS__) )
{ mexErrMsgTxt("PARAMS must be a column vector with 4 elements."); }
/* get pointers to input arrays */
timepoints = mxGetPr(prhs[0]);
species_init = mxGetPr(prhs[1]);
parameters = mxGetPr(prhs[2]);
/* get number of timepoints */
n_timepoints = mxGetM(prhs[0]);
/* Create an mxArray for output trajectories */
plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL );
plhs[1] = mxCreateDoubleMatrix(n_timepoints, __N_SPECIES__, mxREAL);
plhs[2] = mxCreateDoubleMatrix(n_timepoints, __N_OBSERVABLES__, mxREAL);
/* get pointers to output arrays */
return_status = mxGetPr(plhs[0]);
species_out = mxGetPr(plhs[1]);
observables_out = mxGetPr(plhs[2]);
/* initialize intermediate data vectors */
expressions = NULL;
expressions = N_VNew_Serial(__N_EXPRESSIONS__);
if (check_flag((void *)expressions, "N_VNew_Serial", 0))
{
return_status[0] = 1;
return;
}
observables = NULL;
observables = N_VNew_Serial(__N_OBSERVABLES__);
if (check_flag((void *)observables, "N_VNew_Serial", 0))
{
N_VDestroy_Serial(expressions);
return_status[0] = 1;
return;
}
ratelaws = NULL;
ratelaws = N_VNew_Serial(__N_RATELAWS__);
if (check_flag((void *)ratelaws, "N_VNew_Serial", 0))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
return_status[0] = 1;
return;
}
/* set up pointers to intermediate data vectors */
temp_data[0] = expressions;
temp_data[1] = observables;
temp_data[2] = ratelaws;
/* calculate expressions (expressions are constant, so only do this once!) */
calc_expressions( expressions, parameters );
/* SOLVE model equations! */
species = NULL;
cvode_mem = NULL;
/* Set the scalar relative tolerance */
reltol = 1e-06;
abstol = 1e-06;
/* Create serial vector for Species */
species = N_VNew_Serial(__N_SPECIES__);
if (check_flag((void *)species, "N_VNew_Serial", 0))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
return_status[0] = 1;
return;
}
for ( i = 0; i < __N_SPECIES__; i++ )
{ NV_Ith_S(species,i) = species_init[i]; }
/* write initial species populations into species_out */
for ( i = 0; i < __N_SPECIES__; i++ )
{ species_out[i*n_timepoints] = species_init[i]; }
/* write initial observables populations into species_out */
calc_observables( observables, species, expressions );
for ( i = 0; i < __N_OBSERVABLES__; i++ )
{ observables_out[i*n_timepoints] = NV_Ith_S(observables,i); }
/* Call CVodeCreate to create the solver memory:
* CV_ADAMS or CV_BDF is the linear multistep method
* CV_FUNCTIONAL or CV_NEWTON is the nonlinear solver 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))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* Call CVodeInit to initialize the integrator memory:
* cvode_mem is the pointer to the integrator memory returned by CVodeCreate
* rhs_func 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
*/
flag = CVodeInit(cvode_mem, calc_species_deriv, timepoints[0], species);
if (check_flag(&flag, "CVodeInit", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* Set scalar relative and absolute tolerances */
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSStolerances", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* pass params to rhs_func */
flag = CVodeSetUserData(cvode_mem, &temp_data);
if (check_flag(&flag, "CVodeSetFdata", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* select linear solver */
flag = CVDense(cvode_mem, __N_SPECIES__);
if (check_flag(&flag, "CVDense", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
flag = CVodeSetMaxNumSteps(cvode_mem, 2000);
if (check_flag(&flag, "CVodeSetMaxNumSteps", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
flag = CVodeSetMaxErrTestFails(cvode_mem, 7);
if (check_flag(&flag, "CVodeSetMaxErrTestFails", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
flag = CVodeSetMaxConvFails(cvode_mem, 10);
if (check_flag(&flag, "CVodeSetMaxConvFails", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
flag = CVodeSetMaxStep(cvode_mem, 0.0);
if (check_flag(&flag, "CVodeSetMaxStep", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* integrate to each timepoint */
for ( i=1; i < n_timepoints; i++ )
{
flag = CVode(cvode_mem, timepoints[i], species, &time, CV_NORMAL);
if (check_flag(&flag, "CVode", 1))
{
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
CVodeFree(&cvode_mem);
return_status[0] = 1;
return;
}
/* copy species output from nvector to matlab array */
for ( j = 0; j < __N_SPECIES__; j++ )
{ species_out[j*n_timepoints + i] = NV_Ith_S(species,j); }
/* copy observables output from nvector to matlab array */
calc_observables( observables, species, expressions );
for ( j = 0; j < __N_OBSERVABLES__; j++ )
{ observables_out[j*n_timepoints + i] = NV_Ith_S(observables,j); }
}
/* Free vectors */
N_VDestroy_Serial(expressions);
N_VDestroy_Serial(observables);
N_VDestroy_Serial(ratelaws);
N_VDestroy_Serial(species);
/* Free integrator memory */
CVodeFree(&cvode_mem);
return;
}
int cvode_init(solver_props *props){
assert(props->statesize > 0);
cvode_mem *mem = (cvode_mem*) malloc(props->num_models*sizeof(cvode_mem));
unsigned int modelid;
props->mem = mem;
for(modelid=0; modelid<props->num_models; modelid++){
// Set location to store the value of the next states
mem[modelid].next_states = &(props->next_states[modelid*props->statesize]);
mem[modelid].props = props;
// Set the modelid on a per memory structure basis
mem[modelid].modelid = modelid;
// Create intial value vector
// This is done to avoid having the change the internal indexing within the flows and for the output_buffer
mem[modelid].y0 = N_VMake_Serial(props->statesize, mem[modelid].next_states);
// Create data structure for solver
// mem[modelid].cvmem = CVodeCreate(CV_BDF, CV_NEWTON);
mem[modelid].cvmem = CVodeCreate(props->cvode.lmm, props->cvode.iter);
// Initialize CVODE
if(CVodeInit(mem[modelid].cvmem, user_fun_wrapper, props->starttime, mem[modelid].y0) != CV_SUCCESS){
PRINTF( "Couldn't initialize CVODE");
}
// Set CVODE error handler
if(CVodeSetErrHandlerFn(mem[modelid].cvmem, cvode_err_handler, mem)){
PRINTF( "Couldn't set CVODE error handler");
}
// Set solver tolerances
if(CVodeSStolerances(mem[modelid].cvmem, props->reltol, props->abstol) != CV_SUCCESS){
PRINTF( "Could not set CVODE tolerances");
}
// Set maximum order
if(CVodeSetMaxOrd(mem[modelid].cvmem, props->cvode.max_order) != CV_SUCCESS) {
PRINTF( "Could not set CVODE maximum order");
}
// Set linear solver
switch (props->cvode.solv) {
case CVODE_DENSE:
if(CVDense(mem[modelid].cvmem, mem[modelid].props->statesize) != CV_SUCCESS){
PRINTF( "Could not set CVODE DENSE linear solver");
}
break;
case CVODE_DIAG:
if(CVDiag(mem[modelid].cvmem) != CV_SUCCESS){
PRINTF( "Could not set CVODE DIAG linear solver");
}
break;
case CVODE_BAND:
if(CVBand(mem[modelid].cvmem, mem[modelid].props->statesize, mem[modelid].props->cvode.upperhalfbw, mem[modelid].props->cvode.lowerhalfbw) != CV_SUCCESS){
PRINTF( "Could not set CVODE BAND linear solver");
}
break;
default:
PRINTF( "No valid CVODE solver passed");
}
// Set user data to contain pointer to memory structure for use in model_flows
if(CVodeSetUserData(mem[modelid].cvmem, &mem[modelid]) != CV_SUCCESS){
PRINTF( "CVODE failed to initialize user data");
}
}
return 0;
}
int Solver::init(rhsfunc f, int argc, char **argv, bool restarting, int nout, real tstep)
{
#ifdef CHECK
int msg_point = msg_stack.push("Initialising CVODE solver");
#endif
/// Call the generic initialisation first
if(GenericSolver::init(f, argc, argv, restarting, nout, tstep))
return 1;
// Save nout and tstep for use in run
NOUT = nout;
TIMESTEP = tstep;
output.write("Initialising SUNDIALS' CVODE solver\n");
// Set the rhs solver function
func = f;
// Calculate number of variables (in generic_solver)
int local_N = getLocalN();
// Get total problem size
int neq;
if(MPI_Allreduce(&local_N, &neq, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD)) {
output.write("\tERROR: MPI_Allreduce failed!\n");
return 1;
}
output.write("\t3d fields = %d, 2d fields = %d neq=%d, local_N=%d\n",
n3Dvars(), n2Dvars(), neq, local_N);
// Allocate memory
if((uvec = N_VNew_Parallel(MPI_COMM_WORLD, local_N, neq)) == NULL)
bout_error("ERROR: SUNDIALS memory allocation failed\n");
// Put the variables into uvec
if(save_vars(NV_DATA_P(uvec)))
bout_error("\tERROR: Initial variable value not set\n");
/// Get options
real abstol, reltol;
int maxl;
int mudq, mldq;
int mukeep, mlkeep;
bool use_precon, use_jacobian;
real max_timestep;
bool adams_moulton, func_iter; // Time-integration method
options.setSection("solver");
options.get("mudq", mudq, n3Dvars()*(MXSUB+2));
options.get("mldq", mldq, n3Dvars()*(MXSUB+2));
options.get("mukeep", mukeep, n3Dvars()+n2Dvars());
options.get("mlkeep", mlkeep, n3Dvars()+n2Dvars());
options.get("ATOL", abstol, 1.0e-12);
options.get("RTOL", reltol, 1.0e-5);
options.get("maxl", maxl, 5);
options.get("use_precon", use_precon, false);
options.get("use_jacobian", use_jacobian, false);
options.get("max_timestep", max_timestep, -1.);
int mxsteps; // Maximum number of steps to take between outputs
options.get("pvode_mxstep", mxsteps, 500);
options.get("adams_moulton", adams_moulton, false);
int lmm = CV_BDF;
if(adams_moulton) {
// By default use functional iteration for Adams-Moulton
lmm = CV_ADAMS;
output.write("\tUsing Adams-Moulton implicit multistep method\n");
options.get("func_iter", func_iter, true);
}else {
output.write("\tUsing BDF method\n");
// Use Newton iteration for BDF
options.get("func_iter", func_iter, false);
}
int iter = CV_NEWTON;
if(func_iter)
iter = CV_FUNCTIONAL;
// Call CVodeCreate
if((cvode_mem = CVodeCreate(lmm, iter)) == NULL)
bout_error("ERROR: CVodeCreate failed\n");
if( CVodeSetUserData(cvode_mem, this) < 0 ) // For callbacks, need pointer to solver object
bout_error("ERROR: CVodeSetUserData failed\n");
if( CVodeInit(cvode_mem, cvode_rhs, simtime, uvec) < 0 )
bout_error("ERROR: CVodeInit failed\n");
if( CVodeSStolerances(cvode_mem, reltol, abstol) < 0 )
bout_error("ERROR: CVodeSStolerances failed\n");
CVodeSetMaxNumSteps(cvode_mem, mxsteps);
if(max_timestep > 0.0) {
// Setting a maximum timestep
CVodeSetMaxStep(cvode_mem, max_timestep);
}
/// Newton method can include Preconditioners and Jacobian function
if(!func_iter) {
output.write("\tUsing Newton iteration\n");
/// Set Preconditioner
if(use_precon) {
if( CVSpgmr(cvode_mem, PREC_LEFT, maxl) != CVSPILS_SUCCESS )
bout_error("ERROR: CVSpgmr failed\n");
if(prefunc == NULL) {
output.write("\tUsing BBD preconditioner\n");
if( CVBBDPrecInit(cvode_mem, local_N, mudq, mldq,
mukeep, mlkeep, ZERO, cvode_bbd_rhs, NULL) )
bout_error("ERROR: CVBBDPrecInit failed\n");
}else {
output.write("\tUsing user-supplied preconditioner\n");
if( CVSpilsSetPreconditioner(cvode_mem, NULL, cvode_pre) )
bout_error("ERROR: CVSpilsSetPreconditioner failed\n");
}
}else {
// Not using preconditioning
output.write("\tNo preconditioning\n");
if( CVSpgmr(cvode_mem, PREC_NONE, maxl) != CVSPILS_SUCCESS )
bout_error("ERROR: CVSpgmr failed\n");
}
/// Set Jacobian-vector multiplication function
if((use_jacobian) && (jacfunc != NULL)) {
output.write("\tUsing user-supplied Jacobian function\n");
if( CVSpilsSetJacTimesVecFn(cvode_mem, cvode_jac) != CVSPILS_SUCCESS )
bout_error("ERROR: CVSpilsSetJacTimesVecFn failed\n");
}else
output.write("\tUsing difference quotient approximation for Jacobian\n");
}else {
output.write("\tUsing Functional iteration\n");
}
#ifdef CHECK
msg_stack.pop(msg_point);
#endif
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, retval, my_pe, npes;
sunindextype local_N, nperpe, nrem, my_base;
long int 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_retval((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_retval((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 */
cvode_mem = CVodeCreate(CV_ADAMS);
if(check_retval((void *)cvode_mem, "CVodeCreate", 0, my_pe)) MPI_Abort(comm, 1);
retval = CVodeSetUserData(cvode_mem, data);
if(check_retval(&retval, "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. */
retval = CVodeInit(cvode_mem, f, T0, u);
if(check_retval(&retval, "CVodeInit", 1, my_pe)) 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, my_pe)) return(1);
/* Call CVDiag to create and attach CVODE-specific diagonal linear solver */
retval = CVDiag(cvode_mem);
if(check_retval(&retval, "CVDiag", 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) {
retval = CVode(cvode_mem, tout, u, &t, CV_NORMAL);
if(check_retval(&retval, "CVode", 1, my_pe)) break;
umax = N_VMaxNorm(u);
retval = CVodeGetNumSteps(cvode_mem, &nst);
check_retval(&retval, "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;
realtype abstol, reltol, t, tout;
N_Vector u;
int iout, my_pe, npes, flag, jpre;
long int neq, local_N, mudq, mldq, mukeep, mlkeep;
MPI_Comm comm;
data = NULL;
cvode_mem = NULL;
u = NULL;
/* Set problem size neq */
neq = NVARS*MX*MY;
/* Get processor number and total number of pe's */
MPI_Init(&argc, &argv);
comm = MPI_COMM_WORLD;
MPI_Comm_size(comm, &npes);
MPI_Comm_rank(comm, &my_pe);
if (npes != NPEX*NPEY) {
if (my_pe == 0)
fprintf(stderr, "\nMPI_ERROR(0): npes = %d is not equal to NPEX*NPEY = %d\n\n",
npes, NPEX*NPEY);
MPI_Finalize();
return(1);
}
/* Set local length */
local_N = NVARS*MXSUB*MYSUB;
/* Allocate and load user data block */
data = (UserData) malloc(sizeof *data);
if(check_flag((void *)data, "malloc", 2, my_pe)) MPI_Abort(comm, 1);
InitUserData(my_pe, local_N, comm, data);
/* Allocate and initialize u, and set tolerances */
u = N_VNew_Parallel(comm, local_N, neq);
if(check_flag((void *)u, "N_VNew_Parallel", 0, my_pe)) MPI_Abort(comm, 1);
SetInitialProfiles(u, data);
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, my_pe)) MPI_Abort(comm, 1);
/* Set the pointer to user-defined data */
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);
/* Call CVSpgmr to specify the linear solver CVSPGMR with left
preconditioning and the default maximum Krylov dimension maxl */
flag = CVSpgmr(cvode_mem, PREC_LEFT, 0);
if(check_flag(&flag, "CVBBDSpgmr", 1, my_pe)) MPI_Abort(comm, 1);
/* Initialize BBD preconditioner */
mudq = mldq = NVARS*MXSUB;
mukeep = mlkeep = NVARS;
flag = CVBBDPrecInit(cvode_mem, local_N, mudq, mldq,
mukeep, mlkeep, ZERO, flocal, NULL);
if(check_flag(&flag, "CVBBDPrecAlloc", 1, my_pe)) MPI_Abort(comm, 1);
/* Print heading */
if (my_pe == 0) PrintIntro(npes, mudq, mldq, mukeep, mlkeep);
/* 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 integrator, CVBBDPRE, and CVSPGMR */
if (jpre == PREC_RIGHT) {
SetInitialProfiles(u, data);
flag = CVodeReInit(cvode_mem, T0, u);
if(check_flag(&flag, "CVodeReInit", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVBBDPrecReInit(cvode_mem, mudq, mldq, ZERO);
if(check_flag(&flag, "CVBBDPrecReInit", 1, my_pe)) MPI_Abort(comm, 1);
flag = CVSpilsSetPrecType(cvode_mem, PREC_RIGHT);
check_flag(&flag, "CVSpilsSetPrecType", 1, my_pe);
if (my_pe == 0) {
printf("\n\n-------------------------------------------------------");
printf("------------\n");
}
}
if (my_pe == 0) {
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);
if(check_flag(&flag, "CVode", 1, my_pe)) break;
PrintOutput(cvode_mem, my_pe, comm, u, t);
}
/* Print final statistics */
if (my_pe == 0) PrintFinalStats(cvode_mem);
} /* End of jpre loop */
/* Free memory */
N_VDestroy_Parallel(u);
free(data);
CVodeFree(&cvode_mem);
MPI_Finalize();
return(0);
}
int main(int argc, char *argv[])
{
UserData data;
void *cvode_mem;
SUNMatrix A, AB;
SUNLinearSolver LS, LSB;
realtype dx, dy, reltol, abstol, t;
N_Vector u;
int indexB;
realtype reltolB, abstolB;
N_Vector uB;
int retval, ncheck;
data = NULL;
cvode_mem = NULL;
u = uB = NULL;
LS = LSB = NULL;
A = AB = NULL;
/* Allocate and initialize user data memory */
data = (UserData) malloc(sizeof *data);
if(check_retval((void *)data, "malloc", 2)) return(1);
dx = data->dx = XMAX/(MX+1);
dy = data->dy = YMAX/(MY+1);
data->hdcoef = ONE/(dx*dx);
data->hacoef = RCONST(1.5)/(TWO*dx);
data->vdcoef = ONE/(dy*dy);
/* Set the tolerances for the forward integration */
reltol = ZERO;
abstol = ATOL;
/* Allocate u vector */
u = N_VNew_Serial(NEQ);
if(check_retval((void *)u, "N_VNew", 0)) return(1);
/* Initialize u vector */
SetIC(u, data);
/* Create and allocate CVODES memory for forward run */
printf("\nCreate and allocate CVODES memory for forward runs\n");
cvode_mem = CVodeCreate(CV_BDF);
if(check_retval((void *)cvode_mem, "CVodeCreate", 0)) return(1);
retval = CVodeSetUserData(cvode_mem, data);
if(check_retval(&retval, "CVodeSetUserData", 1)) return(1);
retval = CVodeInit(cvode_mem, f, T0, u);
if(check_retval(&retval, "CVodeInit", 1)) return(1);
retval = CVodeSStolerances(cvode_mem, reltol, abstol);
if(check_retval(&retval, "CVodeSStolerances", 1)) return(1);
/* Create banded SUNMatrix for the forward problem */
A = SUNBandMatrix(NEQ, MY, MY);
if(check_retval((void *)A, "SUNBandMatrix", 0)) return(1);
/* Create banded SUNLinearSolver for the forward problem */
LS = SUNLinSol_Band(u, A);
if(check_retval((void *)LS, "SUNLinSol_Band", 0)) return(1);
/* Attach the matrix and linear solver */
retval = CVodeSetLinearSolver(cvode_mem, LS, A);
if(check_retval(&retval, "CVodeSetLinearSolver", 1)) return(1);
/* Set the user-supplied Jacobian routine for the forward problem */
retval = CVodeSetJacFn(cvode_mem, Jac);
if(check_retval(&retval, "CVodeSetJacFn", 1)) return(1);
/* Allocate global memory */
printf("\nAllocate global memory\n");
retval = CVodeAdjInit(cvode_mem, NSTEP, CV_HERMITE);
if(check_retval(&retval, "CVodeAdjInit", 1)) return(1);
/* Perform forward run */
printf("\nForward integration\n");
retval = CVodeF(cvode_mem, TOUT, u, &t, CV_NORMAL, &ncheck);
if(check_retval(&retval, "CVodeF", 1)) return(1);
printf("\nncheck = %d\n", ncheck);
/* Set the tolerances for the backward integration */
reltolB = RTOLB;
abstolB = ATOL;
/* Allocate uB */
uB = N_VNew_Serial(NEQ);
if(check_retval((void *)uB, "N_VNew", 0)) return(1);
/* Initialize uB = 0 */
N_VConst(ZERO, uB);
/* Create and allocate CVODES memory for backward run */
printf("\nCreate and allocate CVODES memory for backward run\n");
retval = CVodeCreateB(cvode_mem, CV_BDF, &indexB);
if(check_retval(&retval, "CVodeCreateB", 1)) return(1);
retval = CVodeSetUserDataB(cvode_mem, indexB, data);
if(check_retval(&retval, "CVodeSetUserDataB", 1)) return(1);
retval = CVodeInitB(cvode_mem, indexB, fB, TOUT, uB);
if(check_retval(&retval, "CVodeInitB", 1)) return(1);
retval = CVodeSStolerancesB(cvode_mem, indexB, reltolB, abstolB);
if(check_retval(&retval, "CVodeSStolerancesB", 1)) return(1);
/* Create banded SUNMatrix for the backward problem */
AB = SUNBandMatrix(NEQ, MY, MY);
if(check_retval((void *)AB, "SUNBandMatrix", 0)) return(1);
/* Create banded SUNLinearSolver for the backward problem */
LSB = SUNLinSol_Band(uB, AB);
if(check_retval((void *)LSB, "SUNLinSol_Band", 0)) return(1);
/* Attach the matrix and linear solver */
retval = CVodeSetLinearSolverB(cvode_mem, indexB, LSB, AB);
if(check_retval(&retval, "CVodeSetLinearSolverB", 1)) return(1);
/* Set the user-supplied Jacobian routine for the backward problem */
retval = CVodeSetJacFnB(cvode_mem, indexB, JacB);
if(check_retval(&retval, "CVodeSetJacFnB", 1)) return(1);
/* Perform backward integration */
printf("\nBackward integration\n");
retval = CVodeB(cvode_mem, T0, CV_NORMAL);
if(check_retval(&retval, "CVodeB", 1)) return(1);
retval = CVodeGetB(cvode_mem, indexB, &t, uB);
if(check_retval(&retval, "CVodeGetB", 1)) return(1);
PrintOutput(uB, data);
N_VDestroy(u); /* Free the u vector */
N_VDestroy(uB); /* Free the uB vector */
CVodeFree(&cvode_mem); /* Free the CVODE problem memory */
SUNLinSolFree(LS); /* Free the forward linear solver memory */
SUNMatDestroy(A); /* Free the forward matrix memory */
SUNLinSolFree(LSB); /* Free the backward linear solver memory */
SUNMatDestroy(AB); /* Free the backward matrix memory */
free(data); /* Free the user data */
return(0);
}
void CVodesIntegrator::initialize(double t0, FuncEval& func)
{
m_neq = func.neq();
m_t0 = t0;
if (m_y) {
N_VDestroy_Serial(nv(m_y)); // free solution vector if already allocated
}
m_y = reinterpret_cast<void*>(N_VNew_Serial(m_neq)); // allocate solution vector
for (int i=0; i<m_neq; i++) {
NV_Ith_S(nv(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(nv(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 = 0;
#if defined(SUNDIALS_VERSION_22) || defined(SUNDIALS_VERSION_23)
if (m_itol == CV_SV) {
// vector atol
flag = CVodeMalloc(m_cvode_mem, cvodes_rhs, m_t0, nv(m_y), m_itol,
m_reltol, nv(m_abstol));
}
else {
// scalar atol
flag = CVodeMalloc(m_cvode_mem, cvodes_rhs, m_t0, nv(m_y), m_itol,
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 CVodeMalloc input argument.");
}
else
throw CVodesErr("CVodeMalloc failed.");
}
#elif defined(SUNDIALS_VERSION_24)
flag = CVodeInit(m_cvode_mem, cvodes_rhs, m_t0, nv(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.");
}
}
if (m_itol == CV_SV) {
flag = CVodeSVtolerances(m_cvode_mem, m_reltol, nv(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.");
}
}
#else
printf("unknown sundials verson\n");
exit(-1);
#endif
if (m_type == DENSE + NOJAC) {
long int N = m_neq;
CVDense(m_cvode_mem, N);
}
else if (m_type == DIAG) {
CVDiag(m_cvode_mem);
}
else if (m_type == GMRES) {
CVSpgmr(m_cvode_mem, PREC_NONE, 0);
}
else if (m_type == BAND + NOJAC) {
long int N = m_neq;
long int nu = m_mupper;
long int nl = m_mlower;
CVBand(m_cvode_mem, N, nu, nl);
}
else {
throw CVodesErr("unsupported option");
}
// pass a pointer to func in m_data
m_fdata = new FuncData(&func, func.nparams());
//m_data = (void*)&func;
#if defined(SUNDIALS_VERSION_22) || defined(SUNDIALS_VERSION_23)
flag = CVodeSetFdata(m_cvode_mem, (void*)m_fdata);
if (flag != CV_SUCCESS) {
throw CVodesErr("CVodeSetFdata failed.");
}
#elif defined(SUNDIALS_VERSION_24)
flag = CVodeSetUserData(m_cvode_mem, (void*)m_fdata);
if (flag != CV_SUCCESS) {
throw CVodesErr("CVodeSetUserData failed.");
}
#endif
if (func.nparams() > 0) {
sensInit(t0, func);
flag = CVodeSetSensParams(m_cvode_mem, DATA_PTR(m_fdata->m_pars),
NULL, NULL);
}
// set options
if (m_maxord > 0)
flag = CVodeSetMaxOrd(m_cvode_mem, m_maxord);
if (m_maxsteps > 0)
flag = CVodeSetMaxNumSteps(m_cvode_mem, m_maxsteps);
if (m_hmax > 0)
flag = CVodeSetMaxStep(m_cvode_mem, m_hmax);
}
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 CVLapackBand to specify the CVBAND band linear solver */
flag = CVLapackBand(cvode_mem, NEQ, MY, MY);
if(check_flag(&flag, "CVLapackBand", 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);
}
PetscErrorCode TSSetUp_Sundials_Nonlinear(TS ts)
{
TS_Sundials *cvode = (TS_Sundials*)ts->data;
PetscErrorCode ierr;
PetscInt glosize,locsize,i,flag;
PetscScalar *y_data,*parray;
void *mem;
const PCType pctype;
PetscTruth pcnone;
Vec sol = ts->vec_sol;
PetscFunctionBegin;
ierr = PCSetFromOptions(cvode->pc);CHKERRQ(ierr);
/* get the vector size */
ierr = VecGetSize(ts->vec_sol,&glosize);CHKERRQ(ierr);
ierr = VecGetLocalSize(ts->vec_sol,&locsize);CHKERRQ(ierr);
/* allocate the memory for N_Vec y */
cvode->y = N_VNew_Parallel(cvode->comm_sundials,locsize,glosize);
if (!cvode->y) SETERRQ(1,"cvode->y is not allocated");
/* initialize N_Vec y: copy ts->vec_sol to cvode->y */
ierr = VecGetArray(ts->vec_sol,&parray);CHKERRQ(ierr);
y_data = (PetscScalar *) N_VGetArrayPointer(cvode->y);
for (i = 0; i < locsize; i++) y_data[i] = parray[i];
/*ierr = PetscMemcpy(y_data,parray,locsize*sizeof(PETSC_SCALAR)); CHKERRQ(ierr);*/
ierr = VecRestoreArray(ts->vec_sol,PETSC_NULL);CHKERRQ(ierr);
ierr = VecDuplicate(ts->vec_sol,&cvode->update);CHKERRQ(ierr);
ierr = VecDuplicate(ts->vec_sol,&cvode->func);CHKERRQ(ierr);
ierr = PetscLogObjectParent(ts,cvode->update);CHKERRQ(ierr);
ierr = PetscLogObjectParent(ts,cvode->func);CHKERRQ(ierr);
/*
Create work vectors for the TSPSolve_Sundials() routine. Note these are
allocated with zero space arrays because the actual array space is provided
by Sundials and set using VecPlaceArray().
*/
ierr = VecCreateMPIWithArray(((PetscObject)ts)->comm,locsize,PETSC_DECIDE,0,&cvode->w1);CHKERRQ(ierr);
ierr = VecCreateMPIWithArray(((PetscObject)ts)->comm,locsize,PETSC_DECIDE,0,&cvode->w2);CHKERRQ(ierr);
ierr = PetscLogObjectParent(ts,cvode->w1);CHKERRQ(ierr);
ierr = PetscLogObjectParent(ts,cvode->w2);CHKERRQ(ierr);
/* Call CVodeCreate to create the solver memory and the use of a Newton iteration */
mem = CVodeCreate(cvode->cvode_type, CV_NEWTON);
if (!mem) SETERRQ(PETSC_ERR_MEM,"CVodeCreate() fails");
cvode->mem = mem;
/* Set the pointer to user-defined data */
flag = CVodeSetUserData(mem, ts);
if (flag) SETERRQ(PETSC_ERR_LIB,"CVodeSetUserData() fails");
/* 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 cvode->y */
flag = CVodeInit(mem,TSFunction_Sundials,ts->ptime,cvode->y);
if (flag){
SETERRQ1(PETSC_ERR_LIB,"CVodeInit() fails, flag %d",flag);
}
flag = CVodeSStolerances(mem,cvode->reltol,cvode->abstol);
if (flag){
SETERRQ1(PETSC_ERR_LIB,"CVodeSStolerances() fails, flag %d",flag);
}
/* initialize the number of steps */
ierr = TSMonitor(ts,ts->steps,ts->ptime,sol);CHKERRQ(ierr);
/* call CVSpgmr to use GMRES as the linear solver. */
/* setup the ode integrator with the given preconditioner */
ierr = PCGetType(cvode->pc,&pctype);CHKERRQ(ierr);
ierr = PetscTypeCompare((PetscObject)cvode->pc,PCNONE,&pcnone);CHKERRQ(ierr);
if (pcnone){
flag = CVSpgmr(mem,PREC_NONE,0);
if (flag) SETERRQ1(PETSC_ERR_LIB,"CVSpgmr() fails, flag %d",flag);
} else {
flag = CVSpgmr(mem,PREC_LEFT,0);
if (flag) SETERRQ1(PETSC_ERR_LIB,"CVSpgmr() fails, flag %d",flag);
/* Set preconditioner and solve routines Precond and PSolve,
and the pointer to the user-defined block data */
flag = CVSpilsSetPreconditioner(mem,TSPrecond_Sundials,TSPSolve_Sundials);
if (flag) SETERRQ1(PETSC_ERR_LIB,"CVSpilsSetPreconditioner() fails, flag %d", flag);
}
flag = CVSpilsSetGSType(mem, MODIFIED_GS);
if (flag) SETERRQ1(PETSC_ERR_LIB,"CVSpgmrSetGSType() fails, flag %d",flag);
PetscFunctionReturn(0);
}
/*
* Functions to use CVODES
*
*/
struct Integrator* CreateIntegrator(struct Simulation* sim,
class ExecutableModel* em)
{
if (!(sim && em))
{
ERROR("CreateIntegrator","Invalid arguments when creating integrator");
return((struct Integrator*)NULL);
}
int flag,mlmm,miter;
struct Integrator* integrator =
(struct Integrator*)malloc(sizeof(struct Integrator));
integrator->y = NULL;
integrator->cvode_mem = NULL;
integrator->simulation = simulationClone(sim);
// FIXME: really need to handle this properly, but for now simply grabbing a handle.
integrator->em = em;
/* Check for errors in the simulation */
if (simulationGetATolLength(integrator->simulation) < 1)
{
ERROR("CreateIntegrator","Absolute tolerance(s) not set\n");
DestroyIntegrator(&integrator);
return(NULL);
}
/* Would be good if we didn't require the specification of the
tabulation step size, but for now it is required so we should
check that it has a sensible value */
if (!simulationIsBvarTabStepSet(integrator->simulation))
{
ERROR("CreateIntegrator","Tabulation step size must be set\n");
DestroyIntegrator(&integrator);
return(NULL);
}
/* start and end also needs to be set */
if (!simulationIsBvarStartSet(integrator->simulation))
{
ERROR("CreateIntegrator","Bound variable interval start must be set\n");
DestroyIntegrator(&integrator);
return(NULL);
}
if (!simulationIsBvarEndSet(integrator->simulation))
{
ERROR("CreateIntegrator","Bound variable interval end must be set\n");
DestroyIntegrator(&integrator);
return(NULL);
}
/* Create serial vector of length NR for I.C. */
integrator->y = N_VNew_Serial(em->nRates);
if (check_flag((void *)(integrator->y),"N_VNew_Serial",0))
{
DestroyIntegrator(&integrator);
return(NULL);
}
/* Initialize y */
realtype* yD = NV_DATA_S(integrator->y);
int i;
for (i=0;i<(em->nRates);i++) yD[i] = (realtype)(em->states[i]);
/* adjust parameters accordingly */
switch (simulationGetMultistepMethod(integrator->simulation))
{
case ADAMS:
{
mlmm = CV_ADAMS;
break;
}
case BDF:
{
mlmm = CV_BDF;
break;
}
default:
{
ERROR("CreateIntegrator","Invalid multistep method choice\n");
DestroyIntegrator(&integrator);
return(NULL);
}
}
switch (simulationGetIterationMethod(integrator->simulation))
{
case FUNCTIONAL:
{
miter = CV_FUNCTIONAL;
break;
}
case NEWTON:
{
miter = CV_NEWTON;
break;
}
default:
{
ERROR("CreateIntegrator","Invalid iteration method choice\n");
DestroyIntegrator(&integrator);
return(NULL);
}
}
/*
Call CVodeCreate to create the solver memory:
A pointer to the integrator problem memory is returned and
stored in cvode_mem.
*/
integrator->cvode_mem = CVodeCreate(mlmm,miter);
if (check_flag((void *)(integrator->cvode_mem),"CVodeCreate",0))
{
DestroyIntegrator(&integrator);
return(NULL);
}
/*
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)
tStart is the initial time
y is the initial dependent variable vector
CV_SS specifies scalar relative and absolute tolerances
reltol the scalar relative tolerance
&abstol is the absolute tolerance vector
*/
flag = CVodeInit(integrator->cvode_mem,f,
simulationGetBvarStart(integrator->simulation),integrator->y);
if (check_flag(&flag,"CVodeMalloc",1))
{
DestroyIntegrator(&integrator);
return(NULL);
}
double* atol = simulationGetATol(integrator->simulation);
if (simulationGetATolLength(integrator->simulation) == 1)
{
flag = CVodeSStolerances(integrator->cvode_mem,simulationGetRTol(integrator->simulation),atol[0]);
if (check_flag(&flag,"CVodeSStolerances",1))
{
DestroyIntegrator(&integrator);
return(NULL);
}
}
else
{
ERROR("CreateIntegrator", "array abstol not supported yet.");
DestroyIntegrator(&integrator);
return(NULL);
}
free(atol);
/* if using Newton iteration need a linear solver */
if (simulationGetIterationMethod(integrator->simulation) == NEWTON)
{
switch (simulationGetLinearSolver(integrator->simulation))
{
case DENSE:
{
/* Call CVDense to specify the CVDENSE dense linear solver */
flag = CVDense(integrator->cvode_mem,em->nRates);
if (check_flag(&flag,"CVDense",1))
{
DestroyIntegrator(&integrator);
return(NULL);
}
} break;
case BAND:
{
/* Call CVBand to specify the CVBAND linear solver */
long int upperBW = em->nRates - 1; /* FIXME: This probably doesn't make */
long int lowerBW = em->nRates - 1; /* any sense, but should do until I */
/* fix it */
flag = CVBand(integrator->cvode_mem,em->nRates,upperBW,lowerBW);
if (check_flag(&flag,"CVBand",1))
{
DestroyIntegrator(&integrator);
return(NULL);
}
} break;
case DIAG:
{
/* Call CVDiag to specify the CVDIAG linear solver */
flag = CVDiag(integrator->cvode_mem);
if (check_flag(&flag,"CVDiag",1))
{
DestroyIntegrator(&integrator);
return(NULL);
}
} break;
case SPGMR:
{
/* Call CVSpgmr to specify the linear solver CVSPGMR
with no preconditioning and the maximum Krylov dimension maxl */
flag = CVSpgmr(integrator->cvode_mem,PREC_NONE,0);
if(check_flag(&flag,"CVSpgmr",1))
{
DestroyIntegrator(&integrator);
return(NULL);
}
} break;
case SPBCG:
{
/* Call CVSpbcg to specify the linear solver CVSPBCG
with no preconditioning and the maximum Krylov dimension maxl */
flag = CVSpbcg(integrator->cvode_mem,PREC_NONE,0);
if(check_flag(&flag,"CVSpbcg",1))
{
DestroyIntegrator(&integrator);
return(NULL);
}
} break;
case SPTFQMR:
{
/* Call CVSptfqmr to specify the linear solver CVSPTFQMR
with no preconditioning and the maximum Krylov dimension maxl */
flag = CVSptfqmr(integrator->cvode_mem,PREC_NONE,0);
if(check_flag(&flag,"CVSptfqmr",1))
{
DestroyIntegrator(&integrator);
return(NULL);
}
} break;
default:
{
ERROR("CreateIntegrator",
"Must specify a valid linear solver when using "
"Newton iteration\n");
DestroyIntegrator(&integrator);
return(NULL);
}
}
}
/* Pass through the executable model to f */
// FIXME: really need to handle this properly, but for now simply grabbing a handle.
flag = CVodeSetUserData(integrator->cvode_mem,(void*)(em));
if (check_flag(&flag,"CVodeSetUserData",1))
{
DestroyIntegrator(&integrator);
return(NULL);
}
/* Set the maximum time step size if it looks valid */
double mxD = simulationGetBvarMaxStep(integrator->simulation);
double tbD = simulationGetBvarTabStep(integrator->simulation);
double maxStep;
if (simulationIsBvarMaxStepSet(integrator->simulation))
{
flag = CVodeSetMaxStep(integrator->cvode_mem,
(realtype)mxD);
maxStep = mxD;
if (check_flag(&flag,"CVodeSetMaxStep (max)",1))
{
DestroyIntegrator(&integrator);
return(NULL);
}
}
else
{
flag = CVodeSetMaxStep(integrator->cvode_mem,
(realtype)tbD);
maxStep = tbD;
if (check_flag(&flag,"CVodeSetMaxStep (tab)",1))
{
DestroyIntegrator(&integrator);
return(NULL);
}
}
simulationSetBvarMaxStep(integrator->simulation,maxStep);
simulationSetBvarMaxStep(sim,maxStep);
/* try and make a sensible guess at the maximal number of steps to
get to tout to take into account case where we simply want to
integrate over a large time period in small steps (why?) */
double tout = simulationGetBvarStart(integrator->simulation)+
simulationGetBvarTabStep(integrator->simulation);
if (simulationIsBvarEndSet(integrator->simulation))
{
double end = simulationGetBvarEnd(integrator->simulation);
if (tout > end) tout = end;
}
long int maxsteps = (long int)ceil(tout/maxStep) * 100;
if (maxsteps < 500) maxsteps = 500; /* default value */
flag = CVodeSetMaxNumSteps(integrator->cvode_mem,maxsteps);
if (check_flag(&flag,"CVodeSetMaxNumSteps",1))
{
DestroyIntegrator(&integrator);
return(NULL);
}
return(integrator);
}
static int simulate_nmr_pulse(struct bloch_sim *bs)
{
N_Vector M = NULL;
M = N_VNew_Serial(3 * bs->num_cells);
if (check_flag((void *)M, "N_VNew_Serial", 0)) return(1);
int i;
/* Set initial (t=0) magnetization conditions */
for(i=0; i < bs->num_cells; ++i)
{
X(M,i) = 0.0;
Y(M,i) = 0.0;
Z(M,i) = bs->cell_frequencies[i] / bs->w_avg;
}
realtype reltol = RCONST(1.0e-14);
realtype abstol = RCONST(1.0e-14);
void *cvode_mem = CVodeCreate(CV_ADAMS, CV_FUNCTIONAL);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
int flag;
//TODO: check if flag should be pointer;
flag = CVodeInit(cvode_mem, bloch_equations, 0.0, M);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
flag = CVodeSetUserData(cvode_mem, bs);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
flag = CVDense(cvode_mem, 3 * bs->num_cells);
if (check_flag(&flag, "CVDense", 1)) return(1);
flag = CVDlsSetDenseJacFn(cvode_mem, bloch_jacobian);
if (check_flag(&flag, "CVDlsSetDenseJacFn", 1)) return(1);
///////////////////////////
// PI/2 PULSE SIMULATION //
///////////////////////////
bs->rf_on = 1;
flag = CVodeSetStopTime(cvode_mem, bs->pi2_duration);
if (check_flag(&flag, "CVodeSetStopTime", 1)) return 1;
realtype time_reached;
flag = CVode(cvode_mem, bs->pi2_duration, M, &time_reached, CV_NORMAL);
if (flag != CV_SUCCESS)
{
printf("ERROR: Failed to simulate Pi/2 pulse\n");
}
// {{{ PI2 PULSE DEBUG STATEMENTS
if (DEBUG)
{
printf("\n");
printf("#####################################\n");
printf("### PI/2 PULSE SIMULATION DETAILS ###\n");
printf("#####################################\n");
printf("\n");
printf("TIME REACHED: %.15e\n", time_reached);
printf("TIME REACHED - PI2_DURATION: %.15e\n", time_reached - bs->pi2_duration);
printf("\n");
printf("MAGNETIZATION AT END OF PI/2 PULSE:\n");
for (i = 0; i<bs->num_cells; ++i)
{
printf("CELL %d: %.4e, %.4e, %.4e\n", i, X(M,i), Y(M,i), Z(M,i));
}
}
// }}}
////////////////////
// FID SIMULATION //
////////////////////
bs->rf_on = 0;
if (DEBUG)
{
printf("##############################\n");
printf("### FID SIMULATION DETAILS ###\n");
printf("##############################\n");
}
flag = CVodeReInit(cvode_mem, 0.0, M);
if (check_flag(&flag, "CVodeReInit", 1)) return(1);
time_reached = 0.0;
flag = CVodeSetStopTime(cvode_mem, bs->fid_duration);
if (check_flag(&flag, "CVodeSetStopTime", 1)) return 1;
flag = CVodeRootInit(cvode_mem, 1, bloch_root);
if (check_flag(&flag, "CVodeRootInit", 1)) return 1;
realtype time_desired, M_FID_X;
while (time_reached < bs->fid_duration)
{
time_desired = time_reached + bs->fid_sampling_interval;
flag = CVode(cvode_mem, time_desired, M, &time_reached, CV_NORMAL);
if (flag == CV_ROOT_RETURN)
{
bs->zero_crossings[bs->num_zero_crossings] = time_reached;
M_FID_X = 0.0;
for (i=0; i < bs->num_cells; i++)
{
M_FID_X += X(M,i) * cos(bs->w_avg * time_reached);
M_FID_X += Y(M,i) * sin(bs->w_avg * time_reached);
}
bs->envelope[bs->num_zero_crossings] = M_FID_X / bs->num_cells;
bs->num_zero_crossings++;
}
}
bs->zero_crossings = (realtype*) realloc(bs->zero_crossings, sizeof(realtype) * bs->num_zero_crossings);
bs->envelope = (realtype*) realloc(bs->envelope, sizeof(realtype) * bs->num_zero_crossings);
if (!bs->zero_crossings || !bs->envelope) {
printf("ERROR: reallocating zero crossing and/or envelope array memory failed!\n");
exit(1);
}
N_VDestroy_Serial(M);
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 CVodeInit 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 = CVodeSetUserData(cvode_mem, wdata);
if(check_flag(&flag, "CVodeSetUserData", 1)) return(1);
flag = CVodeInit(cvode_mem, f, T0, c);
if(check_flag(&flag, "CVodeInit", 1)) return(1);
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSStolerances", 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 = CVSpilsSetEpsLin(cvode_mem, DELT);
if(check_flag(&flag, "CVSpilsSetEpsLin", 1)) return(1);
flag = CVSpilsSetPreconditioner(cvode_mem, Precond, PSolve);
if(check_flag(&flag, "CVSpilsSetPreconditioner", 1)) return(1);
} else {
flag = CVodeReInit(cvode_mem, T0, c);
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);
}
int main(int argc, char *argv[])
{
realtype abstol=ATOL, reltol=RTOL, t;
N_Vector c;
WebData wdata;
void *cvode_mem;
SUNLinearSolver LS, LSB;
int retval, ncheck;
int indexB;
realtype reltolB=RTOL, abstolB=ATOL;
N_Vector cB;
c = NULL;
cB = NULL;
wdata = NULL;
cvode_mem = NULL;
LS = LSB = NULL;
/* Allocate and initialize user data */
wdata = AllocUserData();
if(check_retval((void *)wdata, "AllocUserData", 2)) return(1);
InitUserData(wdata);
/* Set-up forward problem */
/* Initializations */
c = N_VNew_Serial(NEQ+1);
if(check_retval((void *)c, "N_VNew_Serial", 0)) return(1);
CInit(c, wdata);
/* Call CVodeCreate/CVodeInit for forward run */
printf("\nCreate and allocate CVODES memory for forward run\n");
cvode_mem = CVodeCreate(CV_BDF);
if(check_retval((void *)cvode_mem, "CVodeCreate", 0)) return(1);
wdata->cvode_mem = cvode_mem; /* Used in Precond */
retval = CVodeSetUserData(cvode_mem, wdata);
if(check_retval(&retval, "CVodeSetUserData", 1)) return(1);
retval = CVodeInit(cvode_mem, f, T0, c);
if(check_retval(&retval, "CVodeInit", 1)) return(1);
retval = CVodeSStolerances(cvode_mem, reltol, abstol);
if(check_retval(&retval, "CVodeSStolerances", 1)) return(1);
/* Create SUNLinSol_SPGMR linear solver for forward run */
LS = SUNLinSol_SPGMR(c, PREC_LEFT, 0);
if(check_retval((void *)LS, "SUNLinSol_SPGMR", 0)) return(1);
/* Attach the linear sovler */
retval = CVodeSetLinearSolver(cvode_mem, LS, NULL);
if (check_retval(&retval, "CVodeSetLinearSolver", 1)) return 1;
/* Set the preconditioner solve and setup functions */
retval = CVodeSetPreconditioner(cvode_mem, Precond, PSolve);
if(check_retval(&retval, "CVodeSetPreconditioner", 1)) return(1);
/* Set-up adjoint calculations */
printf("\nAllocate global memory\n");
retval = CVodeAdjInit(cvode_mem, NSTEPS, CV_HERMITE);
if(check_retval(&retval, "CVadjInit", 1)) return(1);
/* Perform forward run */
printf("\nForward integration\n");
retval = CVodeF(cvode_mem, TOUT, c, &t, CV_NORMAL, &ncheck);
if(check_retval(&retval, "CVodeF", 1)) return(1);
printf("\nncheck = %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, N_VGetArrayPointer(c)[NEQ]);
#else
printf("\n G = int_t int_x int_y c%d(t,x,y) dx dy dt = %f \n\n",
ISPEC, N_VGetArrayPointer(c)[NEQ]);
#endif
/* Set-up backward problem */
/* Allocate cB */
cB = N_VNew_Serial(NEQ);
if(check_retval((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");
retval = CVodeCreateB(cvode_mem, CV_BDF, &indexB);
if(check_retval(&retval, "CVodeCreateB", 1)) return(1);
retval = CVodeSetUserDataB(cvode_mem, indexB, wdata);
if(check_retval(&retval, "CVodeSetUserDataB", 1)) return(1);
retval = CVodeSetMaxNumStepsB(cvode_mem, indexB, 1000);
if(check_retval(&retval, "CVodeSetMaxNumStepsB", 1)) return(1);
retval = CVodeInitB(cvode_mem, indexB, fB, TOUT, cB);
if(check_retval(&retval, "CVodeInitB", 1)) return(1);
retval = CVodeSStolerancesB(cvode_mem, indexB, reltolB, abstolB);
if(check_retval(&retval, "CVodeSStolerancesB", 1)) return(1);
wdata->indexB = indexB;
/* Create SUNLinSol_SPGMR linear solver for backward run */
LSB = SUNLinSol_SPGMR(cB, PREC_LEFT, 0);
if(check_retval((void *)LSB, "SUNLinSol_SPGMR", 0)) return(1);
/* Attach the linear sovler */
retval = CVodeSetLinearSolverB(cvode_mem, indexB, LSB, NULL);
if (check_retval(&retval, "CVodeSetLinearSolverB", 1)) return 1;
/* Set the preconditioner solve and setup functions */
retval = CVodeSetPreconditionerB(cvode_mem, indexB, PrecondB, PSolveB);
if(check_retval(&retval, "CVodeSetPreconditionerB", 1)) return(1);
/* Perform backward integration */
printf("\nBackward integration\n");
retval = CVodeB(cvode_mem, T0, CV_NORMAL);
if(check_retval(&retval, "CVodeB", 1)) return(1);
retval = CVodeGetB(cvode_mem, indexB, &t, cB);
if(check_retval(&retval, "CVodeGetB", 1)) return(1);
PrintOutput(cB, NS, MXNS, wdata);
/* Free all memory */
CVodeFree(&cvode_mem);
N_VDestroy(c);
N_VDestroy(cB);
SUNLinSolFree(LS);
SUNLinSolFree(LSB);
FreeUserData(wdata);
return(0);
}
int main()
{
realtype abstol, reltol, t, tout;
N_Vector u;
UserData data;
void *cvode_mem;
int flag, iout, jpre;
long int ml, mu;
u = NULL;
data = NULL;
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 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);
/* Call CVBandPreInit to initialize band preconditioner */
ml = mu = 2;
flag = CVBandPrecInit(cvode_mem, NEQ, mu, ml);
if(check_flag(&flag, "CVBandPrecInit", 0)) 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, T0, u);
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);
} /* End of jpre loop */
/* Free memory */
N_VDestroy_Serial(u);
free(data);
CVodeFree(&cvode_mem);
return(0);
}
void CvodeSolver::initialize(const double &pVoiStart,
const int &pRatesStatesCount, double *pConstants,
double *pRates, double *pStates,
double *pAlgebraic,
ComputeRatesFunction pComputeRates)
{
if (!mSolver) {
// Retrieve some of the CVODE properties
double maximumStep = MaximumStepDefaultValue;
int maximumNumberOfSteps = MaximumNumberOfStepsDefaultValue;
QString integrationMethod = IntegrationMethodDefaultValue;
QString iterationType = IterationTypeDefaultValue;
QString linearSolver = LinearSolverDefaultValue;
QString preconditioner = PreconditionerDefaultValue;
int upperHalfBandwidth = UpperHalfBandwidthDefaultValue;
int lowerHalfBandwidth = LowerHalfBandwidthDefaultValue;
double relativeTolerance = RelativeToleranceDefaultValue;
double absoluteTolerance = AbsoluteToleranceDefaultValue;
if (mProperties.contains(MaximumStepId)) {
maximumStep = mProperties.value(MaximumStepId).toDouble();
} else {
emit error(QObject::tr("the 'maximum step' property value could not be retrieved"));
return;
}
if (mProperties.contains(MaximumNumberOfStepsId)) {
maximumNumberOfSteps = mProperties.value(MaximumNumberOfStepsId).toInt();
} else {
emit error(QObject::tr("the 'maximum number of steps' property value could not be retrieved"));
return;
}
if (mProperties.contains(IntegrationMethodId)) {
integrationMethod = mProperties.value(IntegrationMethodId).toString();
} else {
emit error(QObject::tr("the 'integration method' property value could not be retrieved"));
return;
}
if (mProperties.contains(IterationTypeId)) {
iterationType = mProperties.value(IterationTypeId).toString();
if (!iterationType.compare(NewtonIteration)) {
// We are dealing with a Newton iteration, so retrieve and check
// its linear solver
if (mProperties.contains(LinearSolverId)) {
linearSolver = mProperties.value(LinearSolverId).toString();
bool needUpperAndLowerHalfBandwidths = false;
if ( !linearSolver.compare(DenseLinearSolver)
|| !linearSolver.compare(DiagonalLinearSolver)) {
// We are dealing with a dense/diagonal linear solver,
// so nothing more to do
} else if (!linearSolver.compare(BandedLinearSolver)) {
// We are dealing with a banded linear solver, so we
// need both an upper and a lower half bandwidth
needUpperAndLowerHalfBandwidths = true;
} else {
// We are dealing with a GMRES/Bi-CGStab/TFQMR linear
// solver, so retrieve and check its preconditioner
if (mProperties.contains(PreconditionerId)) {
preconditioner = mProperties.value(PreconditionerId).toString();
} else {
emit error(QObject::tr("the 'preconditioner' property value could not be retrieved"));
return;
}
if (!preconditioner.compare(BandedPreconditioner)) {
// We are dealing with a banded preconditioner, so
// we need both an upper and a lower half bandwidth
needUpperAndLowerHalfBandwidths = true;
}
}
if (needUpperAndLowerHalfBandwidths) {
if (mProperties.contains(UpperHalfBandwidthId)) {
upperHalfBandwidth = mProperties.value(UpperHalfBandwidthId).toInt();
if ( (upperHalfBandwidth < 0)
|| (upperHalfBandwidth >= pRatesStatesCount)) {
emit error(QObject::tr("the 'upper half-bandwidth' property must have a value between 0 and %1").arg(pRatesStatesCount-1));
return;
}
} else {
emit error(QObject::tr("the 'upper half-bandwidth' property value could not be retrieved"));
return;
}
if (mProperties.contains(LowerHalfBandwidthId)) {
lowerHalfBandwidth = mProperties.value(LowerHalfBandwidthId).toInt();
if ( (lowerHalfBandwidth < 0)
|| (lowerHalfBandwidth >= pRatesStatesCount)) {
emit error(QObject::tr("the 'lower half-bandwidth' property must have a value between 0 and %1").arg(pRatesStatesCount-1));
return;
}
} else {
emit error(QObject::tr("the 'lower half-bandwidth' property value could not be retrieved"));
return;
}
}
} else {
emit error(QObject::tr("the 'linear solver' property value could not be retrieved"));
return;
}
}
} else {
emit error(QObject::tr("the 'iteration type' property value could not be retrieved"));
return;
}
if (mProperties.contains(RelativeToleranceId)) {
relativeTolerance = mProperties.value(RelativeToleranceId).toDouble();
if (relativeTolerance < 0) {
emit error(QObject::tr("the 'relative tolerance' property must have a value greater than or equal to 0"));
return;
}
} else {
emit error(QObject::tr("the 'relative tolerance' property value could not be retrieved"));
return;
}
if (mProperties.contains(AbsoluteToleranceId)) {
absoluteTolerance = mProperties.value(AbsoluteToleranceId).toDouble();
if (absoluteTolerance < 0) {
emit error(QObject::tr("the 'absolute tolerance' property must have a value greater than or equal to 0"));
return;
}
} else {
emit error(QObject::tr("the 'absolute tolerance' property value could not be retrieved"));
return;
}
if (mProperties.contains(InterpolateSolutionId)) {
mInterpolateSolution = mProperties.value(InterpolateSolutionId).toBool();
} else {
emit error(QObject::tr("the 'interpolate solution' property value could not be retrieved"));
return;
}
// Initialise the ODE solver itself
OpenCOR::Solver::OdeSolver::initialize(pVoiStart, pRatesStatesCount,
pConstants, pRates, pStates,
pAlgebraic, pComputeRates);
// Create the states vector
mStatesVector = N_VMake_Serial(pRatesStatesCount, pStates);
// Create the CVODE solver
bool newtonIteration = !iterationType.compare(NewtonIteration);
mSolver = CVodeCreate(!integrationMethod.compare(BdfMethod)?CV_BDF:CV_ADAMS,
newtonIteration?CV_NEWTON:CV_FUNCTIONAL);
// Use our own error handler
CVodeSetErrHandlerFn(mSolver, errorHandler, this);
// Initialise the CVODE solver
CVodeInit(mSolver, rhsFunction, pVoiStart, mStatesVector);
// Set some user data
mUserData = new CvodeSolverUserData(pConstants, pAlgebraic,
pComputeRates);
CVodeSetUserData(mSolver, mUserData);
// Set the maximum step
CVodeSetMaxStep(mSolver, maximumStep);
// Set the maximum number of steps
CVodeSetMaxNumSteps(mSolver, maximumNumberOfSteps);
// Set the linear solver, if needed
if (newtonIteration) {
if (!linearSolver.compare(DenseLinearSolver)) {
CVDense(mSolver, pRatesStatesCount);
} else if (!linearSolver.compare(BandedLinearSolver)) {
CVBand(mSolver, pRatesStatesCount, upperHalfBandwidth, lowerHalfBandwidth);
} else if (!linearSolver.compare(DiagonalLinearSolver)) {
CVDiag(mSolver);
} else {
// We are dealing with a GMRES/Bi-CGStab/TFQMR linear solver
if (!preconditioner.compare(BandedPreconditioner)) {
if (!linearSolver.compare(GmresLinearSolver))
CVSpgmr(mSolver, PREC_LEFT, 0);
else if (!linearSolver.compare(BiCgStabLinearSolver))
CVSpbcg(mSolver, PREC_LEFT, 0);
else
CVSptfqmr(mSolver, PREC_LEFT, 0);
CVBandPrecInit(mSolver, pRatesStatesCount, upperHalfBandwidth, lowerHalfBandwidth);
} else {
if (!linearSolver.compare(GmresLinearSolver))
CVSpgmr(mSolver, PREC_NONE, 0);
else if (!linearSolver.compare(BiCgStabLinearSolver))
CVSpbcg(mSolver, PREC_NONE, 0);
else
CVSptfqmr(mSolver, PREC_NONE, 0);
}
}
}
// Set the relative and absolute tolerances
CVodeSStolerances(mSolver, relativeTolerance, absoluteTolerance);
} else {
// Reinitialise the CVODE object
CVodeReInit(mSolver, pVoiStart, mStatesVector);
}
}
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 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);
/* 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, T0, u);
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);
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);
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);
break;
}
/* Set preconditioner setup and solve routines Precond and PSolve,
and the pointer to the user-defined block data */
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, 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()
{
void *cvode_mem;
SUNMatrix A;
SUNLinearSolver LS;
N_Vector y;
int flag, ret;
realtype reltol, abstol, t0, t1, t2, t;
long int nst1, nst2, nst;
reltol = RCONST(1.0e-3);
abstol = RCONST(1.0e-4);
t0 = RCONST(0.0);
t1 = RCONST(1.0);
t2 = RCONST(2.0);
/* Allocate the vector of initial conditions */
y = N_VNew_Serial(NEQ);
/* Set initial condition */
NV_Ith_S(y,0) = RCONST(1.0);
/*
* ------------------------------------------------------------
* Shared initialization and setup
* ------------------------------------------------------------
*/
/* Call CVodeCreate to create CVODE memory block and specify the
* Backward Differentiaion Formula */
cvode_mem = CVodeCreate(CV_BDF);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
/* Call CVodeInit to initialize integrator memory and specify the
* user's right hand side function y'=f(t,y), the initial time T0
* and the initial condiition vector y. */
ret = CVodeInit(cvode_mem, f, t0, y);
if (check_flag((void *)&ret, "CVodeInit", 1)) return(1);
/* Call CVodeSStolerances to specify integration tolereances,
* specifically the scalar relative and absolute tolerance. */
ret = CVodeSStolerances(cvode_mem, reltol, abstol);
if (check_flag((void *)&ret, "CVodeSStolerances", 1)) return(1);
/* Provide RHS flag as user data which can be access in user provided routines */
ret = CVodeSetUserData(cvode_mem, &flag);
if (check_flag((void *)&ret, "CVodeSetUserData", 1)) return(1);
/* Create dense SUNMatrix for use in linear solver */
A = SUNDenseMatrix(NEQ, NEQ);
if (check_flag((void *)A, "SUNDenseMatrix", 0)) return(1);
/* Create dense linear solver for use by CVode */
LS = SUNLinSol_Dense(y, A);
if (check_flag((void *)LS, "SUNLinSol_Dense", 0)) return(1);
/* Attach the linear solver and matrix to CVode by calling CVodeSetLinearSolver */
ret = CVodeSetLinearSolver(cvode_mem, LS, A);
if (check_flag((void *)&ret, "CVodeSetLinearSolver", 1)) return(1);
/*
* ---------------------------------------------------------------
* Discontinuity in the solution
*
* 1) Integrate to the discontinuity
* 2) Integrate from the discontinuity
* ---------------------------------------------------------------
*/
/* ---- Integrate to the discontinuity */
printf("\nDiscontinuity in solution\n\n");
/* set TSTOP (max time solution proceeds to) - this is not required */
ret = CVodeSetStopTime(cvode_mem, t1);
if (check_flag((void *)&ret, "CVodeSetStopTime", 1)) return(1);
flag = RHS1; /* use -y for RHS */
t = t0; /* set the integrator start time */
printf("%12.8e %12.8e\n",t,NV_Ith_S(y,0));
while (t<t1) {
/* advance solver just one internal step */
ret = CVode(cvode_mem, t1, y, &t, CV_ONE_STEP);
if (check_flag((void *)&ret, "CVode", 1)) return(1);
printf("%12.8e %12.8e\n",t,NV_Ith_S(y,0));
}
/* Get the number of steps the solver took to get to the discont. */
ret = CVodeGetNumSteps(cvode_mem, &nst1);
if (check_flag((void *)&ret, "CvodeGetNumSteps", 1)) return(1);
/* ---- Integrate from the discontinuity */
/* Include discontinuity */
NV_Ith_S(y,0) = RCONST(1.0);
/* Reinitialize the solver */
ret = CVodeReInit(cvode_mem, t1, y);
if (check_flag((void *)&ret, "CVodeReInit", 1)) return(1);
/* set TSTOP (max time solution proceeds to) - this is not required */
ret = CVodeSetStopTime(cvode_mem, t2);
if (check_flag((void *)&ret, "CVodeSetStopTime", 1)) return(1);
flag = RHS1; /* use -y for RHS */
t = t1; /* set the integrator start time */
printf("%12.8e %12.8e\n",t,NV_Ith_S(y,0));
while (t<t2) {
/* advance solver just one internal step */
ret = CVode(cvode_mem, t2, y, &t, CV_ONE_STEP);
if (check_flag((void *)&ret, "CVode", 1)) return(1);
printf("%12.8e %12.8e\n",t,NV_Ith_S(y,0));
}
/* Get the number of steps the solver took after the discont. */
ret = CVodeGetNumSteps(cvode_mem, &nst2);
if (check_flag((void *)&ret, "CvodeGetNumSteps", 1)) return(1);
/* Print statistics */
nst = nst1 + nst2;
printf("\nNumber of steps: %ld + %ld = %ld\n",nst1, nst2, nst);
/*
* ---------------------------------------------------------------
* Discontinuity in RHS: Case 1 - explicit treatment
* Note that it is not required to set TSTOP, but without it
* we would have to find y(t1) to reinitialize the solver.
* ---------------------------------------------------------------
*/
printf("\nDiscontinuity in RHS: Case 1 - explicit treatment\n\n");
/* Set initial condition */
NV_Ith_S(y,0) = RCONST(1.0);
/* Reinitialize the solver. CVodeReInit does not reallocate memory
* so it can only be used when the new problem size is the same as
* the problem size when CVodeCreate was called. */
ret = CVodeReInit(cvode_mem, t0, y);
if (check_flag((void *)&ret, "CVodeReInit", 1)) return(1);
/* ---- Integrate to the discontinuity */
/* Set TSTOP (max time solution proceeds to) to location of discont. */
ret = CVodeSetStopTime(cvode_mem, t1);
if (check_flag((void *)&ret, "CVodeSetStopTime", 1)) return(1);
flag = RHS1; /* use -y for RHS */
t = t0; /* set the integrator start time */
printf("%12.8e %12.8e\n",t,NV_Ith_S(y,0));
while (t<t1) {
/* advance solver just one internal step */
ret = CVode(cvode_mem, t1, y, &t, CV_ONE_STEP);
if (check_flag((void *)&ret, "CVode", 1)) return(1);
printf("%12.8e %12.8e\n",t,NV_Ith_S(y,0));
}
/* Get the number of steps the solver took to get to the discont. */
ret = CVodeGetNumSteps(cvode_mem, &nst1);
if (check_flag((void *)&ret, "CvodeGetNumSteps", 1)) return(1);
/* If TSTOP was not set, we'd need to find y(t1): */
/* CVodeGetDky(cvode_mem, t1, 0, y); */
/* ---- Integrate from the discontinuity */
/* Reinitialize solver */
ret = CVodeReInit(cvode_mem, t1, y);
/* set TSTOP (max time solution proceeds to) - this is not required */
ret = CVodeSetStopTime(cvode_mem, t2);
if (check_flag((void *)&ret, "CVodeSetStopTime", 1)) return(1);
flag = RHS2; /* use -5y for RHS */
t = t1; /* set the integrator start time */
printf("%12.8e %12.8e\n",t,NV_Ith_S(y,0));
while (t<t2) {
/* advance solver just one internal step */
ret = CVode(cvode_mem, t2, y, &t, CV_ONE_STEP);
if (check_flag((void *)&ret, "CVode", 1)) return(1);
printf("%12.8e %12.8e\n",t,NV_Ith_S(y,0));
}
/* Get the number of steps the solver took after the discont. */
ret = CVodeGetNumSteps(cvode_mem, &nst2);
if (check_flag((void *)&ret, "CvodeGetNumSteps", 1)) return(1);
/* Print statistics */
nst = nst1 + nst2;
printf("\nNumber of steps: %ld + %ld = %ld\n",nst1, nst2, nst);
/*
* ---------------------------------------------------------------
* Discontinuity in RHS: Case 2 - let CVODE deal with it
* Note that here we MUST set TSTOP to ensure that the
* change in the RHS happens at the appropriate time
* ---------------------------------------------------------------
*/
printf("\nDiscontinuity in RHS: Case 2 - let CVODE deal with it\n\n");
/* Set initial condition */
NV_Ith_S(y,0) = RCONST(1.0);
/* Reinitialize the solver. CVodeReInit does not reallocate memory
* so it can only be used when the new problem size is the same as
* the problem size when CVodeCreate was called. */
ret = CVodeReInit(cvode_mem, t0, y);
if (check_flag((void *)&ret, "CVodeReInit", 1)) return(1);
/* ---- Integrate to the discontinuity */
/* Set TSTOP (max time solution proceeds to) to location of discont. */
ret = CVodeSetStopTime(cvode_mem, t1);
if (check_flag((void *)&ret, "CVodeSetStopTime", 1)) return(1);
flag = RHS1; /* use -y for RHS */
t = t0; /* set the integrator start time */
printf("%12.8e %12.8e\n",t,NV_Ith_S(y,0));
while (t<t1) {
/* advance solver just one internal step */
ret = CVode(cvode_mem, t1, y, &t, CV_ONE_STEP);
if (check_flag((void *)&ret, "CVode", 1)) return(1);
printf("%12.8e %12.8e\n",t,NV_Ith_S(y,0));
}
/* Get the number of steps the solver took to get to the discont. */
ret = CVodeGetNumSteps(cvode_mem, &nst1);
if (check_flag((void *)&ret, "CvodeGetNumSteps", 1)) return(1);
/* ---- Integrate from the discontinuity */
/* set TSTOP (max time solution proceeds to) - this is not required */
ret = CVodeSetStopTime(cvode_mem, t2);
if (check_flag((void *)&ret, "CVodeSetStopTime", 1)) return(1);
flag = RHS2; /* use -5y for RHS */
t = t1; /* set the integrator start time */
printf("%12.8e %12.8e\n",t,NV_Ith_S(y,0));
while (t<t2) {
/* advance solver just one internal step */
ret = CVode(cvode_mem, t2, y, &t, CV_ONE_STEP);
if (check_flag((void *)&ret, "CVode", 1)) return(1);
printf("%12.8e %12.8e\n",t,NV_Ith_S(y,0));
}
/* Get the number of steps the solver took after the discont. */
ret = CVodeGetNumSteps(cvode_mem, &nst);
if (check_flag((void *)&ret, "CvodeGetNumSteps", 1)) return(1);
/* Print statistics */
nst2 = nst - nst1;
printf("\nNumber of steps: %ld + %ld = %ld\n",nst1, nst2, nst);
/* Free memory */
N_VDestroy(y);
SUNMatDestroy(A);
SUNLinSolFree(LS);
CVodeFree(&cvode_mem);
return(0);
}
