HSolveStruct.cpp

/**********************************************************************
** This program is part of 'MOOSE', the
** Messaging Object Oriented Simulation Environment.
**           copyright (C) 2003-2007 Upinder S. Bhalla. and NCBS
** It is made available under the terms of the
** GNU Lesser General Public License version 2.1
** See the file COPYING.LIB for the full notice.
**********************************************************************/

#include <cmath>
#include "header.h"
#include "../biophysics/SpikeGen.h"
#include "HSolveStruct.h"

void ChannelStruct::setPowers(
	double Xpower,
	double Ypower,
	double Zpower )
{
	Xpower_ = Xpower;
	takeXpower_ = selectPower( Xpower );
	
	Ypower_ = Ypower;
	takeYpower_ = selectPower( Ypower );
	
	Zpower_ = Zpower;
	takeZpower_ = selectPower( Zpower );
}

double ChannelStruct::powerN( double x, double p )
{
	if ( x > 0.0 )
		return exp( p * log( x ) );
	return 0.0;
}

PFDD ChannelStruct::selectPower( double power )
{
	if ( power == 0.0 )
		return powerN;
	else if ( power == 1.0 )
		return power1;
	else if ( power == 2.0 )
		return power2;
	else if ( power == 3.0 )
		return power3;
	else if ( power == 4.0 )
		return power4;
	else
		return powerN;
}

void ChannelStruct::process( double*& state, CurrentStruct& current )
{
	double fraction = 1.0;
	
	if( Xpower_ > 0.0 )
		fraction *= takeXpower_( *( state++ ), Xpower_ );
	if( Ypower_ > 0.0 )
		fraction *= takeYpower_( *( state++ ), Ypower_ );
	if( Zpower_ > 0.0 )
		fraction *= takeZpower_( *( state++ ), Zpower_ );
	
	current.Gk = Gbar_ * fraction;
}

void SpikeGenStruct::reinit( ProcPtr info  )
{
	SpikeGen* spike = reinterpret_cast< SpikeGen* >( e_.data() );
	
	spike->reinit( e_, info );
}

void SpikeGenStruct::send( ProcPtr info  )
{
	SpikeGen* spike = reinterpret_cast< SpikeGen* >( e_.data() );
	
	spike->handleVm( *Vm_ );
	spike->process( e_, info );
}

CaConcStruct::CaConcStruct()
	:
		c_( 0.0 ),
		CaBasal_( 0.0 ),
		factor1_( 0.0 ),
		factor2_( 0.0 ),
		ceiling_( 0.0 ),
		floor_( 0.0 )
{ ; }

CaConcStruct::CaConcStruct(
	double Ca,
	double CaBasal,
	double tau,
	double B,
	double ceiling,
	double floor,
	double dt )
{
	setCa( Ca );
	setCaBasal( CaBasal );
	setTauB( tau, B, dt );
	ceiling_ = ceiling;
	floor_ = floor;
}

void CaConcStruct::setCa( double Ca ) {
	c_ = Ca - CaBasal_;
}

void CaConcStruct::setCaBasal( double CaBasal ) {
	/*
	 * Also updating 'c_' here, so that only 'CaBasal' changes, and 'Ca'
	 * remains the same. This is good because otherwise one has to bother about
	 * the order in which 'setCa()' and 'setCaBasal()' are called.
	 * 
	 * 'Ca' is:
	 *         Ca = CaBasal_ + c_
	 * 
	 * if:
	 *         Ca_new = Ca_old
	 * 
	 * then:
	 *         CaBasal_new + c_new = CaBasal_old + c_old
	 * 
	 * so:
	 *         c_new = c_old + CaBasal_old - CaBasal_new
	 */
	c_ += CaBasal_ - CaBasal;
	CaBasal_ = CaBasal;
}

void CaConcStruct::setTauB( double tau, double B, double dt ) {
	factor1_ = 4.0 / ( 2.0 + dt / tau ) - 1.0;
	factor2_ = 2.0 * B * dt / ( 2.0 + dt / tau );
}

double CaConcStruct::process( double activation ) {
	c_ = factor1_ * c_ + factor2_ * activation;
	
	double ca = CaBasal_ + c_;
	
	if ( ceiling_ > 0 && ca > ceiling_ ) {
		ca = ceiling_;
		setCa( ca );
	}
	
	if ( ca < floor_ ) {
		ca = floor_;
		setCa( ca );
	}
	
	return ca;
}