C# libsbmlcs.SBMLDocument类代码示例

 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 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();
//.........这里部分代码省略.........