CSBMLExporter.cpp File Reference

#include <cmath>
#include "CSBMLExporter.h"
#include "SBMLUtils.h"
#include "SBMLImporter.h"
#include "utilities/CCopasiException.h"
#include "sbml/SBMLDocument.h"
#include "sbml/Compartment.h"
#include "sbml/Model.h"
#include "sbml/Species.h"
#include "sbml/Parameter.h"
#include "sbml/Reaction.h"
#include "sbml/KineticLaw.h"
#include "sbml/SBMLWriter.h"
#include "sbml/SpeciesReference.h"
#include "sbml/math/ASTNode.h"
#include "sbml/annotation/ModelHistory.h"
#include "sbml/annotation/CVTerm.h"
#include "sbml/SBMLErrorLog.h"
#include "sbml/SBMLError.h"
#include "CopasiDataModel/CCopasiDataModel.h"
#include "SBMLIncompatibility.h"
#include "model/CCompartment.h"
#include "model/CModel.h"
#include "model/CEvent.h"
#include "model/CMetab.h"
#include "function/CExpression.h"
#include "function/CEvaluationNode.h"
#include "model/CAnnotation.h"
#include "model/CReaction.h"
#include "utilities/CCopasiParameter.h"
#include "model/CModelValue.h"
#include "function/CFunction.h"
#include "report/CKeyFactory.h"
#include "ConverterASTNode.h"
#include "utilities/CCopasiTree.h"
#include "model/CChemEqElement.h"
#include "utilities/CVersion.h"
#include "sbml/Trigger.h"
#include "sbml/Event.h"
#include "sbml/EventAssignment.h"
#include <sbml/xml/XMLInputStream.h>
#include "compareExpressions/compare_utilities.h"
#include "MIRIAM/CRDFUtilities.h"
#include "MIRIAM/CModelMIRIAMInfo.h"
#include "MIRIAM/CReference.h"
#include "MIRIAM/CBiologicalDescription.h"
#include "MIRIAM/CConstants.h"
#include "MIRIAM/CCreator.h"
#include "MIRIAM/CModified.h"
#include "MIRIAM/CRDFPredicate.h"
#include "layout/CListOfLayouts.h"
#include "copasi/report/CCopasiRootContainer.h"
#include "commandline/CLocaleString.h"

Go to the source code of this file.

Macros
#define	INIT_DEFAULTS(element)
#define	USE_LAYOUT   1

Functions
void	addInitialAssignmentsToModel (SBMLDocument *doc, std::map< const std::string, Parameter * > &initialValueMap, const CCopasiDataModel &dataModel)
std::string	addRateOfIfItDoesNotExist (SBMLDocument *pSBMLDocument, std::map< std::string, const SBase * > &idMap, const char *id)
void	addToInitialValueMap (std::map< const std::string, Parameter * > *initialMap, const CCopasiObject *pObject, const CCopasiObject *pObjectParent, int sbmlLevel, int sbmlVersion)
void	adjustNames (ASTNode *node, SBMLDocument *pSBMLDocument, std::map< std::string, const SBase * > &idMap)
std::string	convertExpression (const std::string &expression, const std::map< const std::string, Parameter * > &initialValueMap)
std::string	createFunctionDefinitonForURI (SBMLDocument *pSBMLDocument, std::map< std::string, const SBase * > &idMap, const char *id, const std::string &sNamespace, const std::string &elementName, const std::string &definition, const std::string &lambda)
std::string	getAnnotationStringFor (const CCopasiObject *pObjectParent)
std::string	getUserDefinedFuctionForName (SBMLDocument *pSBMLDocument, std::map< std::string, const SBase * > &idMap, const char *id)
std::string	hasFunctionDefinitionForURI (SBMLDocument *pSBMLDocument, const std::string &sNamespace, const std::string &elementName, const std::string &definition)
void	removeStickyTagFromElements (SBMLDocument *pSBMLDocument)

Macro Definition Documentation

#define INIT_DEFAULTS

(

element

)

Value:

{\
  }

Definition at line 48 of file CSBMLExporter.cpp.

Referenced by CSBMLExporter::createAreaUnit(), CSBMLExporter::createCompartment(), CSBMLExporter::createLengthUnit(), CSBMLExporter::createMetabolite(), CSBMLExporter::createParameter(), CSBMLExporter::createReaction(), CSBMLExporter::createSubstanceUnit(), CSBMLExporter::createTimeUnit(), and CSBMLExporter::createVolumeUnit().

#define USE_LAYOUT   1

Definition at line 17 of file CSBMLExporter.cpp.

Function Documentation

void addInitialAssignmentsToModel	(	SBMLDocument *	doc,
		std::map< const std::string, Parameter * > &	initialValueMap,
		const CCopasiDataModel &	dataModel
	)

Definition at line 3369 of file CSBMLExporter.cpp.

References CCopasiContainer::getObject(), and CCopasiObject::getObjectParent().

Referenced by CSBMLExporter::createSBMLDocument().

{
  if (doc == NULL || doc->getModel() == NULL || initialValueMap.size() == 0)
    return;

  std::map<const std::string, Parameter*>::const_iterator it;

  for (it = initialValueMap.begin(); it != initialValueMap.end(); ++it)
    {
      Parameter* param = it->second;
      // add parameter to model
      int result = doc->getModel()->addParameter(param);
      doc->getModel()->getParameter(param->getId())->setUserData((void*)"1");

      const CCopasiObject *obj = static_cast<const CCopasiObject *>(dataModel.getObject(it->first));
      const std::string &sbmlId = (static_cast<const CModelEntity*>(obj->getObjectParent()))->getSBMLId();

      // create an initial assignment for the newly created initial quantity
      // to synchronize it with the original element.
      InitialAssignment* ia = doc->getModel()->createInitialAssignment();
      ia->setSymbol(it->second->getId());
      ia->setMath(SBML_parseFormula(sbmlId.c_str()));
      ia->setUserData((void*)"1");

      delete param;
    }
}

std::string addRateOfIfItDoesNotExist	(	SBMLDocument *	pSBMLDocument,
		std::map< std::string, const SBase * > &	idMap,
		const char *	id
	)

Definition at line 167 of file CSBMLExporter.cpp.

References createFunctionDefinitonForURI(), and hasFunctionDefinitionForURI().

Referenced by getUserDefinedFuctionForName(), and CSBMLExporter::replaceSpeciesReferences().

{
  std::string newId = hasFunctionDefinitionForURI(pSBMLDocument,
                      "http://sbml.org/annotations/symbols",
                      "symbols",
                      "http://en.wikipedia.org/wiki/Derivative");

  if (!newId.empty()) return newId;

  newId = createFunctionDefinitonForURI(
            pSBMLDocument,
            idMap,
            id,
            "http://sbml.org/annotations/symbols",
            "symbols",
            "http://en.wikipedia.org/wiki/Derivative",
            "lambda(a,NaN)"
          );
  return newId;
}

void addToInitialValueMap	(	std::map< const std::string, Parameter * > *	initialMap,
		const CCopasiObject *	pObject,
		const CCopasiObject *	pObjectParent,
		int	sbmlLevel,
		int	sbmlVersion
	)

Definition at line 2347 of file CSBMLExporter.cpp.

References C_FLOAT64, getAnnotationStringFor(), CCopasiObject::getCN(), CCopasiObject::getKey(), CCopasiObject::getObjectName(), CCopasiObject::getValuePointer(), and CCopasiObject::isValueDbl().

Referenced by CSBMLExporter::checkForUnsupportedObjectReferences().

{
  if (initialMap == NULL || pObject == NULL || pObjectParent == NULL)
    return;

  const std::string& cn = pObject->getCN();

  if ((*initialMap)[cn] != NULL)
    {
      // already have the initial assignment no need to add another one
      return;
    }

  Parameter* initial = new Parameter(sbmlLevel, sbmlVersion);
  initial->setAnnotation(getAnnotationStringFor(pObjectParent));
  initial->initDefaults();
  initial->setId(pObjectParent->getKey());
  initial->setName("Initial for " + pObjectParent->getObjectName());

  if (pObject->isValueDbl())
    initial->setValue(*((const C_FLOAT64*) pObject->getValuePointer()));

  (*initialMap) [cn] = initial;
}

void adjustNames	(	ASTNode *	node,
		SBMLDocument *	pSBMLDocument,
		std::map< std::string, const SBase * > &	idMap
	)

Definition at line 7054 of file CSBMLExporter.cpp.

References getUserDefinedFuctionForName().

Referenced by CSBMLExporter::convertToASTNode().

{
  if (node == NULL)
    return;

  if (node->isNumber() || node->isConstant() || node->isName())
    return;

  if (node->getType() == AST_FUNCTION)
    {
      std::string adjustedName = getUserDefinedFuctionForName(
                                   pSBMLDocument,
                                   idMap,
                                   node->getName()
                                 );
      node->setName(adjustedName .c_str());
    }

  for (unsigned int i = 0; i < node->getNumChildren(); ++i)
    {
      adjustNames(node->getChild(i), pSBMLDocument, idMap);
    }
}

std::string convertExpression	(	const std::string &	expression,
		const std::map< const std::string, Parameter * > &	initialValueMap
	)

Definition at line 1810 of file CSBMLExporter.cpp.

Referenced by CSBMLExporter::createEvent(), CSBMLExporter::createRule(), and CSBMLExporter::exportEventAssignments().

{
  if (initialValueMap.empty())
    return expression;

  std::string result = expression;
  std::map<const std::string, Parameter*>::const_iterator it;

  for (it = initialValueMap.begin(); it != initialValueMap.end(); ++it)
    {
      size_t length = it->first.length();
      size_t start;

      while ((start = result.find(it->first)) != std::string::npos)
        {
          result.replace(start, length, it->second->getId());
        }
    }

  return result;
}

std::string createFunctionDefinitonForURI	(	SBMLDocument *	pSBMLDocument,
		std::map< std::string, const SBase * > &	idMap,
		const char *	id,
		const std::string &	sNamespace,
		const std::string &	elementName,
		const std::string &	definition,
		const std::string &	lambda
	)

Definition at line 139 of file CSBMLExporter.cpp.

References CSBMLExporter::createUniqueId().

Referenced by addRateOfIfItDoesNotExist(), and getUserDefinedFuctionForName().

{
  if (pSBMLDocument == NULL || pSBMLDocument->getModel() == NULL) return id;

  std::string newId = CSBMLExporter::createUniqueId(idMap, id, false);

  FunctionDefinition *def = pSBMLDocument->getModel()->createFunctionDefinition();
  def -> setId(newId);
  def -> setMath(SBML_parseFormula(lambda.c_str()));

  std::stringstream annotation;
  std::string annotElement = pSBMLDocument->getLevel() == 1 ? "annotations" : "annotation";
  annotation << "<" << annotElement << "> <" << elementName
             << " xmlns='" << sNamespace
             << "' definition='" << definition
             << "' /> </" << annotElement << ">";

  def->setAnnotation(annotation.str());

  return newId;
}

std::string getAnnotationStringFor

(

const CCopasiObject *

pObjectParent

)

Definition at line 2335 of file CSBMLExporter.cpp.

Referenced by addToInitialValueMap().

{
  std::stringstream str;
  str << "<initialValue xmlns='http://copasi.org/initialValue' ";
  str << "parent='" << ((CModelEntity*)pObjectParent)->getSBMLId() <<  "' />";
  return str.str();
}

std::string getUserDefinedFuctionForName	(	SBMLDocument *	pSBMLDocument,
		std::map< std::string, const SBase * > &	idMap,
		const char *	id
	)

Definition at line 190 of file CSBMLExporter.cpp.

References addRateOfIfItDoesNotExist(), createFunctionDefinitonForURI(), and hasFunctionDefinitionForURI().

Referenced by adjustNames().

{
  std::string newId;

  if (id == std::string("RNORMAL"))
    {
      newId = hasFunctionDefinitionForURI(pSBMLDocument,
                                          "http://sbml.org/annotations/distribution",
                                          "distribution",
                                          "http://www.uncertml.org/distributions/normal");

      if (!newId.empty()) return newId;

      newId = createFunctionDefinitonForURI(
                pSBMLDocument,
                idMap,
                id,
                "http://sbml.org/annotations/distribution",
                "distribution",
                "http://www.uncertml.org/distributions/normal",
                "lambda(m,s,m)"
              );
      return newId;
    }
  else if (id == std::string("RUNIFORM"))
    {
      newId = hasFunctionDefinitionForURI(pSBMLDocument,
                                          "http://sbml.org/annotations/distribution",
                                          "distribution",
                                          "http://www.uncertml.org/distributions/uniform");

      if (!newId.empty()) return newId;

      newId = createFunctionDefinitonForURI(
                pSBMLDocument,
                idMap,
                id,
                "http://sbml.org/annotations/distribution",
                "distribution",
                "http://www.uncertml.org/distributions/uniform",
                "lambda(a,b,(a+b)/2)"
              );
      return newId;
    }
  else if (id == std::string("RGAMMA"))
    {
      newId = hasFunctionDefinitionForURI(pSBMLDocument,
                                          "http://sbml.org/annotations/distribution",
                                          "distribution",
                                          "http://www.uncertml.org/distributions/gamma");

      if (!newId.empty()) return newId;

      newId = createFunctionDefinitonForURI(
                pSBMLDocument,
                idMap,
                id,
                "http://sbml.org/annotations/distribution",
                "distribution",
                "http://www.uncertml.org/distributions/gamma",
                "lambda(a,b,a*b)"
              );
      return newId;
    }
  else if (id == std::string("RPOISSON"))
    {
      newId = hasFunctionDefinitionForURI(pSBMLDocument,
                                          "http://sbml.org/annotations/distribution",
                                          "distribution",
                                          "http://www.uncertml.org/distributions/poisson");

      if (!newId.empty()) return newId;

      newId = createFunctionDefinitonForURI(
                pSBMLDocument,
                idMap,
                id,
                "http://sbml.org/annotations/distribution",
                "distribution",
                "http://www.uncertml.org/distributions/poisson",
                "lambda(mu,mu)"
              );
      return newId;
    }
  else if (id == std::string("MAX"))
    {
      newId = hasFunctionDefinitionForURI(pSBMLDocument,
                                          "http://sbml.org/annotations/function",
                                          "function",
                                          "http://sbml.org/annotations/function/max");

      if (!newId.empty()) return newId;

      newId = createFunctionDefinitonForURI(
                pSBMLDocument,
                idMap,
                id,
                "http://sbml.org/annotations/function",
                "function",
                "http://sbml.org/annotations/function/max",
                "lambda(a,b,piecewise(a,geq(a,b),b))"
              );
      return newId;
    }
  else if (id == std::string("MIN"))
    {
      newId = hasFunctionDefinitionForURI(pSBMLDocument,
                                          "http://sbml.org/annotations/function",
                                          "function",
                                          "http://sbml.org/annotations/function/min");

      if (!newId.empty()) return newId;

      newId = createFunctionDefinitonForURI(
                pSBMLDocument,
                idMap,
                id,
                "http://sbml.org/annotations/function",
                "function",
                "http://sbml.org/annotations/function/min",
                "lambda(a,b,piecewise(a,leq(a,b),b))"
              );
      return newId;
    }
  else if (id == std::string("rateOf"))
    {
      return addRateOfIfItDoesNotExist(pSBMLDocument, idMap, id);
    }

  return id;
}

std::string hasFunctionDefinitionForURI	(	SBMLDocument *	pSBMLDocument,
		const std::string &	sNamespace,
		const std::string &	elementName,
		const std::string &	definition
	)

Definition at line 104 of file CSBMLExporter.cpp.

Referenced by addRateOfIfItDoesNotExist(), and getUserDefinedFuctionForName().

{
  if (pSBMLDocument == NULL || pSBMLDocument->getModel() == NULL) return "";

  for (unsigned int i = 0; i < pSBMLDocument->getModel()->getNumFunctionDefinitions(); ++i)
    {
      FunctionDefinition* current = pSBMLDocument->getModel()->getFunctionDefinition(i);

      if (current == NULL) continue;

      if (!current->isSetAnnotation()) continue;

      const XMLNode* element = current->getAnnotation();

      if (element == NULL) continue;

      for (unsigned int i = 0 ; i < element->getNumChildren(); ++i)
        {
          const XMLNode& annot = element->getChild(i);

          if (annot.getURI() == sNamespace &&
              annot.getName() == elementName &&
              annot.getAttrValue("definition") == definition)
            {
              return current->getId();
            }
        }
    }

  return "";
}

void removeStickyTagFromElements

(

SBMLDocument *

pSBMLDocument

)

Definition at line 3222 of file CSBMLExporter.cpp.

Referenced by CSBMLExporter::exportModelToString().

{
  if (pSBMLDocument == NULL || pSBMLDocument->getModel() == NULL)
    return;

  // reset sticky parameters
  for (unsigned int i = 0; i < pSBMLDocument->getModel()->getNumParameters(); ++i)
    pSBMLDocument->getModel()->getParameter(i)->setUserData(NULL);

  // reset sticky initial assignments
  for (unsigned int i = 0; i < pSBMLDocument->getModel()->getNumInitialAssignments(); ++i)
    pSBMLDocument->getModel()->getInitialAssignment(i)->setUserData(NULL);
}