/** C.0: Loads, validates and parses an SBML file, also converts SBML level 1 to level 2 files, return NULL if errors were encountered during libSBML validation and consistency check, stores libSBML warngings */ SBMLDocument_t * parseModel(char *file, int printMessage, int validate, char *schemaPath, char *schema11FileName, char *schema12FileName, char *schema21FileName) { unsigned int i, errors ; SBMLDocument_t *d; SBMLDocument_t *d2; SBMLReader_t *sr; if ( validate ) { if ( printMessage ) { fprintf(stderr, "Validating SBML.\n"); fprintf(stderr, "This can take a while for SBML level 2.\n"); } sr = newSBMLReader(schemaPath, schema11FileName, schema12FileName, schema21FileName); } else { sr = SBMLReader_create(); } d = SBMLReader_readSBML(sr, file); SBMLReader_free(sr); errors = 0; if ( validate ) { errors = SBMLDocument_getNumFatals(d) + SBMLDocument_getNumErrors(d); } if (SBMLDocument_getNumFatals(d) + SBMLDocument_getNumErrors(d) == 0) SBMLDocument_checkConsistency(d); /* AMF 9th Dec 2005 added back because inconsistent models can cause the solver to crash despite the consistancy check causing memory leaks - talk to Ben B! */ /* check for warnings and errors */ for (i =0 ; i != SBMLDocument_getNumWarnings(d); i++) storeSBMLError(WARNING_ERROR_TYPE, SBMLDocument_getWarning(d, i)); for (i =0 ; i != SBMLDocument_getNumErrors(d); i++) storeSBMLError(ERROR_ERROR_TYPE, SBMLDocument_getError(d, i)); for (i =0 ; i != SBMLDocument_getNumFatals(d); i++) storeSBMLError(FATAL_ERROR_TYPE, SBMLDocument_getFatal(d, i)); RETURN_ON_ERRORS_WITH(NULL); /* convert level 1 models to level 2 */ if ( SBMLDocument_getLevel(d) == 1 ) { d2 = convertModel(d); SBMLDocument_free(d); if ( printMessage ) fprintf(stderr, "SBML converted from level 1 to level 2.\n"); return (d2); } return (d); }
SBMLReader_t * newSBMLReader (char *schemaPath, char *schema11, char *schema12, char *schema21) { SBMLReader_t *sr; char *schema[3]; schema[0] = concat(schemaPath, schema11); schema[1] = concat(schemaPath, schema12); schema[2] = concat(schemaPath, schema21); sr = SBMLReader_create(); SBMLReader_setSchemaValidationLevel(sr, XML_SCHEMA_VALIDATION_BASIC); SBMLReader_setSchemaFilenameL1v1(sr, schema[0]); SBMLReader_setSchemaFilenameL1v2(sr, schema[1]); SBMLReader_setSchemaFilenameL2v1(sr, schema[2]); free(schema[0]); free(schema[1]); free(schema[2]); return (sr); }
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); }
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; Reaction_t *r; KineticLaw_t *kl; ASTNode_t *nary; ASTNode_t *diff; /* 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); m = SBMLDocument_getModel(d); r = Model_getReaction(m,0); kl = Reaction_getKineticLaw(r); nary = KineticLaw_getMath(kl); printf("N-ary formula: %s\n", SBML_formulaToString(nary)); diff = differentiateAST(nary, "Product"); printf("N-ary diff: %s\n", SBML_formulaToString(diff)); ASTNode_free(diff); return (EXIT_SUCCESS); }
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 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); }