|
public addChild ( |
||
| disownedChild | ||
| return | int | |
public void test_ValidASTNode_binary()
{
ASTNode n = new ASTNode(libsbml.AST_DIVIDE);
assertEquals( false, (n.isWellFormedASTNode()) );
ASTNode c = libsbml.parseFormula("c");
n.addChild(c);
assertEquals( false, (n.isWellFormedASTNode()) );
ASTNode d = libsbml.parseFormula("d");
n.addChild(d);
assertEquals( true, n.isWellFormedASTNode() );
n = null;
}
public void test_ValidASTNode_lambda()
{
ASTNode n = new ASTNode(libsbml.AST_LAMBDA);
assertEquals( false, (n.isWellFormedASTNode()) );
ASTNode c = libsbml.parseFormula("c");
n.addChild(c);
assertEquals( true, n.isWellFormedASTNode() );
ASTNode d = libsbml.parseFormula("d");
n.addChild(d);
assertEquals( true, n.isWellFormedASTNode() );
ASTNode e = libsbml.parseFormula("e");
n.addChild(e);
assertEquals( true, n.isWellFormedASTNode() );
n = null;
}
public void test_ASTNode_addChild1()
{
ASTNode node = new ASTNode();
ASTNode c1 = new ASTNode();
ASTNode c2 = new ASTNode();
ASTNode c1_1 = new ASTNode();
int i = 0;
node.setType(libsbml.AST_LOGICAL_AND);
c1.setName( "a");
c2.setName( "b");
node.addChild(c1);
node.addChild(c2);
assertTrue( node.getNumChildren() == 2 );
assertTrue(( "and(a, b)" == libsbml.formulaToString(node) ));
c1_1.setName( "d");
i = node.addChild(c1_1);
assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS );
assertTrue( node.getNumChildren() == 3 );
assertTrue(( "and(a, b, d)" == libsbml.formulaToString(node) ));
assertTrue(( "a" == node.getChild(0).getName() ));
assertTrue(( "b" == node.getChild(1).getName() ));
assertTrue(( "d" == node.getChild(2).getName() ));
node = null;
}
public void test_ASTNode_removeChild()
{
ASTNode node = new ASTNode();
ASTNode c1 = new ASTNode();
ASTNode c2 = new ASTNode();
int i = 0;
node.setType(libsbml.AST_PLUS);
c1.setName( "foo");
c2.setName( "foo2");
node.addChild(c1);
node.addChild(c2);
assertTrue( node.getNumChildren() == 2 );
i = node.removeChild(0);
assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS );
assertTrue( node.getNumChildren() == 1 );
i = node.removeChild(1);
assertTrue( i == libsbml.LIBSBML_INDEX_EXCEEDS_SIZE );
assertTrue( node.getNumChildren() == 1 );
i = node.removeChild(0);
assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS );
assertTrue( node.getNumChildren() == 0 );
node = null;
}
public void test_ASTNode_replaceChild()
{
ASTNode node = new ASTNode();
ASTNode c1 = new ASTNode();
ASTNode c2 = new ASTNode();
ASTNode c3 = new ASTNode();
ASTNode newc = new ASTNode();
int i = 0;
node.setType(libsbml.AST_LOGICAL_AND);
c1.setName( "a");
c2.setName( "b");
c3.setName( "c");
node.addChild(c1);
node.addChild(c2);
node.addChild(c3);
assertTrue( node.getNumChildren() == 3 );
assertTrue(( "and(a, b, c)" == libsbml.formulaToString(node) ));
newc.setName( "d");
i = node.replaceChild(0,newc);
assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS );
assertTrue( node.getNumChildren() == 3 );
assertTrue(( "and(d, b, c)" == libsbml.formulaToString(node) ));
i = node.replaceChild(3,newc);
assertTrue( i == libsbml.LIBSBML_INDEX_EXCEEDS_SIZE );
assertTrue( node.getNumChildren() == 3 );
assertTrue(( "and(d, b, c)" == libsbml.formulaToString(node) ));
i = node.replaceChild(1,c1);
assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS );
assertTrue( node.getNumChildren() == 3 );
assertTrue(( "and(d, a, c)" == libsbml.formulaToString(node) ));
node = null;
}
public void test_ASTNode_isUMinus()
{
ASTNode n = new ASTNode();
n.setType(libsbml.AST_MINUS);
assertTrue( n.isUMinus() == false );
n.addChild(new ASTNode(libsbml.AST_NAME));
assertTrue( n.isUMinus() == true );
n = null;
}
public void test_ASTNode_one_child()
{
ASTNode node = new ASTNode();
ASTNode child = new ASTNode();
node.addChild(child);
assertTrue( node.getNumChildren() == 1 );
assertTrue( node.getLeftChild() == child );
assertTrue( node.getRightChild() == null );
assertTrue( node.getChild(0) == child );
assertTrue( node.getChild(1) == null );
node = null;
}
public void test_ASTNode_getPrecedence()
{
ASTNode n = new ASTNode();
n.setType(libsbml.AST_PLUS);
assertTrue( n.getPrecedence() == 2 );
n.setType(libsbml.AST_MINUS);
assertTrue( n.getPrecedence() == 2 );
n.setType(libsbml.AST_TIMES);
assertTrue( n.getPrecedence() == 3 );
n.setType(libsbml.AST_DIVIDE);
assertTrue( n.getPrecedence() == 3 );
n.setType(libsbml.AST_POWER);
assertTrue( n.getPrecedence() == 4 );
n.setType(libsbml.AST_MINUS);
n.addChild(new ASTNode(libsbml.AST_NAME));
assertTrue( n.isUMinus() == true );
assertTrue( n.getPrecedence() == 5 );
n.setType(libsbml.AST_NAME);
assertTrue( n.getPrecedence() == 6 );
n.setType(libsbml.AST_FUNCTION);
assertTrue( n.getPrecedence() == 6 );
n = null;
}
public void test_ASTNode_isSqrt()
{
ASTNode n = new ASTNode();
ASTNode c;
n.setType(libsbml.AST_FUNCTION);
assertTrue( n.isSqrt() == false );
n.setType(libsbml.AST_FUNCTION_ROOT);
assertTrue( n.isSqrt() == false );
c = new ASTNode();
n.addChild(c);
c.setValue(2);
assertTrue( n.isSqrt() == false );
n.addChild(new ASTNode());
assertTrue( n.isSqrt() == true );
c.setValue(3);
assertTrue( n.isSqrt() == false );
n = 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_Rule_setMath2()
{
ASTNode math = new ASTNode(libsbml.AST_DIVIDE);
ASTNode a = new ASTNode();
a.setName( "a");
math.addChild(a);
int i = R.setMath(math);
assertTrue( i == libsbml.LIBSBML_INVALID_OBJECT );
assertEquals( false, R.isSetMath() );
math = null;
}
public void test_ASTNode_canonicalizeFunctionsL1()
{
ASTNode n = new ASTNode(libsbml.AST_FUNCTION);
ASTNode c;
n.setName( "acos");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCCOS );
n.setType(libsbml.AST_FUNCTION);
n.setName( "asin");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCSIN );
n.setType(libsbml.AST_FUNCTION);
n.setName( "atan");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCTAN );
n.setType(libsbml.AST_FUNCTION);
n.setName( "ceil");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_CEILING );
n.setType(libsbml.AST_FUNCTION);
n.setName( "pow");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_POWER );
n = null;
n = new ASTNode(libsbml.AST_FUNCTION);
n.setName( "log");
c = new ASTNode();
c.setName( "x");
n.addChild(c);
assertTrue( n.getType() == libsbml.AST_FUNCTION );
assertTrue( n.getNumChildren() == 1 );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_LN );
assertTrue( n.getNumChildren() == 1 );
n.setType(libsbml.AST_FUNCTION);
c = new ASTNode();
c.setName( "y");
n.addChild(c);
assertTrue( n.getType() == libsbml.AST_FUNCTION );
assertTrue( n.getNumChildren() == 2 );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_LOG );
n = null;
n = new ASTNode(libsbml.AST_FUNCTION);
n.setName( "log10");
c = new ASTNode();
c.setName( "x");
n.addChild(c);
assertTrue( n.getType() == libsbml.AST_FUNCTION );
assertTrue( n.getNumChildren() == 1 );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_LOG );
assertTrue( n.getNumChildren() == 2 );
c = n.getLeftChild();
assertTrue( c.getType() == libsbml.AST_INTEGER );
assertTrue( c.getInteger() == 10 );
c = n.getRightChild();
assertTrue( c.getType() == libsbml.AST_NAME );
assertTrue(( "x" == c.getName() ));
n = null;
n = new ASTNode(libsbml.AST_FUNCTION);
n.setName( "sqr");
c = new ASTNode();
c.setName( "x");
n.addChild(c);
assertTrue( n.getType() == libsbml.AST_FUNCTION );
assertTrue( n.getNumChildren() == 1 );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_POWER );
assertTrue( n.getNumChildren() == 2 );
c = n.getLeftChild();
assertTrue( c.getType() == libsbml.AST_NAME );
assertTrue(( "x" == c.getName() ));
c = n.getRightChild();
assertTrue( c.getType() == libsbml.AST_INTEGER );
assertTrue( c.getInteger() == 2 );
n = null;
n = new ASTNode(libsbml.AST_FUNCTION);
n.setName( "sqrt");
c = new ASTNode();
c.setName( "x");
n.addChild(c);
assertTrue( n.getType() == libsbml.AST_FUNCTION );
assertTrue( n.getNumChildren() == 1 );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ROOT );
assertTrue( n.getNumChildren() == 2 );
c = n.getLeftChild();
assertTrue( c.getType() == libsbml.AST_INTEGER );
assertTrue( c.getInteger() == 2 );
c = n.getRightChild();
assertTrue( c.getType() == libsbml.AST_NAME );
assertTrue(( "x" == c.getName() ));
n = null;
}
public void test_ValidASTNode_root()
{
ASTNode n = new ASTNode(libsbml.AST_FUNCTION_ROOT);
assertEquals( false, (n.isWellFormedASTNode()) );
ASTNode c = libsbml.parseFormula("c");
n.addChild(c);
assertEquals( true, n.isWellFormedASTNode() );
ASTNode d = libsbml.parseFormula("3");
n.addChild(d);
assertEquals( true, n.isWellFormedASTNode() );
ASTNode e = libsbml.parseFormula("3");
n.addChild(e);
assertEquals( false, (n.isWellFormedASTNode()) );
n = null;
}
public void test_SpeciesReference_setStoichiometryMath2()
{
StoichiometryMath sm = new StoichiometryMath(2,4);
ASTNode math = new ASTNode(libsbml.AST_TIMES);
ASTNode a = new ASTNode();
a.setName( "a");
math.addChild(a);
sm.setMath(math);
int i = sr.setStoichiometryMath(sm);
assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS );
assertEquals( true, sr.isSetStoichiometryMath() );
sm = null;
}
public void test_KineticLaw_setMath2()
{
ASTNode math = new ASTNode(libsbml.AST_TIMES);
ASTNode a = new ASTNode();
a.setName( "a");
math.addChild(a);
int i = kl.setMath(math);
assertTrue( i == libsbml.LIBSBML_INVALID_OBJECT );
assertEquals( false, kl.isSetMath() );
math = null;
}
public void test_KineticLaw_setMath1()
{
ASTNode math = new ASTNode(libsbml.AST_TIMES);
ASTNode a = new ASTNode();
ASTNode b = new ASTNode();
a.setName( "a");
b.setName( "b");
math.addChild(a);
math.addChild(b);
string formula;
ASTNode math1;
int i = kl.setMath(math);
assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS );
assertEquals( true, kl.isSetMath() );
math1 = kl.getMath();
assertTrue( math1 != null );
formula = libsbml.formulaToString(math1);
assertTrue( formula != null );
assertTrue(( "a * b" == formula ));
math = null;
}
public static void Main(string[] args)
{
ArraysPkgNamespaces arraysNs = new ArraysPkgNamespaces();
SBMLDocument doc = new SBMLDocument(arraysNs);
doc.setPackageRequired("arrays", true);
Model model = doc.createModel();
// create compartment
Compartment comp = model.createCompartment();
comp.setMetaId("dd");
comp.setId("s");
comp.setConstant(true);
// set dimensions
ArraysSBasePlugin compPlugin = (ArraysSBasePlugin) comp.getPlugin("arrays");
Dimension dim = compPlugin.createDimension();
dim.setId("i");
dim.setSize("n");
// create species
Species species = model.createSpecies();
species.setId("A");
species.setCompartment("s");
species.setHasOnlySubstanceUnits(false);
species.setBoundaryCondition(false);
species.setConstant(false);
ArraysSBasePlugin splugin = (ArraysSBasePlugin) species.getPlugin("arrays");
dim = splugin.createDimension();
dim.setId("i");
dim.setSize("n");
species = model.createSpecies();
species.setId("B");
species.setCompartment("s");
species.setHasOnlySubstanceUnits(false);
species.setBoundaryCondition(false);
species.setConstant(false);
splugin = (ArraysSBasePlugin) species.getPlugin("arrays");
dim = splugin.createDimension();
dim.setId("i");
dim.setSize("n");
species = model.createSpecies();
species.setId("C");
species.setCompartment("s");
species.setHasOnlySubstanceUnits(false);
species.setBoundaryCondition(false);
species.setConstant(false);
splugin = (ArraysSBasePlugin) species.getPlugin("arrays");
dim = splugin.createDimension();
dim.setId("i");
dim.setSize("n");
// create parameter
Parameter param = model.createParameter();
param.setId("n");
param.setValue(100);
param.setConstant(true);
// create reaction
Reaction reaction = model.createReaction();
reaction.setId("reaction1");
reaction.setReversible(false);
reaction.setFast(false);
ArraysSBasePlugin reactionPlugin = (ArraysSBasePlugin) reaction.getPlugin("arrays");
dim = reactionPlugin.createDimension();
dim.setId("i");
dim.setSize("n");
SpeciesReference speciesRef = reaction.createReactant();
speciesRef.setSpecies("A");
speciesRef.setConstant(false);
ArraysSBasePlugin refPlugin = (ArraysSBasePlugin) speciesRef.getPlugin("arrays");
Index index = refPlugin.createIndex();
ASTNode ast = new ASTNode(libsbml.AST_LINEAR_ALGEBRA_SELECTOR);
ASTNode ci = new ASTNode(libsbml.AST_NAME);
ci.setName("A");
ast.addChild(ci);
ci = new ASTNode(libsbml.AST_NAME);
ci.setName("i");
ast.addChild(ci);
index.setMath(ast);
speciesRef = reaction.createProduct();
speciesRef.setSpecies("C");
speciesRef.setConstant(false);
refPlugin = (ArraysSBasePlugin) speciesRef.getPlugin("arrays");
index = refPlugin.createIndex();
ast = new ASTNode(libsbml.AST_LINEAR_ALGEBRA_SELECTOR);
ci = new ASTNode(libsbml.AST_NAME);
ci.setName("C");
ast.addChild(ci);
ci = new ASTNode(libsbml.AST_NAME);
ci.setName("i");
ast.addChild(ci);
index.setMath(ast);
libsbml.writeSBMLToFile(doc, "arrays1.xml");
}
public void test_SpeciesReference_setStoichiometryMath5()
{
SpeciesReference sr1 = new SpeciesReference(1,2);
StoichiometryMath sm = new StoichiometryMath(2,4);
ASTNode math = new ASTNode(libsbml.AST_TIMES);
ASTNode a = new ASTNode();
ASTNode b = new ASTNode();
a.setName( "a");
b.setName( "b");
math.addChild(a);
math.addChild(b);
sm.setMath(math);
int i = sr1.setStoichiometryMath(sm);
assertTrue( i == libsbml.LIBSBML_UNEXPECTED_ATTRIBUTE );
assertEquals( false, sr1.isSetStoichiometryMath() );
sm = null;
sr1 = null;
}
public void test_ASTNode_children()
{
ASTNode parent = new ASTNode();
ASTNode left = new ASTNode();
ASTNode right = new ASTNode();
ASTNode right2 = new ASTNode();
parent.setType(libsbml.AST_PLUS);
left.setValue(1);
right.setValue(2);
right2.setValue(3);
parent.addChild(left);
parent.addChild(right);
assertTrue( parent.getNumChildren() == 2 );
assertTrue( left.getNumChildren() == 0 );
assertTrue( right.getNumChildren() == 0 );
assertTrue( parent.getLeftChild() == left );
assertTrue( parent.getRightChild() == right );
assertTrue( parent.getChild(0) == left );
assertTrue( parent.getChild(1) == right );
assertTrue( parent.getChild(2) == null );
parent.addChild(right2);
assertTrue( parent.getNumChildren() == 3 );
assertTrue( left.getNumChildren() == 0 );
assertTrue( right.getNumChildren() == 0 );
assertTrue( right2.getNumChildren() == 0 );
assertTrue( parent.getLeftChild() == left );
assertTrue( parent.getRightChild() == right2 );
assertTrue( parent.getChild(0) == left );
assertTrue( parent.getChild(1) == right );
assertTrue( parent.getChild(2) == right2 );
assertTrue( parent.getChild(3) == null );
parent = null;
}
public void test_ASTNode_deepCopy_1()
{
ASTNode node = new ASTNode();
ASTNode child, copy;
node.setCharacter( '+');
node.addChild(new ASTNode());
node.addChild(new ASTNode());
node.getLeftChild().setValue(1);
node.getRightChild().setValue(2);
assertTrue( node.getType() == libsbml.AST_PLUS );
assertTrue( node.getCharacter() == '+' );
assertTrue( node.getNumChildren() == 2 );
child = node.getLeftChild();
assertTrue( child.getType() == libsbml.AST_INTEGER );
assertTrue( child.getInteger() == 1 );
assertTrue( child.getNumChildren() == 0 );
child = node.getRightChild();
assertTrue( child.getType() == libsbml.AST_INTEGER );
assertTrue( child.getInteger() == 2 );
assertTrue( child.getNumChildren() == 0 );
copy = node.deepCopy();
assertTrue( copy != node );
assertTrue( copy.getType() == libsbml.AST_PLUS );
assertTrue( copy.getCharacter() == '+' );
assertTrue( copy.getNumChildren() == 2 );
child = copy.getLeftChild();
assertTrue( child != node.getLeftChild() );
assertTrue( child.getType() == libsbml.AST_INTEGER );
assertTrue( child.getInteger() == 1 );
assertTrue( child.getNumChildren() == 0 );
child = copy.getRightChild();
assertTrue( child != node.getRightChild() );
assertTrue( child.getType() == libsbml.AST_INTEGER );
assertTrue( child.getInteger() == 2 );
assertTrue( child.getNumChildren() == 0 );
node = null;
copy = null;
}
/**
*
* 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 static void Main(string[] args)
{
ArraysPkgNamespaces arraysNs = new ArraysPkgNamespaces();
SBMLDocument doc = new SBMLDocument(arraysNs);
doc.setPackageRequired("arrays", true);
Model model = doc.createModel();
// create parameters
Parameter param = model.createParameter();
param.setId("n");
param.setValue(10);
param.setConstant(true);
param = model.createParameter();
param.setId("m");
param.setValue(10);
param.setConstant(true);
param = model.createParameter();
param.setId("x");
param.setValue(5.7);
param.setConstant(true);
ArraysSBasePlugin paramPlugin = (ArraysSBasePlugin) param.getPlugin("arrays");
Dimension dim = paramPlugin.createDimension();
dim.setId("i");
dim.setSize("n");
param = model.createParameter();
param.setId("y");
param.setConstant(false);
paramPlugin = (ArraysSBasePlugin) param.getPlugin("arrays");
dim = paramPlugin.createDimension();
dim.setId("i");
dim.setSize("n");
param = model.createParameter();
param.setId("z");
param.setConstant(false);
paramPlugin = (ArraysSBasePlugin) param.getPlugin("arrays");
dim = paramPlugin.createDimension();
dim.setId("i");
dim.setSize("n");
// create initial assignments
InitialAssignment assignment = model.createInitialAssignment();
assignment.setSymbol("y");
ASTNode ast = new ASTNode(libsbml.AST_REAL);
ast.setValue(3.2);
assignment.setMath(ast);
assignment = model.createInitialAssignment();
assignment.setSymbol("z");
ast = new ASTNode(libsbml.AST_REAL);
ast.setValue(5.7);
assignment.setMath(ast);
ArraysSBasePlugin assignmentPlugin = (ArraysSBasePlugin) assignment.getPlugin("arrays");
dim = assignmentPlugin.createDimension();
dim.setId("i");
dim.setSize("m");
Index index = assignmentPlugin.createIndex();
ASTNode newAst = new ASTNode(libsbml.AST_FUNCTION);
newAst.setName("selector");
ASTNode ci = new ASTNode(libsbml.AST_NAME);
ci.setName("z");
newAst.addChild(ci);
ci = new ASTNode(libsbml.AST_NAME);
ci.setName("i");
newAst.addChild(ci);
index.setMath(newAst);
assignment = model.createInitialAssignment();
assignment.setSymbol("z");
ast = new ASTNode(libsbml.AST_REAL);
ast.setValue(3.2);
assignment.setMath(ast);
assignmentPlugin = (ArraysSBasePlugin) assignment.getPlugin("arrays");
dim = assignmentPlugin.createDimension();
dim.setId("i");
dim.setSize("m");
index = assignmentPlugin.createIndex();
newAst = new ASTNode(libsbml.AST_LINEAR_ALGEBRA_SELECTOR);
ci = new ASTNode(libsbml.AST_NAME);
ci.setName("z");
newAst.addChild(ci);
ASTNode plus = new ASTNode(libsbml.AST_PLUS);
ci = new ASTNode(libsbml.AST_NAME);
ci.setName("i");
plus.addChild(ci);
ci = new ASTNode(libsbml.AST_NAME);
ci.setName("m");
plus.addChild(ci);
newAst.addChild(plus);
index.setMath(newAst);
libsbml.writeSBMLToFile(doc, "arrays2.xml");
}
