#include <Dsolve.h>

Inheritance diagram for Dsolve:

Collaboration diagram for Dsolve:

Public Member Functions
void	build (double dt)

void	buildMeshJunctions (const Eref &e, Id other)

void	buildNeuroMeshJunctions (const Eref &e, Id spineD, Id psdD)

void	calcJnChan (const DiffJunction &jn, Dsolve *other, double dt)

void	calcJnDiff (const DiffJunction &jn, Dsolve *other, double dt)

void	calcJnXfer (const DiffJunction &jn, const vector< unsigned int > &srcXfer, const vector< unsigned int > &destXfer, Dsolve srcDsolve, Dsolve destDsolve)

void	calcJunction (const DiffJunction &jn, double dt)

void	calcOtherJnChan (const DiffJunction &jn, Dsolve *other, double dt)

unsigned int	convertIdToPoolIndex (Id id) const

unsigned int	convertIdToPoolIndex (const Eref &e) const

	Dsolve ()

void	fillConcChans (const vector< ObjId > &chans)

void	filterCrossRateTerms (const vector< pair< Id, Id > > &xrt)

void	getBlock (vector< double > &values) const

double	getDiffConst (const Eref &e) const
	Diffusion constant: Only one per pool, voxel number is ignored. More...

double	getDiffScale (unsigned int voxel) const

double	getDiffVol1 (unsigned int voxel) const
	LookupFied for examining cross-solver diffusion terms. More...

double	getDiffVol2 (unsigned int voxel) const

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	getNumLocalVoxels () const
	Number of voxels here. pools_.size() == getNumLocalVoxels. More...

unsigned int	getNumPools () const
	gets number of pools (species) handled by system. More...

unsigned int	getNumVarPools () const

unsigned int	getNumVoxels () const

vector< double >	getNvec (unsigned int pool) const

string	getPath (const Eref &e) const

unsigned int	getPoolIndex (const Eref &e) const
	Return pool index, using Stoich ptr to do lookup. More...

Id	getStoich () const

void	makePoolMapFromElist (const vector< ObjId > &elist, vector< Id > &temp)

VoxelPoolsBase *	pools (unsigned int i)
	Return a pointer to the specified VoxelPool. More...

void	print () const

void	process (const Eref &e, ProcPtr p)

void	rebuildPools ()

void	reinit (const Eref &e, ProcPtr p)

void	setBlock (const vector< double > &values)

void	setCompartment (Id id)
	Assigns compartment. More...

void	setDiffConst (const Eref &e, double value)
	Diffusion constant: Only one per pool, voxel number is ignored. More...

void	setDiffScale (unsigned int voxel, double scale)

void	setDiffVol1 (unsigned int voxel, double vol)

void	setDiffVol2 (unsigned int voxel, double vol)

void	setDsolve (Id id)
	Inherited, defining dummy function here. More...

void	setMotorConst (const Eref &e, double value)

void	setN (const Eref &e, double value)
	Set # of molecules in given pool and voxel. Varies with time. More...

void	setNinit (const Eref &e, double value)
	Set initial # of molecules in given pool and voxel. Bdry cond. More...

void	setNumAllVoxels (unsigned int numVoxels)
	Inherited virtual. More...

void	setNumPools (unsigned int num)
	Specifies number of pools (species) handled by system. More...

void	setNvec (unsigned int pool, vector< double > vec)

void	setPath (const Eref &e, string path)
	Dummy, inherited but not used. More...

void	setPrev ()
	Used to tell Dsolver to assign 'prev' values. More...

void	setStoich (Id id)

void	setupCrossSolverReacs (const map< Id, vector< Id > > &xr, Id otherStoich)

void	setupCrossSolverReacVols (const vector< vector< Id > > &subCompts, const vector< vector< Id > > &prdCompts)

void	updateJunctions (double dt)
	Used for telling Dsolver to handle all ops across Junctions. More...

void	updateRateTerms (unsigned int index)

double	volume (unsigned int i) const
	Return volume of voxel i. More...

	~Dsolve ()

Public Member Functions inherited from ZombiePoolInterface
Id	getCompartment () const

	ZombiePoolInterface ()

Static Public Member Functions
static const Cinfo *	initCinfo ()

static void	innerBuildMeshJunctions (Id self, Id other, bool isMembraneBound)

static void	mapChansBetweenDsolves (DiffJunction &jn, Id self, Id other)

static void	mapDiffPoolsBetweenDsolves (DiffJunction &jn, Id self, Id other)
	Sets up map of matching pools for diffusion. More...

static void	mapXfersBetweenDsolves (vector< unsigned int > &srcPools, vector< unsigned int > &destPools, Id src, Id dest)

Private Attributes
vector< ConcChanInfo >	channels_
	Internal vector, one for each ConcChan managed by Dsolve. More...

double	dt_
	Timestep used by diffusion calculations. More...

vector< DiffJunction >	junctions_

unsigned int	numLocalPools_

unsigned int	numTotPools_

unsigned int	numVoxels_

string	path_
	Path of pools managed by Dsolve, may include other classes too. More...

vector< unsigned int >	poolMap_
	Looks up pool# from pool Id, using poolMapStart_ as offset. More...

unsigned int	poolMapStart_
	smallest Id value for poolMap_ More...

vector< DiffPoolVec >	pools_
	Internal vector, one for each pool species managed by Dsolve. More...

unsigned int	poolStartIndex_

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

The Dsolve manages a large number of pools, each inhabiting a large number of voxels that are shared for all the pools. Each pool is represented by an array of concs, one for each voxel. Each such array is kept on a single node for efficient solution. The different pool arrays are assigned to different nodes for balance. All pool arrays We have the parent Dsolve as a global. It constructs the diffusion matrix from the NeuroMesh and generates the opvecs. We have the child DiffPoolVec as a local. Each one contains a vector of pool 'n' in each voxel, plus the opvec for that pool. There is an array of DiffPoolVecs, one for each species, and we let the system put each DiffPoolVec on a suitable node for balancing. Some DiffPoolVecs are for molecules that don't diffuse. These simply have an empty opvec.

Definition at line 29 of file Dsolve.h.

Constructor & Destructor Documentation

Dsolve::Dsolve ( )

Definition at line 188 of file Dsolve.cpp.

Referenced by initCinfo().

     :
         dt_( -1.0 ),
         numTotPools_( 0 ),
         numLocalPools_( 0 ),
         poolStartIndex_( 0 ),
         numVoxels_( 0 )
 {;}

Here is the caller graph for this function:

Dsolve::~Dsolve ( )

Definition at line 197 of file Dsolve.cpp.

198 {;}

Member Function Documentation

void Dsolve::build ( double dt )

This key function does the work of setting up the Dsolve. Should be called after the compartment has been attached to the Dsolve, and the stoich is assigned. Called during the setStoich function.

build: This function is called either by setStoich or setPath. By this point the diffusion consts etc will be assigned to the poolVecs. This requires

Stoich should be assigned, OR
A 'path' should be assigned which has been traversed to find pools.
compartment should be assigned so we know how many voxels.
If Stoich, its 'path' should be set so we know numPools. It needs to know the numVoxels from the compartment. At the time of path setting the zombification is done, which takes the Id of the solver.
After this build can be done. Just reinit doesn't make sense since the build does a lot of things which should not be repeated for each reinit.

Definition at line 723 of file Dsolve.cpp.

References FastMatrixElim::buildBackwardSub(), FastMatrixElim::buildForDiffusion(), FastMatrixElim::buildForwardElim(), FastMatrixElim::checkSymmetricShape(), ZombiePoolInterface::compartment_, Eref::data(), doubleEq(), dt_, Id::eref(), ChemCompt::getNumEntries(), MeshCompt::getParentVoxel(), MeshCompt::getVoxelArea(), MeshCompt::getVoxelLength(), ChemCompt::getVoxelVolume(), FastMatrixElim::hinesReorder(), numLocalPools_, numVoxels_, FastMatrixElim::opsReorder(), pools_, and SparseMatrix< T >::print().

Referenced by reinit().

 {
     if ( doubleEq( dt, dt_ ) )
         return;
     if ( compartment_ == Id() ) {
         cout << "Dsolve::build: Warning: No compartment defined. \n"
                 "Did you forget to assign 'stoich.dsolve = this' ?\n";
         return;
     }
     dt_ = dt;
     const MeshCompt* m = reinterpret_cast< const MeshCompt* >(
                         compartment_.eref().data() );
     unsigned int numVoxels = m->getNumEntries();
 
     for ( unsigned int i = 0; i < numLocalPools_; ++i ) {
         bool debugFlag = false;
         vector< unsigned int > diagIndex;
         vector< double > diagVal;
         vector< Triplet< double > > fops;
         FastMatrixElim elim( numVoxels, numVoxels );
         if ( elim.buildForDiffusion(
             m->getParentVoxel(), m->getVoxelVolume(),
             m->getVoxelArea(), m->getVoxelLength(),
             pools_[i].getDiffConst(), pools_[i].getMotorConst(), dt ) )
         {
             vector< unsigned int > parentVoxel = m->getParentVoxel();
             assert( elim.checkSymmetricShape() );
             vector< unsigned int > lookupOldRowsFromNew;
             elim.hinesReorder( parentVoxel, lookupOldRowsFromNew );
             assert( elim.checkSymmetricShape() );
             pools_[i].setNumVoxels( numVoxels_ );
             elim.buildForwardElim( diagIndex, fops );
             elim.buildBackwardSub( diagIndex, fops, diagVal );
             elim.opsReorder( lookupOldRowsFromNew, fops, diagVal );
             if (debugFlag )
                 elim.print();
         }
         pools_[i].setOps( fops, diagVal );
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::buildMeshJunctions	(	const Eref &	e,
		Id	other
	)

Builds junctions between current Dsolve and another. For this to work the respective meshes must be compatible. These junctions handle diffusion between different meshes.

Definition at line 792 of file Dsolve.cpp.

References Element::cinfo(), ZombiePoolInterface::compartment_, Id::element(), Field< A >::get(), Eref::id(), innerBuildMeshJunctions(), Cinfo::isA(), and Id::path().

Referenced by initCinfo().

 {
     Id otherMesh;
     if ( other.element()->cinfo()->isA( "Dsolve" ) ) {
         otherMesh = Field< Id >::get( other, "compartment" );
         if ( compartment_.element()->cinfo()->isA( "ChemCompt" ) &&
             otherMesh.element()->cinfo()->isA( "ChemCompt" ) ) {
                 bool isMembraneBound = 
                     Field< bool >::get( compartment_, "isMembraneBound" );
                 innerBuildMeshJunctions( e.id(), other, isMembraneBound );
                 return;
         }
     }
     cout << "Warning: Dsolve::buildMeshJunctions: one of '" <<
         compartment_.path() << ", " << otherMesh.path() <<
         "' is not a Mesh\n";
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::buildNeuroMeshJunctions	(	const Eref &	e,
		Id	spineD,
		Id	psdD
	)

Builds junctions between Dsolves handling NeuroMesh, SpineMesh, and PsdMesh. Must only be called from the one handling the NeuroMesh. These junctions handle diffusion between different meshes. Note that a single NeuroMesh may contact many spines which are all in a single SpineMesh. Likewise each spine has a single PSD, but there are many spines in the SpineMesh and matching psds in the PsdMesh. Finally, note that there may be many molecules which diffuse across each diffusion junction.

Should be called only from the Dsolve handling the NeuroMesh.

Definition at line 768 of file Dsolve.cpp.

References Element::cinfo(), ZombiePoolInterface::compartment_, Id::element(), Field< A >::get(), Eref::id(), innerBuildMeshJunctions(), Cinfo::isA(), and Id::path().

Referenced by initCinfo().

 {
     if ( !compartment_.element()->cinfo()->isA( "NeuroMesh" ) ) {
         cout << "Warning: Dsolve::buildNeuroMeshJunction: Compartment '" <<
                 compartment_.path() << "' is not a NeuroMesh\n";
         return;
     }
     Id spineMesh = Field< Id >::get( spineD, "compartment" );
     if ( !spineMesh.element()->cinfo()->isA( "SpineMesh" ) ) {
         cout << "Warning: Dsolve::buildNeuroMeshJunction: Compartment '" <<
                 spineMesh.path() << "' is not a SpineMesh\n";
         return;
     }
     Id psdMesh = Field< Id >::get( psdD, "compartment" );
     if ( !psdMesh.element()->cinfo()->isA( "PsdMesh" ) ) {
         cout << "Warning: Dsolve::buildNeuroMeshJunction: Compartment '" <<
                 psdMesh.path() << "' is not a PsdMesh\n";
         return;
     }
 
     innerBuildMeshJunctions( spineD, e.id(), false );
     innerBuildMeshJunctions( psdD, spineD, false );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::calcJnChan	(	const DiffJunction &	jn,
		Dsolve *	other,
		double	dt
	)

Definition at line 373 of file Dsolve.cpp.

References channels_, ConcChanInfo::chanPool, DiffPoolVec::getN(), integ(), DiffJunction::myChannels, ConcChanInfo::myPool, NA, ConcChanInfo::otherPool, ConcChanInfo::permeability, pools_, DiffPoolVec::setN(), and DiffJunction::vj.

Referenced by calcJunction().

 {
     // Each jn has some channels
     // Each channel has a chanPool, an intPool and an extPool.
     // chanPool and intPool must be on self, extPool is on other. In
     // cases where the intPool is on other, it attempts to swap the
     // int and ext pools, but this too could fail
     // because the chanPool could be a third compartment, such as the memb
     //
     // Don't have a solution for this case as yet.
     // Other alternative is to have a message to update the N of the chan,
     // so it isn't in the domain of the solver at all except for here.
     // In which case we will want to point to the Moose object for it.
     //
     
     for ( unsigned int i = 0; i < jn.myChannels.size(); ++i ) {
         ConcChanInfo& myChan = channels_[ jn.myChannels[i] ];
         DiffPoolVec& myDv = pools_[ myChan.myPool ];
         DiffPoolVec& otherDv = other->pools_[ myChan.otherPool ];
         DiffPoolVec& chanDv = pools_[ myChan.chanPool ];
         for ( vector< VoxelJunction >::const_iterator
             j = jn.vj.begin(); j != jn.vj.end(); ++j ) {
 
             double myN = myDv.getN( j->first );
             double lastN = myN;
             double otherN = otherDv.getN( j->second );
             double chanN = chanDv.getN( j->first );
             double perm = myChan.permeability * chanN / NA;
             myN = integ( myN, perm * myN/j->firstVol, 
                             perm * otherN/j->secondVol, dt );
             otherN += lastN - myN;  // Mass consv
             if ( otherN < 0.0 ) { // Avoid negatives
                 myN += otherN;
                 otherN = 0.0;
             }
             myDv.setN( j->first, myN );
             otherDv.setN( j->second, otherN );
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::calcJnDiff	(	const DiffJunction &	jn,
		Dsolve *	other,
		double	dt
	)

Definition at line 309 of file Dsolve.cpp.

References EPSILON, DiffPoolVec::getDiffConst(), DiffPoolVec::getN(), integ(), DiffJunction::myPools, DiffJunction::otherPools, pools_, DiffPoolVec::setN(), and DiffJunction::vj.

Referenced by calcJunction().

 {
     const double EPSILON = 1e-16;
     assert( jn.otherPools.size() == jn.myPools.size() );
     for ( unsigned int i = 0; i < jn.myPools.size(); ++i ) {
         DiffPoolVec& myDv = pools_[ jn.myPools[i] ];
         if ( myDv.getDiffConst() < EPSILON )
             continue;
         DiffPoolVec& otherDv = other->pools_[ jn.otherPools[i] ];
         if ( otherDv.getDiffConst() < EPSILON )
             continue;
         // This geom mean is used in case we have the odd situation of
         // different diffusion constants.
         double effectiveDiffConst =
             sqrt( myDv.getDiffConst() * otherDv.getDiffConst() );
         for ( vector< VoxelJunction >::const_iterator
             j = jn.vj.begin(); j != jn.vj.end(); ++j ) {
             double myN = myDv.getN( j->first );
             double otherN = otherDv.getN( j->second );
             // Here we do an exp Euler calculation
             // rf is rate from self to other.
             // double k = myDv.getDiffConst() * j->diffScale;
             double k = effectiveDiffConst * j->diffScale;
             double lastN = myN;
             myN = integ( myN,
                 k * myN / j->firstVol,
                 k * otherN / j->secondVol,
                 dt
             );
             otherN += lastN - myN; // Simple mass conservation
             if ( otherN < 0.0 ) { // Avoid negatives
                 myN += otherN;
                 otherN = 0.0;
             }
             myDv.setN( j->first, myN );
             otherDv.setN( j->second, otherN );
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::calcJnXfer	(	const DiffJunction &	jn,
		const vector< unsigned int > &	srcXfer,
		const vector< unsigned int > &	destXfer,
		Dsolve *	srcDsolve,
		Dsolve *	destDsolve
	)

Definition at line 349 of file Dsolve.cpp.

References DiffPoolVec::getN(), DiffPoolVec::getPrev(), pools_, DiffPoolVec::setN(), and DiffJunction::vj.

Referenced by calcJunction().

 {
     assert( destXfer.size() == srcXfer.size() );
     for ( unsigned int i = 0; i < srcXfer.size(); ++i ) {
         DiffPoolVec& srcDv = srcDsolve->pools_[ srcXfer[i] ];
         DiffPoolVec& destDv = destDsolve->pools_[ destXfer[i] ];
         for ( vector< VoxelJunction >::const_iterator
             j = jn.vj.begin(); j != jn.vj.end(); ++j ) {
             double prevSrc = srcDv.getPrev( j->first );
             double prevDest = destDv.getPrev( j->second );
             double srcN = srcDv.getN( j->first );
             double destN = destDv.getN( j->second );
             // Consider delta as sum of local dN, and reference as prevDest
             // newN = (srcN - prevSrc + destN - prevDest)  + prevDest
             double newN = srcN + destN - prevSrc;
             srcDv.setN( j->first, newN );
             destDv.setN( j->second, newN );
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::calcJunction	(	const DiffJunction &	jn,
		double	dt
	)

Computes flux through a junction between diffusion solvers. Most used at junctions on spines and PSDs, but can also be used when a given diff solver is decomposed. At present the lookups on the other diffusion solver assume that the data is on the local node. Once this works well I can figure out how to do across nodes.

Computes flux through a junction between diffusion solvers. Most used at junctions on spines and PSDs, but can also be used when a given diff solver is decomposed. At present the lookups on the other diffusion solver assume that the data is on the local node. Once this works well I can figure out how to do across nodes. Note that we split the diffusion and channel calculations before and after then calcJnXfer calculations. This improves accuracy by 5x.

Definition at line 457 of file Dsolve.cpp.

References calcJnChan(), calcJnDiff(), calcJnXfer(), calcOtherJnChan(), Element::cinfo(), Eref::data(), Id::element(), Id::eref(), Cinfo::isA(), DiffJunction::myXferDest, DiffJunction::myXferSrc, DiffJunction::otherDsolve, DiffJunction::otherXferDest, and DiffJunction::otherXferSrc.

Referenced by updateJunctions().

 {
     Id oid( jn.otherDsolve );
     assert ( oid != Id() );
     assert ( oid.element()->cinfo()->isA( "Dsolve" ) );
 
     Dsolve* other = reinterpret_cast< Dsolve* >( oid.eref().data() );
     calcJnDiff( jn, other, dt/2.0 );
 
     calcJnChan( jn, other, dt/2.0 );
     calcOtherJnChan( jn, other, dt/2.0 );
 
     calcJnXfer( jn, jn.myXferSrc, jn.otherXferDest, this, other );
     calcJnXfer( jn, jn.otherXferSrc, jn.myXferDest, other, this );
 
     calcJnDiff( jn, other, dt/2.0 );
 
     calcJnChan( jn, other, dt/2.0 );
     calcOtherJnChan( jn, other, dt/2.0 );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::calcOtherJnChan	(	const DiffJunction &	jn,
		Dsolve *	other,
		double	dt
	)

Definition at line 415 of file Dsolve.cpp.

References channels_, ConcChanInfo::chanPool, DiffPoolVec::getN(), integ(), ConcChanInfo::myPool, NA, DiffJunction::otherChannels, ConcChanInfo::otherPool, ConcChanInfo::permeability, pools_, DiffPoolVec::setN(), and DiffJunction::vj.

Referenced by calcJunction().

 {
     for ( unsigned int i = 0; i < jn.otherChannels.size(); ++i ) {
         ConcChanInfo& otherChan = other->channels_[ jn.otherChannels[i] ];
         // This is the DiffPoolVec for the pools on the other Dsolve,
         // the one with the channel.
         // DiffPoolVec& otherDv = other->pools_[ jn.otherPools[otherChan.myPool] ];
         DiffPoolVec& otherDv = other->pools_[ otherChan.myPool ];
         // Local diffPoolVec.
         // DiffPoolVec& myDv = pools_[ jn.myPools[otherChan.otherPool] ];
         DiffPoolVec& myDv = pools_[ otherChan.otherPool ];
         DiffPoolVec& chanDv = other->pools_[ otherChan.chanPool ];
         for ( vector< VoxelJunction >::const_iterator
             j = jn.vj.begin(); j != jn.vj.end(); ++j ) {
 
             double myN = myDv.getN( j->first );
             double lastN = myN;
             double otherN = otherDv.getN( j->second );
             double chanN = chanDv.getN( j->second );
             double perm = otherChan.permeability * chanN / NA;
             myN = integ( myN, perm * myN/j->firstVol, 
                             perm * otherN/j->secondVol, dt );
             otherN += lastN - myN;  // Mass consv
             if ( otherN < 0.0 ) { // Avoid negatives
                 myN += otherN;
                 otherN = 0.0;
             }
             myDv.setN( j->first, myN );
             otherDv.setN( j->second, otherN );
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned int Dsolve::convertIdToPoolIndex ( Id id ) const

Definition at line 982 of file Dsolve.cpp.

References poolMap_, and poolMapStart_.

Referenced by convertIdToPoolIndex(), fillConcChans(), getDiffConst(), getN(), getNinit(), getPoolIndex(), mapChansBetweenDsolves(), setDiffConst(), setMotorConst(), setN(), and setNinit().

 {
     unsigned int i  = id.value() - poolMapStart_;
     if ( i < poolMap_.size() ) {
         return poolMap_[i];
     }
     cout << "Warning: Dsolve::convertIdToPoollndex: Id out of range, (" <<
         poolMapStart_ << ", " << id << ", " << id.path() << ", " <<
         poolMap_.size() + poolMapStart_ << "\n";
     return 0;
 }

Here is the caller graph for this function:

unsigned int Dsolve::convertIdToPoolIndex ( const Eref & e ) const

Definition at line 994 of file Dsolve.cpp.

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

 {
     return convertIdToPoolIndex( e.id() );
 }

Here is the call graph for this function:

void Dsolve::fillConcChans ( const vector< ObjId > & chans )

Definition at line 547 of file Dsolve.cpp.

References ObjId::bad(), channels_, convertIdToPoolIndex(), Cinfo::find(), Cinfo::findFinfo(), ObjId::id, and Id::value().

Referenced by setStoich().

 {
     static const Cinfo* ccc = Cinfo::find( "ConcChan" );
     static const Finfo* inPoolFinfo = ccc->findFinfo( "inPool" );
     static const Finfo* outPoolFinfo = ccc->findFinfo( "outPool" );
     static const Finfo* chanPoolFinfo = ccc->findFinfo( "setNumChan" );
     FuncId fin = static_cast< const DestFinfo* >( inPoolFinfo )->getFid();
     FuncId fout = static_cast< const DestFinfo* >(outPoolFinfo )->getFid();
     FuncId fchan = 
             static_cast< const DestFinfo* >(chanPoolFinfo )->getFid();
 
     // Find the in pools and the chan pools on the current compt.
     // Save the Id of the outPool as an integer.
     // Use these and the permeability to create the ConcChanInfo.
     for ( auto i = chans.begin(); i != chans.end(); ++i ) {
         vector< Id > ret;
         if (i->element()->getNeighbors( ret, inPoolFinfo ) == 0 ) return;
         ObjId inPool( ret[0] );
         ret.clear();
         if (i->element()->getNeighbors( ret, outPoolFinfo ) == 0 ) return;
         ObjId outPool( ret[0] );
         ret.clear();
         if (i->element()->getNeighbors( ret, chanPoolFinfo ) == 0 ) return;
         ObjId chanPool( ret[0] );
         ret.clear();
         unsigned int outPoolValue = outPool.id.value();
         bool swapped = false;
         if ( !( inPool.bad() or chanPool.bad() ) ) {
             unsigned int inPoolIndex = convertIdToPoolIndex( inPool.id );
             unsigned int chanPoolIndex = convertIdToPoolIndex(chanPool.id);
             if ( inPoolIndex == ~0U ) { // Swap in and out as chan is symm
                 inPoolIndex = convertIdToPoolIndex( outPool.id );
                 outPoolValue = inPool.id.value();
                 swapped = true;
             }
             if ( ( inPoolIndex != ~0U) && (chanPoolIndex != ~0U ) ) {
                 ConcChanInfo cci( 
                     inPoolIndex, outPoolValue, chanPoolIndex, 
                     Field< double >::get( *i, "permeability" ), 
                     swapped
                 );
                 channels_.push_back( cci );
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::filterCrossRateTerms ( const vector< pair< Id, Id > > & xrt )

void Dsolve::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 1099 of file Dsolve.cpp.

References numLocalPools_, numVoxels_, pools_, and poolStartIndex_.

 {
     unsigned int startVoxel = values[0];
     unsigned int numVoxels = values[1];
     unsigned int startPool = values[2];
     unsigned int numPools = values[3];
 
     assert( startVoxel + numVoxels <= numVoxels_ );
     assert( startPool >= poolStartIndex_ );
     assert( numPools + startPool <= numLocalPools_ );
     values.resize( 4 );
 
     for ( unsigned int i = 0; i < numPools; ++i ) {
         unsigned int j = i + startPool;
         if ( j >= poolStartIndex_ && j < poolStartIndex_ + numLocalPools_ ){
             vector< double >::const_iterator q =
                 pools_[ j - poolStartIndex_ ].getNvec().begin();
 
             values.insert( values.end(),
                 q + startVoxel, q + startVoxel + numVoxels );
         }
     }
 }

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

virtual

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

Implements ZombiePoolInterface.

Definition at line 1062 of file Dsolve.cpp.

References convertIdToPoolIndex(), and pools_.

 {
     unsigned int pid = convertIdToPoolIndex( e );
     if ( pid >= pools_.size() )   // Ignore silently, out of range.
         return 0.0;
     return pools_[ convertIdToPoolIndex( e ) ].getDiffConst();
 }

Here is the call graph for this function:

double Dsolve::getDiffScale ( unsigned int voxel ) const

Definition at line 282 of file Dsolve.cpp.

References checkJn(), VoxelJunction::diffScale, and junctions_.

Referenced by initCinfo().

 {
     if ( checkJn( junctions_, voxel, "getDiffScale" ) ) {
         const VoxelJunction& vj = junctions_[0].vj[ voxel ];
         return vj.diffScale;
     }
     return 0.0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double Dsolve::getDiffVol1 ( unsigned int voxel ) const

LookupFied for examining cross-solver diffusion terms.

Definition at line 248 of file Dsolve.cpp.

References checkJn(), VoxelJunction::firstVol, and junctions_.

Referenced by initCinfo().

 {
     if ( checkJn( junctions_, voxel, "getDiffVol1" ) ) {
         const VoxelJunction& vj = junctions_[0].vj[ voxel ];
         return vj.firstVol;
     }
     return 0.0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double Dsolve::getDiffVol2 ( unsigned int voxel ) const

Definition at line 265 of file Dsolve.cpp.

References checkJn(), junctions_, and VoxelJunction::secondVol.

Referenced by initCinfo().

 {
     if ( checkJn( junctions_, voxel, "getDiffVol2" ) ) {
         const VoxelJunction& vj = junctions_[0].vj[ voxel ];
         return vj.secondVol;
     }
     return 0.0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

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

Implements ZombiePoolInterface.

Definition at line 1014 of file Dsolve.cpp.

References convertIdToPoolIndex(), Eref::dataIndex(), numVoxels_, and pools_.

 {
     unsigned int pid = convertIdToPoolIndex( e );
     if ( pid >= pools_.size() ) return 0.0; // ignore silently
     unsigned int vox = e.dataIndex();
     if ( vox <  numVoxels_ ) {
         return pools_[ pid ].getN( vox );
     }
     cout << "Warning: Dsolve::setN: Eref " << e << " out of range " <<
             pools_.size() << ", " << numVoxels_ << "\n";
     return 0.0;
 }

Here is the call graph for this function:

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

virtual

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

Implements ZombiePoolInterface.

Definition at line 1041 of file Dsolve.cpp.

References convertIdToPoolIndex(), Eref::dataIndex(), numVoxels_, and pools_.

 {
     unsigned int pid = convertIdToPoolIndex( e );
     if ( pid >= pools_.size() ) return 0.0; // ignore silently
     unsigned int vox = e.dataIndex();
     if ( vox < numVoxels_ ) {
         return pools_[ pid ].getNinit( vox );
     }
     cout << "Warning: Dsolve::setNinit: Eref " << e << " out of range " <<
             pools_.size() << ", " << numVoxels_ << "\n";
     return 0.0;
 }

Here is the call graph for this function:

unsigned int Dsolve::getNumLocalVoxels ( ) const

virtual

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

Implements ZombiePoolInterface.

Definition at line 1167 of file Dsolve.cpp.

References numVoxels_.

 {
     return numVoxels_;
 }

unsigned int Dsolve::getNumPools ( ) const

virtual

gets number of pools (species) handled by system.

Implements ZombiePoolInterface.

Definition at line 1093 of file Dsolve.cpp.

References numTotPools_.

Referenced by initCinfo().

 {
     return numTotPools_;
 }

Here is the caller graph for this function:

unsigned int Dsolve::getNumVarPools ( ) const

Definition at line 965 of file Dsolve.cpp.

 {
     return 0;
 }

unsigned int Dsolve::getNumVoxels ( ) const

Definition at line 970 of file Dsolve.cpp.

References numVoxels_.

Referenced by initCinfo().

 {
     return numVoxels_;
 }

Here is the caller graph for this function:

vector< double > Dsolve::getNvec ( unsigned int pool ) const

Definition at line 215 of file Dsolve.cpp.

References pools_.

Referenced by initCinfo().

 {
     static vector< double > ret;
     if ( pool <  pools_.size() )
         return pools_[pool].getNvec();
 
     cout << "Warning: Dsolve::setNvec: pool index out of range\n";
     return ret;
 }

Here is the caller graph for this function:

string Dsolve::getPath ( const Eref & e ) const

Definition at line 697 of file Dsolve.cpp.

References path_.

Referenced by initCinfo().

 {
     return path_;
 }

Here is the caller graph for this function:

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

virtual

Return pool index, using Stoich ptr to do lookup.

Implements ZombiePoolInterface.

Definition at line 1162 of file Dsolve.cpp.

References convertIdToPoolIndex().

 {
     return convertIdToPoolIndex( e );
 }

Here is the call graph for this function:

Id Dsolve::getStoich ( ) const

Definition at line 595 of file Dsolve.cpp.

References ZombiePoolInterface::stoich_.

Referenced by initCinfo().

 {
     return stoich_;
 }

Here is the caller graph for this function:

const Cinfo * Dsolve::initCinfo ( )

static

Definition at line 36 of file Dsolve.cpp.

References buildMeshJunctions(), buildNeuroMeshJunctions(), Dsolve(), dsolveCinfo, ZombiePoolInterface::getCompartment(), getDiffScale(), getDiffVol1(), getDiffVol2(), getNumPools(), getNumVoxels(), getNvec(), getPath(), getStoich(), Neutral::initCinfo(), path, process(), reinit(), setCompartment(), setDiffScale(), setDiffVol1(), setDiffVol2(), setNumPools(), setNvec(), setPath(), and setStoich().

 {
         // Field definitions
 
         static ValueFinfo< Dsolve, Id > stoich (
             "stoich",
             "Stoichiometry object for handling this reaction system.",
             &Dsolve::setStoich,
             &Dsolve::getStoich
         );
 
         static ElementValueFinfo< Dsolve, string > path (
             "path",
             "Path of reaction system. Must include all the pools that "
             "are to be handled by the Dsolve, can also include other "
             "random objects, which will be ignored.",
             &Dsolve::setPath,
             &Dsolve::getPath
         );
 
         static ReadOnlyValueFinfo< Dsolve, unsigned int > numVoxels(
             "numVoxels",
             "Number of voxels in the core reac-diff system, on the "
             "current diffusion solver. ",
             &Dsolve::getNumVoxels
         );
         static ReadOnlyValueFinfo< Dsolve, unsigned int > numAllVoxels(
             "numAllVoxels",
             "Number of voxels in the core reac-diff system, on the "
             "current diffusion solver. ",
             &Dsolve::getNumVoxels
         );
         static LookupValueFinfo<
                 Dsolve, unsigned int, vector< double > > nVec(
             "nVec",
             "vector of # of molecules along diffusion length, "
             "looked up by pool index",
             &Dsolve::setNvec,
             &Dsolve::getNvec
         );
 
         static ValueFinfo< Dsolve, unsigned int > numPools(
             "numPools",
             "Number of molecular pools in the entire reac-diff system, "
             "including variable, function and buffered.",
             &Dsolve::setNumPools,
             &Dsolve::getNumPools
         );
 
         static ValueFinfo< Dsolve, Id > compartment (
             "compartment",
             "Reac-diff compartment in which this diffusion system is "
             "embedded.",
             &Dsolve::setCompartment,
             &Dsolve::getCompartment
         );
 
         static LookupValueFinfo< Dsolve, unsigned int, double > diffVol1 (
             "diffVol1",
             "Volume used to set diffusion scaling: firstVol[ voxel# ] "
             "Particularly relevant for diffusion between PSD and head.",
             &Dsolve::setDiffVol1,
             &Dsolve::getDiffVol1
         );
 
         static LookupValueFinfo< Dsolve, unsigned int, double > diffVol2 (
             "diffVol2",
             "Volume used to set diffusion scaling: secondVol[ voxel# ] "
             "Particularly relevant for diffusion between spine and dend.",
             &Dsolve::setDiffVol2,
             &Dsolve::getDiffVol2
         );
 
         static LookupValueFinfo< Dsolve, unsigned int, double > diffScale (
             "diffScale",
             "Geometry term to set diffusion scaling: diffScale[ voxel# ] "
             "Here the scaling term is given by cross-section area/length "
             "Relevant for diffusion between spine head and dend, or PSD.",
             &Dsolve::setDiffScale,
             &Dsolve::getDiffScale
         );
 
 
         // DestFinfo definitions
 
         static DestFinfo process( "process",
             "Handles process call",
             new ProcOpFunc< Dsolve >( &Dsolve::process ) );
         static DestFinfo reinit( "reinit",
             "Handles reinit call",
             new ProcOpFunc< Dsolve >( &Dsolve::reinit ) );
 
         static DestFinfo buildMeshJunctions( "buildMeshJunctions",
             "Builds junctions between mesh on current Dsolve, and another"
             " Dsolve. The meshes have to be compatible. ",
             new EpFunc1< Dsolve, Id >(
                     &Dsolve::buildMeshJunctions ) );
 
         static DestFinfo buildNeuroMeshJunctions( "buildNeuroMeshJunctions",
             "Builds junctions between NeuroMesh, SpineMesh and PsdMesh",
             new EpFunc2< Dsolve, Id, Id >(
                     &Dsolve::buildNeuroMeshJunctions ) );
 
         // 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* dsolveFinfos[] =
     {
         &stoich,            // ElementValue
         &path,              // ElementValue
         &compartment,       // Value
         &numVoxels,         // ReadOnlyValue
         &numAllVoxels,          // ReadOnlyValue
         &nVec,              // LookupValue
         &numPools,          // Value
         &diffVol1,              // LookupValue
         &diffVol2,              // LookupValue
         &diffScale,             // LookupValue
         &buildMeshJunctions,    // DestFinfo
         &buildNeuroMeshJunctions,   // DestFinfo
         &proc,              // SharedFinfo
     };
 
     static Dinfo< Dsolve > dinfo;
     static  Cinfo dsolveCinfo(
         "Dsolve",
         Neutral::initCinfo(),
         dsolveFinfos,
         sizeof(dsolveFinfos)/sizeof(Finfo *),
         &dinfo
     );
 
     return &dsolveCinfo;
 }

Here is the call graph for this function:

void Dsolve::innerBuildMeshJunctions	(	Id	self,
		Id	other,
		bool	isMembraneBound
	)

static

buildMeshJunctions is the inner utility function for building the junction between any specified pair of Dsolves. Note that it builds the junction on the 'self' Dsolve.

Definition at line 941 of file Dsolve.cpp.

References junctions_, mapChansBetweenDsolves(), mapDiffPoolsBetweenDsolves(), mapVoxelsBetweenMeshes(), mapXfersBetweenDsolves(), DiffJunction::myXferDest, DiffJunction::myXferSrc, DiffJunction::otherDsolve, DiffJunction::otherXferDest, DiffJunction::otherXferSrc, and Id::value().

Referenced by buildMeshJunctions(), and buildNeuroMeshJunctions().

 {
     DiffJunction jn; // This is based on the Spine Dsolver.
     jn.otherDsolve = other.value();
     Dsolve* dself = reinterpret_cast< Dsolve* >( self.eref().data() );
     if ( selfIsMembraneBound ) {
         mapChansBetweenDsolves( jn, self, other );
     } else {
         mapDiffPoolsBetweenDsolves( jn, self, other );
     }
     mapXfersBetweenDsolves( jn.myXferSrc, jn.otherXferDest, self, other );
     mapXfersBetweenDsolves( jn.otherXferSrc, jn.myXferDest, other, self );
 
     mapVoxelsBetweenMeshes( jn, self, other );
 
 
     // printJunction( self, other, jn );
     dself->junctions_.push_back( jn );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::makePoolMapFromElist	(	const vector< ObjId > &	elist,
		vector< Id > &	temp
	)

Fills in poolMap_ using elist of objects found when the 'setPath' function is executed. temp is returned with the list of PoolBase objects that exist on the path.

Definition at line 622 of file Dsolve.cpp.

References path_, poolMap_, poolMapStart_, and ZombiePoolInterface::stoich_.

Referenced by setPath().

 {
     unsigned int minId = 0;
     unsigned int maxId = 0;
     temp.resize( 0 );
     for ( vector< ObjId >::const_iterator
             i = elist.begin(); i != elist.end(); ++i ) {
         if ( i->element()->cinfo()->isA( "PoolBase" ) ) {
             temp.push_back( i->id );
             if ( minId == 0 )
                 maxId = minId = i->id.value();
             else if ( i->id.value() < minId )
                 minId = i->id.value();
             else if ( i->id.value() > maxId )
                 maxId = i->id.value();
         }
     }
 
     if ( temp.size() == 0 ) {
         cout << "Dsolve::makePoolMapFromElist::( " << path_ <<
                 " ): Error: path is has no pools\n";
         return;
     }
 
     stoich_ = Id();
     poolMapStart_ = minId;
     poolMap_.resize( 1 + maxId - minId );
     for ( auto i = poolMap_.begin(); i != poolMap_.end(); ++i )
         *i = ~0U;
     for ( unsigned int i = 0; i < temp.size(); ++i ) {
         unsigned int idValue = temp[i].value();
         assert( idValue >= minId );
         assert( idValue - minId < poolMap_.size() );
         poolMap_[ idValue - minId ] = i;
     }
 }

Here is the caller graph for this function:

void Dsolve::mapChansBetweenDsolves	(	DiffJunction &	jn,
		Id	self,
		Id	other
	)

static

Definition at line 892 of file Dsolve.cpp.

References channels_, convertIdToPoolIndex(), Eref::data(), Id::eref(), DiffJunction::myChannels, and DiffJunction::otherChannels.

Referenced by innerBuildMeshJunctions().

 {
     Dsolve* otherSolve = reinterpret_cast< Dsolve* >(
                     other.eref().data() );
     Dsolve* selfSolve = reinterpret_cast< Dsolve* >( self.eref().data() );
     vector< ConcChanInfo >& ch = selfSolve->channels_;
     unsigned int outIndex;
     for ( unsigned int i = 0; i < ch.size(); ++i ) {
         unsigned int chanIndex = ch[i].chanPool;
         outIndex = otherSolve->convertIdToPoolIndex( ch[i].otherPool );
         if ( (outIndex != ~0U) && (chanIndex != ~0U ) ) {
             jn.myChannels.push_back(i);
             ch[i].otherPool = outIndex; // replace the Id with the index.
             ch[i].chanPool = chanIndex; //chanIndex may be on either Dsolve
         }
     }
     // Now set up the other Dsolve.
     vector< ConcChanInfo >& ch2 = otherSolve->channels_;
     for ( unsigned int i = 0; i < ch2.size(); ++i ) {
         unsigned int chanIndex = ch2[i].chanPool;
         outIndex = selfSolve->convertIdToPoolIndex( ch2[i].otherPool );
         if ( (outIndex != ~0U) && (chanIndex != ~0U) ) {
             jn.otherChannels.push_back(i);
             ch2[i].otherPool = outIndex;  // replace the Id with the index
             ch2[i].chanPool = chanIndex;  //chanIndex may be on either Dsolve
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::mapDiffPoolsBetweenDsolves	(	DiffJunction &	jn,
		Id	self,
		Id	other
	)

static

Sets up map of matching pools for diffusion.

Definition at line 824 of file Dsolve.cpp.

References Eref::data(), Id::eref(), DiffJunction::myPools, DiffJunction::otherPools, and pools_.

Referenced by innerBuildMeshJunctions().

 {
     Dsolve* mySolve = reinterpret_cast< Dsolve* >( self.eref().data() );
     unordered_map< string, unsigned int > myPools;
     for ( unsigned int i = 0; i < mySolve->pools_.size(); ++i ) {
             Id pool( mySolve->pools_[i].getId() );
             assert( pool != Id() );
             myPools[ pool.element()->getName() ] = i;
     }
 
     const Dsolve* otherSolve = reinterpret_cast< const Dsolve* >(
                     other.eref().data() );
     for ( unsigned int i = 0; i < otherSolve->pools_.size(); ++i ) {
         Id otherPool( otherSolve->pools_[i].getId() );
         unordered_map< string, unsigned int >::iterator p =
             myPools.find( otherPool.element()->getName() );
         if ( p != myPools.end() ) {
             jn.otherPools.push_back( i );
             jn.myPools.push_back( p->second );
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::mapXfersBetweenDsolves	(	vector< unsigned int > &	srcPools,
		vector< unsigned int > &	destPools,
		Id	src,
		Id	dest
	)

static

static void mapXfersBetweenDsolves(...) Build a list of all the molecules that should transfer instantaneously to another compartment, for cross-compartment reactions. Here we look for src names of the form <name>_xfer_<destComptName> For example, if we had an enzyme in compartment 'src', whose product should go to pool 'bar' in compartment 'dest', the name of the enzyme product in compartment src would be bar_xfer_dest

Definition at line 858 of file Dsolve.cpp.

References Eref::data(), Id::element(), Id::eref(), Field< A >::get(), Element::getName(), and pools_.

Referenced by innerBuildMeshJunctions().

 {
     Id destMesh = Field< Id >::get( dest, "compartment" );
     string xferPost( string( "_xfer_" ) + destMesh.element()->getName() );
     size_t xlen = xferPost.length();
 
     Dsolve* srcSolve = reinterpret_cast< Dsolve* >( src.eref().data() );
     unordered_map< string, unsigned int > srcMap;
     for ( unsigned int i = 0; i < srcSolve->pools_.size(); ++i ) {
             Id pool( srcSolve->pools_[i].getId() );
             assert( pool != Id() );
             string poolName = pool.element()->getName();
             if ( poolName.length() > xlen ) {
                 size_t prefixLen = poolName.length() - xlen;
                 if ( poolName.rfind( xferPost ) == prefixLen )
                     srcMap[ poolName.substr( 0, prefixLen) ] = i;
             }
     }
 
     const Dsolve* destSolve = reinterpret_cast< const Dsolve* >(
                     dest.eref().data() );
     for ( unsigned int i = 0; i < destSolve->pools_.size(); ++i ) {
         Id destPool( destSolve->pools_[i].getId() );
         unordered_map< string, unsigned int >::iterator p =
             srcMap.find( destPool.element()->getName() );
         if ( p != srcMap.end() ) {
             destPools.push_back( i );
             srcPools.push_back( p->second );
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

VoxelPoolsBase * Dsolve::pools ( unsigned int i )

virtual

Return a pointer to the specified VoxelPool.

Implements ZombiePoolInterface.

Definition at line 1172 of file Dsolve.cpp.

 {
     return 0;
 }

void Dsolve::print ( ) const

Utility func for debugging: Prints N_ matrix

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

Definition at line 478 of file Dsolve.cpp.

References ProcInfo::dt, and pools_.

Referenced by initCinfo().

 {
     for ( vector< DiffPoolVec >::iterator
                     i = pools_.begin(); i != pools_.end(); ++i ) {
         i->advance( p->dt );
     }
 }

Here is the caller graph for this function:

void Dsolve::rebuildPools ( )

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

Definition at line 486 of file Dsolve.cpp.

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

Referenced by initCinfo().

 {
     build( p->dt );
     for ( vector< DiffPoolVec >::iterator
                     i = pools_.begin(); i != pools_.end(); ++i ) {
         i->reinit();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::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 1132 of file Dsolve.cpp.

References numLocalPools_, numVoxels_, pools_, and poolStartIndex_.

 {
     unsigned int startVoxel = values[0];
     unsigned int numVoxels = values[1];
     unsigned int startPool = values[2];
     unsigned int numPools = values[3];
 
     assert( startVoxel + numVoxels <= numVoxels_ );
     assert( startPool >= poolStartIndex_ );
     assert( numPools + startPool <= numLocalPools_ );
     assert( values.size() == 4 + numVoxels * numPools );
 
     for ( unsigned int i = 0; i < numPools; ++i ) {
         unsigned int j = i + startPool;
         if ( j >= poolStartIndex_ && j < poolStartIndex_ + numLocalPools_ ){
             vector< double >::const_iterator
                 q = values.begin() + 4 + i * numVoxels;
             pools_[ j - poolStartIndex_ ].setNvec( startVoxel, numVoxels, q );
         }
     }
 }

void Dsolve::setCompartment ( Id compartment )

virtual

Assigns compartment.

Reimplemented from ZombiePoolInterface.

Definition at line 604 of file Dsolve.cpp.

References ZombiePoolInterface::compartment_, Field< A >::get(), id, Cinfo::isA(), Cinfo::name(), and numVoxels_.

Referenced by initCinfo().

 {
     const Cinfo* c = id.element()->cinfo();
     compartment_ = id;
     numVoxels_ = Field< unsigned int >::get( id, "numMesh" );
     if ( c->isA( "CubeMesh" ) ) { // we do only linear diffusion for now
         unsigned int nx = Field< unsigned int >::get( id, "nx" );
         unsigned int ny = Field< unsigned int >::get( id, "nx" );
         unsigned int nz = Field< unsigned int >::get( id, "nx" );
         if ( !( nx*ny == 1 || nx*nz == 1 || ny*nz == 1 ) ) {
             cout << "Warning: Dsolve::setCompartment:: Cube mesh: " <<
             c->name() << " found with >1 dimension of voxels. " <<
             "Only 1-D diffusion supported for now.\n";
             return;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

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

Implements ZombiePoolInterface.

Definition at line 1054 of file Dsolve.cpp.

References convertIdToPoolIndex(), and pools_.

 {
     unsigned int pid = convertIdToPoolIndex( e );
     if ( pid >= pools_.size() )   // Ignore silently, out of range.
         return;
     pools_[ convertIdToPoolIndex( e ) ].setDiffConst( v );
 }

Here is the call graph for this function:

void Dsolve::setDiffScale	(	unsigned int	voxel,
		double	scale
	)

Definition at line 274 of file Dsolve.cpp.

References checkJn(), VoxelJunction::diffScale, and junctions_.

Referenced by initCinfo().

 {
     if ( checkJn( junctions_, voxel, "setDiffScale" ) ) {
         VoxelJunction& vj = junctions_[0].vj[ voxel ];
         vj.diffScale = adx;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::setDiffVol1	(	unsigned int	voxel,
		double	vol
	)

Definition at line 240 of file Dsolve.cpp.

References checkJn(), VoxelJunction::firstVol, and junctions_.

Referenced by initCinfo().

 {
     if ( checkJn( junctions_, voxel, "setDiffVol1" ) ) {
         VoxelJunction& vj = junctions_[0].vj[ voxel ];
         vj.firstVol = vol;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::setDiffVol2	(	unsigned int	voxel,
		double	vol
	)

Definition at line 257 of file Dsolve.cpp.

References checkJn(), junctions_, and VoxelJunction::secondVol.

Referenced by initCinfo().

 {
     if ( checkJn( junctions_, voxel, "setDiffVol2" ) ) {
         VoxelJunction& vj = junctions_[0].vj[ voxel ];
         vj.secondVol = vol;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::setDsolve ( Id id )

virtual

Inherited, defining dummy function here.

Implements ZombiePoolInterface.

Definition at line 601 of file Dsolve.cpp.

602 {;}

void Dsolve::setMotorConst	(	const Eref &	e,
		double	val
	)

virtual

Motor constant: Only one per pool, voxel number is ignored. Used only in Dsolves, so here I put in a dummy.

Reimplemented from ZombiePoolInterface.

Definition at line 1070 of file Dsolve.cpp.

References convertIdToPoolIndex(), and pools_.

 {
     unsigned int pid = convertIdToPoolIndex( e );
     if ( pid >= pools_.size() )   // Ignore silently, out of range.
         return;
     pools_[ convertIdToPoolIndex( e ) ].setMotorConst( v );
 }

Here is the call graph for this function:

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

virtual

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

Implements ZombiePoolInterface.

Definition at line 999 of file Dsolve.cpp.

References convertIdToPoolIndex(), Eref::dataIndex(), numVoxels_, and pools_.

 {
     unsigned int pid = convertIdToPoolIndex( e );
     // Ignore silently, as this may be a valid pid for the ksolve to use.
     if ( pid >= pools_.size() )
         return;
     unsigned int vox = e.dataIndex();
     if ( vox < numVoxels_ ) {
         pools_[ pid ].setN( vox, v );
         return;
     }
     cout << "Warning: Dsolve::setN: Eref " << e << " out of range " <<
             pools_.size() << ", " << numVoxels_ << "\n";
 }

Here is the call graph for this function:

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

virtual

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

Implements ZombiePoolInterface.

Definition at line 1027 of file Dsolve.cpp.

References convertIdToPoolIndex(), Eref::dataIndex(), numVoxels_, and pools_.

 {
     unsigned int pid = convertIdToPoolIndex( e );
     if ( pid >= pools_.size() )  // Ignore silently
         return;
     unsigned int vox = e.dataIndex();
     if ( vox < numVoxels_ ) {
         pools_[ pid ].setNinit( vox, v );
         return;
     }
     cout << "Warning: Dsolve::setNinit: Eref " << e << " out of range " <<
             pools_.size() << ", " << numVoxels_ << "\n";
 }

Here is the call graph for this function:

void Dsolve::setNumAllVoxels ( unsigned int numVoxels )

virtual

Inherited virtual.

Implements ZombiePoolInterface.

Definition at line 975 of file Dsolve.cpp.

References numLocalPools_, numVoxels_, and pools_.

 {
     numVoxels_ = num;
     for ( unsigned int i = 0 ; i < numLocalPools_; ++i )
         pools_[i].setNumVoxels( numVoxels_ );
 }

void Dsolve::setNumPools ( unsigned int num )

virtual

Specifies number of pools (species) handled by system.

Implements ZombiePoolInterface.

Definition at line 1078 of file Dsolve.cpp.

References numLocalPools_, numTotPools_, numVoxels_, pools_, and poolStartIndex_.

Referenced by initCinfo(), and setPath().

 {
     // Decompose numPoolSpecies here, assigning some to each node.
     numTotPools_ = numPoolSpecies;
     numLocalPools_ = numPoolSpecies;
     poolStartIndex_ = 0;
 
     pools_.resize( numLocalPools_ );
     for ( unsigned int i = 0 ; i < numLocalPools_; ++i ) {
         pools_[i].setNumVoxels( numVoxels_ );
         // pools_[i].setId( reversePoolMap_[i] );
         // pools_[i].setParent( me );
     }
 }

Here is the caller graph for this function:

void Dsolve::setNvec	(	unsigned int	pool,
		vector< double >	vec
	)

Definition at line 204 of file Dsolve.cpp.

References pools_.

Referenced by initCinfo().

 {
     if ( pool < pools_.size() ) {
         if ( vec.size() != pools_[pool].getNumVoxels() ) {
             cout << "Warning: Dsolve::setNvec: pool index out of range\n";
         } else {
             pools_[ pool ].setNvec( vec );
         }
     }
 }

Here is the caller graph for this function:

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

Dummy, inherited but not used.

Definition at line 660 of file Dsolve.cpp.

References Field< A >::get(), Eref::id(), ZombieBufPool::initCinfo(), BufPool::initCinfo(), ZombiePool::initCinfo(), Pool::initCinfo(), makePoolMapFromElist(), Cinfo::name(), numVoxels_, poolMap_, poolMapStart_, pools_, setNumPools(), simpleWildcardFind(), value, and PoolBase::zombify().

Referenced by initCinfo().

 {
     vector< ObjId > elist;
     simpleWildcardFind( path, elist );
     if ( elist.size() == 0 ) {
         cout << "Dsolve::setPath::( " << path << " ): Error: path is empty\n";
         return;
     }
     vector< Id > temp;
     makePoolMapFromElist( elist, temp );
 
     setNumPools( temp.size() );
     for ( unsigned int i = 0; i < temp.size(); ++i ) {
         Id id = temp[i];
         double diffConst = Field< double >::get( id, "diffConst" );
         double motorConst = Field< double >::get( id, "motorConst" );
         const Cinfo* c = id.element()->cinfo();
         if ( c == Pool::initCinfo() ) {
             PoolBase::zombify( id.element(), ZombiePool::initCinfo(), Id(), e.id() );
         } else if ( c == BufPool::initCinfo() ) {
             PoolBase::zombify( id.element(), ZombieBufPool::initCinfo(), Id(), e.id() );
             // Any Functions will have to continue to manage the BufPools.
             // This needs them to be replicated, and for their messages
             // to be copied over. Not really set up here.
         } else {
             cout << "Error: Dsolve::setPath( " << path << " ): unknown pool class:" << c->name() << endl;
         }
         id.element()->resize( numVoxels_ );
 
         unsigned int j = temp[i].value() - poolMapStart_;
         assert( j < poolMap_.size() );
         pools_[ poolMap_[i] ].setId( id.value() );
         pools_[ poolMap_[j] ].setDiffConst( diffConst );
         pools_[ poolMap_[j] ].setMotorConst( motorConst );
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::setPrev ( )

virtual

Used to tell Dsolver to assign 'prev' values.

Reimplemented from ZombiePoolInterface.

Definition at line 1124 of file Dsolve.cpp.

References pools_.

 {
     for ( auto i = pools_.begin(); i != pools_.end(); ++i ) {
         // if (i->getDiffConst() > 0.0 )
             i->setPrevVec();
     }
 }

void Dsolve::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 506 of file Dsolve.cpp.

References Element::cinfo(), Eref::data(), Id::element(), Id::eref(), fillConcChans(), Field< A >::get(), PoolBase::getDiffConst(), id, Cinfo::isA(), path_, poolMap_, poolMapStart_, pools_, ZombiePoolInterface::stoich_, Id::value(), and wildcardFind().

Referenced by initCinfo().

 {
     if ( !id.element()->cinfo()->isA( "Stoich" ) ) {
         cout << "Dsolve::setStoich::( " << id << " ): Error: provided Id is not a Stoich\n";
         return;
     }
 
     stoich_ = id;
     poolMap_ = Field< vector< unsigned int > >::get( stoich_, "poolIdMap" );
     poolMapStart_ = poolMap_.back();
     poolMap_.pop_back();
 
     path_ = Field< string >::get( stoich_, "path" );
     // cout << "Pool Info for stoich " << id.path() << endl;
 
     for ( unsigned int i = 0; i < poolMap_.size(); ++i ) {
         unsigned int poolIndex = poolMap_[i];
         if ( poolIndex != ~0U && poolIndex < pools_.size() ) {
             // assert( poolIndex < pools_.size() );
             Id pid( i + poolMapStart_ );
             assert( pid.element()->cinfo()->isA( "PoolBase" ) );
             PoolBase* pb =
                     reinterpret_cast< PoolBase* >( pid.eref().data());
             double diffConst = pb->getDiffConst( pid.eref() );
             double motorConst = pb->getMotorConst( pid.eref() );
             pools_[ poolIndex ].setId( pid.value() );
             pools_[ poolIndex ].setDiffConst( diffConst );
             pools_[ poolIndex ].setMotorConst( motorConst );
             /*
             cout << i << " poolIndex=" <<  poolIndex <<
                     ", id=" << pid.value() <<
                     ", name=" << pid.element()->getName() << endl;
                     */
         }
     }
     string chanpath = path_ + "[ISA=ConcChan]";
     vector< ObjId > chans;
     wildcardFind( chanpath, chans );
     fillConcChans( chans );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Dsolve::setupCrossSolverReacs	(	const map< Id, vector< Id > > &	xr,
		Id	otherStoich
	)

void Dsolve::setupCrossSolverReacVols	(	const vector< vector< Id > > &	subCompts,
		const vector< vector< Id > > &	prdCompts
	)

void Dsolve::updateJunctions ( double dt )

virtual

Used for telling Dsolver to handle all ops across Junctions.

Reimplemented from ZombiePoolInterface.

Definition at line 495 of file Dsolve.cpp.

References calcJunction(), and junctions_.

 {
     for ( vector< DiffJunction >::const_iterator
             i = junctions_.begin(); i != junctions_.end(); ++i ) {
         calcJunction( *i, dt );
     }
 }

Here is the call graph for this function:

void Dsolve::updateRateTerms ( unsigned int index )

virtual

Informs the solver that the rate terms or volumes have changed and that the parameters must be updated. The index specifies which rateTerm to change, and if it is ~0U it means update all of them.

Implements ZombiePoolInterface.

Definition at line 1157 of file Dsolve.cpp.

 {
     ;
 }

double Dsolve::volume ( unsigned int i ) const

virtual

Return volume of voxel i.

Implements ZombiePoolInterface.

Definition at line 1177 of file Dsolve.cpp.

 {
     return 1.0;
 }

Member Data Documentation

vector< ConcChanInfo > Dsolve::channels_

private

Internal vector, one for each ConcChan managed by Dsolve.

Definition at line 209 of file Dsolve.h.

Referenced by calcJnChan(), calcOtherJnChan(), fillConcChans(), and mapChansBetweenDsolves().

double Dsolve::dt_

private

Timestep used by diffusion calculations.

Definition at line 199 of file Dsolve.h.

Referenced by build().

vector< DiffJunction > Dsolve::junctions_

private

Lists all the diffusion junctions managed by this Dsolve. Each junction entry provides the info needed to do the numerical integration for flux between the Dsolves.

Definition at line 222 of file Dsolve.h.

Referenced by getDiffScale(), getDiffVol1(), getDiffVol2(), innerBuildMeshJunctions(), setDiffScale(), setDiffVol1(), setDiffVol2(), and updateJunctions().