#include <CEFMAlgorithm.h>

Inheritance diagram for CEFMAlgorithm:

Collaboration diagram for CEFMAlgorithm:

Classes
class	CSpeciesOrderNode

Public Member Functions
virtual bool	calculate ()

void	calculateFluxModes ()

	CEFMAlgorithm (const CEFMAlgorithm &src, const CCopasiContainer *pParent=NULL)

virtual bool	initialize ()

	~CEFMAlgorithm ()

Public Member Functions inherited from CEFMMethod
	CEFMMethod (const CEFMMethod &src, const CCopasiContainer *pParent=NULL)

virtual bool	isValidProblem (const CCopasiProblem *pProblem)

virtual	~CEFMMethod ()

Public Member Functions inherited from CCopasiMethod
	CCopasiMethod (const CCopasiMethod &src, const CCopasiContainer *pParent=NULL)

const CCopasiMethod::SubType &	getSubType () const

const CCopasiTask::Type &	getType () const

virtual void	load (CReadConfig &configBuffer, CReadConfig::Mode mode=CReadConfig::SEARCH)

virtual void	print (std::ostream *ostream) const

virtual void	printResult (std::ostream *ostream) const

virtual bool	setCallBack (CProcessReport *pCallBack)

virtual	~CCopasiMethod ()

Public Member Functions inherited from CCopasiParameterGroup
bool	addGroup (const std::string &name)

bool	addParameter (const CCopasiParameter &parameter)

bool	addParameter (const std::string &name, const CCopasiParameter::Type type)

template<class CType >
bool	addParameter (const std::string &name, const CCopasiParameter::Type type, const CType &value)

void	addParameter (CCopasiParameter *pParameter)

CCopasiParameterGroup *	assertGroup (const std::string &name)

template<class CType >
CCopasiParameter *	assertParameter (const std::string &name, const CCopasiParameter::Type type, const CType &defaultValue)

index_iterator	beginIndex () const

name_iterator	beginName () const

	CCopasiParameterGroup (const CCopasiParameterGroup &src, const CCopasiContainer *pParent=NULL)

	CCopasiParameterGroup (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &objectType="ParameterGroup")

void	clear ()

virtual bool	elevateChildren ()

index_iterator	endIndex () const

name_iterator	endName () const

CCopasiParameterGroup *	getGroup (const std::string &name)

const CCopasiParameterGroup *	getGroup (const std::string &name) const

CCopasiParameterGroup *	getGroup (const size_t &index)

const CCopasiParameterGroup *	getGroup (const size_t &index) const

size_t	getIndex (const std::string &name) const

std::string	getKey (const std::string &name) const

std::string	getKey (const size_t &index) const

virtual const std::string &	getName (const size_t &index) const

virtual const CObjectInterface *	getObject (const CCopasiObjectName &cn) const

CCopasiParameter *	getParameter (const std::string &name)

const CCopasiParameter *	getParameter (const std::string &name) const

CCopasiParameter *	getParameter (const size_t &index)

const CCopasiParameter *	getParameter (const size_t &index) const

CCopasiParameter::Type	getType (const std::string &name) const

CCopasiParameter::Type	getType (const size_t &index) const

std::string	getUniqueParameterName (const CCopasiParameter *pParameter) const

const CCopasiParameter::Value &	getValue (const std::string &name) const

const CCopasiParameter::Value &	getValue (const size_t &index) const

CCopasiParameter::Value &	getValue (const std::string &name)

CCopasiParameter::Value &	getValue (const size_t &index)

CCopasiParameterGroup &	operator= (const CCopasiParameterGroup &rhs)

bool	removeParameter (const std::string &name)

bool	removeParameter (const size_t &index)

template<class CType >
bool	setValue (const std::string &name, const CType &value)

template<class CType >
bool	setValue (const size_t &index, const CType &value)

size_t	size () const

bool	swap (const size_t &iFrom, const size_t &iTo)

bool	swap (index_iterator &from, index_iterator &to)

virtual	~CCopasiParameterGroup ()

Public Member Functions inherited from CCopasiParameter
	CCopasiParameter (const CCopasiParameter &src, const CCopasiContainer *pParent=NULL)

	CCopasiParameter (const std::string &name, const Type &type, const void pValue=NULL, const CCopasiContainer pParent=NULL, const std::string &objectType="Parameter")

virtual CCopasiObjectName	getCN () const

virtual const std::string &	getKey () const

virtual std::string	getObjectDisplayName (bool regular=true, bool richtext=false) const

const CCopasiParameter::Type &	getType () const

const Value &	getValue () const

Value &	getValue ()

virtual void *	getValuePointer () const

CCopasiObject *	getValueReference () const

bool	isValidValue (const C_FLOAT64 &value) const

bool	isValidValue (const C_INT32 &value) const

bool	isValidValue (const unsigned C_INT32 &value) const

bool	isValidValue (const bool &value) const

bool	isValidValue (const std::string &value) const

bool	isValidValue (const CCopasiObjectName &value) const

bool	isValidValue (const std::vector< CCopasiParameter * > &value) const

CCopasiParameter &	operator= (const CCopasiParameter &rhs)

template<class CType >
bool	setValue (const CType &value)

bool	setValue (const std::vector< CCopasiParameter * > &value)

virtual	~CCopasiParameter ()

Public Member Functions inherited from CCopasiContainer
virtual bool	add (CCopasiObject *pObject, const bool &adopt=true)

	CCopasiContainer (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=CCopasiObject::Container)

	CCopasiContainer (const CCopasiContainer &src, const CCopasiContainer *pParent=NULL)

virtual std::string	getChildObjectUnits (const CCopasiObject *pObject) const

virtual const objectMap &	getObjects () const

virtual std::string	getUnits () const

virtual const CCopasiObject *	getValueObject () const

virtual bool	remove (CCopasiObject *pObject)

virtual	~CCopasiContainer ()

Public Member Functions inherited from CCopasiObject
void	addDirectDependency (const CCopasiObject *pObject)

	CCopasiObject (const CCopasiObject &src, const CCopasiContainer *pParent=NULL)

void	clearDirectDependencies ()

void	clearRefresh ()

bool	dependsOn (DataObjectSet candidates, const DataObjectSet &context=DataObjectSet()) const

void	getAllDependencies (DataObjectSet &dependencies, const DataObjectSet &context) const

virtual const DataObjectSet &	getDirectDependencies (const DataObjectSet &context=DataObjectSet()) const

CCopasiContainer *	getObjectAncestor (const std::string &type) const

CCopasiDataModel *	getObjectDataModel ()

const CCopasiDataModel *	getObjectDataModel () const

const std::string &	getObjectName () const

CCopasiContainer *	getObjectParent () const

const std::string &	getObjectType () const

virtual const CObjectInterface::ObjectSet &	getPrerequisites () const

virtual Refresh *	getRefresh () const

UpdateMethod *	getUpdateMethod () const

bool	hasCircularDependencies (DataObjectSet &candidates, DataObjectSet &verified, const DataObjectSet &context) const

bool	hasUpdateMethod () const

bool	isArray () const

bool	isContainer () const

bool	isDataModel () const

bool	isMatrix () const

bool	isNameVector () const

bool	isNonUniqueName () const

virtual bool	isPrerequisiteForContext (const CObjectInterface *pObject, const CMath::SimulationContextFlag &context, const CObjectInterface::ObjectSet &changedObjects) const

bool	isReference () const

bool	isRoot () const

bool	isSeparator () const

bool	isStaticString () const

bool	isValueBool () const

bool	isValueDbl () const

bool	isValueInt () const

bool	isValueInt64 () const

bool	isValueString () const

bool	isVector () const

virtual bool	mustBeDeleted (const DataObjectSet &deletedObjects) const

void	removeDirectDependency (const CCopasiObject *pObject)

void	setDirectDependencies (const DataObjectSet &directDependencies)

bool	setObjectName (const std::string &name)

virtual bool	setObjectParent (const CCopasiContainer *pParent)

void	setObjectValue (const C_FLOAT64 &value)

void	setObjectValue (const C_INT32 &value)

void	setObjectValue (const bool &value)

template<class CType >
void	setRefresh (CType pType, void(CType::method)(void))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const C_FLOAT64 &))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const C_INT32 &))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const bool &))

virtual	~CCopasiObject ()

Public Member Functions inherited from CObjectInterface
	CObjectInterface ()

virtual	~CObjectInterface ()

Protected Member Functions
	CEFMAlgorithm (const CCopasiContainer *pParent=NULL)

	CEFMAlgorithm (const CCopasiMethod::SubType subType, const CCopasiContainer *pParent=NULL)

Protected Member Functions inherited from CEFMMethod
	CEFMMethod (const CCopasiTask::Type &taskType, const SubType &subType, const CCopasiContainer *pParent=NULL)

Protected Member Functions inherited from CCopasiMethod
	CCopasiMethod (const CCopasiTask::Type &taskType, const SubType &subType, const CCopasiContainer *pParent=NULL)

Protected Member Functions inherited from CCopasiParameterGroup
	CCopasiParameterGroup ()

Protected Member Functions inherited from CCopasiContainer
template<class CType >
CCopasiObject *	addMatrixReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

template<class CType >
CCopasiObject *	addObjectReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

template<class CType >
CCopasiObject *	addVectorReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

void	initObjects ()

Protected Member Functions inherited from CCopasiObject
	CCopasiObject ()

	CCopasiObject (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=0)

Protected Attributes
size_t	mhSteps

std::vector< size_t >	mIndexSet

unsigned C_INT32	mMaxStep

CTableauMatrix *	mpCurrentTableau

CModel *	mpModel

CTableauMatrix *	mpNextTableau

size_t	mReversible

unsigned C_INT32	mStep

unsigned C_INT32	mStepProcess

std::vector< std::vector < C_FLOAT64 > >	mStoi

Protected Attributes inherited from CEFMMethod
std::vector< CFluxMode > *	mpFluxModes

std::vector< const CReaction * > *	mpReorderedReactions

Protected Attributes inherited from CCopasiMethod
CProcessReport *	mpCallBack

Protected Attributes inherited from CCopasiParameter
std::string	mKey

CCopasiObject *	mpValueReference

size_t	mSize

Value	mValue

Protected Attributes inherited from CCopasiContainer
objectMap	mObjects

Private Member Functions
void	buildFluxModes ()

double	calculateCombinations (size_t index)

void	calculateNextTableau ()

bool	findMinimalCombinationIndex ()

void	initObjects ()

Friends
CEFMMethod *	CEFMMethod::createMethod (CCopasiMethod::SubType subType)

Additional Inherited Members
Public Types inherited from CCopasiMethod
enum	SubType { unset = 0, RandomSearch, RandomSearchMaster, SimulatedAnnealing, CoranaWalk, DifferentialEvolution, ScatterSearch, GeneticAlgorithm, EvolutionaryProgram, SteepestDescent, HybridGASA, GeneticAlgorithmSR, HookeJeeves, LevenbergMarquardt, NelderMead, SRES, Statistics, ParticleSwarm, Praxis, TruncatedNewton, Newton, deterministic, LSODAR, directMethod, stochastic, tauLeap, adaptiveSA, hybrid, hybridLSODA, hybridODE45, DsaLsodar, tssILDM, tssILDMModified, tssCSP, mcaMethodReder, scanMethod, lyapWolf, sensMethod, EFMAlgorithm, EFMBitPatternTreeAlgorithm, EFMBitPatternAlgorithm, Householder, crossSectionMethod, linearNoiseApproximation }

Public Types inherited from CCopasiParameterGroup
typedef parameterGroup::iterator	index_iterator

typedef CCopasiContainer::objectMap::iterator	name_iterator

typedef std::vector < CCopasiParameter * >	parameterGroup

Public Types inherited from CCopasiParameter
enum	Type { DOUBLE = 0, UDOUBLE, INT, UINT, BOOL, GROUP, STRING, CN, KEY, FILE, EXPRESSION, INVALID }

Public Types inherited from CCopasiContainer
typedef std::multimap < std::string, CCopasiObject * >	objectMap

Public Types inherited from CCopasiObject
typedef std::set< const CCopasiObject * >	DataObjectSet

typedef std::vector< Refresh * >	DataUpdateSequence

Public Types inherited from CObjectInterface
typedef std::set< const CObjectInterface * >	ObjectSet

typedef std::vector < CObjectInterface * >	UpdateSequence

Static Public Member Functions inherited from CEFMMethod
static CEFMMethod *	createMethod (CCopasiMethod::SubType subType=CCopasiMethod::EFMAlgorithm)

Static Public Member Functions inherited from CCopasiObject
static std::vector< Refresh * >	buildUpdateSequence (const DataObjectSet &objects, const DataObjectSet &uptoDateObjects, const DataObjectSet &context=DataObjectSet())

static void	setRenameHandler (CRenameHandler *rh)

Static Public Attributes inherited from CCopasiMethod
static const std::string	SubTypeName []

static const char *	XMLSubType []

Static Public Attributes inherited from CCopasiParameter
static const std::string	TypeName []

static const char *	XMLType []

Static Public Attributes inherited from CCopasiContainer
static const std::vector < CCopasiContainer * >	EmptyList

Protected Types inherited from CCopasiObject
enum	Flag { Container = 0x1, Vector = 0x2, Matrix = 0x4, NameVector = 0x8, Reference = 0x10, ValueBool = 0x20, ValueInt = 0x40, ValueInt64 = 0x80, ValueDbl = 0x100, NonUniqueName = 0x200, StaticString = 0x400, ValueString = 0x800, Separator = 0x1000, ModelEntity = 0x2000, Array = 0x4000, DataModel = 0x8000, Root = 0x10000, Gui = 0x20000 }

Static Protected Attributes inherited from CCopasiObject
static CRenameHandler *	smpRenameHandler = NULL

Detailed Description

Definition at line 39 of file CEFMAlgorithm.h.

Constructor & Destructor Documentation

CEFMAlgorithm::CEFMAlgorithm ( const CCopasiContainer * pParent = NULL )

protected

Default constructor

Parameters

const CCopasiContainer * pParent (Default: NULL)

Definition at line 73 of file CEFMAlgorithm.cpp.

References initObjects().

                                                             :
   CEFMMethod(CCopasiTask::fluxMode, CCopasiMethod::EFMAlgorithm, pParent),
   mpModel(NULL),
   mStoi(),
   mReversible(0),
   mpCurrentTableau(NULL),
   mpNextTableau(NULL),
   mIndexSet()
 {initObjects();}

CEFMAlgorithm::CEFMAlgorithm	(	const CCopasiMethod::SubType	subType,
		const CCopasiContainer *	pParent = `NULL`
	)

protected

Constructor to be called by derived methods

Parameters

const	CCopasiMethod::SubType subType
const	CCopasiContainer * pParent (Default: NULL)

Definition at line 83 of file CEFMAlgorithm.cpp.

References initObjects().

                                                                                                 :
   CEFMMethod(CCopasiTask::fluxMode, subType, pParent),
   mpModel(NULL),
   mStoi(),
   mReversible(0),
   mpCurrentTableau(NULL),
   mpNextTableau(NULL),
   mIndexSet()
 {initObjects();}

CEFMAlgorithm::CEFMAlgorithm	(	const CEFMAlgorithm &	src,
		const CCopasiContainer *	pParent = `NULL`
	)

Copy Constructor

Parameters

const CEFMAlgorithm & src

Definition at line 93 of file CEFMAlgorithm.cpp.

References initObjects().

                                                               :
   CEFMMethod(src, pParent),
   mpModel(NULL),
   mStoi(),
   mReversible(0),
   mpCurrentTableau(NULL),
   mpNextTableau(NULL),
   mIndexSet()
 {initObjects();}

CEFMAlgorithm::~CEFMAlgorithm ( )

Destructor

Definition at line 104 of file CEFMAlgorithm.cpp.

References DESTRUCTOR_TRACE, mpCurrentTableau, mpNextTableau, and pdelete.

 {
   DESTRUCTOR_TRACE;
   pdelete(mpCurrentTableau);
   pdelete(mpNextTableau);
 }

Member Function Documentation

void CEFMAlgorithm::buildFluxModes ( )

private

Construct the flux modes

Definition at line 376 of file CEFMAlgorithm.cpp.

References CTableauMatrix::begin(), CTableauMatrix::end(), mpCurrentTableau, and CEFMMethod::mpFluxModes.

Referenced by calculateFluxModes().

 {
   mpFluxModes->clear();
 
   std::list< const CTableauLine * >::iterator a = mpCurrentTableau->begin();
   std::list< const CTableauLine * >::iterator end = mpCurrentTableau->end();
 
   while (a != end)
     {
       mpFluxModes->push_back(CFluxMode(*a));
       a++;
     }
 }

bool CEFMAlgorithm::calculate ( void )

virtual

Execute the optimization algorithm calling simulation routine when needed. It is noted that this procedure can give feedback of its progress by the callback function set with SetCallback. @ return success;

Reimplemented from CEFMMethod.

Reimplemented in CSSAMethod.

Definition at line 195 of file CEFMAlgorithm.cpp.

References calculateFluxModes(), CProcessReport::finishItem(), initialize(), mhSteps, and CCopasiMethod::mpCallBack.

 {
   if (!initialize())
     {
       if (mpCallBack)
         mpCallBack->finishItem(mhSteps);
 
       return false;
     }
 
   calculateFluxModes();
 
   return true;
 }

double CEFMAlgorithm::calculateCombinations ( size_t index )

private

Calculate number of combinations for an index

Definition at line 426 of file CEFMAlgorithm.cpp.

References CTableauMatrix::begin(), CTableauMatrix::end(), and mpCurrentTableau.

Referenced by findMinimalCombinationIndex().

 {
   double posIrr = 0;
   double negIrr = 0;
   double rev = 0;
 
   //Reversible reactions
   std::list< const CTableauLine * >::const_iterator it = mpCurrentTableau->begin();
   std::list< const CTableauLine * >::const_iterator end = mpCurrentTableau->end();
 
   for (; it != end; ++it)
     {
       if ((*it)->isReversible() && (*it)->getMultiplier(index) != 0.0)
         {
           rev++;
         }
       else if ((*it)->getMultiplier(index) < 0.0)
         {
           negIrr++;
         }
       else if ((*it)->getMultiplier(index) > 0.0)
         {
           posIrr++;
         }
     }
 
   return (posIrr + rev) * (negIrr + rev);
 }

void CEFMAlgorithm::calculateFluxModes ( )

Do the actual calculation

Definition at line 210 of file CEFMAlgorithm.cpp.

References buildFluxModes(), calculateNextTableau(), COutputInterface::DURING, findMinimalCombinationIndex(), CProcessReport::finishItem(), CCopasiObject::getObjectParent(), mhSteps, mIndexSet, mMaxStep, CCopasiMethod::mpCallBack, mpCurrentTableau, mReversible, mStep, mStepProcess, mStoi, pdelete, and CProcessReport::progressItem().

Referenced by CSSAMethod::buildExtremeCurrents(), and calculate().

 {
   bool Continue = true;
 
   if (mStoi.size())
     {
       /* initialize the current tableau matrix */
       pdelete(mpCurrentTableau);
       mpCurrentTableau = new CTableauMatrix(mStoi, mReversible);
 
       /* Do the iteration */
       mIndexSet.resize(mMaxStep);
 
       for (mStep = 0; mStep < mMaxStep; mStep++)
         mIndexSet[mStep] = mStep;
 
       while (findMinimalCombinationIndex() && Continue)
         {
           calculateNextTableau();
           mStepProcess++;
 
           if (mpCallBack)
             Continue &= mpCallBack->progressItem(mhSteps);
 
           static_cast<CCopasiTask *>(getObjectParent())->output(COutputInterface::DURING);
         }
 
       /* Build the elementary flux modes to be returned */
       if (Continue)
         buildFluxModes();
 
       /* Delete the current / final tableau matrix */
       pdelete(mpCurrentTableau);
     }
 
   if (mpCallBack)
     Continue &= mpCallBack->finishItem(mhSteps);
 }

void CEFMAlgorithm::calculateNextTableau ( )

private

Initialize arrays and pointer called by calculate.

Definition at line 249 of file CEFMAlgorithm.cpp.

References CProcessReport::addItem(), CTableauMatrix::addLine(), CTableauMatrix::begin(), C_FLOAT64, C_INT32, CTableauMatrix::end(), CProcessReport::finishItem(), CCopasiMethod::mpCallBack, mpCurrentTableau, mpNextTableau, mStep, pdelete, CProcessReport::proceed(), CProcessReport::progressItem(), CTableauMatrix::removeLine(), and CTableauMatrix::size().

Referenced by calculateFluxModes().

 {
   std::list< const CTableauLine * >::iterator a;
   std::list< const CTableauLine * >::iterator b;
   C_FLOAT64 ma, mb;
 #ifdef COPASI_DEBUG_TRACE
   DebugFile << *mpCurrentTableau << std::endl;
 #endif //COPASI_DEBUG_TRACE
 
   mpNextTableau = new CTableauMatrix();
 
   /* Move all lines with zeros in the step column to the new tableau matrix */
   /* and remove them from the current tableau matrix */
   a = mpCurrentTableau->begin();
 
   bool Continue = true;
 
   unsigned C_INT32 Counter, MaxCounter;
   size_t hCounter;
 
   Counter = 0;
   MaxCounter = (unsigned C_INT32) mpCurrentTableau->size();
 
   if (mpCallBack)
     hCounter =
       mpCallBack->addItem("Current Line",
                           Counter,
                           & MaxCounter);
 
   while (a != mpCurrentTableau->end() && Continue)
     if ((*a)->getMultiplier(mStep) == 0.0)
       {
         /* We have to make sure that "a" points to the next element in the */
         /* list after the removal of itself */
 
         if (a == mpCurrentTableau->begin())
           {
             mpNextTableau->addLine(*a, false);
             mpCurrentTableau->removeLine(a);
             a = mpCurrentTableau->begin();
           }
         else
           {
             /* We have to remember the previous element so that a++ points to */
             /* past the removed one */
             b = a--;
             mpNextTableau->addLine(*b, false);
             mpCurrentTableau->removeLine(b);
             a++;
           }
 
         Counter++;
 
         if (mpCallBack)
           Continue &= mpCallBack->progressItem(hCounter);
       }
     else
       a++;
 
   C_FLOAT64 Sign;
 
   /* Now we create all linear combinations of the remaining lines in the */
   /* current tableau */
   a = mpCurrentTableau->begin();
 
   //std::cout << "Tableau Marker A" << std::endl << std::endl;
 
   while (a != mpCurrentTableau->end() && Continue)
     {
       b = a;
       b++;
 
       /* We make sure that "mb" is positive */
       mb = (*a)->getMultiplier(mStep);
 
       if (mb < 0.0)
         {
           mb *= -1.0;
           Sign = 1.0;
         }
       else
         Sign = -1.0;
 
       //std::cout << "Tableau Marker B" << std::endl << std::endl;
 
       while (b != mpCurrentTableau->end() && Continue)
         {
           ma = Sign * (*b)->getMultiplier(mStep);
 
           /* The multiplier "ma" for irreversible reactions must be positive */
           if (ma > 0.0 || (*a)->isReversible())
             mpNextTableau->addLine(new CTableauLine(ma, **a, mb, **b));
 
           /*CTableauLine * debugLine = new CTableauLine(ma, **a, mb, **b);
           if(debugLine->isReversible())
             std::cout << "Reversible Rxn" << std::endl;
           else std::cout << "Irreversible Rxn" << std::endl;
           std::cout << "Flux Score: " << debugLine->getScore() << "Flux Mode Vector: "
             << debugLine->getFluxMode() << std::endl;*/
 
           b++;
 
           if (mpCallBack)
             Continue &= mpCallBack->proceed();
         }
 
       // We no longer need a since all linear combinations have been build;
       mpCurrentTableau->removeLine(a);
       a = mpCurrentTableau->begin();
 
       Counter++;
 
       if (mpCallBack)
         Continue &= mpCallBack->progressItem(hCounter);
     }
 
   if (mpCallBack)
     Continue &= mpCallBack->finishItem(hCounter);
 
   /* Assign the next tableau to the current tableau and cleanup */
   pdelete(mpCurrentTableau);
 
   mpCurrentTableau = mpNextTableau;
 
   mpNextTableau = NULL;
 }

bool CEFMAlgorithm::findMinimalCombinationIndex ( )

private

Find index containing smallest number of combinations

Definition at line 390 of file CEFMAlgorithm.cpp.

References C_INT32, calculateCombinations(), mIndexSet, and mStep.

Referenced by calculateFluxModes().

 {
   double minCombine = std::numeric_limits<double>::infinity();
   double combine = 0;
   size_t minIndex = 0;
   size_t counter;
 
   if (mIndexSet.size() == 0)
     return false;
   else if (mIndexSet.size() == 1)
     {
       mStep = (unsigned C_INT32) mIndexSet[0];
       mIndexSet.pop_back();
       return true;
     }
 
   for (counter = 0; counter < mIndexSet.size(); counter++)
     {
       combine = calculateCombinations(mIndexSet[counter]);
 
       if (combine < minCombine)
         {
           minCombine = combine;
           minIndex = counter;
         }
 
       if (combine == 0)
         break;
     }
 
   mStep = (unsigned C_INT32) mIndexSet[minIndex];
   mIndexSet.erase(mIndexSet.begin() + minIndex);
 
   return true;
 }

bool CEFMAlgorithm::initialize ( )

virtual

Initialize arrays and pointer.

Returns: bool success

Reimplemented from CEFMMethod.

Reimplemented in CSSAMethod.

Definition at line 116 of file CEFMAlgorithm.cpp.

References CProcessReport::addItem(), C_INT32, CCopasiProblem::getModel(), CCopasiObject::getObjectParent(), CCopasiTask::getProblem(), CModel::getReactions(), CModel::getStoi(), CEFMMethod::initialize(), mhSteps, mMaxStep, CCopasiMethod::mpCallBack, CEFMMethod::mpFluxModes, mpModel, CEFMMethod::mpReorderedReactions, mReversible, mStep, mStepProcess, mStoi, CTransposeView< Matrix >::numRows(), and pTask.

Referenced by calculate().

 {
   if (!CEFMMethod::initialize())
     {
       return false;
     }
 
   CEFMTask * pTask = dynamic_cast< CEFMTask *>(getObjectParent());
 
   if (pTask == NULL) return false;
 
   mpModel = pTask->getProblem()->getModel();
 
   if (mpModel == NULL) return false;
 
   mpFluxModes->clear();
 
   /* ModelStoi is the transpose of the models stoichiometry matrix */
   const CTransposeView< CMatrix< C_FLOAT64 > > ModelStoi(mpModel->getStoi());
 
   size_t row, numRows = ModelStoi.numRows();
   size_t col, numCols = ModelStoi.numCols();
 
   /* Size the stoichiometry matrix passed to the algorithm */
   mStoi.resize(numRows);
   std::vector< std::vector< C_FLOAT64 > >::iterator it = mStoi.begin();
   std::vector< std::vector< C_FLOAT64 > >::iterator end = mStoi.end();
 
   for (; it != end; ++it)
     it->resize(numCols);
 
   /* Get the reactions from the model */
   /* Note: We have as many reactions as we have rows in ModelStoi */
   const CCopasiVectorNS < CReaction > & Reaction = mpModel->getReactions();
 
   /* Vector to keep track of the rearrangements necessary to put the */
   /* reversible reactions to the top of stoichiometry matrix */
   mpReorderedReactions->resize(numRows);
 
   /* Reversible reaction counter */
   mReversible = 0;
   size_t Insert;
   size_t InsertReversible = 0;
   size_t InsertIrreversible = numRows - 1;
 
   /* Build the transpose of the stoichiometry matrix, */
 
   /* sort reversible reactions to the top, count them */
 
   /* and keep track of the rearrangement */
   for (row = 0; row < numRows; row++)
     {
       if (Reaction[row]->isReversible())
         {
           Insert = InsertReversible++;
           mReversible++;
         }
       else
         Insert = InsertIrreversible--;
 
       (*mpReorderedReactions)[Insert] = Reaction[row];
 
       for (col = 0; col < numCols; col++)
         mStoi[Insert][col] = ModelStoi(row, col);
     }
 
   mStep = 0;
   mStepProcess = 0;
   mMaxStep = (unsigned C_INT32) numCols;
 
   if (mpCallBack)
     mhSteps =
       mpCallBack->addItem("Current Step",
                           mStepProcess,
                           & mMaxStep);
 
   return true;
 }

void CEFMAlgorithm::initObjects ( )

private

Definition at line 111 of file CEFMAlgorithm.cpp.

References CCopasiContainer::addObjectReference(), mStep, and CCopasiObject::ValueInt.

Referenced by CEFMAlgorithm().

 {
   addObjectReference("Current Step", mStep, CCopasiObject::ValueInt);
 }

Friends And Related Function Documentation

CEFMMethod* CEFMMethod::createMethod ( CCopasiMethod::SubType subType )

friend

Member Data Documentation

size_t CEFMAlgorithm::mhSteps

protected

Handle to the process report item "Current Step"

Definition at line 174 of file CEFMAlgorithm.h.

Referenced by CSSAMethod::calculate(), calculate(), calculateFluxModes(), CSSAMethod::initialize(), and initialize().

std::vector<size_t> CEFMAlgorithm::mIndexSet

protected

Vector set containing all step indexes for iteration when calculating flux modes.

Definition at line 179 of file CEFMAlgorithm.h.

Referenced by calculateFluxModes(), and findMinimalCombinationIndex().

unsigned C_INT32 CEFMAlgorithm::mMaxStep

protected

The max step used for process report.

Definition at line 169 of file CEFMAlgorithm.h.

Referenced by calculateFluxModes(), CSSAMethod::initialize(), and initialize().

CTableauMatrix* CEFMAlgorithm::mpCurrentTableau

protected

A pointer to the current tableau matrix

Definition at line 149 of file CEFMAlgorithm.h.

Referenced by buildFluxModes(), calculateCombinations(), calculateFluxModes(), calculateNextTableau(), and ~CEFMAlgorithm().

CModel* CEFMAlgorithm::mpModel

protected

A pointer to the model

Definition at line 134 of file CEFMAlgorithm.h.

Referenced by CSSAMethod::buildKineticMatrix(), CSSAMethod::buildStoichiometry(), CSSAMethod::calculate(), CSSAMethod::initialize(), and initialize().

CTableauMatrix* CEFMAlgorithm::mpNextTableau

protected

A pointer to the next tableaun matrix

Definition at line 154 of file CEFMAlgorithm.h.

Referenced by calculateNextTableau(), and ~CEFMAlgorithm().

size_t CEFMAlgorithm::mReversible

protected

The number of reversible reactions.

Definition at line 144 of file CEFMAlgorithm.h.

Referenced by calculateFluxModes(), CSSAMethod::initialize(), and initialize().

unsigned C_INT32 CEFMAlgorithm::mStep

protected

The current step used for process report.

Definition at line 159 of file CEFMAlgorithm.h.

Referenced by calculateFluxModes(), calculateNextTableau(), findMinimalCombinationIndex(), CSSAMethod::initialize(), initialize(), and initObjects().

unsigned C_INT32 CEFMAlgorithm::mStepProcess

protected

The current step used for process report.

Definition at line 164 of file CEFMAlgorithm.h.

Referenced by calculateFluxModes(), and initialize().

std::vector< std::vector< C_FLOAT64 > > CEFMAlgorithm::mStoi

protected

Matrix containing the reordered stoichiometry matrix.

Definition at line 139 of file CEFMAlgorithm.h.

Referenced by CSSAMethod::buildStoichiometry(), calculateFluxModes(), CSSAMethod::initialize(), initialize(), and CSSAMethod::testForMixingStability().

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

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation