void FIDA_SPILSSETPREC(int *flag, int *ier)
{
*ier = 0;
if (*flag == 0) {
*ier = IDASpilsSetPreconditioner(IDA_idamem, NULL, NULL);
} else {
if (F2C_IDA_ewtvec == NULL) {
F2C_IDA_ewtvec = N_VClone(F2C_IDA_vec);
if (F2C_IDA_ewtvec == NULL) {
*ier = -1;
return;
}
}
*ier = IDASpilsSetPreconditioner(IDA_idamem, (IDASpilsPrecSetupFn) FIDAPSet,
(IDASpilsPrecSolveFn) FIDAPSol);
}
return;
}
int IDABBDSpbcg(void *ida_mem, int maxl, void *bbd_data)
{
IDAMem IDA_mem;
int flag;
flag = IDASpbcg(ida_mem, maxl);
if(flag != IDASPILS_SUCCESS) return(flag);
IDA_mem = (IDAMem) ida_mem;
if (bbd_data == NULL) {
IDAProcessError(IDA_mem, IDABBDPRE_PDATA_NULL, "IDABBDPRE", "IDABBDSpbcg", MSGBBD_PDATA_NULL);
return(IDABBDPRE_PDATA_NULL);
}
flag = IDASpilsSetPreconditioner(ida_mem, IDABBDPrecSetup, IDABBDPrecSolve, bbd_data);
if(flag != IDASPILS_SUCCESS) return(flag);
return(IDASPILS_SUCCESS);
}
int main()
{
void *mem;
UserData data;
N_Vector uu, up, constraints, res;
int ier, iout;
realtype rtol, atol, t0, t1, tout, tret;
long int netf, ncfn, ncfl;
mem = NULL;
data = NULL;
uu = up = constraints = res = NULL;
/* Allocate N-vectors and the user data structure. */
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);
data = (UserData) malloc(sizeof *data);
data->pp = NULL;
if(check_flag((void *)data, "malloc", 2)) return(1);
/* Assign parameters in the user data structure. */
data->mm = MGRID;
data->dx = ONE/(MGRID-ONE);
data->coeff = ONE/(data->dx * data->dx);
data->pp = N_VNew_Serial(NEQ);
if(check_flag((void *)data->pp, "N_VNew_Serial", 0)) return(1);
/* Initialize uu, up. */
SetInitialProfile(data, uu, up, res);
/* Set constraints to all 1's for nonnegative solution values. */
N_VConst(ONE, constraints);
/* Assign various 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 = IDASetConstraints(mem, constraints);
if(check_flag(&ier, "IDASetConstraints", 1)) return(1);
N_VDestroy_Serial(constraints);
ier = IDAInit(mem, resHeat, 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 IDASpgmr to specify the linear solver. */
ier = IDASpgmr(mem, 0);
if(check_flag(&ier, "IDASpgmr", 1)) return(1);
ier = IDASpilsSetPreconditioner(mem, PsetupHeat, PsolveHeat);
if(check_flag(&ier, "IDASpilsSetPreconditioner", 1)) return(1);
/* Print output heading. */
PrintHeader(rtol, atol);
/*
* -------------------------------------------------------------------------
* CASE I
* -------------------------------------------------------------------------
*/
/* Print case number, output table heading, and initial line of table. */
printf("\n\nCase 1: gsytpe = MODIFIED_GS\n");
printf("\n Output Summary (umax = max-norm of solution) \n\n");
printf(" time umax k nst nni nje nre nreLS h npe nps\n" );
printf("----------------------------------------------------------------------\n");
/* 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. */
ier = IDAGetNumErrTestFails(mem, &netf);
check_flag(&ier, "IDAGetNumErrTestFails", 1);
ier = IDAGetNumNonlinSolvConvFails(mem, &ncfn);
check_flag(&ier, "IDAGetNumNonlinSolvConvFails", 1);
ier = IDASpilsGetNumConvFails(mem, &ncfl);
check_flag(&ier, "IDASpilsGetNumConvFails", 1);
printf("\nError test failures = %ld\n", netf);
printf("Nonlinear convergence failures = %ld\n", ncfn);
printf("Linear convergence failures = %ld\n", ncfl);
/*
* -------------------------------------------------------------------------
* CASE II
* -------------------------------------------------------------------------
*/
/* Re-initialize uu, up. */
SetInitialProfile(data, uu, up, res);
/* Re-initialize IDA and IDASPGMR */
ier = IDAReInit(mem, t0, uu, up);
if(check_flag(&ier, "IDAReInit", 1)) return(1);
ier = IDASpilsSetGSType(mem, CLASSICAL_GS);
if(check_flag(&ier, "IDASpilsSetGSType",1)) return(1);
/* Print case number, output table heading, and initial line of table. */
printf("\n\nCase 2: gstype = CLASSICAL_GS\n");
printf("\n Output Summary (umax = max-norm of solution) \n\n");
printf(" time umax k nst nni nje nre nreLS h npe nps\n" );
printf("----------------------------------------------------------------------\n");
/* 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. */
ier = IDAGetNumErrTestFails(mem, &netf);
check_flag(&ier, "IDAGetNumErrTestFails", 1);
ier = IDAGetNumNonlinSolvConvFails(mem, &ncfn);
check_flag(&ier, "IDAGetNumNonlinSolvConvFails", 1);
ier = IDASpilsGetNumConvFails(mem, &ncfl);
check_flag(&ier, "IDASpilsGetNumConvFails", 1);
printf("\nError test failures = %ld\n", netf);
printf("Nonlinear convergence failures = %ld\n", ncfn);
printf("Linear convergence failures = %ld\n", ncfl);
/* Free Memory */
IDAFree(&mem);
N_VDestroy_Serial(uu);
N_VDestroy_Serial(up);
N_VDestroy_Serial(res);
N_VDestroy_Serial(data->pp);
free(data);
return(0);
}
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);
}
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, 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);
}
