END_TEST
START_TEST ( test_SpeciesReference_Modifier_parent_create )
{
Reaction *r = new Reaction(2, 4);
ModifierSpeciesReference *sr = r->createModifier();
ListOf *lo = r->getListOfModifiers();
fail_unless(lo == sr->getParentSBMLObject());
fail_unless(lo == r->getModifier(0)->getParentSBMLObject());
fail_unless(r == lo->getParentSBMLObject());
}
END_TEST
START_TEST ( test_SpeciesReference_Modifier_parent_add )
{
ModifierSpeciesReference *sr = new ModifierSpeciesReference(2, 4);
sr->setSpecies("s");
Reaction *r = new Reaction(2, 4);
r->addModifier(sr);
delete sr;
ListOf *lo = r->getListOfModifiers();
fail_unless(lo == r->getModifier(0)->getParentSBMLObject());
fail_unless(r == lo->getParentSBMLObject());
}
/*
* Checks that all variables referenced in FunctionDefinition bodies are
* bound variables (function arguments).
*/
void
KineticLawVars::check_ (const Model& m, const Reaction& r)
{
unsigned int n;
/* create list of all species in the reaction */
for (n = 0; n < r.getNumReactants(); n++)
{
mSpecies.append(r.getReactant(n)->getSpecies());
}
for (n = 0; n < r.getNumProducts(); n++)
{
mSpecies.append(r.getProduct(n)->getSpecies());
}
for (n = 0; n < r.getNumModifiers(); n++)
{
mSpecies.append(r.getModifier(n)->getSpecies());
}
if ( r.isSetKineticLaw() && r.getKineticLaw()->isSetMath() )
{
const ASTNode* math = r.getKineticLaw()->getMath();
List* names = math->getListOfNodes( ASTNode_isName );
for (n = 0; n < names->getSize(); ++n)
{
ASTNode* node = static_cast<ASTNode*>( names->get(n) );
string name = node->getName() ? node->getName() : "";
if (m.getSpecies(name) != NULL && !mSpecies.contains(name) )
logUndefined(r, name);
}
delete names;
}
mSpecies.clear();
}
int
main (int argc, char* argv[])
{
if (argc != 2)
{
cout << endl << "Usage: printNotes filename" << endl << endl;
return 1;
}
unsigned int i,j;
const char* filename = argv[1];
SBMLDocument* document;
SBMLReader reader;
document = reader.readSBML(filename);
unsigned int errors = document->getNumErrors();
cout << endl;
cout << "filename: " << filename << endl;
cout << endl;
if(errors > 0)
{
document->printErrors(cerr);
delete document;
return errors;
}
/* Model */
Model* m = document->getModel();
printNotes(m);
for(i=0; i < m->getNumReactions(); i++)
{
Reaction* re = m->getReaction(i);
printNotes(re);
/* SpeciesReference (Reacatant) */
for(j=0; j < re->getNumReactants(); j++)
{
SpeciesReference* rt = re->getReactant(j);
if (rt->isSetNotes()) cout << " ";
printNotes(rt, (rt->isSetSpecies() ? rt->getSpecies() : std::string("")) );
}
/* SpeciesReference (Product) */
for(j=0; j < re->getNumProducts(); j++)
{
SpeciesReference* rt = re->getProduct(j);
if (rt->isSetNotes()) cout << " ";
printNotes(rt, (rt->isSetSpecies() ? rt->getSpecies() : std::string("")) );
}
/* ModifierSpeciesReference (Modifier) */
for(j=0; j < re->getNumModifiers(); j++)
{
ModifierSpeciesReference* md = re->getModifier(j);
if (md->isSetNotes()) cout << " ";
printNotes(md, (md->isSetSpecies() ? md->getSpecies() : std::string("")) );
}
/* Kineticlaw */
if(re->isSetKineticLaw())
{
KineticLaw* kl = re->getKineticLaw();
if (kl->isSetNotes()) cout << " ";
printNotes(kl);
/* Parameter */
for(j=0; j < kl->getNumParameters(); j++)
{
Parameter* pa = kl->getParameter(j);
if (pa->isSetNotes()) cout << " ";
printNotes(pa);
}
}
}
/* Species */
for(i=0; i < m->getNumSpecies(); i++)
{
Species* sp = m->getSpecies(i);
printNotes(sp);
}
/* Compartment */
for(i=0; i < m->getNumCompartments(); i++)
{
Compartment* sp = m->getCompartment(i);
printNotes(sp);
}
/* FunctionDefinition */
for(i=0; i < m->getNumFunctionDefinitions(); i++)
{
FunctionDefinition* sp = m->getFunctionDefinition(i);
printNotes(sp);
}
/* UnitDefinition */
for(i=0; i < m->getNumUnitDefinitions(); i++)
{
UnitDefinition* sp = m->getUnitDefinition(i);
printNotes(sp);
}
/* Parameter */
for(i=0; i < m->getNumParameters(); i++)
{
Parameter* sp = m->getParameter(i);
printNotes(sp);
}
/* Rule */
for(i=0; i < m->getNumRules(); i++)
{
Rule* sp = m->getRule(i);
printNotes(sp);
}
/* InitialAssignment */
for(i=0; i < m->getNumInitialAssignments(); i++)
{
InitialAssignment* sp = m->getInitialAssignment(i);
printNotes(sp);
}
/* Event */
for(i=0; i < m->getNumEvents(); i++)
{
Event* sp = m->getEvent(i);
printNotes(sp);
/* Trigger */
if(sp->isSetTrigger())
{
const Trigger* tg = sp->getTrigger();
if (tg->isSetNotes()) cout << " ";
printNotes(const_cast<Trigger*>(tg));
}
/* Delay */
if(sp->isSetDelay())
{
const Delay* dl = sp->getDelay();
if (dl->isSetNotes()) cout << " ";
printNotes(const_cast<Delay*>(dl));
}
/* EventAssignment */
for(j=0; j < sp->getNumEventAssignments(); j++)
{
EventAssignment* ea = sp->getEventAssignment(j);
if (ea->isSetNotes()) cout << " ";
printNotes(ea);
}
}
/* SpeciesType */
for(i=0; i < m->getNumSpeciesTypes(); i++)
{
SpeciesType* sp = m->getSpeciesType(i);
printNotes(sp);
}
/* Constraint */
for(i=0; i < m->getNumConstraints(); i++)
{
Constraint* sp = m->getConstraint(i);
printNotes(sp);
}
delete document;
return errors;
}
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();
}
}
}
}
}
/**
* Load a gene network from an SBML file. Overrides Structure.load(). Format must
* be equal GeneNetwork.SBML. Note, the SBML file must be in the exact same format
* as the SBML files produced by writeSBML(). In particular, we assume that reactions are listed
* *ordered* as we do in writeSBML().
* @param filename URL to the file describing the network to load
* @param format File format (GML, DOT, etc.)
* @throws IOException
*/
void GeneNetwork::load_sbml(const char *filename) {
SBMLDocument* document;
SBMLReader reader;
document = reader.readSBML(filename);
unsigned int errors = document->getNumErrors();
if (errors > 0) {
std::cerr << "Failed to open file " << filename << std::endl;
exit(1);
}
Model *m = document->getModel();
// -----------------------------------------
// Set the network size and create the genes
// do not count the species _void_
int size = m->getNumSpecies() - 1;
ListOfSpecies *species = m->getListOfSpecies();
for (int g=0; g < size; g++) {
if (species->get(g)->getId() != "_void_") {
//HillGene hg = new HillGene(this);
//hg.setLabel(species.get(g).getId());
HillGene *n = new HillGene(species->get(g)->getId());
//n.setLabel(species->get(g)->getId());
nodes_.push_back(*n);
delete n;
}
}
x_ = Vec_DP(nodes_.size());
x_ = 0;
y_ = Vec_DP(nodes_.size());
y_ = 0;
//vector<string> parameterNames; // the names of the parameters
//vector<double> parameterValues; // the values of the parameters
std::map<std::string, double> params;
std::vector<std::string> inputNodes; // the indexes of the inputs
HillGene src, tgt;
Parameter *param;
// 2 loops for one gene: both synthesis and degradation reactions
// (we assume that reactions are listed *ordered* as we do in writeSBML())
//int counter = 0;
for (unsigned int i=0; i < m->getNumReactions(); i++) {
Reaction *re = m->getReaction(i);
std::string id = re->getId();
std::stringstream ss;
ss << i;
//::logging::log::emit<Debug>() << id.c_str() <<
// ::logging::log::endl;
tgt = nodes_.at(getIndexOfNode(getGeneReactantId(id)));
//tgt->setLabel(getGeneReactantId(*re));
//SpeciesReference *rt = re->getReactant(0);
//Node *tgt = new HillGene();
//tgt->setLabel(rt->getSpecies());
//ListOfSpeciesReferences *modifiers = re->getListOfModifiers();
for (unsigned int j=0; j < re->getNumModifiers(); j++) {
ModifierSpeciesReference *md = re->getModifier(j);
src = nodes_.at(getIndexOfNode(md->getSpecies()));
inputNodes.push_back(src.getLabel());
// set output genes
std::vector<std::string> outputs = src.getOutputGenes();
outputs.push_back(tgt.getLabel());
src.setOutputGenes(outputs);
// The edge type is unknown for now, it is initialized later
Edge *e = new Edge(&src, &tgt, "+-");
edges_.push_back(*e);
//delete src;
delete e;
}
KineticLaw *kl = re->getKineticLaw();
for(unsigned int j=0; j < kl->getNumParameters(); j++) {
param = kl->getParameter(j);
params[param->getId()] = param->getValue();
//char buf[256];
//sprintf(buf, "%s\t%f", param->getId().c_str(), param->getValue());
//::logging::log::emit<Info>() << buf << ::logging::log::endl;
}
//::logging::log::emit<Info>() << ::logging::log::dec << params.size() <<
// ::logging::log::endl;
// in the second iteration for this gene
if (i%2 == 1) {
// set parameters in gene
//tgt.initialization(params, inputNodes);
nodes_.at(getIndexOfNode(getGeneReactantId(id))).initialization(params, inputNodes);;
//char buf[256];
//sprintf(buf, "%f", params["k_1"]);
//::logging::log::emit<Info>() << buf << ::logging::log::endl;
inputNodes.clear(); // don't clear because the reference was copied to the gene
//parameterNames.clear(); // reset (they were not copied)
//parameterValues.clear();
params.clear();
}
//counter++;
}
//setEdgeTypesAccordingToDynamicalModel();
//signed_ = true;
//delete document;
//delete n;
//delete e;
}
//static
void SBMLUtils::collectIds(Model* pModel, std::map<std::string, const SBase*>& ids, std::map<std::string, const SBase*>& metaIds)
{
if (pModel != NULL)
{
// the model itself
SBase* pSBase = NULL;
std::string id;
if (pModel->isSetId())
{
id = pModel->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pModel->isSetMetaId())
{
id = pModel->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// ListOfFunctionDefinitions
pSBase = pModel->getListOfFunctionDefinitions();
if (pSBase != NULL)
{
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// all FunctionDefinitions
unsigned int i, iMax = pModel->getListOfFunctionDefinitions()->size();
for (i = 0; i < iMax; ++i)
{
pSBase = pModel->getListOfFunctionDefinitions()->get(i);
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
// ListOfUnitDefinition
pSBase = pModel->getListOfUnitDefinitions();
if (pSBase != NULL)
{
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// all UnitDefinitions
// for each UnitDefinition: ListOfUnits, each Unit in ListOfUnits
unsigned int i, iMax = pModel->getListOfUnitDefinitions()->size();
for (i = 0; i < iMax; ++i)
{
/* UnitDefinitions have their ids in a different namespace
so we only consider meta ids.
*/
UnitDefinition* pUDef = pModel->getUnitDefinition(i);
assert(pUDef != NULL);
if (pUDef->isSetMetaId())
{
id = pUDef->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pUDef));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
ListOf* pList = pUDef->getListOfUnits();
if (pList != NULL)
{
if (pList->isSetMetaId())
{
id = pList->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pList));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
unsigned j, jMax = pList->size();
for (j = 0; j < jMax; ++j)
{
pSBase = pList->get(j);
assert(pSBase != NULL);
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
}
}
// ListOfCompartmentTypes
pSBase = pModel->getListOfCompartmentTypes();
if (pSBase != NULL)
{
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// each compartment type
unsigned int i, iMax = pModel->getListOfCompartmentTypes()->size();
for (i = 0; i < iMax; ++i)
{
pSBase = pModel->getCompartmentType(i);
assert(pSBase != NULL);
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
// ListOfSpeciesTypes
pSBase = pModel->getListOfSpeciesTypes();
if (pSBase != NULL)
{
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// each species type
unsigned int i, iMax = pModel->getListOfSpeciesTypes()->size();
for (i = 0; i < iMax; ++i)
{
pSBase = pModel->getSpeciesType(i);
assert(pSBase != NULL);
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
// ListOfCompartments
pSBase = pModel->getListOfCompartments();
if (pSBase != NULL)
{
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// all compartments
unsigned int i, iMax = pModel->getListOfCompartments()->size();
for (i = 0; i < iMax; ++i)
{
pSBase = pModel->getCompartment(i);
assert(pSBase != NULL);
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
// ListOfSpecies
pSBase = pModel->getListOfSpecies();
if (pSBase != NULL)
{
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// all species
unsigned int i, iMax = pModel->getListOfSpecies()->size();
for (i = 0; i < iMax; ++i)
{
pSBase = pModel->getSpecies(i);
assert(pSBase != NULL);
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
// ListOfParameters
pSBase = pModel->getListOfParameters();
if (pSBase != NULL)
{
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// each parameter
unsigned int i, iMax = pModel->getListOfParameters()->size();
for (i = 0; i < iMax; ++i)
{
pSBase = pModel->getParameter(i);
assert(pSBase != NULL);
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
// ListOfInitialAssignments
pSBase = pModel->getListOfInitialAssignments();
if (pSBase != NULL)
{
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// each initial assignment
unsigned int i, iMax = pModel->getListOfInitialAssignments()->size();
for (i = 0; i < iMax; ++i)
{
pSBase = pModel->getInitialAssignment(i);
assert(pSBase != NULL);
// initial assignments have no ids
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
// ListOfRules
pSBase = pModel->getListOfRules();
if (pSBase != NULL)
{
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// each rule
unsigned int i, iMax = pModel->getListOfRules()->size();
for (i = 0; i < iMax; ++i)
{
pSBase = pModel->getRule(i);
assert(pSBase != NULL);
// rules don't have ids
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
// ListOfConstraints
pSBase = pModel->getListOfConstraints();
if (pSBase != NULL)
{
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// each constraint
unsigned int i, iMax = pModel->getListOfConstraints()->size();
for (i = 0; i < iMax; ++i)
{
pSBase = pModel->getConstraint(i);
assert(pSBase != NULL);
// constraints don't have ids
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
// ListOfReactions
pSBase = pModel->getListOfReactions();
if (pSBase != NULL)
{
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// all reactions
unsigned int i, iMax = pModel->getListOfReactions()->size();
for (i = 0; i < iMax; ++i)
{
Reaction* pReaction = pModel->getReaction(i);
assert(pReaction != NULL);
if (pReaction->isSetId())
{
id = pReaction->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pReaction));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pReaction->isSetMetaId())
{
id = pReaction->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pReaction));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// for each reaction: ListOfSubstrates, each substrate, ListOfProducts, each
// Product, ListOfModifieres, each modifier, KineticLaw, ListOfparameters,
// each parameter
if (pReaction->getListOfReactants() != NULL)
{
pSBase = pReaction->getListOfReactants();
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
unsigned int j, jMax = pReaction->getListOfReactants()->size();
for (j = 0; j < jMax; ++j)
{
pSBase = pReaction->getReactant(j);
assert(pSBase != NULL);
// since L2V2 species references can have ids
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
if (pReaction->getListOfProducts() != NULL)
{
pSBase = pReaction->getListOfProducts();
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
unsigned int j, jMax = pReaction->getListOfProducts()->size();
for (j = 0; j < jMax; ++j)
{
pSBase = pReaction->getProduct(j);
assert(pSBase != NULL);
// since L2V2 species references can have ids
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
if (pReaction->getListOfModifiers() != NULL)
{
pSBase = pReaction->getListOfModifiers();
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
unsigned int j, jMax = pReaction->getListOfModifiers()->size();
for (j = 0; j < jMax; ++j)
{
pSBase = pReaction->getModifier(j);
assert(pSBase != NULL);
// since L2V2 species references can have ids
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
KineticLaw* pKLaw = pReaction->getKineticLaw();
if (pKLaw != NULL)
{
if (pKLaw->isSetMetaId())
{
id = pKLaw->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pKLaw));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
pSBase = pKLaw->getListOfParameters();
if (pSBase != NULL)
{
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
unsigned int j, jMax = pKLaw->getListOfParameters()->size();
for (j = 0; j < jMax; ++j)
{
pSBase = pKLaw->getParameter(j);
assert(pSBase != NULL);
// local parameters have their ids in a
// different namespace
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
}
}
}
// ListOfEvents
pSBase = pModel->getListOfEvents();
if (pSBase != NULL)
{
if (pSBase->isSetId())
{
id = pSBase->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pModel));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// each event
unsigned int i, iMax = pModel->getListOfEvents()->size();
for (i = 0; i < iMax; ++i)
{
Event* pEvent = pModel->getEvent(i);
assert(pEvent != NULL);
if (pEvent->isSetId())
{
id = pEvent->getId();
if (ids.find(id) == ids.end())
{
ids.insert(std::pair<const std::string, const SBase*>(id, pEvent));
}
else
{
CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 68, id.c_str());
}
}
if (pEvent->isSetMetaId())
{
id = pEvent->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pEvent));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
// in each event Trigger,Delay,ListOfEventAssignments, each event assignment
if (pEvent->isSetTrigger())
{
pSBase = pEvent->getTrigger();
assert(pSBase != NULL);
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
if (pEvent->isSetDelay())
{
pSBase = pEvent->getDelay();
assert(pSBase != NULL);
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
if (pEvent->getListOfEventAssignments() != NULL)
{
pSBase = pEvent->getListOfEventAssignments();
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
unsigned int j, jMax = pEvent->getListOfEventAssignments()->size();
for (j = 0; j < jMax; ++j)
{
pSBase = pEvent->getEventAssignment(j);
assert(pSBase != NULL);
if (pSBase->isSetMetaId())
{
id = pSBase->getMetaId();
if (metaIds.find(id) == metaIds.end())
{
metaIds.insert(std::pair<const std::string, const SBase*>(id, pSBase));
}
else
{
CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 67, id.c_str());
}
}
}
}
}
}
}
}
