int main() { void *mem; UserData webdata; N_Vector cc, cp, id; int iout, retval; long int mu, ml; 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); 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); retval = IDASetUserData(mem, webdata); if(check_flag(&retval, "IDASetUserData", 1)) return(1); retval = IDASetId(mem, id); if(check_flag(&retval, "IDASetId", 1)) return(1); retval = IDAInit(mem, resweb, t0, cc, cp); if(check_flag(&retval, "IDAInit", 1)) return(1); retval = IDASStolerances(mem, rtol, atol); if(check_flag(&retval, "IDASStolerances", 1)) return(1); /* Call IDABand to specify the IDA linear solver. */ mu = ml = NSMX; retval = IDABand(mem, NEQ, mu, ml); if(check_flag(&retval, "IDABand", 1)) return(1); /* Call IDACalcIC (with default options) to correct the initial values. */ tout = RCONST(0.001); retval = IDACalcIC(mem, IDA_YA_YDP_INIT, tout); if(check_flag(&retval, "IDACalcIC", 1)) return(1); /* Print heading, basic parameters, and initial values. */ PrintHeader(mu, ml, rtol, atol); PrintOutput(mem, cc, ZERO); /* Loop over iout, call IDASolve (normal mode), print selected output. */ for (iout = 1; iout <= NOUT; iout++) { retval = IDASolve(mem, tout, &tret, cc, cp, IDA_NORMAL); if(check_flag(&retval, "IDASolve", 1)) return(retval); 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); free(webdata); return(0); }
int SundialsIda::integrateToTime(realtype t) { int flag = IDASolve(sundialsMem, t, &tInt, y.forSundials(), ydot.forSundials(), IDA_NORMAL); return flag; }
int main(void) { void *mem; UserData data; N_Vector uu, up, constraints, id, res; int ier, iout; long int mu, ml, netf, ncfn; realtype rtol, atol, t0, t1, tout, tret; mem = NULL; data = NULL; uu = up = constraints = id = res = NULL; /* Create vectors uu, up, res, constraints, id. */ 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); id = N_VNew_Serial(NEQ); if(check_flag((void *)id, "N_VNew_Serial", 0)) return(1); /* Create and load problem data block. */ data = (UserData) malloc(sizeof *data); if(check_flag((void *)data, "malloc", 2)) return(1); data->mm = MGRID; data->dx = ONE/(MGRID - ONE); data->coeff = ONE/( (data->dx) * (data->dx) ); /* Initialize uu, up, id. */ SetInitialProfile(data, uu, up, id, res); /* Set constraints to all 1's for nonnegative solution values. */ N_VConst(ONE, constraints); /* Set remaining input 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 = IDASetId(mem, id); if(check_flag(&ier, "IDASetId", 1)) return(1); ier = IDASetConstraints(mem, constraints); if(check_flag(&ier, "IDASetConstraints", 1)) return(1); N_VDestroy_Serial(constraints); ier = IDAInit(mem, heatres, 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 IDABand to specify the linear solver. */ mu = MGRID; ml = MGRID; ier = IDABand(mem, NEQ, mu, ml); if(check_flag(&ier, "IDABand", 1)) return(1); /* Call IDACalcIC to correct the initial values. */ ier = IDACalcIC(mem, IDA_YA_YDP_INIT, t1); if(check_flag(&ier, "IDACalcIC", 1)) return(1); /* Print output heading. */ PrintHeader(rtol, atol); PrintOutput(mem, t0, uu); /* 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 and free memory. */ ier = IDAGetNumErrTestFails(mem, &netf); check_flag(&ier, "IDAGetNumErrTestFails", 1); ier = IDAGetNumNonlinSolvConvFails(mem, &ncfn); check_flag(&ier, "IDAGetNumNonlinSolvConvFails", 1); printf("\n netf = %ld, ncfn = %ld \n", netf, ncfn); IDAFree(&mem); N_VDestroy_Serial(uu); N_VDestroy_Serial(up); N_VDestroy_Serial(id); N_VDestroy_Serial(res); free(data); return(0); }
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(_z); _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) { _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(_z); calcFunction(_tCurrent, NV_DATA_S(_CV_y), NV_DATA_S(_CV_yp)); } } 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 _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)); _continuous_system->evaluateAll(IContinuous::CONTINUOUS); if(writeOutput) writeToFile(0, _tEnd, _h); _accStps += _locStps; _solverStatus = DONE; } } }
int main(int argc, char *argv[]) { MPI_Comm comm; void *mem; UserData data; int thispe, iout, ier, npes; long int Neq, local_N, mudq, mldq, mukeep, mlkeep; realtype rtol, atol, t0, t1, tout, tret; N_Vector uu, up, constraints, id, res; mem = NULL; data = NULL; uu = up = constraints = id = res = NULL; /* Get processor number and total number of pe's. */ MPI_Init(&argc, &argv); comm = MPI_COMM_WORLD; MPI_Comm_size(comm, &npes); MPI_Comm_rank(comm, &thispe); if (npes != NPEX*NPEY) { if (thispe == 0) fprintf(stderr, "\nMPI_ERROR(0): npes = %d is not equal to NPEX*NPEY = %d\n", npes,NPEX*NPEY); MPI_Finalize(); return(1); } /* Set local length local_N and global length Neq. */ local_N = MXSUB*MYSUB; Neq = MX * MY; /* Allocate N-vectors. */ uu = N_VNew_Parallel(comm, local_N, Neq); if(check_flag((void *)uu, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1); up = N_VNew_Parallel(comm, local_N, Neq); if(check_flag((void *)up, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1); res = N_VNew_Parallel(comm, local_N, Neq); if(check_flag((void *)res, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1); constraints = N_VNew_Parallel(comm, local_N, Neq); if(check_flag((void *)constraints, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1); id = N_VNew_Parallel(comm, local_N, Neq); if(check_flag((void *)id, "N_VNew_Parallel", 0, thispe)) MPI_Abort(comm, 1); /* Allocate and initialize the data structure. */ data = (UserData) malloc(sizeof *data); if(check_flag((void *)data, "malloc", 2, thispe)) MPI_Abort(comm, 1); InitUserData(thispe, comm, data); /* Initialize the uu, up, id, and constraints profiles. */ SetInitialProfile(uu, up, id, res, data); N_VConst(ONE, constraints); t0 = ZERO; t1 = RCONST(0.01); /* Scalar relative and absolute tolerance. */ rtol = ZERO; atol = RCONST(1.0e-3); /* Call IDACreate and IDAMalloc to initialize solution */ mem = IDACreate(); if(check_flag((void *)mem, "IDACreate", 0, thispe)) MPI_Abort(comm, 1); ier = IDASetUserData(mem, data); if(check_flag(&ier, "IDASetUserData", 1, thispe)) MPI_Abort(comm, 1); ier = IDASetSuppressAlg(mem, TRUE); if(check_flag(&ier, "IDASetSuppressAlg", 1, thispe)) MPI_Abort(comm, 1); ier = IDASetId(mem, id); if(check_flag(&ier, "IDASetId", 1, thispe)) MPI_Abort(comm, 1); ier = IDASetConstraints(mem, constraints); if(check_flag(&ier, "IDASetConstraints", 1, thispe)) MPI_Abort(comm, 1); N_VDestroy_Parallel(constraints); ier = IDAInit(mem, heatres, t0, uu, up); if(check_flag(&ier, "IDAInit", 1, thispe)) MPI_Abort(comm, 1); ier = IDASStolerances(mem, rtol, atol); if(check_flag(&ier, "IDASStolerances", 1, thispe)) MPI_Abort(comm, 1); mudq = MXSUB; mldq = MXSUB; mukeep = 1; mlkeep = 1; /* Print problem description */ if (thispe == 0 ) PrintHeader(Neq, rtol, atol); /* * ----------------------------- * Case 1 -- mldq = mudq = MXSUB * ----------------------------- */ /* Call IDASpgmr to specify the linear solver. */ ier = IDASpgmr(mem, 0); if(check_flag(&ier, "IDASpgmr", 1, thispe)) MPI_Abort(comm, 1); /* Call IDABBDPrecInit to initialize BBD preconditioner. */ ier = IDABBDPrecInit(mem, local_N, mudq, mldq, mukeep, mlkeep, ZERO, reslocal, NULL); if(check_flag(&ier, "IDABBDPrecAlloc", 1, thispe)) MPI_Abort(comm, 1); /* Print output heading (on processor 0 only) and initial solution. */ if (thispe == 0) PrintCase(1, mudq, mukeep); /* Loop over tout, call IDASolve, print output. */ 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, thispe)) MPI_Abort(comm, 1); PrintOutput(thispe, mem, tret, uu); } /* Print final statistics */ if (thispe == 0) PrintFinalStats(mem); /* * ----------------------------- * Case 2 -- mldq = mudq = 1 * ----------------------------- */ mudq = 1; mldq = 1; /* Re-initialize the uu and up profiles. */ SetInitialProfile(uu, up, id, res, data); /* Call IDAReInit to re-initialize IDA. */ ier = IDAReInit(mem, t0, uu, up); if(check_flag(&ier, "IDAReInit", 1, thispe)) MPI_Abort(comm, 1); /* Call IDABBDPrecReInit to re-initialize BBD preconditioner. */ ier = IDABBDPrecReInit(mem, mudq, mldq, ZERO); if(check_flag(&ier, "IDABBDPrecReInit", 1, thispe)) MPI_Abort(comm, 1); /* Print output heading (on processor 0 only). */ if (thispe == 0) PrintCase(2, mudq, mukeep); /* Loop over tout, call IDASolve, print output. */ 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, thispe)) MPI_Abort(comm, 1); PrintOutput(thispe, mem, tret, uu); } /* Print final statistics */ if (thispe == 0) PrintFinalStats(mem); /* Free Memory */ IDAFree(&mem); free(data); N_VDestroy_Parallel(id); N_VDestroy_Parallel(res); N_VDestroy_Parallel(up); N_VDestroy_Parallel(uu); MPI_Finalize(); return(0); }
int main(int argc, char *argv[]) { MPI_Comm comm; void *mem; UserData webdata; 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 FIDA_SOLVE(realtype *tout, realtype *tret, realtype *yret, realtype *ypret, int *itask, int *ier) { int klast, kcur; *ier = 0; /* Attach user data to vectors */ N_VSetArrayPointer(yret, F2C_IDA_vec); N_VSetArrayPointer(ypret, F2C_IDA_ypvec); *ier = IDASolve(IDA_idamem, *tout, tret, F2C_IDA_vec, F2C_IDA_ypvec, *itask); /* Reset data pointers */ N_VSetArrayPointer(NULL, F2C_IDA_vec); N_VSetArrayPointer(NULL, F2C_IDA_ypvec); /* Set optional outputs */ IDAGetWorkSpace(IDA_idamem, &IDA_iout[0], /* LENRW */ &IDA_iout[1]); /* LENIW */ IDAGetIntegratorStats(IDA_idamem, &IDA_iout[2], /* NST */ &IDA_iout[3], /* NRE */ &IDA_iout[7], /* NSETUPS */ &IDA_iout[4], /* NETF */ &klast, /* KLAST */ &kcur, /* KCUR */ &IDA_rout[0], /* HINUSED */ &IDA_rout[1], /* HLAST */ &IDA_rout[2], /* HCUR */ &IDA_rout[3]); /* TCUR */ IDA_iout[8] = (long int) klast; IDA_iout[9] = (long int) kcur; IDAGetNonlinSolvStats(IDA_idamem, &IDA_iout[6], /* NNI */ &IDA_iout[5]); /* NCFN */ IDAGetNumBacktrackOps(IDA_idamem, &IDA_iout[10]); /* NBCKTRK */ IDAGetTolScaleFactor(IDA_idamem, &IDA_rout[4]); /* TOLSFAC */ /* Root finding is on */ if (IDA_nrtfn != 0) IDAGetNumGEvals(IDA_idamem, &IDA_iout[11]); /* NGE */ switch(IDA_ls) { case IDA_LS_DENSE: case IDA_LS_BAND: case IDA_LS_LAPACKDENSE: case IDA_LS_LAPACKBAND: IDADlsGetWorkSpace(IDA_idamem, &IDA_iout[12], &IDA_iout[13]); /* LENRWLS, LENIWLS */ IDADlsGetLastFlag(IDA_idamem, &IDA_iout[14]); /* LSTF */ IDADlsGetNumResEvals(IDA_idamem, &IDA_iout[15]); /* NRE */ IDADlsGetNumJacEvals(IDA_idamem, &IDA_iout[16]); /* NJE */ break; case IDA_LS_KLU: case IDA_LS_SUPERLUMT: IDASlsGetLastFlag(IDA_idamem, &IDA_iout[14]); /* LSTF */ IDASlsGetNumJacEvals(IDA_idamem, &IDA_iout[16]); /* NJE */ break; case IDA_LS_SPGMR: case IDA_LS_SPBCG: case IDA_LS_SPTFQMR: IDASpilsGetWorkSpace(IDA_idamem, &IDA_iout[12], &IDA_iout[13]); /* LENRWLS, LENIWLS */ IDASpilsGetLastFlag(IDA_idamem, &IDA_iout[14]); /* LSTF */ IDASpilsGetNumResEvals(IDA_idamem, &IDA_iout[15]); /* NRE */ IDASpilsGetNumJtimesEvals(IDA_idamem, &IDA_iout[16]); /* NJE */ IDASpilsGetNumPrecEvals(IDA_idamem, &IDA_iout[17]); /* NPE */ IDASpilsGetNumPrecSolves(IDA_idamem, &IDA_iout[18]); /* NPS */ IDASpilsGetNumLinIters(IDA_idamem, &IDA_iout[19]); /* NLI */ IDASpilsGetNumConvFails(IDA_idamem, &IDA_iout[20]); /* NCFL */ break; } return; }
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(void) { void *mem; UserData data; N_Vector uu, up, constraints, id, res; /* uu is u, up is du/dt */ int ier, iout; long int netf, ncfn; realtype rtol, atol, t0, t1, tout, tret; int nnz; /* number of non-zeroes */ mem = NULL; data = NULL; uu = up = constraints = id = res = NULL; /* Create vectors uu, up, res, constraints, id. */ 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); id = N_VNew_Serial(NEQ); /* differentiate between algebraic and differential */ if(check_flag((void *)id, "N_VNew_Serial", 0)) return(1); /* Create and load problem data block. */ data = (UserData) malloc(sizeof *data); if(check_flag((void *)data, "malloc", 2)) return(1); data->mm = MGRID; data->dx = ONE/(MGRID - ONE); data->coeff = ONE/( (data->dx) * (data->dx) ); /* Initialize uu, up, id. */ SetInitialProfile(data, uu, up, id, res); /* Set constraints to all 1's for nonnegative solution values. */ N_VConst(ONE, constraints); /* Set remaining input parameters. */ t0 = ZERO; t1 = RCONST(0.01); rtol = ZERO; atol = RCONST(1.0e-8); /* 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); /* Sets up which components are algebraic or differential */ ier = IDASetId(mem, id); if(check_flag(&ier, "IDASetId", 1)) return(1); ier = IDASetConstraints(mem, constraints); if(check_flag(&ier, "IDASetConstraints", 1)) return(1); N_VDestroy_Serial(constraints); ier = IDAInit(mem, heatres, 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 IDAKLU and set up the linear solver */ nnz = NEQ*NEQ; ier = IDAKLU(mem, NEQ, nnz, CSC_MAT); if(check_flag(&ier, "IDAKLU", 1)) return(1); /* check size of Jacobian matrix */ if(MGRID >= 4){ ier = IDASlsSetSparseJacFn(mem, jacHeat); } /* special case MGRID=3 */ else if(MGRID==3){ ier = IDASlsSetSparseJacFn(mem, jacHeat3); } /* MGRID<=2 is pure boundary points, nothing to solve */ else{ printf("MGRID size is too small to run.\n"); return(1); } if(check_flag(&ier, "IDASlsSetSparseJacFn", 1)) return(1); /* Call IDACalcIC to correct the initial values. */ ier = IDACalcIC(mem, IDA_YA_YDP_INIT, t1); if(check_flag(&ier, "IDACalcIC", 1)) return(1); /* Print output heading. */ PrintHeader(rtol, atol); PrintOutput(mem, t0, uu); /* 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 and free memory. */ ier = IDAGetNumErrTestFails(mem, &netf); check_flag(&ier, "IDAGetNumErrTestFails", 1); ier = IDAGetNumNonlinSolvConvFails(mem, &ncfn); check_flag(&ier, "IDAGetNumNonlinSolvConvFails", 1); printf("\n netf = %ld, ncfn = %ld \n", netf, ncfn); IDAFree(&mem); N_VDestroy_Serial(uu); N_VDestroy_Serial(up); N_VDestroy_Serial(id); N_VDestroy_Serial(res); free(data); return(0); }
int main(void) { void *mem; N_Vector yy, yp, avtol; realtype rtol, *yval, *ypval, *atval; realtype t0, tout1, tout, tret; int iout, retval, retvalr; int rootsfound[2]; mem = NULL; yy = yp = avtol = NULL; yval = ypval = atval = NULL; /* Allocate N-vectors. */ yy = N_VNew_Serial(NEQ); if(check_flag((void *)yy, "N_VNew_Serial", 0)) return(1); yp = N_VNew_Serial(NEQ); if(check_flag((void *)yp, "N_VNew_Serial", 0)) return(1); avtol = N_VNew_Serial(NEQ); if(check_flag((void *)avtol, "N_VNew_Serial", 0)) return(1); /* Create and initialize y, y', and absolute tolerance vectors. */ yval = NV_DATA_S(yy); yval[0] = ONE; yval[1] = ZERO; yval[2] = ZERO; ypval = NV_DATA_S(yp); ypval[0] = RCONST(-0.04); ypval[1] = RCONST(0.04); ypval[2] = ZERO; rtol = RCONST(1.0e-4); atval = NV_DATA_S(avtol); atval[0] = RCONST(1.0e-8); atval[1] = RCONST(1.0e-6); atval[2] = RCONST(1.0e-6); /* Integration limits */ t0 = ZERO; tout1 = RCONST(0.4); PrintHeader(rtol, avtol, yy); /* Call IDACreate and IDAMalloc to initialize IDA memory */ mem = IDACreate(); if(check_flag((void *)mem, "IDACreate", 0)) return(1); retval = IDAInit(mem, resrob, t0, yy, yp); if(check_flag(&retval, "IDAInit", 1)) return(1); retval = IDASVtolerances(mem, rtol, avtol); if(check_flag(&retval, "IDASVtolerances", 1)) return(1); /* Free avtol */ N_VDestroy_Serial(avtol); /* Call IDARootInit to specify the root function grob with 2 components */ retval = IDARootInit(mem, 2, grob); if (check_flag(&retval, "IDARootInit", 1)) return(1); /* Call IDADense and set up the linear solver. */ retval = IDADense(mem, NEQ); if(check_flag(&retval, "IDADense", 1)) return(1); retval = IDADlsSetDenseJacFn(mem, jacrob); if(check_flag(&retval, "IDADlsSetDenseJacFn", 1)) return(1); /* In loop, call IDASolve, print results, and test for error. Break out of loop when NOUT preset output times have been reached. */ iout = 0; tout = tout1; while(1) { retval = IDASolve(mem, tout, &tret, yy, yp, IDA_NORMAL); PrintOutput(mem,tret,yy); if(check_flag(&retval, "IDASolve", 1)) return(1); if (retval == IDA_ROOT_RETURN) { retvalr = IDAGetRootInfo(mem, rootsfound); check_flag(&retvalr, "IDAGetRootInfo", 1); PrintRootInfo(rootsfound[0],rootsfound[1]); } if (retval == IDA_SUCCESS) { iout++; tout *= RCONST(10.0); } if (iout == NOUT) break; } PrintFinalStats(mem); /* Free memory */ IDAFree(&mem); N_VDestroy_Serial(yy); N_VDestroy_Serial(yp); return(0); }
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); }