void FIDA_SETIIN(char key_name[], long int *ival, int *ier)
{
if (!strncmp(key_name,"MAX_ORD",7))
*ier = IDASetMaxOrd(IDA_idamem, (int) *ival);
else if (!strncmp(key_name,"MAX_NSTEPS",10))
*ier = IDASetMaxNumSteps(IDA_idamem, (int) *ival);
else if (!strncmp(key_name,"MAX_ERRFAIL",11))
*ier = IDASetMaxErrTestFails(IDA_idamem, (int) *ival);
else if (!strncmp(key_name,"MAX_NITERS",10))
*ier = IDASetMaxNonlinIters(IDA_idamem, (int) *ival);
else if (!strncmp(key_name,"MAX_CONVFAIL",12))
*ier = IDASetMaxConvFails(IDA_idamem, (int) *ival);
else if (!strncmp(key_name,"SUPPRESS_ALG",12))
*ier = IDASetSuppressAlg(IDA_idamem, (int) *ival);
else if (!strncmp(key_name,"MAX_NSTEPS_IC",13))
*ier = IDASetMaxNumStepsIC(IDA_idamem, (int) *ival);
else if (!strncmp(key_name,"MAX_NITERS_IC",13))
*ier = IDASetMaxNumItersIC(IDA_idamem, (int) *ival);
else if (!strncmp(key_name,"MAX_NJE_IC",10))
*ier = IDASetMaxNumJacsIC(IDA_idamem, (int) *ival);
else if (!strncmp(key_name,"LS_OFF_IC",9))
*ier = IDASetLineSearchOffIC(IDA_idamem, (int) *ival);
else {
*ier = -99;
printf("FIDASETIIN: Unrecognized key.\n\n");
}
}
int IDASetMaxNumStepsB(void *ida_mem, int which, long int mxstepsB)
{
IDAMem IDA_mem;
IDAadjMem IDAADJ_mem;
IDABMem IDAB_mem;
void *ida_memB;
/* Is ida_mem valid? */
if (ida_mem == NULL) {
IDAProcessError(NULL, IDA_MEM_NULL, "IDAA", "IDASetMaxNumStepsB", MSGAM_NULL_IDAMEM);
return IDA_MEM_NULL;
}
IDA_mem = (IDAMem) ida_mem;
/* Is ASA initialized? */
if (IDA_mem->ida_adjMallocDone == FALSE) {
IDAProcessError(IDA_mem, IDA_NO_ADJ, "IDAA", "IDASetMaxNumStepsB", MSGAM_NO_ADJ);
return(IDA_NO_ADJ);
}
IDAADJ_mem = IDA_mem->ida_adj_mem;
/* Check the value of which */
if ( which >= nbckpbs ) {
IDAProcessError(IDA_mem, IDA_ILL_INPUT, "IDAA", "IDASetMaxNumStepsB", MSGAM_BAD_WHICH);
return(IDA_ILL_INPUT);
}
/* Find the IDABMem entry in the linked list corresponding to 'which'. */
IDAB_mem = IDAADJ_mem->IDAB_mem;
while (IDAB_mem != NULL) {
if( which == IDAB_mem->ida_index ) break;
/* advance */
IDAB_mem = IDAB_mem->ida_next;
}
ida_memB = (void *) IDAB_mem->IDA_mem;
return IDASetMaxNumSteps(ida_memB, mxstepsB);
}
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));
}
}
void Ida::initialize()
{
_properties = dynamic_cast<ISystemProperties*>(_system);
_continuous_system = dynamic_cast<IContinuous*>(_system);
_event_system = dynamic_cast<IEvent*>(_system);
_mixed_system = dynamic_cast<IMixedSystem*>(_system);
_time_system = dynamic_cast<ITime*>(_system);
IGlobalSettings* global_settings = dynamic_cast<ISolverSettings*>(_idasettings)->getGlobalSettings();
// Kennzeichnung, dass initialize()() (vor der Integration) aufgerufen wurde
_idid = 5000;
_tLastEvent = 0.0;
_event_n = 0;
SolverDefaultImplementation::initialize();
_dimStates = _continuous_system->getDimContinuousStates();
_dimZeroFunc = _event_system->getDimZeroFunc()+_event_system->getDimClock();
_dimAE = _continuous_system->getDimAE();
if(_dimAE>0)
_dimSys=_dimAE+ _dimStates;
else
_dimSys=_dimStates;
if (_dimStates <= 0)
{
_idid = -1;
throw std::invalid_argument("Ida::initialize()");
}
else
{
// Allocate state vectors, stages and temporary arrays
/*if (_z)
delete[] _z;
if (_zInit)
delete[] _zInit;
if (_zWrite)
delete[] _zWrite;*/
if (_y)
delete[] _y;
if (_yInit)
delete[] _yInit;
if (_yWrite)
delete[] _yWrite;
if (_ypWrite)
delete[] _ypWrite;
if (_yp)
delete[] _yp;
if (_dae_res)
delete[] _dae_res;
if (_zeroSign)
delete[] _zeroSign;
if (_absTol)
delete[] _absTol;
if(_delta)
delete [] _delta;
if(_deltaInv)
delete [] _deltaInv;
if(_ysave)
delete [] _ysave;
_y = new double[_dimSys];
_yp = new double[_dimSys];
_yInit = new double[_dimSys];
_yWrite = new double[_dimSys];
_ypWrite = new double[_dimSys];
_dae_res = new double[_dimSys];
/*
_z = new double[_dimSys];
_zInit = new double[_dimSys];
_zWrite = new double[_dimSys];
*/
_zeroSign = new int[_dimZeroFunc];
_absTol = new double[_dimSys];
_delta =new double[_dimSys];
_deltaInv =new double[_dimSys];
_ysave =new double[_dimSys];
memset(_y, 0, _dimSys * sizeof(double));
memset(_yp, 0, _dimSys * sizeof(double));
memset(_yInit, 0, _dimSys * sizeof(double));
memset(_ysave, 0, _dimSys * sizeof(double));
std::fill_n(_absTol, _dimSys, 1.0);
// Counter initialisieren
_outStps = 0;
if (_idasettings->getDenseOutput())
{
// Ausgabeschrittweite
_hOut = global_settings->gethOutput();
}
// Allocate memory for the solver
_idaMem = IDACreate();
if (check_flag((void*) _idaMem, "IDACreate", 0))
{
_idid = -5;
throw std::invalid_argument(/*_idid,_tCurrent,*/"Ida::initialize()");
}
//
// Make Ida ready for integration
//
// Set initial values for IDA
//_continuous_system->evaluateAll(IContinuous::CONTINUOUS);
_continuous_system->getContinuousStates(_yInit);
memcpy(_y, _yInit, _dimStates * sizeof(double));
if(_dimAE>0)
{
_mixed_system->getAlgebraicDAEVars(_yInit+_dimStates);
memcpy(_y+_dimStates, _yInit+_dimStates, _dimAE * sizeof(double));
_continuous_system->getContinuousStates(_yp);
}
// Get nominal values
_continuous_system->getNominalStates(_absTol);
for (int i = 0; i < _dimStates; i++)
_absTol[i] = dynamic_cast<ISolverSettings*>(_idasettings)->getATol();
_CV_y0 = N_VMake_Serial(_dimSys, _yInit);
_CV_y = N_VMake_Serial(_dimSys, _y);
_CV_yp = N_VMake_Serial(_dimSys, _yp);
_CV_yWrite = N_VMake_Serial(_dimSys, _yWrite);
_CV_ypWrite = N_VMake_Serial(_dimSys, _ypWrite);
_CV_absTol = N_VMake_Serial(_dimSys, _absTol);
if (check_flag((void*) _CV_y0, "N_VMake_Serial", 0))
{
_idid = -5;
throw std::invalid_argument("Ida::initialize()");
}
//is already initialized: calcFunction(_tCurrent, NV_DATA_S(_CV_y0), NV_DATA_S(_CV_yp),NV_DATA_S(_CV_yp));
// Initialize Ida (Initial values are required)
_idid = IDAInit(_idaMem, rhsFunctionCB, _tCurrent, _CV_y0, _CV_yp);
if (_idid < 0)
{
_idid = -5;
throw std::invalid_argument("Ida::initialize()");
}
_idid = IDASetErrHandlerFn(_idaMem, errOutputIDA, _data);
if (_idid < 0)
throw std::invalid_argument("IDA::initialize()");
// Set Tolerances
_idid = IDASVtolerances(_idaMem, dynamic_cast<ISolverSettings*>(_idasettings)->getRTol(), _CV_absTol); // RTOL and ATOL
if (_idid < 0)
throw std::invalid_argument("IDA::initialize()");
// Set the pointer to user-defined data
_idid = IDASetUserData(_idaMem, _data);
if (_idid < 0)
throw std::invalid_argument("IDA::initialize()");
_idid = IDASetInitStep(_idaMem, 1e-6); // INITIAL STEPSIZE
if (_idid < 0)
throw std::invalid_argument("Ida::initialize()");
_idid = IDASetMaxStep(_idaMem, global_settings->getEndTime() / 10.0); // MAXIMUM STEPSIZE
if (_idid < 0)
throw std::invalid_argument("IDA::initialize()");
_idid = IDASetMaxNonlinIters(_idaMem, 5); // Max number of iterations
if (_idid < 0)
throw std::invalid_argument("IDA::initialize()");
_idid = IDASetMaxErrTestFails(_idaMem, 100);
if (_idid < 0)
throw std::invalid_argument("IDA::initialize()");
_idid = IDASetMaxNumSteps(_idaMem, 1e3); // Max Number of steps
if (_idid < 0)
throw std::invalid_argument(/*_idid,_tCurrent,*/"IDA::initialize()");
// Initialize linear solver
_idid = IDADense(_idaMem, _dimSys);
if (_idid < 0)
throw std::invalid_argument("IDA::initialize()");
if(_dimAE>0)
{
_idid = IDASetSuppressAlg(_idaMem, TRUE);
double* tmp = new double[_dimSys];
std::fill_n(tmp, _dimStates, 1.0);
std::fill_n(tmp+_dimStates, _dimAE, 0.0);
_idid = IDASetId(_idaMem, N_VMake_Serial(_dimSys,tmp));
delete [] tmp;
if (_idid < 0)
throw std::invalid_argument("IDA::initialize()");
}
// Use own jacobian matrix
//_idid = CVDlsSetDenseJacFn(_idaMem, &jacobianFunctionCB);
//if (_idid < 0)
// throw std::invalid_argument("IDA::initialize()");
if (_dimZeroFunc)
{
_idid = IDARootInit(_idaMem, _dimZeroFunc, &zeroFunctionCB);
memset(_zeroSign, 0, _dimZeroFunc * sizeof(int));
_idid = IDASetRootDirection(_idaMem, _zeroSign);
if (_idid < 0)
throw std::invalid_argument(/*_idid,_tCurrent,*/"IDA::initialize()");
memset(_zeroSign, -1, _dimZeroFunc * sizeof(int));
memset(_zeroVal, -1, _dimZeroFunc * sizeof(int));
}
_ida_initialized = true;
//
// IDA is ready for integration
//
// BOOST_LOG_SEV(ida_lg::get(), ida_info) << "IDA initialized";
}
}
int main(void)
{
UserData data;
void *mem;
N_Vector yy, yp, id, q;
realtype tret, tout;
int flag;
id = N_VNew_Serial(NEQ);
yy = N_VNew_Serial(NEQ);
yp = N_VNew_Serial(NEQ);
q = N_VNew_Serial(1);
data = (UserData) malloc(sizeof *data);
data->a = 0.5; /* half-length of crank */
data->J1 = 1.0; /* crank moment of inertia */
data->m2 = 1.0; /* mass of connecting rod */
data->m1 = 1.0;
data->J2 = 2.0; /* moment of inertia of connecting rod */
data->params[0] = 1.0; /* spring constant */
data->params[1] = 1.0; /* damper constant */
data->l0 = 1.0; /* spring free length */
data->F = 1.0; /* external constant force */
N_VConst(ONE, id);
NV_Ith_S(id, 9) = ZERO;
NV_Ith_S(id, 8) = ZERO;
NV_Ith_S(id, 7) = ZERO;
NV_Ith_S(id, 6) = ZERO;
/* Consistent IC*/
setIC(yy, yp, data);
/* IDAS initialization */
mem = IDACreate();
flag = IDAInit(mem, ressc, TBEGIN, yy, yp);
flag = IDASStolerances(mem, RTOLF, ATOLF);
flag = IDASetUserData(mem, data);
flag = IDASetId(mem, id);
flag = IDASetSuppressAlg(mem, TRUE);
flag = IDASetMaxNumSteps(mem, 20000);
/* Call IDADense and set up the linear solver. */
flag = IDADense(mem, NEQ);
N_VConst(ZERO, q);
flag = IDAQuadInit(mem, rhsQ, q);
flag = IDAQuadSStolerances(mem, RTOLQ, ATOLQ);
flag = IDASetQuadErrCon(mem, TRUE);
PrintHeader(RTOLF, ATOLF, yy);
/* Print initial states */
PrintOutput(mem,0.0,yy);
/* Perform forward run */
tout = TEND/NOUT;
while (1) {
flag = IDASolve(mem, tout, &tret, yy, yp, IDA_NORMAL);
if (check_flag(&flag, "IDASolve", 1)) return(1);
PrintOutput(mem,tret,yy);
tout += TEND/NOUT;
if (tret > TEND) break;
}
PrintFinalStats(mem);
IDAGetQuad(mem, &tret, q);
printf("--------------------------------------------\n");
printf(" G = %24.16f\n", Ith(q,1));
printf("--------------------------------------------\n\n");
IDAFree(&mem);
/* Free memory */
free(data);
N_VDestroy(id);
N_VDestroy_Serial(yy);
N_VDestroy_Serial(yp);
N_VDestroy_Serial(q);
return(0);
}
CAMLprim value sundials_ml_ida_set_max_num_steps(value ida_solver, value maxsteps) {
CAMLparam2(ida_solver, maxsteps);
const int ret = IDASetMaxNumSteps(IDA_MEM(ida_solver), Int_val(maxsteps));
CAMLreturn(Val_int(ret));
}
int main(void)
{
UserData data;
void *mem;
N_Vector yy, yp, id, q, *yyS, *ypS, *qS;
realtype tret;
realtype pbar[2];
realtype dp, G, Gm[2], Gp[2];
int flag, is;
realtype atolS[NP];
id = N_VNew_Serial(NEQ);
yy = N_VNew_Serial(NEQ);
yp = N_VNew_Serial(NEQ);
q = N_VNew_Serial(1);
yyS= N_VCloneVectorArray(NP,yy);
ypS= N_VCloneVectorArray(NP,yp);
qS = N_VCloneVectorArray_Serial(NP, q);
data = (UserData) malloc(sizeof *data);
data->a = 0.5; /* half-length of crank */
data->J1 = 1.0; /* crank moment of inertia */
data->m2 = 1.0; /* mass of connecting rod */
data->m1 = 1.0;
data->J2 = 2.0; /* moment of inertia of connecting rod */
data->params[0] = 1.0; /* spring constant */
data->params[1] = 1.0; /* damper constant */
data->l0 = 1.0; /* spring free length */
data->F = 1.0; /* external constant force */
N_VConst(ONE, id);
NV_Ith_S(id, 9) = ZERO;
NV_Ith_S(id, 8) = ZERO;
NV_Ith_S(id, 7) = ZERO;
NV_Ith_S(id, 6) = ZERO;
printf("\nSlider-Crank example for IDAS:\n");
/* Consistent IC*/
setIC(yy, yp, data);
for (is=0;is<NP;is++) {
N_VConst(ZERO, yyS[is]);
N_VConst(ZERO, ypS[is]);
}
/* IDA initialization */
mem = IDACreate();
flag = IDAInit(mem, ressc, TBEGIN, yy, yp);
flag = IDASStolerances(mem, RTOLF, ATOLF);
flag = IDASetUserData(mem, data);
flag = IDASetId(mem, id);
flag = IDASetSuppressAlg(mem, TRUE);
flag = IDASetMaxNumSteps(mem, 20000);
/* Call IDADense and set up the linear solver. */
flag = IDADense(mem, NEQ);
flag = IDASensInit(mem, NP, IDA_SIMULTANEOUS, NULL, yyS, ypS);
pbar[0] = data->params[0];pbar[1] = data->params[1];
flag = IDASetSensParams(mem, data->params, pbar, NULL);
flag = IDASensEEtolerances(mem);
IDASetSensErrCon(mem, TRUE);
N_VConst(ZERO, q);
flag = IDAQuadInit(mem, rhsQ, q);
flag = IDAQuadSStolerances(mem, RTOLQ, ATOLQ);
flag = IDASetQuadErrCon(mem, TRUE);
N_VConst(ZERO, qS[0]);
flag = IDAQuadSensInit(mem, rhsQS, qS);
atolS[0] = atolS[1] = ATOLQ;
flag = IDAQuadSensSStolerances(mem, RTOLQ, atolS);
flag = IDASetQuadSensErrCon(mem, TRUE);
/* Perform forward run */
printf("\nForward integration ... ");
flag = IDASolve(mem, TEND, &tret, yy, yp, IDA_NORMAL);
if (check_flag(&flag, "IDASolve", 1)) return(1);
printf("done!\n");
PrintFinalStats(mem);
IDAGetQuad(mem, &tret, q);
printf("--------------------------------------------\n");
printf(" G = %24.16f\n", Ith(q,1));
printf("--------------------------------------------\n\n");
IDAGetQuadSens(mem, &tret, qS);
printf("-------------F O R W A R D------------------\n");
printf(" dG/dp: %12.4le %12.4le\n", Ith(qS[0],1), Ith(qS[1],1));
printf("--------------------------------------------\n\n");
IDAFree(&mem);
/* Finite differences for dG/dp */
dp = 0.00001;
data->params[0] = ONE;
data->params[1] = ONE;
mem = IDACreate();
setIC(yy, yp, data);
flag = IDAInit(mem, ressc, TBEGIN, yy, yp);
flag = IDASStolerances(mem, RTOLFD, ATOLFD);
flag = IDASetUserData(mem, data);
flag = IDASetId(mem, id);
flag = IDASetSuppressAlg(mem, TRUE);
/* Call IDADense and set up the linear solver. */
flag = IDADense(mem, NEQ);
N_VConst(ZERO, q);
IDAQuadInit(mem, rhsQ, q);
IDAQuadSStolerances(mem, RTOLQ, ATOLQ);
IDASetQuadErrCon(mem, TRUE);
IDASolve(mem, TEND, &tret, yy, yp, IDA_NORMAL);
IDAGetQuad(mem,&tret,q);
G = Ith(q,1);
/*printf(" G =%12.6e\n", Ith(q,1));*/
/******************************
* BACKWARD for k
******************************/
data->params[0] -= dp;
setIC(yy, yp, data);
IDAReInit(mem, TBEGIN, yy, yp);
N_VConst(ZERO, q);
IDAQuadReInit(mem, q);
IDASolve(mem, TEND, &tret, yy, yp, IDA_NORMAL);
IDAGetQuad(mem, &tret, q);
Gm[0] = Ith(q,1);
/*printf("Gm[0]=%12.6e\n", Ith(q,1));*/
/****************************
* FORWARD for k *
****************************/
data->params[0] += (TWO*dp);
setIC(yy, yp, data);
IDAReInit(mem, TBEGIN, yy, yp);
N_VConst(ZERO, q);
IDAQuadReInit(mem, q);
IDASolve(mem, TEND, &tret, yy, yp, IDA_NORMAL);
IDAGetQuad(mem, &tret, q);
Gp[0] = Ith(q,1);
/*printf("Gp[0]=%12.6e\n", Ith(q,1));*/
/* Backward for c */
data->params[0] = ONE;
data->params[1] -= dp;
setIC(yy, yp, data);
IDAReInit(mem, TBEGIN, yy, yp);
N_VConst(ZERO, q);
IDAQuadReInit(mem, q);
IDASolve(mem, TEND, &tret, yy, yp, IDA_NORMAL);
IDAGetQuad(mem, &tret, q);
Gm[1] = Ith(q,1);
/* Forward for c */
data->params[1] += (TWO*dp);
setIC(yy, yp, data);
IDAReInit(mem, TBEGIN, yy, yp);
N_VConst(ZERO, q);
IDAQuadReInit(mem, q);
IDASolve(mem, TEND, &tret, yy, yp, IDA_NORMAL);
IDAGetQuad(mem, &tret, q);
Gp[1] = Ith(q,1);
IDAFree(&mem);
printf("\n\n Checking using Finite Differences \n\n");
printf("---------------BACKWARD------------------\n");
printf(" dG/dp: %12.4le %12.4le\n", (G-Gm[0])/dp, (G-Gm[1])/dp);
printf("-----------------------------------------\n\n");
printf("---------------FORWARD-------------------\n");
printf(" dG/dp: %12.4le %12.4le\n", (Gp[0]-G)/dp, (Gp[1]-G)/dp);
printf("-----------------------------------------\n\n");
printf("--------------CENTERED-------------------\n");
printf(" dG/dp: %12.4le %12.4le\n", (Gp[0]-Gm[0])/(TWO*dp) ,(Gp[1]-Gm[1])/(TWO*dp));
printf("-----------------------------------------\n\n");
/* Free memory */
free(data);
N_VDestroy(id);
N_VDestroy_Serial(yy);
N_VDestroy_Serial(yp);
N_VDestroy_Serial(q);
return(0);
}
