Object Type: Ca_concen
Description: Single pool model for Ca concentration.
Author: M. Wilson, Caltech (2/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Ca_concen_type [in src/segment/seg_struct.h]
Size: 112 bytes
Fields: tau time constant of decay
Ca_base resting (base level) concentration
B equals 1/(ion_charge * Faraday * volume)
Ca Resulting concentraton of Ca++ ions
C Intermediate result, Ca - Ca_base
thick Holds thickness of shell (used by readcell)
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: CaConcen [in src/segment/Ca_concen.c]
Classes: concentration segment
Actions: INIT
PROCESS
RESET
CHECK
SAVE2
RESTORE2
Messages: I_Ca Ik Receives ionic current Ik from a channel
BASE Ca_base Sets Ca_base with a message
fI_Ca Ik fraction Receives fractional current Ik*fraction
INCREASE delta_Ik Add delta_Ik to incoming current
DECREASE delta_Ik Subtract delta_Ik from incoming current
------------------------------------------------------------------------------
Notes: Single shell model for Ca concentration.
Solves dC/dt = B*Ik - C/tau.
Ca = Ca_base + C.
In SI units, where concentration is moles/m^3
(milli-moles/liter) and current is in amperes, theory gives B
= 5.2e-6/(shell volume). In practice, B is a parameter to be
fitted or estimated from experiment, as buffering, non-uniform
distribution of Ca, etc., will modify this value. If thick =
0, the readcell routine calculates B by dividing the "density"
parameter in the cell parameter file by the volume of the
compartment. Otherwise, it scales as a true shell, with the
volume of a shell having thickness thick. A negative value of
the "density" parameter may be used to indicate that it should
be taken as an absolute value of B, without scaling.
Example: see Scripts/burster
See also:
readcell
OBJECT KPORES 3/14/92 (AS)
DESCRIPTION:
Simulates a population of potassium ion channel proteins (pores)
embedded in a patch of membrane over an isopotential region. Each
individual pore undergoes standard Markov kinetics through a five state
scheme:
4an-> 3an-> 2an-> an->
[n0]---------[n1]---------[n2]---------[n3]---------[n4]
<-bn <-2bn <-3bn <-4bn
where [n4] = Open State and an and bn have voltage dependencies
given by:
an = (alpha_A + alpha_B*Vk)/(alpha_C + exp((alpha_D+Vk)/alpha_F))
bn = (beta_A + beta_B*Vk)/(beta_C + exp((beta_D+Vk)/beta_F))
The total population of pores is given by Nt.
The total number of pores within each of the five stable states
at any given iteration is given by n0, n1, n2, n3, n4, respectively.
The total number of pores in the open stable state is given
by No = n4.
The open state conductance of a pore is given by Gmax.
The effective conductance for the population of pores at any
given iteration is then Gk = Gmax*No.
SPECIFICATIONS:
FUNCTION KPorePop()
DATA STRUCTURE K_pore_type
CLASS segment membrane
SIZE ?? bytes
AUTHOR A. Strassberg Caltech 3/92
ACTIONS:
CHECK null
RESET sets initial distribution of pores into the various stable
states based upon the equilibrium solutions to the Markov
matrix for given Vk.
PROCESS updates the distribution of the stable states of the
population based upon the rate constants an and bn, derived
from the current transmembrane voltage Vk.
INIT null
MESSAGES:
VOLTAGE sends transmembrane voltage Vk to the population of pores.
This Vk is used to update the state distribution after each
iteration.
FIELDS:
See DESCRIPTION
RELATED COMMANDS/TOPICS:
Napores
ERROR MESSAGES:
BUGS:
NOTES:
See Strassberg and DeFelice, 1993, Neural Computation 5:6
and the demonstration scripts in Scripts/examples/pore
Object Type: Mg_block
Description: Implementation of voltage- and [Mg]-dependent
blocking of a channel.
Author: E. De Schutter, Caltech (11/90)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Mg_block_type [in src/segment/seg_struct.h]
Size: 120 bytes
Fields: Ik blocked value of current
Gk blocked value of current
Ek blocked value of current k
Zk charge; may also be used as
{charge / relative fraction of I},
e.g. 2/(Ica/Itot) -> msg to difpool
KMg_A A-factor K(v) in eq'n for Mg block reaction
KMg_B B-factor K(v) in eq'n for Mg block reaction
CMg [Mg] in mM
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: MgBlock [in src/segment/Mg_block.c]
Classes: segment channel
Actions: INIT [INIT does nothing]
PROCESS
RESET
CHECK
Messages: VOLTAGE Vm voltage from the compartment
CHANNEL Gk Ek unblocked Gk and Ek from compartment
CHANNEL1 Gk
CHANNEL2 Gk Ek
CHARGE Zk
------------------------------------------------------------------------------
Notes: An Mg_block element may be interposed between a synaptically
activated channel (a synchan or hebsynchan) and a compartment.
This calculates a blocked value of Gk that is reduced from
the incoming Gk by a factor of A/(A + [Mg]*exp(-Vm/B)).
The example below puts this in the form of the Zador, Koch,
and Brown equation [Proc. Natl. Acad. Sci. USA 10:6718-6722
(1990)], with A = 1/eta and B = 1/gamma.
Example:
float CMg = 2 // [Mg] in mM
float eta = 0.33 // per mM
float gamma = 60 // per Volt
create synchan {compartment}/{channel}
setfield ^ \
Ek {Ek} \
tau1 {tau1} \
tau2 {tau2} \
gmax {gmax}
create Mg_block {compartment}/{channel}/block
setfield ^ \
CMg {CMg} \
KMg_A {1.0/eta} \
KMg_B {1.0/gamma}
addmsg {compartment}/{channel} {compartment}/{channel}/block \
CHANNEL Gk Ek
addmsg {compartment}/{channel}/block {compartment} CHANNEL Gk Ek
addmsg {compartment} {compartment}/{channel}/block VOLTAGE Vm
// Even though the channel current isn't used, CHECK expects this message
addmsg {compartment} {compartment}/{channel} VOLTAGE Vm
See also:
synchan
OBJECT NAPORES 3/14/92 (AS)
DESCRIPTION:
Simulates a population of sodium ion channels proteins (pores) embedded
in a patch of membrane over an isopotential region. Each individual pore
undergoes standard Markov kinetics through an eight state scheme:
3am-> 2am-> am->
[m0h1]---------------[m1h1]---------------[m2h1]---------------[m3h1]
| <-bm | <-2bm | <-3bm |
| | | |
/\ | /\ | /\ | /\ |
ah | bh ah | bh ah | bh ah | bh
| \/ | \/ | \/ | \/
| | | |
| 3am-> | 2am-> | am-> |
[m0h0]---------------[m1h0]---------------[m2h0]---------------[m3h0]
<-bm <-2bm <-3bm
where [m3h1] = Open State and am, bm, ah and bh have voltage
dependencies given by:
am = (malpha_A + malpha_B*Vk)/(malpha_C + exp((malpha_D+Vk)/malpha_F))
bm = (mbeta_A + mbeta_B*Vk)/(mbeta_C + exp((mbeta_D+Vk)/mbeta_F))
ah = (halpha_A + halpha_B*Vk)/(halpha_C + exp((halpha_D+Vk)/halpha_F))
bh = (hbeta_A + hbeta_B*Vk)/(hbeta_C + exp((hbeta_D+Vk)/hbeta_F))
The total population of pores is given by Nt. The total number of pores
within each of the eight stable states at any given iteration is given by
m0h0, m1h0, m2h0, m3h0, m0h1, m1h1, m2h1, and m3h1, respectively. The
total number of pores in the open stable state is given by No = m3h1.
The open state conductance of a pore is given by Gmax. The effective
conductance for the population of pores at any given iteration is then
Gk = Gmax*No.
SPECIFICATIONS:
FUNCTION NaPorePop()
DATA STRUCTURE Na_pore_type
CLASS segment membrane
SIZE ?? bytes
AUTHOR A. Strassberg Caltech 3/92
ACTIONS:
CHECK null
RESET sets initial distribution of pores into the various stable
states based upon the equilibrium solutions to the Markov
matrix for given Vk.
PROCESS updates the distribution of the stable states of the
population based upon the rate constants an and bn, derived
from the current transmembrane voltage Vk.
INIT null
MESSAGES:
VOLTAGE sends transmembrane voltage Vk to the population of pores.
This Vk is used to update the state distribution after each
iteration.
FIELDS:
See DESCRIPTION
RELATED COMMANDS/TOPICS:
Kpores
ERROR MESSAGES:
BUGS:
NOTES:
See Strassberg and DeFelice, 1993, Neural Computation 5:6
and the demonstration scripts in Scripts/examples/pore
Object Type: PID
Description: PID (proportional, integral, derivative) feedback controller
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: PID_type [in src/user/user_struct.h]
Size: 144 bytes
Fields: cmd inputs the command (desired) value of sns
sns inputs the sensed (measured) value
output = gain*(e + tau_d*de/dt + 1/tau_i * e_integral)
gain determines the sensitivity of the controller
tau_i integration time constant, typically = dt
tau_d derivative time constant, typically = dt/4
saturation sets permissible range of output
e internal variable (error = cmd-sns)
e_integral internal variable (integral of e dt)
e_deriv internal variable
e_previous internal variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PIDcontroller [in src/user/PID.c]
Classes: device
Actions: INIT
PROCESS
RESET
Messages: CMD command
SNS sense
GAIN gain
------------------------------------------------------------------------------
Notes:
The PID is used for feedback control of dynamical systems. For example, in
a voltage clamp circuit it is used with a pulsegen, RC, and diffamp device
to provide the required injection current to maintain the membrane voltage
at the desired level. The RC-filtered command voltage is scaled by the
diffamp and then presented to the PID with a CMD message. The output is
sent to a compartment with an INJECT message, and the resulting Vm in the
compartment is fed back to the PID with a SNS message. A higher gain gives
a better clamp, but requires a smaller integration time step to avoid
numerical instability.
For more information on PID controllers see: Franklin, Powel, Emami-Naeini
(1986) "Feedback Control of Dynamic Systems", Addison-Wesley, pp. 99-106.
Example: Scripts/squid/squid_electronics.g
See also:
Object Type: RC
Description: A series resistance R, shunted by a capacitance C.
Author: M. Wilson, Caltech (6/88)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: RCunit_type [in /usr/genesis/src/segment/seg_struct.h]
Size: 96 bytes
Fields: V0 initial value of "state" (set on RESET)
R series resistance
C shunting capacitance
state output value
inject input value
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RC_Unit [in src/segment/rcunit.c]
Classes: segment
Actions: CHECK PROCESS RESET
Messages: INJECT inject (input-value)
------------------------------------------------------------------------------
Notes:
An RC element is often used as a low-pass filter, as with a voltage clamp
circuit, in order to prevent a step change in the command voltage from
causing numerical instabilities.
Example: Scripts/squid/squid_electronics.g
See also:
Object Type: asc_file
Description:
The asc_file object is used to write data to a file in ASCII format. A new
line is written at every time step of the clock which is assigned. Unless
the notime flag is set, the first item on each line is the simulation time.
Each SAVE message which is received adds another item to the line.
Author: M. Wilson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: ascfile_type [in src/out/out_struct.h]
Size: 88 bytes
Fields:
filename data file name to be written
fp data file pointer
is_open flag: is file currently open?
initialize flag: has file been initialized?
leave_open flag: leave file open? 1 leaves the file open
all the time so you can write on it whenever
you want (a good idea if the file is used
frequently, but there is a limit to number of
files that can be left open at any time);
0 closes the file after every write to it
(only useful if you have more than 30 files;
this is slow)
append flag: append data after resetting?
flush flag: flush data to disk at each interval?
1 forces program to send data to the disk at
once and not store it in a buffer (slow but
secure); 0 (default) writes data in a buffer
(fast)
notime flag: if non-zero, don't output the time
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: AscFileOutput [in src/out/out_ascfile.c]
Classes: output
Actions: RESET PROCESS DELETE SAVE FLUSH OUT_OPEN OUT_WRITE
Messages: SAVE data
------------------------------------------------------------------------------
Notes:
If the filename field is not set, the output file will be given the same
name as the element which is created from the asc_file object.
When the append flag is zero, a reset will close and reopen the file,
setting the file pointer at the begining, effectively creating a new file
if the simulation is stepped again. When the append flag is set to a
non-zero value, additional steps after a reset will be appended to the
file. The OUT_WRITE action may be called to write any string to the file.
The OUT_OPEN command is used to manually initialize the file for writing,
and must be called before calling OUT_WRITE. In append mode, it must be
called after changing the filename to a new output file name, or renaming
an existing one.
For binary data, use disk_out.
Example:
create asc_file /out
setfield /out flush 1 leave_open 1 append 1
setclock 1 0.001
useclock /out 1
// Assume the existence of /cell/soma to provide output
addmsg /cell/soma /out SAVE Vm
setfield /cell/soma inject 0
step 0.1 -t
// append the results of a new run with different injection
setfield /cell/soma inject 0.1e-9
reset
step 0.1 -t
// now do yet another injection with output to a different file
setfield /out filename out2
call /out OUT_OPEN
call /out OUT_WRITE "Run #2" // Write a header
setfield /cell/soma inject 0.2e-9
reset
step 0.1 -t
See also:
disk_out ,
disk_in
Object Type: autocorr
Description: Computes the auto-correlation of a spike train
A histogram containing the count of
events for each bin is constructed.
Author: D. Jaeger, Caltech (9/92)
revised for Genesis v2.2 11/99
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: doac_type [in genesis/src/device/spike_struct.h]
Size: 100 bytes
Fields: num_bins (int) number of bins in histogram
binwidth (float) binwidth in sec
reset_mode (int) 0 or 1
threshold (float) input amplitude triggering spike event
*acarray (int) histogram array containing data
nospks (int) number of spikes from source
*sptimes (float) array of spike times from source
curridx (int) internal indexing
calcidx (int) internal indexing
maxspikes (int) internal boundary condition
wintime (float) internal boundary condition
dont (int) internal condition
allocated (int) internal condition
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: Doac [in genesis/src/device/acxc.c]
Classes: datanal
Actions: PROCESS update *sptimes, *acarray, nospks
RESET if reset_mode = 0, empties *sptimes but not
*acarray
if reset_mode = 1, empties *sptimes and
recreates *acarray
Messages: SPIKE : signal amplitude from source
------------------------------------------------------------------------------
Notes:
User must setfield num_bins and binwidth (in sec) so
that a data array is created on RESET. The input is assumed to
cross the amplitude given in the threshold field only for one
timestep to generate a spike. Vm is not to be used as an input field.
Valid inputs may be derived from random, neutral or spike objects.
An internal spike time buffer is set up for a maximal
spike rate of 1000 events / second. A greater density of spikes
will lead missed events in the histogram.
The auto-corrlation histogram is updated with each timestep.
However, the first results will only be available after the
simulation time has reached the value of num_bins * binwidth.
This is due to the fact that any spike needs to be correlated
with other spikes across a time window of this duration.
The data are stored in *acarray and can be accessed with
a getfield command (see example).
Example:
create autocorr /ac
setfield ^ binwidth 0.002 num_bins 200 threshold 0.5
/* this example uses random object for input */
create random /input
setfield ^ min_amp 1 max_amp 1 rate {in1_rate} reset 1 reset_value 0
addmsg /input1 /ac SPIKE state
/* To display data on a graph, use this function after creating the graph */
function plotac(source, dest, pname, color)
str source,dest,color
int maxbin
int i,barval
maxbin = {getfield {source}, num_bins}
setfield {dest} xmax {maxbin}
call {dest} RESET
for(i=0; i < maxbin; i = i + 1)
barval = {getfield {source}, acarray[{i}]}
addpts {dest} -plotname {pname} -color {color} {i} 0
addpts {dest} -plotname {pname} -color {color} {i} {barval}
addpts {dest} -plotname {pname} -color {color} {{i}+1} 0
end
end
See also:
crosscorr ,
interspike ,
peristim ,
Scripts/examples/spike/spikes.g
Object Type: calculator
Description: Adds, subtracts, multiplies, and divides using messages.
Author: Erik De Schutter, BBF-UIA 6/98
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: calc_type [in src/device/dev_struct.h]
Size: 100 bytes
Fields: output computed value
resetclock clock # used to reset output value (default 0)
output_init value of output after reset (default 0)
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: CalculatorFunc [in src/device/calculator.c]
Classes: device
Actions: RESET PROCESS DELETE CREATE
Messages: SUM number
SUBTRACT number
MULTIPLY number
DIVIDE number
------------------------------------------------------------------------------
Notes:
The calculator is often used to sum multiple inputs. For example, the
total channel current in a cell could be calculated with:
foreach s ({el /cell/##[CLASS=channel]})
addmsg {s} /calculator_element SUM Ik
end
With the resetclock default of clock 0, the calculator is reinitialized to
output_init (default 0) at every time step, so that it may calculate a new
value of the sum from incoming messages at each time step. If resetclock is
set to a clock with a longer time step, then operations are performed on
the previous output, until it is time to reset the output to output_init.
The example below uses a resetclock with a longer time step in order to
generate a periodic ramp output.
Example:
create xform /data
create xgraph /data/calculator
create xbutton /data/RESET -script reset
create xbutton /data/RUN -script "step 100"
create xbutton /data/QUIT -script quit
xshow /data
// Create a ramp generator by summing a constant input
// The length of the ramp is given by the resetclock
setclock 0 1.0
setclock 1 25.0
create neutral /source
setfield /source x 4
create calculator /source/ramp
setfield /source/ramp resetclock 1
addmsg /source /source/ramp SUM x
addmsg /source/ramp /data/calculator PLOT output *output *red
addmsg /source /data/calculator PLOT x *input *blue
reset
See also:
Object Type: compartment
Description: Axially asymmetric compartment. Ra is located on
one side of the compartment. This is slightly more
computationally efficient than the symmetric counterpart.
Author: M. Wilson, Caltech (6/88)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: compartment_type [in src/segment/seg_struct.h]
Size: 124 bytes
Fields: Rm total membrane resistance
Cm total membrane capacitance
Em membrane resting potential
Ra axial resistance
inject injected current in membrane
dia compartment diameter
len compartment length
Vm voltage across the membrane
previous_state Vm at previous time step
Im approximation to the total membrane current
initVm initial value to set Vm on reset
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: Compartment [in src/segment/compartment.c]
Classes: segment
membrane
Actions: INIT assign previous_state = Vm
PROCESS update Vm, calculate Im
RESET assign Vm = Em
CHECK make sure Rm>0, Cm>0,
Ra'>0 (if RAXIAL message is present),
Ra>0 (if AXIAL message is present)
SAVE2
RESTORE2
Messages: CHANNEL Gk Ek delivers the conductance and equilibrium
potential of channel within the compartment
RAXIAL Ra Vm delivers the Ra and Vm of a compartment
AXIAL Vm delivers the Vm of a compartment
INJECT inject sets the inject field to the message value
EREST Em sets the Em field to the message value
------------------------------------------------------------------------------
Notes: Simulates a section of passive membrane or cable. The
potential across the membrane is given by Vm. There is a
leakage path for current through the resistance Rm. This
resistance is in series with a leakage battery Em. This
compartment can be coupled to other compartments with an axial
resistance Ra. The compartment is not symmetrical, with Ra
lumped to one side of the compartment. Any number of ionic
channels can be introduced into the membrane (Gk, Ek in the
circuit diagram). The membrane also allows current
injection.
The compartment Im is the sum of axial currents and injected
current only. The (transmembrane) channel currents or the
leakage current are not included. For a multicompartment
cell, under a quasistatic approximation (C*dV/dt is small), Im
is approximately equal to the sum of the channel and leakage
currents, due to charge conservation. This approximation is
used in the efield object (see efield.doc) to allow Im to be
used to calculate external field potentials. The exception to
this is when Im is calculated with hsolve in chanmode 4. In
that case, Im is directly calculated as the sum of the channel
currents and leakage current though Rm.
When a compartment performs its RESET action (usually
invoked by the reset command), Vm is set to the value of the
initVm field. Normally, initVm follows any changes to Em,
so Vm will be initialized to Em upon reset. If, as in the
Hodgkin-Huxley model, Em is a leakage potential that is
different from the rest potential, initVm may be set to the
rest potential. It will then no longer follow Em, and Vm
will be set to the rest potential upon reset.
Calculates Vm using:
dVm/dt = {(Em - Vm)/Rm + SUM[(Ek - Vm)*Gk] +
(Vm' - Vm)/Ra' + (Vm'' - Vm)/Ra + inject}/Cm
In the diagram, the compartment shown in the middle
receives the Vm' and Ra' of the upper compartment with
an RAXIAL message, and the Vm'' of the lower compartment
with an AXIAL message. Channels deliver their Gk and Ek
with a CHANNEL message.
Vm'
o_________________________________________________
| | | | |
\
/ Ra'
\
|
|
| Vm
o_________________________________________________
| | | | |
\ | | | |
/ Ra \ \ | |
\ --/--> / | ___|___
| Gk \ Rm \ / \ _______ Cm
| | | / A \ |
| | | \ | / |
| Ek --- Em --- \ / |
| ------- ------- | Iinject|
| | | | |
| |_____________|________|________|
|
| Vm''
o_________________________________________________
| | | | |
Example:
See also:
symcompartment
Object Type: concchan
Description: Concentration-driven membrane channel. Equivalent
to 1-D diffusion of molecules across a membrane. The
concchan, like the enzyme, is a property of a pool and so
each concchan should be attached to a pool which specifies
the number of concchans.
Author: U. S. Bhalla MSSM Aug/93
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: [in src/kinetics/kin_struct.h]
Size: 124 bytes
Fields:
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the decrease.
perm Permeability
gmax conductance (not currently used)
n number of concchans
Vm potential across channel (not currently used)
use_nernst flag (not currently used)
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: [in src/kinetics/concchan.c]
Classes: segment
Actions: SET PROCESS RESET
Messages:
SUBSTRATE n vol Number of molecules in substrate pool
PRODUCT n vol Number of molecules in product pool
NUMCHAN n Number of concchans specified by pool
Vm Vm Sets the Vm field (not currently used)
------------------------------------------------------------------------------
Notes: The concchan allows the substrate and product pools to diffuse
back and forth. The state variables A and B are used in the
return messages to the substrates and products. (However the
roles of A and B are reversed for the product pools).
If there are both substrate and product pools (as evidenced by
having both a SUBSTRATE and a PRODUCT message to the
concchan), the SUBSTRATE message calculates conc1 = n/vol, and
PRODUCT calculates conc2 = n/vol. Here, n/vol represents the
density of molecules in the pool, not the density of conchans.
Then A and B are set to
A = conc2 * perm * n
B = conc1 * perm * n
where n is the number of concchans.
Example: // numerically attach the chan to the pool
addmsg {pool} {chan} NUMCHAN n
// Attaches the pool to the chan as a substrate
addmsg {chan} {pool} REAC A B
addmsg {pool} {chan} SUBSTRATE n vol
// Attaches the pool to the chan as a product
addmsg {chan} {pool} REAC B A
addmsg {pool} {chan} PRODUCT n vol
See also:
pool
Object Type: concpool
Description: A "well-mixed" concentration pool without diffusion that can
have miscellaneous in/out flows (when coupled to other
objects). It has better controls over size/volume than
Ca_concen and does not include its own equilibration
mechanisms.
Author: E. De Schutter BBF-UIA 4/94 - 3/99
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: concpool_type [in src/concen/conc_struct.h]
Size: 132 bytes
Fields: C concentration (calculated by concpool) in mM
prev_C concentration at previous time step
Ceq equilibrium concentration in mM
val ionic valence
leak constant in/outflow in mM/sec
shape_mode Set to one of the predefined global variables
SHELL=0, SLICE=SLAB=1, TUBE=2, USERDEF=3.
SHELL: onion shell. Set len for cylindrical shell (zero
length for spherical shell), dia (outer diameter of shell)
and thick (thickness of shell); vol, is computed on RESET.
SLICE (or SLAB): salami slices of cylinder. Set dia
(diameter of cylinder) and thick (thickness of slab), len
is not used; vol is computed on RESET.
TUBE: a cylinder with diameter dia and length len. For
concpools inside a difshell: make dia negative in the
prototype; readcell will scale len so as to obtain an
appropriate change in vol relative to the difshell.
USERDEF: len, dia, thick are not used. Set vol field
to desired pool volume.
len shell length
dia shell diameter
thick shell thickness
vol shell volume
-----------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ConcPool [in src/concen/concpool.c]
Classes: concentration segment
Actions: RESTORE2 SAVE2 CHECK RECALC RESET PROCESS INIT
Messages: CONCEN C (sets C with a message)
STOREINFLUX flux (flux into store in moles/sec;
increases C)
STOREOUTFLUX flux (flux out of store in moles/sec;
decreases C)
BUFFER kBf kBb Bfree Bbound (fields sent from a buffer,
e.g. a fixbuffer)
HILLPUMP vmax Kd Hill (sent from a hillpump; setting
Hill=1 is equivalent to an
MMMPUMP message from an mmpump)
------------------------------------------------------------------------------
Notes:
Unlike the difshell, the concpool provides a single shell model of a
"well-mixed" concentration pool without diffusion between shells. As it can
also couple to buffers and pumps, it provides for multiple mechanisms for
calcium removal and has better controls over size/volume than the Ca_concen.
The buffers (e.g, fixbuffer) interact with a difshell or concpool to model the
binding of calcium to buffer molecules and to calculate the concentrations of
free and bound ions using a kinetic scheme with forward and backward rate
constants for the binding and release of calcium. The BUFFER message from a
buffer passes on the rate constants and the calculated free and bound
concentrations so that the concpool may calculate the resulting ion
concentration C. Details of the fields that are passed to the concpool with
messages from buffers and the hillpump are provided in the documentation for
these objects.
For a general description of buffered calcium diffusion see: De Schutter E.,
and Smolen P., "Calcium dynamics in large neuronal models", in Methods in
neuronal modeling: From ions to networks (2nd edition), C. Koch and I. Segev
editors, pp. 211-250 (1998).
Example:
See also:
difshell ,
fixbuffer ,
hillpump
Object Type: crosscorr
Description: Computes the cross-correlation between two trains of
spike events. A histogram containing the count of
events for each bin is constructed.
Author: D. Jaeger, Caltech (9/92)
revised for Genesis v2.2 11/99
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: doxc_type [in genesis/src/device/spike_struct.h]
Size: 116 bytes
Fields: num_bins (int) number of bins in histogram
binwidth (float) binwidth in sec
reset_mode (int) 0 or 1
threshold (float) input amplitude triggering spike event
*xcarray (int) histogram array containing data
no1spks (int) number of spikes from source 1
no2spks (int) number of spikes from source 2
*sp1times (float) array of spike times from source 1
*sp2times (float) array of spike times from source 2
curr1idx (int) internal indexing
curr2idx (int) internal indexing
calc1idx (int) internal indexing
calc2idx (int) internal indexing
maxspikes (int) internal boundary condition
wintime (float) internal boundary condition
dontnow (int) internal condition
allocated (int) internal condition
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: Doxc [in genesis/src/device/acxc.c]
Classes: device
Actions: PROCESS update *spktimes, *xcarray, nospks
RESET if reset_mode = 0, empties *spktimes but not
*xcarray
if reset_mode = 1, empties *spktimes and
recreates *xcarray
Messages: XSPIKE : signal amplitude from source 1
YSPIKE : signal amplitdue from source 2
------------------------------------------------------------------------------
Notes:
User must setfield num_bins (only even number of bins
are allowed) and binwidth (in sec) so that a data array
is created on RESET. The input is assumed to cross the amplitude
given in the threshold field only for one timestep to generate
a spike. Vm is not to be used as an input field. Valid inputs
may be derived from random, neutral or spike objects.
An internal spike time buffer is set up for a maximal
spike rate of 1000 events / second. A greater density of spikes
will lead to missing events in the histogram.
The cross-corrlation table is updated with each timestep.
However, the first results will only be available after the
simulation time has reached the value of num_bins * binwidth.
The data are stored in *xcarray and can be accessed with
a getfield command (see example). The 0 delay time bin is stored in
the center of the histogram, i.e. for num_bins = 100, xcarray[49]
contains the 0 delay time bin.
Example:
create autocorr /xc12
setfield ^ binwidth 0.002 num_bins 200 threshold 0.5
/* this example uses random object for input */
create random /input1
setfield ^ min_amp 1 max_amp 1 rate {in1_rate} reset 1 reset_value 0
create random /input2
setfield ^ min_amp 1 max_amp 1 rate {in1_rate} reset 1 reset_value 0
addmsg /input1 /xc12 XSPIKE state
addmsg /input2 /xc12 YSPIKE state
/* To display data on a graph, use this function after creating the graph */
function plotxc(source, dest, color)
str source, dest, color
int bins, minbin, maxbin, barval
/* display *xcarray of doxc element {source} on graph {dest}
The display could be made nicer than this. */
bins = getfield {source}, num_bins
minbin = -({bins} / 2)
maxbin = {bins} / 2
setfield {dest} xmin {minbin} xmax {maxbin}
call {dest} RESET
for(i=minbin; i < maxbin; i = i + 1)
barval = {getfield {source}, xcarray[{{i}+{maxbin}}]}
addpts {dest} -plotname xcor -color {color} {i} 0
addpts {dest} -plotname xcor -color {color} {i} {barval}
addpts {dest} -plotname xcor -color {color} {i} 0
end
end
------------------------------------------------------------------------------
Notes:
User must setfield num_bins and binwidth (in sec) so
that a data array is created on RESET. The input is assumed to
cross the amplitude given in the threshold field only for one
timestep to generate a spike. Vm is not to be used as an input field.
Valid inputs may be derived from random, neutral or spike objects.
An internal spike time buffer is set up for a maximal
spike rate of 1000 events / second. A greater density of spikes
will lead missed events in the histogram.
The cross-corrlation histogram ought to be used with clock 0.
The first results will only be available after the
simulation time has reached the value of num_bins * binwidth.
This is due to the fact that any spike needs to be correlated
with other spikes across a time window of this duration.
The data are stored in *xcarray and can be accessed with
a getfield command (see example).
See also:
autocorr ,
interspike ,
peristim ,
Scripts/examples/spike/spikes.g
Object Type: ddsyn
Description: modified synchan with table front end to transform voltage
to activation, for dendro-dendritic synapses. Calculates
channel current therefore needs membrane state.
Author: U. S. Bhalla, Caltech (5/91)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: dd_syn_type [in src/olf/olf_struct.h]
Size: 164 bytes
Fields: Gk channel conductance
Ik channel current
Ek channel reversal potential
gmax maximum conductance
tau1 open time constant of channel activation
tau2 close time constant of channel activation
transf table for transform from Vm to activation;
usual interpolation element with the normal
set of fields; set up using TABCREATE, filled
by indexing as usual, and interpolated using
TABFILL
activation channel activation; set either by a table
lookup of the transform of the incoming
VOLTAGE message or by synaptic input
transf_alloced flag for allocation of transform
X state variable for time response
Y state variable for time response
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: DDSyn [in src/olf/dd_syn.c]
Classes: segment, channel
Actions: INIT
PROCESS
RESET
CHECK
SET
DUMP
SAVE2
RESTORE2
TABCREATE
TABFILL
Messages: VOLTAGE voltage [tells channel what membrane
potential is]
ACTIVATION activation [sends activation directly to
channel; sums linearly with
other ACTIVATION input and
transformed V_PRESYN input]
V_PRESYN presynaptic-voltage [sends presynaptic voltage to
transform table; sums linearly
at output of table, so
multiple V_PRESYN inputs are
first transformed, then their
activations are summed]
RAND_ACTIVATION [rather than sending direct
probability amplitude activation signal, specifies
probability (from 0 to 1) that
activation of size amplitude
will occur at synapse (useful
for sending random synaptic
input to synapse)]
------------------------------------------------------------------------------
Notes: Dendrodendritic synapse with tabulated transform
from presyn potential to postsyn activation.
The table for the transform is created using tabcreate
and is shared with all copies of the element
The ddsyn element is the equivalent of a synchan element
with a tabulated transform from input voltage to channel
activation. This serves as a way of representing
dendro-dendritic synapses. The usual fields and messages for
the synchan element remain available. The table entries are
filled in the usual ways from the script interface, and can be
shared between ddsyn elements.
Example: Here we create a ddsyn channel to act as the synaptic input
for granule cells in an olfactory bulb model.
// for dd, ax, and centrif inputs
create ddsyn glu_gran_usb
call glu_gran_usb TABCREATE 10 -0.070 0.05
setfield glu_gran_usb \
Ek {EGlu} \
tau1 4.0e-3 \ // sec
tau2 6.0e-3 \ // sec
gmax {GGlu} \ // Siemens
// Setting up the table for transforming
// from presyn Vm to activation
transf->table[0] 0 \
transf->table[1] 0.05 \
transf->table[2] 0.1 \
transf->table[3] 0.2 \
transf->table[4] 0.5 \
transf->table[5] 0.7 \
transf->table[6] 0.8 \
transf->table[7] 0.9 \
transf->table[8] 0.95 \
transf->table[9] 0.98 \
transf->table[10] 1
call glu_gran_usb TABFILL 1000 0
See also: Scripts/examples/ddsyn
Object Type: dif2buffer
Description: Implementation of a first-order diffusible (mobile) buffer
with variable total buffer concentration. Should be coupled
to a difshell, where the change in the concentration of the
buffered ion is computed.
Author: E. De Schutter BBF-UIA 8/94 - 4/96
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: dif2buffer_type [in src/concen/conc_struct.h]
Size: 172 bytes
Fields: activation ion concentration from incoming CONCEN message
Bfree free buffer concentration (calculated) in mM
Bbound bound buffer concentration (calculated) in mM
prev_free Bfree at previous time step
prev_bound Bbound at previous time step
Btot total buffer concentration in mM (used on reset)
kBf forward rate constant in 1/(mM*sec)
kBb backward rate constant in 1/sec
Dfree diffusion constant for Bfree in m^2/sec
Dbound diffusion constant for Bbound in m^2/sec
shape_mode Set to one of the predefined global
variables SHELL=0, SLICE=SLAB=1, USERDEF=3.
SHELL: onion shell, for radial diffusion. Set len for
cylindrical shell (zero length for spherical shell), dia
(outer diameter of shell) and thick (thickness of shell);
vol, surf_up, and surf_down are computed on RESET.
SLICE (or SLAB): salami slices of cylinder, for axial
diffusion. Set dia (diameter of cylinder) and thick
(thickness of slab), len is not used; vol, surf_up, and
surf_down are computed on RESET.
USERDEF: len, dia, thick are not used. Set vol, surf_up
and surf_down.
len shell length
dia shell diameter
thick shell thickness
vol shell volume
surf_up area of upper (outer) shell surface
surf_down area of lower (inner) shell surface
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: Dif2Buffer [in src/concen/dif2buffer.c]
Classes: concbuffer segment
Actions: RESTORE2 SAVE2 CHECK RECALC RESET PROCESS INIT
Messages: CONCEN C (buffered ion concentration, sent
from a difshell or concpool)
BDIFF_DOWN prev_free prev_bound thick (diffusion to inner shell,
sent from an outer shell)
BDIFF_UP prev_free prev_bound thick (diffusion to outer shell,
sent from an inner shell)
------------------------------------------------------------------------------
Notes:
The buffers (e.g, fixbuffer) interact with a difshell to model the binding of
calcium to buffer molecules and to calculate the concentrations of free and
bound buffer molecules, using a kinetic scheme with forward and backward rate
constants for the binding and release of calcium. Intracellular buffers are
often mobile, and the diffusion of buffer molecules can carry calcium with
them. This can often make a significant contribution to the transport of
calcium, in addition to the diffusion of free Ca++ ions that is modeled by the
difshell object. These diffusible buffers can be modeled with the difbuffer
and dif2buffer objects, instead of using the non-mobile fixbuffer.
Like the fixbuffer, the dif2buffer interacts with a difshell to model the
binding of calcium to buffer molecules and to calculate the concentrations of
free and bound buffer molecules using a kinetic scheme with forward and
backward rate constants for the binding and release of calcium. The rate
constants kBf and kBb are set by the user, and the concentration C is sent
with a CONCEN message from the difshell. The BUFFER message to a difshell
from a buffer passes on the rate constants and the calculated free and bound
buffer concentrations.
In addition, the dif2buffer acts like a difshell, in the sense that it allows
diffusion between adjacent buffer shells. However, it is the free and bound
buffer molecules, rather than free ions that are diffusing. Adjacent buffer
shells are coupled by BDIFF_DOWN and BDIFF_UP messages that are analogous to
the DIFF_DOWN and DIFF_UP messages that link adjacent difshells. Note that a
dif2buffer should have the same dimensions and shape_mode as the difshell to
which it is coupled.
For the difbuffer, the assumption is made that the diffusion rate for bound
and free buffer molecules is the same (as they are much larger than the Ca
atoms), so there is a single diffusion constant D, and they diffuse together,
with dBbound/dt = -dBfree/dt. The dif2buffer does not make this assumption,
and treats the diffusion of free and bound molecules separately. Thus, there
are separate diffusion constants Dfree and Dbound, and the BDIFF_DOWN and
BDIFF_UP messages pass both the previous step Bfree and Bbound values along
with the buffer shell thickness.
NOTE: When using difshell, difbuffer, or dif2buffer elements without hsolve
(or in chanmodes 0 or 1), it will be necessary to issue two reset commands
after setting up the simulation.
For a general description of buffered calcium diffusion see:
De Schutter E., and Smolen P., "Calcium dynamics in large neuronal
models", in Methods in neuronal modeling: From ions to networks
(2nd edition), C. Koch and I. Segev editors, pp. 211-250 (1998).
Example:
See also:
difshell ,
difbuffer ,
fixbuffer
Object Type: difbuffer
Description: Implementation of a first-order diffusible (mobile) buffer
with constant total buffer concentration. Should be coupled
to a difshell, where the change in the concentration of the
buffered ion is computed.
Author: E. De Schutter BBF-UIA 8/94 - 6/96
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: difbuffer_type [in src/concen/conc_struct.h]
Size: 168 bytes
Fields: activation ion concentration from incoming CONCEN message
Bfree free buffer concentration (calculated) in mM
Bbound bound buffer concentration (calculated) in mM
prev_free Bfree at previous time step
prev_bound Bbound at previous time step
Btot total buffer concentration in mM (free + bound)
kBf forward rate constant in 1/(mM*sec)
kBb backward rate constant in 1/sec
D diffusion constant of buffer molecules, m^2/sec
shape_mode Set to one of the predefined global
variables SHELL=0, SLICE=SLAB=1, USERDEF=3.
SHELL: onion shell, for radial diffusion. Set len for
cylindrical shell (zero length for spherical shell), dia
(outer diameter of shell) and thick (thickness of shell);
vol, surf_up, and surf_down are computed on RESET.
SLICE (or SLAB): salami slices of cylinder, for axial
diffusion. Set dia (diameter of cylinder) and thick
(thickness of slab), len is not used; vol, surf_up, and
surf_down are computed on RESET.
USERDEF: len, dia, thick are not used. Set vol, surf_up
and surf_down.
len shell length
dia shell diameter
thick shell thickness
vol shell volume
surf_up area of upper (outer) shell surface
surf_down area of lower (inner) shell surface
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: DifBuffer [in src/concen/difbuffer.c]
Classes: concbuffer segment
Actions: RESTORE2 SAVE2 CHECK RECALC RESET PROCESS INIT
Messages: CONCEN C (buffered ion concentration, sent
from a difshell or concpool)
BDIFF_DOWN prev_free thick (diffusion to inner shell, sent from
an outer shell)
BDIFF_UP prev_free thick (diffusion to outer shell, sent from
an inner shell)
DIFF_DOWN prev_free thick (alias for BDIFF_DOWN)
DIFF_UP prev_free thick (alias for BDIFF_UP)
------------------------------------------------------------------------------
Notes:
The buffers (e.g, fixbuffer) interact with a difshell to model the binding of
calcium to buffer molecules and to calculate the concentrations of free and
bound buffer molecules, using a kinetic scheme with forward and backward rate
constants for the binding and release of calcium. Intracellular buffers are
often mobile, and the diffusion of buffer molecules can carry calcium with
them. This can often make a significant contribution to the transport of
calcium, in addition to the diffusion of free Ca++ ions that is modeled by the
difshell object. These diffusible buffers can be modeled with the difbuffer
and dif2buffer objects, instead of using the non-mobile fixbuffer.
Like the fixbuffer, the difbuffer interacts with a difshell to model the
binding of calcium to buffer molecules and to calculate the concentrations of
free and bound buffer molecules using a kinetic scheme with forward and
backward rate constants for the binding and release of calcium. The rate
constants kBf and kBb are set by the user, and the concentration C is sent
with a CONCEN message from the difshell. The BUFFER message to a difshell
from a buffer passes on the rate constants and the calculated free and bound
buffer concentrations.
In addition, the difbuffer acts like a difshell, in the sense that it allows
diffusion between adjacent buffer shells. However, it is the free and bound
buffer molecules, rather than free ions that are diffusing. Adjacent buffer
shells are coupled by BDIFF_DOWN and BDIFF_UP messages that are analogous to
the DIFF_DOWN and DIFF_UP messages that link adjacent difshells. Note that a
difbuffer should have the same dimensions and shape_mode as the difshell to
which it is coupled.
For the difbuffer, the assumption is made that the diffusion rate for bound
and free buffer molecules is the same (as they are much larger than the Ca
atoms), so there is a single diffusion constant D, and they diffuse together,
with dBbound/dt = -dBfree/dt. The dif2buffer does not make this assumption,
and treats the diffusion of free and bound molecules separately.
NOTE: When using difshell, difbuffer, or dif2buffer elements without hsolve
(or in chanmodes 0 or 1), it will be necessary to issue two reset commands
after setting up the simulation.
For a general description of buffered calcium diffusion see:
De Schutter E., and Smolen P., "Calcium dynamics in large neuronal
models", in Methods in neuronal modeling: From ions to networks
(2nd edition), C. Koch and I. Segev editors, pp. 211-250 (1998).
Example:
See also:
difshell ,
fixbuffer ,
dif2buffer
Object Type: diffamp
Description: Difference amplifier, takes two inputs and produces an
output proportional to their difference.
Author: M. Wilson, Caltech (2/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: diffamp_type [in src/device/dev_struct.h]
Size: 96 bytes
Fields: gain
saturation
plus
minus
output
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: DifferenceAmp [in src/device/diffamp.c]
Classes: device
Actions: RESET sets the output to zero
PROCESS calculates and sets the output from the inputs
Messages: PLUS +input
MINUS -input
GAIN gain
------------------------------------------------------------------------------
Notes:
Adds inputs from PLUS messages and subtracts those received with MINUS
messages. The output is this total, multiplied by gain, but limited to the
range -saturation to +saturatation. If there are no MINUS messages, the
minus input is taken as zero. Normally, the gain field is set using
"setfield", but it may also be varied with a GAIN message. This object also
provides a convenient way to sum or scale quantities which are to be plotted
by sending a PLOT message to an xgraph.
Example:
See also:
Object Type: difshell
Description: Implementation of a concentration shell that can have
miscellaneous in/out flows (when coupled to other objects),
and one-dimensional diffusion between other difshells.
Author: E. De Schutter BBF-UIA 4/94 - 3/99
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: difshell_type [in src/concen/conc_struct.h]
Size: 152 bytes
Fields: C concentration (calculated by difshell) in mM
prev_C concentration at previous time step
Ceq equilibrium concentration in mM
D diffusion constant in m^2/sec
val ionic valence
leak constant in/outflow in mM/sec
shape_mode Set to one of the predefined global
variables SHELL=0, SLICE=SLAB=1, USERDEF=3.
SHELL: onion shell, for radial diffusion. Set len for
cylindrical shell (zero length for spherical shell), dia
(outer diameter of shell) and thick (thickness of shell);
vol, surf_up, and surf_down are computed on RESET.
SLICE (or SLAB): salami slices of cylinder, for axial
diffusion. Set dia (diameter of cylinder) and thick
(thickness of slab), len is not used; vol, surf_up, and
surf_down are computed on RESET.
USERDEF: len, dia, thick are not used. Set vol, surf_up
and surf_down.
len shell length
dia shell diameter
thick shell thickness
vol shell volume
surf_up area of upper (outer) shell surface
surf_down area of lower (inner) shell surface
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: DifShell [in src/concen/difshell.c]
Classes: concentration segment
Actions: RESTORE2 SAVE2 CHECK RECALC RESET PROCESS INIT
Messages: INFLUX I_Ca (current flow in A; increases C)
OUTFLUX I_Ca (current flow in A; decreases C)
FINFLUX I_Ca fraction (current flow, scaled by fraction)
FOUTFLUX I_Ca fraction (current flow, scaled by fraction)
STOREINFLUX flux (flux into store in moles/sec;
increases C)
STOREOUTFLUX flux (flux out of store in moles/sec;
decreases C)
DIFF_DOWN prev_C thick (diffusion to inner shell, sent from
an outer shell)
DIFF_UP prev_C thick (diffusion to outer shell, sent from
an inner shell)
BUFFER kBf kBb Bfree Bbound (fields sent from a buffer,
e.g. a fixbuffer)
TAUPUMP kP Ceq (sent from a taupump)
EQTAUPUMP kP (sent from a taupump; uses Ceq from
the difshell)
MMPUMP vmax Km (sent from a mmpump)
HILLPUMP vmax Kd Hill (sent from a hillpump)
------------------------------------------------------------------------------
Notes:
The concentration of intracellular calcium close to the cell membrane surface
can have a significant influence on the conductance of calcium dependent
potassium channels and on mechanisms for synaptic plasticity. Unless the
neural compartment is very small and the calcium is "well-mixed", the calcium
concentration may vary considerably within the compartment. It may then be
necessary to model diffusion within the compartment by dividing it into a
number of shells. The difshell object is used for modeling these shells and
diffusion between them. It may also be used for modeling axial diffusion
between compartments. Just as the length of a neural compartment should be
chosen to give small differences in membrane potential between adjacent
compartments, the thickness of diffusion shells should be chosen to give small
differences in concentration between adjacent shells.
A difshell is typically coupled to buffers and/or pumps, in order to provide
for multiple mechanisms for calcium removal.
The buffers (e.g, fixbuffer) interact with a difshell or concpool to model the
binding of calcium to buffer molecules and to calculate the concentrations of
free and bound ions using a kinetic scheme with forward and backward rate
constants for the binding and release of calcium. The BUFFER message from a
buffer passes on the rate constants and the calculated free and bound
concentrations so that the difshell may calculate the resulting ion
concentration C in the shell.
The ionic pumps provide various mechanisms to remove ions from the shell.
Details of the fields that are passed to the difshell with messages from
the pumps are provided in the documentation for the various pump objects.
The various FLUX messages assume SI units for the Faraday constant, currents
and dimensions. If other units are used, scale the val parameter to account
for this.
NOTE: When using difshell, difbuffer, or dif2buffer elements without hsolve
(or in chanmodes 0 or 1), it will be necessary to issue two reset commands
after setting up the simulation.
For a general description of buffered calcium diffusion see:
De Schutter E., and Smolen P., "Calcium dynamics in large neuronal
models", in Methods in neuronal modeling: From ions to networks
(2nd edition), C. Koch and I. Segev editors, pp. 211-250 (1998). The
spinedemo simulation gives a detailed example of the use of the difshell,
taupump, and fixbuffer objects for modeling calcium diffusion in dendritic
spines.
Example:
/* based on spinedemo, for spine head initial shell (headshell0) */
create difshell headshell0
setfield headshell0 C 0.000020 Ceq 0.000020 D 6.0e-10 val 2.0 leak 0.0
setfield headshell0 shape_mode {SLAB} len 0.0 dia 0.5e-6 thick 0.1e-6
/* Ca fraction of NMDA current is influx into outer shell */
addmsg Mg_block headshell0 FINFLUX Ik 0.128
/* attach fast immobile buffer */ headbuf0
create fixbuffer headbuf0
setfield headbuf0 Btot 0.2 kBf 5.0e5 kBb 500 // mM, 1/(mM*sec), 1/sec
addmsg headbuf0 headshell0 BUFFER kBf kBb Bfree Bbound
addmsg headshell0 headbuf0 CONCEN C
/* attach the pump */
create taupump headpump0
setfield headpump0 Ceq 0.000020
/* The pump rate is proportional to the surface-to-volume ratio
spine head initial shell is end of cylinder, so stv=1/thick */
setfield headpump0 T_C {thick/Pump_kP} // pump rate Pump_kP = 1.4e-5
addmsg headpump0 headshell0 TAUPUMP kP Ceq
/* set up diffusion messages, assuming the existence of headshell1 */
addmsg headshell0 headshell1 DIFF_DOWN prev_C thick
addmsg headshell1 headshell0 DIFF_UP prev_C thick
// similar statements for the other shells ...
See also:
taupump ,
fixbuffer , Scripts/examples/spinedemo
Object Type: disk_in
Description: Reads in a 2-d array of data from an ascii or binary file.
Author: U. S. Bhalla, Caltech (1/90)
Coordinate read-in added by U. S. Bhalla, Mt. Sinai, 5/95.
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: disk_in_type [in src/olf/olf_struct.h]
Size: 148 bytes + allocation for arrays and interpols
Fields: filename name of data file
leave_open flag: leave file open between steps [cycles]
nx x dimension of input val array
ny y dimension of input val array
loop flag: return to start of file on EOF
val 2D array of input values
fp pointer to file
fileformat flag: 0 (default) for ASCII, 1 for FMT1
time_offset offset from sim time for FMT1 files
is_open internal flag : is file open yet?
allocated internal flag: Is array allocated yet?
tempdata data array used for FMT1 reading
start_time field used for FMT1 handling
dt field used for FMT1 handling
datatype field used for FMT1 handling
header_size field used for FMT1 handling
lastpos field used for FMT1 handling
xpts,ypts,zpts Interpols used for storing coordinate
information when FMT1 files are read.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: DiskIn [in src/olf/disk_in.c]
Classes: segment
Actions:
RECALC CHECK SET RESET PROCESS INIT
Messages:
none
------------------------------------------------------------------------------
Notes:
The disk_in element reads in data from a file to the val
array in the element every clock tick. This is a 2-d array
with dimensions set by the nx and ny fields.
The source file can be either in ASCII or FMT1 formats. FMT1
is the GENESIS-specific format used by disk_out. Data in
FMT1 files is time-stamped, and accessed according to the
current simulation clock.
At RESET, disk_in automatically figures out if the file
is FMT1. If not it assumes it is ASCII. The fileformat
flag is set accordingly.
FMT1 files contain information on the number of data items,
and the 3-d coordinate information for each item. On RESET,
the 'val' array is automatically allocated for the data values.
nx is set to 1, and ny is set to the number of data items.
Also on RESET, the coordinate information is loaded into the
xpts,ypts,zpts interpol-structs, which are automatically
allocated as needed. These interpols can be accessed in
the usual ways. See the interpol documentation.
ASCII files do not have coordinate information. The nx and ny
fields must be set prior to reading in an ASCII file, so
that the disk_in can figure out how many data points to
read per time-step. Changing nx and ny causes
automatic reallocation of the 'val' array, with dire
results for any messages that had been linked to earlier
incarnations of the val array. In other words, never set
the nx or ny unless you are sure that no messages
are being sent from the input array. Typically one sets
nx and ny as soon as one creates the disk_in, and
later adds messages.
The leave_open flag should normally be set to 1 to avoid
closing and reopening the file every clock tick.
The time_offset field allows one to specify the difference
between the simulation time and the FMT1 internal time stamp.
The format of the ascii file is simply a sequence of numbers,
separated by spaces, tabs or newlines, with a maximum of 16
numbers per line. They are read in sequentially to fill the
val[x][y] array, the x index being incremented more rapidly .
Every time a new clock tick is read in, the reading starts
from a new line, discarding any unread data on the previous
line.
The format of the FMT1 file is highly condensed. See the
source (in src/out/out_view.c) and the documentation for
disk_out for more details. In general, it includes information
on the size of the file, the coordinates of all elements
whose values are stored, and the time-step at which successive
data values are stored.
Example:
create disk_in /in
// read a single line with 2 variables at each time step
// from the file Vm1 (in Scripts/MultiCell)
setfield /in nx 2 ny 1 filename Vm1 dt 1 leave_open 1
create xform /form
create xgraph /form/graph
setfield /form/graph xmax 500 ymin -100 ymax 50
// The Vm value is the second one on each line
addmsg /in /form/graph PLOT val[1][0] *Vm *red
xshow /form
reset
step 500
Alternatively, the message from the disk_in element could have been an INPUT
message to a spikegen element. The spikegen element could then send a SPIKE
message to a synchan element, as in Scripts/tutorials/tutorial4.g.
If we had 100 cells, each containing a spikegen element, with names
``cell[0]/spike'' through ``cell[99]/spike'' and a data file containing
multiple groups of 10 lines with 10 Vm values each, to represent 100
simultaneous inputs, we could use statements like this:
// send a message for each spike generator
for (i=0;i<=9; i = i + 1)
for (j=0;j<=9; j = j + 1)
addmsg /in /cell[{j + 10*i}]/spike INPUT val[{i}][{j}]
end
end
Normally, you will want to use a clock with a much larger step for reading
in the data than that used for the integration of the equations for
calculating membrane potentials, etc. Otherwise, the data file would have
to be very large. The example in Scripts/examples/XODUS/fileview also
illustrates the use of arrays and the binary format.
Object Type: disk_out
Description:
The disk_out object is used to write data to a file in a special binary
format. This is done at every time step of the clock which is assigned.
These files are usually used with a disk_in object and the xview widget or
the xgraph widget to "replay" the results of a simulation. An external
program (or your own compiled GENESIS function) can write files in this
format in order to provide a convenient interface to the display
capabilities of XODUS.
Author: M. Wilson, Caltech (6/88)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: file_type [in src/out/out_struct.h]
Size: 88 bytes
Fields: filename data file name to be written
fp data file pointer
is_open flag: is file currently open?
initialize flag: has file been initialized?
leave_open flag: leave file open? 1 leaves the file open
all the time so you can write on it whenever
you want (a good idea if the file is used
frequently, but there is a limit to number of
files which can be left open any any time);
0 closes the file after every write to it
(only useful if you have more than 30 files;
this is slow)
append flag: append data after resetting?
flush flag: flush data to disk at each interval?
1 forces program to send data to the disk at
once and not store it in a buffer (slow but
secure); 0 (default) writes data in a buffer
(fast)
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: FileOutput [in src/out/out_file.c]
Classes: output
Actions:
SAVE DELETE PROCESS RESET
Messages: SAVE data
------------------------------------------------------------------------------
Notes:
If the filename field is not set, the output file will be given the same
name as the element which is created from the disk_out object. Use asc_file
for writing the data in ASCII format.
Example:
(from Scripts/orient_tut/V1_output.g)
function do_disk_out(diskpath,srcpath,field)
str name
create disk_out /output/{diskpath}
setfield /output/{diskpath} leave_open 1 flush 1
addmsg {srcpath} /output/{diskpath} SAVE {field}
end
do_disk_out vert_disk /lgn/vert/soma[] Vm
do_disk_out horiz_disk /lgn/horiz/soma[] Vm
Also see the example in Scripts/examples/XODUS/fileview/generate.g.
Normally, you need not be concerned with the format of the files produced
by a disk_out element. However, you may wish to write either a GENESIS
function or an external program which produces an output file which can
be displayed with an xview widget. The code which writes a disk_out
file can be found in /usr/genesis/src/out/out_file.c, and the code which
reads the data from the file can be found in /usr/genesis/src/out/out_view.c.
The following two C programs describe this format and show how to write and
read these data files.
------------------------------------------------------------------------------
/* diskwrt.c - a demo program to write a sample file "test_disk" in the
GENESIS "disk_out" format, to be viewed with the xfileview widget. */
#include <stdio.h>
#include <math.h>
main()
{
FILE *fpr;
int width = 5;
int height = 5;
float start = 0.0;
float dt = 1.0;
float x, y, data;
int ntimes;
fpr = fopen("test_disk", "w");
headerwrt(start, dt, width, height, fpr);
data = 0.0; /* make some bogus data */
for (ntimes = 0; ntimes < 20; ntimes++)
for (y = 0.0; y < height; y++) {
for (x = 0.0; x < width; x++) {
data = x*x + y*y + height*ntimes;
fwrite (&data, sizeof (float),1, fpr);
}
}
fclose(fpr);
} /* end main */
headerwrt(start, deltat, width, height, fp)
/* Header for files compatible with GENESIS disk_out
"FMT1" - 80 byte null terminated character string as identifying label
start - starting time - float
dt - time step - float
ndata - number of data points per time step - int
datatype - int code for data type - disk_out uses only FLOAT = 4, but
display routines can use DOUBLE = 5, INT = 3, SHORT = 2.
x1,y1,z1,x2,y2,z2,....,xndata,yndata,zndata - x,y,z coordinates for icon
representing each data point - float
The header is then followed by data - ndata values for each time step,
with the data type specified by "datatype".
*/
float start, deltat;
int width, height;
FILE *fp;
{
char label[80];
float strt, dt;
int ndata, datatype;
float x, y, z;
float dx = 2.0; /* horiz spacing between icons */
float dy = 2.0; /* vert spacing between icons */
int i, j;
strt = start; /* use local variables so addresses are correct */
dt = deltat; /* otherwise fwrite gets wrong start and deltat */
strcpy(label,"FMT1");
fwrite (label, sizeof (char),80, fp);
fwrite (&strt, sizeof (float),1, fp);
fwrite (&dt, sizeof (float),1, fp);
ndata = width*height;
fwrite (&ndata, sizeof (int),1, fp);
datatype = 4; /* use float data */
fwrite (&datatype, sizeof (int),1, fp);
z = 0.0; /* 2-D display */
for (j=0, y = 0.0; j < height; j++) {
for (i=0, x = 0.0; i < width; i++) {
fwrite (&x, sizeof (float),1, fp);
fwrite (&y, sizeof (float),1, fp);
fwrite (&z, sizeof (float),1, fp);
x = x + dx;
}
y = y + dy;
}
}
------------------------------------------------------------------------------
/* diskrd.c - Reads and displays the header information of files produced by
the GENESIS disk_out widget */
#include <stdio.h>
main(argc,argv)
int argc;
char **argv;
{
char label[100];
float fval;
int i;
int ndata;
int datatype;
FILE *fp;
if(argc < 2){
printf("usage: %s filename\n",argv[0]);
exit();
}
if((fp = fopen(argv[1],"r")) == NULL){
printf("unable to find file '%s'\n",argv[1]);
exit();
}
/* read in the file header */
fread(label,sizeof(char),80,fp);
/* check the label */
if(strncmp("FMT1",label,4) != 0){
printf("file '%s' is not a valid FMT1 data file\n",argv[1]);
fclose(fp);
exit();
}
/* starting time */
fread (&fval, sizeof (float),1,fp);
printf("%-20s = %e\n","start time",fval);
/* time step */
fread (&fval, sizeof (float),1,fp);
printf("%-20s = %e\n","time step",fval);
/* number of data points */
fread (&ndata, sizeof (int),1,fp);
printf("%-20s = %d\n","ndata points",ndata);
/** data type */
fread (&datatype, sizeof (int),1,fp);
printf("%-20s = %d\n","data type",datatype);
fclose(fp);
}
----------------------------------------------------------------------------
See also:
disk_in ,
asc_file
Object Type: diskio
Description:
The diskio object can be used to open/create a binary format file on disk
(specified with -fileformat option) that can be then used to read/write
data or metadata from/to it with child objects, 'variable' or 'metadata'
respectively in this same library. Unlike disk_out/disk_in, the reading
and writing actions are combined into this one new object.
For purposes of backwards compatibility (BC), diskio responds to the
set of messages that disk_out and disk_in respond to at a minimum, and
allows the user to read/write files directly from/to the disk at every
time-step of the clock which is assigned. It also allows the "replay" of
the results of a simulation through the xview and xgraph widgets in XODUS
by message passing as well as the "xsimplot" command added in genesis 2.2.
As of GENESIS 2.2, diskio supports files in the FMT1 and Netcdf formats.
Netcdf is a portable, network transparent, public domain binary format.
Netcdf interfaces to various popular analysis/signal-processing tools
including MATLAB are available in the public domain. Specifically,
* MEXCDF
WEB: http://crusty.er.usgs.gov/mexcdf.html
FTP: crusty.er.usgs.gov (128.128.19.19) or contact
Rich Signell at rsignell@crusty.er.usgs.gov.
* MexEPS
WEB: http://www.pmel.noaa.gov/epic/mexeps.html
FTP: ftp.pmel.noaa.gov/epic/mexeps/
* fanmat
WEB: http://www.unidata.ucar.edu/packages/netcdf/contrib.html
FTP: ftp.unidata.ucar.edu/pub/netcdf/contrib/fanmat.taz
are freely available packages that allow MATLAB to read/write/visualize
netcdf data.
The implementation of the diskio library and the diskio, metadata, and
variable objects makes use of netcdf, which is Copyright
1993-1997 by University Corporation for Atmospheric Research/Unidata. the
netcdf library is provided as per the terms of the UCAR/Unidata license,
described in the copyright notice found in the src/diskio/interface/netcdf
directory tree.
Author: V.Jagadish, Caltech (9/96)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Gen_Diskio_Type [in src/diskio/diskio_struct.h]
Size: 172 bytes + allocation for arrays and interpols
Fields: accessmode Mode with which the file is accessed
- 'r', 'w' or 'a' (Read/Write/Append)
- Read-only field specifiable on the
command line using the -accessmode option
but cannot be set/unset subsequently
using setfield
- Defaults to 'r' (Read mode) as this is the
most non-destructive
- Append 'a' mode is not supported currently
- BC NOTE: Due to the default mode being
readonly 'r', it is not sufficient to
merely replace creation-lines of disk_out
with diskio but to add the option
"-accessmode w" as well. cf. See Examples.
filename Data file name to read from or write into
- Defaults to name of object if not specified
- Can be set/unset as required : The old file
will have data and metadata written into it
till that point in time, if the accessmode
was 'w' (write).
fileformat Format of the data file
- Unlike disk_out it is a character string
field but allows numerical setting for BC.
("1" => FMT1, "2" => netcdf)
- Defaults to FMT1 if not specified
- Subsequent setting/unsetting of this
field is allowed only to preserve BC with
disk_out/disk_in. This is effectively a
NOP as far as the physical file is
concerned. Only the the value of the
field changes to reflect the setting and
is not recommended.
append Flag: 1 => data should be appended to file
after RESET. This has certain implications
from the point of view of interpreting the
'variable' object value[], input and output
fields. If the append flag is on, there
could be more than 1 value associated with
a single time instance. The output field
will always reflect the first value for the
time instant set for the input field. All
values however can be retrieved from the
value[] field and the size field of the
variable will show the total number of
values stored. The user needs to keep track
of when the reset was done and the time
step rate (dt) to interpret the values
stored in the value[] field.
is_open Read-only flag: is file currently open?
is_writable Read-only flag: is file writable?
val 2D array of input values
nx x dimension of input val array
ny y dimension of input val array
xpts,ypts,zpts Interpols used for storing coordinate
information when the binary file is read
flush Same functionality as in disk_out
leave_open Same functionality as in disk_out
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: Gen_Diskio [in src/diskio/gen_diskio.c]
Classes: output
Actions: CREATE PROCESS SET ADDMSGIN DELETEMSGIN SHOW
RESET:
It is essential that the RESET action be called
on the diskio object for allocating and filling the
"xpts ypts zpts" interpol arrays before using
them to render/replay data graphically on the
xview objects.
cf. Example: Scripts/examples/diskiolib/diskio
/replayview.g
QUIT:
FLUSH:
UPDATE: when called on the diskio object, allows the user
to commit any changes done interactively
or in the process of running a simulation or script,
to the file on disk. This allows another diskio
object to simultaneously access updated data from the
same file.
DELETE: also commits changes but with the usual effect of
deleting the object and all its children. Please note
that this action does not delete the physical file on
disk.
GENERAL NOTE: The process of committing changes to disk is
time-consuming for netcdf files. This is
inherent in the implementation of the
netcdf library. So please expect high
latency after you quit or do a delete or
call one of the above 4 actions on the
diskio object, when supporting the netcdf
fileformat. In general, the netcdf library
provides its portability across
architectures at the cost of efficiency in
speed. Therefore, performance-wise one will
notice diskio is slower than
disk_out/disk_in, in this situation. The
same is however not true for FMT1 file
support.
Messages: SAVE data
IMPORTANT BACKWARDS COMPATIBILITY (BC) NOTES:
---------------------------------------------
As previously mentioned, diskio responds to the same set of
messages that disk_out and disk_in respond to as a minimum, for
purposes of BC.
Since the actual data is encapsulated within the variable object
and the design eventually envisages the exclusive use of this child
object to manipulate data, any incoming SAVE messages to the diskio
object (thro the addmsg command) will result in the automatic
creation of child variables and the forwarding of the message to
them. So the data will be stored and manipulated via these child
variables, while letting the user transparently deal only with the
diskio object as was done previously with disk_out/disk_in.
For every SAVE message there will be a specially named child
variable object - 'autoSAVE_diskio[i]', where i is the index of
the element and that corresponds to the number of the message.
The indices will be reused if any messages are deleted and added
later.
Also, for every SAVE message, the 3-D position coords of the source
element needs to be stored for possible future replay via graphical
objects like xview. This is done through the automatic creation of
specially named indexed metadata children -
'auto3-DPosSAVE_diskio[i]'.
So in applications where diskio is intended to be used as a
replacement for disk_out/disk_in, these variables & metadata will
be automatically created in the hierarchy for every SAVE message to
the object. Directly manipulating these child objects should be
avoided, since it would essentially change the contents of the
file, if committed.
Example:
* Run Scripts/examples/diskiolib/diskio/generate.g
* genesis> le /diskio
------------------------------------------------------------------------------
Notes:
As a departure from the disk_out/disk_in objects, this object internally
just serves to interface (open/create/close) with a binary file on disk.
The actual data in the file can be more flexibly managed using the child
'variable' objects in this library. For purposes of backwards
compatibility, however, the diskio object will respond to the same messages
as the disk_out and disk_in objects at a minimum to actively write/read
data to/from the file during a simulation run.
Some binary file formats notably netcdf (which this library supports) allow
descripive data (metadata) to be stored in them along with the actual data.
Child 'metadata' objects in this library allow the user to manipulate the
metadata content in these files.
Use asc_file for writing data in ASCII format.
Examples:
0. create diskio /dout -filename testfile.nc -fileformat netcdf -accessmode w
// Not specifiying a fileformat while creating a file defaults to FMT1
1. create diskio /dout_FMT1 -filename testfile.fmt1 -accessmode w
2. call /dout UPDATE
3. delete /dout
4. Also, please see Scripts/examples/diskiolib/diskio/
- generate.g
- generate_netcdf.g
- replayview.g
- replaygraph.g
- simplot.g
______________________________________________________________________________
See also:
variable ,
metadata ,
disk_out ,
disk_in ,
asc_file
Object Type: efield
Description: An extracellular field potential recording electrode that uses
current sources and their distance from the electrode site to
calculate the field.
Author: M. Wilson, Caltech (2/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: efield_type [in src/device/dev_struct.h]
Size: 64 bytes
Fields: scale
field
x
y
z
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ExtracellularRecordingElectrode [in src/device/efield.c]
Classes: device
Actions: PROCESS
RESET
RECALC
Messages: CURRENT current 0.0
------------------------------------------------------------------------------
Notes: If one assumes that the medium surrounding neurons is
of homogeneous resistivity and has no capacitance,
then the field potential generated by a compartmental
model can be calculated from the following equation:
Im
1 n i
F = ------ SUM ----- (see Nunez, 1981)
4*pi*s i=1 R
i
where F is the field potential in volts, s is
conductivity in 1/(Ohms*m), Im_i is the transmembrane
current (Amperes) accoss the ith neural compartment,
and R_i is the distance from the ith neural
compartment to the recording electrode (i.e. the
efield object).
This equation is most accurate in the case of elongated
neurons oriented with the axis perpendicular to the scalp, as
is the case with cortical pyramidal cells. It is probably not
very good for a small cell. See the documentation of
compartment and symcompartment for details of the calculation
of the compartment Im.
In the case of the efield object, the term 1/(4*pi*s)
is replaced by the scale field, otherwise the same
equation is used to calculate field potentials.
The RECALC action must be called in order for efield
to calculate the distances to neural compartments.
For more information about field potentials and how
they are used in GENESIS simulations, see Chapter 9 in
The Book of GENESIS. For a derivation of the above
equation, see:
Nunez, P.L. (1981) Electric Fields of the Brain: The
Neurophysics of EEG, Oxford University Press, Oxford.
Example: create efield electrode
setfield electrode scale -1e3 x 0.00 y 0.00 x 0.00
addmsg some_compartment electrode CURRENT Im 0.0
call electrode RECALC
See also: Scripts/piriform/field.g,
compartment ,
symcompartment
Object Type: enz
Description: Enzyme activity for a pre-existing pool. An enz does two
things: it handles the reactions in the Michaelis-Menten (MM)
scheme below, and it also acts as a pool to represent the
enzyme-substrate complex. It can only be
created on a pool, it is not an independent object.
The MM scheme is modeled as:
k1 k3
Substrate + Enzyme <-----> EnzComplex ----> Enz + Prd
k2
The enz is really a utility object, as it replaces
two reacs and a pool, but does not add anything extra.
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1993).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: enz_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: CoComplex Concentration of enz-substrate complex.
CoComplex = nComplex/vol
CoComplexInit Initial concentration of enz-substrate
complex.
CoComplex gets set to this value on
RESET.
nComplex Number of molecules of complex.
nComplexInit Initial number of molecules of complex.
'nComplex'gets set to this value on
RESET.
vol Volume occupied by enzyme. Often
involves scale factor so as to have
direct conversion from 'n' to some
sensible units of Co, such as
micromolar.
sA A state variable to pass to substrate
in messages.
pA A state variable to pass to products
in messages.
eA A state variable to pass to parent
enzyme pool in messages.
B B state variable to pass to substrate
and parent enzyme pool in messages
k1,k2,k3 Michaelis-Menten parameters.
keepconc Flag determining whether to change
concs or n when volume changes
usecomplex Flag. Determines whether the enzyme
complex is used when the parent enzyme
is involved in other reactions.
Consider:
E + A <----> E.A
where E is a pool reacting with A.
Suppose E has an enzyme site. Then,
whenever some of the enzyme is complexed
with a substrate, the conc of E
decreases unless 'usecomplex' is true.
ksum Internal variable. ksum = k2 + k3.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: EnzFunc [in src/kinetics/enz.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: ENZYME n [n is number of molecules of enzyme
pool to which this site is attached]
SUBSTRATE n [Number of molecules of substrate]
VOL vol [volume of enzyme pool]
INTRAMOL n [Total number of molecules in an
intramolecular reaction]
------------------------------------------------------------------------------
Notes: See pool documentation for example of use.
------------------------------------------------------------------------------
Object Type: event_tofile
Description: A gizmo that collects an INPUT message. When value
in message exceeds threshold, current simulation
time is written to asci file.
Designed to allow ascii output from a range of
objects, like channelC3, synchan, timetable.
Author: D. Jaeger, Caltech (3/95)
---------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: event_tofile_type [in genesis/src/device/spike_struct.h]
Size: 64 bytes
Fields: fname File name of asci output
fp file pointer
open flag
threshold threshold above which time is written to file
-----------------------------------------------------------------------
SIMULATION PARAMETERS
Function: Event_tofileFunc [in genesis/src/device/event_tofile.c]
Classes: device
Actions: PROCESS
SET
OPEN
CLOSE
FLUSH
Messages: INPUT compared against threshold
-----------------------------------------------------------------------
Notes: An ascii file containing simulation times at which an event
occurred is generated. The event arrives via an INPUT
message, and is generated when the input value exceeds
threshold. Only positive thresholds are implemented.
Before activation the file needs to be opened with a reset or call
OPEN statement. The generic openfile, writefile, and closfile
commands can NOT be used with the same file.
Example:
create synchan syn
create event_tofile etf
set etf fname test.asc
sendmsg syn etf INPUT activation
reset
... // run simulation
call etf CLOSE
See also:
openfile ,
writefile ,
closefile
(for general asci file control),
timetable ,
spikegen ,
randomspike (for good source elements
to feed into event_tofile), Scripts/examples/spike/spikes.g.
Object Type: facsynchan
Description: Synaptically activated channel with synaptic facilitation
and/or synaptic depression.
Author: Mike Vanier
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: fac_synchan_type [in src/newconn/newconn_struct.h]
Size: 252 bytes
Fields: activation driving force ("transmitter") for channel
conductance
Ik channel current
Gk time varying channel conductance
Ek reversal potential of channel
tau1 first time constant of channel activation
tau2 second time constant of channel activation
gmax peak channel conductance (but see Notes below)
nsynapses number of incoming spike messages
(readonly)
event_buffer_size size of event buffer (readonly)
pending_events number of pending spike events in event
buffer (readonly)
nodes_per_synapse number of event nodes to allocate per
synapse (default 1)
synapse synapse buffer
fac_depr_on flag: no fac/depr if 0
max_fac upper limit on facilitation
fac_per_spike synaptic facilitation per spike
fac_tau time constant of synaptic facilitation
depr_per_spike synaptic depression per spike
depr_tau time constant of synaptic depression
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: FacSynchan [in src/newconn/facsynchan.c]
Classes: segment channel synchannel
Actions: CREATE Set default values and initialize object.
PROCESS Update Gk, calculate Ik, update facilitation/
depression state of synaptic weights.
RESET Assign activation = 0, Gk = 0; calculate
time-step-dependent coefficients; remove
all pending SPIKE events; reset facilitation/
depression state of synaptic weights.
RECALC Recalculate time-step-dependent coefficients.
CHECK Make sure tau1>0, tau2>0, gmax>0; make sure a
VOLTAGE message is present (in order to
calculate Ik); make sure facilitation/
depression parameters are reasonable.
SAVE2 Called by the save command.
RESTORE2 Called by the restore command
EVENT Put a spike event into the event buffer.
ADDMSGIN Add a new message.
DELETEMSGIN Delete a message.
MSGINDELETED Do cleanup after message is deleted.
RESETBUFFER Reset size of event buffer to
(nodes_per_synapse * nsynapses) nodes.
DELETE Delete the element.
COPY Copies the element.
Messages: VOLTAGE Vm
SPIKE
------------------------------------------------------------------------------
Notes: The `facsynchan' object is a version of the synchan object
that can exhibit synaptic facilitation, synaptic depression,
or some combination of the two.
1) General information about synchans.
The `facsynchan' object, like all synchan objects, simulates a
time dependent synaptically activated ionic channel. A
variable channel conductance `Gk' is activated by the
application of transmitter. This conductance then changes with
damped second-order characteristics with a time course given
by two time constants `tau1' and `tau2'. This gives rise to
an alpha function/dual exponential conductance waveform for an
impulse spike input. The channel also calculates channel
current (`Ik') and therefore needs the membrane state (`Vm').
Each SPIKE message to a synchan establishes a synaptic
connection and increments `nsynapses'. The synapses are
numbered starting with 0, and each contains a field for a
synaptic weight and a propagation delay. For example, the
weight of the first synaptic connection is held in the field
`synapse[0].weight' while the delay is `synapse[0].delay'.
`Gk' reaches a value (`gmax' * `weight') for a single event
delivered with a SPIKE message. Note that even though
synapses are not elements, they do have fields that can be
accessed individually. They can be thought of as
"sub-elements" or substructures of the element. Note also
that `gmax' is not the absolute maximum conductance of the
synapse; it is just the maximum conductance given a single
synaptic connection with a weight of 1.0 only. Multiple
synapses onto a particular synchan, weights higher than 1.0,
and/or synaptic facilitation can all give rise to total
conductances that are greater than `gmax'.
Any number of spike events can be pending per synapse. The
`facsynchan' object stores all spike events in a buffer until
they are scheduled to occur. If enough events come in to
overload the buffer, the buffer will dynamically expand to
enable storage of all events. The size of the buffer in
events is stored in the `event_buffer_size' field which is
readonly. The number of actual spikes in the buffer which
have not yet hit the channel are stored in the
`pending_events' field (also readonly). The
`nodes_per_synapse' field controls how many large the event
buffer is initially. The default is to have one node per
synapse, but if you expect a lot of events or very few events
you can change this number to be greater or less than the
default (1), respectively. This will speed up the simulation
slightly in the first case and save memory in the second. If
you leave this field alone the object will still work fine.
The "resetsynchanbuffers" command will cause all the buffers
in all synchan and derived objects to be reset to a size of
`nodes_per_synapse' * `nsynapses' (which will also cause all
pending events to be flushed).
The "copy" command will fail for any synchan type which is
receiving SPIKE messages. The correct way to set up
simulations is to set up prototype cells which do not receive
any SPIKE messages on their synchans, copy these cells, and
then add the appropriate SPIKE messages (by hand or by using
planarconnect or volumeconnect). We may eventually build a
more intelligent copy command which will permit copying of
synchans with SPIKE messages, but for now, don't do it.
2) Specific information about implementing synaptic
facilitation and depression.
Each synapse, in addition to its `weight' and `delay' fields,
has two other fields called `fac' and `depr' which represent
the current level of synaptic facilitation and depression,
respectively. Each time a spike hits, the facilitation and
depression values are incremented by a fixed amount
(`fac_per_spike' and `depr_per_spike', respectively) which can
be zero but not negative. The facilitation and depression
values decay away with a time constant equal to `fac_tau' and
`depr_tau', respectively. The effective synaptic weight when
a spike hits is calculated from these equations:
wt_multiplier = max((1 + fac) / (1 + depr), max_fac)
wt_effective = wt * wt_multiplier
Thus, a `fac' value of 1.0 and a `depr' value of 0.0 will give
rise to a wt_multiplier value of 2.0 (assuming that `max_fac'
> 2.0), so the effective weight at that point in time will be
twice the listed synaptic weight. The `max_fac' field allows
you to limit the amount that a particular synaptic weight can
grow; however, there is no limit to how low a weight can
shrink due to depression. If `max_fac' is negative, there is
no maximum facilitation level. This is the default (`max_fac'
= -1, to be precise).
You can switch facilitation/depression off by setting
`fac_dep_on' to 0. The default is 1 (facilitation on).
Example: Scripts/examples/facsynchan/facdemo.g
Bugs: The SAVE2/RESTORE2 actions have not been tested and may
contain bugs. Please report any bugs you find.
Caveats: The facsynchan object is not supported by the cell reader
(readcell), so if it is to be used in a model described
by a cell parameter (.p) file, you will need to use it in
a prototype compartment that is included with the readcell
"*compt" option.
See also:
synchan ,
resetsynchanbuffers ,
Connections ,
NewSynapticObjects ,
readcell
Object Type: fixbuffer
Description: Implementation of a first-order fixed (non-mobile) buffer.
Should be coupled to a difshell or concpool, where the change
in the concentration of the buffered ion is computed.
Author: E. De Schutter BBF-UIA 8/94 - 9/95
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: fixbuffer_type [in src/concen/conc_struct.h]
Size: 124 bytes
Fields: activation ion concentration from incoming CONCEN message
Bfree free buffer concentration (calculated) in mM
Bbound bound buffer concentration (calculated) in mM
prev_free Bfree at previous time step
prev_bound Bbound at previous time step
Btot total buffer concentration in mM (free + bound)
kBf forward rate constant in 1/(mM*sec)
kBb backward rate constant in 1/sec
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: FixBuffer [in src/concen/fixbuffer.c]
Classes: concbuffer segment
Actions: RESTORE2 SAVE2 CHECK RESET PROCESS INIT
Messages: CONCEN C (buffered ion concentration, sent from a
difshell or concpool)
------------------------------------------------------------------------------
Notes:
The fixbuffer interacts with a difshell or concpool to model the binding of
calcium to buffer molecules and to calculate the concentrations of free and
bound buffer molecules using a kinetic scheme with forward and backward rate
constants for the binding and release of calcium:
dBfree/dt = kBb*Bbound - kBf*Bfree*C
Bbound = Btot - Bfree, where Btot == constant
The rate constants kBf and kBb are set by the user, and the concentration C is
sent with a CONCEN message from the difshell or concpool. The BUFFER message
to a difshell or concpool from a buffer passes on the rate constants and the
calculated free and bound buffer concentrations.
For a general description of buffered calcium diffusion see: De Schutter E.,
and Smolen P., "Calcium dynamics in large neuronal models", in Methods in
neuronal modeling: From ions to networks (2nd edition), C. Koch and I. Segev
editors, pp. 211-250 (1998). The spinedemo simulation gives a detailed
example of the use of the difshell, taupump, and fixbuffer objects for
modeling calcium diffusion in dendritic spines.
Example: create fixbuffer headbuf0
setfield headbuf0 Btot 0.2 \ // Total buffer conc in mM
kBf 5.0e5 \// Forward binding rate 1/(mM*sec)
kBb 500 // Backward rate, 1/sec
addmsg headbuf0 headshell0 BUFFER kBf kBb Bfree Bbound
addmsg headshell0 headbuf0 CONCEN C
See also:
difshell ,
taupump , Scripts/examples/spinedemo
Object Type: freq_monitor
Description: Calculates running event (spike) frequency over a given time
window using exponential weighting.
Author: M. Wilson, Caltech (2/89), modified by D. Jaeger
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: freq_mon_type [in src/device/dev_struct.h]
Size: 84 bytes
Fields: tmin minimum time interval which must be held by
the buffer
size buffer size, in number of events
current current buffer location
start starting buffer location - 1
end last occupied buffer location
event_size size of each event data structure
event circular event buffer
exponent power by which to weight
frequency curent calculated value of the frequency
(set to zero on reset)
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: FrequencyMonitor [in src/device/new_frequency.c]
Classes: device
Actions: PROCESS RESET CREATE
Messages: NONZERO_TRIG input trigger on nonzero input
ZERO_TRIG input trigger only when input is zero
POSITIVE_TRIG input trigger on positive input
NEGATIVE_TRIG input trigger on negtive input
WINDOW tmin sets the window size tmin
CONTINUOUS input triggers every time
------------------------------------------------------------------------------
Notes: This is a frequency measuring device which computes the
running event frequency over a time interval using exponential
weighting. The field "tmin" should be set in order to specify
the interval or "window" for averaging. Larger values give a
smoother result. If "exponent" is unequal to the default
value of zero, inputs are weighted by exp(exponent*time). The
frequency field may be examined or sent to a graph.
The first four messages are used to give it an input, and the
counting of input events is triggered by one of the four
conditions. The most common way to use the frequency monitor
is to set the "tmin" field to an appropriate timing window,
send it a POSITIVE_TRIG message with the state of a spiking
element, and send a "PLOT frequency" message from the monitor
to a graph.
Example: See the demonstration script Scripts/examples/spike/freqmon.g.
See also:
Object Type: funcgen
Description:
This is a function generator which produces periodic output with a waveform
set by the mode field.
Author: M. Wilson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: funcgen_type [in src/device/dev_struct.h]
Size: 96 bytes
Fields: mode flag: 0=sine; 1=square; 2=triangle; 3=constant
amplitude peak-to-peak amplitude
dc_offset constant to be added to output
phase phase in degrees
frequency frequency
output output waveform
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: FunctionGenerator [in src/device/funcgen.c]
Classes: device
Actions: CHECK PROCESS RESET
Messages: AMPLITUDE amplitude
DC_OFFSET dc_offset
PHASE phase
FREQUENCY frequency
------------------------------------------------------------------------------
Notes:
In a simulation, you would set up messages between the funcgen element
(in our example it is called "funky") and other elements which are to
receive its output. For example:
addmsg funky funcplot PLOT output *function *red // funcplot is an xgraph
addmsg funky Exc_channel ACTIVATION output // Exc_channel is a synchan
Example: Scripts/examples/sigmoid
See also:
Object Type: fura2
Description: Computes fura2 fluorescence in a single difshell.
Author: E. De Schutter BBF-UIA 1/95
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: fura2_type [in src/concen/conc_struct.h]
Size: 104 bytes
Fields: F340 F340 fluorescence
F380 F380 fluorescence
ratio F340/F380
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: FuraRatio [in src/concen/fura2.c]
Classes: concentration segment
Actions: RESET PROCESS
Messages: CONCEN Bfree Bbound vol (from all fura2 difbuffers)
------------------------------------------------------------------------------
Notes: Computes the fluorescence signal of the fura-2 calcium
indicator dye by adding together information from a series of
difbuffers (representing the fura2 in shells).
In order to use the fura2 object, create difbuffers to model
the diffusion of the fura-2 dye and Ca buffering for each
difshell that is associated with a compartment. The Btot, D,
kBf, and kBb fields for the difbuffers should be set to values
that are typical of the ionic environment of the dye. The
difbuffers are linked to their difshells with the usual
messages.
Then send "CONCEN Bfree Bbound vol" messages to a single fura2
element from each difbuffer that corresponds to the
compartment for which you wish to calculate the fura-2
fluorescence signal.
For a general description of buffered calcium diffusion see:
De Schutter E., and Smolen P., "Calcium dynamics in large
neuronal models", in Methods in neuronal modeling: From ions
to networks (2nd edition), C. Koch and I. Segev editors, pp.
211-250 (1998). Details of the GENESIS implementation of the
fura2 object are given in Sec. 6.6.4. Also see Blumenfeld et.
al., Biophys. J. 63: 1146-1164 (1992) for additional
discussion of fura-2 parameters.
Example:
See also:
difshell ,
difbuffer
Object Type: ghk
Description: Calculates the Goldman-Hodgkin-Katz (constant field) equation
for a single ionic species. Provides current as well as
reversal potential and slope conductance.
Author: Subba Shankar 8/25/91, modified by EDS 9/93-10/96
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: ghk_type [in src/segment/seg_struct.h]
Size: 136 bytes
Fields: Ik channel current (calculated)
Gk channel conductance (calculated)
Ek channel reversal potential (calculated)
T temperature (degrees Celcius)
p permeability
Vm membrane potential
Cin concentration inside the compartment in mM
Cout concentration outside the cell in mM
valency charge on ion
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: Ghk [in src/segment/ghk.c]
Classes: device channel
Actions: CHECK PROCESS RESET
Messages: Cin concentration
Cout concentration
VOLTAGE Vm
PERMEABILITY p
------------------------------------------------------------------------------
Notes:
The general equation used is:
Cin * exp(K * Vm) - Cout
Ik = -p * F * K * Vm ------------------------
exp(K * Vm) - 1
valency * F
where K = -------------
R * (T + 273)
F = Faraday's constant (9.6487e4 coul/mol)
R = universal gas constant (8.314 volts*coul/(deg K * mol))
Unlike the tabchannel or tab2Dchannel, it is not assumed that the current
obeys Ohm's law and is proportional to the membrane potential Vm. However, a
compartment (or symcompartment) will expect a channel element to provide Gk
and the reversal potential Ek in a "CHANNEL Gk Ek" message, and use these to
calculate the incoming ionic current from Ik = Gk*(Ek - Vm). In order for
a ghk element to be used like a channel, suitable values of Gk and Ek must
be provided. This may be done by making the assumption that over a single time
step, Gk and Ek vary slowly compared to Vm. Then the approximation can be
made that dIk/dVm = - Gk, and that Ek = (Ik + Gk*Vm)/Gk. Thus, Ek is
calculated by the ghk element, rather than being set by the user or by
an incoming message. Note that the sign of the current expresses the GENESIS
convention that current flow into a compartment is positive.
One way to use this object would be to let a voltage or ligand gated channel
element determine the permeability of the channel as a function of time,
voltage, concentration of ligand, etc., and then send that permeability to a
ghk element (as a message) to determine the net current through the channel.
The resulting Gk and Ek could be sent to the compartment that contains the
channel. If you are keeping track of the concentration of your ion with a
concentration type element, you could send it the Ik field of the ghk element.
You could then get Cin or Cout messages from the concentration element into
the ghk element.
In the example below, the conductance Gk is sent to the ghk element in
a PERMEABILITY message. Although the permeability p and conductance Gk
have differnet units, the scaling has been taken into account in the ghk
object, as long as SI (MKS) units are used.
A full explanation of the constant field equation can be found in:
1) From Neuron to Brain, Kuffler, et al., Sinauer Assoc.
2nd edition, (1984) p. 123, 130.
2) Electric Current Flow in Excitable Cells, Jack, et al.,
Oxford Press, (1983) p. 237.
3) Ionic Channels of Ecitable Membranes, Hille, Sinauer Assoc.
2nd edition, (1992) pp 345-347.
Example: create ghk soma/Ca_ghk
setfield soma/Ca_ghk Cin {CCaI} Cout {CCaO} valency 2.0 T {Temp}
addmsg soma soma/Ca_ghk VOLTAGE Vm
addmsg soma/Ca_ghk soma CHANNEL Gk Ek
addmsg soma soma/CaT VOLTAGE Vm
setfield soma/CaT Gbar {GCaTs*surf}
addmsg soma/CaT soma/Ca_ghk PERMEABILITY Gk
addmsg soma soma/CaP VOLTAGE Vm
setfield soma/CaP Gbar {GCaPs*surf}
addmsg soma/CaP soma/Ca_ghk PERMEABILITY Gk
See also:
tabcurrent ,
setupghk ,
setupNaCa
Object Type: hebbsynchan
Description: Synaptically activated channel with a simple mechanism for
hebbian weight changes as a function of pre- and postsynaptic
activities.
Author: Mike Vanier 9/95; revised 4/96
--------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: HebbSynchan_type [in src/newconn/newconn_struct.h]
Size: 296 bytes
Fields: activation driving force (transmitter) for channel
conductance
Ik channel current
Gk time varying channel conductance
Ek reversal potential of channel
tau1 first time constant of channel activation
tau2 second time constant of channel activation
gmax peak channel conductance
frequency random activation frequency (default = 0)
nsynapses number of incoming spike messages (read only)
event_buffer_size size of event buffer (read only)
pending_events number of pending spike events in event
buffer (read only)
nodes_per_synapse number of event nodes to allocate per
synapse (default = 1)
synapse synapse buffer
pre_tau1 rise time constant for presynaptic averaging
pre_tau2 decay time constant for presynaptic averaging
pre_thresh_lo lower presynaptic threshold
pre_thresh_hi upper presynaptic threshold
avg_Vm averaged membrane potential (read only)
post_tau time constant for postsynaptic averaging
post_thresh_lo lower postsynaptic threshold
post_thresh_hi upper postsynaptic threshold
post_scale scaling factor for postsynaptic activities
weight_change_rate rate of weight change (roughly in units/sec)
min_weight minimum weight
max_weight maximum weight
change_weights flag: nonzero means weights can be changed
--------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: HebbSynchan [in src/newconn/hebbsynchan.c]
Classes: segment channel synchannel
Actions: CREATE set synapse_size hidden field
INIT assign activation = 0
PROCESS update Gk, calculate Ik; calculate hebbian
presynaptic and postsynaptic activities
RESET assign activation = 0, Gk = 0; calculate
time-step-dependent coefficients
RECALC recalculate time-step-dependent coefficients
CHECK make sure tau1 > 0, tau2 > 0; make sure a
VOLTAGE message is present (in order to
calculate Ik); check hebbian fields, etc.
SAVE2 called by the save command
RESTORE2 called by the restore command
EVENT put a spike event into the event buffer
ADDMSGIN
DELETEMSGIN
MSGINDELETED
RESETBUFFER reset size of event buffer to
(nodes_per_synapse * nsynapses) nodes
DELETE delete the element
COPY copies the element
Messages: VOLTAGE Vm
ACTIVATION activation
RAND_ACTIVATION probability amplitude
MOD modulation
WEIGHT_CHANGE_MOD modulation
SPIKE
------------------------------------------------------------------------------
Notes: This object simulates a time-dependent synaptically
activated ionic channel. A variable channel conductance Gk
is activated by the application of transmitter. This
conductance then changes with damped second-order
characteristics with a time course given by two time
constants tau1 and tau2. This gives rise to an
alpha-function/dual-exponential conductance waveform for an
impulse spike input. The channel also calculates channel
current Ik and therefore needs the membrane state (Vm).
Each SPIKE message to a synchan or hebbsynchan establishes a
synaptic connection and increments nsynapses. The synapses
are numbered starting with 0, and each contains a field for a
synaptic weight and a propagation delay. For example, the
weight of the first synaptic connection is held in the field
"synapse[0].weight". Gk reaches a value gmax*weight for a
single event delivered with a SPIKE message. Note that even
though synapses are not elements, they do have fields that can
be accessed individually. They can be thought of as
"sub-elements" or substructures of the element. The fields
the user should be concerned about in the synapse are "weight"
and "delay".
The above description is also true for the synchan object.
Hebbsynchans also have a "pre_activity" field, described
below. Note that this field was named "pre_avg" in GENESIS
version 2.0.1. The hebbsynchan object also updates the
synaptic weights of the synapses based on the presynaptic
"activities" (which are calculated separately for each
synapse) and the postsynaptic activity (which is the same for
all synapses which are part of a given hebbsynchan). The
activities are artificial values which do not have a direct
relationship to any real biological entities; very loosely we
can think of the presynaptic activity as being the amount of
calcium current through an NMDA receptor while the
postsynaptic activity is derived from an average of the
postsynaptic membrane potential (which will affect NMDA
receptors in reality). The pre- and postsynaptic activities
are used to update the weights in a roughly Hebbian manner
described below, which is similar but by no means identical to
the way NMDA-dependent LTP works. For serious GENESIS
hackers, we have isolated the actual weight change algorithm
in a single function in "hebbsynchan.c" which can be altered
if you need a different algorithm. If you want to calculate
pre- or postsynaptic activities differently you have to do a
lot more work.
The presynaptic activity is calculated by having each spike
generate a generalized alpha-function waveform with a
maximum size of 1 in the "pre_activity" field of the
synapse. This is meant to be analogous to an NMDA channel
conductance so the rise and fall times should be slow; for
instance we might use pre_tau1 of 10 msec and pre_tau2 of
100 msec. Note that this activity value doesn't mean that
there is a slow conductance being simulated here; it's just
used to determine a measure of presynaptic spiking
activity. When weight updates occur, the presynaptic
activity relative to two thresholds (pre_thresh_lo and
pre_thresh_hi) are used to calculate the weight change (see
below).
Also at each time step, the membrane potential of the
compartment the hebbsynchan is connected to is used to
update the "avg_Vm" field. This is done by running the Vm
of the compartment through a leaky integrator with a time
constant of post_tau. When weight updates occur, the
postsynaptic activity relative to two thresholds
(post_thresh_lo and post_thresh_hi) are used to calculate
the weight change (see below). Also, since presynaptic
activity values are dimensionless but avg_Vm has the
dimensions of volts, postsynaptic activities are internally
calculated by dividing the difference between avg_Vm and
the nearest threshold by "post_scale", which is also in
units of volts. You can think of post_scale as the amount
that avg_Vm has to be above threshold to give a
postsynaptic activity of 1.0.
The 2-d space defined by the pre- and postsynaptic
activities are separated into 9 regions based on two
presynaptic and two postsynaptic thresholds (called
"pre_thresh_lo", "pre_thresh_hi", "post_thresh_lo", and
"post_thresh_hi"). The values of the thresholds are fixed
and are specified by the user. The weight changes in each
of the nine regions are as follows:
---------> Presynaptic activity ----->
low medium high
Post- | |
synaptic | |
activity: | |
no | no change | decrease
low change | |
| | |
| | |
| -------------------------------------------------- <--- post_thresh_lo
| | |
| | |
\|/ no change | no change | no change
medium | |
| | |
| | |
| | |
| -------------------------------------------------- <--- post_thresh_hi
| | |
| | |
\|/ decrease | no change | increase
high | |
| |
| |
| |
^^^ ^^^
pre_thresh_lo pre_thresh_hi
The diagram shows what happens for various combinations of
pre- and postsynaptic activities. Note that if
pre_thresh_lo = pre_thresh_hi and post_thresh_lo =
post_thresh_hi then there are only four regions and the
weights will always be changing unless both presynaptic and
postsynaptic activities are below the thresholds. The
weight change algorithm used converts pre_activity into a
value which is the difference between the pre_activity of
the synapse and the nearest threshold value i.e.
real_pre_activity = pre_activity - pre_thresh_hi
(if pre_activity > pre_thresh_hi), OR
= pre_activity - pre_thresh_lo
(if pre_activity < pre_thresh_lo;
note that this gives a negative number), OR
= 0 otherwise
Similarly, the weight change algorithm calculates a "real"
postsynaptic activity as follows:
real_post_activity = (avg_Vm - post_thresh_hi) / post_scale
(if avg_Vm > post_thresh_hi), OR
= (avg_Vm - post_thresh_lo) / post_scale
(if post_activity < post_thresh_lo;
note that this gives a negative number), OR
= 0 otherwise
Note that the post_thresh values are both in units of
volts, like avg_Vm.
Once we have the "real" pre- and postsynaptic activities we
can update the weights. Essentially the algorithm now is
just the Hebb algorithm:
weight_change = real_pre_activity * real_post_activity *
weight_change_rate * dt;
where dt is the time step size in seconds. The
weight_change_rate is a field in the object and has units
of (1/time). Thus the overall weight change is
dimensionless, as is the weight itself. If
(real_pre_activity * real_post_activity *
weight_change_rate) equalled 1.0, then the weight would
increase roughly at the rate of 1 unit per second. One
neat feature of this scheme is that if weight_change_rate
is negative you get an anti-Hebbian synapse.
Unfortunately, there's more to it than this. There are
also two fields called "min_weight" and "max_weight" which
keep the weights of synapses connected to the hebbsynchan
within specified limits. We could in theory just truncate
the weights if the weight change algorithm tried to push it
beyond the limits, but in order to make it more smooth the
weight change calculated above is modified depending on how
close you are to min_weight or max_weight. The effect of
this is that the weight change rate is reduced when you
approach either limit.
There is also a field called "change_weights". If this is
set to zero, no weight changes will occur. Otherwise,
weight updates will occur according to the above algorithm.
In addition, hebbsynchans can receive a WEIGHT_CHANGE_MOD
message (or multiple messages of this type) which will
modify the effective value of weight_change_rate based on
the message value. In this case the effective
weight_change_rate is the product of the value in the field
of the object and the value in the message. The field
value is not changed. Thus you can have, say, a
sinusoidally varying weight change rate by setting
weight_change_rate to 1.0 and adding a WEIGHT_CHANGE_MOD
message from a sine wave generator (funcgen object) where
the sine wave varies from 0 to 2.0, say.
The "copy" command will fail for any synchan or hebbsynchan
which is receiving SPIKE messages. The correct way to set
up simulations is to set up prototype cells which do not
receive any SPIKE messages on their synchans, copy these
cells, and then add the appropriate SPIKE messages (by hand
or by using planarconnect or volumeconnect). We are
working on a more "intelligent" copy command which will
permit copying of synchans with SPIKE messages, but for
now, don't do it.
Default values of hebbian parameters (SI units are assumed
here):
pre_tau1 0.010 // seconds
pre_tau2 0.100 // seconds
pre_thresh_lo 3.0
pre_thresh_hi 3.0
post_thresh_lo -0.065 // Volts
post_thresh_hi -0.065 // Volts
post_scale 0.002 // Volts
weight_change_rate 1.0
min_weight 0.0
max_weight 100.0
change_weights 1
The RESET action does not restore the weights to the original
(unlearned) values. If you wish to re-run a simulation
starting from the initial state, write a script function that
sets the weights to the original values and then performs a
reset.
Example: Scripts/examples/hebb/hebb.g
See also:
synchan ,
resetsynchanbuffers ,
Connections ,
NewSynapticObjects
Object Type: hh_channel
Description: Implements the channel model described in A.L.Hodgkin and
A.F.Huxley, J.Physiol(Lond) 117, pp 500-544 (1952)
In the Hodgkin-Huxley model, the general form for the
channel conductance is represented as being proportional to
an activation state variable raised to an integer power
times an inactivation state variable raised to another
integer power. The hh_channel object calculates the channel
conductance from the equation
Gk = Gbar*X^Xpower * Y^Ypower
In the usual Hodgkin-Huxley notation for the Na channel, X
corresponds to the activation variable, m, with Xpower = 3,
and Y corresponds to the inactivation variable, h, with
Ypower = 1.
Channel elements which are created from the hh_channel
object calculate both X and Y by solving differential
equations of the form
dX/dt = alpha*(1-X) - beta*X
The voltage-dependent rate variables, alpha and beta, can
each assume one of the three functional forms:
1 (EXPONENTIAL): alpha(v) = A exp((v-V0)/B)
2 (SIGMOID): alpha(v) = A / (exp((v-V0)/B) + 1)
3 (LINOID): alpha(v) = A (v-V0) / (exp((v-V0)/B) - 1)
The form to be used and the constants A, B and V0 are
specified for each rate variable by setting fields in the
hh_channel element.
Author: M. Nelson, Caltech (8/88)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: hh_channel_type [in src/hh/hh_struct.h]
Size: 184 bytes
Fields: activation channel activation
Gk channel conductance
Ik channel current
Ek channel reversal potential
Gbar channel maximum conductance
X value of X gate (m)
Y value of Y gate (h)
Xpower power to raise X gate to
Ypower power to raise Y gate to
X_alpha_FORM Equation form for X gate alpha rate constant
1 = EXPONENTIAL, 2 = SIGMOID, 3 = LINOID
X_alpha_A A constant for X gate alpha rate constant
X_alpha_B B constant for X gate alpha rate constant
X_alpha_V0 V0 constant for X gate alpha rate constant
X_beta_FORM Equation form for X gate beta rate constant
1 = EXPONENTIAL, 2 = SIGMOID, 3 = LINOID
X_beta_A A constant for X gate beta rate constant
X_beta_B B constant for X gate beta rate constant
X_beta_V0 V0 constant for X gate beta rate constant
Y_alpha_FORM Equation form for Y gate alpha rate constant
1 = EXPONENTIAL, 2 = SIGMOID, 3 = LINOID
Y_alpha_A A constant for Y gate alpha rate constant
Y_alpha_B B constant for Y gate alpha rate constant
Y_alpha_V0 V0 constant for Y gate alpha rate constant
Y_beta_FORM Equation form for Y gate beta rate constant
1 = EXPONENTIAL, 2 = SIGMOID, 3 = LINOID
Y_beta_A A constant for Y gate beta rate constant
Y_beta_B B constant for Y gate beta rate constant
Y_beta_V0 V0 constant for Y gate beta rate constant
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: hh_channel [in src/hh/channel.c]
Classes: segment channel
Actions: INIT
PROCESS
RESET
CHECK
CALC_ALPHA
CALC_BETA
CALC_MINF
Messages: VOLTAGE Vm
------------------------------------------------------------------------------
Notes: The tabchannel object provides a faster and more general way
to implement this type of channel.
The CALC_ALPHA, CALC_BETA, and CALC_MINF actions are used with
calls of the form
y = {call <element> CALC_ALPHA <gate> <x-value>}
in order to access values of alpha, beta or m_inf (the steady
state activation, alpha/(alpha + beta)) for the specified gate
(X or Y) and a particular value of the independent variable.
This feature is most often used for making plots of these
quantities. Note that the activation time constant can be
calculated from tau = 1/(alpha + beta).
Example: Scripts/neurokit/prototypes/hhchan.g
See also:
tabchannel ,
vdep_channel
Object Type: hillpump
Description: A simple model for the store membrane pump (SERCA), similar
to the mmpump, but with a Hill exponent.
Author: E. De Schutter BBF-UIA 11/97
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: hillpump_type [in src/concen/conc_struct.h]
Size: 92 bytes
Fields: vmax maximum pump velocity, scaled by mebrane
surface area. i.e., max ion flux in moles/sec.
Kd disassociation constant
Hill Hill exponent
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: HillPump [in src/concen/hillpump.c]]
Classes:: gate segment
Actions: CHECK RESET PROCESS INIT
Messages: MMKD Kd (changes Kd value)
------------------------------------------------------------------------------
Notes:
The hillpump is similar to the mmpump, and is coupled to a difshell to reduce
the concentration in the shell, and to a concpool to increase the
concentration. The message "HILLPUMP vmax Kd Hill" to a difshell causes the
concentration to change as dC/dt = -vmax*(C^Hill/(C^Hill+Kd)/vol. When sent
to a concpool, it changes the concentration with the opposite sign. Note that
the maximum pump velocity vmax should have previously been multiplied by the
membrane surface area, so that it is in moles/sec.
This does not have the electrogenic effect (Ik) calculation of the mmpump. It
gets Kd from a MMKD message (or a setfield), and simply stores Kd, vmax, Hill,
letting the difshell or concpool do the calculations.
Example:
See also:
mmpump ,
difshell ,
concpool
Object Type: hsolve
Description: An object used for implementing the Hines method for the
implicit solution of dendritic trees, as well as a set of
routines that maximize speed. This allows faster, more
stable numerical integration methods to be used with GENESIS,
particularly when there are many compartments in a cell.
Author: U. S. Bhalla and E. De Schutter Caltech 91-93,
E. De Schutter BBF-UIA 94-99.
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: hsolve_type [in src/hines/hines_struct.h]
Size: 552 bytes
Fields: path wildcard list of compartments to be
integrated; specifies all compartments
belonging to cell which hsolve element will
deal with. The default is
./##[][TYPE=compartment]
chanmode flag that controls channel computations and
chip-array use.
0 = default. It is the most general, uses least memory
and is slowest (no chip-array). It takes over the
actions of compartments only, computing all other
object types as before. As a consequence, all
computed fields of the original elements are updated,
and all user-setable fields may be set, just as before
the element was taken over by the hsolve element.
This means that you can add and delete outgoing
messages to compartments or other elements whenever
you like and easily change parameters during the
course of the simulation, making this the easiest mode
to use. It is also the most compatible mode of
operation, and is guaranteed to work with any future
new object type. One significant limitation is that
you cannot add or delete AXIAL, RAXIAL or CHANNEL
messages, once the hsolve element has been created.
In order to calculate the compartment Im field,
the compute_Im flag must be set.
1 = like chanmode 0, but optimizes calculations for
tabchannel equations. This will be faster than
chanmode 0 for models containing tabchannels and
tab2Dchannels.
2 = assumes integer exponents (maximum = 6) for
tabchannel and tab2Dchannel gate variables. Chanmodes
2-5 are the fastest because of the large 'chip-array'.
Under these moses, you can no longer assume that all
the fields of the elements that are taken over by
hsolve will be updated. Incoming and outgoing
messages to and from the disabled elements will work
properly, provided that they were added prior to
setting up the hsolve element. However, the Vm fields
of all compartments are automatically updated under
chanmode 2, whether or not there were pre-existing
messages to output Vm. Note also that several fields
(Gk, Ik, Ek, and Im) are not available for output in
chanmodes 2 and 3, so you have to use chanmode 4 or 5
with findsolvefield if you want to output these fields.
3 = as chanmode 2, but Vm fields of compartments are
not automatically updated. This mode is faster than
chanmode 2, at the expense of somewhat greater memory
usage. All disabled elements (including compartments)
that had outgoing messages to non-hsolved objects
during the SETUP call are updated at a rate determined
by outclock. Thus SAVE and PLOT messages will work
properly, except with the fields Gk, Ik, Ek, and Im.
4 = as chanmode 3, but more variables (e.g. Gk, Ik,
Ek, Im and leak) are stored by hsolve so that they can
be accessed by SAVE or PLOT messages (see
findsolvefield documentation for more details). The
added field, leak, is available for each compartment
to give the current flowing through the membrane
resistance Rm. Im is calculated directly as the sum
of the channel currents and the leakage current.
5 = as chanmode 4, but normalizes the currents and
conductances stored in the hsolve givals array (for
display purposes only).
computeIm flag to determine whether the compartment Im field
is calculated in chanmodes 0 and 1. If set, Im is
approximated by the sum of axial currents and injected
current, as done for non-hsolved compartments and
symcompartments.
0 = the default, does not calculate Im.
1 = calculates Im, with a decrease in speed.
comptmode flag that selects option for compartment computations
0 = uses least memory, and is slightly slower. However
the amount of time spent in this part is usually less
than 10% of the total, so this should not matter.
1 = the default, uses a lot of memory and is twice as
fast for the actual Hines matrix calculation. This
may be only a 5% difference. comptmode 1 is
required for chanmodes 2-5.
calcmode flag affecting operations for chanmodes 2-5.
0 = no interpolation will be performed in lookup
tables. This mode is for backward compatibility with
older versions of hsolve (prior to GENESIS 2.1) which
did not use interpolation.
1 = default mode with linear interpolation of values
in lookup tables.
storemode flag, only valid for chanmodes 4 and 5, to allow the
output of total currents and conductances. For each
type of voltage gated channel in the model, the total
currents or conductances are the sum of the
corresponding Ik or Gk fields for all compartments
where the channel is present. This assumes that these
channels have the same name in each compartment.
These are stored in an array called itotal. When the
hsolve element is set up, a message will be output
giving a list of channel names and corresponding
itotal indices, if the 'silent' command has previously
been given with a negative argument.
0 = no sums are stored.
1 = total currents are stored.
2 = total conductances are stored.
no_elminfo = 0/1; flag that controls whether the HPUT and HSET
actions will work. Is relevant only for chanmodes
2-5. Default is zero (HPUT and HSET work).
Saves memory if non-zero value is used (HPUT, HSET
do not work; HRESTORE and HSAVE do).
outclock number [0-99] of the clock used for all element
updates if chanmode = 3, 4, or 5, will affect SAVE and
PLOT messages. The element update routines are not
very efficient, so setting them to a slower clock will
speed up things. Note however that any object that is
not computed by the hines solver and that depends on a
message from a hsolve-computed object will be affected.
The other fields displayed with the showobject command are NOT
to be set by the user.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: HinesSolver [in src/hines/hsolve.c]
Classes: hsolver
Actions: RESET does the standard reset functions, but also for
chanmodes 2-5, it will update all parameters in
the chip-array (equivalent to a HRESTORE call) and
recompute rate factor tables if clocks were changed.
DELETE standard actions
PROCESS standard actions
SETUP setup all internal tables. Must be called before the
hsolve element is used. User accessible fields
(path, chanmode, etc.) should have been set. Model
changes after the SETUP call may have no effect on
the computations.
DUPLICATE does an efficient duplication of an hsolve element.
Use this in a network simulation for identical
copies of a neuron. Only the tables containing
changing parameters (Vm, etc.) will be duplicated.
Syntax: call hsolve1 DUPLICATE hsolve2 duplic_path
HPUT updates chip-array. Fields from a single element are
put into the chip-array (chanmodes 2 or 3). Do this
call after a setfield command on the element.
Syntax: call hsolve HPUT element_path
HGET updates hsolve-computed element. Computed values are
put from the chip-array into a single element
(chanmodes 2-5). Do this call before a getfield on
the element. Syntax: call hsolve HGET element_path
HRESTORE the complete chip-array is updated. Fields from all
hsolve-computed elements are put into chip-array
(chanmodes 2-5). Do this call after a restore
command or after multiple setfield commands.
Syntax: call hsolve HRESTORE
HSAVE all hsolve-computed elements are updated. Computed
values are put from the chip array into all elements
(chanmodes 2-5). Do this call before a save
command or before multiple getfield commands.
Syntax: call hsolve HSAVE
Messages: None.
Example:
// Do all the preparatory grunge work
.
.
// create the cell as an hsolve element
readcell test.p /test -hsolve
// set the chanmode, comptmode and calcmode (if other than defaults)
setfield /test chanmode 2
// set up the arrays and tables for the solver
call /test/solve SETUP
// use the Crank-Nicholson method for the hsolve element
setmethod 11
// It is essential to call reset (or reschedule) after setting
// up an hsolver, so that the process list gets updated.
reset
------------------------------------------------------------------------------
Notes:
The hsolve element completely takes over the calculations for compartment and
symcompartment elements and certain other elements specified as part of the
cell. Each hsolve element should only solve one cell. The timestep for the
integration is determined by the clock assigned to the hsolve element, and the
clocks for these elements which are taken over are ignored.
When using the Hines solver with a neuron, it is best to think of the entire
neuron as a single object since the individual compartments within the cell
are no longer responsible for their own computations. This loss of object
orientedness is mitigated to some degree by the ability of the solver to
transparently interact with elements utilizing other integration schemes.
There are 2 basic modes for hsolve operation: without chip-array (chanmode 0
or 1), or with chip-array (chanmodes 2-5). Without chip-array is the most
compatible mode, but is the slowest. With the chip-array, hsolve is much
faster because the original elements are no longer used, instead all
simulation parameters are stored in a huge array (this improves memory access
times). Unfortunately you can no longer expect that it will update the fields
in computed objects (like Vm in a compartment or Ca in Ca_concen) so that
graphic or file output might not work. Vice versa, if you change a field
(like inject in compartment) it might not affect the simulation. However,
there are methods available to get values in and out of the chip-array, which
involve special settings and/or the use of the HPUT, HGET, HSAVE and HRESTORE
actions listed above. This is ilustrated in another example below. The
documentation for findsolvefield describes another method, introduced in
GENESIS 2.1, that also allows access to these values.
The example above illustrates the process of setting up the hsolve element.
First, one should create the cell as an hsolve element at the root of the cell
element tree. This may be done in one step by using the "-hsolve" option with
readcell. Note that, starting with GENESIS version 2.2, it is necessary to
provide the full path to the cell when using readcell to directly create an
hsolve. (e.g. you can't use "readcell test.p test -hsolve", even if "/" is
the current working element.)
If readcell is not used, then the hsolved cell should be created with
statements like
create hsolve /test
create compartment /test/soma
create tabchannel /test/soma/Na_channel
...
It is required that only compartments (or symcompartments) be children of the
cell, and that channel, concentration, etc. elements should be children or
grandchildren of the compartment to which they are attached.
Next, set any fields of the hsolve which are needed to specify non-default
values of chanmode, comptmode, calcmode, storemode, etc. Then, one needs to
call the SETUP action in order to tell the hsolve element to create all the
solution arrays and tables. Finally, chose either method 10 (backwards Euler)
or 11 (Crank-Nicholson) as the method to be used. All elements that lie
outside this tree will continue to be treated by the previous explicit method
(typically exponential Euler). The Scripts/examples/hines directory contains
an example that which demonstrates both chanmodes 0 and 2.
Although it is not presently necessary to create the hsolve element as the
root of the element tree, future versions of hsolve may require this. The
older method of creating the hsolve is to create the cell as a neutral
element, create the hsolve element as a child element, and then set the hsolve
path field to indicate which elements will be taken over. Typically, a
wildcard path is used to refer to all compartment elements in the simulation.
This includes all hsolvable sublelements of these compartments. For example,
// readcell will place the compartments below the neutral '/test'
readcell test.p /test
// create the hines solver element below the cell '/test'
create hsolve /test/solve
// Specify the path for the solver
setfield /test/solve path /test/##[][TYPE=compartment]
RESTRICTIONS
It is important to be aware of some of the restrictions imposed by the use
of hsolve:
Only the objects compartment, symcompartment, tabchannel, tab2Dchannel,
tabcurrent, spikegen, Ca_concen, concpool, nernst, Mg_block, ghk, taupump,
mmpump, hillpump, difshell, fixbuffer, difbuffer, dif2buffer, fura2, synchan,
and the oldconn library channels channelC2 and channelC3 are handled by
hsolve. If your simulation uses these listed objects, the use of hsolve will
increase speed significantly. Note that as of GENESIS version 2.2,
symcompartment objects are handled by hsolve.
An important restriction introduced in GENESIS version 2.1 is that, for
chanmodes 2-5, the element tree of your cell (or other element tree to be
taken over by hsolve) must not contain any non-hsolvable elements other than
neutral elements. For existing simulations which violate this restriction, it
will be easiest to switch to chanmode 0 or 1.
It is not guaranteed that messages from unlisted objects to listed objects
will work, though solve should alert you about any such incompatibilities.
Most incoming messages will work if you use chanmodes 2-5, however you will
receive a warning if the source of the message is not hsolved. This is to let
you know that the source element is being solved by a less accurate explicit
method. Messages from listed to unlisted objects will only work for certain
chanmode settings.
hsolve does not keep track of changes made to the model after the hsolve SETUP
command (particularly the following commands: create, copy, delete, addmsg,
deletemsg). In chanmode 0 or 1 this only affects the listed objects and
messages between them; in chanmodes 2-5 this affects the listed objects and
ALL messages going in or out from them. The hsolver should be used in these
modes only for finished models (you can use it for parameter searches); do not
use it if you are still constructing and testing a model.
hsolve may miscalculate if you change clocks used by tabchannels,
tab2Dchannels, synchans, or channelC2/C3 objects without doing a reset (only
in chanmodes 2-5).
The Hines solver utilizes a considerable amount of memory. Memory use
increases as the result of comptmode + chanmode - no_elminfo flags. In
particular, going from chanmode 0 or 1 to chanmode 2, 3, or 4 causes a big
jump in memory usage. Approximately 100 bytes are required per compartment if
the speed-optimized version of the hsolve element is used. Most of this
storage is for tables describing the sequence of calculations. These tables
can, however, be shared between cells which are identical in topology and
differ only in parameter values.
FURTHER EXAMPLES
* Copying cells with the hsolve element
When a cell using the hsolve element is copied, the pointers in the
duplicated hsolve element are unchanged. In other words, they refer back to
the original cell. One could simply change the path to refer to the current
cell and call SETUP again, but that would unnecessarily duplicate a lot of
tables. The efficient option would be to use the original tables where they
are identical, and construct new ones where they refer to the current cell.
This is done using the DUPLICATE sction, which takes the name of the new
hsolve element and a wildcard path duplic_path as arguments. duplic_path
points to all compartments that should be taken over by the new solver.
For example,
// Copy the original cell to /test2
copy /test /test2
// create the hines solver element below the cell '/test'
create hsolve /test/solve
// Specify the path for the solver and the chanmode
setfield /test/solve path /test/##[][TYPE=compartment] chanmode 4
call /test/solve SETUP
// Duplicate the hsolver
call /test/solve DUPLICATE /test2/solve /test2/##[][TYPE=compartment]
reset
There are several commands, including createmap and cellsheet, that copy
cells. The DUPLICATE command should be issued for the hsolvers on each copy.
When using chanmodes 3 or higher, findsolvefield must be used with messages in
order to access fields of duplicated hsolves, as shown in the documentation
for findsolvefield.
* Deleting hsolve elements
When an hsolve element is set up it removes the relevant channels and
compartments from the list of elements to be processed, by setting a bit
(0x100) on the flag field of those elements. These elements are re-enabled
and the bit set back to 0 when the hsolve element is deleted.
WARNING: in the present implementation, the hsolve element does not check
whether it has had duplicates made using the DUPLICATE command. This makes it
possible to delete the tables for all of the copies by deleting any one of
them, resulting in segmentation violations and similar amusements. In other
words, do not delete hsolves on duplicated cells.
* Accessing data fields in chanmodes 2-5.
A script similar to this example might be used for running a long simulation
as a background job, using no graphics. The HPUT and HSAVE actions are used
in chanmode 2 or 3 to allow the simulation results and the final state of
the simulation to be saved to disk. A disk_out element is used to output the
Vm of a soma compartment in a compressed binary format. However, it is
equally possible to output Vm from every compartment, or from an array of
cells. Later, a script using a disk_in element can display the results using
messages from the disk_in to an xgraph or xview. The save command is used
here to save field values of all elements except nernst elements and the
hsolve element. This will allow the simulation to be resumed from its final
state by using the restore command.
For more details, see Scripts/examples/XODUS/fileview and the documentation
for disk_out, disk_in, save, and restore.
/* load scripts and global variables */
include defaults
include other_stuff
pushe /library
make_my_stuff
pope
/* make the model */
readcell my_cell {my_cellpath} -hsolve
/* set the clocks */
setclock 0 1e-5 /* integration */
setclock 1 1e-4 /* output */
/* create the output or graphics elements */
/* note that if you want to output Vm only, but from multiple
** compartments, you should use chanmode == 2; if you want to
** output other fields or Vm from only one compartment,
** use chanmode == 3 */
create disk_out /output/disk
useclock /output/disk 1
addmsg {my_cellpath}/soma /output/disk Vm
addmsg ...
/* create any other elements */
....
/* setup the hines solver */
setfield {my_cellpath} \
comptmode 1 \
chanmode 3 \
outclock 1
call {my_cellpath} SETUP
setmethod 11 // Crank-Nicholson integration method
/* initialize output */
setfield /output/plot_out filename {filename} initialize 1
setfield /output/plot_out filename {filename} append 1 leave_open 1
reset
step 0.10 -t
/* do a current injection */
setfield {my_cellpath}/soma inject 1.0e-9 /* in Amps */
/* update chip array */
call {my_cellpath} HPUT {my_cellpath}/soma
step 2.00 -t
/* save the integration values to disk */
call {my_cellpath} HSAVE
save {my_cellpath}/##[][TYPE!=nernst][TYPE!=hsolve] {savename}
quit
---------------------------------------------------------------------------
DETAILED DESCRIPTION
The Hines library provides elements and functions for the efficient implicit
solution of the systems of differential equations arising in single-neuron
models. The sparse matrix arising from the the branched structure of neurons
is ordered by the method described by Michael Hines, which permits it to be
solved in order N operations using Gaussian elimination without pivoting.
The nonlinear equations resulting from the Hodgkin-Huxley description of ion
channels are treated as conditionally linear, and also solved in an
efficient, second-order manner. Compatibility with other integration
schemes is maintained so that mixed integration schemes are feasible.
The element sets up a data structure whereby the only change needed for
other identical cells is to reassign pointers to the compartment and channel
elements. This avoids having to reallocate and rederive the solving
scheme. Solutions are done using gaussian forward and backward elimination
without pivoting. The numbering and evaluation sequence ensures that no new
off-diagonal terms are formed which might mess up the sparse matrix
representation. The sparse matrix is represented by a single 'values' array
indexed using the ri and cip arrays. The actual solution system is stored
as a linear sequence of operations on the 'values' array, in an attempt to
speed things up a bit.
The implicit method leads to numerically stable solutions for all time
steps. Numerical accuracy, however, imposes limits on the integration time
step which must be empirically evaluated for each simulation. Typical
values are 100 microsecond time steps for purely passive membranes and 20
microsecond time steps for membranes with active channels. This confers a
considerable speed up in detailed neuronal simulations where the presence of
electrotonically small compartments (such as dendritic spines) leads to
systems of equations which are numerically very stiff. In order to obtain
similar accuracy using explicit integration methods, time steps in the
nanosecond range may be required.
In addition to the substantial speed advantage gained from the use of an
implicit solution, the coding of the Hines solver element has been done with
a view to computational efficiency. This results in a speed up of around 50%
compared to the same model with the same time step, using the conventional
explicit Euler integration scheme.
Code changes needed for the Hines library
This section is probably of interest only to individuals who have developed
their own code libraries and who are deeply entangled in GENESIS coding
issues. For most users the changes are transparent, once the .simrc and
schedule.g file have been updated to reflect the addition of a new library.
The incorporation of a completely new integration scheme to the simulator can
be expected to have numerous repercussions. Fortunately, the changes needed for
the Hines library turned out to be relatively painless. No changes were needed
for the code of any of the existing elements. There is a slight rearrangement
of the order of fields in the various channel objects, and a new globally
#define'd type called CHAN_TYPE has been created so that all these channel
objects have the following common fields at identical memory offsets: Ik, Gk
and Ek (See src/sim/struct_defs.h). All channels whose structures obey this
convention can be used in cells utilizing the hsolve element. A very small
number of channel objects (such as channelC) do not share these fields and
therefore cannot be part of cell models which use the hines solver.
A new flag (0x100) has been employed for the Hines solver, which causes the
removal of compartment and tabchannel elements from the action list (the list
of elements whose action functions are to be called according to the clocks).
This flag is similar to the disable option except that it leaves the children
of these elements intact.
In the interests of speed (which is, after all, what the Hines method is all
about) I have 'unrolled' the sparse matrix solution into a single giant
function array. This is done at setup time, so the actual solution does not
involve any conditionals and minimises array lookups. This is moderately
expensive in terms of memory. The size of the function array allocated is
S = FA * sizeof (int) ; FA = 10 + 1.5 * M^2 / N
where S is the size of the array, FA is the number of functions allocated, M
is the number of non-zero coefficients in the solution matrix and N is the
number of compartments. M depends strongly on the branching pattern of the
cell. FA is an approximation to, and is greater than F, which is the actual
number of locations needed in the function table. For example, in a mitral
cell model, which has limited branching:
N = 286 ; M = 856 ; FA = 3853 ; S = 15412 ; F = 3710
In a granule cell model with numerous dendritic spines:
N = 944 ; M = 2830 ; FA = 12736 ; S = 50944 ; F = 12264
A reasonable approximation is that each compartment requires about 54 bytes in
the function table, which is not too bad.
References: Hines, M. (1984) Efficient computation of branched nerve
equations. Int. J. Bio-Med. Comp. 15: 69-76
Mascagni, M.V. (1989) Methods in Neuronal Modeling Ed: Koch
and Segev. Chapter 13. 439-484
See also:
setmethod ,
findsolvefield
Object Type: interspike
Description: Generates an interspike interval histogram.
Author: E. De Schutter Caltech 8/91
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: interspike_type [in src/device/dev_struct.h]
Size: 116 bytes
Fields: output gives the most recent interspike interval
threshold voltage threshold for determining when a spike
occurs
binwidth time interval between bins
num_bins number of table entries (bins)
trigger_mode 0 (free run) or 1 (triggered)
reset_mode if 1 then bins will be emptied upon RESET
table table with the number of spikes for that bin
prev_time time of last event (not set by user)
triggered set to 1 on RESET if trigger_mode = 0 (free run),
else is 0 until a TRIGGER message is received
(not set by user)
spiking flag indicating spike in progress
(not set by user)
allocated flag indicating table has been allocated
(not set by user)
------------------------------------------------------------------------------
Function: InterSpikeInterval [in src/device/interspike.c]
Classes: device
Actions: CHECK PROCESS RESET
Messages: SPIKE time (Time of occurrence of a spike.)
TRIGGER state (If state is > 0, the previous spike time is
set to the current time, and binning starts
at first bin.)
INPUT voltage (The Vm value sent to be compared with
threshold.)
------------------------------------------------------------------------------
Notes: interspike produces an interspike interval histogram (ISI).
Incoming data is used to fill an internal array (called table)
that contains num_bins entries from which the histogram values
can be read. These objects can collect data on-line during a
simulation, but do not produce much useful information during
the simulation (the output field of interspike can be used to
look at the most recent interspike interval). At the end of
the run, the histogram results can be retrieved with commands
such as "getfield /interspike table[{i}]", with i taking on
values from 0 through nbins-1. The example script reads the
table entries and and plots a histogram after the run phase of
the simulation.
The last bin also contains the number of intervals with
values larger than that of the last bin.
There are two modes that may be used, as determined by the
"trigger_mode" field. If the field is 0, the system is
free-running and begins accumulating data right away.
Otherwise, the system waits until it receives a trigger to
start binning incoming events. The trigger should be a single
time step event like the state field of a 'spikegen' or
'randomspike' object, sent with a TRIGGER message.
Events can be defined in one of two ways. They can be
determined from the time that the value of an INPUT message
first exceeds threshold. The voltage must then fall below
threshold before another spike event can be recorded.)
Alternatively, a SPIKE message can be sent giving the time
that a spike occurs. Note that this is NOT like the SPIKE
message of a synchan, which does not require an argument.
Example: See Scripts/examples/spike.
See also:
peristim
Object Type: leakage
Description: Provides a constant conductance in series with a battery.
This is often used to implement a passive "leakage" channel
having a fixed conductance.
Author: M. Wilson, Caltech (6/88)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: leakage_type [in src/segment/seg_struct.h]
Size: 96 bytes
Fields: Gk the Gk to be sent in a CHANNEL message
Ek the leakage battery
activation the leakage conductance used to calculate Ik
Ik channel current
inject not used
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: Leakage [in src/segment/leakage.c]
Classes: segment
channel
Actions: PROCESS Calculates Ik
RESET Sets Ik = 0
CHECK Checks to see if an incoming VOLTAGE
message has been established.
Messages: VOLTAGE Vm
------------------------------------------------------------------------------
Notes: This object is intended to be used as a flexible leakage
term in conjunction with the membrane model. As with any
other type of channel, it normally is used to send its
conductance (Gk) and reversal potential (the battery in series
with Gk) to the parent compartment using a CHANNEL message.
In this case, Gk has a constant value, to be set by the user.
Although this feature is not often used, a leakage element
also calculates the current, Ik = (Ek - Vm)*activation. Here,
Vm is the compartment membrane potential received with a
VOLTAGE message, and "activation" is a conductance. This
would normally be set by the user to the same value as Gk, but
this is not done automatically. As Gk does not depend on Vm,
a VOLTAGE message is not strictly required if Ik not is
needed. However, the check command will issue a warning if
one has not been established.
Example:
create leakage K_leak
setfield K_leak Ek {EK} Gk {Gleak}
addmsg K_leak .. CHANNEL Gk Ek
addmsg .. K_leak VOLTAGE Vm
See also:
Object Type: metadata
Description:
File formats such as netcdf allow the inclusion of descriptive content in
addition to actual data. This is extremely useful from the perspective of
having important documentation, such as time of creation, author, purpose
or critical information about individual variables or the file as a whole,
alongside the actual data in the same file.
The genesis metadata object allows the user to manipulate this descriptive
data that is in an existing file or write new metadata content into it. As
already mentioned, descriptive data can describe individual variables in
the file (local metadata) or the file as a whole (global metadata). This
distinction is replicated well, through the hierarchical element structure
in genesis. So a metadata object will be identified as a local attribute if
the immediate parent is a 'variable' object and global if the 'diskio' object
is the immediate parent.
FMT1 files do not support the notion of metadata and hence arbitrary
creation of metadata objects in this case will not be allowed. For the sake
of consistency, however, when SAVE messages are sent to the diskio object,
automatically created metadata elements (auto3-DPosSAVE_diskio[]) store
relevant information for inspection. The fields are made readonly in the
case of FMT1.
Author: V.Jagadish (9/96)
------------------------------------------------------------------------------
ELEMENT PARAMETERS:
DataStructure: Gen_Metadata_Type [in src/diskio/diskio_struct.h]
Size: 92 bytes
Fields: datatype The type of the value(s) held in the metadata
- The list of valid types are given in the
notes section of this document.
- Defaults to 'char8' (8-bit char)
- readonly for FMT1 files.
size The maximum number of descriptive values the
object can hold.
- Like variables, metadata objects can hold
an array of descriptive values the size of
which is limited by the value of this field.
- If the datatype is 'char8' (default) the
user could provide a string as an argument
to the value field without
specifying a size or index, and the size
(which is the number of chars in the string
including the '/0' character) is
internally calculated and set in this field.
- The default value is 1.
- readonly for FMT1 files.
value The value(s) held by the metadata.
- Since metadata can hold an array of
values or a single one, an index (with
the genesis style indexing syntax) needs
to be specified while setting or showing
this field. The index defaults to 0 if
not specified, the exception to it being
the case that the datatype is 'char8'.
- Not specifying the index for a 'char8' type
metadata will translate to mean the entire
string and individual indices will mean the
character in that position.
- As in the case of the variable object,
multiple argument values can be specified
for this field (see examples) and the values
will be accessed starting with index 0.
- The default value is 0 for numerical
datatypes and ''(blank) for character types
- readonly for FMT1 files.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: Gen_Metadata [in src/diskio/gen_metadata.c]
Classes: output
Actions: CREATE PROCESS RESET SET SHOW ADDMSGIN
FLUSH:
UPDATE: the object commits the underlying metadata values
to the file on disk.
DELETE: commits any changes to disk if necessary and then
deletes the object but does not remove the
underlying attribute on file.
------------------------------------------------------------------------------
Notes:
The default metadata is an 8-bit single blank character (char8)
The datatype field stores the type of the variable as a string. The types
are chosen to be as generic as possible. They are not based on the usual
'C' data types but rather on the user's perspective.
Table 1.2 shows the valid datatype names and what they mean to the user.
Please note that not all these types are supported by all file formats.
An error to that effect will be printed if a metadata obeject of an
unsupported type is attempted to be created.
As opposed to variables, the size and datatype fields of metadata objects
can be reset within netcdf.
A smaller size setting than the original truncates values and a larger size
does not disturb the old values but adds the appropriate number of default
values (0 or '').
Changing the datatype for a metadata object defaults all the values
(as specified by the size field) to the new type. The old values will be lost.
Table 1.2 - Valid datatypes
Name Description
____ | ___________
|
|
uint8 | 8-bit unsigned int
|
int8 | 8-bit signed int
|
uint16 | 16-bit unsigned int
|
int16 | 16-bit signed int
|
uint32 | 32-bit unsigned int
|
int32 | 32-bit signed int
|
uint64 | 64-bit unsigned int
|
int64 | 64-bit signed int
|
float32 | 32-bit float
|
float64 | 64-bit float
|
uchar8 | 8-bit unsigned char
|
char8 | 8-bit signed char
|
char16 | 16-bit (unicode) char
|
string | string type (i.e not an array of chars)
|
________________+______________________________________________________
Examples:
create diskio /dout -filename "testfile.nc" -accessmode w
create metadata /dout/author -value "Venkat Jagadish"
showfield /dout/author value // This will print out the entire string
showfield /dout/author value[2] // This will print the 3rd char - 'n'
create variable /dout/Vmtrace -datatype float32
create metadata /dout/Vmtrace/starttimes -datatype float32 -size 3 \
-value "5 45 65"
create metadata /dout/Vmtrace/stoptimes -datatype float32 -size 3 \
-value "20 60 80"
setfield /dout/Vmtrace/starttimes value[1] 55
setfield /dout/Vmtrace/stoptimes value[1] 70
setfield /dout/Vmtrace/starttimes datatype float64
showfield /dout/Vmtrace/starttimes value[1] // Setting datatype resets
// values to default - 0
// (in this case)
_______________________________________________________________________
See also:
diskio ,
variable
Object Type: mmpump
Description: Implementation of a simple pump with Michaelis Menten kinetics,
to be coupled to a difshell.
Author: E. De Schutter BBF-UIA 9/94 - 3/99
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: mmpump_type [in src/concen/conc_struct.h]
Size: 108 bytes
Fields: Ik computed electrogenic effect (if val!=0)
vmax maximum pump velocity, scaled by mebrane
surface area. i.e., max ion flux in moles/sec.
val charge of ion
Kd half-maximal activating concentration in mM
mmconst mmconst=vmax*val*FARADAY (calculated on reset)
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: MMPump [in src/concen/mmpump.c]
Classes: gate segment
Actions: CHECK RESET PROCESS INIT
Messages: CONCEN C (use for electrogenic effect only)
MMKD Kd (changes Kd value)
------------------------------------------------------------------------------
Notes:
The mmpump and other ionic pumps provide various mechanisms to remove ions
from a concentration shell (difshell). The mmpump is a simple model
for the plasma membrane pump (PMCA) with Michaelis Menten kinetics.
For a general description of buffered calcium diffusion and ionic pumps, see:
De Schutter E., and Smolen P., "Calcium dynamics in large neuronal models", in
Methods in neuronal modeling: From ions to networks (2nd edition), C. Koch and
I. Segev editors, pp. 211-250 (1998). Sec. 6.3.2 and Eq. 6.10 describe the
Michaelis Menten pump, which may be used to model a Ca-ATPase pump. This is
also discussed in A. Zador, C. koch, and T. H. Brown, Proc. Natl. Acad. Sci.
(USA) 87: 6718-6722 (1990).
Note that this object does not compute anything by itself, unless the
electrogenic action is simulated by specifying a non-zero value of val. When
coupled to a difshell with a MMPUMP message that sends the vmax and Kd field
values, the difshell computes its change in ion concentration from dC/dt =
-vmax*(C/(Kd + C))/vol. This corresponds to De Schutter and Smolen Eq. 6.10,
if the maximum pump velocity vmax has previously been multiplied by the
membrane surface area, so that it is in moles/sec.
The current outflow across the membrane due to the electrogenic effect of the
pump can also be simulated by using a CONCEN message into the pump, and using
a non-zero value for the valence (e.g. val = 2, for Ca++ ions). In this case,
the mmpump calculates Ik = mmconst * C/(Kd + C), where the constant mmconst is
set to vmax * val * FARADAY on reset. Note that, in contrast to the GENESIS
channel objects, the Ik calculated by the mmpump has a positive sign for an
outward current, rather than obeying the usual GENESIS convention of "inward
positive".
Example: addmsg mmpump0 shell0 MMPUMP vmax Kd
See also:
difshell ,
taupump , Scripts/examples/spinedemo
Object Type: nernst
Description: Calculates the Nernst potential for the given
ionic concentrations and temperature.
Author: M. Wilson, Caltech (3/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: nernst_type [in src/device/dev_struct.h]
Size: 96 bytes
Fields: E equilibrium (Nernst) potential
T temperature in degrees Celsius
valency ionic valency z
scale voltage scale factor
Cin internal ionic concentration
Cout external ionic concentration
constant scale*(R/zF)*(T + 273.15)
This is set by the element,
and should not be set by the user.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: Nernst [in src/device/nernst.c]
Classes: device
channel
Actions: PROCESS sets the fields from incoming messages
and calculates constant and E.
RESET similar to a single PROCESS step.
CHECK checks for valid messages and parameters.
Messages: CIN Cin sets the Cin field.
COUT Cout sets the Cout field.
TEMP T sets the T field, and calculates constant.
------------------------------------------------------------------------------
Notes: A nernst element calculates E = constant * ln(Cout/Cin)
= scale*(R/zF)*(T + 273.15)*ln(Cout/Cin), where R is the
universal gas constant (1.9872 cal/mol deg) and F is Faraday's
constant (23061 cal/volt mol). Note that the temperature in
degrees Celsius is internally converted to degrees Kelvin. A
scale factor of 1 gives E in volts, and a scale factor of
1e3 gives E in millivolts.
A nernst element is usually used with a channel and a
Ca_concen element to calculate the channel equilibrium
potential (Ek) from the internal ionic concentration in a
shell near the compartment surface. The equilibrium potential
is sent from the nernst element to the channel with an EK
message, and the nernst element receives the concentration
from the Ca_concen element with a Cin message. The Ca_concen
element calculates this concentration from ionic currents
delivered with an I_k message.
It is also possible to perform a "one-time" calculation of E
with fixed values of the ionic concentrations by setting these
fields instead of setting up messages, and performing a reset.
If this is done, the nernst element should be disabled to
avoid wasting time performing the PROCESS action.
Example:
// assume that a tabchannel `Ca' has been set up
create Ca_concen conc
setfield conc \
B {5.2e-6/(area*shell_thick)} \
Ca_base 4.0e-5 \
tau 1e-4 \
thick {shell_thick}
create nernst nernst
setfield nernst \
Cout 4.0 \ // external Ca concentration of 4 mM.
T 21 \ // near room temperature
valency 2 \ // Ca++
scale 1 // E in volts
addmsg Ca conc I_Ca Ik
addmsg conc nernst CIN Ca
addmsg nernst Ca EK E
function reset_nernst // Insure that resets are done in proper order
call Ca RESET
call conc RESET // Ca_concen must be reset before nernst
reset // reset everything
end
See also:
Ca_concen
Object Type: neutral
Description: empty object used for grouping
Author: Caltech
ELEMENT PARAMETERS
DataStructure: element_type [in src/sim/sim_struct.h]
Size: 68 bytes
Fields: [none]
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: NULL [i.e., none]
Classes: element
Actions: [none]
Messages: [none]
------------------------------------------------------------------------------
Notes: A set of default element types is distributed with GENESIS.
One of the simplest is the "neutral" object which can be
used to create an empty element used for grouping, much like
a directory in the UNIX file system. It is often used to
represent a cell, containing subelements for compartments,
channels, etc. Although it has no other fields, it has the
usual setable [x,y,z] coordinate fields possesed by other
objects. This allows it to be given a position in a network.
The addfield, addaction, and addmsgdef commands can be used
to give a neutral element new fields, actions, and messages,
allowing it to be used as customizable element, or the basis
of an extended object
Example:
See also:
Object Type: paramtableBF
Description: This object implements a brute-force search as part of a
parameter search process, and also stores the parameter
tables and various bookkeeping information relating to the
parameter search process. It is mainly for use in
systematically mapping out the parameter space of a model.
Author: Mike Vanier, Caltech
-------------------------------------------------------------------------
ELEMENT PARAMETERS
Data structure: paramtableBF_type [in src/param/param_struct.h]
Size: 168 bytes (more when tables are loaded)
Fields:
iteration_number iteration number
num_params total number of parameters
num_params_to_search number of parameters to search over
search array of flags:
0 = don't search this parameter,
1 = do search this parameter
type type of parameter:
0 = additive,
1 = multiplicative
range of parameter values
min of parameter values
max of parameter values
label label of parameter,
for documentation purposes only
current array of parameter values
to be simulated next
current_match match value of current parameter set
being simulated
best array of parameter values
giving best match so far
best_match best match value
new_best_match flag: 1 if last match was the best so far
done flag: 1 when the simulation is finished
filename where parameter information is
stored/saved as a binary file
alloced flag: 1 means tables are allocated
orig array of original parameter values
search_divisions number of points on the range
to test
search_rangemod fraction of the full range to
search over
search_count where we are in the search for
each param
-------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ParamtableBF [in src/param/paramtableBF.c]
Classes: param
Actions: Note: required arguments to actions are in <angle brackets>;
optional arguments are in [square brackets].
CREATE Creates the object (not invoked directly).
TABCREATE <num_params>
Initializes the object for a given number of
parameters.
DELETE Deletes all allocated memory.
TABDELETE Same as DELETE.
INITSEARCH Initializes the search process.
Usage: ParamtableBF_INITSEARCH \
<param-number1> <npts1> <scale1> ... \
<param-numbern> <nptsn> <scalen>
This function expects its arguments to be in the
form of (<param_number> <npts> <scale>) triplets,
where <param_number> is the index of the parameter
to be varied, <npts> is the number of
equally-spaced points along the parameter axis to
test, and <scale> is the proportion of the total
range to use; 1.0 means use the entire range. Note
that the range is relative to a center point which
is where the parameter search starts from.
EVALUATE <match>
Copies the match value into the current_match field.
If this match is the best match so far, this action
copies the current parameter set into the best
parameter set and the current_match field into the
best_match field.
UPDATE_PARAMS
Chooses the next set of parameters to simulate.
This object systematically works its way through
parameter space, simulating all points on a
multidimensional grid whose features are specified
in the INITSEARCH action.
SAVE [filename]
Saves the object as a binary file. If no
argument given, use the "filename" field
of the element.
SAVEBEST <filename>
Saves the best parameter set to an ascii file.
RESTORE [filename]
Restores the object from a binary file. If no
argument given, use the "filename" field of the
element.
RESTOREBEST Restores the best parameter table from a text file.
DISPLAY Displays the best parameter set obtained so
far on stdout.
CHECK Runs a series of self-check diagnostics on this
object.
Messages: none
-------------------------------------------------------------------------
Notes: This object stores parameter tables and calculates new tables
to be simulated in a parameter search process using a
brute-force algorithm. The algorithm divides the parameter
space into a multidimensional grid where all points are
equidistant to their neighbors in each dimension. Then it
systematically walks through the space, calculating and
outputting a match value for each point.
This algorithm is effectively useless for searching parameter
space per se because of the combinatorial explosion that occurs
when you have more than a few parameters (e.g. 3 or 4).
However, it can be used effectively to map out parameter space
very coarsely for a small number of parameters. For instance,
you could keep all but two parameters fixed and map out the
two-dimensional parameter space that consists of varying values
for each of the two parameters. This may give some insight
into various aspects of a model. Alternatively, you could map
out all the parameters at a very coarse scale, which can be
used (for instance) to give a reasonable starting point for
other algorithms. In practice, this is still not feasible for
more than 5 or 6 parameters.
Example: See Scripts/param/BF for demo scripts.
See also: Parameter Search (
Param ),
Paramtable ,
setsearch ,
initparamBF ,
paramtableCG ,
paramtableGA ,
paramtableSA ,
paramtableSS
Object Type: paramtableCG
Description: This object implements a conjugate gradient descent
algorithm as part of a parameter search process, and also
stores the parameter tables and various bookkeeping
information relating to the parameter search process.
Author: Mike Vanier, Caltech
-------------------------------------------------------------------------
ELEMENT PARAMETERS
Data structure: paramtableCG_type [in src/param/param_struct.h]
Size: 308 bytes (more when tables are loaded)
Fields: iteration_number iteration number
num_params total number of parameters
num_params_to_search number of parameters to search over
search array of flags:
0 = don't search this parameter,
1 = do search this parameter
type type of parameter:
0 = additive,
1 = multiplicative
center of parameter values in range
range of parameter values
min of parameter values
max of parameter values
label label of parameter,
for documentation purposes only
current array of parameter values
to be simulated next
current_match match value of current parameter set
being simulated
best array of parameter values
giving best match so far
best_match best match value
new_best_match flag: 1 if last match was the best so far
done flag: 1 when the simulation is finished
filename where parameter information is
stored/saved as a binary file
alloced flag: 1 means tables are allocated
linemin_number which line minimization we're doing;
for bookkeeping only
state state of parameter search:
0 = random searches at startup
1 = gradient calculation
2 = line minimization
deriv_method 0 = do a proper derivative;
1 = quick-and-dirty estimate
(not yet implemented)
deriv_index index of parameter we're taking
the derivative of
deriv_h_init initial values of h (the spatial step
size) to use in derivative
calculations
deriv_h_decrease how fast to decrease h
deriv_h_min lowest permissible value of h
deriv array of 1st partial derivatives:
d(match)/d(param)
dir direction vector
tolerance tolerance of parameter search as a whole
linemin_tolerance tolerance of line minimization
routines
-------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ParamtableCG [in src/param/paramtableCG.c]
Classes: param
Actions: Note: required arguments to actions are in <angle brackets>;
optional arguments are in [square brackets].
CREATE Creates the object (not invoked directly).
TABCREATE <num_params>
Initializes the object for a given number of
parameters.
DELETE Deletes all allocated memory.
TABDELETE Same as DELETE.
INITSEARCH Initializes the search process.
RANDOMIZE Picks a random parameter set from the parameter
space as a potential starting point for the search.
EVALUATE <match>
Copies the match value into the current_match field.
If this match is the best match so far, this action
copies the current parameter set into the best
parameter set and the current_match field into the
best_match field.
UPDATE_PARAMS
Chooses the next set of parameters to
simulate based on past results.
UPDATE_PARAMS2
Increments iteration_number. Only used in
random searches at the beginning of a CG
parameter search.
LOADBEST Copies best parameter values to current values;
can be used to start the search at the best values
found so far.
RESTART Re-initializes parameter search at the
best point found so far.
SAVE [filename]
Saves the object as a binary file. If no
argument given, use the "filename" field
of the element.
SAVEBEST <filename>
Saves the best parameter set to an ascii file.
RESTORE [filename]
Restores the object from a binary file. If no
argument given, use the "filename" field of the
element.
RESTOREBEST Restores the best parameter table from a text file.
DISPLAY Displays the best parameter set obtained so
far on stdout.
CHECK Runs a series of self-check diagnostics on this
object.
Messages: none
-------------------------------------------------------------------------
Notes: This object stores parameter tables and calculates new tables
to be simulated in a parameter search process using a
conjugate gradient-descent algorithm. Here is a brief
description of the algorithm:
The conjugate-gradient (CG) method is a type of gradient
descent algorithm. In this method the gradient of the match
function at a given point in parameter space and the direction
of steepest descent with respect to this function are computed.
A line minimization in the direction of steepest descent is
done to find the point on the line with the best match value.
A new gradient is calculated at this point and the procedure is
iterated until the method converges to a local minimum of the
matching function. Successive line minimizations are done in
directions which are "conjugate" to one another so that
successive minimizations are as nearly independent of each
other as possible. In theory this will guarantee that the
parameter search will find a local minimum of the objective
function.
The termination criteria used by the algorithm is that either
(a) the gradient must be very close to zero, or (b) successive
line minimizations must produce nearly identical results. Note
that this can happen fairly early in the search, resulting in
rapid convergence to a local minimum which is nowhere near the
global minimum. Welcome to gradient-descent algorithms :-) One
way around this is to simply rerun the search from random
starting points again and again until you find better matches.
A better alternative is to use the simulated annealing (SA)
method instead of this one, which also incorporates a
(modified) gradient descent algorithm so that you get the best
of both worlds (i.e. ability to escape from local minima
characteristic of SA methods, and convergence to local minima
characteristic of gradient descent algorithms).
The fields deriv_h_init, deriv_h_decrease, deriv_h_min do not
have to be set explicitly; they are set to "reasonable" values
by default. deriv_h_init is actually an array of values, one
per parameter. The (hidden) field h represents the spatial
step size used in the derivative calculation. You can find
more information about this in the source code; don't mess with
it unless you know what you're doing or your results will
probably be worse.
The code for this routine was adapted from the conjugate
gradient code in Numerical Recipes in C, 2nd Ed., by Press
et. al. (chapter 10). The actual code is substantially
different but the algorithm is essentially the same.
Example: See Scripts/param/CG for demo scripts.
See also: Parameter Search (
Param ),
Paramtable ,
setsearch ,
initparamCG ,
paramtableGA ,
paramtableSA ,
paramtableSS
Object Type: paramtableGA
Description: This object implements a simple genetic algorithm as part
of a parameter search process, and also stores the
parameter tables and various bookkeeping information
relating to the parameter search process.
Author: Mike Vanier, Caltech
-------------------------------------------------------------------------
ELEMENT PARAMETERS
Data structure: paramtableGA_type [in src/param/param_struct.h]
Size: 272 bytes (more when tables are loaded)
Fields: generation generation number
num_tables number of parameter tables
num_params number of parameters per table
num_params_to_search number of parameters to search over
search array of flags:
0 = don't search this parameter,
1 = do search this parameter
type type of parameter:
0 = additive,
1 = multiplicative
center of parameter values in range
range of parameter values
label label of parameter,
for documentation purposes only
best array of parameter values
giving best match (fitness) so far
best_match best match (fitness) value
filename where parameter information is
stored/saved as a binary file
alloced flag: 1 means tables are allocated
param_size size of parameters in bytes:
1, 2, 4 are the only choices
param two-dimensional parameter array
fitness array of fitness values for
parameter sets
min_fitness minimum fitness value
max_fitness maximum fitness value
avg_fitness average fitness value
stdev_fitness standard deviation of fitness values
min_fitness_index index of minimum fitness in fitness
array
max_fitness_index index of maximum fitness in fitness
array
normfitness array of normalized fitness values
cumulfitness array of cumulative normalized
fitness values
preserve number of best matches to
retain unchanged
crossover_type type of crossover algorithm:
0 = choose exactly <crossover_number>
crossover points for all
parameter sets that are being
crossed over
1 = choose an average of
<crossover_number> crossover points
for all parameter sets that are
being crossed over
crossover_probability probability of crossover
crossover_number number of crossovers per parameter
string
crossover_break_param flag: if 0, crossovers can't
occur inside parameter values.
mutation_probability probability of mutation per bit
use_gray_code flag: if nonzero, use Gray code
for encoding numbers (see below).
do_restart flag for whether to restart ever
restart_after restart after this many
unproductive generations
restart_count count of unproductive generations
old_fitness old fitness value, that we have
to do better than
restart_thresh need to get this much above
old_fitness to not restart
-------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ParamtableGA [in src/param/paramtableGA.c]
Classes: param
Actions: Note: required arguments to actions are in <angle brackets>;
optional arguments are in [square brackets].
CREATE Creates the object (not invoked directly).
TABCREATE <num_tables> <num_params>
Initializes the object for a given number of
parameter tables and a given number of
parameters.
DELETE Deletes all allocated memory.
TABDELETE Same as DELETE.
INITSEARCH [random]
Initializes the search process. If "random" is
given as the argument then the first parameter
set is the original parameter set and all other
sets are chosen randomly within the given
ranges; if "random" is not given as the
argument then *all* parameter sets are chosen
randomly.
RANDOMIZE Randomizes parameters in tables. Not
normally called directly.
UPDATE_PARAMS Chooses the next set of parameters to
simulate based on past results.
Calls the REPRODUCE, CROSSOVER, and MUTATE
actions.
REPRODUCE Performs fitness-proportional reproduction.
Not normally invoked directly.
CROSSOVER Performs crossing-over between parameter sets.
Not normally invoked directly.
MUTATE Mutates each bit of the parameter sets with
a fixed (low) probability. Not normally
invoked directly.
FITSTATS Calculates statistics on the fitnesses of
the parameter sets currently stored in the
tables.
RECENTER Moves the center points of the parameter
ranges to correspond to the best parameter
set obtained so far.
RESTART Re-seeds the all the parameter tables with
random values in the allowed range, except
for the protected tables (see below).
SAVE [filename]
Saves the object as a binary file. If no
argument given, use the "filename" field
of the element.
SAVEBEST <filename>
Saves the best parameter set to an ascii file.
RESTORE [filename]
Restores the object from a binary file. If no
argument given, use the "filename" field of the
element.
RESTOREBEST Restores a parameter set from a text file,
normally the best set so far obtained. You
can use INITSEARCH without the "random"
option to keep this set and randomize the rest
of the table.
CHECK Runs a series of self-check diagnostics on this
object.
Messages: none
-------------------------------------------------------------------------
Notes: This object stores parameter tables and calculates new tables
to be simulated in a parameter search process using a
simple genetic algorithm. Here is a short description of the
algorithm:
The genetic algorithm (GA) method treats each parameter set as
an individual in a large breeding population. A new generation
of the population is derived from the preceding generation by
reproduction, crossing-over and mutation. This is accomplished
by discretizing the parameter values into bit strings and
crossing-over and mutating the different bit strings. A
population of parameter sets is selected randomly from the
parameter space and the fitness of each one is evaluated.
Fitness values, unlike the match values calculated by functions
like `spkcmp', are increasing for better and better models; a
perfect parameter set would have infinite fitness. Typically,
you take the inverse (or some power of the inverse) of the
value returned by `spkcmp' or `shape_match' to get the fitness
value.
Once fitnesses are calculated, the next generation is
determined by reproducing the current generation, with each
parameter set being chosen for reproduction in proportion to
its fitness (fitness-proportional reproduction). Then a fixed
percentage of the resulting parameter sets are crossed over by
choosing pairs of parameter sets at random, choosing one or
more breakpoints within the bit string and exchanging the bit
strings above the breakpoint (single-point recombination).
Finally, each parameter set is subjected to mutation with a low
probability per bit. In this way, highly fit parameter sets
are selected for and less fit sets are eliminated from the
population over a series of generations. Furthermore, the
processes of crossing-over and recombination can generate new
parameter combinations whose fitness is greater than that of
its predecessors.
Parameters can be stored as bit strings in one of two ways. In
the first way, the parameter range can be divided up into even
increments and the position of the parameter within that range
can be encoded by converting its relative position from a
floating-point number into an integer, where 0 represents one
end of the parameter range and the maximum possible integer
(which depends on the param_size field) represents the other
end. Successive binary numbers represent successively higher
parameter values. This is specified by setting the
"use_gray_code" field to 0. If "use_gray_code" is 1, then the
binary encoding is a Gray code encoding in which successive
values are guaranteed to differ by one bit exactly. This turns
out to be mildly advantageous for genetic algorithms, so
"use_gray_code" is set to 1 by default. If you don't
understand any of this, don't worry; just use the defaults and
you'll be fine.
By default, a crossover in a bit string can occur anywhere,
even inside the bit string that represents a single parameter.
Note that a crossover occurring inside a parameter is
effectively mutating that parameter too. If you don't want
this, set the field "crossover_break_param" to 0. This is the
default as well. In practice, this makes very little
difference.
There are two different kinds of crossover algorithms that can
be used, which are determined by the field "crossover_type".
In one case (crossover_type = 0), the field "crossover_number"
represents the exact number of crossovers for each pair of
parameter sets that is crossed over. Thus, if crossover_number
is 1, you have single-point crossovers; if crossover_number is
2, you have two-point crossovers, etc. In the other case
(crossover_type = 1) the crossover_number field represents the
*average* number of crossovers per pair of parameter sets. In
this case, there is a low probability for a crossover for each
possible crossover location between a pair of parameter sets.
This leads to a roughly Poisson distribution of crossovers for
the parameter sets chosen. The advantage of this is that you
can get single, double, triple etc. crossovers within the same
population, which can be useful in selecting for highly fit
parameter sets. The disadvantage is that some parameter sets
which are meant to be crossed over will not be. I suspect that
having crossover_type set to 1 is advantageous, although I have
no hard data to back me up. It is the default.
Note that the "mutation_probability" field is calculated per
bit, not per parameter. For each bit of each parameter table,
a separate random number is generated to determine whether to
mutate that bit.
A non-standard (but not original) feature of the genetic
algorithm implemented here is the ability to preserve the best
tables unchanged from generation to generation. This is very
useful (in fact, I consider it essential) because GA parameter
searches in genesis often use fairly small populations. This
means that genetic drift can easily cause the best parameter
sets to be crossed-over and/or mutated out of existence. To
prevent this, the field "preserve" sets the number of best
parameter tables to retain unchanged (unmutated,
uncrossed-over) between generations. For instance, if preserve
is 5, the 5 best parameter tables will be copied unchanged from
one generation to the next. These tables can also participate
in crossing-over and mutations, but you are guaranteed that one
unaltered copy of each of the tables will be present in the
next generation. The default value of preserve is 1 (preserve
only the best table); I recommend you leave it at that.
Another non-standard feature of the genetic algorithm
implemented here is that if no real progress has been achieved
after a large number of generations, then the parameter tables
can be reseeded (i.e. replaced with random values from the
allowable parameter ranges for all parameters). This is called
"restarting", which is a bit of a misnomer since the best
parameter tables are not altered. This is controlled by the
"do_restart" field, which is 1 if restarts are enabled and 0 if
not (1 is the default). If restarts are enabled, then the
object keeps track of the best fitness value and the generation
that it was first achieved at. If, after a certain number of
generations (set by the field "restart_after" which defaults to
25), the best fitness has not improved substantially (set by
the field "restart_thresh" which defaults to 1.0), then all the
parameter tables will be replaced by random values except for
the best table(s) (set by the preserve field as described
above) which are preserved unaltered. This can be useful if
you get into a suboptimal region of parameter space which is
difficult to get out of by crossing over and mutating, for
whatever reason.
If you are running genesis on a 64-bit machine (e.g. DEC
alpha), then you may have to change the definitions of
Param_short, Param_medium, and/or Param_long in
src/param/param_struct.h. All of these should be unsigned
integer types. Param_short should be one byte long,
Param_medium should be two bytes long, and Param_long should be
four bytes long.
Note that this object only instantiates one kind of genetic
algorithm. There are as many variations of the genetic
algorithm concept as there are people working on them. Feel
free to come up with your own variants and tell us all about
them :-)
Finally, if all the above has left you hopelessly confused,
don't worry; just use the default values for all the fields and
use the GA demo as a template, and you should do fine. The
options are mainly for experts and/or hackers to play with.
Example: See Scripts/param/GA for demo scripts.
See also: Parameter Search (
Param ),
Paramtable ,
setsearch ,
initparamGA ,
getparamGA ,
setparamGA ,
paramtableBF ,
paramtableCG ,
paramtableSA ,
paramtableSS
Object Type: paramtableSA
Description: This object implements a continuous version of simulated
annealing as part of a parameter search process, and also
stores the parameter tables and various bookkeeping
information relating to the parameter search process.
Author: Mike Vanier, Caltech
-------------------------------------------------------------------------
ELEMENT PARAMETERS
Data structure: paramtableSA_type [in src/param/param_struct.h]
Size: 276 bytes (more when tables are loaded)
Fields: iteration_number iteration number
num_params total number of parameters
num_params_to_search number of parameters to search over
search array of flags:
0 = don't search this parameter,
1 = do search this parameter
type type of parameter:
0 = additive,
1 = multiplicative
center of parameter values in range
range of parameter values
min of parameter values
max of parameter values
label label of parameter,
for documentation purposes only
current array of parameter values
to be simulated next
current_match match value of current parameter set
being simulated
best array of parameter values
giving best match so far
best_match best match value
new_best_match flag: 1 if last match was the best so far
done flag: 1 when the simulation is finished
filename where parameter information is
stored/saved as a binary file
alloced flag: 1 means tables are allocated
iterations_per_temp number of iterations per temperature level
temperature of annealing process
inittemp initial temperature of annealing process
annealing_method 0 = manual,
1 = linear decay,
2 = exponential decay
max_iterations maximum number of iterations;
for linear decay only
annealing_rate how fast the temperature drops;
for proportional decay only
testtemp test for whether simulation is finished
when temperature is below this value
tolerance if matches are within this distance
of each other we're done
stop_after if best match hasn't changed after
this many iterations then stop
restart_every call RESTART action every x iterations
state of search process (0-5)
simplex_init_noise proportion of initial noise in
simplex; a number in (0,1); default = 0
simplex points on the simplex:
(num_params + 1) x (num_params)
simplex_match match values for each point in the simplex
scale "typical" length scale of starting points
scalemod modifiers of length scales in
(num_params) dimensions; default: all = 1
-------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ParamtableSA [in src/param/paramtableSA.c]
Classes: param
Actions: Note: required arguments to actions are in <angle brackets>;
optional arguments are in [square brackets].
CREATE Creates the object (not invoked directly).
TABCREATE <num_params>
Initializes the object for a given number of
parameters.
DELETE Deletes all allocated memory.
TABDELETE Same as DELETE.
INITSEARCH [random]
Initializes the search process; sets up initial
simplex values (see below); if "random" is given as
the argument then the simplex is populated by
random points in the parameter space; otherwise one
point on the simplex represents the original model.
EVALUATE <match>
Copies the match value into the current_match field.
If this match is the best match so far, this action
copies the current parameter set into the best
parameter set and the current_match field into the
best_match field.
UPDATE_PARAMS
Chooses the next set of parameters to
simulate based on past results.
RECENTER Moves the center points of the parameter
ranges to correspond to the best parameter
set obtained so far.
RESTART Replaces the worst point on simplex with the
point corresponding to the best match.
RESTART2 Like INITSEARCH, but preserves the best
match obtained so far.
SAVE [filename]
Saves the object as a binary file. If no
argument given, use the "filename" field
of the element.
SAVEBEST <filename>
Save the best parameter set to an ascii file.
RESTORE [filename]
Restores the object from a binary file. If no
argument given, use the "filename" field of the
element.
DISPLAY Displays the best parameter set obtained so
far on stdout.
DISPLAY2 Same as DISPLAY, but also prints the current
parameters.
CHECK Runs a series of self-check diagnostics on this
object.
Messages: none
-------------------------------------------------------------------------
Notes: This object stores parameter tables and calculates new tables
to be simulated in a parameter search process using a
continuous-space simulated annealing algorithm. The algorithm
is taken from Press et. al., Numerical Recipes in C,
2nd. edition, chapter 10, pp. 451-455. This algorithm is much
too complex to describe in detail here, but here is the
two-second summary:
The algorithm constructs a geometrical object called a simplex.
If there are N parameters, the simplex has N+1 points
(vertices) and conceptually occupies a volume in parameter
space. For instance, a triangle is a 3-simplex in 2 dimensions
and a tetrahedron is a 4-simplex in three dimensions.
Confused? There's more :-) Each vertex of the simplex
corresponds to a particular parameter set in parameter space.
Each vertex's corresponding parameter set is simulated and its
match value is calculated. Depending on the state of the
algorithm, several different things can happen, but typically
the worst point is discarded and a new point is selected. By
itself, this describes a gradient-descent algorithm; the
simulated annealing process comes in by adding noise to the
match values based on a temperature parameter (the higher the
temperature, the more noise). At high temperatures, the
simplex performs essentially a random walk in parameter space,
but as the temperature lowers, the simplex spends more and more
time exploring areas of the space which correspond to good
match values. As the temperature drops to zero, the simplex
will perform a gradient descent in the parameter space and find
a local minimum (which is hopefully close to the global minimum
as well).
Example: See Scripts/param/SA for demo scripts.
See also: Parameter Search (
Param ),
Paramtable ,
setsearch ,
initparamSA ,
paramtableBF ,
paramtableCG ,
paramtableGA ,
paramtableSS
Object Type: paramtableSS
Description: This object implements a stochastic-search (SS)
algorithm as part of a parameter search process, and also
stores the parameter tables and various bookkeeping
information relating to the parameter search process.
Author: Mike Vanier, Caltech
-------------------------------------------------------------------------
ELEMENT PARAMETERS
Data structure: paramtableSS_type [in src/param/param_struct.h]
Size: 184 bytes (more when tables are loaded)
Fields: iteration_number iteration number
num_params total number of parameters
search array of flags:
0 = don't search this parameter,
1 = do search this parameter
type type of parameter:
0 = additive,
1 = multiplicative
range of parameter values
min of parameter values
max of parameter values
label label of parameter,
for documentation purposes only
current array of parameter values
to be simulated next
best array of parameter values
giving best match so far
best_match best match value
filename where parameter information is
stored/saved as a binary file
alloced flag: 1 means tables are allocated
round_number number of expansion-contraction cycles
we have completed
variance current variance of gaussian
distribution
minvariance minimum variance of algorithm
maxvariance maximum variance of algorithm
addvarscale scaling factor for variances of
additive parameters
multvarscale scaling factor for variances of
multiplicative parameters
contract rate of variance contraction
-------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ParamtableSS [in src/param/paramtableSS.c]
Classes: param
Actions: Note: required arguments to actions are in <angle brackets>;
optional arguments are in [square brackets].
CREATE Creates the object (not invoked directly).
TABCREATE <num_params>
Initializes the object for a given number of
parameters.
DELETE Deletes all allocated memory.
TABDELETE Same as DELETE.
INITSEARCH Initializes the search process. Note that
TABCREATE must be called before calling this
action. Also, the maxvariance field must
be set before calling this action. This action
will start the search off at the parameters set
by the initparamSS function.
RANDOMIZE Randomizes parameters in tables; uses a uniform
distribution from (best - range, best + range).
Can be used after INITSEARCH to pick a random
point in the parameter space to start with.
UPDATE_PARAMS
Chooses the next set of parameters to
simulate based on past results.
ACCEPT <match>
Copies the match value to the best_match field
and the current parameters to the best fields.
RECENTER Recalculates the min and max values based on
the best and range values. You might try doing
this after a best match is found to allow you
to search through a larger search space than
the initial limits would allow.
SAVE [filename]
Saves the object as a binary file. If no
argument given, use the "filename" field
of the element.
SAVEBEST <filename>
Saves the best parameter set to an ascii file.
RESTORE [filename]
Restores the object from a binary file. If no
argument given, use the "filename" field of the
element.
DISPLAY Displays the best parameter set obtained so
far on stdout.
CHECK Runs a series of self-check diagnostics on this
object.
Messages: none
-------------------------------------------------------------------------
Notes: This object stores parameter tables and calculates new tables
to be simulated in a parameter search process using a
stochastic-search algorithm. Here is a brief description of
this algorithm:
A random starting point in parameter space is chosen. New
points are selected from a multidimensional Gaussian
distribution centered on the starting point with a given
(initially large) variance. These new points are evaluated,
and if one is found that is a better match than the previous
best match, the Gaussian distribution is moved so that it is
centered on the new (best) point. In addition, the variance of
the distribution decreases each iteration until it reaches some
minimum value, at which time it is increased to the original
value. This constitutes one "round", and successive
expansion-contraction rounds are performed for as long as the
modeler wants. In principle, choosing points from a
distribution with a large variance will allow the modeler to
search over large regions of parameter space, while choosing
points from a distribution with a much smaller variance will
allow the modeler to find locally optimal points in small
regions of parameter space.
In general, this algorithm performs more poorly than the
simulated annealing and the genetic algorithm methods. It was
included mostly for comparison purposes, since some
investigators have used this method for parameterizing neural
models. Nevertheless, we recommend that you skip this method
entirely and instead use the GA or SA methods.
You can modify the variance separately for additive and
multiplicative parameters using the addvarscale and
multvarscale fields. This can be useful since the scales of
additive and multiplicative parameters can be very different
(e.g. of order 1.0 for Gbar scaling (multiplicative) and of
order 0.001 (1 mV) for minf offsets (additive)). Ideally you'd
like to be able to modify the variance on a per-parameter basis
(like the scalemod fields in paramtableSA) but we haven't
gotten around to that yet.
Example: See Scripts/param/SS for demo scripts.
See also: Parameter Search (
Param ),
Paramtable ,
setsearch ,
initparamSS ,
paramtableBF ,
paramtableCG ,
paramtableGA ,
paramtableSA
Object Type: peristim
Description: Generates a peristimulus spike histogram.
Author: E. De Schutter Caltech 8/91; embellished by D. Jaeger 8/92
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: new_peristim_type [in src/device/dev_struct.h]
Size: 112 bytes
Fields: output gives the most recent peristimulus value
threshold voltage threshold for determining when a spike
occurs
binwidth time interval between bins
num_bins number of table entries (bins)
trigger_mode 0 (free run) or 1 (triggered)
reset_mode if 1 then bins will be emptied upon RESET
table contains num_bins entries of histogram values
bin_index index into the table, giving current bin
(not set by user)
bin_steps time steps since the start of the current bin
(not set by user)
spiking flag indicating spike in progress
(not set by user)
allocated flag indicating table has been allocated
(not set by user)
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: NewPeriStimulusDistribution [in src/device/new_peristim.c]
Classes: device
Actions: CHECK PROCESS RESET
Messages: INVM voltage (Records a spike event when voltage first
exceeds threshold. The voltage must then
fall below threshold before another spike
event can be recorded.)
TRIGGER state (Starts recording spikes starting with the
first bin, when state is non-zero.)
READTIME time (Adds a spike event to the table in the
bin appropriate for the value of time.
This could be used with a timetable,
table, or asc_file element to retrieve
spike times from a table or a file.)
INSPIKE state (Records a spike event whenever state
exceeds threshold. This message would be
sent by an element, such as a spikegen,
that represents a spike by a state that
lasts for a single time step.)
------------------------------------------------------------------------------
Notes: In the example below, there are 1000 bins to process 1 second
of spike events, using a 1 msec bin width. The typical use
would be to run the simulation, and send a trigger event to
the peristim element at 1 second intervals. This would
normally coincide with the application of some stimulus to the
cell.
Each time the triggering device generates a triggering event
and stimulates the cell, the resulting action potentials will
be counted and placed in bins according to the time that they
occurred since the trigger event. At the end of the run, the
histogram results can be retrieved with commands such as
"getfield /peristim table[{i}]", with i taking on values from
0 through nbins-1.
If trigger_mode is set to zero (free run mode), then spike
data is gathered continously, looping through all the bins and
then starting again in the first bin. Otherwise, data after
the last bin is ignored until a TRIGGER message is received.
When a non-zero TRIGGER message is received, subseqent spike
events are binned starting with the the first bin, table[0].
This is true regardless of the value of trigger_mode.
Normally the source of the TRIGGER message is an element, such
as a spikegen, that sends the value of a state field that
lasts for a single time step.
Example:
float binwidth = 0.001; int nbins = 1000
create peristim /peristim
setfield /peristim threshold 0 num_bins {nbins} binwidth {binwidth}
setfield /peristim trigger_mode 1
// Assume that /trigger_device generates spike events in its state field
addmsg /trigger_device /peristim TRIGGER state
// Assume a cell, generating action potentials in the soma compartment
addmsg /cell/soma /peristim INVM Vm
See also:
interspike
Object Type: playback
Description: update a pre-filled buffer
Author: M. Wilson, Caltech (6/88)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: playback_type [in src/buffer/buf_struct.h]
Size: 100 bytes
Fields:
tmin
size
current
start
end
event_size
event
state
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PlaybackBuffer [in src/buffer/playback.c]
Classes: buffer
Actions: PROCESS
RESET
COPY BufferCopy
CREATE BufferCreate
Messages: none
------------------------------------------------------------------------------
Notes: The putevent command may be used to fill the buffer
Example:
create playback /test
putevent /test 10 10.0 20 0.0 30 30.0 40 0.0 50 50.0 60 0.0
create xform /testform
create xgraph /testform/graph
addmsg /test /testform/graph PLOT state *playback *blue
xshow /testform
reset
step 100
See also:
putevent
Object Type: pool
Description: Pool of molecules involved in chemical reactions and
transport between cellular compartments. Keeps track of the
number of molecules resulting from forward and backward
reactions. Uses mean-rate theory which assumes large numbers
of molecules, not probabilities of transitions of individual
molecules.
Does Michaelis-Menten enzyme kinetics when hooked to the 'enz'
object, and standard kinetic reactions with the 'reac' object.
The MM scheme is modeled as:
k1 k3
Substrate + Enzyme <-----> EnzComplex ----> Enz + Prd
k2
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Note that vol, n and Co are interdependent. vol is never
changed except by the user or by messages. n changes if Co is
changed. Co changes if either vol or n is changed. Volume is
typically scaled by the Avogadro number, so that Co is in
convenient units such as micromolar.
During integration, all calculations are done in terms of
n, and, where needed, vol. Co is calculated as n / vol on
each timestep.
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1993).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pool_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: Co Concentration of molecule. Calculated
from 'n' as n/vol.
CoInit Initial concentration of molecule.
Co gets set to this value on RESET.
CoTotal Total concentration of molecule. Used
when applying conservation rules.
CoRemaining CoTotal - Co.
n Number of molecules. This is the
value used for all calcultions.
nInit Initial number of molecules.
'n 'gets set to this value on RESET.
nTotal Total number of molecules. Used
when applying conservation rules.
nRemaining nTotal - n
nMin Minimum allowed number of molecules.
Normally zero.
vol Volume occupied by pool. Often involves
extra units so as to have direct
conversion from 'n' to some sensible
units of Co, such as micromolar.
slave_enable Flag used to control buffering and
other overrides. Values:
1 - Obey slave message, representing n
2 - Obey slave message, representing Co
4 - Buffering on: n is set to nInit,
Co to CoInit, every timestep.
See below for details.
keepconc Flag determining whether to change
concs or n when volume changes
consv_flag Internal flag keeping track of presence
of CONSERVE and SUMTOTAL msgs
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PoolFunc [in src/kinetics/pool.c]
Classes: segment, concentration
Actions: CREATE
PROCESS
RESET
SET
Messages: REAC A B [A is increment to n,
B is decrement to n,
where n is number of molecules in pool.
This message is used for hooking up
all reactions and enzymes.]
MM_PRD A [increment n by A. This message is
used for the product of enzymes.
We assume it is irreversible, so there
is no B term]
SLAVE number [Sets n or Co to this command number
depending on the slave_enable status,
described below. This message is
used to make concentrations in the pool
follow an external signal.]
REMAINING n [decrement to nRemaining]
CONSERVE n nInit [This message is used for setting up
conservation relationships.
n from all derived molecules is summed
to do the conservation. nInit is used
during RESET to calculate the total
number of molecules. See notes.]
VOL vol [volume of pool]
SUMTOTAL n nInit [This message is used to make a pool
whose n is the sum of that of several
other pools. nInit is used at
RESET to get the initial levels]
------------------------------------------------------------------------------
Notes:
The pool has numerous extras used in practical simulations.
Most of these are readily accessed from within kinetikit, which is
the recommended way of developing kinetic simulations. For
completeness, here is a list of features of the pool:
1. Buffering. When slave_enable is set to 4, then all the pool
does is assign n to nInit and Co to CoInit every timestep.
2. Following an external signal. This works when the SLAVE
message is passing in the external number. if slave_enable is
1 then the external number represents n. If it is 2 the
external number represents Co.
3. Conservation relationships. In some cases it helps stability
and accuracy to apply explicit conservation relationships,
rather than rely on the implicit ones that arise from the
numerical integrations. Warning: in some cases explicit
conservation relationships actually worsen stability ! So
try it for each case before relying on it. Conservation
relationships are set up in two phases:
- identify the pool whose value you want to be calculated
from conservation.
- Send CONSERVE messages from all pools to which this molecule
gets converted. Be sure you have found ALL the pools: this is
a very common source of error. For example, you may need to
send a CONSERVE message from enzyme intermediates, which
are represented by 'enz' objects.
4. Summation. In some cases the final amount of an active
species recieves contributions from several independent pathways.
An example is an enzyme whose active site always has the same
activity regardless of the means of activation. The total amount
of the active enzyme could then be represented as the sum of
the active forms from several independent activation pathways.
The SUMTOTAL message is used for such cases.
5. Calculating the amount of the molecule that has reacted, and is
no longer in this pool.
The nRemaining field plus the REMAINING message are used for this.
Again, the REMAINING message must come in from all other molecules
into which this pool may convert. This is mainly useful for checking
accuracy and stability.
The combination of pools, reacs, and tables is capable in principle of
implementing very complicated ODEs, not restricted to
chemical reactions. The pools represent the variables, reacs represent
processes increasing and decreasing variables, and the tables can
twiddle the rate constants of the reacs according to arbitrary
complicated functions. It should be stressed that this is an
extremely inefficient but reasonably general way of doing this.
Example:
Message setup between pools, reacs and enzymes:
For the reaction
kf
2X + Y <======> Z
kb
we would have 3 pools, and 1 reac. The messaging would be as follows:
addmsg X reac SUBSTRATE n
addmsg X reac SUBSTRATE n
addmsg reac X REAC A B
addmsg reac X REAC A B
addmsg Y reac SUBSTRATE n
addmsg reac Y REAC A B
addmsg Z reac SUBSTRATE n
addmsg reac Z REAC B A
Some points about this messaging scheme:
1. We need N sets of SUBSTRATE and REAC messages between a pool and
a reac, where the order of the reaction for that pool is N.
2. The Z pool, which is the product, has the A and B state variables
reversed in the message. This is because any decrease in X or Y is an
_increase_ in Z.
Setting up the enzymatic reaction:
Sub + X --> Prd
We normally put the enzyme site enz as a child of the pool which
represents the enzyme.
create enz X/enz
A given pool can have any number of enzyme
'sites'. This is required when an enzyme has different levels
of activity for different substrates, as each of the enzyme 'sites'
can then be given different rates. The messaging would look like this:
addmsg X X/enz ENZYME n
addmsg X/enz X REAC eA B
addmsg sub X/enz SUBSTRATE n
addmsg X/enz sub REAC sA B
addmsg X/enz prd MM_PRD pA
Some points about this messaging scheme:
1. In the irreversible Michaelis-Menten model we are using, the
enzyme cannot reduce the level of the product. So there is only one
term required in the outgoing message, and no incoming message from
the product to the enzyem
2. If this scheme doesn't suit you, you can always build better
enzyme models using combinations of reacs and intermediate pools.
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates
and products, though reactions of order greater than 2 are
rare. Any number of reacs can be hooked up to a given pool.
The generic reaction scheme is:
kf
Substrate1 + S2 + .. <----> Prd1 + Prd2 + ...
kb
Author: U. S. Bhalla, National Centre for Biological Sciences,
Bangalore, India. (1996).
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: reac_type [in src/kinetics/kin_struct.h]
Size: bytes
Fields: kf Forward rate constant. Units depend
on the order of the reaction, ie,
the number of molecules on the
left hand side. First
order is sec^-1, second order is
sec^-1.num^-1, etc.
kb Backward rate constant. Units depend
on the number of molecules on the
right hand side, in a similar way.
A, B Internal state variables, used to
communicate with pools. A represents
increase in the pool n, B is the
decrease.
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: ReacFunc [in src/kinetics/reac.c]
Classes: segment
Actions: PROCESS
RESET
SET
Messages: SUBSTRATE n [Number of molecules in substrate pool]
PRODUCT n [Number of molecules in product pool]
KF kf [Forward rate constant]
KB kb [Backward rate constant]
------------------------------------------------------------------------------
Notes: See pool documentation for complete example.
------------------------------------------------------------------------------
26.52 receptor
Object Type: receptor
Description: takes the weighted sum of up to 10 odors to determine membraneesenting n
P>
Object Type: pulsegen
Description: General purpose pulse generator
Author: M. Nelson, Caltech (4/89)
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: pulsegen_type [in src/user/user_struct.h]
Size: 120 bytes
Fields: level1 level of pulse1
width1 width of pulse1
delay1 delay of pulse1
(wrt ext. input - trig or gate mode)
(wrt pulse2 - free run mode)
level2 level of pulse2
width2 width of pulse2
delay2 delay of pulse2 (wrt pulse1)
baselevel baseline level
trig_mode flag: 0=free run, 1=ext. trig, 2=ext. gate
output output
trig_time internal state variable
previous_input internal state variable
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: PulseGen [in src/user/pulsegen.c]
Classes: device
Actions: PROCESS RESET
Messages: INPUT "gate/trig" (0 = low, non-0 = high)
LEVEL pulse# level
WIDTH pulse# width
DELAY pulse# delay
------------------------------------------------------------------------------
Notes:
This device can generate a variety of pulse patterns: single pulses, double
pulses (each with its own level and width), and pulse trains (of single
pulses or pairs). It can be triggered, gated, or allowed to free run.
In combination with a spikegen object, it can be used to generate bursts of
spikes for use as synaptic input. (See Scripts/neuron/inputs.g.)
The following diagram illustrates the relationships between the fields:
+-----------------+ level1
trigger | |
| | | +-------------+ level2
| | | | |
V | | | |
+--- baselevel --+ +--------+ +----
<---- delay1 ----><---- width1 ----> <-- width2 -->
<--------- delay2 -------->
If delay2 <= width1, then level2 starts imediately after the end of the
pulse at level1. This means that if delay2, width2 and level2 are not set
and remain at their default values of 0, there will be only one type of
pulse. It will repeat after a time delay1 after the end of the pulse
(free run mode) or a time delay1 after it is triggered (trigger or gate
mode).
Example: Scripts/examples/pulsegen/PulseGenDemo.g
See also:
26.50 randomspike
Object Type: randomspike
Description: place a random event into the buffer
Author: M. Wilson, Caltech 6/88, Dave Bilitch 1/94
------------------------------------------------------------------------------
ELEMENT PARAMETERS
DataStructure: Randomspike_type [src/newconn/newconn_struct.h]
Size: 100 bytes
Fields: min_amp minimum amplitude of event
max_amp maximum amplitude of event
rate rate of generation of events
reset flag for whether to reset after each event
reset_value what to reset state to
state current state of object
abs_refract minimum time between events
------------------------------------------------------------------------------
SIMULATION PARAMETERS
Function: RandomEvent [in src/newconn/randomspike.c]
Classes: buffer
Actions: INIT
RESET
PROCESS
Messages: RATE rate
MINMAX min max
------------------------------------------------------------------------------
Notes: Generates a time series of events at a rate given by the rate
parameter. The probability of an event for a single time step
is given by rate*dt where dt is the clock rate of the
element. However, no event will be generated at a time less
than abs_refract. When an event has been generated, the
amplitude of the event is a random variable uniformly
distributed between min_amp and max_amp. The state field
has the value of the event amplitude if an event has been
generated. If an event is not generated then the value of
the state field depends on the reset field. If reset is
non-zero then the state is takes on the value given in
reset_value. Otherwise the state will behave like a latch
containing the amplitude of the previous event.
Example: Scripts/tutorials/tutorial4.g
See also:
26.51 reac
Object Type: reac
Description: Chemical reaction object. Works with pools to provide kf and
kb. Reacs calculate the changes in concs for each pool hooked
into them. The pool is responsible for adding up all the
up and down changes resulting from various reactions it is
involved in. Each reac can handle any number of substrates