#include <SEDMLUtils.h>

Public Member Functions
int	processArchive (const std::string &archiveFile, std::string &fileName, std::string &fileContent)

	SEDMLUtils ()

virtual	~SEDMLUtils ()

Static Public Member Functions
static std::string	findIdByNameAndType (const std::map< CCopasiObject , SBase > &map, int typeCode, const std::string &name)

static std::string	getNextId (const std::string &base, int count)

static const CCopasiObject *	getObjectForSbmlId (const CModel *pModel, const std::string &id, const std::string &SBMLType, bool initial=false)

static std::string	getXPathAndName (std::string &sbmlId, const std::string &type, const CModel *pModel, const CCopasiDataModel &dataModel)

static std::string	getXPathForObject (const CCopasiObject &object)

static std::string &	removeCharactersFromString (std::string &str, const std::string &characters)

static const CCopasiObject *	resolveDatagenerator (const CModel model, const SedDataGenerator dataReference)

static const CCopasiObject *	resolveXPath (const CModel *model, const std::string &xpath, bool initial=false)

static void	splitStrings (const std::string &xpath, char delim, std::vector< std::string > &stringsContainer)

static std::string	translateTargetXpathInSBMLId (const std::string &xpath, std::string &SBMLType)

Detailed Description

Definition at line 27 of file SEDMLUtils.h.

Constructor & Destructor Documentation

SEDMLUtils::SEDMLUtils ( )

Definition at line 455 of file SEDMLUtils.cpp.

 {
   // TODO Auto-generated constructor stub
 }

SEDMLUtils::~SEDMLUtils ( )

virtual

Definition at line 460 of file SEDMLUtils.cpp.

 {
   // TODO Auto-generated destructor stub
 }

Member Function Documentation

std::string SEDMLUtils::findIdByNameAndType	(	const std::map< CCopasiObject , SBase > &	map,
		int	typeCode,
		const std::string &	name
	)

static

Definition at line 26 of file SEDMLUtils.cpp.

Referenced by getXPathAndName().

 {
   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 "";
 }

std::string SEDMLUtils::getNextId	(	const std::string &	base,
		int	count
	)

static

Definition at line 294 of file SEDMLUtils.cpp.

Referenced by CSEDMLExporter::createDataGenerators(), CSEDMLExporter::createScanTask(), CSEDMLExporter::createSteadyStateTask(), CSEDMLExporter::createTimeCourseTask(), and SEDMLImporter::readListOfPlotsFromSedMLOutput().

 {
   std::stringstream str; str << base << count;
   return str.str();
 }

const CCopasiObject * SEDMLUtils::getObjectForSbmlId	(	const CModel *	pModel,
		const std::string &	id,
		const std::string &	SBMLType,
		bool	initial = `false`
	)

static

Definition at line 375 of file SEDMLUtils.cpp.

References CModel::getCompartments(), CModel::getMetabolites(), CModel::getModelValues(), CCopasiContainer::getObject(), CModel::getReactions(), and CCopasiVector< T >::size().

Referenced by resolveXPath().

 {
   if (SBMLType == "Time")
     return static_cast<const CCopasiObject *>(pModel->getObject(CCopasiObjectName("Reference=Time")));
 
   if (SBMLType == "species")
     {
       size_t iMet, imax = pModel->getMetabolites().size();
 
       for (iMet = 0; iMet < imax; ++iMet)
         {
           // the importer should not need to change the initial concentration
           // pModel->getMetabolites()[iMet]->setInitialConcentration(0.896901);
 
           if (pModel->getMetabolites()[iMet]->getSBMLId() == id)
             {
               if (initial)
                 return pModel->getMetabolites()[iMet]->getInitialConcentrationReference();
 
               return pModel->getMetabolites()[iMet]->getConcentrationReference();
             }
         }
     }
   else if (SBMLType == "reaction")
     {
       size_t iMet, imax = pModel->getReactions().size();
 
       for (iMet = 0; iMet < imax; ++iMet)
         {
           if (pModel->getReactions()[iMet]->getSBMLId() == id)
             {
               if (initial)
                 return NULL;
 
               return pModel->getReactions()[iMet]->getFluxReference();
             }
         }
     }
   else if (SBMLType == "parameter")
     {
       size_t iMet, imax = pModel->getModelValues().size();
 
       for (iMet = 0; iMet < imax; ++iMet)
         {
           if (pModel->getModelValues()[iMet]->getSBMLId() == id)
             {
               if (initial)
                 return pModel->getModelValues()[iMet]->getInitialValueReference();
 
               return pModel->getModelValues()[iMet]->getValueReference();
             }
         }
     }
 
   else if (SBMLType == "compartment")
     {
       size_t iComp, imax = pModel->getCompartments().size();
 
       for (iComp = 0; iComp < imax; ++iComp)
         {
           if (pModel->getCompartments()[iComp]->getSBMLId() == id)
             {
               if (initial)
                 return pModel->getCompartments()[iComp]->getInitialValueReference();
 
               return pModel->getCompartments()[iComp]->getValueReference();
             }
         }
     }
 
   return NULL;
 }

std::string SEDMLUtils::getXPathAndName	(	std::string &	sbmlId,
		const std::string &	type,
		const CModel *	pModel,
		const CCopasiDataModel &	dataModel
	)

static

Definition at line 65 of file SEDMLUtils.cpp.

References findIdByNameAndType(), removeCharactersFromString(), SEDML_TIME_URN, and splitStrings().

Referenced by CSEDMLExporter::createDataGenerators(), and getXPathForObject().

 {
   std::vector<std::string> stringsContainer;
   std::string targetXPathString;
 
   const std::map<CCopasiObject*, SBase*>& copasi2sbmlmap =
     const_cast<CCopasiDataModel&>(dataModel).getCopasi2SBMLMap();
   std::string displayName = sbmlId;
 
   if (copasi2sbmlmap.size() == 0)
     {
       // this should not be happening, as this is used to verify the element.
       return "";
     }
 
   std::map<CCopasiObject*, SBase*>::const_iterator pos;
 
   if (type == "Concentration" || type == "InitialConcentration")
     {
       targetXPathString = "/sbml:sbml/sbml:model/sbml:listOfSpecies/sbml:species[@id=\'";
       //remove unwanted characters from the plot item object name
       removeCharactersFromString(displayName, "[]");
 
       if (type == "InitialConcentration")
         {
           displayName = displayName.substr(0, displayName.length() - 2);
         }
 
       sbmlId = findIdByNameAndType(copasi2sbmlmap, SBML_SPECIES, displayName);
 
       if (!sbmlId.empty())
         {
           return targetXPathString + sbmlId + "\']";
         }
       else
         return "";
     }
 
   else if (type == "Flux")
     {
       targetXPathString = "/sbml:sbml/sbml:model/sbml:listOfReactions/sbml:reaction[@id=\'";
       splitStrings(displayName, ')', stringsContainer);
       displayName = stringsContainer[0];
 
       removeCharactersFromString(displayName, "(");
 
       sbmlId = findIdByNameAndType(copasi2sbmlmap, SBML_REACTION, displayName);
 
       if (!sbmlId.empty())
         {
           return targetXPathString + sbmlId + "\']";
         }
       else
         return "";
     }
   else if (type == "Value" || type == "InitialValue")
     {
       if (type == "InitialValue")
         {
           displayName = displayName.substr(0, displayName.find(".InitialValue"));
         }
 
       targetXPathString = "/sbml:sbml/sbml:model/sbml:listOfParameters/sbml:parameter[@id=\'";
       splitStrings(displayName, '[', stringsContainer);
 
       if (stringsContainer.size() == 1)
         {
           // not found ... might be a local parameter
           removeCharactersFromString(displayName, "()");
           splitStrings(displayName, '.', stringsContainer);
 
           if (stringsContainer.size() == 2)
             {
               sbmlId = stringsContainer[0] + "_" + stringsContainer[1];
               std::stringstream xpath;
               xpath << "/sbml:sbml/sbml:model/sbml:listOfReactions/sbml:reaction[@id=\'";
               xpath << stringsContainer[0];
               xpath << "\']/sbml:kineticLaw/sbml:listOfParameters/sbml:parameter[@id=\'";
               xpath << stringsContainer[1];
               xpath << "\']";
               return xpath.str();
             }
         }
 
       displayName = stringsContainer[1];
 
       removeCharactersFromString(displayName, "]");
 
       sbmlId = findIdByNameAndType(copasi2sbmlmap, SBML_PARAMETER , displayName);
 
       if (sbmlId.empty())
         sbmlId = findIdByNameAndType(copasi2sbmlmap, SBML_LOCAL_PARAMETER , displayName);
 
       if (!sbmlId.empty())
         {
           return targetXPathString + sbmlId + "\']";
         }
       else
         return "";
     }
   else if (type == "Volume" || type == "InitialVolume")
     {
       targetXPathString = "/sbml:sbml/sbml:model/sbml:listOfCompartments/sbml:compartment[@id=\'";
       splitStrings(displayName, '[', stringsContainer);
       displayName = stringsContainer[1];
 
       if (type == "InitialVolume")
         {
           displayName = displayName.substr(0, displayName.find(".InitialVolume"));
         }
 
       if (type == "Volume")
         {
           displayName = displayName.substr(0, displayName.find(".Volume"));
         }
 
       removeCharactersFromString(displayName, "]");
 
       sbmlId = findIdByNameAndType(copasi2sbmlmap, SBML_COMPARTMENT, displayName);
 
       if (!sbmlId.empty())
         {
           return targetXPathString + sbmlId + "\']";
         }
       else
         return "";
     }
   else if (type == "Time" || type == "Initial Time")
     return SEDML_TIME_URN;
 
   sbmlId = "";
   return targetXPathString;
 }

std::string SEDMLUtils::getXPathForObject ( const CCopasiObject & object )

static

Definition at line 284 of file SEDMLUtils.cpp.

References CCopasiDataModel::getModel(), CCopasiObject::getObjectDataModel(), CCopasiObject::getObjectDisplayName(), and getXPathAndName().

Referenced by CSEDMLExporter::createScanTask().

 {
   const std::string& type = object.getObjectName();
   const CCopasiDataModel* dm = object.getObjectDataModel();
   std::string yAxis = object.getObjectDisplayName();
   std::string targetXPathString = getXPathAndName(yAxis, type,
                                   dm->getModel(), *dm);
   return targetXPathString;
 }

int SEDMLUtils::processArchive	(	const std::string &	archiveFile,
		std::string &	fileName,
		std::string &	fileContent
	)

Definition at line 300 of file SEDMLUtils.cpp.

 {
 
   int err = 0;
   /*
   const char * cArchive = archiveFile.c_str();
 
     //Open the ZIP archive
     zip *zip = zip_open(cArchive, 0, &err);
 
     //Search for file using its given name
     const char *nameOfFile = fileName.c_str();
     struct zip_stat st;
     zip_stat_init(&st);
     zip_stat(zip, nameOfFile, 0, &st);
 
     //Alloc memory for its uncompressed contents
     char *fileCont = new char[st.size];
 
     //Read the compressed file
   zip_file *file = zip_fopen(zip, nameOfFile, 0);
   zip_fread(file, fileCont, st.size);
 
   std::ostringstream fileContentStream;
   size_t i, iMax = st.size;
   for(i = 0; i<iMax; ++i){
     fileContentStream << fileCont[i];
   }
   fileContent = fileContentStream.str();
 
   //close the file and archive
   zip_fclose(file);
   zip_close(zip);
   */
 
   return err;
 }

std::string & SEDMLUtils::removeCharactersFromString	(	std::string &	str,
		const std::string &	characters
	)

static

Definition at line 273 of file SEDMLUtils.cpp.

Referenced by CSEDMLExporter::createDataGenerators(), getXPathAndName(), and translateTargetXpathInSBMLId().

 {
   for (unsigned int ii = 0; ii < characters.length(); ++ii)
     {
       str.erase(std::remove(str.begin(), str.end(), characters[ii]), str.end());
     }
 
   return str;
 }

const CCopasiObject * SEDMLUtils::resolveDatagenerator	(	const CModel *	model,
		const SedDataGenerator *	dataReference
	)

static

Definition at line 203 of file SEDMLUtils.cpp.

References CCopasiContainer::getObject(), resolveXPath(), and SEDML_TIME_URN.

Referenced by SEDMLImporter::readListOfPlotsFromSedMLOutput().

 {
   // for now one variable only
   if (dataReference == NULL || dataReference->getNumVariables() < 1) return NULL;
 
   const SedVariable* var = dataReference->getVariable(0);
 
   if (var->isSetSymbol() && var->getSymbol() == SEDML_TIME_URN)
     {
       return static_cast<const CCopasiObject *>(model->getObject(CCopasiObjectName("Reference=Time")));
     }
 
   return resolveXPath(model, var->getTarget());
 }

const CCopasiObject * SEDMLUtils::resolveXPath	(	const CModel *	model,
		const std::string &	xpath,
		bool	initial = `false`
	)

static

Definition at line 242 of file SEDMLUtils.cpp.

References CCopasiObject::getObject(), getObjectForSbmlId(), CCopasiObject::getObjectParent(), and translateTargetXpathInSBMLId().

Referenced by applyAttributeChange(), SEDMLImporter::importTasks(), and resolveDatagenerator().

 {
   std::string SBMLType;
   std::string id = translateTargetXpathInSBMLId(xpath, SBMLType);
   const CCopasiObject* result = getObjectForSbmlId(model, id, SBMLType, initial);
 
   if (result == NULL)
     {
       // old method fails here, possibly a local parameter
       size_t pos = xpath.find("/sbml:kineticLaw/sbml:listOfParameters/");
 
       if (pos != std::string::npos)
         {
           std::string reactionType;
           std::string reactionId = translateTargetXpathInSBMLId(xpath.substr(0, pos), reactionType);
           const CCopasiObject* flux = getObjectForSbmlId(model, reactionId, reactionType);
 
           if (flux != NULL)
             {
               const CCopasiObject* reactionObj = flux->getObjectParent();
               std::string cn = "ParameterGroup=Parameters,Parameter=" + id + ",Reference=Value";
               return dynamic_cast<const CCopasiObject*>(reactionObj->getObject(cn));
             }
         }
     }
 
   return result;
 }

void SEDMLUtils::splitStrings	(	const std::string &	xpath,
		char	delim,
		std::vector< std::string > &	stringsContainer
	)

static

This is a hack at the moment better solution for processing XPath string may be developed in the future

Definition at line 344 of file SEDMLUtils.cpp.

Referenced by getXPathAndName(), and translateTargetXpathInSBMLId().

 {
   std::string myPath = xpath;
   xpathStrings.clear();
   std::string next;
 
   // For each character in the string
   for (std::string::const_iterator it = xpath.begin(); it != xpath.end(); it++)
     {
       // check delimeter character
       if (*it == delim)
         {
           if (!next.empty())
             {
               // Add them to the xpathStrings vector
               xpathStrings.push_back(next);
               next.clear();
             }
         }
       else
         {
           next += *it;
         }
     }
 
   if (!next.empty())
     xpathStrings.push_back(next);
 }

std::string SEDMLUtils::translateTargetXpathInSBMLId	(	const std::string &	xpath,
		std::string &	SBMLType
	)

static

Definition at line 219 of file SEDMLUtils.cpp.

References removeCharactersFromString(), and splitStrings().

Referenced by resolveXPath().

 {
   std::vector<std::string> xpathStrings;
   std::string id, nextString;
 
   splitStrings(xpath, ':', xpathStrings);
   nextString = xpathStrings[xpathStrings.size() - 1];
 
   splitStrings(nextString, '[', xpathStrings);
   SBMLType = xpathStrings[0];
   nextString = xpathStrings[xpathStrings.size() - 1];
 
   splitStrings(nextString, '=', xpathStrings);
   nextString = xpathStrings[xpathStrings.size() - 1];
   splitStrings(nextString, ']', xpathStrings);
   id = xpathStrings[0];
 
   //remove the remaining unwanted characters
   removeCharactersFromString(id, "\"']");
   return id;
 }

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation