Gsolve Class Reference

#include <Gsolve.h>

Inheritance diagram for Gsolve:

Collaboration diagram for Gsolve:

Public Member Functions
void	fillIncrementFuncDep ()
void	fillMmEnzDep ()
void	fillPoolFuncDep ()
void	getBlock (vector< double > &values) const
bool	getClockedUpdate () const
	Flag: returns true if randomized round to integers is done. More...
Id	getCompartment () const
	Inherited from ZombiePoolInterface. More...
double	getDiffConst (const Eref &e) const
	Diffusion constant: Only one per pool, voxel number is ignored. More...
double	getN (const Eref &e) const
	Get # of molecules in given pool and voxel. Varies with time. More...
double	getNinit (const Eref &e) const
	get initial # of molecules in given pool and voxel. Bdry cond. More...
unsigned int	getNumAllVoxels () const
vector< unsigned int >	getNumFire (unsigned int voxel) const
unsigned int	getNumLocalVoxels () const
	Number of voxels here. pools_.size() == getNumLocalVoxels. More...
unsigned int	getNumPools () const
	Inherited. More...
vector< double >	getNvec (unsigned int voxel) const
	Returns the vector of pool Num at the specified voxel. More...
unsigned int	getPoolIndex (const Eref &e) const
	Return pool index, using Stoich ptr to do lookup. More...
bool	getRandInit () const
	Flag: returns true if randomized round to integers is done. More...
Id	getStoich () const
unsigned int	getVoxelIndex (const Eref &e) const
	Gsolve ()
void	initProc (const Eref &e, ProcPtr p)
void	initReinit (const Eref &e, ProcPtr p)
void	insertMathDepReacs (unsigned int mathDepIndex, unsigned int firedReac)
void	makeReacDepsUnique ()
Gsolve &	operator= (const Gsolve &)
void	parallel_advance (int begin, int end, size_t nWorkers, ProcPtr p, const GssaSystem *sys)
VoxelPoolsBase *	pools (unsigned int i)
	Inherited. More...
void	process (const Eref &e, ProcPtr p)
void	rebuildGssaSystem ()
void	reinit (const Eref &e, ProcPtr p)
void	setBlock (const vector< double > &values)
void	setClockedUpdate (bool val)
	Flag: set true if randomized round to integers is to be done. More...
void	setCompartment (Id compt)
	Assigns compartment. More...
void	setDiffConst (const Eref &e, double v)
	Diffusion constant: Only one per pool, voxel number is ignored. More...
void	setDsolve (Id dsolve)
void	setN (const Eref &e, double v)
	Set # of molecules in given pool and voxel. Varies with time. More...
void	setNinit (const Eref &e, double v)
	Set initial # of molecules in given pool and voxel. Bdry cond. More...
void	setNumAllVoxels (unsigned int num)
void	setNumPools (unsigned int num)
void	setNvec (unsigned int voxel, vector< double > vec)
void	setRandInit (bool val)
	Flag: set true if randomized round to integers is to be done. More...
void	setStoich (Id stoich)
void	updateRateTerms (unsigned int index)
void	updateVoxelVol (vector< double > vols)
double	volume (unsigned int i) const
	Inherited. More...
	~Gsolve ()
Public Member Functions inherited from ZombiePoolInterface
Id	getCompartment () const
virtual void	setMotorConst (const Eref &e, double val)
virtual void	setPrev ()
	Used to tell Dsolver to assign 'prev' values. More...
virtual void	updateJunctions (double dt)
	Used for telling Dsolver to handle all ops across Junctions. More...
	ZombiePoolInterface ()

Static Public Member Functions
static const Cinfo *	initCinfo ()

Private Attributes
Id	dsolve_
ZombiePoolInterface *	dsolvePtr_
	Pointer to diffusion solver. More...
vector< GssaVoxelPools >	pools_
unsigned int	startVoxel_
	First voxel indexed on the current node. More...
Stoich *	stoichPtr_
	Utility ptr used to help Pool Id lookups by the Ksolve. More...
GssaSystem	sys_
bool	useClockedUpdate_
	Flag: True if atot should be updated every clock tick. More...

Additional Inherited Members
Protected Attributes inherited from ZombiePoolInterface
Id	compartment_
	Id of Chem compartment used to figure out volumes of voxels. More...
bool	isBuilt_
	Flag: True when solver setup has been completed. More...
Id	stoich_

Detailed Description

Definition at line 14 of file Gsolve.h.

Constructor & Destructor Documentation

Gsolve::Gsolve

(

)

Definition at line 206 of file Gsolve.cpp.

Referenced by initCinfo().

               :
#if PARALLELIZE_GSOLVE_WITH_CPP11_ASYNC
    numThreads_ ( 2 ),
#endif
    pools_( 1 ),
    startVoxel_( 0 ),
    dsolve_(),
    dsolvePtr_( 0 ),
    useClockedUpdate_( false )
{
    ;
}

Here is the caller graph for this function:

Gsolve::~Gsolve

(

)

Definition at line 224 of file Gsolve.cpp.

{
    ;
}

Member Function Documentation

void Gsolve::fillIncrementFuncDep

(

)

Here we fill in the dependencies involving incrementFuncs. These are the functions that evaluate an expression that specifies rate of change of # of a target molecule. There are two dependencies:

1. When a reaction fires, all the incrementFuncs that depend on the reactants must update their rates. This is added to sys_.dependency[] which is the usual handler for reac dependencies. Note that the inputs to the incrementFuncs are NOT present in the stoichiometry matrix, so this has to be done as a separate step.
2. When the incrementFunc fires, then downstream reacs must update their rates. This is handled by default with the regular dependency calculations, since incrementFuncs are treated like regular reactions.

Definition at line 694 of file Gsolve.cpp.

References GssaSystem::dependency, GssaSystem::dependentMathExpn, Stoich::getNumAllPools(), Stoich::getNumRates(), Stoich::getRateTerms(), SparseMatrix< T >::getRow(), stoichPtr_, sys_, and GssaSystem::transposeN.

Referenced by rebuildGssaSystem().

{
    // create map of funcs that depend on specified molecule.
    vector< vector< unsigned int > > funcMap(
        stoichPtr_->getNumAllPools() );
    const vector< RateTerm* >& rates = stoichPtr_->getRateTerms();
    vector< FuncRate* > incrementRates;
    vector< unsigned int > incrementRateIndex;
    const vector< RateTerm* >::const_iterator q;
    for ( unsigned int i = 0; i < rates.size(); ++i )
    {
        FuncRate *term =
            dynamic_cast< FuncRate* >( rates[i] );
        if (term)
        {
            incrementRates.push_back( term );
            incrementRateIndex.push_back( i );
        }
    }

    for ( unsigned int k = 0; k < incrementRates.size(); ++k )
    {
        const vector< unsigned int >& molIndex =
            incrementRates[k]->getFuncArgIndex();
        for ( unsigned int j = 0; j < molIndex.size(); ++j )
            funcMap[ molIndex[j] ].push_back( incrementRateIndex[k] );
    }

    unsigned int numRates = stoichPtr_->getNumRates();
    sys_.dependentMathExpn.resize( numRates );
    vector< unsigned int > indices;
    for ( unsigned int i = 0; i < numRates; ++i )
    {
        // Algorithm:
        // 1.Go through stoich matrix finding all the poolIndices affected
        // by each Rate Term.
        // 2.Use funcMap to look up FuncRateTerms affected by these indices
        // 3. Add the rateTerm->FuncRateTerm mapping to the dependencies.

        const int* entry;
        const unsigned int* colIndex;
        unsigned int numInRow =
            sys_.transposeN.getRow( i, &entry, &colIndex );
        // 1.Go through stoich matrix finding all the poolIndices affected
        // by each Rate Term.
        for ( unsigned int j = 0; j < numInRow; ++j )
        {
            unsigned int molIndex = colIndex[j]; // Affected poolIndex

            // 2.Use funcMap to look up FuncRateTerms affected by these indices
            vector< unsigned int >& funcs = funcMap[ molIndex ];
            // 3. Add the rateTerm->FuncRateTerm mapping to the dependencies.
            vector< unsigned int >& rdep = sys_.dependency[i];
            rdep.insert( rdep.end(), funcs.begin(), funcs.end() );
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Gsolve::fillMmEnzDep

(

)

Fill in dependency list for all MMEnzs on reactions. The dependencies of MMenz products are already in the system, so here we just need to add cases where any reaction product is the Enz of an MMEnz.

Definition at line 580 of file Gsolve.cpp.

References GssaSystem::dependency, Stoich::getNumRates(), RateTerm::getReactants(), SparseMatrix< T >::getRow(), Stoich::rates(), stoichPtr_, sys_, and GssaSystem::transposeN.

Referenced by rebuildGssaSystem().

{
    unsigned int numRates = stoichPtr_->getNumRates();
    vector< unsigned int > indices;

    // Make a map to look up enzyme RateTerm using
    // the key of the enzyme molecule.
    map< unsigned int, unsigned int > enzMolMap;
    for ( unsigned int i = 0; i < numRates; ++i )
    {
        const MMEnzymeBase* mme = dynamic_cast< const MMEnzymeBase* >(
                                      stoichPtr_->rates( i ) );
        if ( mme )
        {
            vector< unsigned int > reactants;
            mme->getReactants( reactants );
            if ( reactants.size() > 1 )
                enzMolMap[ reactants.front() ] = i; // front is enzyme.
        }
    }

    // Use the map to fill in deps.
    for ( unsigned int i = 0; i < numRates; ++i )
    {
        // Extract the row of all molecules that depend on the reac.
        const int* entry;
        const unsigned int* colIndex;

        unsigned int numInRow =
            sys_.transposeN.getRow( i, &entry, &colIndex );
        for( unsigned int j = 0; j < numInRow; ++j )
        {
            map< unsigned int, unsigned int >::iterator pos =
                enzMolMap.find( colIndex[j] );
            if ( pos != enzMolMap.end() )
                sys_.dependency[i].push_back( pos->second );
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Gsolve::fillPoolFuncDep

(

)

Here we fill in the dependencies involving poolFuncs. These are the functions that evaluate an expression and assign directly to the

of a target molecule.

There are two dependencies:

1. When a reaction fires, all the Functions that depend on the reactants must update their target molecule. This is in sys_.dependentMathExpn[].
2. All the reactions that depend on the updated target molecules must now recompute their propensity. This, along with other reac dependencies, is in sys_.dependency[].

Definition at line 631 of file Gsolve.cpp.

References GssaSystem::dependency, GssaSystem::dependentMathExpn, Stoich::funcs(), Stoich::getNumAllPools(), Stoich::getNumFuncs(), Stoich::getNumRates(), FuncTerm::getReactantIndex(), SparseMatrix< T >::getRow(), Stoich::getStoichiometryMatrix(), FuncTerm::getTarget(), stoichPtr_, sys_, and GssaSystem::transposeN.

Referenced by rebuildGssaSystem().

{
    // create map of funcs that depend on specified molecule.
    vector< vector< unsigned int > > funcMap(
        stoichPtr_->getNumAllPools() );
    unsigned int numFuncs = stoichPtr_->getNumFuncs();
    for ( unsigned int i = 0; i < numFuncs; ++i )
    {
        const FuncTerm *f = stoichPtr_->funcs( i );
        vector< unsigned int > molIndex = f->getReactantIndex();
        for ( unsigned int j = 0; j < molIndex.size(); ++j )
            funcMap[ molIndex[j] ].push_back( i );
    }
    // The output of each func is a mol indexed as
    // numVarMols + numBufMols + i
    unsigned int numRates = stoichPtr_->getNumRates();
    sys_.dependentMathExpn.resize( numRates );
    vector< unsigned int > indices;
    for ( unsigned int i = 0; i < numRates; ++i )
    {
        vector< unsigned int >& dep = sys_.dependentMathExpn[ i ];
        dep.resize( 0 );
        // Extract the row of all molecules that depend on the reac.
        const int* entry;
        const unsigned int* colIndex;
        unsigned int numInRow =
            sys_.transposeN.getRow( i, &entry, &colIndex );
        for ( unsigned int j = 0; j < numInRow; ++j )
        {
            unsigned int molIndex = colIndex[j];
            vector< unsigned int >& funcs = funcMap[ molIndex ];
            dep.insert( dep.end(), funcs.begin(), funcs.end() );
            for ( unsigned int k = 0; k < funcs.size(); ++k )
            {
                // unsigned int outputMol = funcs[k] + funcOffset;
                unsigned int outputMol = stoichPtr_->funcs( funcs[k] )->getTarget();
                // Insert reac deps here. Columns are reactions.
                vector< int > e; // Entries: we don't need.
                vector< unsigned int > c; // Column index: the reactions.
                stoichPtr_->getStoichiometryMatrix().
                getRow( outputMol, e, c );
                // Each of the reacs (col entries) depend on this func.
                vector< unsigned int > rdep = sys_.dependency[i];
                rdep.insert( rdep.end(), c.begin(), c.end() );
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Gsolve::getBlock ( vector< double > &  values ) const

virtual

Gets block of data. The first 4 entries are passed in on the 'values' vector: the start voxel, numVoxels, start pool#, numPools. These are followed by numVoxels * numPools of data values which are filled in by the function. We assert that the entire requested block is present in this ZombiePoolInterface. The block is organized as an array of arrays of voxels; values[pool#][voxel#]

Note that numVoxels and numPools are the number in the current block, not the upper limit of the block. So values.size() == 4 + numPools * numVoxels.

Implements ZombiePoolInterface.

Definition at line 970 of file Gsolve.cpp.

References pools_, and startVoxel_.

Referenced by process().

{
    unsigned int startVoxel = values[0];
    unsigned int numVoxels = values[1];
    unsigned int startPool = values[2];
    unsigned int numPools = values[3];

    assert( startVoxel >= startVoxel_ );
    assert( numVoxels <= pools_.size() );
    assert( pools_.size() > 0 );
    assert( numPools + startPool <= pools_[0].size() );
    values.resize( 4 + numVoxels * numPools );

    for ( unsigned int i = 0; i < numVoxels; ++i )
    {
        const double* v = pools_[ startVoxel + i ].S();
        for ( unsigned int j = 0; j < numPools; ++j )
        {
            values[ 4 + j * numVoxels + i]  = v[ j + startPool ];
        }
    }
}

Here is the caller graph for this function:

bool Gsolve::getClockedUpdate

(

)

const

Flag: returns true if randomized round to integers is done.

Definition at line 352 of file Gsolve.cpp.

References useClockedUpdate_.

Referenced by initCinfo().

{
    return useClockedUpdate_;
}

Here is the caller graph for this function:

Id Gsolve::getCompartment

(

)

const

Inherited from ZombiePoolInterface.

Definition at line 256 of file Gsolve.cpp.

References ZombiePoolInterface::compartment_.

Referenced by initCinfo().

{
    return compartment_;
}

Here is the caller graph for this function:

double Gsolve::getDiffConst ( const Eref &  e ) const

virtual

Diffusion constant: Only one per pool, voxel number is ignored.

Implements ZombiePoolInterface.

Definition at line 948 of file Gsolve.cpp.

{
    return 0;
}

double Gsolve::getN ( const Eref &  e ) const

virtual

Get # of molecules in given pool and voxel. Varies with time.

Implements ZombiePoolInterface.

Definition at line 903 of file Gsolve.cpp.

References getPoolIndex(), getVoxelIndex(), OFFNODE, and pools_.

{
    unsigned int vox = getVoxelIndex( e );
    if ( vox != OFFNODE )
        return pools_[vox].getN( getPoolIndex( e ) );
    return 0.0;
}

Here is the call graph for this function:

double Gsolve::getNinit ( const Eref &  e ) const

virtual

get initial # of molecules in given pool and voxel. Bdry cond.

Implements ZombiePoolInterface.

Definition at line 935 of file Gsolve.cpp.

References getPoolIndex(), getVoxelIndex(), OFFNODE, and pools_.

{
    unsigned int vox = getVoxelIndex( e );
    if ( vox != OFFNODE )
        return pools_[vox].getNinit( getPoolIndex( e ) );
    return 0.0;
}

Here is the call graph for this function:

unsigned int Gsolve::getNumAllVoxels

(

)

const

Definition at line 283 of file Gsolve.cpp.

References pools_.

Referenced by initCinfo().

{
    return pools_.size(); // Need to redo.
}

Here is the caller graph for this function:

vector< unsigned int > Gsolve::getNumFire

(

unsigned int

voxel

)

const

Definition at line 331 of file Gsolve.cpp.

References dummy, GssaVoxelPools::numFire(), and pools_.

Referenced by initCinfo().

{
    static vector< unsigned int > dummy;
    if ( voxel < pools_.size() )
    {
        return const_cast< GssaVoxelPools* >( &( pools_[ voxel ]) )->numFire();
    }
    return dummy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned int Gsolve::getNumLocalVoxels ( ) const

virtual

Number of voxels here. pools_.size() == getNumLocalVoxels.

Implements ZombiePoolInterface.

Definition at line 278 of file Gsolve.cpp.

References pools_.

Referenced by initCinfo(), and process().

{
    return pools_.size();
}

Here is the caller graph for this function:

unsigned int Gsolve::getNumPools ( ) const

virtual

Inherited.

Implements ZombiePoolInterface.

Definition at line 963 of file Gsolve.cpp.

References pools_.

Referenced by initCinfo().

{
    if ( pools_.size() > 0 )
        return pools_[0].size();
    return 0;
}

Here is the caller graph for this function:

vector< double > Gsolve::getNvec

(

unsigned int

voxel

)

const

Returns the vector of pool Num at the specified voxel.

Definition at line 299 of file Gsolve.cpp.

References dummy, pools_, and VoxelPoolsBase::Svec().

Referenced by initCinfo().

{
    static vector< double > dummy;
    if ( voxel < pools_.size() )
    {
        return const_cast< GssaVoxelPools* >( &( pools_[ voxel ]) )->Svec();
    }
    return dummy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned int Gsolve::getPoolIndex ( const Eref &  er ) const

virtual

Return pool index, using Stoich ptr to do lookup.

Implements ZombiePoolInterface.

Definition at line 844 of file Gsolve.cpp.

References Stoich::convertIdToPoolIndex(), Eref::id(), and stoichPtr_.

Referenced by getN(), getNinit(), setN(), and setNinit().

{
    return stoichPtr_->convertIdToPoolIndex( e.id() );
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Gsolve::getRandInit

(

)

const

Flag: returns true if randomized round to integers is done.

Definition at line 342 of file Gsolve.cpp.

References sys_, and GssaSystem::useRandInit.

Referenced by initCinfo().

{
    return sys_.useRandInit;
}

Here is the caller graph for this function:

Id Gsolve::getStoich

(

)

const

Definition at line 233 of file Gsolve.cpp.

References ZombiePoolInterface::stoich_.

Referenced by initCinfo().

{
    return stoich_;
}

Here is the caller graph for this function:

unsigned int Gsolve::getVoxelIndex

(

const Eref &

e

)

const

Definition at line 849 of file Gsolve.cpp.

References Eref::dataIndex(), OFFNODE, pools_, and startVoxel_.

Referenced by getN(), getNinit(), setN(), and setNinit().

{
    unsigned int ret = e.dataIndex();
    if ( ret < startVoxel_  || ret >= startVoxel_ + pools_.size() )
        return OFFNODE;
    return ret - startVoxel_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const Cinfo * Gsolve::initCinfo ( )

static

Definition at line 37 of file Gsolve.cpp.

References getClockedUpdate(), getCompartment(), getNumAllVoxels(), getNumFire(), getNumLocalVoxels(), getNumPools(), getNvec(), getRandInit(), getStoich(), Gsolve(), gsolveCinfo, init(), Neutral::initCinfo(), initProc(), initReinit(), process(), reinit(), setClockedUpdate(), setCompartment(), setNumAllVoxels(), setNumPools(), setNvec(), setRandInit(), setStoich(), and updateVoxelVol().

{
    // Field definitions

    static ValueFinfo< Gsolve, Id > stoich (
        "stoich",
        "Stoichiometry object for handling this reaction system.",
        &Gsolve::setStoich,
        &Gsolve::getStoich
    );

    static ValueFinfo< Gsolve, Id > compartment (
        "compartment",
        "Compartment that contains this reaction system.",
        &Gsolve::setCompartment,
        &Gsolve::getCompartment
    );

    static ReadOnlyValueFinfo< Gsolve, unsigned int > numLocalVoxels(
        "numLocalVoxels",
        "Number of voxels in the core reac-diff system, on the "
        "current solver. ",
        &Gsolve::getNumLocalVoxels
    );
    static LookupValueFinfo<
    Gsolve, unsigned int, vector< double > > nVec(
        "nVec",
        "vector of pool counts",
        &Gsolve::setNvec,
        &Gsolve::getNvec
    );
    static ValueFinfo< Gsolve, unsigned int > numAllVoxels(
        "numAllVoxels",
        "Number of voxels in the entire reac-diff system, "
        "including proxy voxels to represent abutting compartments.",
        &Gsolve::setNumAllVoxels,
        &Gsolve::getNumAllVoxels
    );

    static ValueFinfo< Gsolve, unsigned int > numPools(
        "numPools",
        "Number of molecular pools in the entire reac-diff system, "
        "including variable, function and buffered.",
        &Gsolve::setNumPools,
        &Gsolve::getNumPools
    );

    static ValueFinfo< Gsolve, bool > useRandInit(
        "useRandInit",
        "Flag: True when using probabilistic (random) rounding.\n "
        "Default: True.\n "
        "When initializing the mol# from floating-point Sinit values, "
        "we have two options. One is to look at each Sinit, and round "
        "to the nearest integer. The other is to look at each Sinit, "
        "and probabilistically round up or down depending on the  "
        "value. For example, if we had a Sinit value of 1.49,  "
        "this would always be rounded to 1.0 if the flag is false, "
        "and would be rounded to 1.0 and 2.0 in the ratio 51:49 if "
        "the flag is true. ",
        &Gsolve::setRandInit,
        &Gsolve::getRandInit
    );

    static ValueFinfo< Gsolve, bool > useClockedUpdate(
        "useClockedUpdate",
        "Flag: True to cause all reaction propensities to be updated "
        "on every clock tick.\n"
        "Default: False.\n"
        "This flag should be set when the reaction system "
        "includes a function with a dependency on time or on external "
        "events. It has a significant speed penalty so the flag "
        "should not be set unless there are such functions. " ,
        &Gsolve::setClockedUpdate,
        &Gsolve::getClockedUpdate
    );
    static ReadOnlyLookupValueFinfo<
    Gsolve, unsigned int, vector< unsigned int > > numFire(
        "numFire",
        "Vector of the number of times each reaction has fired."
        "Indexed by the voxel number."
        "Zeroed out at reinit.",
        &Gsolve::getNumFire
    );

    // DestFinfo definitions

    static DestFinfo process( "process",
                              "Handles process call",
                              new ProcOpFunc< Gsolve >( &Gsolve::process ) );
    static DestFinfo reinit( "reinit",
                             "Handles reinit call",
                             new ProcOpFunc< Gsolve >( &Gsolve::reinit ) );

    static DestFinfo voxelVol( "voxelVol",
                               "Handles updates to all voxels. Comes from parent "
                               "ChemCompt object.",
                               new OpFunc1< Gsolve, vector< double > >(
                                   &Gsolve::updateVoxelVol )
                             );

    static DestFinfo initProc( "initProc",
                               "Handles initProc call from Clock",
                               new ProcOpFunc< Gsolve >( &Gsolve::initProc ) );
    static DestFinfo initReinit( "initReinit",
                                 "Handles initReinit call from Clock",
                                 new ProcOpFunc< Gsolve >( &Gsolve::initReinit ) );

    // Shared definitions
    static Finfo* procShared[] =
    {
        &process, &reinit
    };
    static SharedFinfo proc( "proc",
                             "Shared message for process and reinit",
                             procShared, sizeof( procShared ) / sizeof( const Finfo* )
                           );

    static Finfo* initShared[] =
    {
        &initProc, &initReinit
    };
    static SharedFinfo init( "init",
                             "Shared message for initProc and initReinit. This is used"
                             " when the system has cross-compartment reactions. ",
                             initShared, sizeof( initShared ) / sizeof( const Finfo* )
                           );


    static Finfo* gsolveFinfos[] =
    {
        &stoich,            // Value
        &numLocalVoxels,    // ReadOnlyValue
        &nVec,              // LookupValue
        &numAllVoxels,      // ReadOnlyValue
        &numPools,          // Value
        &voxelVol,          // DestFinfo
        &proc,              // SharedFinfo
        &init,              // SharedFinfo
        // Here we put new fields that were not there in the Ksolve.
        &useRandInit,       // Value
        &useClockedUpdate,  // Value
        &numFire,           // ReadOnlyLookupValue
    };

    static Dinfo< Gsolve > dinfo;
    static  Cinfo gsolveCinfo(
        "Gsolve",
        Neutral::initCinfo(),
        gsolveFinfos,
        sizeof(gsolveFinfos)/sizeof(Finfo *),
        &dinfo
    );

    return &gsolveCinfo;
}

Here is the call graph for this function:

void Gsolve::initProc	(	const Eref &	e,
		ProcPtr	p
	)

Definition at line 532 of file Gsolve.cpp.

Referenced by initCinfo().

{;}

Here is the caller graph for this function:

void Gsolve::initReinit	(	const Eref &	e,
		ProcPtr	p
	)

Definition at line 535 of file Gsolve.cpp.

References pools_, stoichPtr_, and sys_.

Referenced by initCinfo().

{
    if ( !stoichPtr_ )
        return;
    for ( unsigned int i = 0 ; i < pools_.size(); ++i )
    {
        pools_[i].reinit( &sys_ );
    }
}

Here is the caller graph for this function:

void Gsolve::insertMathDepReacs	(	unsigned int	mathDepIndex,
		unsigned int	firedReac
	)

Inserts reactions that depend on molecules modified by the specified MathExpn, into the dependency list. Later.

Definition at line 805 of file Gsolve.cpp.

{
    /*
    unsigned int molIndex = sumTotals_[ mathDepIndex ].target( S_ );
    vector< unsigned int > reacIndices;

    // Extract the row of all reacs that depend on the target molecule
    if ( N_.getRowIndices( molIndex, reacIndices ) > 0 ) {
        vector< unsigned int >& dep = dependency_[ firedReac ];
        dep.insert( dep.end(), reacIndices.begin(), reacIndices.end() );
    }
    */
}

void Gsolve::makeReacDepsUnique

(

)

STL stuff follows, with the usual weirdness.

Definition at line 822 of file Gsolve.cpp.

References GssaSystem::dependency, Stoich::getNumRates(), stoichPtr_, and sys_.

Referenced by rebuildGssaSystem().

{
    unsigned int numRates = stoichPtr_->getNumRates();
    for ( unsigned int i = 0; i < numRates; ++i )
    {
        vector< unsigned int >& dep = sys_.dependency[ i ];
        // Here we want to remove self-entries as well as duplicates.
        sort( dep.begin(), dep.end() );
        vector< unsigned int >::iterator k = dep.begin();

        vector< unsigned int >::iterator pos =
            unique( dep.begin(), dep.end() );
        dep.resize( pos - dep.begin() );
        /*
        */
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Gsolve & Gsolve::operator=

(

const Gsolve &

)

Definition at line 219 of file Gsolve.cpp.

{
    return *this;
}

void Gsolve::parallel_advance	(	int	begin,
		int	end,
		size_t	nWorkers,
		ProcPtr	p,
		const GssaSystem *	sys
	)

Referenced by process().

Here is the caller graph for this function:

VoxelPoolsBase * Gsolve::pools ( unsigned int  i )

virtual

Inherited.

Implements ZombiePoolInterface.

Definition at line 1052 of file Gsolve.cpp.

References pools_.

{
    if ( pools_.size() > i )
        return &pools_[i];
    return 0;
}

void Gsolve::process	(	const Eref &	e,
		ProcPtr	p
	)

Definition at line 398 of file Gsolve.cpp.

References advance(), ProcInfo::currTime, dsolvePtr_, ProcInfo::dt, ZombiePoolInterface::getBlock(), getBlock(), getNumLocalVoxels(), Stoich::getNumVarPools(), moose::mtrand(), parallel_advance(), pools_, ZombiePoolInterface::setBlock(), setBlock(), ZombiePoolInterface::setPrev(), stoichPtr_, sys_, ZombiePoolInterface::updateJunctions(), and useClockedUpdate_.

Referenced by initCinfo().

{
    // cout << stoichPtr_ << "  dsolve = " <<   dsolvePtr_ << endl;
    if ( !stoichPtr_ )
        return;

    // First, handle incoming diffusion values. Note potential for
    // issues with roundoff if diffusion is not integral.
    if ( dsolvePtr_ )
    {
        vector< double > dvalues( 4 );
        dvalues[0] = 0;
        dvalues[1] = getNumLocalVoxels();
        dvalues[2] = 0;
        dvalues[3] = stoichPtr_->getNumVarPools();
        dsolvePtr_->getBlock( dvalues );
        dsolvePtr_->setPrev();

        // Here we need to convert to integers, just in case. Normally
        // one would use a stochastic (integral) diffusion method with
        // the GSSA, but in mixed models it may be more complicated.
        vector< double >::iterator i = dvalues.begin() + 4;

        for ( ; i != dvalues.end(); ++i )
        {
            //  cout << *i << " " << round( *i ) << "       ";
#if SIMPLE_ROUNDING
            *i = round( *i );
#else
            double base = floor( *i );

            // Use global RNG.
            if ( moose::mtrand() >= (*i - base) )
                *i = base;
            else
                *i = base + 1.0;
#endif
        }
        setBlock( dvalues );
    }

    // Third: Fix the rates if we have had any diffusion or xreacs
    // happening. This is very inefficient at this point, need to fix.
    if ( dsolvePtr_ )
    {
        for ( vector< GssaVoxelPools >::iterator
                i = pools_.begin(); i != pools_.end(); ++i )
        {
            i->refreshAtot( &sys_ );
        }
    }
    // Fourth, update the mol #s.
    // First we advance the simulation.
    size_t nvPools = pools_.size( );

#if PARALLELIZE_GSOLVE_WITH_CPP11_ASYNC
    // If there is only one voxel-pool or one thread is specified by user then
    // there is no point in using std::async there.
    if( 1 == getNumThreads( ) || 1 == nvPools )
    {
        for ( size_t i = 0; i < nvPools; i++ )
            pools_[i].advance( p, &sys_ );
    }
    else
    {
        /*-----------------------------------------------------------------------------
         *  Somewhat complicated computation to compute the number of threads. 1
         *  thread per (at least) voxel pool is ideal situation.
         *-----------------------------------------------------------------------------*/
        size_t grainSize = min( nvPools, 1 + (nvPools / numThreads_ ) );
        size_t nWorkers = nvPools / grainSize;

        for (size_t i = 0; i < nWorkers; i++)
            parallel_advance( i * grainSize, (i+1) * grainSize, nWorkers, p, &sys_ );

    }
#else
    for ( size_t i = 0; i < nvPools; i++ )
        pools_[i].advance( p, &sys_ );
#endif

    if ( useClockedUpdate_ )   // Check if a clocked stim is to be updated
    {
        for ( auto &v : pools_ )
            v.recalcTime( &sys_, p->currTime );
    }

    // Finally, assemble and send the integrated values off for the Dsolve.
    if ( dsolvePtr_ )
    {
        vector< double > kvalues( 4 );
        kvalues[0] = 0;
        kvalues[1] = getNumLocalVoxels();
        kvalues[2] = 0;
        kvalues[3] = stoichPtr_->getNumVarPools();
        getBlock( kvalues );
        dsolvePtr_->setBlock( kvalues );

        // Now use the values in the Dsolve to update junction fluxes
        // for diffusion, channels, and xreacs
        dsolvePtr_->updateJunctions( p->dt );
        // Here the Gsolve may need to do something to convert to integers
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Gsolve::rebuildGssaSystem

(

)

Definition at line 548 of file Gsolve.cpp.

References Stoich::convertRatesToStochasticForm(), GssaSystem::dependency, fillIncrementFuncDep(), fillMmEnzDep(), fillPoolFuncDep(), KinSparseMatrix::getGillespieDependence(), Stoich::getNumCoreRates(), Stoich::getNumProxyPools(), Stoich::getNumRates(), Stoich::getNumVarPools(), Stoich::getRateTerms(), Stoich::getStoichiometryMatrix(), GssaSystem::isReady, makeReacDepsUnique(), pools_, stoichPtr_, sys_, SparseMatrix< T >::transpose(), GssaSystem::transposeN, and KinSparseMatrix::truncateRow().

Referenced by reinit().

{
    stoichPtr_->convertRatesToStochasticForm();
    sys_.transposeN = stoichPtr_->getStoichiometryMatrix();
    sys_.transposeN.transpose();
    sys_.transposeN.truncateRow( stoichPtr_->getNumVarPools() + stoichPtr_->getNumProxyPools() );
    vector< vector< unsigned int > > & dep = sys_.dependency;
    dep.resize( stoichPtr_->getNumRates() );
    for ( unsigned int i = 0; i < stoichPtr_->getNumRates(); ++i )
    {
        sys_.transposeN.getGillespieDependence( i, dep[i] );
    }
    fillMmEnzDep();
    fillPoolFuncDep();
    fillIncrementFuncDep();
    makeReacDepsUnique();
    for ( vector< GssaVoxelPools >::iterator
            i = pools_.begin(); i != pools_.end(); ++i )
    {
        i->setNumReac( stoichPtr_->getNumRates() );
        i->updateAllRateTerms( stoichPtr_->getRateTerms(),
                               stoichPtr_->getNumCoreRates() );
    }
    sys_.isReady = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Gsolve::reinit	(	const Eref &	e,
		ProcPtr	p
	)

Definition at line 503 of file Gsolve.cpp.

References GssaSystem::isReady, pools_, rebuildGssaSystem(), stoichPtr_, and sys_.

Referenced by initCinfo().

{
    if ( !stoichPtr_ )
        return;
    if ( !sys_.isReady )
        rebuildGssaSystem();
    // First reinit concs.
    for ( vector< GssaVoxelPools >::iterator
            i = pools_.begin(); i != pools_.end(); ++i )
    {
        i->reinit( &sys_ );
    }
    // Second, update the atots.
    for ( vector< GssaVoxelPools >::iterator
            i = pools_.begin(); i != pools_.end(); ++i )
    {
        i->refreshAtot( &sys_ );
    }

#if PARALLELIZE_GSOLVE_WITH_CPP11_ASYNC
    if( 1 < getNumThreads( ) )
        cout << "Info: Using threaded gsolve: " << getNumThreads( )
            << " threads. " << endl;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Gsolve::setBlock ( const vector< double > &  values )

virtual

Sets block of data. The first 4 entries on the 'values' vector are the start voxel, numVoxels, start pool#, numPools. These are followed by numVoxels * numPools of data values.

Implements ZombiePoolInterface.

Definition at line 993 of file Gsolve.cpp.

References pools_, and startVoxel_.

Referenced by process().

{
    unsigned int startVoxel = values[0];
    unsigned int numVoxels = values[1];
    unsigned int startPool = values[2];
    unsigned int numPools = values[3];

    assert( startVoxel >= startVoxel_ );
    assert( numVoxels <= pools_.size() );
    assert( pools_.size() > 0 );
    assert( numPools + startPool <= pools_[0].size() );

    for ( unsigned int i = 0; i < numVoxels; ++i )
    {
        double* v = pools_[ startVoxel + i ].varS();
        for ( unsigned int j = 0; j < numPools; ++j )
        {
            v[ j + startPool ] = values[ 4 + j * numVoxels + i ];
        }
    }
}

Here is the caller graph for this function:

void Gsolve::setClockedUpdate

(

bool

val

)

Flag: set true if randomized round to integers is to be done.

Definition at line 357 of file Gsolve.cpp.

References useClockedUpdate_.

Referenced by initCinfo().

{
    useClockedUpdate_ = val;
}

Here is the caller graph for this function:

void Gsolve::setCompartment ( Id  compartment )

virtual

Assigns compartment.

Reimplemented from ZombiePoolInterface.

Definition at line 238 of file Gsolve.cpp.

References Element::cinfo(), ZombiePoolInterface::compartment_, Id::element(), Cinfo::isA(), and pools_.

Referenced by initCinfo().

{
    if ( ( compt.element()->cinfo()->isA( "ChemCompt" ) ) )
    {
        compartment_ = compt;
        vector< double > vols =
            Field< vector< double > >::get( compt, "voxelVolume" );
        if ( vols.size() > 0 )
        {
            pools_.resize( vols.size() );
            for ( unsigned int i = 0; i < vols.size(); ++i )
            {
                pools_[i].setVolume( vols[i] );
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Gsolve::setDiffConst ( const Eref &  e, double  val  )

virtual

Diffusion constant: Only one per pool, voxel number is ignored.

Implements ZombiePoolInterface.

Definition at line 943 of file Gsolve.cpp.

{
    ; // Do nothing.
}

void Gsolve::setDsolve ( Id  dsolve )

virtual

Inherited. Needed for reac-diff calculations so the Gsolve can orchestrate the data transfer between the itself and the diffusion solver.

Implements ZombiePoolInterface.

Definition at line 857 of file Gsolve.cpp.

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

{
    if ( dsolve == Id () )
    {
        dsolvePtr_ = 0;
        dsolve_ = Id();
    }
    else if ( dsolve.element()->cinfo()->isA( "Dsolve" ) )
    {
        dsolve_ = dsolve;
        dsolvePtr_ = reinterpret_cast< ZombiePoolInterface* >(
                         dsolve.eref().data() );
    }
    else
    {
        cout << "Warning: Gsolve::setDsolve: Object '" << dsolve.path() <<
             "' should be class Dsolve, is: " <<
             dsolve.element()->cinfo()->name() << endl;
    }
}

Here is the call graph for this function:

void Gsolve::setN ( const Eref &  e, double  val  )

virtual

Set # of molecules in given pool and voxel. Varies with time.

Implements ZombiePoolInterface.

Definition at line 883 of file Gsolve.cpp.

References Element::cinfo(), Eref::element(), getPoolIndex(), getVoxelIndex(), Cinfo::isA(), GssaSystem::isReady, OFFNODE, pools_, and sys_.

{
    unsigned int vox = getVoxelIndex( e );
    if ( vox != OFFNODE )
    {
        if ( e.element()->cinfo()->isA( "ZombieBufPool" ) )
        {
            // Do NOT round it here, it is folded into rate term.
            pools_[vox].setN( getPoolIndex( e ), v );
            // refresh rates because nInit controls ongoing value of n.
            if ( sys_.isReady )
                pools_[vox].refreshAtot( &sys_ );
        }
        else
        {
            pools_[vox].setN( getPoolIndex( e ), round( v ) );
        }
    }
}

Here is the call graph for this function:

void Gsolve::setNinit ( const Eref &  e, double  val  )

virtual

Set initial # of molecules in given pool and voxel. Bdry cond.

Implements ZombiePoolInterface.

Definition at line 911 of file Gsolve.cpp.

References Element::cinfo(), Eref::element(), getPoolIndex(), getVoxelIndex(), Cinfo::isA(), GssaSystem::isReady, OFFNODE, pools_, and sys_.

{
    unsigned int vox = getVoxelIndex( e );
    if ( vox != OFFNODE )
    {
        if ( e.element()->cinfo()->isA( "ZombieBufPool" ) )
        {
            // Do NOT round it here, it is folded into rate term.
            pools_[vox].setNinit( getPoolIndex( e ), v );
            // refresh rates because nInit controls ongoing value of n.
            if ( sys_.isReady )
                pools_[vox].refreshAtot( &sys_ );
        }
        else
        {
            // I now do the rounding at reinit time. It is better there as
            // it can give a distinct value each cycle. It is also better
            // to keep the full resolution of Ninit for volume scaling.
            // pools_[vox].setNinit( getPoolIndex( e ), round( v ) );
            pools_[vox].setNinit( getPoolIndex( e ), v );
        }
    }
}

Here is the call graph for this function:

void Gsolve::setNumAllVoxels ( unsigned int  num )

virtual

Assigns the number of voxels used in the entire reac-diff system. Note that fewer than this may be used on any given node.

Implements ZombiePoolInterface.

Definition at line 289 of file Gsolve.cpp.

References GssaSystem::isReady, pools_, and sys_.

Referenced by initCinfo().

{
    if ( numVoxels == 0 )
    {
        return;
    }
    pools_.resize( numVoxels );
    sys_.isReady = false;
}

Here is the caller graph for this function:

void Gsolve::setNumPools ( unsigned int  num )

virtual

Assigns number of different pools (chemical species) present in each voxel.

Implements ZombiePoolInterface.

Definition at line 953 of file Gsolve.cpp.

References GssaSystem::isReady, pools_, and sys_.

Referenced by initCinfo().

{
    sys_.isReady = false;
    unsigned int numVoxels = pools_.size();
    for ( unsigned int i = 0 ; i < numVoxels; ++i )
    {
        pools_[i].resizeArrays( numPoolSpecies );
    }
}

Here is the caller graph for this function:

void Gsolve::setNvec	(	unsigned int	voxel,
		vector< double >	vec
	)

Definition at line 309 of file Gsolve.cpp.

References GssaSystem::isReady, pools_, and sys_.

Referenced by initCinfo().

{
    if ( voxel < pools_.size() )
    {
        if ( nVec.size() != pools_[voxel].size() )
        {
            cout << "Warning: Gsolve::setNvec: size mismatch ( " <<
                 nVec.size() << ", " << pools_[voxel].size() << ")\n";
            return;
        }
        double* s = pools_[voxel].varS();
        for ( unsigned int i = 0; i < nVec.size(); ++i )
        {
            s[i] = round( nVec[i] );
            if ( s[i] < 0.0 )
                s[i] = 0.0;
        }
        if ( sys_.isReady )
            pools_[voxel].refreshAtot( &sys_ );
    }
}

Here is the caller graph for this function:

void Gsolve::setRandInit

(

bool

val

)

Flag: set true if randomized round to integers is to be done.

Definition at line 347 of file Gsolve.cpp.

References sys_, and GssaSystem::useRandInit.

Referenced by initCinfo().

{
    sys_.useRandInit = val;
}

Here is the caller graph for this function:

void Gsolve::setStoich ( Id  stoich )

virtual

Informs the ZPI about the stoich, used during subsequent computations. Called to wrap up the model building. The Stoich does this call after it has set up its own path.

Implements ZombiePoolInterface.

Definition at line 261 of file Gsolve.cpp.

References Element::cinfo(), Eref::data(), Id::element(), Id::eref(), Stoich::getNumAllPools(), Cinfo::isA(), GssaSystem::isReady, pools_, GssaSystem::stoich, ZombiePoolInterface::stoich_, stoichPtr_, and sys_.

Referenced by initCinfo().

{
    // This call is done _before_ setting the path on stoich
    assert( stoich.element()->cinfo()->isA( "Stoich" ) );
    stoich_ = stoich;
    stoichPtr_ = reinterpret_cast< Stoich* >( stoich.eref().data() );
    if ( stoichPtr_->getNumAllPools() == 0 )
    {
        stoichPtr_ = 0;
        return;
    }
    sys_.stoich = stoichPtr_;
    sys_.isReady = false;
    for ( unsigned int i = 0; i < pools_.size(); ++i )
        pools_[i].setStoich( stoichPtr_ );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Gsolve::updateRateTerms ( unsigned int  index )

virtual

Rescale specified voxel rate term following rate constant change or volume change. If index == ~0U then does all terms.

Implements ZombiePoolInterface.

Definition at line 1031 of file Gsolve.cpp.

References Stoich::getNumCoreRates(), Stoich::getRateTerms(), pools_, and stoichPtr_.

Referenced by updateVoxelVol().

{
    if ( index == ~0U )
    {
        // unsigned int numCrossRates = stoichPtr_->getNumRates() - stoichPtr_->getNumCoreRates();
        for ( unsigned int i = 0 ; i < pools_.size(); ++i )
        {
            pools_[i].updateAllRateTerms( stoichPtr_->getRateTerms(),
                                          stoichPtr_->getNumCoreRates() );
        }
    }
    else if ( index < stoichPtr_->getNumRates() )
    {
        for ( unsigned int i = 0 ; i < pools_.size(); ++i )
            pools_[i].updateRateTerms( stoichPtr_->getRateTerms(),
                                       stoichPtr_->getNumCoreRates(), index );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Gsolve::updateVoxelVol

(

vector< double >

vols

)

Handles request to change volumes of voxels in this Ksolve, and all cascading effects of this. At this point it won't handle change in size of voxel array.

Definition at line 1016 of file Gsolve.cpp.

References pools_, and updateRateTerms().

Referenced by initCinfo().

{
    // For now we assume identical numbers of voxels. Also assume
    // identical voxel junctions. But it should not be too hard to
    // update those too.
    if ( vols.size() == pools_.size() )
    {
        for ( unsigned int i = 0; i < vols.size(); ++i )
        {
            pools_[i].setVolumeAndDependencies( vols[i] );
        }
        updateRateTerms( ~0U );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

double Gsolve::volume ( unsigned int  i ) const

virtual

Inherited.

Implements ZombiePoolInterface.

Definition at line 1059 of file Gsolve.cpp.

References pools_.

{
    if ( pools_.size() > i )
        return pools_[i].getVolume();
    return 0.0;
}

Member Data Documentation

Id Gsolve::dsolve_

private

Id of diffusion solver, needed for coordinating numerics.

Definition at line 165 of file Gsolve.h.

Referenced by setDsolve().

ZombiePoolInterface* Gsolve::dsolvePtr_

private

Pointer to diffusion solver.

Definition at line 168 of file Gsolve.h.

Referenced by process(), and setDsolve().

vector< GssaVoxelPools > Gsolve::pools_

private

Each VoxelPools entry handles all the pools in a single voxel. Each entry knows how to update itself in order to complete the kinetic calculations for that voxel. The ksolver does multinode management by indexing only the subset of entries present on this node.

Definition at line 154 of file Gsolve.h.

Referenced by getBlock(), getN(), getNinit(), getNumAllVoxels(), getNumFire(), getNumLocalVoxels(), getNumPools(), getNvec(), getVoxelIndex(), initReinit(), pools(), process(), rebuildGssaSystem(), reinit(), setBlock(), setCompartment(), setN(), setNinit(), setNumAllVoxels(), setNumPools(), setNvec(), setStoich(), updateRateTerms(), updateVoxelVol(), and volume().

unsigned int Gsolve::startVoxel_

private

First voxel indexed on the current node.

Definition at line 157 of file Gsolve.h.

Referenced by getBlock(), getVoxelIndex(), and setBlock().

Stoich* Gsolve::stoichPtr_

private

Utility ptr used to help Pool Id lookups by the Ksolve.

Definition at line 160 of file Gsolve.h.

Referenced by fillIncrementFuncDep(), fillMmEnzDep(), fillPoolFuncDep(), getPoolIndex(), initReinit(), makeReacDepsUnique(), process(), rebuildGssaSystem(), reinit(), setStoich(), and updateRateTerms().

GssaSystem Gsolve::sys_

private

Definition at line 146 of file Gsolve.h.

Referenced by fillIncrementFuncDep(), fillMmEnzDep(), fillPoolFuncDep(), getRandInit(), initReinit(), makeReacDepsUnique(), process(), rebuildGssaSystem(), reinit(), setN(), setNinit(), setNumAllVoxels(), setNumPools(), setNvec(), setRandInit(), and setStoich().

bool Gsolve::useClockedUpdate_

private

Flag: True if atot should be updated every clock tick.

Definition at line 171 of file Gsolve.h.

Referenced by getClockedUpdate(), process(), and setClockedUpdate().

---

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

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