static void PrintOutput(void *mem, realtype t, N_Vector y)
{
realtype *yval;
int retval, kused;
long int nst;
realtype hused;
yval = NV_DATA_S(y);
retval = IDAGetLastOrder(mem, &kused);
check_flag(&retval, "IDAGetLastOrder", 1);
retval = IDAGetNumSteps(mem, &nst);
check_flag(&retval, "IDAGetNumSteps", 1);
retval = IDAGetLastStep(mem, &hused);
check_flag(&retval, "IDAGetLastStep", 1);
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf("%10.4Le %12.4Le %12.4Le %12.4Le | %3ld %1d %12.4Le\n",
t, yval[0], yval[1], yval[2], nst, kused, hused);
#elif defined(SUNDIALS_DOUBLE_PRECISION)
printf("%10.4e %12.4e %12.4e %12.4e | %3ld %1d %12.4e\n",
t, yval[0], yval[1], yval[2], nst, kused, hused);
#else
printf("%10.4e %12.4e %12.4e %12.4e | %3ld %1d %12.4e\n",
t, yval[0], yval[1], yval[2], nst, kused, hused);
#endif
}
static void PrintOutput(void *ida_mem, N_Vector c, realtype t)
{
int i, kused, retval;
long int nst;
realtype *c_bl, *c_tr, hused;
retval = IDAGetLastOrder(ida_mem, &kused);
check_retval(&retval, "IDAGetLastOrder", 1);
retval = IDAGetNumSteps(ida_mem, &nst);
check_retval(&retval, "IDAGetNumSteps", 1);
retval = IDAGetLastStep(ida_mem, &hused);
check_retval(&retval, "IDAGetLastStep", 1);
c_bl = IJ_Vptr(c,0,0);
c_tr = IJ_Vptr(c,MX-1,MY-1);
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf("%8.2Le %12.4Le %12.4Le | %3ld %1d %12.4Le\n",
t, c_bl[0], c_tr[0], nst, kused, hused);
for (i=1;i<NUM_SPECIES;i++)
printf(" %12.4Le %12.4Le |\n",c_bl[i],c_tr[i]);
#elif defined(SUNDIALS_DOUBLE_PRECISION)
printf("%8.2e %12.4e %12.4e | %3ld %1d %12.4e\n",
t, c_bl[0], c_tr[0], nst, kused, hused);
for (i=1;i<NUM_SPECIES;i++)
printf(" %12.4e %12.4e |\n",c_bl[i],c_tr[i]);
#else
printf("%8.2e %12.4e %12.4e | %3ld %1d %12.4e\n",
t, c_bl[0], c_tr[0], nst, kused, hused);
for (i=1;i<NUM_SPECIES;i++)
printf(" %12.4e %12.4e |\n",c_bl[i],c_tr[i]);
#endif
printf("\n");
}
static void PrintOutput(void *mem, realtype t, N_Vector uu)
{
int ier;
realtype umax, hused;
long int nst, nni, nje, nre;
int kused;
umax = N_VMaxNorm(uu);
ier = IDAGetLastOrder(mem, &kused);
check_flag(&ier, "IDAGetLastOrder", 1);
ier = IDAGetNumSteps(mem, &nst);
check_flag(&ier, "IDAGetNumSteps", 1);
ier = IDAGetNumNonlinSolvIters(mem, &nni);
check_flag(&ier, "IDAGetNumNonlinSolvIters", 1);
ier = IDAGetNumResEvals(mem, &nre);
check_flag(&ier, "IDAGetNumResEvals", 1);
ier = IDAGetLastStep(mem, &hused);
check_flag(&ier, "IDAGetLastStep", 1);
ier = IDASlsGetNumJacEvals(mem, &nje);
check_flag(&ier, "IDASlsGetNumJacEvals", 1);
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf(" %5.2Lf %13.5Le %d %3ld %3ld %3ld %4ld %9.2Le \n",
t, umax, kused, nst, nni, nje, nre, hused);
#elif defined(SUNDIALS_DOUBLE_PRECISION)
printf(" %5.2f %13.5e %d %3ld %3ld %3ld %4ld %9.2e \n",
t, umax, kused, nst, nni, nje, nre, hused);
#else
printf(" %5.2f %13.5e %d %3ld %3ld %3ld %4ld %9.2e \n",
t, umax, kused, nst, nni, nje, nre, hused);
#endif
}
static void PrintOutput(void *mem, N_Vector cc, realtype tt,
UserData webdata, MPI_Comm comm)
{
MPI_Status status;
realtype *cdata, clast[2], hused;
long int nst;
int i, kused, flag, thispe, npelast, ilast;;
thispe = webdata->thispe;
npelast = webdata->npes - 1;
cdata = N_VGetArrayPointer_Parallel(cc);
/* Send conc. at top right mesh point from PE npes-1 to PE 0. */
if (thispe == npelast) {
ilast = NUM_SPECIES*MXSUB*MYSUB - 2;
if (npelast != 0)
MPI_Send(&cdata[ilast], 2, PVEC_REAL_MPI_TYPE, 0, 0, comm);
else { clast[0] = cdata[ilast]; clast[1] = cdata[ilast+1]; }
}
/* On PE 0, receive conc. at top right from PE npes - 1.
Then print performance data and sampled solution values. */
if (thispe == 0) {
if (npelast != 0)
MPI_Recv(&clast[0], 2, PVEC_REAL_MPI_TYPE, npelast, 0, comm, &status);
flag = IDAGetLastOrder(mem, &kused);
check_flag(&flag, "IDAGetLastOrder", 1, thispe);
flag = IDAGetNumSteps(mem, &nst);
check_flag(&flag, "IDAGetNumSteps", 1, thispe);
flag = IDAGetLastStep(mem, &hused);
check_flag(&flag, "IDAGetLastStep", 1, thispe);
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf("%8.2Le %12.4Le %12.4Le | %3ld %1d %12.4Le\n",
tt, cdata[0], clast[0], nst, kused, hused);
for (i=1;i<NUM_SPECIES;i++)
printf(" %12.4Le %12.4Le |\n",cdata[i],clast[i]);
#elif defined(SUNDIALS_DOUBLE_PRECISION)
printf("%8.2e %12.4e %12.4e | %3ld %1d %12.4e\n",
tt, cdata[0], clast[0], nst, kused, hused);
for (i=1;i<NUM_SPECIES;i++)
printf(" %12.4e %12.4e |\n",cdata[i],clast[i]);
#else
printf("%8.2e %12.4e %12.4e | %3ld %1d %12.4e\n",
tt, cdata[0], clast[0], nst, kused, hused);
for (i=1;i<NUM_SPECIES;i++)
printf(" %12.4e %12.4e |\n",cdata[i],clast[i]);
#endif
printf("\n");
}
}
static void PrintOutput(void *mem, realtype t, N_Vector y)
{
realtype *yval;
int flag, kused;
long int nst;
realtype hused;
yval = NV_DATA_S(y);
flag = IDAGetLastOrder(mem, &kused);
flag = IDAGetNumSteps(mem, &nst);
flag = IDAGetLastStep(mem, &hused);
printf("%10.4e %12.4e %12.4e %12.4e %3ld %1d %12.4e\n",
t, yval[0], yval[1], yval[2], nst, kused, hused);
}
int FIDALapackBandJac(long int N, long int mupper, long int mlower,
realtype t, realtype c_j,
N_Vector yy, N_Vector yp, N_Vector rr,
DlsMat J, void *user_data,
N_Vector vtemp1, N_Vector vtemp2, N_Vector vtemp3)
{
realtype *yy_data, *yp_data, *rr_data, *jacdata, *ewtdata, *v1data, *v2data, *v3data;
realtype h;
long int eband;
int ier;
FIDAUserData IDA_userdata;
/* Initialize all pointers to NULL */
yy_data = yp_data = rr_data = jacdata = ewtdata = NULL;
v1data = v2data = v3data = NULL;
/* NOTE: The user-supplied routine should set ier to an
appropriate value, but we preset the value to zero
(meaning SUCCESS) so the user need only reset the
value if an error occurred */
ier = 0;
IDAGetErrWeights(IDA_idamem, F2C_IDA_ewtvec);
IDAGetLastStep(IDA_idamem, &h);
/* Get pointers to vector data */
yy_data = N_VGetArrayPointer(yy);
yp_data = N_VGetArrayPointer(yp);
rr_data = N_VGetArrayPointer(rr);
ewtdata = N_VGetArrayPointer(F2C_IDA_ewtvec);
v1data = N_VGetArrayPointer(vtemp1);
v2data = N_VGetArrayPointer(vtemp2);
v3data = N_VGetArrayPointer(vtemp3);
eband = (J->s_mu) + mlower + 1;
jacdata = BAND_COL(J,0) - mupper;
IDA_userdata = (FIDAUserData) user_data;
/* Call user-supplied routine */
FIDA_BJAC(&N, &mupper, &mlower, &eband, &t, yy_data, yp_data, rr_data,
&c_j, jacdata, ewtdata, &h,
IDA_userdata->ipar, IDA_userdata->rpar,
v1data, v2data, v3data, &ier);
return(ier);
}
static void PrintOutput(int id, void *mem, realtype t, N_Vector uu)
{
realtype umax, hused;
int kused, ier;
long int nst, nni, nre, nli, npe, nps, nreLS, nge;
umax = N_VMaxNorm(uu);
if (id == 0) {
ier = IDAGetLastOrder(mem, &kused);
check_flag(&ier, "IDAGetLastOrder", 1, id);
ier = IDAGetNumSteps(mem, &nst);
check_flag(&ier, "IDAGetNumSteps", 1, id);
ier = IDAGetNumNonlinSolvIters(mem, &nni);
check_flag(&ier, "IDAGetNumNonlinSolvIters", 1, id);
ier = IDAGetNumResEvals(mem, &nre);
check_flag(&ier, "IDAGetNumResEvals", 1, id);
ier = IDAGetLastStep(mem, &hused);
check_flag(&ier, "IDAGetLastStep", 1, id);
ier = IDASpilsGetNumLinIters(mem, &nli);
check_flag(&ier, "IDASpilsGetNumLinIters", 1, id);
ier = IDASpilsGetNumResEvals(mem, &nreLS);
check_flag(&ier, "IDASpilsGetNumResEvals", 1, id);
ier = IDABBDPrecGetNumGfnEvals(mem, &nge);
check_flag(&ier, "IDABBDPrecGetNumGfnEvals", 1, id);
ier = IDASpilsGetNumPrecEvals(mem, &npe);
check_flag(&ier, "IDASpilsGetPrecEvals", 1, id);
ier = IDASpilsGetNumPrecSolves(mem, &nps);
check_flag(&ier, "IDASpilsGetNumPrecSolves", 1, id);
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf(" %5.2Lf %13.5Le %d %3ld %3ld %3ld %4ld %4ld %4ld %9.2Le %3ld %3ld\n",
t, umax, kused, nst, nni, nli, nre, nreLS, nge, hused, npe, nps);
#elif defined(SUNDIALS_DOUBLE_PRECISION)
printf(" %5.2f %13.5e %d %3ld %3ld %3ld %4ld %4ld %4ld %9.2e %3ld %3ld\n",
t, umax, kused, nst, nni, nli, nre, nreLS, nge, hused, npe, nps);
#else
printf(" %5.2f %13.5e %d %3ld %3ld %3ld %4ld %4ld %4ld %9.2e %3ld %3ld\n",
t, umax, kused, nst, nni, nli, nre, nreLS, nge, hused, npe, nps);
#endif
}
}
int FIDAJtimes(realtype t, N_Vector yy, N_Vector yp, N_Vector rr,
N_Vector v, N_Vector Jv,
realtype c_j, void *jac_data,
N_Vector vtemp1, N_Vector vtemp2)
{
realtype *yy_data, *yp_data, *rr_data, *vdata, *Jvdata, *ewtdata;
realtype *v1data, *v2data;
realtype h;
FIDAUserData IDA_userdata;
int ier;
/* Initialize all pointers to NULL */
yy_data = yp_data = rr_data = vdata = Jvdata = ewtdata = NULL;
/* NOTE: The user-supplied routine should set ier to an
appropriate value, but we preset the value to zero
(meaning SUCCESS) so the user need only reset the
value if an error occurred */
ier = 0;
IDAGetErrWeights(IDA_idamem, F2C_IDA_ewtvec);
IDAGetLastStep(IDA_idamem, &h);
/* Get pointers to vector data */
yy_data = N_VGetArrayPointer(yy);
yp_data = N_VGetArrayPointer(yp);
rr_data = N_VGetArrayPointer(rr);
ewtdata = N_VGetArrayPointer(F2C_IDA_ewtvec);
vdata = N_VGetArrayPointer(v);
Jvdata = N_VGetArrayPointer(Jv);
v1data = N_VGetArrayPointer(vtemp1);
v2data = N_VGetArrayPointer(vtemp2);
IDA_userdata = (FIDAUserData) jac_data;
/* Call user-supplied routine */
FIDA_JTIMES(&t, yy_data, yp_data, rr_data, vdata, Jvdata,
&c_j, ewtdata, &h,
IDA_userdata->ipar, IDA_userdata->rpar,
v1data, v2data, &ier);
return(ier);
}
static void PrintOutput(void *mem, realtype t, N_Vector uu)
{
realtype hused, umax;
long int nst, nni, nje, nre, nreS, nli, npe, nps;
int kused, ier;
umax = N_VMaxNorm(uu);
ier = IDAGetLastOrder(mem, &kused);
check_flag(&ier, "IDAGetLastOrder", 1);
ier = IDAGetNumSteps(mem, &nst);
check_flag(&ier, "IDAGetNumSteps", 1);
ier = IDAGetNumNonlinSolvIters(mem, &nni);
check_flag(&ier, "IDAGetNumNonlinSolvIters", 1);
ier = IDAGetNumResEvals(mem, &nre);
check_flag(&ier, "IDAGetNumResEvals", 1);
ier = IDAGetLastStep(mem, &hused);
check_flag(&ier, "IDAGetLastStep", 1);
ier = IDASpgmrGetNumJtimesEvals(mem, &nje);
check_flag(&ier, "IDASpgmrGetNumJtimesEvals", 1);
ier = IDASpgmrGetNumLinIters(mem, &nli);
check_flag(&ier, "IDASpgmrGetNumLinIters", 1);
ier = IDASpgmrGetNumResEvals(mem, &nreS);
check_flag(&ier, "IDASpgmrGetNumResEvals", 1);
ier = IDASpgmrGetNumPrecEvals(mem, &npe);
check_flag(&ier, "IDASpgmrGetPrecEvals", 1);
ier = IDASpgmrGetNumPrecSolves(mem, &nps);
check_flag(&ier, "IDASpgmrGetNumPrecSolves", 1);
#if defined(SUNDIALS_EXTENDED_PRECISION)
printf(" %5.2Lf %13.5Le %d %3ld %3ld %3ld %4ld %4ld %9.2Le %3ld %3ld\n",
t, umax, kused, nst, nni, nje, nre, nreS, hused, npe, nps);
#elif defined(SUNDIALS_DOUBLE_PRECISION)
printf(" %5.2f %13.5le %d %3ld %3ld %3ld %4ld %4ld %9.2le %3ld %3ld\n",
t, umax, kused, nst, nni, nje, nre, nreS, hused, npe, nps);
#else
printf(" %5.2f %13.5e %d %3ld %3ld %3ld %4ld %4ld %9.2e %3ld %3ld\n",
t, umax, kused, nst, nni, nje, nre, nreS, hused, npe, nps);
#endif
}
void Ida::IDACore()
{
_idid = IDAReInit(_idaMem, _tCurrent, _CV_y,_CV_yp);
_idid = IDASetStopTime(_idaMem, _tEnd);
_idid = IDASetInitStep(_idaMem, 1e-12);
if (_idid < 0)
throw std::runtime_error("IDA::ReInit");
bool writeEventOutput = (_settings->getGlobalSettings()->getOutputPointType() == OPT_ALL);
bool writeOutput = !(_settings->getGlobalSettings()->getOutputPointType() == OPT_NONE);
while ((_solverStatus & ISolver::CONTINUE) && !_interrupt )
{
_cv_rt = IDASolve(_idaMem, _tEnd, &_tCurrent, _CV_y, _CV_yp, IDA_ONE_STEP);
_idid = IDAGetNumSteps(_idaMem, &_locStps);
if (_idid != IDA_SUCCESS)
throw std::runtime_error("IDAGetNumSteps failed. The ida mem pointer is NULL");
_idid =IDAGetLastStep(_idaMem, &_h);
if (_idid != IDA_SUCCESS)
throw std::runtime_error("IDAGetLastStep failed. The ida mem pointer is NULL");
//Check if there was at least one output-point within the last solver interval
// -> Write output if true
if (writeOutput)
{
writeIDAOutput(_tCurrent, _h, _locStps);
}
#ifdef RUNTIME_PROFILING
MEASURETIME_REGION_DEFINE(idaStepCompletedHandler, "IDAStepCompleted");
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_START(measuredFunctionStartValues, idaStepCompletedHandler, "IDAStepCompleted");
}
#endif
//set completed step to system and check if terminate was called
if(_continuous_system->stepCompleted(_tCurrent))
_solverStatus = DONE;
#ifdef RUNTIME_PROFILING
if(MeasureTime::getInstance() != NULL)
{
MEASURETIME_END(measuredFunctionStartValues, measuredFunctionEndValues, (*measureTimeFunctionsArray)[5], idaStepCompletedHandler);
}
#endif
// Perform state selection
bool state_selection = stateSelection();
if (state_selection)
_continuous_system->getContinuousStates(_y);
_zeroFound = false;
// Check if step was successful
if (check_flag(&_cv_rt, "IDA", 1))
{
_solverStatus = ISolver::SOLVERERROR;
break;
}
// A root was found
if ((_cv_rt == IDA_ROOT_RETURN) && !isInterrupted())
{
// IDA is setting _tCurrent to the time where the first event occurred
double _abs = fabs(_tLastEvent - _tCurrent);
_zeroFound = true;
if ((_abs < 1e-3) && _event_n == 0)
{
_tLastEvent = _tCurrent;
_event_n++;
}
else if ((_abs < 1e-3) && (_event_n >= 1 && _event_n < 500))
{
_event_n++;
}
else if ((_abs >= 1e-3))
{
//restart event counter
_tLastEvent = _tCurrent;
_event_n = 0;
}
else
throw std::runtime_error("Number of events exceeded in time interval " + to_string(_abs) + " at time " + to_string(_tCurrent));
// IDA has interpolated the states at time 'tCurrent'
_time_system->setTime(_tCurrent);
// To get steep steps in the result file, two value points (P1 and P2) must be added
//
// Y | (P2) X...........
// | :
// | :
// |........X (P1)
// |---------------------------------->
// | ^ t
// _tCurrent
// Write the values of (P1)
if (writeEventOutput)
{
if(_dimAE>0)
{
_continuous_system->evaluateDAE(IContinuous::CONTINUOUS);
}
else
{
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
}
writeToFile(0, _tCurrent, _h);
}
_idid = IDAGetRootInfo(_idaMem, _zeroSign);
for (int i = 0; i < _dimZeroFunc; i++)
_events[i] = bool(_zeroSign[i]);
if (_mixed_system->handleSystemEvents(_events))
{
// State variables were reinitialized, thus we have to give these values to the ida-solver
// Take care about the memory regions, _z is the same like _CV_y
_continuous_system->getContinuousStates(_y);
if(_dimAE>0)
{
_mixed_system->getAlgebraicDAEVars(_y+_dimStates);
_continuous_system->getRHS(_yp);
}
calcFunction(_tCurrent, NV_DATA_S(_CV_y), NV_DATA_S(_CV_yp),_dae_res);
}
}
if ((_zeroFound || state_selection)&& !isInterrupted())
{
// Write the values of (P2)
if (writeEventOutput)
{
// If we want to write the event-results, we should evaluate the whole system again
if(_dimAE>0)
{
_continuous_system->evaluateDAE(IContinuous::CONTINUOUS);
}
else
{
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
}
writeToFile(0, _tCurrent, _h);
}
_idid = IDAReInit(_idaMem, _tCurrent, _CV_y,_CV_yp);
if (_idid < 0)
throw std::runtime_error("IDA::ReInit()");
// Der Eventzeitpunkt kann auf der Endzeit liegen (Time-Events). In diesem Fall wird der Solver beendet, da IDA sonst eine interne Warnung schmeißt
if (_tCurrent == _tEnd)
_cv_rt = IDA_TSTOP_RETURN;
}
// Zähler für die Anzahl der ausgegebenen Schritte erhöhen
++_outStps;
_tLastSuccess = _tCurrent;
if (_cv_rt == IDA_TSTOP_RETURN)
{
_time_system->setTime(_tEnd);
_continuous_system->setContinuousStates(NV_DATA_S(_CV_y));
if(_dimAE>0)
{
_mixed_system->setAlgebraicDAEVars(NV_DATA_S(_CV_y)+_dimStates);
_continuous_system->setStateDerivatives(NV_DATA_S(_CV_yp));
_continuous_system->evaluateDAE(IContinuous::CONTINUOUS);
}
else
{
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
}
if(writeOutput)
writeToFile(0, _tEnd, _h);
_accStps += _locStps;
_solverStatus = DONE;
}
}
}
CAMLprim value sundials_ml_ida_get_last_step(value ida_solver, value hlast) {
CAMLparam2(ida_solver, hlast);
double* _hlast = (double*)Field(hlast, 0);
const int ret = IDAGetLastStep(IDA_MEM(ida_solver), _hlast);
CAMLreturn(Val_int(ret));
}
