bool variesIn(string id, Model* model, const map<string, vector<double> >& results) { if (variesIn(id, results)) return true; Rule* rule = model->getRule(id); if (rule != NULL) { if (rule->getTypeCode() == SBML_RATE_RULE) return true; return variesIn(rule->getMath(), model, results); } if (!getConstant(id, model, results)) { //The variable might be set by an algebraic rule for (unsigned long r=0; r<model->getNumRules(); r++) { if (model->getRule(r)->getTypeCode() == SBML_ALGEBRAIC_RULE) { if (appearsIn(id, model->getRule(r)->getMath()) && variesBesides(id, model->getRule(r)->getMath(), model, results)) return true; } } } for (unsigned long e=0; e<model->getNumEvents(); e++) { Event* event = model->getEvent(e); for (unsigned long ea=0; ea<event->getNumEventAssignments(); ea++) { if (event->getEventAssignment(ea)->getVariable() == id) return true; } } Species* species = model->getSpecies(id); if (species==NULL) return false; if (species->isSetBoundaryCondition() && species->getBoundaryCondition()==true) return false; for (unsigned long r=0; r<model->getNumReactions(); r++) { Reaction* rxn = model->getReaction(r); if (variesIn(id, rxn->getListOfReactants(), results)) return true; if (variesIn(id, rxn->getListOfProducts(), results)) return true; } return false; }
void CrfSaver::_writeReactionMolecule (Reaction &reaction, int i) { _atom_stereo_flags = reaction.getInversionArray(i).ptr(); _bond_rc_flags = reaction.getReactingCenterArray(i).ptr(); _aam = reaction.getAAMArray(i).ptr(); _writeMolecule(reaction.getMolecule(i)); }
void CrfSaver::saveReaction (Reaction &reaction) { _writeReactionInfo(reaction); int i; _atom_stereo_flags = 0; _bond_rc_flags = 0; _aam = 0; for (i = reaction.reactantBegin(); i < reaction.reactantEnd(); i = reaction.reactantNext(i)) _writeReactionMolecule(reaction, i); for (i = reaction.productBegin(); i < reaction.productEnd(); i = reaction.productNext(i)) _writeReactionMolecule(reaction, i); if (reaction.catalystCount() > 0) { for (i = reaction.catalystBegin(); i < reaction.catalystEnd(); i = reaction.catalystNext(i)) _writeReactionMolecule(reaction, i); } if (_encoder.get() != 0) _encoder->finish(); }
Value * add_reaction ( std::list<Value *> * args, Scope * s ) { World * world = current_gro_program->get_world(); // args are: reactants, products, rate std::list<Value *>::iterator i = args->begin(); Value * R = *i; i++; Value * P = *i; i++; Value * k = *i; Reaction r (k->num_value()); for ( i=R->list_value()->begin(); i != R->list_value()->end(); i++ ) { if ( (*i)->int_value() < 0 || (*i)->int_value() >= world->num_signals() ) throw std::string ( "Reaction refers to a non-existant reactant." ); r.add_reactant( (*i)->int_value() ); } for ( i=P->list_value()->begin(); i != P->list_value()->end(); i++ ) { if ( (*i)->int_value() < 0 || (*i)->int_value() >= world->num_signals() ) throw std::string ( "Reaction refers to a non-existant product." ); r.add_product( (*i)->int_value() ); } world->add_reaction(r); return new Value ( Value::UNIT ); }
void AssignmentCycles::addReactionDependencies(const Model& m, const Reaction& object) { unsigned int ns; std::string thisId = object.getId(); /* loop thru the list of names in the Math * if they refer to a Reaction, an Assignment Rule * or an Initial Assignment add to the map * with the variable as key */ List* variables = object.getKineticLaw()->getMath() ->getListOfNodes( ASTNode_isName ); for (ns = 0; ns < variables->getSize(); ns++) { ASTNode* node = static_cast<ASTNode*>( variables->get(ns) ); string name = node->getName() ? node->getName() : ""; if (m.getReaction(name)) { mIdMap.insert(pair<const std::string, std::string>(thisId, name)); } else if (m.getRule(name) && m.getRule(name)->isAssignment()) { mIdMap.insert(pair<const std::string, std::string>(thisId, name)); } else if (m.getInitialAssignment(name)) { mIdMap.insert(pair<const std::string, std::string>(thisId, name)); } } delete variables; }
/* 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); } } } }
bool getConstant(string id, Model* model, const map<string, vector<double> >& results) { if (variesIn(id, results)) return false; SBase* element = model->getElementBySId(id); Compartment* comp = static_cast<Compartment*>(element); Species* species = static_cast<Species*>(element); Parameter* param = static_cast<Parameter*>(element); Reaction* rxn = static_cast<Reaction*>(element); SpeciesReference* sr= static_cast<SpeciesReference*>(element); switch (element->getTypeCode()) { case SBML_COMPARTMENT: if (!comp->getConstant()) return false; break; case SBML_SPECIES: if (!species->getConstant()) return false; break; case SBML_PARAMETER: if (!param->getConstant()) return false; break; case SBML_REACTION: if (rxn->isSetKineticLaw()) { if (variesIn(rxn->getKineticLaw()->getMath(), model, results)) return false; } break; case SBML_SPECIES_REFERENCE: if (!sr->getConstant()) return false; break; default: assert(false); //Uncaught type! return true; break; } return true; }
void ReactionAtomNeighbourhoodCounters::calculate(Reaction &reac) { int i; _counters.resize(reac.count()); for (i = reac.begin(); i < reac.end(); i = reac.next(i)) _counters[i].calculate(reac.getMolecule(i)); }
unsigned int AtomicCompositionTable::CheckStoichiometry(std::ostream& fOut, const Reaction& reaction, const double epsilon) { Eigen::VectorXd reactant_side(element_weights_list_.size()); Eigen::VectorXd product_side(element_weights_list_.size()); reactant_side.setZero(); product_side.setZero(); for(unsigned int i=0;i<reaction.reactant_nu_indices().size();i++) for(int j=0;j<reactant_side.size();j++) reactant_side(j) += element_coefficients_list_(reaction.reactant_nu_indices()[i],j)*reaction.reactant_nu()[i]; for(unsigned int i=0;i<reaction.product_nu_indices().size();i++) for(int j=0;j<product_side.size();j++) product_side(j) += element_coefficients_list_(reaction.product_nu_indices()[i],j)*reaction.product_nu()[i]; Eigen::VectorXd relative_errors(element_weights_list_.size()); for(int i=0;i<reactant_side.size();i++) relative_errors(i) = std::fabs(reactant_side(i)-product_side(i))/std::max((reactant_side(i)+product_side(i))*0.5, 1.e-32); for(int i=0;i<reactant_side.size();i++) if (relative_errors(i)>epsilon) { fOut << "Error in reaction stoichiometry" << std::endl; fOut << "Atom Reactants Products Rel. error(%)" << std::endl; for(int k=0;k<reactant_side.size();k++) { if (relative_errors(k)*100. > epsilon) { fOut << std::left << std::setw(10) << element_names_list_[k]; fOut << std::left << std::setw(16) << reactant_side(k); fOut << std::left << std::setw(16) << product_side(k); fOut << std::left << std::setw(16) << relative_errors(k)*100.; fOut << std::endl; } } return 1; } double max_relative_errors = relative_errors.maxCoeff(); if (max_relative_errors>1.e-12) { fOut << "Warning: the reaction is not perfectly balanced!" << std::endl; fOut << "Atom Reactants Products Rel. error(%)" << std::endl; for(int k=0;k<reactant_side.size();k++) { if (relative_errors(k)*100. > 1e-10) { fOut << std::left << std::setw(10) << element_names_list_[k]; fOut << std::left << std::setw(16) << reactant_side(k); fOut << std::left << std::setw(16) << product_side(k); fOut << std::left << std::setw(16) << relative_errors(k)*100.; fOut << std::endl; } } return 2; } return 0; }
void CrfLoader::_loadReactionMolecule (Reaction &reaction, int index, bool have_aam) { _bond_rc_flags = &reaction.getReactingCenterArray(index); _atom_stereo_flags = &reaction.getInversionArray(index); if (have_aam) _aam = &reaction.getAAMArray(index); _loadMolecule(reaction.getMolecule(index)); }
void CrfSaver::_writeReactionInfo (Reaction &reaction) { _output.writeByte(reaction.reactantsCount()); _output.writeByte(reaction.productsCount()); byte have_aam = 1; _output.writeByte(have_aam); }
END_TEST START_TEST ( test_Reaction ) { Reaction* r = new Reaction(2, 4); fail_unless (r->hasRequiredElements()); delete r; }
void checkReactions(Model* model, set<string>& components, set<string>& tests, const map<string, vector<double> >& results, int type) { if (model->getNumReactions() > 0) { components.insert("Reaction"); for (unsigned int r=0; r<model->getNumReactions(); r++) { Reaction* rxn = model->getReaction(r); if (rxn->isSetFast() && rxn->getFast()) { tests.insert("FastReaction"); } if (rxn->isSetReversible() && rxn->getReversible()) { if (type!=1) { tests.insert("ReversibleReaction [?]"); } } ListOfSpeciesReferences* reactants = rxn->getListOfReactants(); checkSpeciesRefs(model, reactants, components, tests, results); ListOfSpeciesReferences* products = rxn->getListOfProducts(); checkSpeciesRefs(model, products, components, tests, results); if (rxn->isSetKineticLaw()) { KineticLaw* kl = rxn->getKineticLaw(); if (kl->getNumParameters() > 0) { tests.insert("LocalParameters"); } if (kl->isSetMath() == false) { tests.insert("NoMathML"); } } } } }
END_TEST START_TEST ( test_KineticLaw_parent_create ) { Reaction * r = new Reaction(2, 4); KineticLaw* kl = r->createKineticLaw(); fail_unless(r == kl->getParentSBMLObject()); delete r; }
void CrfSaver::_writeReactionInfo (Reaction &reaction) { _output.writePackedUInt(reaction.reactantsCount()); _output.writePackedUInt(reaction.productsCount()); byte features = CrfFeatureFlags::CRF_AAM; if (reaction.catalystCount() > 0) features |= CrfFeatureFlags::CRF_CATALYST; _output.writeByte(features); if (reaction.catalystCount() > 0) _output.writePackedUInt(reaction.catalystCount()); }
END_TEST START_TEST ( test_Reaction_parent_create ) { Model *m = new Model(2, 4); Reaction *r = m->createReaction(); ListOf *lo = m->getListOfReactions(); fail_unless(lo == m->getReaction(0)->getParentSBMLObject()); fail_unless(lo == r->getParentSBMLObject()); fail_unless(m == lo->getParentSBMLObject()); }
END_TEST START_TEST ( test_KineticLaw_parent_create_model ) { Model *m = new Model(2, 4); Reaction * r = m->createReaction(); KineticLaw* kl = r->createKineticLaw(); fail_unless(r == kl->getParentSBMLObject()); fail_unless(r == r->getKineticLaw()->getParentSBMLObject()); delete r; }
END_TEST START_TEST ( test_Reaction ) { Reaction* r = new Reaction(2, 4); fail_unless (!(r->hasRequiredAttributes())); r->setId("r"); fail_unless (r->hasRequiredAttributes()); delete r; }
END_TEST START_TEST ( test_SpeciesReference_Reactant_parent_create ) { Reaction *r = new Reaction(2, 4); SpeciesReference *sr = r->createReactant(); ListOf *lo = r->getListOfReactants(); fail_unless(lo == r->getReactant(0)->getParentSBMLObject()); fail_unless(lo == sr->getParentSBMLObject()); fail_unless(r == lo->getParentSBMLObject()); }
END_TEST START_TEST (test_WriteL3SBML_Reaction_compartment) { const char* expected = "<reaction id=\"r\" reversible=\"false\"" " fast=\"true\" compartment=\"c\"/>"; const char* expected1 = "<reaction id=\"r\" reversible=\"false\"" " fast=\"true\"/>"; Reaction *r = D->createModel()->createReaction(); r->setId("r"); r->setReversible(false); r->setFast(true); r->setCompartment("c"); char* sbml = r->toSBML(); fail_unless( equals(expected, sbml) ); safe_free(sbml); r->unsetCompartment(); sbml = r->toSBML(); fail_unless( equals(expected1, sbml) ); safe_free(sbml); }
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()); }
void convertPow(SBMLDocument* doc, bool shouldChangePow, bool inlineCompartmentSizes) { Model* model = SBMLDocument_getModel(doc); if (model == NULL) { return; } std::map<string, double> compartmentValueMap; if (inlineCompartmentSizes) { for(unsigned int i = 0; i < model->getNumCompartments(); ++i) { Compartment* c = model->getCompartment(i); compartmentValueMap[c->getId()] = c->getSize(); } } for(unsigned int i = 0; i < model->getNumReactions(); ++i) { Reaction* r = model->getReaction(i); KineticLaw* kl = r->getKineticLaw(); const char* strKineticFormula; if (kl == NULL) { strKineticFormula = ""; } else { strKineticFormula = KineticLaw_getFormula(kl); if (strKineticFormula == NULL) { continue; } } ASTNode* ast_Node = SBML_parseFormula (strKineticFormula); if (ast_Node != NULL) { changePow(ast_Node, compartmentValueMap, shouldChangePow); kl->setMath (ast_Node); } delete ast_Node; } }
END_TEST START_TEST (test_WriteL3SBML_Reaction_full) { const char* expected = "<reaction id=\"v1\" reversible=\"true\" fast=\"false\">\n" " <listOfReactants>\n" " <speciesReference species=\"x0\"/>\n" " </listOfReactants>\n" " <listOfProducts>\n" " <speciesReference species=\"s1\"/>\n" " </listOfProducts>\n" " <listOfModifiers>\n" " <modifierSpeciesReference species=\"m1\"/>\n" " </listOfModifiers>\n" " <kineticLaw>\n" " <math xmlns=\"http://www.w3.org/1998/Math/MathML\">\n" " <apply>\n" " <divide/>\n" " <apply>\n" " <times/>\n" " <ci> vm </ci>\n" " <ci> s1 </ci>\n" " </apply>\n" " <apply>\n" " <plus/>\n" " <ci> km </ci>\n" " <ci> s1 </ci>\n" " </apply>\n" " </apply>\n" " </math>\n" " </kineticLaw>\n" "</reaction>"; D->createModel(); Reaction* r = D->getModel()->createReaction(); r->setId("v1"); r->setReversible(true); r->setFast(false); r->createReactant()->setSpecies("x0"); r->createProduct ()->setSpecies("s1"); r->createModifier()->setSpecies("m1"); r->createKineticLaw()->setFormula("(vm * s1)/(km + s1)"); char* sbml = r->toSBML(); fail_unless( equals(expected, sbml) ); safe_free(sbml); }
END_TEST START_TEST ( test_KineticLaw_parent_add ) { KineticLaw* kl=new KineticLaw(2, 4); Reaction * r = new Reaction(2, 4); r->setKineticLaw(kl); fail_unless(r == r->getKineticLaw()->getParentSBMLObject()); delete r; }
END_TEST START_TEST ( test_SpeciesReference_Product_parent_create_model ) { Model *m = new Model(2, 4); Reaction *r = m->createReaction(); SpeciesReference *sr = m->createProduct(); ListOf *lo = r->getListOfProducts(); fail_unless(lo == r->getProduct(0)->getParentSBMLObject()); fail_unless(lo == sr->getParentSBMLObject()); fail_unless(r == lo->getParentSBMLObject()); }
void IcrLoader::loadReaction (Reaction &reaction) { char id[3]; _scanner.readCharsFix(3, id); int version = -1; if (strncmp(id, IcrSaver::VERSION2, 3) == 0) version = 2; else if (strncmp(id, IcrSaver::VERSION1, 3) == 0) version = 1; else throw Error("expected '%s' or '%s', got %.*s. Resave your reaction with new format.", IcrSaver::VERSION1, IcrSaver::VERSION2, 3, id); char bits = _scanner.readChar(); bool have_xyz = ((bits & ICM_XYZ) != 0); bool have_bond_dirs = ((bits & ICM_BOND_DIRS) != 0); CrfLoader loader(_scanner); if (have_xyz) loader.xyz_scanner = &_scanner; loader.version = version; loader.loadReaction(reaction); if (have_xyz) if (!have_bond_dirs) reaction.markStereocenterBonds(); }
void ReactionCdxLoader::loadReaction (Reaction &rxn) { rxn.clear(); QS_DEF(Array<char>, buf); _scanner.readAll(buf); buf.push(0); }
ReactionTest(): myReaction(5.0), emptyReaction(5.0), calcium("Ca"), carbon("C"), oxygen("O"), calcium_carbonate("CaCO3") { calcium.SetConcentration(2.0); carbon.SetConcentration(3.0); oxygen.SetConcentration(5.0); calcium_carbonate.SetConcentration(7.0); myReaction.AddReactant(calcium); myReaction.AddReactant(carbon); myReaction.AddReactant(oxygen); myReaction.AddProduct(calcium_carbonate); };
/** @cond doxygenLibsbmlInternal */ IdList* SBMLLevelVersionConverter::collectSpeciesReferenceIds() { IdList* srids = new IdList(); for (unsigned int i = 0; i < mDocument->getModel()->getNumReactions(); i++) { Reaction *r = mDocument->getModel()->getReaction(i); for (unsigned int j = 0; j < r->getNumReactants(); j++) { if (r->getReactant(j)->isSetId()) { srids->append(r->getReactant(j)->getId()); } } for (unsigned int j = 0; j < r->getNumProducts(); j++) { if (r->getProduct(j)->isSetId()) { srids->append(r->getProduct(j)->getId()); } } } return srids; }
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); } } } }