public void test_SBMLConvertStrict_convertNonStrictSBO() { SBMLDocument d = new SBMLDocument(2,4); Model m = d.createModel(); Compartment c = m.createCompartment(); c.setId( "c"); c.setConstant(false); (c).setSBOTerm(64); assertTrue( d.setLevelAndVersion(2,3,true) == false ); assertTrue( d.getLevel() == 2 ); assertTrue( d.getVersion() == 4 ); assertTrue( d.setLevelAndVersion(2,2,true) == false ); assertTrue( d.getLevel() == 2 ); assertTrue( d.getVersion() == 4 ); assertTrue( d.setLevelAndVersion(2,1,true) == true ); assertTrue( d.getLevel() == 2 ); assertTrue( d.getVersion() == 1 ); Compartment c1 = d.getModel().getCompartment(0); assertTrue( (c1).getSBOTerm() == -1 ); assertTrue( d.setLevelAndVersion(1,2,true) == true ); assertTrue( d.getLevel() == 1 ); assertTrue( d.getVersion() == 2 ); Compartment c2 = d.getModel().getCompartment(0); assertTrue( (c2).getSBOTerm() == -1 ); d = null; }
public void setUp() { string filename = "../../sbml/annotation/test/test-data/annotationL3.xml"; d = libsbml.readSBML(filename); m = d.getModel(); c = m.getCompartment(0); }
public void test_SBMLDocument_setLevelAndVersion() { SBMLDocument d = new SBMLDocument(2,2); Model m1 = new Model(2,2); d.setModel(m1); assertTrue( d.setLevelAndVersion(2,3,false) == true ); assertTrue( d.setLevelAndVersion(2,1,false) == true ); assertTrue( d.setLevelAndVersion(1,2,false) == true ); assertTrue( d.setLevelAndVersion(1,1,false) == false ); d = null; }
public void test_SBMLDocument_createWith() { SBMLDocument d = new SBMLDocument(1,2); assertTrue( d.getTypeCode() == libsbml.SBML_DOCUMENT ); assertTrue( d.getNotes() == null ); assertTrue( d.getAnnotation() == null ); assertTrue( d.getLevel() == 1 ); assertTrue( d.getVersion() == 2 ); assertTrue( d.getNumErrors() == 0 ); d = null; }
public void test_CompartmentType_parent_NULL() { SBMLDocument d = new SBMLDocument(2,4); Model m = d.createModel(); CompartmentType c = m.createCompartmentType(); CompartmentType c1 = c.clone(); d = null; assertTrue( c1.getAncestorOfType(libsbml.SBML_MODEL) == null ); assertTrue( c1.getParentSBMLObject() == null ); assertEquals(c1.getSBMLDocument(),null); c1 = null; }
public static void Main(String[] args) { if (!SBMLExtensionRegistry.isPackageEnabled("comp")) { Console.WriteLine("This copy of libSBML does not contain the 'comp' extension"); Console.WriteLine("Unable to proceed with the resolver example the model."); Environment.Exit(2); } // create custom resolver CustomResolver resolver = new CustomResolver(); // add the resolver and store its index, so we can free it later. int index = SBMLResolverRegistry.getInstance().addResolver(resolver); // create a new document with comp enabled SBMLDocument doc = new SBMLDocument(new CompPkgNamespaces()); // get a hold of a plugin object CompSBMLDocumentPlugin plugin = (CompSBMLDocumentPlugin)doc.getPlugin("comp"); // create an external model definition ExternalModelDefinition external = plugin.createExternalModelDefinition(); // set the source to the URI external.setSource("http://www.ebi.ac.uk/biomodels-main/download?mid=BMID000000063853"); // resolve the model Model model = external.getReferencedModel(); if (model == null) { Console.Error.WriteLine("couldn't resolve"); Environment.Exit(2); } // model is ready to be used now, however, only as long and the document // holding the external model definition is still alive and referenced Console.WriteLine("Model id: " + model.getId()); Console.WriteLine("# species: " + model.getNumSpecies()); Console.WriteLine("# reactions: " + model.getNumReactions()); // now that we are done get rid of the resolver SBMLResolverRegistry.getInstance().removeResolver(index); // also clear the resolver instance, just to be sure that it has // no more references to the C# resolver SBMLResolverRegistry.deleteResolerRegistryInstance(); // finally we can get rid of the C# resolver resolver = null; }
static void Main(string[] args) { SBMLNamespaces sbmlns = new SBMLNamespaces(3, 1, "distrib", 1); SBMLDocument document = new SBMLDocument(sbmlns); // set the required attribute to true DistribSBMLDocumentPlugin docPlug = (DistribSBMLDocumentPlugin) (document->getPlugin("distrib")); docPlug.setRequired(true); // create the Model Model model = document.createModel(); // create the FunctionDefintion FunctionDefinition fd = model.createFunctionDefinition(); fd.setId("mynormal"); ASTNode math = libsbml.parseFormula("lambda(param1, param2, 0)"); fd.setMath(math); // // Get a DistribFunctionDefinitionPlugin object plugged in the fd object. // // The type of the returned value of SBase::getPlugin() function is SBasePlugin, and // thus the value needs to be casted for the corresponding derived class. // DistribFunctionDefinitionPlugin fdPlugin = (DistribFunctionDefinitionPlugin)(fd.getPlugin("distrib")); // create a DrawFromDistribution object DrawFromDistribution draw = fdPlugin.createDrawFromDistribution(); // create the distribInputs DistribInput input1 = draw.createDistribInput(); input1.setId("mu"); input1.setIndex(0); DistribInput input2 = draw.createDistribInput(); input2.setId("sigma"); input2.setIndex(1); // create the UncertMLNode object UncertMLNode uncert = libsbml.createDistributionNode ("NormalDistribution", "mean, variance", "mu,sigma"); draw.setUncertML(uncert); libsbml.writeSBMLToFile(document, "distrib_example1.xml"); }
public void test_internal_consistency_check_20419() { SBMLDocument d = new SBMLDocument(3,1); long errors; Model m = d.createModel(); UnitDefinition ud = m.createUnitDefinition(); errors = d.checkInternalConsistency(); assertTrue( errors == 1 ); assertTrue( d.getError(0).getErrorId() == 20419 ); ud.setId("ud"); d.getErrorLog().clearLog(); errors = d.checkInternalConsistency(); assertTrue( errors == 0 ); d = null; }
public void test_internal_consistency_check_20306() { SBMLDocument d = new SBMLDocument(3,1); long errors; Model m = d.createModel(); FunctionDefinition fd = m.createFunctionDefinition(); fd.setId("fd"); errors = d.checkInternalConsistency(); assertTrue( errors == 1 ); assertTrue( d.getError(0).getErrorId() == 20306 ); ASTNode ast = libsbml.parseFormula("lambda(x, 2*x)"); fd.setMath(ast); errors = d.checkInternalConsistency(); assertTrue( errors == 0 ); d = null; }
public void test_SBMLConvert_convertFromL3() { SBMLDocument d = new SBMLDocument(3,1); Model m = d.createModel(); string sid = "C"; Compartment c = m.createCompartment(); c.setId(sid); c.setSize(1.2); c.setConstant(true); c.setSpatialDimensions(3.4); assertTrue( d.setLevelAndVersion(1,1,true) == false ); assertTrue( d.setLevelAndVersion(1,2,true) == false ); assertTrue( d.setLevelAndVersion(2,1,true) == false ); assertTrue( d.setLevelAndVersion(2,2,true) == false ); assertTrue( d.setLevelAndVersion(2,3,true) == false ); assertTrue( d.setLevelAndVersion(2,4,true) == false ); assertTrue( d.setLevelAndVersion(3,1,true) == true ); }
public void test_SBMLDocument_setLevelAndVersion_Error() { SBMLDocument d = new SBMLDocument(); d.setLevelAndVersion(2,1,true); Model m1 = new Model(2,1); Unit u = new Unit(2,1); u.setKind(libsbml.UnitKind_forName("mole")); u.setOffset(3.2); UnitDefinition ud = new UnitDefinition(2,1); ud.setId( "ud"); ud.addUnit(u); m1.addUnitDefinition(ud); d.setModel(m1); assertTrue( d.setLevelAndVersion(2,2,true) == false ); assertTrue( d.setLevelAndVersion(2,3,true) == false ); assertTrue( d.setLevelAndVersion(1,2,true) == false ); assertTrue( d.setLevelAndVersion(1,1,true) == false ); d = null; }
public void test_SBMLConvertStrict_convertL1ParamRule() { SBMLDocument d = new SBMLDocument(1,2); Model m = d.createModel(); Compartment c = m.createCompartment(); c.setId( "c"); Parameter p = m.createParameter(); p.setId( "p"); Parameter p1 = m.createParameter(); p1.setId( "p1"); ASTNode math = libsbml.parseFormula("p"); Rule ar = m.createAssignmentRule(); ar.setVariable( "p1"); ar.setMath(math); ar.setUnits( "mole"); assertTrue( d.setLevelAndVersion(2,1,true) == true ); assertTrue( d.getLevel() == 2 ); assertTrue( d.getVersion() == 1 ); Rule r1 = d.getModel().getRule(0); assertTrue( r1.getUnits() == "" ); d = null; }
static void Main(string[] args) { SBMLNamespaces sbmlns = new SBMLNamespaces(3, 1, "distrib", 1); SBMLDocument document = new SBMLDocument(sbmlns); // set the required attribute to true DistribSBMLDocumentPlugin docPlug = (DistribSBMLDocumentPlugin) (document->getPlugin("distrib")); docPlug.setRequired(true); // create the Model Model model = document.createModel(); // create the Parameter Parameter p = model.createParameter(); p.setId("V"); p.setConstant(true); // // Get a DistribSBasePlugin object plugged in the parameter object. // DistribSBasePlugin pPlugin = (DistribSBasePlugin)(p.getPlugin("distrib")); // create a Uncertainty object Uncertainty uncert = pPlugin.createUncertainty(); // create the UncertMLNode object UncertMLNode uncertML = libsbml.createDistributionNode ("Statistics", "Mean, Variance", "V_pop, V_omega"); uncert.setUncertML(uncertML); libsbml.writeSBMLToFile(document, "distrib_example2.xml"); }
public void test_SBMLConvert_addModifiersToReaction() { SBMLDocument d = new SBMLDocument(1,2); Model m = d.createModel(); Reaction r = m.createReaction(); KineticLaw kl = r.createKineticLaw(); kl.setFormula( "k1*S1*S2*S3*S4*S5"); SimpleSpeciesReference ssr1; SimpleSpeciesReference ssr2; Species s1 = m.createSpecies(); s1.setId( "S1" ); Species s2 = m.createSpecies(); s2.setId( "S2"); Species s3 = m.createSpecies(); s3.setId( "S3"); Species s4 = m.createSpecies(); s4.setId( "S4"); Species s5 = m.createSpecies(); s5.setId( "S5"); SpeciesReference sr1 = r.createReactant(); SpeciesReference sr2 = r.createReactant(); SpeciesReference sr3 = r.createProduct(); sr1.setSpecies( "S1"); sr2.setSpecies( "S2"); sr3.setSpecies( "S5"); assertTrue( r.getNumModifiers() == 0 ); assertTrue( d.setLevelAndVersion(2,1,false) == true ); assertTrue( d.getLevel() == 2 ); assertTrue( d.getVersion() == 1 ); assertTrue( m.getReaction(0).getNumModifiers() == 2 ); ssr1 = m.getReaction(0).getModifier(0); ssr2 = m.getReaction(0).getModifier(1); assertTrue(( "S3" == ssr1.getSpecies() )); assertTrue(( "S4" == ssr2.getSpecies() )); d = null; }
/** * * Writes the given SBMLDocument to the given file. * */ private static bool writeExampleSBML(SBMLDocument sbmlDoc, string filename) { int result = libsbml.writeSBML(sbmlDoc, filename); if (result == 1) { Console.WriteLine("Wrote file \"" + filename + "\""); return true; } else { Console.WriteLine("Failed to write \"" + filename + "\""); return false; } }
//=============================================================================== // // // 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; }
//=============================================================================== // // // Helper functions for writing/validating the given SBML documents. // // //=============================================================================== /** * * Validates the given SBMLDocument. * * This function is based on validateSBML.cpp implemented by * Sarah Keating, Ben Bornstein, and Michael Hucka. * */ private static bool validateExampleSBML(SBMLDocument sbmlDoc) { if (sbmlDoc == null) { Console.Error.WriteLine("validateExampleSBML: given a null SBML Document"); return false; } string consistencyMessages = ""; string validationMessages = ""; bool noProblems = true; int numCheckFailures = 0; int numConsistencyErrors = 0; int numConsistencyWarnings = 0; int numValidationErrors = 0; int numValidationWarnings = 0; // LibSBML 3.3 is lenient when generating models from scratch using the // API for creating objects. Once the whole model is done and before it // gets written out, it's important to check that the whole model is in // fact complete, consistent and valid. numCheckFailures = (int)sbmlDoc.checkInternalConsistency(); if (numCheckFailures > 0) { noProblems = false; for (int i = 0; i < numCheckFailures; i++) { SBMLError sbmlErr = sbmlDoc.getError(i); if (sbmlErr.isFatal() || sbmlErr.isError()) { ++numConsistencyErrors; } else { ++numConsistencyWarnings; } } consistencyMessages = sbmlDoc.getErrorLog().toString(); } // If the internal checks fail, it makes little sense to attempt // further validation, because the model may be too compromised to // be properly interpreted. if (numConsistencyErrors > 0) { consistencyMessages += "Further validation aborted."; } else { numCheckFailures = (int)sbmlDoc.checkConsistency(); if (numCheckFailures > 0) { noProblems = false; for (int i = 0; i < numCheckFailures; i++) { SBMLError sbmlErr = sbmlDoc.getError(i); if (sbmlErr.isFatal() || sbmlErr.isError()) { ++numValidationErrors; } else { ++numValidationWarnings; } } validationMessages = sbmlDoc.getErrorLog().toString(); } } if (noProblems) return true; else { if (numConsistencyErrors > 0) { Console.WriteLine("ERROR: encountered " + numConsistencyErrors + " consistency error" + (numConsistencyErrors == 1 ? "" : "s") + " in model '" + sbmlDoc.getModel().getId() + "'."); } if (numConsistencyWarnings > 0) { Console.WriteLine("Notice: encountered " + numConsistencyWarnings + " consistency warning" + (numConsistencyWarnings == 1 ? "" : "s") + " in model '" + sbmlDoc.getModel().getId() + "'."); } Console.WriteLine(); Console.WriteLine(consistencyMessages); if (numValidationErrors > 0) { Console.WriteLine("ERROR: encountered " + numValidationErrors + " validation error" + (numValidationErrors == 1 ? "" : "s") + " in model '" + sbmlDoc.getModel().getId() + "'."); } if (numValidationWarnings > 0) { Console.WriteLine("Notice: encountered " + numValidationWarnings + " validation warning" + (numValidationWarnings == 1 ? "" : "s") + " in model '" + sbmlDoc.getModel().getId() + "'."); } Console.WriteLine(); Console.WriteLine(validationMessages); return (numConsistencyErrors == 0 && numValidationErrors == 0); } }
public void test_SBMLDocument_constructor() { SBase s; try { s = new SBMLDocument(1,1); s = new SBMLDocument(1,2); s = new SBMLDocument(2,1); s = new SBMLDocument(2,2); s = new SBMLDocument(2,3); s = new SBMLDocument(2,4); s = new SBMLDocument(3,1); s = new SBMLDocument(SN11); s = new SBMLDocument(SN12); s = new SBMLDocument(SN21); s = new SBMLDocument(SN22); s = new SBMLDocument(SN23); s = new SBMLDocument(SN24); s = new SBMLDocument(SN31); } catch (SBMLConstructorException e) { s = null; } assertTrue(s != null); string msg = ""; try { s = new SBMLDocument(9,9); } catch (SBMLConstructorException e) { msg = e.Message; } assertTrue(msg == ErrMsg); msg = ""; try { s = new SBMLDocument(SN99); } catch (SBMLConstructorException e) { msg = e.Message; } assertTrue(msg == ErrMsg); }
static void testWriteSBML(SBMLDocument d, string file) { try { if ( libsbml.writeSBML(d, file) == 0) { ERR("[WriteSBML] Error: cannot write " + file); } else { OK(); } } catch (Exception e) { ERR("[WriteSBML] (" + file + ") Error: Exception thrown : " + e.Message); } try { string sbmlstr = libsbml.writeSBMLToString(d); if ( libsbml.writeSBML(libsbml.readSBMLFromString(sbmlstr), file) == 0) { ERR("[WriteSBML] Error: cannot write " + file); } else { OK(); } } catch (Exception e) { ERR("[WriteSBML] (" + file + ") Error: Exception thrown : " + e.Message); } }
static void testWriteCompressedSBML(SBMLDocument d, string file) { if ( SBMLWriter.hasZlib() ) { // // write/read gzip file // string cfile = file + ".gz"; try { if ( libsbml.writeSBML(d, cfile) == 0) { ERR("[WriteCompressedSBML] Error: cannot write " + file + ".gz"); } else { OK(); } } catch (Exception e) { ERR("[WriteCompressedSBML] (" + cfile + ") Error: Exception thrown : " + e.Message); } // // write/read zip file // cfile = file + ".zip"; try { if ( libsbml.writeSBML(d, cfile) == 0) { ERR("[WriteCompressedSBML] Error: cannot write " + file + ".zip"); } else { OK(); } } catch (Exception e) { ERR("[WriteCompressedSBML] (" + cfile + ") Error: Exception thrown : " + e.Message); } } if ( SBMLWriter.hasBzip2() ) { // // write/read bzip2 file // string cfile = file + ".bz2"; try { if (libsbml.writeSBML(d, cfile) == 0) { ERR("[WriteCompressedSBML] Error: cannot write " + cfile); } else { if ( libsbml.readSBML(cfile) == null) { ERR("[WriteCompressedSBML] Error: failed to read " + cfile); } else { OK(); } } } catch (Exception e) { ERR("[WriteCompressedSBML] (" + cfile + ") Error: Exception thrown : " + e.Message); } } }
static void testCreateSBML() { SBMLDocument d = new SBMLDocument(defLevel,defVersion); Model m = d.createModel(); m.setId("testmodel"); Compartment c1 = m.createCompartment(); Compartment c2 = m.createCompartment(); c1.setId("c1"); c2.setId("c2"); Species s1 = m.createSpecies(); Species s2 = m.createSpecies(); string id1 = "s1"; string id2 = "s2"; // strings with non-ASCII characters (multibyte characters) string n1 = "γ-lyase"; string n2 = "β-synthase"; s1.setId(id1); s1.setName(n1); s1.setCompartment("c1"); s2.setId(id2); s2.setName(n2); s2.setCompartment("c2"); string file = "test2.xml"; try { if ( libsbml.writeSBML(d, file) == 0) { ERR("[CreateSBML] Error: cannot write " + file); } else { OK(); } } catch (Exception e) { ERR("[CreateSBML] (" + file + ") Error: Exception thrown : " + e.Message); } testReadSBMLFromFile(file); }
/** */ /* libsbml-internal */ public string writeToString(SBMLDocument d) { string ret = libsbmlPINVOKE.SBMLWriter_writeToString(swigCPtr, SBMLDocument.getCPtr(d)); return ret; }
/** * Writes the given SBML document to filename. * * @htmlinclude assuming-compressed-file.html * * @param d the SBML document to be written * * @param filename the name or full pathname of the file where the SBML * is to be written. * * @return @c true on success and @c false if the filename could not be * opened for writing. * * @note @htmlinclude note-writing-zipped-files.html * * @see setProgramVersion(string version) * @see setProgramName(string name) */ public bool writeSBMLToFile(SBMLDocument d, string filename) { bool ret = libsbmlPINVOKE.SBMLWriter_writeSBMLToFile(swigCPtr, SBMLDocument.getCPtr(d), filename); if (libsbmlPINVOKE.SWIGPendingException.Pending) throw libsbmlPINVOKE.SWIGPendingException.Retrieve(); return ret; }
/** * Writes the given SBML document to the output stream. * * @param d the SBML document to be written * * @param stream the stream object where the SBML is to be written. * * @return @c true on success and @c false if one of the underlying * parser components fail (rare). * * @see setProgramVersion(string version) * @see setProgramName(string name) */ public bool writeSBML(SBMLDocument d, OStream stream) { bool ret = libsbmlPINVOKE.SBMLWriter_writeSBML__SWIG_1(swigCPtr, SBMLDocument.getCPtr(d), SWIGTYPE_p_std__ostream.getCPtr(stream.get_ostream())); if (libsbmlPINVOKE.SWIGPendingException.Pending) throw libsbmlPINVOKE.SWIGPendingException.Retrieve(); return ret; }
/** * Validates the given SBMLDocument object. * * This is identical to calling setDocument(@if java SBMLDocument @endif) * followed by validate(). * * @param d the SBML document to validate * * @return the number of validation failures that occurred. The objects * describing the actual failures can be retrieved using getFailures(). */ public long validate(SBMLDocument d) { return (long)libsbmlPINVOKE.SBMLValidator_validate__SWIG_1(swigCPtr, SBMLDocument.getCPtr(d)); }
/** * Sets the current SBML document to the given SBMLDocument object. * * @param doc the document to use for this validation * * @return an integer value indicating the success/failure of the * validation. @if clike The value is drawn from the enumeration * #OperationReturnValues_t. @endif The possible values returned by this * function are * @li @link libsbmlcs#LIBSBML_OPERATION_SUCCESS LIBSBML_OPERATION_SUCCESS@endlink * * @see getDocument() */ public new int setDocument(SBMLDocument doc) { int ret = (SwigDerivedClassHasMethod("setDocument", swigMethodTypes3) ? libsbmlPINVOKE.SBMLValidator_setDocumentSwigExplicitSBMLValidator(swigCPtr, SBMLDocument.getCPtr(doc)) : libsbmlPINVOKE.SBMLValidator_setDocument(swigCPtr, SBMLDocument.getCPtr(doc))); return ret; }
/** * * Creates an SBML model represented in "7.8 Example involving function definitions" * in the SBML Level 2 Version 4 Specification. * */ private static SBMLDocument createExampleInvolvingFunctionDefinitions() { int level = Level; int version = Version; //--------------------------------------------------------------------------- // // Creates an SBMLDocument object // //--------------------------------------------------------------------------- SBMLDocument sbmlDoc = new SBMLDocument(level, version); //--------------------------------------------------------------------------- // // Creates a Model object inside the SBMLDocument object. // //--------------------------------------------------------------------------- Model model = sbmlDoc.createModel(); model.setId("functionExample"); //--------------------------------------------------------------------------- // // Creates a FunctionDefinition object inside the Model object. // //--------------------------------------------------------------------------- FunctionDefinition fdef = model.createFunctionDefinition(); fdef.setId("f"); // Sets a math (ASTNode object) to the FunctionDefinition object. string mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">" + " <lambda>" + " <bvar>" + " <ci> x </ci>" + " </bvar>" + " <apply>" + " <times/>" + " <ci> x </ci>" + " <cn> 2 </cn>" + " </apply>" + " </lambda>" + "</math>"; ASTNode astMath = libsbml.readMathMLFromString(mathXMLString); fdef.setMath(astMath); //--------------------------------------------------------------------------- // // Creates a Compartment object inside the Model object. // //--------------------------------------------------------------------------- Compartment comp; const string compName = "compartmentOne"; // Creates a Compartment object ("compartmentOne") comp = model.createCompartment(); comp.setId(compName); // Sets the "size" attribute of the Compartment object. // // The units of this Compartment object is the default SBML // units of volume (litre), and thus we don't have to explicitly invoke // setUnits("litre") function to set the default units. // comp.setSize(1); //--------------------------------------------------------------------------- // // Creates Species objects inside the Model object. // //--------------------------------------------------------------------------- Species sp; //--------------------------------------------------------------------------- // (Species1) Creates a Species object ("S1") //--------------------------------------------------------------------------- sp = model.createSpecies(); sp.setId("S1"); // Sets the "compartment" attribute of the Species object to identify the // compartnet in which the Species object located. sp.setCompartment(compName); // Sets the "initialConcentration" attribute of the Species object. // // The units of this Species object is determined by two attributes of this // Species object ("substanceUnits" and "hasOnlySubstanceUnits") and the // "spatialDimension" attribute of the Compartment object ("cytosol") in which // this species object located. // Since the default values are used for "substanceUnits" (substance (mole)) // and "hasOnlySubstanceUnits" (false) and the value of "spatialDimension" (3) // is greater than 0, the units of this Species object is mole/litre . // sp.setInitialConcentration(1); //--------------------------------------------------------------------------- // (Species2) Creates a Species object ("S2") //--------------------------------------------------------------------------- sp = model.createSpecies(); sp.setId("S2"); sp.setCompartment(compName); sp.setInitialConcentration(0); //--------------------------------------------------------------------------- // // Creates a global Parameter object inside the Model object. // //--------------------------------------------------------------------------- Parameter para; // Creates a Parameter ("t") para = model.createParameter(); para.setId("t"); para.setValue(1); para.setUnits("second"); //--------------------------------------------------------------------------- // // Creates Reaction objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointers. Reaction reaction; SpeciesReference spr; KineticLaw kl; //--------------------------------------------------------------------------- // (Reaction1) Creates a Reaction object ("reaction_1"). //--------------------------------------------------------------------------- reaction = model.createReaction(); reaction.setId("reaction_1"); reaction.setReversible(false); //--------------------------------------------------------------------------- // Creates Reactant objects inside the Reaction object ("reaction_1"). //--------------------------------------------------------------------------- // (Reactant1) Creates a Reactant object that references Species "S1" // in the model. spr = reaction.createReactant(); spr.setSpecies("S1"); //--------------------------------------------------------------------------- // Creates a Product object inside the Reaction object ("reaction_1"). //--------------------------------------------------------------------------- // Creates a Product object that references Species "S2" in the model. spr = reaction.createProduct(); spr.setSpecies("S2"); //--------------------------------------------------------------------------- // Creates a KineticLaw object inside the Reaction object ("reaction_1"). //--------------------------------------------------------------------------- kl = reaction.createKineticLaw(); //--------------------------------------------------------------------------- // Sets a math (ASTNode object) to the KineticLaw object. //--------------------------------------------------------------------------- mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">" + " <apply>" + " <divide/>" + " <apply>" + " <times/>" + " <apply>" + " <ci> f </ci>" + " <ci> S1 </ci>" + " </apply>" + " <ci> compartmentOne </ci>" + " </apply>" + " <ci> t </ci>" + " </apply>" + "</math>"; astMath = libsbml.readMathMLFromString(mathXMLString); kl.setMath(astMath); // Returns the created SBMLDocument object. // The returned object must be explicitly deleted by the caller, // otherwise memory leak will happen. return sbmlDoc; }
public void test_SBMLConvertStrict_convertToL1() { SBMLDocument d = new SBMLDocument(2,4); Model m = d.createModel(); (m).setMetaId( "_m"); Compartment c = m.createCompartment(); c.setId( "c"); (c).setSBOTerm(240); Species s = m.createSpecies(); s.setId( "s"); s.setCompartment( "c"); assertTrue( d.setLevelAndVersion(1,2,true) == true ); assertTrue( d.getLevel() == 1 ); assertTrue( d.getVersion() == 2 ); Model m1 = d.getModel(); assertTrue( (m1).getMetaId() == "" ); Compartment c1 = m1.getCompartment(0); assertTrue( (c1).getSBOTerm() == -1 ); Species s1 = m1.getSpecies(0); assertTrue( s1.getHasOnlySubstanceUnits() == false ); d = null; }
/** * * Creates an SBML model represented in "7.2 Example involving units" * in the SBML Level 2 Version 4 Specification. * */ private static SBMLDocument createExampleInvolvingUnits() { int level = Level; int version = Version; //--------------------------------------------------------------------------- // // Creates an SBMLDocument object // //--------------------------------------------------------------------------- SBMLDocument sbmlDoc = new SBMLDocument(level, version); // Adds the namespace for XHTML to the SBMLDocument object. We need this // because we will add notes to the model. (By default, the SBML document // created by SBMLDocument only declares the SBML XML namespace.) sbmlDoc.getNamespaces().add("http://www.w3.org/1999/xhtml", "xhtml"); //--------------------------------------------------------------------------- // // Creates a Model object inside the SBMLDocument object. // //--------------------------------------------------------------------------- Model model = sbmlDoc.createModel(); model.setId("unitsExample"); //--------------------------------------------------------------------------- // // Creates UnitDefinition objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointers (reused more than once below). UnitDefinition unitdef; Unit unit; //--------------------------------------------------------------------------- // (UnitDefinition1) Creates an UnitDefinition object ("substance"). // // This has the effect of redefining the default unit of subtance for the // whole model. //--------------------------------------------------------------------------- unitdef = model.createUnitDefinition(); unitdef.setId("substance"); // Creates an Unit inside the UnitDefinition object unit = unitdef.createUnit(); unit.setKind(libsbml.UNIT_KIND_MOLE); unit.setScale(-3); //-------------------------------------------------------------------------------- // (UnitDefinition2) Creates an UnitDefinition object ("mmls") //-------------------------------------------------------------------------------- // Note that we can reuse the pointers 'unitdef' and 'unit' because the // actual UnitDefinition object (along with the Unit objects within it) // is already attached to the Model object. unitdef = model.createUnitDefinition(); unitdef.setId("mmls"); // Creates an Unit inside the UnitDefinition object ("mmls") unit = unitdef.createUnit(); unit.setKind(libsbml.UNIT_KIND_MOLE); unit.setScale(-3); // Creates an Unit inside the UnitDefinition object ("mmls") unit = unitdef.createUnit(); unit.setKind(libsbml.UNIT_KIND_LITRE); unit.setExponent(-1); // Creates an Unit inside the UnitDefinition object ("mmls") unit = unitdef.createUnit(); unit.setKind(libsbml.UNIT_KIND_SECOND); unit.setExponent(-1); //-------------------------------------------------------------------------------- // (UnitDefinition3) Creates an UnitDefinition object ("mml") //-------------------------------------------------------------------------------- unitdef = model.createUnitDefinition(); unitdef.setId("mml"); // Creates an Unit inside the UnitDefinition object ("mml") unit = unitdef.createUnit(); unit.setKind(libsbml.UNIT_KIND_MOLE); unit.setScale(-3); // Creates an Unit inside the UnitDefinition object ("mml") unit = unitdef.createUnit(); unit.setKind(libsbml.UNIT_KIND_LITRE); unit.setExponent(-1); //--------------------------------------------------------------------------- // // Creates a Compartment object inside the Model object. // //--------------------------------------------------------------------------- Compartment comp; string compName = "cell"; // Creates a Compartment object ("cell") comp = model.createCompartment(); comp.setId(compName); // Sets the "size" attribute of the Compartment object. // // The units of this Compartment object is the default SBML // units of volume (litre), and thus we don't have to explicitly invoke // setUnits("litre") function to set the default units. // comp.setSize(1); //--------------------------------------------------------------------------- // // Creates Species objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointer (reused more than once below). Species sp; //--------------------------------------------------------------------------- // (Species1) Creates a Species object ("x0") //--------------------------------------------------------------------------- sp = model.createSpecies(); sp.setId("x0"); // Sets the "compartment" attribute of the Species object to identify the // compartnet in which the Species object located. sp.setCompartment(compName); // Sets the "initialConcentration" attribute of the Species object. // // The units of this Species object is determined by two attributes of this // Species object ("substanceUnits" and "hasOnlySubstanceUnits") and the // "spatialDimensions" attribute of the Compartment object ("cytosol") in which // this species object is located. // Since the default values are used for "substanceUnits" (substance (mole)) // and "hasOnlySubstanceUnits" (false) and the value of "spatialDimension" (3) // is greater than 0, the units of this Species object is moles/liters . // sp.setInitialConcentration(1); //--------------------------------------------------------------------------- // (Species2) Creates a Species object ("x1") //--------------------------------------------------------------------------- sp = model.createSpecies(); sp.setId("x1"); sp.setCompartment(compName); sp.setInitialConcentration(1); //--------------------------------------------------------------------------- // (Species3) Creates a Species object ("s1") //--------------------------------------------------------------------------- sp = model.createSpecies(); sp.setCompartment(compName); sp.setId("s1"); sp.setInitialConcentration(1); //--------------------------------------------------------------------------- // (Species4) Creates a Species object ("s2") //--------------------------------------------------------------------------- sp = model.createSpecies(); sp.setCompartment(compName); sp.setId("s2"); sp.setInitialConcentration(1); //--------------------------------------------------------------------------- // // Creates global Parameter objects inside the Model object. // //--------------------------------------------------------------------------- Parameter para; // Creates a Parameter ("vm") para = model.createParameter(); para.setId("vm"); para.setValue(2); para.setUnits("mmls"); // Creates a Parameter ("km") para = model.createParameter(); para.setId("km"); para.setValue(2); para.setUnits("mml"); //--------------------------------------------------------------------------- // // Creates Reaction objects inside the Model object. // //--------------------------------------------------------------------------- // Temporary pointers. Reaction reaction; SpeciesReference spr; KineticLaw kl; //--------------------------------------------------------------------------- // (Reaction1) Creates a Reaction object ("v1"). //--------------------------------------------------------------------------- reaction = model.createReaction(); reaction.setId("v1"); //--------------------------------------------------------------------------- // Creates Reactant objects inside the Reaction object ("v1"). //--------------------------------------------------------------------------- // (Reactant1) Creates a Reactant object that references Species "x0" // in the model. spr = reaction.createReactant(); spr.setSpecies("x0"); //--------------------------------------------------------------------------- // Creates a Product object inside the Reaction object ("v1"). //--------------------------------------------------------------------------- // Creates a Product object that references Species "s1" in the model. spr = reaction.createProduct(); spr.setSpecies("s1"); //--------------------------------------------------------------------------- // Creates a KineticLaw object inside the Reaction object ("v1"). //--------------------------------------------------------------------------- kl = reaction.createKineticLaw(); // Creates a <notes> element in the KineticLaw object. // Here we illustrate how to do it using a literal string. This requires // known the required syntax of XHTML and the requirements for SBML <notes> // elements. Later below, we show how to create notes using objects instead // of strings. string notesString = "<xhtml:p> ((vm * s1)/(km + s1)) * cell </xhtml:p>"; kl.setNotes(notesString); //--------------------------------------------------------------------------- // Creates an ASTNode object which represents the following KineticLaw object. // // <math xmlns=\"http://www.w3.org/1998/Math/MathML\"> // <apply> // <times/> // <apply> // <divide/> // <apply> // <times/> // <ci> vm </ci> // <ci> s1 </ci> // </apply> // <apply> // <plus/> // <ci> km </ci> // <ci> s1 </ci> // </apply> // </apply> // <ci> cell </ci> // </apply> // </math> //--------------------------------------------------------------------------- // // In the following code, ASTNode objects, which construct an ASTNode tree // of the above math, are created and added in the order of preorder traversal // of the tree (i.e. the order corresponds to the nested structure of the above // MathML elements), and thus the following code maybe a bit more efficient but // maybe a bit difficult to read. // ASTNode astMath = new ASTNode(libsbml.AST_TIMES); astMath.addChild(new ASTNode(libsbml.AST_DIVIDE)); ASTNode astDivide = astMath.getLeftChild(); astDivide.addChild(new ASTNode(libsbml.AST_TIMES)); ASTNode astTimes = astDivide.getLeftChild(); astTimes.addChild(new ASTNode(libsbml.AST_NAME)); astTimes.getLeftChild().setName("vm"); astTimes.addChild(new ASTNode(libsbml.AST_NAME)); astTimes.getRightChild().setName("s1"); astDivide.addChild(new ASTNode(libsbml.AST_PLUS)); ASTNode astPlus = astDivide.getRightChild(); astPlus.addChild(new ASTNode(libsbml.AST_NAME)); astPlus.getLeftChild().setName("km"); astPlus.addChild(new ASTNode(libsbml.AST_NAME)); astPlus.getRightChild().setName("s1"); astMath.addChild(new ASTNode(libsbml.AST_NAME)); astMath.getRightChild().setName("cell"); //--------------------------------------------- // // set the Math element // //------------------------------------------------ kl.setMath(astMath); //--------------------------------------------------------------------------- // (Reaction2) Creates a Reaction object ("v2"). //--------------------------------------------------------------------------- reaction = model.createReaction(); reaction.setId("v2"); //--------------------------------------------------------------------------- // Creates Reactant objects inside the Reaction object ("v2"). //--------------------------------------------------------------------------- // (Reactant2) Creates a Reactant object that references Species "s1" // in the model. spr = reaction.createReactant(); spr.setSpecies("s1"); //--------------------------------------------------------------------------- // Creates a Product object inside the Reaction object ("v2"). //--------------------------------------------------------------------------- // Creates a Product object that references Species "s2" in the model. spr = reaction.createProduct(); spr.setSpecies("s2"); //--------------------------------------------------------------------------- // Creates a KineticLaw object inside the Reaction object ("v2"). //--------------------------------------------------------------------------- kl = reaction.createKineticLaw(); // Sets a notes (by XMLNode) to the KineticLaw object. // // The following code is an alternative to using setNotes(const string&). // The equivalent code would be like this: // // notesString = "<xhtml:p>((vm * s2)/(km + s2))*cell</xhtml:p>"; // kl.setNotes(notesString); // Creates an XMLNode of start element (<xhtml:p>) without attributes. XMLNode notesXMLNode = new XMLNode( new XMLTriple("p", "", "xhtml"), new XMLAttributes()); // Adds a text element to the start element. notesXMLNode.addChild(new XMLNode(" ((vm * s2)/(km + s2)) * cell ")); // Adds it to the kineticLaw object. kl.setNotes(notesXMLNode); //--------------------------------------------------------------------------- // Sets a math (ASTNode object) to the KineticLaw object. //--------------------------------------------------------------------------- // To create mathematical expressions, one would typically construct // an ASTNode tree as the above example code which creates a math of another // KineticLaw object. Here, to save some space and illustrate another approach // of doing it, we will write out the formula in MathML form and then use a // libSBML convenience function to create the ASTNode tree for us. // (This is a bit dangerous; it's very easy to make mistakes when writing MathML // by hand, so in a real program, we would not really want to do it this way.) string mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">" + " <apply>" + " <times/>" + " <apply>" + " <divide/>" + " <apply>" + " <times/>" + " <ci> vm </ci>" + " <ci> s2 </ci>" + " </apply>" + " <apply>" + " <plus/>" + " <ci> km </ci>" + " <ci> s2 </ci>" + " </apply>" + " </apply>" + " <ci> cell </ci>" + " </apply>" + "</math>"; astMath = libsbml.readMathMLFromString(mathXMLString); kl.setMath(astMath); //--------------------------------------------------------------------------- // (Reaction3) Creates a Reaction object ("v3"). //--------------------------------------------------------------------------- reaction = model.createReaction(); reaction.setId("v3"); //--------------------------------------------------------------------------- // Creates Reactant objects inside the Reaction object ("v3"). //--------------------------------------------------------------------------- // (Reactant2) Creates a Reactant object that references Species "s2" // in the model. spr = reaction.createReactant(); spr.setSpecies("s2"); //--------------------------------------------------------------------------- // Creates a Product object inside the Reaction object ("v3"). //--------------------------------------------------------------------------- // Creates a Product object that references Species "x1" in the model. spr = reaction.createProduct(); spr.setSpecies("x1"); //--------------------------------------------------------------------------- // Creates a KineticLaw object inside the Reaction object ("v3"). //--------------------------------------------------------------------------- kl = reaction.createKineticLaw(); // Sets a notes (by string) to the KineticLaw object. notesString = "<xhtml:p> ((vm * x1)/(km + x1)) * cell </xhtml:p>"; kl.setNotes(notesString); //--------------------------------------------------------------------------- // Sets a math (ASTNode object) to the KineticLaw object. //--------------------------------------------------------------------------- mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">" + " <apply>" + " <times/>" + " <apply>" + " <divide/>" + " <apply>" + " <times/>" + " <ci> vm </ci>" + " <ci> x1 </ci>" + " </apply>" + " <apply>" + " <plus/>" + " <ci> km </ci>" + " <ci> x1 </ci>" + " </apply>" + " </apply>" + " <ci> cell </ci>" + " </apply>" + "</math>"; astMath = libsbml.readMathMLFromString(mathXMLString); kl.setMath(astMath); // Returns the created SBMLDocument object. // The returned object must be explicitly deleted by the caller, // otherwise memory leak will happen. return sbmlDoc; }
public void test_SBMLConvertStrict_convertNonStrictUnits() { SBMLDocument d = new SBMLDocument(2,4); Model m = d.createModel(); Compartment c = m.createCompartment(); c.setId( "c"); c.setConstant(false); Parameter p = m.createParameter(); p.setId( "p"); p.setUnits( "mole"); ASTNode math = libsbml.parseFormula("p"); Rule ar = m.createAssignmentRule(); ar.setVariable( "c"); ar.setMath(math); assertTrue( d.setLevelAndVersion(2,1,true) == false ); assertTrue( d.getLevel() == 2 ); assertTrue( d.getVersion() == 4 ); assertTrue( d.setLevelAndVersion(2,2,true) == false ); assertTrue( d.getLevel() == 2 ); assertTrue( d.getVersion() == 4 ); assertTrue( d.setLevelAndVersion(2,3,true) == false ); assertTrue( d.getLevel() == 2 ); assertTrue( d.getVersion() == 4 ); assertTrue( d.setLevelAndVersion(1,2,true) == false ); assertTrue( d.getLevel() == 2 ); assertTrue( d.getVersion() == 4 ); d = null; }