CSBMLExporter Class Reference

#include <CSBMLExporter.h>

Collaboration diagram for CSBMLExporter:

Public Member Functions
	CSBMLExporter ()
void	disownSBMLDocument ()
bool	exportModel (CCopasiDataModel &dataModel, const std::string &filename, unsigned int sbmlLevel=2, unsigned int sbmlVersion=1, bool overwrite=false)
const std::string	exportModelToString (CCopasiDataModel &dataModel, unsigned int sbmlLevel, unsigned int sbmlVersion)
const std::map< const CCopasiObject *, SBase * > &	getCOPASI2SBMLMap () const
SBMLDocument *	getSBMLDocument ()
bool	isSetExportCOPASIMIRIAM () const
void	setExportCOPASIMIRIAM (bool exportMIRIAM)
	~CSBMLExporter ()

Static Public Member Functions
static const std::string	createUniqueId (const std::map< std::string, const SBase * > &idMap, const std::string &prefix, bool addIndexForFirst, const std::string &separator="_")
static const std::vector < SBMLIncompatibility >	isModelSBMLCompatible (const CCopasiDataModel &pDataModel, int sbmlLevel, int sbmlVersion)

Protected Member Functions
void	assignSBMLIdsToReactions (CModel *pModel)
void	checkForUnsupportedFunctionCalls (const CCopasiDataModel &dataModel, unsigned int sbmlLEvel, unsigned int sbmlVersion, std::vector< SBMLIncompatibility > &result)
void	checkForUnsupportedObjectReferences (const CCopasiDataModel &dataModel, unsigned int sbmlLevel, unsigned int sbmlVersion, std::vector< SBMLIncompatibility > &result)
void	collectIds (const CCopasiDataModel &dataModel, std::map< std::string, const SBase * > &idMap)
ASTNode *	convertToASTNode (const CEvaluationNode *pOrig, CCopasiDataModel &dataModel)
void	convertToLevel1 ()
void	createAreaUnit (const CCopasiDataModel &dataModel)
void	createCompartment (CCompartment &compartment)
void	createCompartments (CCopasiDataModel &dataModel)
void	createEvent (CEvent &event, Event *pSBMLEvent, CCopasiDataModel &dataModel)
void	createEvents (CCopasiDataModel &dataModel)
void	createFunctionDefinition (CFunction &function, CCopasiDataModel &dataModel)
void	createFunctionDefinitions (CCopasiDataModel &dataModel)
const std::map< std::string, const SBase * >	createIdMap (const Model &sbmlModel)
void	createInitialAssignment (const CModelEntity &modelEntity, CCopasiDataModel &dataModel)
void	createInitialAssignments (CCopasiDataModel &dataModel)
CEvaluationNode *	createKineticExpression (CFunction *pFun, const std::vector< std::vector< std::string > > &arguments)
KineticLaw *	createKineticLaw (CReaction &reaction, CCopasiDataModel &dataModel, unsigned int level, unsigned int version)
void	createLengthUnit (const CCopasiDataModel &dataModel)
void	createMetabolite (CMetab &metab)
void	createMetabolites (CCopasiDataModel &dataModel)
void	createParameter (CModelValue &parameter)
void	createParameters (CCopasiDataModel &dataModel)
void	createReaction (CReaction &reaction, CCopasiDataModel &dataModel)
void	createReactions (CCopasiDataModel &dataModel)
void	createRule (const CModelEntity &modelEntity, CCopasiDataModel &dataModel, Rule *pOldRule)
void	createRules (CCopasiDataModel &dataModel)
void	createSBMLDocument (CCopasiDataModel &dataModel)
void	createSubstanceUnit (const CCopasiDataModel &dataModel)
void	createTimeUnit (const CCopasiDataModel &dataModel)
void	createUnits (const CCopasiDataModel &dataModel)
void	createVolumeUnit (const CCopasiDataModel &dataModel)
void	exportEventAssignments (const CEvent &event, Event *pSBMLEvent, CCopasiDataModel &dataModel)
void	findAvogadro (const CCopasiDataModel &dataModel)
bool	hasVolumeAssignment (const CCopasiDataModel &dataModel)
std::vector< CModelEntity * >	orderRules (const CCopasiDataModel &dataModel)
void	outputIncompatibilities () const
void	removeInitialAssignment (const std::string &sbmlId)
void	removeRule (const std::string &sbmlId)
void	removeUnusedObjects ()
void	replace_local_parameters (ASTNode *pOrigNode, const CCopasiDataModel &dataModel)
XMLNode *	replaceChild (const XMLNode *pParent, const XMLNode *pNewChild, unsigned int index)
CEvaluationNode *	replaceSpeciesReferences (const CEvaluationNode *pOrigNode, const CCopasiDataModel &dataModel)
void	restore_local_parameters (ASTNode *pOrigNode, const CCopasiDataModel &dataModel)
void	setFunctionSBMLIds (const CEvaluationNode *pNode, CCopasiDataModel &dataModel)
void	updateCOPASI2SBMLMap (const CCopasiDataModel &dataModel)
bool	updateMIRIAMAnnotation (const CCopasiObject *pCOPASIObject, SBase *pSBMLObject, std::map< std::string, const SBase * > &metaIds)

Static Protected Member Functions
static void	check_for_spatial_size_units (const CCopasiDataModel &dataModel, std::vector< SBMLIncompatibility > &result)
static void	checkForEvents (const CCopasiDataModel &dataModel, std::vector< SBMLIncompatibility > &result)
static void	checkForInitialAssignments (const CCopasiDataModel &dataModel, std::vector< SBMLIncompatibility > &result)
static void	checkForODESpeciesInNonfixedCompartment (const CCopasiDataModel &dataModel, std::vector< SBMLIncompatibility > result)
static void	checkForPiecewiseFunctions (const CCopasiDataModel &dataModel, std::vector< SBMLIncompatibility > &result)
static void	checkForPiecewiseFunctions (const CEvaluationNode &node, std::vector< SBMLIncompatibility > &result, const std::string &objectName, const std::string &objectType)
static void	checkForUnsupportedFunctionCalls (const CEvaluationNode &node, const std::set< CEvaluationNodeFunction::SubType > &unsupportedFunctions, std::vector< SBMLIncompatibility > &result, const std::string &objectDescription)
static void	checkForUnsupportedObjectReferences (const CEvaluationTree &expression, const CCopasiDataModel &dataModel, unsigned int sbmlLevel, unsigned int sbmlVersion, std::vector< SBMLIncompatibility > &result, bool initialExpression=false, std::map< const std::string, Parameter * > *initialMap=NULL)
static void	convert_to_l1v1 (std::string &l1v2_string)
static ASTNode *	convertASTTreeToLevel1 (const ASTNode *pNode, const ListOfFunctionDefinitions &functions, std::string &message)
static const std::set < CFunction * >	createFunctionSetFromFunctionNames (const std::set< std::string > &names, CFunctionDB *pFunDB)
static CEvaluationNode *	createMassActionExpression (const std::vector< std::vector< std::string > > &arguments, bool isReversible)
static ASTNode *	createTimesTree (const CCopasiVector< CChemEqElement > &vect, unsigned int pos=0)
static const std::set < CEvaluationNodeFunction::SubType >	createUnsupportedFunctionTypeSet (unsigned int sbmlLevel)
static void	findDirectlyUsedFunctions (const CEvaluationNode *pRootNode, std::set< std::string > &result)
static void	findModelEntityDependencies (const CEvaluationNode *pNode, const CCopasiDataModel &dataModel, std::set< const CModelEntity * > &dependencies)
static const std::vector < CFunction * >	findUsedFunctions (std::set< CFunction * > &functions, CFunctionDB *pFunctionDB)
static ASTNode *	isDividedByVolume (const ASTNode *pRootNode, const std::string &compartmentId)
static void	isEventAssignmentSBMLCompatible (std::string &key, const CExpression *pExpression, const CCopasiDataModel &dataModel, unsigned int sbmlLevel, unsigned int sbmlVersion, const std::string &eventName, std::vector< SBMLIncompatibility > &result)
static void	isEventSBMLCompatible (const CEvent *pEvent, const CCopasiDataModel &dataModel, unsigned int sbmlLevel, unsigned int sbmlVersion, std::vector< SBMLIncompatibility > &result)
static void	isExpressionSBMLCompatible (const CEvaluationTree &expr, const CCopasiDataModel &dataModel, int sbmlLevel, int sbmlVersion, std::vector< SBMLIncompatibility > &result, const std::string &objectDescription, bool initialExression=false, std::map< const std::string, Parameter * > *initialMap=NULL)
static void	isExpressionSBMLL1Compatible (const CEvaluationTree &expr, const CCopasiDataModel &dataModel, std::vector< SBMLIncompatibility > &result)
static void	isExpressionSBMLL2V1Compatible (const CEvaluationTree &expr, const CCopasiDataModel &dataModel, std::vector< SBMLIncompatibility > &result)
static void	isExpressionSBMLL2V3Compatible (const CEvaluationTree &expression, const CCopasiDataModel &pDataModel, std::vector< SBMLIncompatibility > &result)
static void	isModelSBMLL1Compatible (const CCopasiDataModel &dataModel, std::vector< SBMLIncompatibility > &result)
static void	isModelSBMLL2V1Compatible (const CCopasiDataModel &dataModel, std::vector< SBMLIncompatibility > &result)
static void	isModelSBMLL2V3Compatible (const CCopasiDataModel &dataModel, std::vector< SBMLIncompatibility > &result)
static bool	isValidSId (const std::string &id)
static CEvaluationNode *	multiplyByObject (const CEvaluationNode *pOrigNode, const CCopasiObject *pObject)
static ASTNode *	replaceL1IncompatibleNodes (const ASTNode *pNode)
static bool	setSBMLNotes (SBase *pSBase, const CAnnotation *pAnno)

Protected Attributes
std::vector< CModelEntity * >	mAssignmentVector
bool	mAvogadroCreated
std::map< const CCopasiObject *, SBase * >	mCOPASI2SBMLMap
bool	mDocumentDisowned
bool	mExportCOPASIMIRIAM
ListOfFunctionDefinitions	mExportedFunctions
std::map< std::string, const CEvaluationTree * >	mFunctionIdMap
std::map< const FunctionDefinition *, const CCopasiObject * >	mFunctionMap
std::set< SBase * >	mHandledSBMLObjects
bool	mHaveModelHistoryAuthorWarning
bool	mHaveModelHistoryCreationDateWarning
bool	mHaveModelHistoryModificationDateWarning
std::map< std::string, const SBase * >	mIdMap
std::vector< SBMLIncompatibility >	mIncompatibilities
bool	mIncompleteExport
std::vector< CModelEntity * >	mInitialAssignmentVector
std::map< const std::string, Parameter * >	mInitialValueMap
std::map< std::string, const SBase * >	mMetaIdMap
bool	mMIRIAMWarning
std::vector< CModelEntity * >	mODEVector
std::map< std::string, Parameter * >	mParameterReplacementMap
const CModelValue *	mpAvogadro
SBMLDocument *	mpSBMLDocument
unsigned int	mSBMLLevel
unsigned int	mSBMLVersion
std::set< std::string >	mSpatialSizeUnitsSpecies
std::set< CFunction * >	mUsedFunctions
bool	mVariableVolumes

Detailed Description

Definition at line 52 of file CSBMLExporter.h.

Constructor & Destructor Documentation

CSBMLExporter::CSBMLExporter

(

)

Default Konstruktor

Definition at line 328 of file CSBMLExporter.cpp.

                            : mpSBMLDocument(NULL), mSBMLLevel(2), mSBMLVersion(1), mIncompleteExport(false), mVariableVolumes(false), mpAvogadro(NULL), mAvogadroCreated(false), mMIRIAMWarning(false), mDocumentDisowned(false), mExportCOPASIMIRIAM(false), mExportedFunctions(2, 1)
{}

CSBMLExporter::~CSBMLExporter

(

)

Destruktor

Definition at line 331 of file CSBMLExporter.cpp.

References mDocumentDisowned, mpSBMLDocument, and pdelete.

{
  if (this->mDocumentDisowned == false)
    {
      pdelete(mpSBMLDocument);
    }
};

Member Function Documentation

void CSBMLExporter::assignSBMLIdsToReactions ( CModel *  pModel )

protected

Since we want to replace local reaction parameters by global parameters if they are used in an assignment, we have to create the reactions after creating the rules and events. On the other hand, a reaction flux might also be referenced in an assignment or an event and the creation of this rule or event only works if the reactions already have SBML ids. To solve this problem, the reactions have to be assigned SBML ids prior to creating rules and events. This is what this method does.

Definition at line 7556 of file CSBMLExporter.cpp.

References CCopasiVector< T >::begin(), createUniqueId(), CCopasiVector< T >::end(), CModel::getReactions(), and mIdMap.

Referenced by createSBMLDocument().

{
  std::string sbmlId;
  CCopasiVectorNS<CReaction>::const_iterator it = pModel->getReactions().begin(), endit = pModel->getReactions().end();

  while (it != endit)
    {
      if ((*it)->getSBMLId().empty())
        {
          sbmlId = CSBMLExporter::createUniqueId(this->mIdMap, (*it)->getObjectName(), false);
          (*it)->setSBMLId(sbmlId);
          this->mIdMap.insert(std::pair<const std::string, const SBase*>(sbmlId, (const SBase*)NULL));
        }

      ++it;
    }
}

void CSBMLExporter::check_for_spatial_size_units ( const CCopasiDataModel &  dataModel, std::vector< SBMLIncompatibility > &  result  )

staticprotected

Go through all species in the model and check if the corresponding species in the SBML model has the spatialSizeUnits attribute set. This attribute is not supported in SBML L2V3 and above, so we have to get rid of this attribute when we export to a level equal to or higher than L2V3. If the attribute has the same value as the compartments units, we can just delete it without changing the model, otherwise we have to give a corresponding warning.

Definition at line 2597 of file CSBMLExporter.cpp.

References SBMLImporter::areSBMLUnitDefinitionsIdentical(), CCopasiVector< T >::begin(), CCopasiVector< T >::end(), CCopasiMessage::EXCEPTION, CModel::getMetabolites(), CCopasiDataModel::getModel(), SBMLImporter::getSBMLUnitDefinitionForId(), and MCSBML.

Referenced by createMetabolites(), and isModelSBMLL2V3Compatible().

{
  const SBMLDocument* pSBMLDocument = const_cast<const SBMLDocument*>(const_cast<CCopasiDataModel&>(dataModel).getCurrentSBMLDocument());

  if (pSBMLDocument != NULL)
    {
      // check all species in the model if they have a spatial size attribute set
      // and if it is identical to the unit of the compartment the species is in
      const CModel* pModel = dataModel.getModel();

      if (pModel != NULL)
        {
          CCopasiVector<CMetab>::const_iterator it = pModel->getMetabolites().begin(), endit = pModel->getMetabolites().end();
          std::set<std::string> badSpecies;
          const std::map<CCopasiObject*, SBase*>& copasi2sbmlmap = const_cast<CCopasiDataModel&>(dataModel).getCopasi2SBMLMap();
          std::map<CCopasiObject*, SBase*>::const_iterator pos;
          const Species* pSBMLSpecies = NULL;
          std::string spatialSizeUnits;

          while (it != endit)
            {
              pos = copasi2sbmlmap.find(*it);

              if (pos != copasi2sbmlmap.end())
                {
                  // check for the spatial size units attribute
                  pSBMLSpecies = dynamic_cast<const Species*>(pos->second);
                  assert(pSBMLSpecies != NULL);

                  if (pSBMLSpecies == NULL) continue;

                  if (pSBMLSpecies->isSetSpatialSizeUnits())
                    {
                      spatialSizeUnits = pSBMLSpecies->getSpatialSizeUnits();
                      // check if the units are the same as the one on the species
                      // compartment
                      assert(pSBMLDocument->getModel() != NULL);
                      const Compartment* pCompartment = pSBMLDocument->getModel()->getCompartment(pSBMLSpecies->getCompartment());
                      assert(pCompartment != NULL);

                      if (pCompartment != NULL)
                        {
                          UnitDefinition* pUDef1 = NULL;
                          UnitDefinition* pUDef2 = NULL;

                          if (pCompartment->isSetUnits())
                            {
                              assert(pSBMLDocument->getModel() != NULL);

                              if (pSBMLDocument->getModel() != NULL)
                                {
                                  pUDef1 = SBMLImporter::getSBMLUnitDefinitionForId(pCompartment->getUnits(), pSBMLDocument->getModel());
                                }
                            }
                          else
                            {
                              // the compartment has the default units associated with the
                              // symbol length , area or volume depending on the spatial size
                              // of the compartment
                              assert(pSBMLDocument->getModel() != NULL);

                              if (pSBMLDocument->getModel() != NULL)
                                {
                                  switch (pCompartment->getSpatialDimensions())
                                    {
                                      case 0:
                                        // the species is not allowed to have a
                                        // spatialDimensionsUnit attribute
                                        CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 83 , pSBMLSpecies->getId().c_str());
                                        break;

                                      case 1:
                                        pUDef1 = SBMLImporter::getSBMLUnitDefinitionForId("length", pSBMLDocument->getModel());
                                        break;

                                      case 2:
                                        pUDef1 = SBMLImporter::getSBMLUnitDefinitionForId("area", pSBMLDocument->getModel());
                                        break;

                                      case 3:
                                        pUDef1 = SBMLImporter::getSBMLUnitDefinitionForId("volume", pSBMLDocument->getModel());
                                        break;

                                      default:
                                        CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 82 , pCompartment->getId().c_str());
                                        break;
                                    }
                                }
                            }

                          if (pUDef1 != NULL && pUDef2 != NULL)
                            {
                              // compare the two unit definitions
                              if (!SBMLImporter::areSBMLUnitDefinitionsIdentical(pUDef1, pUDef2))
                                {
                                  // add the species to bad species
                                  badSpecies.insert(pSBMLSpecies->getId());
                                }
                            }

                          // delete the unit definitions
                          if (pUDef1 != NULL)
                            {
                              delete pUDef1;
                            }

                          if (pUDef2 != NULL)
                            {
                              delete pUDef2;
                            }
                        }
                    }
                }

              ++it;
            }

          if (!badSpecies.empty())
            {
              // create the incompatibility message
              std::ostringstream os;
              std::set<std::string>::const_iterator sit = badSpecies.begin(), sendit = badSpecies.end();

              while (sit != sendit)
                {
                  os << *sit << ", ";
                  ++sit;
                }

              result.push_back(SBMLIncompatibility(2, os.str().substr(0, os.str().size() - 2).c_str()));
            }
        }
    }
}

void CSBMLExporter::checkForEvents ( const CCopasiDataModel &  dataModel, std::vector< SBMLIncompatibility > &  result  )

staticprotected

Checks if the given datamodel contains events. This is called if SBML Level 1 is to be exported.

Definition at line 4552 of file CSBMLExporter.cpp.

References CModel::getEvents(), CCopasiDataModel::getModel(), and CCopasiVector< T >::size().

Referenced by createEvents(), and isModelSBMLL1Compatible().

{
  if (dataModel.getModel() != NULL && dataModel.getModel()->getEvents().size() > 0)
    {
      result.push_back(SBMLIncompatibility(7));
    }
}

void CSBMLExporter::checkForInitialAssignments ( const CCopasiDataModel &  dataModel, std::vector< SBMLIncompatibility > &  result  )

staticprotected

This method checks wether the given model contains any initial assignments.

This method checks whether the given model contains any initial assignments.

Definition at line 2887 of file CSBMLExporter.cpp.

References CCopasiVector< T >::begin(), CCopasiVector< T >::end(), CModel::getCompartments(), CModel::getMetabolites(), CCopasiDataModel::getModel(), and CModel::getModelValues().

Referenced by createSBMLDocument(), isModelSBMLL1Compatible(), and isModelSBMLL2V1Compatible().

{
  const CModel* pModel = dataModel.getModel();

  if (pModel != NULL)
    {
      // check for rules
      const CCopasiVectorNS<CCompartment>& compartments = pModel->getCompartments();
      CCopasiVectorNS<CCompartment>::const_iterator compIt = compartments.begin(), compEndit = compartments.end();

      while (compIt != compEndit)
        {
          if ((*compIt)->getInitialExpression() != "")
            {
              result.push_back(SBMLIncompatibility(5, "Compartment", (*compIt)->getObjectName().c_str()));
            }

          ++compIt;
        }

      const CCopasiVector<CMetab>& metabs = pModel->getMetabolites();

      CCopasiVector<CMetab>::const_iterator metabIt = metabs.begin(), metabEndit = metabs.end();

      while (metabIt != metabEndit)
        {
          if ((*metabIt)->getInitialExpression() != "")
            {
              result.push_back(SBMLIncompatibility(5, "Metabolite", (*metabIt)->getObjectName().c_str()));
            }

          ++metabIt;
        }

      const CCopasiVectorN<CModelValue>& parameters = pModel->getModelValues();

      CCopasiVectorN<CModelValue>::const_iterator mvIt = parameters.begin(), mvEndit = parameters.end();

      while (mvIt != mvEndit)
        {
          if ((*mvIt)->getInitialExpression() != "")
            {
              result.push_back(SBMLIncompatibility(5, "Parameter", (*mvIt)->getObjectName().c_str()));
            }

          ++mvIt;
        }
    }
}

void CSBMLExporter::checkForODESpeciesInNonfixedCompartment ( const CCopasiDataModel &  dataModel, std::vector< SBMLIncompatibility >  result  )

staticprotected

Checks wether the model contains a metabolite that is defined by an ODE expression and that is located in a variable volume. Since COPASI interprets the expression differntly from SBML, we can not correctly export this yet. See Bug 903.

Checks whether the model contains a metabolite that is defined by an ODE expression and that is located in a variable volume. Since COPASI interprets the expression differently from SBML, we can not correctly export this yet. See Bug 903.

Definition at line 2738 of file CSBMLExporter.cpp.

References CCopasiVector< T >::begin(), CCopasiVector< T >::end(), CModelEntity::FIXED, CModel::getMetabolites(), CCopasiDataModel::getModel(), CCopasiObject::getObjectName(), CModelEntity::getStatus(), and CModelEntity::ODE.

Referenced by isModelSBMLCompatible().

{
  const CModel* pModel = dataModel.getModel();
  const CCopasiVector<CMetab>& metabolites = pModel->getMetabolites();
  CCopasiVector<CMetab>::const_iterator it = metabolites.begin(), endit = metabolites.end();

  while (it != endit)
    {
      if ((*it)->getStatus() == CModelValue::ODE)
        {
          const CCompartment* pCompartment = (*it)->getCompartment();
          assert(pCompartment != NULL);

          if (pCompartment->getStatus() != CModelValue::FIXED)
            {
              result.push_back(SBMLIncompatibility(3, (*it)->getObjectName().c_str(), pCompartment->getObjectName().c_str()));
            }
        }

      ++it;
    }
}

void CSBMLExporter::checkForPiecewiseFunctions ( const CCopasiDataModel &  dataModel, std::vector< SBMLIncompatibility > &  result  )

staticprotected

Checks all expressions in the given datamodel for piecewise defined functions.

Definition at line 5531 of file CSBMLExporter.cpp.

References CModelEntity::ASSIGNMENT, createFunctionSetFromFunctionNames(), findDirectlyUsedFunctions(), findUsedFunctions(), CModel::getCompartments(), CModelEntity::getExpressionPtr(), CReaction::getFunction(), CCopasiRootContainer::getFunctionList(), CModel::getMetabolites(), CCopasiDataModel::getModel(), CModel::getModelValues(), CCopasiObject::getObjectName(), CModel::getReactions(), CEvaluationTree::getRoot(), CModelEntity::getStatus(), CModelEntity::ODE, and CCopasiVector< T >::size().

Referenced by checkForPiecewiseFunctions(), and isModelSBMLL1Compatible().

{
  std::set<std::string> usedFunctionNames;
  const CModel* pModel = dataModel.getModel();

  if (pModel == NULL) return;

  // go through all model entities and check assignments
  // we don't have to check initial assignment since those can not be exported
  // anyway
  const CModelEntity* pME = NULL;
  const CCopasiVectorNS<CCompartment>& compartments = pModel->getCompartments();
  size_t i, iMax = compartments.size();

  for (i = 0; i < iMax; ++i)
    {
      pME = compartments[i];

      if (pME->getStatus() == CModelEntity::ODE || pME->getStatus() == CModelEntity::ASSIGNMENT)
        {
          const CEvaluationTree* pTree = pME->getExpressionPtr();
          CSBMLExporter::findDirectlyUsedFunctions(pTree->getRoot(), usedFunctionNames);
          CSBMLExporter::checkForPiecewiseFunctions(*pTree->getRoot(), result, pME->getObjectName(), "rule for compartment");
        }
    }

  const CCopasiVector<CMetab>& metabolites = pModel->getMetabolites();

  iMax = metabolites.size();

  for (i = 0; i < iMax; ++i)
    {
      pME = metabolites[i];

      if (pME->getStatus() == CModelEntity::ODE || pME->getStatus() == CModelEntity::ASSIGNMENT)
        {
          const CEvaluationTree* pTree = pME->getExpressionPtr();
          CSBMLExporter::findDirectlyUsedFunctions(pTree->getRoot(), usedFunctionNames);
          CSBMLExporter::checkForPiecewiseFunctions(*pTree->getRoot(), result, pME->getObjectName(), "rule for metabolite");
        }
    }

  const CCopasiVectorN<CModelValue>& modelvalues = pModel->getModelValues();

  iMax = modelvalues.size();

  for (i = 0; i < iMax; ++i)
    {
      pME = modelvalues[i];

      if (pME->getStatus() == CModelEntity::ODE || pME->getStatus() == CModelEntity::ASSIGNMENT)
        {
          const CEvaluationTree* pTree = pME->getExpressionPtr();
          CSBMLExporter::findDirectlyUsedFunctions(pTree->getRoot(), usedFunctionNames);
          CSBMLExporter::checkForPiecewiseFunctions(*pTree->getRoot(), result, pME->getObjectName(), "rule for global parameter");
        }
    }

  // go through all reactions and check the function called in the kinetic
  // laws.
  CReaction* pReaction = NULL;
  const CCopasiVectorNS<CReaction>& reactions = pModel->getReactions();
  iMax = reactions.size();

  for (i = 0; i < iMax; ++i)
    {
      pReaction = reactions[i];

      if (pReaction->getFunction() != NULL)
        {
          CSBMLExporter::findDirectlyUsedFunctions(pReaction->getFunction()->getRoot(), usedFunctionNames);
        }
    }

  // check indirectly called functions
  std::set<CFunction*> directlyUsedFunctions = CSBMLExporter::createFunctionSetFromFunctionNames(usedFunctionNames, CCopasiRootContainer::getFunctionList());
  std::vector<CFunction*> functions = CSBMLExporter::findUsedFunctions(directlyUsedFunctions, CCopasiRootContainer::getFunctionList());
  std::vector<CFunction*>::const_iterator it = functions.begin(), endit = functions.end();

  while (it != endit)
    {
      CSBMLExporter::checkForPiecewiseFunctions(*(*it)->getRoot(), result, (*it)->getObjectName(), "function");
      ++it;
    }
}

void CSBMLExporter::checkForPiecewiseFunctions ( const CEvaluationNode &  node, std::vector< SBMLIncompatibility > &  result, const std::string &  objectName, const std::string &  objectType  )

staticprotected

Checks the given node and all it's children for the occurence of piecewise functions.

Definition at line 5617 of file CSBMLExporter.cpp.

References checkForPiecewiseFunctions(), CEvaluationNode::CHOICE, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), and CEvaluationNode::type().

{

  // no need to go through the children.
  // one incompatibility warning is enough
  if (CEvaluationNode::type(node.getType()) == CEvaluationNode::CHOICE)
    {
      result.push_back(SBMLIncompatibility(8, objectType.c_str(), objectName.c_str()));
    }
  else
    {
      // store the old size
      // if one error has been found, we can stop looking at the other
      // children
      size_t size = result.size();
      const CEvaluationNode* pChild = dynamic_cast<const CEvaluationNode*>(node.getChild());

      while (pChild != NULL && result.size() == size)
        {
          CSBMLExporter::checkForPiecewiseFunctions(*pChild, result, objectName, objectType);
          pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
        }
    }
}

void CSBMLExporter::checkForUnsupportedFunctionCalls ( const CCopasiDataModel &  dataModel, unsigned int  sbmlLevel, unsigned int  sbmlVersion, std::vector< SBMLIncompatibility > &  result  )

protected

This static methods checks, wether the model uses any function calls that can not be expressed in SBML like the random distribution functions.

This static methods checks, whether the model uses any function calls that can not be expressed in SBML like the random distribution functions.

Definition at line 2786 of file CSBMLExporter.cpp.

References createUnsupportedFunctionTypeSet(), CModelEntity::getExpressionPtr(), CModelEntity::getInitialExpressionPtr(), CCopasiObject::getObjectName(), CCopasiObject::getObjectType(), CEvaluationTree::getRoot(), mAssignmentVector, mInitialAssignmentVector, mODEVector, and mUsedFunctions.

Referenced by checkForUnsupportedFunctionCalls(), and isExpressionSBMLCompatible().

{
  // Fill the set of unsupported functions depending on the level and
  // version
  std::set<CEvaluationNodeFunction::SubType> unsupportedFunctionTypes = CSBMLExporter::createUnsupportedFunctionTypeSet(sbmlLevel);
  // check all metabolites,parameters and compartments
  // make sure the list of assignments and initial assignments is filled
  // before this function is called
  size_t i, iMax = mAssignmentVector.size();
  const CModelEntity* pME = NULL;

  for (i = 0; i < iMax; ++i)
    {
      pME = mAssignmentVector[i];
      assert(pME != NULL);

      if (pME != NULL)
        {
          checkForUnsupportedFunctionCalls(*pME->getExpressionPtr()->getRoot(), unsupportedFunctionTypes, result, std::string(pME->getObjectType() + " called \"" + pME->getObjectName() + "\""));
        }
    }

  // check ode rules
  iMax = mODEVector.size();

  for (i = 0; i < iMax; ++i)
    {
      pME = mODEVector[i];
      assert(pME != NULL);

      if (pME != NULL)
        {
          checkForUnsupportedFunctionCalls(*pME->getExpressionPtr()->getRoot(), unsupportedFunctionTypes, result, std::string(pME->getObjectType() + " called \"" + pME->getObjectName() + "\""));
        }
    }

  // check initial assignments
  iMax = mInitialAssignmentVector.size();

  for (i = 0; i < iMax; ++i)
    {
      pME = mInitialAssignmentVector[i];
      assert(pME != NULL);

      if (pME != NULL)
        {
          checkForUnsupportedFunctionCalls(*pME->getInitialExpressionPtr()->getRoot(), unsupportedFunctionTypes, result, std::string(pME->getObjectType() + " called \"" + pME->getObjectName() + "\""));
        }
    }

  // if we already have a list of used functions, we can go through this here
  // make sure the list of used function has been filled before this is
  // called
  iMax = mUsedFunctions.size();
  std::set<CFunction*>::iterator it = this->mUsedFunctions.begin(), endit = this->mUsedFunctions.end();

  while (it != endit)
    {
      assert(*it != NULL);

      if (*it != NULL)
        {
          checkForUnsupportedFunctionCalls(*(*it)->getRoot(), unsupportedFunctionTypes, result, std::string("function called \"" + (*it)->getObjectName() + "\""));
        }

      ++it;
    }
}

void CSBMLExporter::checkForUnsupportedFunctionCalls ( const CEvaluationNode &  node, const std::set< CEvaluationNodeFunction::SubType > &  unsupportedFunctions, std::vector< SBMLIncompatibility > &  result, const std::string &  objectDescription  )

staticprotected

This static methods checks recursively, whether the given CEvaluationNode constains any function calls that can not be expressed in SBML like the random distribution functions.

Definition at line 2861 of file CSBMLExporter.cpp.

References checkForUnsupportedFunctionCalls(), CEvaluationNode::FUNCTION, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getData(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::getType(), CEvaluationNode::subType(), and CEvaluationNode::type().

{
  if (CEvaluationNode::type(node.getType()) == CEvaluationNode::FUNCTION)
    {
      CEvaluationNodeFunction::SubType subtype = (CEvaluationNodeFunction::SubType)CEvaluationNode::subType(node.getType());

      if (unsupportedFunctions.find(subtype) != unsupportedFunctions.end())
        {
          result.push_back(SBMLIncompatibility(2, node.getData().c_str(), objectDescription.c_str()));
        }
    }

  const CEvaluationNode* pChild = dynamic_cast<const CEvaluationNode*>(node.getChild());

  while (pChild != NULL)
    {
      checkForUnsupportedFunctionCalls(*pChild, unsupportedFunctions, result, objectDescription);
      pChild = dynamic_cast<const CEvaluationNode*>(pChild->getSibling());
    }
}

void CSBMLExporter::checkForUnsupportedObjectReferences ( const CCopasiDataModel &  dataModel, unsigned int  sbmlLevel, unsigned int  sbmlVersion, std::vector< SBMLIncompatibility > &  result  )

protected

Checks all assignments (initial and transient) for references to objects that can not be exported to SBML.

Definition at line 2284 of file CSBMLExporter.cpp.

References CModelEntity::getExpressionPtr(), CModelEntity::getInitialExpressionPtr(), CCopasiDataModel::getModel(), mAssignmentVector, mInitialAssignmentVector, mInitialValueMap, and mODEVector.

Referenced by isExpressionSBMLCompatible().

{
  // check all metabolites,parameters and compartments
  const CModel* pModel = dataModel.getModel();
  assert(pModel);

  if (pModel == NULL) return;

  size_t i, iMax = this->mAssignmentVector.size();
  const CModelEntity* pME;

  for (i = 0; i < iMax; ++i)
    {
      pME = this->mAssignmentVector[i];
      assert(pME != NULL);

      if (pME != NULL)
        {
          checkForUnsupportedObjectReferences(*pME->getExpressionPtr(), dataModel, sbmlLevel, sbmlVersion, result, false, &mInitialValueMap);
        }
    }

  // check ode rules
  iMax = this->mODEVector.size();

  for (i = 0; i < iMax; ++i)
    {
      pME = this->mODEVector[i];
      assert(pME != NULL);

      if (pME != NULL)
        {
          checkForUnsupportedObjectReferences(*pME->getExpressionPtr(), dataModel, sbmlLevel, sbmlVersion, result, false, &mInitialValueMap);
        }
    }

  // check initial assignments
  iMax = this->mInitialAssignmentVector.size();

  for (i = 0; i < iMax; ++i)
    {
      pME = this->mInitialAssignmentVector[i];
      assert(pME != NULL);

      if (pME != NULL)
        {
          checkForUnsupportedObjectReferences(*pME->getInitialExpressionPtr(), dataModel, sbmlLevel, sbmlVersion, result, false, &mInitialValueMap);
        }
    }
}

void CSBMLExporter::checkForUnsupportedObjectReferences ( const CEvaluationTree &  expression, const CCopasiDataModel &  dataModel, unsigned int  sbmlLevel, unsigned int  sbmlVersion, std::vector< SBMLIncompatibility > &  result, bool  initialExpression = false, std::map< const std::string, Parameter * > *  initialMap = NULL  )

staticprotected

Checks the given expression for references to objects that can not be exported to SBML.

Definition at line 2376 of file CSBMLExporter.cpp.

References addToInitialValueMap(), CCopasiDataModel::getModel(), CEvaluationTree::getNodeList(), CEvaluationNodeObject::getObjectCN(), CCopasiObject::getObjectName(), CCopasiObject::getObjectParent(), CCopasiObject::getObjectType(), CCopasiObject::isReference(), CEvaluationNode::OBJECT, CCopasiDataModel::ObjectFromName(), and CEvaluationNode::type().

{
  // SBML Level 1 and Level 2 Version 1 can have references to transient values of
  // compartments, metabolites and global parameters as well as time (model)

  // SBML Level 2 Version 2 and above can have the same references as level 1 plus references to
  // reaction fluxes.

  // Starting with COPASI Build 30 references to local parameters are allowed
  // as well because they are converted to global parameters
  const std::vector<CEvaluationNode*>& objectNodes = expr.getNodeList();
  size_t j, jMax = objectNodes.size();

  for (j = 0; j < jMax; ++j)
    {
      if (CEvaluationNode::type(objectNodes[j]->getType()) == CEvaluationNode::OBJECT)
        {
          const CEvaluationNodeObject* pObjectNode = dynamic_cast<const CEvaluationNodeObject*>(objectNodes[j]);
          assert(pObjectNode);

          if (pObjectNode == NULL) continue;

          std::vector<CCopasiContainer*> containers;
          containers.push_back(const_cast<CModel*>(dataModel.getModel()));
          const CCopasiObject* pObject =
            dataModel.ObjectFromName(containers, pObjectNode->getObjectCN());
          assert(pObject);

          if (pObject->isReference())
            {
              const CCopasiObject* pObjectParent = pObject->getObjectParent();
              assert(pObjectParent);
              std::string typeString = pObjectParent->getObjectType();

              if (typeString == "Compartment")
                {
                  // must be a reference to the (transient) or initial volume
                  if (initialExpression == true)
                    {
                      if (pObject->getObjectName() != "InitialVolume")
                        {
                          result.push_back(SBMLIncompatibility(1, pObject->getObjectName().c_str(), "compartment", pObjectParent->getObjectName().c_str()));
                        }
                    }
                  else
                    {
                      if (pObject->getObjectName() == "InitialVolume"
                          && initialMap != NULL
                          && (sbmlLevel > 2 || (sbmlLevel == 2 && sbmlVersion > 1)))
                        {
                          // add new parameter for the initial value
                          addToInitialValueMap(initialMap, pObject, pObjectParent, sbmlLevel, sbmlVersion);
                        }
                      else if (pObject->getObjectName() != "Volume"
                               && pObject->getObjectName() != "Rate")
                        {
                          result.push_back(SBMLIncompatibility(1, pObject->getObjectName().c_str(), "compartment", pObjectParent->getObjectName().c_str()));
                        }
                    }
                }
              else if (typeString == "Metabolite")
                {
                  // must be a reference to the transient or initial concentration
                  if (initialExpression == true)
                    {
                      if (pObject->getObjectName() != "InitialConcentration" && pObject->getObjectName() != "InitialParticleNumber")
                        {
                          result.push_back(SBMLIncompatibility(1, pObject->getObjectName().c_str(), "metabolite", pObjectParent->getObjectName().c_str()));
                        }
                    }
                  else
                    {
                      if (pObject->getObjectName() == "InitialConcentration"
                          && initialMap != NULL
                          && (sbmlLevel > 2 || (sbmlLevel == 2 && sbmlVersion > 1)))
                        {
                          // add new parameter for the initial value
                          addToInitialValueMap(initialMap, pObject, pObjectParent, sbmlLevel, sbmlVersion);
                        }
                      else if (pObject->getObjectName() != "Concentration"
                               && pObject->getObjectName() != "ParticleNumber"
                               && pObject->getObjectName() != "Rate")
                        {

                          result.push_back(SBMLIncompatibility(1, pObject->getObjectName().c_str(), "metabolite", pObjectParent->getObjectName().c_str()));
                        }
                    }
                }
              else if (typeString == "ModelValue")
                {
                  // must be a reference to the transient or initial value
                  if (initialExpression == true)
                    {
                      if (pObject->getObjectName() != "InitialValue")
                        {
                          result.push_back(SBMLIncompatibility(1, pObject->getObjectName().c_str(), "parameter", pObjectParent->getObjectName().c_str()));
                        }
                    }
                  else
                    {
                      if (pObject->getObjectName() == "InitialValue"
                          && initialMap != NULL
                          && (sbmlLevel > 2 || (sbmlLevel == 2 && sbmlVersion > 1)))
                        {
                          // add new parameter for the initial value
                          addToInitialValueMap(initialMap, pObject, pObjectParent, sbmlLevel, sbmlVersion);
                        }
                      else if (pObject->getObjectName() != "Value"
                               && pObject->getObjectName() != "Rate")
                        {
                          result.push_back(SBMLIncompatibility(1, pObject->getObjectName().c_str(), "parameter", pObjectParent->getObjectName().c_str()));
                        }
                    }
                }
              else if (typeString == "Model")
                {
                  // must be a reference to the model time
                  if (pObject->getObjectName() != "Time")
                    {
                      result.push_back(SBMLIncompatibility(1, pObject->getObjectName().c_str(), "model", pObjectParent->getObjectName().c_str()));
                    }
                }
              else if (typeString == "Parameter")
                {
                  // must be a local parameter
                  if (pObject->getObjectName() != "Value")
                    {
                      result.push_back(SBMLIncompatibility(1, pObject->getObjectName().c_str(), "local parameter", pObjectParent->getObjectName().c_str()));
                    }
                }
              else
                {
                  if (sbmlLevel == 1 || (sbmlLevel == 2 && sbmlVersion == 1))
                    {
                      result.push_back(SBMLIncompatibility(10, pObject->getObjectName().c_str(), typeString.c_str(), pObjectParent->getObjectName().c_str()));
                    }
                  else
                    {
                      if (typeString == "Reaction")
                        {
                          if (pObject->getObjectName() != "Flux")
                            {
                              result.push_back(SBMLIncompatibility(1, pObject->getObjectName().c_str(), "reaction", pObjectParent->getObjectName().c_str()));
                            }
                        }
                    }
                }
            }
          else
            {
              // normally local parameters are referenced via their value and
              // not directly, so this code should never be called
              const CCopasiParameter* pLocalParameter = dynamic_cast<const CCopasiParameter*>(pObject);

              if (pLocalParameter == NULL)
                {
                  result.push_back(SBMLIncompatibility(1, "value", pObject->getObjectType().c_str() , pObject->getObjectName().c_str()));
                }
            }
        }
    }
}

void CSBMLExporter::collectIds ( const CCopasiDataModel &  dataModel, std::map< std::string, const SBase * > &  idMap  )

protected

This method goes through the given datamodel and collects all SBML ids.

Definition at line 7465 of file CSBMLExporter.cpp.

References CModel::getCompartments(), CModel::getEvents(), CCopasiRootContainer::getFunctionList(), CModel::getMetabolites(), CCopasiDataModel::getModel(), CModel::getModelValues(), CModel::getReactions(), CFunction::getSBMLId(), CModelEntity::getSBMLId(), CEvent::getSBMLId(), CReaction::getSBMLId(), CFunctionDB::loadedFunctions(), and CCopasiVector< T >::size().

Referenced by createSBMLDocument().

{
  size_t i, iMax = CCopasiRootContainer::getFunctionList()->loadedFunctions().size();
  std::string id;

  for (i = 0; i < iMax; ++i)
    {
      const CFunction* pFun = CCopasiRootContainer::getFunctionList()->loadedFunctions()[i];
      id = pFun->getSBMLId();

      if (!id.empty())
        {
          idMap.insert(std::pair<const std::string, const SBase*>(id, (const SBase*)NULL));
        }
    }

  const CModel* pModel = dataModel.getModel();

  id = pModel->getSBMLId();

  if (!id.empty())
    {
      idMap.insert(std::pair<const std::string, const SBase*>(id, (const SBase*)NULL));
    }

  iMax = pModel->getCompartments().size();

  for (i = 0; i < iMax; ++i)
    {
      const CCompartment* pObj = pModel->getCompartments()[i];
      id = pObj->getSBMLId();

      if (!id.empty())
        {
          idMap.insert(std::pair<const std::string, const SBase*>(id, (const SBase*)NULL));
        }
    }

  iMax = pModel->getMetabolites().size();

  for (i = 0; i < iMax; ++i)
    {
      const CMetab* pObj = pModel->getMetabolites()[i];
      id = pObj->getSBMLId();

      if (!id.empty())
        {
          idMap.insert(std::pair<const std::string, const SBase*>(id, (const SBase*)NULL));
        }
    }

  iMax = pModel->getModelValues().size();

  for (i = 0; i < iMax; ++i)
    {
      const CModelValue* pObj = pModel->getModelValues()[i];
      id = pObj->getSBMLId();

      if (!id.empty())
        {
          idMap.insert(std::pair<const std::string, const SBase*>(id, (const SBase*)NULL));
        }
    }

  iMax = pModel->getReactions().size();

  for (i = 0; i < iMax; ++i)
    {
      const CReaction* pObj = pModel->getReactions()[i];
      id = pObj->getSBMLId();

      if (!id.empty())
        {
          idMap.insert(std::pair<const std::string, const SBase*>(id, (const SBase*)NULL));
        }
    }

  iMax = pModel->getEvents().size();

  for (i = 0; i < iMax; ++i)
    {
      const CEvent* pObj = pModel->getEvents()[i];
      id = pObj->getSBMLId();

      if (!id.empty())
        {
          idMap.insert(std::pair<const std::string, const SBase*>(id, (const SBase*)NULL));
        }
    }
}

static void CSBMLExporter::convert_to_l1v1 ( std::string &  l1v2_string )

staticprotected

Converts the SBML model given in SBML Level 1 Version 2 format to SBML Level 1 Version 1. The method basically removes the namespace attribute on the sbml element and changes the version from 2 to 1. It also renames all "species" elements to "specie". All other changes between SBML Level 1 Version 2 and Level 1 Version 1 should not be relevant here.

Referenced by exportModelToString().

ASTNode * CSBMLExporter::convertASTTreeToLevel1 ( const ASTNode *  pNode, const ListOfFunctionDefinitions &  functions, std::string &  message  )

staticprotected

Creates an ASTNode based tree where all occurences of nodes that are not supported in SBML Level 1 are replaced by supported constructs. On error an exception is created. The caller is responsible for freeing the memory of the returned object.

Definition at line 5507 of file CSBMLExporter.cpp.

References create_expression(), CCopasiMessage::EXCEPTION, MCSBML, and replaceL1IncompatibleNodes().

Referenced by convertToLevel1().

{
  ASTNode* pExpanded = create_expression(pNode, &functions);

  if (pExpanded != NULL)
    {
      ASTNode* pReplaced = CSBMLExporter::replaceL1IncompatibleNodes(pExpanded);
      delete pExpanded;

      if (pReplaced == NULL)
        {
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 62, message.c_str());
        }

      pExpanded = pReplaced;
    }
  else
    {
      CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 61, message.c_str());
    }

  return pExpanded;
}

ASTNode * CSBMLExporter::convertToASTNode ( const CEvaluationNode *  pOrig, CCopasiDataModel &  dataModel  )

protected

This converts an CEvaluationNode based tree to an ASTNode tree. It makes sure that all functions used in function calls already have a unique SBML id.

Definition at line 7078 of file CSBMLExporter.cpp.

References adjustNames(), mIdMap, mpSBMLDocument, pResult, setFunctionSBMLIds(), and CEvaluationNode::toAST().

Referenced by createEvent(), createFunctionDefinition(), createInitialAssignment(), createKineticLaw(), createRule(), and exportEventAssignments().

{
  // first go through the tree and check that all function calls are to
  // functions that have an SBML id
  // if they don't, we have to set one
  this->setFunctionSBMLIds(pOrig, dataModel);
  ASTNode* pResult = pOrig->toAST(&dataModel);

  adjustNames(pResult, mpSBMLDocument, mIdMap);

  return pResult;
}

void CSBMLExporter::convertToLevel1 ( )

protected

This method takes care of expanding all function calls in all expressions and converting functions that are not supported in Level 1 as well as constants that were not supported in Level 1

Definition at line 5230 of file CSBMLExporter.cpp.

References convertASTTreeToLevel1(), fatalError, mExportedFunctions, and mpSBMLDocument.

Referenced by createSBMLDocument().

{
  // expand all function calls in rules, events and
  // kinetic laws and delete the functions
  // initial assignments do not need to be considered since they can not be
  // exported to Level 1 anyway
  //
  // checking of the resulting expressions for piecewise functions
  // is done in the convertASTTreeToLevel1 method
  if (this->mpSBMLDocument == NULL) return;

  Model* pModel = this->mpSBMLDocument->getModel();
  Rule* pRule = NULL;
  Reaction* pReaction = NULL;
  KineticLaw* pLaw = NULL;
  unsigned int i, iMax = pModel->getNumRules();

  for (i = 0; i < iMax; ++i)
    {
      pRule = pModel->getRule(i);
      assert(pRule != NULL);
      const ASTNode* pMath = pRule->getMath();
      assert(pMath != NULL);
      std::string message = "rule for object with id \"";
      message += pRule->getVariable();
      message += "\"";
      ASTNode* pNewMath = CSBMLExporter::convertASTTreeToLevel1(pMath, this->mExportedFunctions, message);
      assert(pNewMath != NULL);

      if (pNewMath != NULL)
        {
          pRule->setMath(pNewMath);
          delete pNewMath;
        }
    }

  iMax = pModel->getNumReactions();

  for (i = 0; i < iMax; ++i)
    {
      pReaction = pModel->getReaction(i);
      assert(pReaction != NULL);
      pLaw = pReaction->getKineticLaw();

      // maybe we don't have a kinetic law for all reactions
      if (pLaw != NULL)
        {
          const ASTNode* pMath = pLaw->getMath();
          assert(pMath != NULL);
          std::string message = "kinetic law in reaction with id \"";
          message += pReaction->getId();
          message += "\"";
          ASTNode* pNewMath = CSBMLExporter::convertASTTreeToLevel1(pMath, this->mExportedFunctions, message);
          assert(pNewMath != NULL);

          if (pNewMath != NULL)
            {
              pLaw->setMath(pNewMath);
              delete pNewMath;
            }
          else
            {
              fatalError();
            }
        }
    }
}

void CSBMLExporter::createAreaUnit ( const CCopasiDataModel &  dataModel )

protected

Creates the volume unit for the SBML model.

Creates the area unit for the SBML model.

Definition at line 798 of file CSBMLExporter.cpp.

References SBMLImporter::areSBMLUnitDefinitionsIdentical(), CModel::cm, CModel::dimensionlessLength, CModel::dm, CCopasiMessage::EXCEPTION, CModel::fm, CModel::getAreaUnitEnum(), CCopasiDataModel::getModel(), INIT_DEFAULTS, CModel::m, CModel::microm, CModel::mm, mpSBMLDocument, mSBMLLevel, mSBMLVersion, CModel::nm, and CModel::pm.

Referenced by createUnits().

{
  if (dataModel.getModel() == NULL || this->mpSBMLDocument == NULL || this->mpSBMLDocument->getModel() == NULL) return;

  UnitDefinition uDef(this->mSBMLLevel, this->mSBMLVersion);
  uDef.setName("area");
  uDef.setId("area");
  Unit unit(this->mSBMLLevel, this->mSBMLVersion);
  INIT_DEFAULTS(unit);

  switch (dataModel.getModel()->getAreaUnitEnum())
    {
      case CModel::m:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(2);
        unit.setScale(0);
        break;

      case CModel::dm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(2);
        unit.setScale(-1);
        break;

      case CModel::cm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(2);
        unit.setScale(-2);
        break;

      case CModel::mm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(2);
        unit.setScale(-3);
        break;

      case CModel::microm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(2);
        unit.setScale(-6);
        break;

      case CModel::nm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(2);
        unit.setScale(-9);
        break;

      case CModel::pm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(2);
        unit.setScale(-12);
        break;

      case CModel::fm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(2);
        unit.setScale(-15);
        break;

      case CModel::dimensionlessLength:
        unit.setKind(UNIT_KIND_DIMENSIONLESS);
        unit.setExponent(1);
        unit.setScale(0);
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, "SBMLExporter Error: Unknown copasi area unit.");
        break;
    }

  unit.setMultiplier(1.0);
  uDef.addUnit(&unit);
  Model* pSBMLModel = this->mpSBMLDocument->getModel();
  UnitDefinition* pUdef = pSBMLModel->getUnitDefinition("area");

  if (pUdef != NULL)
    {
      // check if it is the same unit as the existing one if there is one
      // if yes, return, else replace the existing one
      if (!SBMLImporter::areSBMLUnitDefinitionsIdentical(pUdef, &uDef))
        {
          (*pUdef) = uDef;
        }
    }
  else
    {
      // only add it if it is not the default unit definition anyway
      if (this->mSBMLLevel > 2 ||
          unit.getKind() != UNIT_KIND_METRE ||
          unit.getScale() != 0 ||
          unit.getExponent() != 2 ||
          unit.getMultiplier() != 1.0)
        {
          // set the unit definition
          pSBMLModel->addUnitDefinition(&uDef);
        }
    }

// if we write an SBML L3 document, we have to explicitely set the units on the model
#if LIBSBML_VERSION >= 40100

  if (this->mSBMLLevel > 2)
    {
      pSBMLModel->setAreaUnits(uDef.getId());
    }

#endif // LIBSBML_VERSION
}

void CSBMLExporter::createCompartment ( CCompartment &  compartment )

protected

Creates the compartment for the given COPASI compartment.

Definition at line 928 of file CSBMLExporter.cpp.

References CModelEntity::ASSIGNMENT, createUniqueId(), fatalError, CCompartment::getDimensionality(), CModelEntity::getInitialExpression(), CModelEntity::getInitialValue(), CCopasiObject::getObjectName(), CModelEntity::getSBMLId(), CModelEntity::getStatus(), INIT_DEFAULTS, mAssignmentVector, mCOPASI2SBMLMap, mHandledSBMLObjects, mIdMap, mInitialAssignmentVector, mMetaIdMap, mODEVector, mpSBMLDocument, mSBMLLevel, CModelEntity::ODE, removeInitialAssignment(), removeRule(), CModelEntity::setSBMLId(), setSBMLNotes(), and updateMIRIAMAnnotation().

Referenced by createCompartments().

{
  Compartment* pSBMLCompartment = NULL;
  std::string sbmlId = compartment.getSBMLId();

  if (!sbmlId.empty())
    {
      pSBMLCompartment = this->mpSBMLDocument->getModel()->getCompartment(sbmlId);

      if (pSBMLCompartment == NULL)
        {
          pSBMLCompartment = this->mpSBMLDocument->getModel()->createCompartment();
          this->mCOPASI2SBMLMap[&compartment] = pSBMLCompartment;
          pSBMLCompartment->setId(sbmlId);
        }
    }
  else
    {
      pSBMLCompartment = this->mpSBMLDocument->getModel()->createCompartment();
      this->mCOPASI2SBMLMap[&compartment] = pSBMLCompartment;
      sbmlId = CSBMLExporter::createUniqueId(this->mIdMap, compartment.getObjectName(), false);
      compartment.setSBMLId(sbmlId);
      pSBMLCompartment->setId(sbmlId);
    }

  INIT_DEFAULTS((*pSBMLCompartment));

  this->mIdMap.insert(std::pair<const std::string, const SBase*>(sbmlId, pSBMLCompartment));
  this->mHandledSBMLObjects.insert(pSBMLCompartment);

  // don't call setName on level 1 objects because this will also
  // change the id
  if (this->mpSBMLDocument->getLevel() > 1)
    {
      pSBMLCompartment->setName(compartment.getObjectName().c_str());
    }

  pSBMLCompartment->setSpatialDimensions((unsigned int)compartment.getDimensionality());
  double value = compartment.getInitialValue();

  // if the value is NaN, unset the initial volume
  if (!isnan(value))
    {
      pSBMLCompartment->setVolume(value);
    }
  else
    {
      pSBMLCompartment->unsetVolume();
    }

  // fill assignment set
  // a compartment can either have an assignment or an initial assignment but not
  // both
  CModelEntity::Status status = compartment.getStatus();

  if (status == CModelEntity::ASSIGNMENT)
    {
      if (compartment.getDimensionality() != 0)
        {
          this->mAssignmentVector.push_back(&compartment);
          pSBMLCompartment->setConstant(false);
          removeInitialAssignment(pSBMLCompartment->getId());
        }
      else
        {
          fatalError();
        }
    }
  else if (status == CModelEntity::ODE)
    {
      if (compartment.getDimensionality() != 0)
        {
          this->mODEVector.push_back(&compartment);
          pSBMLCompartment->setConstant(false);

          if (compartment.getInitialExpression() != "")
            {
              this->mInitialAssignmentVector.push_back(&compartment);
            }
          else
            {
              removeInitialAssignment(pSBMLCompartment->getId());
            }
        }
      else
        {
          fatalError();
        }
    }
  else
    {
      // do this explicitly since we might handle an existing object from an
      // earlier import that had it attribute set already
      if (this->mSBMLLevel != 1)
        {
          pSBMLCompartment->setConstant(true);
        }
      else
        {
          // Level 1 does not know the constant flag and libsbmnl does not drop
          // it automatically
          pSBMLCompartment->setConstant(false);
        }

      removeRule(pSBMLCompartment->getId());

      // fill initial assignment set
      if (compartment.getInitialExpression() != "")
        {
          if (compartment.getDimensionality() != 0)
            {
              this->mInitialAssignmentVector.push_back(&compartment);
            }
          else
            {
              fatalError();
            }
        }
      else
        {
          removeInitialAssignment(pSBMLCompartment->getId());
        }
    }

  if (pSBMLCompartment != NULL)
    {
      CSBMLExporter::setSBMLNotes(pSBMLCompartment, &compartment);
    }

  if (pSBMLCompartment != NULL && mSBMLLevel == 3)
    {
      pSBMLCompartment->setUnits("volume");
    }

  CSBMLExporter::updateMIRIAMAnnotation(&compartment, pSBMLCompartment, this->mMetaIdMap);
}

void CSBMLExporter::createCompartments ( CCopasiDataModel &  dataModel )

protected

Creates the compartments for the model.

Definition at line 911 of file CSBMLExporter.cpp.

References CCopasiVector< T >::begin(), createCompartment(), CCopasiVector< T >::end(), CModel::getCompartments(), CCopasiDataModel::getModel(), and mpSBMLDocument.

Referenced by createSBMLDocument().

{
  // make sure the SBML Document already exists and that it has a Model set
  if (dataModel.getModel() == NULL || this->mpSBMLDocument == NULL || this->mpSBMLDocument->getModel() == NULL) return;

  CCopasiVectorNS<CCompartment>::const_iterator it = dataModel.getModel()->getCompartments().begin(), endit = dataModel.getModel()->getCompartments().end();

  while (it != endit)
    {
      createCompartment(**it);
      ++it;
    }
}

void CSBMLExporter::createEvent ( CEvent &  event, Event *  pSBMLEvent, CCopasiDataModel &  dataModel  )

protected

Creates an SBML Event for the given COPASI event.

Definition at line 4005 of file CSBMLExporter.cpp.

References convertExpression(), convertToASTNode(), createFunctionSetFromFunctionNames(), createUniqueId(), CCopasiMessage::EXCEPTION, exportEventAssignments(), findDirectlyUsedFunctions(), CEvent::getDelayAssignment(), CCopasiRootContainer::getFunctionList(), CEvaluationTree::getInfix(), CCopasiObject::getObjectName(), CEvaluationTree::getRoot(), CEvent::getSBMLId(), CEvaluationNode::getType(), CEvaluationNode::INVALID, isExpressionSBMLCompatible(), mCOPASI2SBMLMap, MCSBML, mIdMap, mIncompatibilities, mIncompleteExport, mInitialValueMap, mMetaIdMap, mpSBMLDocument, mSBMLLevel, mSBMLVersion, mUsedFunctions, outputIncompatibilities(), replace_local_parameters(), replaceSpeciesReferences(), CEvaluationTree::setInfix(), setSBMLNotes(), CEvaluationNode::type(), updateMIRIAMAnnotation(), and CCopasiMessage::WARNING.

Referenced by createEvents().

{
  // once events are functional, we create them here
  // don't forget to call replaceSpeciesReferences
  // on all mathematical expressions

  // first check if we already have a corresponding event from an earlier
  // import or export
  // if none is found, we create a new event object
  if (pSBMLEvent == NULL)
    {
      pSBMLEvent = this->mpSBMLDocument->getModel()->createEvent();
    }
  else
    {
      // Read the event to the model
      if (this->mpSBMLDocument->getModel()->getListOfEvents()->appendAndOwn(pSBMLEvent) != LIBSBML_OPERATION_SUCCESS)
        {
          // the existing event is not valid and cannot be added to the model, delete and create a new one instead
          delete pSBMLEvent;
          pSBMLEvent = this->mpSBMLDocument->getModel()->createEvent();
        }
    }

  // add the object to the COPASI2SBMLMap
  this->mCOPASI2SBMLMap[&event] = pSBMLEvent;

  // a)  we set the name and the id
  if (!pSBMLEvent->isSetId())
    {
      std::string sbmlId = CSBMLExporter::createUniqueId(this->mIdMap, event.getObjectName(), false);
      this->mIdMap.insert(std::pair<const std::string, const SBase*>(sbmlId, pSBMLEvent));
      pSBMLEvent->setId(sbmlId);
      event.setSBMLId(sbmlId);
    }

  // The attribute 'useValuesfromTriggerTime' is mandatory in L3V1
  if (this->mSBMLLevel > 2)
    {
      pSBMLEvent->setUseValuesFromTriggerTime(event.getDelayAssignment());
    }

#if LIBSBML_VERSION >= 40200

  // if the event came from an SBML L3 model, we have to make sure that the
  // priority is not set when we export the event, otherwise the exported model
  // and the COPASI model will not behave the same.
  if (this->mSBMLLevel > 2)
    {
      pSBMLEvent->setPriority(NULL);
    }

#endif  // LIBSBML_VERSION >= 40200

  // if the name doesn't consists of whitespace only, we set the name
  if (event.getObjectName().find_first_not_of("\t\r\n ") != std::string::npos)
    {
      pSBMLEvent->setName(event.getObjectName());
    }

  // b) we check the trigger expression and export the trigger
  const CExpression* pExpression = event.getTriggerExpressionPtr();
  assert(pExpression != NULL);
  std::vector<SBMLIncompatibility> result;
  CSBMLExporter::isExpressionSBMLCompatible(*pExpression
      , dataModel
      , this->mSBMLLevel
      , this->mSBMLVersion
      , result
      , std::string("event trigger for event with id\"+" + event.getSBMLId() + "\"")
      , false
      , &mInitialValueMap);

  // collect directly used functions
  if (result.empty())
    {
      std::set<std::string> directlyUsedFunctionNames;
      CSBMLExporter::findDirectlyUsedFunctions(pExpression->getRoot(), directlyUsedFunctionNames);
      std::set<CFunction*> usedFunctions = CSBMLExporter::createFunctionSetFromFunctionNames(directlyUsedFunctionNames, CCopasiRootContainer::getFunctionList());

# if defined _MSC_VER && _MSC_VER < 1201 // 1200 Identifies Visual C++ 6.0
      {
        std::set<CFunction*>::const_iterator it = usedFunctions.begin();
        std::set<CFunction*>::const_iterator end = usedFunctions.end();

        for (; it != end; ++it)
          this->mUsedFunctions.insert(*it);
      }
#else
      this->mUsedFunctions.insert(usedFunctions.begin(), usedFunctions.end());
#endif
    }
  else
    {
      this->mIncompatibilities.insert(this->mIncompatibilities.end(), result.begin(), result.end());

      if (!this->mIncompleteExport)
        {
          this->outputIncompatibilities();
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 60, "trigger expression", "event", event.getObjectName().c_str());
        }
    }

  const std::string& changedExpression = convertExpression(pExpression->getInfix(), mInitialValueMap);

  CEvaluationTree tree;

  tree.setInfix(changedExpression);

  const CEvaluationNode* pOrigNode = tree.getRoot();

  //const CEvaluationNode* pOrigNode = pExpression->getRoot();

  if (CEvaluationNode::type(pOrigNode->getType()) == CEvaluationNode::INVALID)
    {
      CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 70, "trigger", "event", event.getObjectName().c_str());
    }

  // the next few lines replace references to species depending on whether
  // it is a reference to an amount or a reference to a concentration.
  // Other factors that influence this replacement are if the model
  // contains variable volumes or if the quantity units are set to CModel::number
  pOrigNode = this->replaceSpeciesReferences(pOrigNode, dataModel);
  assert(pOrigNode != NULL);
  ASTNode* pNode = this->convertToASTNode(pOrigNode, dataModel);
  delete pOrigNode;
  // convert local parameters that are referenced in an expression to global
  // parameters
  this->replace_local_parameters(pNode, dataModel);

  if (pNode != NULL)
    {
      Trigger* pTrigger = pSBMLEvent->createTrigger();
      pTrigger->setMath(pNode);
#if LIBSBML_VERSION >= 40200

      // we need to make sure that the initial value of the trigger is set to true
      // as well as the persistent flag
      // for L3 event because otherwise the exported model will not do the same as
      // the model in COPASI
      if (this->mSBMLLevel > 2)
        {
          pTrigger->setInitialValue(true);
          pTrigger->setPersistent(true);
        }

#endif  // LIBSBML_VERSION >= 40200
      delete pNode;
    }
  else
    {
      if (this->mIncompleteExport != true)
        {
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 60, "trigger", "event", event.getObjectName().c_str());
        }
    }

  // c) we check the delay expression and export it if it is set
  pExpression = event.getDelayExpressionPtr();
  const std::string delayInfix = pExpression == NULL ? "" : pExpression->getInfix();

  if (!delayInfix.empty())
    {
      result.clear();
      CSBMLExporter::isExpressionSBMLCompatible(*pExpression
          , dataModel
          , this->mSBMLLevel
          , this->mSBMLVersion
          , result
          , std::string("event delay for event with id\"+" + event.getSBMLId() + "\"").c_str()
          , false
          , &mInitialValueMap);

      // collect directly used functions
      if (result.empty())
        {
          std::set<std::string> directlyUsedFunctionNames;
          CSBMLExporter::findDirectlyUsedFunctions(pExpression->getRoot(), directlyUsedFunctionNames);
          std::set<CFunction*> usedFunctions = CSBMLExporter::createFunctionSetFromFunctionNames(directlyUsedFunctionNames, CCopasiRootContainer::getFunctionList());

# if defined _MSC_VER && _MSC_VER < 1201 // 1200 Identifies Visual C++ 6.0
          {
            it = usedFunctions.begin();
            usedFunctions.end();

            for (; it != end; ++it)
              this->mUsedFunctions.insert(*it);
          }
#else
          this->mUsedFunctions.insert(usedFunctions.begin(), usedFunctions.end());
#endif
        }
      else
        {
          this->mIncompatibilities.insert(this->mIncompatibilities.end(), result.begin(), result.end());

          if (!this->mIncompleteExport)
            {
              this->outputIncompatibilities();
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 60, "delay expression", "event", event.getObjectName().c_str());
            }
        }

      //pOrigNode = pExpression->getRoot();
      const std::string& changedExpression = convertExpression(pExpression->getInfix(), mInitialValueMap);
      CEvaluationTree tree;
      tree.setInfix(changedExpression);
      const CEvaluationNode* pOrigNode = tree.getRoot();

      if (CEvaluationNode::type(pOrigNode->getType()) == CEvaluationNode::INVALID)
        {
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 70, "delay", "event", event.getObjectName().c_str());
        }

      // the next few lines replace references to species depending on whether
      // it is a reference to an amount or a reference to a concentration.
      // Other factors that influence this replacement are if the model
      // contains variable volumes or if the quantity units are set to CModel::number
      pOrigNode = this->replaceSpeciesReferences(pOrigNode, dataModel);
      assert(pOrigNode != NULL);
      pNode = this->convertToASTNode(pOrigNode, dataModel);
      delete pOrigNode;
      // convert local parameters that are referenced in an expression to global
      // parameters
      this->replace_local_parameters(pNode, dataModel);

      if (pNode != NULL)
        {
          Delay* pDelay = new Delay(this->mSBMLLevel, this->mSBMLVersion);
          pDelay->setMath(pNode);
          pSBMLEvent->setDelay(pDelay);
          delete pNode;
          delete pDelay;

          if (this->mSBMLLevel == 2 && this->mSBMLVersion >= 4)
            {
              pSBMLEvent->setUseValuesFromTriggerTime(event.getDelayAssignment());
            }
          // if the delayAssignment is set to false, we have a problem
          // because the model semantic changes on export
          else if (event.getDelayAssignment() == false &&
                   this->mSBMLLevel <= 2 &&
                   this->mSBMLVersion <= 3)
            {
              CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 77, event.getObjectName().c_str(), this->mSBMLLevel, this->mSBMLVersion);
            }
        }
      else
        {
          if (this->mIncompleteExport != true)
            {
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 60, "delay", "event", event.getObjectName().c_str());
            }
        }
    }

  // export all event assignments
  this->exportEventAssignments(event, pSBMLEvent, dataModel);

  // check if the event has event assignments, if not, we have to delete
  // the event and create an error message (for SBML Levels < 3)
  if (pSBMLEvent->getNumEventAssignments() == 0 && mpSBMLDocument->getLevel() < 3)
    {
      unsigned int i, iMax = this->mpSBMLDocument->getModel()->getNumEvents();

      // the following code does not check if the corrct pointer is found
      // but this should not be a problem
      for (i = 0; i < iMax; ++i)
        {
          if (this->mpSBMLDocument->getModel()->getEvent(i) == pSBMLEvent)
            {
              this->mpSBMLDocument->getModel()->getListOfEvents()->remove(i);
            }
        }

      delete pSBMLEvent;
      this->mCOPASI2SBMLMap.erase(&event);
      pSBMLEvent = NULL;

      CCopasiMessage(CCopasiMessage::WARNING, "The event '%s' contained no event assignments, this is only supported for SBML Level 3 onwards. The event has not been exported.", event.getObjectName().c_str());
    }

  if (pSBMLEvent != NULL)
    {
      CSBMLExporter::setSBMLNotes(pSBMLEvent, &event);
      CSBMLExporter::updateMIRIAMAnnotation(&event, pSBMLEvent, this->mMetaIdMap);
    }
}

void CSBMLExporter::createEvents ( CCopasiDataModel &  dataModel )

protected

Creates the events for the given data model.

Definition at line 3938 of file CSBMLExporter.cpp.

References CCopasiVector< T >::begin(), checkForEvents(), createEvent(), CCopasiVector< T >::end(), CModel::getEvents(), CCopasiDataModel::getModel(), mCOPASI2SBMLMap, mIncompatibilities, mpSBMLDocument, and mSBMLLevel.

Referenced by createSBMLDocument().

{
  if (this->mSBMLLevel == 1)
    {
      CSBMLExporter::checkForEvents(dataModel, this->mIncompatibilities);
      return;
    }

  // bail early
  if (dataModel.getModel() == NULL)
    return;

  Model* pSBMLModel = this->mpSBMLDocument->getModel();

  if (pSBMLModel == NULL)
    return;

  // remove all events from the SBML model and put them in a set
  std::set<Event*> eventSet;

  while (pSBMLModel->getNumEvents() != 0)
    {
      Event* pEvent = pSBMLModel->getListOfEvents()->remove(pSBMLModel->getNumEvents() - 1);
      assert(pEvent != NULL);
      eventSet.insert(pEvent);
    }

  const CCopasiVectorN<CEvent>& events = dataModel.getModel()->getEvents();

  CCopasiVectorN<CEvent>::const_iterator it = events.begin(), endit = events.end();

  Event* pSBMLEvent = NULL;

  std::map<const CCopasiObject*, SBase*>::const_iterator pos;

  while (it != endit)
    {
      // find the old event if there is one
      pos = this->mCOPASI2SBMLMap.find(*it);

      if (pos != this->mCOPASI2SBMLMap.end())
        {
          pSBMLEvent = dynamic_cast<Event*>(pos->second);
        }
      else
        {
          pSBMLEvent = NULL;
        }

      // remove the event from the set
      if (pSBMLEvent) eventSet.erase(pSBMLEvent);

      this->createEvent(**it, pSBMLEvent, dataModel);
      ++it;
    }

  // make sure events that have already been deleted do not get
  // exported
  std::set<Event*>::iterator it2 = eventSet.begin(), endit2 = eventSet.end();

  while (it2 != endit2)
    {
      delete *it2;
      ++it2;
    }
}

void CSBMLExporter::createFunctionDefinition ( CFunction &  function, CCopasiDataModel &  dataModel  )

protected

Create the SBML function definition from the given COPASI function.

Definition at line 3107 of file CSBMLExporter.cpp.

References convertToASTNode(), createUniqueId(), CCopasiMessage::EXCEPTION, isExpressionSBMLCompatible(), isValidSId(), mCOPASI2SBMLMap, MCSBML, mExportedFunctions, mFunctionMap, mIdMap, mIncompatibilities, mMetaIdMap, mpSBMLDocument, mSBMLLevel, mSBMLVersion, setSBMLNotes(), CFunctionParameters::size(), updateMIRIAMAnnotation(), and CCopasiMessage::WARNING.

Referenced by createFunctionDefinitions().

{
  // check the expression
  std::map<const CCopasiObject*, SBase*>::iterator pos = this->mCOPASI2SBMLMap.find(&function);
  FunctionDefinition* pFunDef = NULL;

  // the entry could be NULL when exporting to L2 first and then to L3 because the
  // SBMLExporter::collectIds will add a NULL entry into the id table which will be
  // tranferred to the COPASI2SBMLMap.
  if (pos != this->mCOPASI2SBMLMap.end() && pos->second != NULL)
    {
      pFunDef = dynamic_cast<FunctionDefinition*>(pos->second);
      assert(pFunDef);
      this->mpSBMLDocument->getModel()->getListOfFunctionDefinitions()->appendAndOwn(pFunDef);
    }
  else
    {
      if (this->mpSBMLDocument->getLevel() == 1)
        {
          pFunDef = new FunctionDefinition(2, 4);
        }
      else
        {
          pFunDef = new FunctionDefinition(this->mpSBMLDocument->getLevel(), this->mpSBMLDocument->getVersion());
        }

      this->mFunctionMap[pFunDef] = &function;
      pFunDef->setName(function.getObjectName());
      std::string id = function.getSBMLId();

      if (id.empty())
        {
          id = function.getObjectName();

          if (CSBMLExporter::isValidSId(id))
            {
              if (this->mIdMap.find(id) != this->mIdMap.end())
                {
                  id = CSBMLExporter::createUniqueId(this->mIdMap, id, true);
                }
            }
          else
            {
              id = CSBMLExporter::createUniqueId(this->mIdMap, function.getObjectName(), false);
            }
        }

      this->mIdMap.insert(std::pair<const std::string, const SBase*>(id, pFunDef));
      pFunDef->setId(id);
      function.setSBMLId(id);
      this->mCOPASI2SBMLMap[&function] = pFunDef;
    }

  if (function.getRoot() == NULL)
    {
      std::string errorMessage = std::string("Can not export function '");
      errorMessage += function.getObjectName();
      errorMessage += std::string("'. Function does not have a valid root node.");
      CCopasiMessage(CCopasiMessage::EXCEPTION, errorMessage.c_str());
    }
  else
    {
      std::vector<SBMLIncompatibility> result;
      CSBMLExporter::isExpressionSBMLCompatible(function, dataModel, this->mSBMLLevel, this->mSBMLVersion, result, std::string("function with name \"" + function.getObjectName() + "\"").c_str());

      if (result.empty())
        {
          ASTNode* pFunNode = this->convertToASTNode(function.getRoot(), dataModel);
          // go through the AST tree and replace all function call nodes with with a call to the sbml id
          ASTNode* pLambda = new ASTNode(AST_LAMBDA);
          // add the parameters to the function definition
          const CFunctionParameters& funParams = function.getVariables();
          size_t i, iMax = funParams.size();
          ASTNode* pParamNode = NULL;

          for (i = 0; i < iMax; ++i)
            {
              pParamNode = new ASTNode(AST_NAME);
              pParamNode->setName(funParams[i]->getObjectName().c_str());
              pLambda->addChild(pParamNode);
            }

          pLambda->addChild(pFunNode);

          if (pFunDef->setMath(pLambda) != LIBSBML_OPERATION_SUCCESS)
            {
              CCopasiMessage(CCopasiMessage::WARNING,
                             "The function '%s' uses an invalid expression '%s' that cannot be exported to SBML, the function definition is not exported."
                             , function.getObjectName().c_str()
                             , function.getInfix().c_str());
            }

          this->mExportedFunctions.appendAndOwn(pFunDef);
          delete pLambda;
        }
      else
        {
          this->mIncompatibilities.insert(this->mIncompatibilities.end(), result.begin(), result.end());
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 28, function.getObjectName().c_str());
        }
    }

  if (pFunDef != NULL)
    {
      CSBMLExporter::setSBMLNotes(pFunDef, &function);
    }

  CSBMLExporter::updateMIRIAMAnnotation(&function, pFunDef, this->mMetaIdMap);
}

void CSBMLExporter::createFunctionDefinitions ( CCopasiDataModel &  dataModel )

protected

Create all function definitions.

Definition at line 2940 of file CSBMLExporter.cpp.

References createFunctionDefinition(), fatalError, findUsedFunctions(), CCopasiRootContainer::getFunctionList(), CCopasiObject::getObjectName(), mCOPASI2SBMLMap, mExportedFunctions, mFunctionMap, mpSBMLDocument, and mUsedFunctions.

Referenced by createSBMLDocument().

{
  this->mExportedFunctions.clear(true);
  this->mFunctionMap.clear();
  // make sure the list of used functions is filled before this is
  // called
  // make sure the mCOPASI2SBMLMap is up to date

  // find all indirectly called functions
  std::vector<CFunction*> usedFunctions = findUsedFunctions(this->mUsedFunctions, CCopasiRootContainer::getFunctionList());
  this->mUsedFunctions.clear();
  this->mUsedFunctions.insert(usedFunctions.begin(), usedFunctions.end());

  // remove the function calls that have been created by copasi solely for use
  // as a kinetic law term if it is no longer needed
  Model* pModel = this->mpSBMLDocument->getModel();
  assert(pModel);

  if (pModel == NULL) fatalError();

  std::map<SBase*, const CCopasiObject*> sbml2copasiMap;
  std::map<const CCopasiObject*, SBase*>::iterator mapIt = this->mCOPASI2SBMLMap.begin();
  std::map<const CCopasiObject*, SBase*>::iterator mapEndit = this->mCOPASI2SBMLMap.end();

  while (mapIt != mapEndit)
    {
      sbml2copasiMap.insert(std::make_pair(mapIt->second, mapIt->first));
      ++mapIt;
    }

  std::set<CFunction*> unusedFunctions;
  unsigned int i = 0, iMax = pModel->getNumFunctionDefinitions();
  std::map<SBase*, const CCopasiObject*>::iterator mapPos;
  std::set<std::string> toRemove;

  while (i < iMax)
    {
      FunctionDefinition* pFunDef = pModel->getFunctionDefinition(i);

      if (pFunDef != NULL)
        {
          mapPos = sbml2copasiMap.find(pFunDef);

          if (mapPos != sbml2copasiMap.end())
            {
              CFunction* pFun = dynamic_cast<CFunction*>(const_cast<CCopasiObject*>(mapPos->second));

              if (pFun != NULL && this->mUsedFunctions.find(pFun) == this->mUsedFunctions.end())
                {
                  // the function exists in the model, but it is not used in any
                  // expression
                  if (pFun->getObjectName().find("function_4_") == 0 || pFun->getObjectName().find("Function for ") == 0)
                    {
                      // store the function definition that is to be removed
                      toRemove.insert(pFunDef->getId());
                    }
                  else
                    {
                      // those need to be stored in a separate list since we also
                      // need to find indirectly called functions
                      unusedFunctions.insert(pFun);
                    }
                }
            }
        }

      ++i;
    }

  // find all indirectly called functions for the unused functions
  std::vector<CFunction*> functionsVect = findUsedFunctions(unusedFunctions, CCopasiRootContainer::getFunctionList());
  usedFunctions.insert(usedFunctions.end(), functionsVect.begin(), functionsVect.end());
  // reset the used functions set
  this->mUsedFunctions.clear();
  this->mUsedFunctions.insert(usedFunctions.begin(), usedFunctions.end());

  // now we remove the function definitions from the SBML model
  std::set<std::string>::iterator toRemoveIt = toRemove.begin();
  std::set<std::string>::iterator toRemoveEndit = toRemove.end();

  while (toRemoveIt != toRemoveEndit)
    {
      FunctionDefinition* pFunDef = pModel->getFunctionDefinition(*toRemoveIt);

      if (pFunDef != NULL)
        {
          mapPos = sbml2copasiMap.find(pFunDef);

          if (mapPos != sbml2copasiMap.end() &&
              this->mUsedFunctions.find(dynamic_cast<CFunction*>(const_cast<CCopasiObject*>(mapPos->second))) == this->mUsedFunctions.end())
            {
              pModel->getListOfFunctionDefinitions()->remove(*toRemoveIt);
            }
        }

      ++toRemoveIt;
    }

  // order the remaining function definitions
  // remove duplicates from the vector, always keep the last one
  std::vector<CFunction*>::reverse_iterator reverseIt = usedFunctions.rbegin(), reverseEndit = usedFunctions.rend();
  functionsVect.clear();

  while (reverseIt != reverseEndit)
    {
      if (std::find(functionsVect.begin(), functionsVect.end(), *reverseIt) == functionsVect.end())
        {
          functionsVect.insert(functionsVect.begin(), *reverseIt);
        }

      ++reverseIt;
    }

  // remove all existing function definitions from the list
  // and remove their entries from the copasi2sbmlmap
  iMax = pModel->getNumFunctionDefinitions();

  for (unsigned int i = 0; i < iMax; ++i)
    {
      mapIt = this->mCOPASI2SBMLMap.begin();
      mapEndit = this->mCOPASI2SBMLMap.end();

      while (mapIt != mapEndit)
        {
          if (mapIt->second == pModel->getFunctionDefinition(i))
            {
              this->mCOPASI2SBMLMap.erase(mapIt->first);
              break;
            }

          ++mapIt;
        }
    }

  // don't want to remove the new custom function definitions if present
  // pModel->getListOfFunctionDefinitions()->clear(true);
  for (int i = ((int)pModel->getNumFunctionDefinitions()) - 1; i >= 0; --i)
    {
      FunctionDefinition* current = pModel->getFunctionDefinition(i);

      if (current != NULL &&
          current->isSetAnnotation() &&
          current->getAnnotation()->getNumChildren() == 1 &&
          current->getAnnotation()->getChild(0).getURI().find("http://sbml.org/annotations/") != std::string::npos)
        continue;

      // if we are here it is not one of the custom ones, so delete it
      FunctionDefinition* toDelete = pModel->removeFunctionDefinition(i);
      delete toDelete;
    }

  std::vector<CFunction*>::iterator it = functionsVect.begin(), endit = functionsVect.end();

  while (it != endit)
    {
      if (*it != NULL)
        {
          createFunctionDefinition(**it, dataModel);
        }

      ++it;
    }
}

const std::set< CFunction * > CSBMLExporter::createFunctionSetFromFunctionNames ( const std::set< std::string > &  names, CFunctionDB *  pFunDB  )

staticprotected

Definition at line 5054 of file CSBMLExporter.cpp.

References CCopasiMessage::ERROR, CFunctionDB::findFunction(), and MCSBML.

Referenced by checkForPiecewiseFunctions(), createEvent(), createInitialAssignment(), createRule(), exportEventAssignments(), and findUsedFunctions().

{
  std::set<CFunction*> result;

  if (pFunDB != NULL)
    {
      std::set<std::string>::const_iterator it = names.begin();
      std::set<std::string>::const_iterator endit = names.end();
      CFunction* pFun = NULL;

      while (it != endit)
        {
          pFun = dynamic_cast<CFunction*>(pFunDB->findFunction(*it));

          if (pFun == NULL)
            {
              CCopasiMessage(CCopasiMessage::ERROR, MCSBML + 15, (*it).c_str());
            }
          else
            {
              result.insert(pFun);
            }

          ++it;
        }
    }

  return result;
}

const std::map< std::string, const SBase * > CSBMLExporter::createIdMap ( const Model &  sbmlModel )

protected

Goes through the given SBML model and puts all ids with the corresponding object into a map.

Definition at line 2075 of file CSBMLExporter.cpp.

{
  // go through all function definitions, compartments, species, reactions,
  // parameters and events and create a set with all used ids.
  std::map<std::string, const SBase*> idMap;
  unsigned int i, iMax;

  if (sbmlModel.isSetId())
    {
      idMap.insert(std::pair<const std::string, const SBase*>(sbmlModel.getId(), &sbmlModel));
    }

  if (sbmlModel.getListOfFunctionDefinitions()->isSetId())
    {
      idMap.insert(std::pair<const std::string, const SBase*>(sbmlModel.getListOfFunctionDefinitions()->getId(), sbmlModel.getListOfFunctionDefinitions()));
    }

  iMax = sbmlModel.getNumFunctionDefinitions();

  for (i = 0; i < iMax; ++i)
    {
      idMap.insert(std::pair<const std::string, const SBase*>(sbmlModel.getFunctionDefinition(i)->getId(), sbmlModel.getFunctionDefinition(i)));
    }

  if (sbmlModel.getListOfCompartments()->isSetId())
    {
      idMap.insert(std::pair<const std::string, const SBase*>(sbmlModel.getListOfCompartments()->getId(), sbmlModel.getListOfCompartments()));
    }

  iMax = sbmlModel.getNumCompartments();

  for (i = 0; i < iMax; ++i)
    {
      idMap.insert(std::pair<const std::string, const SBase*>(sbmlModel.getCompartment(i)->getId(), sbmlModel.getCompartment(i)));
    }

  if (sbmlModel.getListOfSpecies()->isSetId())
    {
      idMap.insert(std::pair<const std::string, const SBase*>(sbmlModel.getListOfSpecies()->getId(), sbmlModel.getListOfSpecies()));
    }

  iMax = sbmlModel.getNumSpecies();

  for (i = 0; i < iMax; ++i)
    {
      idMap.insert(std::pair<const std::string, const SBase*>(sbmlModel.getSpecies(i)->getId(), sbmlModel.getSpecies(i)));
    }

  if (sbmlModel.getListOfParameters()->isSetId())
    {
      idMap.insert(std::pair<const std::string, const SBase*>(sbmlModel.getListOfParameters()->getId(), sbmlModel.getListOfParameters()));
    }

  iMax = sbmlModel.getNumParameters();

  for (i = 0; i < iMax; ++i)
    {
      idMap.insert(std::pair<const std::string, const SBase*>(sbmlModel.getParameter(i)->getId(), sbmlModel.getParameter(i)));
    }

  if (sbmlModel.getListOfReactions()->isSetId())
    {
      idMap.insert(std::pair<const std::string, const SBase*>(sbmlModel.getListOfReactions()->getId(), sbmlModel.getListOfReactions()));
    }

  iMax = sbmlModel.getNumReactions();

  for (i = 0; i < iMax; ++i)
    {
      const Reaction* pReaction = sbmlModel.getReaction(i);

      if (pReaction != NULL)
        {
          idMap.insert(std::pair<const std::string, const SBase*>(pReaction->getId(), pReaction));

          if (pReaction->getListOfReactants()->isSetId())
            {
              idMap.insert(std::pair<const std::string, const SBase*>(pReaction->getListOfReactants()->getId(), pReaction->getListOfReactants()));
            }

          unsigned int j, jMax = pReaction->getNumReactants();
          const SpeciesReference* pSRef = NULL;

          for (j = 0; j < jMax; ++j)
            {
              pSRef = pReaction->getReactant(j);

              if (pSRef->isSetId())
                {
                  idMap.insert(std::pair<const std::string, const SBase*>(pSRef->getId(), pSRef));
                }
            }

          if (pReaction->getListOfProducts()->isSetId())
            {
              idMap.insert(std::pair<const std::string, const SBase*>(pReaction->getListOfProducts()->getId(), pReaction->getListOfProducts()));
            }

          jMax = pReaction->getNumProducts();

          for (j = 0; j < jMax; ++j)
            {
              pSRef = pReaction->getProduct(j);

              if (pSRef->isSetId())
                {
                  idMap.insert(std::pair<const std::string, const SBase*>(pSRef->getId(), pSRef));
                }
            }

          if (pReaction->getListOfModifiers()->isSetId())
            {
              idMap.insert(std::pair<const std::string, const SBase*>(pReaction->getListOfModifiers()->getId(), pReaction->getListOfModifiers()));
            }

          jMax = pReaction->getNumModifiers();
          const ModifierSpeciesReference* pModSRef;

          for (j = 0; j < jMax; ++j)
            {
              pModSRef = pReaction->getModifier(j);

              if (pModSRef->isSetId())
                {
                  idMap.insert(std::pair<const std::string, const SBase*>(pModSRef->getId(), pModSRef));
                }
            }
        }
    }

  if (sbmlModel.getListOfEvents()->isSetId())
    {
      idMap.insert(std::pair<const std::string, const SBase*>(sbmlModel.getListOfEvents()->getId(), sbmlModel.getListOfEvents()));
    }

  iMax = sbmlModel.getNumEvents();

  for (i = 0; i < iMax; ++i)
    {
      idMap.insert(std::pair<const std::string, const SBase*>(sbmlModel.getEvent(i)->getId(), sbmlModel.getEvent(i)));
    }

  // if COPASI is compiled with layout, we have to add those ids as well
  const LayoutModelPlugin* lmPlugin = (LayoutModelPlugin*)sbmlModel.getPlugin("layout");

  if (lmPlugin != NULL)
    {
      if (lmPlugin->getListOfLayouts()->isSetId())
        {
          idMap.insert(std::pair<const std::string, const SBase*>(lmPlugin->getListOfLayouts()->getId(), lmPlugin->getListOfLayouts()));
        }

      iMax = lmPlugin->getListOfLayouts()->size();

      for (i = 0; i < iMax; ++i)
        {
          const Layout* pLayout = lmPlugin->getLayout(i);

          if (pLayout != NULL)
            {
              if (pLayout->isSetId())
                {
                  idMap.insert(std::pair<const std::string, const SBase*>(pLayout->getId(), pLayout));
                }
            }
        }
    }

  return idMap;
}

void CSBMLExporter::createInitialAssignment ( const CModelEntity &  modelEntity, CCopasiDataModel &  dataModel  )

protected

Creates the initial assignment for the given COPASI model entity.

Definition at line 1673 of file CSBMLExporter.cpp.

References convertToASTNode(), createFunctionSetFromFunctionNames(), CCopasiMessage::EXCEPTION, findDirectlyUsedFunctions(), CMetab::getCompartment(), CCompartment::getDimensionality(), CCopasiRootContainer::getFunctionList(), CModelEntity::getInitialExpressionPtr(), CModelEntity::getInitialValueReference(), CCopasiObject::getObjectName(), CCopasiObject::getObjectType(), CEvaluationTree::getRoot(), CModelEntity::getSBMLId(), CEvaluationNode::getType(), CEvaluationNode::INVALID, isExpressionSBMLCompatible(), mCOPASI2SBMLMap, MCSBML, mHandledSBMLObjects, mIncompatibilities, mIncompleteExport, mInitialValueMap, mpSBMLDocument, mSBMLLevel, mSBMLVersion, multiplyByObject(), mUsedFunctions, outputIncompatibilities(), replace_local_parameters(), replaceSpeciesReferences(), and CEvaluationNode::type().

Referenced by createInitialAssignments().

{
  // check the expression
  std::vector<SBMLIncompatibility> result;
  CSBMLExporter::isExpressionSBMLCompatible(*modelEntity.getInitialExpressionPtr()
      , dataModel
      , this->mSBMLLevel
      , this->mSBMLVersion
      , result
      , std::string("initial expression for object named \"" + modelEntity.getObjectName() + "\"").c_str()
      , true
      , &mInitialValueMap);

  // collect directly used functions
  if (result.empty())
    {
      std::set<std::string> directlyUsedFunctionNames;
      CSBMLExporter::findDirectlyUsedFunctions(modelEntity.getInitialExpressionPtr()->getRoot(), directlyUsedFunctionNames);
      std::set<CFunction*> usedFunctions = CSBMLExporter::createFunctionSetFromFunctionNames(directlyUsedFunctionNames, CCopasiRootContainer::getFunctionList());

#if defined _MSC_VER && _MSC_VER < 1201 // 1200 Identifies Visual C++ 6.0
      {
        std::set<CFunction*>::const_iterator it = usedFunctions.begin();
        std::set<CFunction*>::const_iterator end = usedFunctions.end();

        for (; it != end; ++it)
          this->mUsedFunctions.insert(*it);
      }
#else
      this->mUsedFunctions.insert(usedFunctions.begin(), usedFunctions.end());
#endif

      // create the actual initial assignment
      InitialAssignment* pInitialAssignment = this->mpSBMLDocument->getModel()->getInitialAssignment(modelEntity.getSBMLId());

      if (pInitialAssignment == NULL)
        {
          pInitialAssignment = this->mpSBMLDocument->getModel()->createInitialAssignment();
          pInitialAssignment->setSymbol(modelEntity.getSBMLId());
        }

      // set the math
      this->mHandledSBMLObjects.insert(pInitialAssignment);
      const CEvaluationNode* pOrigNode = modelEntity.getInitialExpressionPtr()->getRoot();

      if (CEvaluationNode::type(pOrigNode->getType()) == CEvaluationNode::INVALID)
        {
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 70, "initial assignment", modelEntity.getObjectType().c_str(), modelEntity.getObjectName().c_str());
        }

      // the next few lines replace references to species depending on whether
      // it is a reference to an amount or a reference to a concentration.
      // Other factors that influence this replacement are if the model
      // contains variable volumes or if the quantity units are set to CModel::number
      pOrigNode = this->replaceSpeciesReferences(pOrigNode, dataModel);
      assert(pOrigNode != NULL);

      // check if the rule is for an amount species
      // if this is the case, we have to multiply the expression by the volume
      // of the compartment the species is in
      // create the actual rule
      const CMetab* pMetab = dynamic_cast<const CMetab*>(&modelEntity);

      if (pMetab != NULL)
        {
          std::map<const CCopasiObject*, SBase*>::const_iterator pos = this->mCOPASI2SBMLMap.find(&modelEntity);
          assert(pos != this->mCOPASI2SBMLMap.end());

          if (dynamic_cast<const Species*>(pos->second)->getHasOnlySubstanceUnits() == true)
            {
              const CCompartment* pCompartment = pMetab->getCompartment();

              if (pCompartment->getDimensionality() != 0)
                {
                  CEvaluationNode* pNode = CSBMLExporter::multiplyByObject(pOrigNode, pCompartment->getInitialValueReference());
                  assert(pNode != NULL);

                  if (pNode != NULL)
                    {
                      delete pOrigNode;
                      pOrigNode = pNode;
                    }
                }
            }
        }

      ASTNode* pNode = this->convertToASTNode(pOrigNode, dataModel);
      delete pOrigNode;
      // convert local parameters that are referenced in an expression to global
      // parameters
      this->replace_local_parameters(pNode, dataModel);

      if (pNode != NULL)
        {
          pInitialAssignment->setMath(pNode);
          delete pNode;
        }
      else
        {
          if (this->mIncompleteExport == true)
            {
              // remove the initial assignment from the SBML model
              unsigned int i = 0, iMax = this->mpSBMLDocument->getModel()->getNumInitialAssignments();

              while (i < iMax)
                {
                  if (this->mpSBMLDocument->getModel()->getInitialAssignment(i)->getSymbol() == modelEntity.getSBMLId())
                    {
                      this->mpSBMLDocument->getModel()->getListOfInitialAssignments()->remove(i);
                      break;
                    }

                  ++i;
                }
            }
          else
            {
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 60, "initial assignment", modelEntity.getObjectType().c_str(), modelEntity.getObjectName().c_str());
            }
        }
    }
  else
    {
      this->mIncompatibilities.insert(this->mIncompatibilities.end(), result.begin(), result.end());

      if (!this->mIncompleteExport)
        {
          this->outputIncompatibilities();
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 60, "initial assignment", modelEntity.getObjectType().c_str(), modelEntity.getObjectName().c_str());
        }
    }
}

void CSBMLExporter::createInitialAssignments ( CCopasiDataModel &  dataModel )

protected

Creates the initial assignments for the model.

Definition at line 1650 of file CSBMLExporter.cpp.

References createInitialAssignment(), and mInitialAssignmentVector.

Referenced by createSBMLDocument().

{
  // make sure the mInitialAssignmentVector has been filled already

  // create the initial assignments
  size_t i, iMax = this->mInitialAssignmentVector.size();
  const CModelEntity* pME = NULL;

  for (i = 0; i < iMax; ++i)
    {
      pME = mInitialAssignmentVector[i];
      assert(pME != NULL);

      if (pME != NULL)
        {
          createInitialAssignment(*pME, dataModel);
        }
    }
}

CEvaluationNode * CSBMLExporter::createKineticExpression ( CFunction *  pFun, const std::vector< std::vector< std::string > > &  arguments  )

protected

Creates an expression from a given node and a set of parameter mappings by replacing the function arguments with the parameters. static CEvaluationNode* createExpressionTree(const CEvaluationNode* const pNode, const std::map<std::string, std::string>& parameterMap, const CCopasiDataModel& dataModel); Creates an expression from a given function and a set of parameters by replacing the function arguments with the parameters. static CEvaluationNode* createExpressionTree(const CFunction* const pFun, const std::vector<std::vector<std::string> >& arguments, const CCopasiDataModel& dataModel); Create an expression that corresponds to a kinetic law. If the kinetic law was mass action, the expression is a mass action term , otherwise it is a function call.

Definition at line 4802 of file CSBMLExporter.cpp.

References CEvaluationNodeCall::addChild(), CEvaluationNodeObject::CN, createMassActionExpression(), fatalError, CEvaluationNodeCall::FUNCTION, CKeyFactory::get(), CCopasiObject::getCN(), CCopasiRootContainer::getKeyFactory(), CCopasiObject::getObjectName(), CEvaluationTree::getType(), CFunction::getVariables(), CFunction::isReversible(), CEvaluationTree::MassAction, mUsedFunctions, pResult, CFunctionParameters::size(), and TriTrue.

Referenced by createKineticLaw().

{
  if (!pFun || pFun->getVariables().size() != arguments.size()) fatalError();

  CEvaluationNode* pResult;

  if (pFun->getType() == CEvaluationTree::MassAction)
    {
      pResult = CSBMLExporter::createMassActionExpression(arguments, pFun->isReversible() == TriTrue);
    }
  else
    {
      CEvaluationNodeCall* pFunctionCall = new CEvaluationNodeCall(CEvaluationNodeCall::FUNCTION, pFun->getObjectName());
      this->mUsedFunctions.insert(pFun);
      size_t i, iMax = arguments.size();
      std::string cn;

      for (i = 0; i < iMax; ++i)
        {
          if (arguments[i].size() != 1) fatalError(); // we can't have arrays here.

          const CCopasiObject* pObject = CCopasiRootContainer::getKeyFactory()->get(arguments[i][0]);

          if (!pObject) fatalError();

          if (dynamic_cast<const CModel*>(pObject) != NULL)
            {
              cn = "<" + pObject->getCN() + ",Reference=Time>";
            }
          else if (dynamic_cast<const CCompartment*>(pObject) != NULL)
            {
              cn = "<" + pObject->getCN() + ",Reference=Volume>";
            }
          else if (dynamic_cast<const CMetab*>(pObject) != NULL)
            {
              cn = "<" + pObject->getCN() + ",Reference=Concentration>";
            }
          else if (dynamic_cast<const CModelValue*>(pObject) != NULL)
            {
              cn = "<" + pObject->getCN() + ",Reference=Value>";
            }
          else if (dynamic_cast<const CReaction*>(pObject) != NULL)
            {
              cn = "<" + pObject->getCN() + ",Reference=Flux>";
            }
          else if (dynamic_cast<const CCopasiParameter*>(pObject) != NULL)
            {
              // local parameter of a reaction
              // must set the node content to the SBML id if the parameter
              cn = "<" + pObject->getCN() + ">";
            }
          else
            {
              cn = "<" + pObject->getCN() + ">";
            }

          pFunctionCall->addChild(new CEvaluationNodeObject(CEvaluationNodeObject::CN, cn));
        }

      pResult = pFunctionCall;
    }

  return pResult;
}

KineticLaw * CSBMLExporter::createKineticLaw ( CReaction &  reaction, CCopasiDataModel &  dataModel, unsigned int  level, unsigned int  version  )

protected

Create the kinetic law for the given reaction. On failure NULL is returned.

Definition at line 4584 of file CSBMLExporter.cpp.

References convertToASTNode(), createKineticExpression(), fatalError, CKeyFactory::get(), CReaction::getChemEq(), CCopasiParameter::getCN(), CReaction::getCompartmentNumber(), CCompartment::getDimensionality(), CReaction::getFunction(), CReaction::getFunctionParameters(), CCopasiRootContainer::getKeyFactory(), CCopasiObject::getObjectName(), CReaction::getParameterMapping(), CReaction::getParameterMappings(), CReaction::getParameterValue(), CChemEq::getProducts(), CModelEntity::getSBMLId(), CChemEq::getSubstrates(), CFunctionParameter::getUsage(), isDividedByVolume(), CReaction::isLocalParameter(), CFunction::isReversible(), mParameterReplacementMap, mpSBMLDocument, mSBMLLevel, CFunctionParameter::PARAMETER, replaceSpeciesReferences(), restore_local_parameters(), CFunctionParameters::size(), CCopasiVector< T >::size(), TriUnspecified, and CFunctionParameter::VARIABLE.

Referenced by createReaction().

{
  KineticLaw* pKLaw = NULL;

  if (!pKLaw)
    {
      /* create a new KineticLaw */
      pKLaw = new KineticLaw(level, version);
    }

  // create the local parameters
  size_t i, iMax = reaction.getFunctionParameters().size();

  for (i = 0; i < iMax; ++i)
    {
      const CFunctionParameter* pPara = reaction.getFunctionParameters()[i];
      // if the reaction calls a general function, all call parameters have a usage of VARIABLE
      // So local parameters will also have a usage of VARIABLE instead of PARAMETER

      if (pPara->getUsage() == CFunctionParameter::PARAMETER ||
          (reaction.getFunction() != NULL &&
           reaction.getFunction()->isReversible() == TriUnspecified &&
           pPara->getUsage() == CFunctionParameter::VARIABLE))
        {
          // only create a parameter if it is a local parameter,
          // and if it is not in the replacement map
          // otherwise the parameter already has been created
          if (reaction.isLocalParameter(i))
            {
              std::vector<std::string> v = reaction.getParameterMapping(pPara->getObjectName());
              assert(v.size() == 1);
              CCopasiObject* pTmpObject = CCopasiRootContainer::getKeyFactory()->get(v[0]);
              assert(pTmpObject != NULL);
              CCopasiParameter* pLocalParameter = dynamic_cast<CCopasiParameter*>(pTmpObject);
              assert(pLocalParameter != NULL);

              if (this->mParameterReplacementMap.find(pLocalParameter->getCN()) == this->mParameterReplacementMap.end())
                {
                  // starting with SBML Level 3, the parameters of a kinetic law are expressed in
                  // libsbml 4.1 does not handle this in a nice way,
                  // so way have to distinguish between the levels we export
                  // Actually here we could probably have gotten away with the old code, but
                  // better safe than sorry
                  Parameter* pSBMLPara = NULL;
#if LIBSBML_VERSION >= 40100

                  if (this->mSBMLLevel > 2)
                    {
                      pSBMLPara = pKLaw->createLocalParameter();
                    }
                  else
                    {
#endif // LIBSBML_VERSION
                      pSBMLPara = pKLaw->createParameter();
#if LIBSBML_VERSION >= 40100
                    }

                  pSBMLPara->setId(pPara->getObjectName().c_str());
#endif // LIBSBML_VERSION

                  // don't call setName on level 1 objects because this will also
                  // change the id
                  if (this->mpSBMLDocument->getLevel() > 1)
                    {
                      pSBMLPara->setName(pPara->getObjectName().c_str());
                    }

                  double value = reaction.getParameterValue(pPara->getObjectName());

                  // if the value is NaN, leave the parameter value unset.
                  if (!isnan(value))
                    {
                      pSBMLPara->setValue(value);
                    }
                }
            }
        }
    }

  // the next few lines replace references to species depending on whether
  // it is a reference to an amount or a reference to a concentration.
  // Other factors that influence this replacement are if the model
  // contains variable volumes or if the quantity units are set to CModel::number
  CEvaluationNode* pExpression = CSBMLExporter::createKineticExpression(const_cast<CFunction*>(reaction.getFunction()), reaction.getParameterMappings());

  if (pExpression == NULL)
    {
      delete pKLaw;
      pKLaw = NULL;
    }
  else
    {
      /*
      ** If the reaction takes place in a single compartment, the rate law has
      ** to be converted from concentration/time to substance/time by
      ** multiplying the rate law with the volume of the compartment.
      */
      CEvaluationNode* pOrigNode = this->replaceSpeciesReferences(pExpression, dataModel);
      delete pExpression;
      assert(pOrigNode != NULL);
      ASTNode* pNode = this->convertToASTNode(pOrigNode, dataModel);
      // since toAST in CEvaluationNodeObject sets the CN of local parameters
      // as the name of the node, we have to go and replace all node names
      // that have a common name that is the CN of a local parameter
      this->restore_local_parameters(pNode, dataModel);
      delete pOrigNode;
      assert(pNode != NULL);

      if (reaction.getCompartmentNumber() == 1)
        {
          const CCompartment& compartment = (reaction.getChemEq().getSubstrates().size() != 0) ? (*reaction.getChemEq().getSubstrates()[0]->getMetabolite()->getCompartment()) : (*reaction.getChemEq().getProducts()[0]->getMetabolite()->getCompartment());

          if (compartment.getDimensionality() != 0)
            {
              // check if the importer has added a division by the volume
              // if so remove it instead of multiplying again
              ASTNode* pTNode = CSBMLExporter::isDividedByVolume(pNode, compartment.getSBMLId());

              if (pTNode)
                {
                  if (pTNode->getNumChildren() == 0)
                    {
                      fatalError();
                    }

                  if (pTNode->getNumChildren() == 1)
                    {
                      ASTNode* pTmp = static_cast<ConverterASTNode*>(pTNode)->removeChild(0);
                      delete pTNode;
                      pTNode = pTmp;
                    }

                  delete pNode;
                  pNode = pTNode;
                }
              else
                {
                  pTNode = new ASTNode(AST_TIMES);
                  ASTNode* pVNode = new ASTNode(AST_NAME);
                  pVNode->setName(compartment.getSBMLId().c_str());
                  pTNode->addChild(pVNode);
                  pTNode->addChild(pNode);
                  pNode = pTNode;
                }
            }
        }

      pKLaw->setMath(pNode);
      delete pNode;
    }

  return pKLaw;
}

void CSBMLExporter::createLengthUnit ( const CCopasiDataModel &  dataModel )

protected

Creates the volume unit for the SBML model.

Creates the length unit for the SBML model.

Definition at line 689 of file CSBMLExporter.cpp.

References SBMLImporter::areSBMLUnitDefinitionsIdentical(), CModel::cm, CModel::dimensionlessLength, CModel::dm, CCopasiMessage::EXCEPTION, CModel::fm, CModel::getLengthUnitEnum(), CCopasiDataModel::getModel(), INIT_DEFAULTS, CModel::m, CModel::microm, CModel::mm, mpSBMLDocument, mSBMLLevel, mSBMLVersion, CModel::nm, and CModel::pm.

Referenced by createUnits().

{
  if (dataModel.getModel() == NULL || this->mpSBMLDocument == NULL || this->mpSBMLDocument->getModel() == NULL) return;

  UnitDefinition uDef(this->mSBMLLevel, this->mSBMLVersion);
  uDef.setName("length");
  uDef.setId("length");
  Unit unit(this->mSBMLLevel, this->mSBMLVersion);
  INIT_DEFAULTS(unit);

  switch (dataModel.getModel()->getLengthUnitEnum())
    {
      case CModel::m:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(1);
        unit.setScale(0);
        break;

      case CModel::dm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(1);
        unit.setScale(-1);
        break;

      case CModel::cm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(1);
        unit.setScale(-2);
        break;

      case CModel::mm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(1);
        unit.setScale(-3);
        break;

      case CModel::microm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(1);
        unit.setScale(-6);
        break;

      case CModel::nm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(1);
        unit.setScale(-9);
        break;

      case CModel::pm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(1);
        unit.setScale(-12);
        break;

      case CModel::fm:
        unit.setKind(UNIT_KIND_METRE);
        unit.setExponent(1);
        unit.setScale(-15);
        break;

      case CModel::dimensionlessLength:
        unit.setKind(UNIT_KIND_DIMENSIONLESS);
        unit.setExponent(1);
        unit.setScale(0);
        break;

      default:
        CCopasiMessage(CCopasiMessage::EXCEPTION, "SBMLExporter Error: Unknown copasi length unit.");
        break;
    }

  unit.setMultiplier(1.0);
  uDef.addUnit(&unit);
  Model* pSBMLModel = this->mpSBMLDocument->getModel();
  UnitDefinition* pUdef = pSBMLModel->getUnitDefinition("length");

  if (pUdef != NULL)
    {
      // check if it is the same unit as the existing one if there is one
      // if yes, return, else replace the existing one
      if (!SBMLImporter::areSBMLUnitDefinitionsIdentical(pUdef, &uDef))
        {
          (*pUdef) = uDef;
        }
    }
  else
    {
      // only add it if it is not the default unit definition anyway
      if (this->mSBMLLevel > 2 || unit.getKind() != UNIT_KIND_METRE || unit.getScale() != 0 || unit.getExponent() != 1 || unit.getMultiplier() != 1.0)
        {
          // set the unit definition
          pSBMLModel->addUnitDefinition(&uDef);
        }
    }

// if we write an SBML L3 document, we have to explicitely set the units on the model
#if LIBSBML_VERSION >= 40100

  if (this->mSBMLLevel > 2)
    {
      pSBMLModel->setLengthUnits(uDef.getId());
    }

#endif // LIBSBML_VERSION
}

CEvaluationNode * CSBMLExporter::createMassActionExpression ( const std::vector< std::vector< std::string > > &  arguments, bool  isReversible  )

staticprotected

This method creates the CEvaluationNode based tree for a reversible or irreversible Mass Action call. The first parameter contains the arguments from the COPASI reaction. The second argument determines whether it is reversible or irreversible mass action.

Definition at line 5907 of file CSBMLExporter.cpp.

References CCopasiNode< _Data >::addChild(), CEvaluationNodeObject::CN, CEvaluationNodeNumber::DOUBLE, CKeyFactory::get(), CCopasiObject::getCN(), CCopasiRootContainer::getKeyFactory(), CEvaluationNodeOperator::MINUS, CEvaluationNodeOperator::MULTIPLY, CEvaluationNodeOperator::POWER, and pResult.

Referenced by createKineticExpression().

{
  assert((isReversible && arguments.size() == 4) || arguments.size() == 2);
  assert(arguments[0].size() == 1 && arguments[1].size() > 0);
  // create a multiplication of all items in arguments[1] and multiply that
  // with item arguments[0][0]
  std::set<std::string> finishedElements;
  std::vector<CEvaluationNode*> multiplicants;
  const CCopasiObject* pObject = CCopasiRootContainer::getKeyFactory()->get(arguments[0][0]);
  assert(pObject != NULL);
  multiplicants.push_back(new CEvaluationNodeObject(CEvaluationNodeObject::CN, "<" + pObject->getCN() + ",Reference=Value>"));
  std::vector<std::string>::const_iterator it = arguments[1].begin(), endit = arguments[1].end();

  while (it != endit)
    {
      if (finishedElements.find(*it) == finishedElements.end())
        {
#ifdef __SUNPRO_CC
          // replaced count call with  "old" count call
          // to compile on Sun Compiler
          unsigned int num = 0;
          std::count(arguments[1].begin(), arguments[1].end(), *it, num);
#else
          size_t num = std::count(arguments[1].begin(), arguments[1].end(), *it);
#endif  // __SUNPRO_CC
          assert(num != 0);
          finishedElements.insert(*it);
          pObject = CCopasiRootContainer::getKeyFactory()->get(*it);
          assert(pObject != NULL);

          if (num == 1)
            {
              multiplicants.push_back(new CEvaluationNodeObject(CEvaluationNodeObject::CN, "<" + pObject->getCN() + ",Reference=Concentration>"));
            }
          else
            {
              std::ostringstream os;
              os << num;
              CEvaluationNodeOperator* pOperator = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");
              pOperator->addChild(new CEvaluationNodeObject(CEvaluationNodeObject::CN, "<" + pObject->getCN() + ",Reference=Concentration>"));
              pOperator->addChild(new CEvaluationNodeNumber(CEvaluationNodeNumber::DOUBLE, os.str()));
              multiplicants.push_back(pOperator);
            }
        }

      ++it;
    }

  std::vector<CEvaluationNode*>::reverse_iterator rIt = multiplicants.rbegin(), rEndit = multiplicants.rend();
  CEvaluationNode* pResult = *rIt;
  ++rIt;
  CEvaluationNode* pTmpNode = NULL;

  if (rIt != rEndit)
    {
      --rEndit;

      while (rIt != rEndit)
        {
          pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
          pTmpNode->addChild(*rIt);
          pTmpNode->addChild(pResult);
          pResult = pTmpNode;
          ++rIt;
        }
    }

  pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
  pTmpNode->addChild(*rIt);
  pTmpNode->addChild(pResult);
  pResult = pTmpNode;

  if (isReversible)
    {
      std::vector<std::vector<std::string> > tmpV;
      tmpV.push_back(arguments[2]);
      tmpV.push_back(arguments[3]);
      pTmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MINUS, "-");
      pTmpNode->addChild(pResult);
      pTmpNode->addChild(CSBMLExporter::createMassActionExpression(tmpV, false));
      pResult = pTmpNode;
    }

  return pResult;
}

void CSBMLExporter::createMetabolite ( CMetab &  metab )

protected

Creates the species for the given COPASI metabolite.

Definition at line 1105 of file CSBMLExporter.cpp.

References CModelEntity::ASSIGNMENT, createUniqueId(), CModelEntity::FIXED, CMetab::getCompartment(), CMetab::getInitialConcentration(), CModelEntity::getInitialExpression(), CModelEntity::getInitialValue(), CMetab::getObjectDisplayName(), CCopasiObject::getObjectName(), CModelEntity::getSBMLId(), CModelEntity::getStatus(), INIT_DEFAULTS, mAssignmentVector, mCOPASI2SBMLMap, mHandledSBMLObjects, mIdMap, mInitialAssignmentVector, mMetaIdMap, mODEVector, mpSBMLDocument, mSBMLLevel, mSBMLVersion, mSpatialSizeUnitsSpecies, mVariableVolumes, CModelEntity::ODE, CModelEntity::REACTIONS, removeInitialAssignment(), removeRule(), CModelEntity::setSBMLId(), setSBMLNotes(), and updateMIRIAMAnnotation().

Referenced by createMetabolites().

{
  Species* pSBMLSpecies = NULL;
  std::string sbmlId = metab.getSBMLId();

  if (!sbmlId.empty())
    {
      pSBMLSpecies = this->mpSBMLDocument->getModel()->getSpecies(sbmlId);

      if (pSBMLSpecies == NULL)
        {
          pSBMLSpecies = this->mpSBMLDocument->getModel()->createSpecies();
          this->mCOPASI2SBMLMap[&metab] = pSBMLSpecies;
          pSBMLSpecies->setId(sbmlId);
        }
      else
        {
#if LIBSBML_VERSION >= 40100

          if (this->mSBMLLevel > 2)
            {
              pSBMLSpecies->unsetConversionFactor();
              // we have to remove the conversionFactor because on import we multiplied the stoichiometries
              // with this factor
            }

#endif // LIBSBML_VERSION

          // clear the spatialSizeUnits attribute if there is any
          if (this->mSBMLLevel > 2 || (this->mSBMLLevel == 2 && this->mSBMLVersion >= 3))
            {
              if (pSBMLSpecies->isSetSpatialSizeUnits())
                {
                  pSBMLSpecies->unsetSpatialSizeUnits();
                  this->mSpatialSizeUnitsSpecies.insert(pSBMLSpecies->getId());
                }
            }
        }
    }
  else
    {
      pSBMLSpecies = this->mpSBMLDocument->getModel()->createSpecies();
      this->mCOPASI2SBMLMap[&metab] = pSBMLSpecies;
      sbmlId = CSBMLExporter::createUniqueId(this->mIdMap, metab.getObjectDisplayName(), false);
      metab.setSBMLId(sbmlId);
      pSBMLSpecies->setId(sbmlId);
    }

  INIT_DEFAULTS((*pSBMLSpecies));

  this->mIdMap.insert(std::pair<const std::string, const SBase*>(sbmlId, pSBMLSpecies));
  this->mHandledSBMLObjects.insert(pSBMLSpecies);

  // don't call setName on level 1 objects because this will also
  // change the id
  if (this->mpSBMLDocument->getLevel() > 1)
    {
      pSBMLSpecies->setName(metab.getObjectName().c_str());
    }

  //const Compartment* pSBMLCompartment = dynamic_cast<const Compartment*>(this->mCOPASI2SBMLMap[const_cast<CCompartment*>(metab.getCompartment())]);
  const Compartment* pSBMLCompartment = this->mpSBMLDocument->getModel()->getCompartment(metab.getCompartment()->getSBMLId());
  assert(pSBMLCompartment);
  pSBMLSpecies->setCompartment(pSBMLCompartment->getId());

  if (this->mVariableVolumes == true)
    {
      pSBMLSpecies->setHasOnlySubstanceUnits(true);
    }

  double value = metab.getInitialConcentration();

  // if the value is NaN, unset the initial amount
  if (!isnan(value))
    {
      // if we set the concentration on a species that had the amount
      // set, the meaning of the model is different when the user changed
      // to size of the corresponding compartment
      // So if the amount had been set, we try to keep this.
      // we also have to set the initial amount if the model has variable
      // volumes since those models export all species with the
      // hasOnlySubstanceUnits flag set to true
      //
      // libsbml 4 does not set the initial concentration on a species any more
      // so we also have to set the initial amount
      if (pSBMLSpecies->isSetInitialAmount() || this->mVariableVolumes == true || pSBMLSpecies->getLevel() == 1)
        {
          pSBMLSpecies->setInitialAmount(value * metab.getCompartment()->getInitialValue());
        }
      else
        {
          pSBMLSpecies->setInitialConcentration(value);
        }
    }
  else
    {
      pSBMLSpecies->unsetInitialConcentration();
      pSBMLSpecies->unsetInitialAmount();
    }

  CModelEntity::Status status = metab.getStatus();

  // a species can either have an assignment or an initial assignment but not
  // both
  if (status == CModelEntity::ASSIGNMENT)
    {
      this->mAssignmentVector.push_back(&metab);
      pSBMLSpecies->setConstant(false);
      pSBMLSpecies->setBoundaryCondition(true);
      removeInitialAssignment(pSBMLSpecies->getId());
    }
  else if (status == CModelEntity::ODE)
    {
      this->mODEVector.push_back(&metab);
      pSBMLSpecies->setConstant(false);
      pSBMLSpecies->setBoundaryCondition(true);

      if (metab.getInitialExpression() != "")
        {
          this->mInitialAssignmentVector.push_back(&metab);
        }
      else
        {
          removeInitialAssignment(pSBMLSpecies->getId());
        }
    }
  else if (status == CModelEntity::FIXED)
    {
      // do this explicitly since we might handle an existing object from an
      // earlier import that had it attribute set already
      if (this->mSBMLLevel != 1)
        {
          pSBMLSpecies->setConstant(true);
        }
      else
        {
          // Level 1 doesn't have the constant attribute and libSBML 3.2.0 does
          // not drop it automatically
          pSBMLSpecies->setConstant(false);
        }

      pSBMLSpecies->setBoundaryCondition(true);
      removeRule(pSBMLSpecies->getId());

      // fill initial assignment set
      if (metab.getInitialExpression() != "")
        {
          this->mInitialAssignmentVector.push_back(&metab);
        }
      else
        {
          removeInitialAssignment(pSBMLSpecies->getId());
        }
    }
  else if (status == CModelEntity::REACTIONS)
    {
      pSBMLSpecies->setConstant(false);
      pSBMLSpecies->setBoundaryCondition(false);

      if (metab.getInitialExpression() != "")
        {
          this->mInitialAssignmentVector.push_back(&metab);
        }
    }

  if (pSBMLSpecies != NULL)
    {
      CSBMLExporter::setSBMLNotes(pSBMLSpecies, &metab);
    }

  if (pSBMLSpecies != NULL && mSBMLLevel == 3)
    {
      // for l3 the unit needs to be set explicitly to substance,
      pSBMLSpecies->setSubstanceUnits("substance");
    }

  CSBMLExporter::updateMIRIAMAnnotation(&metab, pSBMLSpecies, this->mMetaIdMap);
}

void CSBMLExporter::createMetabolites ( CCopasiDataModel &  dataModel )

protected

Creates the compartments for the model.

Definition at line 1068 of file CSBMLExporter.cpp.

References CCopasiVector< T >::begin(), check_for_spatial_size_units(), createMetabolite(), CCopasiVector< T >::end(), CModel::getMetabolites(), CCopasiDataModel::getModel(), MCSBML, mIncompatibilities, mpSBMLDocument, mSBMLLevel, mSBMLVersion, mSpatialSizeUnitsSpecies, and CCopasiMessage::WARNING.

Referenced by createSBMLDocument().

{
  // make sure the SBML Document already exists and that it has a Model set
  if (dataModel.getModel() == NULL || this->mpSBMLDocument == NULL || this->mpSBMLDocument->getModel() == NULL) return;

  if (this->mSBMLLevel > 2 || (this->mSBMLLevel == 2 && this->mSBMLVersion >= 3))
    {
      check_for_spatial_size_units(dataModel, this->mIncompatibilities);
    }

  CCopasiVector<CMetab>::const_iterator it = dataModel.getModel()->getMetabolites().begin(), endit = dataModel.getModel()->getMetabolites().end();
  this->mSpatialSizeUnitsSpecies.clear();

  while (it != endit)
    {
      createMetabolite(**it);
      ++it;
    }

  if (!this->mSpatialSizeUnitsSpecies.empty())
    {
      std::ostringstream os;
      std::set<std::string>::const_iterator sit = this->mSpatialSizeUnitsSpecies.begin(), sendit = this->mSpatialSizeUnitsSpecies.end();

      while (sit != sendit)
        {
          os << *sit << ", ";
          ++sit;
        }

      CCopasiMessage(CCopasiMessage::WARNING, MCSBML + 84, os.str().substr(0, os.str().size() - 2).c_str());
    }
}

void CSBMLExporter::createParameter ( CModelValue &  modelValue )

protected

Creates the parameter for the given COPASI parameter.

Definition at line 1304 of file CSBMLExporter.cpp.

References CModelEntity::ASSIGNMENT, createUniqueId(), CModelEntity::getInitialExpression(), CModelEntity::getInitialValue(), CCopasiObject::getObjectName(), CModelEntity::getSBMLId(), CModelEntity::getStatus(), INIT_DEFAULTS, mAssignmentVector, mCOPASI2SBMLMap, mHandledSBMLObjects, mIdMap, mInitialAssignmentVector, mMetaIdMap, mODEVector, mpSBMLDocument, mSBMLLevel, CModelEntity::ODE, removeInitialAssignment(), removeRule(), CModelEntity::setSBMLId(), setSBMLNotes(), and updateMIRIAMAnnotation().

Referenced by createParameters().

{
  Parameter* pParameter = NULL;
  std::string sbmlId = modelValue.getSBMLId();

  if (!sbmlId.empty())
    {
      pParameter = this->mpSBMLDocument->getModel()->getParameter(sbmlId);

      if (pParameter == NULL)
        {
          pParameter = this->mpSBMLDocument->getModel()->createParameter();
          this->mCOPASI2SBMLMap[&modelValue] = pParameter;
          pParameter->setId(sbmlId);
        }
    }
  else
    {
      pParameter = this->mpSBMLDocument->getModel()->createParameter();
      this->mCOPASI2SBMLMap[&modelValue] = pParameter;
      sbmlId = CSBMLExporter::createUniqueId(this->mIdMap, modelValue.getObjectName(), false);
      modelValue.setSBMLId(sbmlId);
      pParameter->setId(sbmlId);
    }

  INIT_DEFAULTS((*pParameter));

  this->mIdMap.insert(std::pair<const std::string, const SBase*>(sbmlId, pParameter));
  this->mHandledSBMLObjects.insert(pParameter);

  // don't call setName on level 1 objects because this will also
  // change the id
  if (this->mpSBMLDocument->getLevel() > 1)
    {
      pParameter->setName(modelValue.getObjectName());
    }

  double value = modelValue.getInitialValue();

  // if the value is NaN, unset the parameters value
  if (!isnan(value))
    {
      pParameter->setValue(value);
    }
  else
    {
      pParameter->unsetValue();
    }

  // fill assignment set
  // a parameter can either have an assignment or an initial assignment but not
  // both
  CModelEntity::Status status = modelValue.getStatus();

  if (status == CModelEntity::ASSIGNMENT)
    {
      this->mAssignmentVector.push_back(&modelValue);
      pParameter->setConstant(false);
      removeInitialAssignment(pParameter->getId());
    }
  else if (status == CModelEntity::ODE)
    {
      this->mODEVector.push_back(&modelValue);
      pParameter->setConstant(false);

      if (modelValue.getInitialExpression() != "")
        {
          this->mInitialAssignmentVector.push_back(&modelValue);
        }
      else
        {
          removeInitialAssignment(pParameter->getId());
        }
    }
  else
    {
      // do this explicitly since we might handle an existing object from an
      // earlier import that had it attribute set already
      if (this->mSBMLLevel != 1)
        {
          pParameter->setConstant(true);
        }
      else
        {
          // Level 1 does not have a constant flag
          // and libsbml does not drop it automatically
          pParameter->setConstant(false);
        }

      // fill initial assignment set
      removeRule(pParameter->getId());

      if (modelValue.getInitialExpression() != "")
        {
          this->mInitialAssignmentVector.push_back(&modelValue);
        }
      else
        {
          removeInitialAssignment(pParameter->getId());
        }
    }

  if (pParameter != NULL)
    {
      CSBMLExporter::setSBMLNotes(pParameter, &modelValue);
    }

  CSBMLExporter::updateMIRIAMAnnotation(&modelValue, pParameter, this->mMetaIdMap);
}

void CSBMLExporter::createParameters ( CCopasiDataModel &  dataModel )

protected

Creates the parameters for the model.

Definition at line 1287 of file CSBMLExporter.cpp.

References CCopasiVector< T >::begin(), createParameter(), CCopasiVector< T >::end(), CCopasiDataModel::getModel(), CModel::getModelValues(), and mpSBMLDocument.

Referenced by createSBMLDocument().

{
  // make sure the SBML Document already exists and that it has a Model set
  if (dataModel.getModel() == NULL || this->mpSBMLDocument == NULL || this->mpSBMLDocument->getModel() == NULL) return;

  CCopasiVectorN<CModelValue>::const_iterator it = dataModel.getModel()->getModelValues().begin(), endit = dataModel.getModel()->getModelValues().end();

  while (it != endit)
    {
      createParameter(**it);
      ++it;
    }
}

void CSBMLExporter::createReaction ( CReaction &  reaction, CCopasiDataModel &  dataModel  )

protected

Creates the reaction for the given COPASI reaction.

Definition at line 1434 of file CSBMLExporter.cpp.

References createKineticLaw(), createUniqueId(), CCopasiMessage::EXCEPTION, CReaction::getChemEq(), CReaction::getFunction(), CChemEqElement::getMetabolite(), CChemEq::getModifiers(), CChemEqElement::getMultiplicity(), CCopasiObject::getObjectName(), CChemEq::getProducts(), CModelEntity::getSBMLId(), CReaction::getSBMLId(), CChemEq::getSubstrates(), CCopasiRootContainer::getUndefinedFunction(), INIT_DEFAULTS, CReaction::isReversible(), mCOPASI2SBMLMap, MCSBML, mHandledSBMLObjects, mIdMap, mIncompleteExport, mMetaIdMap, mpSBMLDocument, mSBMLLevel, CReaction::setSBMLId(), setSBMLNotes(), CCopasiVector< T >::size(), and updateMIRIAMAnnotation().

Referenced by createReactions().

{
  // make sure the mCOPASI2SBMLMap is already updated
  Reaction* pSBMLReaction = NULL;

  // if the reaction has nothing set but the name, we don't do anything
  // This is mandated since SBML Level 2 Version 2. A reactions has to have either
  // a substrate or a product.
  if (reaction.getChemEq().getSubstrates().size() == 0 &&
      reaction.getChemEq().getProducts().size() == 0) return;

  std::string sbmlId = reaction.getSBMLId();

  if (!sbmlId.empty())
    {
      pSBMLReaction = this->mpSBMLDocument->getModel()->getReaction(sbmlId);

      if (pSBMLReaction == NULL)
        {
          /* create a new reaction object */
          pSBMLReaction = this->mpSBMLDocument->getModel()->createReaction();
          mCOPASI2SBMLMap[&reaction] = pSBMLReaction;
          pSBMLReaction->setId(sbmlId);
        }

      // maybe this id was assigned by assignSBMLIdstoReactions and there is no object associated with it
      // If this is the case, we associate the object here.
      std::map<std::string, const SBase*>::const_iterator pos = this->mIdMap.find(sbmlId);
      assert(pos != this->mIdMap.end());

      if (pos->second == NULL)
        {
          this->mIdMap[sbmlId] = pSBMLReaction;
        }
    }
  else
    {
      pSBMLReaction = this->mpSBMLDocument->getModel()->createReaction();
      this->mCOPASI2SBMLMap[&reaction] = pSBMLReaction;
      sbmlId = CSBMLExporter::createUniqueId(this->mIdMap, reaction.getObjectName(), false);
      reaction.setSBMLId(sbmlId);
      pSBMLReaction->setId(sbmlId);
    }

  INIT_DEFAULTS((*pSBMLReaction));

  this->mIdMap.insert(std::pair<const std::string, const SBase*>(sbmlId, pSBMLReaction));
  this->mHandledSBMLObjects.insert(pSBMLReaction);

  // don't call setName on level 1 objects because this will also
  // change the id
  if (this->mpSBMLDocument->getLevel() > 1)
    {
      pSBMLReaction->setName(reaction.getObjectName().c_str());
    }

  pSBMLReaction->setReversible(reaction.isReversible());
  const CChemEq& chemicalEquation = reaction.getChemEq();
  /* Add all substrates */
  unsigned int counter;
  std::set<std::string> usedReferences;

  for (counter = 0; counter < chemicalEquation.getSubstrates().size(); counter++)
    {
      const CChemEqElement* element = chemicalEquation.getSubstrates()[counter];
      const CMetab* pMetabolite = element->getMetabolite();
      assert(pMetabolite);
      SpeciesReference* sRef = NULL;

      if (!(sRef = pSBMLReaction->getReactant(pMetabolite->getSBMLId())))
        {
          sRef = pSBMLReaction->createReactant();
          sRef->setSpecies(pMetabolite->getSBMLId().c_str());
        }

      INIT_DEFAULTS((*sRef));
#if LIBSBML_VERSION > 40100

      if (this->mSBMLLevel > 2)
        sRef->setConstant(true);

#endif
      sRef->setStoichiometry(element->getMultiplicity());
      sRef->setDenominator(1);
      usedReferences.insert(sRef->getSpecies());
    }

  ListOf* l = pSBMLReaction->getListOfReactants();

  for (counter = l->size(); counter > 0; --counter)
    {
      if (usedReferences.find(static_cast<SimpleSpeciesReference*>(l->get(counter - 1))->getSpecies()) == usedReferences.end())
        {
          l->remove(counter - 1);
        }
    }

  /* Add all products */
  usedReferences.clear();

  for (counter = 0; counter < chemicalEquation.getProducts().size(); counter++)
    {
      const CChemEqElement* element = chemicalEquation.getProducts()[counter];
      const CMetab* pMetabolite = element->getMetabolite();
      assert(pMetabolite);
      SpeciesReference* sRef = NULL;

      if (!(sRef = pSBMLReaction->getProduct(pMetabolite->getSBMLId())))
        {
          sRef = pSBMLReaction->createProduct();
          sRef->setSpecies(pMetabolite->getSBMLId().c_str());
        }

      INIT_DEFAULTS((*sRef));
#if LIBSBML_VERSION > 40100

      if (this->mSBMLLevel > 2)
        sRef->setConstant(true);

#endif

      sRef->setStoichiometry(element->getMultiplicity());
      sRef->setDenominator(1);
      usedReferences.insert(sRef->getSpecies());
    }

  l = pSBMLReaction->getListOfProducts();

  for (counter = l->size(); counter > 0; --counter)
    {
      if (usedReferences.find(static_cast<SimpleSpeciesReference*>(l->get(counter - 1))->getSpecies()) == usedReferences.end())
        {
          l->remove(counter - 1);
        }
    }

  /* Add all modifiers */
  usedReferences.clear();

  for (counter = 0; counter < chemicalEquation.getModifiers().size(); counter++)
    {
      const CChemEqElement* element = chemicalEquation.getModifiers()[counter];
      const CMetab* pMetabolite = element->getMetabolite(); assert(pMetabolite);
      ModifierSpeciesReference* sRef = NULL;

      if (!(sRef = pSBMLReaction->getModifier(pMetabolite->getSBMLId())))
        {
          if (pSBMLReaction->getLevel() > 1)
            {
              sRef = pSBMLReaction->createModifier();
              assert(sRef != NULL);
              sRef->setSpecies(pMetabolite->getSBMLId().c_str());
            }
        }

      if (pSBMLReaction->getLevel() > 1)
        {
          usedReferences.insert(sRef->getSpecies());
        }
    }

  l = pSBMLReaction->getListOfModifiers();

  for (counter = l->size(); counter > 0; --counter)
    {
      if (usedReferences.find(static_cast<SimpleSpeciesReference*>(l->get(counter - 1))->getSpecies()) == usedReferences.end())
        {
          l->remove(counter - 1);
        }
    }

  /* create the kinetic law */

  /* if there is one on COPASI */
  if ((reaction.getFunction()) != CCopasiRootContainer::getUndefinedFunction())
    {
      // make sure the creaated kinetic law has the same level and version as the reaction
      // we intend to add it to, otherwise the setKineticLaw function of libsbml 4 will fail
      // to set the kinetic law
      KineticLaw* pKineticLaw = this->createKineticLaw(reaction, dataModel, pSBMLReaction->getLevel(), pSBMLReaction->getVersion());

      if (pKineticLaw != NULL)
        {
          pSBMLReaction->setKineticLaw(pKineticLaw);
          delete pKineticLaw;
        }
      else
        {
          // create an error message and abort
          // maybe only abort if incomplete export is not wanted
          if (this->mIncompleteExport != true)
            {
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 8, reaction.getObjectName().c_str());
            }
          else
            {
              pSBMLReaction->unsetKineticLaw();
            }
        }
    }
  else
    {
      pSBMLReaction->unsetKineticLaw();
    }

  if (pSBMLReaction != NULL)
    {
      CSBMLExporter::setSBMLNotes(pSBMLReaction, &reaction);
    }

  CSBMLExporter::updateMIRIAMAnnotation(&reaction, pSBMLReaction, this->mMetaIdMap);
}

void CSBMLExporter::createReactions ( CCopasiDataModel &  dataModel )

protected

Creates the reactions for the model.

Definition at line 1417 of file CSBMLExporter.cpp.

References CCopasiVector< T >::begin(), createReaction(), CCopasiVector< T >::end(), CCopasiDataModel::getModel(), CModel::getReactions(), and mpSBMLDocument.

Referenced by createSBMLDocument().

{
  // make sure the SBML Document already exists and that it has a Model set
  if (dataModel.getModel() == NULL || this->mpSBMLDocument == NULL || this->mpSBMLDocument->getModel() == NULL) return;

  CCopasiVectorNS<CReaction>::const_iterator it = dataModel.getModel()->getReactions().begin(), endit = dataModel.getModel()->getReactions().end();

  while (it != endit)
    {
      createReaction(**it, dataModel);
      ++it;
    }
}

void CSBMLExporter::createRule ( const CModelEntity &  modelEntity, CCopasiDataModel &  dataModel, Rule *  pOldRule  )

protected

Creates the rule for the given COPASI model entity.

Definition at line 1937 of file CSBMLExporter.cpp.

References CModelEntity::ASSIGNMENT, convertExpression(), convertToASTNode(), createFunctionSetFromFunctionNames(), CCopasiMessage::ERROR, CCopasiMessage::EXCEPTION, findDirectlyUsedFunctions(), CModelEntity::FIXED, CMetab::getCompartment(), CCompartment::getDimensionality(), CModelEntity::getExpression(), CModelEntity::getExpressionPtr(), CCopasiRootContainer::getFunctionList(), CCopasiObject::getObjectName(), CCopasiObject::getObjectType(), CEvaluationTree::getRoot(), CModelEntity::getSBMLId(), CModelEntity::getStatus(), CEvaluationNode::getType(), CModelEntity::getValueReference(), CEvaluationNode::INVALID, isExpressionSBMLCompatible(), mCOPASI2SBMLMap, MCSBML, mIncompatibilities, mIncompleteExport, mInitialValueMap, mpSBMLDocument, mSBMLLevel, mSBMLVersion, multiplyByObject(), mUsedFunctions, outputIncompatibilities(), replace_local_parameters(), replaceSpeciesReferences(), CEvaluationTree::setInfix(), and CEvaluationNode::type().

Referenced by createRules().

{
  // check the expression
  std::vector<SBMLIncompatibility> result;
  CSBMLExporter::isExpressionSBMLCompatible(*modelEntity.getExpressionPtr()
      , dataModel
      , this->mSBMLLevel
      , this->mSBMLVersion
      , result
      , std::string("rule for object named \"" + modelEntity.getObjectName() + "\"").c_str()
      , false
      , &mInitialValueMap);

  // collect directly used functions
  if (result.empty())
    {
      std::set<std::string> directlyUsedFunctionNames;
      CSBMLExporter::findDirectlyUsedFunctions(modelEntity.getExpressionPtr()->getRoot(), directlyUsedFunctionNames);
      std::set<CFunction*> usedFunctions = CSBMLExporter::createFunctionSetFromFunctionNames(directlyUsedFunctionNames, CCopasiRootContainer::getFunctionList());

# if defined _MSC_VER && _MSC_VER < 1201 // 1200 Identifies Visual C++ 6.0
      {
        std::set<CFunction*>::const_iterator it = usedFunctions.begin();
        std::set<CFunction*>::const_iterator end = usedFunctions.end();

        for (; it != end; ++it)
          this->mUsedFunctions.insert(*it);
      }
#else
      this->mUsedFunctions.insert(usedFunctions.begin(), usedFunctions.end());
#endif

      // create the actual rule
      //Rule* pRule = this->mpSBMLDocument->getModel()->getRule(modelEntity.getSBMLId());
      const CMetab* pMetab = dynamic_cast<const CMetab*>(&modelEntity);

      if (pOldRule == NULL)
        {
          if (modelEntity.getStatus() == CModelEntity::ASSIGNMENT)
            {
              pOldRule = this->mpSBMLDocument->getModel()->createAssignmentRule();
            }
          else
            {
              if (pMetab != NULL)
                {
                  // check if the compartment is fixed
                  if (pMetab->getCompartment()->getStatus() != CModelEntity::FIXED)
                    {
                      CCopasiMessage(CCopasiMessage::ERROR, MCSBML + 52, pMetab->getObjectName().c_str());
                    }
                }

              pOldRule = this->mpSBMLDocument->getModel()->createRateRule();
            }

          pOldRule->setVariable(modelEntity.getSBMLId());
        }
      else
        {
          // Read the rule to the model
          this->mpSBMLDocument->getModel()->getListOfRules()->appendAndOwn(pOldRule);
        }

      // set the math

      const std::string& changedExpression = convertExpression(modelEntity.getExpression(), mInitialValueMap);
      CEvaluationTree tree;
      tree.setInfix(changedExpression);
      const CEvaluationNode* pOrigNode = tree.getRoot();

      if (CEvaluationNode::type(pOrigNode->getType()) == CEvaluationNode::INVALID)
        {
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 70, "assignment", modelEntity.getObjectType().c_str(), modelEntity.getObjectName().c_str());
        }

      // the next few lines replace references to species depending on whether
      // it is a reference to an amount or a reference to a concentration.
      // Other factors that influence this replacement are if the model
      // contains variable volumes or if the quantity units are set to CModel::number
      pOrigNode = this->replaceSpeciesReferences(pOrigNode, dataModel);
      assert(pOrigNode != NULL);

      // check if the rule is for an amount species
      // if this is the case, we have to multiply the expression by the volume
      // of the compartment the species is in
      if (pMetab != NULL)
        {
          std::map<const CCopasiObject*, SBase*>::const_iterator pos = this->mCOPASI2SBMLMap.find(&modelEntity);
          assert(pos != this->mCOPASI2SBMLMap.end());

          if (dynamic_cast<const Species*>(pos->second)->getHasOnlySubstanceUnits() == true)
            {
              const CCompartment* pCompartment = pMetab->getCompartment();

              if (pCompartment->getDimensionality() != 0)
                {
                  CEvaluationNode* pNode = CSBMLExporter::multiplyByObject(pOrigNode, pCompartment->getValueReference());
                  assert(pNode != NULL);

                  if (pNode != NULL)
                    {
                      delete pOrigNode;
                      pOrigNode = pNode;
                    }
                }
            }
        }

      ASTNode* pNode = this->convertToASTNode(pOrigNode, dataModel);
      this->replace_local_parameters(pNode, dataModel);
      delete pOrigNode;

      if (pNode != NULL)
        {
          pOldRule->setMath(pNode);
          delete pNode;
        }
      else
        {
          if (this->mIncompleteExport != true)
            {
              CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 60, "rule", modelEntity.getObjectType().c_str(), modelEntity.getObjectName().c_str());
            }
        }
    }
  else
    {
      this->mIncompatibilities.insert(this->mIncompatibilities.end(), result.begin(), result.end());

      if (!this->mIncompleteExport)
        {
          this->outputIncompatibilities();
          CCopasiMessage(CCopasiMessage::EXCEPTION, MCSBML + 60, "rule", modelEntity.getObjectType().c_str(), modelEntity.getObjectName().c_str());
        }
    }
}

void CSBMLExporter::createRules ( CCopasiDataModel &  dataModel )

protected

Creates the rules for the model.

Definition at line 1835 of file CSBMLExporter.cpp.

References createRule(), CModelEntity::getSBMLId(), mODEVector, mpSBMLDocument, and orderRules().

Referenced by createSBMLDocument().

{
  // make sure the mAssignmentVector has been filled already
  // make sure the mODEVector has been filled already
  // order the rules for Level 1 export
  // rules in Level 2 are not ordered.
  //if (this->mSBMLLevel == 1 || (this->mSBMLLevel == 2 && this->mSBMLVersion == 1))
  //  {
  std::vector<CModelEntity*> orderedAssignmentRules = orderRules(dataModel);
  //}
  //
  // remove all rules from the SBML model
  // and put them in a map
  std::map<std::string, Rule*> ruleMap;
  Model* pSBMLModel = this->mpSBMLDocument->getModel();
  assert(pSBMLModel != NULL);

  while (pSBMLModel->getNumRules() != 0)
    {
      Rule* pRule = pSBMLModel->getRule(0);
      assert(pRule != NULL);

      // ignore algebraic rules
      if (pRule->getTypeCode() == SBML_ASSIGNMENT_RULE)
        {
          AssignmentRule* pARule = dynamic_cast<AssignmentRule*>(pRule);
          assert(pARule != NULL);
          ruleMap[pARule->getVariable()] = pARule;
        }
      else if (pRule->getTypeCode() == SBML_RATE_RULE)
        {
          RateRule* pRRule = dynamic_cast<RateRule*>(pRule);
          assert(pRRule != NULL);
          ruleMap[pRRule->getVariable()] = pRRule;
        }

      pSBMLModel->getListOfRules()->remove(0);
    }

  // create the rules
  const CModelEntity* pME = NULL;
  size_t i, iMax = orderedAssignmentRules.size();

  for (i = 0; i < iMax; ++i)
    {
      pME = orderedAssignmentRules[i];
      assert(pME != NULL);

      if (pME != NULL)
        {
          std::map<std::string, Rule*>::const_iterator pos = ruleMap.find(pME->getSBMLId());
          Rule* pOldRule = NULL;

          if (pos != ruleMap.end())
            {
              pOldRule = pos->second;
              assert(pOldRule != NULL);
              ruleMap.erase(pos->first);
            }

          createRule(*pME, dataModel, pOldRule);
        }
    }

  iMax = mODEVector.size();

  for (i = 0; i < iMax; ++i)
    {
      pME = mODEVector[i];
      assert(pME != NULL);

      if (pME != NULL)
        {
          std::map<std::string, Rule*>::const_iterator pos = ruleMap.find(pME->getSBMLId());
          Rule* pOldRule = NULL;

          if (pos != ruleMap.end())
            {
              pOldRule = pos->second;
              assert(pOldRule != NULL);
              ruleMap.erase(pos->first);
            }

          createRule(*pME, dataModel, pOldRule);
        }
    }

  // delete the remaining rules
  std::map<std::string, Rule*>::iterator mapIt = ruleMap.begin(), mapEndit = ruleMap.end();

  while (mapIt != mapEndit)
    {
      delete mapIt->second;
      ++mapIt;
    }

  ruleMap.clear();
}

void CSBMLExporter::createSBMLDocument ( CCopasiDataModel &  dataModel )

protected

Creates an SBMLDocument from the given CCopasiDataModelObject. It checks if an SBMLDocument already exists from an import and if this is the case, the old document is copied. If none exists a new one is created. Copying the old one makes sure that if something goes wrong during export, the original model is still consistent.

Definition at line 3399 of file CSBMLExporter.cpp.

References addInitialAssignmentsToModel(), assignSBMLIdsToReactions(), checkForInitialAssignments(), SBMLUtils::collectIds(), collectIds(), convertToLevel1(), createCompartments(), createEvents(), createFunctionDefinitions(), createInitialAssignments(), createMetabolites(), createParameters(), createReactions(), createRules(), createUniqueId(), createUnits(), CCopasiMessage::EXCEPTION, fatalError, findAvogadro(), CCopasiDataModel::getCurrentSBMLDocument(), CModelEntity::getKey(), CCopasiDataModel::getModel(), CCopasiObject::getObjectName(), CModelEntity::getSBMLId(), hasVolumeAssignment(), mAvogadroCreated, mCOPASI2SBMLMap, mExportedFunctions, mFunctionIdMap, mFunctionMap, mHaveModelHistoryAuthorWarning, mHaveModelHistoryCreationDateWarning, mHaveModelHistoryModificationDateWarning, mIdMap, mIncompatibilities, mIncompleteExport, mInitialValueMap, mMetaIdMap, mpAvogadro, mpSBMLDocument, mSBMLLevel, mSBMLVersion, mVariableVolumes, outputIncompatibilities(), CModel::removeModelValue(), setSBMLNotes(), updateCOPASI2SBMLMap(), and updateMIRIAMAnnotation().

Referenced by exportModelToString().

{
  // reset warnings for missing entries in modelhistory
  mHaveModelHistoryAuthorWarning = false;
  mHaveModelHistoryCreationDateWarning = false;
  mHaveModelHistoryModificationDateWarning = false;

  const SBMLDocument* pOldSBMLDocument = dataModel.getCurrentSBMLDocument();
  const CModel* pModel = dataModel.getModel();
  assert(pModel != NULL);

  if (pOldSBMLDocument == NULL)
    {
      this->mpSBMLDocument = new SBMLDocument(this->mSBMLLevel, this->mSBMLVersion);
    }
  else
    {
      this->mpSBMLDocument = dynamic_cast<SBMLDocument*>(pOldSBMLDocument->clone());
    }

  if (this->mpSBMLDocument == NULL) fatalError();

#if LIBSBML_VERSION >= 50000
  const std::string uri = (this->mSBMLLevel < 3 ? LayoutExtension::getXmlnsL2() : LayoutExtension::getXmlnsL3V1V1());
  this->mpSBMLDocument->enablePackage(uri, "layout", true);

  if (this->mSBMLLevel > 2)
    this->mpSBMLDocument->setPackageRequired("layout", false);

  const std::string renderuri = (this->mSBMLLevel < 3 ? RenderExtension::getXmlnsL2() : RenderExtension::getXmlnsL3V1V1());
  this->mpSBMLDocument->enablePackage(renderuri, "render", true);

  if (this->mSBMLLevel > 2)
    this->mpSBMLDocument->setPackageRequired("render", false);

#endif

  if (this->mpSBMLDocument->getModel() == NULL)
    {
      // there might still be COPASI object that have an SBML id, we have to
      // collect those as well
      CSBMLExporter::collectIds(dataModel, this->mIdMap);
      std::string id = pModel->getSBMLId();

      if (id.empty())
        {
          id = CSBMLExporter::createUniqueId(this->mIdMap, pModel->getObjectName(), false);
          this->mIdMap.insert(std::pair<const std::string, const SBase*>(id, this->mpSBMLDocument->getModel()));
        }

      this->mpSBMLDocument->createModel(id);
    }
  else
    {
      SBMLUtils::collectIds(this->mpSBMLDocument->getModel(), this->mIdMap, this->mMetaIdMap);
    }

  this->mFunctionIdMap.clear();
  // update the copasi2sbmlmap
  updateCOPASI2SBMLMap(dataModel);
  // update the comments on the model
  this->mpSBMLDocument->getModel()->setName(pModel->getObjectName());

  if (pModel != NULL && this->mpSBMLDocument->getModel() != NULL)
    {
      CSBMLExporter::setSBMLNotes(this->mpSBMLDocument->getModel(), pModel);
    }

  // update the MIRIAM annotation on the model
  CSBMLExporter::updateMIRIAMAnnotation(pModel, this->mpSBMLDocument->getModel(), this->mMetaIdMap);
#if LIBSBML_VERSION >= 40100

  if (this->mSBMLLevel > 2)
    {
      // we have to remove the conversionFactor because on import we multiplied the stoichiometries
      // with this factor
      this->mpSBMLDocument->getModel()->unsetConversionFactor();
    }

#endif // LIBSBML_VERSION

  // create units, compartments, species, parameters, reactions, initial
  // assignment, assignments, (event) and function definitions
  createUnits(dataModel);
  // try to find a parameter that represents Avogadros number
  findAvogadro(dataModel);

  // check if there is an assignment to a volume
  // in that case we has to export all species with the
  // hasOnlySubstanceUnits flag set to true
  this->mVariableVolumes = this->hasVolumeAssignment(dataModel);

  createCompartments(dataModel);
  createMetabolites(dataModel);
  createParameters(dataModel);

  // TODO here we should check the expressions but the function definitions
  // TODO have not been created yet, so we can't
  // TODO Maybe we don't have to do all checks here.
  // TODO it would probably be enough to check if the expressions are valid and
  // TODO to check the function calls later on when the functions are created.

  // only export initial assignments for Level 2 Version 2 and above
  if (this->mSBMLLevel != 1 && !(this->mSBMLLevel == 2 && this->mSBMLVersion == 1))
    {
      createInitialAssignments(dataModel);
    }
  else
    {
      checkForInitialAssignments(dataModel, this->mIncompatibilities);
    }

  // since the flux of a reaction can be referenced in an assignment,
  // we have to make sure that asll reactions do have SBML Ids prior to creating the rules
  // and events
  assignSBMLIdsToReactions(dataModel.getModel());

  createRules(dataModel);
  createEvents(dataModel);

  // we have to export the reactions after all other entities that have
  // expressions since an expression could contain a local parameter
  // If it did, it would have to be converted to a global parameter and that
  // has to be taken into consideration when creating the reactions
  createReactions(dataModel);
  // find all used functions
  createFunctionDefinitions(dataModel);

  if (this->mSBMLLevel == 1)
    {
      // do SBML Level1 Voodoo
      // e.g. replace some of the unsupported nodes with workarounds
      convertToLevel1();
      // delete all function definitions since L1 does not have functions
      Model* pSBMLModel = this->mpSBMLDocument->getModel();
      assert(pSBMLModel != NULL);
      int i = pSBMLModel->getListOfFunctionDefinitions()->size();

      while (i > 0)
        {
          --i;
          // fix for bug 1086
          // remove the object from the COPASI2SBML Map
          std::map<const CCopasiObject*, SBase*>::iterator it = this->mCOPASI2SBMLMap.begin(), endit = this->mCOPASI2SBMLMap.end();

          while (it != endit)
            {
              if (it->second == pSBMLModel->getFunctionDefinition(i))
                {
                  this->mCOPASI2SBMLMap.erase(it);
                  break;
                }

              ++it;
            }

          delete pSBMLModel->getListOfFunctionDefinitions()->remove(i);
        }
    }
  else
    {
      // add all function definitions to the model
      Model* pSBMLModel = this->mpSBMLDocument->getModel();
      assert(pSBMLModel != NULL);

      if (pSBMLModel != NULL)
        {
          unsigned int i = 0, iMax = this->mExportedFunctions.size();
#if LIBSBML_VERSION >= 40100
          int result;
#endif // LIBSBML_VERSION >= 40100
          FunctionDefinition* pFunDef = NULL;
          std::map<const FunctionDefinition*, const CCopasiObject*>::const_iterator funPos;

          while (i < iMax)
            {
              pFunDef = this->mExportedFunctions.get(i);
              assert(pFunDef != NULL);
              // match the namespaces to those of the model
              pFunDef->setSBMLNamespaces(pSBMLModel->getSBMLNamespaces());
// add methods only return a value starting with libsbml 4
#if LIBSBML_VERSION >= 40100
              result = pSBMLModel->addFunctionDefinition(pFunDef);
              assert(result == LIBSBML_OPERATION_SUCCESS);
#else
              pSBMLModel->addFunctionDefinition(pFunDef);
              assert(pSBMLModel->getFunctionDefinition(pFunDef->getId()) != NULL);
#endif // LIBSBML_VERSION >= 40100
              // now we need to add the newly created FunctionDefinition to the copasi2sbml map
              funPos = this->mFunctionMap.find(pFunDef);
              assert(funPos != this->mFunctionMap.end());
              pFunDef = pSBMLModel->getFunctionDefinition(pFunDef->getId());
              assert(pFunDef != NULL);
              this->mCOPASI2SBMLMap[funPos->second] = pFunDef;
              ++i;
            }

          //the assert below no longer holds, as we export uniform / normal as functiondefinitions
          //assert(pSBMLModel->getNumFunctionDefinitions() == this->mExportedFunctions.size());
        }
    }

  // In case the document is just a clone of an old model, we have to set the level and version
  if (this->mpSBMLDocument->getLevel() != this->mSBMLLevel || this->mpSBMLDocument->getVersion() != this->mSBMLVersion)
    {
#if LIBSBML_VERSION >= 50400

      SBMLNamespaces targetNs(mSBMLLevel, mSBMLVersion); // use reference, as the ns gets cloned

      if (mSBMLLevel == 1 && mSBMLVersion == 1)
        {
          // l1v1 export tailor made to suit GEPASI, with pow -> ^ notation and
          // inlining of compartment sizes in kinetics.

          ConversionProperties prop(&targetNs);
          prop.addOption("convertToL1V1", true,
                         "convert the document to SBML Level 1 Version 1");
          prop.addOption("changePow", true,
                         "change pow expressions to the (^) hat notation");
          prop.addOption("inlineCompartmentSizes", true,
                         "if true, occurrances of compartment ids in expressions will be replaced with their initial size");

          mpSBMLDocument->convert(prop);
        }
      else
        {

          ConversionProperties prop(&targetNs);
          prop.addOption("strict", false);
          prop.addOption("setLevelAndVersion", true);
          prop.addOption("ignorePackages", true);

          mpSBMLDocument->convert(prop);
        }

#else
      this->mpSBMLDocument->setLevelAndVersion(this->mSBMLLevel, this->mSBMLVersion);
#endif
    }

  if (this->mpSBMLDocument->getLevel() != this->mSBMLLevel || this->mpSBMLDocument->getVersion() != this->mSBMLVersion)
    {
      unsigned int i, iMax = this->mpSBMLDocument->getNumErrors();
      std::string message("libSBML could not convert the model to the requested level and/or version. The reason(s) given were:");

      for (i = 0; i < iMax ; ++i)
        {
          const XMLError* pSBMLError = this->mpSBMLDocument->getError(i);
          message += "\n";
          message += pSBMLError->getMessage();
        }

      CCopasiMessage(CCopasiMessage::EXCEPTION, message.c_str());
    }

  // remove mpAvogadro from the model again
  if (this->mAvogadroCreated == true)
    {
      std::map<const CCopasiObject*, SBase*>::iterator pos = this->mCOPASI2SBMLMap.find(this->mpAvogadro);
      this->mCOPASI2SBMLMap.erase(pos);
      dataModel.getModel()->removeModelValue(this->mpAvogadro->getKey(), true);
    }

  this->outputIncompatibilities();

  // if the model is incompatible with SBML export, throw an exception
  if (!this->mIncompatibilities.empty() && !this->mIncompleteExport)
    {
      CCopasiMessage(CCopasiMessage::EXCEPTION, "Model incompatible with chosen version and/or level of SBML.");
    }

  // if initial assignments were used we will have to add them to the document
  addInitialAssignmentsToModel(mpSBMLDocument, mInitialValueMap, dataModel);
  mInitialValueMap.clear();