void SpeciesManager::SetSpeciesHomeworlds(const std::map<std::string, std::set<int>>& species_homeworld_ids) {
CheckPendingSpeciesTypes();
ClearSpeciesHomeworlds();
for (auto& entry : species_homeworld_ids) {
const std::string& species_name = entry.first;
const std::set<int>& homeworlds = entry.second;
Species* species = nullptr;
auto species_it = m_species.find(species_name);
if (species_it != end())
species = species_it->second.get();
if (species) {
species->SetHomeworlds(homeworlds);
} else {
ErrorLogger() << "SpeciesManager::SetSpeciesHomeworlds couldn't find a species with name " << species_name << " to assign homeworlds to";
}
}
}
static void save_molecular_type(const MolecularTypeBase* mtb,
std::vector<std::pair<ParticleID, Voxel> > voxels, H5::Group* group)
{
const Species species(mtb->species());
boost::scoped_ptr<H5::Group> mtgroup(
new H5::Group(group->createGroup(species.serial().c_str())));
h5_species_struct property;
property.radius = mtb->radius();
property.D = mtb->D();
const MolecularTypeBase* loc(mtb->location());
if (loc->is_vacant())
std::strcpy(property.location, "");
else
std::strcpy(property.location, loc->species().serial().c_str());
property.is_structure = mtb->is_structure() ? 1 : 0;
property.dimension = mtb->get_dimension();
H5::CompType property_comp_type(get_property_comp());
mtgroup->createAttribute("property", property_comp_type,
H5::DataSpace(H5S_SCALAR)).write(property_comp_type, &property);
// Save voxels
const Integer num_voxels(voxels.size());
std::size_t vidx(0);
boost::scoped_array<h5_voxel_struct> h5_voxel_array(new h5_voxel_struct[num_voxels]);
for (std::vector<std::pair<ParticleID, Voxel> >::const_iterator itr(voxels.begin());
itr != voxels.end(); ++itr)
{
h5_voxel_array[vidx].lot = (*itr).first.lot();
h5_voxel_array[vidx].serial = (*itr).first.serial();
h5_voxel_array[vidx].coordinate = (*itr).second.coordinate();
++vidx;
}
H5::CompType voxel_comp_type(get_voxel_comp());
hsize_t dims[] = {num_voxels};
H5::DataSpace dspace(/* RANK= */1, dims);
boost::scoped_ptr<H5::DataSet> dset(new H5::DataSet(
mtgroup->createDataSet("voxels", voxel_comp_type, dspace)));
dset->write(h5_voxel_array.get(), dset->getDataType());
}
// Update AtomTypes definitions
void DUQ::updateAtomTypes()
{
// Loop over Atoms in all Species - check AtomType availability and validity for each
AtomType* at;
for (Species* sp = species_.first(); sp != NULL; sp = sp->next)
{
for (SpeciesAtom* i = sp->atoms(); i != NULL; i = i->next)
{
// Is current AtomType definition valid?
if (i->atomType() != NULL)
{
// Check it exists...
if (!atomTypes_.contains(i->atomType())) i->setAtomType(NULL);
else
{
// Check elements
if (i->element() == i->atomType()->element()) continue;
else i->setAtomType(NULL);
}
}
// Either not valid, or nothing present.
// Does an AtomType definition exist for this element?
at = atomTypeForElement(i->element());
if (!at)
{
// Create a suitable AtomType
at = atomTypes_.add();
at->setElement(i->element());
at->setParameters(PeriodicTable::element(i->element()).parameters());
at->setName(uniqueAtomTypeName(PeriodicTable::element(i->element()).symbol(), at));
}
i->setAtomType(at);
}
}
// Step through AtomType definitions and make sure all have a valid set of Parameters
for (AtomType* at = atomTypes_.first(); at != NULL; at = at->next)
{
if (!at->parameters()) at->setParameters(PeriodicTable::element(at->element()).parameters());
}
}
int Database::editSpecies(Species s)
{
QVariant name = s.getName().toString().toLower();
if(this->specieExist(name) > 0){
this->showError(QMessageBox::tr("Esta espécie já existe"));
return 0;
}
if(this->specieExist(name) <= 0){
this->query.prepare("UPDATE Species SET name=? WHERE Species.id=?;");
this->query.addBindValue(name);
this->query.addBindValue(s.getId());
if(!this->query.exec()){
this->showError(this->query.lastError());
return -1;
}
return 1;
}
QMessageBox::information(0, QMessageBox::tr("Erro"),QMessageBox::tr("Espécie não encontrada!"));
return 0;
}
/*
* Initial setup.
*/
void
ClusterIdentifier::initialize(int speciesId, int atomTypeId, double cutoff)
{
// Set member variables
speciesId_ = speciesId;
atomTypeId_ = atomTypeId;
cutoff_ = cutoff;
// Allocate memory
Species* speciesPtr = &system().simulation().species(speciesId);
int moleculeCapacity = speciesPtr->capacity();
links_.allocate(moleculeCapacity);
clusters_.reserve(64);
int atomCapacity = system().simulation().atomCapacity();
cellList_.setAtomCapacity(atomCapacity);
// Note: We must set the cellist atom capacity to the total atom capacity,
// even though we are only interested in clusters of one species, because
// the celllist atom capacity sets the maximum allowed atom index value.
}
END_TEST
START_TEST ( test_Species_parent_add )
{
Species *ia = new Species(2, 4);
ia->setId("s");
ia->setCompartment("c");
Model *m = new Model(2, 4);
m->addSpecies(ia);
delete ia;
ListOf *lo = m->getListOfSpecies();
fail_unless(lo == m->getSpecies(0)->getParentSBMLObject());
fail_unless(m == lo->getParentSBMLObject());
}
void NetworkModel::remove_species_attribute(const Species& sp)
{
species_container_type::iterator i(
std::find(species_attributes_.begin(), species_attributes_.end(), sp));
if (i == species_attributes_.end())
{
std::ostringstream message;
message << "Speices [" << sp.serial() << "] not found";
throw NotFound(message.str()); // use boost::format if it's allowed
}
species_attributes_.erase(i);
}
/*
* Initialize all Angle objects for Molecules of one Species.
*
* This functions assigns pointers to Atoms and angle types ids within a
* contiguous block of Angle objects, and sets a pointer in each Molecule
* to the first Angle in the associated block.
*/
void Simulation::initializeSpeciesAngles(int iSpecies)
{
if (nAngleType_ <= 0) {
UTIL_THROW("nAngleType must be positive");
}
Species* speciesPtr = 0;
Molecule *moleculePtr = 0;
Angle *anglePtr = 0;
Atom *firstAtomPtr, *atom0Ptr, *atom1Ptr, *atom2Ptr;
int iMol, iAngle, atom0Id, atom1Id, atom2Id, type;
int capacity, nAngle;
speciesPtr = &species(iSpecies);
capacity = speciesPtr->capacity();
nAngle = speciesPtr->nAngle();
// Initialize pointers before loop
moleculePtr = &molecules_[firstMoleculeIds_[iSpecies]];
anglePtr = &angles_[firstAngleIds_[iSpecies]];
// Loop over molecules in Species
for (iMol = 0; iMol < capacity; ++iMol) {
firstAtomPtr = &(moleculePtr->atom(0));
moleculePtr->setFirstAngle(*anglePtr);
moleculePtr->setNAngle(nAngle);
if (nAngle > 0) {
// Create angles for a molecule
for (iAngle = 0; iAngle < nAngle; ++iAngle) {
// Get pointers to atoms spanning the angle and angle type
atom0Id = speciesPtr->speciesAngle(iAngle).atomId(0);
atom1Id = speciesPtr->speciesAngle(iAngle).atomId(1);
atom2Id = speciesPtr->speciesAngle(iAngle).atomId(2);
type = speciesPtr->speciesAngle(iAngle).typeId();
atom0Ptr = firstAtomPtr + atom0Id;
atom1Ptr = firstAtomPtr + atom1Id;
atom2Ptr = firstAtomPtr + atom2Id;
// Set fields of the Angle object
anglePtr->setAtom(0, *atom0Ptr);
anglePtr->setAtom(1, *atom1Ptr);
anglePtr->setAtom(2, *atom2Ptr);
anglePtr->setTypeId(type);
++anglePtr;
}
}
++moleculePtr;
}
}
/*
* Generate random molecules
*/
bool Generator::generate(int nMolecule,
const DArray<double>& diameters,
CellList& cellList)
{
// Preconditions
UTIL_CHECK(nMolecule <= species().capacity());
UTIL_CHECK(cellList.atomCapacity() == simulation().atomCapacity());
// Attempt to place all molecules in Species
int speciesId = species().id();
int maxAttempt = 200;
int iAttempt;
bool success;
bool isMutable;
Species* speciesPtr;
for (int iMol = 0; iMol < nMolecule; ++iMol) {
Molecule &newMolecule= simulation().getMolecule(speciesId);
system().addMolecule(newMolecule);
speciesPtr = &system().simulation().species(speciesId);
isMutable = speciesPtr->isMutable();
if (isMutable) {
speciesPtr->mutator().setMoleculeState(newMolecule, 0);
}
success = false;
iAttempt = 0;
while (!success && iAttempt < maxAttempt) {
success = attemptPlaceMolecule(newMolecule,
diameters, cellList);
++iAttempt;
}
if (!success) {
system().removeMolecule(newMolecule);
Log::file() << "Failed to insert Linear molecule "
<< iMol << "\n";
return false;
}
}
return true;
}
/*
* Load from archive.
*/
void EndSwapMove::loadParameters(Serializable::IArchive& ar)
{
McMove::loadParameters(ar);
loadParameter<int>(ar, "speciesId", speciesId_);
ar & atomTypeIds_;
// Validate
Species* speciesPtr = &(simulation().species(speciesId_));
int nAtom = speciesPtr->nAtom();
if (speciesPtr->isMutable()) {
UTIL_THROW("EndSwapMove applied to mutable species");
}
Linear* linearPtr = dynamic_cast<Linear*>(speciesPtr);
if (linearPtr == 0) {
UTIL_THROW("EndSwapMove applied to species that is not Linear");
}
if (nAtom != atomTypeIds_.capacity()) {
UTIL_THROW("Inconsistent capacity for atomTypeIds array");
}
positions_.allocate(nAtom);
}
END_TEST
START_TEST (test_RDFAnnotationMetaid_setAnnotation3)
{
const char * rdfAnn =
"<annotation>\n"
" <rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:dcterms=\"http://purl.org/dc/terms/\" xmlns:vCard=\"http://www.w3.org/2001/vcard-rdf/3.0#\" xmlns:bqbiol=\"http://biomodels.net/biology-qualifiers/\" xmlns:bqmodel=\"http://biomodels.net/model-qualifiers/\">\n"
" <rdf:Description rdf:about=\"#_003\">\n"
" <dc:creator>\n"
" <rdf:Bag>\n"
" <rdf:li rdf:parseType=\"Resource\">\n"
" <vCard:N rdf:parseType=\"Resource\">\n"
" <vCard:Family>Le Novere</vCard:Family>\n"
" <vCard:Given>Nicolas</vCard:Given>\n"
" </vCard:N>\n"
" <vCard:EMAIL>[email protected]</vCard:EMAIL>\n"
" <vCard:ORG rdf:parseType=\"Resource\">\n"
" <vCard:Orgname>EMBL-EBI</vCard:Orgname>\n"
" </vCard:ORG>\n"
" </rdf:li>\n"
" </rdf:Bag>\n"
" </dc:creator>\n"
" <dcterms:created rdf:parseType=\"Resource\">\n"
" <dcterms:W3CDTF>2005-02-02T14:56:11Z</dcterms:W3CDTF>\n"
" </dcterms:created>\n"
" <dcterms:modified rdf:parseType=\"Resource\">\n"
" <dcterms:W3CDTF>2006-05-30T10:46:02Z</dcterms:W3CDTF>\n"
" </dcterms:modified>\n"
" <bqbiol:is>\n"
" <rdf:Bag>\n"
" <rdf:li rdf:resource=\"http://www.geneontology.org/#GO:0007274\"/>\n"
" </rdf:Bag>\n"
" </bqbiol:is>\n"
" </rdf:Description>\n"
" </rdf:RDF>\n"
"</annotation>";
Species *s = m->getSpecies(0);
fail_unless(s->setAnnotation(rdfAnn) == LIBSBML_UNEXPECTED_ATTRIBUTE);
fail_unless(s->getAnnotation() == NULL);
s->setMetaId("_003");
fail_unless(s->setAnnotation(rdfAnn) == LIBSBML_OPERATION_SUCCESS);
fail_unless(s->getAnnotation() != NULL);
fail_unless( equals(rdfAnn, s->getAnnotation()->toXMLString().c_str()));
}
/*
* Initialize all Dihedral objects for Molecules of one Species.
*
* This functions assigns pointers to Atoms and Dihedral types ids within
* a contiguous block of Dihedral objects, and sets a pointer in each
* Molecule to the first Dihedral in the associated block.
*/
void Simulation::initializeSpeciesDihedrals(int iSpecies)
{
Species* speciesPtr = 0;
Molecule *moleculePtr = 0;
Dihedral *dihedralPtr = 0;
Atom *firstAtomPtr, *atom0Ptr, *atom1Ptr, *atom2Ptr, *atom3Ptr;
int iMol, iDihedral, atom0Id, atom1Id, atom2Id, atom3Id, type;
int capacity, nDihedral;
speciesPtr = &species(iSpecies);
capacity = speciesPtr->capacity();
nDihedral = speciesPtr->nDihedral();
// Initialize pointers before loop
moleculePtr = &molecules_[firstMoleculeIds_[iSpecies]];
dihedralPtr = &dihedrals_[firstDihedralIds_[iSpecies]];
// Loop over molecules in Species
for (iMol = 0; iMol < capacity; ++iMol) {
firstAtomPtr = &(moleculePtr->atom(0));
moleculePtr->setFirstDihedral(*dihedralPtr);
moleculePtr->setNDihedral(nDihedral);
if (nDihedral > 0) {
// Create dihedrals for a molecule
for (iDihedral = 0; iDihedral < nDihedral; ++iDihedral) {
// Get local indices for atoms and dihedral type
atom0Id = speciesPtr->speciesDihedral(iDihedral).atomId(0);
atom1Id = speciesPtr->speciesDihedral(iDihedral).atomId(1);
atom2Id = speciesPtr->speciesDihedral(iDihedral).atomId(2);
atom3Id = speciesPtr->speciesDihedral(iDihedral).atomId(3);
type = speciesPtr->speciesDihedral(iDihedral).typeId();
// Calculate atom pointers
atom0Ptr = firstAtomPtr + atom0Id;
atom1Ptr = firstAtomPtr + atom1Id;
atom2Ptr = firstAtomPtr + atom2Id;
atom3Ptr = firstAtomPtr + atom3Id;
// Set fields of the Dihedral object
dihedralPtr->setAtom(0, *atom0Ptr);
dihedralPtr->setAtom(1, *atom1Ptr);
dihedralPtr->setAtom(2, *atom2Ptr);
dihedralPtr->setAtom(3, *atom3Ptr);
dihedralPtr->setTypeId(type);
++dihedralPtr;
}
}
++moleculePtr;
}
}
std::string SEDMLUtils::findIdByNameAndType(
const std::map<CCopasiObject*, SBase*>& map,
int typeCode,
const std::string& name)
{
std::map<CCopasiObject*, SBase*>::const_iterator it = map.begin();
std::string::size_type compartmentStart = name.find("{");
std::string nameOnly = name.substr(0, compartmentStart);
while (it != map.end())
{
SBase* current = it->second;
if (((current->getTypeCode() & typeCode) == typeCode) &&
current->getName() == name)
return current->getId();
if (typeCode == SBML_SPECIES && compartmentStart != std::string::npos)
{
if (((current->getTypeCode() & typeCode) == typeCode) &&
current->getName() == nameOnly)
{
std::string compName = name.substr(compartmentStart + 1, name.size() - compartmentStart - 2);
std::string compId = findIdByNameAndType(map, SBML_COMPARTMENT, compName);
Species* species = (Species*) current;
if (species->getCompartment() == compId)
return species->getId();
}
}
++it;
}
return "";
}
int Database::insertSpecie(Species s)
{
QVariant name = s.getName().toString().toLower();
if(!this->specieExist(name)){
this->query.prepare("INSERT INTO Species (name) VALUES (:name);");
this->query.bindValue(":name",name);
if(!this->query.exec()){
this->showError(this->query.lastError());
return -1;
}
return this->query.lastInsertId().toInt();
}
this->showError(QMessageBox::tr("Essa espécie já existe!"));
return 0;
}
void setupInitialConditions()
{
relVelocity_ = 1e-1;
setName("AdhesiveForceUnitTest_ParticleParticleInteraction");
setParticleDimensions(3);
species->setDensity(2000.0);
species->setStiffness(1e2);
species->setAdhesionStiffness(1e2);
species->setAdhesionForceMax(1e-5*species->getAdhesionStiffness());
species->setSlidingStiffness(1.2e1);
species->setSlidingFrictionCoefficient(0.01);
setSystemDimensions(3);
setGravity(Vec3D(0,0,0));
setTimeStep(5e-6 / 2.0);
Mdouble R = 1e-3;
setXMax( 2*R);
setYMax( R);
setZMax( R);
setXMin(-2*R);
setYMin(-R);
setZMin(-R);
particleHandler.clear();
BaseParticle P;
P.setRadius(R);
P.setPosition(Vec3D(-R-species->getInteractionDistance()/3,0,0));
P.setVelocity(Vec3D(relVelocity_/2,0,0));
particleHandler.copyAndAddObject(P);
P.setPosition(Vec3D(R+species->getInteractionDistance()/3,0,0));
P.setVelocity(Vec3D(-relVelocity_/2,0,0));
particleHandler.copyAndAddObject(P);
setTimeMax(getTimeStep()*250*2);
setFileType(FileType::ONE_FILE);
setSaveCount(1);
}
std::vector<ReactionRule> NetworkModel::query_reaction_rules(
const Species& sp) const
{
first_order_reaction_rules_map_type::const_iterator
i(first_order_reaction_rules_map_.find(sp.serial()));
std::vector<ReactionRule> retval;
if (i != first_order_reaction_rules_map_.end())
{
retval.reserve((*i).second.size());
for (first_order_reaction_rules_map_type::mapped_type::const_iterator
j((*i).second.begin()); j != (*i).second.end(); ++j)
{
retval.push_back(reaction_rules_[*j]);
}
}
return retval;
}
END_TEST
START_TEST (test_WriteL3SBML_Species)
{
const char* expected =
"<species id=\"Ca2\" compartment=\"cell\" initialAmount=\"0.7\""
" substanceUnits=\"mole\" hasOnlySubstanceUnits=\"false\""
" boundaryCondition=\"true\" constant=\"true\"/>";
Species *s = D->createModel()->createSpecies();
s->setId("Ca2");
s->setCompartment("cell");
s->setInitialAmount(0.7);
s->setUnits("mole");
s->setBoundaryCondition(true);
s->setHasOnlySubstanceUnits(false);
s->setConstant(true);
char* sbml = s->toSBML();
fail_unless( equals(expected, sbml) );
safe_free(sbml);
}
void CompartmentSpaceVectorImpl::add_molecules(
const Species& sp, const Integer& num)
{
if (num < 0)
{
std::ostringstream message;
message << "The number of molecules must be positive. [" << sp.serial() << "]";
throw std::invalid_argument(message.str());
}
species_map_type::const_iterator i(index_map_.find(sp));
if (i == index_map_.end())
{
// throw NotFound("Species not found");
reserve_species(sp);
i = index_map_.find(sp);
}
num_molecules_[(*i).second] += num;
}
END_TEST
START_TEST ( test_Species_L1 )
{
Species* s = new Species(1, 2);
fail_unless (!(s->hasRequiredAttributes()));
s->setId("s");
fail_unless (!(s->hasRequiredAttributes()));
s->setCompartment("c");
fail_unless (!(s->hasRequiredAttributes()));
s->setInitialAmount(2);
fail_unless (s->hasRequiredAttributes());
delete s;
}
/*
* Logs a message about species with boundary condition false
* being set by reaction and rules
*/
void
SpeciesReactionOrRule::logConflict (const Species& s, const Reaction& r)
{
msg =
//"A <species>'s quantity cannot be determined simultaneously by both "
//"reactions and rules. More formally, if the identifier of a <species> "
//"definition having 'boundaryCondition'='false' and 'constant'='false' is "
//"referenced by a <speciesReference> anywhere in a model, then this "
//"identifier cannot also appear as the value of a 'variable' in an "
//"<assignmentRule> or a <rateRule>. (References: L2V1 Section 4.6.5; L2V2 "
//"Section 4.8.6; L2V3 Section 4.8.6.)
"The species '";
msg += s.getId();
msg += "' occurs in both a rule and reaction '";
msg += r.getId();
msg += "'.";
logFailure(s);
}
/*
* Logs a message about species with boundary condition false
* being set by reaction and rules
*/
void
UniqueSpeciesTypesInCompartment::logConflict (const Species& s, const Compartment& c)
{
msg =
//"There cannot be more than one species of a given <speciesType> in the "
//"same compartment of a model. More formally, for any given compartment, "
//"there cannot be more than one <species> definition in which both of the "
//"following hold simultaneously: (i) the <species>' 'compartment' value "
//"is set to that compartment's identifier and (ii) the <species>' "
//"'speciesType' is set the same value as the 'speciesType' of another "
//"<species> that also sets its 'compartment' to that compartment "
//"identifier. (References: L2V2 Section 4.8.2; L2V3 Section 4.8.2)"
"The compartment '";
msg += c.getId();
msg += "' contains more than one species with species type '";
msg += s.getSpeciesType();
msg += "'.";
logFailure(s);
}
END_TEST
START_TEST ( test_Species )
{
Species* s = new Species(2, 4);
fail_unless (!(s->hasRequiredAttributes()));
s->setId("s");
fail_unless (!(s->hasRequiredAttributes()));
s->setCompartment("c");
fail_unless (s->hasRequiredAttributes());
delete s;
}
std::vector<ReactionRule> NetworkModel::query_reaction_rules(
const Species& sp1, const Species& sp2) const
{
std::vector<ReactionRule> retval;
const std::pair<Species::serial_type, Species::serial_type>
key(sp1.serial() < sp2.serial()?
std::make_pair(sp1.serial(), sp2.serial()):
std::make_pair(sp2.serial(), sp1.serial()));
second_order_reaction_rules_map_type::const_iterator
i(second_order_reaction_rules_map_.find(key));
if (i != second_order_reaction_rules_map_.end())
{
retval.reserve((*i).second.size());
for (second_order_reaction_rules_map_type::mapped_type::const_iterator
j((*i).second.begin()); j != (*i).second.end(); ++j)
{
retval.push_back(reaction_rules_[*j]);
}
}
return retval;
}
void ProcessMolfileDirectory(string Directory,string OutputDirectory) {
vector<string> DirectoryList = GetDirectoryFileList(Directory);
Data* NewData = new Data(0);
for (int i=0; i < int(DirectoryList.size()); i++) {
cout << DirectoryList[i] << endl;
Species* NewSpecies = new Species("", NewData, false);
if (DirectoryList[i].length() > 0) {
NewSpecies->ReadFromMol(Directory+DirectoryList[i]);
NewSpecies->LabelAtoms();
string FileRoot = RemovePath(RemoveExtension(DirectoryList[i]));
ofstream Output;
if (OpenOutput(Output,OutputDirectory+FileRoot+".txt")) {
Output << "Atom index;Group;GroupIndex" << endl;
for (int j=0; j < NewSpecies->FNumAtoms(); j++) {
Output << j << ";" << NewSpecies->GetAtom(j)->FGroupString() << ";" << NewSpecies->GetAtom(j)->FGroupIndex() << endl;
}
Output.close();
}
}
delete NewSpecies;
}
}
/**
*
* Creates an SBML model represented in "7.2 Example involving units"
* in the SBML Level 2 Version 4 Specification.
*
*/
SBMLDocument* createExampleInvolvingUnits()
{
const unsigned int level = Level;
const unsigned int version = Version;
//---------------------------------------------------------------------------
//
// Creates an SBMLDocument object
//
//---------------------------------------------------------------------------
SBMLDocument* sbmlDoc = new SBMLDocument(level,version);
// Adds the namespace for XHTML to the SBMLDocument object. We need this
// because we will add notes to the model. (By default, the SBML document
// created by SBMLDocument only declares the SBML XML namespace.)
sbmlDoc->getNamespaces()->add("http://www.w3.org/1999/xhtml", "xhtml");
//---------------------------------------------------------------------------
//
// Creates a Model object inside the SBMLDocument object.
//
//---------------------------------------------------------------------------
Model* model = sbmlDoc->createModel();
model->setId("unitsExample");
//---------------------------------------------------------------------------
//
// Creates UnitDefinition objects inside the Model object.
//
//---------------------------------------------------------------------------
// Temporary pointers (reused more than once below).
UnitDefinition* unitdef;
Unit *unit;
//---------------------------------------------------------------------------
// (UnitDefinition1) Creates an UnitDefinition object ("substance").
//
// This has the effect of redefining the default unit of subtance for the
// whole model.
//---------------------------------------------------------------------------
unitdef = model->createUnitDefinition();
unitdef->setId("substance");
// Creates an Unit inside the UnitDefinition object
unit = unitdef->createUnit();
unit->setKind(UNIT_KIND_MOLE);
unit->setScale(-3);
//--------------------------------------------------------------------------------
// (UnitDefinition2) Creates an UnitDefinition object ("mmls")
//--------------------------------------------------------------------------------
// Note that we can reuse the pointers 'unitdef' and 'unit' because the
// actual UnitDefinition object (along with the Unit objects within it)
// is already attached to the Model object.
unitdef = model->createUnitDefinition();
unitdef->setId("mmls");
// Creates an Unit inside the UnitDefinition object ("mmls")
unit = unitdef->createUnit();
unit->setKind(UNIT_KIND_MOLE);
unit->setScale(-3);
// Creates an Unit inside the UnitDefinition object ("mmls")
unit = unitdef->createUnit();
unit->setKind(UNIT_KIND_LITRE);
unit->setExponent(-1);
// Creates an Unit inside the UnitDefinition object ("mmls")
unit = unitdef->createUnit();
unit->setKind(UNIT_KIND_SECOND);
unit->setExponent(-1);
//--------------------------------------------------------------------------------
// (UnitDefinition3) Creates an UnitDefinition object ("mml")
//--------------------------------------------------------------------------------
unitdef = model->createUnitDefinition();
unitdef->setId("mml");
// Creates an Unit inside the UnitDefinition object ("mml")
unit = unitdef->createUnit();
unit->setKind(UNIT_KIND_MOLE);
unit->setScale(-3);
// Creates an Unit inside the UnitDefinition object ("mml")
unit = unitdef->createUnit();
unit->setKind(UNIT_KIND_LITRE);
unit->setExponent(-1);
//---------------------------------------------------------------------------
//
// Creates a Compartment object inside the Model object.
//
//---------------------------------------------------------------------------
Compartment* comp;
const string compName = "cell";
// Creates a Compartment object ("cell")
comp = model->createCompartment();
comp->setId(compName);
// Sets the "size" attribute of the Compartment object.
//
// The units of this Compartment object is the default SBML
// units of volume (litre), and thus we don't have to explicitly invoke
// setUnits("litre") function to set the default units.
//
comp->setSize(1);
//---------------------------------------------------------------------------
//
// Creates Species objects inside the Model object.
//
//---------------------------------------------------------------------------
// Temporary pointer (reused more than once below).
Species *sp;
//---------------------------------------------------------------------------
// (Species1) Creates a Species object ("x0")
//---------------------------------------------------------------------------
sp = model->createSpecies();
sp->setId("x0");
// Sets the "compartment" attribute of the Species object to identify the
// compartnet in which the Species object located.
sp->setCompartment(compName);
// Sets the "initialConcentration" attribute of the Species object.
//
// The units of this Species object is determined by two attributes of this
// Species object ("substanceUnits" and "hasOnlySubstanceUnits") and the
// "spatialDimensions" attribute of the Compartment object ("cytosol") in which
// this species object is located.
// Since the default values are used for "substanceUnits" (substance (mole))
// and "hasOnlySubstanceUnits" (false) and the value of "spatialDimension" (3)
// is greater than 0, the units of this Species object is moles/liters .
//
sp->setInitialConcentration(1);
//---------------------------------------------------------------------------
// (Species2) Creates a Species object ("x1")
//---------------------------------------------------------------------------
sp = model->createSpecies();
sp->setId("x1");
sp->setCompartment(compName);
sp->setInitialConcentration(1);
//---------------------------------------------------------------------------
// (Species3) Creates a Species object ("s1")
//---------------------------------------------------------------------------
sp = model->createSpecies();
sp->setCompartment(compName);
sp->setId("s1");
sp->setInitialConcentration(1);
//---------------------------------------------------------------------------
// (Species4) Creates a Species object ("s2")
//---------------------------------------------------------------------------
sp = model->createSpecies();
sp->setCompartment(compName);
sp->setId("s2");
sp->setInitialConcentration(1);
//---------------------------------------------------------------------------
//
// Creates global Parameter objects inside the Model object.
//
//---------------------------------------------------------------------------
Parameter* para;
// Creates a Parameter ("vm")
para = model->createParameter();
para->setId("vm");
para->setValue(2);
para->setUnits("mmls");
// Creates a Parameter ("km")
para = model->createParameter();
para->setId("km");
para->setValue(2);
para->setUnits("mml");
//---------------------------------------------------------------------------
//
// Creates Reaction objects inside the Model object.
//
//---------------------------------------------------------------------------
// Temporary pointers.
Reaction* reaction;
SpeciesReference* spr;
KineticLaw* kl;
//---------------------------------------------------------------------------
// (Reaction1) Creates a Reaction object ("v1").
//---------------------------------------------------------------------------
reaction = model->createReaction();
reaction->setId("v1");
//---------------------------------------------------------------------------
// Creates Reactant objects inside the Reaction object ("v1").
//---------------------------------------------------------------------------
// (Reactant1) Creates a Reactant object that references Species "x0"
// in the model.
spr = reaction->createReactant();
spr->setSpecies("x0");
//---------------------------------------------------------------------------
// Creates a Product object inside the Reaction object ("v1").
//---------------------------------------------------------------------------
// Creates a Product object that references Species "s1" in the model.
spr = reaction->createProduct();
spr->setSpecies("s1");
//---------------------------------------------------------------------------
// Creates a KineticLaw object inside the Reaction object ("v1").
//---------------------------------------------------------------------------
kl = reaction->createKineticLaw();
// Creates a <notes> element in the KineticLaw object.
// Here we illustrate how to do it using a literal string. This requires
// known the required syntax of XHTML and the requirements for SBML <notes>
// elements. Later below, we show how to create notes using objects instead
// of strings.
string notesString = "<xhtml:p> ((vm * s1)/(km + s1)) * cell </xhtml:p>";
kl->setNotes(notesString);
//---------------------------------------------------------------------------
// Creates an ASTNode object which represents the following KineticLaw object.
//
// <math xmlns=\"http://www.w3.org/1998/Math/MathML\">
// <apply>
// <times/>
// <apply>
// <divide/>
// <apply>
// <times/>
// <ci> vm </ci>
// <ci> s1 </ci>
// </apply>
// <apply>
// <plus/>
// <ci> km </ci>
// <ci> s1 </ci>
// </apply>
// </apply>
// <ci> cell </ci>
// </apply>
// </math>
//---------------------------------------------------------------------------
//
// In the following code, ASTNode objects, which construct an ASTNode tree
// of the above math, are created and added in the order of preorder traversal
// of the tree (i.e. the order corresponds to the nested structure of the above
// MathML elements), and thus the following code maybe a bit more efficient but
// maybe a bit difficult to read.
//
ASTNode* astMath = new ASTNode(AST_TIMES);
astMath->addChild(new ASTNode(AST_DIVIDE));
ASTNode* astDivide = astMath->getLeftChild();
astDivide->addChild(new ASTNode(AST_TIMES));
ASTNode* astTimes = astDivide->getLeftChild();
astTimes->addChild(new ASTNode(AST_NAME));
astTimes->getLeftChild()->setName("vm");
astTimes->addChild(new ASTNode(AST_NAME));
astTimes->getRightChild()->setName("s1");
astDivide->addChild(new ASTNode(AST_PLUS));
ASTNode* astPlus = astDivide->getRightChild();
astPlus->addChild(new ASTNode(AST_NAME));
astPlus->getLeftChild()->setName("km");
astPlus->addChild(new ASTNode(AST_NAME));
astPlus->getRightChild()->setName("s1");
astMath->addChild(new ASTNode(AST_NAME));
astMath->getRightChild()->setName("cell");
//---------------------------------------------
//
// set the Math element
//
//------------------------------------------------
kl->setMath(astMath);
delete astMath;
//---------------------------------------------------------------------------
// (Reaction2) Creates a Reaction object ("v2").
//---------------------------------------------------------------------------
reaction = model->createReaction();
reaction->setId("v2");
//---------------------------------------------------------------------------
// Creates Reactant objects inside the Reaction object ("v2").
//---------------------------------------------------------------------------
// (Reactant2) Creates a Reactant object that references Species "s1"
// in the model.
spr = reaction->createReactant();
spr->setSpecies("s1");
//---------------------------------------------------------------------------
// Creates a Product object inside the Reaction object ("v2").
//---------------------------------------------------------------------------
// Creates a Product object that references Species "s2" in the model.
spr = reaction->createProduct();
spr->setSpecies("s2");
//---------------------------------------------------------------------------
// Creates a KineticLaw object inside the Reaction object ("v2").
//---------------------------------------------------------------------------
kl = reaction->createKineticLaw();
// Sets a notes (by XMLNode) to the KineticLaw object.
//
// The following code is an alternative to using setNotes(const string&).
// The equivalent code would be like this:
//
// notesString = "<xhtml:p>((vm * s2)/(km + s2))*cell</xhtml:p>";
// kl->setNotes(notesString);
// Creates an XMLNode of start element (<xhtml:p>) without attributes.
XMLNode notesXMLNode(XMLTriple("p", "", "xhtml"), XMLAttributes());
// Adds a text element to the start element.
notesXMLNode.addChild(XMLNode(" ((vm * s2)/(km + s2)) * cell "));
// Adds it to the kineticLaw object.
kl->setNotes(¬esXMLNode);
//---------------------------------------------------------------------------
// Sets a math (ASTNode object) to the KineticLaw object.
//---------------------------------------------------------------------------
// To create mathematical expressions, one would typically construct
// an ASTNode tree as the above example code which creates a math of another
// KineticLaw object. Here, to save some space and illustrate another approach
// of doing it, we will write out the formula in MathML form and then use a
// libSBML convenience function to create the ASTNode tree for us.
// (This is a bit dangerous; it's very easy to make mistakes when writing MathML
// by hand, so in a real program, we would not really want to do it this way.)
string mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">"
" <apply>"
" <times/>"
" <apply>"
" <divide/>"
" <apply>"
" <times/>"
" <ci> vm </ci>"
" <ci> s2 </ci>"
" </apply>"
" <apply>"
" <plus/>"
" <ci> km </ci>"
" <ci> s2 </ci>"
" </apply>"
" </apply>"
" <ci> cell </ci>"
" </apply>"
"</math>";
astMath = readMathMLFromString(mathXMLString.c_str());
kl->setMath(astMath);
delete astMath;
//---------------------------------------------------------------------------
// (Reaction3) Creates a Reaction object ("v3").
//---------------------------------------------------------------------------
reaction = model->createReaction();
reaction->setId("v3");
//---------------------------------------------------------------------------
// Creates Reactant objects inside the Reaction object ("v3").
//---------------------------------------------------------------------------
// (Reactant2) Creates a Reactant object that references Species "s2"
// in the model.
spr = reaction->createReactant();
spr->setSpecies("s2");
//---------------------------------------------------------------------------
// Creates a Product object inside the Reaction object ("v3").
//---------------------------------------------------------------------------
// Creates a Product object that references Species "x1" in the model.
spr = reaction->createProduct();
spr->setSpecies("x1");
//---------------------------------------------------------------------------
// Creates a KineticLaw object inside the Reaction object ("v3").
//---------------------------------------------------------------------------
kl = reaction->createKineticLaw();
// Sets a notes (by string) to the KineticLaw object.
notesString = "<xhtml:p> ((vm * x1)/(km + x1)) * cell </xhtml:p>";
kl->setNotes(notesString);
//---------------------------------------------------------------------------
// Sets a math (ASTNode object) to the KineticLaw object.
//---------------------------------------------------------------------------
mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">"
" <apply>"
" <times/>"
" <apply>"
" <divide/>"
" <apply>"
" <times/>"
" <ci> vm </ci>"
" <ci> x1 </ci>"
" </apply>"
" <apply>"
" <plus/>"
" <ci> km </ci>"
" <ci> x1 </ci>"
" </apply>"
" </apply>"
" <ci> cell </ci>"
" </apply>"
"</math>";
astMath = readMathMLFromString(mathXMLString.c_str());
kl->setMath(astMath);
delete astMath;
// Returns the created SBMLDocument object.
// The returned object must be explicitly deleted by the caller,
// otherwise memory leak will happen.
return sbmlDoc;
}
/**
*
* Creates an SBML model represented in "7.1 A Simple example application of SBML"
* in the SBML Level 2 Version 4 Specification.
*
*/
SBMLDocument* createExampleEnzymaticReaction()
{
const unsigned int level = Level;
const unsigned int version = Version;
//---------------------------------------------------------------------------
//
// Creates an SBMLDocument object
//
//---------------------------------------------------------------------------
SBMLDocument* sbmlDoc = new SBMLDocument(level,version);
//---------------------------------------------------------------------------
//
// Creates a Model object inside the SBMLDocument object.
//
//---------------------------------------------------------------------------
Model* model = sbmlDoc->createModel();
model->setId("EnzymaticReaction");
//---------------------------------------------------------------------------
//
// Creates UnitDefinition objects inside the Model object.
//
//---------------------------------------------------------------------------
// Temporary pointers (reused more than once below).
UnitDefinition* unitdef;
Unit* unit;
//---------------------------------------------------------------------------
// (UnitDefinition1) Creates an UnitDefinition object ("per_second")
//---------------------------------------------------------------------------
unitdef = model->createUnitDefinition();
unitdef->setId("per_second");
// Creates an Unit inside the UnitDefinition object
unit = unitdef->createUnit();
unit->setKind(UNIT_KIND_SECOND);
unit->setExponent(-1);
//--------------------------------------------------------------------------------
// (UnitDefinition2) Creates an UnitDefinition object ("litre_per_mole_per_second")
//--------------------------------------------------------------------------------
// Note that we can reuse the pointers 'unitdef' and 'unit' because the
// actual UnitDefinition object (along with the Unit objects within it)
// is already attached to the Model object.
unitdef = model->createUnitDefinition();
unitdef->setId("litre_per_mole_per_second");
// Creates an Unit inside the UnitDefinition object ("litre_per_mole_per_second")
unit = unitdef->createUnit();
unit->setKind(UNIT_KIND_MOLE);
unit->setExponent(-1);
// Creates an Unit inside the UnitDefinition object ("litre_per_mole_per_second")
unit = unitdef->createUnit();
unit->setKind(UNIT_KIND_LITRE);
unit->setExponent(1);
// Creates an Unit inside the UnitDefinition object ("litre_per_mole_per_second")
unit = unitdef->createUnit();
unit->setKind(UNIT_KIND_SECOND);
unit->setExponent(-1);
//---------------------------------------------------------------------------
//
// Creates a Compartment object inside the Model object.
//
//---------------------------------------------------------------------------
Compartment* comp;
const string compName = "cytosol";
// Creates a Compartment object ("cytosol")
comp = model->createCompartment();
comp->setId(compName);
// Sets the "size" attribute of the Compartment object.
//
// We are not setting the units on the compartment size explicitly, so
// the units of this Compartment object will be the default SBML units of
// volume, which are liters.
//
comp->setSize(1e-14);
//---------------------------------------------------------------------------
//
// Creates Species objects inside the Model object.
//
//---------------------------------------------------------------------------
// Temporary pointer (reused more than once below).
Species *sp;
//---------------------------------------------------------------------------
// (Species1) Creates a Species object ("ES")
//---------------------------------------------------------------------------
// Create the Species objects inside the Model object.
sp = model->createSpecies();
sp->setId("ES");
sp->setName("ES");
// Sets the "compartment" attribute of the Species object to identify the
// compartment in which the Species object is located.
sp->setCompartment(compName);
// Sets the "initialAmount" attribute of the Species object.
//
// In SBML, the units of a Species object's initial quantity are
// determined by two attributes, "substanceUnits" and
// "hasOnlySubstanceUnits", and the "spatialDimensions" attribute
// of the Compartment object ("cytosol") in which the species
// object is located. Here, we are using the default values for
// "substanceUnits" (which is "mole") and "hasOnlySubstanceUnits"
// (which is "false"). The compartment in which the species is
// located uses volume units of liters, so the units of these
// species (when the species appear in numerical formulas in the
// model) will be moles/liters.
//
sp->setInitialAmount(0);
//---------------------------------------------------------------------------
// (Species2) Creates a Species object ("P")
//---------------------------------------------------------------------------
sp = model->createSpecies();
sp->setCompartment(compName);
sp->setId("P");
sp->setName("P");
sp->setInitialAmount(0);
//---------------------------------------------------------------------------
// (Species3) Creates a Species object ("S")
//---------------------------------------------------------------------------
sp = model->createSpecies();
sp->setCompartment(compName);
sp->setId("S");
sp->setName("S");
sp->setInitialAmount(1e-20);
//---------------------------------------------------------------------------
// (Species4) Creates a Species object ("E")
//---------------------------------------------------------------------------
sp = model->createSpecies();
sp->setCompartment(compName);
sp->setId("E");
sp->setName("E");
sp->setInitialAmount(5e-21);
//---------------------------------------------------------------------------
//
// Creates Reaction objects inside the Model object.
//
//---------------------------------------------------------------------------
// Temporary pointers.
Reaction* reaction;
SpeciesReference* spr;
KineticLaw* kl;
//---------------------------------------------------------------------------
// (Reaction1) Creates a Reaction object ("veq").
//---------------------------------------------------------------------------
reaction = model->createReaction();
reaction->setId("veq");
// (Reactant1) Creates a Reactant object that references Species "E"
// in the model. The object will be created within the reaction in the
// SBML <listOfReactants>.
spr = reaction->createReactant();
spr->setSpecies("E");
// (Reactant2) Creates a Reactant object that references Species "S"
// in the model.
spr = reaction->createReactant();
spr->setSpecies("S");
//---------------------------------------------------------------------------
// (Product1) Creates a Product object that references Species "ES" in
// the model.
//---------------------------------------------------------------------------
spr = reaction->createProduct();
spr->setSpecies("ES");
//---------------------------------------------------------------------------
// Creates a KineticLaw object inside the Reaction object ("veq").
//---------------------------------------------------------------------------
kl = reaction->createKineticLaw();
//---------------------------------------------------------------------------
// Creates an ASTNode object which represents the following math of the
// KineticLaw.
//
// <math xmlns="http://www.w3.org/1998/Math/MathML">
// <apply>
// <times/>
// <ci> cytosol </ci>
// <apply>
// <minus/>
// <apply>
// <times/>
// <ci> kon </ci>
// <ci> E </ci>
// <ci> S </ci>
// </apply>
// <apply>
// <times/>
// <ci> koff </ci>
// <ci> ES </ci>
// </apply>
// </apply>
// </apply>
// </math>
//
//---------------------------------------------------------------------------
//------------------------------------------
//
// create nodes representing the variables
//
//------------------------------------------
ASTNode* astCytosol = new ASTNode(AST_NAME);
astCytosol->setName("cytosol");
ASTNode* astKon = new ASTNode(AST_NAME);
astKon->setName("kon");
ASTNode* astKoff = new ASTNode(AST_NAME);
astKoff->setName("koff");
ASTNode* astE = new ASTNode(AST_NAME);
astE->setName("E");
ASTNode* astS = new ASTNode(AST_NAME);
astS->setName("S");
ASTNode* astES = new ASTNode(AST_NAME);
astES->setName("ES");
//--------------------------------------------
//
// create node representing
// <apply>
// <times/>
// <ci> koff </ci>
// <ci> ES </ci>
// </apply>
//
//--------------------------------------------
ASTNode *astTimes1 = new ASTNode(AST_TIMES);
astTimes1->addChild(astKoff);
astTimes1->addChild(astES);
//--------------------------------------------
//
// create node representing
// <apply>
// <times/>
// <ci> kon </ci>
// <ci> E </ci>
// <ci> S </ci>
// </apply>
//
//
// (NOTES)
//
// Since there is a restriction with an ASTNode of "<times/>" operation
// such that the ASTNode is a binary class and thus only two operands can
// be directly added, the following code in this comment block is invalid
// because the code directly adds three <ci> ASTNodes to <times/> ASTNode.
//
// ASTNode *astTimes = new ASTNode(AST_TIMES);
// astTimes->addChild(astKon);
// astTimes->addChild(astE);
// astTimes->addChild(astS);
//
// The following valid code after this comment block creates the ASTNode
// as a binary tree.
//
// Please see "Converting between ASTs and text strings" described
// at http://sbml.org/Software/libSBML/docs/cpp-api/class_a_s_t_node.html
// for the detailed information.
//
//--------------------------------------------
ASTNode *astTimes2 = new ASTNode(AST_TIMES);
astTimes2->addChild(astE);
astTimes2->addChild(astS);
ASTNode *astTimes = new ASTNode(AST_TIMES);
astTimes->addChild(astKon);
astTimes->addChild(astTimes2);
//--------------------------------------------
//
// create node representing
// <apply>
// <minus/>
// <apply>
// <times/>
// <ci> kon </ci>
// <ci> E </ci>
// <ci> S </ci>
// </apply>
// <apply>
// <times/>
// <ci> koff </ci>
// <ci> ES </ci>
// </apply>
// </apply>
//
//--------------------------------------------
ASTNode *astMinus = new ASTNode(AST_MINUS);
astMinus->addChild(astTimes);
astMinus->addChild(astTimes1);
//--------------------------------------------
//
// create node representing
// <apply>
// <times/>
// <ci> cytosol </ci>
// <apply>
// <minus/>
// <apply>
// <times/>
// <ci> kon </ci>
// <ci> E </ci>
// <ci> S </ci>
// </apply>
// <apply>
// <times/>
// <ci> koff </ci>
// <ci> ES </ci>
// </apply>
// </apply>
// </apply>
//
//--------------------------------------------
ASTNode* astMath = new ASTNode(AST_TIMES);
astMath->addChild(astCytosol);
astMath->addChild(astMinus);
//---------------------------------------------
//
// set the Math element
//
//------------------------------------------------
kl->setMath(astMath);
// KineticLaw::setMath(const ASTNode*) sets the math of the KineticLaw object
// to a copy of the given ASTNode, and thus basically the caller should delete
// the original ASTNode object if the caller has the ownership of the object to
// avoid memory leak.
delete astMath;
//---------------------------------------------------------------------------
// Creates local Parameter objects inside the KineticLaw object.
//---------------------------------------------------------------------------
// Creates a Parameter ("kon")
Parameter* para = kl->createParameter();
para->setId("kon");
para->setValue(1000000);
para->setUnits("litre_per_mole_per_second");
// Creates a Parameter ("koff")
para = kl->createParameter();
para->setId("koff");
para->setValue(0.2);
para->setUnits("per_second");
//---------------------------------------------------------------------------
// (Reaction2) Creates a Reaction object ("vcat") .
//---------------------------------------------------------------------------
reaction = model->createReaction();
reaction->setId("vcat");
reaction->setReversible(false);
//---------------------------------------------------------------------------
// Creates Reactant objects inside the Reaction object ("vcat").
//---------------------------------------------------------------------------
// (Reactant1) Creates a Reactant object that references Species "ES" in the
// model.
spr = reaction->createReactant();
spr->setSpecies("ES");
//---------------------------------------------------------------------------
// Creates a Product object inside the Reaction object ("vcat").
//---------------------------------------------------------------------------
// (Product1) Creates a Product object that references Species "E" in the model.
spr = reaction->createProduct();
spr->setSpecies("E");
// (Product2) Creates a Product object that references Species "P" in the model.
spr = reaction->createProduct();
spr->setSpecies("P");
//---------------------------------------------------------------------------
// Creates a KineticLaw object inside the Reaction object ("vcat").
//---------------------------------------------------------------------------
kl = reaction->createKineticLaw();
//---------------------------------------------------------------------------
// Sets a math (ASTNode object) to the KineticLaw object.
//---------------------------------------------------------------------------
// To create mathematical expressions, one would typically construct
// an ASTNode tree as the above example code which creates a math of another
// KineticLaw object. Here, to save some space and illustrate another approach
// of doing it, we will write out the formula in MathML form and then use a
// libSBML convenience function to create the ASTNode tree for us.
// (This is a bit dangerous; it's very easy to make mistakes when writing MathML
// by hand, so in a real program, we would not really want to do it this way.)
string mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">"
" <apply>"
" <times/>"
" <ci> cytosol </ci>"
" <ci> kcat </ci>"
" <ci> ES </ci>"
" </apply>"
"</math>";
astMath = readMathMLFromString(mathXMLString.c_str());
kl->setMath(astMath);
delete astMath;
//---------------------------------------------------------------------------
// Creates local Parameter objects inside the KineticLaw object.
//---------------------------------------------------------------------------
// Creates a Parameter ("kcat")
para = kl->createParameter();
para->setId("kcat");
para->setValue(0.1);
para->setUnits("per_second");
// Returns the created SBMLDocument object.
// The returned object must be explicitly deleted by the caller,
// otherwise a memory leak will happen.
return sbmlDoc;
}
/**
*
* Creates an SBML model represented in "7.8 Example involving function definitions"
* in the SBML Level 2 Version 4 Specification.
*
*/
SBMLDocument* createExampleInvolvingFunctionDefinitions()
{
const unsigned int level = Level;
const unsigned int version = Version;
//---------------------------------------------------------------------------
//
// Creates an SBMLDocument object
//
//---------------------------------------------------------------------------
SBMLDocument* sbmlDoc = new SBMLDocument(level,version);
//---------------------------------------------------------------------------
//
// Creates a Model object inside the SBMLDocument object.
//
//---------------------------------------------------------------------------
Model* model = sbmlDoc->createModel();
model->setId("functionExample");
//---------------------------------------------------------------------------
//
// Creates a FunctionDefinition object inside the Model object.
//
//---------------------------------------------------------------------------
FunctionDefinition* fdef = model->createFunctionDefinition();
fdef->setId("f");
// Sets a math (ASTNode object) to the FunctionDefinition object.
string mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">"
" <lambda>"
" <bvar>"
" <ci> x </ci>"
" </bvar>"
" <apply>"
" <times/>"
" <ci> x </ci>"
" <cn> 2 </cn>"
" </apply>"
" </lambda>"
"</math>";
ASTNode* astMath = readMathMLFromString(mathXMLString.c_str());
fdef->setMath(astMath);
delete astMath;
//---------------------------------------------------------------------------
//
// Creates a Compartment object inside the Model object.
//
//---------------------------------------------------------------------------
Compartment* comp;
const string compName = "compartmentOne";
// Creates a Compartment object ("compartmentOne")
comp = model->createCompartment();
comp->setId(compName);
// Sets the "size" attribute of the Compartment object.
//
// The units of this Compartment object is the default SBML
// units of volume (litre), and thus we don't have to explicitly invoke
// setUnits("litre") function to set the default units.
//
comp->setSize(1);
//---------------------------------------------------------------------------
//
// Creates Species objects inside the Model object.
//
//---------------------------------------------------------------------------
Species* sp;
//---------------------------------------------------------------------------
// (Species1) Creates a Species object ("S1")
//---------------------------------------------------------------------------
sp = model->createSpecies();
sp->setId("S1");
// Sets the "compartment" attribute of the Species object to identify the
// compartnet in which the Species object located.
sp->setCompartment(compName);
// Sets the "initialConcentration" attribute of the Species object.
//
// The units of this Species object is determined by two attributes of this
// Species object ("substanceUnits" and "hasOnlySubstanceUnits") and the
// "spatialDimension" attribute of the Compartment object ("cytosol") in which
// this species object located.
// Since the default values are used for "substanceUnits" (substance (mole))
// and "hasOnlySubstanceUnits" (false) and the value of "spatialDimension" (3)
// is greater than 0, the units of this Species object is mole/litre .
//
sp->setInitialConcentration(1);
//---------------------------------------------------------------------------
// (Species2) Creates a Species object ("S2")
//---------------------------------------------------------------------------
sp = model->createSpecies();
sp->setId("S2");
sp->setCompartment(compName);
sp->setInitialConcentration(0);
//---------------------------------------------------------------------------
//
// Creates a global Parameter object inside the Model object.
//
//---------------------------------------------------------------------------
Parameter* para;
// Creates a Parameter ("t")
para = model->createParameter();
para->setId("t");
para->setValue(1);
para->setUnits("second");
//---------------------------------------------------------------------------
//
// Creates Reaction objects inside the Model object.
//
//---------------------------------------------------------------------------
// Temporary pointers.
Reaction* reaction;
SpeciesReference* spr;
KineticLaw* kl;
//---------------------------------------------------------------------------
// (Reaction1) Creates a Reaction object ("reaction_1").
//---------------------------------------------------------------------------
reaction = model->createReaction();
reaction->setId("reaction_1");
reaction->setReversible(false);
//---------------------------------------------------------------------------
// Creates Reactant objects inside the Reaction object ("reaction_1").
//---------------------------------------------------------------------------
// (Reactant1) Creates a Reactant object that references Species "S1"
// in the model.
spr = reaction->createReactant();
spr->setSpecies("S1");
//---------------------------------------------------------------------------
// Creates a Product object inside the Reaction object ("reaction_1").
//---------------------------------------------------------------------------
// Creates a Product object that references Species "S2" in the model.
spr = reaction->createProduct();
spr->setSpecies("S2");
//---------------------------------------------------------------------------
// Creates a KineticLaw object inside the Reaction object ("reaction_1").
//---------------------------------------------------------------------------
kl = reaction->createKineticLaw();
//---------------------------------------------------------------------------
// Sets a math (ASTNode object) to the KineticLaw object.
//---------------------------------------------------------------------------
mathXMLString = "<math xmlns=\"http://www.w3.org/1998/Math/MathML\">"
" <apply>"
" <divide/>"
" <apply>"
" <times/>"
" <apply>"
" <ci> f </ci>"
" <ci> S1 </ci>"
" </apply>"
" <ci> compartmentOne </ci>"
" </apply>"
" <ci> t </ci>"
" </apply>"
"</math>";
astMath = readMathMLFromString(mathXMLString.c_str());
kl->setMath(astMath);
delete astMath;
// Returns the created SBMLDocument object.
// The returned object must be explicitly deleted by the caller,
// otherwise memory leak will happen.
return sbmlDoc;
}
LIBSBML_CPP_NAMESPACE_USE
int
main (int argc, char *argv[])
{
SBMLDocument* d;
unsigned int errors, n;
Species *s;
if (argc != 3)
{
cout << endl
<< " usage: addCVTerms <input-filename> <output-filename>" << endl
<< " Adds controlled vocabulary term to a species" << endl
<< endl;
return 2;
}
d = readSBML(argv[1]);
errors = d->getNumErrors();
if (errors > 0)
{
cout << "Read Error(s):" << endl;
d->printErrors(cout);
cout << "Correct the above and re-run." << endl;
}
else
{
n = d->getModel()->getNumSpecies();
if (n <= 0)
{
cout << "Model has no species.\n Cannot add CV terms\n";
}
else
{
s = d->getModel()->getSpecies(0);
CVTerm *cv = new CVTerm();
cv->setQualifierType(BIOLOGICAL_QUALIFIER);
cv->setBiologicalQualifierType(BQB_IS_VERSION_OF);
cv->addResource("http://www.geneontology.org/#GO:0005892");
CVTerm *cv2 = new CVTerm();
cv2->setQualifierType(BIOLOGICAL_QUALIFIER);
cv2->setBiologicalQualifierType(BQB_IS);
cv2->addResource("http://www.geneontology.org/#GO:0005895");
CVTerm *cv1 = new CVTerm();
cv1->setQualifierType(BIOLOGICAL_QUALIFIER);
cv1->setBiologicalQualifierType(BQB_IS_VERSION_OF);
cv1->addResource("http://www.ebi.ac.uk/interpro/#IPR002394");
s->addCVTerm(cv);
s->addCVTerm(cv2);
s->addCVTerm(cv1);
writeSBML(d, argv[2]);
}
}
delete d;
return errors;
}
// This little tool function helps ordering the genomes by fitness
bool species_greater(Species ls, Species rs)
{
return ((ls.GetBestFitness()) > (rs.GetBestFitness()));
}
bool
Interaction::isInteraction(const Species &speci) const
{
return !(intName.compare(speci.getIntName()));
}
