public void test_SBMLConvertStrict_convertNonStrictSBO()
{
SBMLDocument d = new SBMLDocument(2,4);
Model m = d.createModel();
Compartment c = m.createCompartment();
c.setId( "c");
c.setConstant(false);
(c).setSBOTerm(64);
assertTrue( d.setLevelAndVersion(2,3,true) == false );
assertTrue( d.getLevel() == 2 );
assertTrue( d.getVersion() == 4 );
assertTrue( d.setLevelAndVersion(2,2,true) == false );
assertTrue( d.getLevel() == 2 );
assertTrue( d.getVersion() == 4 );
assertTrue( d.setLevelAndVersion(2,1,true) == true );
assertTrue( d.getLevel() == 2 );
assertTrue( d.getVersion() == 1 );
Compartment c1 = d.getModel().getCompartment(0);
assertTrue( (c1).getSBOTerm() == -1 );
assertTrue( d.setLevelAndVersion(1,2,true) == true );
assertTrue( d.getLevel() == 1 );
assertTrue( d.getVersion() == 2 );
Compartment c2 = d.getModel().getCompartment(0);
assertTrue( (c2).getSBOTerm() == -1 );
d = null;
}
static void Main(string[] args)
{
SBMLNamespaces sbmlns = new SBMLNamespaces(3, 1, "distrib", 1);
SBMLDocument document = new SBMLDocument(sbmlns);
// set the required attribute to true
DistribSBMLDocumentPlugin docPlug = (DistribSBMLDocumentPlugin)
(document->getPlugin("distrib"));
docPlug.setRequired(true);
// create the Model
Model model = document.createModel();
// create the FunctionDefintion
FunctionDefinition fd = model.createFunctionDefinition();
fd.setId("mynormal");
ASTNode math = libsbml.parseFormula("lambda(param1, param2, 0)");
fd.setMath(math);
//
// Get a DistribFunctionDefinitionPlugin object plugged in the fd 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.
//
DistribFunctionDefinitionPlugin fdPlugin =
(DistribFunctionDefinitionPlugin)(fd.getPlugin("distrib"));
// create a DrawFromDistribution object
DrawFromDistribution draw = fdPlugin.createDrawFromDistribution();
// create the distribInputs
DistribInput input1 = draw.createDistribInput();
input1.setId("mu");
input1.setIndex(0);
DistribInput input2 = draw.createDistribInput();
input2.setId("sigma");
input2.setIndex(1);
// create the UncertMLNode object
UncertMLNode uncert = libsbml.createDistributionNode
("NormalDistribution", "mean, variance", "mu,sigma");
draw.setUncertML(uncert);
libsbml.writeSBMLToFile(document, "distrib_example1.xml");
}
public void test_internal_consistency_check_20419()
{
SBMLDocument d = new SBMLDocument(3,1);
long errors;
Model m = d.createModel();
UnitDefinition ud = m.createUnitDefinition();
errors = d.checkInternalConsistency();
assertTrue( errors == 1 );
assertTrue( d.getError(0).getErrorId() == 20419 );
ud.setId("ud");
d.getErrorLog().clearLog();
errors = d.checkInternalConsistency();
assertTrue( errors == 0 );
d = null;
}
public void test_internal_consistency_check_20306()
{
SBMLDocument d = new SBMLDocument(3,1);
long errors;
Model m = d.createModel();
FunctionDefinition fd = m.createFunctionDefinition();
fd.setId("fd");
errors = d.checkInternalConsistency();
assertTrue( errors == 1 );
assertTrue( d.getError(0).getErrorId() == 20306 );
ASTNode ast = libsbml.parseFormula("lambda(x, 2*x)");
fd.setMath(ast);
errors = d.checkInternalConsistency();
assertTrue( errors == 0 );
d = null;
}
public void test_SBMLConvert_convertFromL3()
{
SBMLDocument d = new SBMLDocument(3,1);
Model m = d.createModel();
string sid = "C";
Compartment c = m.createCompartment();
c.setId(sid);
c.setSize(1.2);
c.setConstant(true);
c.setSpatialDimensions(3.4);
assertTrue( d.setLevelAndVersion(1,1,true) == false );
assertTrue( d.setLevelAndVersion(1,2,true) == false );
assertTrue( d.setLevelAndVersion(2,1,true) == false );
assertTrue( d.setLevelAndVersion(2,2,true) == false );
assertTrue( d.setLevelAndVersion(2,3,true) == false );
assertTrue( d.setLevelAndVersion(2,4,true) == false );
assertTrue( d.setLevelAndVersion(3,1,true) == true );
}
public void test_SBMLConvertStrict_convertL1ParamRule()
{
SBMLDocument d = new SBMLDocument(1,2);
Model m = d.createModel();
Compartment c = m.createCompartment();
c.setId( "c");
Parameter p = m.createParameter();
p.setId( "p");
Parameter p1 = m.createParameter();
p1.setId( "p1");
ASTNode math = libsbml.parseFormula("p");
Rule ar = m.createAssignmentRule();
ar.setVariable( "p1");
ar.setMath(math);
ar.setUnits( "mole");
assertTrue( d.setLevelAndVersion(2,1,true) == true );
assertTrue( d.getLevel() == 2 );
assertTrue( d.getVersion() == 1 );
Rule r1 = d.getModel().getRule(0);
assertTrue( r1.getUnits() == "" );
d = null;
}
static void Main(string[] args)
{
SBMLNamespaces sbmlns = new SBMLNamespaces(3, 1, "distrib", 1);
SBMLDocument document = new SBMLDocument(sbmlns);
// set the required attribute to true
DistribSBMLDocumentPlugin docPlug = (DistribSBMLDocumentPlugin)
(document->getPlugin("distrib"));
docPlug.setRequired(true);
// create the Model
Model model = document.createModel();
// create the Parameter
Parameter p = model.createParameter();
p.setId("V");
p.setConstant(true);
//
// Get a DistribSBasePlugin object plugged in the parameter object.
//
DistribSBasePlugin pPlugin =
(DistribSBasePlugin)(p.getPlugin("distrib"));
// create a Uncertainty object
Uncertainty uncert = pPlugin.createUncertainty();
// create the UncertMLNode object
UncertMLNode uncertML = libsbml.createDistributionNode
("Statistics", "Mean, Variance", "V_pop, V_omega");
uncert.setUncertML(uncertML);
libsbml.writeSBMLToFile(document, "distrib_example2.xml");
}
public void test_SBMLConvert_addModifiersToReaction()
{
SBMLDocument d = new SBMLDocument(1,2);
Model m = d.createModel();
Reaction r = m.createReaction();
KineticLaw kl = r.createKineticLaw();
kl.setFormula( "k1*S1*S2*S3*S4*S5");
SimpleSpeciesReference ssr1;
SimpleSpeciesReference ssr2;
Species s1 = m.createSpecies();
s1.setId( "S1" );
Species s2 = m.createSpecies();
s2.setId( "S2");
Species s3 = m.createSpecies();
s3.setId( "S3");
Species s4 = m.createSpecies();
s4.setId( "S4");
Species s5 = m.createSpecies();
s5.setId( "S5");
SpeciesReference sr1 = r.createReactant();
SpeciesReference sr2 = r.createReactant();
SpeciesReference sr3 = r.createProduct();
sr1.setSpecies( "S1");
sr2.setSpecies( "S2");
sr3.setSpecies( "S5");
assertTrue( r.getNumModifiers() == 0 );
assertTrue( d.setLevelAndVersion(2,1,false) == true );
assertTrue( d.getLevel() == 2 );
assertTrue( d.getVersion() == 1 );
assertTrue( m.getReaction(0).getNumModifiers() == 2 );
ssr1 = m.getReaction(0).getModifier(0);
ssr2 = m.getReaction(0).getModifier(1);
assertTrue(( "S3" == ssr1.getSpecies() ));
assertTrue(( "S4" == ssr2.getSpecies() ));
d = null;
}
public void test_SBMLConvert_convertToL1_Species_Amount()
{
SBMLDocument d = new SBMLDocument(2,4);
Model m = d.createModel();
string sid = "C";
Compartment c = new Compartment(2,4);
Species s = new Species(2,4);
c.setId(sid);
m.addCompartment(c);
s.setCompartment(sid);
s.setInitialAmount(2.34);
m.addSpecies(s);
assertTrue( d.setLevelAndVersion(1,2,true) == true );
assertTrue( s.getInitialAmount() == 2.34 );
d = null;
}
public void test_SBMLConvert_convertFromL3_conversionFactor()
{
SBMLDocument d = new SBMLDocument(3,1);
Model m = d.createModel();
string sid = "P";
m.setConversionFactor(sid);
Parameter c = m.createParameter();
c.setId(sid);
c.setConstant(true);
assertTrue( d.setLevelAndVersion(1,1,true) == false );
assertTrue( d.setLevelAndVersion(1,2,true) == false );
assertTrue( d.setLevelAndVersion(2,1,true) == false );
assertTrue( d.setLevelAndVersion(2,2,true) == false );
assertTrue( d.setLevelAndVersion(2,3,true) == false );
assertTrue( d.setLevelAndVersion(2,4,true) == false );
assertTrue( d.setLevelAndVersion(3,1,true) == true );
}
public void test_SBMLConvertStrict_convertToL1()
{
SBMLDocument d = new SBMLDocument(2,4);
Model m = d.createModel();
(m).setMetaId( "_m");
Compartment c = m.createCompartment();
c.setId( "c");
(c).setSBOTerm(240);
Species s = m.createSpecies();
s.setId( "s");
s.setCompartment( "c");
assertTrue( d.setLevelAndVersion(1,2,true) == true );
assertTrue( d.getLevel() == 1 );
assertTrue( d.getVersion() == 2 );
Model m1 = d.getModel();
assertTrue( (m1).getMetaId() == "" );
Compartment c1 = m1.getCompartment(0);
assertTrue( (c1).getSBOTerm() == -1 );
Species s1 = m1.getSpecies(0);
assertTrue( s1.getHasOnlySubstanceUnits() == false );
d = null;
}
public void test_SBMLConvert_convertToL3_defaultUnits()
{
SBMLDocument d = new SBMLDocument(1,2);
Model m = d.createModel();
string sid = "C";
Compartment c = m.createCompartment();
c.setId(sid);
c.setSize(1.2);
c.setUnits( "volume");
assertTrue( m.getNumUnitDefinitions() == 0 );
assertTrue( d.setLevelAndVersion(3,1,true) == true );
assertTrue( m.getNumUnitDefinitions() == 2 );
UnitDefinition ud = m.getUnitDefinition(0);
assertTrue( ud != null );
assertTrue(( "volume" == ud.getId() ));
assertTrue( ud.getNumUnits() == 1 );
Unit u = ud.getUnit(0);
assertTrue( u.getKind() == libsbml.UNIT_KIND_LITRE );
assertTrue( u.getExponent() == 1 );
assertTrue( u.getMultiplier() == 1 );
assertTrue( u.getScale() == 0 );
ud = m.getUnitDefinition(1);
assertTrue( ud != null );
assertTrue(( "time" == ud.getId() ));
assertTrue( ud.getNumUnits() == 1 );
u = ud.getUnit(0);
assertTrue( u.getKind() == libsbml.UNIT_KIND_SECOND );
assertTrue( u.getExponent() == 1 );
assertTrue( u.getMultiplier() == 1 );
assertTrue( u.getScale() == 0 );
assertTrue(( "time" == m.getTimeUnits() ));
d = null;
}
public void test_SBMLConvert_convertToL1_Species_Concentration()
{
SBMLDocument d = new SBMLDocument(2,1);
Model m = d.createModel();
string sid = "C";
Compartment c = new Compartment(2,1);
Species s = new Species(2,1);
c.setId(sid);
c.setSize(1.2);
m.addCompartment(c);
s.setId( "s" );
s.setCompartment(sid);
s.setInitialConcentration(2.34);
m.addSpecies(s);
assertTrue( d.setLevelAndVersion(1,2,true) == true );
Species s1 = m.getSpecies(0);
assertTrue( s1 != null );
assertTrue(( "C" == s1.getCompartment() ));
assertTrue( m.getCompartment( "C").getSize() == 1.2 );
assertTrue( s1.getInitialConcentration() == 2.34 );
assertTrue( s1.isSetInitialConcentration() == true );
d = null;
}
static void testCreateSBML()
{
SBMLDocument d = new SBMLDocument(defLevel,defVersion);
Model m = d.createModel();
m.setId("testmodel");
Compartment c1 = m.createCompartment();
Compartment c2 = m.createCompartment();
c1.setId("c1");
c2.setId("c2");
Species s1 = m.createSpecies();
Species s2 = m.createSpecies();
string id1 = "s1";
string id2 = "s2";
// strings with non-ASCII characters (multibyte characters)
string n1 = "γ-lyase";
string n2 = "β-synthase";
s1.setId(id1);
s1.setName(n1);
s1.setCompartment("c1");
s2.setId(id2);
s2.setName(n2);
s2.setCompartment("c2");
string file = "test2.xml";
try
{
if ( libsbml.writeSBML(d, file) == 0)
{
ERR("[CreateSBML] Error: cannot write " + file);
}
else
{
OK();
}
}
catch (Exception e)
{
ERR("[CreateSBML] (" + file + ") Error: Exception thrown : " + e.Message);
}
testReadSBMLFromFile(file);
}
/**
*
* Creates an SBML model represented in "7.8 Example involving function definitions"
* in the SBML Level 2 Version 4 Specification.
*
*/
private static SBMLDocument createExampleInvolvingFunctionDefinitions()
{
int level = Level;
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 = libsbml.readMathMLFromString(mathXMLString);
fdef.setMath(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 = libsbml.readMathMLFromString(mathXMLString);
kl.setMath(astMath);
// Returns the created SBMLDocument object.
// The returned object must be explicitly deleted by the caller,
// otherwise memory leak will happen.
return sbmlDoc;
}
public void test_SBMLConvert_convertToL2v4_DuplicateAnnotations_model()
{
SBMLDocument d = new SBMLDocument(2,1);
Model m = d.createModel();
string annotation = "<rdf/>\n<rdf/>";
int i = (m).setAnnotation(annotation);
assertTrue( d.getLevel() == 2 );
assertTrue( d.getVersion() == 1 );
assertTrue( (m).getAnnotation().getNumChildren() == 2 );
assertTrue( d.setLevelAndVersion(2,4,true) == true );
assertTrue( d.getLevel() == 2 );
assertTrue( d.getVersion() == 4 );
m = d.getModel();
assertTrue( (m).getAnnotation().getNumChildren() == 1 );
d = null;
}
public void test_SBMLConvert_convertToL3_stoichiometryMath()
{
SBMLDocument d = new SBMLDocument(2,1);
Model m = d.createModel();
Compartment c = m.createCompartment();
c.setId( "c" );
Species s = m.createSpecies();
s.setId( "s");
s.setCompartment( "c");
Reaction r = m.createReaction();
SpeciesReference sr = r.createReactant();
sr.setSpecies( "s");
StoichiometryMath sm = sr.createStoichiometryMath();
ASTNode ast = libsbml.parseFormula("c*2");
sm.setMath(ast);
assertTrue( m.getNumRules() == 0 );
assertTrue( sr.isSetId() == false );
assertTrue( d.setLevelAndVersion(3,1,false) == true );
m = d.getModel();
r = m.getReaction(0);
sr = r.getReactant(0);
assertTrue( m.getNumRules() == 1 );
assertTrue( sr.isSetId() == true );
Rule rule = m.getRule(0);
assertTrue(( rule.getVariable() == sr.getId() ));
d = null;
}
public void test_SBMLConvert_convertToL3_reaction()
{
SBMLDocument d = new SBMLDocument(2,2);
Model m = d.createModel();
string sid = "C";
Reaction r = m.createReaction();
r.setId(sid);
assertTrue( d.setLevelAndVersion(3,1,false) == true );
Reaction r1 = m.getReaction(0);
assertTrue( r1.hasRequiredAttributes() == true );
d = null;
}
public void test_SBMLConvert_convertToL3_species()
{
SBMLDocument d = new SBMLDocument(2,2);
Model m = d.createModel();
string sid = "C";
Species s = m.createSpecies();
Species s1;
s.setId(sid);
s.setCompartment( "comp");
assertTrue( d.setLevelAndVersion(3,1,false) == true );
s1 = m.getSpecies(0);
assertTrue( s1.hasRequiredAttributes() == true );
d = null;
}
public void test_SBMLConvert_convertToL3_reactant()
{
SBMLDocument d = new SBMLDocument(2,2);
Model m = d.createModel();
Reaction r = m.createReaction();
SpeciesReference sr = r.createReactant();
SpeciesReference sr1;
sr.setSpecies( "s" );
assertTrue( d.setLevelAndVersion(3,1,false) == true );
sr1 = m.getReaction(0).getReactant(0);
assertTrue( sr1.hasRequiredAttributes() == true );
d = null;
}
public void test_SBMLConvert_convertToL3_parameter()
{
SBMLDocument d = new SBMLDocument(2,2);
Model m = d.createModel();
string sid = "C";
Parameter p = m.createParameter();
Parameter p1;
p.setId(sid);
assertTrue( d.setLevelAndVersion(3,1,false) == true );
p1 = m.getParameter(0);
assertTrue( p1.hasRequiredAttributes() == true );
d = null;
}
public void test_SBMLConvert_convertToL3_localParameters()
{
SBMLDocument d = new SBMLDocument(1,2);
Model m = d.createModel();
Compartment c = m.createCompartment();
c.setId( "c" );
Species s = m.createSpecies();
s.setId( "s");
s.setCompartment( "c");
Reaction r = m.createReaction();
SpeciesReference sr = r.createReactant();
sr.setSpecies( "s");
KineticLaw kl = r.createKineticLaw();
kl.setFormula( "s*k");
Parameter p = kl.createParameter();
p.setId( "k");
assertTrue( kl.getNumLocalParameters() == 0 );
assertTrue( d.setLevelAndVersion(3,1,false) == true );
m = d.getModel();
r = m.getReaction(0);
kl = r.getKineticLaw();
assertTrue( kl.getNumLocalParameters() == 1 );
LocalParameter lp = kl.getLocalParameter(0);
d = null;
}
public void test_SBMLConvert_convertFromL3_priority()
{
SBMLDocument d = new SBMLDocument(3,1);
Model m = d.createModel();
Event e = m.createEvent();
Priority p = e.createPriority();
assertTrue( d.setLevelAndVersion(1,1,false) == false );
assertTrue( d.setLevelAndVersion(1,2,false) == false );
assertTrue( d.setLevelAndVersion(2,1,false) == true );
assertTrue( d.setLevelAndVersion(2,2,false) == true );
assertTrue( d.setLevelAndVersion(2,3,false) == true );
assertTrue( d.setLevelAndVersion(2,4,false) == true );
assertTrue( d.setLevelAndVersion(3,1,false) == true );
}
public void test_SBMLConvert_convertToL3_trigger()
{
SBMLDocument d = new SBMLDocument(2,2);
Model m = d.createModel();
Event e = m.createEvent();
Trigger t = e.createTrigger();
Trigger t1;
assertTrue( d.setLevelAndVersion(3,1,false) == true );
t1 = m.getEvent(0).getTrigger();
assertTrue( t1.hasRequiredAttributes() == true );
d = null;
}
public void test_SBMLConvertStrict_convertNonStrictUnits()
{
SBMLDocument d = new SBMLDocument(2,4);
Model m = d.createModel();
Compartment c = m.createCompartment();
c.setId( "c");
c.setConstant(false);
Parameter p = m.createParameter();
p.setId( "p");
p.setUnits( "mole");
ASTNode math = libsbml.parseFormula("p");
Rule ar = m.createAssignmentRule();
ar.setVariable( "c");
ar.setMath(math);
assertTrue( d.setLevelAndVersion(2,1,true) == false );
assertTrue( d.getLevel() == 2 );
assertTrue( d.getVersion() == 4 );
assertTrue( d.setLevelAndVersion(2,2,true) == false );
assertTrue( d.getLevel() == 2 );
assertTrue( d.getVersion() == 4 );
assertTrue( d.setLevelAndVersion(2,3,true) == false );
assertTrue( d.getLevel() == 2 );
assertTrue( d.getVersion() == 4 );
assertTrue( d.setLevelAndVersion(1,2,true) == false );
assertTrue( d.getLevel() == 2 );
assertTrue( d.getVersion() == 4 );
d = null;
}
public void test_SBMLConvert_convertToL3_unit()
{
SBMLDocument d = new SBMLDocument(2,2);
Model m = d.createModel();
string sid = "C";
UnitDefinition ud = m.createUnitDefinition();
ud.setId(sid);
Unit u = ud.createUnit();
u.setKind(libsbml.UNIT_KIND_MOLE);
assertTrue( d.setLevelAndVersion(3,1,false) == true );
Unit u1 = m.getUnitDefinition(0).getUnit(0);
assertTrue( u1.hasRequiredAttributes() == true );
d = null;
}
//===============================================================================
//
//
// Functions for creating the Example SBML documents.
//
//
//===============================================================================
/**
*
* Creates an SBML model represented in "7.1 A Simple example application of SBML"
* in the SBML Level 2 Version 4 Specification.
*
*/
private static SBMLDocument createExampleEnzymaticReaction()
{
int level = Level;
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(libsbml.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(libsbml.UNIT_KIND_MOLE);
unit.setExponent(-1);
// Creates an Unit inside the UnitDefinition object ("litre_per_mole_per_second")
unit = unitdef.createUnit();
unit.setKind(libsbml.UNIT_KIND_LITRE);
unit.setExponent(1);
// Creates an Unit inside the UnitDefinition object ("litre_per_mole_per_second")
unit = unitdef.createUnit();
unit.setKind(libsbml.UNIT_KIND_SECOND);
unit.setExponent(-1);
//---------------------------------------------------------------------------
//
// Creates a Compartment object inside the Model object.
//
//---------------------------------------------------------------------------
Compartment comp;
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(libsbml.AST_NAME);
astCytosol.setName("cytosol");
ASTNode astKon = new ASTNode(libsbml.AST_NAME);
astKon.setName("kon");
ASTNode astKoff = new ASTNode(libsbml.AST_NAME);
astKoff.setName("koff");
ASTNode astE = new ASTNode(libsbml.AST_NAME);
astE.setName("E");
ASTNode astS = new ASTNode(libsbml.AST_NAME);
astS.setName("S");
ASTNode astES = new ASTNode(libsbml.AST_NAME);
astES.setName("ES");
//--------------------------------------------
//
// create node representing
// <apply>
// <times/>
// <ci> koff </ci>
// <ci> ES </ci>
// </apply>
//
//--------------------------------------------
ASTNode astTimes1 = new ASTNode(libsbml.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(libsbml.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(libsbml.AST_TIMES);
astTimes2.addChild(astE);
astTimes2.addChild(astS);
ASTNode astTimes = new ASTNode(libsbml.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(libsbml.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(libsbml.AST_TIMES);
astMath.addChild(astCytosol);
astMath.addChild(astMinus);
//---------------------------------------------
//
// set the Math element
//
//------------------------------------------------
kl.setMath(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 = libsbml.readMathMLFromString(mathXMLString);
kl.setMath(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;
}
public void test_SBMLConvert_invalidLevelVersion()
{
SBMLDocument d = new SBMLDocument(2,1);
Model m = d.createModel();
string sid = "C";
Compartment c = m.createCompartment();
c.setId(sid);
c.setSize(1.2);
c.setUnits( "volume");
assertTrue( d.setLevelAndVersion(1,3,true) == false );
assertTrue( d.setLevelAndVersion(2,5,true) == false );
assertTrue( d.setLevelAndVersion(3,2,true) == false );
assertTrue( d.setLevelAndVersion(4,1,true) == false );
}
/**
*
* Creates an SBML model represented in "7.2 Example involving units"
* in the SBML Level 2 Version 4 Specification.
*
*/
private static SBMLDocument createExampleInvolvingUnits()
{
int level = Level;
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(libsbml.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(libsbml.UNIT_KIND_MOLE);
unit.setScale(-3);
// Creates an Unit inside the UnitDefinition object ("mmls")
unit = unitdef.createUnit();
unit.setKind(libsbml.UNIT_KIND_LITRE);
unit.setExponent(-1);
// Creates an Unit inside the UnitDefinition object ("mmls")
unit = unitdef.createUnit();
unit.setKind(libsbml.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(libsbml.UNIT_KIND_MOLE);
unit.setScale(-3);
// Creates an Unit inside the UnitDefinition object ("mml")
unit = unitdef.createUnit();
unit.setKind(libsbml.UNIT_KIND_LITRE);
unit.setExponent(-1);
//---------------------------------------------------------------------------
//
// Creates a Compartment object inside the Model object.
//
//---------------------------------------------------------------------------
Compartment comp;
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(libsbml.AST_TIMES);
astMath.addChild(new ASTNode(libsbml.AST_DIVIDE));
ASTNode astDivide = astMath.getLeftChild();
astDivide.addChild(new ASTNode(libsbml.AST_TIMES));
ASTNode astTimes = astDivide.getLeftChild();
astTimes.addChild(new ASTNode(libsbml.AST_NAME));
astTimes.getLeftChild().setName("vm");
astTimes.addChild(new ASTNode(libsbml.AST_NAME));
astTimes.getRightChild().setName("s1");
astDivide.addChild(new ASTNode(libsbml.AST_PLUS));
ASTNode astPlus = astDivide.getRightChild();
astPlus.addChild(new ASTNode(libsbml.AST_NAME));
astPlus.getLeftChild().setName("km");
astPlus.addChild(new ASTNode(libsbml.AST_NAME));
astPlus.getRightChild().setName("s1");
astMath.addChild(new ASTNode(libsbml.AST_NAME));
astMath.getRightChild().setName("cell");
//---------------------------------------------
//
// set the Math element
//
//------------------------------------------------
kl.setMath(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 = new XMLNode(
new XMLTriple("p", "", "xhtml"),
new XMLAttributes());
// Adds a text element to the start element.
notesXMLNode.addChild(new XMLNode(" ((vm * s2)/(km + s2)) * cell "));
// Adds it to the kineticLaw object.
kl.setNotes(notesXMLNode);
//---------------------------------------------------------------------------
// 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 = libsbml.readMathMLFromString(mathXMLString);
kl.setMath(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 = libsbml.readMathMLFromString(mathXMLString);
kl.setMath(astMath);
// Returns the created SBMLDocument object.
// The returned object must be explicitly deleted by the caller,
// otherwise memory leak will happen.
return sbmlDoc;
}
public void test_SBMLConvert_convertToL3_compartment()
{
SBMLDocument d = new SBMLDocument(2,2);
Model m = d.createModel();
string sid = "C";
Compartment c = m.createCompartment();
Compartment c1;
c.setId(sid);
assertTrue( d.setLevelAndVersion(3,1,false) == true );
c1 = m.getCompartment(0);
assertTrue( c1.hasRequiredAttributes() == true );
d = null;
}
