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_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_MathMLFormatter_csymbol_time()
{
string expected = wrapMathML(" <csymbol encoding=\"text\" " + "definitionURL=\"http://www.sbml.org/sbml/symbols/time\"> t </csymbol>\n");
N = new ASTNode(libsbml.AST_NAME_TIME);
N.setName("t");
S = libsbml.writeMathMLToString(N);
assertEquals( true, equals(expected,S) );
}
public void test_ASTNode_avogadro_bug()
{
double val;
ASTNode n = new ASTNode();
n.setName( "NA");
n.setType(libsbml.AST_NAME_AVOGADRO);
assertTrue(( "NA" == n.getName() ));
val = n.getReal();
assertTrue( val == 6.02214179e23 );
assertTrue( n.isConstant() == true );
n = 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_getName()
{
ASTNode n = new ASTNode();
n.setName( "foo");
assertTrue(( "foo" == n.getName() ));
n.setType(libsbml.AST_NAME_TIME);
assertTrue(( "foo" == n.getName() ));
n.setName(null);
assertTrue( n.getName() == null );
n.setType(libsbml.AST_CONSTANT_E);
assertTrue(( "exponentiale" == n.getName() ));
n.setType(libsbml.AST_CONSTANT_FALSE);
assertTrue(( "false" == n.getName() ));
n.setType(libsbml.AST_CONSTANT_PI);
assertTrue(( "pi" == n.getName() ));
n.setType(libsbml.AST_CONSTANT_TRUE);
assertTrue(( "true" == n.getName() ));
n.setType(libsbml.AST_LAMBDA);
assertTrue(( "lambda" == n.getName() ));
n.setType(libsbml.AST_FUNCTION);
n.setName( "f");
assertTrue(( "f" == n.getName() ));
n.setType(libsbml.AST_FUNCTION_DELAY);
assertTrue(( "f" == n.getName() ));
n.setName(null);
assertTrue(( "delay" == n.getName() ));
n.setType(libsbml.AST_FUNCTION);
assertTrue( n.getName() == null );
n.setType(libsbml.AST_FUNCTION_ABS);
assertTrue(( "abs" == n.getName() ));
n.setType(libsbml.AST_FUNCTION_ARCCOS);
assertTrue(( "arccos" == n.getName() ));
n.setType(libsbml.AST_FUNCTION_TAN);
assertTrue(( "tan" == n.getName() ));
n.setType(libsbml.AST_FUNCTION_TANH);
assertTrue(( "tanh" == n.getName() ));
n.setType(libsbml.AST_LOGICAL_AND);
assertTrue(( "and" == n.getName() ));
n.setType(libsbml.AST_LOGICAL_NOT);
assertTrue(( "not" == n.getName() ));
n.setType(libsbml.AST_LOGICAL_OR);
assertTrue(( "or" == n.getName() ));
n.setType(libsbml.AST_LOGICAL_XOR);
assertTrue(( "xor" == n.getName() ));
n.setType(libsbml.AST_RELATIONAL_EQ);
assertTrue(( "eq" == n.getName() ));
n.setType(libsbml.AST_RELATIONAL_GEQ);
assertTrue(( "geq" == n.getName() ));
n.setType(libsbml.AST_RELATIONAL_LT);
assertTrue(( "lt" == n.getName() ));
n.setType(libsbml.AST_RELATIONAL_NEQ);
assertTrue(( "neq" == n.getName() ));
n = null;
}
public void test_ASTNode_deepCopy_4()
{
ASTNode node = new ASTNode(libsbml.AST_FUNCTION_ABS);
ASTNode copy;
node.setName( "ABS");
assertTrue( node.getType() == libsbml.AST_FUNCTION_ABS );
assertTrue(( "ABS" == node.getName() ));
assertTrue( node.getNumChildren() == 0 );
copy = node.deepCopy();
assertTrue( copy != node );
assertTrue( copy.getType() == libsbml.AST_FUNCTION_ABS );
assertTrue(( "ABS" == copy.getName() ));
assertTrue( copy.getNumChildren() == 0 );
node = null;
copy = null;
}
public void test_ASTNode_setInteger()
{
ASTNode node = new ASTNode();
node.setName( "foo");
assertTrue( node.getType() == libsbml.AST_NAME );
assertTrue(( "foo" == node.getName() ));
assertTrue( node.getCharacter() == '\0' );
assertTrue( node.getInteger() == 0 );
assertTrue( node.getReal() == 0 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
node.setValue(3.2);
assertTrue( node.getType() == libsbml.AST_REAL );
assertTrue( node.getInteger() == 0 );
assertTrue( node.getName() == null );
assertTrue( node.getCharacter() == '\0' );
assertTrue( node.getReal() == 3.2 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
node.setValue(321);
assertTrue( node.getType() == libsbml.AST_INTEGER );
assertTrue( node.getInteger() == 321 );
assertTrue( node.getName() == null );
assertTrue( node.getCharacter() == '\0' );
assertTrue( node.getReal() == 0 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
node = 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 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 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_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_ASTNode_canonicalizeLogical()
{
ASTNode n = new ASTNode(libsbml.AST_FUNCTION);
n.setName( "and");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_LOGICAL_AND );
n.setType(libsbml.AST_FUNCTION);
n.setName( "not");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_LOGICAL_NOT );
n.setType(libsbml.AST_FUNCTION);
n.setName( "or");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_LOGICAL_OR );
n.setType(libsbml.AST_FUNCTION);
n.setName( "xor");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_LOGICAL_XOR );
n.setType(libsbml.AST_FUNCTION);
n = null;
}
public void test_ASTNode_setName()
{
string name = "foo";
ASTNode node = new ASTNode();
assertTrue( node.getType() == libsbml.AST_UNKNOWN );
node.setName(name);
assertTrue( node.getType() == libsbml.AST_NAME );
assertTrue(( name == node.getName() ));
assertTrue( node.getCharacter() == '\0' );
assertTrue( node.getInteger() == 0 );
assertTrue( node.getReal() == 0 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
if (node.getName() == name);
{
}
node.setName(null);
assertTrue( node.getType() == libsbml.AST_NAME );
if (node.getName() != null);
{
}
node.setType(libsbml.AST_FUNCTION_COS);
assertTrue( node.getType() == libsbml.AST_FUNCTION_COS );
assertTrue(( "cos" == node.getName() ));
assertTrue( node.getCharacter() == '\0' );
assertTrue( node.getInteger() == 0 );
assertTrue( node.getReal() == 0 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
node.setType(libsbml.AST_PLUS);
node.setName(name);
assertTrue( node.getType() == libsbml.AST_NAME );
assertTrue(( name == node.getName() ));
assertTrue( node.getCharacter() == '+' );
assertTrue( node.getInteger() == 0 );
assertTrue( node.getReal() == 0 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
node = null;
}
public void test_ASTNode_canonicalizeRelational()
{
ASTNode n = new ASTNode(libsbml.AST_FUNCTION);
n.setName( "eq");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_RELATIONAL_EQ );
n.setType(libsbml.AST_FUNCTION);
n.setName( "geq");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_RELATIONAL_GEQ );
n.setType(libsbml.AST_FUNCTION);
n.setName( "gt");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_RELATIONAL_GT );
n.setType(libsbml.AST_FUNCTION);
n.setName( "leq");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_RELATIONAL_LEQ );
n.setType(libsbml.AST_FUNCTION);
n.setName( "lt");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_RELATIONAL_LT );
n.setType(libsbml.AST_FUNCTION);
n.setName( "neq");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_RELATIONAL_NEQ );
n.setType(libsbml.AST_FUNCTION);
n = null;
}
public void test_ASTNode_setName_override()
{
ASTNode node = new ASTNode(libsbml.AST_FUNCTION_SIN);
assertTrue(( "sin" == node.getName() ));
assertTrue( node.getType() == libsbml.AST_FUNCTION_SIN );
node.setName( "MySinFunc");
assertTrue(( "MySinFunc" == node.getName() ));
assertTrue( node.getType() == libsbml.AST_FUNCTION_SIN );
node.setName(null);
assertTrue(( "sin" == node.getName() ));
assertTrue( node.getType() == libsbml.AST_FUNCTION_SIN );
node = null;
}
public void test_ASTNode_deepCopy_2()
{
ASTNode node = new ASTNode();
ASTNode copy;
node.setName( "Foo");
assertTrue( node.getType() == libsbml.AST_NAME );
assertTrue(( "Foo" == node.getName() ));
assertTrue( node.getNumChildren() == 0 );
copy = node.deepCopy();
assertTrue( copy != node );
assertTrue( copy.getType() == libsbml.AST_NAME );
assertTrue(( "Foo" == copy.getName() ));
assertTrue( copy.getNumChildren() == 0 );
node = null;
copy = null;
}
public void test_ASTNode_setReal()
{
ASTNode node = new ASTNode();
node.setName( "foo");
assertTrue( node.getType() == libsbml.AST_NAME );
node.setValue(32.1);
assertTrue( node.getType() == libsbml.AST_REAL );
assertTrue( node.getInteger() == 0 );
assertTrue( node.getName() == null );
assertTrue( node.getCharacter() == '\0' );
assertTrue( node.getReal() == 32.1 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
assertTrue( node.getMantissa() == 32.1 );
node.setValue(45,90);
assertTrue( node.getType() == libsbml.AST_RATIONAL );
assertTrue( node.getInteger() == 45 );
assertTrue( node.getName() == null );
assertTrue( node.getCharacter() == '\0' );
assertTrue( node.getReal() == 0.5 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 90 );
assertTrue( node.getMantissa() == 0 );
node.setValue(32.0,4);
assertTrue( node.getType() == libsbml.AST_REAL_E );
assertTrue( node.getInteger() == 0 );
assertTrue( node.getName() == null );
assertTrue( node.getCharacter() == '\0' );
assertTrue( node.getReal() == 320000 );
assertTrue( node.getExponent() == 4 );
assertTrue( node.getDenominator() == 1 );
assertTrue( node.getMantissa() == 32 );
node = null;
}
public void test_ASTNode_freeName()
{
ASTNode node = new ASTNode();
int i = 0;
i = node.setName( "a");
assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS );
assertTrue(( "a" == libsbml.formulaToString(node) ));
assertTrue(( "a" == node.getName() ));
i = node.freeName();
assertTrue( i == libsbml.LIBSBML_OPERATION_SUCCESS );
assertTrue( node.getName() == null );
i = node.freeName();
assertTrue( i == libsbml.LIBSBML_UNEXPECTED_ATTRIBUTE );
assertTrue( node.getName() == null );
node.setType(libsbml.AST_UNKNOWN);
i = node.freeName();
assertTrue( i == libsbml.LIBSBML_UNEXPECTED_ATTRIBUTE );
assertTrue( node.getName() == null );
node = null;
}
public void test_ASTNode_canonicalizeConstants()
{
ASTNode n = new ASTNode();
n.setName( "ExponentialE");
assertEquals( true, n.isName() );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_CONSTANT_E );
n.setType(libsbml.AST_NAME);
n.setName( "False");
assertEquals( true, n.isName() );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_CONSTANT_FALSE );
n.setType(libsbml.AST_NAME);
n.setName( "Pi");
assertEquals( true, n.isName() );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_CONSTANT_PI );
n.setType(libsbml.AST_NAME);
n.setName( "True");
assertEquals( true, n.isName() );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_CONSTANT_TRUE );
n.setType(libsbml.AST_NAME);
n.setName( "Foo");
assertEquals( true, n.isName() );
n.canonicalize();
assertEquals( true, n.isName() );
n = 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_setType()
{
ASTNode node = new ASTNode();
node.setName( "foo");
assertTrue( node.getType() == libsbml.AST_NAME );
node.setType(libsbml.AST_FUNCTION);
assertTrue( node.getType() == libsbml.AST_FUNCTION );
assertTrue(( "foo" == node.getName() ));
node.setType(libsbml.AST_NAME);
assertTrue( node.getType() == libsbml.AST_NAME );
assertTrue(( "foo" == node.getName() ));
node.setType(libsbml.AST_INTEGER);
assertTrue( node.getType() == libsbml.AST_INTEGER );
node.setType(libsbml.AST_REAL);
assertTrue( node.getType() == libsbml.AST_REAL );
node.setType(libsbml.AST_UNKNOWN);
assertTrue( node.getType() == libsbml.AST_UNKNOWN );
node.setType(libsbml.AST_PLUS);
assertTrue( node.getType() == libsbml.AST_PLUS );
assertTrue( node.getCharacter() == '+' );
node.setType(libsbml.AST_MINUS);
assertTrue( node.getType() == libsbml.AST_MINUS );
assertTrue( node.getCharacter() == '-' );
node.setType(libsbml.AST_TIMES);
assertTrue( node.getType() == libsbml.AST_TIMES );
assertTrue( node.getCharacter() == '*' );
node.setType(libsbml.AST_DIVIDE);
assertTrue( node.getType() == libsbml.AST_DIVIDE );
assertTrue( node.getCharacter() == '/' );
node.setType(libsbml.AST_POWER);
assertTrue( node.getType() == libsbml.AST_POWER );
assertTrue( node.getCharacter() == '^' );
node = null;
}
public void test_ASTNode_setCharacter()
{
ASTNode node = new ASTNode();
node.setName( "foo");
assertTrue( node.getType() == libsbml.AST_NAME );
assertTrue( node.getCharacter() == '\0' );
assertTrue(( "foo" == node.getName() ));
assertTrue( node.getInteger() == 0 );
assertTrue( node.getReal() == 0 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
node.setCharacter( '+');
assertTrue( node.getType() == libsbml.AST_PLUS );
assertTrue( node.getCharacter() == '+' );
assertTrue( node.getName() == null );
assertTrue( node.getInteger() == 0 );
assertTrue( node.getReal() == 0 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
node.setCharacter( '-');
assertTrue( node.getType() == libsbml.AST_MINUS );
assertTrue( node.getCharacter() == '-' );
assertTrue( node.getName() == null );
assertTrue( node.getInteger() == 0 );
assertTrue( node.getReal() == 0 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
node.setCharacter( '*');
assertTrue( node.getType() == libsbml.AST_TIMES );
assertTrue( node.getCharacter() == '*' );
assertTrue( node.getName() == null );
assertTrue( node.getInteger() == 0 );
assertTrue( node.getReal() == 0 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
node.setCharacter( '/');
assertTrue( node.getType() == libsbml.AST_DIVIDE );
assertTrue( node.getCharacter() == '/' );
assertTrue( node.getName() == null );
assertTrue( node.getInteger() == 0 );
assertTrue( node.getReal() == 0 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
node.setCharacter( '^');
assertTrue( node.getType() == libsbml.AST_POWER );
assertTrue( node.getCharacter() == '^' );
assertTrue( node.getName() == null );
assertTrue( node.getInteger() == 0 );
assertTrue( node.getReal() == 0 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
node.setCharacter( '$');
assertTrue( node.getType() == libsbml.AST_UNKNOWN );
assertTrue( node.getCharacter() == '$' );
assertTrue( node.getName() == null );
assertTrue( node.getInteger() == 0 );
assertTrue( node.getReal() == 0 );
assertTrue( node.getExponent() == 0 );
assertTrue( node.getDenominator() == 1 );
node = null;
}
public void test_ASTNode_canonicalizeFunctions()
{
ASTNode n = new ASTNode(libsbml.AST_FUNCTION);
n.setName( "abs");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ABS );
n.setType(libsbml.AST_FUNCTION);
n.setName( "arccos");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCCOS );
n.setType(libsbml.AST_FUNCTION);
n.setName( "arccosh");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCCOSH );
n.setType(libsbml.AST_FUNCTION);
n.setName( "arccot");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCCOT );
n.setType(libsbml.AST_FUNCTION);
n.setName( "arccoth");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCCOTH );
n.setType(libsbml.AST_FUNCTION);
n.setName( "arccsc");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCCSC );
n.setType(libsbml.AST_FUNCTION);
n.setName( "arccsch");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCCSCH );
n.setType(libsbml.AST_FUNCTION);
n.setName( "arcsec");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCSEC );
n.setType(libsbml.AST_FUNCTION);
n.setName( "arcsech");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCSECH );
n.setType(libsbml.AST_FUNCTION);
n.setName( "arcsin");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCSIN );
n.setType(libsbml.AST_FUNCTION);
n.setName( "arcsinh");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCSINH );
n.setType(libsbml.AST_FUNCTION);
n.setName( "arctan");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCTAN );
n.setType(libsbml.AST_FUNCTION);
n.setName( "arctanh");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ARCTANH );
n.setType(libsbml.AST_FUNCTION);
n.setName( "ceiling");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_CEILING );
n.setType(libsbml.AST_FUNCTION);
n.setName( "cos");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_COS );
n.setType(libsbml.AST_FUNCTION);
n.setName( "cosh");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_COSH );
n.setType(libsbml.AST_FUNCTION);
n.setName( "cot");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_COT );
n.setType(libsbml.AST_FUNCTION);
n.setName( "coth");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_COTH );
n.setType(libsbml.AST_FUNCTION);
n.setName( "csc");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_CSC );
n.setType(libsbml.AST_FUNCTION);
n.setName( "csch");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_CSCH );
n.setType(libsbml.AST_FUNCTION);
n.setName( "exp");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_EXP );
n.setType(libsbml.AST_FUNCTION);
n.setName( "factorial");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_FACTORIAL );
n.setType(libsbml.AST_FUNCTION);
n.setName( "floor");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_FLOOR );
n.setType(libsbml.AST_FUNCTION);
n.setName( "lambda");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_LAMBDA );
n.setType(libsbml.AST_FUNCTION);
n.setName( "ln");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_LN );
n.setType(libsbml.AST_FUNCTION);
n.setName( "log");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_LOG );
n.setType(libsbml.AST_FUNCTION);
n.setName( "piecewise");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_PIECEWISE );
n.setType(libsbml.AST_FUNCTION);
n.setName( "power");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_POWER );
n.setType(libsbml.AST_FUNCTION);
n.setName( "root");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_ROOT );
n.setType(libsbml.AST_FUNCTION);
n.setName( "sec");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_SEC );
n.setType(libsbml.AST_FUNCTION);
n.setName( "sech");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_SECH );
n.setType(libsbml.AST_FUNCTION);
n.setName( "sin");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_SIN );
n.setType(libsbml.AST_FUNCTION);
n.setName( "sinh");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_SINH );
n.setType(libsbml.AST_FUNCTION);
n.setName( "tan");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_TAN );
n.setType(libsbml.AST_FUNCTION);
n.setName( "tanh");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION_TANH );
n.setType(libsbml.AST_FUNCTION);
n.setName( "Foo");
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n.canonicalize();
assertTrue( n.getType() == libsbml.AST_FUNCTION );
n = null;
}
public void test_MathMLFormatter_csymbol_delay()
{
string expected = wrapMathML(" <apply>\n" +
" <csymbol encoding=\"text\" definitionURL=\"http://www.sbml.org/sbml/" +
"symbols/delay\"> my_delay </csymbol>\n" +
" <ci> x </ci>\n" +
" <cn> 0.1 </cn>\n" +
" </apply>\n");
N = libsbml.parseFormula("delay(x, 0.1)");
N.setName("my_delay");
S = libsbml.writeMathMLToString(N);
assertEquals( true, equals(expected,S) );
}
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;
}
//===============================================================================
//
//
// 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 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");
}
