#include <HSolveActive.h>

Inheritance diagram for HSolveActive:

Collaboration diagram for HSolveActive:

Public Member Functions
	HSolveActive ()

void	reinit (ProcPtr info)

void	setup (Id seed, double dt)

void	step (ProcPtr info)
	Equivalent to process. More...

Public Member Functions inherited from HSolvePassive
void	setup (Id seed, double dt)

void	solve ()

Public Member Functions inherited from HinesMatrix
double	getA (unsigned int row, unsigned int col) const

double	getB (unsigned int row) const

unsigned int	getSize () const

double	getVMid (unsigned int row) const

	HinesMatrix ()

void	setup (const vector< TreeNodeStruct > &tree, double dt)

Protected Attributes
vector< double >	ca_
	Ca conc in each pool. More...

vector< double >	caActivation_
	calcium pool More...

int	caAdvance_

vector< CaConcStruct >	caConc_
	Ca pool info. More...

vector< Id >	caConcId_
	calcium from difshells More...

vector< unsigned int >	caCount_
	each compartment More...

vector< int >	caDependIndex_
	depdt channel depend upon? More...

int	caDiv_

double	caMax_

double	caMin_

vector< LookupRow * >	caRow_

vector< LookupRow >	caRowCompt_

LookupTable	caTable_

vector< double * >	caTarget_

vector< unsigned int >	chan2compt_

vector< unsigned int >	chan2state_
	a state index More...

vector< ChannelStruct >	channel_
	to compartment: chan2compt More...

vector< int >	channelCount_
	compartment More...

vector< Id >	channelId_
	Used for localIndex-ing. More...

vector< LookupColumn >	column_
	to lookup for this species More...

vector< CurrentStruct >	current_
	Channel current. More...

vector< currentVecIter >	currentBoundary_

vector< double >	externalCalcium_

vector< double >	externalCurrent_

vector< Id >	gateId_
	Used for localIndex-ing. More...

vector< bool >	gCaDepend_
	depend on Ca conc? More...

vector< unsigned int >	outCa_

vector< unsigned int >	outIk_

vector< unsigned int >	outVm_

vector< SpikeGenStruct >	spikegen_

vector< double >	state_
	Fraction of gates open. More...

vector< SynChanStruct >	synchan_

int	vDiv_

double	vMax_

double	vMin_

LookupTable	vTable_

Protected Attributes inherited from HSolvePassive
vector< CompartmentStruct >	compartment_

vector< Id >	compartmentId_

map< unsigned int, InjectStruct >	inject_

vector< TreeNodeStruct >	tree_

vector< double >	V_

Protected Attributes inherited from HinesMatrix
vector< vdIterator >	backOperand_

double	dt_

vector< double >	HJ_

vector< double >	HJCopy_

vector< double >	HS_

vector< JunctionStruct >	junction_

unsigned int	nCompt_

vector< vdIterator >	operand_

int	stage_
	reached. Used in getA. More...

vector< double >	VMid_
	middle of a time step. More...

Private Types
typedef vector< CurrentStruct > ::iterator	currentVecIter

Private Member Functions
void	advanceCalcium ()

void	advanceChannels (double dt)

void	advanceSynChans (ProcPtr info)

void	backwardSubstitute ()

void	calculateChannelCurrents ()

void	cleanup ()

void	createLookupTables ()

void	forwardEliminate ()

void	manageOutgoingMessages ()

void	readCalcium ()

void	readExternalChannels ()

void	readGates ()

void	readHHChannels ()

void	readSynapses ()

void	reinitCalcium ()

void	reinitChannels ()

void	reinitCompartments ()

void	reinitSpikeGens (ProcPtr info)

void	sendSpikes (ProcPtr info)

void	sendValues (ProcPtr info)

void	updateMatrix ()

Static Private Attributes
static const int	INSTANT_X = 1

static const int	INSTANT_Y = 2

static const int	INSTANT_Z = 4

Additional Inherited Members
Protected Types inherited from HinesMatrix
typedef vector< double >::iterator	vdIterator

Protected Member Functions inherited from HSolvePassive
void	backwardSubstitute ()

void	forwardEliminate ()

void	updateMatrix ()

Detailed Description

Definition at line 29 of file HSolveActive.h.

Member Typedef Documentation

typedef vector< CurrentStruct >::iterator HSolveActive::currentVecIter

private

Definition at line 31 of file HSolveActive.h.

Constructor & Destructor Documentation

HSolveActive::HSolveActive ( )

Definition at line 33 of file HSolveActive.cpp.

 {
     caAdvance_ = 1;
 
     // Default lookup table size
     //~ vDiv_ = 3000;    // for voltage
     //~ caDiv_ = 3000;   // for calcium
 }

Member Function Documentation

void HSolveActive::advanceCalcium ( )

private

Definition at line 153 of file HSolveActive.cpp.

 {
     vector< double* >::iterator icatarget = caTarget_.begin();
     vector< double >::iterator ivmid = VMid_.begin();
     vector< CurrentStruct >::iterator icurrent = current_.begin();
     vector< currentVecIter >::iterator iboundary = currentBoundary_.begin();
 
     /*
      * caAdvance_: This flag determines how current flowing into a calcium pool
      * is computed. A value of 0 means that the membrane potential at the
      * beginning of the time-step is used for the calculation. This is how
      * GENESIS does its computations. A value of 1 means the membrane potential
      * at the middle of the time-step is used. This is the correct way of
      * integration, and is the default way.
      */
     if ( caAdvance_ == 1 )
     {
         for ( ; iboundary != currentBoundary_.end(); ++iboundary )
         {
             for ( ; icurrent < *iboundary; ++icurrent )
             {
                 if ( *icatarget )
                     **icatarget += icurrent->Gk * ( icurrent->Ek - *ivmid );
 
                 ++icatarget;
             }
 
             ++ivmid;
         }
     }
     else if ( caAdvance_ == 0 )
     {
         vector< double >::iterator iv = V_.begin();
         double v0;
 
         for ( ; iboundary != currentBoundary_.end(); ++iboundary )
         {
             for ( ; icurrent < *iboundary; ++icurrent )
             {
                 if ( *icatarget )
                 {
                     v0 = ( 2 * *ivmid - *iv );
 
                     **icatarget += icurrent->Gk * ( icurrent->Ek - v0 );
                 }
 
                 ++icatarget;
             }
 
             ++ivmid, ++iv;
         }
     }
 
     vector< CaConcStruct >::iterator icaconc;
     vector< double >::iterator icaactivation = caActivation_.begin();
     vector< double >::iterator ica = ca_.begin();
     for ( icaconc = caConc_.begin(); icaconc != caConc_.end(); ++icaconc )
     {
         *ica = icaconc->process( *icaactivation );
         ++ica, ++icaactivation;
     }
 
     caActivation_.assign( caActivation_.size(), 0.0 );
 }

void HSolveActive::advanceChannels ( double dt )

private

Definition at line 218 of file HSolveActive.cpp.

References LookupRow::row.

 {
     vector< double >::iterator iv;
     vector< double >::iterator istate = state_.begin();
     vector< int >::iterator ichannelcount = channelCount_.begin();
     vector< ChannelStruct >::iterator ichan = channel_.begin();
     vector< ChannelStruct >::iterator chanBoundary;
     vector< unsigned int >::iterator icacount = caCount_.begin();
     vector< double >::iterator ica = ca_.begin();
     vector< double >::iterator caBoundary;
     vector< LookupColumn >::iterator icolumn = column_.begin();
     vector< LookupRow >::iterator icarowcompt;
     vector< LookupRow* >::iterator icarow = caRow_.begin();
     vector< double >::iterator iextca = externalCalcium_.begin();
 
     LookupRow vRow;
     LookupRow dRow;
     double C1, C2;
 
     for ( iv = V_.begin(); iv != V_.end(); ++iv )
     {
         vTable_.row( *iv, vRow );
         icarowcompt = caRowCompt_.begin();
         caBoundary = ica + *icacount;
         for ( ; ica < caBoundary; ++ica )
         {
             caTable_.row( *ica, *icarowcompt );
 
             ++icarowcompt;
         }
 
         /*
          * Optimize by moving "if ( instant )" outside the loop, because it is
          * rarely used. May also be able to avoid "if ( power )".
          *
          * Or not: excellent branch predictors these days.
          *
          * Will be nice to test these optimizations.
          */
         chanBoundary = ichan + *ichannelcount;
         for ( ; ichan < chanBoundary; ++ichan )
         {
 
       caTable_.row( *iextca, dRow );
 
             if ( ichan->Xpower_ > 0.0 )
             {
                 vTable_.lookup( *icolumn, vRow, C1, C2 );
                 //~ *istate = *istate * C1 + C2;
                 //~ *istate = ( C1 + ( 2 - C2 ) * *istate ) / C2;
                 if ( ichan->instant_ & INSTANT_X )
                     *istate = C1 / C2;
                 else
                 {
                     double temp = 1.0 + dt / 2.0 * C2;
                     *istate = ( *istate * ( 2.0 - temp ) + dt * C1 ) / temp;
                 }
 
                 ++icolumn, ++istate;
             }
 
             if ( ichan->Ypower_ > 0.0 )
             {
                 vTable_.lookup( *icolumn, vRow, C1, C2 );
                 //~ *istate = *istate * C1 + C2;
                 //~ *istate = ( C1 + ( 2 - C2 ) * *istate ) / C2;
                 if ( ichan->instant_ & INSTANT_Y )
                     *istate = C1 / C2;
                 else
                 {
                     double temp = 1.0 + dt / 2.0 * C2;
                     *istate = ( *istate * ( 2.0 - temp ) + dt * C1 ) / temp;
 
 }
                 ++icolumn, ++istate;
             }
 
             if ( ichan->Zpower_ > 0.0 )
             {
                 LookupRow* caRow = *icarow;
 
                 if ( caRow )
                 {
                     caTable_.lookup( *icolumn, *caRow, C1, C2 );
 
                 }
                  else if (*iextca >0)
 
            {
              caTable_.lookup( *icolumn, dRow, C1, C2 );
            }
         else
                 {
           vTable_.lookup( *icolumn, vRow, C1, C2 );
 
                 }
 
                 //~ *istate = *istate * C1 + C2;
                 //~ *istate = ( C1 + ( 2 - C2 ) * *istate ) / C2;
                 if ( ichan->instant_ & INSTANT_Z )
                     *istate = C1 / C2;
                 else
                 {
                     double temp = 1.0 + dt / 2.0 * C2;
                     *istate = ( *istate * ( 2.0 - temp ) + dt * C1 ) / temp;
                 }
 
                 ++icolumn, ++istate, ++icarow;
 
             }
         ++iextca;
         }
 
         ++ichannelcount, ++icacount;
     }
 }

void HSolveActive::advanceSynChans ( ProcPtr info )

private

SynChans are currently not under solver's control

Definition at line 338 of file HSolveActive.cpp.

 {
     return;
 }

void HSolveActive::backwardSubstitute ( )

private

void HSolveActive::calculateChannelCurrents ( )

private

Integration: Defined in HSolveActive.cpp

Definition at line 69 of file HSolveActive.cpp.

 {
     vector< ChannelStruct >::iterator ichan;
     vector< CurrentStruct >::iterator icurrent = current_.begin();
 
     if ( state_.size() != 0 )
     {
         double* istate = &state_[ 0 ];
 
         for ( ichan = channel_.begin(); ichan != channel_.end(); ++ichan )
         {
             ichan->process( istate, *icurrent );
             ++icurrent;
         }
     }
 }

void HSolveActive::cleanup ( )

private

Definition at line 676 of file HSolveActiveSetup.cpp.

References caDependIndex_, and gCaDepend_.

Referenced by setup().

 {
 //  compartmentId_.clear();
     gCaDepend_.clear();
     caDependIndex_.clear();
 }

Here is the caller graph for this function:

void HSolveActive::createLookupTables ( )

private

Definition at line 339 of file HSolveActiveSetup.cpp.

References LookupTable::addColumns(), caCount_, caDependIndex_, caDiv_, caMax_, caMin_, caRow_, caRowCompt_, caTable_, channel_, LookupTable::column(), column_, gateId_, gCaDepend_, Field< A >::get(), HSolveUtils::rates(), HSolveUtils::Grid::size(), vDiv_, vMax_, vMin_, and vTable_.

Referenced by setup().

 {
     std::set< Id > caSet;
     std::set< Id > vSet;
     vector< Id > caGate;
     vector< Id > vGate;
     map< Id, unsigned int > gateSpecies;
 
     for ( unsigned int ig = 0; ig < gateId_.size(); ++ig )
         if ( gCaDepend_[ ig ] )
             caSet.insert( gateId_[ ig ] );
         else
             vSet.insert( gateId_[ ig ] );
 
     caGate.insert( caGate.end(), caSet.begin(), caSet.end() );
     vGate.insert( vGate.end(), vSet.begin(), vSet.end() );
 
     for ( unsigned int ig = 0; ig < caGate.size(); ++ig )
         gateSpecies[ caGate[ ig ] ] = ig;
     for ( unsigned int ig = 0; ig < vGate.size(); ++ig )
         gateSpecies[ vGate[ ig ] ] = ig;
 
     /*
      * Finding the smallest xmin and largest xmax across all gates' lookup
      * tables.
      *
      * # of divs is determined by finding the smallest dx (highest density).
      */
     vMin_ = numeric_limits< double >::max();
     vMax_ = numeric_limits< double >::min();
     double vDx = numeric_limits< double >::max();
     caMin_ = numeric_limits< double >::max();
     caMax_ = numeric_limits< double >::min();
     double caDx = numeric_limits< double >::max();
 
     double min;
     double max;
     unsigned int divs;
     double dx;
 
     for ( unsigned int ig = 0; ig < caGate.size(); ++ig )
     {
         min = Field< double >::get( caGate[ ig ], "min" );
         max = Field< double >::get( caGate[ ig ], "max" );
         divs = Field< unsigned int >::get( caGate[ ig ], "divs" );
         dx = ( max - min ) / divs;
 
         if ( min < caMin_ )
             caMin_ = min;
         if ( max > caMax_ )
             caMax_ = max;
         if ( dx < caDx )
             caDx = dx;
     }
     double caDiv = ( caMax_ - caMin_ ) / caDx;
     caDiv_ = static_cast< int >( caDiv + 0.5 ); // Round-off to nearest int.
 
     for ( unsigned int ig = 0; ig < vGate.size(); ++ig )
     {
         min = Field< double >::get( vGate[ ig ], "min" );
         max = Field< double >::get( vGate[ ig ], "max" );
         divs = Field< unsigned int >::get( vGate[ ig ], "divs" );
         dx = ( max - min ) / divs;
 
         if ( min < vMin_ )
             vMin_ = min;
         if ( max > vMax_ )
             vMax_ = max;
         if ( dx < vDx )
             vDx = dx;
     }
     double vDiv = ( vMax_ - vMin_ ) / vDx;
     vDiv_ = static_cast< int >( vDiv + 0.5 ); // Round-off to nearest int.
 
     caTable_ = LookupTable( caMin_, caMax_, caDiv_, caGate.size() );
     vTable_ = LookupTable( vMin_, vMax_, vDiv_, vGate.size() );
 
     vector< double > A, B;
     vector< double >::iterator ia, ib;
     // double a, b;
     //~ int AMode, BMode;
     //~ bool interpolate;
 
     // Calcium-dependent lookup tables
     HSolveUtils::Grid caGrid( caMin_, caMax_, caDiv_ );
     //~ if ( !caGate.empty() ) {
     //~ grid.resize( 1 + caDiv_ );
     //~ double dca = ( caMax_ - caMin_ ) / caDiv_;
     //~ for ( int igrid = 0; igrid <= caDiv_; ++igrid )
     //~ grid[ igrid ] = caMin_ + igrid * dca;
     //~ }
 
     for ( unsigned int ig = 0; ig < caGate.size(); ++ig )
     {
         HSolveUtils::rates( caGate[ ig ], caGrid, A, B );
         //~ HSolveUtils::modes( caGate[ ig ], AMode, BMode );
         //~ interpolate = ( AMode == 1 ) || ( BMode == 1 );
 
         ia = A.begin();
         ib = B.begin();
         for ( unsigned int igrid = 0; igrid < caGrid.size(); ++igrid )
         {
             // Use one of the optimized forms below, instead of A and B
             // directly. Also updated reinit() accordingly (for gate state).
 //            a = *ia;
 //            b = *ib;
 
             // *ia = ( 2.0 - dt_ * b ) / ( 2.0 + dt_ * b );
             // *ib = dt_ * a / ( 1.0 + dt_ * b / 2.0 );
             // *ia = dt_ * a;
            // *ib = 1.0 + dt_ * b / 2.0;
             ++ia, ++ib;
         }
 
         //~ caTable_.addColumns( ig, A, B, interpolate );
         caTable_.addColumns( ig, A, B );
     }
 
     // Voltage-dependent lookup tables
     HSolveUtils::Grid vGrid( vMin_, vMax_, vDiv_ );
     //~ if ( !vGate.empty() ) {
     //~ grid.resize( 1 + vDiv_ );
     //~ double dv = ( vMax_ - vMin_ ) / vDiv_;
     //~ for ( int igrid = 0; igrid <= vDiv_; ++igrid )
     //~ grid[ igrid ] = vMin_ + igrid * dv;
     //~ }
 
 
     for ( unsigned int ig = 0; ig < vGate.size(); ++ig )
     {
         //~ interpolate = HSolveUtils::get< HHGate, bool >( vGate[ ig ], "useInterpolation" );
         HSolveUtils::rates( vGate[ ig ], vGrid, A, B );
         //~ HSolveUtils::modes( vGate[ ig ], AMode, BMode );
         //~ interpolate = ( AMode == 1 ) || ( BMode == 1 );
 
         ia = A.begin();
         ib = B.begin();
         for ( unsigned int igrid = 0; igrid < vGrid.size(); ++igrid )
         {
             // Use one of the optimized forms below, instead of A and B
             // directly. Also updated reinit() accordingly (for gate state).
 //            a = *ia;
 //            b = *ib;
 
             // *ia = ( 2.0 - dt_ * b ) / ( 2.0 + dt_ * b );
             // *ib = dt_ * a / ( 1.0 + dt_ * b / 2.0 );
             // *ia = dt_ * a;
             // *ib = 1.0 + dt_ * b / 2.0;
             ++ia, ++ib;
         }
 
         //~ vTable_.addColumns( ig, A, B, interpolate );
         vTable_.addColumns( ig, A, B );
     }
 
     column_.reserve( gateId_.size() );
     for ( unsigned int ig = 0; ig < gateId_.size(); ++ig )
     {
         unsigned int species = gateSpecies[ gateId_[ ig ] ];
 
         LookupColumn column;
         if ( gCaDepend_[ ig ] )
             caTable_.column( species, column );
         else
             vTable_.column( species, column );
 
         column_.push_back( column );
     }
 
     unsigned int maxN = *( max_element( caCount_.begin(), caCount_.end() ) );
     caRowCompt_.resize( maxN );
 
     for ( unsigned int ichan = 0; ichan < channel_.size(); ++ichan )
     {
         if ( channel_[ ichan ].Zpower_ > 0.0 )
         {
             int index = caDependIndex_[ ichan ];
 
             if ( index == -1 )
                 caRow_.push_back( 0 );
             else
                 caRow_.push_back( &caRowCompt_[ index ] );
         }
     }
 
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void HSolveActive::forwardEliminate ( )

private

void HSolveActive::manageOutgoingMessages ( )

private

Definition at line 598 of file HSolveActiveSetup.cpp.

References caConcId_, channelId_, HSolvePassive::compartmentId_, outCa_, outIk_, outVm_, and HSolveUtils::targets().

Referenced by setup().

 {
     vector< Id > targets;
     vector< string > filter;
 
     /*
      * Going through all comparments, and finding out which ones have external
      * targets through the VmOut msg. External refers to objects that do not
      * belong the cell being managed by this HSolve. We find these by excluding
      * any HHChannels and SpikeGens from the VmOut targets. These will then
      * be used in HSolveActive::sendValues() to send out the messages behalf of
      * the original objects.
      */
     filter.push_back( "HHChannel" );
     filter.push_back( "SpikeGen" );
     for ( unsigned int ic = 0; ic < compartmentId_.size(); ++ic )
     {
         targets.clear();
 
         int nTargets = HSolveUtils::targets(
                            compartmentId_[ ic ],
                            "VmOut",
                            targets,
                            filter,
                            false    // include = false. That is, use filter to exclude.
                        );
 
         if ( nTargets )
             outVm_.push_back( ic );
     }
 
     /*
      * As before, going through all CaConcs, and finding any which have external
      * targets.
      */
     filter.clear();
     filter.push_back( "HHChannel" );
     for ( unsigned int ica = 0; ica < caConcId_.size(); ++ica )
     {
         targets.clear();
 
         int nTargets = HSolveUtils::targets(
                            caConcId_[ ica ],
                            "concOut",
                            targets,
                            filter,
                            false    // include = false. That is, use filter to exclude.
                        );
 
         if ( nTargets )
             outCa_.push_back( ica );
     }
 
     filter.clear();
     filter.push_back( "CaConc" );
 
     for ( unsigned int ik = 0; ik < channelId_.size(); ++ik )
     {
         targets.clear();
 
         int nTargets = HSolveUtils::targets(
                            channelId_[ ik ],
                            "IkOut",
                            targets,
                            filter,
                            false    // include = false. That is, use filter to exclude.
                        );
 
         if ( nTargets )
             outIk_.push_back( ik );
 
 
     }
 
 
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void HSolveActive::readCalcium ( )

private

Definition at line 252 of file HSolveActiveSetup.cpp.

References ca_, caActivation_, caConc_, caConcId_, caCount_, HSolveUtils::caDepend(), caDependIndex_, HSolveUtils::caTarget(), caTarget_, channel_, channelCount_, channelId_, HinesMatrix::dt_, externalCalcium_, Field< A >::get(), and HinesMatrix::nCompt_.

Referenced by setup().

 {
     double Ca, CaBasal, tau, B, ceiling, floor;
     vector< Id > caConcId;
     vector< int > caTargetIndex;
     map< Id, int > caConcIndex;
     int nTarget, nDepend = 0;
     vector< Id >::iterator iconc;
 
     caCount_.resize( nCompt_ );
     unsigned int ichan = 0;
 
     for ( unsigned int ic = 0; ic < nCompt_; ++ic )
     {
 
         unsigned int chanBoundary = ichan + channelCount_[ ic ];
         unsigned int nCa = caConc_.size();
 
         for ( ; ichan < chanBoundary; ++ichan )
         {
             caConcId.clear();
 
             nTarget = HSolveUtils::caTarget( channelId_[ ichan ], caConcId );
             if ( nTarget == 0 )
                 // No calcium pools fed by this channel.
                 caTargetIndex.push_back( -1 );
 
             nDepend = HSolveUtils::caDepend( channelId_[ ichan ], caConcId );
 
         if ( nDepend == 0)
                 // Channel does not depend on calcium.
 
           caDependIndex_.push_back( -1 );
 
 
         externalCalcium_.push_back(0);
 
             for ( iconc = caConcId.begin(); iconc != caConcId.end(); ++iconc )
                 if ( caConcIndex.find( *iconc ) == caConcIndex.end() )
                 {
                     caConcIndex[ *iconc ] = caCount_[ ic ];
                     ++caCount_[ ic ];
 
                     Ca = Field< double >::get( *iconc, "Ca" );
                     CaBasal = Field< double >::get( *iconc, "CaBasal" );
                     tau = Field< double >::get( *iconc, "tau" );
                     B = Field< double >::get( *iconc, "B" );
                     ceiling = Field< double >::get( *iconc, "ceiling" );
                     floor = Field< double >::get( *iconc, "floor" );
 
                     caConc_.push_back(
                         CaConcStruct(
                             Ca, CaBasal,
                             tau, B,
                             ceiling, floor,
                             dt_
                         )
                     );
                     caConcId_.push_back( *iconc );
                 }
 
             if ( nTarget != 0 )
                 caTargetIndex.push_back( caConcIndex[ caConcId.front() ] + nCa );
             if ( nDepend != 0 )
                 caDependIndex_.push_back( caConcIndex[ caConcId.back() ] );
 
 
         }
     }
 
 
 
     caTarget_.resize( channel_.size() );
     ca_.resize( caConc_.size() );
     caActivation_.resize( caConc_.size() );
 
     for ( unsigned int ichan = 0; ichan < channel_.size(); ++ichan )
     {
         if ( caTargetIndex[ ichan ] == -1 )
             caTarget_[ ichan ] = 0;
         else
             caTarget_[ ichan ] = &caActivation_[ caTargetIndex[ ichan ] ];
     }
 
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void HSolveActive::readExternalChannels ( )

private

Definition at line 579 of file HSolveActiveSetup.cpp.

References HSolvePassive::compartmentId_, and externalCurrent_.

Referenced by setup().

 {
     vector< string > filter;
     filter.push_back( "HHChannel" );
     //~ filter.push_back( "SynChan" );
 
     //~ externalChannelId_.resize( compartmentId_.size() );
     externalCurrent_.resize( 2 * compartmentId_.size(), 0.0 );
 
     //~ for ( unsigned int ic = 0; ic < compartmentId_.size(); ++ic )
     //~ HSolveUtils::targets(
     //~ compartmentId_[ ic ],
     //~ "channel",
     //~ externalChannelId_[ ic ],
     //~ filter,
     //~ false    // include = false. That is, use filter to exclude.
     //~ );
 }

Here is the caller graph for this function:

void HSolveActive::readGates ( )

private

Definition at line 237 of file HSolveActiveSetup.cpp.

References channelId_, gateId_, HSolveUtils::gates(), gCaDepend_, and Field< A >::get().

Referenced by setup().

 {
     vector< Id >::iterator ichan;
     unsigned int nGates = 0;
     int useConcentration = 0;
     for ( ichan = channelId_.begin(); ichan != channelId_.end(); ++ichan )
     {
         nGates = HSolveUtils::gates( *ichan, gateId_ );
         gCaDepend_.insert( gCaDepend_.end(), nGates, 0 );
         useConcentration = Field< int >::get( *ichan, "useConcentration" );
         if ( useConcentration )
             gCaDepend_.back() = 1;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void HSolveActive::readHHChannels ( )

private

Setting up of data structures: Defined in HSolveActiveSetup.cpp

Definition at line 162 of file HSolveActiveSetup.cpp.

References chan2compt_, chan2state_, channel_, channelCount_, channelId_, HSolvePassive::compartmentId_, current_, currentBoundary_, CurrentStruct::Ek, ChannelStruct::Gbar_, Field< A >::get(), HSolveUtils::hhchannels(), ChannelStruct::instant_, ChannelStruct::modulation_, HinesMatrix::nCompt_, ChannelStruct::setPowers(), and state_.

Referenced by setup().

 {
     vector< Id >::iterator icompt;
     vector< Id >::iterator ichan;
     int nChannel = 0;
     double Gbar = 0.0, Ek = 0.0;
     double X = 0.0, Y = 0.0, Z = 0.0;
     double Xpower = 0.0, Ypower = 0.0, Zpower = 0.0;
     int instant = 0;
 
     for ( icompt = compartmentId_.begin(); icompt != compartmentId_.end(); ++icompt )
     {
         nChannel = HSolveUtils::hhchannels( *icompt, channelId_ );
 
         // todo: discard channels with Gbar = 0.0
         channelCount_.push_back( nChannel );
 
         ichan = channelId_.end() - nChannel;
         for ( ; ichan != channelId_.end(); ++ichan )
         {
             channel_.resize( channel_.size() + 1 );
             ChannelStruct& channel = channel_.back();
 
             current_.resize( current_.size() + 1 );
             CurrentStruct& current = current_.back();
 
             Gbar    = Field< double >::get( *ichan, "Gbar" );
             Ek    = Field< double >::get( *ichan, "Ek" );
             X    = Field< double >::get( *ichan, "X" );
             Y    = Field< double >::get( *ichan, "Y" );
             Z    = Field< double >::get( *ichan, "Z" );
             Xpower    = Field< double >::get( *ichan, "Xpower" );
             Ypower    = Field< double >::get( *ichan, "Ypower" );
             Zpower    = Field< double >::get( *ichan, "Zpower" );
             instant    = Field< int >::get( *ichan, "instant" );
             double modulation = Field< double >::get( *ichan, "modulation");
 
             current.Ek = Ek;
 
             channel.Gbar_ = Gbar;
             channel.setPowers( Xpower, Ypower, Zpower );
             channel.instant_ = instant;
             channel.modulation_ = modulation;
 
             /*
              * Map channel index to state index. This is useful in the
              * interface to find gate values.
              */
             chan2state_.push_back( state_.size() );
 
             if ( Xpower > 0.0 )
                 state_.push_back( X );
             if ( Ypower > 0.0 )
                 state_.push_back( Y );
             if ( Zpower > 0.0 )
                 state_.push_back( Z );
 
             /*
              * Map channel index to compartment index. This is useful in the
              * interface to generate channel Ik values (since we then need the
              * compartment Vm).
              */
             chan2compt_.push_back( icompt - compartmentId_.begin() );
         }
     }
 
     int nCumulative = 0;
     currentBoundary_.resize( nCompt_ );
     for ( unsigned int ic = 0; ic < nCompt_; ++ic )
     {
         nCumulative += channelCount_[ ic ];
         currentBoundary_[ ic ] = current_.begin() + nCumulative;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void HSolveActive::readSynapses ( )

private

Reads in SynChans and SpikeGens.

Unlike Compartments, HHChannels, etc., neither of these are zombified. In other words, their fields are not managed by HSolve, and their "process" functions are invoked to do their calculations. For SynChans, the process calls are made by their respective clocks, and hence the process message is not dropped. On the other hand, we drop the SpikeGen process messages here, and explicitly call the SpikeGen process() from the HSolve via a pointer.

Definition at line 538 of file HSolveActiveSetup.cpp.

References ObjId::bad(), HSolvePassive::compartmentId_, SynChanStruct::compt_, Msg::deleteMsg(), SynChanStruct::elm_, Cinfo::findFinfo(), DestFinfo::getFid(), SpikeGen::initCinfo(), HinesMatrix::nCompt_, spikegen_, HSolveUtils::spikegens(), synchan_, HSolveUtils::synchans(), and HSolvePassive::V_.

Referenced by setup().

 {
     vector< Id > spikeId;
     vector< Id > synId;
     vector< Id >::iterator syn;
     vector< Id >::iterator spike;
     SynChanStruct synchan;
 
     for ( unsigned int ic = 0; ic < nCompt_; ++ic )
     {
         synId.clear();
         HSolveUtils::synchans( compartmentId_[ ic ], synId );
         for ( syn = synId.begin(); syn != synId.end(); ++syn )
         {
             synchan.compt_ = ic;
             synchan.elm_ = *syn;
             synchan_.push_back( synchan );
         }
 
         static const Finfo* procDest = SpikeGen::initCinfo()->findFinfo( "process");
         assert( procDest );
         const DestFinfo* df = dynamic_cast< const DestFinfo* >( procDest );
         assert( df );
 
         spikeId.clear();
         HSolveUtils::spikegens( compartmentId_[ ic ], spikeId );
         // Very unlikely that there will be >1 spikegens in a compartment,
         // but lets take care of it anyway.
         for ( spike = spikeId.begin(); spike != spikeId.end(); ++spike )
         {
             spikegen_.push_back(
                 SpikeGenStruct( &V_[ ic ], spike->eref() )
             );
 
             ObjId mid = spike->element()->findCaller( df->getFid() );
             if ( ! mid.bad()  )
                 Msg::deleteMsg( mid );
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void HSolveActive::reinit ( ProcPtr info )

Definition at line 43 of file HSolveActiveSetup.cpp.

References externalCurrent_, reinitCalcium(), reinitChannels(), reinitCompartments(), reinitSpikeGens(), and sendValues().

Referenced by HSolve::reinit().

 {
     externalCurrent_.assign( externalCurrent_.size(), 0.0 );
 
     reinitSpikeGens( info );
     reinitCompartments();
     reinitCalcium();
     reinitChannels();
     sendValues( info );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void HSolveActive::reinitCalcium ( )

private

Definition at line 67 of file HSolveActiveSetup.cpp.

References ca_, caActivation_, and caConc_.

Referenced by reinit().

 {
     caActivation_.assign( caActivation_.size(), 0.0 );
 
     for ( unsigned int i = 0; i < ca_.size(); ++i )
     {
         caConc_[ i ].c_ = 0.0;
         ca_[ i ] = caConc_[ i ].CaBasal_;
     }
 }

Here is the caller graph for this function:

void HSolveActive::reinitChannels ( )

private

Definition at line 78 of file HSolveActiveSetup.cpp.

References ca_, caCount_, caRow_, caRowCompt_, caTable_, channel_, channelCount_, column_, externalCalcium_, LookupTable::lookup(), LookupTable::row(), state_, HSolvePassive::V_, and vTable_.

Referenced by reinit().

 {
     vector< double >::iterator iv;
     vector< double >::iterator istate = state_.begin();
     vector< int >::iterator ichannelcount = channelCount_.begin();
     vector< ChannelStruct >::iterator ichan = channel_.begin();
     vector< ChannelStruct >::iterator chanBoundary;
     vector< unsigned int >::iterator icacount = caCount_.begin();
     vector< double >::iterator ica = ca_.begin();
     vector< double >::iterator caBoundary;
     vector< LookupColumn >::iterator icolumn = column_.begin();
     vector< LookupRow >::iterator icarowcompt;
     vector< LookupRow* >::iterator icarow = caRow_.begin();
     vector< double>::iterator iextca = externalCalcium_.begin();
 
     LookupRow vRow;
     LookupRow dRow;
     double C1, C2;
     for ( iv = V_.begin(); iv != V_.end(); ++iv )
     {
 
         vTable_.row( *iv, vRow );
         icarowcompt = caRowCompt_.begin();
 
         caBoundary = ica + *icacount;
         for ( ; ica < caBoundary; ++ica )
         {
             caTable_.row( *ica, *icarowcompt );
 
             ++icarowcompt;
 
         }
 
         chanBoundary = ichan + *ichannelcount;
         for ( ; ichan < chanBoundary; ++ichan )
         {
 
       caTable_.row( *iextca, dRow );
 
             if ( ichan->Xpower_ > 0.0 )
             {
                 vTable_.lookup( *icolumn, vRow, C1, C2 );
 
                 *istate = C1 / C2;
 
                 ++icolumn, ++istate;
             }
 
             if ( ichan->Ypower_ > 0.0 )
             {
                 vTable_.lookup( *icolumn, vRow, C1, C2 );
 
                 *istate = C1 / C2;
 
                 ++icolumn, ++istate;
             }
 
             if ( ichan->Zpower_ > 0.0 )
             {
                 LookupRow* caRow = *icarow;
 
                 if ( caRow )
                 {
                     caTable_.lookup( *icolumn, *caRow, C1, C2 );
                 }
         else if (*iextca>0)
           caTable_.lookup( *icolumn, dRow, C1, C2 );
                 else
                 {
                     vTable_.lookup( *icolumn, vRow, C1, C2 );
                 }
 
                 *istate = C1 / C2;
 
                 ++icolumn, ++istate, ++icarow;
             }
 
         ++iextca;
         }
 
         ++ichannelcount, ++icacount;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void HSolveActive::reinitCompartments ( )

private

Definition at line 61 of file HSolveActiveSetup.cpp.

References HinesMatrix::nCompt_, HSolvePassive::tree_, and HSolvePassive::V_.

Referenced by reinit().

 {
     for ( unsigned int ic = 0; ic < nCompt_; ++ic )
         V_[ ic ] = tree_[ ic ].initVm;
 }

Here is the caller graph for this function:

void HSolveActive::reinitSpikeGens ( ProcPtr info )

private

Reinit code: Defined in HSolveActiveSetup.cpp

Definition at line 54 of file HSolveActiveSetup.cpp.

References spikegen_.

Referenced by reinit().

 {
     vector< SpikeGenStruct >::iterator ispike;
     for ( ispike = spikegen_.begin(); ispike != spikegen_.end(); ++ispike )
         ispike->reinit( info );
 }

Here is the caller graph for this function:

void HSolveActive::sendSpikes ( ProcPtr info )

private

Definition at line 343 of file HSolveActive.cpp.

 {
     vector< SpikeGenStruct >::iterator ispike;
     for ( ispike = spikegen_.begin(); ispike != spikegen_.end(); ++ispike )
         ispike->send( info );
 }

void HSolveActive::sendValues ( ProcPtr info )

private

This function dispatches state values via any source messages on biophysical objects which have been taken over.

Definition at line 355 of file HSolveActive.cpp.

References CaConcBase::concOut(), ChanBase::IkOut(), and moose::CompartmentBase::VmOut().

Referenced by reinit().

 {
     vector< unsigned int >::iterator i;
 
     for ( i = outVm_.begin(); i != outVm_.end(); ++i ) {
         Compartment::VmOut()->send(
             //~ ZombieCompartment::VmOut()->send(
             compartmentId_[ *i ].eref(),
             V_[ *i ]
         );
     }
 
     for ( i = outIk_.begin(); i != outIk_.end(); ++i ){
 
         unsigned int comptIndex = chan2compt_[ *i ];
 
         assert( comptIndex < V_.size() );
 
         ChanBase::IkOut()->send(channelId_[*i].eref(),
                 (current_[ *i ].Ek - V_[ comptIndex ]) * current_[ *i ].Gk);
 
     }
 
     for ( i = outCa_.begin(); i != outCa_.end(); ++i )
         //~ CaConc::concOut()->send(
         CaConcBase::concOut()->send(
             caConcId_[ *i ].eref(),
             ca_[ *i ]
         );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void HSolveActive::setup	(	Id	seed,
		double	dt
	)

Definition at line 17 of file HSolveActiveSetup.cpp.

References cleanup(), createLookupTables(), manageOutgoingMessages(), readCalcium(), readExternalChannels(), readGates(), readHHChannels(), readSynapses(), and HSolvePassive::setup().

Referenced by HSolve::setup().

 {
     //~ cout << ".. HA.setup()" << endl;
 
     this->HSolvePassive::setup( seed, dt );
 
     readHHChannels();
     readGates();
     readCalcium();
     createLookupTables();
     readSynapses(); // Reads SynChans, SpikeGens. Drops process msg for SpikeGens.
     readExternalChannels();
     manageOutgoingMessages(); // Manages messages going out from the cell's components.
 
     //~ reinit();
     cleanup();
 
     //~ cout << "# of compartments: " << compartmentId_.size() << "." << endl;
     //~ cout << "# of channels: " << channelId_.size() << "." << endl;
     //~ cout << "# of gates: " << gateId_.size() << "." << endl;
     //~ cout << "# of states: " << state_.size() << "." << endl;
     //~ cout << "# of Ca pools: " << caConc_.size() << "." << endl;
     //~ cout << "# of SynChans: " << synchan_.size() << "." << endl;
     //~ cout << "# of SpikeGens: " << spikegen_.size() << "." << endl;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void HSolveActive::step ( ProcPtr info )

Equivalent to process.

Definition at line 45 of file HSolveActive.cpp.

References HSolvePassive::backwardSubstitute(), ProcInfo::dt, and HSolvePassive::forwardEliminate().

Referenced by HSolve::process().

 {
     if ( nCompt_ <= 0 )
         return;
 
     if ( !current_.size() )
     {
         current_.resize( channel_.size() );
     }
 
     advanceChannels( info->dt );
     calculateChannelCurrents();
     updateMatrix();
     HSolvePassive::forwardEliminate();
     HSolvePassive::backwardSubstitute();
     advanceCalcium();
     advanceSynChans( info );
 
     sendValues( info );
     sendSpikes( info );
 
     externalCurrent_.assign( externalCurrent_.size(), 0.0 );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void HSolveActive::updateMatrix ( )

private

Definition at line 86 of file HSolveActive.cpp.

References InjectStruct::injectBasal, InjectStruct::injectVarying, and value.

 {
     /*
      * Copy contents of HJCopy_ into HJ_. Cannot do a vector assign() because
      * iterators to HJ_ get invalidated in MS VC++
      */
     if ( HJ_.size() != 0 )
         memcpy( &HJ_[ 0 ], &HJCopy_[ 0 ], sizeof( double ) * HJ_.size() );
 
     double GkSum, GkEkSum; vector< CurrentStruct >::iterator icurrent = current_.begin();
     vector< currentVecIter >::iterator iboundary = currentBoundary_.begin();
     vector< double >::iterator ihs = HS_.begin();
     vector< double >::iterator iv = V_.begin();
 
     vector< CompartmentStruct >::iterator ic;
     for ( ic = compartment_.begin(); ic != compartment_.end(); ++ic )
     {
         GkSum   = 0.0;
         GkEkSum = 0.0;
         for ( ; icurrent < *iboundary; ++icurrent )
         {
             GkSum   += icurrent->Gk;
             GkEkSum += icurrent->Gk * icurrent->Ek;
         }
 
         *ihs = *( 2 + ihs ) + GkSum;
         *( 3 + ihs ) = *iv * ic->CmByDt + ic->EmByRm + GkEkSum;
 
         ++iboundary, ihs += 4, ++iv;
     }
 
     map< unsigned int, InjectStruct >::iterator inject;
     for ( inject = inject_.begin(); inject != inject_.end(); ++inject )
     {
         unsigned int ic = inject->first;
         InjectStruct& value = inject->second;
 
         HS_[ 4 * ic + 3 ] += value.injectVarying + value.injectBasal;
 
         value.injectVarying = 0.0;
     }
 
     // Synapses are being handled as external channels.
     //~ double Gk, Ek;
     //~ vector< SynChanStruct >::iterator isyn;
     //~ for ( isyn = synchan_.begin(); isyn != synchan_.end(); ++isyn ) {
     //~ get< double >( isyn->elm_, synGkFinfo, Gk );
     //~ get< double >( isyn->elm_, synEkFinfo, Ek );
     //~
     //~ unsigned int ic = isyn->compt_;
     //~ HS_[ 4 * ic ] += Gk;
     //~ HS_[ 4 * ic + 3 ] += Gk * Ek;
     //~ }
 
     ihs = HS_.begin();
     vector< double >::iterator iec;
     for ( iec = externalCurrent_.begin(); iec != externalCurrent_.end(); iec += 2 )
     {
         *ihs += *iec;
         *( 3 + ihs ) += *( iec + 1 );
 
         ihs += 4;
     }
 
     stage_ = 0;    // Update done.
 }

Member Data Documentation

vector< double > HSolveActive::ca_

protected

Ca conc in each pool.

Definition at line 81 of file HSolveActive.h.

Referenced by HSolve::getCa(), readCalcium(), reinitCalcium(), reinitChannels(), and HSolve::setCa().

vector< double > HSolveActive::caActivation_

protected

calcium pool

Ca current entering each

Definition at line 82 of file HSolveActive.h.

Referenced by HSolve::iCa(), readCalcium(), and reinitCalcium().

int HSolveActive::caAdvance_

protected

Solver parameters: exposed as fields in MOOSE caAdvance_: This flag determines how current flowing into a calcium pool is computed. A value of 0 means that the membrane potential at the beginning of the time-step is used for the calculation. This is how GENESIS does its computations. A value of 1 means the membrane potential at the middle of the time-step is used. This is the correct way of integration, and is the default way.

Definition at line 53 of file HSolveActive.h.

Referenced by HSolve::getCaAdvance(), and HSolve::setCaAdvance().

vector< CaConcStruct > HSolveActive::caConc_

protected

Ca pool info.

Definition at line 80 of file HSolveActive.h.

Referenced by HSolve::getCa(), HSolve::getCaBasal(), HSolve::getCaCeiling(), HSolve::getCaFloor(), HSolve::iCa(), readCalcium(), reinitCalcium(), HSolve::setCa(), HSolve::setCaBasal(), HSolve::setCaCeiling(), HSolve::setCaFloor(), and HSolve::setTauB().

vector< Id > HSolveActive::caConcId_

protected

calcium from difshells

Used for localIndex-ing.

Definition at line 123 of file HSolveActive.h.

Referenced by manageOutgoingMessages(), HSolve::mapIds(), readCalcium(), HSolve::unzombify(), and HSolve::zombify().

vector< unsigned int > HSolveActive::caCount_

protected

each compartment

Number of calcium pools in

Definition at line 91 of file HSolveActive.h.

Referenced by createLookupTables(), readCalcium(), and reinitChannels().

vector< int > HSolveActive::caDependIndex_

protected

depdt channel depend upon?

Which pool does each Ca

Definition at line 93 of file HSolveActive.h.

Referenced by cleanup(), createLookupTables(), and readCalcium().

int HSolveActive::caDiv_

protected

Definition at line 68 of file HSolveActive.h.

Referenced by createLookupTables(), HSolve::getCaDiv(), and HSolve::setCaDiv().

double HSolveActive::caMax_

protected

Definition at line 67 of file HSolveActive.h.

Referenced by createLookupTables(), HSolve::getCaMax(), and HSolve::setCaMax().

double HSolveActive::caMin_

protected

Definition at line 66 of file HSolveActive.h.

Referenced by createLookupTables(), HSolve::getCaMin(), and HSolve::setCaMin().

vector< LookupRow* > HSolveActive::caRow_

protected

Points into caRowCompt. For each channel, points to the appropriate pool's LookupRow in the caRowCompt vector. This value is then used by the channel. Also happens in HSolveActive::advanceChannels

Definition at line 104 of file HSolveActive.h.

Referenced by createLookupTables(), and reinitChannels().

vector< LookupRow > HSolveActive::caRowCompt_

protected

Lookup row buffer. For each compartment, the lookup rows for calcium dependent channels are loaded into this vector before being used. The vector is then reused for the next compartment. This vector therefore has a size equal to the maximum number of calcium pools across all compartments. This is done in HSolveActive::advanceChannels

Definition at line 97 of file HSolveActive.h.

Referenced by createLookupTables(), and reinitChannels().

LookupTable HSolveActive::caTable_

protected

Definition at line 88 of file HSolveActive.h.

Referenced by createLookupTables(), and reinitChannels().

vector< double* > HSolveActive::caTarget_

protected

For each channel, which calcium pool is being fed? Points into caActivation.

Definition at line 84 of file HSolveActive.h.

Referenced by readCalcium().

vector< unsigned int > HSolveActive::chan2compt_

protected

Index of the compt to which a given (index) channel belongs.

Definition at line 114 of file HSolveActive.h.

Referenced by HSolve::getIk(), and readHHChannels().

vector< unsigned int > HSolveActive::chan2state_

protected

a state index

Converts a chnnel index to

Definition at line 117 of file HSolveActive.h.

Referenced by HSolve::getX(), HSolve::getY(), HSolve::getZ(), readHHChannels(), HSolve::setX(), HSolve::setY(), and HSolve::setZ().

vector< ChannelStruct > HSolveActive::channel_

protected

to compartment: chan2compt

Vector of channels. Link

Definition at line 76 of file HSolveActive.h.

Referenced by createLookupTables(), HSolve::getHHChannelGbar(), HSolve::getInstant(), HSolve::getX(), HSolve::getY(), HSolve::getZ(), readCalcium(), readHHChannels(), reinitChannels(), HSolve::setHHChannelGbar(), HSolve::setHHmodulation(), HSolve::setInstant(), HSolve::setPowers(), HSolve::setX(), HSolve::setY(), and HSolve::setZ().

vector< int > HSolveActive::channelCount_

protected

compartment

Number of channels in each

Definition at line 109 of file HSolveActive.h.

Referenced by readCalcium(), readHHChannels(), and reinitChannels().

vector< Id > HSolveActive::channelId_

protected

Used for localIndex-ing.

Definition at line 124 of file HSolveActive.h.

Referenced by manageOutgoingMessages(), HSolve::mapIds(), readCalcium(), readGates(), readHHChannels(), HSolve::unzombify(), and HSolve::zombify().

vector< LookupColumn > HSolveActive::column_

protected

to lookup for this species

Which column in the table

Definition at line 95 of file HSolveActive.h.

Referenced by createLookupTables(), and reinitChannels().

vector< CurrentStruct > HSolveActive::current_

protected

Channel current.

Internal data structures. Will also be accessed in derived class HSolve.

Definition at line 73 of file HSolveActive.h.

Referenced by HSolve::getEk(), HSolve::getGk(), HSolve::getIk(), HSolve::getIm(), readHHChannels(), HSolve::setEk(), and HSolve::setGk().

vector< currentVecIter > HSolveActive::currentBoundary_

protected

Used to designate compt boundaries in the current_ vector.

Definition at line 111 of file HSolveActive.h.

Referenced by HSolve::getIm(), and readHHChannels().

vector< double > HSolveActive::externalCalcium_

protected

Definition at line 122 of file HSolveActive.h.

Referenced by HSolve::addConc(), readCalcium(), and reinitChannels().

vector< double > HSolveActive::externalCurrent_

protected

External currents from channels that HSolve cannot internalize.

Definition at line 119 of file HSolveActive.h.

Referenced by HSolve::addGkEk(), readExternalChannels(), and reinit().

vector< Id > HSolveActive::gateId_

protected

Used for localIndex-ing.

Definition at line 125 of file HSolveActive.h.

Referenced by createLookupTables(), and readGates().

vector< bool > HSolveActive::gCaDepend_

protected

depend on Ca conc?

Does the conductance

Definition at line 89 of file HSolveActive.h.

Referenced by cleanup(), createLookupTables(), and readGates().

const int HSolveActive::INSTANT_X = 1

staticprivate

Definition at line 172 of file HSolveActive.h.

const int HSolveActive::INSTANT_Y = 2

staticprivate

Definition at line 173 of file HSolveActive.h.

const int HSolveActive::INSTANT_Z = 4

staticprivate

Definition at line 174 of file HSolveActive.h.

vector< unsigned int > HSolveActive::outCa_

protected

concOut info. Tells you which compartments have external calcium-dependent channels so that you can send out Calcium concentrations in only those compartments.

Definition at line 131 of file HSolveActive.h.

Referenced by manageOutgoingMessages().

vector< unsigned int > HSolveActive::outIk_

protected

Definition at line 135 of file HSolveActive.h.

Referenced by manageOutgoingMessages().

vector< unsigned int > HSolveActive::outVm_

protected

VmOut info. Tells you which compartments have external voltage-dependent channels (if any), so that you can send out Vm values only in those places

Definition at line 127 of file HSolveActive.h.

Referenced by manageOutgoingMessages().

vector< SpikeGenStruct > HSolveActive::spikegen_

protected

Definition at line 78 of file HSolveActive.h.

Referenced by readSynapses(), and reinitSpikeGens().

vector< double > HSolveActive::state_

protected

Fraction of gates open.

Definition at line 74 of file HSolveActive.h.

Referenced by HSolve::getX(), HSolve::getY(), HSolve::getZ(), readHHChannels(), reinitChannels(), HSolve::setX(), HSolve::setY(), and HSolve::setZ().

vector< SynChanStruct > HSolveActive::synchan_

protected

Definition at line 79 of file HSolveActive.h.

Referenced by readSynapses().

int HSolveActive::vDiv_

protected

Definition at line 65 of file HSolveActive.h.

Referenced by createLookupTables(), HSolve::getVDiv(), and HSolve::setVDiv().

double HSolveActive::vMax_

protected

Definition at line 64 of file HSolveActive.h.

Referenced by createLookupTables(), HSolve::getVMax(), and HSolve::setVMax().

double HSolveActive::vMin_

protected

vMin_, vMax_, vDiv_, caMin_, caMax_, caDiv_:

These are the parameters for the lookup tables for rate constants. 'min' and 'max' are the boundaries within which the function is defined. 'div' is the number of divisions between min and max.

Definition at line 63 of file HSolveActive.h.

Referenced by createLookupTables(), HSolve::getVMin(), and HSolve::setVMin().

LookupTable HSolveActive::vTable_

protected

Definition at line 87 of file HSolveActive.h.

Referenced by createLookupTables(), and reinitChannels().

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

moose-core/hsolve/HSolveActive.h
moose-core/hsolve/HSolveActive.cpp
moose-core/hsolve/HSolveActiveSetup.cpp

Public Member Functions

Protected Attributes

Private Types

Private Member Functions

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation