createKineticLaw() public méthode

public createKineticLaw ( ) : KineticLaw
Résultat KineticLaw
 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_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_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;
 }
Exemple #4
0
        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")
                    {
                        // convert Expression of the ECELL format to
                        // SBML kineticLaw formula
                        // setExpressionAnnotation( aKineticLaw, anExpression );
                        bool aDelayFlag = false;
                        anExpression = convertExpression(anExpression,
                                             aVariableReferenceList,
                                             aProcess.ParentSystemID);

                        // get Current System Id
                        string CompartmentOfReaction = "";
                        foreach (EcellReference aVariableReference in aVariableReferenceList)
                        {
                            if (aVariableReference.Coefficient == 0)
                                continue;
                            CompartmentOfReaction = getCompartmentID(aVariableReference.FullID, aProcess.ParentSystemID);
                        }

                        // set KineticLaw Formula
                        if ( aDelayFlag == false )
                            aKineticLaw.setFormula( anExpression );
                        else
                        {
                            ASTNode anASTNode = libsbml.libsbml.parseFormula( anExpression );
                            anASTNode = setDelayType( anASTNode );

                            aKineticLaw.setMath( anASTNode );
                        }
                    }
                    // set VariableReference property ( SpeciesReference )
                    else if ( aProperty.Name == "VariableReferenceList" )
                    {
                        // make a flag. Because SBML model is defined
                        // both Product and Reactant. This flag is required
                        // in order to judge whether the Product and the
                        // Reactant are defined.

                        bool aReactantFlag = false;
                        bool aProductFlag = false;

                        foreach(EcellReference aVariableReference in aVariableReferenceList)
                        {
                            // --------------------------------
                            // add Reactants to Reaction object
                            // --------------------------------
                            if ( aVariableReference.Coefficient < 0 )
                            {
                                // change the Reactant Flag
                                aReactantFlag = true;

                                // create Reactant object
                                SpeciesReference aReactant = aSBMLModel.createReactant();

                                // set Species Id to Reactant object
                                string aSpeciesReferenceId = getVariableReferenceId
                                                      ( aVariableReference.FullID,
                                                        aProcess.ParentSystemID );

                                aReactant.setSpecies( aSpeciesReferenceId );

                                // set Stoichiometry
                                aReactant.setStoichiometry( -aVariableReference.Coefficient );
                            }
                            // -------------------------------
                            // add Products to Reaction object
                            // -------------------------------
                            else if ( aVariableReference.Coefficient > 0 )
                            {
                                // change the Product Flag
                                aProductFlag = true;

                                // create Product object
                                SpeciesReference aProduct = aSBMLModel.createProduct();

                                // set Species Id
                                string aSpeciesReferenceId = getVariableReferenceId
                                                      ( aVariableReference.FullID,
                                                        aProcess.ParentSystemID );

                                aProduct.setSpecies( aSpeciesReferenceId );

                                // set Stoichiometry
                                aProduct.setStoichiometry( aVariableReference.Coefficient );
                            }

                            // --------------------------------
                            // add Modifiers to Reaction object
                            // --------------------------------

                            else
                            {
                                // create Modifier object
                                ModifierSpeciesReference aModifier = aSBMLModel.createModifier();

                                // set Species Id to Modifier object
                                string aVariableReferenceId = getVariableReferenceId( aVariableReference.FullID, aProcess.ParentSystemID );

                                aModifier.setSpecies( aVariableReferenceId );
                            }

                        }

                        // set EmptySet Species, because if it didn"t define,
                        // Reactant or Product can not be defined.
                        //if (!aReactantFlag)
                        //{
                        //    // create Reactant object
                        //    SpeciesReference aReactant = aSBMLModel.createReactant();

                        //    // set Species Id to Reactant object
                        //    aReactant.setSpecies("EmptySet");

                        //    // set Stoichiometry
                        //    aReactant.setStoichiometry(0);
                        //}
                        //else if (!aProductFlag)
                        //{
                        //    // create Product object
                        //    SpeciesReference aProduct = aSBMLModel.createProduct();

                        //    // set Species Id
                        //    aProduct.setSpecies("EmptySet");

                        //    // set Stoichiometry
                        //    aProduct.setStoichiometry(0);
                        //}
                    }
                    // These properties are not defined in SBML Lv2
                    else if ( aProperty.Name == "Priority" ||
                           aProperty.Name == "Activity" ||
                           aProperty.Name == "IsContinuous" ||
                           aProperty.Name == "StepperID" ||
                           aProperty.Name == "FireMethod" ||
                           aProperty.Name == "InitializeMethod" )
                    {
                        continue;
                    }
                    else
                    {
                        // create Parameter Object (Local)
                        Parameter aParameter = aSBMLModel.createKineticLawParameter();

                        // set Parameter ID
                        aParameter.setId( aProperty.Name );

                        // set Parameter Value
                        aParameter.setValue((double)aProperty.Value);
                    }
                }
                // add KineticLaw Object to Reaction Object
                aReaction.setKineticLaw( aKineticLaw );
            }
        }
 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;
 }
Exemple #6
0
 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;
 }