/* adds species referred to in a KineticLaw to the ListOfModifiers
* this will only be applicable when up converting an L1 model
*/
void
Model::addModifiers ()
{
//
// Level 2/3 has a listOfModifiers associated with a Reaction
// which are not listed in a L1 Model.
// For each symbol in the Reaction's KineticLaw,
// that symbol is a modifier iff:
//
// 1. It is defined as a Species in the Model
// 2. It is not a Reactant or Product in this Reaction.
//
// Thus modifiers must be added where appropriate.
//
const char *id;
unsigned int size;
unsigned int n, l;
const ASTNode *node;
List *names;
KineticLaw* kl;
for (n = 0; n < getNumReactions(); n++)
{
kl = getReaction(n)->getKineticLaw();
if (kl == NULL || kl->isSetMath() == false) continue;
node = kl->getMath();
names = node->getListOfNodes((ASTNodePredicate) ASTNode_isName);
size = names->getSize();
for (l = 0; l < size; l++)
{
node = (ASTNode *) names->get(l);
id = node->getName();
// 1. It is an AST_NAME (not AST_NAME_TIME), and
if (node->getType() != AST_NAME) continue;
// 2. It refers to a Species in this Model, and
if (id == NULL || getSpecies(id) == NULL) continue;
// 3. It is not a Reactant, Product, or (already) a Modifier
if (getReaction(n)->getReactant(id) != NULL) continue;
if (getReaction(n)->getProduct (id) != NULL) continue;
if (getReaction(n)->getModifier(id) != NULL) continue;
getReaction(n)->createModifier()->setSpecies(id);
}
delete names;
}
}
/* convert from L1 to L3 */
void
Model::convertL3ToL1 ()
{
//
// Level 3 allows a model to be specified without a Compartment. However
// this is not valid in Level 1. Thus if a L3 model has no Compartment
// one must be included
//
if (getNumCompartments() == 0)
{
createCompartment()->setId(ASSIGNED_COMPARTMENT);
}
dealWithModelUnits();
dealWithAssigningL1Stoichiometry(*this, false);
for (unsigned int i = 0; i < getNumReactions(); i++)
{
Reaction *r = getReaction(i);
if (r->isSetKineticLaw())
{
KineticLaw *kl = r->getKineticLaw();
for (unsigned int j = 0; j < kl->getNumLocalParameters(); j++)
{
Parameter *lp = new Parameter(getLevel(), getVersion());
(*lp) = *(kl->getLocalParameter(j));
kl->addParameter(lp);
}
}
}
}
//-----------------------------------------------------------------------------
// Function : ReactionNetwork::addProduct
// Purpose : add a species/stoichiometric coefficient pair to the
// product list of a specified named reaction
// The species is specified using its name, and must be
// one of those in the list provided by setSpecies
// (must not be one from the Constants list).
// Special Notes :
// Scope : public
// Creator : Tom Russo, SNL, Electrical and Microsystems Modeling
// Creation Date : 03/20/06
//-----------------------------------------------------------------------------
void ReactionNetwork::addProduct(const std::string &name, const std::string &product, double stoich)
{
std::map<std::string,int>::iterator n_i;
// check that reaction name exists in map
// check that name exists in map
int reactionNum;
reactionNum=getReactionNum(name);
if (reactionNum == -1)
{
Report::DevelFatal() << " Attempt to add product " << product
<< " to non-existant reaction " << name;
}
else
{
int speciesNum;
// now check if we know this product
n_i = speciesMap.find(product);
if (n_i == speciesMap.end())
{
// not a solution species --- is it a constant?
n_i = constantsMap.find(product);
if (n_i == constantsMap.end())
{ // nope
Report::DevelFatal() << "attempt to add unknown product " << product
<< " to reaction number " << reactionNum
<< "("<<name<<")";
}
else
{
std::ostringstream ost;
#ifdef Xyce_RXN_WARNINGS
Report::UserWarning() << " Specified constant species " << product
<< " as product of reaction number " << reactionNum
<< "(" << name << ")"<<std::endl
<< " IGNORING that product";
#endif
}
}
else
{
speciesNum = n_i->second;
getReaction(reactionNum).addProduct(speciesNum,stoich);
}
}
}
/* converting to l1 any metaid attributes should be removed */
void
Model::removeMetaId()
{
unsigned int n, i;
unsetMetaId();
for (n = 0; n < getNumUnitDefinitions(); n++)
{
getUnitDefinition(n)->unsetMetaId();
for (i = 0; i < getUnitDefinition(n)->getNumUnits(); i++)
{
getUnitDefinition(n)->getUnit(i)->unsetMetaId();
}
}
for (n = 0; n < getNumCompartments(); n++)
{
getCompartment(n)->unsetMetaId();
}
for (n = 0; n < getNumSpecies(); n++)
{
getSpecies(n)->unsetMetaId();
}
for (n = 0; n < getNumParameters(); n++)
{
getParameter(n)->unsetMetaId();
}
for (n = 0; n < getNumRules(); n++)
{
getRule(n)->unsetMetaId();
}
for (n = 0; n < getNumReactions(); n++)
{
getReaction(n)->unsetMetaId();
for (i = 0; i < getReaction(n)->getNumReactants(); i++)
{
getReaction(n)->getReactant(i)->unsetMetaId();
}
for (i = 0; i < getReaction(n)->getNumProducts(); i++)
{
getReaction(n)->getProduct(i)->unsetMetaId();
}
if (getReaction(n)->isSetKineticLaw())
{
getReaction(n)->getKineticLaw()->unsetMetaId();
}
}
}
//-----------------------------------------------------------------------------
// Function : ReactionNetwork::setRateConstant
// Purpose : set the rate constant for the named reaction
// Special Notes :
// Scope : public
// Creator : Tom Russo, SNL, Electrical and Microsystems Modeling
// Creation Date : 03/20/06
//-----------------------------------------------------------------------------
void ReactionNetwork::setRateConstant(const std::string &name, double k)
{
int reactionNum;
// check that reaction name exists in map
reactionNum=getReactionNum(name);
if (reactionNum == -1)
{
Report::DevelFatal() << " Attempt to set rate constant of non-existant reaction "
<< name;
}
else
{
getReaction(reactionNum).setRateConstant(k);
}
}
//-----------------------------------------------------------------------------
// Function : ReactionNetwork::unscaleRateConstantFromCalculator
// Purpose : unscale the rate constant for the named reaction according
// to its saved method
// Special Notes :
// Scope : public
// Creator : Tom Russo, SNL, Electrical and Microsystems Modeling
// Creation Date : 08/01/06
//-----------------------------------------------------------------------------
void ReactionNetwork::unscaleRateConstantFromCalculator (const std::string &name)
{
int reactionNum;
// check that reaction name exists in map
reactionNum = getReactionNum(name);
if (reactionNum == -1)
{
Report::DevelFatal() << " Attempt to scale rate constant of non-existant reaction "
<< name;
}
else
{
getReaction(reactionNum).unscaleRateConstantFromCalculator();
}
}
//-----------------------------------------------------------------------------
// Function : ReactionNetwork::setRateConstantFromCalculator
// Purpose : set the rate constant for the named reaction according
// to its saved method
// Special Notes :
// Scope : public
// Creator : Lawrence C Musson, SNL, Electrical and Microsystems Modeling
// Creation Date : 04/17/2014
//-----------------------------------------------------------------------------
void ReactionNetwork::setRateConstantFromCalculator (const std::string &name, double T,
std::vector<double> &concs,
std::vector<double> &constant_vec)
{
int reactionNum;
// check that reaction name exists in map
reactionNum = getReactionNum(name);
if (reactionNum == -1)
{
Report::DevelFatal() << " Attempt to scale rate constant of non-existant reaction "
<< name;
}
else
{
getReaction(reactionNum).setRateConstantFromCalculator(T,concs,constant_vec);
}
}
void
Model::convertParametersToLocals(unsigned int level, unsigned int version)
{
for (unsigned int i = 0; i < getNumReactions(); i++)
{
Reaction *r = getReaction(i);
if (r->isSetKineticLaw())
{
KineticLaw *kl = r->getKineticLaw();
for (unsigned int j = 0; j < kl->getNumParameters(); j++)
{
LocalParameter *lp = new LocalParameter(level, version);
(*lp) = *(kl->getParameter(j));
kl->addLocalParameter(lp);
}
}
}
}
//-----------------------------------------------------------------------------
// Function : ReactionNetwork::addReactant
// Purpose : add a species/stoichiometric coefficient pair to the
// reactant list of a specified named reaction
// The species is specified using its name, and can be either
// one of those in the list provided by setSpecies or
// setConstants.
// Special Notes :
// Scope : public
// Creator : Tom Russo, SNL, Electrical and Microsystems Modeling
// Creation Date : 03/20/06
//-----------------------------------------------------------------------------
void ReactionNetwork::addReactant(const std::string &name, const std::string &reactant, double stoich)
{
std::map<std::string,int>::iterator n_i;
// check that name exists in map
int reactionNum;
reactionNum=getReactionNum(name);
if (reactionNum == -1)
{
Report::DevelFatal() << " Attempt to add reactant " << reactant
<< " to non-existant reaction " << name;
}
else
{
int speciesNum;
// now check if we know this reactant
n_i = speciesMap.find(reactant);
if (n_i == speciesMap.end())
{
// not a solution species --- is it a constant?
n_i = constantsMap.find(reactant);
if (n_i == constantsMap.end())
{ // nope
Report::DevelFatal() << "attempt to add unknown reactant " << reactant
<< " to reaction number " << reactionNum
<< "("<<name<<")";
}
else
{
speciesNum = -(n_i->second+1);
}
}
else
{
speciesNum = n_i->second;
}
getReaction(reactionNum).addReactant(speciesNum,stoich);
}
}
void
Model::setSpeciesReferenceConstantValueAndStoichiometry()
{
for (unsigned int i = 0; i < getNumReactions(); i++)
{
Reaction *r = getReaction(i);
unsigned int j;
for (j = 0; j < r->getNumReactants(); j++)
{
if (!(r->getReactant(j)->isSetStoichiometryMath()))
{
r->getReactant(j)->setConstant(true);
if (!(r->getReactant(j)->isSetStoichiometry()))
{
r->getReactant(j)->setStoichiometry(1);
}
}
else
{
r->getReactant(j)->setConstant(false);
}
}
for (j = 0; j < r->getNumProducts(); j++)
{
if (!(r->getProduct(j)->isSetStoichiometryMath()))
{
r->getProduct(j)->setConstant(true);
if (!(r->getProduct(j)->isSetStoichiometry()))
{
r->getProduct(j)->setStoichiometry(1);
}
}
else
{
r->getProduct(j)->setConstant(false);
}
}
}
}
/* convert from L1 to L3 */
void
Model::convertL3ToL2 (bool strict)
{
dealWithModelUnits();
dealWithStoichiometry();
dealWithEvents(strict);
for (unsigned int i = 0; i < getNumReactions(); i++)
{
Reaction *r = getReaction(i);
if (r->isSetKineticLaw())
{
KineticLaw *kl = r->getKineticLaw();
for (unsigned int j = 0; j < kl->getNumLocalParameters(); j++)
{
Parameter *lp = new Parameter(getLevel(), getVersion());
(*lp) = *(kl->getLocalParameter(j));
kl->addParameter(lp);
}
}
}
}
const char * IndigoCdxReaction::getName ()
{
return getReaction().name.ptr();
}
BaseReaction & IndigoCdxReaction::getBaseReaction ()
{
return getReaction();
}
const char * IndigoSmilesReaction::getName ()
{
if (getReaction().name.ptr() == 0)
return "";
return getReaction().name.ptr();
}
BaseReaction & IndigoSmilesReaction::getBaseReaction ()
{
return getReaction();
}
BaseReaction & IndigoRdfReaction::getBaseReaction ()
{
return getReaction();
}
void
Model::removeDuplicateTopLevelAnnotations()
{
unsigned int i, n;
this->removeDuplicateAnnotations();
if (getNumFunctionDefinitions() > 0)
{
getListOfFunctionDefinitions()->removeDuplicateAnnotations();
for (i = 0; i < getNumFunctionDefinitions(); i++)
{
getFunctionDefinition(i)->removeDuplicateAnnotations();
}
}
if (getNumUnitDefinitions() > 0)
{
getListOfUnitDefinitions()->removeDuplicateAnnotations();
for (i = 0; i < getNumUnitDefinitions(); i++)
{
getUnitDefinition(i)->removeDuplicateAnnotations();
getUnitDefinition(i)->getListOfUnits()->removeDuplicateAnnotations();
for (n = 0; n < getUnitDefinition(i)->getNumUnits(); n++)
{
getUnitDefinition(i)->getUnit(n)->removeDuplicateAnnotations();
}
}
}
if (getNumCompartmentTypes() > 0)
{
getListOfCompartmentTypes()->removeDuplicateAnnotations();
for (i = 0; i < getNumCompartmentTypes(); i++)
{
getCompartmentType(i)->removeDuplicateAnnotations();
}
}
if (getNumSpeciesTypes() > 0)
{
getListOfSpeciesTypes()->removeDuplicateAnnotations();
for (i = 0; i < getNumSpeciesTypes(); i++)
{
getSpeciesType(i)->removeDuplicateAnnotations();
}
}
if (getNumCompartments() > 0)
{
getListOfCompartments()->removeDuplicateAnnotations();
for (i = 0; i < getNumCompartments(); i++)
{
getCompartment(i)->removeDuplicateAnnotations();
}
}
if (getNumSpecies() > 0)
{
getListOfSpecies()->removeDuplicateAnnotations();
for (i = 0; i < getNumSpecies(); i++)
{
getSpecies(i)->removeDuplicateAnnotations();
}
}
if (getNumParameters() > 0)
{
getListOfParameters()->removeDuplicateAnnotations();
for (i = 0; i < getNumParameters(); i++)
{
getParameter(i)->removeDuplicateAnnotations();
}
}
if (getNumInitialAssignments() > 0)
{
getListOfInitialAssignments()->removeDuplicateAnnotations();
for (i = 0; i < getNumInitialAssignments(); i++)
{
getInitialAssignment(i)->removeDuplicateAnnotations();
}
}
if (getNumConstraints() > 0)
{
getListOfConstraints()->removeDuplicateAnnotations();
for (i = 0; i < getNumConstraints(); i++)
{
getConstraint(i)->removeDuplicateAnnotations();
}
}
if (getNumRules() > 0)
{
getListOfRules()->removeDuplicateAnnotations();
for (i = 0; i < getNumRules(); i++)
{
getRule(i)->removeDuplicateAnnotations();
}
}
if (getNumReactions() > 0)
{
getListOfReactions()->removeDuplicateAnnotations();
for (i = 0; i < getNumReactions(); i++)
{
Reaction * r = getReaction(i);
r->removeDuplicateAnnotations();
if (r->getNumReactants() > 0)
{
r->getListOfReactants()->removeDuplicateAnnotations();
for (n = 0; n < r->getNumReactants(); n++)
{
r->getReactant(n)->removeDuplicateAnnotations();
}
}
if (r->getNumProducts() > 0)
{
r->getListOfProducts()->removeDuplicateAnnotations();
for (n = 0; n < r->getNumProducts(); n++)
{
r->getProduct(n)->removeDuplicateAnnotations();
}
}
if (r->getNumModifiers() > 0)
{
r->getListOfModifiers()->removeDuplicateAnnotations();
for (n = 0; n < r->getNumModifiers(); n++)
{
r->getModifier(n)->removeDuplicateAnnotations();
}
}
if (r->isSetKineticLaw())
{
r->getKineticLaw()->removeDuplicateAnnotations();
if (r->getKineticLaw()->getNumParameters() > 0)
{
r->getKineticLaw()->getListOfParameters()
->removeDuplicateAnnotations();
for (n = 0; n < r->getKineticLaw()->getNumParameters(); n++)
{
r->getKineticLaw()->getParameter(n)->removeDuplicateAnnotations();
}
}
}
}
}
if (getNumEvents() > 0)
{
getListOfEvents()->removeDuplicateAnnotations();
for (i = 0; i < getNumEvents(); i++)
{
getEvent(i)->removeDuplicateAnnotations();
if (getEvent(i)->getNumEventAssignments() > 0)
{
getEvent(i)->getListOfEventAssignments()->removeDuplicateAnnotations();
for (n = 0; n < getEvent(i)->getNumEventAssignments(); n++)
{
getEvent(i)->getEventAssignment(n)->removeDuplicateAnnotations();
}
}
}
}
}
void
Model::convertStoichiometryMath()
{
unsigned int n, j;
Reaction * r;
SpeciesReference *sr;
unsigned int idCount = 0;
char newid[15];
std::string id;
for (n = 0; n < getNumReactions(); n++)
{
r = getReaction(n);
for (j = 0; j < r->getNumReactants(); j++)
{
sr = r->getReactant(j);
if (sr->isSetStoichiometryMath())
{
if (!sr->isSetId())
{
sprintf(newid, "generatedId_%u", idCount);
id.assign(newid);
sr->setId(id);
idCount++;
}
else
{
id = sr->getId();
}
sr->setConstant(false);
AssignmentRule * ar = createAssignmentRule();
ar->setVariable(id);
if (sr->getStoichiometryMath()->isSetMath())
{
ar->setMath(sr->getStoichiometryMath()->getMath());
}
}
}
for (j = 0; j < r->getNumProducts(); j++)
{
sr = r->getProduct(j);
if (sr->isSetStoichiometryMath())
{
if (!sr->isSetId())
{
sprintf(newid, "generatedId_%u", idCount);
id.assign(newid);
sr->setId(id);
idCount++;
}
else
{
id = sr->getId();
}
sr->setConstant(false);
AssignmentRule * ar = createAssignmentRule();
ar->setVariable(id);
if (sr->getStoichiometryMath()->isSetMath())
{
ar->setMath(sr->getStoichiometryMath()->getMath());
}
}
}
}
}
void
Model::removeSBOTermsNotInL2V2(bool strict)
{
unsigned int n, i;
if (strict == true)
{
for (n = 0; n < getNumUnitDefinitions(); n++)
{
getUnitDefinition(n)->unsetSBOTerm();
for (i = 0; i < getUnitDefinition(n)->getNumUnits(); i++)
{
getUnitDefinition(n)->getUnit(i)->unsetSBOTerm();
}
}
for (n = 0; n < getNumCompartments(); n++)
{
getCompartment(n)->unsetSBOTerm();
}
for (n = 0; n < getNumSpecies(); n++)
{
getSpecies(n)->unsetSBOTerm();
}
for (n = 0; n < getNumCompartmentTypes(); n++)
{
getCompartmentType(n)->unsetSBOTerm();
}
for (n = 0; n < getNumSpeciesTypes(); n++)
{
getSpeciesType(n)->unsetSBOTerm();
}
for (n = 0; n < getNumReactions(); n++)
{
for (i = 0; i < getReaction(n)->getNumReactants(); i++)
{
if (getReaction(n)->getReactant(i)->isSetStoichiometryMath())
{
getReaction(n)->getReactant(i)->getStoichiometryMath()->unsetSBOTerm();
}
}
for (i = 0; i < getReaction(n)->getNumProducts(); i++)
{
if (getReaction(n)->getProduct(i)->isSetStoichiometryMath())
{
getReaction(n)->getProduct(i)->getStoichiometryMath()->unsetSBOTerm();
}
}
}
for (n = 0; n < getNumEvents(); n++)
{
if (getEvent(n)->isSetTrigger())
{
getEvent(n)->getTrigger()->unsetSBOTerm();
}
if (getEvent(n)->isSetDelay())
{
getEvent(n)->getDelay()->unsetSBOTerm();
}
}
}
}
void
Model::removeSBOTerms(bool strict)
{
unsigned int n, i;
if (strict == true)
{
unsetSBOTerm();
for (n = 0; n < getNumUnitDefinitions(); n++)
{
getUnitDefinition(n)->unsetSBOTerm();
for (i = 0; i < getUnitDefinition(n)->getNumUnits(); i++)
{
getUnitDefinition(n)->getUnit(i)->unsetSBOTerm();
}
}
for (n = 0; n < getNumCompartments(); n++)
{
getCompartment(n)->unsetSBOTerm();
}
for (n = 0; n < getNumSpecies(); n++)
{
getSpecies(n)->unsetSBOTerm();
}
for (n = 0; n < getNumParameters(); n++)
{
getParameter(n)->unsetSBOTerm();
}
for (n = 0; n < getNumRules(); n++)
{
getRule(n)->unsetSBOTerm();
}
for (n = 0; n < getNumReactions(); n++)
{
getReaction(n)->unsetSBOTerm();
for (i = 0; i < getReaction(n)->getNumReactants(); i++)
{
getReaction(n)->getReactant(i)->unsetSBOTerm();
if (getReaction(n)->getReactant(i)->isSetStoichiometryMath())
{
getReaction(n)->getReactant(i)->getStoichiometryMath()->unsetSBOTerm();
}
}
for (i = 0; i < getReaction(n)->getNumProducts(); i++)
{
getReaction(n)->getProduct(i)->unsetSBOTerm();
if (getReaction(n)->getProduct(i)->isSetStoichiometryMath())
{
getReaction(n)->getProduct(i)->getStoichiometryMath()->unsetSBOTerm();
}
}
for (i = 0; i < getReaction(n)->getNumModifiers(); i++)
{
getReaction(n)->getModifier(i)->unsetSBOTerm();
}
if (getReaction(n)->isSetKineticLaw())
{
getReaction(n)->getKineticLaw()->unsetSBOTerm();
}
}
for (n = 0; n < getNumFunctionDefinitions(); n++)
{
getFunctionDefinition(n)->unsetSBOTerm();
}
for (n = 0; n < getNumEvents(); n++)
{
getEvent(n)->unsetSBOTerm();
for (i = 0; i < getEvent(n)->getNumEventAssignments(); i++)
{
getEvent(n)->getEventAssignment(i)->unsetSBOTerm();
}
if (getEvent(n)->isSetTrigger())
{
getEvent(n)->getTrigger()->unsetSBOTerm();
}
if (getEvent(n)->isSetDelay())
{
getEvent(n)->getDelay()->unsetSBOTerm();
}
}
}
}
void
Model::assignRequiredValues()
{
// when converting to L3 some attributes which have default values in L1/L2
// but are required in L3 are not present or set
unsigned int i, n;
if (getNumUnitDefinitions() > 0)
{
for (i = 0; i < getNumUnitDefinitions(); i++)
{
for (n = 0; n < getUnitDefinition(i)->getNumUnits(); n++)
{
Unit *u = getUnitDefinition(i)->getUnit(n);
if (!u->isSetExponent())
u->setExponent(1.0);
if (!u->isSetScale())
u->setScale(0);
if (!u->isSetMultiplier())
u->setMultiplier(1.0);
}
}
}
if (getNumCompartments() > 0)
{
for (i = 0; i < getNumCompartments(); i++)
{
Compartment *c = getCompartment(i);
c->setConstant(c->getConstant());
}
}
if (getNumSpecies() > 0)
{
for (i = 0; i < getNumSpecies(); i++)
{
Species * s = getSpecies(i);
s->setBoundaryCondition(s->getBoundaryCondition());
s->setHasOnlySubstanceUnits(s->getHasOnlySubstanceUnits());
s->setConstant(s->getConstant());
}
}
if (getNumParameters() > 0)
{
for (i = 0; i < getNumParameters(); i++)
{
Parameter * p = getParameter(i);
p->setConstant(p->getConstant());
}
}
if (getNumReactions() > 0)
{
for (i = 0; i < getNumReactions(); i++)
{
Reaction * r = getReaction(i);
r->setFast(r->getFast());
r->setReversible(r->getReversible());
if (r->getNumReactants() > 0)
{
for (n = 0; n < r->getNumReactants(); n++)
{
SpeciesReference *sr = r->getReactant(n);
if (sr->isSetStoichiometryMath())
{
sr->setConstant(false);
}
else
{
sr->setConstant(true);
}
}
}
if (r->getNumProducts() > 0)
{
for (n = 0; n < r->getNumProducts(); n++)
{
SpeciesReference *sr = r->getProduct(n);
if (sr->isSetStoichiometryMath())
{
sr->setConstant(false);
}
else
{
sr->setConstant(true);
}
}
}
}
}
if (getNumEvents() > 0)
{
for (i = 0; i < getNumEvents(); i++)
{
Event * e = getEvent(i);
e->setUseValuesFromTriggerTime(e->getUseValuesFromTriggerTime());
if (e->isSetTrigger())
{
Trigger *t = e->getTrigger();
t->setPersistent(true);
t->setInitialValue(true);
}
}
}
}
void
Model::dealWithStoichiometry()
{
unsigned int idCount = 0;
for (unsigned int i = 0; i < getNumReactions(); i++)
{
Reaction *r = getReaction(i);
unsigned int j;
for (j = 0; j < r->getNumReactants(); j++)
{
SpeciesReference *sr = r->getReactant(j);
if (sr->isSetStoichiometry() == false)
{
if (sr->isSetId() == false)
{
createNoValueStoichMath(*this, *sr, idCount);
idCount++;
}
else
{
// id is set it could be used by initialAssignment
// used by rule
// not used
if (getInitialAssignment(sr->getId()) != NULL)
{
useStoichMath(*this, *sr, false);
}
else if (getRule(sr->getId()) != NULL)
{
//assignmentRule
if (getRule(sr->getId())->getTypeCode() == SBML_ASSIGNMENT_RULE)
{
useStoichMath(*this, *sr, true);
}
else if (getRule(sr->getId())->getTypeCode() == SBML_RATE_RULE)
{
createParameterAsRateRule(*this, *sr, *(getRule(sr->getId())), idCount);
idCount++;
}
}
else
{
createNoValueStoichMath(*this, *sr, idCount);
idCount++;
}
}
}
else
{
// stoichiometry is set
if (sr->isSetId())
{
// id is set it could be used by initialAssignment
// used by rule
// not used
if (getInitialAssignment(sr->getId()) != NULL)
{
useStoichMath(*this, *sr, false);
}
else if (getRule(sr->getId()) != NULL)
{
//assignmentRule
if (getRule(sr->getId())->getTypeCode() == SBML_ASSIGNMENT_RULE)
{
useStoichMath(*this, *sr, true);
}
else if (getRule(sr->getId())->getTypeCode() == SBML_RATE_RULE)
{
createParameterAsRateRule(*this, *sr, *(getRule(sr->getId())), idCount);
idCount++;
}
}
}
// no id set - do not need to do anything
}
}
for (j = 0; j < r->getNumProducts(); j++)
{
SpeciesReference *sr = r->getProduct(j);
if (sr->isSetStoichiometry() == false)
{
if (sr->isSetId() == false)
{
createNoValueStoichMath(*this, *sr, idCount);
idCount++;
}
else
{
// id is set it could be used by initialAssignment
// used by rule
// not used
if (getInitialAssignment(sr->getId()) != NULL)
{
useStoichMath(*this, *sr, false);
}
else if (getRule(sr->getId()) != NULL)
{
//assignmentRule
if (getRule(sr->getId())->getTypeCode() == SBML_ASSIGNMENT_RULE)
{
useStoichMath(*this, *sr, true);
}
else if (getRule(sr->getId())->getTypeCode() == SBML_RATE_RULE)
{
createParameterAsRateRule(*this, *sr, *(getRule(sr->getId())), idCount);
idCount++;
}
}
else
{
createNoValueStoichMath(*this, *sr, idCount);
idCount++;
}
}
}
else
{
// stoichiometry is set
if (sr->isSetId())
{
// id is set it could be used by initialAssignment
// used by rule
// not used
if (getInitialAssignment(sr->getId()) != NULL)
{
useStoichMath(*this, *sr, false);
}
else if (getRule(sr->getId()) != NULL)
{
//assignmentRule
if (getRule(sr->getId())->getTypeCode() == SBML_ASSIGNMENT_RULE)
{
useStoichMath(*this, *sr, true);
}
else if (getRule(sr->getId())->getTypeCode() == SBML_RATE_RULE)
{
createParameterAsRateRule(*this, *sr, *(getRule(sr->getId())), idCount);
idCount++;
}
}
}
// no id set - do not need to do anything
}
}
}
}