#include <CDimension.h>

Collaboration diagram for CFindDimensions:

Public Member Functions
	CFindDimensions (const CFunction *function, bool d1, bool d2, bool d3, bool d4, bool d5)

void	findDimensions (CDimension rootDim)

void	findDimensions (bool isMulticompartment)

std::vector< std::string >	findDimensionsBoth (const CModel *pModel)

const std::vector< CDimension > &	getDimensions () const

void	setChemicalEquation (const CChemEq *eq)

void	setMolecularitiesForMassAction (const size_t &m1, const size_t &m2)

void	setupDimensions ()

void	setUseHeuristics (bool flag)

Private Member Functions
	CFindDimensions ()

void	findDimension (size_t index)
	find dim for one parameter More...

CDimension	findDimension (const CEvaluationNode node, const CEvaluationNode requestingNode=NULL)

void	findDimensions ()
	find dim for all parameters More...

void	findDimensionsMassAction ()

Private Attributes
bool	mD1

bool	mD2

bool	mD3

bool	mD4

bool	mD5

std::vector< CDimension >	mDimensions

C_FLOAT64	mM1

C_FLOAT64	mM2

const CFunction *	mpFunction

CDimension	mRootDimension

bool	mUseHeuristics

Detailed Description

CFindDimensions class. The class tries to find the dimensions of the "PARAMETER" variable nodes in a function tree.

The function is specified in the constructor. After that the dimension of the root node has to be specified. This can be done with either of the two public findDimensions() methods. The result can be retrieved using the getDimensions() method.

Definition at line 107 of file CDimension.h.

Constructor & Destructor Documentation

CFindDimensions::CFindDimensions ( )

private

CFindDimensions::CFindDimensions	(	const CFunction *	function,
		bool	d1,
		bool	d2,
		bool	d3,
		bool	d4,
		bool	d5
	)

construct the class for a given function. d1,d2,d3, d4, d5 indicate if the base unit (for quantity, volume, time, area, length) is dimensionless

Definition at line 285 of file CDimension.cpp.

References setupDimensions().

   : mpFunction(function),
     mRootDimension(),
     mUseHeuristics(false),
     mM1(-1.0), mM2(-1.0),
     mD1(d1), mD2(d2), mD3(d3), mD4(d4), mD5(d5)
 {
   setupDimensions();
 }

Member Function Documentation

void CFindDimensions::findDimension ( size_t index )

private

find dim for one parameter

Definition at line 453 of file CDimension.cpp.

References CDimension::compare(), CEvaluationTree::getNodeList(), mDimensions, mpFunction, and CEvaluationNode::VARIABLE.

Referenced by findDimension(), and findDimensions().

 {
   if (!mpFunction) return;
 
   if (index >= mDimensions.size()) return;
 
   CDimension result;
 
   //find all variable nodes with given index
   std::vector<const CEvaluationNode*> nodes;
   const std::vector< CEvaluationNode * > & allnodes = mpFunction->getNodeList();
   std::vector< CEvaluationNode * >::const_iterator it, itEnd = allnodes.end();
 
   for (it = allnodes.begin(); it != itEnd; ++it)
     {
       if ((*it)->getType() == CEvaluationNode::VARIABLE)
         if (dynamic_cast<const CEvaluationNodeVariable*>(*it)->getIndex() == index)
           {
             nodes.push_back(*it);
           }
     }
 
   //find dimension for all nodes and compare results
   std::vector<const CEvaluationNode * >::const_iterator it2, it2End = nodes.end();
 
   for (it2 = nodes.begin(); it2 != it2End; ++it2)
     {
       result = result.compare(findDimension(*it2));
     }
 
   mDimensions[index] = result;
 }

CDimension CFindDimensions::findDimension	(	const CEvaluationNode *	node,
		const CEvaluationNode *	requestingNode = `NULL`
	)

private

Definition at line 486 of file CDimension.cpp.

References CDimension::compare(), CEvaluationNodeOperator::DIVIDE, fatalError, findDimension(), CEvaluationNodeVariable::getIndex(), CEvaluationNodeOperator::getLeft(), CCopasiNode< _Data >::getParent(), CEvaluationNodeOperator::getRight(), CEvaluationNode::getType(), CEvaluationNode::getValue(), mDimensions, CEvaluationNodeOperator::MINUS, mRootDimension, CEvaluationNodeOperator::MULTIPLY, mUseHeuristics, CEvaluationNodeOperator::PLUS, CDimension::setDimension(), and CDimension::setUnknown().

 {
   CDimension result;
 
   //variable node
   const CEvaluationNodeVariable* varnode = dynamic_cast<const CEvaluationNodeVariable*>(node);
 
   if (varnode)
     {
       //is dim known?
       if (!mDimensions[varnode->getIndex()].isUnknown())
         result = mDimensions[varnode->getIndex()];
 
       else if (requestingNode) //do not try to evaluate dim recursively if asked by parent node
         {
           if (node->getParent())
             result.setUnknown();
           else //no parent
             fatalError();
         }
       else // !requestingNode; method is called from outside, evaluate recursively
         {
           if (node->getParent())
             {
               const CEvaluationNode* parent = dynamic_cast<const CEvaluationNode*>(node->getParent());
 
               if (parent) result = findDimension(parent, node);
             }
           else //no parent, use root dimension
             {
               result = mRootDimension;
             }
         }
     }
 
   //operator node
   const CEvaluationNodeOperator* opnode = dynamic_cast<const CEvaluationNodeOperator*>(node);
 
   if (opnode)
     {
       assert(requestingNode); //should not be called from outside
 
       switch (opnode->getType() & 0x00FFFFFF)
         {
           case CEvaluationNodeOperator::PLUS:
           case CEvaluationNodeOperator::MINUS:
           {
             CDimension r1, r2;
 
             if (requestingNode == node->getParent()) //called by parent
               {
                 r1 = findDimension(opnode->getLeft(), node);
                 r2 = findDimension(opnode->getRight(), node);
               }
             else //called by one of the children
               {
                 const CEvaluationNode* parent = dynamic_cast<const CEvaluationNode*>(node->getParent());
 
                 if (parent) r1 = findDimension(parent, node);
                 else r1 = mRootDimension;
 
                 if (requestingNode == opnode->getLeft())
                   r2 = findDimension(opnode->getRight(), node);
 
                 if (requestingNode == opnode->getRight())
                   r2 = findDimension(opnode->getLeft(), node);
               }
 
             //r1 and r2 are now the dimensions of the two nodes that are not the
             //requesting node.
             /*if (r1.isContradiction() || r2.isContradiction())
               result.setContradiction();
             else if (r1 == r2)
               result = r1;
             else if (r1.isUnknown())
               result = r2;
             else if (r2.isUnknown())
               result =r1;
             else
               result.setContradiction();*/
             result = r1.compare(r2);
           }
           break;
 
           case CEvaluationNodeOperator::MULTIPLY:
           {
             CDimension r1, r2;
 
             if (requestingNode == node->getParent()) //called by parent
               {
                 r1 = findDimension(opnode->getLeft(), node);
                 r2 = findDimension(opnode->getRight(), node);
 
                 result = r1 + r2;
               }
             else //called by one of the children
               {
                 //parent node
                 const CEvaluationNode* parent = dynamic_cast<const CEvaluationNode*>(node->getParent());
 
                 if (parent) r1 = findDimension(parent, node);
                 else r1 = mRootDimension;
 
                 //other child
                 if (requestingNode == opnode->getLeft())
                   r2 = findDimension(opnode->getRight(), node);
 
                 if (requestingNode == opnode->getRight())
                   r2 = findDimension(opnode->getLeft(), node);
 
                 result = r1 - r2;
               }
           }
           break;
 
           case CEvaluationNodeOperator::DIVIDE:
           {
             CDimension r1, r2;
 
             if (requestingNode == node->getParent()) //called by parent
               {
                 r1 = findDimension(opnode->getLeft(), node);
                 r2 = findDimension(opnode->getRight(), node);
 
                 result = r1 - r2;
               }
             else //called by one of the children
               {
                 //parent node
                 const CEvaluationNode* parent = dynamic_cast<const CEvaluationNode*>(node->getParent());
 
                 if (parent) r1 = findDimension(parent, node);
                 else r1 = mRootDimension;
 
                 //other child
                 if (requestingNode == opnode->getLeft())
                   {
                     r2 = findDimension(opnode->getRight(), node);
                     result = r1 + r2;
                   }
 
                 if (requestingNode == opnode->getRight())
                   {
                     r2 = findDimension(opnode->getLeft(), node);
                     result = r2 - r1;
                   }
               }
           }
           break;
 
           default:
             break;
         }
     }
 
   //number node
   const CEvaluationNodeNumber* numnode = dynamic_cast<const CEvaluationNodeNumber*>(node);
 
   if (numnode)
     {
       //heuristics!
       if (mUseHeuristics && (numnode->getValue() == 1.0))
         result.setDimension(0, 0, 0, 0, 0);
     }
 
   return result;
 }

void CFindDimensions::findDimensions ( CDimension rootDim )

find the dimensions from explicitly given root node dimension

Definition at line 340 of file CDimension.cpp.

References findDimensions(), and mRootDimension.

 {
   mRootDimension = rootDim;
   findDimensions();
 }

void CFindDimensions::findDimensions ( bool isMulticompartment )

find the dimensions for a function that is used in a reaction the dimension of the root node depends on the number of compartments that are involved in the reaction

Definition at line 346 of file CDimension.cpp.

References findDimensions(), CDimension::fixDimensionless(), mD1, mD2, mD3, mD4, mD5, mRootDimension, and CDimension::setDimension().

 {
   if (isMulticompartment)
     mRootDimension.setDimension(1, 0, -1, 0, 0); //amount of subs/time
   else
     mRootDimension.setDimension(1, -1, -1, 0, 0); //TODO !!! conc/time
 
   mRootDimension.fixDimensionless(mD1, mD2, mD3, mD4, mD5);
 
   findDimensions();
 }

void CFindDimensions::findDimensions ( )

private

find dim for all parameters

Definition at line 383 of file CDimension.cpp.

References findDimension(), findDimensionsMassAction(), CFunction::getVariables(), mDimensions, mpFunction, and CFunctionParameters::size().

Referenced by findDimensions(), and findDimensionsBoth().

 {
   if (!mpFunction) return;
 
   if (dynamic_cast<const CMassAction*>(mpFunction))
     {
       findDimensionsMassAction();
       return;
     }
 
   size_t i, imax = mpFunction->getVariables().size();
 
   for (i = 0; i < imax; ++i)
     if (mDimensions[i].isUnknown())
       findDimension(i);
 
   for (i = 0; i < imax; ++i)
     if (mDimensions[i].isUnknown())
       findDimension(i);
 
   for (i = 0; i < imax; ++i)
     if (mDimensions[i].isUnknown())
       findDimension(i);
 
   //TODO: conistency check for known dimensions?
 }

std::vector< std::string > CFindDimensions::findDimensionsBoth ( const CModel * pModel )

find the dimensions for both a one-compartment and a multi-compartment reaction

Definition at line 358 of file CDimension.cpp.

References findDimensions(), mDimensions, and setupDimensions().

 {
   //first for single compartment
   findDimensions(false);
   std::vector<CDimension> store = mDimensions;
 
   //next for multiple compartments
   setupDimensions();
   findDimensions(true);
 
   //compare...
   std::vector<std::string> ret;
   std::vector<CDimension>::const_iterator it1, it2, it1end = store.end();
 
   for (it1 = store.begin(), it2 = mDimensions.begin(); it1 != it1end; ++it1, ++it2)
     {
       if (*it1 == *it2)
         ret.push_back(it1->getDisplayString(pModel));
       else
         ret.push_back(it1->getDisplayString(pModel) + " or " + it2->getDisplayString(pModel));
     }
 
   return ret;
 }

void CFindDimensions::findDimensionsMassAction ( )

private

determine dimensions for mass action kinetics chemical equation needs to be known

Definition at line 430 of file CDimension.cpp.

References CDimension::fixDimensionless(), mD1, mD2, mD3, mD4, mD5, mDimensions, mM1, mM2, mRootDimension, and CDimension::setDimension().

Referenced by findDimensions().

 {
   if (mM1 < 0) return;
 
   CDimension conc; conc.setDimension(1.0, -1.0, 0.0, 0, 0); //TODO!!!
 
   mRootDimension.fixDimensionless(mD1, mD2, mD3, mD4, mD5);
   conc.fixDimensionless(mD1, mD2, mD3, mD4, mD5);
 
   if (mDimensions[0].isUnknown())
     {
       mDimensions[0] = mRootDimension - conc * mM1;
     }
 
   if (mDimensions.size() == 2) return; //irreversible
 
   if (mDimensions[2].isUnknown())
     {
       mDimensions[2] = mRootDimension - conc * mM2;
     }
 }

const std::vector< CDimension > & CFindDimensions::getDimensions ( ) const

Definition at line 335 of file CDimension.cpp.

References mDimensions.

 {
   return mDimensions;
 }

void CFindDimensions::setChemicalEquation ( const CChemEq * eq )

tell about chemical equation. This is needed only for mass action kinetics. It is ignored otherwise.

Definition at line 410 of file CDimension.cpp.

References C_FLOAT64, CChemEq::getMolecularity(), mM1, mM2, CChemEq::PRODUCT, and CChemEq::SUBSTRATE.

 {
   //mpChemEq = eq;
   if (!eq)
     {
       mM1 = 0.0; mM2 = 0.0;
       return;
     }
 
   mM1 = (C_FLOAT64) eq->getMolecularity(CChemEq::SUBSTRATE);
   mM2 = (C_FLOAT64) eq->getMolecularity(CChemEq::PRODUCT);
 }

void CFindDimensions::setMolecularitiesForMassAction	(	const size_t &	m1,
		const size_t &	m2
	)

Definition at line 423 of file CDimension.cpp.

References C_INVALID_INDEX, mM1, and mM2.

 {
   mM1 = (m1 != C_INVALID_INDEX) ? m1 : -1.0;
   mM2 = (m2 != C_INVALID_INDEX) ? m2 : -1.0;
 }

void CFindDimensions::setupDimensions ( )

initialize the known dimensions (from the parameter roles) and set the others to "unknown". This is called by the constructor.

Definition at line 295 of file CDimension.cpp.

References CFunction::getVariables(), mD1, mD2, mD3, mD4, mD5, mDimensions, CFunctionParameter::MODIFIER, mpFunction, CFunctionParameter::PRODUCT, CFunctionParameters::size(), CFunctionParameter::SUBSTRATE, CFunctionParameter::TIME, and CFunctionParameter::VOLUME.

Referenced by CFindDimensions(), and findDimensionsBoth().

 {
   if (!mpFunction) return;
 
   mDimensions.resize(mpFunction->getVariables().size());
 
   size_t i, imax = mpFunction->getVariables().size();
 
   for (i = 0; i < imax; ++i)
     {
       switch (mpFunction->getVariables()[i]->getUsage())
         {
           case CFunctionParameter::SUBSTRATE:
           case CFunctionParameter::PRODUCT:
           case CFunctionParameter::MODIFIER:
             mDimensions[i].setDimension(1, -1, 0, 0, 0); //concentration
             break;
 
           case CFunctionParameter::VOLUME:
             mDimensions[i].setUnknown(); // TODO Dimension(0, 1, 0); //volume
             break;
 
           case CFunctionParameter::TIME:
             mDimensions[i].setDimension(0, 0, 1, 0, 0); //time
             break;
 
           default:
             mDimensions[i].setUnknown();
             break;
         }
 
       mDimensions[i].fixDimensionless(mD1, mD2, mD3, mD4, mD5);
     }
 }