void FIDA_CALCIC(int *icopt, realtype *tout1, int *ier)
{
*ier = 0;
*ier = IDACalcIC(IDA_idamem, *icopt, *tout1);
return;
}
int main(int argc, char *argv[])
{
MPI_Comm comm;
void *mem;
UserData webdata;
long int SystemSize, local_N, mudq, mldq, mukeep, mlkeep;
realtype rtol, atol, t0, tout, tret;
N_Vector cc, cp, res, id;
int thispe, npes, maxl, iout, retval;
cc = cp = res = id = NULL;
webdata = NULL;
mem = NULL;
/* Set communicator, and get processor number and total number of PE's. */
MPI_Init(&argc, &argv);
comm = MPI_COMM_WORLD;
MPI_Comm_rank(comm, &thispe);
MPI_Comm_size(comm, &npes);
if (npes != NPEX*NPEY) {
if (thispe == 0)
fprintf(stderr,
"\nMPI_ERROR(0): npes = %d not equal to NPEX*NPEY = %d\n",
npes, NPEX*NPEY);
MPI_Finalize();
return(1);
}
/* Set local length (local_N) and global length (SystemSize). */
local_N = MXSUB*MYSUB*NUM_SPECIES;
SystemSize = NEQ;
/* Set up user data block webdata. */
webdata = (UserData) malloc(sizeof *webdata);
webdata->rates = N_VNew_Parallel(comm, local_N, SystemSize);
webdata->acoef = newDenseMat(NUM_SPECIES, NUM_SPECIES);
InitUserData(webdata, thispe, npes, comm);
/* Create needed vectors, and load initial values.
The vector res is used temporarily only. */
cc = N_VNew_Parallel(comm, local_N, SystemSize);
if(check_flag((void *)cc, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1);
cp = N_VNew_Parallel(comm, local_N, SystemSize);
if(check_flag((void *)cp, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1);
res = N_VNew_Parallel(comm, local_N, SystemSize);
if(check_flag((void *)res, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1);
id = N_VNew_Parallel(comm, local_N, SystemSize);
if(check_flag((void *)id, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1);
SetInitialProfiles(cc, cp, id, res, webdata);
N_VDestroy_Parallel(res);
/* Set remaining inputs to IDAMalloc. */
t0 = ZERO;
rtol = RTOL;
atol = ATOL;
/* Call IDACreate and IDAMalloc to initialize solution */
mem = IDACreate();
if(check_flag((void *)mem, "IDACreate", 0, thispe)) MPI_Abort(comm, 1);
retval = IDASetUserData(mem, webdata);
if(check_flag(&retval, "IDASetUserData", 1, thispe)) MPI_Abort(comm, 1);
retval = IDASetId(mem, id);
if(check_flag(&retval, "IDASetId", 1, thispe)) MPI_Abort(comm, 1);
retval = IDAInit(mem, resweb, t0, cc, cp);
if(check_flag(&retval, "IDAInit", 1, thispe)) MPI_Abort(comm, 1);
retval = IDASStolerances(mem, rtol, atol);
if(check_flag(&retval, "IDASStolerances", 1, thispe)) MPI_Abort(comm, 1);
/* Call IDASpgmr to specify the IDA linear solver IDASPGMR */
maxl = 16;
retval = IDASpgmr(mem, maxl);
if(check_flag(&retval, "IDASpgmr", 1, thispe)) MPI_Abort(comm, 1);
/* Call IDABBDPrecInit to initialize the band-block-diagonal preconditioner.
The half-bandwidths for the difference quotient evaluation are exact
for the system Jacobian, but only a 5-diagonal band matrix is retained. */
mudq = mldq = NSMXSUB;
mukeep = mlkeep = 2;
retval = IDABBDPrecInit(mem, local_N, mudq, mldq, mukeep, mlkeep,
ZERO, reslocal, NULL);
if(check_flag(&retval, "IDABBDPrecInit", 1, thispe)) MPI_Abort(comm, 1);
/* Call IDACalcIC (with default options) to correct the initial values. */
tout = RCONST(0.001);
retval = IDACalcIC(mem, IDA_YA_YDP_INIT, tout);
if(check_flag(&retval, "IDACalcIC", 1, thispe)) MPI_Abort(comm, 1);
/* On PE 0, print heading, basic parameters, initial values. */
if (thispe == 0) PrintHeader(SystemSize, maxl,
mudq, mldq, mukeep, mlkeep,
rtol, atol);
PrintOutput(mem, cc, t0, webdata, comm);
/* Call IDA in tout loop, normal mode, and print selected output. */
for (iout = 1; iout <= NOUT; iout++) {
retval = IDASolve(mem, tout, &tret, cc, cp, IDA_NORMAL);
if(check_flag(&retval, "IDASolve", 1, thispe)) MPI_Abort(comm, 1);
PrintOutput(mem, cc, tret, webdata, comm);
if (iout < 3) tout *= TMULT;
else tout += TADD;
}
/* On PE 0, print final set of statistics. */
if (thispe == 0) PrintFinalStats(mem);
/* Free memory. */
N_VDestroy_Parallel(cc);
N_VDestroy_Parallel(cp);
N_VDestroy_Parallel(id);
IDAFree(&mem);
destroyMat(webdata->acoef);
N_VDestroy_Parallel(webdata->rates);
free(webdata);
MPI_Finalize();
return(0);
}
void IdaSolver::initialize(const double &pVoiStart, const double &pVoiEnd,
const int &pStatesCount, const int &pCondVarCount,
double *pConstants, double *pRates, double *pStates,
double *pAlgebraic, double *pCondVar,
ComputeEssentialVariablesFunction pComputeEssentialVariables,
ComputeResidualsFunction pComputeResiduals,
ComputeRootInformationFunction pComputeRootInformation,
ComputeStateInformationFunction pComputeStateInformation)
{
static const double VoiEpsilon = 1.0e-9;
if (!mSolver) {
// Initialise the ODE solver itself
OpenCOR::CoreSolver::CoreDaeSolver::initialize(pVoiStart, pVoiEnd,
pStatesCount,
pCondVarCount,
pConstants, pRates,
pStates, pAlgebraic,
pCondVar,
pComputeEssentialVariables,
pComputeResiduals,
pComputeRootInformation,
pComputeStateInformation);
// Retrieve some of the IDA properties
if (mProperties.contains(MaximumStepProperty))
mMaximumStep = mProperties.value(MaximumStepProperty).toDouble();
else
emit error(QObject::tr("the 'maximum step' property value could not be retrieved"));
if (mProperties.contains(MaximumNumberOfStepsProperty))
mMaximumNumberOfSteps = mProperties.value(MaximumNumberOfStepsProperty).toInt();
else
emit error(QObject::tr("the 'maximum number of steps' property value could not be retrieved"));
if (mProperties.contains(RelativeToleranceProperty))
mRelativeTolerance = mProperties.value(RelativeToleranceProperty).toDouble();
else
emit error(QObject::tr("the 'relative tolerance' property value could not be retrieved"));
if (mProperties.contains(AbsoluteToleranceProperty))
mAbsoluteTolerance = mProperties.value(AbsoluteToleranceProperty).toDouble();
else
emit error(QObject::tr("the 'absolute tolerance' property value could not be retrieved"));
// Create the states vector
mStatesVector = N_VMake_Serial(pStatesCount, pStates);
mRatesVector = N_VMake_Serial(pStatesCount, pRates);
// Create the IDA solver
mSolver = IDACreate();
// Use our own error handler
IDASetErrHandlerFn(mSolver, errorHandler, this);
// Initialise the IDA solver
IDAInit(mSolver, residualFunction, pVoiStart,
mStatesVector, mRatesVector);
IDARootInit(mSolver, pCondVarCount, rootFindingFunction);
//---GRY--- NEED TO CHECK THAT OUR IDA CODE WORKS AS EXPECTED BY TRYING
// IT OUT ON A MODEL WHICH NEEDS ROOT FINDING (E.G. THE
// SAUCERMAN MODEL)...
// Set some user data
delete mUserData; // Just in case the solver got initialised before
mUserData = new IdaSolverUserData(pConstants, pAlgebraic, pCondVar,
pComputeEssentialVariables,
pComputeResiduals,
pComputeRootInformation);
IDASetUserData(mSolver, mUserData);
// Set the linear solver
IDADense(mSolver, pStatesCount);
// Set the maximum step
IDASetMaxStep(mSolver, mMaximumStep);
// Set the maximum number of steps
IDASetMaxNumSteps(mSolver, mMaximumNumberOfSteps);
// Set the relative and absolute tolerances
IDASStolerances(mSolver, mRelativeTolerance, mAbsoluteTolerance);
// Compute the model's initial conditions
// Note: this requires retrieving the model's state information, setting
// the IDA object's id vector and then calling IDACalcIC()...
double *id = new double[pStatesCount];
pComputeStateInformation(id);
N_Vector idVector = N_VMake_Serial(pStatesCount, id);
IDASetId(mSolver, idVector);
IDACalcIC(mSolver, IDA_YA_YDP_INIT,
pVoiStart+((pVoiEnd-pVoiStart > 0)?VoiEpsilon:-VoiEpsilon));
N_VDestroy_Serial(idVector);
delete[] id;
} else {
// Reinitialise the IDA object
IDAReInit(mSolver, pVoiStart, mStatesVector, mRatesVector);
// Compute the model's new initial conditions
IDACalcIC(mSolver, IDA_YA_YDP_INIT,
pVoiStart+((pVoiEnd-pVoiStart > 0)?VoiEpsilon:-VoiEpsilon));
}
}
int main(int argc, char *argv[])
{
MPI_Comm comm;
void *mem;
UserData webdata;
long int SystemSize, local_N;
realtype rtol, atol, t0, tout, tret;
N_Vector cc, cp, res, id;
int thispe, npes, maxl, iout, flag;
cc = cp = res = id = NULL;
webdata = NULL;
mem = NULL;
/* Set communicator, and get processor number and total number of PE's. */
MPI_Init(&argc, &argv);
comm = MPI_COMM_WORLD;
MPI_Comm_rank(comm, &thispe);
MPI_Comm_size(comm, &npes);
if (npes != NPEX*NPEY) {
if (thispe == 0)
fprintf(stderr,
"\nMPI_ERROR(0): npes = %d not equal to NPEX*NPEY = %d\n",
npes, NPEX*NPEY);
MPI_Finalize();
return(1);
}
/* Set local length (local_N) and global length (SystemSize). */
local_N = MXSUB*MYSUB*NUM_SPECIES;
SystemSize = NEQ;
/* Set up user data block webdata. */
webdata = AllocUserData(comm, local_N, SystemSize);
if (check_flag((void *)webdata, "AllocUserData", 0, thispe)) MPI_Abort(comm, 1);
InitUserData(webdata, thispe, npes, comm);
/* Create needed vectors, and load initial values.
The vector res is used temporarily only. */
cc = N_VNew_Parallel(comm, local_N, SystemSize);
if (check_flag((void *)cc, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1);
cp = N_VNew_Parallel(comm, local_N, SystemSize);
if (check_flag((void *)cp, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1);
res = N_VNew_Parallel(comm, local_N, SystemSize);
if (check_flag((void *)res, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1);
id = N_VNew_Parallel(comm, local_N, SystemSize);
if (check_flag((void *)id, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1);
SetInitialProfiles(cc, cp, id, res, webdata);
N_VDestroy(res);
/* Set remaining inputs to IDAMalloc. */
t0 = ZERO;
rtol = RTOL;
atol = ATOL;
/* Call IDACreate and IDAMalloc to initialize IDA.
A pointer to IDA problem memory is returned and stored in idamem. */
mem = IDACreate();
if (check_flag((void *)mem, "IDACreate", 0, thispe)) MPI_Abort(comm, 1);
flag = IDASetUserData(mem, webdata);
if (check_flag(&flag, "IDASetUserData", 1, thispe)) MPI_Abort(comm, 1);
flag = IDASetId(mem, id);
if (check_flag(&flag, "IDASetId", 1, thispe)) MPI_Abort(comm, 1);
flag = IDAInit(mem, resweb, t0, cc, cp);
if (check_flag(&flag, "IDAinit", 1, thispe)) MPI_Abort(comm, 1);
flag = IDASStolerances(mem, rtol, atol);
if (check_flag(&flag, "IDASStolerances", 1, thispe)) MPI_Abort(comm, 1);
webdata->ida_mem = mem;
/* Call IDASpgmr to specify the IDA linear solver IDASPGMR and specify
the preconditioner routines supplied (Precondbd and PSolvebd).
maxl (max. Krylov subspace dim.) is set to 16. */
maxl = 16;
flag = IDASpgmr(mem, maxl);
if (check_flag(&flag, "IDASpgmr", 1, thispe))
MPI_Abort(comm, 1);
flag = IDASpilsSetPreconditioner(mem, Precondbd, PSolvebd);
if (check_flag(&flag, "IDASpilsSetPreconditioner", 1, thispe))
MPI_Abort(comm, 1);
/* Call IDACalcIC (with default options) to correct the initial values. */
tout = RCONST(0.001);
flag = IDACalcIC(mem, IDA_YA_YDP_INIT, tout);
if (check_flag(&flag, "IDACalcIC", 1, thispe))
MPI_Abort(comm, 1);
/* On PE 0, print heading, basic parameters, initial values. */
if (thispe == 0) PrintHeader(SystemSize, maxl, rtol, atol);
PrintOutput(mem, cc, t0, webdata, comm);
/* Loop over iout, call IDASolve (normal mode), print selected output. */
for (iout = 1; iout <= NOUT; iout++) {
flag = IDASolve(mem, tout, &tret, cc, cp, IDA_NORMAL);
if (check_flag(&flag, "IDASolve", 1, thispe)) MPI_Abort(comm, 1);
PrintOutput(mem, cc, tret, webdata, comm);
if (iout < 3) tout *= TMULT;
else tout += TADD;
}
/* On PE 0, print final set of statistics. */
if (thispe == 0) PrintFinalStats(mem);
/* Free memory. */
N_VDestroy_Parallel(cc);
N_VDestroy_Parallel(cp);
N_VDestroy_Parallel(id);
IDAFree(&mem);
FreeUserData(webdata);
MPI_Finalize();
return(0);
}
int main(void)
{
void *mem;
UserData data;
N_Vector uu, up, constraints, id, res;
int ier, iout;
long int mu, ml, netf, ncfn;
realtype rtol, atol, t0, t1, tout, tret;
mem = NULL;
data = NULL;
uu = up = constraints = id = res = NULL;
/* Create vectors uu, up, res, constraints, id. */
uu = N_VNew_Serial(NEQ);
if(check_flag((void *)uu, "N_VNew_Serial", 0)) return(1);
up = N_VNew_Serial(NEQ);
if(check_flag((void *)up, "N_VNew_Serial", 0)) return(1);
res = N_VNew_Serial(NEQ);
if(check_flag((void *)res, "N_VNew_Serial", 0)) return(1);
constraints = N_VNew_Serial(NEQ);
if(check_flag((void *)constraints, "N_VNew_Serial", 0)) return(1);
id = N_VNew_Serial(NEQ);
if(check_flag((void *)id, "N_VNew_Serial", 0)) return(1);
/* Create and load problem data block. */
data = (UserData) malloc(sizeof *data);
if(check_flag((void *)data, "malloc", 2)) return(1);
data->mm = MGRID;
data->dx = ONE/(MGRID - ONE);
data->coeff = ONE/( (data->dx) * (data->dx) );
/* Initialize uu, up, id. */
SetInitialProfile(data, uu, up, id, res);
/* Set constraints to all 1's for nonnegative solution values. */
N_VConst(ONE, constraints);
/* Set remaining input parameters. */
t0 = ZERO;
t1 = RCONST(0.01);
rtol = ZERO;
atol = RCONST(1.0e-3);
/* Call IDACreate and IDAMalloc to initialize solution */
mem = IDACreate();
if(check_flag((void *)mem, "IDACreate", 0)) return(1);
ier = IDASetUserData(mem, data);
if(check_flag(&ier, "IDASetUserData", 1)) return(1);
ier = IDASetId(mem, id);
if(check_flag(&ier, "IDASetId", 1)) return(1);
ier = IDASetConstraints(mem, constraints);
if(check_flag(&ier, "IDASetConstraints", 1)) return(1);
N_VDestroy_Serial(constraints);
ier = IDAInit(mem, heatres, t0, uu, up);
if(check_flag(&ier, "IDAInit", 1)) return(1);
ier = IDASStolerances(mem, rtol, atol);
if(check_flag(&ier, "IDASStolerances", 1)) return(1);
/* Call IDABand to specify the linear solver. */
mu = MGRID; ml = MGRID;
ier = IDABand(mem, NEQ, mu, ml);
if(check_flag(&ier, "IDABand", 1)) return(1);
/* Call IDACalcIC to correct the initial values. */
ier = IDACalcIC(mem, IDA_YA_YDP_INIT, t1);
if(check_flag(&ier, "IDACalcIC", 1)) return(1);
/* Print output heading. */
PrintHeader(rtol, atol);
PrintOutput(mem, t0, uu);
/* Loop over output times, call IDASolve, and print results. */
for (tout = t1, iout = 1; iout <= NOUT; iout++, tout *= TWO) {
ier = IDASolve(mem, tout, &tret, uu, up, IDA_NORMAL);
if(check_flag(&ier, "IDASolve", 1)) return(1);
PrintOutput(mem, tret, uu);
}
/* Print remaining counters and free memory. */
ier = IDAGetNumErrTestFails(mem, &netf);
check_flag(&ier, "IDAGetNumErrTestFails", 1);
ier = IDAGetNumNonlinSolvConvFails(mem, &ncfn);
check_flag(&ier, "IDAGetNumNonlinSolvConvFails", 1);
printf("\n netf = %ld, ncfn = %ld \n", netf, ncfn);
IDAFree(&mem);
N_VDestroy_Serial(uu);
N_VDestroy_Serial(up);
N_VDestroy_Serial(id);
N_VDestroy_Serial(res);
free(data);
return(0);
}
/*
* Initial condition
*/
CAMLprim value sundials_ml_ida_calc_ic(value ida_solver, value icopt, value tout1) {
CAMLparam3(ida_solver, icopt, tout1);
const int ret = IDACalcIC(IDA_MEM(ida_solver), Int_val(icopt), Double_val(tout1));
CAMLreturn(Val_int(ret));
}
int main(int argc, char *argv[])
{
MPI_Comm comm;
void *mem;
UserData data;
int thispe, iout, ier, npes;
int Neq, local_N, mudq, mldq, mukeep, mlkeep;
realtype rtol, atol, t0, t1, tout, tret;
N_Vector uu, up, constraints, id, res;
realtype *pbar;
int is;
N_Vector *uuS, *upS;
booleantype sensi, err_con;
int sensi_meth;
mem = NULL;
data = NULL;
uu = up = constraints = id = res = NULL;
uuS = upS = NULL;
/* 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, &thispe);
if (npes != NPEX*NPEY) {
if (thispe == 0)
fprintf(stderr,
"\nMPI_ERROR(0): npes = %d is not equal to NPEX*NPEY = %d\n",
npes,NPEX*NPEY);
MPI_Finalize();
return(1);
}
/* Process arguments */
ProcessArgs(argc, argv, thispe, &sensi, &sensi_meth, &err_con);
/* Set local length local_N and global length Neq. */
local_N = MXSUB*MYSUB;
Neq = MX * MY;
/* Allocate N-vectors. */
uu = N_VNew_Parallel(comm, local_N, Neq);
if(check_flag((void *)uu, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1);
up = N_VNew_Parallel(comm, local_N, Neq);
if(check_flag((void *)up, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1);
res = N_VNew_Parallel(comm, local_N, Neq);
if(check_flag((void *)res, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1);
constraints = N_VNew_Parallel(comm, local_N, Neq);
if(check_flag((void *)constraints, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1);
id = N_VNew_Parallel(comm, local_N, Neq);
if(check_flag((void *)id, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1);
/* Allocate and initialize the data structure. */
data = (UserData) malloc(sizeof *data);
if(check_flag((void *)data, "malloc", 2, thispe)) MPI_Abort(comm, 1);
InitUserData(thispe, comm, data);
/* Initialize the uu, up, id, and constraints profiles. */
SetInitialProfile(uu, up, id, res, data);
N_VConst(ONE, constraints);
t0 = ZERO; t1 = RCONST(0.01);
/* Scalar relative and absolute tolerance. */
rtol = ZERO;
atol = RCONST(1.0e-3);
/* Call IDACreate and IDAInit to initialize solution and various
IDASet*** functions to specify optional inputs:
- indicate which variables are differential and which are algebraic
- exclude algebraic variables from error test
- specify additional constraints on solution components */
mem = IDACreate();
if(check_flag((void *)mem, "IDACreate", 0, thispe)) MPI_Abort(comm, 1);
ier = IDASetUserData(mem, data);
if(check_flag(&ier, "IDASetUserData", 1, thispe)) MPI_Abort(comm, 1);
ier = IDASetSuppressAlg(mem, TRUE);
if(check_flag(&ier, "IDASetSuppressAlg", 1, thispe)) MPI_Abort(comm, 1);
ier = IDASetId(mem, id);
if(check_flag(&ier, "IDASetId", 1, thispe)) MPI_Abort(comm, 1);
ier = IDASetConstraints(mem, constraints);
if(check_flag(&ier, "IDASetConstraints", 1, thispe)) MPI_Abort(comm, 1);
N_VDestroy_Parallel(constraints);
ier = IDAInit(mem, heatres, t0, uu, up);
if(check_flag(&ier, "IDAInit", 1, thispe)) MPI_Abort(comm, 1);
/* Specify state tolerances (scalar relative and absolute tolerances) */
ier = IDASStolerances(mem, rtol, atol);
if(check_flag(&ier, "IDASStolerances", 1, thispe)) MPI_Abort(comm, 1);
/* Call IDASpgmr to specify the linear solver. */
ier = IDASpgmr(mem, 12);
if(check_flag(&ier, "IDASpgmr", 1, thispe)) MPI_Abort(comm, 1);
/* Call IDABBDPrecInit to initialize BBD preconditioner. */
mudq = MXSUB;
mldq = MXSUB;
mukeep = 1;
mlkeep = 1;
ier = IDABBDPrecInit(mem, local_N, mudq, mldq, mukeep, mlkeep,
ZERO, reslocal, NULL);
if(check_flag(&ier, "IDABBDPrecInit", 1, thispe)) MPI_Abort(comm, 1);
/* Sensitivity-related settings */
if( sensi) {
/* Allocate and set pbar, the vector with order of magnitude
information for the problem parameters. (Note: this is
done here as an illustration only, as the default values
for pbar, if pbar is not supplied, are anyway 1.0) */
pbar = (realtype *) malloc(NS*sizeof(realtype));
if (check_flag((void *)pbar, "malloc", 2, thispe)) MPI_Abort(comm, 1);
for (is=0; is<NS; is++) pbar[is] = data->p[is];
/* Allocate sensitivity solution vectors uuS and upS and set them
to an initial guess for the sensitivity ICs (the IC for uuS are
0.0 since the state IC do not depend on the porblem parameters;
however, the derivatives upS may not and therefore we will have
to call IDACalcIC to find them) */
uuS = N_VCloneVectorArray_Parallel(NS, uu);
if (check_flag((void *)uuS, "N_VCloneVectorArray_Parallel", 0, thispe)) MPI_Abort(comm, 1);
for (is = 0; is < NS; is++) N_VConst(ZERO,uuS[is]);
upS = N_VCloneVectorArray_Parallel(NS, uu);
if (check_flag((void *)upS, "N_VCloneVectorArray_Parallel", 0, thispe)) MPI_Abort(comm, 1);
for (is = 0; is < NS; is++) N_VConst(ZERO,upS[is]);
/* Initialize FSA using the default internal sensitivity residual function
(Note that this requires specifying the problem parameters -- see below) */
ier = IDASensInit(mem, NS, sensi_meth, NULL, uuS, upS);
if(check_flag(&ier, "IDASensInit", 1, thispe)) MPI_Abort(comm, 1);
/* Indicate the use of internally estimated tolerances for the sensitivity
variables (based on the tolerances provided for the states and the
pbar values) */
ier = IDASensEEtolerances(mem);
if(check_flag(&ier, "IDASensEEtolerances", 1, thispe)) MPI_Abort(comm, 1);
/* Specify whether the sensitivity variables are included in the error
test or not */
ier = IDASetSensErrCon(mem, err_con);
if(check_flag(&ier, "IDASetSensErrCon", 1, thispe)) MPI_Abort(comm, 1);
/* Specify the problem parameters and their order of magnitude
(Note that we do not specify the index array plist and therefore
IDAS will compute sensitivities w.r.t. the first NS parameters) */
ier = IDASetSensParams(mem, data->p, pbar, NULL);
if(check_flag(&ier, "IDASetSensParams", 1, thispe)) MPI_Abort(comm, 1);
/* Compute consistent initial conditions (Note that this is required
only if performing SA since uu and up already contain consistent
initial conditions for the states) */
ier = IDACalcIC(mem, IDA_YA_YDP_INIT, t1);
if(check_flag(&ier, "IDACalcIC", 1, thispe)) MPI_Abort(comm, 1);
}
/* Print problem description */
if (thispe == 0 ) PrintHeader(Neq, rtol, atol, mudq, mukeep,
sensi, sensi_meth, err_con);
/* Loop over tout, call IDASolve, print output. */
for (tout = t1, iout = 1; iout <= NOUT; iout++, tout *= TWO) {
ier = IDASolve(mem, tout, &tret, uu, up, IDA_NORMAL);
if(check_flag(&ier, "IDASolve", 1, thispe)) MPI_Abort(comm, 1);
if (sensi) {
ier = IDAGetSens(mem, &tret, uuS);
if(check_flag(&ier, "IDAGetSens", 1, thispe)) MPI_Abort(comm, 1);
}
PrintOutput(thispe, mem, tret, uu, sensi, uuS);
}
/* Print final statistics */
if (thispe == 0) PrintFinalStats(mem);
/* Free Memory */
IDAFree(&mem);
free(data);
N_VDestroy_Parallel(id);
N_VDestroy_Parallel(res);
N_VDestroy_Parallel(up);
N_VDestroy_Parallel(uu);
MPI_Finalize();
return(0);
}
int main(int argc, char *argv[])
{
void *ida_mem;
SUNMatrix A;
SUNLinearSolver LS;
UserData webdata;
N_Vector cc, cp, id;
int iout, retval;
sunindextype mu, ml;
realtype rtol, atol, t0, tout, tret;
int num_threads;
ida_mem = NULL;
A = NULL;
LS = NULL;
webdata = NULL;
cc = cp = id = NULL;
/* Set the number of threads to use */
num_threads = 1; /* default value */
#ifdef _OPENMP
num_threads = omp_get_max_threads(); /* overwrite with OMP_NUM_THREADS enviroment variable */
#endif
if (argc > 1) /* overwrite with command line value, if supplied */
num_threads = strtol(argv[1], NULL, 0);
/* Allocate and initialize user data block webdata. */
webdata = (UserData) malloc(sizeof *webdata);
webdata->rates = N_VNew_OpenMP(NEQ, num_threads);
webdata->acoef = newDenseMat(NUM_SPECIES, NUM_SPECIES);
webdata->nthreads = num_threads;
InitUserData(webdata);
/* Allocate N-vectors and initialize cc, cp, and id. */
cc = N_VNew_OpenMP(NEQ, num_threads);
if(check_retval((void *)cc, "N_VNew_OpenMP", 0)) return(1);
cp = N_VNew_OpenMP(NEQ, num_threads);
if(check_retval((void *)cp, "N_VNew_OpenMP", 0)) return(1);
id = N_VNew_OpenMP(NEQ, num_threads);
if(check_retval((void *)id, "N_VNew_OpenMP", 0)) return(1);
SetInitialProfiles(cc, cp, id, webdata);
/* Set remaining inputs to IDAMalloc. */
t0 = ZERO;
rtol = RTOL;
atol = ATOL;
/* Call IDACreate and IDAMalloc to initialize IDA. */
ida_mem = IDACreate();
if(check_retval((void *)ida_mem, "IDACreate", 0)) return(1);
retval = IDASetUserData(ida_mem, webdata);
if(check_retval(&retval, "IDASetUserData", 1)) return(1);
retval = IDASetId(ida_mem, id);
if(check_retval(&retval, "IDASetId", 1)) return(1);
retval = IDAInit(ida_mem, resweb, t0, cc, cp);
if(check_retval(&retval, "IDAInit", 1)) return(1);
retval = IDASStolerances(ida_mem, rtol, atol);
if(check_retval(&retval, "IDASStolerances", 1)) return(1);
/* Setup band matrix and linear solver, and attach to IDA. */
mu = ml = NSMX;
A = SUNBandMatrix(NEQ, mu, ml);
if(check_retval((void *)A, "SUNBandMatrix", 0)) return(1);
LS = SUNLinSol_Band(cc, A);
if(check_retval((void *)LS, "SUNLinSol_Band", 0)) return(1);
retval = IDASetLinearSolver(ida_mem, LS, A);
if(check_retval(&retval, "IDASetLinearSolver", 1)) return(1);
/* Call IDACalcIC (with default options) to correct the initial values. */
tout = RCONST(0.001);
retval = IDACalcIC(ida_mem, IDA_YA_YDP_INIT, tout);
if(check_retval(&retval, "IDACalcIC", 1)) return(1);
/* Print heading, basic parameters, and initial values. */
PrintHeader(mu, ml, rtol, atol);
PrintOutput(ida_mem, cc, ZERO);
/* Loop over iout, call IDASolve (normal mode), print selected output. */
for (iout = 1; iout <= NOUT; iout++) {
retval = IDASolve(ida_mem, tout, &tret, cc, cp, IDA_NORMAL);
if(check_retval(&retval, "IDASolve", 1)) return(retval);
PrintOutput(ida_mem, cc, tret);
if (iout < 3) tout *= TMULT; else tout += TADD;
}
/* Print final statistics and free memory. */
PrintFinalStats(ida_mem);
printf("num_threads = %i\n\n", num_threads);
/* Free memory */
IDAFree(&ida_mem);
SUNLinSolFree(LS);
SUNMatDestroy(A);
N_VDestroy_OpenMP(cc);
N_VDestroy_OpenMP(cp);
N_VDestroy_OpenMP(id);
destroyMat(webdata->acoef);
N_VDestroy_OpenMP(webdata->rates);
free(webdata);
return(0);
}
void SundialsIda::initialize()
{
sundialsMem = IDACreate();
if (check_flag((void *)sundialsMem, "IDACreate", 0)) {
throw DebugException("SundialsIda::initialize: error in IDACreate");
}
IDASetUserData(sundialsMem, theDAE);
int flag;
if (calcIC) {
// Pick an appropriate initial condition for ydot and algebraic components of y
flag = IDASetId(sundialsMem, componentId.forSundials());
}
flag = IDAInit(sundialsMem, f, t0, y.forSundials(), ydot.forSundials());
if (check_flag(&flag, "IDAMalloc", 1)) {
throw DebugException("SundialsIda::initialize: error in IDAInit");
}
IDASVtolerances(sundialsMem, reltol, abstol.forSundials());
if (findRoots) {
rootsFound.resize(nRoots);
// Call IDARootInit to specify the root function g with nRoots components
flag = IDARootInit(sundialsMem, nRoots, g);
if (check_flag(&flag, "IDARootInit", 1)) {
throw DebugException("SundialsIda::initialize: error in IDARootInit");
}
}
// Call IDASpbcg to specify the IDASpbcg dense linear solver
flag = IDASpbcg(sundialsMem, 0);
if (check_flag(&flag, "IDASpbcg", 1)) {
throw DebugException("SundialsIda::initialize: error in IDASpbcg");
}
if (imposeConstraints) {
flag = IDASetConstraints(sundialsMem, constraints.forSundials());
if (check_flag(&flag, "IDASetConstraints", 1)) {
throw DebugException("SundialsIda::initialize: error in IDASetConstraints");
}
}
// this seems to work better using the default J-v function rather than specifying our own...
//flag = IDASpilsSetJacTimesVecFn(sundialsMem, JvProd, theDAE);
//if (check_flag(&flag, "IDASpilsSetJacTimesVecFn", 1)) {
// throw myException("SundialsIda::initialize: error in IDASpilsSetJacTimesVecFn");
//}
flag = IDASpilsSetPreconditioner(sundialsMem, preconditionerSetup, preconditionerSolve);
if (check_flag(&flag, "IDASpilsSetPreconditioner", 1)) {
throw DebugException("SundialsIda::initialize: error in IDASpilsSetPreconditioner");
}
if (calcIC) {
flag = IDACalcIC(sundialsMem, IDA_YA_YDP_INIT, t0+1e-4);
if (check_flag(&flag, "IDACalcIC", 1)) {
logFile.write("IDACalcIC Error");
throw DebugException("SundialsIda::initialize: error in IDACalcIC");
}
flag = IDAGetConsistentIC(sundialsMem, y0.forSundials(), ydot0.forSundials());
if (check_flag(&flag, "IDAGetConsistentIC", 1)) {
throw DebugException("SundialsIda::initialize: error in IDAGetConsistentIC");
}
}
}
int main()
{
void *mem;
UserData webdata;
N_Vector cc, cp, id;
int iout, retval;
long int mu, ml;
realtype rtol, atol, t0, tout, tret;
mem = NULL;
webdata = NULL;
cc = cp = id = NULL;
/* Allocate and initialize user data block webdata. */
webdata = (UserData) malloc(sizeof *webdata);
webdata->rates = N_VNew_Serial(NEQ);
webdata->acoef = newDenseMat(NUM_SPECIES, NUM_SPECIES);
InitUserData(webdata);
/* Allocate N-vectors and initialize cc, cp, and id. */
cc = N_VNew_Serial(NEQ);
if(check_flag((void *)cc, "N_VNew_Serial", 0)) return(1);
cp = N_VNew_Serial(NEQ);
if(check_flag((void *)cp, "N_VNew_Serial", 0)) return(1);
id = N_VNew_Serial(NEQ);
if(check_flag((void *)id, "N_VNew_Serial", 0)) return(1);
SetInitialProfiles(cc, cp, id, webdata);
/* Set remaining inputs to IDAMalloc. */
t0 = ZERO;
rtol = RTOL;
atol = ATOL;
/* Call IDACreate and IDAMalloc to initialize IDA. */
mem = IDACreate();
if(check_flag((void *)mem, "IDACreate", 0)) return(1);
retval = IDASetUserData(mem, webdata);
if(check_flag(&retval, "IDASetUserData", 1)) return(1);
retval = IDASetId(mem, id);
if(check_flag(&retval, "IDASetId", 1)) return(1);
retval = IDAInit(mem, resweb, t0, cc, cp);
if(check_flag(&retval, "IDAInit", 1)) return(1);
retval = IDASStolerances(mem, rtol, atol);
if(check_flag(&retval, "IDASStolerances", 1)) return(1);
/* Call IDABand to specify the IDA linear solver. */
mu = ml = NSMX;
retval = IDABand(mem, NEQ, mu, ml);
if(check_flag(&retval, "IDABand", 1)) return(1);
/* Call IDACalcIC (with default options) to correct the initial values. */
tout = RCONST(0.001);
retval = IDACalcIC(mem, IDA_YA_YDP_INIT, tout);
if(check_flag(&retval, "IDACalcIC", 1)) return(1);
/* Print heading, basic parameters, and initial values. */
PrintHeader(mu, ml, rtol, atol);
PrintOutput(mem, cc, ZERO);
/* Loop over iout, call IDASolve (normal mode), print selected output. */
for (iout = 1; iout <= NOUT; iout++) {
retval = IDASolve(mem, tout, &tret, cc, cp, IDA_NORMAL);
if(check_flag(&retval, "IDASolve", 1)) return(retval);
PrintOutput(mem, cc, tret);
if (iout < 3) tout *= TMULT; else tout += TADD;
}
/* Print final statistics and free memory. */
PrintFinalStats(mem);
/* Free memory */
IDAFree(&mem);
N_VDestroy_Serial(cc);
N_VDestroy_Serial(cp);
N_VDestroy_Serial(id);
destroyMat(webdata->acoef);
N_VDestroy_Serial(webdata->rates);
free(webdata);
return(0);
}
int main(void)
{
void *mem;
UserData data;
N_Vector uu, up, constraints, id, res; /* uu is u, up is du/dt */
int ier, iout;
long int netf, ncfn;
realtype rtol, atol, t0, t1, tout, tret;
int nnz; /* number of non-zeroes */
mem = NULL;
data = NULL;
uu = up = constraints = id = res = NULL;
/* Create vectors uu, up, res, constraints, id. */
uu = N_VNew_Serial(NEQ);
if(check_flag((void *)uu, "N_VNew_Serial", 0)) return(1);
up = N_VNew_Serial(NEQ);
if(check_flag((void *)up, "N_VNew_Serial", 0)) return(1);
res = N_VNew_Serial(NEQ);
if(check_flag((void *)res, "N_VNew_Serial", 0)) return(1);
constraints = N_VNew_Serial(NEQ);
if(check_flag((void *)constraints, "N_VNew_Serial", 0)) return(1);
id = N_VNew_Serial(NEQ); /* differentiate between algebraic and differential */
if(check_flag((void *)id, "N_VNew_Serial", 0)) return(1);
/* Create and load problem data block. */
data = (UserData) malloc(sizeof *data);
if(check_flag((void *)data, "malloc", 2)) return(1);
data->mm = MGRID;
data->dx = ONE/(MGRID - ONE);
data->coeff = ONE/( (data->dx) * (data->dx) );
/* Initialize uu, up, id. */
SetInitialProfile(data, uu, up, id, res);
/* Set constraints to all 1's for nonnegative solution values. */
N_VConst(ONE, constraints);
/* Set remaining input parameters. */
t0 = ZERO;
t1 = RCONST(0.01);
rtol = ZERO;
atol = RCONST(1.0e-8);
/* Call IDACreate and IDAMalloc to initialize solution */
mem = IDACreate();
if(check_flag((void *)mem, "IDACreate", 0)) return(1);
ier = IDASetUserData(mem, data);
if(check_flag(&ier, "IDASetUserData", 1)) return(1);
/* Sets up which components are algebraic or differential */
ier = IDASetId(mem, id);
if(check_flag(&ier, "IDASetId", 1)) return(1);
ier = IDASetConstraints(mem, constraints);
if(check_flag(&ier, "IDASetConstraints", 1)) return(1);
N_VDestroy_Serial(constraints);
ier = IDAInit(mem, heatres, t0, uu, up);
if(check_flag(&ier, "IDAInit", 1)) return(1);
ier = IDASStolerances(mem, rtol, atol);
if(check_flag(&ier, "IDASStolerances", 1)) return(1);
/* Call IDAKLU and set up the linear solver */
nnz = NEQ*NEQ;
ier = IDAKLU(mem, NEQ, nnz, CSC_MAT);
if(check_flag(&ier, "IDAKLU", 1)) return(1);
/* check size of Jacobian matrix */
if(MGRID >= 4){
ier = IDASlsSetSparseJacFn(mem, jacHeat);
}
/* special case MGRID=3 */
else if(MGRID==3){
ier = IDASlsSetSparseJacFn(mem, jacHeat3);
}
/* MGRID<=2 is pure boundary points, nothing to solve */
else{
printf("MGRID size is too small to run.\n");
return(1);
}
if(check_flag(&ier, "IDASlsSetSparseJacFn", 1)) return(1);
/* Call IDACalcIC to correct the initial values. */
ier = IDACalcIC(mem, IDA_YA_YDP_INIT, t1);
if(check_flag(&ier, "IDACalcIC", 1)) return(1);
/* Print output heading. */
PrintHeader(rtol, atol);
PrintOutput(mem, t0, uu);
/* Loop over output times, call IDASolve, and print results. */
for (tout = t1, iout = 1; iout <= NOUT; iout++, tout *= TWO) {
ier = IDASolve(mem, tout, &tret, uu, up, IDA_NORMAL);
if(check_flag(&ier, "IDASolve", 1)) return(1);
PrintOutput(mem, tret, uu);
}
/* Print remaining counters and free memory. */
ier = IDAGetNumErrTestFails(mem, &netf);
check_flag(&ier, "IDAGetNumErrTestFails", 1);
ier = IDAGetNumNonlinSolvConvFails(mem, &ncfn);
check_flag(&ier, "IDAGetNumNonlinSolvConvFails", 1);
printf("\n netf = %ld, ncfn = %ld \n", netf, ncfn);
IDAFree(&mem);
N_VDestroy_Serial(uu);
N_VDestroy_Serial(up);
N_VDestroy_Serial(id);
N_VDestroy_Serial(res);
free(data);
return(0);
}
int main()
{
void *mem;
UserData webdata;
N_Vector cc, cp, id;
int iout, jx, jy, flag;
long int maxl;
realtype rtol, atol, t0, tout, tret;
mem = NULL;
webdata = NULL;
cc = cp = id = NULL;
/* Allocate and initialize user data block webdata. */
webdata = (UserData) malloc(sizeof *webdata);
webdata->rates = N_VNew_Serial(NEQ);
webdata->acoef = newDenseMat(NUM_SPECIES, NUM_SPECIES);
webdata->ewt = N_VNew_Serial(NEQ);
for (jx = 0; jx < MX; jx++) {
for (jy = 0; jy < MY; jy++) {
(webdata->pivot)[jx][jy] = newLintArray(NUM_SPECIES);
(webdata->PP)[jx][jy] = newDenseMat(NUM_SPECIES, NUM_SPECIES);
}
}
InitUserData(webdata);
/* Allocate N-vectors and initialize cc, cp, and id. */
cc = N_VNew_Serial(NEQ);
if(check_flag((void *)cc, "N_VNew_Serial", 0)) return(1);
cp = N_VNew_Serial(NEQ);
if(check_flag((void *)cp, "N_VNew_Serial", 0)) return(1);
id = N_VNew_Serial(NEQ);
if(check_flag((void *)id, "N_VNew_Serial", 0)) return(1);
SetInitialProfiles(cc, cp, id, webdata);
/* Set remaining inputs to IDAMalloc. */
t0 = ZERO;
rtol = RTOL;
atol = ATOL;
/* Call IDACreate and IDAMalloc to initialize IDA. */
mem = IDACreate();
if(check_flag((void *)mem, "IDACreate", 0)) return(1);
flag = IDASetUserData(mem, webdata);
if(check_flag(&flag, "IDASetUserData", 1)) return(1);
flag = IDASetId(mem, id);
if(check_flag(&flag, "IDASetId", 1)) return(1);
flag = IDAInit(mem, resweb, t0, cc, cp);
if(check_flag(&flag, "IDAInit", 1)) return(1);
flag = IDASStolerances(mem, rtol, atol);
if(check_flag(&flag, "IDASStolerances", 1)) return(1);
webdata->ida_mem = mem;
/* Call IDASpgmr to specify the IDA linear solver. */
maxl = 16; /* max dimension of the Krylov subspace */
flag = IDASpgmr(mem, maxl);
if(check_flag(&flag, "IDASpgmr", 1)) return(1);
flag = IDASpilsSetPreconditioner(mem, Precond, PSolve);
if(check_flag(&flag, "IDASpilsSetPreconditioner", 1)) return(1);
/* Call IDACalcIC (with default options) to correct the initial values. */
tout = RCONST(0.001);
flag = IDACalcIC(mem, IDA_YA_YDP_INIT, tout);
if(check_flag(&flag, "IDACalcIC", 1)) return(1);
/* Print heading, basic parameters, and initial values. */
PrintHeader(maxl, rtol, atol);
PrintOutput(mem, cc, ZERO);
/* Loop over iout, call IDASolve (normal mode), print selected output. */
for (iout = 1; iout <= NOUT; iout++) {
flag = IDASolve(mem, tout, &tret, cc, cp, IDA_NORMAL);
if(check_flag(&flag, "IDASolve", 1)) return(flag);
PrintOutput(mem, cc, tret);
if (iout < 3) tout *= TMULT; else tout += TADD;
}
/* Print final statistics and free memory. */
PrintFinalStats(mem);
/* Free memory */
IDAFree(&mem);
N_VDestroy_Serial(cc);
N_VDestroy_Serial(cp);
N_VDestroy_Serial(id);
destroyMat(webdata->acoef);
N_VDestroy_Serial(webdata->rates);
N_VDestroy_Serial(webdata->ewt);
for (jx = 0; jx < MX; jx++) {
for (jy = 0; jy < MY; jy ++) {
destroyArray((webdata->pivot)[jx][jy]);
destroyMat((webdata->PP)[jx][jy]);
}
}
free(webdata);
return(0);
}