/* convert from L1 to L3 */ void Model::convertL3ToL1 () { // // Level 3 allows a model to be specified without a Compartment. However // this is not valid in Level 1. Thus if a L3 model has no Compartment // one must be included // if (getNumCompartments() == 0) { createCompartment()->setId(ASSIGNED_COMPARTMENT); } dealWithModelUnits(); dealWithAssigningL1Stoichiometry(*this, false); for (unsigned int i = 0; i < getNumReactions(); i++) { Reaction *r = getReaction(i); if (r->isSetKineticLaw()) { KineticLaw *kl = r->getKineticLaw(); for (unsigned int j = 0; j < kl->getNumLocalParameters(); j++) { Parameter *lp = new Parameter(getLevel(), getVersion()); (*lp) = *(kl->getLocalParameter(j)); kl->addParameter(lp); } } } }
END_TEST START_TEST ( test_Reaction_parent_NULL ) { SBMLDocument *d = new SBMLDocument(); Model *m = d->createModel(); Reaction *c = m->createReaction(); SpeciesReference *sr = c->createReactant(); KineticLaw *kl = c->createKineticLaw(); fail_unless(c->getAncestorOfType(SBML_MODEL) == m); fail_unless (c->getSBMLDocument() == d); fail_unless(sr->getAncestorOfType(SBML_REACTION) == c); fail_unless(kl->getAncestorOfType(SBML_REACTION) == c); Reaction *c1 = c->clone(); delete d; fail_unless(c1->getAncestorOfType(SBML_MODEL) == NULL); fail_unless(c1->getParentSBMLObject() == NULL); fail_unless (c1->getSBMLDocument() == NULL); SpeciesReference *sr1 = c1->getReactant(0); fail_unless(sr1->getAncestorOfType(SBML_MODEL) == NULL); fail_unless(sr1->getAncestorOfType(SBML_REACTION) == c1); fail_unless (sr1->getSBMLDocument() == NULL); fail_unless(c1->getKineticLaw()->getAncestorOfType(SBML_MODEL) == NULL); fail_unless(c1->getKineticLaw()->getAncestorOfType(SBML_REACTION) == c1); fail_unless (c1->getKineticLaw()->getSBMLDocument() == NULL); delete c1; }
void checkReactions(Model* model, set<string>& components, set<string>& tests, const map<string, vector<double> >& results, int type) { if (model->getNumReactions() > 0) { components.insert("Reaction"); for (unsigned int r=0; r<model->getNumReactions(); r++) { Reaction* rxn = model->getReaction(r); if (rxn->isSetFast() && rxn->getFast()) { tests.insert("FastReaction"); } if (rxn->isSetReversible() && rxn->getReversible()) { if (type!=1) { tests.insert("ReversibleReaction [?]"); } } ListOfSpeciesReferences* reactants = rxn->getListOfReactants(); checkSpeciesRefs(model, reactants, components, tests, results); ListOfSpeciesReferences* products = rxn->getListOfProducts(); checkSpeciesRefs(model, products, components, tests, results); if (rxn->isSetKineticLaw()) { KineticLaw* kl = rxn->getKineticLaw(); if (kl->getNumParameters() > 0) { tests.insert("LocalParameters"); } if (kl->isSetMath() == false) { tests.insert("NoMathML"); } } } } }
END_TEST START_TEST ( test_KineticLaw ) { KineticLaw* kl = new KineticLaw(2, 4); fail_unless (kl->hasRequiredAttributes()); delete kl; }
/* adds species referred to in a KineticLaw to the ListOfModifiers * this will only be applicable when up converting an L1 model */ void Model::addModifiers () { // // Level 2/3 has a listOfModifiers associated with a Reaction // which are not listed in a L1 Model. // For each symbol in the Reaction's KineticLaw, // that symbol is a modifier iff: // // 1. It is defined as a Species in the Model // 2. It is not a Reactant or Product in this Reaction. // // Thus modifiers must be added where appropriate. // const char *id; unsigned int size; unsigned int n, l; const ASTNode *node; List *names; KineticLaw* kl; for (n = 0; n < getNumReactions(); n++) { kl = getReaction(n)->getKineticLaw(); if (kl == NULL || kl->isSetMath() == false) continue; node = kl->getMath(); names = node->getListOfNodes((ASTNodePredicate) ASTNode_isName); size = names->getSize(); for (l = 0; l < size; l++) { node = (ASTNode *) names->get(l); id = node->getName(); // 1. It is an AST_NAME (not AST_NAME_TIME), and if (node->getType() != AST_NAME) continue; // 2. It refers to a Species in this Model, and if (id == NULL || getSpecies(id) == NULL) continue; // 3. It is not a Reactant, Product, or (already) a Modifier if (getReaction(n)->getReactant(id) != NULL) continue; if (getReaction(n)->getProduct (id) != NULL) continue; if (getReaction(n)->getModifier(id) != NULL) continue; getReaction(n)->createModifier()->setSpecies(id); } delete names; } }
END_TEST START_TEST ( test_KineticLaw_parent_create ) { Reaction * r = new Reaction(2, 4); KineticLaw* kl = r->createKineticLaw(); fail_unless(r == kl->getParentSBMLObject()); delete r; }
END_TEST START_TEST ( test_KineticLaw_parent_create_model ) { Model *m = new Model(2, 4); Reaction * r = m->createReaction(); KineticLaw* kl = r->createKineticLaw(); fail_unless(r == kl->getParentSBMLObject()); fail_unless(r == r->getKineticLaw()->getParentSBMLObject()); delete r; }
END_TEST START_TEST ( test_KineticLaw_L1 ) { KineticLaw* kl = new KineticLaw(1, 2); fail_unless (!(kl->hasRequiredAttributes())); kl->setFormula("kl"); fail_unless (kl->hasRequiredAttributes()); delete kl; }
END_TEST START_TEST ( test_KineticLaw ) { KineticLaw* kl = new KineticLaw(2, 4); fail_unless (!(kl->hasRequiredElements())); kl->setMath(SBML_parseFormula("kl")); fail_unless (kl->hasRequiredElements()); delete kl; }
void convertPow(SBMLDocument* doc, bool shouldChangePow, bool inlineCompartmentSizes) { Model* model = SBMLDocument_getModel(doc); if (model == NULL) { return; } std::map<string, double> compartmentValueMap; if (inlineCompartmentSizes) { for(unsigned int i = 0; i < model->getNumCompartments(); ++i) { Compartment* c = model->getCompartment(i); compartmentValueMap[c->getId()] = c->getSize(); } } for(unsigned int i = 0; i < model->getNumReactions(); ++i) { Reaction* r = model->getReaction(i); KineticLaw* kl = r->getKineticLaw(); const char* strKineticFormula; if (kl == NULL) { strKineticFormula = ""; } else { strKineticFormula = KineticLaw_getFormula(kl); if (strKineticFormula == NULL) { continue; } } ASTNode* ast_Node = SBML_parseFormula (strKineticFormula); if (ast_Node != NULL) { changePow(ast_Node, compartmentValueMap, shouldChangePow); kl->setMath (ast_Node); } delete ast_Node; } }
void createKineticLawForReaction(Reaction* reaction) { if (reaction == NULL) return; reaction->unsetKineticLaw(); KineticLaw *law = reaction->getKineticLaw(); if (law == NULL) { law = reaction->createKineticLaw(); LocalParameter* fluxValue = law->createLocalParameter(); fluxValue->initDefaults(); fluxValue->setId("FLUX_VALUE"); fluxValue->setValue(0); fluxValue->setUnits("dimensionless"); ASTNode* astn = SBML_parseFormula("FLUX_VALUE"); law->setMath(astn); delete astn; } LocalParameter* LB = law->getLocalParameter("LOWER_BOUND"); if (LB == NULL) { LB = law->createLocalParameter(); LB->initDefaults(); LB->setId("LOWER_BOUND"); LB->setUnits("dimensionless"); LB->setValue(-std::numeric_limits<double>::infinity()); } LocalParameter* UB = law->getLocalParameter("UPPER_BOUND"); if (UB == NULL) { UB = law->createLocalParameter(); UB->initDefaults(); UB->setId("UPPER_BOUND"); UB->setUnits("dimensionless"); LB->setValue(std::numeric_limits<double>::infinity()); } LocalParameter* param = law->getLocalParameter("OBJECTIVE_COEFFICIENT"); if (param == NULL) { param = law->createLocalParameter(); param->initDefaults(); param->setId("OBJECTIVE_COEFFICIENT"); param->setUnits("dimensionless"); param->setValue(0); } }
void Model::convertParametersToLocals(unsigned int level, unsigned int version) { for (unsigned int i = 0; i < getNumReactions(); i++) { Reaction *r = getReaction(i); if (r->isSetKineticLaw()) { KineticLaw *kl = r->getKineticLaw(); for (unsigned int j = 0; j < kl->getNumParameters(); j++) { LocalParameter *lp = new LocalParameter(level, version); (*lp) = *(kl->getParameter(j)); kl->addLocalParameter(lp); } } } }
void updateKineticLawFromBound(Reaction* reaction, FluxBound* current) { if (reaction == NULL || current == NULL) return; const string operation = current -> getOperation(); KineticLaw *law = reaction->getKineticLaw(); LocalParameter* LB = law->getLocalParameter("LOWER_BOUND"); LocalParameter* UB = law->getLocalParameter("UPPER_BOUND"); if (operation == "less" || operation == "lessEqual" || operation == "equal") { UB->setValue(current->getValue()); } if (operation == "greater" || operation == "greaterEqual" || operation == "equal") { LB->setValue(current->getValue()); } }
END_TEST START_TEST ( test_KineticLaw_Parameter_parent_create_model ) { Model *m = new Model(2, 4); Reaction *r = m->createReaction(); KineticLaw* kl = m->createKineticLaw(); Parameter * p = m->createKineticLawParameter(); fail_unless(kl->getNumParameters() == 1); ListOfParameters *lop = kl->getListOfParameters(); fail_unless(r == kl->getParentSBMLObject()); fail_unless(kl == lop->getParentSBMLObject()); fail_unless(lop == p->getParentSBMLObject()); fail_unless(lop == kl->getParameter(0)->getParentSBMLObject()); delete kl; }
END_TEST START_TEST ( test_KineticLaw_parent_NULL ) { Reaction * r = new Reaction(2, 4); KineticLaw *kl = r->createKineticLaw(); Parameter *p = kl->createParameter(); fail_unless(r == kl->getParentSBMLObject()); fail_unless(r == p->getAncestorOfType(SBML_REACTION)); fail_unless(kl == p->getAncestorOfType(SBML_KINETIC_LAW)); KineticLaw *kl1 = kl->clone(); fail_unless(kl1->getParentSBMLObject() == NULL); fail_unless(kl1->getParameter(0)->getAncestorOfType(SBML_REACTION) == NULL); fail_unless(kl1 == kl1->getParameter(0)->getAncestorOfType(SBML_KINETIC_LAW)); delete r; }
END_TEST START_TEST (test_WriteL3SBML_KineticLaw_ListOfParameters) { const char* expected = "<kineticLaw>\n" " <listOfLocalParameters>\n" " <localParameter id=\"n\" value=\"1.2\"/>\n" " </listOfLocalParameters>\n" "</kineticLaw>"; KineticLaw *kl = D->createModel()->createReaction()->createKineticLaw(); LocalParameter *p = kl->createLocalParameter(); p->setId("n"); p->setValue(1.2); char* sbml = kl->toSBML(); fail_unless( equals(expected, sbml) ); safe_free(sbml); }
void setObjectiveCoefficient(FbcModelPlugin* plugin, Model* model) { if (plugin == NULL || model == NULL) return; Objective* obj = plugin->getActiveObjective(); if (obj == NULL) return; for (unsigned int i = 0; i < obj->getNumFluxObjectives(); ++i) { FluxObjective* fluxObj = obj->getFluxObjective(i); if (fluxObj == NULL) continue; Reaction* reaction = model->getReaction(fluxObj->getReaction()); if (reaction == NULL) continue; KineticLaw* law = reaction->getKineticLaw(); if (law == NULL) continue; LocalParameter* param = law->getLocalParameter("OBJECTIVE_COEFFICIENT"); param->setValue(fluxObj->getCoefficient()); } }
/* convert from L1 to L3 */ void Model::convertL3ToL2 (bool strict) { dealWithModelUnits(); dealWithStoichiometry(); dealWithEvents(strict); for (unsigned int i = 0; i < getNumReactions(); i++) { Reaction *r = getReaction(i); if (r->isSetKineticLaw()) { KineticLaw *kl = r->getKineticLaw(); for (unsigned int j = 0; j < kl->getNumLocalParameters(); j++) { Parameter *lp = new Parameter(getLevel(), getVersion()); (*lp) = *(kl->getLocalParameter(j)); kl->addParameter(lp); } } } }
int Submodel::convertTimeAndExtentWith(const ASTNode* tcf, const ASTNode* xcf, const ASTNode* klmod) { if (tcf==NULL && xcf==NULL) return LIBSBML_OPERATION_SUCCESS; Model* model = getInstantiation(); if (model==NULL) { //getInstantiation sets its own error messages. return LIBSBML_OPERATION_FAILED; } ASTNode tcftimes(AST_TIMES); ASTNode tcfdiv(AST_DIVIDE); if (tcf != NULL) { tcftimes.addChild(tcf->deepCopy()); tcfdiv.addChild(tcf->deepCopy()); } ASTNode rxndivide(AST_DIVIDE); if (klmod != NULL) { ASTNode rxnref(AST_NAME); rxndivide.addChild(rxnref.deepCopy()); rxndivide.addChild(klmod->deepCopy()); } List* allElements = model->getAllElements(); for (ListIterator iter = allElements->begin(); iter != allElements->end(); ++iter) { SBase* element = static_cast<SBase*>(*iter); assert(element != NULL); ASTNode* ast1 = NULL; ASTNode* ast2 = NULL; Constraint* constraint = NULL; Delay* delay = NULL; EventAssignment* ea = NULL; InitialAssignment* ia = NULL; KineticLaw* kl = NULL; Priority* priority = NULL; RateRule* rrule = NULL; Rule* rule = NULL; Submodel* submodel = NULL; Trigger* trigger = NULL; string cf = ""; //Reaction math will be converted below, in the bits with the kinetic law. But because of that, we need to handle references *to* the reaction: even if it has no kinetic law, the units have changed, and this needs to be reflected by the flattening routine. if (rxndivide.getNumChildren() != 0 && element->getTypeCode()==SBML_REACTION && element->isSetId()) { rxndivide.getChild(0)->setName(element->getId().c_str()); for (ListIterator iter = allElements->begin(); iter != allElements->end(); ++iter) { SBase* subelement = static_cast<SBase*>(*iter); subelement->replaceSIDWithFunction(element->getId(), &rxndivide); } } //Submodels need their timeConversionFactor and extentConversionFactor attributes converted. We're moving top-down, so all we need to do here is fix the conversion factor attributes themselves, pointing them to new parameters if need be. if ((tcf !=NULL || xcf != NULL) && element->getTypeCode()==SBML_COMP_SUBMODEL) { submodel = static_cast<Submodel*>(element); if (tcf != NULL) { if (submodel->isSetTimeConversionFactor()) { createNewConversionFactor(cf, tcf, submodel->getTimeConversionFactor(), model); submodel->setTimeConversionFactor(cf); } else { submodel->setTimeConversionFactor(tcf->getName()); } } if (xcf != NULL) { if (submodel->isSetExtentConversionFactor()) { createNewConversionFactor(cf, xcf, submodel->getExtentConversionFactor(), model); submodel->setExtentConversionFactor(cf); } else { submodel->setExtentConversionFactor(xcf->getName()); } } } if (tcf==NULL) { if (klmod !=NULL && element->getTypeCode()==SBML_KINETIC_LAW) { kl = static_cast<KineticLaw*>(element); if (kl->isSetMath()) { ast1 = new ASTNode(AST_TIMES); ast1->addChild(klmod->deepCopy()); ast1->addChild(kl->getMath()->deepCopy()); kl->setMath(ast1); delete ast1; } } } else { // All math 'time' and 'delay' csymbols must still be converted. // Also, several constructs are modified directly. switch(element->getTypeCode()) { //This would be a WHOLE LOT SIMPLER if there was a 'hasMath' class in libsbml. But even so, it would have to // handle the kinetic laws, rate rules, and delays separately. case SBML_KINETIC_LAW: //Kinetic laws are multiplied by 'klmod'. kl = static_cast<KineticLaw*>(element); ast1 = kl->getMath()->deepCopy(); convertCSymbols(ast1, &tcfdiv, &tcftimes); if (klmod !=NULL) { kl = static_cast<KineticLaw*>(element); if (kl->isSetMath()) { ast2 = new ASTNode(AST_TIMES); ast2->addChild(klmod->deepCopy()); ast2->addChild(ast1); kl->setMath(ast2); delete ast2; } } else { kl->setMath(ast1); delete ast1; } break; case SBML_DELAY: //Delays are multiplied by the time conversion factor. delay = static_cast<Delay*>(element); if (delay->isSetMath()) { ast1 = delay->getMath()->deepCopy(); convertCSymbols(ast1, &tcfdiv, &tcftimes); tcftimes.addChild(ast1); delay->setMath(&tcftimes); tcftimes.removeChild(1); delete ast1; } break; case SBML_RATE_RULE: //Rate rules are divided by the time conversion factor. rrule = static_cast<RateRule*>(element); if (rrule->isSetMath()) { ast1 = rrule->getMath()->deepCopy(); tcfdiv.insertChild(0, ast1); rrule->setMath(&tcfdiv); tcfdiv.removeChild(0); delete ast1; } //Fall through to: case SBML_ASSIGNMENT_RULE: case SBML_ALGEBRAIC_RULE: //Rules in general need csymbols converted. rule = static_cast<Rule*>(element); if (rule->isSetMath()) { ast1 = rule->getMath()->deepCopy(); convertCSymbols(ast1, &tcfdiv, &tcftimes); rule->setMath(ast1); delete ast1; } break; case SBML_EVENT_ASSIGNMENT: //Event assignments need csymbols converted. ea = static_cast<EventAssignment*>(element); if (ea->isSetMath()) { ast1 = ea->getMath()->deepCopy(); convertCSymbols(ast1, &tcfdiv, &tcftimes); ea->setMath(ast1); delete ast1; } break; case SBML_INITIAL_ASSIGNMENT: //Initial assignments need csymbols converted. ia = static_cast<InitialAssignment*>(element); if (ia->isSetMath()) { ast1 = ia->getMath()->deepCopy(); convertCSymbols(ast1, &tcfdiv, &tcftimes); ia->setMath(ast1); delete ast1; } break; case SBML_CONSTRAINT: //Constraints need csymbols converted. constraint = static_cast<Constraint*>(element); if (constraint->isSetMath()) { ast1 = constraint->getMath()->deepCopy(); convertCSymbols(ast1, &tcfdiv, &tcftimes); constraint->setMath(ast1); delete ast1; } break; case SBML_PRIORITY: //Priorities need csymbols converted. priority = static_cast<Priority*>(element); if (priority->isSetMath()) { ast1 = priority->getMath()->deepCopy(); convertCSymbols(ast1, &tcfdiv, &tcftimes); priority->setMath(ast1); delete ast1; } break; case SBML_TRIGGER: //Triggers need csymbols converted. trigger = static_cast<Trigger*>(element); if (trigger->isSetMath()) { ast1 = trigger->getMath()->deepCopy(); convertCSymbols(ast1, &tcfdiv, &tcftimes); trigger->setMath(ast1); delete ast1; } break; default: //Do nothing! If we wanted to call a plugin routine, this would be the place. The only other alternative is to #ifdef some code in here that deals with the math-containing package objects explicitly. Which might be the best option, all told. break; } } } delete allElements; return LIBSBML_OPERATION_SUCCESS; }
int main (int argc, char* argv[]) { if (argc != 2) { cout << endl << "Usage: printNotes filename" << endl << endl; return 1; } unsigned int i,j; const char* filename = argv[1]; SBMLDocument* document; SBMLReader reader; document = reader.readSBML(filename); unsigned int errors = document->getNumErrors(); cout << endl; cout << "filename: " << filename << endl; cout << endl; if(errors > 0) { document->printErrors(cerr); delete document; return errors; } /* Model */ Model* m = document->getModel(); printNotes(m); for(i=0; i < m->getNumReactions(); i++) { Reaction* re = m->getReaction(i); printNotes(re); /* SpeciesReference (Reacatant) */ for(j=0; j < re->getNumReactants(); j++) { SpeciesReference* rt = re->getReactant(j); if (rt->isSetNotes()) cout << " "; printNotes(rt, (rt->isSetSpecies() ? rt->getSpecies() : std::string("")) ); } /* SpeciesReference (Product) */ for(j=0; j < re->getNumProducts(); j++) { SpeciesReference* rt = re->getProduct(j); if (rt->isSetNotes()) cout << " "; printNotes(rt, (rt->isSetSpecies() ? rt->getSpecies() : std::string("")) ); } /* ModifierSpeciesReference (Modifier) */ for(j=0; j < re->getNumModifiers(); j++) { ModifierSpeciesReference* md = re->getModifier(j); if (md->isSetNotes()) cout << " "; printNotes(md, (md->isSetSpecies() ? md->getSpecies() : std::string("")) ); } /* Kineticlaw */ if(re->isSetKineticLaw()) { KineticLaw* kl = re->getKineticLaw(); if (kl->isSetNotes()) cout << " "; printNotes(kl); /* Parameter */ for(j=0; j < kl->getNumParameters(); j++) { Parameter* pa = kl->getParameter(j); if (pa->isSetNotes()) cout << " "; printNotes(pa); } } } /* Species */ for(i=0; i < m->getNumSpecies(); i++) { Species* sp = m->getSpecies(i); printNotes(sp); } /* Compartment */ for(i=0; i < m->getNumCompartments(); i++) { Compartment* sp = m->getCompartment(i); printNotes(sp); } /* FunctionDefinition */ for(i=0; i < m->getNumFunctionDefinitions(); i++) { FunctionDefinition* sp = m->getFunctionDefinition(i); printNotes(sp); } /* UnitDefinition */ for(i=0; i < m->getNumUnitDefinitions(); i++) { UnitDefinition* sp = m->getUnitDefinition(i); printNotes(sp); } /* Parameter */ for(i=0; i < m->getNumParameters(); i++) { Parameter* sp = m->getParameter(i); printNotes(sp); } /* Rule */ for(i=0; i < m->getNumRules(); i++) { Rule* sp = m->getRule(i); printNotes(sp); } /* InitialAssignment */ for(i=0; i < m->getNumInitialAssignments(); i++) { InitialAssignment* sp = m->getInitialAssignment(i); printNotes(sp); } /* Event */ for(i=0; i < m->getNumEvents(); i++) { Event* sp = m->getEvent(i); printNotes(sp); /* Trigger */ if(sp->isSetTrigger()) { const Trigger* tg = sp->getTrigger(); if (tg->isSetNotes()) cout << " "; printNotes(const_cast<Trigger*>(tg)); } /* Delay */ if(sp->isSetDelay()) { const Delay* dl = sp->getDelay(); if (dl->isSetNotes()) cout << " "; printNotes(const_cast<Delay*>(dl)); } /* EventAssignment */ for(j=0; j < sp->getNumEventAssignments(); j++) { EventAssignment* ea = sp->getEventAssignment(j); if (ea->isSetNotes()) cout << " "; printNotes(ea); } } /* SpeciesType */ for(i=0; i < m->getNumSpeciesTypes(); i++) { SpeciesType* sp = m->getSpeciesType(i); printNotes(sp); } /* Constraint */ for(i=0; i < m->getNumConstraints(); i++) { Constraint* sp = m->getConstraint(i); printNotes(sp); } delete document; return errors; }
//static void SBMLUtils::collectIds(Model* pModel, std::map<std::string, const SBase*>& ids, std::map<std::string, const SBase*>& metaIds) { if (pModel != NULL) { // the model itself SBase* pSBase = NULL; std::string id; if (pModel->isSetId()) { id = pModel->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pModel->isSetMetaId()) { id = pModel->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // ListOfFunctionDefinitions pSBase = pModel->getListOfFunctionDefinitions(); if (pSBase != NULL) { if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // all FunctionDefinitions unsigned int i, iMax = pModel->getListOfFunctionDefinitions()->size(); for (i = 0; i < iMax; ++i) { pSBase = pModel->getListOfFunctionDefinitions()->get(i); if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } // ListOfUnitDefinition pSBase = pModel->getListOfUnitDefinitions(); if (pSBase != NULL) { if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // all UnitDefinitions // for each UnitDefinition: ListOfUnits, each Unit in ListOfUnits unsigned int i, iMax = pModel->getListOfUnitDefinitions()->size(); for (i = 0; i < iMax; ++i) { /* UnitDefinitions have their ids in a different namespace so we only consider meta ids. */ UnitDefinition* pUDef = pModel->getUnitDefinition(i); assert(pUDef != NULL); if (pUDef->isSetMetaId()) { id = pUDef->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pUDef)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } ListOf* pList = pUDef->getListOfUnits(); if (pList != NULL) { if (pList->isSetMetaId()) { id = pList->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pList)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } unsigned j, jMax = pList->size(); for (j = 0; j < jMax; ++j) { pSBase = pList->get(j); assert(pSBase != NULL); if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } } } // ListOfCompartmentTypes pSBase = pModel->getListOfCompartmentTypes(); if (pSBase != NULL) { if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // each compartment type unsigned int i, iMax = pModel->getListOfCompartmentTypes()->size(); for (i = 0; i < iMax; ++i) { pSBase = pModel->getCompartmentType(i); assert(pSBase != NULL); if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } // ListOfSpeciesTypes pSBase = pModel->getListOfSpeciesTypes(); if (pSBase != NULL) { if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // each species type unsigned int i, iMax = pModel->getListOfSpeciesTypes()->size(); for (i = 0; i < iMax; ++i) { pSBase = pModel->getSpeciesType(i); assert(pSBase != NULL); if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } // ListOfCompartments pSBase = pModel->getListOfCompartments(); if (pSBase != NULL) { if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // all compartments unsigned int i, iMax = pModel->getListOfCompartments()->size(); for (i = 0; i < iMax; ++i) { pSBase = pModel->getCompartment(i); assert(pSBase != NULL); if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } // ListOfSpecies pSBase = pModel->getListOfSpecies(); if (pSBase != NULL) { if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // all species unsigned int i, iMax = pModel->getListOfSpecies()->size(); for (i = 0; i < iMax; ++i) { pSBase = pModel->getSpecies(i); assert(pSBase != NULL); if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } // ListOfParameters pSBase = pModel->getListOfParameters(); if (pSBase != NULL) { if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // each parameter unsigned int i, iMax = pModel->getListOfParameters()->size(); for (i = 0; i < iMax; ++i) { pSBase = pModel->getParameter(i); assert(pSBase != NULL); if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } // ListOfInitialAssignments pSBase = pModel->getListOfInitialAssignments(); if (pSBase != NULL) { if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // each initial assignment unsigned int i, iMax = pModel->getListOfInitialAssignments()->size(); for (i = 0; i < iMax; ++i) { pSBase = pModel->getInitialAssignment(i); assert(pSBase != NULL); // initial assignments have no ids if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } // ListOfRules pSBase = pModel->getListOfRules(); if (pSBase != NULL) { if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // each rule unsigned int i, iMax = pModel->getListOfRules()->size(); for (i = 0; i < iMax; ++i) { pSBase = pModel->getRule(i); assert(pSBase != NULL); // rules don't have ids if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } // ListOfConstraints pSBase = pModel->getListOfConstraints(); if (pSBase != NULL) { if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // each constraint unsigned int i, iMax = pModel->getListOfConstraints()->size(); for (i = 0; i < iMax; ++i) { pSBase = pModel->getConstraint(i); assert(pSBase != NULL); // constraints don't have ids if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } // ListOfReactions pSBase = pModel->getListOfReactions(); if (pSBase != NULL) { if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // all reactions unsigned int i, iMax = pModel->getListOfReactions()->size(); for (i = 0; i < iMax; ++i) { Reaction* pReaction = pModel->getReaction(i); assert(pReaction != NULL); if (pReaction->isSetId()) { id = pReaction->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pReaction)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pReaction->isSetMetaId()) { id = pReaction->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pReaction)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // for each reaction: ListOfSubstrates, each substrate, ListOfProducts, each // Product, ListOfModifieres, each modifier, KineticLaw, ListOfparameters, // each parameter if (pReaction->getListOfReactants() != NULL) { pSBase = pReaction->getListOfReactants(); if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } unsigned int j, jMax = pReaction->getListOfReactants()->size(); for (j = 0; j < jMax; ++j) { pSBase = pReaction->getReactant(j); assert(pSBase != NULL); // since L2V2 species references can have ids if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } if (pReaction->getListOfProducts() != NULL) { pSBase = pReaction->getListOfProducts(); if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } unsigned int j, jMax = pReaction->getListOfProducts()->size(); for (j = 0; j < jMax; ++j) { pSBase = pReaction->getProduct(j); assert(pSBase != NULL); // since L2V2 species references can have ids if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } if (pReaction->getListOfModifiers() != NULL) { pSBase = pReaction->getListOfModifiers(); if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } unsigned int j, jMax = pReaction->getListOfModifiers()->size(); for (j = 0; j < jMax; ++j) { pSBase = pReaction->getModifier(j); assert(pSBase != NULL); // since L2V2 species references can have ids if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } KineticLaw* pKLaw = pReaction->getKineticLaw(); if (pKLaw != NULL) { if (pKLaw->isSetMetaId()) { id = pKLaw->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pKLaw)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } pSBase = pKLaw->getListOfParameters(); if (pSBase != NULL) { if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } unsigned int j, jMax = pKLaw->getListOfParameters()->size(); for (j = 0; j < jMax; ++j) { pSBase = pKLaw->getParameter(j); assert(pSBase != NULL); // local parameters have their ids in a // different namespace if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } } } } // ListOfEvents pSBase = pModel->getListOfEvents(); if (pSBase != NULL) { if (pSBase->isSetId()) { id = pSBase->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // each event unsigned int i, iMax = pModel->getListOfEvents()->size(); for (i = 0; i < iMax; ++i) { Event* pEvent = pModel->getEvent(i); assert(pEvent != NULL); if (pEvent->isSetId()) { id = pEvent->getId(); if (ids.find(id) == ids.end()) { ids.insert(std::pair<const std::string, const SBase*>(id, pEvent)); } else { CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str()); } } if (pEvent->isSetMetaId()) { id = pEvent->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pEvent)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } // in each event Trigger,Delay,ListOfEventAssignments, each event assignment if (pEvent->isSetTrigger()) { pSBase = pEvent->getTrigger(); assert(pSBase != NULL); if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } if (pEvent->isSetDelay()) { pSBase = pEvent->getDelay(); assert(pSBase != NULL); if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } if (pEvent->getListOfEventAssignments() != NULL) { pSBase = pEvent->getListOfEventAssignments(); if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } unsigned int j, jMax = pEvent->getListOfEventAssignments()->size(); for (j = 0; j < jMax; ++j) { pSBase = pEvent->getEventAssignment(j); assert(pSBase != NULL); if (pSBase->isSetMetaId()) { id = pSBase->getMetaId(); if (metaIds.find(id) == metaIds.end()) { metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase)); } else { CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str()); } } } } } } } }
/** * Save the gene network to an SBML file. If the argument is null, use the network id. * @param filename URL to the file describing the network to load * @throws IOException */ void GeneNetwork::writeSBML(const char *filename) { ofstream data_file(filename); if (!data_file.is_open()) { std::cerr << "Failed to open file " << filename << std::endl; exit(1); } data_file.close(); ::logging::log::emit<Info>() << "Writing file " << filename << ::logging::log::endl; SBMLDocument *sbmlDoc = new SBMLDocument(3, 1); Model *model = sbmlDoc->createModel(); model->setId(id_); //model.getNotes ().add (comment_); // save network description int size = getSize(); Compartment *comp = model->createCompartment(); comp->setId("cell"); comp->setSize(1); std::vector<Species*> all_sp; Species *sp; for (int s=0; s < size; s++) { // save gene as species // species[s] = new Species(nodeIds_.get(s), nodeIds_.get(s)); sp = model->createSpecies(); sp->setCompartment("cell"); sp->setId((nodes_.at(s)).getLabel()); all_sp.push_back(sp); //species[s].setInitialAmount(?); // maybe save the wild-type steady state? //model.addSpecies(species[s]); } // create the void species sp = model->createSpecies(); sp->setCompartment("cell"); sp->setId("_void_"); sp->setInitialAmount(0); sp->setBoundaryCondition(true); sp->setConstant(true); all_sp.push_back(sp); //model.addSpecies(species[size]); // SET SYNTHESIS AND DEGRADATION REACTIONS FOR EVERY GENE for (int i=0; i<size; i++) { //::logging::log::emit<Info>() << ::logging::log::dec << i << //::logging::log::endl; // the ID of gene i // String currentGeneID = nodeIds_.get(i); string currentGeneID = (nodes_.at(i)).getLabel(); // The modifiers (regulators) of gene i std::vector<std::string> inputGenes = (nodes_.at(i)).getInputGenes(); // SYNTHESIS REACTION std::string reactionId = currentGeneID + "_synthesis"; Reaction *reaction = model->createReaction(); KineticLaw *kineticLaw = reaction->createKineticLaw(); SpeciesReference *spr; ModifierSpeciesReference *msr; reaction->setId(reactionId); reaction->setReversible (false); spr = reaction->createReactant(); spr->setSpecies(sp->getId()); spr = reaction->createProduct(); spr->setSpecies((all_sp.at(i))->getId()); std::stringstream ss; ss << inputGenes.size(); //::logging::log::emit<Debug>() << "node = " << nodes_.at(i).getLabel().c_str() << " #inputs = " << ss.str().c_str() << ::logging::log::endl; for (unsigned int r=0; r<inputGenes.size(); r++) {// set gene modifiers // reaction.addModifier(species[inputIndexes.get(r)]); //log.log(Level.INFO, "i = " + size); msr = reaction->createModifier(); msr->setSpecies((all_sp.at(getIndexOfNode(inputGenes.at(r))))->getId()); } //std::vector<RegulatoryModule> modules = (nodes_.at(i)).getRegulatoryModules(); //log.log(Level.INFO, "size = " + modules.size()); std::map<std::string, double> *params = new std::map<std::string, double>(); (nodes_.at(i)).compileParameters(*params); //char buf[256]; //sprintf(buf, "%f", nodes_.at(i).getDelta()); //::logging::log::emit<Info>() << buf << ::logging::log::endl; //::logging::log::emit<Info>() << ::logging::log::dec << nodes_.at(i).getAlpha().size() << // ::logging::log::endl; Parameter *para; // save gene parameters (note, the first param is the degradation rate) std::map<std::string, double>::iterator p = params->begin(); //p++; for (; p!=params->end(); p++) { //if (p == params->begin()) { // p++; // continue; //} //::logging::log::emit<Info>() << p->first.c_str() << // ::logging::log::endl; if (p->first != "delta") { para = kineticLaw->createParameter(); para->setId(p->first); para->setValue(p->second); } } reaction->setKineticLaw(kineticLaw); model->addReaction(reaction); // DEGRADATION REACTION reaction = model->createReaction(); kineticLaw = reaction->createKineticLaw(); reactionId = currentGeneID + "_degradation"; reaction->setId(reactionId); reaction->setReversible(false); spr = reaction->createReactant(); spr->setSpecies((all_sp.at(i))->getId()); spr = reaction->createProduct(); spr->setSpecies(sp->getId()); para = kineticLaw->createParameter(); std::map<std::string,double>::iterator it = params->find("delta"); para->setId(it->first); para->setValue(it->second); reaction->setKineticLaw (kineticLaw); model->addReaction (reaction); } // PRINT FILE SBMLWriter sbmlWriter; sbmlWriter.writeSBML(sbmlDoc, filename); delete sbmlDoc; }
/** * * 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; }
/** @cond doxygenLibsbmlInternal */ int Replacing::updateIDs(SBase* oldnames, SBase* newnames) { int ret = LIBSBML_OPERATION_SUCCESS; SBMLDocument* doc = getSBMLDocument(); if (oldnames->isSetId() && !newnames->isSetId()) { if (doc) { string error = "Unable to transform IDs in Replacing::updateIDs during replacement: the '" + oldnames->getId() + "' element's replacement does not have an ID set."; doc->getErrorLog()->logPackageError("comp", CompMustReplaceIDs, getPackageVersion(), getLevel(), getVersion(), error, getLine(), getColumn()); } return LIBSBML_INVALID_OBJECT; } if (oldnames->isSetMetaId() && !newnames->isSetMetaId()) { if (doc) { string error = "Unable to transform IDs in Replacing::updateIDs during replacement: the replacement of the element with metaid '" + oldnames->getMetaId() + "' does not have a metaid."; doc->getErrorLog()->logPackageError("comp", CompMustReplaceMetaIDs, getPackageVersion(), getLevel(), getVersion(), error, getLine(), getColumn()); } return LIBSBML_INVALID_OBJECT; } //LS DEBUG Somehow we need to check identifiers from other packages here (like spatial id's). How, exactly, is anyone's guess. Model* replacedmod = const_cast<Model*>(CompBase::getParentModel(oldnames)); KineticLaw* replacedkl; ASTNode newkl; if (replacedmod==NULL) { if (doc) { string error = "Unable to transform IDs in Replacing::updateIDs during replacement: the replacement of '" + oldnames->getId() + "' does not have a valid model."; doc->getErrorLog()->logPackageError("comp", CompModelFlatteningFailed, getPackageVersion(), getLevel(), getVersion(), error, getLine(), getColumn()); } return LIBSBML_INVALID_OBJECT; } List* allElements = replacedmod->getAllElements(); string oldid = oldnames->getId(); string newid = newnames->getId(); if (!oldid.empty()) { switch(oldnames->getTypeCode()) { case SBML_UNIT_DEFINITION: replacedmod->renameUnitSIdRefs(oldid, newid); for (unsigned int e=0; e<allElements->getSize(); e++) { SBase* element = static_cast<SBase*>(allElements->get(e)); element->renameUnitSIdRefs(oldid, newid); } break; case SBML_LOCAL_PARAMETER: replacedkl = static_cast<KineticLaw*>(oldnames->getAncestorOfType(SBML_KINETIC_LAW)); if (replacedkl->isSetMath()) { newkl = *replacedkl->getMath(); newkl.renameSIdRefs(oldid, newid); replacedkl->setMath(&newkl); } break; case SBML_COMP_PORT: break; //LS DEBUG And here is where we would need some sort of way to check if the id wasn't an SId for some objects. default: replacedmod->renameSIdRefs(oldnames->getId(), newnames->getId()); for (unsigned int e=0; e<allElements->getSize(); e++) { SBase* element = static_cast<SBase*>(allElements->get(e)); element->renameSIdRefs(oldid, newid); } } } string oldmetaid = oldnames->getMetaId(); string newmetaid = newnames->getMetaId(); if (oldnames->isSetMetaId()) { replacedmod->renameMetaIdRefs(oldmetaid, newmetaid); for (unsigned int e=0; e<allElements->getSize(); e++) { SBase* element = static_cast<SBase*>(allElements->get(e)); element->renameMetaIdRefs(oldmetaid, newmetaid); } } //LS DEBUG And here is where we would need some sort of way to check for ids that were not 'id' or 'metaid'. delete allElements; return ret; }
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; } } }
/** * * 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 test000009::test_references_to_species() { // load the CPS file // export to SBML // check the resulting SBML model CCopasiDataModel* pDataModel = pCOPASIDATAMODEL; std::istringstream iss(test000009::MODEL_STRING); CPPUNIT_ASSERT(load_cps_model_from_stream(iss, *pDataModel) == true); CPPUNIT_ASSERT(pDataModel->getModel() != NULL); CPPUNIT_ASSERT(pDataModel->exportSBMLToString(NULL, 2, 3).empty() == false); SBMLDocument* pDocument = pDataModel->getCurrentSBMLDocument(); CPPUNIT_ASSERT(pDocument != NULL); Model* pModel = pDocument->getModel(); CPPUNIT_ASSERT(pModel != NULL); // assert that there is only one compartment and // assert the compartment is constant CPPUNIT_ASSERT(pModel->getNumCompartments() == 1); Compartment* pCompartment = pModel->getCompartment(0); CPPUNIT_ASSERT(pCompartment->getConstant() == false); CPPUNIT_ASSERT(pModel->getNumSpecies() == 2); Species* pSpecies = pModel->getSpecies(1); CPPUNIT_ASSERT(pSpecies->getHasOnlySubstanceUnits() == true); pSpecies = pModel->getSpecies(0); std::string idSpeciesA = pSpecies->getId(); CPPUNIT_ASSERT(pSpecies->getHasOnlySubstanceUnits() == true); CPPUNIT_ASSERT(pModel->getNumRules() == 2); // there are two rules, one is the rule for the compartment AssignmentRule* pRule = dynamic_cast<AssignmentRule*>(pModel->getRule(0)); CPPUNIT_ASSERT(pRule != NULL); CPPUNIT_ASSERT(pModel->getNumParameters() == 1); Parameter* pParameter = pModel->getParameter(0); CPPUNIT_ASSERT(pParameter != NULL); if (pRule->getVariable() != pParameter->getId()) { pRule = dynamic_cast<AssignmentRule*>(pModel->getRule(1)); } CPPUNIT_ASSERT(pRule->getVariable() == pParameter->getId()); const ASTNode* pMath = pRule->getMath(); CPPUNIT_ASSERT(pMath != NULL); // the expression should be the species divided by the volume CPPUNIT_ASSERT(pMath->getType() == AST_DIVIDE); CPPUNIT_ASSERT(pMath->getChild(0) != NULL); CPPUNIT_ASSERT(pMath->getChild(0)->getType() == AST_NAME); CPPUNIT_ASSERT(pMath->getChild(0)->getName() == pSpecies->getId()); CPPUNIT_ASSERT(pMath->getChild(1) != NULL); CPPUNIT_ASSERT(pMath->getChild(1)->getType() == AST_NAME); CPPUNIT_ASSERT(pMath->getChild(1)->getName() == pCompartment->getId()); CPPUNIT_ASSERT(pModel->getNumReactions() == 2); Reaction* pReaction = pModel->getReaction(0); // make sure this is reaction A -> CPPUNIT_ASSERT(pReaction != NULL); CPPUNIT_ASSERT(pReaction->getNumReactants() == 1); CPPUNIT_ASSERT(pReaction->getNumProducts() == 0); // check if all references in the kinetic law are unmodified // math element must be a multiplication of the mass action term by // the compartment volume // the mass action term is a multiplication of the parameter node by // the species node // the code that multiplies the reaction by the compartments volume // recognizes the division of the species by the compartment and cancels // those two CPPUNIT_ASSERT(pReaction->isSetKineticLaw() == true); KineticLaw* pLaw = pReaction->getKineticLaw(); CPPUNIT_ASSERT(pLaw != NULL); CPPUNIT_ASSERT(pLaw->isSetMath() == true); pMath = pLaw->getMath(); CPPUNIT_ASSERT(pMath->getType() == AST_TIMES); CPPUNIT_ASSERT(pMath->getNumChildren() == 2); CPPUNIT_ASSERT(pMath->getChild(0)->getType() == AST_NAME); CPPUNIT_ASSERT(pMath->getChild(0)->getName() == std::string("k1")); CPPUNIT_ASSERT(pMath->getChild(1) != NULL); CPPUNIT_ASSERT(pMath->getChild(1)->getType() == AST_NAME); CPPUNIT_ASSERT(pMath->getChild(1)->getName() == idSpeciesA); pReaction = pModel->getReaction(1); // make sure this is reaction A -> S CPPUNIT_ASSERT(pReaction != NULL); CPPUNIT_ASSERT(pReaction->getNumReactants() == 1); CPPUNIT_ASSERT(pReaction->getNumProducts() == 1); // check if all references in the kinetic law are unmodified // math element must be a multiplication of the compartments volume with // a function call with three arguments // the first argument is the reference to the species CPPUNIT_ASSERT(pReaction->isSetKineticLaw() == true); pLaw = pReaction->getKineticLaw(); CPPUNIT_ASSERT(pLaw != NULL); CPPUNIT_ASSERT(pLaw->isSetMath() == true); pMath = pLaw->getMath(); CPPUNIT_ASSERT(pMath->getType() == AST_TIMES); CPPUNIT_ASSERT(pMath->getNumChildren() == 2); CPPUNIT_ASSERT(pMath->getChild(0)->getType() == AST_NAME); CPPUNIT_ASSERT(pMath->getChild(0)->getName() == pCompartment->getId()); pMath = pMath->getChild(1); CPPUNIT_ASSERT(pMath != NULL); CPPUNIT_ASSERT(pMath->getType() == AST_FUNCTION); CPPUNIT_ASSERT(pMath->getNumChildren() == 3); pMath = pMath->getChild(0); CPPUNIT_ASSERT(pMath != NULL); CPPUNIT_ASSERT(pMath->getType() == AST_DIVIDE); CPPUNIT_ASSERT(pMath->getNumChildren() == 2); CPPUNIT_ASSERT(pMath->getChild(0) != NULL); CPPUNIT_ASSERT(pMath->getChild(0)->getType() == AST_NAME); CPPUNIT_ASSERT(pMath->getChild(0)->getName() == idSpeciesA); CPPUNIT_ASSERT(pMath->getChild(1) != NULL); CPPUNIT_ASSERT(pMath->getChild(1)->getType() == AST_NAME); CPPUNIT_ASSERT(pMath->getChild(1)->getName() == pCompartment->getId()); }
/** * * Creates an SBML model represented in "7.2 Example involving units" * in the SBML Level 2 Version 4 Specification. * */ SBMLDocument* createExampleInvolvingUnits() { const unsigned int level = Level; const unsigned int version = Version; //--------------------------------------------------------------------------- // // Creates an SBMLDocument object // //--------------------------------------------------------------------------- SBMLDocument* sbmlDoc = new SBMLDocument(level,version); // Adds the namespace for XHTML to the SBMLDocument object. We need this // because we will add notes to the model. (By default, the SBML document // created by SBMLDocument only declares the SBML XML namespace.) sbmlDoc->getNamespaces()->add("http://www.w3.org/1999/xhtml", "xhtml"); //--------------------------------------------------------------------------- // // Creates a Model object inside the SBMLDocument object. // //--------------------------------------------------------------------------- Model* model = sbmlDoc->createModel(); model->setId("unitsExample"); //--------------------------------------------------------------------------- // // Creates UnitDefinition objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointers (reused more than once below). UnitDefinition* unitdef; Unit *unit; //--------------------------------------------------------------------------- // (UnitDefinition1) Creates an UnitDefinition object ("substance"). // // This has the effect of redefining the default unit of subtance for the // whole model. //--------------------------------------------------------------------------- unitdef = model->createUnitDefinition(); unitdef->setId("substance"); // Creates an Unit inside the UnitDefinition object unit = unitdef->createUnit(); unit->setKind(UNIT_KIND_MOLE); unit->setScale(-3); //-------------------------------------------------------------------------------- // (UnitDefinition2) Creates an UnitDefinition object ("mmls") //-------------------------------------------------------------------------------- // 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("mmls"); // Creates an Unit inside the UnitDefinition object ("mmls") unit = unitdef->createUnit(); unit->setKind(UNIT_KIND_MOLE); unit->setScale(-3); // Creates an Unit inside the UnitDefinition object ("mmls") unit = unitdef->createUnit(); unit->setKind(UNIT_KIND_LITRE); unit->setExponent(-1); // Creates an Unit inside the UnitDefinition object ("mmls") unit = unitdef->createUnit(); unit->setKind(UNIT_KIND_SECOND); unit->setExponent(-1); //-------------------------------------------------------------------------------- // (UnitDefinition3) Creates an UnitDefinition object ("mml") //-------------------------------------------------------------------------------- unitdef = model->createUnitDefinition(); unitdef->setId("mml"); // Creates an Unit inside the UnitDefinition object ("mml") unit = unitdef->createUnit(); unit->setKind(UNIT_KIND_MOLE); unit->setScale(-3); // Creates an Unit inside the UnitDefinition object ("mml") unit = unitdef->createUnit(); unit->setKind(UNIT_KIND_LITRE); unit->setExponent(-1); //--------------------------------------------------------------------------- // // Creates a Compartment object inside the Model object. // //--------------------------------------------------------------------------- Compartment* comp; const string compName = "cell"; // Creates a Compartment object ("cell") 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. // //--------------------------------------------------------------------------- // Temporary pointer (reused more than once below). Species *sp; //--------------------------------------------------------------------------- // (Species1) Creates a Species object ("x0") //--------------------------------------------------------------------------- sp = model->createSpecies(); sp->setId("x0"); // 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 // "spatialDimensions" attribute of the Compartment object ("cytosol") in which // this species object is 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 moles/liters . // sp->setInitialConcentration(1); //--------------------------------------------------------------------------- // (Species2) Creates a Species object ("x1") //--------------------------------------------------------------------------- sp = model->createSpecies(); sp->setId("x1"); sp->setCompartment(compName); sp->setInitialConcentration(1); //--------------------------------------------------------------------------- // (Species3) Creates a Species object ("s1") //--------------------------------------------------------------------------- sp = model->createSpecies(); sp->setCompartment(compName); sp->setId("s1"); sp->setInitialConcentration(1); //--------------------------------------------------------------------------- // (Species4) Creates a Species object ("s2") //--------------------------------------------------------------------------- sp = model->createSpecies(); sp->setCompartment(compName); sp->setId("s2"); sp->setInitialConcentration(1); //--------------------------------------------------------------------------- // // Creates global Parameter objects inside the Model object. // //--------------------------------------------------------------------------- Parameter* para; // Creates a Parameter ("vm") para = model->createParameter(); para->setId("vm"); para->setValue(2); para->setUnits("mmls"); // Creates a Parameter ("km") para = model->createParameter(); para->setId("km"); para->setValue(2); para->setUnits("mml"); //--------------------------------------------------------------------------- // // Creates Reaction objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointers. Reaction* reaction; SpeciesReference* spr; KineticLaw* kl; //--------------------------------------------------------------------------- // (Reaction1) Creates a Reaction object ("v1"). //--------------------------------------------------------------------------- reaction = model->createReaction(); reaction->setId("v1"); //--------------------------------------------------------------------------- // Creates Reactant objects inside the Reaction object ("v1"). //--------------------------------------------------------------------------- // (Reactant1) Creates a Reactant object that references Species "x0" // in the model. spr = reaction->createReactant(); spr->setSpecies("x0"); //--------------------------------------------------------------------------- // Creates a Product object inside the Reaction object ("v1"). //--------------------------------------------------------------------------- // Creates a Product object that references Species "s1" in the model. spr = reaction->createProduct(); spr->setSpecies("s1"); //--------------------------------------------------------------------------- // Creates a KineticLaw object inside the Reaction object ("v1"). //--------------------------------------------------------------------------- kl = reaction->createKineticLaw(); // Creates a <notes> element in the KineticLaw object. // Here we illustrate how to do it using a literal string. This requires // known the required syntax of XHTML and the requirements for SBML <notes> // elements. Later below, we show how to create notes using objects instead // of strings. string notesString = "<xhtml:p> ((vm * s1)/(km + s1)) * cell </xhtml:p>"; kl->setNotes(notesString); //--------------------------------------------------------------------------- // Creates an ASTNode object which represents the following KineticLaw object. // // <math xmlns=\"http://www.w3.org/1998/Math/MathML\"> // <apply> // <times/> // <apply> // <divide/> // <apply> // <times/> // <ci> vm </ci> // <ci> s1 </ci> // </apply> // <apply> // <plus/> // <ci> km </ci> // <ci> s1 </ci> // </apply> // </apply> // <ci> cell </ci> // </apply> // </math> //--------------------------------------------------------------------------- // // In the following code, ASTNode objects, which construct an ASTNode tree // of the above math, are created and added in the order of preorder traversal // of the tree (i.e. the order corresponds to the nested structure of the above // MathML elements), and thus the following code maybe a bit more efficient but // maybe a bit difficult to read. // ASTNode* astMath = new ASTNode(AST_TIMES); astMath->addChild(new ASTNode(AST_DIVIDE)); ASTNode* astDivide = astMath->getLeftChild(); astDivide->addChild(new ASTNode(AST_TIMES)); ASTNode* astTimes = astDivide->getLeftChild(); astTimes->addChild(new ASTNode(AST_NAME)); astTimes->getLeftChild()->setName("vm"); astTimes->addChild(new ASTNode(AST_NAME)); astTimes->getRightChild()->setName("s1"); astDivide->addChild(new ASTNode(AST_PLUS)); ASTNode* astPlus = astDivide->getRightChild(); astPlus->addChild(new ASTNode(AST_NAME)); astPlus->getLeftChild()->setName("km"); astPlus->addChild(new ASTNode(AST_NAME)); astPlus->getRightChild()->setName("s1"); astMath->addChild(new ASTNode(AST_NAME)); astMath->getRightChild()->setName("cell"); //--------------------------------------------- // // set the Math element // //------------------------------------------------ kl->setMath(astMath); delete astMath; //--------------------------------------------------------------------------- // (Reaction2) Creates a Reaction object ("v2"). //--------------------------------------------------------------------------- reaction = model->createReaction(); reaction->setId("v2"); //--------------------------------------------------------------------------- // Creates Reactant objects inside the Reaction object ("v2"). //--------------------------------------------------------------------------- // (Reactant2) 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 ("v2"). //--------------------------------------------------------------------------- // 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 ("v2"). //--------------------------------------------------------------------------- kl = reaction->createKineticLaw(); // Sets a notes (by XMLNode) to the KineticLaw object. // // The following code is an alternative to using setNotes(const string&). // The equivalent code would be like this: // // notesString = "<xhtml:p>((vm * s2)/(km + s2))*cell</xhtml:p>"; // kl->setNotes(notesString); // Creates an XMLNode of start element (<xhtml:p>) without attributes. XMLNode notesXMLNode(XMLTriple("p", "", "xhtml"), XMLAttributes()); // Adds a text element to the start element. notesXMLNode.addChild(XMLNode(" ((vm * s2)/(km + s2)) * cell ")); // Adds it to the kineticLaw object. kl->setNotes(¬esXMLNode); //--------------------------------------------------------------------------- // 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/>" " <apply>" " <divide/>" " <apply>" " <times/>" " <ci> vm </ci>" " <ci> s2 </ci>" " </apply>" " <apply>" " <plus/>" " <ci> km </ci>" " <ci> s2 </ci>" " </apply>" " </apply>" " <ci> cell </ci>" " </apply>" "</math>"; astMath = readMathMLFromString(mathXMLString.c_str()); kl->setMath(astMath); delete astMath; //--------------------------------------------------------------------------- // (Reaction3) Creates a Reaction object ("v3"). //--------------------------------------------------------------------------- reaction = model->createReaction(); reaction->setId("v3"); //--------------------------------------------------------------------------- // Creates Reactant objects inside the Reaction object ("v3"). //--------------------------------------------------------------------------- // (Reactant2) Creates a Reactant object that references Species "s2" // in the model. spr = reaction->createReactant(); spr->setSpecies("s2"); //--------------------------------------------------------------------------- // Creates a Product object inside the Reaction object ("v3"). //--------------------------------------------------------------------------- // Creates a Product object that references Species "x1" in the model. spr = reaction->createProduct(); spr->setSpecies("x1"); //--------------------------------------------------------------------------- // Creates a KineticLaw object inside the Reaction object ("v3"). //--------------------------------------------------------------------------- kl = reaction->createKineticLaw(); // Sets a notes (by string) to the KineticLaw object. notesString = "<xhtml:p> ((vm * x1)/(km + x1)) * cell </xhtml:p>"; kl->setNotes(notesString); //--------------------------------------------------------------------------- // Sets a math (ASTNode object) to the KineticLaw object. //--------------------------------------------------------------------------- mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">" " <apply>" " <times/>" " <apply>" " <divide/>" " <apply>" " <times/>" " <ci> vm </ci>" " <ci> x1 </ci>" " </apply>" " <apply>" " <plus/>" " <ci> km </ci>" " <ci> x1 </ci>" " </apply>" " </apply>" " <ci> cell </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; }
/** * Load a gene network from an SBML file. Overrides Structure.load(). Format must * be equal GeneNetwork.SBML. Note, the SBML file must be in the exact same format * as the SBML files produced by writeSBML(). In particular, we assume that reactions are listed * *ordered* as we do in writeSBML(). * @param filename URL to the file describing the network to load * @param format File format (GML, DOT, etc.) * @throws IOException */ void GeneNetwork::load_sbml(const char *filename) { SBMLDocument* document; SBMLReader reader; document = reader.readSBML(filename); unsigned int errors = document->getNumErrors(); if (errors > 0) { std::cerr << "Failed to open file " << filename << std::endl; exit(1); } Model *m = document->getModel(); // ----------------------------------------- // Set the network size and create the genes // do not count the species _void_ int size = m->getNumSpecies() - 1; ListOfSpecies *species = m->getListOfSpecies(); for (int g=0; g < size; g++) { if (species->get(g)->getId() != "_void_") { //HillGene hg = new HillGene(this); //hg.setLabel(species.get(g).getId()); HillGene *n = new HillGene(species->get(g)->getId()); //n.setLabel(species->get(g)->getId()); nodes_.push_back(*n); delete n; } } x_ = Vec_DP(nodes_.size()); x_ = 0; y_ = Vec_DP(nodes_.size()); y_ = 0; //vector<string> parameterNames; // the names of the parameters //vector<double> parameterValues; // the values of the parameters std::map<std::string, double> params; std::vector<std::string> inputNodes; // the indexes of the inputs HillGene src, tgt; Parameter *param; // 2 loops for one gene: both synthesis and degradation reactions // (we assume that reactions are listed *ordered* as we do in writeSBML()) //int counter = 0; for (unsigned int i=0; i < m->getNumReactions(); i++) { Reaction *re = m->getReaction(i); std::string id = re->getId(); std::stringstream ss; ss << i; //::logging::log::emit<Debug>() << id.c_str() << // ::logging::log::endl; tgt = nodes_.at(getIndexOfNode(getGeneReactantId(id))); //tgt->setLabel(getGeneReactantId(*re)); //SpeciesReference *rt = re->getReactant(0); //Node *tgt = new HillGene(); //tgt->setLabel(rt->getSpecies()); //ListOfSpeciesReferences *modifiers = re->getListOfModifiers(); for (unsigned int j=0; j < re->getNumModifiers(); j++) { ModifierSpeciesReference *md = re->getModifier(j); src = nodes_.at(getIndexOfNode(md->getSpecies())); inputNodes.push_back(src.getLabel()); // set output genes std::vector<std::string> outputs = src.getOutputGenes(); outputs.push_back(tgt.getLabel()); src.setOutputGenes(outputs); // The edge type is unknown for now, it is initialized later Edge *e = new Edge(&src, &tgt, "+-"); edges_.push_back(*e); //delete src; delete e; } KineticLaw *kl = re->getKineticLaw(); for(unsigned int j=0; j < kl->getNumParameters(); j++) { param = kl->getParameter(j); params[param->getId()] = param->getValue(); //char buf[256]; //sprintf(buf, "%s\t%f", param->getId().c_str(), param->getValue()); //::logging::log::emit<Info>() << buf << ::logging::log::endl; } //::logging::log::emit<Info>() << ::logging::log::dec << params.size() << // ::logging::log::endl; // in the second iteration for this gene if (i%2 == 1) { // set parameters in gene //tgt.initialization(params, inputNodes); nodes_.at(getIndexOfNode(getGeneReactantId(id))).initialization(params, inputNodes);; //char buf[256]; //sprintf(buf, "%f", params["k_1"]); //::logging::log::emit<Info>() << buf << ::logging::log::endl; inputNodes.clear(); // don't clear because the reference was copied to the gene //parameterNames.clear(); // reset (they were not copied) //parameterValues.clear(); params.clear(); } //counter++; } //setEdgeTypesAccordingToDynamicalModel(); //signed_ = true; //delete document; //delete n; //delete e; }