SBML_ODESOLVER_API cvodeSettings_t *CvodeSettings_clone(cvodeSettings_t *set)
{
int i;
cvodeSettings_t *clone;
ASSIGN_NEW_MEMORY(clone, struct cvodeSettings, NULL);
/* Setting SBML ODE Solver integration parameters */
CvodeSettings_setErrors(clone, set->Error, set->RError, set->Mxstep);
CvodeSettings_setSwitches(clone, set->UseJacobian, set->Indefinitely,
set->HaltOnEvent, set->SteadyState,
set->StoreResults,
set->Sensitivity, set->SensMethod);
CvodeSettings_setMethod(clone, set->CvodeMethod, set->MaxOrder);
CvodeSettings_setIterMethod(clone, set->IterMethod);
/* Unless indefinite integration is chosen, generate a TimePoints array */
if ( !clone->Indefinitely ) {
ASSIGN_NEW_MEMORY_BLOCK(clone->TimePoints,clone->PrintStep+1,double,NULL);
/* copy TimePoint array */
for ( i=0; i<=clone->PrintStep; i++ ) {
clone->TimePoints[i] = set->TimePoints[i];
}
}
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
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);
}
