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