Ksolve Class Reference

#include <Ksolve.h>

Inheritance diagram for Ksolve:

Collaboration diagram for Ksolve:

Public Member Functions
void	getBlock (vector< double > &values) const
double	getDiffConst (const Eref &e) const
	Diffusion constant: Only one per pool, voxel number is ignored. More...
Id	getDsolve () const
	Inherited from ZombiePoolInterface. More...
double	getEpsAbs () const
	Assigns Absolute tolerance for integration. More...
double	getEpsRel () const
	Assigns Relative tolerance for integration. More...
double	getEstimatedDt () const
string	getMethod () const
	Assigns integration method. 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
unsigned int	getNumLocalVoxels () const
	Inherited from ZombiePoolInterface. More...
unsigned int	getNumPools () const
	gets number of pools (species) handled by system. 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...
Id	getStoich () const
	Assigns Stoich object to Ksolve. More...
unsigned int	getVoxelIndex (const Eref &e) const
void	initProc (const Eref &e, ProcPtr p)
void	initReinit (const Eref &e, ProcPtr p)
	Ksolve ()
void	matchJunctionVols (vector< double > &vols, Id otherCompt) const
VoxelPoolsBase *	pools (unsigned int i)
	Return a pointer to the specified VoxelPool. More...
void	print () const
void	process (const Eref &e, ProcPtr p)
void	reinit (const Eref &e, ProcPtr p)
void	setBlock (const vector< double > &values)
void	setDiffConst (const Eref &e, double v)
	Diffusion constant: Only one per pool, voxel number is ignored. More...
void	setDsolve (Id dsolve)
	Assigns the diffusion solver. Used by the reac solvers. More...
void	setEpsAbs (double val)
void	setEpsRel (double val)
void	setMethod (string method)
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	setStoich (Id stoich)
void	updateRateTerms (unsigned int index)
void	updateVoxelVol (vector< double > vols)
double	volume (unsigned int i) const
	Return volume of voxel i. More...
	~Ksolve ()
Public Member Functions inherited from ZombiePoolInterface
Id	getCompartment () const
virtual void	setCompartment (Id compartment)
	Assigns compartment. More...
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...
double	epsAbs_
double	epsRel_
string	method_
vector< VoxelPools >	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...

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 15 of file Ksolve.h.

Constructor & Destructor Documentation

Ksolve::Ksolve

(

)

Definition at line 216 of file Ksolve.cpp.

Referenced by initCinfo().

    :
#if USE_GSL
    method_( "rk5" ),
#elif USE_BOOST_ODE
    method_( "rk5a" ),
#endif
    epsAbs_( 1e-7 ),
    epsRel_( 1e-7 ),
#if PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
    numThreads_( 3 ),
#endif
    pools_( 1 ),
    startVoxel_( 0 ),
    dsolve_(),
    dsolvePtr_( 0 )
{
    ;
}

Here is the caller graph for this function:

Ksolve::~Ksolve

(

)

Definition at line 236 of file Ksolve.cpp.

{
    ;
}

Member Function Documentation

void Ksolve::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 753 of file Ksolve.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:

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

virtual

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

Implements ZombiePoolInterface.

Definition at line 718 of file Ksolve.cpp.

{
    return 0;
}

Id Ksolve::getDsolve

(

)

const

Inherited from ZombiePoolInterface.

Assigns Dsolve object to Ksolve.

Definition at line 401 of file Ksolve.cpp.

References dsolve_.

{
    return dsolve_;
}

double Ksolve::getEpsAbs

(

)

const

Assigns Absolute tolerance for integration.

Definition at line 274 of file Ksolve.cpp.

References epsAbs_.

Referenced by initCinfo().

{
    return epsAbs_;
}

Here is the caller graph for this function:

double Ksolve::getEpsRel

(

)

const

Assigns Relative tolerance for integration.

Definition at line 288 of file Ksolve.cpp.

References epsRel_.

Referenced by initCinfo().

{
    return epsRel_;
}

Here is the caller graph for this function:

double Ksolve::getEstimatedDt

(

)

const

This does a quick and dirty estimate of the timestep suitable for this sytem

Definition at line 474 of file Ksolve.cpp.

References EPSILON, Stoich::getNumAllPools(), Stoich::getNumRates(), pools_, and stoichPtr_.

Referenced by initCinfo().

{
    static const double EPSILON = 1e-15;
    vector< double > s( stoichPtr_->getNumAllPools(), 1.0 );
    vector< double > v( stoichPtr_->getNumRates(), 0.0 );
    double maxVel = 0.0;
    if ( pools_.size() > 0.0 )
    {
        pools_[0].updateReacVelocities( &s[0], v );
        for ( vector< double >::iterator
                i = v.begin(); i != v.end(); ++i )
            if ( maxVel < *i )
                maxVel = *i;
    }
    if ( maxVel < EPSILON )
        return 0.1; // Based on typical sig pathway reac rates.
    // Heuristic: the largest velocity times dt should be 10% of mol conc.
    return 0.1 / maxVel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

string Ksolve::getMethod

(

)

const

Assigns integration method.

Definition at line 245 of file Ksolve.cpp.

References method_.

Referenced by initCinfo().

{
    return method_;
}

Here is the caller graph for this function:

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

virtual

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

Implements ZombiePoolInterface.

Definition at line 690 of file Ksolve.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 Ksolve::getNinit ( const Eref &  e ) const

virtual

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

Implements ZombiePoolInterface.

Definition at line 705 of file Ksolve.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 Ksolve::getNumAllVoxels

(

)

const

Definition at line 432 of file Ksolve.cpp.

References pools_.

Referenced by initCinfo().

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

Here is the caller graph for this function:

unsigned int Ksolve::getNumLocalVoxels ( ) const

virtual

Inherited from ZombiePoolInterface.

Implements ZombiePoolInterface.

Definition at line 427 of file Ksolve.cpp.

References pools_.

Referenced by initCinfo(), and process().

{
    return pools_.size();
}

Here is the caller graph for this function:

unsigned int Ksolve::getNumPools ( ) const

virtual

gets number of pools (species) handled by system.

Implements ZombiePoolInterface.

Definition at line 732 of file Ksolve.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 > Ksolve::getNvec

(

unsigned int

voxel

)

const

Returns the vector of pool Num at the specified voxel.

Definition at line 447 of file Ksolve.cpp.

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

Referenced by initCinfo().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Return pool index, using Stoich ptr to do lookup.

Implements ZombiePoolInterface.

Definition at line 666 of file Ksolve.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:

Id Ksolve::getStoich

(

)

const

Assigns Stoich object to Ksolve.

Definition at line 317 of file Ksolve.cpp.

References ZombiePoolInterface::stoich_.

Referenced by initCinfo().

{
    return stoich_;
}

Here is the caller graph for this function:

unsigned int Ksolve::getVoxelIndex

(

const Eref &

e

)

const

Definition at line 671 of file Ksolve.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 * Ksolve::initCinfo ( )

static

Definition at line 40 of file Ksolve.cpp.

References ZombiePoolInterface::getCompartment(), getEpsAbs(), getEpsRel(), getEstimatedDt(), getMethod(), getNumAllVoxels(), getNumLocalVoxels(), getNumPools(), getNvec(), getStoich(), init(), Neutral::initCinfo(), initProc(), initReinit(), Ksolve(), ksolveCinfo, process(), reinit(), ZombiePoolInterface::setCompartment(), setEpsAbs(), setEpsRel(), setMethod(), setNumAllVoxels(), setNumPools(), setNvec(), and updateVoxelVol().

{
    // Field definitions

    static ValueFinfo< Ksolve, string > method (
        "method",
        "Integration method, using GSL. So far only explict. Options are:"
        "rk5: The default Runge-Kutta-Fehlberg 5th order adaptive dt method"
        "gsl: alias for the above"
        "rk4: The Runge-Kutta 4th order fixed dt method"
        "rk2: The Runge-Kutta 2,3 embedded fixed dt method"
        "rkck: The Runge-Kutta Cash-Karp (4,5) method"
        "rk8: The Runge-Kutta Prince-Dormand (8,9) method" ,
        &Ksolve::setMethod,
        &Ksolve::getMethod
    );

    static ValueFinfo< Ksolve, double > epsAbs (
        "epsAbs",
        "Absolute permissible integration error range.",
        &Ksolve::setEpsAbs,
        &Ksolve::getEpsAbs
    );

    static ValueFinfo< Ksolve, double > epsRel (
        "epsRel",
        "Relative permissible integration error range.",
        &Ksolve::setEpsRel,
        &Ksolve::getEpsRel
    );


    static ValueFinfo< Ksolve, Id > compartment(
        "compartment",
        "Compartment in which the Ksolve reaction system lives.",
        &Ksolve::setCompartment,
        &Ksolve::getCompartment
    );

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

#if PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
    static ValueFinfo< Ksolve, unsigned int > numThreads (
        "numThreads",
        "Number of threads to use (applicable in deterministic case)",
        &Ksolve::setNumThreads,
        &Ksolve::getNumThreads
    );
#endif

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

    static ReadOnlyValueFinfo< Ksolve, double > estimatedDt(
        "estimatedDt",
        "Estimated timestep for reac system based on Euler error",
        &Ksolve::getEstimatedDt
    );
    static ReadOnlyValueFinfo< Ksolve, Id > stoich(
        "stoich",
        "Id for stoichiometry object tied to this Ksolve",
        &Ksolve::getStoich
    );


    // DestFinfo definitions

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

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

    static DestFinfo voxelVol( "voxelVol",
                               "Handles updates to all voxels. Comes from parent "
                               "ChemCompt object.",
                               new OpFunc1< Ksolve, vector< double > >(
                                   &Ksolve::updateVoxelVol )
                             );
    // Shared definitions
    static Finfo* procShared[] =
    {
        &process, &reinit
    };
    static SharedFinfo proc( "proc",
                             "Shared message for process and reinit. These are used for "
                             "all regular Ksolve calculations including interfacing with "
                             "the diffusion calculations by a Dsolve.",
                             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* ksolveFinfos[] =
    {
        &method,            // Value
        &epsAbs,            // Value
        &epsRel ,           // Value
#if PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
        &numThreads,                    // Value
#endif
        &compartment,       // Value
        &numLocalVoxels,    // ReadOnlyValue
        &nVec,              // LookupValue
        &numAllVoxels,      // ReadOnlyValue
        &numPools,          // Value
        &estimatedDt,       // ReadOnlyValue
        &stoich,            // ReadOnlyValue
        &voxelVol,          // DestFinfo
        &proc,              // SharedFinfo
        &init,              // SharedFinfo
    };

    static Dinfo< Ksolve > dinfo;
    static  Cinfo ksolveCinfo(
        "Ksolve",
        Neutral::initCinfo(),
        ksolveFinfos,
        sizeof(ksolveFinfos)/sizeof(Finfo *),
        &dinfo
    );

    return &ksolveCinfo;
}

Here is the call graph for this function:

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

Definition at line 626 of file Ksolve.cpp.

Referenced by initCinfo().

{
}

Here is the caller graph for this function:

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

Definition at line 630 of file Ksolve.cpp.

References ProcInfo::dt, pools_, and reinit().

Referenced by initCinfo().

{
    for ( unsigned int i = 0 ; i < pools_.size(); ++i )
        pools_[i].reinit( p->dt );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Ksolve::matchJunctionVols	(	vector< double > &	vols,
		Id	otherCompt
	)		const

VoxelPoolsBase * Ksolve::pools ( unsigned int  i )

virtual

Return a pointer to the specified VoxelPool.

Implements ZombiePoolInterface.

Definition at line 739 of file Ksolve.cpp.

References pools_.

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

void Ksolve::print

(

)

const

Definition at line 823 of file Ksolve.cpp.

References ZombiePoolInterface::compartment_, dsolve_, Stoich::getKsolve(), method_, Id::path(), pools_, ZombiePoolInterface::stoich_, and stoichPtr_.

{
    cout << "path = " << stoichPtr_->getKsolve().path() <<
         ", numPools = " << pools_.size() << "\n";
    for ( unsigned int i = 0; i < pools_.size(); ++i )
    {
        cout << "pools[" << i << "] contents = ";
        pools_[i].print();
    }
    cout << "method = " << method_ << ", stoich=" << stoich_.path() <<endl;
    cout << "dsolve = " << dsolve_.path() << endl;
    cout << "compartment = " << compartment_.path() << endl;
}

Here is the call graph for this function:

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

Definition at line 497 of file Ksolve.cpp.

References advance(), dsolvePtr_, ProcInfo::dt, ZombiePoolInterface::getBlock(), getBlock(), getNumLocalVoxels(), Stoich::getNumVarPools(), ZombiePoolInterface::isBuilt_, pools_, ZombiePoolInterface::setBlock(), setBlock(), ZombiePoolInterface::setPrev(), stoichPtr_, and ZombiePoolInterface::updateJunctions().

Referenced by initCinfo().

{
    if ( isBuilt_ == false )
        return;

    // First, handle incoming diffusion values, update S with those.
    if ( dsolvePtr_ )
    {
        vector< double > dvalues( 4 );
        dvalues[0] = 0;
        dvalues[1] = getNumLocalVoxels();
        dvalues[2] = 0;
        dvalues[3] = stoichPtr_->getNumVarPools();

        dsolvePtr_->getBlock( dvalues );
        // Second, set the prev_ value in DiffPoolVec
        dsolvePtr_->setPrev();
        setBlock( dvalues );
    }

    size_t nvPools = pools_.size( );

#ifdef PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
    // Third, do the numerical integration for all reactions.
    size_t grainSize = min( nvPools, 1 + (nvPools / numThreads_ ) );
    size_t nWorkers = nvPools / grainSize;

    if( 1 == nWorkers || 1 == nvPools )
    {
        if( numThreads_ > 1 )
        {
#ifndef NDEBUG
            cout << "Debug: Reset to 1 threads " << endl;
#endif
            numThreads_ = 1;
        }

        for ( size_t i = 0; i < nvPools; i++ )
            pools_[i].advance( p );
    }
    else
    {
        /*-----------------------------------------------------------------------------
         *  Somewhat complicated computation to compute the number of threads. 1
         *  thread per (at least) voxel pool is ideal situation.
         *-----------------------------------------------------------------------------*/
        //cout << "Grain size " << grainSize <<  " Workers : " << nWorkers << endl;
        for (size_t i = 0; i < nWorkers; i++)
            parallel_advance( i * grainSize, (i+1) * grainSize, nWorkers, p );
    }
#else
    for ( size_t i = 0; i < nvPools; i++ )
        pools_[i].advance( p );
#endif


    // 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 is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 600 of file Ksolve.cpp.

References ProcInfo::dt, ZombiePoolInterface::isBuilt_, pools_, and stoichPtr_.

Referenced by initCinfo(), and initReinit().

{
    if ( !stoichPtr_ )
        return;

    if ( isBuilt_ )
    {
        for ( unsigned int i = 0 ; i < pools_.size(); ++i )
            pools_[i].reinit( p->dt );
    }
    else
    {
        cout << "Warning:Ksolve::reinit: Reaction system not initialized\n";
        return;
    }

#if PARALLELIZE_KSOLVE_WITH_CPP11_ASYNC
    if( 1 < getNumThreads( ) )
        cout << "Debug: User wants Ksolve with " << numThreads_ << " threads" << endl;
#endif

}

Here is the caller graph for this function:

void Ksolve::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 776 of file Ksolve.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() );
    assert( values.size() == 4 + numVoxels * numPools );

    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 Ksolve::setDiffConst ( const Eref &  e, double  val  )

virtual

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

Implements ZombiePoolInterface.

Definition at line 713 of file Ksolve.cpp.

{
    ; // Do nothing.
}

void Ksolve::setDsolve ( Id  dsolve )

virtual

Assigns the diffusion solver. Used by the reac solvers.

Implements ZombiePoolInterface.

Definition at line 406 of file Ksolve.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: Ksolve::setDsolve: Object '" << dsolve.path() <<
             "' should be class Dsolve, is: " <<
             dsolve.element()->cinfo()->name() << endl;
    }
}

Here is the call graph for this function:

void Ksolve::setEpsAbs

(

double

val

)

Definition at line 279 of file Ksolve.cpp.

References epsAbs_.

Referenced by initCinfo().

{
    if ( epsAbs < 0 )
        epsAbs_ = 1.0e-4;
    else
        epsAbs_ = epsAbs;
}

Here is the caller graph for this function:

void Ksolve::setEpsRel

(

double

val

)

Definition at line 293 of file Ksolve.cpp.

References epsRel_.

Referenced by initCinfo().

{
    if ( epsRel < 0 )
    {
        epsRel_ = 1.0e-6;
    }
    else
    {
        epsRel_ = epsRel;
    }
}

Here is the caller graph for this function:

void Ksolve::setMethod

(

string

method

)

Definition at line 250 of file Ksolve.cpp.

References method_.

Referenced by initCinfo().

{
#if USE_GSL
    if ( method == "rk5" || method == "gsl" )
    {
        method_ = "rk5";
    }
    else if ( method == "rk4"  || method == "rk2" ||
              method == "rk8" || method == "rkck" )
    {
        method_ = method;
    }
    else
    {
        cout << "Warning: Ksolve::setMethod: '" << method <<
             "' not known, using rk5\n";
        method_ = "rk5";
    }
#elif USE_BOOST_ODE
    // TODO: Check for boost related methods.
    method_ = method;
#endif
}

Here is the caller graph for this function:

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

virtual

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

Implements ZombiePoolInterface.

Definition at line 683 of file Ksolve.cpp.

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

{
    unsigned int vox = getVoxelIndex( e );
    if ( vox != OFFNODE )
        pools_[vox].setN( getPoolIndex( e ), v );
}

Here is the call graph for this function:

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

virtual

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

Implements ZombiePoolInterface.

Definition at line 698 of file Ksolve.cpp.

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

{
    unsigned int vox = getVoxelIndex( e );
    if ( vox != OFFNODE )
        pools_[vox].setNinit( getPoolIndex( e ), v );
}

Here is the call graph for this function:

void Ksolve::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 438 of file Ksolve.cpp.

References pools_.

Referenced by initCinfo().

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

Here is the caller graph for this function:

void Ksolve::setNumPools ( unsigned int  num )

virtual

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

Implements ZombiePoolInterface.

Definition at line 723 of file Ksolve.cpp.

References pools_.

Referenced by initCinfo().

{
    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 Ksolve::setNvec	(	unsigned int	voxel,
		vector< double >	vec
	)

Definition at line 457 of file Ksolve.cpp.

References pools_.

Referenced by initCinfo().

{
    if ( voxel < pools_.size() )
    {
        if ( nVec.size() != pools_[voxel].size() )
        {
            cout << "Warning: Ksolve::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] = nVec[i];
    }
}

Here is the caller graph for this function:

void Ksolve::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 353 of file Ksolve.cpp.

References Element::cinfo(), Eref::data(), Id::element(), OdeSystem::epsAbs, epsAbs_, OdeSystem::epsRel, epsRel_, Id::eref(), Stoich::getNumAllPools(), OdeSystem::initStepSize, Cinfo::isA(), ZombiePoolInterface::isBuilt_, OdeSystem::method, method_, pools_, ZombiePoolInterface::stoich_, and stoichPtr_.

{
    assert( stoich.element()->cinfo()->isA( "Stoich" ) );
    stoich_ = stoich;
    stoichPtr_ = reinterpret_cast< Stoich* >( stoich.eref().data() );
    if ( !isBuilt_ )
    {
        OdeSystem ode;
        ode.epsAbs = epsAbs_;
        ode.epsRel = epsRel_;
        // ode.initStepSize = getEstimatedDt();
        ode.initStepSize = 0.01; // This will be overridden at reinit.
        ode.method = method_;
#ifdef USE_GSL
        ode.gslSys.dimension = stoichPtr_->getNumAllPools();
        if ( ode.gslSys.dimension == 0 ) {
            stoichPtr_ = 0;
            return; // No pools, so don't bother.
        }
        innerSetMethod( ode, method_ );
        ode.gslSys.function = &VoxelPools::gslFunc;
        ode.gslSys.jacobian = 0;
        innerSetMethod( ode, method_ );
        unsigned int numVoxels = pools_.size();
        for ( unsigned int i = 0 ; i < numVoxels; ++i )
        {
            ode.gslSys.params = &pools_[i];
            pools_[i].setStoich( stoichPtr_, &ode );
            // pools_[i].setIntDt( ode.initStepSize ); // We're setting it up anyway
        }
#elif USE_BOOST_ODE
        ode.dimension = stoichPtr_->getNumAllPools();
        ode.boostSys.epsAbs = epsAbs_;
        ode.boostSys.epsRel = epsRel_;
        ode.boostSys.method = method_;
        if ( ode.dimension == 0 )
            return; // No pools, so don't bother.
        unsigned int numVoxels = pools_.size();
        for ( unsigned int i = 0 ; i < numVoxels; ++i )
        {
            ode.boostSys.params = &pools_[i];
            pools_[i].setStoich( stoichPtr_, &ode );
        }
#endif
        isBuilt_ = true;
    }
}

Here is the call graph for this function:

void Ksolve::updateRateTerms ( unsigned int  index )

virtual

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

updateRateTerms obtains the latest parameters for the rates_ vector, and has each of the pools update its parameters including rescaling for volumes.

Implements ZombiePoolInterface.

Definition at line 641 of file Ksolve.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].resetXreacScale( numCrossRates );
            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 Ksolve::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 800 of file Ksolve.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 Ksolve::volume ( unsigned int  i ) const

virtual

Return volume of voxel i.

Implements ZombiePoolInterface.

Definition at line 746 of file Ksolve.cpp.

References pools_.

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

Member Data Documentation

Id Ksolve::dsolve_

private

Id of diffusion solver, needed for coordinating numerics.

Definition at line 167 of file Ksolve.h.

Referenced by getDsolve(), print(), and setDsolve().

ZombiePoolInterface* Ksolve::dsolvePtr_

private

Pointer to diffusion solver.

Definition at line 170 of file Ksolve.h.

Referenced by process(), and setDsolve().

double Ksolve::epsAbs_

private

Definition at line 139 of file Ksolve.h.

Referenced by getEpsAbs(), setEpsAbs(), and setStoich().

double Ksolve::epsRel_

private

Definition at line 140 of file Ksolve.h.

Referenced by getEpsRel(), setEpsRel(), and setStoich().

string Ksolve::method_

private

Definition at line 138 of file Ksolve.h.

Referenced by getMethod(), print(), setMethod(), and setStoich().

vector< VoxelPools > Ksolve::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 156 of file Ksolve.h.

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

unsigned int Ksolve::startVoxel_

private

First voxel indexed on the current node.

Definition at line 159 of file Ksolve.h.

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

Stoich* Ksolve::stoichPtr_

private

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

Definition at line 162 of file Ksolve.h.

Referenced by getEstimatedDt(), getPoolIndex(), print(), process(), reinit(), setStoich(), and updateRateTerms().

---

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

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