public addChild ( |
||
disownedChild | ||
Результат | 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"); }