addChild() public method

public addChild ( ASTNode disownedChild ) : int
disownedChild ASTNode
return int
示例#1
0
 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;
 }
示例#3
0
 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;
 }
示例#4
0
 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;
 }
示例#5
0
 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;
 }
示例#6
0
 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;
 }
示例#7
0
 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;
 }
示例#8
0
 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;
 }
示例#9
0
 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;
 }
示例#12
0
 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;
 }
示例#13
0
 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;
 }
示例#17
0
    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;
 }
示例#19
0
 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;
 }
示例#20
0
 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;
    }
示例#22
0
    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");
    }