\chapter{Results}


	\hsp{8mm} 
		In this Chapter, we will discuss the results that
		have been gathered from designing and implementing an
		object oriented neocortical simulator. The first half
		of this Chapter  discusses the parallel implementation,
		which includes a subsection discussing the algorithm
		for distributing the data onto multiple nodes within
		the cluster. The next sub-section discusses message
		passing and communication, and the MessageBus object in
		particular. The following section discusses the hardware
		of the system, with a justification for the need of such
		large amounts of RAM and such high-speed interconnection
		network. Then, in sub-section XX, optimization issues are
		discussed and the results of scaling the system. The final
		sub-section of the first half of this Chapter details
		the control flow of the system with a listing of the
		activity of each object that is involved at each stage.

		In the second half of this Chapter, the biological
		accuracy of the simulator is demonstrated. In these
		sub-sections, synaptic dynamics of Redistribution
		of Synaptic Efficacy and Hebbian learning are
		illustrated. There is also a display of the
		membrane dynamics of various channels that have been
		modeled. Finally, in sub-section XX, there is a display
		of the results of auditory processing spoken words.

	\section{Parallel Implementation}

		\hsp{8mm} 
		Because of the potential size of the neural network,
		this simulator was designed to run in parallel. The
		parallel algorithm spreads data across multiple nodes
		and allows for fine or coarse grain communication
		between these nodes. Distribution of the data takes
		place in initialization and consists of aggregating
		specific groups of cells onto a given node. Specifically,
		the program divides the number of layers as evenly as
		possible across all nodes. Connection information is
		maintained by the individual compartments only.

		Inter-cell communication is handled via the MessageBus
		object, which functions as a router for packing and
		delivering of the messages. It encapsulates all of the
		Message Passing Interface (MPI) calls, and can easily
		be swapped out with a MessageBus object employing an
		alternate communication paradigm.


	   \subsection{Message Passing and Communication}
		\hsp{8mm} 
		The MessageBus object is an important object for
		facilitating communication between objects within
		each brain. Through the use of MPI, the current
		implementation handles communication with external
		nodes. The communication scheme of the simulator is best
		described by Figure~\ref{fig:csots}.

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/MsgBusDiagram.ps}}
        \caption{Communication scheme of the simulator} \label{fig:csots}
        \end{figure}


		When a compartment fires an action potential, it
		communicates this event by creating a message for each
		compartment that is to receive this notification. The
		compartment then passes this message either to it's
		parent cell (for intra-cell communication), or to the
		MessageBus (for inter-cell communication). In the former
		case, the parent cell delivers the message to the sibling
		compartment without going through the MessageBus. In the
		latter case, however, the MessageBus takes the message and
		relays it to the cell specified in the message address. 

		If the receiving cell is off-node, it is the
		responsibility of the MessageBus to package this
		information in an MPI data buffer and send it to the
		proper node. Upon receipt of an off-node message, the
		MessageBus unpacks the data from the MPI data buffer,
		stores it in a Message object, and then forwards it to
		the local, recipient cell. 

		The message that is sent between cells contains two
		things (1) a static set of data that is consistent
		for each message, and (2) a dynamic set of data that
		changes depending on the message type. The static data
		set contains the message type, sending address, receiving
		address and timestep (i.e., the message envelope). The
		dynamic data set contains such information as the membrane
		voltage values, external stimuli values, or reporting
		information. 

		The sending and receiving of messages is done using
		blocking sends (\verb+MPI_Send+) and blocking receives
		(\verb+MPI_Recv+). The MessageBus employs an algorithm for
		sending and receiving off-node messages that prevents
		node starvation or deadlock. This algorithm is based
		on a simple all-to-all personalized message exchange as
		described in \cite{kggk:book}. Each node sends a message at each time
		step; the MPI element TAG is utilized to distinguish
		between data messages, empty messages, and multi-part
		messages. The MessageBus exits this stage only when the
		sign off has been given for each node in the cluster. In
		this way, the MessageBus prevents a situation whereby one
		node the cluster has not finished sending its messages
		but the other MessageBuses have finished receiving.

		The MessageBus also uses synchronization to create
		a lock step barrier, so that the brains on different
		nodes reach the MessageBus at the same time, to process
		messages in the same order. This barrier prevents a
		deadlock condition (one MessageBus is sending but no
		other MessageBus is receiving), as well as preventing
		a starvation situation (one MessageBus is receiving,
		but no other nodes are sending). 

	   \subsection{Hardware and Interconnection Network}

		\hsp{8mm} 
		In our model, connectivity between cells drives everything
		from memory and CPU usage to latency in inter-nodal
		communication. The cluster that runs this simulation
		consist of 30 dual-Pentium III 1-GHz processor nodes,
		with 4GB of RAM per node. This hardware architecture
		permits high connectivity (more than 10million synapses
		per node). In addition, Myrinet \cite{myrinet} 
		is utilized to handle the intensity of communication
		that occurs in the fine grain parallel model. 

		Without such a high-bandwidth/low-latency interconnection
		network, the system's communication would saturate at low
		inter-column connectivity. For example, this simulator was
		run on another cluster which consisted of 20 dual Pentium
		II XX MHz processors, each consisting of 512MB of RAM,
		and a dual Fast Ethernet interconnect\cite{datacom}. 
		On this cluster,
		the simulator was able to run with low connectivity (low
		numbers of synapses and messages), but went to swap once
		the number of synapses approached one million per node. 

	   \subsection{Optimization}

		\hsp{8mm} 
		Thus far there have been two major areas of
		optimization. These did not change the interface to any
		other object, but did change the internal implementation
		of the object being optimized. The first change dealt with
		our use of messages. Because there is a direct correlation
		between connectivity and message passing, we needed to
		rethink the message allocation and de-allocation within
		the system. 

		When we first implemented the simulator, the
		messages were created and deleted as the simulation
		progressed. Profiling of the simulator showed that
		this was a very time consuming task and so the following
		optimization was made. A MessageManager object was created
		as a warehouse of message data. During initialization
		of the program, the MessageManager allocates all of
		the messages that will be utilized throughout the
		entire run. The amount to be allocated is dependent
		on 1) the number of synapses, 2) the number of cells
		receiving stimulus, and 3) the number of cells receiving
		reports. Since all three of these objects utilize the
		MessageBus for message passing, a maximum of all three
		quantities denotes the maximum number of messages that
		could be passed at each time step. In case there is
		a need for more messages, however, the MessageManager
		can allocate more messages if they are needed at any
		point in the simulation. Because multiple threads access
		this shared message pool, the MessageManager utilizes a
		system semaphore to block access to the pool when this
		re-allocation is occurring.

		In terms of functionality, the MessageManager wraps the
		``new'' and ``delete'' function calls, and merely returns a
		pointer to the next available message in the queue. If
		no more memory can be allocated, the MessageManager
		returns a NULL value. This optimization resulted in a 30\%
		increase in performance time.

		Another important optimization was the breaking
		down of the Synapse object into static and dynamic
		parts. Initially, the synapse object was instantiated with
		both parts, but profiling showed that each synapse was
		approaching 1500 bytes in size. This was a huge amount
		of memory being allocated, considering that a modest
		simulation has approximately 1.5 million synapses. 

		In reviewing the data required for the synapses, we
		noticed that there was only a small amount that  was
		absolutely necessary within the synapse itself. This
		small amount was kept in the local synapse object as a
		dynamic data set. The rest of the data was deemed to be
		unchanging and pulled out into the brain object where only
		one copy was instantiated. The brain object now provides
		wrapper functions for this data set. This reduction of
		the synapse object to 120 bytes allows the simulator to
		accommodate larger quantities of synapses, and therefore,
		larger and more highly connected cellular networks. 

	   \subsection{Scaling and Performance Analysis}

		\hsp{8mm} 
		In order to test scaling of network size, several
		test cases were run both sequentially and then in
		parallel. In each test case, connectivity was the
		driving factor. For the sequential test cases, a single
		column was created based upon biological data gathered
		from \cite{hm:hmagupd}. The connectivity ranged from a ``full column,''
		which constituted approximately 1.5 million synapses
		to a ``mini-column,'' which contained approximately
		800,000 synapses; to a ``micro-column,'' which contained
		approximately 34,000 synapses. These test cases were
		run on both cortex (the 30 node 4GB RAM/node cluster)
		and on hercules (the 20 node 512 MB RAM/node cluster).

		Figure~\ref{fig:etvsohc} shows these results plotted against each
		other. As one can see there is a faster execution
		time on cortex which is associated with its faster
		processor. This is to be expected, however, when the
		synapse count exceeds 1million per node, hercules
		must go to swap to accommodate the required memory
		allocations, and this causes its performance time to
		slow down tremendously. This simulation was stopped
		after it had reached only timestep 100 (out of 5,000)
		after approximately 3 days of running. 

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/Cortex_Hercules_SynVsExecTime.ps}}
        \caption{Execution time versus synapses on Hercules and Cortex using
Ethernet} \label{fig:etvsohc}
        \end{figure}

		To test the inter-connection network, several test
		cases were run on both the Ethernet (dual 100Mbps) and
		the Myrinet interconnect. Connectivity was modulated in
		each case. A five column run, fifteen column run, and a
		thirty column run were performed using three different
		cell connection schemes. In the first scheme, the multiple
		columns were daisy-chained together, with only the first
		column receiving external stimulus. Figure~\ref{fig:srocum} 
		shows the results of these simulations for each node quantity. 

		In the second scheme, the multiple columns were connected
		n(n-1) with a constant probability (i.e., same probability
		of connection across all nodes). Figure~\ref{fig:srocuewvcs} 
		shows the results of this across all nodes. As can be seen,
		there is a slow down in performance as the connection
		bottlenecks on the Ethernet.

		In the third connection scheme, the multiple columns were
		connected n(n-1) with a radial probability centering
		around the node receiving external stimuli. This means
		that the columns in closest proximity to the central
		column are connected with a higher probability, to each
		other and to the central node. As the distance from the
		central column increases, the probability of connection
		decreases. 

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/junk.ps}}
        \caption{Scaling results on Cortex using Myrinet with various connection schemes.} \label{fig:srocum}
        \end{figure}

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/ExecTimeVsNodes.ps}}
        \caption{Scaling results on Cortex using Ethernet with various connection schemes.} \label{fig:srocuewvcs}
        \end{figure}


	   \subsection{Control Flow}

		\hsp{8mm} 
		The control flow of the cortical simulator consists of
		three major stages: initialization, brain computation,
		and post-processing of the data. Each stage and its
		constituent parts are discussed in some detail within
		this section. 

		The initialization stage is handled by the
		InitializationManager and is implemented as a factory
		model. Initialization occurs on all of the nodes
		concurrently. In designing the system, we decided to
		duplicate work across processes in order to save idle time
		on non-root nodes, as well as to avoid communicating the
		CellConnectionMatrix once it had been instantiated. Each
		step in initialization is contingent on successful
		completion of the previous steps, and the program may exit
		at any point in this process if an error is detected.

		The first step of initialization is the reading and
		parsing of the input file. This file contains templates
		for biological data structures (i.e., cells, channels,
		synapses, columns, layers, brain, etc.), functional units
		(such as reports, stimulus), and connectivity. The data
		from the input file is stored in temporary variables
		which utilize the dynamic memory allocation of Standard
		Template Library (STL) vectors. 

		The second step of initialization is the displaying of
		values to the user. The DisplayObject object, if requested
		by the user, will prompt the user to accept/reject the
		configuration that has just been read in. 

		The third step of initialization is the error checking
		of the temporary variables. The ErrorCheck object is
		responsible for examining the data for consistency and
		biological accuracy. In case of errors in the input,
		this object will display the incorrect variable along
		with the correct range for that variable, before exiting
		the program. 

		The fourth step in initialization lays the groundwork
		for parallelization of the simulation. This step is
		handled by the CreateConnectMatrix object, which is
		responsible for filling in the global connectivity
		matrix. CreateConnectMatrix utilizes the connection
		schemes that were specified by the user and stores this
		information in the CellManager object. The CellManager
		holds the groups of cell types, their location in the
		brain (node number, column and layer), and their global
		cell identification values. The CreateConnectMatrix
		object updates each cell list in the CellManager with
		the constituent cell connections. 

		The fifth step creates the DistributionManager object,
		which uses the connection information now stored in the
		CellManager to distribute the various cell groups onto
		the nodes within the cluster. During this process the
		DistributionManager updates the CellManager with the
		node number for each cell group. The CellManager can
		then be used by the MakeObjects object to instantiate
		the cell objects. 

		The sixth step in initialization is handled by the
		MakeObjects object, which instantiate each object from
		the biological template provided by the user. Each node in
		the cluster has a MakeObjects object which is responsible
		for checking the current machine number, and making
		only those cells which are situated on that particular
		node. The CellManager object is utilized heavily for this
		task since it stores the node address of each cell being
		instantiated. This step creates the data parallelization
		of the cortical simulator. The global cell list is now
		a virtual global list, in which its constituent parts
		are spread out among different nodes within the cluster. 

		The last step in initialization is handled by the
		ConnectionManager object and consists of making
		the connections between the cell/compartments in
		the brain. Each node loops through it's local cell
		list and fills in the connection matrix for the given
		cell/compartment. One synapse object is instantiated
		for each connection, and it is owned by the receiving
		(post-synaptic) cell/compartment. The MessageBus is
		employed at this point to allow the compartments to
		communicate and process the synaptic ID values of their
		connecting cell/compartment.

		After the initialization stage is complete, each
		constituent helper object is deleted. The brain objects
		on each node are then synchronized before beginning the
		next stage of the simulation and the file I/O thread is
		launched. The simulator is now ready to proceed to the
		main computational loop. 

		On each timestep, the brain visits the objects that it
		contains. These include the stimulus, report, MessageBus
		(which is actually a global object, but is pointed to
		by the brain), and each local cell. The cells then visit
		their constituent compartments, which, in turn,  process
		the integrate-and-fire routines mentioned previously. 

		The third stage of the simulator takes place either once
		the brain object has completed its pre-determined number
		of cycles or once a report has completed its duration and
		the temporary file has been closed. This stage consists
		of using the PostProcessing object to reformat the output
		data files into a more user friendly context. Once the
		final stage has been completed, the simulation deletes
		all allocated memory and the program terminates.

	\section{Biological Accuracy}

	   \subsection{Synaptic Dynamics}

	   \paragraph{Redistribution of Synaptic Efficacy}
		In order to test the Redistribution of Synaptic Efficacy
		algorithm, a stimulus of a preset pattern was injected
		into a single cell. This stimulus consisted of six pulses
		of amplitude 2.1nA sustained for 0.002 seconds each,
		followed by a 0.5 second pause, and then a final single
		pulse of the same amplitude and width as before. This
		pulse injects enough sustained current into the recipient
		cell to induce an action potential. This cell was then
		connected to on other cell and the membrane voltage of
		the post-synaptic cell was measured to determine if the
		PSC waveform had been affected by the input stimuli. 

		The next four figures show the results of these runs with various
		synaptic, RSE dynamics turned on. Figure~\ref{fig:cvwnrsee} 
		shows a
		baseline activity with no dynamics turned on. As one can
		see, the membrane voltage remains peaked at a constant
		value, reflecting that the PSC was not modified in any
		way. 

		Figure~\ref{fig:cvwrsefe} shows the cell voltage when 
		the synapse has
		facilitation time constants higher that the depression
		time constants, and that the \verb+U_mean+ has room to
		grow. With each incoming spike, the synapse releases
		more neurotransmitters (it is facilitated to do so),
		and after a pause, the synapse has recovered its quantity
		of neurotransmitters. 

		Figure~\ref{fig:cvwrsede}  shows the cell voltage when 
		the synapse has
		depression time constants higher than facilitating
		ones, and when the \verb+U_mean+ has a higher initial value,
		and has room to degrade. With each incoming spike,
		the synapse releases less and less neurotransmitters
		(its effectiveness if depressed), and after a
		pause, the synapse has recovered  some quantity of
		neurotransmitters. This the synaptic PSC waveform has a
		lower amplitude each time, affecting the post-synaptic
		cell less and less with each spike in a train. We can
		see that the amplitudes of the cell voltage waveforms
		decrease over the six pulses. 

		Figure~\ref{fig:cvwrsefade}  shows the cell voltage when 
		both facilitation
		and depression dynamics are active. This shows the
		neurotransmitters degrading at first and then reaching a
		steady state value. After a pause, however, the synapse
		has recovered its neurotransmitters. 

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_RSE_None.ps}}
        \caption{Cell Voltage with no RSE enabled.} \label{fig:cvwnrsee}
        \end{figure}

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_RSE_Facil.ps}}
        \caption{Cell Voltage with RSE Facilitation enabled.} \label{fig:cvwrsefe}
        \end{figure}

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_RSE_Depr.ps}}
        \caption{Cell Voltage with RSE Depression enabled.} \label{fig:cvwrsede}
        \end{figure}

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_RSE_Both.ps}}
        \caption{Cell Voltage with RSE Facilitation and Depression enabled.} \label{fig:cvwrsefade}
        \end{figure}

	   \paragraph{Hebbian Learning in Synapses}
		To test learning, a similar network topology was
		employed using two cells connected point to point. In
		this case, however, both the pre- and post-synaptic cells
		are receiving an external stimulus. This stimulus is a
		pulse set at 2.1 nA with a sustained width of 0.002 and
		delivered as six pulses, a 0.5 second pause, and then a
		final pulse. These stimuli are sent to the pre0synaptic
		cell, and then the same pulse waveform is sent to the
		post-synaptic cell, but this stimulus is shifted in
		time. 

		The direction of this shift determines how the learning is
		tested. For example, to test positive Hebbian learning,
		we want to positively reinforce the connection between
		the two cells. This means forcing the post-synaptic cell
		to fire an action potential within the positive Hebbian
		window occurring after the pre-synaptic cell has fired a
		spike. We shifted the inject time of the post-synaptic
		input stimulus	to coincide with the positive Hebbian
		learning window. This causes the post-synaptic cell
		to strengthen the connection (increasing the \verb+U_mean+)
		with the pre-synaptic cell. 

		Conversely, to test negative Hebbian learning, the
		pre-synaptic cell is given the stimulus that causes it
		to spike and therefore send a signal to the post-synaptic
		cell. This post-synaptic cell receives a stimulus within
		the negative Hebbian learning window (which occurs before
		the spike of the pre-synaptic cell). This causes the
		post-synaptic cell to weaken the connection with the
		pre0synaptic cell (decreasing the \verb+U_mean+). 

		In Figure~\ref{fig:cvwnle}, we show a baseline of cell voltage with
		no learning dynamics turned on. As one can see, the
		cell spikes at regular intervals (corresponding to its
		stimulus injection), and that its membrane voltage has
		minor peaks outside those spikes. These minor peaks
		correspond to the input from the pre-synaptic cell, and
		since there is no modification of the synaptic \verb+U_mean+,
		the peak of each of these remains constant.

		In Figure~\ref{fig:cvwphle}, we show the results of positive Hebbian
		learning. The post-synaptic cell fires after receiving a
		pre-synaptic input, and the connection is strengthened by
		increasing the \verb+U_mean+. This can be seen in the increase
		in amplitude of the cell voltage (minor) waveforms. 

		In Figure~\ref{fig:cvwnhle}, we show the results of negative Hebbian
		learning. The post-synaptic cell fires before it receives
		pre-synaptic input, and this connection is weakened by
		decreasing the \verb+U_mean+ value. This can be seen in the
		gradual decrease of the non-spike cell voltage waveform
		amplitudes. 

		Figure~\ref{fig:cvwpanhle} shows the results of both positive and
		negative Hebbian learning. the post-synaptic cell fires
		within a window that sometimes corresponds to the negative
		Hebbian window, which weakens the connection between the
		two cells. At other times, the post-synaptic cell fires
		within a window that corresponds to the positive Hebbian
		learning window, which strengthens the connection. This
		can be seen in the graph where the amplitude of the cell
		voltage waveforms (non-spike) oscillate between higher
		and lower peak values. 

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_Learn_None.ps}}
        \caption{Cell Voltage with no learning enabled.} \label{fig:cvwnle}
        \end{figure}

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_Learn_PosHebb.ps}}
        \caption{Cell Voltage with positive Hebbian learning enabled.} \label{fig:cvwphle}
        \end{figure}

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_Learn_NegHeb.ps}}
        \caption{Cell Voltage with negative Hebbian learning enabled.} \label{fig:cvwnhle}
        \end{figure}

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_Learn_BothHeb.ps}}
        \caption{Cell Voltage with positive and negative Hebbian learning
enabled.} \label{fig:cvwpanhle}
        \end{figure}

	   \subsection{Channel Dynamics}


		\hsp{8mm} 
		To test the channel dynamics, a series of pulses were
		input into a single cell model. This cell contained
		the channel to be tested, and the input pattern of an
		800ms pulse width of 0.03 nA, and then a 200mS gap of
		no input stimulus followed by a second 800 micro-second
		pulse of 0.07nA. The tau values, the half min values,
		the slope factors, and the strengths were modified to
		get the results necessary to comply with the biological
		accuracy presented in \cite{syn:opfadogabaiasitn}.

		In Figure~\ref{fig:cvwnc}, we show the cell activity 
		when there are
		no channels in the compartment. As one can see in the
		second half of the simulation (after 15,000 timesteps),
		the cell has an average spiking rate of 20Hz. This figure
		is a baseline for comparison of the activity of the cell
		when certain channels are being modeled. 

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_NoChannels.ps}}
        \caption{Cell Voltage with no channels.\cite{jbm:cdjbm}} \label{fig:cvwnc}
        \end{figure}

		In Figure~\ref{fig:cvwbac}, we show the cell activity when a bursting
		channel is employed in the cell. This is done by modeling
		a Sodium ($Na^{+}$) channel in addition to an AHP channel. The
		$Na^{+}$ channel is modeled as a modified A channel where the
		reversal potential is changed from -80mV to 100mV. It
		can be seen from this figure that because of the  $Na^{+}$
		channel, there is bursting behavior, but when the  $Na^{+}$
		channel shuts off, the AHP channel then accommodates
		the cell behavior. 

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_bAC_Channel.ps}}
        \caption{Cell Voltage with bursting accommodating channel (bAC).\cite{jbm:cdjbm}} \label{fig:cvwbac}
        \end{figure}

		In Figure~\ref{fig:cvwcac}, we show the cell activity when we have
		a classic accommodating behavior. In this case, we
		modeled this by using an AHP channel, and one can see
		from the figure that there is a gradual suppression of
		cell spiking resulting in a steady state being reached
		around timestep 15,000. 

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_cAC_Channel.ps}}
        \caption{Cell Voltage with classic accommodating channel (cAC).
\cite{jbm:cdjbm}} \label{fig:cvwcac}
        \end{figure}

		In Figure~\ref{fig:cvwcnac}, we show a classic non-accommodating
		behavior using an M channel to model it. As can be seen,
		the cell reaches steady state very quickly, which is what
		it means to be non-accommodating, since accommodating
		behavior takes longer to reach steady state.

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_cNAC_Channel.ps}}
        \caption{Cell Voltage with classic non-accommodating channel (cNAC) \cite{jbm:cdjbm}.} \label{fig:cvwcnac}
        \end{figure}

		In Figure~\ref{fig:cvwdnac} we show the cell activity with a delayed
		non-accommodating channel in use. This was modeled
		using an A channel, which activates sub-threshold with
		a fast time constant for the m-particle (suppressing
		cell firing). Since the h particle has a slower time
		constant, it gradually shuts down this channel, which
		allows it to spike. So the name comes from the delay
		(d) in spiking and the non-accommodating behavior can
		be seen in the constant inter-spike interval.

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_dNAC_Channel.ps}}
        \caption{Cell Voltage with delayed non-accommodating channel (dNAC)
		\cite{jbm:cdjbm}.} \label{fig:cvwdnac}
        \end{figure}

		Figure~\ref{fig:cvwcstut} shows the cell behavior when a classic
		stuttering channel is employed. This is modeled using
		a  SIK channel, which is a Supra-threshold Inactivaing
		Potassium ($K^{+}$) channel (using the A channel dynamics). In
		this case, the m particle does not open until the cell
		spikes (as can be seen in the figure, from time steps
		[14,000..15,000] ), which causes the channel top open,
		and thus to suppress cell spiking activity (as can be
		seen in the figure, from timesteps [15,000..18,000]). Then
		the h particle becomes effective in closing the channel,
		which allows spiking, and this process repeats itself. 

		The SIK channel shows the h and m particles interacting,
		and that the half-min values are set so that the
		effectiveness of the channel occurs after threshold has
		been reached. 

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/CellVolt_cSTUT_Channel.ps}}
        \caption{Cell Voltage with classic stuttering channel (cSTUT).} \label{fig:cvwcstut}
        \end{figure}

	   \subsection{Auditory Processing}
		\hsp{8mm} 
		Another test case of the simulator is the spike encoding
		of an auditory word as spoken by the author. The word
		spoken was ``About'' and it was saved as a text file of
		various decibels listed at specific frequencies across
		the time axis. This auditory file is first converted
		from decibels to a normalized sequence of numbers,
		then to a user specified frequency, then to a spike
		probability matrix, and then finally transformed into
		stimulus objects which fire only at a specific times and
		to a predetermined set of cells. For more information
		on the results of auditory processing in our simulator,
		please see\cite{nn:lspsoprmsc}.

		In Figure~\ref{fig:mooswa}, we show the audio (decibel) display of
		the word ``About.'' The three distinct phonemes (/A/,
		/BOU/, /T/) can be seen in this image. Figure~\ref{fig:seoswa} shows
		the spike encoding of this word in approximately 1300
		cells that received this input. Because the word ``About''
		is spread out over time (approximately 0.5 seconds),
		this figure shows the spike activity of the cells over that
		0.5 second interval. Figure~\ref{fig:dposeswa} shows a density plot of
		the same spike encoded word.  The three phonemes can be seen in
		timesteps [1..1,000] (/A/), timesteps [2,000..3,500]
		(/BOU/), and timesteps [4,800..5,000] (/T/). 


        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/XAbout.ps}}
        \caption{MatLab Output of spoken word ``about'' \cite{phg:matlab}.} \label{fig:mooswa}
        \end{figure}

        \begin{figure}
        \epsfxsize=6in
        \centerline{\epsffile{chap04/cell_volt_about.ps}}
        \caption{Spike Encoding of of spoken word ``about'' \cite{phg:matlab}.} \label{fig:seoswa}
        \end{figure}

        \begin{figure}
        \epsfxsize=6in
       \centerline{\epsffile{chap04/About_Density.ps}}
        \caption{Density plot of spike encoded spoken word ``about''
\cite{phg:matlab}.} \label{fig:dposeswa}
        \end{figure}

