createAlgebraicRule() public method

public createAlgebraicRule ( ) : AlgebraicRule
return AlgebraicRule
 public void test_AlgebraicRule_parent_create()
 {
     Model m = new Model(2,4);
       AlgebraicRule r = m.createAlgebraicRule();
       ListOf lo = m.getListOfRules();
       assertTrue( lo == m.getRule(0).getParentSBMLObject() );
       assertTrue( lo == r.getParentSBMLObject() );
       assertTrue( m == lo.getParentSBMLObject() );
 }
示例#2
0
 public void test_AlgebraicRule_ancestor_create()
 {
     Model m = new Model(2,4);
       AlgebraicRule r = m.createAlgebraicRule();
       ListOf lo = m.getListOfRules();
       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 );
       Rule obj = m.getRule(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 );
 }
示例#3
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 );
            }
        }