/*
* 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;
}
//create REACTION
void SbmlReader::createReaction( map< string,Id > &molMap )
{
map< string,double > rctMap;
map< string,double >::iterator rctMap_iter;
map< string,double >pdtMap;
map< string,double >::iterator pdtMap_iter;
map< string,Eref >::iterator elemt_iter;
map< string,EnzymeInfo >enzInfoMap;
double rctorder,pdtorder;
static const Cinfo* moleculeCinfo = initMoleculeCinfo();
static const Finfo* reacFinfo =moleculeCinfo->findFinfo( "reac" );
static const Cinfo* reactionCinfo = initReactionCinfo();
static const Finfo* subFinfo = reactionCinfo->findFinfo( "sub" );
static const Finfo* prdFinfo = reactionCinfo->findFinfo( "prd" );
static const Finfo* kfFinfo = reactionCinfo->findFinfo( "kf" );
static const Finfo* kbFinfo = reactionCinfo->findFinfo( "kb" );
Reaction* reac;
for ( unsigned int r = 0; r < model_->getNumReactions(); r++ )
{
reac = model_->getReaction( r );
const string id=reac->getId();
//cout<<"reaction is "<<id<<endl;
std::string name;
if ( reac->isSetName() ){
name = reac->getName();
}
string grpname = getAnnotation( reac,enzInfoMap );
if ( (grpname != "") && (enzInfoMap[grpname].stage == 3) )
setupEnzymaticReaction( enzInfoMap[grpname],grpname );
else if ( grpname == "" )
{
if ( reac->getNumModifiers()> 0 )
setupMMEnzymeReaction( reac,id );
else{
bool rev=reac->getReversible();
bool fast=reac->getFast();
if ( fast ){
cout<<"warning: for now fast attribute is not handled"<<endl;
errorFlag_ = true;
}
int numRcts = reac->getNumReactants();
int numPdts = reac->getNumProducts();
if ( numRcts == 0 && numPdts != 0 ){
const SpeciesReference* pdt = reac->getProduct( 0 );
std::string spName = pdt->getSpecies();
Id parent = molMap.find( spName )->second; //gives compartment of spName
string parentCompt = parent()->name();
//cout<<"parent of reactant :"<<parentCompt<<endl;
ostringstream spId;
spId <<id<<"_Src";
molecule_ = Neutral::create( "Molecule",spId.str(),parent,Id::scratchId() );//create Molecule
molMap[spId.str()] = parent;
elmtMap_[spId.str()] = Eref( molecule_ );
::set< double >( molecule_,"conc", 1 );
::set< int >( molecule_,"mode",4 );
reaction_ = Neutral::create( "Reaction",id,parent,Id::scratchId() ); //create Reaction
Eref( reaction_ ).add( subFinfo->msg(),elmtMap_[spId.str()],reacFinfo->msg(),ConnTainer::Default );
}
else{
const SpeciesReference* rect=reac->getReactant(0);
std::string sp=rect->getSpecies();
Id m = molMap.find(sp)->second; //gives compartment of sp
reaction_ = Neutral::create( "Reaction",id,m,Id::scratchId() ); //create Reaction
double rctcount=0.0;
rctMap.clear();
for ( unsigned int rt=0;rt<reac->getNumReactants();rt++ )
{
const SpeciesReference* rct=reac->getReactant(rt);
sp=rct->getSpecies();
rctMap_iter = rctMap.find(sp);
if ( rctMap_iter != rctMap.end() ){
rctcount = rctMap_iter->second;
}
else {
rctcount = 0.0;
}
rctcount += rct->getStoichiometry();
rctMap[sp] = rctcount;
for ( int i=0;(int)i<rct->getStoichiometry();i++ )
{
Eref(reaction_).add( subFinfo->msg(),elmtMap_[sp],reacFinfo->msg(),ConnTainer::Default );
}
}
}
double pdtcount = 0.0;
pdtMap.clear();
for ( unsigned int pt=0;pt<reac->getNumProducts();pt++ )
{
const SpeciesReference* pdt=reac->getProduct(pt);
std::string sp=pdt->getSpecies();
pdtMap_iter = pdtMap.find(sp);
if ( pdtMap_iter != pdtMap.end() ){
pdtcount = pdtMap_iter->second;
}
else {
pdtcount = 0.0;
}
pdtcount += pdt->getStoichiometry();
pdtMap[sp] = pdtcount;
for ( int i=0;i<pdt->getStoichiometry();i++ )
{
Eref(reaction_).add( prdFinfo->msg(),elmtMap_[sp],reacFinfo->msg(),ConnTainer::Default );
}
}
//order of reactants
rctorder = 0.0;
string rsp = "",psp = "";
for ( rctMap_iter=rctMap.begin();rctMap_iter!=rctMap.end();rctMap_iter++ )
{
rctorder += rctMap_iter->second;
rsp=rctMap_iter->first; //species of the reactant
}
//cout<<"rct order = "<<rctorder<<endl;
//order of products
pdtorder = 0.0;
for ( pdtMap_iter=pdtMap.begin();pdtMap_iter!=pdtMap.end();pdtMap_iter++ )
{
pdtorder += pdtMap_iter->second;
psp=pdtMap_iter->first; //species of the product
}
//cout<<"pdt order = "<<pdtorder<<endl;
if ( reac->isSetKineticLaw() )
{ KineticLaw * klaw=reac->getKineticLaw();
//vector< double > rate = getKLaw( klaw,rev );
vector< double > rate;
rate.clear();
getKLaw( klaw,rev,rate );
if ( errorFlag_ )
return;
else if ( !errorFlag_ ){
::set< double >( reaction_, kfFinfo, rate[0] );
::set< double >( reaction_, kbFinfo, rate[1] );
}
}
}//else modifier
}//else
}//reaction
}//create reaction
void SbmlReader::createReaction(const map< string, Id > &molSidcmptMIdMap ) {
Reaction* reac;
map< string,double > rctMap;
map< string,double >::iterator rctMap_iter;
map< string,double >prdMap;
map< string,double >::iterator prdMap_iter;
map< string,EnzymeInfo >enzInfoMap;
for ( unsigned int r = 0; r < model_->getNumReactions(); r++ ) {
Id reaction_;
reac = model_->getReaction( r );
noOfsub_ = 0;
noOfprd_ = 0;
std:: string id; //=reac->getId();
if ( reac->isSetId() )
id = reac->getId();
std::string name;
if ( reac->isSetName() ) {
name = reac->getName();
name = nameString(name);
}
if (name.empty()) {
if (id.empty())
assert("Reaction id and name is empty");
else
name = id;
}
string grpname = getAnnotation( reac,enzInfoMap );
if ( (grpname != "") && (enzInfoMap[grpname].stage == 3) ) {
setupEnzymaticReaction( enzInfoMap[grpname],grpname ,molSidcmptMIdMap,name);
}
//if (grpname != "")
// {
//cout << "\n enz matic reaction " << enzInfoMap[grpname].stage;
//setupEnzymaticReaction( enzInfoMap[grpname],grpname ,molSidcmptMIdMap);
//}
else if ( grpname == "" ) {
if (reac->getNumModifiers() > 0)
setupMMEnzymeReaction( reac,id,name ,molSidcmptMIdMap);
else {
bool rev=reac->getReversible();
bool fast=reac->getFast();
if ( fast ) {
cout<<"warning: for now fast attribute is not handled"<<endl;
errorFlag_ = true;
}
int numRcts = reac->getNumReactants();
int numPdts = reac->getNumProducts();
if ( numRcts == 0 && numPdts != 0 ) {
cout << "Reaction with zero Substrate is not possible but exist in this model";
const SpeciesReference* pdt = reac->getProduct( 0 );
std::string spName = pdt->getSpecies();
Id parent = molSidcmptMIdMap.find( spName )->second; //gives compartment of spName
cout << " \n \t ################################# Sub = 0 and prd != 0 need to the reac ############### ";
const SpeciesReference* rect=reac->getReactant(0);
std::string sp=rect->getSpecies();
Id comptRef = molSidcmptMIdMap.find(sp)->second; //gives compartment of sp
Id meshEntry = Neutral::child( comptRef.eref(), "mesh" );
Shell* shell = reinterpret_cast< Shell* >( Id().eref().data() );
reaction_ = shell->doCreate("Reac", meshEntry, name, 1);
//shell->doAddMsg( "Single", meshEntry, "remeshReacs", reaction_, "remesh");
//Get Substrate
addSubPrd(reac,reaction_,"prd");
} //if numRcts == 0
else {
const SpeciesReference* rect=reac->getReactant(0);
std::string sp=rect->getSpecies();
Id comptRef = molSidcmptMIdMap.find(sp)->second; //gives compartment of sp
Id meshEntry = Neutral::child( comptRef.eref(), "mesh" );
Shell* shell = reinterpret_cast< Shell* >( Id().eref().data() );
reaction_ = shell->doCreate("Reac", comptRef, name, 1);
//shell->doAddMsg( "Single", meshEntry, "remeshReacs", reaction_, "remesh");
//Get Substrate
addSubPrd(reac,reaction_,"sub");
//Get Product
addSubPrd(reac,reaction_,"prd");
}
if ( reac->isSetKineticLaw() ) {
KineticLaw * klaw=reac->getKineticLaw();
//vector< double > rate = getKLaw( klaw,rev );
vector< double > rate;
rate.clear();
getKLaw( klaw,rev,rate );
if ( errorFlag_ )
return;
else if ( !errorFlag_ ) {
//cout << " Reaction name " << name << " kf " << rate[0] << " kb " << rate[1]<<endl;
Field < double > :: set( reaction_, "Kf", rate[0] );
Field < double > :: set( reaction_, "Kb", rate[1] );
/*if (numRcts > 1)
rate[0] = rate[0]*pow(1e3,1.0);
cout << "Reaction " << id << " " << name << " " << rate[0] << " " << rate[1]<<endl;
Field < double > :: set( reaction_, "Kf", rate[0] );
Field < double > :: set( reaction_, "Kb", rate[1] );
*/
}
} //issetKineticLaw
} //else
} // else grpname == ""
}//for unsigned
} //reaction