SBML_ODESOLVER_API int IntegratorInstance_checkTrigger(integratorInstance_t *engine)
{
int i, j, fired;
ASTNode_t *trigger, *assignment;
Event_t *e;
EventAssignment_t *ea;
variableIndex_t *vi;
cvodeSettings_t *opt = engine->opt;
cvodeData_t *data = engine->data;
odeModel_t *om = engine->om;
fired = 0;
for ( i=0; i<Model_getNumEvents(om->simple); i++ ) {
e = Model_getEvent(om->simple, i);
trigger = (ASTNode_t *) Event_getTrigger(e);
if ( data->trigger[i] == 0 && evaluateAST(trigger, data) ) {
if (opt->HaltOnEvent)
SolverError_error(ERROR_ERROR_TYPE,
SOLVER_ERROR_EVENT_TRIGGER_FIRED,
"Event Trigger %d (%s) fired at time %g. "
"Aborting simulation.",
i, SBML_formulaToString(trigger),
data->currenttime);
/* removed AMF 08/11/05
else
SolverError_error(WARNING_ERROR_TYPE,
SOLVER_ERROR_EVENT_TRIGGER_FIRED,
"Event Trigger %d (%s) fired at time %g. ",
i, SBML_formulaToString(trigger),
data->currenttime); */
fired++;
data->trigger[i] = 1;
for ( j=0; j<Event_getNumEventAssignments(e); j++ ) {
ea = Event_getEventAssignment(e, j);
assignment = (ASTNode_t *) EventAssignment_getMath(ea);
vi = ODEModel_getVariableIndex(om,
EventAssignment_getVariable(ea));
IntegratorInstance_setVariableValue(engine, vi,
evaluateAST(assignment, data));
VariableIndex_free(vi);
}
}
else {
data->trigger[i] = 0;
}
}
return fired;
}
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 doit(void)
{
int i ;
cvodeSettings_t *settings ;
variableIndex_t *s1, *s2, *k1;
integratorInstance_t *integratorInstanceA;
odeModel_t *model = ODEModel_createFromFile("basic.xml");
RETURN_ON_ERRORS_WITH(1);
s1 = ODEModel_getVariableIndex(model, "S1");
s2 = ODEModel_getVariableIndex(model, "S2");
k1 = ODEModel_getVariableIndex(model, "k_1");
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);
CvodeSettings_setCompileFunctions(settings, 1); /* compile model */
integratorInstanceA = IntegratorInstance_create(model, settings);
RETURN_ON_ERRORS_WITH(1);
DumpState(integratorInstanceA, s1, s2);
for (i=0; i != 50; i++)
{
IntegratorInstance_integrateOneStep(integratorInstanceA);
RETURN_ON_ERRORS_WITH(1);
if (IntegratorInstance_getVariableValue(integratorInstanceA, s1) < 7.5e-16)
IntegratorInstance_setVariableValue(integratorInstanceA, k1, 2.0);
DumpState(integratorInstanceA, s1, s2);
}
IntegratorInstance_free(integratorInstanceA);
VariableIndex_free(s1);
VariableIndex_free(s2);
ODEModel_free(model);
CvodeSettings_free(settings);
return 0;
}
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);
}