#include <ZombiePool.h>

Inheritance diagram for ZombiePool:

Collaboration diagram for ZombiePool:

Public Member Functions
double	vGetConc (const Eref &e) const

double	vGetConcInit (const Eref &e) const

double	vGetDiffConst (const Eref &e) const

bool	vGetIsBuffered (const Eref &e) const

double	vGetMotorConst (const Eref &e) const

double	vGetN (const Eref &e) const

double	vGetNinit (const Eref &e) const

unsigned int	vGetSpecies (const Eref &e) const

double	vGetVolume (const Eref &e) const

void	vSetConc (const Eref &e, double v)

void	vSetConcInit (const Eref &e, double v)

void	vSetDiffConst (const Eref &e, double v)

void	vSetMotorConst (const Eref &e, double v)
	Dummy MotorConst field for most Pool subclasses. More...

void	vSetN (const Eref &e, double v)

void	vSetNinit (const Eref &e, double v)

void	vSetSolver (Id ksolve, Id dsolve)

void	vSetSpecies (const Eref &e, unsigned int v)

void	vSetVolume (const Eref &e, double v)

	ZombiePool ()

	~ZombiePool ()

Public Member Functions inherited from PoolBase
void	decrement (double val)

double	getConc (const Eref &e) const

double	getConcInit (const Eref &e) const

double	getDiffConst (const Eref &e) const

bool	getIsBuffered (const Eref &e) const

double	getMotorConst (const Eref &e) const

double	getN (const Eref &e) const

double	getNinit (const Eref &e) const

SpeciesId	getSpecies (const Eref &e) const

double	getVolume (const Eref &e) const

void	handleMolWt (const Eref &e, double v)

void	increment (double val)

void	nIn (double val)

	PoolBase ()

void	process (const Eref &e, ProcPtr p)

void	reac (double A, double B)

void	reinit (const Eref &e, ProcPtr p)

void	setConc (const Eref &e, double v)

void	setConcInit (const Eref &e, double v)

void	setDiffConst (const Eref &e, double v)

void	setIsBuffered (const Eref &e, bool v)

void	setMotorConst (const Eref &e, double v)

void	setN (const Eref &e, double v)

void	setNinit (const Eref &e, double v)

void	setSpecies (const Eref &e, SpeciesId v)

void	setVolume (const Eref &e, double v)

virtual void	vDecrement (double val)

virtual void	vHandleMolWt (const Eref &e, double v)

virtual void	vIncrement (double val)

virtual void	vnIn (double val)

virtual void	vProcess (const Eref &e, ProcPtr p)

virtual void	vReac (double A, double B)

virtual void	vReinit (const Eref &e, ProcPtr p)

virtual void	vSetIsBuffered (const Eref &e, bool v)
	I put in a default empty function for vSetIsBuffered. More...

virtual	~PoolBase ()

Static Public Member Functions
static const Cinfo *	initCinfo ()

Static Public Member Functions inherited from PoolBase
static const Cinfo *	initCinfo ()

static void	zombify (Element original, const Cinfo zClass, Id ksolve, Id dsolve)

Protected Attributes
double	diffConst_

ZombiePoolInterface *	dsolve_

ZombiePoolInterface *	ksolve_

double	motorConst_

Detailed Description

This class is used by the Dsolve and Ksolve to take over from regular pools. Possibly other solver classes will eventually use it too.

Definition at line 17 of file ZombiePool.h.

Constructor & Destructor Documentation

ZombiePool::ZombiePool ( )

Definition at line 61 of file ZombiePool.cpp.

62 : dsolve_( 0 ), ksolve_( 0 ), diffConst_( 1e-12 ), motorConst_( 0.0 )

63 {;}

ZombiePool::motorConst_

double motorConst_

Definition: ZombiePool.h:73

ZombiePool::dsolve_

ZombiePoolInterface * dsolve_

Definition: ZombiePool.h:70

ZombiePool::ksolve_

ZombiePoolInterface * ksolve_

Definition: ZombiePool.h:71

ZombiePool::diffConst_

double diffConst_

Definition: ZombiePool.h:72

ZombiePool::~ZombiePool ( )

Definition at line 65 of file ZombiePool.cpp.

66 {;}

Member Function Documentation

const Cinfo * ZombiePool::initCinfo ( )

static

Definition at line 21 of file ZombiePool.cpp.

References PoolBase::initCinfo(), and zombiePoolCinfo.

Referenced by ZombieBufPool::initCinfo(), and Dsolve::setPath().

 {
         // Field Definitions: All inherited from PoolBase
         // MsgDest Definitions: All inherited from PoolBase
         // SrcFinfo Definitions: All inherited from PoolBase
         // SharedMsg Definitions: All inherited from PoolBase
 
     // Note that here the isOneZombie_ flag on the Dinfo constructor is
     // true. This means that the duplicate and copy operations only make
     // one copy, regardless of how big the array of zombie pools.
     // The assumption is that each Id has a single pool, which can be
     // present in many voxels.
     static Dinfo< ZombiePool > dinfo( true );
     static Cinfo zombiePoolCinfo (
         "ZombiePool",
         PoolBase::initCinfo(),
         0,
         0,
         &dinfo
     );
 
     return &zombiePoolCinfo;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double ZombiePool::vGetConc ( const Eref & e ) const

virtual

Implements PoolBase.

Definition at line 118 of file ZombiePool.cpp.

References lookupVolumeFromMesh(), NA, and vGetN().

 {
     return vGetN( e ) / ( NA * lookupVolumeFromMesh( e ) );
 }

Here is the call graph for this function:

double ZombiePool::vGetConcInit ( const Eref & e ) const

virtual

Reimplemented from PoolBase.

Definition at line 133 of file ZombiePool.cpp.

References lookupVolumeFromMesh(), NA, and vGetNinit().

 {
     return vGetNinit( e ) / (NA * lookupVolumeFromMesh( e ) );
 }

Here is the call graph for this function:

double ZombiePool::vGetDiffConst ( const Eref & e ) const

virtual

Implements PoolBase.

Definition at line 145 of file ZombiePool.cpp.

References diffConst_.

 {
     return diffConst_;
 }

bool ZombiePool::vGetIsBuffered ( const Eref & e ) const

virtual

Implements PoolBase.

Definition at line 182 of file ZombiePool.cpp.

 {
     return false;
 }

double ZombiePool::vGetMotorConst ( const Eref & e ) const

virtual

Reimplemented from PoolBase.

Definition at line 150 of file ZombiePool.cpp.

References motorConst_.

 {
     return motorConst_;
 }

double ZombiePool::vGetN ( const Eref & e ) const

virtual

Implements PoolBase.

Definition at line 85 of file ZombiePool.cpp.

References dsolve_, ZombiePoolInterface::getN(), and ksolve_.

Referenced by vGetConc().

 {
     if ( ksolve_ != 0 )
         return ksolve_->getN( e );
     else if ( dsolve_ != 0 )
         return dsolve_->getN( e );
     return 0.0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double ZombiePool::vGetNinit ( const Eref & e ) const

virtual

Implements PoolBase.

Definition at line 102 of file ZombiePool.cpp.

References dsolve_, ZombiePoolInterface::getNinit(), and ksolve_.

Referenced by vGetConcInit().

 {
     if ( ksolve_ != 0 )
         return ksolve_->getNinit( e );
     else if ( dsolve_ != 0 )
         return dsolve_->getNinit( e );
     return 0.0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned int ZombiePool::vGetSpecies ( const Eref & e ) const

virtual

Implements PoolBase.

Definition at line 167 of file ZombiePool.cpp.

 {
     return 0;
 }

double ZombiePool::vGetVolume ( const Eref & e ) const

virtual

Implements PoolBase.

Definition at line 177 of file ZombiePool.cpp.

References lookupVolumeFromMesh().

 {
     return lookupVolumeFromMesh( e );
 }

Here is the call graph for this function:

void ZombiePool::vSetConc	(	const Eref &	e,
		double	v
	)

virtual

Implements PoolBase.

Definition at line 111 of file ZombiePool.cpp.

References lookupVolumeFromMesh(), NA, and vSetN().

 {
     // unsigned int pool = convertIdToPoolIndex( e.id() );
     double n = NA * conc * lookupVolumeFromMesh( e );
     vSetN( e, n );
 }

Here is the call graph for this function:

void ZombiePool::vSetConcInit	(	const Eref &	e,
		double	v
	)

virtual

Implements PoolBase.

Definition at line 123 of file ZombiePool.cpp.

References lookupVolumeFromMesh(), NA, and vSetNinit().

 {
     double n = NA * conc * lookupVolumeFromMesh( e );
     vSetNinit( e, n );
 }

Here is the call graph for this function:

void ZombiePool::vSetDiffConst	(	const Eref &	e,
		double	v
	)

virtual

Implements PoolBase.

Definition at line 138 of file ZombiePool.cpp.

References diffConst_, dsolve_, and ZombiePoolInterface::setDiffConst().

 {
     diffConst_ = v;
     if ( dsolve_ )
         dsolve_->setDiffConst( e, v );
 }

Here is the call graph for this function:

void ZombiePool::vSetMotorConst	(	const Eref &	e,
		double	v
	)

virtual

Dummy MotorConst field for most Pool subclasses.

Reimplemented from PoolBase.

Definition at line 155 of file ZombiePool.cpp.

References dsolve_, motorConst_, and ZombiePoolInterface::setMotorConst().

 {
     motorConst_ = v;
     if ( dsolve_ )
         dsolve_->setMotorConst( e, v );
 }

Here is the call graph for this function:

void ZombiePool::vSetN	(	const Eref &	e,
		double	v
	)

virtual

Implements PoolBase.

Definition at line 76 of file ZombiePool.cpp.

References dsolve_, ksolve_, and ZombiePoolInterface::setN().

Referenced by vSetConc(), and ZombieBufPool::vSetN().

 {
     if ( ksolve_ )
         ksolve_->setN( e, v );
     if ( dsolve_ )
         dsolve_->setN( e, v );
     // S_[ e.index().value() ][ convertIdToPoolIndex( e.id() ) ] = v;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ZombiePool::vSetNinit	(	const Eref &	e,
		double	v
	)

virtual

Implements PoolBase.

Definition at line 94 of file ZombiePool.cpp.

References dsolve_, ksolve_, and ZombiePoolInterface::setNinit().

Referenced by vSetConcInit(), and ZombieBufPool::vSetN().

 {
     if ( ksolve_ )
         ksolve_->setNinit( e, v );
     if ( dsolve_ )
         dsolve_->setNinit( e, v );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ZombiePool::vSetSolver	(	Id	ksolve,
		Id	dsolve
	)

virtual

Assign whatever info is needed by the zombie based on the solver Element. Encapsulates some unpleasant field extraction, casting, and assignment. Default version of this function does nothing.

Reimplemented from PoolBase.

Definition at line 191 of file ZombiePool.cpp.

References Element::cinfo(), ObjId::data(), dsolve_, Id::element(), Cinfo::isA(), ksolve_, and Cinfo::name().

 {
     // Nasty unsafe typecast. I would have preferred to pass in a
     // safely typed pointer but that would have exposed a low-level
     // class for the ZombiePoolInterface.
     if ( ksolve.element()->cinfo()->isA( "Ksolve" ) ||
                     ksolve.element()->cinfo()->isA( "Gsolve" ) ) {
             ksolve_= reinterpret_cast< ZombiePoolInterface *>(
                     ObjId( ksolve, 0 ).data() );
     } else if ( ksolve == Id() ) {
             ksolve_ = 0;
     } else {
             cout << "Warning:ZombiePool::vSetSolver: solver class " <<
                     ksolve.element()->cinfo()->name() <<
                     " not known.\nShould be Ksolve or Gsolve\n";
             ksolve_ = 0;
     }
 
     if ( dsolve.element()->cinfo()->isA( "Dsolve" ) ) {
             dsolve_= reinterpret_cast< ZombiePoolInterface *>(
                     ObjId( dsolve, 0 ).data() );
     } else if ( dsolve == Id() ) {
             dsolve_ = 0;
     } else {
             cout << "Warning:ZombiePool::vSetSolver: solver class " <<
                     dsolve.element()->cinfo()->name() <<
                     " not known.\nShould be Dsolve\n";
             dsolve_ = 0;
     }
 }

Here is the call graph for this function:

void ZombiePool::vSetSpecies	(	const Eref &	e,
		unsigned int	v
	)

virtual

Implements PoolBase.

Definition at line 162 of file ZombiePool.cpp.

 {
     ;
 }

void ZombiePool::vSetVolume	(	const Eref &	e,
		double	v
	)

virtual

Implements PoolBase.

Definition at line 172 of file ZombiePool.cpp.

 {
     assert( 0 ); // Illegal op, but should handle more gracefully.
 }

Member Data Documentation

double ZombiePool::diffConst_

protected

Definition at line 72 of file ZombiePool.h.

Referenced by vGetDiffConst(), and vSetDiffConst().

ZombiePoolInterface* ZombiePool::dsolve_

protected

The ZombiePoolInterface pointers hold the solvers for the ZombiePool. At least one must be assigned. Field assignments propagate from the pool to whichever is assigned. Field lookups first check the dsolve, then the ksolve. The ZombiePool may be managed by the diffusion solver without the involvement of the Stoich class at all. So instead of routing the zombie operations through the Stoich, we have pointers directly into the Dsolve and Ksolve.

Definition at line 70 of file ZombiePool.h.

Referenced by vGetN(), vGetNinit(), vSetDiffConst(), vSetMotorConst(), vSetN(), vSetNinit(), and vSetSolver().

ZombiePoolInterface* ZombiePool::ksolve_

protected

Definition at line 71 of file ZombiePool.h.

Referenced by vGetN(), vGetNinit(), vSetN(), vSetNinit(), and vSetSolver().

double ZombiePool::motorConst_

protected

Definition at line 73 of file ZombiePool.h.

Referenced by vGetMotorConst(), and vSetMotorConst().

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

moose-core/ksolve/ZombiePool.h
moose-core/ksolve/ZombiePool.cpp

Public Member Functions

Static Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation