END_TEST
START_TEST (test_WriteL3SBML_Reaction_compartment)
{
const char* expected = "<reaction id=\"r\" reversible=\"false\""
" fast=\"true\" compartment=\"c\"/>";
const char* expected1 = "<reaction id=\"r\" reversible=\"false\""
" fast=\"true\"/>";
Reaction *r = D->createModel()->createReaction();
r->setId("r");
r->setReversible(false);
r->setFast(true);
r->setCompartment("c");
char* sbml = r->toSBML();
fail_unless( equals(expected, sbml) );
safe_free(sbml);
r->unsetCompartment();
sbml = r->toSBML();
fail_unless( equals(expected1, sbml) );
safe_free(sbml);
}
END_TEST
START_TEST (test_WriteL3SBML_Reaction_full)
{
const char* expected =
"<reaction id=\"v1\" reversible=\"true\" fast=\"false\">\n"
" <listOfReactants>\n"
" <speciesReference species=\"x0\"/>\n"
" </listOfReactants>\n"
" <listOfProducts>\n"
" <speciesReference species=\"s1\"/>\n"
" </listOfProducts>\n"
" <listOfModifiers>\n"
" <modifierSpeciesReference species=\"m1\"/>\n"
" </listOfModifiers>\n"
" <kineticLaw>\n"
" <math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n"
" <apply>\n"
" <divide/>\n"
" <apply>\n"
" <times/>\n"
" <ci> vm </ci>\n"
" <ci> s1 </ci>\n"
" </apply>\n"
" <apply>\n"
" <plus/>\n"
" <ci> km </ci>\n"
" <ci> s1 </ci>\n"
" </apply>\n"
" </apply>\n"
" </math>\n"
" </kineticLaw>\n"
"</reaction>";
D->createModel();
Reaction* r = D->getModel()->createReaction();
r->setId("v1");
r->setReversible(true);
r->setFast(false);
r->createReactant()->setSpecies("x0");
r->createProduct ()->setSpecies("s1");
r->createModifier()->setSpecies("m1");
r->createKineticLaw()->setFormula("(vm * s1)/(km + s1)");
char* sbml = r->toSBML();
fail_unless( equals(expected, sbml) );
safe_free(sbml);
}
END_TEST
START_TEST ( test_Reaction )
{
Reaction* r = new Reaction(2, 4);
fail_unless (!(r->hasRequiredAttributes()));
r->setId("r");
fail_unless (r->hasRequiredAttributes());
delete r;
}
END_TEST
START_TEST ( test_Reaction_parent_add )
{
Reaction *ia = new Reaction(2, 4);
Model *m = new Model(2, 4);
ia->setId("k");
m->addReaction(ia);
delete ia;
ListOf *lo = m->getListOfReactions();
fail_unless(lo == m->getReaction(0)->getParentSBMLObject());
fail_unless(m == lo->getParentSBMLObject());
}
/**
*
* 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;
}
/**
*
* 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;
}
/**
*
* 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;
}
LIBSBML_CPP_NAMESPACE_USE
int main(int argc,char** argv)
{
SBMLNamespaces sbmlns(3,1,"fbc",1);
// create the document
SBMLDocument *document = new SBMLDocument(&sbmlns);
document->setPackageRequired("fbc", false);
// create the Model
Model* model=document->createModel();
// create the Compartment
Compartment* compartment = model->createCompartment();
compartment->setId("compartment");
compartment->setConstant(true);
compartment->setSize(1);
// create the Species
Species* species = model->createSpecies();
species->setId("Node1");
species->setCompartment("compartment");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("Node2");
species->setCompartment("compartment");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("Node3");
species->setCompartment("compartment");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("Node4");
species->setCompartment("compartment");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("Node5");
species->setCompartment("compartment");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("Node6");
species->setCompartment("compartment");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("Node7");
species->setCompartment("compartment");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("Node8");
species->setCompartment("compartment");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("Node0");
species->setCompartment("compartment");
species->setBoundaryCondition(true);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("Node9");
species->setCompartment("compartment");
species->setBoundaryCondition(true);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
Reaction* reaction = model->createReaction();
reaction->setId("J0");
reaction->setReversible(false);
reaction->setFast(false);
SpeciesReference* reactant = reaction->createReactant();
reactant->setSpecies("Node0");
reactant->setStoichiometry(1);
reactant->setConstant(true);
SpeciesReference* product = reaction->createProduct();
product->setSpecies("Node1");
product->setStoichiometry(1);
product->setConstant(true);
reaction = model->createReaction();
reaction->setId("J1");
reaction->setReversible(false);
reaction->setFast(false);
reactant = reaction->createReactant();
reactant->setSpecies("Node1");
reactant->setStoichiometry(1);
reactant->setConstant(true);
product = reaction->createProduct();
product->setSpecies("Node2");
product->setStoichiometry(1);
product->setConstant(true);
reaction = model->createReaction();
reaction->setId("J2");
reaction->setReversible(false);
reaction->setFast(false);
reactant = reaction->createReactant();
reactant->setSpecies("Node2");
reactant->setStoichiometry(1);
reactant->setConstant(true);
product = reaction->createProduct();
product->setSpecies("Node3");
product->setStoichiometry(1);
product->setConstant(true);
reaction = model->createReaction();
reaction->setId("J3");
reaction->setReversible(false);
reaction->setFast(false);
reactant = reaction->createReactant();
reactant->setSpecies("Node1");
reactant->setStoichiometry(1);
reactant->setConstant(true);
product = reaction->createProduct();
product->setSpecies("Node4");
product->setStoichiometry(1);
product->setConstant(true);
reaction = model->createReaction();
reaction->setId("J4");
reaction->setReversible(false);
reaction->setFast(false);
reactant = reaction->createReactant();
reactant->setSpecies("Node4");
reactant->setStoichiometry(1);
reactant->setConstant(true);
product = reaction->createProduct();
product->setSpecies("Node3");
product->setStoichiometry(1);
product->setConstant(true);
reaction = model->createReaction();
reaction->setId("J5");
reaction->setReversible(false);
reaction->setFast(false);
reactant = reaction->createReactant();
reactant->setSpecies("Node3");
reactant->setStoichiometry(1);
reactant->setConstant(true);
product = reaction->createProduct();
product->setSpecies("Node5");
product->setStoichiometry(1);
product->setConstant(true);
reaction = model->createReaction();
reaction->setId("J6");
reaction->setReversible(false);
reaction->setFast(false);
reactant = reaction->createReactant();
reactant->setSpecies("Node5");
reactant->setStoichiometry(1);
reactant->setConstant(true);
product = reaction->createProduct();
product->setSpecies("Node6");
product->setStoichiometry(1);
product->setConstant(true);
reaction = model->createReaction();
reaction->setId("J7");
reaction->setReversible(false);
reaction->setFast(false);
reactant = reaction->createReactant();
reactant->setSpecies("Node6");
reactant->setStoichiometry(1);
reactant->setConstant(true);
product = reaction->createProduct();
product->setSpecies("Node7");
product->setStoichiometry(1);
product->setConstant(true);
reaction = model->createReaction();
reaction->setId("J8");
reaction->setReversible(false);
reaction->setFast(false);
reactant = reaction->createReactant();
reactant->setSpecies("Node5");
reactant->setStoichiometry(1);
reactant->setConstant(true);
product = reaction->createProduct();
product->setSpecies("Node8");
product->setStoichiometry(1);
product->setConstant(true);
reaction = model->createReaction();
reaction->setId("J9");
reaction->setReversible(false);
reaction->setFast(false);
reactant = reaction->createReactant();
reactant->setSpecies("Node8");
reactant->setStoichiometry(1);
reactant->setConstant(true);
product = reaction->createProduct();
product->setSpecies("Node7");
product->setStoichiometry(1);
product->setConstant(true);
reaction = model->createReaction();
reaction->setId("J10");
reaction->setReversible(false);
reaction->setFast(false);
reactant = reaction->createReactant();
reactant->setSpecies("Node7");
reactant->setStoichiometry(1);
reactant->setConstant(true);
product = reaction->createProduct();
product->setSpecies("Node9");
product->setStoichiometry(1);
product->setConstant(true);
//
// Get a FbcModelPlugin object plugged in the model object.
//
// The type of the returned value of SBase::getPlugin() function is
// SBasePlugin*, and thus the value needs to be casted for the
// corresponding derived class.
//
FbcModelPlugin* mplugin
= static_cast<FbcModelPlugin*>(model->getPlugin("fbc"));
FluxBound* bound= mplugin->createFluxBound();
bound->setId("bound1");
bound->setReaction("J0");
bound->setOperation("equal");
bound->setValue(10);
Objective* objective = mplugin->createObjective();
objective->setId("obj1");
objective->setType("maximize");
// mark obj1 as active objective
mplugin->setActiveObjectiveId("obj1");
FluxObjective* fluxObjective = objective->createFluxObjective();
fluxObjective->setReaction("J8");
fluxObjective->setCoefficient(1);
writeSBML(document,"fbc_example1.xml");
delete document;
}
LIBSBML_CPP_NAMESPACE_USE
int main(int argc,char** argv)
{
DynPkgNamespaces sbmlns;
// create the document
SBMLDocument *document = new SBMLDocument(&sbmlns);
document->setPackageRequired("dyn", true);
// create the Model
Model* model=document->createModel();
model->setId("singleCell");
// create the Compartment
Compartment* compartment = model->createCompartment();
compartment->setId("Extracellular");
compartment->setConstant(true);
compartment->setSize(8000000);
compartment->setSpatialDimensions(3.0);
compartment = model->createCompartment();
compartment->setId("PlasmaMembrane");
compartment->setConstant(true);
compartment->setSize(314);
compartment->setSpatialDimensions(2.0);
compartment = model->createCompartment();
compartment->setId("Cytosol");
compartment->setConstant(true);
compartment->setSize(523);
compartment->setSpatialDimensions(3.0);
// create the Species
Species* species = model->createSpecies();
species->setId("C_EC");
species->setCompartment("Extracellular");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("RTR_M");
species->setCompartment("PlasmaMembrane");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("RCC_M");
species->setCompartment("PlasmaMembrane");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("A_C");
species->setCompartment("Cytosol");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("AA_C");
species->setCompartment("Cytosol");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("T");
species->setCompartment("Cytosol");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setInitialConcentration(10);
species->setHasOnlySubstanceUnits(false);
species = model->createSpecies();
species->setId("S");
species->setCompartment("Cytosol");
species->setBoundaryCondition(false);
species->setConstant(false);
species->setInitialConcentration(5);
species->setHasOnlySubstanceUnits(false);
// create the Reactions
Reaction* reaction = model->createReaction();
reaction->setId("r1");
reaction->setReversible(true);
reaction->setFast(false);
reaction->setCompartment("Extracellular");
SpeciesReference* reactant = reaction->createReactant();
reactant->setSpecies("RTR_M");
reactant->setStoichiometry(1);
reactant->setConstant(true);
reactant = reaction->createReactant();
reactant->setSpecies("C_EC");
reactant->setStoichiometry(1);
reactant->setConstant(true);
SpeciesReference* product = reaction->createProduct();
product->setSpecies("RCC_M");
product->setStoichiometry(1);
product->setConstant(true);
reaction = model->createReaction();
reaction->setId("r2");
reaction->setReversible(true);
reaction->setFast(false);
reaction->setCompartment("Cytosol");
reactant = reaction->createReactant();
reactant->setSpecies("A_C");
reactant->setStoichiometry(1);
reactant->setConstant(true);
product = reaction->createProduct();
product->setSpecies("AA_C");
product->setStoichiometry(1);
product->setConstant(true);
SimpleSpeciesReference* modifier = reaction->createModifier();
modifier->setSpecies("RCC_M");
// Create Event
Event* event = model->createEvent();
event->setUseValuesFromTriggerTime(true);
Trigger* trigger = event->createTrigger();
trigger->setInitialValue(false);
trigger->setPersistent(true);
trigger->setMath(SBML_parseFormula("lt(AA_C, T)"));
//
// Get a DynEventPlugin object plugged in the event object.
//
// The type of the returned value of SBase::getPlugin() function is
// SBasePlugin*, and thus the value needs to be casted for the
// corresponding derived class.
//
DynEventPlugin* eplugin
= static_cast<DynEventPlugin*>(event->getPlugin("dyn"));
eplugin->setApplyToAll(true);
eplugin->setCboTerm("http://cbo.biocomplexity.indiana.edu/svn/cbo/trunk/CBO_1_0.owl#CellDeath");
event = model->createEvent();
event->setUseValuesFromTriggerTime(true);
trigger = event->createTrigger();
trigger->setInitialValue(false);
trigger->setPersistent(true);
trigger->setMath(SBML_parseFormula("lt(AA_C, S)"));
eplugin = static_cast<DynEventPlugin*>(event->getPlugin("dyn"));
eplugin->setApplyToAll(true);
eplugin->setCboTerm("http://cbo.biocomplexity.indiana.edu/svn/cbo/trunk/CBO_1_0.owl#CellDevision");
document->checkConsistency();
if (document->getNumErrors(LIBSBML_SEV_ERROR) > 0)
document->printErrors();
writeSBML(document,"dyn_example1.xml");
delete document;
}
void writeSpatialSBML() {
/*
// SBMLNamespaces of SBML Level 3 Version 1 with Spatial Version 1
SBMLNamespaces sbmlns(3,1,"spatial",1);
// SpatialPkgNamespaces spatialns(3,1,1);
// add Required Elements package namespace
sbmlns.addPkgNamespace("req", 1);
*/
// SBMLNamespaces of SBML Level 3 Version 1 with 'req' Version 1
// then add 'spatial' package namespace.
RequiredElementsPkgNamespaces sbmlns(3,1,1);
sbmlns.addPkgNamespace("spatial",1);
// create the L3V1 document with spatial package
SBMLDocument document(&sbmlns);
// set 'required' attribute on document for 'spatial' and 'req' packages to 'T'??
SBMLDocumentPlugin* dplugin;
dplugin = static_cast<SBMLDocumentPlugin*>(document.getPlugin("spatial"));
dplugin->setRequired(true);
dplugin = static_cast<SBMLDocumentPlugin*>(document.getPlugin("req"));
dplugin->setRequired(true);
// create the Model
Model *model = document.createModel();
model-> setId("trial_spatial");
model-> setName("trial_spatial");
// create the Compartments
Compartment* compartment = model->createCompartment();
compartment->setId("cytosol");
compartment->setConstant(true);
// create the Species
Species* species1 = model->createSpecies();
species1->setId("ATPc");
species1->setCompartment("cytosol");
species1->setInitialConcentration(1.0);
species1->setHasOnlySubstanceUnits(false);
species1->setBoundaryCondition(false);
species1->setConstant(false);
// spatial package extension to species.
// required elements package extention to parameter
RequiredElementsSBasePlugin* reqplugin;
reqplugin = static_cast<RequiredElementsSBasePlugin*>(species1->getPlugin("req"));
reqplugin->setMathOverridden("spatial");
reqplugin->setCoreHasAlternateMath(true);
SpatialSpeciesRxnPlugin* srplugin;
srplugin = static_cast<SpatialSpeciesRxnPlugin*>(species1->getPlugin("spatial"));
srplugin->setIsSpatial(true);
// add parameter for diff coeff of species1
Parameter* paramSp = model->createParameter();
paramSp->setId(species1->getId()+"_dc");
paramSp->setValue(1.0);
// required elements package extention to parameter
reqplugin = static_cast<RequiredElementsSBasePlugin*>(paramSp->getPlugin("req"));
reqplugin->setMathOverridden("spatial");
reqplugin->setCoreHasAlternateMath(true);
// spatial package extension to parameter.
SpatialParameterPlugin* pplugin;
pplugin = static_cast<SpatialParameterPlugin*>(paramSp->getPlugin("spatial"));
DiffusionCoefficient* diffCoeff = pplugin->getDiffusionCoefficient();
diffCoeff->setVariable(species1->getId());
diffCoeff->setCoordinateIndex(0);
// add parameter for adv coeff of species1
paramSp = model->createParameter();
paramSp->setId(species1->getId()+"_ac");
paramSp->setValue(1.5);
// required elements package extention to parameter
reqplugin = static_cast<RequiredElementsSBasePlugin*>(paramSp->getPlugin("req"));
reqplugin->setMathOverridden("spatial");
reqplugin->setCoreHasAlternateMath(true);
// spatial package extension to parameter.
pplugin = static_cast<SpatialParameterPlugin*>(paramSp->getPlugin("spatial"));
AdvectionCoefficient* advCoeff = pplugin->getAdvectionCoefficient();
advCoeff->setVariable(species1->getId());
advCoeff->setCoordinateIndex(0);
// add parameter for boundary condition of species1
paramSp = model->createParameter();
paramSp->setId(species1->getId()+"_bc");
paramSp->setValue(2.0);
// required elements package extention to parameter
reqplugin = static_cast<RequiredElementsSBasePlugin*>(paramSp->getPlugin("req"));
reqplugin->setMathOverridden("spatial");
reqplugin->setCoreHasAlternateMath(true);
// spatial package extension to parameter.
pplugin = static_cast<SpatialParameterPlugin*>(paramSp->getPlugin("spatial"));
BoundaryCondition* boundCon = pplugin->getBoundaryCondition();
boundCon->setVariable(species1->getId());
boundCon->setType("value");
boundCon->setCoordinateBoundary("Xmin");
Species* species2 = model->createSpecies();
species2->setId("ADPc");
species2->setCompartment("cytosol");
species2->setInitialConcentration(1);
species2->setHasOnlySubstanceUnits(false);
species2->setBoundaryCondition(false);
species2->setConstant(false);
srplugin = static_cast<SpatialSpeciesRxnPlugin*>(species2->getPlugin("spatial"));
srplugin->setIsSpatial(true);
/* // create a parameter
Parameter* param = model->createParameter();
param->setId("k_1");
param->setValue(0.24);
param->setConstant(true);
// create an assignment rule
AssignmentRule* assignRule = model->createAssignmentRule();
assignRule->setVariable(species1->getId());
assignRule->setFormula("species2+k_1");
*/
/*
reqplugin = static_cast<RequiredElementsSBasePlugin*>(assignRule->getPlugin("req"));
reqplugin->setMathOverridden("spatial");
reqplugin->setCoreHasAlternateMath(false);
*/
Reaction* reaction = model->createReaction();
reaction->setId("rxn1");
reaction->setReversible(false);
reaction->setFast(false);
reaction->setCompartment("cytosol");
srplugin = static_cast<SpatialSpeciesRxnPlugin*>(reaction->getPlugin("spatial"));
srplugin->setIsLocal(true);
//
// Get a SpatialModelPlugin object plugged in the model object.
//
// The type of the returned value of SBase::getPlugin() function is
// SBasePlugin*, and thus the value needs to be casted for the
// corresponding derived class.
//
SpatialModelPlugin* mplugin;
mplugin = static_cast<SpatialModelPlugin*>(model->getPlugin("spatial"));
//
// Creates a geometry object via SpatialModelPlugin object.
//
Geometry* geometry = mplugin->getGeometry();
geometry->setCoordinateSystem("XYZ");
CoordinateComponent* coordX = geometry->createCoordinateComponent();
coordX->setSpatialId("coordComp1");
coordX->setComponentType("cartesian");
coordX->setSbmlUnit("umeter");
coordX->setIndex(1);
BoundaryMin* minX = coordX->createBoundaryMin();
minX->setSpatialId("Xmin");
minX->setValue(0.0);
BoundaryMax* maxX = coordX->createBoundaryMax();
maxX->setSpatialId("Xmax");
maxX->setValue(10.0);
Parameter* paramX = model->createParameter();
paramX->setId("x");
paramX->setValue(8.0);
// required elements package extention to parameter
// RequiredElementsSBasePlugin* reqplugin;
reqplugin = static_cast<RequiredElementsSBasePlugin*>(paramX->getPlugin("req"));
reqplugin->setMathOverridden("spatial");
reqplugin->setCoreHasAlternateMath(true);
// spatial package extension to parameter.
// SpatialParameterPlugin* pplugin;
pplugin = static_cast<SpatialParameterPlugin*>(paramX->getPlugin("spatial"));
SpatialSymbolReference* spSymRef = pplugin->getSpatialSymbolReference();
spSymRef->setSpatialId(coordX->getSpatialId());
spSymRef->setType(coordX->getElementName());
DomainType* domainType = geometry->createDomainType();
domainType->setSpatialId("dtype1");
domainType->setSpatialDimensions(3);
// Spatial package extension to compartment (mapping compartment with domainType)
// required elements package extention to compartment
reqplugin = static_cast<RequiredElementsSBasePlugin*>(compartment->getPlugin("req"));
reqplugin->setMathOverridden("spatial");
reqplugin->setCoreHasAlternateMath(true);
SpatialCompartmentPlugin* cplugin;
cplugin = static_cast<SpatialCompartmentPlugin*>(compartment->getPlugin("spatial"));
CompartmentMapping* compMapping = cplugin->getCompartmentMapping();
compMapping->setSpatialId("compMap1");
compMapping->setCompartment(compartment->getId());
compMapping->setDomainType(domainType->getSpatialId());
compMapping->setUnitSize(1.0);
Domain* domain = geometry->createDomain();
domain->setSpatialId("domain1");
domain->setDomainType("dtype1");
domain->setImplicit(false);
domain->setShapeId("circle");
InteriorPoint* internalPt1 = domain->createInteriorPoint();
internalPt1->setCoord1(1.0);
domain = geometry->createDomain();
domain->setSpatialId("domain2");
domain->setDomainType("dtype1");
domain->setImplicit(false);
domain->setShapeId("square");
InteriorPoint* internalPt2 = domain->createInteriorPoint();
internalPt2->setCoord1(5.0);
AdjacentDomains* adjDomain = geometry->createAdjacentDomains();
adjDomain->setSpatialId("adjDomain1");
adjDomain->setDomain1("domain1");
adjDomain->setDomain2("domain2");
AnalyticGeometry* analyticGeom = geometry->createAnalyticGeometry();
analyticGeom->setSpatialId("analyticGeom1");
AnalyticVolume* analyticVol = analyticGeom->createAnalyticVolume();
analyticVol->setSpatialId("analyticVol1");
analyticVol->setDomainType(domainType->getSpatialId());
analyticVol->setFunctionType("squareFn");
analyticVol->setOrdinal(1);
const char* mathMLStr = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\"><apply xmlns=\"\"><plus /><apply><times /><ci>x</ci><ci>x</ci></apply><apply><minus /><cn>1.0</cn></apply></apply></math>";
ASTNode* mathNode = readMathMLFromString(mathMLStr);
analyticVol->setMath(mathNode);
SampledFieldGeometry* sfg = geometry->createSampledFieldGeometry();
sfg->setSpatialId("sampledFieldGeom1");
SampledField* sampledField = sfg->createSampledField();
sampledField->setSpatialId("sampledField1");
sampledField->setNumSamples1(4);
sampledField->setNumSamples2(4);
sampledField->setNumSamples3(2);
sampledField->setDataType("double");
sampledField->setInterpolationType("linear");
sampledField->setEncoding("encoding1");
//int samples[5] = {1, 2, 3, 4, 5};
int samples[32] = {
// z=0
0,0,0,0,
0,1,1,0,
0,1,1,0,
0,0,0,0,
// z=1
0,0,0,0,
0,1,1,0,
0,1,1,0,
0,0,0,0
};
ImageData* id = sampledField->createImageData();
id->setDataType("compressed");
id->setSamples(samples, 32);
SampledVolume* sampledVol = sfg->createSampledVolume();
sampledVol->setSpatialId("sv_1");
sampledVol->setDomainType(domainType->getSpatialId());
sampledVol->setSampledValue(128.0);
sampledVol->setMinValue(0.0);
sampledVol->setMaxValue(255.0);
ParametricGeometry* pg = geometry->createParametricGeometry();
pg->setSpatialId("parametricGeom1");
ParametricObject* paramObj = pg->createParametricObject();
paramObj->setSpatialId("po_1");
paramObj->setDomain(domain->getSpatialId());
paramObj->setPolygonType("hexagon");
int ptIndices[5] = {1, 2, 3, 4, 5};
PolygonObject* po = paramObj->createPolygonObject();
po->setPointIndices(ptIndices, 5);
SpatialPoint* spPt = pg->createSpatialPoint();
spPt->setSpatialId("sp_1");
spPt->setDomain(domain->getSpatialId());
spPt->setCoord1(1);
spPt->setCoord2(2);
spPt->setCoord3(3);
CSGeometry* csg = geometry->createCSGeometry();
csg->setSpatialId("csGeom1");
CSGObject* csgObj = csg->createCSGObject();
csgObj->setSpatialId("csg_csgo_1");
csgObj->setDomainType(domainType->getSpatialId());
csgObj->setOrdinal(1);
CSGScale* scale = csgObj->createCSGScale();
scale->setScaleX(2.0);
scale->setScaleY(3.0);
scale->setScaleZ(4.0);
CSGPrimitive* prim1 = scale->createCSGPrimitive();
prim1->setPrimitiveType("SOLID_SPHERE");
csgObj = csg->createCSGObject();
csgObj->setSpatialId("csg_csgo_2");
csgObj->setDomainType(domainType->getSpatialId());
CSGSetOperator* setUnion = csgObj->createCSGSetOperator();
setUnion->setOperationType("UNION");
/* CSGPrimitive* prim = setUnion->createCSGPrimitive();
prim->setPrimitiveType("SOLID_SPHERE");
CSGPrimitive* prim2 = setUnion->createCSGPrimitive();
prim2->setPrimitiveType("SOLID_CONE");
*/
CSGPrimitive* prim2 = new CSGPrimitive(3,1,1);
prim2->setSpatialId("cone0");
prim2->setPrimitiveType("SOLID_CONE");
CSGTranslation* translatedCone = new CSGTranslation(3,1,1);
translatedCone->setSpatialId("translation0");
translatedCone->setTranslateX(2.0);
translatedCone->setTranslateY(2.0);
translatedCone->setTranslateZ(2.0);
translatedCone->setChild(prim2);
int n = setUnion->addCSGNodeChild(translatedCone);
CSGPrimitive* prim3 = new CSGPrimitive(3,1,1);
prim3->setSpatialId("sphere0");
prim3->setPrimitiveType("SOLID_SPHERE");
n = setUnion->addCSGNodeChild(prim3);
writeSBML(&document, "spatial_example0.xml");
}
/**
* 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;
}
END_TEST
START_TEST(test_FbcExtension_create_and_write_new_geneassociation
)
{
FbcPkgNamespaces *sbmlns = new FbcPkgNamespaces(3, 1, 2);
// create the document
SBMLDocument document(sbmlns);
document.setConsistencyChecks(LIBSBML_CAT_UNITS_CONSISTENCY, false);
document.setConsistencyChecks(LIBSBML_CAT_MODELING_PRACTICE, false);
// create the Model
Model* model = document.createModel();
// create the Compartment
Compartment* compartment = model->createCompartment();
compartment->setId("compartment");
compartment->setConstant(true);
compartment->setSize(1);
// create the Species
Species* species = model->createSpecies();
species->setId("Node1");
species->setCompartment("compartment");
species->setBoundaryCondition(false);
species = model->createSpecies();
species->setId("Node2");
species->setCompartment("compartment");
species->setBoundaryCondition(false);
Reaction* reaction = model->createReaction();
reaction->setId("J0");
reaction->setReversible(false);
SpeciesReference* reactant = reaction->createReactant();
reactant->setSpecies("Node0");
reactant->setStoichiometry(1);
SpeciesReference* product = reaction->createProduct();
product->setSpecies("Node1");
product->setStoichiometry(1);
// use fbc
FbcModelPlugin* mplugin = static_cast<FbcModelPlugin*>(model->getPlugin("fbc"));
fail_unless(mplugin != NULL);
FluxBound* bound = mplugin->createFluxBound();
bound->setId("bound1");
bound->setReaction("J0");
bound->setOperation("equal");
bound->setValue(10);
Objective* objective = mplugin->createObjective();
objective->setId("obj1");
objective->setType("maximize");
FluxObjective* fluxObjective = objective->createFluxObjective();
fluxObjective->setReaction("J0");
fluxObjective->setCoefficient(1);
FbcReactionPlugin* rplug = dynamic_cast<FbcReactionPlugin*>(reaction->getPlugin("fbc"));
fail_unless(rplug != NULL);
GeneProductAssociation * ga = rplug->createGeneProductAssociation();
ga->setId("ga1");
ga->setAssociation("MG_077 AND MG_321 AND MG_080 AND MG_078 AND MG_079");
fail_unless(ga->getAssociation() != NULL);
fail_unless(mplugin->getNumGeneProducts() == 5);
ga->setAssociation("MG_077 AND MG_321 AND MG_080 AND MG_078 AND MG_079");
fail_unless(ga->getAssociation() != NULL);
fail_unless(mplugin->getNumGeneProducts() == 5);
delete sbmlns;
}
END_TEST
START_TEST(test_FbcExtension_create_and_write_L3V1V1)
{
FbcPkgNamespaces *sbmlns = new FbcPkgNamespaces(3, 1, 1);
// create the document
SBMLDocument *document = new SBMLDocument(sbmlns);
delete sbmlns;
// create the Model
Model* model = document->createModel();
// create the Compartment
Compartment* compartment = model->createCompartment();
compartment->setId("compartment");
compartment->setConstant(true);
compartment->setSize(1);
// create the Species
Species* species = model->createSpecies();
species->setId("Node1");
species->setCompartment("compartment");
species->setBoundaryCondition(false);
species = model->createSpecies();
species->setId("Node2");
species->setCompartment("compartment");
species->setBoundaryCondition(false);
Reaction* reaction = model->createReaction();
reaction->setId("J0");
reaction->setReversible(false);
SpeciesReference* reactant = reaction->createReactant();
reactant->setSpecies("Node0");
reactant->setStoichiometry(1);
SpeciesReference* product = reaction->createProduct();
product->setSpecies("Node1");
product->setStoichiometry(1);
// use fbc
FbcModelPlugin* mplugin = static_cast<FbcModelPlugin*>(model->getPlugin("fbc"));
fail_unless(mplugin != NULL);
FluxBound* bound = mplugin->createFluxBound();
bound->setId("bound1");
bound->setReaction("J0");
bound->setOperation("equal");
bound->setValue(10);
Objective* objective = mplugin->createObjective();
objective->setId("obj1");
objective->setType("maximize");
FluxObjective* fluxObjective = objective->createFluxObjective();
fluxObjective->setReaction("J0");
fluxObjective->setCoefficient(1);
string s1 = writeSBMLToStdString(document);
// check clone()
SBMLDocument* document2 = document->clone();
string s2 = writeSBMLToStdString(document2);
fail_unless(s1 == s2);
// check operator=
Model m = *(document->getModel());
document2->setModel(&m);
s2 = writeSBMLToStdString(document2);
fail_unless(s1 == s2);
delete document2;
delete document;
}
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;
}
}
}
void writeSpatialSBML()
{
// SBMLNamespaces of SBML Level 3 Version 1 with 'req' Version 1
// then add 'spatial' package namespace.
SpatialPkgNamespaces sbmlns(3,1,1);
// create the L3V1 document with spatial package
SBMLDocument document(&sbmlns);
// set 'required' attribute on document for 'spatial' and 'req' packages to 'T'??
SBMLDocumentPlugin* dplugin;
dplugin = static_cast<SBMLDocumentPlugin*>(document.getPlugin("spatial"));
dplugin->setRequired(true);
// create the Model
Model *model = document.createModel();
model-> setId("trial_spatial");
model-> setName("trial_spatial");
// create the Compartments
Compartment* compartment = model->createCompartment();
compartment->setId("cytosol");
compartment->setConstant(true);
// create the Species
Species* species1 = model->createSpecies();
species1->setId("ATPc");
species1->setCompartment("cytosol");
species1->setInitialConcentration(1.0);
species1->setHasOnlySubstanceUnits(false);
species1->setBoundaryCondition(false);
species1->setConstant(false);
// spatial package extension to species.
SpatialSpeciesPlugin* srplugin;
srplugin = static_cast<SpatialSpeciesPlugin*>(species1->getPlugin("spatial"));
srplugin->setIsSpatial(true);
// add parameter for diff coeff of species1
Parameter* paramSp = model->createParameter();
paramSp->setId(species1->getId()+"_dc");
paramSp->setValue(1.0);
// spatial package extension to parameter.
SpatialParameterPlugin* pplugin;
pplugin = static_cast<SpatialParameterPlugin*>(paramSp->getPlugin("spatial"));
DiffusionCoefficient* diffCoeff = pplugin->createDiffusionCoefficient();
diffCoeff->setVariable(species1->getId());
diffCoeff->setType(SPATIAL_DIFFUSIONKIND_ANISOTROPIC);
CoordinateReference* coordRef = diffCoeff->createCoordinateReference();
coordRef->setCoordinate(SPATIAL_COORDINATEKIND_CARTESIAN_X);
// add parameter for adv coeff of species1
paramSp = model->createParameter();
paramSp->setId(species1->getId()+"_ac");
paramSp->setValue(1.5);
// spatial package extension to parameter.
pplugin = static_cast<SpatialParameterPlugin*>(paramSp->getPlugin("spatial"));
AdvectionCoefficient* advCoeff = pplugin->createAdvectionCoefficient();
advCoeff->setVariable(species1->getId());
advCoeff->setCoordinate(SPATIAL_COORDINATEKIND_CARTESIAN_X);
// add parameter for boundary condition of species1
paramSp = model->createParameter();
paramSp->setId(species1->getId()+"_bc");
paramSp->setValue(2.0);
// spatial package extension to parameter.
pplugin = static_cast<SpatialParameterPlugin*>(paramSp->getPlugin("spatial"));
BoundaryCondition* boundCon = pplugin->createBoundaryCondition();
boundCon->setVariable(species1->getId());
boundCon->setType(SPATIAL_BOUNDARYKIND_DIRICHLET);
boundCon->setCoordinateBoundary("Xmin");
Species* species2 = model->createSpecies();
species2->setId("ADPc");
species2->setCompartment("cytosol");
species2->setInitialConcentration(1);
species2->setHasOnlySubstanceUnits(false);
species2->setBoundaryCondition(false);
species2->setConstant(false);
srplugin = static_cast<SpatialSpeciesPlugin*>(species2->getPlugin("spatial"));
srplugin->setIsSpatial(true);
Reaction* reaction = model->createReaction();
reaction->setId("rxn1");
reaction->setReversible(false);
reaction->setFast(false);
reaction->setCompartment("cytosol");
SpatialReactionPlugin* rplugin = static_cast<SpatialReactionPlugin*>(reaction->getPlugin("spatial"));
rplugin->setIsLocal(true);
//
// Get a SpatialModelPlugin object plugged in the model object.
//
// The type of the returned value of SBase::getPlugin() function is
// SBasePlugin*, and thus the value needs to be casted for the
// corresponding derived class.
//
SpatialModelPlugin* mplugin;
mplugin = static_cast<SpatialModelPlugin*>(model->getPlugin("spatial"));
//
// Creates a geometry object via SpatialModelPlugin object.
//
Geometry* geometry = mplugin->createGeometry();
geometry->setCoordinateSystem(SPATIAL_GEOMETRYKIND_CARTESIAN);
CoordinateComponent* coordX = geometry->createCoordinateComponent();
coordX->setId("coordComp1");
coordX->setType(SPATIAL_COORDINATEKIND_CARTESIAN_X);
coordX->setUnit("umeter");
Boundary* minX = coordX->createBoundaryMin();
minX->setId("Xmin");
minX->setValue(0.0);
Boundary* maxX = coordX->createBoundaryMax();
maxX->setId("Xmax");
maxX->setValue(10.0);
Parameter* paramX = model->createParameter();
paramX->setId("x");
paramX->setValue(8.0);
// spatial package extension to parameter.
// SpatialParameterPlugin* pplugin;
pplugin = static_cast<SpatialParameterPlugin*>(paramX->getPlugin("spatial"));
SpatialSymbolReference* spSymRef = pplugin->createSpatialSymbolReference();
spSymRef->setSpatialRef(coordX->getId());
DomainType* domainType = geometry->createDomainType();
domainType->setId("dtype1");
domainType->setSpatialDimension(3);
// Spatial package extension to compartment (mapping compartment with domainType)
SpatialCompartmentPlugin* cplugin;
cplugin = static_cast<SpatialCompartmentPlugin*>(compartment->getPlugin("spatial"));
CompartmentMapping* compMapping = cplugin->createCompartmentMapping();
compMapping->setId("compMap1");
compMapping->setDomainType(domainType->getId());
compMapping->setUnitSize(1.0);
Domain* domain = geometry->createDomain();
domain->setId("domain1");
domain->setDomainType("dtype1");
InteriorPoint* internalPt1 = domain->createInteriorPoint();
internalPt1->setCoord1(1.0);
domain = geometry->createDomain();
domain->setId("domain2");
domain->setDomainType("dtype1");
InteriorPoint* internalPt2 = domain->createInteriorPoint();
internalPt2->setCoord1(5.0);
AdjacentDomains* adjDomain = geometry->createAdjacentDomains();
adjDomain->setId("adjDomain1");
adjDomain->setDomain1("domain1");
adjDomain->setDomain2("domain2");
AnalyticGeometry* analyticGeom = geometry->createAnalyticGeometry();
analyticGeom->setId("analyticGeom1");
AnalyticVolume* analyticVol = analyticGeom->createAnalyticVolume();
analyticVol->setId("analyticVol1");
analyticVol->setDomainType(domainType->getId());
analyticVol->setFunctionType(SPATIAL_FUNCTIONKIND_LAYERED);
analyticVol->setOrdinal(1);
const char* mathMLStr = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\"><apply xmlns=\"\"><plus /><apply><times /><ci>x</ci><ci>x</ci></apply><apply><minus /><cn>1.0</cn></apply></apply></math>";
ASTNode* mathNode = readMathMLFromString(mathMLStr);
analyticVol->setMath(mathNode);
SampledFieldGeometry* sfg = geometry->createSampledFieldGeometry();
sfg->setId("sampledFieldGeom1");
SampledField* sampledField = sfg->createSampledField();
sampledField->setId("sampledField1");
sampledField->setNumSamples1(4);
sampledField->setNumSamples2(4);
sampledField->setNumSamples3(2);
sampledField->setDataType("double");
sampledField->setInterpolationType("linear");
sampledField->setEncoding("encoding1");
//int samples[5] = {1, 2, 3, 4, 5};
int samples[32] = {
// z=0
0,0,0,0,
0,1,1,0,
0,1,1,0,
0,0,0,0,
// z=1
0,0,0,0,
0,1,1,0,
0,1,1,0,
0,0,0,0
};
ImageData* id = sampledField->createImageData();
id->setDataType("uint8");
id->setSamples(samples, 32);
SampledVolume* sampledVol = sfg->createSampledVolume();
sampledVol->setId("sv_1");
sampledVol->setDomainType(domainType->getId());
sampledVol->setSampledValue(128.0);
sampledVol->setMinValue(0.0);
sampledVol->setMaxValue(255.0);
writeSBML(&document, "spatial_example2.xml");
}
LIBSBML_CPP_NAMESPACE_USE
int main(int argc,char** argv)
{
DynPkgNamespaces sbmlns;
sbmlns.addPackageNamespace("comp", 1, "comp");
// create the document
SBMLDocument *document = new SBMLDocument(&sbmlns);
document->setPackageRequired("dyn", true);
document->setPackageRequired("comp", true);
// create the Model
Model* model=document->createModel();
model->setId("grid2x2");
// create the Compartment
Compartment* compartment = model->createCompartment();
compartment->setId("Loc1");
compartment->setConstant(false);
compartment->setSize(1);
compartment->setSpatialDimensions(2.0);
DynCompartmentPlugin* cplugin =
static_cast<DynCompartmentPlugin*>(compartment->getPlugin("dyn"));
SpatialComponent* component = cplugin->createSpatialComponent();
component->setSpatialIndex(DYN_SPATIALKIND_CARTESIANX);
component->setVariable("q1_X");
component = cplugin->createSpatialComponent();
component->setSpatialIndex(DYN_SPATIALKIND_CARTESIANY);
component->setVariable("q1_Y");
CompSBasePlugin* compPlugin =
static_cast<CompSBasePlugin*>(compartment->getPlugin("comp"));
ReplacedElement* relement = compPlugin->createReplacedElement();
relement->setIdRef("C");
relement->setSubmodelRef("GRID_1_1_cell");
compartment = model->createCompartment();
compartment->setId("Loc2");
compartment->setConstant(false);
compartment->setSize(1);
compartment->setSpatialDimensions(2.0);
cplugin =
static_cast<DynCompartmentPlugin*>(compartment->getPlugin("dyn"));
component = cplugin->createSpatialComponent();
component->setSpatialIndex(DYN_SPATIALKIND_CARTESIANX);
component->setVariable("q2_X");
component = cplugin->createSpatialComponent();
component->setSpatialIndex(DYN_SPATIALKIND_CARTESIANY);
component->setVariable("q2_Y");
compPlugin =
static_cast<CompSBasePlugin*>(compartment->getPlugin("comp"));
relement = compPlugin->createReplacedElement();
relement->setIdRef("C");
relement->setSubmodelRef("GRID_1_2_cell");
compartment = model->createCompartment();
compartment->setId("Loc3");
compartment->setConstant(false);
compartment->setSize(1);
compartment->setSpatialDimensions(2.0);
cplugin =
static_cast<DynCompartmentPlugin*>(compartment->getPlugin("dyn"));
component = cplugin->createSpatialComponent();
component->setSpatialIndex(DYN_SPATIALKIND_CARTESIANX);
component->setVariable("q3_X");
component = cplugin->createSpatialComponent();
component->setSpatialIndex(DYN_SPATIALKIND_CARTESIANY);
component->setVariable("q3_Y");
compPlugin =
static_cast<CompSBasePlugin*>(compartment->getPlugin("comp"));
relement = compPlugin->createReplacedElement();
relement->setIdRef("C");
relement->setSubmodelRef("GRID_2_1_cell");
compartment = model->createCompartment();
compartment->setId("Loc4");
compartment->setConstant(false);
compartment->setSize(1);
compartment->setSpatialDimensions(2.0);
cplugin =
static_cast<DynCompartmentPlugin*>(compartment->getPlugin("dyn"));
component = cplugin->createSpatialComponent();
component->setSpatialIndex(DYN_SPATIALKIND_CARTESIANX);
component->setVariable("q4_X");
component = cplugin->createSpatialComponent();
component->setSpatialIndex(DYN_SPATIALKIND_CARTESIANY);
component->setVariable("q4_Y");
compPlugin =
static_cast<CompSBasePlugin*>(compartment->getPlugin("comp"));
relement = compPlugin->createReplacedElement();
relement->setIdRef("C");
relement->setSubmodelRef("GRID_2_2_cell");
// create Parameters
Parameter* param = model->createParameter();
param->initDefaults();
param->setId("q1_X");
param->setValue(1);
param = model->createParameter();
param->initDefaults();
param->setId("q1_Y");
param->setValue(1);
param = model->createParameter();
param->initDefaults();
param->setId("q2_X");
param->setValue(2);
param = model->createParameter();
param->initDefaults();
param->setId("q2_Y");
param->setValue(1);
param = model->createParameter();
param->initDefaults();
param->setId("q3_X");
param->setValue(1);
param = model->createParameter();
param->initDefaults();
param->setId("q3_Y");
param->setValue(2);
param = model->createParameter();
param->initDefaults();
param->setId("q4_X");
param->setValue(2);
param = model->createParameter();
param->initDefaults();
param->setId("q4_Y");
param->setValue(2);
// create SubModels
CompModelPlugin* mplugin =
static_cast<CompModelPlugin*>(model->getPlugin("comp"));
Submodel* submodel = mplugin->createSubmodel();
submodel->setId("GRID_1_1_cell");
submodel->setModelRef("Cell");
submodel = mplugin->createSubmodel();
submodel->setId("GRID_1_2_cell");
submodel->setModelRef("Cell");
submodel = mplugin->createSubmodel();
submodel->setId("GRID_2_1_cell");
submodel->setModelRef("Cell");
submodel = mplugin->createSubmodel();
submodel->setId("GRID_2_2_cell");
submodel->setModelRef("Cell");
// create the ModelDefinition
CompSBMLDocumentPlugin* dplugin =
static_cast<CompSBMLDocumentPlugin*>(document->getPlugin("comp"));
ModelDefinition* mdef = dplugin->createModelDefinition();
mdef->setId("Cell");
compartment = mdef->createCompartment();
compartment->initDefaults();
compartment->setId("C");
compartment->setSpatialDimensions(2.0);
compartment->setSize(1.0);
Species* species = mdef->createSpecies();
species->setId("R");
species->setCompartment("C");
species->setHasOnlySubstanceUnits(false);
species->setBoundaryCondition(false);
species->setConstant(false);
species = mdef->createSpecies();
species->setId("S");
species->setCompartment("C");
species->setHasOnlySubstanceUnits(false);
species->setBoundaryCondition(false);
species->setConstant(false);
Reaction* reaction = mdef->createReaction();
reaction->setId("Degradation_R");
reaction->setReversible(false);
reaction->setFast(false);
reaction->setCompartment("C");
SpeciesReference* reactant = reaction->createReactant();
reactant->setSpecies("R");
reactant->setStoichiometry(1);
reactant->setConstant(true);
reaction = mdef->createReaction();
reaction->setId("Degradation_S");
reaction->setReversible(false);
reaction->setFast(false);
reaction->setCompartment("C");
reactant = reaction->createReactant();
reactant->setSpecies("S");
reactant->setStoichiometry(1);
reactant->setConstant(true);
document->checkConsistency();
Event* event = mdef->createEvent();
event->setId("event0");
event->setUseValuesFromTriggerTime(false);
DynEventPlugin* eplugin =
static_cast<DynEventPlugin*>(event->getPlugin("dyn"));
eplugin->setApplyToAll(true);
eplugin->setCboTerm("http://cbo.biocomplexity.indiana.edu/svn/cbo/trunk/CBO_1_0.owl#CellDivision");
Trigger* trigger = event->createTrigger();
trigger->setInitialValue(false);
trigger->setPersistent(false);
trigger->setMath(SBML_parseFormula("true"));
if (document->getNumErrors(LIBSBML_SEV_ERROR) > 0)
document->printErrors();
writeSBML(document,"dyn_example2.xml");
delete document;
}