| 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() );
}
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 );
}
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 );
}
}