static integratorInstance_t *callIntegrator(odeModel_t *om, cvodeSettings_t *set) { char *tout; char *nout; double time; int printstep; integratorInstance_t *ii; printf("Please enter end time in seconds: "); tout = get_line(stdin); tout = util_trim(tout); printf("... and the number of output times: "); nout = get_line(stdin); nout = util_trim(nout); if ( !(time = (float) floor(atof(tout))) || !(printstep = (int) atof(nout)) ) { printf("\nEntered outtime %s or number of output times %s\n", tout, nout); printf("could not be converted to a number. Try again, please!\n"); } else { CvodeSettings_setTime(set, time, printstep); CvodeSettings_dump(set); ii = IntegratorInstance_create(om, set); integrator(ii, 1, 0, stdout); SolverError_dumpAndClearErrors(); return (ii); } return NULL; }
int main (int argc, char *argv[]){ int i, j; char *model; double time; double printstep; /* libSBML types */ SBMLDocument_t *d; SBMLReader_t *sr; Model_t *m; /* SOSlib types */ SBMLResults_t *results; timeCourse_t *tc; cvodeSettings_t *set; /* parsing command-line arguments */ if (argc < 4 ) { fprintf(stderr, "usage %s sbml-model-file simulation-time time-steps\n", argv[0]); exit(EXIT_FAILURE); } model = argv[1]; time = atof(argv[2]); printstep = atoi(argv[3]); /* parsing the SBML model with libSBML */ sr = SBMLReader_create(); d = SBMLReader_readSBML(sr, model); SBMLReader_free(sr); /* Setting SBML ODE Solver integration parameters */ set = CvodeSettings_create(); CvodeSettings_setTime(set, time, printstep); CvodeSettings_setErrors(set, 1e-9, 1e-4, 1000); /* calling the SBML ODE Solver which returns SBMLResults */ results = SBML_odeSolver(d, set); if ( SolverError_getNum(FATAL_ERROR_TYPE) ) { printf("Integration not sucessful!\n"); SolverError_dumpAndClearErrors(); return(EXIT_FAILURE); } /* now we have the results and can free the inputs */ CvodeSettings_free(set); SBMLDocument_free(d); /* print results */ printf("### RESULTS \n"); SBMLResults_dump(results); SolverError_dumpAndClearErrors(); /* now we can also free the result structure */ SBMLResults_free(results); return (EXIT_SUCCESS); }
SBML_ODESOLVER_API cvodeSettings_t *CvodeSettings_createWith(double Time, int PrintStep, double Error, double RError, int Mxstep, int UseJacobian, int Indefinitely, int HaltOnEvent, int SteadyState, int StoreResults, int Sensitivity, int SensMethod) { cvodeSettings_t *set; ASSIGN_NEW_MEMORY(set, struct cvodeSettings, NULL); /* 1. Setting SBML ODE Solver integration parameters */ CvodeSettings_setErrors(set, Error, RError, Mxstep); /* set non-linear solver defaults (BDF, Newton, max.order 5*/ set->CvodeMethod = 0; set->IterMethod = 0; set->MaxOrder = 5; CvodeSettings_setSwitches(set, UseJacobian, Indefinitely, HaltOnEvent, SteadyState, StoreResults, Sensitivity, SensMethod); /* 2. Setting Requested Time Series */ /* Unless indefinite integration, generate a TimePoints array */ if ( !Indefinitely ) { /* ... generate default TimePoint array */ CvodeSettings_setTime(set, Time, PrintStep); } return set; }
int doit(int argc, char *argv[]) { double i, j ; cvodeSettings_t *settings = CvodeSettings_create(); variableIndex_t *speciesVI, *parameterVI, *parameter2VI; integratorInstance_t *integratorInstance; char *modelStr, *parameterStr, *parameter2Str, *speciesStr; double parameter, parameterEnd, parameterStepSize, parameter2, parameter2End, parameter2StepSize, errorTolerance, relativeErrorTolerance, endtime, initCond, maxDiff, diff; int maximumIntegrationSteps; odeModel_t *model ; if (argc < 11) { fprintf( stderr, "usage %s sbml-model variable parameter1 parameter1-start parameter1-end parameter1-step parameter2 parameter2-start parameter2-end parameter2-step [endtime] [error-tolerance] [relative-error-tolerance] [maximum integration steps]\n", argv[0]); exit(0); } modelStr = argv[1]; speciesStr = argv[2]; parameterStr = argv[3]; parameter = atof(argv[4]); parameterEnd = atof(argv[5]); parameterStepSize = atof(argv[6]); parameter2Str = argv[7]; parameter2 = atof(argv[8]); parameter2End = atof(argv[9]); parameter2StepSize = atof(argv[10]); if (argc > 12) endtime = atof(argv[11]); else endtime = 10000; if (argc > 13) errorTolerance = atof(argv[12]); else errorTolerance = 1e-6; if (argc > 14) relativeErrorTolerance = atof(argv[13]); else relativeErrorTolerance = 1e-4; if (argc > 15) maximumIntegrationSteps = atoi(argv[14]); else maximumIntegrationSteps = 1e9; model = ODEModel_createFromFile(modelStr); RETURN_ON_ERRORS_WITH(1); speciesVI = ODEModel_getVariableIndex(model, speciesStr); parameterVI = ODEModel_getVariableIndex(model, parameterStr); parameter2VI = ODEModel_getVariableIndex(model, parameter2Str); RETURN_ON_ERRORS_WITH(1); /* integrate until steady state */ if ( endtime == 0 ) { /* stop integration upon a steady state */ CvodeSettings_setIndefinitely(settings, 1); CvodeSettings_setSteadyStateThreshold(settings, 1e-9); CvodeSettings_setHaltOnSteadyState(settings, 1); CvodeSettings_setTime(settings, 1, 1); } else { CvodeSettings_setHaltOnSteadyState(settings, 0); CvodeSettings_setIndefinitely(settings, 0); CvodeSettings_setTime(settings, endtime, 1000); } /* absolute tolerance in Cvode integration */ CvodeSettings_setError(settings, errorTolerance); /* relative tolerance in Cvode integration */ CvodeSettings_setRError(settings, relativeErrorTolerance); /* maximum step number for CVode integration */ CvodeSettings_setMxstep(settings, maximumIntegrationSteps); /* doesn't stop integration upon an event */ CvodeSettings_setHaltOnEvent(settings, 0); /* don't Store time course history */ CvodeSettings_setStoreResults(settings, 0); /* compile model */ CvodeSettings_setCompileFunctions(settings, 1); integratorInstance = IntegratorInstance_create(model, settings); printf("set xlabel '%s'\n", ODEModel_getVariableName(model, parameterVI)); printf("set ylabel '%s'\n", ODEModel_getVariableName(model, parameter2VI)); printf("splot '-' using 1:2:3 title '%s' with points pointtype 1 pointsize 1 palette\n", ODEModel_getVariableName(model, speciesVI) ); /* remember initial condition of observed variable */ initCond = IntegratorInstance_getVariableValue(integratorInstance, speciesVI); maxDiff = 0.0; int error = 0 ; int run = 0; for ( run=0; run<2; run++ ) { for (i = parameter; i <= parameterEnd; i += parameterStepSize) { for (j = parameter2; j <= parameter2End; j += parameter2StepSize) { /* add fourth parameter here */ IntegratorInstance_reset( integratorInstance); RETURN_ON_ERRORS_WITH(1); /* for the second run reset the initial condition of the observed variable to a multiple of the maximum observed difference of its value wrt to its initial condition */ if ( run == 1 ) IntegratorInstance_setVariableValue(integratorInstance, speciesVI, fabs(5*(initCond-maxDiff))); IntegratorInstance_setVariableValue(integratorInstance, parameterVI, i); IntegratorInstance_setVariableValue(integratorInstance, parameter2VI, j); /* printf("ic %g\t", IntegratorInstance_getVariableValue(integratorInstance, speciesVI)); */ while(!IntegratorInstance_checkSteadyState(integratorInstance) && !IntegratorInstance_timeCourseCompleted(integratorInstance) ) { IntegratorInstance_integrateOneStep(integratorInstance); if (SolverError_getNum(ERROR_ERROR_TYPE) || SolverError_getNum(FATAL_ERROR_TYPE)) { fprintf(stderr, "ERROR at parameter 1 = %g, parameter 2 = %g\n", i, j); DumpErrors(); error++; } } /* printf("end %g\n", IntegratorInstance_getVariableValue(integratorInstance, speciesVI)); */ /* check whether the final value has largest difference to initial condition */ diff = fabs(initCond - IntegratorInstance_getVariableValue(integratorInstance, speciesVI)); if ( diff > maxDiff ) maxDiff = diff; DumpState(integratorInstance, parameterVI, parameter2VI, speciesVI); } } } printf("end\n"); /* printf("end\n init %g, MAX DIFF %g, abs %g\n", initCond, maxDiff, fabs(initCond-maxDiff)); */ if ( error ) printf("\t%d errors occured\n", error); IntegratorInstance_free(integratorInstance); VariableIndex_free(parameterVI); VariableIndex_free(parameter2VI); VariableIndex_free(speciesVI); ODEModel_free(model); CvodeSettings_free(settings); return 0; }
int main (int argc, char *argv[]){ int i, j; char *model, *parameter, *reaction; double start, end, steps, value; double time ; double printstep; /* libSBML types */ SBMLDocument_t *d; SBMLReader_t *sr; /* SOSlib types */ cvodeSettings_t *set; varySettings_t *vs; SBMLResultsMatrix_t *resM; SBMLResults_t *results; /* parsing command-line arguments */ if (argc < 8 ) { fprintf(stderr, "usage %s sbml-model-file simulation-time time-steps" " start-value end-value step-number parameter-id" " [optional reaction-id]\n", argv[0]); exit(EXIT_FAILURE); } model = argv[1]; time = atof(argv[2]); printstep = atoi(argv[3]); parameter = argv[7]; start = atof(argv[4]); end = atof(argv[5]); steps = atoi(argv[6]); if ( argc > 8 ) { reaction = argv[8]; } else{ reaction = NULL; } printf("### Varying parameter %s (reaction %s) from %f to %f in %f steps\n", parameter, reaction, start, end, steps); /* parsing the SBML model with libSBML */ sr = SBMLReader_create(); d = SBMLReader_readSBML(sr, model); SBMLReader_free(sr); /* Setting SBML ODE Solver integration parameters with default values */ set = CvodeSettings_create(); /* resetting the values we need */ CvodeSettings_setTime(set, time, printstep); CvodeSettings_setErrors(set, 1e-18, 1e-10, 10000); CvodeSettings_setSwitches(set, 1, 0, 1, 1, 1, 0, 0); CvodeSettings_setSteadyState(set, 1); /* Setting SBML Ode Solver batch integration parameters */ vs = VarySettings_allocate(1, steps+1); VarySettings_addParameter(vs, parameter, reaction, start, end); VarySettings_dump(vs); /* calling the SBML ODE Solver Batch function, and retrieving SBMLResults */ resM = SBML_odeSolverBatch(d, set, vs); if ( resM == NULL ) { printf("### Parameter variation not succesful!\n"); return(0); } /* we don't need these anymore */ CvodeSettings_free(set); SBMLDocument_free(d); VarySettings_free(vs); results = resM->results[0][0]; for ( i=0; i<resM->i; i++ ) { for ( j=0; j<resM->j; j++ ) { results = SBMLResultsMatrix_getResults(resM, i, j); printf("### RESULTS Parameter %d, Step %d \n", i+1, j+1); /* printing results only for species*/ SBMLResults_dumpSpecies(results); } } /* SolverError_dumpAndClearErrors(); */ SBMLResultsMatrix_free(resM); return (EXIT_SUCCESS); }
int doIt(void) { int i ; cvodeSettings_t *settings, *set2; variableIndex_t *s1, *s2; integratorInstance_t *integratorInstance; odeModel_t *model = ODEModel_createFromFile("basic-model1-forward-l2.xml"); RETURN_ON_ERRORS_WITH(1) s1 = ODEModel_getVariableIndex(model, "S1"); s2 = ODEModel_getVariableIndex(model, "S2"); /* Creating settings with default values */ settings = CvodeSettings_create(); /* Setting end time to .1, number of time steps to 1 and NULL instead of an optional predefined time series (double *); due to Indefinitely == 1, Printstep 5 will be ignored and Time = 0.1 will be used as timestep for infinite integration */ CvodeSettings_setTime(settings, .1, 5); /* Setting Cvode Parameters: absolute tolerance, relative tolerance and maximal internal step, respectively */ CvodeSettings_setErrors(settings, 1e-20, 1e-14, 500); /* Setting Integration Switches */ CvodeSettings_setMethod(settings, 1, 12); CvodeSettings_setJacobian(settings, 1); CvodeSettings_setIndefinitely(settings, 1); CvodeSettings_setHaltOnEvent(settings, 0); CvodeSettings_setSteadyState(settings, 0); CvodeSettings_setStoreResults(settings, 0); CvodeSettings_setSensitivity(settings, 0); /* first integration run */ printf("\nFIRST INTEGRATION RUN WITH:\n"); CvodeSettings_dump(settings); integratorInstance = IntegratorInstance_create(model, settings); RETURN_ON_ERRORS_WITH(1); /* print variable (ODE, assignments) and constant names */ printf("#time "); IntegratorInstance_dumpNames(integratorInstance); /* print initial conditions and parameters */ IntegratorInstance_dumpData(integratorInstance); for (i=0; i != 12; i++) { /* setting the next time step, uncomment the following function call to see its effect */ /* IntegratorInstance_setNextTimeStep(integratorInstance, 0.2*(i+1)); */ IntegratorInstance_integrateOneStep(integratorInstance); RETURN_ON_ERRORS_WITH(1); /* print current data */ IntegratorInstance_dumpData(integratorInstance); } /* now, let's try again, with different settings */ set2 = CvodeSettings_create(); /* as Indefinitely will be set to 0, a finite integration to time 0.24 in 6 steps will be run */ CvodeSettings_setTime(set2, 1.2, 6); CvodeSettings_setErrors(set2, 1e-16, 1e-14, 500); /* switches can be set all together, same order as above */ CvodeSettings_setSwitches(set2, 1, 0, 0, 0, 0, 0, 0); printf("\nNOW, LET'S TRY AGAIN WITH DIFFERENT SETTINGS:\n"); CvodeSettings_dump(set2); IntegratorInstance_set(integratorInstance, set2); IntegratorInstance_dumpData(integratorInstance); while( !IntegratorInstance_timeCourseCompleted(integratorInstance) ) { IntegratorInstance_integrateOneStep(integratorInstance); RETURN_ON_ERRORS_WITH(1); IntegratorInstance_dumpData(integratorInstance); } printf("\n\nFINISHED SUCCESSFULLY!\n"); printf("Please, note the different values e.g. at time 1.2.\n"); printf("The values for the first run a more exact, due to the much\n"); printf("lower error tolerances. The error tolerances have to be\n"); printf("adapted to the ranges of each model!!\n\n"); IntegratorInstance_free(integratorInstance); ODEModel_free(model); VariableIndex_free(s1); VariableIndex_free(s2); CvodeSettings_free(settings); CvodeSettings_free(set2); return 0; }
int main (int argc, char *argv[]){ int i; odeModel_t *om; cvodeSettings_t *set; integratorInstance_t *ii; variableIndex_t *p; int flag; /* Setting SBML ODE Solver integration parameters */ set = CvodeSettings_create(); CvodeSettings_setTime(set, 1000, 10); CvodeSettings_setErrors(set, 1e-15, 1e-8, 1e4); CvodeSettings_setMethod(set, 0, 5); /* CvodeSettings_setStoreResults(set, 0); */ CvodeSettings_setJacobian(set, 1); /* for testing only */ CvodeSettings_setCompileFunctions(set, 0); /* for testing only */ /* creating the odeModel */ om = ODEModel_createFromFile("MAPK.xml"); ii = IntegratorInstance_create(om, set); /* ACTIVATE SENSITIVITY ANALYSIS */ CvodeSettings_setSensitivity(set, 1); /* 0: simultaneous 1: staggered, 2: staggered1 see CVODES user guide for details */ CvodeSettings_setSensMethod(set, 0); /* ACTIVATE ADJOINT ANALYSIS */ CvodeSettings_setDoAdj(set); CvodeSettings_setAdjTime(set, 1000, 100); CvodeSettings_setAdjErrors(set, 1e-15, 1e-8); CvodeSettings_setnSaveSteps(set, 1000); printf("Try 3 integrations with selected parameters/ICs!\n"); char *sensIDTest[4]; sensIDTest[0] = "MAPK"; sensIDTest[2] = "MAPK_P"; sensIDTest[1] = "K1"; sensIDTest[3] = "Ki"; CvodeSettings_setSensParams(set, sensIDTest, 4); fprintf(stdout, "\n\nReading in linear objective function from: 'MAPK.linobjfun'\n"); fprintf(stdout, "Demonstration of forward/adjoint sensitivity (near) equivalence. \n\n"); /* Initially, only linear objective is present */ flag = IntegratorInstance_setLinearObjectiveFunction(ii, "MAPK.linobjfun"); if (flag!=1) return(EXIT_FAILURE); /* reset integrator to new settings */ IntegratorInstance_reset(ii); /* get a parameter for which we will check sensitivities */ p = ODEModel_getVariableIndex(om, "K1"); i = 0; while ( i < 4 ) { /* if ( i == 2) break; */ /* Set nonlinear objective function after 2 loops */ if ( i == 2) { fprintf(stdout, "\nReading in nonlinear objective now: 'MAPK.objfun'\n\n"); flag = IntegratorInstance_setObjectiveFunction(ii, "MAPK.objfun"); if (flag!=1) return(EXIT_FAILURE); } IntegratorInstance_reset(ii); while( !IntegratorInstance_timeCourseCompleted(ii) ) if ( !IntegratorInstance_integrateOneStep(ii) ) break; printf("\nIntegration time was %g\n\n", IntegratorInstance_getIntegrationTime(ii)); /* IntegratorInstance_dumpData(ii); */ printf("Param default: %s\n", ODEModel_getVariableName(om, p)); IntegratorInstance_dumpPSensitivities(ii, p); flag = IntegratorInstance_CVODEQuad(ii); if (flag!=1) return(EXIT_FAILURE); if ( i < 2) fprintf(stdout, "\n### Printing Forward Sensitivities\n"); else fprintf(stdout, "\n### Printing Objective Function (since nonlinear objective is present)\n"); flag = IntegratorInstance_printQuad(ii, stdout); if (flag!=1) return(EXIT_FAILURE); /* Now go into adjoint phase */ IntegratorInstance_resetAdjPhase(ii); /* Adjoint phase */ while( !IntegratorInstance_timeCourseCompleted(ii) ) if ( !IntegratorInstance_integrateOneStep(ii) ) break; printf("\nIntegration time was %g\n\n", IntegratorInstance_getIntegrationTime(ii)); /* Print out adjoint soln */ IntegratorInstance_dumpAdjData(ii); /* adjoint quadrature */ flag = IntegratorInstance_CVODEQuad(ii); if (flag!=1) return(EXIT_FAILURE); fprintf(stdout, "\n### Printing Adjoint Sensitivities: int_0^T <df/dp, psi> dt\n"); flag = IntegratorInstance_printQuad(ii, stdout); if (flag!=1) return(EXIT_FAILURE); fprintf(stdout, "\n############# DONE RUN NUMBER %d #############\n", i); i++; } /* VariableIndex_free(y); */ VariableIndex_free(p); /* now we have the results and can free the inputs */ IntegratorInstance_free(ii); CvodeSettings_free(set); ODEModel_free(om); return (EXIT_SUCCESS); }
int doit(void) { int i ; cvodeSettings_t *settings ; variableIndex_t *s1, *s2; integratorInstance_t *integratorInstanceA; integratorInstance_t *integratorInstanceB; odeModel_t *model = ODEModel_createFromFile("events-2-events-1-assignment-l2.xml"); RETURN_ON_ERRORS_WITH(1); assert(ODEModel_hasVariable(model, "S1")); assert(ODEModel_hasVariable(model, "S1")); assert(!ODEModel_hasVariable(model, "foobar")); s1 = ODEModel_getVariableIndex(model, "S1"); s2 = ODEModel_getVariableIndex(model, "S2"); /* Creating settings with default values */ settings = CvodeSettings_create(); /* Setting end time to .1, number of time steps to 1 and NULL instead of an optional predefined time series (double *); due to Indefinitely == 1, Printstep 1 will be ignored and Time = 0.1 will be used as timestep for infinite integration */ CvodeSettings_setTime(settings, .01, 1); /* Setting Cvode Parameters: absolute and relative tolerances and maximal internal step */ CvodeSettings_setErrors(settings, 1e-18, 1e-14, 500); /* Setting Integration Switches: see documentation or example simpleIntegratorInstance.c for details on the passed values */ CvodeSettings_setSwitches(settings, 1, 1, 0, 0, 0, 0); integratorInstanceA = IntegratorInstance_create(model, settings); RETURN_ON_ERRORS_WITH(1); integratorInstanceB = IntegratorInstance_create(model, settings); RETURN_ON_ERRORS_WITH(1); DumpState(integratorInstanceA, integratorInstanceB, s1, s2); for (i=0; i != 500; i++) { IntegratorInstance_integrateOneStep(integratorInstanceA); RETURN_ON_ERRORS_WITH(1); IntegratorInstance_integrateOneStep(integratorInstanceB); RETURN_ON_ERRORS_WITH(1); DumpState(integratorInstanceA, integratorInstanceB, s1, s2); } IntegratorInstance_free(integratorInstanceA); IntegratorInstance_free(integratorInstanceB); VariableIndex_free(s1); VariableIndex_free(s2); ODEModel_free(model); CvodeSettings_free(settings); return 0; }
int main(void) { char *formula; variableIndex_t *vi = NULL; variableIndex_t *vj = NULL; const ASTNode_t *f = NULL; cvodeData_t *data = NULL; cvodeSettings_t *set; integratorInstance_t *iI; /* first load an SBML model and directly construct the internal odeModel from it */ odeModel_t *odeModel = ODEModel_createFromFile("MAPK.xml"); if ( ODEModel_constructJacobian(odeModel) && ODEModel_getNeq(odeModel) ) { printf("\n\nSuccessfully constructed the jacobian matrix J\n\n"); printf("We might be interested in the `sparsity' of J,\n"); printf("... we can just evaluate the jacobian entries:\n\n"); /* we need cvodeData for evaluating formulas */ data = CvodeData_create(odeModel); /* ! IMPORTANT : initialize values */ CvodeData_initializeValues(data); printf("Jacobian with initial conditions:\n"); printJacobian(odeModel, data); /* we must free this cvodeData structure */ CvodeData_free(data); printf("Does it change after integration?\n\n"); /* creating settings and integrate */ set = CvodeSettings_create(); CvodeSettings_setTime(set, 1000, 1); iI = IntegratorInstance_create(odeModel, set); IntegratorInstance_integrate(iI); /* get cvodeData from integratorInstance, it contains the values at the last time point, and just do the same as above */ data = IntegratorInstance_getData(iI); printf("Jacobian at time %g:\n", IntegratorInstance_getTime(iI)); printJacobian(odeModel, data); printf("J[6,4] changed its sign. Let's take a look at the equations:\n\n"); vi = ODEModel_getOdeVariableIndex(odeModel, 6); vj = ODEModel_getOdeVariableIndex(odeModel, 4); f = ODEModel_getOde(odeModel, vi); formula = SBML_formulaToString(f); printf("The ODE d%s/dt = \n%s \n\n", ODEModel_getVariableName(odeModel, vi), formula); free(formula); f = ODEModel_getJacobianEntry(odeModel, vi, vj); formula = SBML_formulaToString(f); printf("The jacobian entry (d%s/dt)/d%s = \n%s \n\n", ODEModel_getVariableName(odeModel, vi), ODEModel_getVariableName(odeModel, vj), formula); free(formula); VariableIndex_free(vi); VariableIndex_free(vj); printf("MAPK_P is both a substrate and a product of MKK_PP "); printf("in different reactions.\nTherefor the corresponding "); printf("entry in the jacobian can change its sign, depending "); printf("on concentrations!\n"); /* finally draw a `species interaction graph' of the jacobian' */ drawJacoby(data, "jacobian", "gif"); printf("Take a look at jacobian interaction graph in"); printf("file jacobian_jm.gif that has just been constructed.\n"); printf("If you have compiled w/o graphviz, you just have a textfile"); printf(" jacobian.dot\n"); printf("Thx and good bye!\n"); /* note that this cvodeData MUST NOT be freed, it stays with and will be freed together with integratorInstance */ IntegratorInstance_free(iI); CvodeSettings_free(set); } else { SolverError_dumpAndClearErrors(); printf("Sorry, for this system we couldn't generate the Jacobian.\n"); printf("Integration can still be run with internal approximation.\n"); } ODEModel_free(odeModel); return 1; }
int doit(void) { int i ; double value; cvodeSettings_t *settings ; variableIndex_t *s1, *s2; integratorInstance_t *integratorInstanceA; integratorInstance_t *integratorInstanceB; odeModel_t *model = ODEModel_createFromFile("basic-model1-forward-l2.xml"); RETURN_ON_ERRORS_WITH(1); s1 = ODEModel_getVariableIndex(model, "S1"); s2 = ODEModel_getVariableIndex(model, "S2"); RETURN_ON_ERRORS_WITH(1); /* Creating settings with default values */ settings = CvodeSettings_create(); /* Setting end time to .1, number of time steps to 1 and NULL instead of an optional predefined time series (double *); due to Indefinitely == 1, Printstep 1 will be ignored and Time = 0.1 will be used as timestep for infinite integration */ CvodeSettings_setTime(settings, .1, 1); /* Setting Cvode Parameters: absolute and relative tolerances and maximal internal step */ CvodeSettings_setErrors(settings, 1e-18, 1e-14, 500); /* Setting Integration Switches: see documentation or example simpleIntegratorInstance.c for details on the passed values */ CvodeSettings_setSwitches(settings, 1, 1, 0, 0, 0, 0, 0); /* use compiled model */ CvodeSettings_setCompileFunctions(settings, 0); /* Generate two independent integrator instances from the same odeModel and cvodeSettings */ integratorInstanceA = IntegratorInstance_create(model, settings); RETURN_ON_ERRORS_WITH(1); integratorInstanceB = IntegratorInstance_create(model, settings); RETURN_ON_ERRORS_WITH(1); DumpState(integratorInstanceA, integratorInstanceB, s1, s2); for (i=0; i != 30; i++) { /* run integrations A and B */ IntegratorInstance_integrateOneStep(integratorInstanceA); RETURN_ON_ERRORS_WITH(1); IntegratorInstance_integrateOneStep(integratorInstanceB); RETURN_ON_ERRORS_WITH(1); /* While variable s1 from integration A is between 1e-15 and 1e-16, set variables s1 and s2 in integration B to some value. This function also takes care of creating and freeing CVODE solver structures when ODE variables are changed! */ value = IntegratorInstance_getVariableValue(integratorInstanceA, s1); if ( value < 1.e-15 && value > 1.e-16 ) { IntegratorInstance_setVariableValue(integratorInstanceB, s1,1.5e-15); IntegratorInstance_setVariableValue(integratorInstanceB, s2,1.5e-15); } DumpState(integratorInstanceA, integratorInstanceB, s1, s2); } IntegratorInstance_free(integratorInstanceA); IntegratorInstance_free(integratorInstanceB); VariableIndex_free(s1); VariableIndex_free(s2); ODEModel_free(model); CvodeSettings_free(settings); return 0; }
int main (int argc, char *argv[]){ int i, j; odeModel_t *om; cvodeSettings_t *set; integratorInstance_t *ii; cvodeResults_t *results; variableIndex_t *y, *p; /* Setting SBML ODE Solver integration parameters */ set = CvodeSettings_create(); CvodeSettings_setTime(set, 300.0, 10); CvodeSettings_setErrors(set, 1e-9, 1e-4, 1e9); /* ACTIVATE SENSITIVITY ANALYSIS */ CvodeSettings_setSensitivity(set, 1); /* 0: simultaneous 1: staggered, 2: staggered1 see CVODES user guide for details */ CvodeSettings_setSensMethod(set, 0); CvodeSettings_setJacobian(set, 1); /* for testing only */ /* CvodeSettings_dump(set); */ /* creating the odeModel */ om = ODEModel_createFromFile("MAPK.xml"); /* get a parameter for which we will check sensitivities */ p = ODEModel_getVariableIndex(om, "K1"); /* calling the integrator */ ii = IntegratorInstance_create(om, set); printf("### Printing Sensitivities to %s (%g) on the fly:\n", ODEModel_getVariableName(om, p), IntegratorInstance_getVariableValue(ii, p)); printf("#time "); IntegratorInstance_dumpNames(ii); IntegratorInstance_dumpPSensitivities(ii, p); while( !IntegratorInstance_timeCourseCompleted(ii) ) { if ( !IntegratorInstance_integrateOneStep(ii) ) { break; } IntegratorInstance_dumpPSensitivities(ii, p); } VariableIndex_free(p); if ( SolverError_getNum(FATAL_ERROR_TYPE) ) { printf("Integration not sucessful!\n"); SolverError_dumpAndClearErrors(); return(EXIT_FAILURE); } y = ODEModel_getVariableIndex(om, "MAPK_P"); printf("\nLet's look at a specific ODE variable:\n"); /* print sensitivities again, but now from stored results */ printf("### RESULTS for Sensitivity Analysis for one ODE variable\n"); printf("#time Variable Sensitivity Params...\n"); printf("#time "); printf("%s ", ODEModel_getVariableName(om, y)); for ( j=0; j<ODEModel_getNsens(om); j++ ) { p = ODEModel_getSensParamIndexByNum(om, j); printf("%s ", ODEModel_getVariableName(om, p)); VariableIndex_free(p); } printf("\n"); results = IntegratorInstance_createResults(ii); for ( i=0; i<CvodeResults_getNout(results); i++ ) { printf("%g ", CvodeResults_getTime(results, i)); printf("%g ", CvodeResults_getValue(results, y, i)); for ( j=0; j<ODEModel_getNsens(om); j++ ) { p = ODEModel_getSensParamIndexByNum(om, j); printf("%g ", CvodeResults_getSensitivity(results, y, p, i)); VariableIndex_free(p); } printf("\n"); } /* drawSensitivity(ii->data, "sensitivity", "ps", 0.9); */ p = ODEModel_getVariableIndex(om, "V1"); printf("\nWhat do sensitivities mean? Let's try out!\n\n"); printf("... add 1 to %s: %g + 1 = ", ODEModel_getVariableName(om, p), IntegratorInstance_getVariableValue(ii, p)); CvodeSettings_setSensitivity(set, 0); IntegratorInstance_reset(ii); IntegratorInstance_setVariableValue(ii, p, IntegratorInstance_getVariableValue(ii,p)+1); printf("%g\n", IntegratorInstance_getVariableValue(ii, p)); printf("... and integrate again:\n\n"); CvodeResults_free(results); IntegratorInstance_integrate(ii); results = IntegratorInstance_createResults(ii); /* and print changed results */ printf("#time %s\n", ODEModel_getVariableName(om, y)); for ( i=0; i<CvodeResults_getNout(results); i++ ) { printf("%g ", CvodeResults_getTime(results, i)); printf("%g\n", CvodeResults_getValue(results, y, i)); } printf("\nSee the difference?\n"); printf("Look what happens when the sensitivity changes its sign\n"); printf("between times 180 and 210.\n\n"); VariableIndex_free(y); VariableIndex_free(p); /* now we have the results and can free the inputs */ IntegratorInstance_free(ii); CvodeSettings_free(set); CvodeResults_free(results); ODEModel_free(om); return (EXIT_SUCCESS); }
int main (int argc, char *argv[]){ int i; char *model; /* libSBML types */ SBMLDocument_t *d; SBMLReader_t *sr; /* SOSlib types */ SBMLResults_t *results; cvodeSettings_t *set; double printstep; double endtime; /* parsing command-line arguments */ if (argc < 2 ) { fprintf(stderr, "usage %s sbml-model-file\n", argv[0]); exit(EXIT_FAILURE); } model = argv[1]; /* parsing the SBML model with libSBML */ sr = SBMLReader_create(); d = SBMLReader_readSBML(sr, model); SBMLReader_free(sr); /* Setting SBML ODE Solver integration parameters */ set = CvodeSettings_create(); /* setting endtime to 25 and printstep number to 6 */ printstep = 6; endtime = 25; CvodeSettings_setTime(set, endtime, printstep); /* writing predefined output times: IMPORTANT: can not exceed the set printstep number !! and first time must equal 0 !! */ CvodeSettings_setTimeStep(set, 1, 0.5); for ( i=2; i<=CvodeSettings_getPrintsteps(set); i++ ) CvodeSettings_setTimeStep(set, i, (i-1)*(i-1)); /* printing integration settings */ /* CvodeSettings_dump(set); */ /* calling the SBML ODE Solver, and retrieving SBMLResults */ results = SBML_odeSolver(d, set); CvodeSettings_free(set); SBMLDocument_free(d); if ( results == NULL ) { printf("Integration not sucessful!\n"); return (EXIT_FAILURE); } /* printing results only for species*/ SBMLResults_dumpSpecies(results); /* now we can also free the result structure */ SBMLResults_free(results); return (EXIT_SUCCESS); }
int main (int argc, char *argv[]) { int i, j, k; int neq, nsens; odeModel_t *om; odeSense_t *os; cvodeSettings_t *set; integratorInstance_t *ii; variableIndex_t *p1, *p2, *p3, *vi; double *weights; /* Setting SBML ODE Solver integration parameters */ set = CvodeSettings_create(); CvodeSettings_setTime(set, 30, 10); CvodeSettings_setErrors(set, 1e-15, 1e-10, 1e9); CvodeSettings_setMethod(set, 0, 5); /* CvodeSettings_setStoreResults(set, 0); */ CvodeSettings_setJacobian(set, 1); /* for testing only */ CvodeSettings_setCompileFunctions(set, 0); /* for testing only */ /* CvodeSettings_dump(set); */ CvodeSettings_setFIM(set); /* ACTIVATE FIM */ /* creating the odeModel */ om = ODEModel_createFromFile("MAPK.xml"); ii = IntegratorInstance_create(om, set); printf("\nFirst try a few integrations without sensitivity\n"); IntegratorInstance_dumpNames(ii); printf("\n"); for ( i=0; i<2; i++ ) { printf("Run #%d:\n", i); IntegratorInstance_integrate(ii); /* IntegratorInstance_dumpData(ii); */ IntegratorInstance_printResults(ii, stderr); IntegratorInstance_reset(ii); printf("finished\n\n"); } /* ACTIVATE SENSITIVITY ANALYSIS */ CvodeSettings_setSensitivity(set, 1); /* 0: simultaneous 1: staggered, 2: staggered1 see CVODES user guide for details */ CvodeSettings_setSensMethod(set, 0); /* reset integrator to new settings */ IntegratorInstance_reset(ii); printf("Now Activate Sensitivity\n\n"); os = IntegratorInstance_getSensitivityModel(ii); nsens = ODESense_getNsens(os); printf("nsens = %i\n\n", nsens); for ( i=0; i<nsens; i++ ) { vi = ODESense_getSensParamIndexByNum(os, i); printf("%s\n", ODEModel_getVariableName(om, vi) ); VariableIndex_free(vi); } printf("\n"); printf("sensitivities calculated for all constants\n"); p1 = ODESense_getSensParamIndexByNum(os, 1); p2 = ODESense_getSensParamIndexByNum(os, 2); p3 = ODESense_getSensParamIndexByNum(os, 3); printf("sensitivities printed for constants %s, %s, %s\n\n", ODEModel_getVariableName(om, p1), ODEModel_getVariableName(om, p2), ODEModel_getVariableName(om, p3)); /* create non-default weights for computation of FIM */ /* weights should be extracted from objective function! */ neq = ODEModel_getNeq(om); ASSIGN_NEW_MEMORY_BLOCK(weights, neq, double, 0); for ( i=0; i<neq; i++ ) weights[i] = 1.; /* set weights (to non-default values) */ IntegratorInstance_setFIMweights(ii, weights, neq); /* *** *** *** *** *** *** discrete data *** *** *** *** *** *** *** */ CvodeSettings_setDiscreteObservation(set); printf("DISCRETE DATA\n\n"); i = 0; while ( i < 2 ) { printf("Run #%d:\n", i); while( !IntegratorInstance_timeCourseCompleted(ii) ) { IntegratorInstance_dumpPSensitivities(ii, p1); IntegratorInstance_dumpPSensitivities(ii, p2); IntegratorInstance_dumpPSensitivities(ii, p3); if ( !IntegratorInstance_integrateOneStep(ii) ) break; } IntegratorInstance_dumpPSensitivities(ii, p1); IntegratorInstance_dumpPSensitivities(ii, p2); IntegratorInstance_dumpPSensitivities(ii, p3); fprintf(stderr, "FIM =\n"); for ( j=0; j<nsens; j++ ) { for ( k=0; k<nsens; k++ ) fprintf(stderr, "%g ", IntegratorInstance_getFIM(ii,j,k)); fprintf(stderr, "\n"); } fprintf(stderr, "\n"); IntegratorInstance_reset(ii); i++; } /* *** *** *** *** *** *** continuous data *** *** *** *** *** *** *** */ CvodeSettings_unsetDiscreteObservation(set); printf("CONTINUOUS DATA\n\n"); i = 0; while ( i < 2 ) { printf("Run #%d:\n", i); while( !IntegratorInstance_timeCourseCompleted(ii) ) { IntegratorInstance_dumpPSensitivities(ii, p1); IntegratorInstance_dumpPSensitivities(ii, p2); IntegratorInstance_dumpPSensitivities(ii, p3); if ( !IntegratorInstance_integrateOneStep(ii) ) break; } IntegratorInstance_dumpPSensitivities(ii, p1); IntegratorInstance_dumpPSensitivities(ii, p2); IntegratorInstance_dumpPSensitivities(ii, p3); /* calculate FIM */ IntegratorInstance_CVODEQuad(ii); fprintf(stderr, "FIM =\n"); for ( j=0; j<nsens; j++ ) { for ( k=0; k<nsens; k++ ) fprintf(stderr, "%g ", IntegratorInstance_getFIM(ii,j,k)); fprintf(stderr, "\n"); } fprintf(stderr, "\n"); IntegratorInstance_reset(ii); i++; } fprintf(stderr, "finished\n"); /* VariableIndex_free(y); */ VariableIndex_free(p1); VariableIndex_free(p2); VariableIndex_free(p3); free(weights); /* now we have the results and can free the inputs */ IntegratorInstance_free(ii); CvodeSettings_free(set); ODEModel_free(om); return (EXIT_SUCCESS); }