/*
* Subclasses should override this method to write out their contained
* SBML objects as XML elements. Be sure to call your parents
* implementation of this method as well.
*/
void
SpeciesReference::writeElements (XMLOutputStream& stream) const
{
if ( mNotes != NULL ) stream << *mNotes;
SpeciesReference * sr = const_cast <SpeciesReference *> (this);
sr->syncAnnotation();
if ( mAnnotation != NULL ) stream << *mAnnotation;
if (getLevel() == 2)
{
if (mStoichiometryMath || mDenominator != 1)
{
if (mStoichiometryMath != NULL)
{
mStoichiometryMath->write(stream);
}
else
{
ASTNode node;
node.setValue(static_cast<long>(mStoichiometry), mDenominator);
stream.startElement("stoichiometryMath");
writeMathML(&node, stream);
stream.endElement("stoichiometryMath");
}
}
}
//
// (EXTENSION)
//
SBase::writeExtensionElements(stream);
}
// #######################################################################
SpeciesReference* SBML_formatter::species2SpeciesReference(const Species* species, const Reaction* rxn, string addToSpeciesID){
string value = species->getId();
SpeciesReference* SR = new SpeciesReference(species->getLevel(), species->getVersion());
value = species->getId();
if (addToSpeciesID != ""){
// sets the species name, as
value.append(addToSpeciesID);
}
SR->setSpecies(value);
SR->setStoichiometry(1);
SR->setId((value.append("_ref_")).append(dtostr(unique)));
value.clear();
value.append(species->getId());
SR->setName((value.append("_in_rxn_")).append(rxn->getId()));
// unique is a static variable which allows anything that needs a modelwide unique value to get
// one;
unique++;
return SR;
}
END_TEST
START_TEST ( test_Reaction_parent_NULL )
{
SBMLDocument *d = new SBMLDocument();
Model *m = d->createModel();
Reaction *c = m->createReaction();
SpeciesReference *sr = c->createReactant();
KineticLaw *kl = c->createKineticLaw();
fail_unless(c->getAncestorOfType(SBML_MODEL) == m);
fail_unless (c->getSBMLDocument() == d);
fail_unless(sr->getAncestorOfType(SBML_REACTION) == c);
fail_unless(kl->getAncestorOfType(SBML_REACTION) == c);
Reaction *c1 = c->clone();
delete d;
fail_unless(c1->getAncestorOfType(SBML_MODEL) == NULL);
fail_unless(c1->getParentSBMLObject() == NULL);
fail_unless (c1->getSBMLDocument() == NULL);
SpeciesReference *sr1 = c1->getReactant(0);
fail_unless(sr1->getAncestorOfType(SBML_MODEL) == NULL);
fail_unless(sr1->getAncestorOfType(SBML_REACTION) == c1);
fail_unless (sr1->getSBMLDocument() == NULL);
fail_unless(c1->getKineticLaw()->getAncestorOfType(SBML_MODEL) == NULL);
fail_unless(c1->getKineticLaw()->getAncestorOfType(SBML_REACTION) == c1);
fail_unless (c1->getKineticLaw()->getSBMLDocument() == NULL);
delete c1;
}
int StoichiometryMath::removeFromParentAndDelete()
{
SBase* parent = getParentSBMLObject();
if (parent==NULL) return LIBSBML_OPERATION_FAILED;
SpeciesReference* parentSR = static_cast<SpeciesReference*>(parent);
if (parentSR == NULL) return LIBSBML_OPERATION_FAILED;
return parentSR->unsetStoichiometryMath();
}
bool variesIn(string id, ListOfSpeciesReferences* srs, const map<string, vector<double> >& results)
{
if (variesIn(id, results)) return true;
for (unsigned long sr=0; sr<srs->size(); sr++) {
SpeciesReference* spref = static_cast<SpeciesReference*>(srs->get(sr));
if (spref->getSpecies() == id) return true;
}
return false;
}
END_TEST
START_TEST ( test_SpeciesReference )
{
SpeciesReference* sr = new SpeciesReference(2, 4);
fail_unless (sr->hasRequiredElements());
delete sr;
}
END_TEST
START_TEST ( test_SpeciesReference_Reactant_parent_create )
{
Reaction *r = new Reaction(2, 4);
SpeciesReference *sr = r->createReactant();
ListOf *lo = r->getListOfReactants();
fail_unless(lo == r->getReactant(0)->getParentSBMLObject());
fail_unless(lo == sr->getParentSBMLObject());
fail_unless(r == lo->getParentSBMLObject());
}
END_TEST
START_TEST ( test_SpeciesReference )
{
SpeciesReference* sr = new SpeciesReference(2, 4);
fail_unless (!(sr->hasRequiredAttributes()));
sr->setSpecies("sr");
fail_unless (sr->hasRequiredAttributes());
delete sr;
}
END_TEST
START_TEST ( test_SpeciesReference_Product_parent_create_model )
{
Model *m = new Model(2, 4);
Reaction *r = m->createReaction();
SpeciesReference *sr = m->createProduct();
ListOf *lo = r->getListOfProducts();
fail_unless(lo == r->getProduct(0)->getParentSBMLObject());
fail_unless(lo == sr->getParentSBMLObject());
fail_unless(r == lo->getParentSBMLObject());
}
void
createParameterAsRateRule(Model &m, SpeciesReference &sr, Rule &rr,
unsigned int idCount)
{
char newid[15];
std::string id;
// create parameter as variable of rate rule
// and use stoichiometryMath to point to this
sprintf(newid, "parameterId_%u", idCount);
id.assign(newid);
Parameter *p = m.createParameter();
p->setId(id);
p->setConstant(false);
rr.setVariable(id);
StoichiometryMath *sm = sr.createStoichiometryMath();
if (sm != NULL)
{
ASTNode *ast = SBML_parseFormula(id.c_str());
sm->setMath(ast);
}
}
END_TEST
START_TEST ( test_StoichiometryMath_parent_add )
{
StoichiometryMath *m = new StoichiometryMath(2, 4);
SpeciesReference *sr = new SpeciesReference(2, 4);
sr->setStoichiometryMath(m);
delete m;
fail_unless(sr == sr->getStoichiometryMath()->getParentSBMLObject());
delete sr;
}
/*
* Copy constructor. Creates a copy of this SpeciesReference.
*/
SpeciesReference::SpeciesReference (const SpeciesReference& orig) :
SimpleSpeciesReference( orig )
, mStoichiometryMath ( NULL )
{
if (&orig == NULL)
{
throw SBMLConstructorException("Null argument to copy constructor");
}
else
{
mStoichiometry = orig.mStoichiometry ;
mDenominator = orig.mDenominator ;
mConstant = orig.mConstant;
mIsSetConstant = orig.mIsSetConstant;
mIsSetStoichiometry = orig.mIsSetStoichiometry;
mExplicitlySetStoichiometry = orig.mExplicitlySetStoichiometry;
mExplicitlySetDenominator = orig.mExplicitlySetDenominator;
if (orig.mStoichiometryMath != NULL)
{
mStoichiometryMath = new StoichiometryMath(*orig.getStoichiometryMath());
mStoichiometryMath->connectToParent(this);
}
}
}
END_TEST
START_TEST (test_WriteL3SBML_SpeciesReference)
{
const char* expected = "<speciesReference species=\"s\""
" stoichiometry=\"3\" constant=\"true\"/>";
SpeciesReference *sr = D->createModel()->createReaction()->createReactant();
sr->setSpecies("s");
sr->setStoichiometry(3);
sr->setConstant(true);
char* sbml = sr->toSBML();
fail_unless( equals(expected, sbml) );
safe_free(sbml);
}
END_TEST
START_TEST ( test_SpeciesReference_Reactant_parent_add )
{
SpeciesReference *sr = new SpeciesReference(2, 4);
Reaction *r = new Reaction(2, 4);
sr->setSpecies("s");
r->addReactant(sr);
delete sr;
ListOf *lo = r->getListOfReactants();
fail_unless(lo == r->getReactant(0)->getParentSBMLObject());
fail_unless(r == lo->getParentSBMLObject());
}
std::string fixMissingStoich(const std::string sbml) {
SBMLDocument *doc = NULL;
try {
doc = readSBMLFromString (sbml.c_str());
Model *m = doc->getModel();
for (int j = 0; j<m->getNumReactions(); ++j) {
Reaction* r = m->getReaction(j);
if (!r)
throw std::runtime_error("No reaction");
// check stoich defined on reactants / products
for (int k = 0; k<r->getNumReactants(); ++k) {
SpeciesReference* s = r->getReactant(k);
if (!isStoichDefined(s))
if (s->setStoichiometry(1.) != LIBSBML_OPERATION_SUCCESS)
throw std::runtime_error("Unable to set stoichiometry");
}
for (int k = 0; k<r->getNumProducts(); ++k) {
SpeciesReference* s = r->getProduct(k);
if (!isStoichDefined(s))
if (s->setStoichiometry(1.) != LIBSBML_OPERATION_SUCCESS)
throw std::runtime_error("Unable to set stoichiometry");
}
// modifiers have no stoichiometry
}
} catch(...) {
delete doc;
throw;
}
SBMLWriter writer;
char* sbml_cstr = writer.writeSBMLToString(doc);
delete doc;
std::string result(sbml_cstr);
free(sbml_cstr);
return result;
}
void
useStoichMath(Model & m, SpeciesReference &sr, bool isRule)
{
// use stoichiometryMath instead
StoichiometryMath *sm = sr.createStoichiometryMath();
if (sm != NULL)
{
if (isRule == true)
{
sm->setMath(m.getRule(sr.getId())->getMath());
m.removeRule(sr.getId());
}
else
{
sm->setMath(m.getInitialAssignment(sr.getId())->getMath());
m.removeInitialAssignment(sr.getId());
}
}
}
/*
* Copy constructor. Creates a copy of this SpeciesReference.
*/
SpeciesReference::SpeciesReference (const SpeciesReference& orig)
: SimpleSpeciesReference( orig )
, mStoichiometry ( orig.mStoichiometry )
, mDenominator ( orig.mDenominator )
, mStoichiometryMath ( NULL )
, mConstant ( orig.mConstant)
, mIsSetConstant ( orig.mIsSetConstant)
, mIsSetStoichiometry ( orig.mIsSetStoichiometry)
, mExplicitlySetStoichiometry ( orig.mExplicitlySetStoichiometry)
, mExplicitlySetDenominator ( orig.mExplicitlySetDenominator)
{
if (orig.mStoichiometryMath != NULL)
{
mStoichiometryMath = new StoichiometryMath(*orig.getStoichiometryMath());
mStoichiometryMath->connectToParent(this);
}
}
void
createNoValueStoichMath(Model & m, SpeciesReference & sr, unsigned int idCount)
{
char newid[15];
std::string id;
// no stoichiometry and no id to set the stoichiometry
// replace with stoichiometryMath using a parameter with no value
sprintf(newid, "parameterId_%u", idCount);
id.assign(newid);
Parameter *p = m.createParameter();
p->setId(id);
p->setConstant(false);
StoichiometryMath *sm = sr.createStoichiometryMath();
if (sm != NULL)
{
ASTNode *ast = SBML_parseFormula(id.c_str());
sm->setMath(ast);
}
}
void dealWithAssigningL1Stoichiometry(Model & m, bool l2)
{
//char newid[15];
std::string id;
for (unsigned int i = 0; i < m.getNumReactions(); i++)
{
Reaction *r = m.getReaction(i);
unsigned int j;
for (j = 0; j < r->getNumReactants(); j++)
{
SpeciesReference *sr = r->getReactant(j);
// we do not get here unless the stoichiometryMath is an integer
// or a rational
if (l2 == true && sr->isSetStoichiometryMath() == true)
{
const ASTNode* ast = sr->getStoichiometryMath()->getMath();
if (ast->isInteger())
{
int num = ast->getInteger();
sr->setStoichiometry(num);
sr->setDenominator(1);
}
else
{
int num = ast->getNumerator();
int denom = ast->getDenominator();
sr->setStoichiometry(num);
sr->setDenominator(denom);
}
sr->unsetStoichiometryMath();
}
else
{
sr->setStoichiometry(sr->getStoichiometry());
sr->setDenominator(1);
}
}
for (j = 0; j < r->getNumProducts(); j++)
{
SpeciesReference *sr = r->getProduct(j);
// we do not get here unless the stoichiometryMath is an integer
// or a rational
if (l2 == true && sr->isSetStoichiometryMath() == true)
{
const ASTNode* ast = sr->getStoichiometryMath()->getMath();
if (ast->isInteger())
{
int num = ast->getInteger();
sr->setStoichiometry(num);
sr->setDenominator(1);
}
else
{
int num = ast->getNumerator();
int denom = ast->getDenominator();
sr->setStoichiometry(num);
sr->setDenominator(denom);
}
sr->unsetStoichiometryMath();
}
else
{
sr->setStoichiometry(sr->getStoichiometry());
sr->setDenominator(1);
}
}
}
}
void dealWithL1Stoichiometry(Model & m, bool l2)
{
unsigned int idCount = 0;
char newid[15];
std::string id;
for (unsigned int i = 0; i < m.getNumReactions(); i++)
{
Reaction *r = m.getReaction(i);
unsigned int j;
for (j = 0; j < r->getNumReactants(); j++)
{
SpeciesReference *sr = r->getReactant(j);
if (sr->getDenominator() != 1)
{
long stoich = static_cast<long>(sr->getStoichiometry());
int denom = sr->getDenominator();
ASTNode *node = new ASTNode();
node->setValue(stoich, denom);
if (l2 == true)
{
StoichiometryMath * sm = sr->createStoichiometryMath();
sm->setMath(node);
}
else
{
sprintf(newid, "speciesRefId_%u", idCount);
id.assign(newid);
idCount++;
sr->setId(id);
InitialAssignment * ar = m.createInitialAssignment();
ar->setSymbol(id);
ar->setMath(node);
sr->unsetStoichiometry();
}
}
}
for (j = 0; j < r->getNumProducts(); j++)
{
SpeciesReference *sr = r->getProduct(j);
if (sr->getDenominator() != 1)
{
long stoich = static_cast<long>(sr->getStoichiometry());
int denom = sr->getDenominator();
ASTNode *node = new ASTNode();
node->setValue(stoich, denom);
if (l2 == true)
{
StoichiometryMath * sm = sr->createStoichiometryMath();
sm->setMath(node);
}
else
{
sprintf(newid, "speciesRefId_%u", idCount);
id.assign(newid);
idCount++;
sr->setId(id);
InitialAssignment * ar = m.createInitialAssignment();
ar->setSymbol(id);
ar->setMath(node);
sr->unsetStoichiometry();
}
}
}
}
}
void
Model::dealWithStoichiometry()
{
unsigned int idCount = 0;
for (unsigned int i = 0; i < getNumReactions(); i++)
{
Reaction *r = getReaction(i);
unsigned int j;
for (j = 0; j < r->getNumReactants(); j++)
{
SpeciesReference *sr = r->getReactant(j);
if (sr->isSetStoichiometry() == false)
{
if (sr->isSetId() == false)
{
createNoValueStoichMath(*this, *sr, idCount);
idCount++;
}
else
{
// id is set it could be used by initialAssignment
// used by rule
// not used
if (getInitialAssignment(sr->getId()) != NULL)
{
useStoichMath(*this, *sr, false);
}
else if (getRule(sr->getId()) != NULL)
{
//assignmentRule
if (getRule(sr->getId())->getTypeCode() == SBML_ASSIGNMENT_RULE)
{
useStoichMath(*this, *sr, true);
}
else if (getRule(sr->getId())->getTypeCode() == SBML_RATE_RULE)
{
createParameterAsRateRule(*this, *sr, *(getRule(sr->getId())), idCount);
idCount++;
}
}
else
{
createNoValueStoichMath(*this, *sr, idCount);
idCount++;
}
}
}
else
{
// stoichiometry is set
if (sr->isSetId())
{
// id is set it could be used by initialAssignment
// used by rule
// not used
if (getInitialAssignment(sr->getId()) != NULL)
{
useStoichMath(*this, *sr, false);
}
else if (getRule(sr->getId()) != NULL)
{
//assignmentRule
if (getRule(sr->getId())->getTypeCode() == SBML_ASSIGNMENT_RULE)
{
useStoichMath(*this, *sr, true);
}
else if (getRule(sr->getId())->getTypeCode() == SBML_RATE_RULE)
{
createParameterAsRateRule(*this, *sr, *(getRule(sr->getId())), idCount);
idCount++;
}
}
}
// no id set - do not need to do anything
}
}
for (j = 0; j < r->getNumProducts(); j++)
{
SpeciesReference *sr = r->getProduct(j);
if (sr->isSetStoichiometry() == false)
{
if (sr->isSetId() == false)
{
createNoValueStoichMath(*this, *sr, idCount);
idCount++;
}
else
{
// id is set it could be used by initialAssignment
// used by rule
// not used
if (getInitialAssignment(sr->getId()) != NULL)
{
useStoichMath(*this, *sr, false);
}
else if (getRule(sr->getId()) != NULL)
{
//assignmentRule
if (getRule(sr->getId())->getTypeCode() == SBML_ASSIGNMENT_RULE)
{
useStoichMath(*this, *sr, true);
}
else if (getRule(sr->getId())->getTypeCode() == SBML_RATE_RULE)
{
createParameterAsRateRule(*this, *sr, *(getRule(sr->getId())), idCount);
idCount++;
}
}
else
{
createNoValueStoichMath(*this, *sr, idCount);
idCount++;
}
}
}
else
{
// stoichiometry is set
if (sr->isSetId())
{
// id is set it could be used by initialAssignment
// used by rule
// not used
if (getInitialAssignment(sr->getId()) != NULL)
{
useStoichMath(*this, *sr, false);
}
else if (getRule(sr->getId()) != NULL)
{
//assignmentRule
if (getRule(sr->getId())->getTypeCode() == SBML_ASSIGNMENT_RULE)
{
useStoichMath(*this, *sr, true);
}
else if (getRule(sr->getId())->getTypeCode() == SBML_RATE_RULE)
{
createParameterAsRateRule(*this, *sr, *(getRule(sr->getId())), idCount);
idCount++;
}
}
}
// no id set - do not need to do anything
}
}
}
}
/**
*
* 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;
}
int
main (int argc, char* argv[])
{
if (argc != 2)
{
cout << endl << "Usage: printNotes filename" << endl << endl;
return 1;
}
unsigned int i,j;
const char* filename = argv[1];
SBMLDocument* document;
SBMLReader reader;
document = reader.readSBML(filename);
unsigned int errors = document->getNumErrors();
cout << endl;
cout << "filename: " << filename << endl;
cout << endl;
if(errors > 0)
{
document->printErrors(cerr);
delete document;
return errors;
}
/* Model */
Model* m = document->getModel();
printNotes(m);
for(i=0; i < m->getNumReactions(); i++)
{
Reaction* re = m->getReaction(i);
printNotes(re);
/* SpeciesReference (Reacatant) */
for(j=0; j < re->getNumReactants(); j++)
{
SpeciesReference* rt = re->getReactant(j);
if (rt->isSetNotes()) cout << " ";
printNotes(rt, (rt->isSetSpecies() ? rt->getSpecies() : std::string("")) );
}
/* SpeciesReference (Product) */
for(j=0; j < re->getNumProducts(); j++)
{
SpeciesReference* rt = re->getProduct(j);
if (rt->isSetNotes()) cout << " ";
printNotes(rt, (rt->isSetSpecies() ? rt->getSpecies() : std::string("")) );
}
/* ModifierSpeciesReference (Modifier) */
for(j=0; j < re->getNumModifiers(); j++)
{
ModifierSpeciesReference* md = re->getModifier(j);
if (md->isSetNotes()) cout << " ";
printNotes(md, (md->isSetSpecies() ? md->getSpecies() : std::string("")) );
}
/* Kineticlaw */
if(re->isSetKineticLaw())
{
KineticLaw* kl = re->getKineticLaw();
if (kl->isSetNotes()) cout << " ";
printNotes(kl);
/* Parameter */
for(j=0; j < kl->getNumParameters(); j++)
{
Parameter* pa = kl->getParameter(j);
if (pa->isSetNotes()) cout << " ";
printNotes(pa);
}
}
}
/* Species */
for(i=0; i < m->getNumSpecies(); i++)
{
Species* sp = m->getSpecies(i);
printNotes(sp);
}
/* Compartment */
for(i=0; i < m->getNumCompartments(); i++)
{
Compartment* sp = m->getCompartment(i);
printNotes(sp);
}
/* FunctionDefinition */
for(i=0; i < m->getNumFunctionDefinitions(); i++)
{
FunctionDefinition* sp = m->getFunctionDefinition(i);
printNotes(sp);
}
/* UnitDefinition */
for(i=0; i < m->getNumUnitDefinitions(); i++)
{
UnitDefinition* sp = m->getUnitDefinition(i);
printNotes(sp);
}
/* Parameter */
for(i=0; i < m->getNumParameters(); i++)
{
Parameter* sp = m->getParameter(i);
printNotes(sp);
}
/* Rule */
for(i=0; i < m->getNumRules(); i++)
{
Rule* sp = m->getRule(i);
printNotes(sp);
}
/* InitialAssignment */
for(i=0; i < m->getNumInitialAssignments(); i++)
{
InitialAssignment* sp = m->getInitialAssignment(i);
printNotes(sp);
}
/* Event */
for(i=0; i < m->getNumEvents(); i++)
{
Event* sp = m->getEvent(i);
printNotes(sp);
/* Trigger */
if(sp->isSetTrigger())
{
const Trigger* tg = sp->getTrigger();
if (tg->isSetNotes()) cout << " ";
printNotes(const_cast<Trigger*>(tg));
}
/* Delay */
if(sp->isSetDelay())
{
const Delay* dl = sp->getDelay();
if (dl->isSetNotes()) cout << " ";
printNotes(const_cast<Delay*>(dl));
}
/* EventAssignment */
for(j=0; j < sp->getNumEventAssignments(); j++)
{
EventAssignment* ea = sp->getEventAssignment(j);
if (ea->isSetNotes()) cout << " ";
printNotes(ea);
}
}
/* SpeciesType */
for(i=0; i < m->getNumSpeciesTypes(); i++)
{
SpeciesType* sp = m->getSpeciesType(i);
printNotes(sp);
}
/* Constraint */
for(i=0; i < m->getNumConstraints(); i++)
{
Constraint* sp = m->getConstraint(i);
printNotes(sp);
}
delete document;
return errors;
}
void
Model::convertStoichiometryMath()
{
unsigned int n, j;
Reaction * r;
SpeciesReference *sr;
unsigned int idCount = 0;
char newid[15];
std::string id;
for (n = 0; n < getNumReactions(); n++)
{
r = getReaction(n);
for (j = 0; j < r->getNumReactants(); j++)
{
sr = r->getReactant(j);
if (sr->isSetStoichiometryMath())
{
if (!sr->isSetId())
{
sprintf(newid, "generatedId_%u", idCount);
id.assign(newid);
sr->setId(id);
idCount++;
}
else
{
id = sr->getId();
}
sr->setConstant(false);
AssignmentRule * ar = createAssignmentRule();
ar->setVariable(id);
if (sr->getStoichiometryMath()->isSetMath())
{
ar->setMath(sr->getStoichiometryMath()->getMath());
}
}
}
for (j = 0; j < r->getNumProducts(); j++)
{
sr = r->getProduct(j);
if (sr->isSetStoichiometryMath())
{
if (!sr->isSetId())
{
sprintf(newid, "generatedId_%u", idCount);
id.assign(newid);
sr->setId(id);
idCount++;
}
else
{
id = sr->getId();
}
sr->setConstant(false);
AssignmentRule * ar = createAssignmentRule();
ar->setVariable(id);
if (sr->getStoichiometryMath()->isSetMath())
{
ar->setMath(sr->getStoichiometryMath()->getMath());
}
}
}
}
}
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;
}
void
Model::assignRequiredValues()
{
// when converting to L3 some attributes which have default values in L1/L2
// but are required in L3 are not present or set
unsigned int i, n;
if (getNumUnitDefinitions() > 0)
{
for (i = 0; i < getNumUnitDefinitions(); i++)
{
for (n = 0; n < getUnitDefinition(i)->getNumUnits(); n++)
{
Unit *u = getUnitDefinition(i)->getUnit(n);
if (!u->isSetExponent())
u->setExponent(1.0);
if (!u->isSetScale())
u->setScale(0);
if (!u->isSetMultiplier())
u->setMultiplier(1.0);
}
}
}
if (getNumCompartments() > 0)
{
for (i = 0; i < getNumCompartments(); i++)
{
Compartment *c = getCompartment(i);
c->setConstant(c->getConstant());
}
}
if (getNumSpecies() > 0)
{
for (i = 0; i < getNumSpecies(); i++)
{
Species * s = getSpecies(i);
s->setBoundaryCondition(s->getBoundaryCondition());
s->setHasOnlySubstanceUnits(s->getHasOnlySubstanceUnits());
s->setConstant(s->getConstant());
}
}
if (getNumParameters() > 0)
{
for (i = 0; i < getNumParameters(); i++)
{
Parameter * p = getParameter(i);
p->setConstant(p->getConstant());
}
}
if (getNumReactions() > 0)
{
for (i = 0; i < getNumReactions(); i++)
{
Reaction * r = getReaction(i);
r->setFast(r->getFast());
r->setReversible(r->getReversible());
if (r->getNumReactants() > 0)
{
for (n = 0; n < r->getNumReactants(); n++)
{
SpeciesReference *sr = r->getReactant(n);
if (sr->isSetStoichiometryMath())
{
sr->setConstant(false);
}
else
{
sr->setConstant(true);
}
}
}
if (r->getNumProducts() > 0)
{
for (n = 0; n < r->getNumProducts(); n++)
{
SpeciesReference *sr = r->getProduct(n);
if (sr->isSetStoichiometryMath())
{
sr->setConstant(false);
}
else
{
sr->setConstant(true);
}
}
}
}
}
if (getNumEvents() > 0)
{
for (i = 0; i < getNumEvents(); i++)
{
Event * e = getEvent(i);
e->setUseValuesFromTriggerTime(e->getUseValuesFromTriggerTime());
if (e->isSetTrigger())
{
Trigger *t = e->getTrigger();
t->setPersistent(true);
t->setInitialValue(true);
}
}
}
}
/**
*
* 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;
}
/**
* Save the gene network to an SBML file. If the argument is null, use the network id.
* @param filename URL to the file describing the network to load
* @throws IOException
*/
void GeneNetwork::writeSBML(const char *filename) {
ofstream data_file(filename);
if (!data_file.is_open()) {
std::cerr << "Failed to open file " << filename << std::endl;
exit(1);
}
data_file.close();
::logging::log::emit<Info>() << "Writing file " << filename <<
::logging::log::endl;
SBMLDocument *sbmlDoc = new SBMLDocument(3, 1);
Model *model = sbmlDoc->createModel();
model->setId(id_);
//model.getNotes ().add (comment_); // save network description
int size = getSize();
Compartment *comp = model->createCompartment();
comp->setId("cell");
comp->setSize(1);
std::vector<Species*> all_sp;
Species *sp;
for (int s=0; s < size; s++) { // save gene as species
// species[s] = new Species(nodeIds_.get(s), nodeIds_.get(s));
sp = model->createSpecies();
sp->setCompartment("cell");
sp->setId((nodes_.at(s)).getLabel());
all_sp.push_back(sp);
//species[s].setInitialAmount(?); // maybe save the wild-type steady state?
//model.addSpecies(species[s]);
}
// create the void species
sp = model->createSpecies();
sp->setCompartment("cell");
sp->setId("_void_");
sp->setInitialAmount(0);
sp->setBoundaryCondition(true);
sp->setConstant(true);
all_sp.push_back(sp);
//model.addSpecies(species[size]);
// SET SYNTHESIS AND DEGRADATION REACTIONS FOR EVERY GENE
for (int i=0; i<size; i++) {
//::logging::log::emit<Info>() << ::logging::log::dec << i <<
//::logging::log::endl;
// the ID of gene i
// String currentGeneID = nodeIds_.get(i);
string currentGeneID = (nodes_.at(i)).getLabel();
// The modifiers (regulators) of gene i
std::vector<std::string> inputGenes = (nodes_.at(i)).getInputGenes();
// SYNTHESIS REACTION
std::string reactionId = currentGeneID + "_synthesis";
Reaction *reaction = model->createReaction();
KineticLaw *kineticLaw = reaction->createKineticLaw();
SpeciesReference *spr;
ModifierSpeciesReference *msr;
reaction->setId(reactionId);
reaction->setReversible (false);
spr = reaction->createReactant();
spr->setSpecies(sp->getId());
spr = reaction->createProduct();
spr->setSpecies((all_sp.at(i))->getId());
std::stringstream ss;
ss << inputGenes.size();
//::logging::log::emit<Debug>() << "node = " << nodes_.at(i).getLabel().c_str() << " #inputs = " << ss.str().c_str() << ::logging::log::endl;
for (unsigned int r=0; r<inputGenes.size(); r++) {// set gene modifiers
// reaction.addModifier(species[inputIndexes.get(r)]);
//log.log(Level.INFO, "i = " + size);
msr = reaction->createModifier();
msr->setSpecies((all_sp.at(getIndexOfNode(inputGenes.at(r))))->getId());
}
//std::vector<RegulatoryModule> modules = (nodes_.at(i)).getRegulatoryModules();
//log.log(Level.INFO, "size = " + modules.size());
std::map<std::string, double> *params = new std::map<std::string, double>();
(nodes_.at(i)).compileParameters(*params);
//char buf[256];
//sprintf(buf, "%f", nodes_.at(i).getDelta());
//::logging::log::emit<Info>() << buf << ::logging::log::endl;
//::logging::log::emit<Info>() << ::logging::log::dec << nodes_.at(i).getAlpha().size() <<
// ::logging::log::endl;
Parameter *para;
// save gene parameters (note, the first param is the degradation rate)
std::map<std::string, double>::iterator p = params->begin();
//p++;
for (; p!=params->end(); p++) {
//if (p == params->begin()) {
// p++;
// continue;
//}
//::logging::log::emit<Info>() << p->first.c_str() <<
// ::logging::log::endl;
if (p->first != "delta") {
para = kineticLaw->createParameter();
para->setId(p->first);
para->setValue(p->second);
}
}
reaction->setKineticLaw(kineticLaw);
model->addReaction(reaction);
// DEGRADATION REACTION
reaction = model->createReaction();
kineticLaw = reaction->createKineticLaw();
reactionId = currentGeneID + "_degradation";
reaction->setId(reactionId);
reaction->setReversible(false);
spr = reaction->createReactant();
spr->setSpecies((all_sp.at(i))->getId());
spr = reaction->createProduct();
spr->setSpecies(sp->getId());
para = kineticLaw->createParameter();
std::map<std::string,double>::iterator it = params->find("delta");
para->setId(it->first);
para->setValue(it->second);
reaction->setKineticLaw (kineticLaw);
model->addReaction (reaction);
}
// PRINT FILE
SBMLWriter sbmlWriter;
sbmlWriter.writeSBML(sbmlDoc, filename);
delete sbmlDoc;
}
/**
*
* Creates an SBML model represented in "7.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;
}
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;
}