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); }