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 ode_solver_reinit(ode_solver* solver, const double t0, double* y0, int lenY, const double* p, int lenP ){
int i,flag;
/* 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;
}
else {
NV_DATA_S(solver->y) = solver->odeModel->v;
}
/* re-initialise */
flag = CVodeReInit(solver->cvode_mem, t0, solver->y);
/* 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 ;
}
int P = solver->odeModel->P;
for(i = 0; i < P; i++)
solver->params[i] = p[i];
flag = CVodeSetUserData(solver->cvode_mem, solver->params);
}
}
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(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);
}
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 jmi_ode_cvode_new(jmi_ode_cvode_t** integrator_ptr, jmi_ode_solver_t* solver) {
jmi_ode_cvode_t* integrator;
jmi_ode_problem_t* problem = solver -> ode_problem;
int flag = 0;
void* cvode_mem;
jmi_real_t* y;
jmi_real_t* atol_nv;
int i;
integrator = (jmi_ode_cvode_t*)calloc(1,sizeof(jmi_ode_cvode_t));
if(!integrator){
jmi_log_node(problem->log, logError, "Error", "Failed to allocate the internal CVODE struct.");
return -1;
}
/* DEFAULT VALUES NEEDS TO BE IMPROVED*/
integrator->lmm = CV_BDF;
integrator->iter = CV_NEWTON;
/* integrator->rtol = 1e-4; */
integrator->rtol = solver->rel_tol;
if (problem->n_real_x > 0) {
integrator->atol = N_VNew_Serial(problem->n_real_x);
} else {
integrator->atol = N_VNew_Serial(1);
}
atol_nv = NV_DATA_S(integrator->atol);
if (problem->n_real_x > 0) {
for (i = 0; i < problem->n_real_x; i++) {
atol_nv[i] = 0.01*integrator->rtol*problem->nominal[i];
}
}else{
atol_nv[0] = 0.01*integrator->rtol*1.0;
}
cvode_mem = CVodeCreate(integrator->lmm,integrator->iter);
if(!cvode_mem){
jmi_log_node(problem->log, logError, "Error", "Failed to allocate the CVODE struct.");
return -1;
}
/* Get the default values for the time and states */
if (problem->n_real_x > 0) {
integrator->y_work = N_VNew_Serial(problem->n_real_x);
y = NV_DATA_S(integrator->y_work);
memcpy (y, problem->states, problem->n_real_x*sizeof(jmi_real_t));
}else{
integrator->y_work = N_VNew_Serial(1);
y = NV_DATA_S(integrator->y_work);
y[0] = 0.0;
}
flag = CVodeInit(cvode_mem, cv_rhs, problem->time, integrator->y_work);
if(flag != 0) {
jmi_log_node(problem->log, logError, "Error", "Failed to initialize CVODE. Returned with <error_flag: %d>", flag);
return -1;
}
flag = CVodeSVtolerances(cvode_mem, integrator->rtol, integrator->atol);
if(flag!=0){
jmi_log_node(problem->log, logError, "Error", "Failed to specify the tolerances. Returned with <error_flag: %d>", flag);
return -1;
}
if (problem->n_real_x > 0) {
flag = CVDense(cvode_mem, problem->n_real_x);
}else{
flag = CVDense(cvode_mem, 1);
}
if(flag!=0){
jmi_log_node(problem->log, logError, "Error", "Failed to specify the linear solver. Returned with <error_flag: %d>", flag);
return -1;
}
flag = CVodeSetUserData(cvode_mem, (void*)solver);
if(flag!=0){
jmi_log_node(problem->log, logError, "Error", "Failed to specify the user data. Returned with <error_flag: %d>", flag);
return -1;
}
if (problem->n_sw > 0){
flag = CVodeRootInit(cvode_mem, problem->n_sw, cv_root);
if(flag!=0){
jmi_log_node(problem->log, logError, "Error", "Failed to specify the event indicator function. Returned with <error_flag: %d>", flag);
return -1;
}
}
flag = CVodeSetErrHandlerFn(cvode_mem, cv_err, (void*)solver);
if(flag!=0){
jmi_log_node(problem->log, logError, "Error", "Failed to specify the error handling function. Returned with <error_flag: %d>", flag);
return -1;
}
integrator->cvode_mem = cvode_mem;
*integrator_ptr = integrator;
return 0;
}
int main(int argc, char *argv[])
{
void *cvode_mem;
UserData data;
realtype dx, reltol, abstol, t, tout;
N_Vector u;
int iout, flag;
realtype *pbar;
int is, *plist;
N_Vector *uS;
booleantype sensi, err_con;
int sensi_meth;
cvode_mem = NULL;
data = NULL;
u = NULL;
pbar = NULL;
plist = NULL;
uS = NULL;
/* Process arguments */
ProcessArgs(argc, argv, &sensi, &sensi_meth, &err_con);
/* Set user data */
data = (UserData) malloc(sizeof *data); /* Allocate data memory */
if(check_flag((void *)data, "malloc", 2)) return(1);
data->p = (realtype *) malloc(NP * sizeof(realtype));
dx = data->dx = XMAX/((realtype)(MX+1));
data->p[0] = RCONST(1.0);
data->p[1] = RCONST(0.5);
/* Allocate and set initial states */
u = N_VNew_Serial(NEQ);
if(check_flag((void *)u, "N_VNew_Serial", 0)) return(1);
SetIC(u, dx);
/* Set integration tolerances */
reltol = ZERO;
abstol = ATOL;
/* Create CVODES object */
cvode_mem = CVodeCreate(CV_ADAMS, CV_FUNCTIONAL);
if(check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
flag = CVodeSetUserData(cvode_mem, data);
if(check_flag(&flag, "CVodeSetUserData", 1)) return(1);
/* Allocate CVODES memory */
flag = CVodeInit(cvode_mem, f, T0, u);
if(check_flag(&flag, "CVodeInit", 1)) return(1);
flag = CVodeSStolerances(cvode_mem, reltol, abstol);
if(check_flag(&flag, "CVodeSStolerances", 1)) return(1);
printf("\n1-D advection-diffusion equation, mesh size =%3d\n", MX);
/* Sensitivity-related settings */
if(sensi) {
plist = (int *) malloc(NS * sizeof(int));
if(check_flag((void *)plist, "malloc", 2)) return(1);
for(is=0; is<NS; is++) plist[is] = is;
pbar = (realtype *) malloc(NS * sizeof(realtype));
if(check_flag((void *)pbar, "malloc", 2)) return(1);
for(is=0; is<NS; is++) pbar[is] = data->p[plist[is]];
uS = N_VCloneVectorArray_Serial(NS, u);
if(check_flag((void *)uS, "N_VCloneVectorArray_Serial", 0)) return(1);
for(is=0;is<NS;is++)
N_VConst(ZERO, uS[is]);
flag = CVodeSensInit1(cvode_mem, NS, sensi_meth, NULL, uS);
if(check_flag(&flag, "CVodeSensInit1", 1)) return(1);
flag = CVodeSensEEtolerances(cvode_mem);
if(check_flag(&flag, "CVodeSensEEtolerances", 1)) return(1);
flag = CVodeSetSensErrCon(cvode_mem, err_con);
if(check_flag(&flag, "CVodeSetSensErrCon", 1)) return(1);
flag = CVodeSetSensDQMethod(cvode_mem, CV_CENTERED, ZERO);
if(check_flag(&flag, "CVodeSetSensDQMethod", 1)) return(1);
flag = CVodeSetSensParams(cvode_mem, data->p, pbar, plist);
if(check_flag(&flag, "CVodeSetSensParams", 1)) return(1);
printf("Sensitivity: YES ");
if(sensi_meth == CV_SIMULTANEOUS)
printf("( SIMULTANEOUS +");
else
if(sensi_meth == CV_STAGGERED) printf("( STAGGERED +");
else printf("( STAGGERED1 +");
if(err_con) printf(" FULL ERROR CONTROL )");
else printf(" PARTIAL ERROR CONTROL )");
} else {
printf("Sensitivity: NO ");
}
/* In loop over output points, call CVode, print results, test for error */
printf("\n\n");
printf("============================================================\n");
printf(" T Q H NST Max norm \n");
printf("============================================================\n");
for (iout=1, tout=T1; iout <= NOUT; iout++, tout += DTOUT) {
flag = CVode(cvode_mem, tout, u, &t, CV_NORMAL);
if(check_flag(&flag, "CVode", 1)) break;
PrintOutput(cvode_mem, t, u);
if (sensi) {
flag = CVodeGetSens(cvode_mem, &t, uS);
if(check_flag(&flag, "CVodeGetSens", 1)) break;
PrintOutputS(uS);
}
printf("------------------------------------------------------------\n");
}
/* Print final statistics */
PrintFinalStats(cvode_mem, sensi);
/* Free memory */
N_VDestroy_Serial(u);
if (sensi) {
N_VDestroyVectorArray_Serial(uS, NS);
free(plist);
free(pbar);
}
free(data);
CVodeFree(&cvode_mem);
return(0);
}
int main(int argc, char *argv[])
{
UserData data;
SUNMatrix A, AB;
SUNLinearSolver LS, LSB;
void *cvode_mem;
realtype reltolQ, abstolQ;
N_Vector y, q, constraints;
int steps;
int indexB;
realtype reltolB, abstolB, abstolQB;
N_Vector yB, qB, constraintsB;
realtype time;
int retval, ncheck;
long int nst, nstB;
CVadjCheckPointRec *ckpnt;
data = NULL;
A = AB = NULL;
LS = LSB = NULL;
cvode_mem = NULL;
ckpnt = NULL;
y = yB = qB = NULL;
constraints = NULL;
constraintsB = NULL;
/* Print problem description */
printf("\nAdjoint Sensitivity Example for Chemical Kinetics\n");
printf("-------------------------------------------------\n\n");
printf("ODE: dy1/dt = -p1*y1 + p2*y2*y3\n");
printf(" dy2/dt = p1*y1 - p2*y2*y3 - p3*(y2)^2\n");
printf(" dy3/dt = p3*(y2)^2\n\n");
printf("Find dG/dp for\n");
printf(" G = int_t0^tB0 g(t,p,y) dt\n");
printf(" g(t,p,y) = y3\n\n\n");
/* User data structure */
data = (UserData) malloc(sizeof *data);
if (check_retval((void *)data, "malloc", 2)) return(1);
data->p[0] = RCONST(0.04);
data->p[1] = RCONST(1.0e4);
data->p[2] = RCONST(3.0e7);
/* Initialize y */
y = N_VNew_Serial(NEQ);
if (check_retval((void *)y, "N_VNew_Serial", 0)) return(1);
Ith(y,1) = RCONST(1.0);
Ith(y,2) = ZERO;
Ith(y,3) = ZERO;
/* Set constraints to all 1's for nonnegative solution values. */
constraints = N_VNew_Serial(NEQ);
if(check_retval((void *)constraints, "N_VNew_Serial", 0)) return(1);
N_VConst(ONE, constraints);
/* Initialize q */
q = N_VNew_Serial(1);
if (check_retval((void *)q, "N_VNew_Serial", 0)) return(1);
Ith(q,1) = ZERO;
/* Set the scalar realtive and absolute tolerances reltolQ and abstolQ */
reltolQ = RTOL;
abstolQ = ATOLq;
/* Create and allocate CVODES memory for forward run */
printf("Create and allocate CVODES memory for forward runs\n");
/* Call CVodeCreate to create the solver memory and specify the
Backward Differentiation Formula */
cvode_mem = CVodeCreate(CV_BDF);
if (check_retval((void *)cvode_mem, "CVodeCreate", 0)) return(1);
/* Call CVodeInit to initialize the integrator memory and specify the
user's right hand side function in y'=f(t,y), the initial time T0, and
the initial dependent variable vector y. */
retval = CVodeInit(cvode_mem, f, T0, y);
if (check_retval(&retval, "CVodeInit", 1)) return(1);
/* Call CVodeWFtolerances to specify a user-supplied function ewt that sets
the multiplicative error weights w_i for use in the weighted RMS norm */
retval = CVodeWFtolerances(cvode_mem, ewt);
if (check_retval(&retval, "CVodeWFtolerances", 1)) return(1);
/* Attach user data */
retval = CVodeSetUserData(cvode_mem, data);
if (check_retval(&retval, "CVodeSetUserData", 1)) return(1);
/* Call CVodeSetConstraints to initialize constraints */
retval = CVodeSetConstraints(cvode_mem, constraints);
if (check_retval(&retval, "CVODESetConstraints", 1)) return(1);
N_VDestroy(constraints);
/* Create dense SUNMatrix for use in linear solves */
A = SUNDenseMatrix(NEQ, NEQ);
if (check_retval((void *)A, "SUNDenseMatrix", 0)) return(1);
/* Create dense SUNLinearSolver object */
LS = SUNLinSol_Dense(y, A);
if (check_retval((void *)LS, "SUNLinSol_Dense", 0)) return(1);
/* Attach the matrix and linear solver */
retval = CVDlsSetLinearSolver(cvode_mem, LS, A);
if (check_retval(&retval, "CVDlsSetLinearSolver", 1)) return(1);
/* Set the user-supplied Jacobian routine Jac */
retval = CVDlsSetJacFn(cvode_mem, Jac);
if (check_retval(&retval, "CVDlsSetJacFn", 1)) return(1);
/* Call CVodeQuadInit to allocate initernal memory and initialize
quadrature integration*/
retval = CVodeQuadInit(cvode_mem, fQ, q);
if (check_retval(&retval, "CVodeQuadInit", 1)) return(1);
/* Call CVodeSetQuadErrCon to specify whether or not the quadrature variables
are to be used in the step size control mechanism within CVODES. Call
CVodeQuadSStolerances or CVodeQuadSVtolerances to specify the integration
tolerances for the quadrature variables. */
retval = CVodeSetQuadErrCon(cvode_mem, SUNTRUE);
if (check_retval(&retval, "CVodeSetQuadErrCon", 1)) return(1);
/* Call CVodeQuadSStolerances to specify scalar relative and absolute
tolerances. */
retval = CVodeQuadSStolerances(cvode_mem, reltolQ, abstolQ);
if (check_retval(&retval, "CVodeQuadSStolerances", 1)) return(1);
/* Allocate global memory */
/* Call CVodeAdjInit to update CVODES memory block by allocting the internal
memory needed for backward integration.*/
steps = STEPS; /* no. of integration steps between two consecutive ckeckpoints*/
retval = CVodeAdjInit(cvode_mem, steps, CV_HERMITE);
/*
retval = CVodeAdjInit(cvode_mem, steps, CV_POLYNOMIAL);
*/
if (check_retval(&retval, "CVodeAdjInit", 1)) return(1);
/* Perform forward run */
printf("Forward integration ... ");
/* Call CVodeF to integrate the forward problem over an interval in time and
saves checkpointing data */
retval = CVodeF(cvode_mem, TOUT, y, &time, CV_NORMAL, &ncheck);
if (check_retval(&retval, "CVodeF", 1)) return(1);
retval = CVodeGetNumSteps(cvode_mem, &nst);
if (check_retval(&retval, "CVodeGetNumSteps", 1)) return(1);
printf("done ( nst = %ld )\n",nst);
printf("\nncheck = %d\n\n", ncheck);
retval = CVodeGetQuad(cvode_mem, &time, q);
if (check_retval(&retval, "CVodeGetQuad", 1)) return(1);
printf("--------------------------------------------------------\n");
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf("G: %12.4Le \n",Ith(q,1));
#elif defined(SUNDIALS_DOUBLE_PRECISION)
printf("G: %12.4e \n",Ith(q,1));
#else
printf("G: %12.4e \n",Ith(q,1));
#endif
printf("--------------------------------------------------------\n\n");
/* Test check point linked list
(uncomment next block to print check point information) */
/*
{
int i;
printf("\nList of Check Points (ncheck = %d)\n\n", ncheck);
ckpnt = (CVadjCheckPointRec *) malloc ( (ncheck+1)*sizeof(CVadjCheckPointRec));
CVodeGetAdjCheckPointsInfo(cvode_mem, ckpnt);
for (i=0;i<=ncheck;i++) {
printf("Address: %p\n",ckpnt[i].my_addr);
printf("Next: %p\n",ckpnt[i].next_addr);
printf("Time interval: %le %le\n",ckpnt[i].t0, ckpnt[i].t1);
printf("Step number: %ld\n",ckpnt[i].nstep);
printf("Order: %d\n",ckpnt[i].order);
printf("Step size: %le\n",ckpnt[i].step);
printf("\n");
}
}
*/
/* Initialize yB */
yB = N_VNew_Serial(NEQ);
if (check_retval((void *)yB, "N_VNew_Serial", 0)) return(1);
Ith(yB,1) = ZERO;
Ith(yB,2) = ZERO;
Ith(yB,3) = ZERO;
/* Initialize qB */
qB = N_VNew_Serial(NP);
if (check_retval((void *)qB, "N_VNew", 0)) return(1);
Ith(qB,1) = ZERO;
Ith(qB,2) = ZERO;
Ith(qB,3) = ZERO;
/* Set the scalar relative tolerance reltolB */
reltolB = RTOL;
/* Set the scalar absolute tolerance abstolB */
abstolB = ATOLl;
/* Set the scalar absolute tolerance abstolQB */
abstolQB = ATOLq;
/* Set constraints to all 1's for nonnegative solution values. */
constraintsB = N_VNew_Serial(NEQ);
if(check_retval((void *)constraintsB, "N_VNew_Serial", 0)) return(1);
N_VConst(ONE, constraintsB);
/* Create and allocate CVODES memory for backward run */
printf("Create and allocate CVODES memory for backward run\n");
/* Call CVodeCreateB to specify the solution method for the backward
problem. */
retval = CVodeCreateB(cvode_mem, CV_BDF, &indexB);
if (check_retval(&retval, "CVodeCreateB", 1)) return(1);
/* Call CVodeInitB to allocate internal memory and initialize the
backward problem. */
retval = CVodeInitB(cvode_mem, indexB, fB, TB1, yB);
if (check_retval(&retval, "CVodeInitB", 1)) return(1);
/* Set the scalar relative and absolute tolerances. */
retval = CVodeSStolerancesB(cvode_mem, indexB, reltolB, abstolB);
if (check_retval(&retval, "CVodeSStolerancesB", 1)) return(1);
/* Attach the user data for backward problem. */
retval = CVodeSetUserDataB(cvode_mem, indexB, data);
if (check_retval(&retval, "CVodeSetUserDataB", 1)) return(1);
/* Call CVodeSetConstraintsB to initialize constraints */
retval = CVodeSetConstraintsB(cvode_mem, indexB, constraintsB);
if(check_retval(&retval, "CVodeSetConstraintsB", 1)) return(1);
N_VDestroy(constraintsB);
/* Create dense SUNMatrix for use in linear solves */
AB = SUNDenseMatrix(NEQ, NEQ);
if (check_retval((void *)AB, "SUNDenseMatrix", 0)) return(1);
/* Create dense SUNLinearSolver object */
LSB = SUNLinSol_Dense(yB, AB);
if (check_retval((void *)LSB, "SUNLinSol_Dense", 0)) return(1);
/* Attach the matrix and linear solver */
retval = CVDlsSetLinearSolverB(cvode_mem, indexB, LSB, AB);
if (check_retval(&retval, "CVDlsSetLinearSolverB", 1)) return(1);
/* Set the user-supplied Jacobian routine JacB */
retval = CVDlsSetJacFnB(cvode_mem, indexB, JacB);
if (check_retval(&retval, "CVDlsSetJacFnB", 1)) return(1);
/* Call CVodeQuadInitB to allocate internal memory and initialize backward
quadrature integration. */
retval = CVodeQuadInitB(cvode_mem, indexB, fQB, qB);
if (check_retval(&retval, "CVodeQuadInitB", 1)) return(1);
/* Call CVodeSetQuadErrCon to specify whether or not the quadrature variables
are to be used in the step size control mechanism within CVODES. Call
CVodeQuadSStolerances or CVodeQuadSVtolerances to specify the integration
tolerances for the quadrature variables. */
retval = CVodeSetQuadErrConB(cvode_mem, indexB, SUNTRUE);
if (check_retval(&retval, "CVodeSetQuadErrConB", 1)) return(1);
/* Call CVodeQuadSStolerancesB to specify the scalar relative and absolute tolerances
for the backward problem. */
retval = CVodeQuadSStolerancesB(cvode_mem, indexB, reltolB, abstolQB);
if (check_retval(&retval, "CVodeQuadSStolerancesB", 1)) return(1);
/* Backward Integration */
PrintHead(TB1);
/* First get results at t = TBout1 */
/* Call CVodeB to integrate the backward ODE problem. */
retval = CVodeB(cvode_mem, TBout1, CV_NORMAL);
if (check_retval(&retval, "CVodeB", 1)) return(1);
/* Call CVodeGetB to get yB of the backward ODE problem. */
retval = CVodeGetB(cvode_mem, indexB, &time, yB);
if (check_retval(&retval, "CVodeGetB", 1)) return(1);
/* Call CVodeGetAdjY to get the interpolated value of the forward solution
y during a backward integration. */
retval = CVodeGetAdjY(cvode_mem, TBout1, y);
if (check_retval(&retval, "CVodeGetAdjY", 1)) return(1);
PrintOutput1(time, TBout1, y, yB);
/* Then at t = T0 */
retval = CVodeB(cvode_mem, T0, CV_NORMAL);
if (check_retval(&retval, "CVodeB", 1)) return(1);
CVodeGetNumSteps(CVodeGetAdjCVodeBmem(cvode_mem, indexB), &nstB);
printf("Done ( nst = %ld )\n", nstB);
retval = CVodeGetB(cvode_mem, indexB, &time, yB);
if (check_retval(&retval, "CVodeGetB", 1)) return(1);
/* Call CVodeGetQuadB to get the quadrature solution vector after a
successful return from CVodeB. */
retval = CVodeGetQuadB(cvode_mem, indexB, &time, qB);
if (check_retval(&retval, "CVodeGetQuadB", 1)) return(1);
retval = CVodeGetAdjY(cvode_mem, T0, y);
if (check_retval(&retval, "CVodeGetAdjY", 1)) return(1);
PrintOutput(time, y, yB, qB);
/* Reinitialize backward phase (new tB0) */
Ith(yB,1) = ZERO;
Ith(yB,2) = ZERO;
Ith(yB,3) = ZERO;
Ith(qB,1) = ZERO;
Ith(qB,2) = ZERO;
Ith(qB,3) = ZERO;
printf("Re-initialize CVODES memory for backward run\n");
retval = CVodeReInitB(cvode_mem, indexB, TB2, yB);
if (check_retval(&retval, "CVodeReInitB", 1)) return(1);
retval = CVodeQuadReInitB(cvode_mem, indexB, qB);
if (check_retval(&retval, "CVodeQuadReInitB", 1)) return(1);
PrintHead(TB2);
/* First get results at t = TBout1 */
retval = CVodeB(cvode_mem, TBout1, CV_NORMAL);
if (check_retval(&retval, "CVodeB", 1)) return(1);
retval = CVodeGetB(cvode_mem, indexB, &time, yB);
if (check_retval(&retval, "CVodeGetB", 1)) return(1);
retval = CVodeGetAdjY(cvode_mem, TBout1, y);
if (check_retval(&retval, "CVodeGetAdjY", 1)) return(1);
PrintOutput1(time, TBout1, y, yB);
/* Then at t = T0 */
retval = CVodeB(cvode_mem, T0, CV_NORMAL);
if (check_retval(&retval, "CVodeB", 1)) return(1);
CVodeGetNumSteps(CVodeGetAdjCVodeBmem(cvode_mem, indexB), &nstB);
printf("Done ( nst = %ld )\n", nstB);
retval = CVodeGetB(cvode_mem, indexB, &time, yB);
if (check_retval(&retval, "CVodeGetB", 1)) return(1);
retval = CVodeGetQuadB(cvode_mem, indexB, &time, qB);
if (check_retval(&retval, "CVodeGetQuadB", 1)) return(1);
retval = CVodeGetAdjY(cvode_mem, T0, y);
if (check_retval(&retval, "CVodeGetAdjY", 1)) return(1);
PrintOutput(time, y, yB, qB);
/* Free memory */
printf("Free memory\n\n");
CVodeFree(&cvode_mem);
N_VDestroy(y);
N_VDestroy(q);
N_VDestroy(yB);
N_VDestroy(qB);
SUNLinSolFree(LS);
SUNMatDestroy(A);
SUNLinSolFree(LSB);
SUNMatDestroy(AB);
if (ckpnt != NULL) free(ckpnt);
free(data);
return(0);
}
int main(int argc, char *argv[])
{
SUNMatrix A;
SUNLinearSolver LS;
void *cvode_mem;
UserData data;
realtype t, tout;
N_Vector y, constraints;
int iout, retval;
realtype pbar[NS];
int is;
N_Vector *yS;
booleantype sensi, err_con;
int sensi_meth;
cvode_mem = NULL;
data = NULL;
y = NULL;
yS = NULL;
A = NULL;
LS = NULL;
constraints = NULL;
/* Process arguments */
ProcessArgs(argc, argv, &sensi, &sensi_meth, &err_con);
/* User data structure */
data = (UserData) malloc(sizeof *data);
if (check_retval((void *)data, "malloc", 2)) return(1);
data->p[0] = RCONST(0.04);
data->p[1] = RCONST(1.0e4);
data->p[2] = RCONST(3.0e7);
/* Initial conditions */
y = N_VNew_Serial(NEQ);
if (check_retval((void *)y, "N_VNew_Serial", 0)) return(1);
Ith(y,1) = Y1;
Ith(y,2) = Y2;
Ith(y,3) = Y3;
/* Set constraints to all 1's for nonnegative solution values. */
constraints = N_VNew_Serial(NEQ);
if(check_retval((void *)constraints, "N_VNew_Serial", 0)) return(1);
N_VConst(ONE, constraints);
/* Create CVODES object */
cvode_mem = CVodeCreate(CV_BDF);
if (check_retval((void *)cvode_mem, "CVodeCreate", 0)) return(1);
/* Allocate space for CVODES */
retval = CVodeInit(cvode_mem, f, T0, y);
if (check_retval(&retval, "CVodeInit", 1)) return(1);
/* Use private function to compute error weights */
retval = CVodeWFtolerances(cvode_mem, ewt);
if (check_retval(&retval, "CVodeSetEwtFn", 1)) return(1);
/* Attach user data */
retval = CVodeSetUserData(cvode_mem, data);
if (check_retval(&retval, "CVodeSetUserData", 1)) return(1);
/* Call CVodeSetConstraints to initialize constraints */
retval = CVodeSetConstraints(cvode_mem, constraints);
if(check_retval(&retval, "CVodeSetConstraints", 1)) return(1);
N_VDestroy(constraints);
/* Create dense SUNMatrix */
A = SUNDenseMatrix(NEQ, NEQ);
if (check_retval((void *)A, "SUNDenseMatrix", 0)) return(1);
/* Create dense SUNLinearSolver */
LS = SUNLinSol_Dense(y, A);
if (check_retval((void *)LS, "SUNLinSol_Dense", 0)) return(1);
/* Attach the matrix and linear solver */
retval = CVDlsSetLinearSolver(cvode_mem, LS, A);
if (check_retval(&retval, "CVDlsSetLinearSolver", 1)) return(1);
/* Set the user-supplied Jacobian routine Jac */
retval = CVDlsSetJacFn(cvode_mem, Jac);
if (check_retval(&retval, "CVDlsSetJacFn", 1)) return(1);
printf("\n3-species chemical kinetics problem\n");
/* Sensitivity-related settings */
if (sensi) {
/* Set parameter scaling factor */
pbar[0] = data->p[0];
pbar[1] = data->p[1];
pbar[2] = data->p[2];
/* Set sensitivity initial conditions */
yS = N_VCloneVectorArray(NS, y);
if (check_retval((void *)yS, "N_VCloneVectorArray", 0)) return(1);
for (is=0;is<NS;is++) N_VConst(ZERO, yS[is]);
/* Call CVodeSensInit1 to activate forward sensitivity computations
and allocate internal memory for COVEDS related to sensitivity
calculations. Computes the right-hand sides of the sensitivity
ODE, one at a time */
retval = CVodeSensInit1(cvode_mem, NS, sensi_meth, fS, yS);
if(check_retval(&retval, "CVodeSensInit", 1)) return(1);
/* Call CVodeSensEEtolerances to estimate tolerances for sensitivity
variables based on the rolerances supplied for states variables and
the scaling factor pbar */
retval = CVodeSensEEtolerances(cvode_mem);
if(check_retval(&retval, "CVodeSensEEtolerances", 1)) return(1);
/* Set sensitivity analysis optional inputs */
/* Call CVodeSetSensErrCon to specify the error control strategy for
sensitivity variables */
retval = CVodeSetSensErrCon(cvode_mem, err_con);
if (check_retval(&retval, "CVodeSetSensErrCon", 1)) return(1);
/* Call CVodeSetSensParams to specify problem parameter information for
sensitivity calculations */
retval = CVodeSetSensParams(cvode_mem, NULL, pbar, NULL);
if (check_retval(&retval, "CVodeSetSensParams", 1)) return(1);
printf("Sensitivity: YES ");
if(sensi_meth == CV_SIMULTANEOUS)
printf("( SIMULTANEOUS +");
else
if(sensi_meth == CV_STAGGERED) printf("( STAGGERED +");
else printf("( STAGGERED1 +");
if(err_con) printf(" FULL ERROR CONTROL )");
else printf(" PARTIAL ERROR CONTROL )");
} else {
printf("Sensitivity: NO ");
}
/* In loop over output points, call CVode, print results, test for error */
printf("\n\n");
printf("===========================================");
printf("============================\n");
printf(" T Q H NST y1");
printf(" y2 y3 \n");
printf("===========================================");
printf("============================\n");
for (iout=1, tout=T1; iout <= NOUT; iout++, tout *= TMULT) {
retval = CVode(cvode_mem, tout, y, &t, CV_NORMAL);
if (check_retval(&retval, "CVode", 1)) break;
PrintOutput(cvode_mem, t, y);
/* Call CVodeGetSens to get the sensitivity solution vector after a
successful return from CVode */
if (sensi) {
retval = CVodeGetSens(cvode_mem, &t, yS);
if (check_retval(&retval, "CVodeGetSens", 1)) break;
PrintOutputS(yS);
}
printf("-----------------------------------------");
printf("------------------------------\n");
}
/* Print final statistics */
PrintFinalStats(cvode_mem, sensi);
/* Free memory */
N_VDestroy(y); /* Free y vector */
if (sensi) {
N_VDestroyVectorArray(yS, NS); /* Free yS vector */
}
free(data); /* Free user data */
CVodeFree(&cvode_mem); /* Free CVODES memory */
SUNLinSolFree(LS); /* Free the linear solver memory */
SUNMatDestroy(A); /* Free the matrix memory */
return(0);
}
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 run_rate_state_sim(std::vector<std::vector<realtype> > &results, RSParams ¶ms) {
realtype long_term_reltol, event_reltol, t, tout, tbase=0;
N_Vector y, long_term_abstol, event_abstol;
unsigned int i, n;
int flag, err_code;
void *long_term_cvode, *event_cvode, *current_cvode;
// Create serial vector of length NEQ for I.C. and abstol
y = N_VNew_Serial(params.num_eqs()*params.num_blocks());
if (check_flag((void *)y, "N_VNew_Serial", 0)) return(1);
long_term_abstol = N_VNew_Serial(params.num_eqs()*params.num_blocks());
if (check_flag((void *)long_term_abstol, "N_VNew_Serial", 0)) return(1);
event_abstol = N_VNew_Serial(params.num_eqs()*params.num_blocks());
if (check_flag((void *)event_abstol, "N_VNew_Serial", 0)) return(1);
// Initialize y
for (i=0;i<params.num_blocks();++i) {
NV_Ith_S(y,i*params.num_eqs()+EQ_X) = params.init_val(i, EQ_X);
NV_Ith_S(y,i*params.num_eqs()+EQ_V) = params.init_val(i, EQ_V);
NV_Ith_S(y,i*params.num_eqs()+EQ_H) = params.init_val(i, EQ_H);
}
/* Initialize interactions */
/*interaction = new realtype[NBLOCKS*NBLOCKS];
double int_level = 1e-2;
double dropoff = 1.1;
for (i=0;i<NBLOCKS;++i) {
for (n=0;n<NBLOCKS;++n) {
interaction[i*NBLOCKS+n] = (i==n?(1.0-int_level):int_level);
}
}*/
/* Set the scalar relative tolerance */
long_term_reltol = RCONST(1.0e-12);
event_reltol = RCONST(1.0e-12);
/* Set the vector absolute tolerance */
for (i=0;i<params.num_blocks();++i) {
Xth(long_term_abstol,i) = RCONST(1.0e-12);
Vth(long_term_abstol,i) = RCONST(1.0e-12);
Hth(long_term_abstol,i) = RCONST(1.0e-12);
Xth(event_abstol,i) = RCONST(1.0e-12);
Vth(event_abstol,i) = RCONST(1.0e-12);
Hth(event_abstol,i) = RCONST(1.0e-12);
}
/* Call CVodeCreate to create the solver memory and specify the
* Backward Differentiation Formula and the use of a Newton iteration */
long_term_cvode = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)long_term_cvode, "CVodeCreate", 0)) return(1);
event_cvode = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)event_cvode, "CVodeCreate", 0)) return(1);
// Turn off error messages
//CVodeSetErrFile(long_term_cvode, NULL);
//CVodeSetErrFile(event_cvode, NULL);
/* Call CVodeInit to initialize the integrator memory and specify the
* user's right hand side function in y'=f(t,y), the inital time T0, and
* the initial dependent variable vector y. */
flag = CVodeInit(long_term_cvode, func, T0, y);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
flag = CVodeInit(event_cvode, func, T0, y);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
/* Call CVodeSVtolerances to specify the scalar relative tolerance
* and vector absolute tolerances */
flag = CVodeSVtolerances(long_term_cvode, long_term_reltol, long_term_abstol);
if (check_flag(&flag, "CVodeSVtolerances", 1)) return(1);
flag = CVodeSVtolerances(event_cvode, event_reltol, event_abstol);
if (check_flag(&flag, "CVodeSVtolerances", 1)) return(1);
/* Set the root finding function */
//flag = CVodeRootInit(long_term_cvode, params.num_blocks(), vel_switch_finder);
//flag = CVodeRootInit(event_cvode, params.num_blocks(), vel_switch_finder);
//if (check_flag(&flag, "CVodeRootInit", 1)) return(1);
/* Call CVDense to specify the CVDENSE dense linear solver */
//flag = CVSpbcg(cvode_mem, PREC_NONE, 0);
//if (check_flag(&flag, "CVSpbcg", 1)) return(1);
//flag = CVSpgmr(cvode_mem, PREC_NONE, 0);
//if (check_flag(&flag, "CVSpgmr", 1)) return(1);
flag = CVDense(long_term_cvode, params.num_eqs()*params.num_blocks());
if (check_flag(&flag, "CVDense", 1)) return(1);
flag = CVDense(event_cvode, params.num_eqs()*params.num_blocks());
if (check_flag(&flag, "CVDense", 1)) return(1);
flag = CVodeSetUserData(long_term_cvode, ¶ms);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
flag = CVodeSetUserData(event_cvode, ¶ms);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
CVodeSetMaxNumSteps(long_term_cvode, 100000);
CVodeSetMaxNumSteps(event_cvode, 100000);
/* Set the Jacobian routine to Jac (user-supplied) */
flag = CVDlsSetDenseJacFn(long_term_cvode, Jac);
if (check_flag(&flag, "CVDlsSetDenseJacFn", 1)) return(1);
flag = CVDlsSetDenseJacFn(event_cvode, Jac);
if (check_flag(&flag, "CVDlsSetDenseJacFn", 1)) return(1);
/* In loop, call CVode, print results, and test for error.
Break out of loop when NOUT preset output times have been reached. */
tout = T0+params.time_step();
err_code = 0;
int mode = 0;
int num_res_vals = params.num_eqs()*params.num_blocks();
while(t+tbase < params.end_time()) {
switch (mode) {
case 0:
current_cvode = long_term_cvode;
break;
case 1:
current_cvode = event_cvode;
break;
}
flag = CVode(current_cvode, tout, y, &t, CV_NORMAL);
record_results(results, y, t, tbase, num_res_vals);
if (check_flag(&flag, "CVode", 1)) {
err_code = flag;
break;
}
if (flag == CV_ROOT_RETURN) {
int flagr;
int rootsfound[params.num_blocks()];
flagr = CVodeGetRootInfo(current_cvode, rootsfound);
if (check_flag(&flagr, "CVodeGetRootInfo", 1)) return(1);
//mode = !mode;
//std::cerr << rootsfound[0] << std::endl;
}
if (flag == CV_SUCCESS) tout += params.time_step();
if (t > 10) {
t -= 10;
tout -= 10;
Xth(y,0) -= 10;
tbase += 10;
CVodeReInit(current_cvode, t, y);
}
}
std::cerr << err_code <<
" X:" << Xth(y,0) <<
" V:" << Vth(y,0) <<
" H:" << Hth(y,0) <<
" F:" << F(0,Vth(y,0),Hth(y,0),params) <<
" dV:" << (Xth(y,0)-t-params.param(0, K_PARAM)*F(0,Vth(y,0),Hth(y,0),params))/params.param(0, R_PARAM) <<
" dH:" << -Hth(y,0)*Vth(y,0)*log(Hth(y,0)*Vth(y,0)) << std::endl;
/* Print some final statistics */
//PrintFinalStats(cvode_mem);
/* Free y and abstol vectors */
N_VDestroy_Serial(y);
N_VDestroy_Serial(long_term_abstol);
N_VDestroy_Serial(event_abstol);
/* Free integrator memory */
CVodeFree(&long_term_cvode);
return err_code;
}
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);
}
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);
}
Bloch_McConnell_CV_Model::Bloch_McConnell_CV_Model () {
m_world->solverSettings = new bmnvec;
/* for (int i=0;i<OPT_SIZE;i++) {m_iopt[i]=0; m_ropt[i]=0.0;}
m_iopt[MXSTEP] = 1000000;
m_ropt[HMAX] = 10000.0;// the maximum stepsize in msec of the integrator*/
m_reltol = RTOL;
//cvode2.5:
// create cvode memory pointer; no mallocs done yet.
// m_cvode_mem = CVodeCreate(CV_BDF,CV_NEWTON);
m_cvode_mem = CVodeCreate(CV_ADAMS,CV_FUNCTIONAL);
// cvode allocate memory.
// do CVodeMalloc with dummy values y0,abstol once here;
// -> CVodeReInit can later be used
//HACK
int pools = m_world->GetNoOfCompartments();
N_Vector y0,abstol;
y0 = N_VNew_Serial(NEQ*pools);
abstol = N_VNew_Serial(NEQ*pools);
((bmnvec*) (m_world->solverSettings))->abstol = N_VNew_Serial(pools*NEQ);
for(int i = 0; i< pools*NEQ; i+=NEQ){
NV_Ith_S(y0,AMPL+i) = 0.0; NV_Ith_S(y0,PHASE+i) = 0.0; NV_Ith_S(y0,ZC+i) = 0.0;
NV_Ith_S(abstol,AMPL+i) = ATOL1; NV_Ith_S(abstol,PHASE+i) = ATOL2; NV_Ith_S(abstol,ZC+i) = ATOL3;
}
#ifndef CVODE26
if(CVodeMalloc(m_cvode_mem,bloch,0,y0,CV_SV,m_reltol,abstol) != CV_SUCCESS ) {
cout << "CVodeMalloc failed! aborting..." << endl;exit (-1);
}
if(CVodeSetFdata(m_cvode_mem, (void *) m_world) !=CV_SUCCESS) {
cout << "CVode function data could not be set. Panic!" << endl;exit (-1);
}
#else
if(CVodeInit(m_cvode_mem,bloch,0,y0) != CV_SUCCESS ) {
cout << "CVodeInit failed! aborting..." << endl;exit (-1);
}
if(CVodeSVtolerances(m_cvode_mem, m_reltol, abstol)!= CV_SUCCESS){
cout << "CVodeSVtolerances failed! aborting..." << endl;exit (-1);
}
if(CVodeSetUserData(m_cvode_mem, (void *) m_world) !=CV_SUCCESS) {
cout << "CVode function data could not be set. Panic!" << endl;exit (-1);
}
#endif
/* int flag;
int blub = (3*pools);
flag = CVDense(m_cvode_mem, blub);
if (flag == CVDENSE_SUCCESS)
cout<< "great" <<endl;
else
cout<< "bad" <<endl;
*/
N_VDestroy_Serial(y0);
N_VDestroy_Serial(abstol);
/*if(CVodeSetFdata(m_cvode_mem, (void *) m_world) !=CV_SUCCESS) {
cout << "CVode function data could not be set. Panic!" << endl;
exit (-1);
}
// set CVODE initial step size
// CVodeSetInitStep(m_cvode_mem, 1e-4);
// set CVODE maximum step size
CVodeSetMaxErrTestFails(m_cvode_mem, 10);
// set CVODE minimum step size
CVodeSetMinStep(m_cvode_mem, 1e-15);
*/
CVodeSetMaxNumSteps(m_cvode_mem, 10000000);
// maximum number of warnings t+h = t (if number negative -> no warnings are issued )
CVodeSetMaxHnilWarns(m_cvode_mem,2);
}
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[])
{
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 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);
}
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(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[])
{
void *cvode_mem;
UserData data;
realtype t, tout;
N_Vector y;
int iout, flag, nthreads, nnz;
realtype pbar[NS];
int is;
N_Vector *yS;
booleantype sensi, err_con;
int sensi_meth;
cvode_mem = NULL;
data = NULL;
y = NULL;
yS = NULL;
/* Process arguments */
ProcessArgs(argc, argv, &sensi, &sensi_meth, &err_con);
/* User data structure */
data = (UserData) malloc(sizeof *data);
if (check_flag((void *)data, "malloc", 2)) return(1);
data->p[0] = RCONST(0.04);
data->p[1] = RCONST(1.0e4);
data->p[2] = RCONST(3.0e7);
/* Initial conditions */
y = N_VNew_Serial(NEQ);
if (check_flag((void *)y, "N_VNew_Serial", 0)) return(1);
Ith(y,1) = Y1;
Ith(y,2) = Y2;
Ith(y,3) = Y3;
/* Call CVodeCreate to create the solver memory and specify the
Backward Differentiation Formula and the use of a Newton iteration */
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
/* Call CVodeInit to initialize the integrator memory and specify the
user's right hand side function in y'=f(t,y), the initial time T0, and
the initial dependent variable vector y. */
flag = CVodeInit(cvode_mem, f, T0, y);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
/* Call CVodeWFtolerances to specify a user-supplied function ewt that sets
the multiplicative error weights W_i for use in the weighted RMS norm */
flag = CVodeWFtolerances(cvode_mem, ewt);
if (check_flag(&flag, "CVodeSetEwtFn", 1)) return(1);
/* Attach user data */
flag = CVodeSetUserData(cvode_mem, data);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
/* Call CVKLU to specify the CVKLU sparse direct linear solver */
nthreads = 1; /* no. of threads to use when factoring the system*/
nnz = NEQ * NEQ; /* max no. of nonzeros entries in the Jac */
flag = CVSuperLUMT(cvode_mem, nthreads, NEQ, nnz);
if (check_flag(&flag, "CVSuperLUMT", 1)) return(1);
/* Set the Jacobian routine to Jac (user-supplied) */
flag = CVSlsSetSparseJacFn(cvode_mem, Jac);
if (check_flag(&flag, "CVSlsSetSparseJacFn", 1)) return(1);
printf("\n3-species chemical kinetics problem\n");
/* Sensitivity-related settings */
if (sensi) {
/* Set parameter scaling factor */
pbar[0] = data->p[0];
pbar[1] = data->p[1];
pbar[2] = data->p[2];
/* Set sensitivity initial conditions */
yS = N_VCloneVectorArray_Serial(NS, y);
if (check_flag((void *)yS, "N_VCloneVectorArray_Serial", 0)) return(1);
for (is=0;is<NS;is++) N_VConst(ZERO, yS[is]);
/* Call CVodeSensInit1 to activate forward sensitivity computations
and allocate internal memory for COVEDS related to sensitivity
calculations. Computes the right-hand sides of the sensitivity
ODE, one at a time */
flag = CVodeSensInit1(cvode_mem, NS, sensi_meth, fS, yS);
if(check_flag(&flag, "CVodeSensInit", 1)) return(1);
/* Call CVodeSensEEtolerances to estimate tolerances for sensitivity
variables based on the rolerances supplied for states variables and
the scaling factor pbar */
flag = CVodeSensEEtolerances(cvode_mem);
if(check_flag(&flag, "CVodeSensEEtolerances", 1)) return(1);
/* Set sensitivity analysis optional inputs */
/* Call CVodeSetSensErrCon to specify the error control strategy for
sensitivity variables */
flag = CVodeSetSensErrCon(cvode_mem, err_con);
if (check_flag(&flag, "CVodeSetSensErrCon", 1)) return(1);
/* Call CVodeSetSensParams to specify problem parameter information for
sensitivity calculations */
flag = CVodeSetSensParams(cvode_mem, NULL, pbar, NULL);
if (check_flag(&flag, "CVodeSetSensParams", 1)) return(1);
printf("Sensitivity: YES ");
if(sensi_meth == CV_SIMULTANEOUS)
printf("( SIMULTANEOUS +");
else
if(sensi_meth == CV_STAGGERED) printf("( STAGGERED +");
else printf("( STAGGERED1 +");
if(err_con) printf(" FULL ERROR CONTROL )");
else printf(" PARTIAL ERROR CONTROL )");
} else {
printf("Sensitivity: NO ");
}
/* In loop over output points, call CVode, print results, test for error */
printf("\n\n");
printf("===========================================");
printf("============================\n");
printf(" T Q H NST y1");
printf(" y2 y3 \n");
printf("===========================================");
printf("============================\n");
for (iout=1, tout=T1; iout <= NOUT; iout++, tout *= TMULT) {
flag = CVode(cvode_mem, tout, y, &t, CV_NORMAL);
if (check_flag(&flag, "CVode", 1)) break;
PrintOutput(cvode_mem, t, y);
/* Call CVodeGetSens to get the sensitivity solution vector after a
successful return from CVode */
if (sensi) {
flag = CVodeGetSens(cvode_mem, &t, yS);
if (check_flag(&flag, "CVodeGetSens", 1)) break;
PrintOutputS(yS);
}
printf("-----------------------------------------");
printf("------------------------------\n");
}
/* Print final statistics */
PrintFinalStats(cvode_mem, sensi);
/* Free memory */
N_VDestroy_Serial(y); /* Free y vector */
if (sensi) {
N_VDestroyVectorArray_Serial(yS, NS); /* Free yS vector */
}
free(data); /* Free user data */
CVodeFree(&cvode_mem); /* Free CVODES memory */
return(0);
}
/*
* 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);
}
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);
}
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(int narg, char **args)
{
realtype reltol, t, tout;
N_Vector state, abstol;
void *cvode_mem;
int flag, flagr;
int rootsfound[NRF];
int rootdir[] = {1,1,1,};
FILE *pout;
pout = stdout;
state = abstol = NULL;
cvode_mem = NULL;
state = N_VNew_Serial(NEQ);
if (check_flag((void *)state, "N_VNew_Serial", 0)) return(1);
abstol = N_VNew_Serial(NEQ);
if (check_flag((void *)abstol, "N_VNew_Serial", 0)) return(1);
realtype a = 0.02;
realtype b = 0.2;
realtype c = -50;
realtype d = 2;
realtype I = 0;
realtype v0 = -70;
realtype p[] = {a, b, c, d, I, v0, };
realtype v = v0;
realtype u = b * v0;
NV_Ith_S(state, 0) = v0;
NV_Ith_S(state, 1) = b * v0;
reltol = RTOL;
NV_Ith_S(abstol,0) = ATOL0;
NV_Ith_S(abstol,1) = ATOL1;
/* Allocations and initializations */
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
flag = CVodeInit(cvode_mem, dstate_dt, T0, state);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
flag = CVodeSetUserData(cvode_mem, p);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
flag = CVodeSVtolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSVtolerances", 1)) return(1);
flag = CVodeRootInit(cvode_mem, NRF, root_functions);
if (check_flag(&flag, "CVodeRootInit", 1)) return(1);
CVodeSetRootDirection(cvode_mem, rootdir);
if (check_flag(&flag, "CVodeSetRootDirection", 1)) return(1);
flag = CVDense(cvode_mem, NEQ);
if (check_flag(&flag, "CVDense", 1)) return(1);
printf(" \n Integrating izhikevich_burster \n\n");
printf("#t v, u, \n");
PrintOutput(pout, t, state);
tout = DT;
while(1) {
flag = CVode(cvode_mem, tout, state, &t, CV_NORMAL);
if(flag == CV_ROOT_RETURN) {
/* Event detected */
flagr = CVodeGetRootInfo(cvode_mem, rootsfound);
if (check_flag(&flagr, "CVodeGetRootInfo", 1)) return(1);
PrintRootInfo(t, state, rootsfound);
if(rootsfound[0]){
//spike
v = NV_Ith_S(state, 0);
u = NV_Ith_S(state, 1);
NV_Ith_S(state, 0) = c;
NV_Ith_S(state, 1) = u + d;
}
if(rootsfound[1]){
//start_inj
I = 5;
p[0] = a;
p[1] = b;
p[2] = c;
p[3] = d;
p[4] = I;
p[5] = v0;
}
if(rootsfound[2]){
//end_inj
I = 0;
p[0] = a;
p[1] = b;
p[2] = c;
p[3] = d;
p[4] = I;
p[5] = v0;
}
/* Restart integration with event-corrected state */
flag = CVodeSetUserData(cvode_mem, p);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
CVodeReInit(cvode_mem, t, state);
//PrintRootInfo(t, state, rootsfound);
}
else
{
PrintOutput(pout, t, state);
if(check_flag(&flag, "CVode", 1)) break;
if(flag == CV_SUCCESS) {
tout += DT;
}
if (t >= T1) break;
}
}
PrintFinalStats(cvode_mem);
N_VDestroy_Serial(state);
N_VDestroy_Serial(abstol);
CVodeFree(&cvode_mem);
fclose(pout);
return(0);
}
int main()
{
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()
{
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()
{
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);
}
int main(int narg, char **args)
{
realtype reltol, t, tout;
N_Vector state, abstol;
void *cvode_mem;
int flag, flagr;
int rootsfound[NRF];
int rootdir[] = {1,};
FILE *pout;
if(!(pout = fopen("results/iaf_v.dat", "w"))){
fprintf(stderr, "Cannot open file results/iaf_v.dat. Are you trying to write to a non-existent directory? Exiting...\n");
exit(1);
}
state = abstol = NULL;
cvode_mem = NULL;
state = N_VNew_Serial(NEQ);
if (check_flag((void *)state, "N_VNew_Serial", 0)) return(1);
abstol = N_VNew_Serial(NEQ);
if (check_flag((void *)abstol, "N_VNew_Serial", 0)) return(1);
realtype reset = -0.07;
realtype C = 3.2e-12;
realtype thresh = -0.055;
realtype gleak = 2e-10;
realtype eleak = -0.053;
realtype p[] = {reset, C, thresh, gleak, eleak, };
realtype v = reset;
NV_Ith_S(state, 0) = reset;
reltol = RTOL;
NV_Ith_S(abstol,0) = ATOL0;
/* Allocations and initializations */
cvode_mem = CVodeCreate(CV_BDF, CV_NEWTON);
if (check_flag((void *)cvode_mem, "CVodeCreate", 0)) return(1);
flag = CVodeInit(cvode_mem, dstate_dt, T0, state);
if (check_flag(&flag, "CVodeInit", 1)) return(1);
flag = CVodeSetUserData(cvode_mem, p);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
flag = CVodeSVtolerances(cvode_mem, reltol, abstol);
if (check_flag(&flag, "CVodeSVtolerances", 1)) return(1);
flag = CVodeRootInit(cvode_mem, NRF, root_functions);
if (check_flag(&flag, "CVodeRootInit", 1)) return(1);
CVodeSetRootDirection(cvode_mem, rootdir);
if (check_flag(&flag, "CVodeSetRootDirection", 1)) return(1);
flag = CVDense(cvode_mem, NEQ);
if (check_flag(&flag, "CVDense", 1)) return(1);
printf(" \n Integrating iaf \n\n");
printf("#t v, \n");
PrintOutput(pout, t, state);
tout = DT;
while(1) {
flag = CVode(cvode_mem, tout, state, &t, CV_NORMAL);
if(flag == CV_ROOT_RETURN) {
/* Event detected */
flagr = CVodeGetRootInfo(cvode_mem, rootsfound);
if (check_flag(&flagr, "CVodeGetRootInfo", 1)) return(1);
PrintRootInfo(t, state, rootsfound);
if(rootsfound[0]){
//condition_0
v = NV_Ith_S(state, 0);
NV_Ith_S(state, 0) = reset;
}
/* Restart integration with event-corrected state */
flag = CVodeSetUserData(cvode_mem, p);
if (check_flag(&flag, "CVodeSetUserData", 1)) return(1);
CVodeReInit(cvode_mem, t, state);
//PrintRootInfo(t, state, rootsfound);
}
else
{
PrintOutput(pout, t, state);
if(check_flag(&flag, "CVode", 1)) break;
if(flag == CV_SUCCESS) {
tout += DT;
}
if (t >= T1) break;
}
}
PrintFinalStats(cvode_mem);
N_VDestroy_Serial(state);
N_VDestroy_Serial(abstol);
CVodeFree(&cvode_mem);
fclose(pout);
return(0);
}
int main(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);
}
/*
** ========
** 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;
}