Stoich Class Reference

#include <Stoich.h>

Collaboration diagram for Stoich:

Public Member Functions
void	allocateModel (const vector< Id > &elist)
	Calculate sizes of all arrays, and allocate them. More...
void	allocateModelObject (Id id)
	Identifies and allocates objects in the Stoich. More...
void	buildFuncLookup ()
void	buildPoolLookup ()
	Functions to build the maps between Ids and internal indices. More...
void	buildRateTermLookup ()
unsigned int	convertIdToFuncIndex (Id id) const
unsigned int	convertIdToPoolIndex (Id id) const
unsigned int	convertIdToReacIndex (Id id) const
void	convertRatesToStochasticForm ()
const FuncTerm *	funcs (unsigned int i) const
bool	getAllowNegative () const
vector< unsigned int >	getColIndex () const
Id	getCompartment () const
Id	getDsolve () const
double	getEnzK2 (const Eref &e) const
	Get rate k2 (1/sec) for enzyme. More...
double	getEnzK3 (const Eref &e) const
	Get rate k3, aka kcat, for enzyme. More...
double	getEnzNumK1 (const Eref &e) const
Id	getKsolve () const
vector< int >	getMatrixEntry () const
double	getMMenzKcat (const Eref &e) const
double	getMMenzNumKm (const Eref &e) const
unsigned int	getNumAllPools () const
unsigned int	getNumBufPools () const
	Returns number of local buffered pools. More...
unsigned int	getNumCoreRates () const
	Number of rate terms for reactions purely on this compartment. More...
unsigned int	getNumFuncs () const
unsigned int	getNumProxyPools () const
unsigned int	getNumRates () const
unsigned int	getNumVarPools () const
	Returns number of local pools that are updated by solver. More...
vector< Id >	getOffSolverCompts () const
const vector< Id > &	getOffSolverPools () const
bool	getOneWay () const
string	getPath (const Eref &e) const
Id	getPoolByIndex (unsigned int index) const
vector< unsigned int >	getPoolIdMap () const
vector< Id >	getProxyPools (Id i) const
double	getR1 (const Eref &e) const
double	getR1offset1 (const Eref &e) const
double	getR1offset2 (const Eref &e) const
double	getR2 (const Eref &e) const
const vector< RateTerm * > &	getRateTerms () const
	Returns a reference to the entire rates_ vector. More...
vector< unsigned int >	getRowStart () const
unsigned int	getSpecies (unsigned int poolIndex) const
int	getStatus () const
const KinSparseMatrix &	getStoichiometryMatrix () const
	Updates the rates for cross-compartment reactions. More...
unsigned int	innerInstallReaction (Id reacId, const vector< Id > &subs, const vector< Id > &prds)
void	installAndUnschedFunc (Id func, Id pool, double volScale)
void	installAndUnschedFuncRate (Id func, Id pool)
void	installAndUnschedFuncReac (Id func, Id reac)
void	installDummyEnzyme (Id enzId, Id enzMolId)
	This is used when the enzyme lacks sub or prd. More...
void	installEnzyme (Id enzId, Id enzMolId, Id cplxId, const vector< Id > &subs, const vector< Id > &prds)
void	installEnzyme (ZeroOrder *r1, ZeroOrder *r2, ZeroOrder *r3, Id enzId, Id enzMolId, const vector< Id > &prds)
void	installMMenz (Id enzId, const vector< Id > &enzMolId, const vector< Id > &subs, const vector< Id > &prds)
void	installMMenz (MMEnzymeBase *meb, unsigned int rateIndex, const vector< Id > &subs, const vector< Id > &prds)
	This is the internal variant to install the MMenz. More...
void	installReaction (Id reacId, const vector< Id > &subs, const vector< Id > &prds)
bool	isFuncTarget (unsigned int poolIndex) const
	Returns true if the specified pool is controlled by a func. More...
void	locateOffSolverReacs (Id myCompt, vector< Id > &elist)
ZeroOrder *	makeHalfReaction (double rate, const vector< Id > &reactants)
	Utility function to make a half reac and return the rate term. More...
const vector< Id > &	offSolverPoolMap (Id compt) const
void	print () const
	Utility function, prints out N_, used for debugging. More...
void	printRates () const
	Another utility function, prints out all Kf, kf, Kb, kb. More...
const RateTerm *	rates (unsigned int i) const
	Utility function to return a rates_ entry. More...
void	resizeArrays ()
	Using the computed array sizes, now allocate space for them. More...
void	scaleBufsAndRates (unsigned int index, double volScale)
	Used to handle run-time size updates for spines. More...
void	setAllowNegative (bool v)
void	setCompartment (Id v)
	assigns compartment occupied by Stoich. More...
void	setDsolve (Id v)
	assigns diffusion solver: Dsovle or a Gillespie voxel stepper More...
void	setElist (const Eref &e, const vector< ObjId > &elist)
void	setEnzK1 (const Eref &e, double v) const
	Later handle all the volumes when this conversion is done. More...
void	setEnzK2 (const Eref &e, double v) const
	Set rate k2 (1/sec) for enzyme. More...
void	setEnzK3 (const Eref &e, double v) const
	Set rate k3 (1/sec) for enzyme. More...
void	setFunctionExpr (const Eref &e, string expr)
void	setKsolve (Id v)
	assigns kinetic solver: Ksovle or GSSAsolve. More...
void	setMMenzKcat (const Eref &e, double v) const
void	setMMenzKm (const Eref &e, double v) const
void	setOneWay (bool v)
void	setPath (const Eref &e, string path)
void	setReacKb (const Eref &e, double v) const
void	setReacKf (const Eref &e, double v) const
void	setSpecies (unsigned int poolIndex, unsigned int s)
	Stoich ()
void	unZombifyModel ()
void	unZombifyPools ()
	unZombifies Pools. Helper for unZombifyModel. More...
void	updateFuncs (double *s, double t) const
	Updates the function values, within s. More...
void	updateRatesAfterRemesh ()
void	updateReacVelocities (const double *s, vector< double > &vel, unsigned int volIndex) const
void	zombifyChemCompt (Id compt)
void	zombifyModel (const Eref &e, const vector< Id > &elist)
Id	zombifyPoolFuncWithScaling (Id pool)
	~Stoich ()

Static Public Member Functions
static const Cinfo *	initCinfo ()

Static Public Attributes
static const unsigned int	PoolIsNotOnSolver

Private Attributes
bool	allowNegative_
vector< Id >	bufPoolVec_
Id	compartment_
	Contains Id of compartment holding reac system. Optional. More...
ZombiePoolInterface *	dinterface_
	Pointer for dsolve. More...
Id	dsolve_
	This contains the Id of the Diffusion solver. Optional. More...
vector< Id >	enzVec_
map< Id, unsigned int >	funcLookup_
vector< FuncTerm * >	funcs_
	The FuncTerms handle mathematical ops on mol levels. More...
vector< unsigned int >	funcTarget_
vector< Id >	incrementFuncVec_
ZombiePoolInterface *	kinterface_
	Pointer for ksolve. More...
Id	ksolve_
	This contains the Id of the Kinetic solver. More...
vector< Id >	mmEnzVec_
KinSparseMatrix	N_
	N_ is the stoichiometry matrix. All pools * all reac terms. More...
unsigned int	numVoxels_
	Number of voxels in reac system. More...
vector< pair< Id, Id > >	offSolverEnzCompts_
vector< Id >	offSolverEnzVec_
vector< pair< Id, Id > >	offSolverMMenzCompts_
vector< Id >	offSolverMMenzVec_
map< Id, vector< Id > >	offSolverPoolMap_
vector< Id >	offSolverPoolVec_
vector< pair< Id, Id > >	offSolverReacCompts_
vector< Id >	offSolverReacVec_
string	path_
vector< Id >	poolFuncVec_
map< Id, unsigned int >	poolLookup_
vector< vector< Id > >	prdComptVec_
vector< RateTerm * >	rates_
map< Id, unsigned int >	rateTermLookup_
vector< Id >	reacFuncVec_
vector< Id >	reacVec_
vector< unsigned int >	species_
int	status_
vector< vector< Id > >	subComptVec_
bool	useOneWay_
vector< Id >	varPoolVec_

Detailed Description

Stoich is the class that handles the stoichiometry matrix for a reaction system, and also setting up the computations for reaction rates. It has to coordinate the operation of a number of model definition classes, most importantly: Pools, Reacs and Enz(yme)s. It also coordinates the setup of a large number of numerical solution engines, or solvers: Ksolve, Gsolve, Dsolve, and SteadyState. The setup process has to follow a tight order, most of which is internally manged by the Stoich. The Stoich itself does not do any 'process' functions. It just sets up data structures for the other objects that do the crunching.

1. Compartment is set up to a cell (neuroMesh) or volume (other meshes)
2. Compartment assigned to Stoich. Here it assigns unique vols.
3. Dsolve and Ksolve assigned to Stoich using setKsolve and setDsolve. 3.1 At this point the Stoich::useOneWay_ flag is set if it is a Gsolve.
4. Call Stoich::setPath. All the rest happens internally, done by Stoich: 4.1 assign compartment to Dsolve and Ksolve. 4.2 assign numPools and compts to Dsolve and Ksolve. 4.3 During Zombification, zeroth vector< RateTerm* > is built. 4.4 afterZombification, stoich builds rateTerm vector for all vols. 4.5 Stoich assigns itself to Dsolve and Ksolve.
   • Ksolve sets up volIndex on each VoxelPool
   • Dsolve gets vector of pools, extracts DiffConst and MotorConst 4.6 Dsolve assigned to Ksolve::dsolve_ field by the Stoich.

Reinit, 5.1 Dsolve builds matrix, provided dt has changed. It needs dt. 5.2 Ksolve builds solvers if not done already, assigning initDt

As seen by the user, this reduces to just 4 stages:

• Make the objects.
• Assign compartment, Ksolve and Dsolve to stoich.
• Set the stoich path.
• Reinit.

Definition at line 49 of file Stoich.h.

Constructor & Destructor Documentation

Stoich::Stoich

(

)

Definition at line 255 of file Stoich.cpp.

    :
    useOneWay_( false ),
    allowNegative_( false ),
    path_( "" ),
    ksolve_(), // Must be reassigned to build stoich system.
    dsolve_(), // Must be assigned if diffusion is planned.
    compartment_(), // Must be assigned if diffusion is planned.
    kinterface_( 0 ),
    dinterface_( 0 ),
    rates_( 0 ),    // No RateTerms yet.
    // uniqueVols_( 1, 1.0 ),
    numVoxels_( 1 ),
    status_( -1 )
{
    ;
}

Stoich::~Stoich

(

)

Definition at line 273 of file Stoich.cpp.

References funcs_, rates_, and unZombifyModel().

{
    unZombifyModel();
    // Note that we cannot do the unZombify here, because it is too
    // prone to problems with the ordering of the delete operations
    // relative to the zombies.
    for ( vector< RateTerm* >::iterator j = rates_.begin();
            j != rates_.end(); ++j )
        delete *j;

    for ( vector< FuncTerm* >::iterator j = funcs_.begin();
            j != funcs_.end(); ++j )
        delete *j;

    /*
     * Do NOT delete FuncTerms, they are just pointers stolen from
     * the non-zombified objects.
    for ( vector< FuncTerm* >::iterator i = funcs_.begin();
        i != funcs_.end(); ++i )
        delete *i;
        */
}

Here is the call graph for this function:

Member Function Documentation

void Stoich::allocateModel

(

const vector< Id > &

elist

)

Calculate sizes of all arrays, and allocate them.

Definition at line 968 of file Stoich.cpp.

References allocateModelObject(), bufPoolVec_, buildFuncLookup(), buildPoolLookup(), buildRateTermLookup(), enzVec_, incrementFuncVec_, mmEnzVec_, poolFuncVec_, reacFuncVec_, reacVec_, resizeArrays(), and varPoolVec_.

Referenced by setElist().

{
    // numVarPools_ = 0;
    // numReac_ = 0;
    // numFunctions_ = 0;
    // vector< Id > bufPools;
    varPoolVec_.clear();
    bufPoolVec_.clear();
    // offSolverPoolVec is filled up by the locateOffSolverReacs function
    reacVec_.clear();
    enzVec_.clear();
    mmEnzVec_.clear();
    poolFuncVec_.clear();
    incrementFuncVec_.clear();
    reacFuncVec_.clear();

    for ( vector< Id >::const_iterator i = elist.begin();
            i != elist.end(); ++i )
        allocateModelObject( *i );
    resizeArrays();

    buildPoolLookup();
    buildRateTermLookup();
    buildFuncLookup();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::allocateModelObject

(

Id

id

)

Identifies and allocates objects in the Stoich.

If this assertion fails it usually means that the elist passed to the solver is not properly restricted to objects located on the current compartment. As a result of this, traversal for finding off-compartment pools generates repeats with the ones in the elist. Note that pool compartment assignment is determined by following the mesh message, and thus a tree-based elist construction for compartments may be incompatible with the generation of the lists of off-compartment pools. It is up to the upstream code to ensure that this is done properly.

This assertion also fails if the Ids concerned had a dimension greater than 1.

Definition at line 844 of file Stoich.cpp.

References bufPoolCinfo, bufPoolVec_, Element::cinfo(), enzCinfo, enzVec_, Cinfo::find(), Cinfo::findFinfo(), functionCinfo, Element::getMsgTargetAndFunctions(), Element::id(), incrementFuncVec_, mmEnzCinfo, mmEnzVec_, poolCinfo, poolFuncVec_, reacCinfo, reacFuncVec_, reacVec_, and varPoolVec_.

Referenced by allocateModel().

{
    static const Cinfo* poolCinfo = Cinfo::find( "Pool" );
    static const Cinfo* bufPoolCinfo = Cinfo::find( "BufPool" );
    static const Cinfo* reacCinfo = Cinfo::find( "Reac" );
    static const Cinfo* enzCinfo = Cinfo::find( "Enz" );
    static const Cinfo* mmEnzCinfo = Cinfo::find( "MMenz" );
    static const Cinfo* functionCinfo = Cinfo::find( "Function" );
    static const Finfo* f1 = functionCinfo->findFinfo( "valueOut" );
    static const SrcFinfo* sf = dynamic_cast< const SrcFinfo* >( f1 );
    assert( sf );

    Element* ei = id.element();
    if ( ei->cinfo() == poolCinfo )
    {
        // objMap_[ id.value() - objMapStart_ ] = numVarPools_;
        varPoolVec_.push_back( id );
        // ++numVarPools_;
    }
    else if ( ei->cinfo() == bufPoolCinfo )
    {
        bufPoolVec_.push_back( id );
    }
    else if ( ei->cinfo() == mmEnzCinfo )
    {
        mmEnzVec_.push_back( ei->id() );
        // objMap_[ id.value() - objMapStart_ ] = numReac_;
        // ++numReac_;
    }
    else if ( ei->cinfo() == reacCinfo )
    {
        reacVec_.push_back( ei->id() );
        /*
        if ( useOneWay_ ) {
            objMap_[ id.value() - objMapStart_ ] = numReac_;
            numReac_ += 2;
        } else {
            objMap_[ id.value() - objMapStart_ ] = numReac_;
            ++numReac_;
        }
        */
    }
    else if ( ei->cinfo() == enzCinfo )
    {
        enzVec_.push_back( ei->id() );
        /*
        if ( useOneWay_ ) {
            objMap_[ id.value() - objMapStart_ ] = numReac_;
            numReac_ += 3;
        } else {
            objMap_[ id.value() - objMapStart_ ] = numReac_;
            numReac_ += 2;
        }
        */
    }
    else if ( ei->cinfo() == functionCinfo )
    {
        vector< ObjId > tgt;
        vector< string > func;
        ei->getMsgTargetAndFunctions( 0, sf, tgt, func );
        if ( func.size() > 0 && func[0] == "increment" )
        {
            incrementFuncVec_.push_back( ei->id() );
            // objMap_[ id.value() - objMapStart_ ] = numReac_;
            // numReac_++;
        }
        else if ( func.size() > 0 && func[0] == "setNumKf" )
        {
            reacFuncVec_.push_back( ei->id() );
        }
        else     // Assume it controls the N of a pool.
        {
            poolFuncVec_.push_back( ei->id() );
            // objMap_[ id.value() - objMapStart_ ] = numFunctions_;
            // ++numFunctions_;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::buildFuncLookup

(

)

Definition at line 1054 of file Stoich.cpp.

References funcLookup_, and poolFuncVec_.

Referenced by allocateModel().

{
    funcLookup_.clear();
    int funcNum = 0;
    vector< Id >::iterator i;
    for ( i = poolFuncVec_.begin(); i != poolFuncVec_.end(); ++i )
        funcLookup_[ *i ] = funcNum++;
}

Here is the caller graph for this function:

void Stoich::buildPoolLookup

(

)

Functions to build the maps between Ids and internal indices.

Definition at line 997 of file Stoich.cpp.

References bufPoolVec_, offSolverPoolVec_, poolLookup_, and varPoolVec_.

Referenced by allocateModel().

{
    // The order of pools is: varPools, offSolverVarPools, bufPools.
    poolLookup_.clear();
    int poolNum = 0;
    vector< Id >::iterator i;
    for ( i = varPoolVec_.begin(); i != varPoolVec_.end(); ++i )
        poolLookup_[ *i ] = poolNum++;
    for ( i = offSolverPoolVec_.begin(); i != offSolverPoolVec_.end(); ++i)
        poolLookup_[ *i ] = poolNum++;
    for ( i = bufPoolVec_.begin(); i != bufPoolVec_.end(); ++i )
        poolLookup_[ *i ] = poolNum++;
}

Here is the caller graph for this function:

void Stoich::buildRateTermLookup

(

)

Definition at line 1011 of file Stoich.cpp.

References enzVec_, incrementFuncVec_, mmEnzVec_, offSolverEnzVec_, offSolverMMenzVec_, offSolverReacVec_, rateTermLookup_, reacVec_, and useOneWay_.

Referenced by allocateModel().

{
    // The order of pools is: varPools, offSolverVarPools, bufPools.
    rateTermLookup_.clear();
    int termNum = 0;
    vector< Id >::iterator i;
    for ( i = reacVec_.begin(); i != reacVec_.end(); ++i )
    {
        rateTermLookup_[ *i ] = termNum;
        termNum += 1 + useOneWay_;
    }
    for ( i = enzVec_.begin(); i != enzVec_.end(); ++i )
    {
        rateTermLookup_[ *i ] = termNum;
        termNum += 2 + useOneWay_;
    }
    for ( i = mmEnzVec_.begin(); i != mmEnzVec_.end(); ++i )
    {
        rateTermLookup_[ *i ] = termNum;
        termNum += 1;
    }
    for ( i=incrementFuncVec_.begin(); i != incrementFuncVec_.end(); ++i )
    {
        rateTermLookup_[ *i ] = termNum;
        termNum += 1;
    }
    for ( i = offSolverReacVec_.begin(); i != offSolverReacVec_.end(); ++i)
    {
        rateTermLookup_[ *i ] = termNum;
        termNum += 1 + useOneWay_;
    }
    for ( i = offSolverEnzVec_.begin(); i != offSolverEnzVec_.end(); ++i )
    {
        rateTermLookup_[ *i ] = termNum;
        termNum += 2 + useOneWay_;
    }
    for ( i=offSolverMMenzVec_.begin(); i != offSolverMMenzVec_.end(); ++i)
    {
        rateTermLookup_[ *i ] = termNum;
        termNum += 1;
    }
}

Here is the caller graph for this function:

unsigned int Stoich::convertIdToFuncIndex

(

Id

id

)

const

Definition at line 1484 of file Stoich.cpp.

References funcLookup_.

Referenced by installAndUnschedFunc(), and setFunctionExpr().

{
    map< Id, unsigned int >::const_iterator i = funcLookup_.find( id );
    if ( i != funcLookup_.end() )
    {
        return i->second;
    }
    return ~0U;
}

Here is the caller graph for this function:

unsigned int Stoich::convertIdToPoolIndex

(

Id

id

)

const

Definition at line 1464 of file Stoich.cpp.

References poolLookup_.

Referenced by Gsolve::getPoolIndex(), Ksolve::getPoolIndex(), installAndUnschedFunc(), installAndUnschedFuncRate(), installAndUnschedFuncReac(), installEnzyme(), installMMenz(), and makeHalfReaction().

{
    map< Id, unsigned int >::const_iterator i = poolLookup_.find( id );
    if ( i != poolLookup_.end() )
    {
        return i->second;
    }
    return ~0U;
}

Here is the caller graph for this function:

unsigned int Stoich::convertIdToReacIndex

(

Id

id

)

const

Definition at line 1474 of file Stoich.cpp.

References rateTermLookup_.

Referenced by VoxelPoolsBase::filterCrossRateTerms(), getR1(), getR1offset1(), getR1offset2(), getR2(), innerInstallReaction(), installAndUnschedFuncRate(), installAndUnschedFuncReac(), installDummyEnzyme(), installEnzyme(), installMMenz(), setEnzK1(), setEnzK2(), setEnzK3(), setFunctionExpr(), setMMenzKcat(), setMMenzKm(), setReacKb(), and setReacKf().

{
    map< Id, unsigned int >::const_iterator i = rateTermLookup_.find( id );
    if ( i != rateTermLookup_.end() )
    {
        return i->second;
    }
    return ~0U;
}

Here is the caller graph for this function:

void Stoich::convertRatesToStochasticForm

(

)

This function is used when the stoich class is employed by a Gsolver for doing stochastic calculations. Here we fix the issue of having a single substrate at more than first order. As the first molecule of the substrate is consumed, the number is depleted by one and so its forward rate is reduced. And so on. This also protects against going negative in mol number or concentration.

Definition at line 1196 of file Stoich.cpp.

References RateTerm::getR1(), and rates_.

Referenced by Gsolve::rebuildGssaSystem().

{
    for ( unsigned int i = 0; i < rates_.size(); ++i )
    {
        vector< unsigned int > molIndex;
        if ( rates_[i]->getReactants( molIndex ) > 1 )
        {
            if ( molIndex.size() == 2 && molIndex[0] == molIndex[1] )
            {
                RateTerm* oldRate = rates_[i];
                rates_[ i ] = new StochSecondOrderSingleSubstrate(
                    oldRate->getR1(), molIndex[ 0 ]
                );
                delete oldRate;
            }
            else if ( molIndex.size() > 2 )
            {
                RateTerm* oldRate = rates_[ i ];
                rates_[i] = new StochNOrder( oldRate->getR1(), molIndex );
                delete oldRate;
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const FuncTerm * Stoich::funcs

(

unsigned int

i

)

const

Definition at line 599 of file Stoich.cpp.

References funcs_.

Referenced by Gsolve::fillPoolFuncDep().

{
    assert( i < funcs_.size() );
    assert( funcs_[i]);
    return funcs_[i];
}

Here is the caller graph for this function:

bool Stoich::getAllowNegative

(

)

const

Definition at line 315 of file Stoich.cpp.

References allowNegative_.

Referenced by initCinfo().

{
    return allowNegative_;
}

Here is the caller graph for this function:

vector< unsigned int > Stoich::getColIndex

(

)

const

Definition at line 617 of file Stoich.cpp.

References SparseMatrix< T >::colIndex(), and N_.

Referenced by initCinfo().

{
    return N_.colIndex();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Id Stoich::getCompartment

(

)

const

Definition at line 505 of file Stoich.cpp.

References compartment_.

Referenced by initCinfo(), and SteadyState::setStoich().

{
    return compartment_;
}

Here is the caller graph for this function:

Id Stoich::getDsolve

(

)

const

Definition at line 469 of file Stoich.cpp.

References dsolve_.

Referenced by initCinfo().

{
    return dsolve_;
}

Here is the caller graph for this function:

double Stoich::getEnzK2

(

const Eref &

e

)

const

Get rate k2 (1/sec) for enzyme.

Definition at line 1986 of file Stoich.cpp.

References getR1offset1(), getR2(), and useOneWay_.

Referenced by ZombieEnz::vGetK2().

{
    if ( useOneWay_ )
        return getR1offset1( e );
    else
        return getR2( e );
}

Here is the call graph for this function:

Here is the caller graph for this function:

double Stoich::getEnzK3

(

const Eref &

e

)

const

Get rate k3, aka kcat, for enzyme.

Definition at line 1994 of file Stoich.cpp.

References getR1offset1(), getR1offset2(), and useOneWay_.

Referenced by ZombieEnz::vGetKcat().

{
    if ( useOneWay_ )
        return getR1offset2( e );
    else
        return getR1offset1( e );
}

Here is the call graph for this function:

Here is the caller graph for this function:

double Stoich::getEnzNumK1

(

const Eref &

e

)

const

Definition at line 1981 of file Stoich.cpp.

References getR1().

{
    return getR1( e );
}

Here is the call graph for this function:

Id Stoich::getKsolve

(

)

const

Definition at line 446 of file Stoich.cpp.

References ksolve_.

Referenced by SteadyState::classifyState(), initCinfo(), and Ksolve::print().

{
    return ksolve_;
}

Here is the caller graph for this function:

vector< int > Stoich::getMatrixEntry

(

)

const

Definition at line 612 of file Stoich.cpp.

References SparseMatrix< T >::matrixEntry(), and N_.

Referenced by initCinfo().

{
    return N_.matrixEntry();
}

Here is the call graph for this function:

Here is the caller graph for this function:

double Stoich::getMMenzKcat

(

const Eref &

e

)

const

Definition at line 1937 of file Stoich.cpp.

References getR2().

Referenced by ZombieMMenz::vGetKcat().

{
    return getR2( e );
}

Here is the call graph for this function:

Here is the caller graph for this function:

double Stoich::getMMenzNumKm

(

const Eref &

e

)

const

Definition at line 1921 of file Stoich.cpp.

References getR1().

{
    return getR1( e );
}

Here is the call graph for this function:

unsigned int Stoich::getNumAllPools

(

)

const

Returns total number of pools. Includes the pools whose actual calculations happen on another solver, but are given a proxy here in order to handle cross-compartment reactions.

Definition at line 520 of file Stoich.cpp.

References bufPoolVec_, offSolverPoolVec_, and varPoolVec_.

Referenced by Gsolve::fillIncrementFuncDep(), Gsolve::fillPoolFuncDep(), Ksolve::getEstimatedDt(), initCinfo(), Gsolve::setStoich(), and Ksolve::setStoich().

{
    return varPoolVec_.size() + offSolverPoolVec_.size() + bufPoolVec_.size();
}

Here is the caller graph for this function:

unsigned int Stoich::getNumBufPools

(

)

const

Returns number of local buffered pools.

Definition at line 515 of file Stoich.cpp.

References bufPoolVec_.

Referenced by initCinfo(), and VoxelPoolsBase::scaleVolsBufsRates().

{
    return bufPoolVec_.size();
}

Here is the caller graph for this function:

unsigned int Stoich::getNumCoreRates

(

)

const

Number of rate terms for reactions purely on this compartment.

Utility function to return # of core rates for reacs which are entirely located on current compartment, including all reactants

Definition at line 574 of file Stoich.cpp.

References enzVec_, incrementFuncVec_, mmEnzVec_, reacVec_, and useOneWay_.

Referenced by installEnzyme(), installMMenz(), installReaction(), Gsolve::rebuildGssaSystem(), VoxelPoolsBase::scaleVolsBufsRates(), SteadyState::setStoich(), GssaVoxelPools::setVolumeAndDependencies(), Gsolve::updateRateTerms(), and Ksolve::updateRateTerms().

{
    return
        reacVec_.size() * (1 + useOneWay_) +
        enzVec_.size() * (2 + useOneWay_ ) +
        mmEnzVec_.size() + incrementFuncVec_.size();
}

Here is the caller graph for this function:

unsigned int Stoich::getNumFuncs

(

)

const

Definition at line 594 of file Stoich.cpp.

References funcs_.

Referenced by Gsolve::fillPoolFuncDep().

{
    return funcs_.size();
}

Here is the caller graph for this function:

unsigned int Stoich::getNumProxyPools

(

)

const

Returns number of proxy pools here for cross-compartment reactions

Definition at line 525 of file Stoich.cpp.

References offSolverPoolVec_.

Referenced by initCinfo(), Gsolve::rebuildGssaSystem(), and VoxelPoolsBase::xferInOnlyProxies().

{
    return offSolverPoolVec_.size();
}

Here is the caller graph for this function:

unsigned int Stoich::getNumRates

(

)

const

Utility function to return # of rates_ entries. This includes the cross-solver reactions.

Definition at line 568 of file Stoich.cpp.

References rates_.

Referenced by GssaVoxelPools::advance(), Gsolve::fillIncrementFuncDep(), Gsolve::fillMmEnzDep(), Gsolve::fillPoolFuncDep(), Ksolve::getEstimatedDt(), initCinfo(), Gsolve::makeReacDepsUnique(), and Gsolve::rebuildGssaSystem().

{
    return rates_.size();
}

Here is the caller graph for this function:

unsigned int Stoich::getNumVarPools

(

)

const

Returns number of local pools that are updated by solver.

Definition at line 510 of file Stoich.cpp.

References varPoolVec_.

Referenced by initCinfo(), Gsolve::process(), Ksolve::process(), Gsolve::rebuildGssaSystem(), GssaVoxelPools::reinit(), VoxelPoolsBase::scaleVolsBufsRates(), and VoxelPoolsBase::xferInOnlyProxies().

{
    return varPoolVec_.size();
}

Here is the caller graph for this function:

vector< Id > Stoich::getOffSolverCompts

(

)

const

List all the compartments to which the current compt is coupled, by cross-compartment reactions. Self not included.

Definition at line 2092 of file Stoich.cpp.

References offSolverPoolMap_.

{
    vector< Id > ret;
    for ( map< Id, vector< Id > >::const_iterator
            i = offSolverPoolMap_.begin(); i != offSolverPoolMap_.end(); ++i )
        ret.push_back( i->first );

    return ret;
}

const vector< Id > & Stoich::getOffSolverPools

(

)

const

Definition at line 2087 of file Stoich.cpp.

References offSolverPoolVec_.

{
    return offSolverPoolVec_;
}

bool Stoich::getOneWay

(

)

const

Definition at line 305 of file Stoich.cpp.

References useOneWay_.

Referenced by VoxelPoolsBase::filterCrossRateTerms().

{
    return useOneWay_;
}

Here is the caller graph for this function:

string Stoich::getPath

(

const Eref &

e

)

const

Definition at line 416 of file Stoich.cpp.

References path_.

Referenced by initCinfo().

{
    return path_;
}

Here is the caller graph for this function:

Id Stoich::getPoolByIndex

(

unsigned int

index

)

const

Definition at line 557 of file Stoich.cpp.

References poolLookup_.

{
    map< Id, unsigned int >::const_iterator i;
    for ( i = poolLookup_.begin(); i != poolLookup_.end(); ++i )
    {
        if( i->second == index )
            return i->first;
    }
    return Id();
}

vector< unsigned int > Stoich::getPoolIdMap

(

)

const

Map to look up the index of the pool from its Id. poolIndex = poolIdMap[ Id::value() - poolOffset ] where the poolOffset is the smallest Id::value. poolOffset is passed back as the last entry of this vector. Any Ids that are not pools return EMPTY=~0.

Definition at line 530 of file Stoich.cpp.

References poolLookup_.

Referenced by initCinfo().

{
    if ( poolLookup_.size() == 0 )
        return vector< unsigned int >( 1, 0 );

    unsigned int minId = 1000000;
    unsigned int maxId = 0;
    unsigned int maxIndex = 0;
    map< Id, unsigned int >::const_iterator i;
    for ( i = poolLookup_.begin(); i != poolLookup_.end(); ++i )
    {
        unsigned int j = i->first.value();
        if ( j < minId ) minId = j;
        if ( j > maxId ) maxId = j;
        if ( maxIndex < i->second ) maxIndex = i->second;
    }
    vector< unsigned int > ret( maxId - minId + 2, ~0U );
    for ( i = poolLookup_.begin(); i != poolLookup_.end(); ++i )
    {
        unsigned int j = i->first.value() - minId;
        ret[j] = i->second;
    }
    ret[ ret.size() -1 ] = minId;

    return ret;
}

Here is the caller graph for this function:

vector< Id > Stoich::getProxyPools

(

Id

i

)

const

Definition at line 627 of file Stoich.cpp.

References Element::cinfo(), dummy, Id::element(), Field< A >::get(), Cinfo::isA(), and offSolverPoolMap_.

Referenced by initCinfo().

{
    static vector< Id > dummy;
    if ( !i.element()->cinfo()->isA( "Stoich" ) )
    {
        cout << "Warning: Stoich::getProxyPools: argument " << i <<
             " is not a Stoich\n";
        return dummy;
    }
    Id compt = Field< Id >::get( i, "compartment" );
    map< Id, vector< Id > >::const_iterator j =
        offSolverPoolMap_.find( compt );
    if ( j != offSolverPoolMap_.end() )
        return j->second;
    return dummy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

double Stoich::getR1

(

const Eref &

e

)

const

Returns the internal rate in #/voxel, for R1, for the specified Eref.

Looks up the matching rate for R1. Later we may have additional scaling terms for the specified voxel.

Definition at line 2006 of file Stoich.cpp.

References convertIdToReacIndex(), Eref::id(), and rates_.

Referenced by getEnzNumK1(), getMMenzNumKm(), getR1offset1(), and getR1offset2().

{
    return rates_[ convertIdToReacIndex( e.id() ) ]->getR1();
}

Here is the call graph for this function:

Here is the caller graph for this function:

double Stoich::getR1offset1

(

const Eref &

e

)

const

Returns internal rate R1 in #/voxel, for the rate term following the one directly referred to by the Eref e. Enzymes define multiple successive rate terms, so we look up the first, and then select one after it.

Definition at line 2010 of file Stoich.cpp.

References convertIdToReacIndex(), getR1(), Eref::id(), and rates_.

Referenced by getEnzK2(), and getEnzK3().

{
    return rates_[ convertIdToReacIndex( e.id() ) + 1 ]->getR1();
}

Here is the call graph for this function:

Here is the caller graph for this function:

double Stoich::getR1offset2

(

const Eref &

e

)

const

Returns internal rate R1 in #/voxel, for the rate term two after the one directly referred to by the Eref e. Enzymes define multiple successive rate terms, so we look up the first, and then select the second one after it.

Definition at line 2014 of file Stoich.cpp.

References convertIdToReacIndex(), getR1(), Eref::id(), and rates_.

Referenced by getEnzK3().

{
    return rates_[ convertIdToReacIndex( e.id() ) + 2 ]->getR1();
}

Here is the call graph for this function:

Here is the caller graph for this function:

double Stoich::getR2

(

const Eref &

e

)

const

Returns the internal rate in #/voxel, for R2, for the specified reacIndex and voxel index. In some cases R2 is undefined, and it then returns 0.

Looks up the matching rate for R2. Later we may have additional scaling terms for the specified voxel.

Definition at line 2023 of file Stoich.cpp.

References convertIdToReacIndex(), Eref::id(), and rates_.

Referenced by getEnzK2(), and getMMenzKcat().

{
    return rates_[ convertIdToReacIndex( e.id() ) ]->getR2();
}

Here is the call graph for this function:

Here is the caller graph for this function:

const vector< RateTerm * > & Stoich::getRateTerms

(

)

const

Returns a reference to the entire rates_ vector.

Definition at line 589 of file Stoich.cpp.

References rates_.

Referenced by Gsolve::fillIncrementFuncDep(), Gsolve::rebuildGssaSystem(), VoxelPoolsBase::scaleVolsBufsRates(), SteadyState::setStoich(), GssaVoxelPools::setVolumeAndDependencies(), Gsolve::updateRateTerms(), and Ksolve::updateRateTerms().

{
    return rates_;
}

Here is the caller graph for this function:

vector< unsigned int > Stoich::getRowStart

(

)

const

Definition at line 622 of file Stoich.cpp.

References N_, and SparseMatrix< T >::rowStart().

Referenced by initCinfo().

{
    return N_.rowStart();
}

Here is the call graph for this function:

Here is the caller graph for this function:

SpeciesId Stoich::getSpecies

(

unsigned int

poolIndex

)

const

Returns SpeciesId of specified pool

Definition at line 2055 of file Stoich.cpp.

References species_.

{
    return species_[ poolIndex ];
}

int Stoich::getStatus

(

)

const

getStatus(): Flag to track status of Stoich object. -1: No path yet assigned. 0: Success 1: Warning: Missing reactant in Reac or Enz 2: Warning: Missing substrate in MMenz 4: Warning: Compartment not defined 8: Warning: Neither Ksolve nor Dsolve defined 16: Warning: No objects found on path

Definition at line 644 of file Stoich.cpp.

References status_.

Referenced by initCinfo().

{
    return status_;
}

Here is the caller graph for this function:

const KinSparseMatrix & Stoich::getStoichiometryMatrix

(

)

const

Updates the rates for cross-compartment reactions.

Get the rate for a single reaction specified by r, as per all the mol numbers in s. double getReacVelocity( unsigned int r, const double* s, unsigned int volIndex ) const;Returns the stoich matrix. Used by gsolve.

Definition at line 1221 of file Stoich.cpp.

References N_.

Referenced by Gsolve::fillPoolFuncDep(), Gsolve::rebuildGssaSystem(), and GssaVoxelPools::updateReacVelocities().

{
    return N_;
}

Here is the caller graph for this function:

const Cinfo * Stoich::initCinfo ( )

static

Definition at line 34 of file Stoich.cpp.

References getAllowNegative(), getColIndex(), getCompartment(), getDsolve(), getKsolve(), getMatrixEntry(), getNumAllPools(), getNumBufPools(), getNumProxyPools(), getNumRates(), getNumVarPools(), getPath(), getPoolIdMap(), getProxyPools(), getRowStart(), getStatus(), Neutral::initCinfo(), path, scaleBufsAndRates(), setAllowNegative(), setCompartment(), setDsolve(), setKsolve(), setPath(), stoichCinfo, and unZombifyModel().

{
    // Field Definitions
    static ElementValueFinfo< Stoich, string > path(
        "path",
        "Wildcard path for reaction system handled by Stoich",
        &Stoich::setPath,
        &Stoich::getPath
    );

    static ValueFinfo< Stoich, Id > ksolve(
        "ksolve",
        "Id of Kinetic reaction solver class that works with this "
        "Stoich. "
        " Must be of class Ksolve, or Gsolve (at present) "
        " Must be assigned before the path is set.",
        &Stoich::setKsolve,
        &Stoich::getKsolve
    );

    static ValueFinfo< Stoich, Id > dsolve(
        "dsolve",
        "Id of Diffusion solver class that works with this Stoich."
        " Must be of class Dsolve "
        " If left unset then the system will be assumed to work in a"
        " non-diffusive, well-stirred cell. If it is going to be "
        " used it must be assigned before the path is set.",
        &Stoich::setDsolve,
        &Stoich::getDsolve
    );

    static ValueFinfo< Stoich, Id > compartment(
        "compartment",
        "Id of chemical compartment class that works with this Stoich."
        " Must be derived from class ChemCompt."
        " If left unset then the system will be assumed to work in a"
        " non-diffusive, well-stirred cell. If it is going to be "
        " used it must be assigned before the path is set.",
        &Stoich::setCompartment,
        &Stoich::getCompartment
    );

    static ValueFinfo< Stoich, bool > allowNegative(
        "allowNegative",
        "Flag: allow negative values if true. Default is false."
        " This is used to protect the chemical system from going unstable"
        " in cases where the numerical integration gives a negative value."
        " Typically it is a small negative value but is obviously"
        " physically impossible. In some cases we want to use the "
        " solvers to handle general systems of equations (not purely "
        " chemical ones), so we have this flag to allow it.",
        &Stoich::setAllowNegative,
        &Stoich::getAllowNegative
    );

    static ReadOnlyValueFinfo< Stoich, unsigned int > numVarPools(
        "numVarPools",
        "Number of time-varying pools to be computed by the "
        "numerical engine",
        &Stoich::getNumVarPools
    );

    static ReadOnlyValueFinfo< Stoich, unsigned int > numBufPools(
        "numBufPools",
        "Number of buffered pools to be computed by the "
        "numerical engine. Includes pools controlled by functions.",
        &Stoich::getNumBufPools
    );

    static ReadOnlyValueFinfo< Stoich, unsigned int > numAllPools(
        "numAllPools",
        "Total number of pools handled by the numerical engine. "
        "This includes variable ones, buffered ones, and functions. "
        "It includes local pools as well as cross-solver proxy pools.",
        &Stoich::getNumAllPools
    );

    static ReadOnlyValueFinfo< Stoich, unsigned int > numProxyPools(
        "numProxyPools",
        "Number of pools here by proxy as substrates of a cross-"
        "compartment reaction.",
        &Stoich::getNumProxyPools
    );

    static ReadOnlyValueFinfo< Stoich, vector< unsigned int > >
    poolIdMap(
        "poolIdMap",
        "Map to look up the index of the pool from its Id."
        "poolIndex = poolIdMap[ Id::value() - poolOffset ] "
        "where the poolOffset is the smallest Id::value. "
        "poolOffset is passed back as the last entry of this vector."
        " Any Ids that are not pools return EMPTY=~0. ",
        &Stoich::getPoolIdMap
    );

    static ReadOnlyValueFinfo< Stoich, unsigned int > numRates(
        "numRates",
        "Total number of rate terms in the reaction system.",
        &Stoich::getNumRates
    );

    // Stuff here for getting Stoichiometry matrix to manipulate in
    // Python.
    static ReadOnlyValueFinfo< Stoich, vector< int > >
    matrixEntry(
        "matrixEntry",
        "The non-zero matrix entries in the sparse matrix. Their"
        "column indices are in a separate vector and the row"
        "information in a third",
        &Stoich::getMatrixEntry
    );
    // Stuff here for getting Stoichiometry matrix to manipulate in
    // Python.
    static ReadOnlyValueFinfo< Stoich, vector< unsigned int > >
    columnIndex(
        "columnIndex",
        "Column Index of each matrix entry",
        &Stoich::getColIndex
    );
    // Stuff here for getting Stoichiometry matrix to manipulate in
    // Python.
    static ReadOnlyValueFinfo< Stoich, vector< unsigned int > >
    rowStart(
        "rowStart",
        "Row start for each block of entries and column indices",
        &Stoich::getRowStart
    );

    // Proxy pool information
    static ReadOnlyLookupValueFinfo< Stoich, Id, vector< Id > >
    proxyPools(
        "proxyPools",
        "Return vector of proxy pools for X-compt reactions between "
        "current stoich, and the argument, which is a StoichId. "
        "The returned pools belong to the compartment handling the "
        "Stoich specified in the argument. "
        "If no pools are found, return an empty vector.",
        &Stoich::getProxyPools
    );

    static ReadOnlyValueFinfo< Stoich, int > status(
        "status",
        "Status of Stoich in the model building process. Values are: "
        "-1: Reaction path not yet assigned.\n "
        "0: Successfully built stoichiometry matrix.\n "
        "1: Warning: Missing a reactant in a Reac or Enz.\n "
        "2: Warning: Missing a substrate in an MMenz.\n "
        "3: Warning: Missing substrates as well as reactants.\n "
        "4: Warning: Compartment not defined.\n "
        "8: Warning: Neither Ksolve nor Dsolve defined.\n "
        "16: Warning: No objects found on path.\n "
        "",
        &Stoich::getStatus
    );

    // MsgDest Definitions
    static DestFinfo unzombify( "unzombify",
                                "Restore all zombies to their native state",
                                new OpFunc0< Stoich >( &Stoich::unZombifyModel )
                              );
    static DestFinfo scaleBufsAndRates( "scaleBufsAndRates",
                                        "Args: voxel#, volRatio\n"
                                        "Handles requests for runtime volume changes in the specified "
                                        "voxel#, Used in adaptors changing spine vols.",
                                        new OpFunc2< Stoich, unsigned int, double >(
                                            &Stoich::scaleBufsAndRates )
                                      );

    // SrcFinfo Definitions

    // SharedMsg Definitions

    static Finfo* stoichFinfos[] =
    {
        &path,              // ElementValue
        &ksolve,            // Value
        &dsolve,            // Value
        &compartment,       // Value
        &allowNegative,     // Value
        &numVarPools,       // ReadOnlyValue
        &numBufPools,       // ReadOnlyValue
        &numAllPools,       // ReadOnlyValue
        &numProxyPools,     // ReadOnlyValue
        &poolIdMap,         // ReadOnlyValue
        &numRates,          // ReadOnlyValue
        &matrixEntry,       // ReadOnlyValue
        &columnIndex,       // ReadOnlyValue
        &rowStart,          // ReadOnlyValue
        &proxyPools,        // ReadOnlyLookupValue
        &status,            // ReadOnlyLookupValue
        &unzombify,         // DestFinfo
        &scaleBufsAndRates, // DestFinfo
    };

    static Dinfo< Stoich > dinfo;
    static Cinfo stoichCinfo (
        "Stoich",
        Neutral::initCinfo(),
        stoichFinfos,
        sizeof( stoichFinfos ) / sizeof ( Finfo* ),
        &dinfo
    );

    return &stoichCinfo;
}

Here is the call graph for this function:

unsigned int Stoich::innerInstallReaction	(	Id	reacId,
		const vector< Id > &	subs,
		const vector< Id > &	prds
	)

This takes the specified forward and reverse half-reacs belonging to the specified Reac, and builds them into the Stoich.

Definition at line 1562 of file Stoich.cpp.

References convertIdToReacIndex(), SparseMatrix< T >::get(), ZeroOrder::getReactants(), makeHalfReaction(), N_, rates_, SparseMatrix< T >::set(), and useOneWay_.

Referenced by installReaction().

{
    ZeroOrder* forward = makeHalfReaction( 0, subs );
    ZeroOrder* reverse = makeHalfReaction( 0, prds );
    unsigned int rateIndex = convertIdToReacIndex( reacId );
    unsigned int revRateIndex = rateIndex;
    if ( useOneWay_ )
    {
        rates_[ rateIndex ] = forward;
        revRateIndex = rateIndex + 1;
        rates_[ revRateIndex ] = reverse;
    }
    else
    {
        rates_[ rateIndex ] =
            new BidirectionalReaction( forward, reverse );
    }

    vector< unsigned int > molIndex;
    vector< double > reacScaleSubstrates;
    vector< double > reacScaleProducts;

    if ( useOneWay_ )
    {
        unsigned int numReactants = forward->getReactants( molIndex );
        for ( unsigned int i = 0; i < numReactants; ++i )
        {
            int temp = N_.get( molIndex[i], rateIndex );
            N_.set( molIndex[i], rateIndex, temp - 1 );
            temp = N_.get( molIndex[i], revRateIndex );
            N_.set( molIndex[i], revRateIndex, temp + 1 );
        }

        numReactants = reverse->getReactants( molIndex );
        for ( unsigned int i = 0; i < numReactants; ++i )
        {
            int temp = N_.get( molIndex[i], rateIndex );
            N_.set( molIndex[i], rateIndex, temp + 1 );
            temp = N_.get( molIndex[i], revRateIndex );
            N_.set( molIndex[i], revRateIndex, temp - 1 );
        }
    }
    else
    {
        unsigned int numReactants = forward->getReactants( molIndex );
        for ( unsigned int i = 0; i < numReactants; ++i )
        {
            int temp = N_.get( molIndex[i], rateIndex );
            N_.set( molIndex[i], rateIndex, temp - 1 );
        }

        numReactants = reverse->getReactants( molIndex );
        for ( unsigned int i = 0; i < numReactants; ++i )
        {
            int temp = N_.get( molIndex[i], revRateIndex );
            N_.set( molIndex[i], rateIndex, temp + 1 );
        }
    }
    return rateIndex;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::installAndUnschedFunc	(	Id	func,
		Id	pool,
		double	volScale
	)

This installs a FuncTerm, which evaluates a function to specify the conc of the specific pool. The pool is a BufPool.

Definition at line 1067 of file Stoich.cpp.

References convertIdToFuncIndex(), convertIdToPoolIndex(), Id::element(), Cinfo::find(), Cinfo::findFinfo(), funcs_, funcTarget_, Field< A >::get(), FuncTerm::setExpr(), FuncTerm::setReactantIndex(), FuncTerm::setTarget(), Element::setTick(), FuncTerm::setVolScale(), and Id::value().

Referenced by zombifyPoolFuncWithScaling().

{
    static const Cinfo* varCinfo = Cinfo::find( "Variable" );
    static const Finfo* funcInputFinfo = varCinfo->findFinfo( "input" );
    static const DestFinfo* df = dynamic_cast< const DestFinfo* >( funcInputFinfo );
    assert( df );
    // Unsched Func
    func.element()->setTick( -2 ); // Disable with option to resurrect.

    // Install the FuncTerm
    FuncTerm* ft = new FuncTerm();

    Id ei( func.value() + 1 );

    unsigned int numSrc = Field< unsigned int >::get( func, "numVars" );
    vector< pair< Id, unsigned int> > srcPools;
#ifndef NDEBUG
    unsigned int n =
#endif
        ei.element()->getInputsWithTgtIndex( srcPools, df );
    assert( numSrc == n );
    vector< unsigned int > poolIndex( numSrc, 0 );
    for ( unsigned int i = 0; i < numSrc; ++i )
    {
        unsigned int j = srcPools[i].second;
        if ( j >= numSrc )
        {
            cout << "Warning: Stoich::installAndUnschedFunc: tgt index not allocated, " << j << ",  " << numSrc << endl;
            continue;
        }
        poolIndex[j] = convertIdToPoolIndex( srcPools[i].first );
    }
    ft->setReactantIndex( poolIndex );
    string expr = Field< string >::get( func, "expr" );
    ft->setExpr( expr );
    // Tie the output of the FuncTerm to the pool it controls.
    unsigned int targetIndex = convertIdToPoolIndex( pool );
    ft->setTarget( targetIndex );
    ft->setVolScale( volScale );
    unsigned int funcIndex = convertIdToFuncIndex( func );
    assert( funcIndex != ~0U );
    // funcTarget_ vector tracks which pools are controlled by which func.
    funcTarget_[targetIndex] = funcIndex;
    funcs_[ funcIndex ] = ft;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::installAndUnschedFuncRate	(	Id	func,
		Id	pool
	)

This installs a FuncRate, which evaluates a function to specify the rate of change of conc of the specific pool. The pool is a Pool.

Definition at line 1113 of file Stoich.cpp.

References convertIdToPoolIndex(), convertIdToReacIndex(), Id::element(), Cinfo::find(), Cinfo::findFinfo(), SparseMatrix< T >::get(), Field< A >::get(), N_, rates_, SparseMatrix< T >::set(), FuncRate::setExpr(), FuncRate::setFuncArgIndex(), Element::setTick(), and Id::value().

Referenced by zombifyModel().

{
    static const Cinfo* varCinfo = Cinfo::find( "Variable" );
    static const Finfo* funcInputFinfo = varCinfo->findFinfo( "input" );
    static const DestFinfo* df = dynamic_cast< const DestFinfo* >( funcInputFinfo );
    assert( df );
    // Unsched Func
    func.element()->setTick( -2 ); // Disable with option to resurrect.

    // Note that we set aside this index during allocateModelObject
    unsigned int rateIndex = convertIdToReacIndex( func );
    unsigned int tempIndex = convertIdToPoolIndex( pool );
    assert( rateIndex != ~0U );
    assert( tempIndex != ~0U );
    // Install the FuncReac
    FuncRate* fr = new FuncRate( 1.0, tempIndex );
    rates_[rateIndex] = fr;
    int stoichEntry = N_.get( tempIndex, rateIndex );
    N_.set( tempIndex, rateIndex, stoichEntry + 1 );

    Id ei( func.value() + 1 );

    unsigned int numSrc = Field< unsigned int >::get( func, "numVars" );
    vector< pair< Id, unsigned int > > srcPools;
#ifndef NDEBUG
    unsigned int n =
#endif
        ei.element()->getInputsWithTgtIndex( srcPools, df );
    assert( numSrc == n );
    vector< unsigned int > poolIndex( numSrc, 0 );
    for ( unsigned int i = 0; i < numSrc; ++i )
    {
        unsigned int j = srcPools[i].second;
        if ( j >= numSrc )
        {
            cout << "Warning: Stoich::installAndUnschedFuncRate: tgt index not allocated, " << j << ",  " << numSrc << endl;
            continue;
        }
        poolIndex[j] = convertIdToPoolIndex( srcPools[i].first );
    }
    fr->setFuncArgIndex( poolIndex );
    string expr = Field< string >::get( func, "expr" );
    fr->setExpr( expr );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::installAndUnschedFuncReac	(	Id	func,
		Id	reac
	)

This installs a FuncReac, which evaluates a function to specify the rate (Kf) of the specified reaction.

Definition at line 1158 of file Stoich.cpp.

References convertIdToPoolIndex(), convertIdToReacIndex(), Id::element(), Cinfo::find(), Cinfo::findFinfo(), Field< A >::get(), rates_, FuncRate::setExpr(), FuncRate::setFuncArgIndex(), Element::setTick(), and Id::value().

Referenced by zombifyModel().

{
    static const Cinfo* varCinfo = Cinfo::find( "Variable" );
    // static const Finfo* funcSrcFinfo = varCinfo->findFinfo( "input" );
    static const Finfo* funcSrcFinfo = varCinfo->findFinfo( "input" );
    assert( funcSrcFinfo );
    // Unsched Func
    func.element()->setTick( -2 ); // Disable with option to resurrect.

    unsigned int rateIndex = convertIdToReacIndex( reac );
    assert( rateIndex != ~0U );
    // Install the FuncReac
    double k = rates_[rateIndex]->getR1();
    vector< unsigned int > reactants;
    unsigned int numForward = rates_[rateIndex]->getReactants( reactants );
    // The reactants vector has both substrates and products.
    reactants.resize( numForward );
    FuncReac* fr = new FuncReac( k, reactants );
    delete rates_[rateIndex];
    rates_[rateIndex] = fr;

    Id ei( func.value() + 1 );

    unsigned int numSrc = Field< unsigned int >::get( func, "numVars" );
    vector< Id > srcPools;
#ifndef NDEBUG
    unsigned int n =
#endif
        ei.element()->getNeighbors( srcPools, funcSrcFinfo);
    assert( numSrc == n );
    vector< unsigned int > poolIndex( numSrc, 0 );
    for ( unsigned int i = 0; i < numSrc; ++i )
        poolIndex[i] = convertIdToPoolIndex( srcPools[i] );
    fr->setFuncArgIndex( poolIndex );
    string expr = Field< string >::get( func, "expr" );
    fr->setExpr( expr );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::installDummyEnzyme	(	Id	enzId,
		Id	enzMolId
	)

This is used when the enzyme lacks sub or prd.

Definition at line 1711 of file Stoich.cpp.

References convertIdToReacIndex(), dummy, rates_, status_, and useOneWay_.

{
    ZeroOrder* r1 = new ZeroOrder( 0.0 ); // Dummy
    ZeroOrder* r2 = new ZeroOrder( 0.0 ); // Dummy
    ZeroOrder* r3 = new ZeroOrder( 0.0 ); // Dummy
    vector< Id > dummy;
    unsigned int rateIndex = convertIdToReacIndex( enzId );
    if ( useOneWay_ )
    {
        rates_[ rateIndex ] = r1;
        rates_[ rateIndex + 1 ] = r2;
        rates_[ rateIndex + 2 ] = r3;
    }
    else
    {
        rates_[ rateIndex ] = new BidirectionalReaction( r1, r2 );
        rates_[ rateIndex + 1 ] = r3;
    }
    status_ = 1;
}

Here is the call graph for this function:

void Stoich::installEnzyme	(	Id	enzId,
		Id	enzMolId,
		Id	cplxId,
		const vector< Id > &	subs,
		const vector< Id > &	prds
	)

Definition at line 1732 of file Stoich.cpp.

References convertIdToReacIndex(), dummy, getCompt(), getNumCoreRates(), ObjId::id, makeHalfReaction(), prdComptVec_, subComptVec_, and useOneWay_.

Referenced by ZombieEnz::setSolver().

{
    vector< Id > temp( subs );
    temp.insert( temp.begin(), enzMolId );
    ZeroOrder* r1 = makeHalfReaction( 0, temp );
    temp.clear();
    temp.resize( 1, cplxId );
    ZeroOrder* r2 = makeHalfReaction( 0, temp );
    ZeroOrder* r3 = makeHalfReaction( 0, temp );

    installEnzyme( r1, r2, r3, enzId, enzMolId, prds );
    unsigned int rateIndex = convertIdToReacIndex( enzId );
    if ( rateIndex < getNumCoreRates() ) // Only handle off-compt reacs
        return;
    vector< Id > subCompt;
    vector< Id > dummy;
    for ( vector< Id >::const_iterator
            i = subs.begin(); i != subs.end(); ++i )
        subCompt.push_back( getCompt( *i ).id );

    if ( useOneWay_ )
    {
        // enz is split into 3 reactions. Only the first might be off-compt
        subComptVec_.push_back( subCompt );
        subComptVec_.push_back( dummy );
        subComptVec_.push_back( dummy );
        prdComptVec_.push_back( dummy );
        prdComptVec_.push_back( dummy );
        prdComptVec_.push_back( dummy );
        //assert ( 2 + rateIndex - getNumCoreRates() == subComptVec_.size());
        //assert ( 2 + rateIndex - getNumCoreRates() == prdComptVec_.size());
    }
    else
    {
        // enz is split into 2 reactions. Only the first might be off-compt
        subComptVec_.push_back( subCompt );
        subComptVec_.push_back( dummy );
        prdComptVec_.push_back( dummy );
        prdComptVec_.push_back( dummy );
        //assert ( 1+rateIndex - getNumCoreRates() == subComptVec_.size() );
        // assert ( 1+rateIndex - getNumCoreRates() == prdComptVec_.size() );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::installEnzyme	(	ZeroOrder *	r1,
		ZeroOrder *	r2,
		ZeroOrder *	r3,
		Id	enzId,
		Id	enzMolId,
		const vector< Id > &	prds
	)

This takes the forward, backward and product formation half-reacs belonging to the specified Enzyme, and builds them into the Stoich. This is the low-level function.

Definition at line 1777 of file Stoich.cpp.

References convertIdToPoolIndex(), convertIdToReacIndex(), SparseMatrix< T >::get(), ZeroOrder::getReactants(), N_, rates_, SparseMatrix< T >::set(), and useOneWay_.

{
    unsigned int rateIndex = convertIdToReacIndex( enzId );

    if ( useOneWay_ )
    {
        rates_[ rateIndex ] = r1;
        rates_[ rateIndex + 1 ] = r2;
        rates_[ rateIndex + 2 ] = r3;
    }
    else
    {
        rates_[ rateIndex ] = new BidirectionalReaction( r1, r2 );
        rates_[ rateIndex + 1 ] = r3;
    }

    vector< unsigned int > poolIndex;
    unsigned int numReactants = r2->getReactants( poolIndex );
    assert( numReactants == 1 ); // Should be cplx as the only product
    unsigned int cplxPool = poolIndex[0];

    if ( useOneWay_ )
    {
        numReactants = r1->getReactants( poolIndex ); // Substrates
        for ( unsigned int i = 0; i < numReactants; ++i )
        {
            int temp = N_.get( poolIndex[i], rateIndex ); // terms for r1
            N_.set( poolIndex[i], rateIndex, temp - 1 );
            temp = N_.get( poolIndex[i], rateIndex + 1 ); //terms for r2
            N_.set( poolIndex[i], rateIndex + 1, temp + 1 );
        }

        int temp = N_.get( cplxPool, rateIndex );   // term for r1
        N_.set( cplxPool, rateIndex, temp + 1 );
        temp = N_.get( cplxPool, rateIndex + 1 );   // term for r2
        N_.set( cplxPool, rateIndex + 1, temp -1 );
    }
    else     // Regular bidirectional reactions.
    {
        numReactants = r1->getReactants( poolIndex ); // Substrates
        for ( unsigned int i = 0; i < numReactants; ++i )
        {
            int temp = N_.get( poolIndex[i], rateIndex );
            N_.set( poolIndex[i], rateIndex, temp - 1 );
        }
        int temp = N_.get( cplxPool, rateIndex );
        N_.set( cplxPool, rateIndex, temp + 1 );
    }

    // Now assign reaction 3. The complex is the only substrate here.
    // Reac 3 is already unidirectional, so all we need to do to handle
    // one-way reactions is to get the index right.
    unsigned int reac3index = ( useOneWay_ ) ? rateIndex + 2 : rateIndex + 1;
    int temp = N_.get( cplxPool, reac3index );
    N_.set( cplxPool, reac3index, temp - 1 );

    // For the products, we go to the prd list directly.
    for ( unsigned int i = 0; i < prds.size(); ++i )
    {
        unsigned int j = convertIdToPoolIndex( prds[i] );
        int temp = N_.get( j, reac3index );
        N_.set( j, reac3index, temp + 1 );
    }
    // Enz is also a product here.
    unsigned int enzPool = convertIdToPoolIndex( enzMolId );
    temp = N_.get( enzPool, reac3index );
    N_.set( enzPool, reac3index, temp + 1 );
}

Here is the call graph for this function:

void Stoich::installMMenz	(	Id	enzId,
		const vector< Id > &	enzMols,
		const vector< Id > &	subs,
		const vector< Id > &	prds
	)

This takes the baseclass for an MMEnzyme and builds the MMenz into the Stoich.

Definition at line 1636 of file Stoich.cpp.

References convertIdToPoolIndex(), convertIdToReacIndex(), dummy, getCompt(), getNumCoreRates(), ObjId::id, installDummy(), prdComptVec_, rates_, status_, and subComptVec_.

{
    MMEnzymeBase* meb;
    unsigned int enzSiteIndex = convertIdToReacIndex( enzId );
    RateTerm** entry = &rates_[enzSiteIndex];
    if ( enzMols.size() != 1 )
    {
        installDummy( entry, enzId, "enzmols" );
        status_ |= 2;
        return;
    }

    if ( prds.size() < 1 )
    {
        installDummy( entry, enzId, "products" );
        status_ |= 1;
        return;
    }
    unsigned int enzIndex = convertIdToPoolIndex( enzMols[0] );

    if ( subs.size() == 1 )
    {
        unsigned int subIndex = convertIdToPoolIndex( subs[0] );
        meb = new MMEnzyme1( 1, 1, enzIndex, subIndex );
    }
    else if ( subs.size() > 1 )
    {
        vector< unsigned int > v;
        for ( unsigned int i = 0; i < subs.size(); ++i )
            v.push_back( convertIdToPoolIndex( subs[i] ) );
        ZeroOrder* rateTerm = new NOrder( 1.0, v );
        meb = new MMEnzyme( 1, 1, enzIndex, rateTerm );
    }
    else
    {
        installDummy( entry, enzId, "substrates" );
        status_ |= 2;
        return;
    }
    installMMenz( meb, enzSiteIndex, subs, prds );
    if ( enzSiteIndex < getNumCoreRates() ) // Only handle off-compt reacs
        return;
    vector< Id > subCompt;
    vector< Id > dummy;
    for ( vector< Id >::const_iterator
            i = subs.begin(); i != subs.end(); ++i )
        subCompt.push_back( getCompt( *i ).id );
    subComptVec_.push_back( subCompt );
    prdComptVec_.push_back( dummy );
    assert ( enzSiteIndex - getNumCoreRates() == subComptVec_.size() );
    assert ( enzSiteIndex - getNumCoreRates() == prdComptVec_.size() );
}

Here is the call graph for this function:

void Stoich::installMMenz	(	MMEnzymeBase *	meb,
		unsigned int	rateIndex,
		const vector< Id > &	subs,
		const vector< Id > &	prds
	)

This is the internal variant to install the MMenz.

This is the inner function to do the installation.

Definition at line 1691 of file Stoich.cpp.

References convertIdToPoolIndex(), SparseMatrix< T >::get(), N_, rates_, and SparseMatrix< T >::set().

{
    rates_[rateIndex] = meb;

    for ( unsigned int i = 0; i < subs.size(); ++i )
    {
        unsigned int poolIndex = convertIdToPoolIndex( subs[i] );
        int temp = N_.get( poolIndex, rateIndex );
        N_.set( poolIndex, rateIndex, temp - 1 );
    }
    for ( unsigned int i = 0; i < prds.size(); ++i )
    {
        unsigned int poolIndex = convertIdToPoolIndex( prds[i] );
        int temp = N_.get( poolIndex, rateIndex );
        N_.set( poolIndex, rateIndex, temp + 1 );
    }
}

Here is the call graph for this function:

void Stoich::installReaction	(	Id	reacId,
		const vector< Id > &	subs,
		const vector< Id > &	prds
	)

Definition at line 1525 of file Stoich.cpp.

References dummy, getCompt(), getNumCoreRates(), ObjId::id, innerInstallReaction(), prdComptVec_, subComptVec_, and useOneWay_.

Referenced by ZombieReac::setSolver().

{
    static vector< Id > dummy;
    unsigned int rateIndex = innerInstallReaction( reacId, subs, prds );
    if ( rateIndex < getNumCoreRates() ) // Only handle off-compt reacs
        return;
    vector< Id > subCompt;
    vector< Id > prdCompt;
    for ( vector< Id >::const_iterator
            i = subs.begin(); i != subs.end(); ++i )
        subCompt.push_back( getCompt( *i ).id );
    for ( vector< Id >::const_iterator
            i = prds.begin(); i != prds.end(); ++i )
        prdCompt.push_back( getCompt( *i ).id );

    assert ( rateIndex - getNumCoreRates() == subComptVec_.size() );
    assert ( rateIndex - getNumCoreRates() == prdComptVec_.size() );
    if ( useOneWay_ )
    {
        subComptVec_.push_back( subCompt );
        subComptVec_.push_back( prdCompt );
        prdComptVec_.push_back( dummy );
        prdComptVec_.push_back( dummy );
    }
    else
    {
        subComptVec_.push_back( subCompt );
        prdComptVec_.push_back( prdCompt );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Stoich::isFuncTarget

(

unsigned int

poolIndex

)

const

Returns true if the specified pool is controlled by a func.

Definition at line 606 of file Stoich.cpp.

References funcTarget_.

Referenced by VoxelPoolsBase::scaleVolsBufsRates().

{
    assert( poolIndex < funcTarget_.size() );
    return ( funcTarget_[poolIndex] != ~0U );
}

Here is the caller graph for this function:

void Stoich::locateOffSolverReacs	(	Id	myCompt,
		vector< Id > &	elist
	)

Scans through elist to find any reactions that connect to pools not located on solver. Removes these reactions from the elist and maintains Ids of the affected reactions, and their off-solver pools, in offSolverReacs_ and offSolverPools_.

Definition at line 725 of file Stoich.cpp.

References Element::cinfo(), extractCompts(), Cinfo::isA(), isOffSolverReac(), offSolverEnzCompts_, offSolverEnzVec_, offSolverMMenzCompts_, offSolverMMenzVec_, offSolverPoolMap_, offSolverPoolVec_, offSolverReacCompts_, and offSolverReacVec_.

{
    offSolverPoolVec_.clear();
    offSolverReacVec_.clear();
    offSolverEnzVec_.clear();
    offSolverMMenzVec_.clear();
    offSolverReacCompts_.clear();
    offSolverEnzCompts_.clear();
    offSolverMMenzCompts_.clear();
    map< Id, Id > poolComptMap; // < pool, compt >

    vector< Id > temp;
    temp.reserve( elist.size() );
    for ( vector< Id >::const_iterator
            i = elist.begin(); i != elist.end(); ++i )
    {
        const Element* e = i->element();
        if ( e->cinfo()->isA( "ReacBase" ) || e->cinfo()->isA( "EnzBase" ) )
        {
            vector< Id > compts;
            if ( isOffSolverReac( e, myCompt, compts, poolComptMap  ) )
            {
                if ( e->cinfo()->isA( "ReacBase" ) )
                {
                    offSolverReacVec_.push_back( *i );
                    offSolverReacCompts_.push_back( extractCompts(compts));
                }
                else if ( e->cinfo()->isA( "CplxEnzBase" ) )
                {
                    offSolverEnzVec_.push_back( *i );
                    offSolverEnzCompts_.push_back( extractCompts(compts));
                }
                else if ( e->cinfo()->isA( "EnzBase" ) )
                {
                    offSolverMMenzVec_.push_back( *i );
                    offSolverMMenzCompts_.push_back(extractCompts(compts));
                }
            }
            else
            {
                temp.push_back( *i );
            }
        }
        else
        {
            temp.push_back( *i );
        }
    }

    offSolverPoolMap_.clear();
    for ( map< Id, Id >::iterator
            i = poolComptMap.begin(); i != poolComptMap.end(); ++i )
    {
        // fill in the map for activeOffSolverPools.
        offSolverPoolMap_[i->second].push_back( i->first );
    }

    // Ensure we don't have repeats, and the pools are ordered by compt
    offSolverPoolVec_.clear();
    for ( map< Id, vector< Id > >::iterator
            i = offSolverPoolMap_.begin(); i != offSolverPoolMap_.end(); ++i )
    {
        if ( i->first != myCompt )
        {
            offSolverPoolVec_.insert( offSolverPoolVec_.end(),
                                      i->second.begin(), i->second.end() );
        }
    }

    elist = temp;
}

Here is the call graph for this function:

ZeroOrder * Stoich::makeHalfReaction	(	double	rate,
		const vector< Id > &	reactants
	)

Utility function to make a half reac and return the rate term.

Definition at line 1494 of file Stoich.cpp.

References convertIdToPoolIndex(), and status_.

Referenced by innerInstallReaction(), and installEnzyme().

{
    ZeroOrder* rateTerm = 0;
    if ( reactants.size() == 1 )
    {
        rateTerm =  new FirstOrder(
            rate, convertIdToPoolIndex( reactants[0] ) );
    }
    else if ( reactants.size() == 2 )
    {
        rateTerm = new SecondOrder( rate,
                                    convertIdToPoolIndex( reactants[0] ),
                                    convertIdToPoolIndex( reactants[1] ) );
    }
    else if ( reactants.size() > 2 )
    {
        vector< unsigned int > temp;
        for ( unsigned int i = 0; i < reactants.size(); ++i )
            temp.push_back( convertIdToPoolIndex( reactants[i] ) );
        rateTerm = new NOrder( rate, temp );
    }
    else
    {
        cout << "Warning: Stoich::makeHalfReaction: no reactants\n";
        status_ |= 1;
        rateTerm = new ZeroOrder(0.0); // Dummy RateTerm to avoid crash.
    }
    return rateTerm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const vector< Id > & Stoich::offSolverPoolMap

(

Id

compt

)

const

Looks up the vector of pool Ids originating from the specified compartment, that are represented on this compartment as proxies.

Definition at line 2102 of file Stoich.cpp.

References offSolverPoolMap_.

{
    static vector< Id > blank( 0 );
    map< Id, vector < Id > >::const_iterator i =
        offSolverPoolMap_.find( compt );
    if ( i != offSolverPoolMap_.end() )
        return i->second;
    return blank;
}

void Stoich::print

(

)

const

Utility function, prints out N_, used for debugging.

Definition at line 2066 of file Stoich.cpp.

References N_, and SparseMatrix< T >::print().

{
    N_.print();
}

Here is the call graph for this function:

void Stoich::printRates

(

)

const

Another utility function, prints out all Kf, kf, Kb, kb.

Definition at line 2072 of file Stoich.cpp.

References Field< A >::get(), and reacVec_.

{
    for ( vector< Id >::const_iterator
            i = reacVec_.begin(); i != reacVec_.end(); ++i )
    {
        double Kf = Field< double >::get( *i, "Kf");
        double Kb = Field< double >::get( *i, "Kb");
        double kf = Field< double >::get( *i, "kf");
        double kb = Field< double >::get( *i, "kb");
        cout << "Id=" << *i << ", (Kf,Kb) = (" << Kf << ", " << Kb <<
             "), (kf, kb) = (" << kf << ", " << kb << ")\n";
    }
}

Here is the call graph for this function:

const RateTerm * Stoich::rates

(

unsigned int

i

)

const

Utility function to return a rates_ entry.

Definition at line 583 of file Stoich.cpp.

References rates_.

Referenced by Gsolve::fillMmEnzDep().

{
    assert( i < rates_.size() );
    return rates_[i];
}

Here is the caller graph for this function:

void Stoich::resizeArrays

(

)

Using the computed array sizes, now allocate space for them.

Builds the objMap vector, which maps all Ids to the internal indices for pools and reacs that are used in the solver. In addition to the elist, it also scans through the offSolverPools and offSolverReacs to build the map. void allocateObjMap( const vector< Id >& elist );

Definition at line 932 of file Stoich.cpp.

References bufPoolVec_, dinterface_, enzVec_, funcs_, funcTarget_, incrementFuncVec_, kinterface_, mmEnzVec_, myUnique(), N_, offSolverEnzVec_, offSolverMMenzVec_, offSolverPoolVec_, offSolverReacVec_, poolFuncVec_, rates_, reacVec_, ZombiePoolInterface::setNumPools(), SparseMatrix< T >::setSize(), species_, useOneWay_, and varPoolVec_.

Referenced by allocateModel().

{
    myUnique( varPoolVec_ );
    myUnique( bufPoolVec_ );
    myUnique( offSolverPoolVec_ );
    myUnique( reacVec_ );
    myUnique( offSolverReacVec_ );
    myUnique( enzVec_ );
    myUnique( offSolverEnzVec_ );
    myUnique( mmEnzVec_ );
    myUnique( offSolverMMenzVec_ );

    unsigned int totNumPools = varPoolVec_.size() + bufPoolVec_.size() +
                               + offSolverPoolVec_.size();

    species_.resize( totNumPools, 0 );

    funcTarget_.clear();
    // Only the pools controlled by a func (targets) have positive indices.
    funcTarget_.resize( totNumPools, ~0 );

    unsigned int totNumRates =
        ( reacVec_.size() + offSolverReacVec_.size() ) * (1+useOneWay_) +
        ( enzVec_.size() + offSolverEnzVec_.size() ) * (2 + useOneWay_ ) +
        mmEnzVec_.size() + offSolverMMenzVec_.size() +
        incrementFuncVec_.size();
    rates_.resize( totNumRates, 0 );
    funcs_.resize( poolFuncVec_.size(), 0 );
    N_.setSize( totNumPools, totNumRates );
    if ( kinterface_ )
        kinterface_->setNumPools( totNumPools );
    if ( dinterface_ ) // Only set up var pools managed locally.
        dinterface_->setNumPools( varPoolVec_.size() );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::scaleBufsAndRates	(	unsigned int	index,
		double	volScale
	)

Used to handle run-time size updates for spines.

Definition at line 2212 of file Stoich.cpp.

References kinterface_, ZombiePoolInterface::pools(), VoxelPoolsBase::scaleVolsBufsRates(), and status_.

Referenced by initCinfo().

{
    if ( !kinterface_ || status_ != 0 )
        return;
    kinterface_->pools( index )->scaleVolsBufsRates( volScale, this );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setAllowNegative

(

bool

v

)

Definition at line 310 of file Stoich.cpp.

References allowNegative_.

Referenced by initCinfo().

{
    allowNegative_ = v;
}

Here is the caller graph for this function:

void Stoich::setCompartment

(

Id

v

)

assigns compartment occupied by Stoich.

Definition at line 474 of file Stoich.cpp.

References Element::cinfo(), compartment_, doubleEq(), Id::element(), Cinfo::isA(), and numVoxels_.

Referenced by initCinfo().

{
    if ( ! (
                compartment.element()->cinfo()->isA( "ChemCompt" )
            )
       )
    {
        cout << "Error: Stoich::setCompartment: invalid class assigned,"
             " should be ChemCompt or derived class\n";
        return;
    }
    compartment_ = compartment;
    vector< double > temp;
    vector< double > vols =
        Field< vector < double > >::get( compartment, "voxelVolume" );
    if ( vols.size() > 0 )
    {
        numVoxels_ = vols.size();
        sort( vols.begin(), vols.end() );
        double bigVol = vols.back();
        assert( bigVol > 0.0 );
        temp.push_back( vols[0] / bigVol );
        for ( vector< double >::iterator
                i = vols.begin(); i != vols.end(); ++i )
        {
            if ( !doubleEq( temp.back(), *i / bigVol ) )
                temp.push_back( *i / bigVol );
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setDsolve

(

Id

v

)

assigns diffusion solver: Dsovle or a Gillespie voxel stepper

Definition at line 451 of file Stoich.cpp.

References Element::cinfo(), Eref::data(), dinterface_, dsolve_, Id::element(), Id::eref(), and Cinfo::isA().

Referenced by initCinfo().

{
    dsolve_ = Id();
    dinterface_ = 0;
    if ( ! (
                dsolve.element()->cinfo()->isA( "Dsolve" )
            )
       )
    {
        cout << "Error: Stoich::setDsolve: invalid class assigned,"
             " should be Dsolve\n";
        return;
    }
    dsolve_ = dsolve;
    dinterface_ = reinterpret_cast< ZombiePoolInterface* >(
                      dsolve.eref().data() );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setElist	(	const Eref &	e,
		const vector< ObjId > &	elist
	)

Internal function which sets up the model based on the provided elist of all elements managed by this solver.

Definition at line 363 of file Stoich.cpp.

References allocateModel(), compartment_, Eref::data(), dinterface_, Shell::doAddMsg(), dsolve_, Id::eref(), filterWildcards(), Eref::id(), kinterface_, ksolve_, ZombiePoolInterface::setCompartment(), ZombiePoolInterface::setDsolve(), ZombiePoolInterface::setStoich(), status_, ZombiePoolInterface::updateRateTerms(), and zombifyModel().

Referenced by setPath().

{
    if ( compartment_ == Id() )
    {
        cout << "Warning: Stoich::setElist/setPath: Compartment not set. Aborting.\n";
        status_ = 4;
        return;
    }
    if ( !( kinterface_ || dinterface_  ) )
    {
        cout << "Warning: Stoich::setElist/setPath: Neither solver has been set. Aborting.\n";
        status_ = 8;
        return;
    }
    status_ = 0;
    if ( kinterface_ )
        kinterface_->setCompartment( compartment_ );
    if ( dinterface_ )
        dinterface_->setCompartment( compartment_ );
    vector< Id > temp;
    filterWildcards( temp, elist );
    if( temp.size() == 0 )
    {
        cout << "Warning: Stoich::setElist/setPath: No kinetics objects found on path. Aborting.\n";
        status_ = 16;
        return;
    }

    // allocateObjMap( temp );
    allocateModel( temp );
    if ( kinterface_ )
    {
        // kinterface_->setNumPools( n );
        kinterface_->setStoich( e.id() );
        Shell* shell =  reinterpret_cast< Shell* >( Id().eref().data() );
        shell->doAddMsg( "Single",
                         compartment_, "voxelVolOut", ksolve_, "voxelVol" );
    }
    if ( dinterface_ )
    {
        // dinterface_->setNumPools( n );
        dinterface_->setStoich( e.id() );
    }
    zombifyModel( e, temp );
    if ( kinterface_ )
    {
        kinterface_->setDsolve( dsolve_ );
        kinterface_->updateRateTerms();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setEnzK1	(	const Eref &	e,
		double	v
	)		const

Later handle all the volumes when this conversion is done.

Sets the rate v (given in millimoloar concentration units) for the forward enzyme reaction of binding substrate to enzyme. Does this throughout the compartment in which the enzyme lives. Internally the stoich uses #/voxel units so this involves querying the volume subsystem about volumes for each voxel, and scaling accordingly.

Definition at line 1943 of file Stoich.cpp.

References convertIdToReacIndex(), Eref::id(), kinterface_, rates_, and ZombiePoolInterface::updateRateTerms().

Referenced by updateRatesAfterRemesh(), ZombieEnz::vSetConcK1(), ZombieEnz::vSetK1(), ZombieEnz::vSetKcat(), ZombieEnz::vSetKm(), and ZombieEnz::vSetNumKm().

{
    unsigned int index = convertIdToReacIndex( e.id() );

    rates_[ index  ]->setR1( v );
    kinterface_->updateRateTerms( index );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setEnzK2	(	const Eref &	e,
		double	v
	)		const

Set rate k2 (1/sec) for enzyme.

Definition at line 1951 of file Stoich.cpp.

References convertIdToReacIndex(), Eref::id(), kinterface_, rates_, ZombiePoolInterface::updateRateTerms(), and useOneWay_.

Referenced by updateRatesAfterRemesh(), ZombieEnz::vSetK2(), ZombieEnz::vSetKcat(), and ZombieEnz::vSetRatio().

{
    unsigned int index = convertIdToReacIndex( e.id() );
    if ( useOneWay_ )
    {
        rates_[ index + 1 ]->setR1( v );
        kinterface_->updateRateTerms( index + 1 );
    }
    else
    {
        rates_[ index ]->setR2( v );
        kinterface_->updateRateTerms( index );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setEnzK3	(	const Eref &	e,
		double	v
	)		const

Set rate k3 (1/sec) for enzyme.

Definition at line 1966 of file Stoich.cpp.

References convertIdToReacIndex(), Eref::id(), kinterface_, rates_, ZombiePoolInterface::updateRateTerms(), and useOneWay_.

Referenced by updateRatesAfterRemesh(), and ZombieEnz::vSetKcat().

{
    unsigned int index = convertIdToReacIndex( e.id() );
    if ( useOneWay_ )
    {
        rates_[ index + 2 ]->setR1( v );
        kinterface_->updateRateTerms( index + 2 );
    }
    else
    {
        rates_[ index + 1 ]->setR1( v );
        kinterface_->updateRateTerms( index + 1 );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setFunctionExpr	(	const Eref &	e,
		string	expr
	)

Sets the arithmetic expression used in a FuncRate or FuncReac

Definition at line 2028 of file Stoich.cpp.

References convertIdToFuncIndex(), convertIdToReacIndex(), funcs_, Eref::id(), Id::path(), rates_, FuncTerm::setExpr(), and FuncRate::setExpr().

Referenced by ZombieFunction::innerSetExpr().

{
    unsigned int index = convertIdToReacIndex( e.id() );
    FuncRate* fr = 0;
    if ( index != ~0U )
        fr = dynamic_cast< FuncRate* >( rates_[index] );
    if ( fr )
    {
        fr->setExpr( expr );
    }
    else
    {
        index = convertIdToFuncIndex( e.id() );
        if ( index != ~0U )
        {
            FuncTerm *ft = dynamic_cast< FuncTerm* >( funcs_[index] );
            if ( ft )
            {
                ft->setExpr( expr );
                return;
            }
        }
        cout << "Warning: Stoich::setFunctionExpr( " << e.id().path() <<
             ", " << expr << " ): func not found";
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setKsolve

(

Id

v

)

assigns kinetic solver: Ksovle or GSSAsolve.

Definition at line 421 of file Stoich.cpp.

References Element::cinfo(), Eref::data(), Id::element(), Id::eref(), Cinfo::isA(), kinterface_, ksolve_, and setOneWay().

Referenced by initCinfo().

{
    ksolve_ = Id();
    kinterface_ = 0;
    if ( ! (
                ksolve.element()->cinfo()->isA( "Ksolve" )  ||
                ksolve.element()->cinfo()->isA( "Gsolve" )
            )
       )
    {
        cout << "Error: Stoich::setKsolve: invalid class assigned,"
             " should be either Ksolve or Gsolve\n";
        return;
    }
    ksolve_ = ksolve;
    kinterface_ = reinterpret_cast< ZombiePoolInterface* >(
                      ksolve.eref().data() );

    if ( ksolve.element()->cinfo()->isA( "Gsolve" ) )
        setOneWay( true );
    else
        setOneWay( false );

}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setMMenzKcat	(	const Eref &	e,
		double	v
	)		const

Sets the kcat for MMenz. No conversions needed.

Definition at line 1926 of file Stoich.cpp.

References convertIdToReacIndex(), Eref::id(), kinterface_, rates_, and ZombiePoolInterface::updateRateTerms().

Referenced by updateRatesAfterRemesh(), and ZombieMMenz::vSetKcat().

{
    unsigned int index = convertIdToReacIndex( e.id() );
    RateTerm* rt = rates_[ index ];
    // MMEnzymeBase* enz = dynamic_cast< MMEnzymeBase* >( rt );
    // assert( enz );

    rt->setR2( v );
    kinterface_->updateRateTerms( index );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setMMenzKm	(	const Eref &	e,
		double	v
	)		const

Sets the Km for MMenz, using appropriate volume conversion to go from the argument (in millimolar) to #/voxel. This may do the assignment among many voxels containing the enz in case there are different volumes.

Definition at line 1895 of file Stoich.cpp.

References convertIdToReacIndex(), Eref::id(), kinterface_, rates_, and ZombiePoolInterface::updateRateTerms().

Referenced by updateRatesAfterRemesh(), ZombieMMenz::vSetKm(), and ZombieMMenz::vSetNumKm().

{
    // Identify MMenz rate term
    unsigned int index = convertIdToReacIndex( e.id() );
    RateTerm* rt = rates_[ index ];
    //MMEnzymeBase* enz = dynamic_cast< MMEnzymeBase* >( rt );
    //assert( enz );
    // Identify MMenz Enzyme substrate. I would have preferred the parent,
    // but that gets messy.
    // unsigned int enzMolIndex = enz->getEnzIndex();

    // This function can be replicated to handle multiple different voxels.
    /*
    vector< double > vols;
    getReactantVols( e, subOut, vols );
    if ( vols.size() == 0 ) {
        cerr << "Error: Stoich::setMMenzKm: no substrates for enzyme " <<
            e << endl;
        return;
    }
    */
    // Do scaling and assignment.
    rt->setR1( v );
    kinterface_->updateRateTerms( index );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setOneWay

(

bool

v

)

Definition at line 300 of file Stoich.cpp.

References useOneWay_.

Referenced by setKsolve().

{
    useOneWay_ = v;
}

Here is the caller graph for this function:

void Stoich::setPath	(	const Eref &	e,
		string	path
	)

Take the provided wildcard path to build the list of elements managed by this solver.

Definition at line 320 of file Stoich.cpp.

References ksolve_, path_, setElist(), status_, and wildcardFind().

Referenced by initCinfo().

{
    if ( path_ != "" && path_ != v )
    {
        // unzombify( path_ );
        cout << "Stoich::setPath: need to clear old path.\n";
        status_ = -1;
        return;
    }
    if ( ksolve_ == Id() )
    {
        cout << "Stoich::setPath: need to first set ksolve.\n";
        status_ = -1;
        return;
    }
    vector< ObjId > elist;
    path_ = v;
    wildcardFind( path_, elist );
    setElist( e, elist );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setReacKb	(	const Eref &	e,
		double	v
	)		const

Sets the reverse rate v (given in millimoloar concentration units) for the specified reaction throughout the compartment in which the reaction lives. Internally the stoich uses #/voxel units so this involves querying the volume subsystem about volumes for each voxel, and scaling accordingly.

For now assume a single rate term.

Definition at line 1874 of file Stoich.cpp.

References convertIdToReacIndex(), Eref::id(), kinterface_, rates_, ZombiePoolInterface::updateRateTerms(), and useOneWay_.

Referenced by updateRatesAfterRemesh(), ZombieReac::vSetConcKb(), and ZombieReac::vSetNumKb().

{
    unsigned int i = convertIdToReacIndex( e.id() );
    if ( i == ~0U )
        return;

    if ( useOneWay_ )
    {
        rates_[ i + 1 ]->setR1( v );
        kinterface_->updateRateTerms( i + 1 );
    }
    else
    {
        rates_[ i ]->setR2( v );
        kinterface_->updateRateTerms( i );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setReacKf	(	const Eref &	e,
		double	v
	)		const

Sets the forward rate v (given in millimoloar concentration units) for the specified reaction throughout the compartment in which the reaction lives. Internally the stoich uses #/voxel units so this involves querying the volume subsystem about volumes for each voxel, and scaling accordingly.

Sets the forward rate v (given in millimoloar concentration units) for the specified reaction throughout the compartment in which the reaction lives. Internally the stoich uses #/voxel units so this involves querying the volume subsystem about volumes for each voxel, and scaling accordingly. For now assume a uniform voxel volume and hence just convert on 0 meshIndex.

Definition at line 1860 of file Stoich.cpp.

References convertIdToReacIndex(), Eref::id(), kinterface_, rates_, and ZombiePoolInterface::updateRateTerms().

Referenced by updateRatesAfterRemesh(), ZombieReac::vSetConcKf(), and ZombieReac::vSetNumKf().

{
    unsigned int i = convertIdToReacIndex( e.id() );
    if ( i != ~0U )
    {
        // rates_[ i ]->setR1( v / volScale );
        rates_[ i ]->setR1( v );
        kinterface_->updateRateTerms( i );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::setSpecies	(	unsigned int	poolIndex,
		unsigned int	s
	)

Assigns SpeciesId of specified pool

Definition at line 2060 of file Stoich.cpp.

References species_.

{
    species_[ poolIndex ] = s;
}

void Stoich::unZombifyModel

(

)

Converts back to ExpEuler type basic kinetic Elements.

Definition at line 1402 of file Stoich.cpp.

References Element::cinfo(), enzCinfo, enzVec_, Cinfo::find(), functionCinfo, Element::getTick(), incrementFuncVec_, Clock::lookupDefaultTick(), mmEnzCinfo, mmEnzVec_, Cinfo::name(), offSolverEnzVec_, offSolverMMenzVec_, offSolverReacVec_, poolFuncVec_, reacCinfo, reacVec_, Element::setTick(), unZombifyPools(), zombieEnzCinfo, zombieFunctionCinfo, zombieMMenzCinfo, zombieReacCinfo, ZombieFunction::zombify(), CplxEnzBase::zombify(), ReacBase::zombify(), and EnzBase::zombify().

Referenced by initCinfo(), and ~Stoich().

{
    static const Cinfo* reacCinfo = Cinfo::find( "Reac" );
    static const Cinfo* enzCinfo = Cinfo::find( "Enz" );
    static const Cinfo* mmEnzCinfo = Cinfo::find( "MMenz" );
    static const Cinfo* functionCinfo = Cinfo::find( "Function");
    static const Cinfo* zombieReacCinfo = Cinfo::find( "ZombieReac");
    static const Cinfo* zombieMMenzCinfo = Cinfo::find( "ZombieMMenz");
    static const Cinfo* zombieEnzCinfo = Cinfo::find( "ZombieEnz");
    static const Cinfo* zombieFunctionCinfo = Cinfo::find( "ZombieFunction");

    unZombifyPools();

    vector< Id > temp = reacVec_;
    temp.insert( temp.end(),
                 offSolverReacVec_.begin(), offSolverReacVec_.end() );
    for ( vector< Id >::iterator i = temp.begin(); i != temp.end(); ++i )
    {
        Element* e = i->element();
        if ( e != 0 &&  e->cinfo() == zombieReacCinfo )
            ReacBase::zombify( e, reacCinfo, Id() );
    }

    temp = mmEnzVec_;
    temp.insert( temp.end(),
                 offSolverMMenzVec_.begin(), offSolverMMenzVec_.end() );
    for ( vector< Id >::iterator i = temp.begin(); i != temp.end(); ++i )
    {
        Element* e = i->element();
        if ( e != 0 &&  e->cinfo() == zombieMMenzCinfo )
            EnzBase::zombify( e, mmEnzCinfo, Id() );
    }

    temp = enzVec_;
    temp.insert( temp.end(),
                 offSolverEnzVec_.begin(), offSolverEnzVec_.end() );
    for ( vector< Id >::iterator i = temp.begin(); i != temp.end(); ++i )
    {
        Element* e = i->element();
        if ( e != 0 &&  e->cinfo() == zombieEnzCinfo )
            CplxEnzBase::zombify( e, enzCinfo, Id() );
    }

    temp = poolFuncVec_;
    temp.insert( temp.end(),
                 incrementFuncVec_.begin(), incrementFuncVec_.end() );
    for ( vector< Id >::iterator i = temp.begin(); i != temp.end(); ++i )
    {
        Element* e = i->element();
        if ( e != 0 && e->cinfo() == zombieFunctionCinfo )
        {
            ZombieFunction::zombify( e, functionCinfo, Id(), Id() );
            //cout << "ZombieFunction unzombify: " << e->getTick() << endl;
        }
        if ( e != 0 && e->getTick() == -2 )
        {
            int t = Clock::lookupDefaultTick( e->cinfo()->name() );
            e->setTick( t );
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::unZombifyPools

(

)

unZombifies Pools. Helper for unZombifyModel.

Definition at line 1376 of file Stoich.cpp.

References bufPoolCinfo, bufPoolVec_, Element::cinfo(), Cinfo::find(), Element::isDoomed(), poolCinfo, varPoolVec_, zombieBufPoolCinfo, zombiePoolCinfo, and PoolBase::zombify().

Referenced by unZombifyModel().

{
    static const Cinfo* poolCinfo = Cinfo::find( "Pool" );
    static const Cinfo* bufPoolCinfo = Cinfo::find( "BufPool" );
    static const Cinfo* zombiePoolCinfo = Cinfo::find( "ZombiePool" );
    static const Cinfo* zombieBufPoolCinfo = Cinfo::find( "ZombieBufPool");
    unsigned int i;
    for ( i = 0; i < varPoolVec_.size(); ++i )
    {
        Element* e = varPoolVec_[i].element();
        if ( !e || e->isDoomed() )
            continue;
        if ( e != 0 &&  e->cinfo() == zombiePoolCinfo )
            PoolBase::zombify( e, poolCinfo, Id(), Id() );
    }

    for ( i = 0; i < bufPoolVec_.size(); ++i )
    {
        Element* e = bufPoolVec_[i].element();
        if ( !e || e->isDoomed() )
            continue;
        if ( e != 0 &&  e->cinfo() == zombieBufPoolCinfo )
            PoolBase::zombify( e, bufPoolCinfo, Id(), Id() );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Stoich::updateFuncs	(	double *	s,
		double	t
	)		const

Updates the function values, within s.

Definition at line 2118 of file Stoich.cpp.

References funcs_.

Referenced by GssaVoxelPools::advance(), VoxelPools::advance(), GssaVoxelPools::refreshAtot(), GssaVoxelPools::reinit(), and GssaVoxelPools::updateDependentMathExpn().

{
    for ( vector< FuncTerm* >::const_iterator i = funcs_.begin();
            i != funcs_.end(); ++i )
    {
        if ( *i )
        {
            (*i)->evalPool( s, t );
            // s holds arguments and also result location
        }
    }
}

Here is the caller graph for this function:

void Stoich::updateRatesAfterRemesh

(

)

This function scans all reacs and enzymes and recalculates the internal rate terms depending on the reference terms stored in the original chemical object.

updateJunctionRates: Updates the rates for cross-compartment reactions. These are located at the end of the rates_ vector, and are directly indexed by the reacTerms. void Stoich::updateJunctionRates( const double* s, const vector< unsigned int >& reacTerms, double* yprime ) { for ( vector< unsigned int >::const_iterator i = reacTerms.begin(); i != reacTerms.end(); ++i ) { assert( *i < rates_[0].size() ); yprime++ += (*rates_[0][*i])( s ); } }

Definition at line 2148 of file Stoich.cpp.

References Field< A >::get(), offSolverEnzVec_, offSolverMMenzVec_, offSolverReacVec_, reacVec_, setEnzK1(), setEnzK2(), setEnzK3(), setMMenzKcat(), setMMenzKm(), setReacKb(), and setReacKf().

{
    for ( vector< Id >::iterator
            i = reacVec_.begin(); i != reacVec_.end(); ++i )
    {
        double Kf = Field< double >::get( *i, "Kf");
        double Kb = Field< double >::get( *i, "Kb");
        setReacKf( i->eref(), Kf );
        setReacKb( i->eref(), Kb );
    }
    vector< Id >::iterator i;
    for (i = offSolverReacVec_.begin(); i != offSolverReacVec_.end(); ++i)
    {
        assert ( i->element()->cinfo()->isA( "ReacBase" ) );
        double Kf = Field< double >::get( *i, "Kf");
        double Kb = Field< double >::get( *i, "Kb");
        setReacKf( i->eref(), Kf );
        setReacKb( i->eref(), Kb );
    }
    for (i = offSolverEnzVec_.begin(); i != offSolverEnzVec_.end(); ++i)
    {
        assert ( i->element()->cinfo()->isA( "CplxEnzBase" ) );
        double concK1 = Field< double >::get( *i, "concK1");
        double k3 = Field< double >::get( *i, "k3");
        double k2 = Field< double >::get( *i, "k2");
        setEnzK3( i->eref(), k3 );
        setEnzK2( i->eref(), k2 );
        setEnzK1( i->eref(), concK1 );
    }
    for (i=offSolverMMenzVec_.begin(); i != offSolverMMenzVec_.end(); ++i)
    {
        assert( i->element()->cinfo()->isA( "MMEnzBase" ) );
        double Km = Field< double >::get( *i, "Km");
        double kcat = Field< double >::get( *i, "kcat");
        setMMenzKm( i->eref(), Km );
        setMMenzKcat( i->eref(), kcat );
    }
}

Here is the call graph for this function:

void Stoich::updateReacVelocities	(	const double *	s,
		vector< double > &	vel,
		unsigned int	volIndex
	)		const

Updates the yprime array, rate of change of each molecule The volIndex specifies which set of rates to use, since the rates are volume dependent. Moved to VoxelPools void updateRates( const double* s, double* yprime, unsigned int volIndex ) const; Computes the velocity of each reaction, vel. The volIndex specifies which set of rates to use, since the rates are volume dependent.

void Stoich::zombifyChemCompt

(

Id

compt

)

void Stoich::zombifyModel	(	const Eref &	e,
		const vector< Id > &	elist
	)

zombifyModel marches through the specified id list and converts all entries into zombies. The first arg e is the Eref of the Stoich itself.

Definition at line 1270 of file Stoich.cpp.

References bufPoolCinfo, Element::cinfo(), dsolve_, Id::element(), enzCinfo, Cinfo::find(), findFuncMsgSrc(), Field< A >::get(), Eref::id(), Element::id(), installAndUnschedFuncRate(), installAndUnschedFuncReac(), ksolve_, mmEnzCinfo, numVoxels_, offSolverEnzVec_, offSolverMMenzVec_, offSolverReacVec_, poolCinfo, reacCinfo, Element::resize(), Field< A >::set(), zombieBufPoolCinfo, zombieEnzCinfo, zombieMMenzCinfo, zombiePoolCinfo, zombieReacCinfo, ZombieFunction::zombify(), CplxEnzBase::zombify(), ReacBase::zombify(), EnzBase::zombify(), PoolBase::zombify(), and zombifyPoolFuncWithScaling().

Referenced by setElist().

{
    static const Cinfo* poolCinfo = Cinfo::find( "Pool" );
    static const Cinfo* bufPoolCinfo = Cinfo::find( "BufPool" );
    static const Cinfo* reacCinfo = Cinfo::find( "Reac" );
    static const Cinfo* enzCinfo = Cinfo::find( "Enz" );
    static const Cinfo* mmEnzCinfo = Cinfo::find( "MMenz" );
    static const Cinfo* zombiePoolCinfo = Cinfo::find( "ZombiePool" );
    static const Cinfo* zombieBufPoolCinfo = Cinfo::find( "ZombieBufPool");
    static const Cinfo* zombieReacCinfo = Cinfo::find( "ZombieReac");
    static const Cinfo* zombieMMenzCinfo = Cinfo::find( "ZombieMMenz");
    static const Cinfo* zombieEnzCinfo = Cinfo::find( "ZombieEnz");
    static const Cinfo* zfCinfo = Cinfo::find( "ZombieFunction" );
    // static const Finfo* funcSrcFinfo = Cinfo::find( "Function")->findFinfo( "valueOut" );
    // vector< Id > meshEntries;
    vector< Id > temp = elist;

    temp.insert( temp.end(), offSolverReacVec_.begin(), offSolverReacVec_.end() );
    temp.insert( temp.end(), offSolverEnzVec_.begin(), offSolverEnzVec_.end() );
    temp.insert( temp.end(), offSolverMMenzVec_.begin(), offSolverMMenzVec_.end() );

    for ( vector< Id >::const_iterator i = temp.begin(); i != temp.end(); ++i )
    {
        Element* ei = i->element();
        if ( ei->cinfo() == poolCinfo )
        {
            // We need to check the increment message before we zombify the
            // pool, because ZombiePool doesn't have this message.
            Id funcId = findFuncMsgSrc( *i, "increment" );
            double concInit =
                Field< double >::get( ObjId( ei->id(), 0 ), "concInit" );
            // Look for func setting rate of change of pool
            // Id funcId = Neutral::child( i->eref(), "func" );
            if ( funcId != Id() )
            {
                // cout << "Found Msg src for increment at " << funcId.path() << endl;
                Element* fe = funcId.element();
                installAndUnschedFuncRate( funcId, (*i) );
                ZombieFunction::zombify( fe, zfCinfo,ksolve_,dsolve_);
            }
            else
            {
                funcId = zombifyPoolFuncWithScaling( *i );
            }
            PoolBase::zombify( ei, zombiePoolCinfo, ksolve_, dsolve_ );
            ei->resize( numVoxels_ );
            for ( unsigned int j = 0; j < numVoxels_; ++j )
            {
                ObjId oi( ei->id(), j );
                Field< double >::set( oi, "concInit", concInit );
            }
        }
        else if ( ei->cinfo() == bufPoolCinfo )
        {
            double concInit =
                Field< double >::get( ObjId( ei->id(), 0 ), "concInit" );
            // Look for func setting conc of pool
            // Id funcId = Neutral::child( i->eref(), "func" );
            Id funcId = zombifyPoolFuncWithScaling( *i );
            if ( funcId == Id() )
            {
                funcId = findFuncMsgSrc( *i, "increment" );
                if ( funcId != Id() )
                {
                    cout << "Warning: Stoich::zombifyModel: Probably you don't want to send increment to a BufPool:" << i->path() << endl;
                    Element* fe = funcId.element();
                    installAndUnschedFuncRate( funcId, (*i) );
                    ZombieFunction::zombify( fe, zfCinfo,ksolve_,dsolve_);
                }
            }
            PoolBase::zombify( ei, zombieBufPoolCinfo, ksolve_, dsolve_ );
            ei->resize( numVoxels_ );
            for ( unsigned int j = 0; j < numVoxels_; ++j )
            {
                ObjId oi( ei->id(), j );
                Field< double >::set( oi, "concInit", concInit );
            }
        }
        else if ( ei->cinfo() == reacCinfo )
        {
            ReacBase::zombify( ei, zombieReacCinfo, e.id() );
            // Id funcId = Neutral::child( i->eref(), "func" );
            Id funcId = findFuncMsgSrc( *i, "setNumKf" );
            if ( funcId != Id() )
            {
                Element* fe = funcId.element();
                installAndUnschedFuncReac( funcId, (*i) );
                ZombieFunction::zombify( fe, zfCinfo,ksolve_,dsolve_);
                /*
                } else {
                cout << "Warning: Stoich::zombifyModel: Failed to connect Func to Reac :" << i->path() << endl;
                return;
                */
            }
        }
        else if ( ei->cinfo() == mmEnzCinfo )
        {
            EnzBase::zombify( ei, zombieMMenzCinfo, e.id() );
        }
        else if ( ei->cinfo() == enzCinfo )
        {
            CplxEnzBase::zombify( ei, zombieEnzCinfo, e.id() );
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Id Stoich::zombifyPoolFuncWithScaling

(

Id

pool

)

Utility function to find if incoming message assigns N or conc, and to appropriately zombify the function and set up its parameters including volume scaling.

Definition at line 1244 of file Stoich.cpp.

References dsolve_, Id::element(), Cinfo::find(), findFuncMsgSrc(), Field< A >::get(), installAndUnschedFunc(), ksolve_, NA, and ZombieFunction::zombify().

Referenced by zombifyModel().

{
    static const Cinfo* zfCinfo = Cinfo::find( "ZombieFunction" );
    Id funcId = findFuncMsgSrc( pool, "setN" );
    if ( funcId != Id() )
    {
        Element* fe = funcId.element();
        installAndUnschedFunc( funcId, pool, 1.0 );
        ZombieFunction::zombify( fe, zfCinfo,ksolve_,dsolve_);
    }
    else
    {
        funcId = findFuncMsgSrc( pool, "setConc" );
        if ( funcId != Id() )
        {
            // cout << "Warning: Stoich::zombifyModel: Prefer to use setN rather than setConc:" << pool.path() << endl;
            Element* fe = funcId.element();
            double vol = Field< double >::get( pool, "volume" );
            installAndUnschedFunc( funcId, pool, vol * NA );
            ZombieFunction::zombify( fe, zfCinfo,ksolve_,dsolve_);
        }
    }
    return funcId;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

bool Stoich::allowNegative_

private

True if pools are permitted to take negative concentrations. This may happen if solver is handling a general equation system that is not constrained by chemical rules. Defaults to False, so that we cannot have negative concs.

Definition at line 496 of file Stoich.h.

Referenced by getAllowNegative(), and setAllowNegative().

vector< Id > Stoich::bufPoolVec_

private

Vector of bufPool Ids.

Definition at line 578 of file Stoich.h.

Referenced by allocateModel(), allocateModelObject(), buildPoolLookup(), getNumAllPools(), getNumBufPools(), resizeArrays(), and unZombifyPools().

Id Stoich::compartment_

private

Contains Id of compartment holding reac system. Optional.

Definition at line 507 of file Stoich.h.

Referenced by getCompartment(), setCompartment(), and setElist().

ZombiePoolInterface* Stoich::dinterface_

private

Pointer for dsolve.

Definition at line 512 of file Stoich.h.

Referenced by resizeArrays(), setDsolve(), and setElist().

Id Stoich::dsolve_

private

This contains the Id of the Diffusion solver. Optional.

Definition at line 504 of file Stoich.h.

Referenced by getDsolve(), setDsolve(), setElist(), zombifyModel(), and zombifyPoolFuncWithScaling().

vector< Id > Stoich::enzVec_

private

Map back from enz index to Id. Needed to unzombify

Definition at line 596 of file Stoich.h.

Referenced by allocateModel(), allocateModelObject(), buildRateTermLookup(), getNumCoreRates(), resizeArrays(), and unZombifyModel().

map< Id, unsigned int > Stoich::funcLookup_

private

Definition at line 634 of file Stoich.h.

Referenced by buildFuncLookup(), and convertIdToFuncIndex().

vector< FuncTerm* > Stoich::funcs_

private

The FuncTerms handle mathematical ops on mol levels.

Definition at line 543 of file Stoich.h.

Referenced by funcs(), getNumFuncs(), installAndUnschedFunc(), resizeArrays(), setFunctionExpr(), updateFuncs(), and ~Stoich().

vector< unsigned int > Stoich::funcTarget_

private

vector tracks which pool is controlled by which func. Unused entries are flagged by ~0. funcTarget_[ poolIndex ] == funcIndex

Definition at line 615 of file Stoich.h.

Referenced by installAndUnschedFunc(), isFuncTarget(), and resizeArrays().

vector< Id > Stoich::incrementFuncVec_

private

Vector of funcs controlling pool increment, that is dN/dt This is handled as a rateTerm.

Definition at line 621 of file Stoich.h.

Referenced by allocateModel(), allocateModelObject(), buildRateTermLookup(), getNumCoreRates(), resizeArrays(), and unZombifyModel().

ZombiePoolInterface* Stoich::kinterface_

private

Pointer for ksolve.

Definition at line 510 of file Stoich.h.

Referenced by resizeArrays(), scaleBufsAndRates(), setElist(), setEnzK1(), setEnzK2(), setEnzK3(), setKsolve(), setMMenzKcat(), setMMenzKm(), setReacKb(), and setReacKf().

Id Stoich::ksolve_

private

This contains the Id of the Kinetic solver.

Definition at line 501 of file Stoich.h.

Referenced by getKsolve(), setElist(), setKsolve(), setPath(), zombifyModel(), and zombifyPoolFuncWithScaling().

vector< Id > Stoich::mmEnzVec_

private

Map back from enz index to Id. Needed to unzombify

Definition at line 602 of file Stoich.h.

Referenced by allocateModel(), allocateModelObject(), buildRateTermLookup(), getNumCoreRates(), resizeArrays(), and unZombifyModel().

KinSparseMatrix Stoich::N_

private

N_ is the stoichiometry matrix. All pools * all reac terms.

Definition at line 546 of file Stoich.h.

Referenced by getColIndex(), getMatrixEntry(), getRowStart(), getStoichiometryMatrix(), innerInstallReaction(), installAndUnschedFuncRate(), installEnzyme(), installMMenz(), print(), and resizeArrays().

unsigned int Stoich::numVoxels_

private

Number of voxels in reac system.

This tracks the unique volumes handled by the reac system. Maps one-to-one with the vector of vector of RateTerms. vector< double > uniqueVols_;

Definition at line 540 of file Stoich.h.

Referenced by setCompartment(), and zombifyModel().

vector< pair< Id, Id > > Stoich::offSolverEnzCompts_

private

Definition at line 709 of file Stoich.h.

Referenced by locateOffSolverReacs().

vector< Id > Stoich::offSolverEnzVec_

private

Definition at line 597 of file Stoich.h.

Referenced by buildRateTermLookup(), locateOffSolverReacs(), resizeArrays(), unZombifyModel(), updateRatesAfterRemesh(), and zombifyModel().

vector< pair< Id, Id > > Stoich::offSolverMMenzCompts_

private

Definition at line 710 of file Stoich.h.

Referenced by locateOffSolverReacs().

vector< Id > Stoich::offSolverMMenzVec_

private

Definition at line 603 of file Stoich.h.

Referenced by buildRateTermLookup(), locateOffSolverReacs(), resizeArrays(), unZombifyModel(), updateRatesAfterRemesh(), and zombifyModel().

map< Id, vector< Id > > Stoich::offSolverPoolMap_

private

Map of vectors of Ids of offSolver pools. Each map entry contains the vector of Ids of proxy pools coming from the specified compartment. In use, the junction will copy the pool indices over for data transfer.

Definition at line 697 of file Stoich.h.

Referenced by getOffSolverCompts(), getProxyPools(), locateOffSolverReacs(), and offSolverPoolMap().

vector< Id > Stoich::offSolverPoolVec_

private

These are pools that were not in the original scope of the solver, but have to be brought in because they are reactants of one or more of the offSolverReacs.

Definition at line 585 of file Stoich.h.

Referenced by buildPoolLookup(), getNumAllPools(), getNumProxyPools(), getOffSolverPools(), locateOffSolverReacs(), and resizeArrays().

vector< pair< Id, Id > > Stoich::offSolverReacCompts_

private

Tracks the reactions that go off the current solver. vector< Id > offSolverReacs_; Which compartment(s) does the off solver reac connect to? Usually it is just one, in which case the second id is Id()

Definition at line 708 of file Stoich.h.

Referenced by locateOffSolverReacs().

vector< Id > Stoich::offSolverReacVec_

private

Definition at line 591 of file Stoich.h.

Referenced by buildRateTermLookup(), locateOffSolverReacs(), resizeArrays(), unZombifyModel(), updateRatesAfterRemesh(), and zombifyModel().

string Stoich::path_

private

Definition at line 498 of file Stoich.h.

Referenced by getPath(), and setPath().

vector< Id > Stoich::poolFuncVec_

private

Vector of funcs controlling pool number, that is N.

Definition at line 608 of file Stoich.h.

Referenced by allocateModel(), allocateModelObject(), buildFuncLookup(), resizeArrays(), and unZombifyModel().

const unsigned int Stoich::PoolIsNotOnSolver

static

Returns the index of the matching volume, which is also the index into the RateTerm vector. unsigned int indexOfMatchingVolume( double vol ) const;

Definition at line 481 of file Stoich.h.

map< Id, unsigned int > Stoich::poolLookup_

private

Definition at line 632 of file Stoich.h.

Referenced by buildPoolLookup(), convertIdToPoolIndex(), getPoolByIndex(), and getPoolIdMap().

vector< vector< Id > > Stoich::prdComptVec_

private

prdComptVec_[rateTermIndex][product#]: Identifies compts for each product for each cross-compartment RateTerm in the rates_vector.

Definition at line 724 of file Stoich.h.

Referenced by installEnzyme(), installMMenz(), and installReaction().

vector< RateTerm* > Stoich::rates_

private

The RateTerms handle the update operations for reaction rate v_. This is the master vector of RateTerms, and it is scaled to a volume such that the 'n' units and the conc units are identical. Duplicates of this vector are made in each voxel with a different volume. The duplicates have rates scaled as per volume. The RateTerms vector also includes reactions that have off-compartment products. These need special volume scaling involving all the interactiong compartments.

Definition at line 531 of file Stoich.h.

Referenced by convertRatesToStochasticForm(), getNumRates(), getR1(), getR1offset1(), getR1offset2(), getR2(), getRateTerms(), innerInstallReaction(), installAndUnschedFuncRate(), installAndUnschedFuncReac(), installDummyEnzyme(), installEnzyme(), installMMenz(), rates(), resizeArrays(), setEnzK1(), setEnzK2(), setEnzK3(), setFunctionExpr(), setMMenzKcat(), setMMenzKm(), setReacKb(), setReacKf(), and ~Stoich().

map< Id, unsigned int > Stoich::rateTermLookup_

private

Definition at line 633 of file Stoich.h.

Referenced by buildRateTermLookup(), and convertIdToReacIndex().

vector< Id > Stoich::reacFuncVec_

private

Vector of funcs controlling reac rate, that is numKf This is handled as a rateTerm.

Definition at line 627 of file Stoich.h.

Referenced by allocateModel(), and allocateModelObject().

vector< Id > Stoich::reacVec_

private

Vector of reaction ids.

Definition at line 590 of file Stoich.h.

Referenced by allocateModel(), allocateModelObject(), buildRateTermLookup(), getNumCoreRates(), printRates(), resizeArrays(), unZombifyModel(), and updateRatesAfterRemesh().

vector< unsigned int > Stoich::species_

private

Lookup from each molecule to its Species identifer This will eventually be tied into an ontology reference.

Definition at line 518 of file Stoich.h.

Referenced by getSpecies(), resizeArrays(), and setSpecies().

int Stoich::status_

private

Number of variable molecules that the solver deals with, that are local to the solver. Number of variable molecules that the solver deals with, including the proxy molecules which belong in other compartments.

unsigned int totVarPools_; Number of buffered molecules Looks up the rate term from the Id for a reac, enzyme, or func. map< Id, unsigned int > rateTermLookup_; Number functions, currently only the ones controlling molecule numbers, like sumtotals. unsigned int numFunctions_; Number of reactions in the solver model. This includes conversion reactions A + B <—> C enzyme reactions E + S <—> E.S —> E + P and MM enzyme reactions rate = E.S.kcat / ( Km + S ) The enzyme reactions count as two reaction steps. unsigned int numReac_; Flag to track status of Stoich object. -1: No path yet assigned. 0: Success 1: Warning: Missing reactant in Reac or Enz 2: Warning: Missing substrate in MMenz 4: Warning: Compartment not defined 8: Warning: Neither Ksolve nore Dsolve defined

Definition at line 684 of file Stoich.h.

Referenced by getStatus(), installDummyEnzyme(), installMMenz(), makeHalfReaction(), scaleBufsAndRates(), setElist(), and setPath().

vector< vector< Id > > Stoich::subComptVec_

private

subComptVec_[rateTermIndex][substrate#]: Identifies compts for each substrate for each cross-compartment RateTerm in the rates_vector.

Definition at line 717 of file Stoich.h.

Referenced by installEnzyme(), installMMenz(), and installReaction().

bool Stoich::useOneWay_

private

True if the stoich matrix is set up to handle only one-way reactions, as is needed in the case of the Gillespie algorithm.

Definition at line 488 of file Stoich.h.

Referenced by buildRateTermLookup(), getEnzK2(), getEnzK3(), getNumCoreRates(), getOneWay(), innerInstallReaction(), installDummyEnzyme(), installEnzyme(), installReaction(), resizeArrays(), setEnzK2(), setEnzK3(), setOneWay(), and setReacKb().

vector< Id > Stoich::varPoolVec_

private

Maps Ids to objects in the S_, RateTerm, and FuncTerm vectors. There will be holes in this map, but look up is very fast. The calling Id must know what it wants to find: all it gets back is an integer. The alternative is to have multiple maps, but that is slower. Assume no arrays. Each Pool/reac etc must be a unique Element. Later we'll deal with diffusion. Minor efficiency: We will usually have a set of objects that are nearly contiguous in the map. May as well start with the first of them. Vector of variablePool Ids.

Definition at line 573 of file Stoich.h.

Referenced by allocateModel(), allocateModelObject(), buildPoolLookup(), getNumAllPools(), getNumVarPools(), resizeArrays(), and unZombifyPools().

---

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

• moose-core/ksolve/Stoich.h
• moose-core/ksolve/Stoich.cpp