SBMLImporter.cpp File Reference

#include <iostream>
#include <vector>
#include <sstream>
#include <map>
#include <limits>
#include <cmath>
#include <sbml/SBMLReader.h>
#include <sbml/SBMLDocument.h>
#include <sbml/Compartment.h>
#include <sbml/Species.h>
#include <sbml/SpeciesReference.h>
#include <sbml/Reaction.h>
#include <sbml/LocalParameter.h>
#include <sbml/KineticLaw.h>
#include <sbml/math/FormulaFormatter.h>
#include <sbml/Model.h>
#include <sbml/UnitKind.h>
#include <sbml/Unit.h>
#include <sbml/Parameter.h>
#include <sbml/InitialAssignment.h>
#include <sbml/Rule.h>
#include <sbml/FunctionDefinition.h>
#include <sbml/UnitDefinition.h>
#include "copasi.h"
#include "report/CKeyFactory.h"
#include "model/CModel.h"
#include "model/CCompartment.h"
#include "model/CMetab.h"
#include "model/CReaction.h"
#include "model/CModelValue.h"
#include "model/CEvent.h"
#include "function/CNodeK.h"
#include "function/CFunctionDB.h"
#include "function/CEvaluationTree.h"
#include "function/CExpression.h"
#include "function/CFunctionParameters.h"
#include "report/CCopasiObjectReference.h"
#include "utilities/CCopasiTree.h"
#include "utilities/CNodeIterator.h"
#include "CopasiDataModel/CCopasiDataModel.h"
#include "report/CCopasiRootContainer.h"
#include "MIRIAM/CRDFGraphConverter.h"
#include "compareExpressions/CEvaluationNodeNormalizer.h"
#include "commandline/CLocaleString.h"
#include "commandline/COptions.h"
#include "SBMLImporter.h"
#include "SBMLUtils.h"
#include "ConverterASTNode.h"
#include "utilities/CProcessReport.h"
#include "copasi/commandline/CConfigurationFile.h"
#include "layout/SBMLDocumentLoader.h"
#include "layout/CListOfLayouts.h"
#include "utilities/CCopasiMessage.h"

Go to the source code of this file.

Macros
#define	INIT_DEFAULTS(element)
#define	USE_LAYOUT   1

Functions
bool	addToKnownFunctionToMap (std::map< std::string, std::string > &map, const FunctionDefinition *sbmlFunction)
int	AstStrCmp (const void *s1, const void *s2)
bool	containsKey (const CCopasiVector< CChemEqElement > &list, const std::string &key)
void	ensureAllArgsAreBeingUsedInFunctionDefinition (const FunctionDefinition *sbmlFunction)
CFunction *	findFunction (CCopasiVectorN< CFunction > &db, const CFunction *func)
CFunction *	getFunctionForKey (CCopasiVectorN< CFunction > &functionDb, const std::string &key)
std::string	getInitialCNForSBase (SBase *sbase, std::map< CCopasiObject *, SBase * > &copasi2sbmlmap)
std::string	getOriginalSBMLId (Parameter *parameter)
std::string	isKnownCustomFunctionDefinition (const FunctionDefinition *sbmlFunction, const std::string &sNamespace, const std::string &elementName, const std::string &definition)

Macro Definition Documentation

#define INIT_DEFAULTS

(

element

)

Value:

{\
  }

Definition at line 49 of file SBMLImporter.cpp.

Referenced by SBMLImporter::createCModelFromSBMLDocument().

#define USE_LAYOUT   1

Definition at line 22 of file SBMLImporter.cpp.

Function Documentation

bool addToKnownFunctionToMap	(	std::map< std::string, std::string > &	map,
		const FunctionDefinition *	sbmlFunction
	)

Definition at line 1590 of file SBMLImporter.cpp.

References isKnownCustomFunctionDefinition().

Referenced by SBMLImporter::createCFunctionFromFunctionDefinition().

{
  if (!sbmlFunction->isSetAnnotation())
    return false;

  std::string id = isKnownCustomFunctionDefinition(sbmlFunction,
                   "http://sbml.org/annotations/symbols",
                   "symbols",
                   "http://en.wikipedia.org/wiki/Derivative");

  if (!id.empty())
    {
      map[id] = "RATE";
      return true;
    }

  id = isKnownCustomFunctionDefinition(sbmlFunction,
                                       "http://sbml.org/annotations/distribution",
                                       "distribution",
                                       "http://www.uncertml.org/distributions/normal");

  if (!id.empty())
    {
      map[id] = "RNORMAL";
      return true;
    }

  id = isKnownCustomFunctionDefinition(sbmlFunction,
                                       "http://sbml.org/annotations/distribution",
                                       "distribution",
                                       "http://www.uncertml.org/distributions/uniform");

  if (!id.empty())
    {
      map[id] = "RUNIFORM";
      return true;
    }

  id = isKnownCustomFunctionDefinition(sbmlFunction,
                                       "http://sbml.org/annotations/distribution",
                                       "distribution",
                                       "http://www.uncertml.org/distributions/gamma");

  if (!id.empty())
    {
      map[id] = "RGAMMA";
      return true;
    }

  id = isKnownCustomFunctionDefinition(sbmlFunction,
                                       "http://sbml.org/annotations/distribution",
                                       "distribution",
                                       "http://www.uncertml.org/distributions/poisson");

  if (!id.empty())
    {
      map[id] = "RPOISSON";
      return true;
    }

  return false;
}

int AstStrCmp	(	const void *	s1,
		const void *	s2
	)

Definition at line 1654 of file SBMLImporter.cpp.

Referenced by ensureAllArgsAreBeingUsedInFunctionDefinition().

{
  const char* a = static_cast<const ASTNode *>(s1)->getName();
  const char* b = static_cast<const ASTNode *>(s2)->getName();

  if (a == NULL && b == NULL) return  0;

  if (a == NULL && b != NULL) return -1;

  if (a != NULL && b == NULL) return  1;

  return strcmp(
           a,
           b);
}

bool containsKey	(	const CCopasiVector< CChemEqElement > &	list,
		const std::string &	key
	)

Definition at line 5724 of file SBMLImporter.cpp.

References CCopasiVector< T >::begin(), and CCopasiVector< T >::end().

Referenced by SBMLImporter::doMapping().

{
  CCopasiVector < CChemEqElement >::const_iterator it = list.begin();
  CCopasiVector < CChemEqElement >::const_iterator end = list.end();

  for (; it != end; ++it)
    {
      if ((*it)->getMetaboliteKey() == key)
        {
          return true;
        }
    }

  return false;
}

void ensureAllArgsAreBeingUsedInFunctionDefinition

(

const FunctionDefinition *

sbmlFunction

)

This function checks the function definition for unused arguments (that would not be properly displayed in the CopasiUI). If found, the function body will be replaced with one including all arguments.

Definition at line 1675 of file SBMLImporter.cpp.

References AstStrCmp().

Referenced by SBMLImporter::createCFunctionFromFunctionDefinition().

{
  if (sbmlFunction == NULL || sbmlFunction->getNumArguments() == 0 || sbmlFunction->getBody() == NULL) return;

  // get all variables
  List *variables = sbmlFunction->getBody()->getListOfNodes(ASTNode_isName);

  // find unused ones
  std::vector<std::string> unused;

  for (unsigned int i = 0; i < sbmlFunction->getNumArguments(); ++i)
    {
      const ASTNode *arg = sbmlFunction->getArgument(i);

      if (variables->find(arg, AstStrCmp) == NULL)
        {
          if (arg->getName() != NULL)
            unused.push_back(arg->getName());
        }
    }

  // get rid of the list
  delete variables;

  // let us hope this is empty
  if (unused.size() == 0)
    return;

  // it is not, so modify the function definition to include all of them
  std::stringstream str;
  str << "lambda(";

  for (unsigned int i = 0; i < sbmlFunction->getNumArguments(); ++i)
    str << sbmlFunction->getArgument(i)->getName() << ", ";

  char* formula = SBML_formulaToString(sbmlFunction->getBody());
  str << formula;

  std::vector<std::string>::iterator it;

  for (it = unused.begin(); it != unused.end(); ++it)
    str << " + 0*" << *it;

  str << ")";

  // update the function definition
  const_cast<FunctionDefinition*>(sbmlFunction)->setMath(SBML_parseFormula(str.str().c_str()));

  // free the formula
  free(formula);
}

CFunction* findFunction	(	CCopasiVectorN< CFunction > &	db,
		const CFunction *	func
	)

Definition at line 2126 of file SBMLImporter.cpp.

References CCopasiVector< T >::size().

Referenced by CModel::convert2NonReversible().

{
  size_t i, iMax = db.size();

  for (i = 0; i < iMax; ++i)
    {
      CFunction* pFun = (db[i]);

      if (*pFun == *func)
        return pFun;
    }

  return NULL;
}

CFunction* getFunctionForKey	(	CCopasiVectorN< CFunction > &	functionDb,
		const std::string &	key
	)

Definition at line 1926 of file SBMLImporter.cpp.

References CCopasiVector< T >::begin(), and CCopasiVector< T >::end().

{
  CFunction* pFunc = NULL;
  CCopasiVectorN<CFunction>::iterator it = functionDb.begin(), endit = functionDb.end();

  while (it != endit)
    {
      if ((*it)->getKey() == key)
        {
          pFunc = dynamic_cast<CFunction*>(*it);
          break;
        }

      ++it;
    }

  return pFunc;
}

std::string getInitialCNForSBase	(	SBase *	sbase,
		std::map< CCopasiObject *, SBase * > &	copasi2sbmlmap
	)

Definition at line 212 of file SBMLImporter.cpp.

References CCopasiObject::getCN(), CMetab::getInitialConcentrationReference(), and CModelEntity::getInitialValueReference().

Referenced by SBMLImporter::createCModelFromSBMLDocument().

{
  std::map<CCopasiObject*, SBase*>::const_iterator it;

  for (it = copasi2sbmlmap.begin(); it != copasi2sbmlmap.end(); ++it)
    {
      if (it->second != sbase)
        continue;

      CMetab *metab = dynamic_cast<CMetab*>(it->first);

      if (metab != NULL)
        return metab->getInitialConcentrationReference()->getCN();

      CCompartment *comp = dynamic_cast<CCompartment*>(it->first);

      if (comp != NULL)
        return comp->getInitialValueReference()->getCN();

      CModelValue *param = dynamic_cast<CModelValue*>(it->first);

      if (param != NULL)
        return param->getInitialValueReference()->getCN();
    }

  return "";
}

std::string getOriginalSBMLId

(

Parameter *

parameter

)

Definition at line 189 of file SBMLImporter.cpp.

Referenced by SBMLImporter::createCModelFromSBMLDocument().

{
  if (parameter == NULL) return "";

  if (!parameter->isSetAnnotation()) return "";

  XMLNode* node = parameter->getAnnotation();

  if (node->getNumChildren() < 1) return "";

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

      if (current.getNamespaces().containsUri("http://copasi.org/initialValue"))
        {
          return current.getAttrValue("parent");
        }
    }

  return "";
}

std::string isKnownCustomFunctionDefinition	(	const FunctionDefinition *	sbmlFunction,
		const std::string &	sNamespace,
		const std::string &	elementName,
		const std::string &	definition
	)

Definition at line 1560 of file SBMLImporter.cpp.

Referenced by addToKnownFunctionToMap().

{
  FunctionDefinition* current = const_cast<FunctionDefinition*>(sbmlFunction);

  if (current == NULL) return "";

  if (!current->isSetAnnotation()) return "";

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

  if (element == NULL) return "";

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