// #######################################################################
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;
}
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;
}
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);
}
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 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);
}
}
}
}
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;
}
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;
}
}
}
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;
}