SBMLImporter Class Reference

#include <SBMLImporter.h>

Inheritance diagram for SBMLImporter:

Public Member Functions
void	applyConversionFactors ()
virtual void	clearCallBack ()
void	deleteCopasiModel ()
std::string	findIdInASTTree (const ASTNode *pMath, const std::map< std::string, double > &reactionIds)
std::string	findIdInASTTree (const ASTNode *pMath, const std::set< std::string > &reactionIds)
bool	getImportCOPASIMIRIAM () const
const CProcessReport *	getProcessReport () const
CModel *	parseSBML (const std::string &sbmlDocumentText, SBMLDocument *&pSBMLDocument, std::map< const CDataObject *, SBase * > &copasi2sbmlmap, CListOfLayouts *&prLol, CDataModel *pDataModel)
CModel *	readSBML (std::string filename, SBMLDocument *&pSBMLDocument, std::map< const CDataObject *, SBase * > &copasi2sbmlmap, CListOfLayouts *&prLol, CDataModel *pDataModel)
void	restoreFunctionDB ()
	SBMLImporter ()
void	setImportCOPASIMIRIAM (bool import)
void	setImportHandler (CProcessReport *pProcessReport)
	~SBMLImporter ()
Public Member Functions inherited from SBMLUnitSupport
void	checkElementUnits (const Model *pSBMLModel, CModel *pCopasiModel)
bool	createUnitExpressionFor (SUnitInfo &unitInfo) const
const SUnitInfo &	importUnit (const std::string unitId, const Model *pSBMLModel)
const SUnitInfo &	importUnit (const UnitDefinition *pUnitDefinition, const bool &allocated)
void	importUnitsFromSBMLDocument (Model *sbmlModel, CModel *pCopasiModel)
	imports the units from the given sbml model More...
void	setLevelAndVersion (int level, int version)
bool	validateUnit (SUnitInfo &unitInfo, const std::string &constraint) const
	~SBMLUnitSupport ()

Static Public Member Functions
static bool	areApproximatelyEqual (const double &x, const double &y, const double &t=1e-9)
static bool	areEqualFunctions (const CFunction *pFun, const CFunction *pFun2)
static bool	areEqualSubtrees (const CEvaluationNode *pNode1, const CEvaluationNode *pNode2)
static bool	checkForUnitsOnNumbers (const ASTNode *pNode)
static CEvaluationNode *	divideByObject (const CEvaluationNode *pOrigNode, const CDataObject *pObject)
static bool	importNotes (CAnnotation *pAnno, const SBase *pSBase)
static bool	isEmptyOrWhiteSpace (const std::string &name)
static void	updateSBMLSpeciesReferenceIds (Model *pModel, std::map< std::string, double > &ids)
Static Public Member Functions inherited from SBMLUnitSupport
static bool	areSBMLUnitDefinitionsIdentical (const SUnitInfo &unitInfo1, const SUnitInfo &unitInfo2)
static void	checkForSpatialSizeUnits (const CDataModel &dataModel, std::vector< SBMLIncompatibility > &result)
static std::string	unitKindToString (UnitKind_t kind)

Protected Member Functions
void	applyStoichiometricExpressions (std::map< const CDataObject *, SBase * > &copasi2sbmlmap, Model *pSBMLModel)
void	areRulesUnique (const Model *copasiMode)
void	checkRuleMathConsistency (const Rule *pRule, std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
bool	checkValidityOfSourceDocument (SBMLDocument *sbmlDoc)
bool	containsVolume (const ASTNode *pNode, const std::string &compartmentCN)
std::map< std::string, ASTNode * >	createBVarMap (const ASTNode *uDefFunction, const ASTNode *function)
CCompartment *	createCCompartmentFromCompartment (const Compartment *sbmlComp, CModel *copasiModel, std::map< const CDataObject *, SBase * > &copasi2sbmlmap, const Model *pSBMLModel)
CFunction *	createCFunctionFromFunctionDefinition (const FunctionDefinition *sbmlFunction, Model *pSBMLModel, std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
CFunction *	createCFunctionFromFunctionTree (const FunctionDefinition *pSBMLFunction, Model *pSBMLModel, std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
CMetab *	createCMetabFromSpecies (const Species *sbmlSpecies, CModel *copasiModel, CCompartment *copasiCompartment, std::map< const CDataObject *, SBase * > &copasi2sbmlmap, const Model *pSBMLModel)
CModel *	createCModelFromSBMLDocument (SBMLDocument *doc, std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
CModelValue *	createCModelValueFromParameter (const Parameter *sbmlParameter, CModel *copasiModel, std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
CReaction *	createCReactionFromReaction (Reaction *sbmlReaction, Model *sbmlModel, CModel *cmodel, std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
void	createDelayFunctionDefinition ()
CEvaluationTree *	createExpressionFromFunction (const CFunction *pFun, const std::vector< std::vector< std::string > > &functionArgumentCNs)
void	createHasOnlySubstanceUnitFactor (Model *pSBMLModel, double factor, std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
bool	createProgressStepOrStop (unsigned C_INT32 globalStep, unsigned C_INT32 currentTotal, const std::string &title)
bool	divideByVolume (ASTNode *node, const std::string &compartmentSBMLId)
void	doMapping (CReaction *pCopasiReaction, const CEvaluationNodeCall *pCallNode)
void	find_local_parameters_in_delay (ASTNode *pNode, Reaction *pSBMLReaction, Model *pModel, std::map< std::string, std::string > &localReplacementMap, const std::set< std::string > &localIds, std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
void	findAvogadroConstant (Model *pSBMLModel, double factor)
CFunction *	findCorrespondingFunction (const CExpression *pExpression, const CReaction *reaction)
void	findFunctionCalls (const CEvaluationNode *pNode, std::set< std::string > &functionNameSet)
void	finishCurrentStep ()
void	finishImport ()
const FunctionDefinition *	getFunctionDefinitionForName (const std::string &name, const Model *model)
void	getIdsFromNode (const ASTNode *pNode, std::set< std::string > &idSet)
void	importEvent (const Event *pEvent, Model *pSBMLModel, CModel *pCopasiModel, std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
void	importEvents (Model *pSBMLModel, CModel *pCopasiModel, std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
void	importFunctionDefinitions (Model *pSBMLModel, std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
void	importInitialAssignments (Model *pSBMLModel, std::map< const CDataObject *, SBase * > &copasi2sbmlMap, const CModel *pCOPASIModel)
bool	importMIRIAM (const SBase *pSBMLObject, CDataObject *pCOPASIObject)
void	importRule (const Rule *rule, CModelEntity::Status ruleType, std::map< const CDataObject *, SBase * > &copasi2sbmlmap, Model *pSBMLModel)
void	importRuleForModelEntity (const Rule *rule, const CModelEntity *pMV, CModelEntity::Status ruleType, std::map< const CDataObject *, SBase * > &copasi2sbmlmap, Model *pSBMLModel)
void	importSBMLRule (const Rule *sbmlRule, std::map< const CDataObject *, SBase * > &copasi2sbmlmap, Model *pSBMLModel)
const CDataObject *	isConstantFlux (const CEvaluationNode *pRoot, CModel *pModel)
bool	isDelayFunctionUsed (ConverterASTNode *pNode)
std::vector< CEvaluationNodeObject * > *	isMassAction (const CEvaluationTree *pTree, const CChemEq &chemicalEquation, const CEvaluationNodeCall *pCallNode=NULL)
std::vector< CEvaluationNodeObject * > *	isMassActionExpression (const CEvaluationNode *pRootNode, const CChemEq &chemicalEquation)
std::vector< CEvaluationNodeObject * > *	isMassActionFunction (const CFunction *pFun, const CChemEq &chemicalEquation, const std::vector< std::vector< std::string > > &functionArgumentCNs)
bool	isSimpleFunctionCall (const CEvaluationNode *pRootNode)
bool	isStochasticModel (const Model *pSBMLModel)
void	multiplySubstanceOnlySpeciesByVolume (ConverterASTNode *pNode)
void	preprocessNode (ConverterASTNode *pNode, Model *pSBMLModel, std::map< const CDataObject *, SBase * > &copasi2sbmlmap, Reaction *pSBMLReaction=NULL)
bool	removeUnusedFunctions (std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
void	renameMassActionParameters (CEvaluationNodeCall *pCallNode)
void	replace_delay_nodes (ConverterASTNode *pNode, Model *pModel, std::map< const CDataObject *, SBase * > &copasi2sbmlmap, Reaction *pSBMLReaction, std::map< std::string, std::string > &localReplacementMap)
void	replace_name_nodes (ASTNode *pNode, const std::map< std::string, std::string > &replacementMap)
void	replace_time_with_initial_time (ASTNode *pNode, const CModel *pCOPASIModel)
void	replaceAmountReferences (ConverterASTNode *pNode, Model *pSBMLModel, double factor, std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
void	replaceCallNodeNames (ASTNode *pNode)
void	replaceLog (ConverterASTNode *sourceNode)
void	replaceObjectNames (ASTNode *pNode, const std::map< const CDataObject *, SBase * > &copasi2sbmlmap, bool initialExpression=false)
void	replacePowerFunctionNodes (ASTNode *node)
void	replaceRoot (ConverterASTNode *sourceNode)
void	replaceTimeAndAvogadroNodeNames (ASTNode *pNode)
void	replaceTimeDependentFunctionCalls (ASTNode *root)
bool	replaceTimeNodesInFunctionDefinition (ASTNode *root, std::string newNodeName)
bool	reportCurrentProgressOrStop ()
bool	sbmlId2CopasiCN (ASTNode *pNode, std::map< const CDataObject *, SBase * > &copasi2sbmlmap, CCopasiParameterGroup &pParamGroup, SBase *pParentObject=NULL)
void	separateProductArguments (const CEvaluationNode *pRootNode, std::vector< const CEvaluationNode * > &arguments)
void	setCorrectUsage (CReaction *pCopasiReaction, const CEvaluationNodeCall *pCallNode)
bool	setInitialValues (CModel *pModel, const std::map< const CDataObject *, SBase * > &copasi2sbmlmap)
CEvaluationNode *	variables2objects (const CEvaluationNode *pOrigNode, const std::map< std::string, std::string > &replacementMap)

Static Protected Member Functions
static void	findDirectDependencies (const ASTNode *pNode, std::set< std::string > &dependencies)
static void	findDirectDependencies (const FunctionDefinition *pFunDef, std::map< const FunctionDefinition *, std::set< std::string > > &dependencies)
static C_FLOAT64	round (const C_FLOAT64 &x)

Protected Attributes
bool	mAssignmentToSpeciesReferenceFound
bool	mAvogadroCreated
std::set< const CDataObject * >	mChangedObjects
std::map< const CChemEqElement *, std::pair< std::string, CChemEq::MetaboliteRole > >	mChemEqElementSpeciesIdMap
std::map< std::string, CCompartment * >	mCompartmentMap
bool	mConversionFactorFound
std::set< std::string >	mCreatedFunctions
unsigned C_INT32	mCurrentStepCounter
size_t	mCurrentStepHandle
unsigned C_INT32	mCurrentStepTotal
bool	mDelayFound
std::map< std::string, std::string >	mDelayNodeMap
std::set< std::string >	mDivisionByCompartmentReactions
bool	mEventAssignmentForSpeciesReferenceIgnored
std::set< std::string >	mExplicitelyTimeDependentFunctionDefinitions
std::set< std::string >	mFastReactions
std::map< std::string, std::string >	mFunctionNameMapping
unsigned C_INT32	mGlobalStepCounter
size_t	mGlobalStepHandle
unsigned C_INT32	mGlobalStepTotal
std::vector< std::string >	mIgnoredParameterUnits
std::set< unsigned int >	mIgnoredSBMLMessages
bool	mImportCOPASIMIRIAM
bool	mIncompleteModel
std::map< std::string, std::string >	mKnownCustomUserDefinedFunctions
std::map< std::string, std::string >	mKnownInitalValues
unsigned int	mOriginalLevel
std::map< std::string, CModelValue * >	mParameterFluxMap
CModel *	mpCopasiModel
CDataModel *	mpDataModel
const CModelValue *	mpModelConversionFactor
std::set< const Parameter * >	mPotentialAvogadroNumbers
CProcessReport *	mpProcessReport
SbmlProgressCallback *	mpSbmlCallback
bool	mRateRuleForSpeciesReferenceIgnored
std::set< std::string >	mReactions
std::set< std::string >	mReactionsWithReplacedLocalParameters
std::map< std::string, const CModelValue * >	mSBMLIdModelValueMap
std::map< std::string, double >	mSBMLSpeciesReferenceIds
std::map< std::string, const CModelValue * >	mSpeciesConversionParameterMap
std::map< const ASTNode *, const CChemEqElement * >	mStoichiometricExpressionMap
std::map< Species *, Compartment * >	mSubstanceOnlySpecies
bool	mUnitOnNumberFound
bool	mUnsupportedAssignmentRuleFound
bool	mUnsupportedRateRuleFound
bool	mUnsupportedRuleFound
std::set< std::string >	mUsedSBMLIds
bool	mUsedSBMLIdsPopulated
std::map< CFunction *, std::string >	sbmlIdMap
std::map< std::string, CMetab * >	speciesMap
Protected Attributes inherited from SBMLUnitSupport
bool	mAvogadroSet = false
unsigned int	mLevel = 0
unsigned int	mVersion = 0

Additional Inherited Members
Public Types inherited from SBMLUnitSupport
enum class	UnitType {   dimensionless , substance , time , volume ,   area , length , other , __SIZE }

Constructor & Destructor Documentation

SBMLImporter()

SBMLImporter::SBMLImporter

(

)

Constructor that initializes speciesMap and the FunctionDB object

References mAssignmentToSpeciesReferenceFound, mAvogadroCreated, mChemEqElementSpeciesIdMap, mConversionFactorFound, mDelayFound, mEventAssignmentForSpeciesReferenceIgnored, mIgnoredSBMLMessages, mIncompleteModel, mpModelConversionFactor, mpProcessReport, mRateRuleForSpeciesReferenceIgnored, mSBMLIdModelValueMap, mSpeciesConversionParameterMap, mUnitOnNumberFound, mUnsupportedAssignmentRuleFound, mUnsupportedRateRuleFound, mUnsupportedRuleFound, and speciesMap.

~SBMLImporter()

SBMLImporter::~SBMLImporter

(

)

Destructor that does nothing.

References mpSbmlCallback, and pdelete.

Member Function Documentation

applyConversionFactors()

void SBMLImporter::applyConversionFactors

(

)

This method checks if there are conversion factors that need to be applied to ChemicalEquationElements and applies them.

References CCopasiMessage::EXCEPTION, CModelEntity::getInitialValue(), mChemEqElementSpeciesIdMap, mpModelConversionFactor, mSpeciesConversionParameterMap, and CChemEq::setMultiplicity().

Referenced by createCModelFromSBMLDocument().

applyStoichiometricExpressions()

void SBMLImporter::applyStoichiometricExpressions ( std::map< const CDataObject *, SBase * > &  copasi2sbmlmap, Model *  pSBMLModel  )

protected

This method evaluates all stoichiometric expressions and sets them as constants on the CChemEqElement.

References CChemEq::addMetabolite(), CDataVector< CType >::begin(), CExpression::calcValue(), CExpression::compile(), CDataVector< CType >::end(), fatalError, CChemEqElement::getMetabolite(), CChemEqElement::getMetaboliteKey(), CChemEqElement::getMultiplicity(), CDataObject::getObjectParent(), CEvaluationTree::getRoot(), CModelEntity::getSBMLId(), CReaction::getSBMLId(), CChemEq::getSubstrates(), MCSBML, mpCopasiModel, mpDataModel, mStoichiometricExpressionMap, preprocessNode(), CChemEq::PRODUCT, replaceObjectNames(), CEvaluationTree::setTree(), CChemEq::SUBSTRATE, and CCopasiMessage::WARNING.

Referenced by createCModelFromSBMLDocument().

areApproximatelyEqual()

bool SBMLImporter::areApproximatelyEqual ( const double &  x, const double &  y, const double &  t = 1e-9  )

static

References min.

Referenced by findAvogadroConstant(), CEvaluationNodeFunction::fromAST(), isMassActionExpression(), and replaceAmountReferences().

areEqualFunctions()

bool SBMLImporter::areEqualFunctions ( const CFunction *  pFun, const CFunction *  pFun2  )

static

References areEqualSubtrees(), CDataObject::getObjectName(), CEvaluationTree::getRoot(), CFunctionParameter::getUsage(), CFunction::getVariables(), CFunctionParameters::size(), and CFunctionParameter::VARIABLE.

Referenced by createCFunctionFromFunctionDefinition(), findCorrespondingFunction(), and CReaction::setFunctionFromExpressionTree().

areEqualSubtrees()

bool SBMLImporter::areEqualSubtrees ( const CEvaluationNode *  pNode1, const CEvaluationNode *  pNode2  )

static

Compares to CEvaluationNode based subtrees recursively.

References CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getData(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::mainType(), and CEvaluationNode::subType().

Referenced by areEqualFunctions().

areRulesUnique()

void SBMLImporter::areRulesUnique ( const Model *  copasiMode )

protected

Checks if no id is used in more than one Assignment and RateRule.

References CCopasiMessage::EXCEPTION, and MCSBML.

Referenced by createCModelFromSBMLDocument().

checkForUnitsOnNumbers()

bool SBMLImporter::checkForUnitsOnNumbers ( const ASTNode *  pASTNode )

static

This method check if a unit has been set on a number node. If such a node is found in the tree, true is returned.

References CNodeContextIterator< Node, Context >::end(), and CNodeContextIterator< Node, Context >::next().

Referenced by preprocessNode().

checkRuleMathConsistency()

void SBMLImporter::checkRuleMathConsistency ( const Rule *  pRule, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap  )

protected

Checks the expression for a give rate or assignment rule for consistency. This basically means it checks that no id present in the expression is the target for one of the following rate or assignment rules.

References CCopasiMessage::EXCEPTION, fatalError, findIdInASTTree(), getIdsFromNode(), MCSBML, SBMLUnitSupport::mLevel, mpCopasiModel, mReactions, and SBMLUnitSupport::mVersion.

Referenced by importRuleForModelEntity().

checkValidityOfSourceDocument()

bool SBMLImporter::checkValidityOfSourceDocument ( SBMLDocument *  sbmlDoc )

protected

checks the given document, and if not valid stops

Parameters

sbmlDoc

the document to be checked

Returns

true if serious errors were encountered and importing stopped

References CCopasiMessage::ERROR, CCopasiMessage::ERROR_FILTERED, CCopasiMessage::EXCEPTION, finishCurrentStep(), finishImport(), CRootContainer::getConfiguration(), CDataModel::getReferenceDirectory(), MCSBML, MCXML, mIgnoredSBMLMessages, mpDataModel, CCopasiMessage::RAW, CCopasiMessage::WARNING, and CCopasiMessage::WARNING_FILTERED.

Referenced by parseSBML().

clearCallBack()

void SBMLImporter::clearCallBack ( )

virtual

clears the currently set progress handler

References setImportHandler().

containsVolume()

bool SBMLImporter::containsVolume ( const ASTNode *  pNode, const std::string &  compartmentCN  )

protected

Checks if the volume with the given CN is one of the parameters to the given call node.

createBVarMap()

std::map< std::string, ASTNode * > SBMLImporter::createBVarMap ( const ASTNode *  uDefFunction, const ASTNode *  function  )

protected

Creates a map of each parameter of the function definition and its corresponding parameter in the function call.

References fatalError.

createCCompartmentFromCompartment()

CCompartment * SBMLImporter::createCCompartmentFromCompartment ( const Compartment *  sbmlCompartment, CModel *  copasiModel, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap, const Model *  pSBMLModel  )

protected

Creates and returns a COPASI CCompartment from the SBML Compartment given as argument.

References C_INVALID_INDEX, CModel::createCompartment(), CModel::getCompartments(), CDataVectorN< CType >::getIndex(), CCompartment::getUnits(), importMIRIAM(), importNotes(), isEmptyOrWhiteSpace(), MCSBML, SBMLUnitSupport::mLevel, CCompartment::setDimensionality(), CModelEntity::setSBMLId(), and CCopasiMessage::WARNING.

Referenced by createCModelFromSBMLDocument().

createCFunctionFromFunctionDefinition()

CFunction * SBMLImporter::createCFunctionFromFunctionDefinition ( const FunctionDefinition *  sbmlFunction, Model *  pSBMLModel, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap  )

protected

Creates and returns a COPASI CFunction from the SBML FunctionDefinition given as argument.

References CFunctionDB::add(), addToKnownFunctionToMap(), areEqualFunctions(), createCFunctionFromFunctionTree(), ensureAllArgsAreBeingUsedInFunctionDefinition(), CCopasiMessage::EXCEPTION, findFunction(), CRootContainer::getFunctionList(), CDataObject::getObjectName(), CFunction::getSBMLId(), CEvaluationTree::getType(), importMIRIAM(), importNotes(), isEmptyOrWhiteSpace(), CFunctionDB::loadedFunctions(), mCreatedFunctions, MCSBML, mKnownCustomUserDefinedFunctions, pdelete, CDataObject::setObjectName(), CFunction::setSBMLId(), CDataVector< CType >::size(), and CEvaluationTree::UserDefined.

Referenced by importFunctionDefinitions().

createCFunctionFromFunctionTree()

CFunction * SBMLImporter::createCFunctionFromFunctionTree ( const FunctionDefinition *  pSBMLFunction, Model *  pSBMLModel, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap  )

protected

References CFunction::addVariable(), CEvaluationTree::compile(), CCopasiMessage::ERROR, CCopasiMessage::EXCEPTION, CEvaluationTree::getRoot(), isDelayFunctionUsed(), isEmptyOrWhiteSpace(), MCSBML, mExplicitelyTimeDependentFunctionDefinitions, preprocessNode(), ConverterASTNode::removeChild(), replaceTimeNodesInFunctionDefinition(), and CEvaluationTree::setTree().

Referenced by createCFunctionFromFunctionDefinition().

createCMetabFromSpecies()

CMetab * SBMLImporter::createCMetabFromSpecies ( const Species *  sbmlSpecies, CModel *  copasiModel, CCompartment *  copasiCompartment, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap, const Model *  pSBMLModel  )

protected

Creates and returns a COPASI CMetab from the given SBML Species object.

Creates and returns a Copasi CMetab from the given SBML Species object.

References C_INVALID_INDEX, CModel::createMetabolite(), fatalError, CModelEntity::FIXED, CDataVectorN< CType >::getIndex(), CCompartment::getMetabolites(), CDataObject::getObjectName(), importMIRIAM(), importNotes(), isEmptyOrWhiteSpace(), SBMLUnitSupport::mLevel, mSubstanceOnlySpecies, CModelEntity::REACTIONS, CModelEntity::setSBMLId(), and CModelEntity::setStatus().

Referenced by createCModelFromSBMLDocument().

createCModelFromSBMLDocument()

CModel * SBMLImporter::createCModelFromSBMLDocument ( SBMLDocument *  doc, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap  )

protected

Creates and returns a COPASI CModel from the SBMLDocument given as argument.

References CModel::appendAllDependents(), applyConversionFactors(), applyStoichiometricExpressions(), areRulesUnique(), CDataVector< CType >::begin(), C_INT32, C_INVALID_INDEX, CModel::compileIfNecessary(), CCore::Concentration, createCCompartmentFromCompartment(), createCMetabFromSpecies(), createCModelValueFromParameter(), createCReactionFromReaction(), createProgressStepOrStop(), CModel::deterministic, CDataVector< CType >::end(), CCopasiMessage::ERROR, CCopasiMessage::EXCEPTION, fatalError, findAvogadroConstant(), CDataObject::getCN(), CReaction::getFluxReference(), CRootContainer::getFunctionList(), getInitialCNForSBase(), CModelEntity::getModel(), CModel::getModelValues(), CDataContainer::getObject(), getOriginalSBMLId(), CModel::getQuantity2NumberFactor(), CModel::getReactions(), CFunction::getSBMLId(), CReaction::getSBMLId(), CCopasiMessage::getText(), importEvents(), importFunctionDefinitions(), importInitialAssignments(), importMIRIAM(), importNotes(), importSBMLRule(), SBMLUnitSupport::importUnitsFromSBMLDocument(), isEmptyOrWhiteSpace(), isStochasticModel(), CFunctionDB::loadedFunctions(), mAvogadroCreated, mCompartmentMap, mConversionFactorFound, MCSBML, mCurrentStepCounter, mCurrentStepHandle, mCurrentStepTotal, mDelayFound, mDivisionByCompartmentReactions, mEventAssignmentForSpeciesReferenceIgnored, mFastReactions, mIgnoredParameterUnits, mKnownInitalValues, SBMLUnitSupport::mLevel, mParameterFluxMap, mpCopasiModel, mpDataModel, mpModelConversionFactor, mPotentialAvogadroNumbers, mpProcessReport, mRateRuleForSpeciesReferenceIgnored, mReactions, mReactionsWithReplacedLocalParameters, mSBMLIdModelValueMap, mSBMLSpeciesReferenceIds, mSpeciesConversionParameterMap, mSubstanceOnlySpecies, mUnitOnNumberFound, mUnsupportedRuleFound, CCopasiMessage::peekLastMessage(), CModel::removeModelValue(), removeUnusedFunctions(), reportCurrentProgressOrStop(), sbmlIdMap, CModel::setAreaUnit(), setInitialValues(), CModel::setLengthUnit(), CModel::setModelType(), CDataObject::setObjectName(), CModel::setQuantityUnit(), CFunction::setSBMLId(), CModelEntity::setSBMLId(), CModel::setTimeUnit(), CModel::setVolumeUnit(), CDataVector< CType >::size(), speciesMap, CModel::stochastic, updateSBMLSpeciesReferenceIds(), and CCopasiMessage::WARNING.

Referenced by parseSBML().

createCModelValueFromParameter()

CModelValue * SBMLImporter::createCModelValueFromParameter ( const Parameter *  sbmlParameter, CModel *  copasiModel, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap  )

protected

Creates and returns a COPASI CModelValue from the given SBML Parameter object.

References C_INVALID_INDEX, CModel::createModelValue(), SBMLUnitSupport::SUnitInfo::expression, CDataVectorN< CType >::getIndex(), CModel::getModelValues(), importMIRIAM(), importNotes(), SBMLUnitSupport::importUnit(), isEmptyOrWhiteSpace(), SBMLUnitSupport::mLevel, mSBMLIdModelValueMap, CModelEntity::setSBMLId(), CModelEntity::setUnitExpression(), SBMLUnitSupport::unitKindToString(), and SBMLUnitSupport::SUnitInfo::valid.

Referenced by createCModelFromSBMLDocument(), createHasOnlySubstanceUnitFactor(), find_local_parameters_in_delay(), and replace_delay_nodes().

createCReactionFromReaction()

CReaction * SBMLImporter::createCReactionFromReaction ( Reaction *  sbmlReaction, Model *  pSBMLModel, CModel *  copasiModel, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap  )

protected

Creates and returns a COPASI CReaction object from the given SBML Reaction object.

References CEvaluationNodeCall::addChild(), CReaction::addModifier(), CCopasiParameterGroup::addParameter(), CReaction::addProduct(), CReaction::addSubstrate(), CModelEntity::ASSIGNMENT, CDataVector< CType >::begin(), C_FLOAT64, C_INVALID_INDEX, CEvaluationNode::copyBranch(), CModel::createModelValue(), CModel::createReaction(), divideByVolume(), doMapping(), CCopasiParameter::DOUBLE, CDataVector< CType >::end(), CCopasiMessage::EXCEPTION, CEvaluationNode::EXPRESSION, fatalError, findCorrespondingFunction(), CFunctionDB::findFunction(), findIdInASTTree(), CEvaluationTree::fromAST(), CReaction::getChemEq(), CCopasiNode< _Data >::getChild(), CDataObject::getCN(), CCopasiNode< _Data >::getData(), CCompartment::getDimensionality(), CRootContainer::getFunctionList(), CDataVectorN< CType >::getIndex(), CDataObject::getKey(), CChemEq::getModifiers(), CDataObject::getObjectName(), CDataObject::getObjectType(), CReaction::getParameters(), CChemEq::getProducts(), CModel::getReactions(), CEvaluationTree::getRoot(), CModelEntity::getSBMLId(), CCopasiNode< _Data >::getSibling(), CChemEq::getSubstrates(), CEvaluationTree::getType(), CFunction::getVariables(), importMIRIAM(), importNotes(), isConstantFlux(), isEmptyOrWhiteSpace(), isMassAction(), CReaction::isReversible(), isSimpleFunctionCall(), CFunction::isSuitable(), CFunctionDB::loadedFunctions(), CEvaluationNode::mainType(), mChemEqElementSpeciesIdMap, mCreatedFunctions, MCSBML, mDivisionByCompartmentReactions, mFastReactions, mIncompleteModel, SBMLUnitSupport::mLevel, mParameterFluxMap, mpCopasiModel, mpModelConversionFactor, mReactions, mSBMLSpeciesReferenceIds, mSpeciesConversionParameterMap, mStoichiometricExpressionMap, CEvaluationNode::OBJECT, pdelete, preprocessNode(), CChemEq::PRODUCT, renameMassActionParameters(), renameShadowingFluxReferences(), replace_name_nodes(), sbmlId2CopasiCN(), CReaction::setFunction(), CReaction::setFunctionFromExpressionTree(), CModelEntity::setInitialExpression(), CDataObject::setObjectName(), CReaction::setReversible(), CFunction::setReversible(), CEvaluationTree::setRoot(), CModelEntity::setSBMLId(), CReaction::setSBMLId(), CModelEntity::setStatus(), CDataVector< CType >::size(), CFunctionParameters::size(), speciesMap, CChemEq::SUBSTRATE, TriFalse, TriTrue, TriUnspecified, CEvaluationTree::UserDefined, variables2objects(), and CCopasiMessage::WARNING.

Referenced by createCModelFromSBMLDocument().

createDelayFunctionDefinition()

void SBMLImporter::createDelayFunctionDefinition ( )

protected

Creates a function definition for the delay function.

createExpressionFromFunction()

CEvaluationTree * SBMLImporter::createExpressionFromFunction ( const CFunction *  pFun, const std::vector< std::vector< std::string > > &  functionArgumentCNs  )

protected

References CEvaluationTree::create(), CEvaluationTree::Expression, CDataObject::getObjectName(), CEvaluationTree::getRoot(), CFunction::getVariables(), CEvaluationTree::setRoot(), CFunctionParameters::size(), and variables2objects().

Referenced by isMassActionFunction().

createHasOnlySubstanceUnitFactor()

void SBMLImporter::createHasOnlySubstanceUnitFactor ( Model *  pSBMLModel, double  factor, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap  )

protected

This method creates a global parameter the represents the factor that is used to convert a particle number into the amount units set on the model. The parameter is only created if it is needed and after exporting the model, the parameter is deleted from the COPASI model again.

References createCModelValueFromParameter(), mAvogadroCreated, mpCopasiModel, mPotentialAvogadroNumbers, and CModelEntity::setInitialValue().

Referenced by replaceAmountReferences().

createProgressStepOrStop()

bool SBMLImporter::createProgressStepOrStop ( unsigned C_INT32  globalStep, unsigned C_INT32  currentTotal, const std::string &  title  )

protected

This utility functions adds a new step to the progress dialog (if present)

Parameters

globalStep	the global steps that have been completed
currentTotal	the total for current task
title	the title of the current task

Returns

a boolean indicating whether processing should be stopped

References CProcessReport::addItem(), C_INVALID_INDEX, CProcessReport::finishItem(), mCurrentStepCounter, mCurrentStepHandle, mCurrentStepTotal, mGlobalStepCounter, mGlobalStepHandle, mpProcessReport, and CProcessReport::progressItem().

Referenced by createCModelFromSBMLDocument(), parseSBML(), and removeUnusedFunctions().

deleteCopasiModel()

void SBMLImporter::deleteCopasiModel

(

)

This call deletes an existing COPASI model. The method can e.g. be called to clean up if an import fails.

References mpCopasiModel.

Referenced by SEDMLImporter::importModel(), CDataModel::importSBML(), and CDataModel::importSBMLFromString().

divideByObject()

CEvaluationNode * SBMLImporter::divideByObject ( const CEvaluationNode *  pOrigNode, const CDataObject *  pObject  )

static

This method divides the given expression by the given object and returns a new expression. The caller is responsible for freeing the memory for the new expression.

References CCopasiNode< _Data >::addChild(), CEvaluationNode::CN, CEvaluationNode::copyBranch(), CEvaluationNode::DIVIDE, CCopasiNode< _Data >::getChild(), CDataObject::getCN(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::mainType(), CEvaluationNode::MULTIPLY, CEvaluationNode::OBJECT, CEvaluationNode::OPERATOR, and CEvaluationNode::subType().

Referenced by importEvent(), importInitialAssignments(), and importRuleForModelEntity().

divideByVolume()

bool SBMLImporter::divideByVolume ( ASTNode *  node, const std::string &  compartmentSBMLId  )

protected

Checks if a compartment size node occurs multiplicatively in the tree. If so, it is removed from the tree. If it returns false, the tree was not changed

Referenced by createCReactionFromReaction().

doMapping()

void SBMLImporter::doMapping ( CReaction *  pCopasiReaction, const CEvaluationNodeCall *  pCallNode  )

protected

References containsKey(), CObjectInterface::DataObject(), fatalError, CReaction::getChemEq(), CCopasiNode< _Data >::getChild(), CEvaluationNodeObject::getData(), CReaction::getFunction(), CDataObject::getKey(), CChemEq::getModifiers(), CDataObject::getObjectFromCN(), CDataObject::getObjectParent(), CDataObject::getObjectType(), CChemEq::getProducts(), CChemEq::getReversibility(), CCopasiNode< _Data >::getSibling(), CChemEq::getSubstrates(), CFunction::getVariables(), CDataObject::hasFlag(), CReaction::isReversible(), CFunctionParameter::MODIFIER, mpCopasiModel, CFunctionParameter::PARAMETER, CFunctionParameter::PRODUCT, CDataObject::Reference, CReaction::setParameterObjects(), CDataVector< CType >::size(), CFunctionParameters::size(), CFunctionParameter::SUBSTRATE, CFunctionParameter::TIME, CFunctionParameter::VARIABLE, and CFunctionParameter::VOLUME.

Referenced by createCReactionFromReaction().

find_local_parameters_in_delay()

void SBMLImporter::find_local_parameters_in_delay ( ASTNode *  pASTNode, Reaction *  pSBMLReaction, Model *  pModel, std::map< std::string, std::string > &  localReplacementMap, const std::set< std::string > &  localIds, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap  )

protected

If we replace delay nodes within kineitc laws, we have to make sure that there is no reference to a local parameter within the replaced delay node because that would mean that we end up with a reference to a local parameter in the rule for the delay replacement which is not allowed in SBML. Therefore we have to convert all local parameters which occur within a delay call into global parameters. This method finds all local parameters that have to be converted to global parameters and it already creates the necessary global parameters. The localReplacementMap returns a mapping between the is of the original parameter and the id of the new parameter it will be replaced with. This map is used in a second step to actually replace the nodes in the expression.

If we replace delay nodes within kinetic laws, we have to make sure that there is no reference to a local parameter within the replaced delay node because that would mean that we end up with a reference to a local parameter in the rule for the delay replacement which is not allowed in SBML. Therefore we have to convert all local parameters which occur within a delay call into global parameters.

References createCModelValueFromParameter(), CNodeContextIterator< Node, Context >::end(), CCopasiMessage::EXCEPTION, fatalError, mpCopasiModel, mUsedSBMLIds, and CNodeContextIterator< Node, Context >::next().

Referenced by replace_delay_nodes().

findAvogadroConstant()

void SBMLImporter::findAvogadroConstant ( Model *  pSBMLModel, double  factor  )

protected

This method goes through the list of global parameters and tries to find a parameter that could correspond to avogadros number.

References areApproximatelyEqual(), and mPotentialAvogadroNumbers.

Referenced by createCModelFromSBMLDocument().

findCorrespondingFunction()

CFunction * SBMLImporter::findCorrespondingFunction ( const CExpression *  pExpression, const CReaction *  pCopasiReaction  )

protected

The methods gets a function where all the parameters have a usage of "PARAMETER". In addition it get the root node of a call to that function which is an expression and contains the actual objects with which the function is called in a certain reaction. From this expression we can determine if there already is a function in the database that does the same. Or we can find out if this function is a Mass Action kinetic.

References areEqualFunctions(), C_INVALID_INDEX, CFunctionDB::findFunction(), CReaction::getChemEq(), CCopasiNode< _Data >::getData(), CRootContainer::getFunctionList(), CDataObject::getObjectName(), CReaction::getParameterIndex(), CChemEq::getProducts(), CEvaluationTree::getRoot(), CChemEq::getSubstrates(), CFunction::getVariables(), CReaction::isReversible(), CDataVector< CType >::size(), CEvaluationTree::size(), CFunctionParameters::size(), TriFalse, and TriTrue.

Referenced by createCReactionFromReaction().

findDirectDependencies() [1/2]

void SBMLImporter::findDirectDependencies ( const ASTNode *  pNode, std::set< std::string > &  dependencies  )

staticprotected

static method that recursively finds all direct function dependencies of the expression rooted at the given node.

References findDirectDependencies().

findDirectDependencies() [2/2]

void SBMLImporter::findDirectDependencies ( const FunctionDefinition *  pFunDef, std::map< const FunctionDefinition *, std::set< std::string > > &  dependencies  )

staticprotected

static method that finds all direct function dependencies of a given function definition.

Referenced by findDirectDependencies(), and importFunctionDefinitions().

findFunctionCalls()

void SBMLImporter::findFunctionCalls ( const CEvaluationNode *  pNode, std::set< std::string > &  functionNameSet  )

protected

Finds all functions calls directly or indirectly used in a function tree.

References CEvaluationNode::CALL, CFunctionDB::findFunction(), CRootContainer::getFunctionList(), CDataObject::getObjectName(), CEvaluationTree::getRoot(), and CDataContainer::insert().

Referenced by removeUnusedFunctions().

findIdInASTTree() [1/2]

std::string SBMLImporter::findIdInASTTree	(	const ASTNode *	pASTNode,
		const std::map< std::string, double > &	reactionIds
	)

This method takes an AST node and a set of ids and returns the first id from the set it finds in the AST tree. This is e.g. used to check if expression in L2V1 contain references to reaction ids.

References CNodeContextIterator< Node, Context >::end(), and CNodeContextIterator< Node, Context >::next().

findIdInASTTree() [2/2]

std::string SBMLImporter::findIdInASTTree	(	const ASTNode *	pMath,
		const std::set< std::string > &	reactionIds
	)

This method takes an AST node and a set of ids and returns the first id from the set it finds in the AST tree. This is e.g. used to check if expression in L2V1 contain references to reaction ids.

References CNodeContextIterator< Node, Context >::end(), and CNodeContextIterator< Node, Context >::next().

Referenced by checkRuleMathConsistency(), createCReactionFromReaction(), importEvent(), and importRuleForModelEntity().

finishCurrentStep()

void SBMLImporter::finishCurrentStep ( )

protected

Notifies the progress dialog that a step finished

References C_INVALID_INDEX, CProcessReport::finishItem(), mCurrentStepHandle, and mpProcessReport.

Referenced by checkValidityOfSourceDocument(), finishImport(), importEvents(), importInitialAssignments(), and removeUnusedFunctions().

finishImport()

void SBMLImporter::finishImport ( )

protected

Notifies the progress dialog that all importing is complete

References finishCurrentStep(), CProcessReport::finishItem(), mGlobalStepHandle, and mpProcessReport.

Referenced by checkValidityOfSourceDocument(), and parseSBML().

getFunctionDefinitionForName()

const FunctionDefinition * SBMLImporter::getFunctionDefinitionForName ( const std::string &  name, const Model *  sbmlModel  )

protected

Returns the user defined SBML function definition that belongs to the given name, or NULL if none can be found.

getIdsFromNode()

void SBMLImporter::getIdsFromNode ( const ASTNode *  pNode, std::set< std::string > &  idSet  )

protected

Recurses an ASTNode tree and gets all SBML Ids in the tree. The ids are stored in the given set.

References CNodeContextIterator< Node, Context >::end(), and CNodeContextIterator< Node, Context >::next().

Referenced by checkRuleMathConsistency().

getImportCOPASIMIRIAM()

bool SBMLImporter::getImportCOPASIMIRIAM

(

)

const

Returns the flag that determines whether COPASI MIRIAM annotation is imported if it is present.

References mImportCOPASIMIRIAM.

getProcessReport()

const CProcessReport * SBMLImporter::getProcessReport

(

)

const

Returns

the progress handler set

References mpProcessReport.

importEvent()

void SBMLImporter::importEvent ( const Event *  pEvent, Model *  pSBMLModel, CModel *  pCopasiModel, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap  )

protected

Imports the given event.

References CDataVectorN< CType >::add(), C_INVALID_INDEX, CEvaluationTree::create(), CModel::createEvent(), divideByObject(), CCopasiMessage::EXCEPTION, CEvaluationTree::Expression, fatalError, findIdInASTTree(), CEvent::getAssignments(), CDataObject::getCN(), CMetab::getCompartment(), CModel::getEvents(), CDataVectorN< CType >::getIndex(), CDataObject::getKey(), CDataObject::getObjectType(), CEvaluationTree::getRoot(), CCopasiMessage::getText(), CModelEntity::getValueReference(), hasCopasiAnnotation(), importMIRIAM(), importNotes(), isEmptyOrWhiteSpace(), MCSBML, mEventAssignmentForSpeciesReferenceIgnored, SBMLUnitSupport::mLevel, mSBMLSpeciesReferenceIds, pdelete, CCopasiMessage::peekLastMessage(), preprocessNode(), replaceObjectNames(), CEvent::setDelayAssignment(), CEvent::setDelayExpressionPtr(), CEventAssignment::setExpressionPtr(), CEvent::setFireAtInitialTime(), CExpression::setIsBoolean(), CEvent::setPersistentTrigger(), CEvent::setPriorityExpressionPtr(), CEvaluationTree::setRoot(), CEvent::setSBMLId(), CEvaluationTree::setTree(), CEvent::setTriggerExpressionPtr(), and CCopasiMessage::WARNING.

Referenced by importEvents().

importEvents()

void SBMLImporter::importEvents ( Model *  pSBMLModel, CModel *  pCopasiModel, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap  )

protected

Imports all events

References CCopasiMessage::EXCEPTION, finishCurrentStep(), CCopasiMessage::getText(), importEvent(), CCopasiMessage::peekLastMessage(), and reportCurrentProgressOrStop().

Referenced by createCModelFromSBMLDocument().

importFunctionDefinitions()

void SBMLImporter::importFunctionDefinitions ( Model *  pSBMLModel, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap  )

protected

Starting with SBML Level 2 Version 4, function definitions no longer need to be ordered, i.e. a function definition may refer to another function definition that is defined somewhere further down in the file. So we have to import the function definitions in the correct order.

References CEvaluationTree::compile(), createCFunctionFromFunctionDefinition(), CCopasiMessage::EXCEPTION, findDirectDependencies(), CDataObject::getObjectName(), CCopasiMessage::getText(), MCSBML, mFunctionNameMapping, mKnownCustomUserDefinedFunctions, CCopasiMessage::peekLastMessage(), and CFunction::setInfix().

Referenced by createCModelFromSBMLDocument().

importInitialAssignments()

void SBMLImporter::importInitialAssignments ( Model *  pSBMLModel, std::map< const CDataObject *, SBase * > &  copasi2sbmlMap, const CModel *  pCOPASIModel  )

protected

Imports all initial assignments if there are any.

References divideByObject(), CCopasiMessage::EXCEPTION, fatalError, finishCurrentStep(), CMetab::getCompartment(), CCompartment::getDimensionality(), CModelEntity::getInitialExpressionPtr(), CModelEntity::getInitialValueReference(), CEvaluationTree::getRoot(), CCopasiMessage::getText(), MCSBML, mKnownInitalValues, SBMLUnitSupport::mLevel, mSBMLSpeciesReferenceIds, mStoichiometricExpressionMap, CCopasiMessage::peekLastMessage(), preprocessNode(), CCopasiMessage::RAW, replace_time_with_initial_time(), replaceObjectNames(), reportCurrentProgressOrStop(), CModelEntity::setInitialExpressionPtr(), CEvaluationTree::setRoot(), CEvaluationTree::setTree(), and CCopasiMessage::WARNING.

Referenced by createCModelFromSBMLDocument().

importMIRIAM()

bool SBMLImporter::importMIRIAM ( const SBase *  pSBMLObject, CDataObject *  pCOPASIObject  )

protected

Imports the MIRIAM annotation from the given SBML object and sets it on the given COPASI object.

References CDataVector< CType >::begin(), CAnnotation::castObject(), CMIRIAMInfo::createBiologicalDescription(), CDataVector< CType >::end(), CMIRIAMInfo::getBiologicalDescriptions(), CFunction::getKey(), CAnnotation::getKey(), CReaction::getKey(), CModelEntity::getKey(), CAnnotation::getMiriamAnnotation(), CMIRIAMInfo::load(), mImportCOPASIMIRIAM, CMIRIAMInfo::save(), CRDFGraphConverter::SBML2Copasi(), CBiologicalDescription::setId(), CAnnotation::setMiriamAnnotation(), CBiologicalDescription::setPredicate(), and CBiologicalDescription::setResource().

Referenced by createCCompartmentFromCompartment(), createCFunctionFromFunctionDefinition(), createCMetabFromSpecies(), createCModelFromSBMLDocument(), createCModelValueFromParameter(), createCReactionFromReaction(), and importEvent().

importNotes()

bool SBMLImporter::importNotes ( CAnnotation *  pAnno, const SBase *  pSBase  )

static

This method reads the notes from an arbitrate SBase object and set them on the given CAnnotation instance.

References CAnnotation::addUnsupportedAnnotation(), and CAnnotation::setNotes().

Referenced by createCCompartmentFromCompartment(), createCFunctionFromFunctionDefinition(), createCMetabFromSpecies(), createCModelFromSBMLDocument(), createCModelValueFromParameter(), createCReactionFromReaction(), and importEvent().

importRule()

void SBMLImporter::importRule ( const Rule *  rule, CModelEntity::Status  ruleType, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap, Model *  pSBMLModel  )

protected

Imports the given RateRule if COPASI supports this kind of RateRule, otherwise a warning is created.

References CModelEntity::ASSIGNMENT, CCopasiMessage::ERROR, CCopasiMessage::EXCEPTION, fatalError, importRuleForModelEntity(), MCSBML, SBMLUnitSupport::mLevel, mOriginalLevel, mRateRuleForSpeciesReferenceIgnored, mSBMLSpeciesReferenceIds, mStoichiometricExpressionMap, CModelEntity::ODE, and CCopasiMessage::WARNING.

Referenced by importSBMLRule().

importRuleForModelEntity()

void SBMLImporter::importRuleForModelEntity ( const Rule *  rule, const CModelEntity *  pMV, CModelEntity::Status  ruleType, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap, Model *  pSBMLModel  )

protected

Imports the given AssignmentRule which is for a global parameter.

References checkRuleMathConsistency(), divideByObject(), CCopasiMessage::ERROR, fatalError, findIdInASTTree(), CModelEntity::FIXED, CCompartment::getDimensionality(), CModelEntity::getExpressionPtr(), CEvaluationTree::getRoot(), CModelEntity::getStatus(), CModelEntity::getValueReference(), MCSBML, CModelEntity::ODE, preprocessNode(), CCopasiMessage::RAW, replaceObjectNames(), CModelEntity::setExpressionPtr(), CEvaluationTree::setRoot(), CModelEntity::setStatus(), CEvaluationTree::setTree(), and CCopasiMessage::WARNING.

Referenced by importRule().

importSBMLRule()

void SBMLImporter::importSBMLRule ( const Rule *  sbmlRule, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap, Model *  pSBMLModel  )

protected

Imports the given Rule if COPASI supports this kind of Rule, otherwise a warning is created.

References CModelEntity::ASSIGNMENT, fatalError, importRule(), mUnsupportedRuleFound, and CModelEntity::ODE.

Referenced by createCModelFromSBMLDocument(), and replace_delay_nodes().

isConstantFlux()

const CDataObject * SBMLImporter::isConstantFlux ( const CEvaluationNode *  pRoot, CModel *  pModel  )

protected

Checks if the given node is an object node that represents a parameter or a model value or a function which has a single parameter and a single node which also represents a parameter.

References CEvaluationNode::CALL, CObjectInterface::DataObject(), CFunctionDB::findFunction(), CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getData(), CRootContainer::getFunctionList(), CDataObject::getObjectFromCN(), CDataObject::getObjectParent(), CEvaluationTree::getRoot(), CDataObject::hasFlag(), CEvaluationNode::mainType(), CEvaluationNode::OBJECT, CDataObject::Reference, and CEvaluationNode::VARIABLE.

Referenced by createCReactionFromReaction().

isDelayFunctionUsed()

bool SBMLImporter::isDelayFunctionUsed ( ConverterASTNode *  pNode )

protected

COPASI can not handle the delay function yet, so if it is used in some expression, we have to abort reading the file.

References CNodeContextIterator< Node, Context >::end(), and CNodeContextIterator< Node, Context >::next().

Referenced by createCFunctionFromFunctionTree(), and preprocessNode().

isEmptyOrWhiteSpace()

bool SBMLImporter::isEmptyOrWhiteSpace ( const std::string &  name )

static

Referenced by createCCompartmentFromCompartment(), createCFunctionFromFunctionDefinition(), createCFunctionFromFunctionTree(), createCMetabFromSpecies(), createCModelFromSBMLDocument(), createCModelValueFromParameter(), createCReactionFromReaction(), and importEvent().

isMassAction()

std::vector< CEvaluationNodeObject * > * SBMLImporter::isMassAction ( const CEvaluationTree *  pTree, const CChemEq &  chemicalEquation, const CEvaluationNodeCall *  pCallNode = NULL  )

protected

References CEvaluationTree::Expression, fatalError, CEvaluationTree::Function, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getData(), CEvaluationTree::getRoot(), CCopasiNode< _Data >::getSibling(), CEvaluationTree::getType(), isMassActionExpression(), isMassActionFunction(), CEvaluationNode::mainType(), CEvaluationNode::OBJECT, CEvaluationTree::PreDefined, and CEvaluationTree::UserDefined.

Referenced by createCReactionFromReaction().

isMassActionExpression()

std::vector< CEvaluationNodeObject * > * SBMLImporter::isMassActionExpression ( const CEvaluationNode *  pRootNode, const CChemEq &  chemicalEquation  )

protected

References CChemEq::addMetabolite(), areApproximatelyEqual(), CEvaluationNode::copyBranch(), CObjectInterface::DataObject(), CCopasiMessage::EXCEPTION, fatalError, CEvaluationNode::FUNCTION, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getData(), CChemEqElement::getMetaboliteKey(), CChemEqElement::getMultiplicity(), CDataObject::getObjectFromCN(), CDataObject::getObjectParent(), CChemEq::getProducts(), CChemEq::getReversibility(), CCopasiNode< _Data >::getSibling(), CChemEq::getSubstrates(), CEvaluationNode::getValuePointer(), CDataObject::hasFlag(), CEvaluationNode::mainType(), MCSBML, CEvaluationNode::MINUS, mpCopasiModel, CEvaluationNode::NUMBER, CEvaluationNode::OBJECT, CEvaluationNode::OPERATOR, pdelete, CEvaluationNode::POWER, CDataObject::Reference, separateProductArguments(), CDataVector< CType >::size(), CChemEq::SUBSTRATE, and CEvaluationNode::subType().

Referenced by isMassAction(), and isMassActionFunction().

isMassActionFunction()

std::vector< CEvaluationNodeObject * > * SBMLImporter::isMassActionFunction ( const CFunction *  pFun, const CChemEq &  chemicalEquation, const std::vector< std::vector< std::string > > &  functionArgumentCNs  )

protected

References createExpressionFromFunction(), CEvaluationTree::getRoot(), and isMassActionExpression().

Referenced by isMassAction().

isSimpleFunctionCall()

bool SBMLImporter::isSimpleFunctionCall ( const CEvaluationNode *  pRootNode )

protected

References CCopasiNode< _Data >::getChild(), and CCopasiNode< _Data >::getSibling().

Referenced by createCReactionFromReaction().

isStochasticModel()

bool SBMLImporter::isStochasticModel ( const Model *  pSBMLModel )

protected

Heuristically checks whether a model was meant to be simulated stochastically. If the substance units are set to items and all reaction are irreversible this function will return true;

Referenced by createCModelFromSBMLDocument().

multiplySubstanceOnlySpeciesByVolume()

void SBMLImporter::multiplySubstanceOnlySpeciesByVolume ( ConverterASTNode *  pNode )

protected

Multiplies all species nodes that belong to species with the hasSubstanceOnlyUnits flag set with the volume of the compartment that the species belongs to. This is only done for kineticLaw, all other mathematical expressions import those references as particle number nodes divided by the quantity2unit factor.

References CNodeIteratorMode::Before, CNodeContextIterator< Node, Context >::end(), mSubstanceOnlySpecies, CNodeContextIterator< Node, Context >::next(), pdelete, CNodeContextIterator< Node, Context >::setProcessingModes(), and CNodeContextIterator< Node, Context >::skipChildren().

Referenced by preprocessNode().

parseSBML()

CModel * SBMLImporter::parseSBML	(	const std::string &	sbmlDocumentText,
		SBMLDocument *&	pSBMLDocument,
		std::map< const CDataObject *, SBase * > &	copasi2sbmlmap,
		CListOfLayouts *&	prLol,
		CDataModel *	pDataModel
	)

Function parses an SBML document with libsbml and converts it to a COPASI CModel object which is returned. Deletion of the returned pointer is up to the caller.

References CProcessReport::addItem(), checkValidityOfSourceDocument(), createCModelFromSBMLDocument(), createProgressStepOrStop(), CCopasiMessage::ERROR, finishImport(), SBMLUnitSupport::mAvogadroSet, MCSBML, mCurrentStepCounter, mCurrentStepHandle, mCurrentStepTotal, mGlobalStepCounter, mGlobalStepHandle, mGlobalStepTotal, SBMLUnitSupport::mLevel, mOriginalLevel, mpCopasiModel, mpDataModel, mpProcessReport, mUsedSBMLIdsPopulated, SBMLUnitSupport::mVersion, SBMLDocumentLoader::readListOfLayouts(), and CProcessReport::setName().

Referenced by CDataModel::importSBMLFromString(), and readSBML().

preprocessNode()

void SBMLImporter::preprocessNode ( ConverterASTNode *  pNode, Model *  pSBMLModel, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap, Reaction *  pSBMLReaction = NULL  )

protected

In a preprocessing step each expression tree that is imported, e.g. for function definitions, rules, event or kinetic laws is preprocessed to replace some of the nodes data. See also replaceCallNodeNames and replaceTimeNodeNames.

References checkForUnitsOnNumbers(), SBMLUtils::collectIds(), CModel::getQuantity2NumberFactor(), isDelayFunctionUsed(), MCSBML, mDelayFound, SBMLUnitSupport::mLevel, mpCopasiModel, mReactionsWithReplacedLocalParameters, mSubstanceOnlySpecies, multiplySubstanceOnlySpeciesByVolume(), mUnitOnNumberFound, mUsedSBMLIds, mUsedSBMLIdsPopulated, pdelete, replace_delay_nodes(), replace_name_nodes(), replaceAmountReferences(), replaceCallNodeNames(), replaceTimeAndAvogadroNodeNames(), replaceTimeDependentFunctionCalls(), and CCopasiMessage::WARNING.

Referenced by applyStoichiometricExpressions(), createCFunctionFromFunctionTree(), createCReactionFromReaction(), importEvent(), importInitialAssignments(), and importRuleForModelEntity().

readSBML()

CModel * SBMLImporter::readSBML	(	std::string	filename,
		SBMLDocument *&	pSBMLDocument,
		std::map< const CDataObject *, SBase * > &	copasi2sbmlmap,
		CListOfLayouts *&	prLol,
		CDataModel *	pDataModel
	)

This functions replaces all species nodes for species that are in the substanceOnlySpeciesVector. With the node multiplied by the volume of the species compartment. void SBMLImporter::replaceSubstanceOnlySpeciesNodes(ConverterASTNode* node, const std::map<Species*, Compartment*>& substanceOnlySpecies) { if (node != NULL) { if (node->getType() == AST_NAME) { std::map<Species*, Compartment*>::const_iterator it = substanceOnlySpecies.begin(); std::map<Species*, Compartment*>::const_iterator endIt = substanceOnlySpecies.end(); while (it != endIt) { if (it->first->getId() == node->getName()) { replace node List* l = new List(); ConverterASTNode* child1 = new ConverterASTNode(AST_NAME); child1->setName(node->getName()); ConverterASTNode* child2 = new ConverterASTNode(AST_NAME); child2->setName(it->second->getId().c_str()); l->add(child1); l->add(child2); node->setChildren(l); node->setType(AST_TIMES); break; } ++it; } } else { unsigned int counter; for (counter = 0;counter < node->getNumChildren();counter++) { this->replaceSubstanceOnlySpeciesNodes((ConverterASTNode*)node->getChild(counter), substanceOnlySpecies); } } } } Function reads an SBML file with libsbml and converts it to a Copasi CModel

References CCopasiMessage::EXCEPTION, CLocaleString::fromUtf8(), MCSBML, and parseSBML().

Referenced by SEDMLImporter::importModel(), and CDataModel::importSBML().

removeUnusedFunctions()

bool SBMLImporter::removeUnusedFunctions ( std::map< const CDataObject *, SBase * > &  copasi2sbmlmap )

protected

Finds all functions that are used and removes those that are not.

References CModelEntity::ASSIGNMENT, C_INT32, createProgressStepOrStop(), findFunctionCalls(), finishCurrentStep(), CModelEntity::FIXED, CEvent::getAssignments(), CModel::getCompartments(), CEvent::getDelayExpressionPtr(), CModel::getEvents(), CEventAssignment::getExpressionPtr(), CModelEntity::getExpressionPtr(), CRootContainer::getFunctionList(), CModelEntity::getInitialExpressionPtr(), CModel::getMetabolites(), CModel::getModelValues(), CDataObject::getObjectName(), CModel::getReactions(), CEvaluationTree::getRoot(), CModelEntity::getStatus(), CEvent::getTriggerExpressionPtr(), CDataContainer::insert(), CFunctionDB::loadedFunctions(), mConversionFactorFound, mCreatedFunctions, mCurrentStepCounter, mpCopasiModel, CDataVectorN< CType >::remove(), reportCurrentProgressOrStop(), CDataVector< CType >::size(), and TriUnspecified.

Referenced by createCModelFromSBMLDocument().

renameMassActionParameters()

void SBMLImporter::renameMassActionParameters ( CEvaluationNodeCall *  pCallNode )

protected

References CObjectInterface::DataObject(), CCopasiNode< _Data >::getChild(), CDataObject::getCN(), CEvaluationNodeObject::getData(), CDataObject::getObjectFromCN(), CCopasiNode< _Data >::getSibling(), mpCopasiModel, CEvaluationNodeObject::setData(), and CDataObject::setObjectName().

Referenced by createCReactionFromReaction().

replace_delay_nodes()

void SBMLImporter::replace_delay_nodes ( ConverterASTNode *  pASTNode, Model *  pModel, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap, Reaction *  pSBMLReaction, std::map< std::string, std::string > &  localReplacementMap  )

protected

This function replaces calls to the delay function in an ASTNode tree by a node that references a new global parameter which the function creates. The global parameter gets an expression which corresponds to the delay call. This is necessary because all knetic laws in COPASI are function calls and function definitions should not contain a call to delay.

This function replaces calls to the delay function in an ASTNode tree by a node that references a new global parameter which the function creates. The global parameter gets an expression which corresponds to the delay call. This is necessary because all kinetic laws in COPASI are function calls and function definitions should not contain a call to delay.

References createCModelValueFromParameter(), CNodeContextIterator< Node, Context >::end(), CCopasiMessage::EXCEPTION, fatalError, find_local_parameters_in_delay(), importSBMLRule(), mDelayNodeMap, SBMLUnitSupport::mLevel, mpCopasiModel, mUsedSBMLIds, CNodeContextIterator< Node, Context >::next(), and replace_name_nodes().

Referenced by preprocessNode().

replace_name_nodes()

void SBMLImporter::replace_name_nodes ( ASTNode *  pASTNode, const std::map< std::string, std::string > &  replacementMap  )

protected

This method gets an ASTNode and a map between old node names and new node names. All AST_NAME nodes with an "old" name are replaced by a node with the "new" name.

References CNodeContextIterator< Node, Context >::end(), and CNodeContextIterator< Node, Context >::next().

Referenced by createCReactionFromReaction(), preprocessNode(), and replace_delay_nodes().

replace_time_with_initial_time()

void SBMLImporter::replace_time_with_initial_time ( ASTNode *  pASTNode, const CModel *  pCopasiModel  )

protected

If an initial expression uses time, we have to import it as initial time instead. This method takes an AST node and converts all time nodes to object nodes that have the common name of the time as the name.

References CNodeContextIterator< Node, Context >::end(), CDataObject::getCN(), CModelEntity::getInitialValueReference(), and CNodeContextIterator< Node, Context >::next().

Referenced by importInitialAssignments().

replaceAmountReferences()

void SBMLImporter::replaceAmountReferences ( ConverterASTNode *  pASTNode, Model *  pSBMLModel, double  factor, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap  )

protected

This method replaces references to the id of species which have the hasOnlySubstanceUnits flag set with the reference divided by avogadros number. The method tries to determine if there already is a multiplication with avogadros number and removes this multiplication rather than adding a new division.

This method replaces references to the id of species which have the hasOnlySubstanceUnits flag set with the reference divided by avogadros number.

References areApproximatelyEqual(), CNodeIteratorMode::Before, createHasOnlySubstanceUnitFactor(), CNodeContextIterator< Node, Context >::end(), mPotentialAvogadroNumbers, mSubstanceOnlySpecies, CNodeContextIterator< Node, Context >::next(), pdelete, CNodeContextIterator< Node, Context >::setProcessingModes(), and CNodeContextIterator< Node, Context >::skipChildren().

Referenced by preprocessNode().

replaceCallNodeNames()

void SBMLImporter::replaceCallNodeNames ( ASTNode *  pNode )

protected

Upon import a function object might change its name due to naming conflicts in the function database. So each ASTNode tree has its call node names replaced before it will be processed further.

References CNodeContextIterator< Node, Context >::end(), CCopasiMessage::EXCEPTION, mCreatedFunctions, MCSBML, mFunctionNameMapping, mKnownCustomUserDefinedFunctions, and CNodeContextIterator< Node, Context >::next().

Referenced by preprocessNode().

replaceLog()

void SBMLImporter::replaceLog ( ConverterASTNode *  sourceNode )

protected

This functions replaces all species nodes for species that are in the substanceOnlySpeciesVector. With the node multiplied by the volume of the species compartment. void replaceSubstanceOnlySpeciesNodes(ConverterASTNode* node, const std::map<Species*, Compartment*>& substanceOnlySpecies); Replaces all occurrences of the log function with two arguments by a division of two separate calls to log.

replaceObjectNames()

void SBMLImporter::replaceObjectNames ( ASTNode *  pNode, const std::map< const CDataObject *, SBase * > &  copasi2sbmlmap, bool  initialExpression = false  )

protected

References CNodeContextIterator< Node, Context >::end(), CCopasiMessage::EXCEPTION, fatalError, CDataObject::getCN(), CModelEntity::getSBMLId(), CReaction::getSBMLId(), MCSBML, mKnownInitalValues, mSBMLSpeciesReferenceIds, mSubstanceOnlySpecies, and CNodeContextIterator< Node, Context >::next().

Referenced by applyStoichiometricExpressions(), importEvent(), importInitialAssignments(), and importRuleForModelEntity().

replacePowerFunctionNodes()

void SBMLImporter::replacePowerFunctionNodes ( ASTNode *  node )

protected

Replaces the variables in a function definition with the actual function parameters that were used when the function was called. The function returns a pointer to the ConverterAST node with the replaced variables. This function replaces the AST_FUNCTION_POWER ASTNodes in a ASTNode tree with the AST_POWER node.

replaceRoot()

void SBMLImporter::replaceRoot ( ConverterASTNode *  sourceNode )

protected

Replaces all occurrences of the root function with two arguments by a call to the power function with the inverse of the first argument.

replaceTimeAndAvogadroNodeNames()

void SBMLImporter::replaceTimeAndAvogadroNodeNames ( ASTNode *  pNode )

protected

The data for a CEvaluationNodeObject needs to have the common name of the model it refers to as its data. Since this model is only known via a pointer in the SBMLImporter at the time of import, all AST_NAME_TIME nodes that are imported need to have their name replaced by the common name of this model. Starting with SBML Level 3 this also applies to the avogadro number.

References CNodeContextIterator< Node, Context >::end(), CDataContainer::getObject(), mpCopasiModel, and CNodeContextIterator< Node, Context >::next().

Referenced by preprocessNode().

replaceTimeDependentFunctionCalls()

void SBMLImporter::replaceTimeDependentFunctionCalls ( ASTNode *  root )

protected

This function replaces function calls to all functions listed in mExplicitelyTimeDependentFunctionDefinitions with the same call but an additional parameter which is the time. This replacement includes all model entities that have a mathematical expression, so depending on the version of SBML, this would include: initial assignments, rules, constraints, kinetic laws and events. The corresponding replacement for the function definitions is done in replaceTimeNodesInFunctionDefinition.

References CNodeContextIterator< Node, Context >::end(), mExplicitelyTimeDependentFunctionDefinitions, and CNodeContextIterator< Node, Context >::next().

Referenced by preprocessNode().

replaceTimeNodesInFunctionDefinition()

bool SBMLImporter::replaceTimeNodesInFunctionDefinition ( ASTNode *  pASTNode, std::string  newNodeName  )

protected

For function definitions that use the time symbol we have to make this a variable that is passed to the function instead. The function recursively goes through the AST tree rooted in root and changes all time nodes to variable nodes with name newNodeName. If a time node has been found, the function return true, otherwise false is returned.

For function definitions that use the time symbol we have to make this a variable that is passed to the function instead. The function recursively goes through the AST tree rooted in root and changes all time nodes to variable nodes with name newNodeName. Additionally all function calls to functions in mExplicitelyTimeDependentFunctionDefinitions have to be changed to contain the added parameter. If a time node has been found, the function returns true, otherwise false is returned.

References CNodeContextIterator< Node, Context >::end(), mExplicitelyTimeDependentFunctionDefinitions, and CNodeContextIterator< Node, Context >::next().

Referenced by createCFunctionFromFunctionTree().

reportCurrentProgressOrStop()

bool SBMLImporter::reportCurrentProgressOrStop ( )

protected

Notifies the progress dialog of local progress

Returns

a boolean indicating whether processing should be stopped

Creates and returns a Copasi CModel from the SBMLDocument given as argument.

References mCurrentStepHandle, mpProcessReport, and CProcessReport::progressItem().

Referenced by createCModelFromSBMLDocument(), importEvents(), importInitialAssignments(), and removeUnusedFunctions().

restoreFunctionDB()

void SBMLImporter::restoreFunctionDB

(

)

References CFunctionDB::findFunction(), CRootContainer::getFunctionList(), CDataObject::getKey(), CEvaluationTree::getType(), mCreatedFunctions, CFunctionDB::removeFunction(), sbmlIdMap, and CEvaluationTree::UserDefined.

Referenced by SEDMLImporter::importModel(), CDataModel::importSBML(), and CDataModel::importSBMLFromString().

round()

C_FLOAT64 SBMLImporter::round ( const C_FLOAT64 &  x )

staticprotected

sbmlId2CopasiCN()

bool SBMLImporter::sbmlId2CopasiCN ( ASTNode *  pNode, std::map< const CDataObject *, SBase * > &  copasi2sbmlmap, CCopasiParameterGroup &  pParamGroup, SBase *  pParentObject = NULL  )

protected

Replaces the ids of named nodes in an ASTNode tree with the correspondingCopasi Common Names.

References CDataObject::getCN(), CCopasiParameter::getCN(), CReaction::getObject(), CDataContainer::getObject(), CCopasiParameterGroup::getParameter(), CModelEntity::getValueReference(), SBMLUnitSupport::mLevel, and mSBMLSpeciesReferenceIds.

Referenced by createCReactionFromReaction().

separateProductArguments()

void SBMLImporter::separateProductArguments ( const CEvaluationNode *  pRootNode, std::vector< const CEvaluationNode * > &  arguments  )

protected

This function takes a node and tries to find out whether the tree under this node consists only of multiply operators and object nodes. The arguments to the multiply operators are returned.

References CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::MULTIPLY, CEvaluationNode::POWER, and CEvaluationNode::subType().

Referenced by isMassActionExpression().

setCorrectUsage()

void SBMLImporter::setCorrectUsage ( CReaction *  pCopasiReaction, const CEvaluationNodeCall *  pCallNode  )

protected

References CObjectInterface::DataObject(), fatalError, CReaction::getChemEq(), CCopasiNode< _Data >::getChild(), CEvaluationNodeObject::getData(), CReaction::getFunction(), CChemEq::getModifiers(), CDataObject::getObjectFromCN(), CDataObject::getObjectParent(), CChemEq::getProducts(), CCopasiNode< _Data >::getSibling(), CChemEq::getSubstrates(), CFunction::getVariables(), CFunctionParameter::MODIFIER, CChemEq::MODIFIER, mpCopasiModel, CFunctionParameter::PARAMETER, CFunctionParameter::PRODUCT, CChemEq::PRODUCT, CFunctionParameter::setUsage(), CDataVector< CType >::size(), CFunctionParameter::SUBSTRATE, CChemEq::SUBSTRATE, and CFunctionParameter::VOLUME.

setImportCOPASIMIRIAM()

void SBMLImporter::setImportCOPASIMIRIAM

(

bool

import

)

Sets the flag that determines whether COPASI MIRIAM annotation is imported if it is present.

References mImportCOPASIMIRIAM.

Referenced by SEDMLImporter::importModel(), CDataModel::importSBML(), and CDataModel::importSBMLFromString().

setImportHandler()

void SBMLImporter::setImportHandler

(

CProcessReport *

pProcessReport

)

sets a progress handler to inform about updates

References mpProcessReport, mpSbmlCallback, and pdelete.

Referenced by clearCallBack(), SEDMLImporter::importModel(), CDataModel::importSBML(), and CDataModel::importSBMLFromString().

setInitialValues()

bool SBMLImporter::setInitialValues ( CModel *  pModel, const std::map< const CDataObject *, SBase * > &  copasi2sbmlmap  )

protected

Sets the initial values on compartments, metabolites and model values if those initial values have been set in the SBML model. Otherwise the routine checks if a rule or an initial assignment has been set for the entity. If the entity has not been set in any way, an error message is created.

References CModelEntity::ASSIGNMENT, CDataVector< CType >::begin(), CObjectInterface::DataObject(), CDataVector< CType >::empty(), CDataVector< CType >::end(), CModelEntity::FIXED, CModel::getCompartments(), CModel::getMetabolites(), CModel::getModelValues(), CDataContainer::getObject(), CModel::getQuantity2NumberFactor(), mChangedObjects, MCSBML, mIncompleteModel, SBMLUnitSupport::mLevel, CModelEntity::ODE, CModelEntity::REACTIONS, CModel::updateInitialValues(), and CCopasiMessage::WARNING.

Referenced by createCModelFromSBMLDocument().

updateSBMLSpeciesReferenceIds()

void SBMLImporter::updateSBMLSpeciesReferenceIds ( Model *  pModel, std::map< std::string, double > &  ids  )

static

Goes through all SBML reactions and collects the ids of all species references.

Referenced by createCModelFromSBMLDocument().

variables2objects()

CEvaluationNode * SBMLImporter::variables2objects ( const CEvaluationNode *  pOrigNode, const std::map< std::string, std::string > &  replacementMap  )

protected

References CCopasiNode< _Data >::addChild(), CEvaluationNode::CN, CEvaluationNode::create(), fatalError, CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getData(), CCopasiNode< _Data >::getSibling(), CEvaluationNode::mainType(), and CEvaluationNode::subType().

Referenced by createCReactionFromReaction(), and createExpressionFromFunction().

Member Data Documentation

mAssignmentToSpeciesReferenceFound

bool SBMLImporter::mAssignmentToSpeciesReferenceFound

protected

Referenced by SBMLImporter().

mAvogadroCreated

bool SBMLImporter::mAvogadroCreated

protected

Referenced by createCModelFromSBMLDocument(), createHasOnlySubstanceUnitFactor(), and SBMLImporter().

mChangedObjects

std::set<const CDataObject*> SBMLImporter::mChangedObjects

protected

Referenced by setInitialValues().

mChemEqElementSpeciesIdMap

std::map<const CChemEqElement*, std::pair<std::string, CChemEq::MetaboliteRole> > SBMLImporter::mChemEqElementSpeciesIdMap

protected

Referenced by applyConversionFactors(), createCReactionFromReaction(), and SBMLImporter().

mCompartmentMap

std::map<std::string, CCompartment*> SBMLImporter::mCompartmentMap

protected

Referenced by createCModelFromSBMLDocument().

mConversionFactorFound

bool SBMLImporter::mConversionFactorFound

protected

Referenced by createCModelFromSBMLDocument(), removeUnusedFunctions(), and SBMLImporter().

mCreatedFunctions

std::set<std::string> SBMLImporter::mCreatedFunctions

protected

Referenced by createCFunctionFromFunctionDefinition(), createCReactionFromReaction(), removeUnusedFunctions(), replaceCallNodeNames(), and restoreFunctionDB().

mCurrentStepCounter

unsigned C_INT32 SBMLImporter::mCurrentStepCounter

protected

current step counter for current import

Referenced by createCModelFromSBMLDocument(), createProgressStepOrStop(), parseSBML(), and removeUnusedFunctions().

mCurrentStepHandle

size_t SBMLImporter::mCurrentStepHandle

protected

the current import step handle

Referenced by createCModelFromSBMLDocument(), createProgressStepOrStop(), finishCurrentStep(), parseSBML(), and reportCurrentProgressOrStop().

mCurrentStepTotal

unsigned C_INT32 SBMLImporter::mCurrentStepTotal

protected

total steps of current import task

Referenced by createCModelFromSBMLDocument(), createProgressStepOrStop(), and parseSBML().

mDelayFound

bool SBMLImporter::mDelayFound

protected

Referenced by createCModelFromSBMLDocument(), preprocessNode(), and SBMLImporter().

mDelayNodeMap

std::map<std::string, std::string> SBMLImporter::mDelayNodeMap

protected

Referenced by replace_delay_nodes().

mDivisionByCompartmentReactions

std::set<std::string> SBMLImporter::mDivisionByCompartmentReactions

protected

Referenced by createCModelFromSBMLDocument(), and createCReactionFromReaction().

mEventAssignmentForSpeciesReferenceIgnored

bool SBMLImporter::mEventAssignmentForSpeciesReferenceIgnored

protected

Referenced by createCModelFromSBMLDocument(), importEvent(), and SBMLImporter().

mExplicitelyTimeDependentFunctionDefinitions

std::set<std::string> SBMLImporter::mExplicitelyTimeDependentFunctionDefinitions

protected

Referenced by createCFunctionFromFunctionTree(), replaceTimeDependentFunctionCalls(), and replaceTimeNodesInFunctionDefinition().

mFastReactions

std::set<std::string> SBMLImporter::mFastReactions

protected

Referenced by createCModelFromSBMLDocument(), and createCReactionFromReaction().

mFunctionNameMapping

std::map<std::string, std::string> SBMLImporter::mFunctionNameMapping

protected

Referenced by importFunctionDefinitions(), and replaceCallNodeNames().

mGlobalStepCounter

unsigned C_INT32 SBMLImporter::mGlobalStepCounter

protected

global step counter

Referenced by createProgressStepOrStop(), and parseSBML().

mGlobalStepHandle

size_t SBMLImporter::mGlobalStepHandle

protected

the global import step handle

Referenced by createProgressStepOrStop(), finishImport(), and parseSBML().

mGlobalStepTotal

unsigned C_INT32 SBMLImporter::mGlobalStepTotal

protected

total step counter for global import

Referenced by parseSBML().

mIgnoredParameterUnits

std::vector<std::string> SBMLImporter::mIgnoredParameterUnits

protected

Referenced by createCModelFromSBMLDocument().

mIgnoredSBMLMessages

std::set<unsigned int> SBMLImporter::mIgnoredSBMLMessages

protected

Referenced by checkValidityOfSourceDocument(), and SBMLImporter().

mImportCOPASIMIRIAM

bool SBMLImporter::mImportCOPASIMIRIAM

protected

Referenced by getImportCOPASIMIRIAM(), importMIRIAM(), and setImportCOPASIMIRIAM().

mIncompleteModel

bool SBMLImporter::mIncompleteModel

protected

Referenced by createCReactionFromReaction(), SBMLImporter(), and setInitialValues().

mKnownCustomUserDefinedFunctions

std::map<std::string, std::string> SBMLImporter::mKnownCustomUserDefinedFunctions

protected

Referenced by createCFunctionFromFunctionDefinition(), importFunctionDefinitions(), and replaceCallNodeNames().

mKnownInitalValues

std::map<std::string, std::string> SBMLImporter::mKnownInitalValues

protected

Referenced by createCModelFromSBMLDocument(), importInitialAssignments(), and replaceObjectNames().

mOriginalLevel

unsigned int SBMLImporter::mOriginalLevel

protected

Referenced by importRule(), and parseSBML().

mParameterFluxMap

std::map<std::string, CModelValue*> SBMLImporter::mParameterFluxMap

protected

Referenced by createCModelFromSBMLDocument(), and createCReactionFromReaction().

mpCopasiModel

CModel* SBMLImporter::mpCopasiModel

protected

Referenced by applyStoichiometricExpressions(), checkRuleMathConsistency(), createCModelFromSBMLDocument(), createCReactionFromReaction(), createHasOnlySubstanceUnitFactor(), deleteCopasiModel(), doMapping(), find_local_parameters_in_delay(), isMassActionExpression(), parseSBML(), preprocessNode(), removeUnusedFunctions(), renameMassActionParameters(), replace_delay_nodes(), replaceTimeAndAvogadroNodeNames(), and setCorrectUsage().

mpDataModel

CDataModel* SBMLImporter::mpDataModel

protected

Referenced by applyStoichiometricExpressions(), checkValidityOfSourceDocument(), createCModelFromSBMLDocument(), and parseSBML().

mpModelConversionFactor

const CModelValue* SBMLImporter::mpModelConversionFactor

protected

Referenced by applyConversionFactors(), createCModelFromSBMLDocument(), createCReactionFromReaction(), and SBMLImporter().

mPotentialAvogadroNumbers

std::set<const Parameter*> SBMLImporter::mPotentialAvogadroNumbers

protected

Referenced by createCModelFromSBMLDocument(), createHasOnlySubstanceUnitFactor(), findAvogadroConstant(), and replaceAmountReferences().

mpProcessReport

CProcessReport* SBMLImporter::mpProcessReport

protected

the import handler

Referenced by createCModelFromSBMLDocument(), createProgressStepOrStop(), finishCurrentStep(), finishImport(), getProcessReport(), parseSBML(), reportCurrentProgressOrStop(), SBMLImporter(), and setImportHandler().

mpSbmlCallback

SbmlProgressCallback* SBMLImporter::mpSbmlCallback

protected

Referenced by setImportHandler(), and ~SBMLImporter().

mRateRuleForSpeciesReferenceIgnored

bool SBMLImporter::mRateRuleForSpeciesReferenceIgnored

protected

Referenced by createCModelFromSBMLDocument(), importRule(), and SBMLImporter().

mReactions

std::set<std::string> SBMLImporter::mReactions

protected

Referenced by checkRuleMathConsistency(), createCModelFromSBMLDocument(), and createCReactionFromReaction().

mReactionsWithReplacedLocalParameters

std::set<std::string> SBMLImporter::mReactionsWithReplacedLocalParameters

protected

Referenced by createCModelFromSBMLDocument(), and preprocessNode().

mSBMLIdModelValueMap

std::map<std::string, const CModelValue*> SBMLImporter::mSBMLIdModelValueMap

protected

Referenced by createCModelFromSBMLDocument(), createCModelValueFromParameter(), and SBMLImporter().

mSBMLSpeciesReferenceIds

std::map<std::string, double> SBMLImporter::mSBMLSpeciesReferenceIds

protected

Referenced by createCModelFromSBMLDocument(), createCReactionFromReaction(), importEvent(), importInitialAssignments(), importRule(), replaceObjectNames(), and sbmlId2CopasiCN().

mSpeciesConversionParameterMap

std::map<std::string, const CModelValue*> SBMLImporter::mSpeciesConversionParameterMap

protected

Referenced by applyConversionFactors(), createCModelFromSBMLDocument(), createCReactionFromReaction(), and SBMLImporter().

mStoichiometricExpressionMap

std::map<const ASTNode*, const CChemEqElement* > SBMLImporter::mStoichiometricExpressionMap

protected

Referenced by applyStoichiometricExpressions(), createCReactionFromReaction(), importInitialAssignments(), and importRule().

mSubstanceOnlySpecies

std::map<Species*, Compartment*> SBMLImporter::mSubstanceOnlySpecies

protected

Referenced by createCMetabFromSpecies(), createCModelFromSBMLDocument(), multiplySubstanceOnlySpeciesByVolume(), preprocessNode(), replaceAmountReferences(), and replaceObjectNames().

mUnitOnNumberFound

bool SBMLImporter::mUnitOnNumberFound

protected

Referenced by createCModelFromSBMLDocument(), preprocessNode(), and SBMLImporter().

mUnsupportedAssignmentRuleFound

bool SBMLImporter::mUnsupportedAssignmentRuleFound

protected

Referenced by SBMLImporter().

mUnsupportedRateRuleFound

bool SBMLImporter::mUnsupportedRateRuleFound

protected

Referenced by SBMLImporter().

mUnsupportedRuleFound

bool SBMLImporter::mUnsupportedRuleFound

protected

Referenced by createCModelFromSBMLDocument(), importSBMLRule(), and SBMLImporter().

mUsedSBMLIds

std::set<std::string> SBMLImporter::mUsedSBMLIds

protected

Referenced by find_local_parameters_in_delay(), preprocessNode(), and replace_delay_nodes().

mUsedSBMLIdsPopulated

bool SBMLImporter::mUsedSBMLIdsPopulated

protected

Referenced by parseSBML(), and preprocessNode().

sbmlIdMap

std::map<CFunction*, std::string> SBMLImporter::sbmlIdMap

protected

Referenced by createCModelFromSBMLDocument(), and restoreFunctionDB().

speciesMap

std::map<std::string, CMetab*> SBMLImporter::speciesMap

protected

Referenced by createCModelFromSBMLDocument(), createCReactionFromReaction(), and SBMLImporter().

---

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

• SBMLImporter.h
• SBMLImporter.cpp