Species Database::fillSpecie() { Species s; this->query.first(); this->record = this->query.record(); s.setId(this->query.value(this->record.indexOf("id"))); s.setName(this->query.value(this->record.indexOf("name"))); return s; }
QList<Species> Database::getAllSpecies() { QList<Species> species; this->query.prepare("Select * FROM Species ORDER BY Species.name;"); if(!this->query.exec()){ this->showError(this->query.lastError()); return species; } while(this->query.next()){ Species s; s.setId(this->query.value(0)); s.setName(this->query.value(1)); species.push_back(s); } return species; }
/** * * Creates an SBML model represented in "7.1 A Simple example application of SBML" * in the SBML Level 2 Version 4 Specification. * */ SBMLDocument* createExampleEnzymaticReaction() { 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("EnzymaticReaction"); //--------------------------------------------------------------------------- // // Creates UnitDefinition objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointers (reused more than once below). UnitDefinition* unitdef; Unit* unit; //--------------------------------------------------------------------------- // (UnitDefinition1) Creates an UnitDefinition object ("per_second") //--------------------------------------------------------------------------- unitdef = model->createUnitDefinition(); unitdef->setId("per_second"); // Creates an Unit inside the UnitDefinition object unit = unitdef->createUnit(); unit->setKind(UNIT_KIND_SECOND); unit->setExponent(-1); //-------------------------------------------------------------------------------- // (UnitDefinition2) Creates an UnitDefinition object ("litre_per_mole_per_second") //-------------------------------------------------------------------------------- // Note that we can reuse the pointers 'unitdef' and 'unit' because the // actual UnitDefinition object (along with the Unit objects within it) // is already attached to the Model object. unitdef = model->createUnitDefinition(); unitdef->setId("litre_per_mole_per_second"); // Creates an Unit inside the UnitDefinition object ("litre_per_mole_per_second") unit = unitdef->createUnit(); unit->setKind(UNIT_KIND_MOLE); unit->setExponent(-1); // Creates an Unit inside the UnitDefinition object ("litre_per_mole_per_second") unit = unitdef->createUnit(); unit->setKind(UNIT_KIND_LITRE); unit->setExponent(1); // Creates an Unit inside the UnitDefinition object ("litre_per_mole_per_second") unit = unitdef->createUnit(); unit->setKind(UNIT_KIND_SECOND); unit->setExponent(-1); //--------------------------------------------------------------------------- // // Creates a Compartment object inside the Model object. // //--------------------------------------------------------------------------- Compartment* comp; const string compName = "cytosol"; // Creates a Compartment object ("cytosol") comp = model->createCompartment(); comp->setId(compName); // Sets the "size" attribute of the Compartment object. // // We are not setting the units on the compartment size explicitly, so // the units of this Compartment object will be the default SBML units of // volume, which are liters. // comp->setSize(1e-14); //--------------------------------------------------------------------------- // // Creates Species objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointer (reused more than once below). Species *sp; //--------------------------------------------------------------------------- // (Species1) Creates a Species object ("ES") //--------------------------------------------------------------------------- // Create the Species objects inside the Model object. sp = model->createSpecies(); sp->setId("ES"); sp->setName("ES"); // Sets the "compartment" attribute of the Species object to identify the // compartment in which the Species object is located. sp->setCompartment(compName); // Sets the "initialAmount" attribute of the Species object. // // In SBML, the units of a Species object's initial quantity are // determined by two attributes, "substanceUnits" and // "hasOnlySubstanceUnits", and the "spatialDimensions" attribute // of the Compartment object ("cytosol") in which the species // object is located. Here, we are using the default values for // "substanceUnits" (which is "mole") and "hasOnlySubstanceUnits" // (which is "false"). The compartment in which the species is // located uses volume units of liters, so the units of these // species (when the species appear in numerical formulas in the // model) will be moles/liters. // sp->setInitialAmount(0); //--------------------------------------------------------------------------- // (Species2) Creates a Species object ("P") //--------------------------------------------------------------------------- sp = model->createSpecies(); sp->setCompartment(compName); sp->setId("P"); sp->setName("P"); sp->setInitialAmount(0); //--------------------------------------------------------------------------- // (Species3) Creates a Species object ("S") //--------------------------------------------------------------------------- sp = model->createSpecies(); sp->setCompartment(compName); sp->setId("S"); sp->setName("S"); sp->setInitialAmount(1e-20); //--------------------------------------------------------------------------- // (Species4) Creates a Species object ("E") //--------------------------------------------------------------------------- sp = model->createSpecies(); sp->setCompartment(compName); sp->setId("E"); sp->setName("E"); sp->setInitialAmount(5e-21); //--------------------------------------------------------------------------- // // Creates Reaction objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointers. Reaction* reaction; SpeciesReference* spr; KineticLaw* kl; //--------------------------------------------------------------------------- // (Reaction1) Creates a Reaction object ("veq"). //--------------------------------------------------------------------------- reaction = model->createReaction(); reaction->setId("veq"); // (Reactant1) Creates a Reactant object that references Species "E" // in the model. The object will be created within the reaction in the // SBML <listOfReactants>. spr = reaction->createReactant(); spr->setSpecies("E"); // (Reactant2) Creates a Reactant object that references Species "S" // in the model. spr = reaction->createReactant(); spr->setSpecies("S"); //--------------------------------------------------------------------------- // (Product1) Creates a Product object that references Species "ES" in // the model. //--------------------------------------------------------------------------- spr = reaction->createProduct(); spr->setSpecies("ES"); //--------------------------------------------------------------------------- // Creates a KineticLaw object inside the Reaction object ("veq"). //--------------------------------------------------------------------------- kl = reaction->createKineticLaw(); //--------------------------------------------------------------------------- // Creates an ASTNode object which represents the following math of the // KineticLaw. // // <math xmlns="http://www.w3.org/1998/Math/MathML"> // <apply> // <times/> // <ci> cytosol </ci> // <apply> // <minus/> // <apply> // <times/> // <ci> kon </ci> // <ci> E </ci> // <ci> S </ci> // </apply> // <apply> // <times/> // <ci> koff </ci> // <ci> ES </ci> // </apply> // </apply> // </apply> // </math> // //--------------------------------------------------------------------------- //------------------------------------------ // // create nodes representing the variables // //------------------------------------------ ASTNode* astCytosol = new ASTNode(AST_NAME); astCytosol->setName("cytosol"); ASTNode* astKon = new ASTNode(AST_NAME); astKon->setName("kon"); ASTNode* astKoff = new ASTNode(AST_NAME); astKoff->setName("koff"); ASTNode* astE = new ASTNode(AST_NAME); astE->setName("E"); ASTNode* astS = new ASTNode(AST_NAME); astS->setName("S"); ASTNode* astES = new ASTNode(AST_NAME); astES->setName("ES"); //-------------------------------------------- // // create node representing // <apply> // <times/> // <ci> koff </ci> // <ci> ES </ci> // </apply> // //-------------------------------------------- ASTNode *astTimes1 = new ASTNode(AST_TIMES); astTimes1->addChild(astKoff); astTimes1->addChild(astES); //-------------------------------------------- // // create node representing // <apply> // <times/> // <ci> kon </ci> // <ci> E </ci> // <ci> S </ci> // </apply> // // // (NOTES) // // Since there is a restriction with an ASTNode of "<times/>" operation // such that the ASTNode is a binary class and thus only two operands can // be directly added, the following code in this comment block is invalid // because the code directly adds three <ci> ASTNodes to <times/> ASTNode. // // ASTNode *astTimes = new ASTNode(AST_TIMES); // astTimes->addChild(astKon); // astTimes->addChild(astE); // astTimes->addChild(astS); // // The following valid code after this comment block creates the ASTNode // as a binary tree. // // Please see "Converting between ASTs and text strings" described // at http://sbml.org/Software/libSBML/docs/cpp-api/class_a_s_t_node.html // for the detailed information. // //-------------------------------------------- ASTNode *astTimes2 = new ASTNode(AST_TIMES); astTimes2->addChild(astE); astTimes2->addChild(astS); ASTNode *astTimes = new ASTNode(AST_TIMES); astTimes->addChild(astKon); astTimes->addChild(astTimes2); //-------------------------------------------- // // create node representing // <apply> // <minus/> // <apply> // <times/> // <ci> kon </ci> // <ci> E </ci> // <ci> S </ci> // </apply> // <apply> // <times/> // <ci> koff </ci> // <ci> ES </ci> // </apply> // </apply> // //-------------------------------------------- ASTNode *astMinus = new ASTNode(AST_MINUS); astMinus->addChild(astTimes); astMinus->addChild(astTimes1); //-------------------------------------------- // // create node representing // <apply> // <times/> // <ci> cytosol </ci> // <apply> // <minus/> // <apply> // <times/> // <ci> kon </ci> // <ci> E </ci> // <ci> S </ci> // </apply> // <apply> // <times/> // <ci> koff </ci> // <ci> ES </ci> // </apply> // </apply> // </apply> // //-------------------------------------------- ASTNode* astMath = new ASTNode(AST_TIMES); astMath->addChild(astCytosol); astMath->addChild(astMinus); //--------------------------------------------- // // set the Math element // //------------------------------------------------ kl->setMath(astMath); // KineticLaw::setMath(const ASTNode*) sets the math of the KineticLaw object // to a copy of the given ASTNode, and thus basically the caller should delete // the original ASTNode object if the caller has the ownership of the object to // avoid memory leak. delete astMath; //--------------------------------------------------------------------------- // Creates local Parameter objects inside the KineticLaw object. //--------------------------------------------------------------------------- // Creates a Parameter ("kon") Parameter* para = kl->createParameter(); para->setId("kon"); para->setValue(1000000); para->setUnits("litre_per_mole_per_second"); // Creates a Parameter ("koff") para = kl->createParameter(); para->setId("koff"); para->setValue(0.2); para->setUnits("per_second"); //--------------------------------------------------------------------------- // (Reaction2) Creates a Reaction object ("vcat") . //--------------------------------------------------------------------------- reaction = model->createReaction(); reaction->setId("vcat"); reaction->setReversible(false); //--------------------------------------------------------------------------- // Creates Reactant objects inside the Reaction object ("vcat"). //--------------------------------------------------------------------------- // (Reactant1) Creates a Reactant object that references Species "ES" in the // model. spr = reaction->createReactant(); spr->setSpecies("ES"); //--------------------------------------------------------------------------- // Creates a Product object inside the Reaction object ("vcat"). //--------------------------------------------------------------------------- // (Product1) Creates a Product object that references Species "E" in the model. spr = reaction->createProduct(); spr->setSpecies("E"); // (Product2) Creates a Product object that references Species "P" in the model. spr = reaction->createProduct(); spr->setSpecies("P"); //--------------------------------------------------------------------------- // Creates a KineticLaw object inside the Reaction object ("vcat"). //--------------------------------------------------------------------------- kl = reaction->createKineticLaw(); //--------------------------------------------------------------------------- // Sets a math (ASTNode object) to the KineticLaw object. //--------------------------------------------------------------------------- // To create mathematical expressions, one would typically construct // an ASTNode tree as the above example code which creates a math of another // KineticLaw object. Here, to save some space and illustrate another approach // of doing it, we will write out the formula in MathML form and then use a // libSBML convenience function to create the ASTNode tree for us. // (This is a bit dangerous; it's very easy to make mistakes when writing MathML // by hand, so in a real program, we would not really want to do it this way.) string mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">" " <apply>" " <times/>" " <ci> cytosol </ci>" " <ci> kcat </ci>" " <ci> ES </ci>" " </apply>" "</math>"; astMath = readMathMLFromString(mathXMLString.c_str()); kl->setMath(astMath); delete astMath; //--------------------------------------------------------------------------- // Creates local Parameter objects inside the KineticLaw object. //--------------------------------------------------------------------------- // Creates a Parameter ("kcat") para = kl->createParameter(); para->setId("kcat"); para->setValue(0.1); para->setUnits("per_second"); // Returns the created SBMLDocument object. // The returned object must be explicitly deleted by the caller, // otherwise a 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; } } }