Collaboration diagram for CTrajectoryMethodDsaLsodar::CPartition:

Public Types
typedef std::multimap< size_t, size_t >	speciesToReactionsMap

Public Member Functions
	CPartition ()

	CPartition (const CPartition &src)

void	determineStochasticSpecies ()

void	intialize (std::vector< CReactionDependencies > &reactions, const speciesToReactionsMap &speciesToReactions, const C_FLOAT64 &lowerThreshold, const C_FLOAT64 &upperThreshold, const CState &state)

bool	rePartition (const CState &state)

	~CPartition ()

Public Attributes
CVector< CReactionDependencies * >	mDeterministicReactions

bool	mHasDeterministic

bool	mHasStochastic

CVector< CReactionDependencies * >	mStochasticReactions

CVector< bool >	mStochasticSpecies

Private Attributes
size_t	mFirstReactionSpeciesIndex

C_FLOAT64	mLowerThreshold

CVector< bool >	mLowSpecies

CVector< size_t >	mNumLowSpecies

size_t	mNumReactionSpecies

speciesToReactionsMap	mSpeciesToReactions

C_FLOAT64	mUpperThreshold

Detailed Description

Definition at line 139 of file CTrajectoryMethodDsaLsodar.h.

Member Typedef Documentation

typedef std::multimap< size_t, size_t > CTrajectoryMethodDsaLsodar::CPartition::speciesToReactionsMap

Definition at line 142 of file CTrajectoryMethodDsaLsodar.h.

Constructor & Destructor Documentation

CTrajectoryMethodDsaLsodar::CPartition::CPartition ( )

Default constructor

Definition at line 87 of file CTrajectoryMethodDsaLsodar.cpp.

                                                 :
   mSpeciesToReactions(),
   mLowerThreshold(),
   mUpperThreshold(),
   mFirstReactionSpeciesIndex(C_INVALID_INDEX),
   mNumReactionSpecies(0),
   mStochasticReactions(0),
   mDeterministicReactions(0),
   mStochasticSpecies(0),
   mHasStochastic(false),
   mHasDeterministic(false),
   mNumLowSpecies(0),
   mLowSpecies(0)
 {}

CTrajectoryMethodDsaLsodar::CPartition::CPartition ( const CPartition & src )

Copy constructor

Parameters

const CPartition & src

Definition at line 102 of file CTrajectoryMethodDsaLsodar.cpp.

                                                                                                 :
   mSpeciesToReactions(src.mSpeciesToReactions),
   mLowerThreshold(src.mLowerThreshold),
   mUpperThreshold(src.mUpperThreshold),
   mFirstReactionSpeciesIndex(C_INVALID_INDEX),
   mNumReactionSpecies(src.mNumReactionSpecies),
   mStochasticReactions(src.mStochasticReactions),
   mDeterministicReactions(src.mDeterministicReactions),
   mStochasticSpecies(src.mStochasticSpecies),
   mHasStochastic(src.mHasStochastic),
   mHasDeterministic(src.mHasDeterministic),
   mNumLowSpecies(src.mNumLowSpecies),
   mLowSpecies(src.mLowSpecies)
 {}

CTrajectoryMethodDsaLsodar::CPartition::~CPartition ( )

Destructor

Definition at line 117 of file CTrajectoryMethodDsaLsodar.cpp.

118 {}

Member Function Documentation

void CTrajectoryMethodDsaLsodar::CPartition::determineStochasticSpecies ( )

Definition at line 295 of file CTrajectoryMethodDsaLsodar.cpp.

References CVectorCore< CType >::array(), CTrajectoryMethodDsaLsodar::mFirstReactionSpeciesIndex, and CTrajectoryMethodDsaLsodar::CReactionDependencies::mSpeciesIndex.

 {
   // All species which participate in stochastic reactions are treated stochastically
   CReactionDependencies **ppReaction = mStochasticReactions.array();
   CReactionDependencies **ppReactionEnd = ppReaction + mStochasticReactions.size();
 
   mStochasticSpecies = false;
 
   for (; ppReaction != ppReactionEnd; ++ppReaction)
     {
       if (*ppReaction != NULL)
         {
           size_t * pSpeciesIndex = (*ppReaction)->mSpeciesIndex.array();
           size_t * pSpeciesIndexEnd = pSpeciesIndex + (*ppReaction)->mSpeciesIndex.size();
 
           for (; pSpeciesIndex != pSpeciesIndexEnd; ++pSpeciesIndex)
             {
               mStochasticSpecies[*pSpeciesIndex - mFirstReactionSpeciesIndex] = true;
             }
         }
     }
 }

void CTrajectoryMethodDsaLsodar::CPartition::intialize	(	std::vector< CReactionDependencies > &	reactions,
		const speciesToReactionsMap &	speciesToReactions,
		const C_FLOAT64 &	lowerThreshold,
		const C_FLOAT64 &	upperThreshold,
		const CState &	state
	)

Definition at line 120 of file CTrajectoryMethodDsaLsodar.cpp.

References CState::beginIndependent(), C_FLOAT64, and CTrajectoryMethodDsaLsodar::mFirstReactionSpeciesIndex.

Referenced by CTrajectoryMethodDsaLsodar::start().

 {
   mSpeciesToReactions = speciesToReactions;
   mLowerThreshold = lowerThreshold;
   mUpperThreshold = upperThreshold;
 
   mFirstReactionSpeciesIndex = mSpeciesToReactions.begin()->first;
   mNumReactionSpecies = mSpeciesToReactions.rbegin()->first - mFirstReactionSpeciesIndex + 1;
 
   mStochasticReactions.resize(reactions.size());
   mStochasticReactions = NULL;
 
   mDeterministicReactions.resize(reactions.size());
   mDeterministicReactions = NULL;
 
   mNumLowSpecies.resize(reactions.size());
   mNumLowSpecies = 0;
 
   mStochasticSpecies.resize(mNumReactionSpecies);
   mStochasticSpecies = false;
 
   mLowSpecies.resize(mNumReactionSpecies);
   mLowSpecies = false;
 
   mHasStochastic = false;
   mHasDeterministic = false;
 
   // Create the initial partition by first counting species with low particle number per reaction
   const C_FLOAT64 * pValue = state.beginIndependent() - 1 + mFirstReactionSpeciesIndex;
   const C_FLOAT64 * pValueEnd = pValue + mNumReactionSpecies;
   bool * pLowSpecies = mLowSpecies.array();
 
   C_FLOAT64 CriticalValue = (mLowerThreshold + mUpperThreshold) * 0.5;
 
   size_t Index = mFirstReactionSpeciesIndex;
 
   for (; pValue != pValueEnd; ++pValue, ++Index, ++pLowSpecies)
     {
       if (*pValue < CriticalValue)
         {
           *pLowSpecies = true;
           std::pair< speciesToReactionsMap::const_iterator, speciesToReactionsMap::const_iterator > Range
           = mSpeciesToReactions.equal_range(Index);
 
           for (; Range.first != Range.second; ++Range.first)
             {
               mNumLowSpecies[Range.first->second]++;
             }
         }
     }
 
   // Reactions for which the count of species with low numbers is non zero
   // are treated stochastically.
   const size_t * pLow = mNumLowSpecies.array();
   const size_t * pLowEnd = pLow + mNumLowSpecies.size();
   std::vector< CReactionDependencies >::iterator itReaction = reactions.begin();
   CReactionDependencies ** ppStochastic = mStochasticReactions.array();
   CReactionDependencies ** ppDeterministic = mDeterministicReactions.array();
 
   for (; pLow != pLowEnd; ++pLow, ++itReaction, ++ppStochastic, ++ppDeterministic)
     {
       if (*pLow != 0)
         {
           *ppStochastic = &(*itReaction);
           mHasStochastic = true;
         }
       else
         {
           *ppDeterministic = &(*itReaction);
           mHasDeterministic = true;
         }
     }
 
   determineStochasticSpecies();
 }

bool CTrajectoryMethodDsaLsodar::CPartition::rePartition ( const CState & state )

Definition at line 200 of file CTrajectoryMethodDsaLsodar.cpp.

References CState::beginIndependent(), C_FLOAT64, and CTrajectoryMethodDsaLsodar::mFirstReactionSpeciesIndex.

Referenced by CTrajectoryMethodDsaLsodar::doSingleStep().

 {
   // Modify the partition if species values move beyond the threshold
   const C_FLOAT64 * pValue = state.beginIndependent() - 1 + mFirstReactionSpeciesIndex;
   const C_FLOAT64 * pValueEnd = pValue + mNumReactionSpecies;
   bool * pLowSpecies = mLowSpecies.array();
 
   bool PartitionChanged = false;
 
   size_t Index = 0;
 
   for (; pValue != pValueEnd; ++pValue, ++Index, ++pLowSpecies)
     {
       if (!*pLowSpecies && *pValue < mLowerThreshold)
         {
           *pLowSpecies = true;
           PartitionChanged = true;
 
           mStochasticSpecies[Index] = true;
 
           std::pair< speciesToReactionsMap::const_iterator, speciesToReactionsMap::const_iterator > Range
           = mSpeciesToReactions.equal_range(Index + mFirstReactionSpeciesIndex);
 
           for (; Range.first != Range.second; ++Range.first)
             {
               mNumLowSpecies[Range.first->second]++;
             }
         }
       else if (*pLowSpecies && *pValue > mUpperThreshold)
         {
           *pLowSpecies = false;
           PartitionChanged = true;
 
           mStochasticSpecies[Index] = true;
 
           std::pair< speciesToReactionsMap::const_iterator, speciesToReactionsMap::const_iterator > Range
           = mSpeciesToReactions.equal_range(Index);
 
           for (; Range.first != Range.second; ++Range.first)
             {
               mNumLowSpecies[Range.first->second]--;
             }
         }
     }
 
   if (!PartitionChanged)
     {
       return false;
     }
 
   PartitionChanged = false;
 
   // Reactions for which the count of species with low numbers is non zero
   // are treated stochastically.
   const size_t * pLow = mNumLowSpecies.array();
   const size_t * pLowEnd = pLow + mNumLowSpecies.size();
   CReactionDependencies ** ppStochastic = mStochasticReactions.array();
   CReactionDependencies ** ppDeterministic = mDeterministicReactions.array();
   mHasStochastic = false;
   mHasDeterministic = false;
 
   for (; pLow != pLowEnd; ++pLow, ++ppStochastic, ++ppDeterministic)
     {
       if (*pLow != 0)
         {
           mHasStochastic = true;
 
           if (*ppDeterministic != NULL)
             {
               PartitionChanged = true;
               *ppStochastic = *ppDeterministic;
               *ppDeterministic = NULL;
             }
         }
       else
         {
           mHasDeterministic = true;
 
           if (*ppStochastic != NULL)
             {
               PartitionChanged = true;
               *ppDeterministic = *ppStochastic;
               *ppStochastic = NULL;
             }
         }
     }
 
   if (PartitionChanged)
     {
       // determineStochasticSpecies();
     }
 
   return PartitionChanged;
 }