END_TEST START_TEST ( test_FunctionDefinition ) { FunctionDefinition* fd = new FunctionDefinition(2, 4); fail_unless (!(fd->hasRequiredElements())); fd->setMath(SBML_parseFormula("fd")); fail_unless (fd->hasRequiredElements()); delete fd; }
END_TEST START_TEST ( test_FunctionDefinition_parent_add ) { FunctionDefinition *fd = new FunctionDefinition(2, 4); Model *m = new Model(2, 4); fd->setId("fd"); fd->setMath(SBML_parseFormula("l")); m->addFunctionDefinition(fd); delete fd; ListOf *lo = m->getListOfFunctionDefinitions(); fail_unless(lo == m->getFunctionDefinition(0)->getParentSBMLObject()); fail_unless(m == lo->getParentSBMLObject()); }
/** * * Creates an SBML model represented in "7.8 Example involving function definitions" * in the SBML Level 2 Version 4 Specification. * */ SBMLDocument* createExampleInvolvingFunctionDefinitions() { const unsigned int level = Level; const unsigned int version = Version; //--------------------------------------------------------------------------- // // Creates an SBMLDocument object // //--------------------------------------------------------------------------- SBMLDocument* sbmlDoc = new SBMLDocument(level,version); //--------------------------------------------------------------------------- // // Creates a Model object inside the SBMLDocument object. // //--------------------------------------------------------------------------- Model* model = sbmlDoc->createModel(); model->setId("functionExample"); //--------------------------------------------------------------------------- // // Creates a FunctionDefinition object inside the Model object. // //--------------------------------------------------------------------------- FunctionDefinition* fdef = model->createFunctionDefinition(); fdef->setId("f"); // Sets a math (ASTNode object) to the FunctionDefinition object. string mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">" " <lambda>" " <bvar>" " <ci> x </ci>" " </bvar>" " <apply>" " <times/>" " <ci> x </ci>" " <cn> 2 </cn>" " </apply>" " </lambda>" "</math>"; ASTNode* astMath = readMathMLFromString(mathXMLString.c_str()); fdef->setMath(astMath); delete astMath; //--------------------------------------------------------------------------- // // Creates a Compartment object inside the Model object. // //--------------------------------------------------------------------------- Compartment* comp; const string compName = "compartmentOne"; // Creates a Compartment object ("compartmentOne") comp = model->createCompartment(); comp->setId(compName); // Sets the "size" attribute of the Compartment object. // // The units of this Compartment object is the default SBML // units of volume (litre), and thus we don't have to explicitly invoke // setUnits("litre") function to set the default units. // comp->setSize(1); //--------------------------------------------------------------------------- // // Creates Species objects inside the Model object. // //--------------------------------------------------------------------------- Species* sp; //--------------------------------------------------------------------------- // (Species1) Creates a Species object ("S1") //--------------------------------------------------------------------------- sp = model->createSpecies(); sp->setId("S1"); // Sets the "compartment" attribute of the Species object to identify the // compartnet in which the Species object located. sp->setCompartment(compName); // Sets the "initialConcentration" attribute of the Species object. // // The units of this Species object is determined by two attributes of this // Species object ("substanceUnits" and "hasOnlySubstanceUnits") and the // "spatialDimension" attribute of the Compartment object ("cytosol") in which // this species object located. // Since the default values are used for "substanceUnits" (substance (mole)) // and "hasOnlySubstanceUnits" (false) and the value of "spatialDimension" (3) // is greater than 0, the units of this Species object is mole/litre . // sp->setInitialConcentration(1); //--------------------------------------------------------------------------- // (Species2) Creates a Species object ("S2") //--------------------------------------------------------------------------- sp = model->createSpecies(); sp->setId("S2"); sp->setCompartment(compName); sp->setInitialConcentration(0); //--------------------------------------------------------------------------- // // Creates a global Parameter object inside the Model object. // //--------------------------------------------------------------------------- Parameter* para; // Creates a Parameter ("t") para = model->createParameter(); para->setId("t"); para->setValue(1); para->setUnits("second"); //--------------------------------------------------------------------------- // // Creates Reaction objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointers. Reaction* reaction; SpeciesReference* spr; KineticLaw* kl; //--------------------------------------------------------------------------- // (Reaction1) Creates a Reaction object ("reaction_1"). //--------------------------------------------------------------------------- reaction = model->createReaction(); reaction->setId("reaction_1"); reaction->setReversible(false); //--------------------------------------------------------------------------- // Creates Reactant objects inside the Reaction object ("reaction_1"). //--------------------------------------------------------------------------- // (Reactant1) Creates a Reactant object that references Species "S1" // in the model. spr = reaction->createReactant(); spr->setSpecies("S1"); //--------------------------------------------------------------------------- // Creates a Product object inside the Reaction object ("reaction_1"). //--------------------------------------------------------------------------- // Creates a Product object that references Species "S2" in the model. spr = reaction->createProduct(); spr->setSpecies("S2"); //--------------------------------------------------------------------------- // Creates a KineticLaw object inside the Reaction object ("reaction_1"). //--------------------------------------------------------------------------- kl = reaction->createKineticLaw(); //--------------------------------------------------------------------------- // Sets a math (ASTNode object) to the KineticLaw object. //--------------------------------------------------------------------------- mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">" " <apply>" " <divide/>" " <apply>" " <times/>" " <apply>" " <ci> f </ci>" " <ci> S1 </ci>" " </apply>" " <ci> compartmentOne </ci>" " </apply>" " <ci> t </ci>" " </apply>" "</math>"; astMath = readMathMLFromString(mathXMLString.c_str()); kl->setMath(astMath); delete astMath; // Returns the created SBMLDocument object. // The returned object must be explicitly deleted by the caller, // otherwise memory leak will happen. return sbmlDoc; }
void Module::CreateSBMLModel() { Model* sbmlmod = m_sbml.createModel(); sbmlmod->setId(m_modulename); sbmlmod->setName(m_modulename); sbmlmod->setNotes("<body xmlns=\"http://www.w3.org/1999/xhtml\"><p> Originally created by libAntimony " VERSION_STRING " (using libSBML " LIBSBML_DOTTED_VERSION ") </p></body>"); char cc = g_registry.GetCC(); //User-defined functions for (size_t uf=0; uf<g_registry.GetNumUserFunctions(); uf++) { const UserFunction* userfunction = g_registry.GetNthUserFunction(uf); assert(userfunction != NULL); FunctionDefinition* fd = sbmlmod->createFunctionDefinition(); fd->setId(userfunction->GetModuleName()); ASTNode* math = parseStringToASTNode(userfunction->ToSBMLString()); fd->setMath(math); delete math; } //Compartments Compartment* defaultCompartment = sbmlmod->createCompartment(); defaultCompartment->setId(DEFAULTCOMP); defaultCompartment->setConstant(true); defaultCompartment->setSize(1); defaultCompartment->setSBOTerm(410); //The 'implicit compartment' size_t numcomps = GetNumVariablesOfType(allCompartments); for (size_t comp=0; comp<numcomps; comp++) { const Variable* compartment = GetNthVariableOfType(allCompartments, comp); Compartment* sbmlcomp = sbmlmod->createCompartment(); sbmlcomp->setId(compartment->GetNameDelimitedBy(cc)); if (compartment->GetDisplayName() != "") { sbmlcomp->setName(compartment->GetDisplayName()); } sbmlcomp->setConstant(compartment->GetIsConst()); formula_type ftype = compartment->GetFormulaType(); assert (ftype == formulaINITIAL || ftype==formulaASSIGNMENT || ftype==formulaRATE); if (ftype != formulaINITIAL) { sbmlcomp->setConstant(false); } const Formula* formula = compartment->GetFormula(); if (formula->IsDouble()) { sbmlcomp->setSize(atof(formula->ToSBMLString().c_str())); } SetAssignmentFor(sbmlmod, compartment); } //Species size_t numspecies = GetNumVariablesOfType(allSpecies); for (size_t spec=0; spec < numspecies; spec++) { const Variable* species = GetNthVariableOfType(allSpecies, spec); Species* sbmlspecies = sbmlmod->createSpecies(); sbmlspecies->setId(species->GetNameDelimitedBy(cc)); if (species->GetDisplayName() != "") { sbmlspecies->setName(species->GetDisplayName()); } sbmlspecies->setConstant(false); //There's no need to try to distinguish between const and var for species. if (species->GetIsConst()) { sbmlspecies->setBoundaryCondition(true); } else { sbmlspecies->setBoundaryCondition(false); } const Variable* compartment = species->GetCompartment(); if (compartment == NULL) { sbmlspecies->setCompartment(defaultCompartment->getId()); } else { sbmlspecies->setCompartment(compartment->GetNameDelimitedBy(cc)); } const Formula* formula = species->GetFormula(); if (formula->IsDouble()) { sbmlspecies->setInitialConcentration(atof(formula->ToSBMLString().c_str())); } else if (formula->IsAmountIn(species->GetCompartment())) { sbmlspecies->setInitialAmount(formula->ToAmount()); } SetAssignmentFor(sbmlmod, species); } //Formulas size_t numforms = GetNumVariablesOfType(allFormulas); for (size_t form=0; form < numforms; form++) { const Variable* formvar = GetNthVariableOfType(allFormulas, form); const Formula* formula = formvar->GetFormula(); Parameter* param = sbmlmod->createParameter(); param->setId(formvar->GetNameDelimitedBy(cc)); if (formvar->GetDisplayName() != "") { param->setName(formvar->GetDisplayName()); } param->setConstant(formvar->GetIsConst()); if (formula->IsDouble()) { param->setValue(atof(formula->ToSBMLString().c_str())); } SetAssignmentFor(sbmlmod, formvar); formula_type ftype = formvar->GetFormulaType(); assert (ftype == formulaINITIAL || ftype==formulaASSIGNMENT || ftype==formulaRATE); if (ftype != formulaINITIAL) { param->setConstant(false); } } //Reactions size_t numrxns = GetNumVariablesOfType(allReactions); for (size_t rxn=0; rxn < numrxns; rxn++) { const Variable* rxnvar = GetNthVariableOfType(allReactions, rxn); const AntimonyReaction* reaction = rxnvar->GetReaction(); if (reaction->IsEmpty()) { continue; //Reactions that involve no species are illegal in SBML. } Reaction* sbmlrxn = sbmlmod->createReaction(); sbmlrxn->setId(rxnvar->GetNameDelimitedBy(cc)); if (rxnvar->GetDisplayName() != "") { sbmlrxn->setName(rxnvar->GetDisplayName()); } if (reaction->GetType() == rdBecomes) { sbmlrxn->setReversible(true); } else { assert(reaction->GetType() == rdBecomesIrreversibly); sbmlrxn->setReversible(false); } const Formula* formula = reaction->GetFormula(); string formstring = formula->ToSBMLString(rxnvar->GetStrandVars()); if (!formula->IsEmpty()) { KineticLaw* kl = sbmlmod->createKineticLaw(); ASTNode* math = parseStringToASTNode(formstring); kl->setMath(math); delete math; } const ReactantList* left = reaction->GetLeft(); for (size_t lnum=0; lnum<left->Size(); lnum++) { const Variable* nthleft = left->GetNthReactant(lnum); double nthstoich = left->GetStoichiometryFor(lnum); SpeciesReference* sr = sbmlmod->createReactant(); sr->setSpecies(nthleft->GetNameDelimitedBy(cc)); sr->setStoichiometry(nthstoich); } const ReactantList* right = reaction->GetRight(); for (size_t rnum=0; rnum<right->Size(); rnum++) { const Variable* nthright = right->GetNthReactant(rnum); double nthstoich = right->GetStoichiometryFor(rnum); SpeciesReference* sr = sbmlmod->createProduct(); sr->setSpecies(nthright->GetNameDelimitedBy(cc)); sr->setStoichiometry(nthstoich); } //Find 'modifiers' and add them. vector<const Variable*> subvars = formula->GetVariablesFrom(formstring, m_modulename); for (size_t v=0; v<subvars.size(); v++) { if (subvars[v] != NULL && subvars[v]->GetType() == varSpeciesUndef) { if (left->GetStoichiometryFor(subvars[v]) == 0 && right->GetStoichiometryFor(subvars[v]) == 0) { ModifierSpeciesReference* msr = sbmlmod->createModifier(); msr->setSpecies(subvars[v]->GetNameDelimitedBy(cc)); } } } } //Events size_t numevents = GetNumVariablesOfType(allEvents); for (size_t ev=0; ev < numevents; ev++) { const Variable* eventvar = GetNthVariableOfType(allEvents, ev); const AntimonyEvent* event = eventvar->GetEvent(); Event* sbmlevent = sbmlmod->createEvent(); sbmlevent->setId(eventvar->GetNameDelimitedBy(cc)); if (eventvar->GetDisplayName() != "") { sbmlevent->setName(eventvar->GetDisplayName()); } Trigger* trig = sbmlevent->createTrigger(); ASTNode* ASTtrig = parseStringToASTNode(event->GetTrigger()->ToSBMLString()); trig->setMath(ASTtrig); delete ASTtrig; const Formula* delay = event->GetDelay(); if (!delay->IsEmpty()) { ASTtrig = parseStringToASTNode(delay->ToSBMLString()); Delay* sbmldelay = sbmlevent->createDelay(); sbmldelay->setMath(ASTtrig); delete ASTtrig; } long numasnts = static_cast<long>(event->GetNumAssignments()); for (long asnt=numasnts-1; asnt>=0; asnt--) { //events are stored in reverse order. Don't ask... EventAssignment* sbmlasnt = sbmlmod->createEventAssignment(); sbmlasnt->setVariable(event->GetNthAssignmentVariableName(asnt, cc)); ASTNode* ASTasnt = parseStringToASTNode(event->GetNthAssignmentFormulaString(asnt, '_', true)); sbmlasnt->setMath(ASTasnt); delete ASTasnt; } } //Interactions size_t numinteractions = GetNumVariablesOfType(allInteractions); for (size_t irxn=0; irxn<numinteractions; irxn++) { const Variable* arxnvar = GetNthVariableOfType(allInteractions, irxn); const AntimonyReaction* arxn = arxnvar->GetReaction(); Reaction* rxn = sbmlmod->getReaction(arxn->GetRight()->GetNthReactant(0)->GetNameDelimitedBy(cc)); if (rxn != NULL) { for (size_t interactor=0; interactor<arxn->GetLeft()->Size(); interactor++) { ModifierSpeciesReference* msr = rxn->createModifier(); msr->setSpecies(arxn->GetLeft()->GetNthReactant(interactor)->GetNameDelimitedBy(cc)); msr->setName(arxnvar->GetNameDelimitedBy(cc)); } } } //Unknown variables (turn into parameters) size_t numunknown = GetNumVariablesOfType(allUnknown); for (size_t form=0; form < numunknown; form++) { const Variable* formvar = GetNthVariableOfType(allUnknown, form); Parameter* param = sbmlmod->createParameter(); param->setId(formvar->GetNameDelimitedBy(cc)); if (formvar->GetDisplayName() != "") { param->setName(formvar->GetDisplayName()); } switch(formvar->GetConstType()) { case constVAR: param->setConstant(true); break; case constCONST: param->setConstant(false); break; case constDEFAULT: break; } } }