C# Model.createReaction方法代码示例

 public void test_Model_createReaction()
 {
     Model m = new  Model(2,2);
       Reaction p = m.createReaction();
       assertTrue( m.getNumReactions() == 1 );
       assertTrue( (p).getLevel() == 2 );
       assertTrue( (p).getVersion() == 2 );
       m = null;
 }

 public void test_Model_createKineticLawParameters()
 {
     Model m = new  Model(2,2);
       Reaction r = m.createReaction();
       KineticLaw kl = m.createKineticLaw();
       Parameter p = m.createKineticLawParameter();
       assertTrue( r.isSetKineticLaw() == true );
       assertTrue( kl.getNumParameters() == 1 );
       assertTrue( (p).getLevel() == 2 );
       assertTrue( (p).getVersion() == 2 );
       m = null;
 }

 public void test_Model_createReactant()
 {
     Model m = new  Model(2,2);
       Reaction p = m.createReaction();
       SpeciesReference sr = m.createReactant();
       assertTrue( p.getNumReactants() == 1 );
       assertTrue( (sr).getLevel() == 2 );
       assertTrue( (sr).getVersion() == 2 );
       m = null;
 }

 public void test_Model_L1V1()
 {
     Model m = new Model(1,1);
       assertEquals( false, (m.hasRequiredElements()) );
       m.createCompartment();
       assertEquals( false, (m.hasRequiredElements()) );
       m.createSpecies();
       assertEquals( false, (m.hasRequiredElements()) );
       m.createReaction();
       assertEquals( true, m.hasRequiredElements() );
       m = null;
 }

 public void test_Model_createKineticLaw()
 {
     Model m = new  Model(2,2);
       Reaction p = m.createReaction();
       KineticLaw kl = m.createKineticLaw();
       assertTrue( p.isSetKineticLaw() == true );
       assertTrue( (kl).getLevel() == 2 );
       assertTrue( (kl).getVersion() == 2 );
       m = null;
 }

 public void test_SpeciesReference_Modifier_parent_create_model()
 {
     Model m = new Model(2,4);
       Reaction r = m.createReaction();
       ModifierSpeciesReference sr = m.createModifier();
       ListOf lo = r.getListOfModifiers();
       assertTrue( lo == sr.getParentSBMLObject() );
       assertTrue( lo == r.getModifier(0).getParentSBMLObject() );
       assertTrue( r == lo.getParentSBMLObject() );
 }

 public void test_SpeciesReference_Reactant_parent_create_model()
 {
     Model m = new Model(2,4);
       Reaction r = m.createReaction();
       SpeciesReference sr = m.createReactant();
       ListOf lo = r.getListOfReactants();
       assertTrue( lo == r.getReactant(0).getParentSBMLObject() );
       assertTrue( lo == sr.getParentSBMLObject() );
       assertTrue( r == lo.getParentSBMLObject() );
 }

 public void test_KineticLaw_parent_create_model()
 {
     Model m = new Model(2,4);
       Reaction r = m.createReaction();
       KineticLaw kl = r.createKineticLaw();
       assertTrue( r == kl.getParentSBMLObject() );
       assertTrue( r == r.getKineticLaw().getParentSBMLObject() );
       r = null;
 }

 public void test_Reaction_parent_create()
 {
     Model m = new Model(2,4);
       Reaction r = m.createReaction();
       ListOf lo = m.getListOfReactions();
       assertTrue( lo == m.getReaction(0).getParentSBMLObject() );
       assertTrue( lo == r.getParentSBMLObject() );
       assertTrue( m == lo.getParentSBMLObject() );
 }

        private static void createReaction(EcellObject anEml, Model aSBMLModel)
        {
            EcellProcess aProcess = (EcellProcess)anEml;
            List<EcellReference> aVariableReferenceList = aProcess.ReferenceList;
            string anExpression = aProcess.Expression;
            // ------------------
            //  make Rule object
            // ------------------
            if ( anEml.ParentSystemID == "/SBMLRule" )
            {
                // get Process Class

                anExpression = convertExpression(
                    anExpression,
                    aVariableReferenceList,
                    aProcess.ParentSystemID);

                if( aProcess.Classname == ProcessConstants.ExpressionAlgebraicProcess )
                {
                    // create AlgebraicRule object
                    AlgebraicRule anAlgebraicRule = aSBMLModel.createAlgebraicRule();

                    // set AlgebraicRule Formula
                    anAlgebraicRule.setFormula( anExpression );
                }
                else if( aProcess.Classname == ProcessConstants.ExpressionAssignmentProcess )
                {
                    foreach(EcellReference aVariableReference in aVariableReferenceList)
                    {
                        if ( aVariableReference.Coefficient != 0 )
                        {
                            // create AssignmentRule object
                            AssignmentRule anAssignmentRule =aSBMLModel.createAssignmentRule();
                            // set AssignmentRule Formula
                            anAssignmentRule.setFormula( aVariableReference.Coefficient.ToString() + "* ( " + anExpression + ")" );
                            string aVariableID = getVariableReferenceId( aVariableReference.FullID, aProcess.ParentSystemID );
                            anAssignmentRule.setVariable( aVariableID );
                        }
                    }
                }
                else if( aProcess.Classname == ProcessConstants.ExpressionFluxProcess )
                {
                    foreach(EcellReference aVariableReference in aVariableReferenceList)
                    {
                        if ( aVariableReference.Coefficient != 0 )
                        {
                            // create AssignmentRule object
                            RateRule aRateRule = aSBMLModel.createRateRule();

                            // set AssignmentRule Formula
                            aRateRule.setFormula( aVariableReference.Coefficient + "* ( " + anExpression + ")" );

                            string aVariableID = getVariableReferenceId( aVariableReference.FullID, aProcess.ParentSystemID );
                            aRateRule.setVariable( aVariableID );
                        }
                    }
                }
                else
                {
                    throw new EcellException("The type of Process must be Algebraic, Assignment, Flux Processes: " + aProcess.Key);
                }

            }
            // ----------------------
            //  make Reaction object
            // ----------------------
            else
            {
                // create Parameter object
                Reaction aReaction = aSBMLModel.createReaction();

                // create KineticLaw Object
                KineticLaw aKineticLaw = aSBMLModel.createKineticLaw();

                // set Reaction ID
                if (aSBMLModel.getLevel() == 1)
                    aReaction.setName( anEml.LocalID );
                if (aSBMLModel.getLevel() == 2)
                    aReaction.setId( anEml.LocalID );

                foreach(EcellData aProperty in anEml.Value)
                {
                    if (!aProperty.Loadable)
                        continue;

                    string aFullPN = aProcess.FullID + ":" + aProperty.Name;

                    // set Name property ( Name )
                    if ( aProperty.Name == "Name" )
                    {
                        // set Reaction Name
                        if (aSBMLModel.getLevel() == 1)
                        {
                        }
                        else if (aSBMLModel.getLevel() == 2)
                            aReaction.setName( (string)aProperty.Value );

                    }
                    // set Expression property ( KineticLaw Formula )
                    else if ( aProperty.Name == "Expression")
//.........这里部分代码省略.........

 public void test_KineticLaw_Parameter_parent_create_model()
 {
     Model m = new Model(2,4);
       Reaction r = m.createReaction();
       KineticLaw kl = m.createKineticLaw();
       Parameter p = m.createKineticLawParameter();
       assertTrue( kl.getNumParameters() == 1 );
       ListOfParameters lop = kl.getListOfParameters();
       assertTrue( r == kl.getParentSBMLObject() );
       assertTrue( kl == lop.getParentSBMLObject() );
       assertTrue( lop == p.getParentSBMLObject() );
       assertTrue( lop == kl.getParameter(0).getParentSBMLObject() );
       kl = null;
 }

 public void test_create_l1v1_units()
 {
     SBMLDocument d;
       Model m;
       Compartment c;
       KineticLaw kl;
       Parameter p;
       Reaction r;
       Species s;
       SpeciesReference sr;
       Unit u;
       UnitDefinition ud;
       d = new  SBMLDocument();
       m = new  Model(2,4);
       d.setModel(m);
       ud = m.createUnitDefinition();
       ud.setName( "substance");
       u = m.createUnit();
       u.setKind(libsbml.UNIT_KIND_MOLE);
       u.setScale(-3);
       ud = m.createUnitDefinition();
       ud.setName( "mls");
       u = m.createUnit();
       u.setKind(libsbml.UNIT_KIND_MOLE);
       u.setScale(-3);
       u = m.createUnit();
       u.setKind(libsbml.UNIT_KIND_LITER);
       u.setExponent(-1);
       u = m.createUnit();
       u.setKind(libsbml.UNIT_KIND_SECOND);
       u.setExponent(-1);
       c = m.createCompartment();
       c.setName( "cell");
       s = m.createSpecies();
       s.setName( "x0");
       s.setCompartment( "cell");
       s.setInitialAmount(1);
       s = m.createSpecies();
       s.setName( "x1");
       s.setCompartment( "cell");
       s.setInitialAmount(1);
       s = m.createSpecies();
       s.setName( "s1");
       s.setCompartment( "cell");
       s.setInitialAmount(1);
       s = m.createSpecies();
       s.setName( "s2");
       s.setCompartment( "cell");
       s.setInitialAmount(1);
       p = m.createParameter();
       p.setName( "vm");
       p.setUnits( "mls");
       p.setValue(2);
       p = m.createParameter();
       p.setName( "km");
       p.setValue(2);
       r = m.createReaction();
       r.setName( "v1");
       sr = m.createReactant();
       sr.setSpecies( "x0");
       sr = m.createProduct();
       sr.setSpecies( "s1");
       kl = m.createKineticLaw();
       kl.setFormula( "(vm * s1)/(km + s1)");
       r = m.createReaction();
       r.setName( "v2");
       sr = m.createReactant();
       sr.setSpecies( "s1");
       sr = m.createProduct();
       sr.setSpecies( "s2");
       kl = m.createKineticLaw();
       kl.setFormula( "(vm * s2)/(km + s2)");
       r = m.createReaction();
       r.setName( "v3");
       sr = m.createReactant();
       sr.setSpecies( "s2");
       sr = m.createProduct();
       sr.setSpecies( "x1");
       kl = m.createKineticLaw();
       kl.setFormula( "(vm * s1)/(km + s1)");
       d = null;
 }

 public void test_SpeciesReference_Reactant_ancestor_create_model()
 {
     Model m = new Model(2,4);
       Reaction r = m.createReaction();
       SpeciesReference sr = m.createReactant();
       ListOf lo = r.getListOfReactants();
       assertTrue( sr.getAncestorOfType(libsbml.SBML_REACTION) == r );
       assertTrue( sr.getAncestorOfType(libsbml.SBML_LIST_OF) == lo );
       assertTrue( sr.getAncestorOfType(libsbml.SBML_MODEL) == m );
       assertTrue( sr.getAncestorOfType(libsbml.SBML_DOCUMENT) == null );
       assertTrue( sr.getAncestorOfType(libsbml.SBML_COMPARTMENT) == null );
       SpeciesReference obj = r.getReactant(0);
       assertTrue( obj.getAncestorOfType(libsbml.SBML_REACTION) == r );
       assertTrue( obj.getAncestorOfType(libsbml.SBML_LIST_OF) == lo );
       assertTrue( obj.getAncestorOfType(libsbml.SBML_MODEL) == m );
       assertTrue( obj.getAncestorOfType(libsbml.SBML_DOCUMENT) == null );
       assertTrue( obj.getAncestorOfType(libsbml.SBML_COMPARTMENT) == null );
 }

 public void test_Reaction_ancestor_create()
 {
     Model m = new Model(2,4);
       Reaction r = m.createReaction();
       ListOf lo = m.getListOfReactions();
       assertTrue( r.getAncestorOfType(libsbml.SBML_MODEL) == m );
       assertTrue( r.getAncestorOfType(libsbml.SBML_LIST_OF) == lo );
       assertTrue( r.getAncestorOfType(libsbml.SBML_DOCUMENT) == null );
       assertTrue( r.getAncestorOfType(libsbml.SBML_EVENT) == null );
       Reaction obj = m.getReaction(0);
       assertTrue( obj.getAncestorOfType(libsbml.SBML_MODEL) == m );
       assertTrue( obj.getAncestorOfType(libsbml.SBML_LIST_OF) == lo );
       assertTrue( obj.getAncestorOfType(libsbml.SBML_DOCUMENT) == null );
       assertTrue( obj.getAncestorOfType(libsbml.SBML_EVENT) == null );
 }

 public void test_KineticLaw_Parameter_ancestor_create_model()
 {
     Model m = new Model(2,4);
       Reaction r = m.createReaction();
       KineticLaw kl = m.createKineticLaw();
       Parameter p = m.createKineticLawParameter();
       assertTrue( kl.getNumParameters() == 1 );
       ListOfParameters lop = kl.getListOfParameters();
       assertTrue( p.getAncestorOfType(libsbml.SBML_KINETIC_LAW) == kl );
       assertTrue( p.getAncestorOfType(libsbml.SBML_LIST_OF) == lop );
       assertTrue( p.getAncestorOfType(libsbml.SBML_REACTION) == r );
       assertTrue( p.getAncestorOfType(libsbml.SBML_MODEL) == m );
       assertTrue( p.getAncestorOfType(libsbml.SBML_DOCUMENT) == null );
       assertTrue( p.getAncestorOfType(libsbml.SBML_COMPARTMENT) == null );
       Parameter obj = kl.getParameter(0);
       assertTrue( obj.getAncestorOfType(libsbml.SBML_KINETIC_LAW) == kl );
       assertTrue( obj.getAncestorOfType(libsbml.SBML_LIST_OF) == lop );
       assertTrue( obj.getAncestorOfType(libsbml.SBML_REACTION) == r );
       assertTrue( obj.getAncestorOfType(libsbml.SBML_MODEL) == m );
       assertTrue( obj.getAncestorOfType(libsbml.SBML_DOCUMENT) == null );
       assertTrue( obj.getAncestorOfType(libsbml.SBML_COMPARTMENT) == null );
       kl = null;
 }