/* Fortran interface to C routine ARKodeGetRootInfo; see
farkroot.h for further information. */
void FARK_ROOTINFO(int *nrtfn, int *info, int *ier)
{
*ier = ARKodeGetRootInfo(ARK_arkodemem, info);
return;
}
void Arkode::ArkodeCore()
{
_idid = ARKodeReInit(_arkodeMem, NULL, ARK_fCallback, _tCurrent, _ARK_y);
_idid = ARKodeSetStopTime(_arkodeMem, _tEnd);
_idid = ARKodeSetInitStep(_arkodeMem, 1e-12);
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"ARKode::ReInit");
bool writeEventOutput = (_settings->getGlobalSettings()->getOutputPointType() == OPT_ALL);
bool writeOutput = !(_settings->getGlobalSettings()->getOutputPointType() == OPT_NONE);
while (_solverStatus & ISolver::CONTINUE && !_interrupt )
{
_ark_rt = ARKode(_arkodeMem, _tEnd, _ARK_y, &_tCurrent, ARK_ONE_STEP);
_idid = ARKodeGetNumSteps(_arkodeMem, &_locStps);
//if (_idid != CV_SUCCESS)
// throw ModelicaSimulationError(SOLVER,"CVodeGetNumSteps failed. The cvode mem pointer is NULL");
_idid = ARKodeGetLastStep(_arkodeMem, &_h);
//if (_idid != CV_SUCCESS)
// throw ModelicaSimulationError(SOLVER,"CVodeGetLastStep failed. The cvode mem pointer is NULL");
//Check if there was at least one output-point within the last solver interval
// -> Write output if true
if (writeOutput)
{
writeArkodeOutput(_tCurrent, _h, _locStps);
}
//set completed step to system and check if terminate was called
if(_continuous_system->stepCompleted(_tCurrent))
_solverStatus = DONE;
// Perform state selection
bool state_selection = stateSelection();
if (state_selection)
_continuous_system->getContinuousStates(_z);
_zeroFound = false;
// Check if step was successful
/*
if (check_flag(&_cv_rt, "CVode", 1))
{
_solverStatus = ISolver::SOLVERERROR;
break;
}*/
// A root was found
if ((_ark_rt == ARK_ROOT_RETURN) && !isInterrupted())
{
// CVode 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 ModelicaSimulationError(EVENT_HANDLING,"Number of events exceeded in time interval " + to_string(_abs) + " at time " + to_string(_tCurrent));
// CVode 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)
{
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
writeToFile(0, _tCurrent, _h);
}
_idid = ARKodeGetRootInfo(_arkodeMem, _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 cvode-solver
// Take care about the memory regions, _z is the same like _CV_y
_continuous_system->getContinuousStates(_z);
}
}
if ((_zeroFound || state_selection)&& !isInterrupted())
{
if (writeEventOutput)
{
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
writeToFile(0, _tCurrent, _h);
}
_idid = ARKodeReInit(_arkodeMem, NULL, ARK_fCallback, _tCurrent, _ARK_y);
if (_idid < 0)
throw ModelicaSimulationError(SOLVER,"CVode::ReInit()");
// Der Eventzeitpunkt kann auf der Endzeit liegen (Time-Events). In diesem Fall wird der Solver beendet, da CVode sonst eine interne Warnung
if (_tCurrent == _tEnd)
_ark_rt = ARK_TSTOP_RETURN;
}
++_outStps;
_tLastSuccess = _tCurrent;
if (_ark_rt == ARK_TSTOP_RETURN)
{
_time_system->setTime(_tEnd);
//Solver has finished calculation - calculate the final values
_continuous_system->setContinuousStates(NV_DATA_S(_ARK_y));
_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
if(writeOutput)
writeToFile(0, _tEnd, _h);
_accStps += _locStps;
_solverStatus = DONE;
}
}
}
/* Main Program */
int main()
{
/* general problem parameters */
realtype T0 = RCONST(0.0); /* initial time */
realtype T1 = RCONST(0.4); /* first output time */
realtype TMult = RCONST(10.0); /* output time multiplication factor */
int Nt = 12; /* total number of output times */
long int NEQ = 3; /* number of dependent vars. */
realtype reltol;
int rootsfound[2];
long int nst, nst_a, nfe, nfi, nsetups;
long int nje, nfeLS, nni, ncfn, netf, nge;
int flag, rtflag; /* reusable error-checking flags */
FILE *UFID;
realtype t, tout;
int iout;
/* general problem variables */
N_Vector y = NULL; /* empty vector for storing solution */
N_Vector atols = NULL; /* empty vector for absolute tolerances */
void *arkode_mem = NULL; /* empty ARKode memory structure */
/* set up the initial conditions */
realtype u0 = RCONST(1.0);
realtype v0 = RCONST(0.0);
realtype w0 = RCONST(0.0);
/* Initial problem output */
printf("\nRobertson ODE test problem (with rootfinding):\n");
printf(" initial conditions: u0 = %g, v0 = %g, w0 = %g\n",u0,v0,w0);
/* Initialize data structures */
y = N_VNew_Serial(NEQ); /* Create serial vector for solution */
if (check_flag((void *) y, "N_VNew_Serial", 0)) return 1;
atols = N_VNew_Serial(NEQ); /* Create serial vector absolute tolerances */
if (check_flag((void *) atols, "N_VNew_Serial", 0)) return 1;
NV_Ith_S(y,0) = u0; /* Set initial conditions into y */
NV_Ith_S(y,1) = v0;
NV_Ith_S(y,2) = w0;
arkode_mem = ARKodeCreate(); /* Create the solver memory */
if (check_flag((void *)arkode_mem, "ARKodeCreate", 0)) return 1;
/* Call ARKodeInit to initialize the integrator memory and specify the
hand-side side function in y'=f(t,y), the inital time T0, and
the initial dependent variable vector y. Note: since this
problem is fully implicit, we set f_E to NULL and f_I to f. */
flag = ARKodeInit(arkode_mem, NULL, f, T0, y);
if (check_flag(&flag, "ARKodeInit", 1)) return 1;
/* Set tolerances */
reltol = RCONST(1.0e-4);
NV_Ith_S(atols,0) = RCONST(1.0e-8);
NV_Ith_S(atols,1) = RCONST(1.0e-11);
NV_Ith_S(atols,2) = RCONST(1.0e-8);
/* Set routines */
flag = ARKodeSetMaxErrTestFails(arkode_mem, 20); /* Increase max error test fails */
if (check_flag(&flag, "ARKodeSetMaxErrTestFails", 1)) return 1;
flag = ARKodeSetMaxNonlinIters(arkode_mem, 8); /* Increase max nonlinear iterations */
if (check_flag(&flag, "ARKodeSetMaxNonlinIters", 1)) return 1;
flag = ARKodeSetNonlinConvCoef(arkode_mem, 1.e-7); /* Update nonlinear solver convergence coeff. */
if (check_flag(&flag, "ARKodeSetNonlinConvCoef", 1)) return 1;
flag = ARKodeSetMaxNumSteps(arkode_mem, 100000); /* Increase max number of steps */
if (check_flag(&flag, "ARKodeSetMaxNumSteps", 1)) return 1;
flag = ARKodeSVtolerances(arkode_mem, reltol, atols); /* Specify tolerances */
if (check_flag(&flag, "ARKodeSStolerances", 1)) return 1;
/* Specify the root-finding function, having 2 equations */
flag = ARKodeRootInit(arkode_mem, 2, g);
if (check_flag(&flag, "ARKodeRootInit", 1)) return 1;
/* Linear solver specification */
flag = ARKDense(arkode_mem, NEQ); /* Specify dense linear solver */
if (check_flag(&flag, "ARKDense", 1)) return 1;
flag = ARKDlsSetDenseJacFn(arkode_mem, Jac); /* Set the Jacobian routine */
if (check_flag(&flag, "ARKDlsSetDenseJacFn", 1)) return 1;
/* Open output stream for results, output comment line */
UFID = fopen("solution.txt","w");
fprintf(UFID,"# t u v w\n");
/* output initial condition to disk */
fprintf(UFID," %.16e %.16e %.16e %.16e\n",
T0, NV_Ith_S(y,0), NV_Ith_S(y,1), NV_Ith_S(y,2));
/* Main time-stepping loop: calls ARKode to perform the integration, then
prints results. Stops when the final time has been reached */
t = T0;
printf(" t u v w\n");
printf(" -----------------------------------------------------\n");
printf(" %12.5e %12.5e %12.5e %12.5e\n",
t, NV_Ith_S(y,0), NV_Ith_S(y,1), NV_Ith_S(y,2));
tout = T1;
iout = 0;
while(1) {
flag = ARKode(arkode_mem, tout, y, &t, ARK_NORMAL); /* call integrator */
if (check_flag(&flag, "ARKode", 1)) break;
printf(" %12.5e %12.5e %12.5e %12.5e\n", t, /* access/print solution */
NV_Ith_S(y,0), NV_Ith_S(y,1), NV_Ith_S(y,2));
fprintf(UFID," %.16e %.16e %.16e %.16e\n",
t, NV_Ith_S(y,0), NV_Ith_S(y,1), NV_Ith_S(y,2));
if (flag == ARK_ROOT_RETURN) { /* check if a root was found */
rtflag = ARKodeGetRootInfo(arkode_mem, rootsfound);
if (check_flag(&rtflag, "ARKodeGetRootInfo", 1)) return 1;
printf(" rootsfound[] = %3d %3d\n",
rootsfound[0], rootsfound[1]);
}
if (flag >= 0) { /* successful solve: update output time */
iout++;
tout *= TMult;
} else { /* unsuccessful solve: break */
fprintf(stderr,"Solver failure, stopping integration\n");
break;
}
if (iout == Nt) break; /* stop after enough outputs */
}
printf(" -----------------------------------------------------\n");
fclose(UFID);
/* Print some final statistics */
flag = ARKodeGetNumSteps(arkode_mem, &nst);
check_flag(&flag, "ARKodeGetNumSteps", 1);
flag = ARKodeGetNumStepAttempts(arkode_mem, &nst_a);
check_flag(&flag, "ARKodeGetNumStepAttempts", 1);
flag = ARKodeGetNumRhsEvals(arkode_mem, &nfe, &nfi);
check_flag(&flag, "ARKodeGetNumRhsEvals", 1);
flag = ARKodeGetNumLinSolvSetups(arkode_mem, &nsetups);
check_flag(&flag, "ARKodeGetNumLinSolvSetups", 1);
flag = ARKodeGetNumErrTestFails(arkode_mem, &netf);
check_flag(&flag, "ARKodeGetNumErrTestFails", 1);
flag = ARKodeGetNumNonlinSolvIters(arkode_mem, &nni);
check_flag(&flag, "ARKodeGetNumNonlinSolvIters", 1);
flag = ARKodeGetNumNonlinSolvConvFails(arkode_mem, &ncfn);
check_flag(&flag, "ARKodeGetNumNonlinSolvConvFails", 1);
flag = ARKDlsGetNumJacEvals(arkode_mem, &nje);
check_flag(&flag, "ARKDlsGetNumJacEvals", 1);
flag = ARKDlsGetNumRhsEvals(arkode_mem, &nfeLS);
check_flag(&flag, "ARKDlsGetNumRhsEvals", 1);
flag = ARKodeGetNumGEvals(arkode_mem, &nge);
check_flag(&flag, "ARKodeGetNumGEvals", 1);
printf("\nFinal Solver Statistics:\n");
printf(" Internal solver steps = %li (attempted = %li)\n",
nst, nst_a);
printf(" Total RHS evals: Fe = %li, Fi = %li\n", nfe, nfi);
printf(" Total linear solver setups = %li\n", nsetups);
printf(" Total RHS evals for setting up the linear system = %li\n", nfeLS);
printf(" Total number of Jacobian evaluations = %li\n", nje);
printf(" Total number of Newton iterations = %li\n", nni);
printf(" Total root-function g evals = %li\n", nge);
printf(" Total number of nonlinear solver convergence failures = %li\n", ncfn);
printf(" Total number of error test failures = %li\n", netf);
/* Clean up and return with successful completion */
N_VDestroy_Serial(y); /* Free y vector */
ARKodeFree(&arkode_mem); /* Free integrator memory */
return 0;
}
