INDEX GLOSSARY
==============

Items in parens like this (syn itemname) are synonyms.
Most items in << angle brackets >> are not themselves index entries, 
but are used for quick text searches to key parts of the index.

Special notation for symbols and subscripts
-------------------------------------------
%DELTA means uppercase delta
%lambda means lowercase lambda
%lambda_AC means lowercase lambda with AC as subscript

Hyphen usage
------------
3-D
behind-the-scenes
built-in
byproduct
Ca2+-gated
calbindin-positive
calcium-activated
calcium-bound
closely-related
compartment-oriented simulation environment
computer-generated
conductance-change synapse
context-dependent
Crank-Nicholson method
cross-section
current-voltage relation
CVODE-specific
depolarization-activated
domain-specific
dt-dependent
e-fold attenuation
empirically-based modeling
event-based communication
event-driven
experimentally-testable
fail-safe
fan-in
fan-out
fast-moving
first order
hands-off policy
HH-style
HH-type
high frequency term
implementation-specific goal
input-output relationship
ligand-bound
ligand-gated channel
ligand-receptor interaction
line-by-line
long-time
low pass filter
mechanism-specific
membrane-associated
membrane-bound pump
mid-run
model-generic
model-specific
moment-to-moment fluctuations
multiple line comment
NEURON-specific feature
NMODL-specific
non-capacitive current
non-NEURON context
non-node location
non-plotted cells
non-pump current
non-steady state
non-tree structures
nonzero
nseg-dependent
object-oriented programming
off-diagonal term
once-only error
one-dimensional
peak-to-peak
pre-existing
problem-dependent
quasi-equilibrium
re-creating
re-execute
re-initialize
re-use
real-world
sealed end
second order
self-event
sequence-dependent
side-effect
single line comment
smoothly varying
spatially-varying
spike-triggered synaptic transmission
STATE-dependent reaction rates
steady state
stream-specific plasticity
synapse-specific plasticity
time-dependent
time step
time-varying
transmitter-receptor interaction
tree-structured
use-dependent
user-defined
user-level specification
user-settable parameter
user-specified
user-supplied Jacobian
voltage-dependent
voltage-independent
voltage-gated
voltage-sensitive
well-chosen
well-designed
well-matched
well-stirred
x-axis

Common hyphen suspects
----------------------
-activated
-based
-bound
-defined
-dependent
-driven
-gated
-sensitive
-settable
-specific
-specified
-style
-triggered
-varying



INDEXED ITEMS BEGIN HERE
========================


! (logical NOT operator)--see hoc syntax: expressions: operators
!= (inequality operator)--see hoc syntax: expressions: operators
$--see funcs and procs: arguments: positional syntax
$1--see funcs and procs: arguments: positional syntax
$i--see funcs and procs: arguments: symbolic positional syntax
$o--see funcs and procs: arguments: positional syntax
$s--see funcs and procs: arguments: positional syntax
% (remainder operator)--see hoc syntax: expressions: operators
& (pointer operator)--see hoc syntax: pointer operator
&& (logical AND operator)--see hoc syntax: expressions: operators
' (apostrophe)--see DERIVATIVE block: ' (apostrophe)
() (paired left and right parentheses)--see hoc syntax: expressions: operators 
(1)--see units: dimensionless
* (multiplication operator)--see hoc syntax: expressions: operators
*/--see hoc syntax: comments
+ (addition operator)--see hoc syntax: expressions: operators
- (subtraction operator)--see hoc syntax: expressions: operators
- (unaryminus operator)--see hoc syntax: expressions: operators
-> (sink reaction indicator)--see KINETIC block: -> (sink reaction indicator)
/ (division operator)--see hoc syntax: expressions: operators
/*--see hoc syntax: comments
//--see hoc syntax: comments
: (colon)--see NMODL: comments, range variable: linear taper
< (less than operator)--see hoc syntax: expressions: operators
<-> (reaction indicator)--see KINETIC block: <-> (reaction indicator)
<< (explicit flux)--see KINETIC block: << (explicit flux)
<= (less than or equal to operator)--see hoc syntax: expressions: operators
= (assignment operator)--see hoc syntax: expressions: operators
== (equality operator)--see hoc syntax: expressions: operators
> (greater than operator)--see hoc syntax: expressions: operators
>= (greater than or equal to operator)--see hoc syntax: expressions: operators
[] (index operator)--see hoc syntax: variables: double, Vector class, object-oriented syntax
\ (backslash)
^ (exponentiation operator)--see hoc syntax: expressions: operators
^C (Control C)--see hoc: interrupting execution
^D (Control D)--see hoc: starting and exiting
_ (underscore)--see hoc syntax: names
_ion--see ion mechanism: _ion suffix
  *_ion--see ion mechanism: automatically created
  *i0_*_ion--see ion mechanism: default concentration: specification in hoc
  *o0_*_ion--see ion mechanism: default concentration: specification in hoc
{}--see hoc syntax: statements: compound statement
|| (logical OR operator)--see hoc syntax: expressions: operators
~ (tilde)--see KINETIC block: ~ (tilde)


%%%%

%DELTA x
  also see spatial grid, discretization
%DELTA t
  fixed--see numeric integration: fixed time step
  also see discretization
%lambda--see length constant
%lambda_AC--see length constant: AC
%lambda_DC--see length constant: DC
%tau--see time constant
%tau_m--see membrane time constant


3333

3--see nseg: why triple nseg?, spatial accuracy: checking
3-D model--see model: 3-D, 3-D specification of geometry
3-D specification of geometry
  3-D information
  arc3d()
  calculation of L, diam, area, and ri
  coordinates
    absolute vs. relative
  data--see 3-D specification of geometry: 3-D information
    also see quantitative morphometric data
  diam3d()
    checking
      also see stylized specification of geometry: diam: checking
  diameter
    also see 3-D specification of geometry: diam3d(), 3-D specification of geometry: calculation of L, diam, area, and ri
    problems
  n3d()
  number of 3-D points--see n3d()
    effect on computational efficiency
    vs. nseg
  origin of cell--see section: root section: is 3-D origin of cell
  points--see 3-D specification of geometry: 3-D information
  pt3dadd()
  pt3dclear()
  x3d(), y3d(), z3d()
  also see stylized specification of geometry


AAAA

abrupt change--see variable: abrupt change of, NET_RECEIVE block: handling abrupt changes and discontinuities
absolute error
  local
    tolerance
      also see STATE block: specifying local absolute error tolerance
    also see numerical error: local, relative error: local
  also see relative error
absolute local error--see absolute error: local
absolute tolerance--see absolute error: local: tolerance
abstraction
AC length constant--see length constant: AC
access
  also see section: currently accessed: default section
accumulation--see ion accumulation
accuracy
  effect of boundary conditions
  of ionic currents--see membrane current: ionic: accuracy, standard run system: fcurrent()
  order--see numeric integration: order of accuracy
  physiological
  qualitative
  quantitative
  spatial--see spatial accuracy
  vs. speed
  temporal--see temporal accuracy
  also see judgment, discretization, numerical error, parameters: sensitivity to
acell_home_--see NetWork Builder: exporting reusable code: acell_home_
action potential ??
  membrane ??
  propagating ??
  also see spike
active current--see channel: voltage-gated
active transport
  electrically silent
  initialization
    pump transient
  kinetic scheme--see Example 9.9: a calcium pump
  pump current
    countering with a NONSPECIFIC_CURRENT
    initialization
    also see NEURON block: NONSPECIFIC_CURRENT
  pump transient--see active transport: initialization: pump transient
  also see buffer, diffusion, ion accumulation
adaptive integration--see numeric integration: adaptive
adaptive time step--see numeric integration: adaptive
adding items to NEURON Main Menu--see NEURONMainMenu class: miscellaneous_add()
adding new functions to NEURON--see NMODL
adding new mechanisms--see mechanisms: user-defined, nrniv: adding new mechanisms, NMODL
addition operator--see hoc syntax: expressions: operators
addplot()--see standard run system: addplot()
advance microstep--see numeric integration: adaptive: advance microstep
  also see standard run system: fadvance(): local time step integration()
advance()--see standard run system: advance()
afferent event--see event: external
aggregation of events to time step boundaries--see numeric integration: fixed time step: event aggregation to time step boundaries
algebra 
  linear--see linear algebra
algebraic equation--see equation: algebraic
algebraic difference equation--see equation: difference
AlphaSynapse
  graphical interface--see PointProcessManager GUI
  parameters
    onset
    tau
    gmax
    e
  preserving spatial accuracy--see point process: preserving spatial accuracy
  also see Example 10.4: alpha function synapse
alpha function synapse--see AlphaSynapse, Example 10.4: alpha function synapse
Alt key--see Graph class: menu_tool()
amount of material--see material: amount
ampa.mod--see Example 10.6: saturating synapses
AMPAergic synapse--see Example 10.3: synapse with exponential decay
  also see Example 10.6: saturating synapses
amplification factor--see amplifier: gain
amplifier
  feedback--see feedback: amplifier
  gain
  headstage
  also see circuit: element: amplifier
analog--see ?? << what the heck is this used for ??
analog system--see ??  << what the heck is this used for ??
analysis
  initialization--see initialization: analysis
analytic solution
  and discrete event simulation--see discrete event simulation: conditions for
anatomical data--see quantitative morphometric data
anatomical distance--see distance
anatomical properties
  separating biology from numerical issues
    also see section, range, range variable
  specifying--see 3-D specification of geometry, stylized specification of geometry, topology: specifying
  also see section, geometry, topology
AND operator--see hoc syntax: expressions: operators
apostrophe--see DERIVATIVE block: ' (apostrophe)
append()--see List class: append(), SectionList class: append(), Vector class: append()
approximate Jacobian--see Jacobian: approximate
approximation
  of a continuous system by a discrete system
  piecewise linear--see continuous variable: piecewise linear approximation
  also see Jacobian: approximate
arc length--see range
arc3d()--see 3-D specification of geometry: arc3d()
architecture--see topology
area
  membrane--see surface area, membrane area
  surface--see surface area, membrane area
  zero area nodes--see section: nodes: zero area
area()  
  as an ASSIGNED variable--see ASSIGNED variable: v, celsius, t, dt, diam, and area
  calculation of--see stylized specification of geometry: calculation of area and ri, 3-D specification of geometry: calculation of L, diam, area, and ri
  effect of creating a Shape--see Shape object: creating: effect on diam, area, and ri
  effect of define_shape()--see define_shape(): effect on diam, area, and ri
  stylized vs. 3-D surface integral
arguments--see funcs and procs: arguments
  also see NET_RECEIVE block, FUNCTION block, PROCEDURE block
  section as--see SectionRef class
  trapping--see good programming style: bulletproofing against nonsense arguments
arithmetic operators--see hoc syntax: expressions: operators
arrays
  in NMODL--see NMODL: arrays, STATE variable: array in NMODL
  of numbers--see hoc syntax: variables: double, Vector class
  of objects--see object: array
  of sections--see section: array
ArtCellGUI
  bringing up an ArtCellGUI
  cell names--see NetWork Builder: cells: names
    changing--see ArtCellGUI: specifying cell types
  changing cell parameters--see NetWork Builder: caveats
    also see PointProcessGroupManager
  specifying cell types
  also see NEURON Main Menu GUI: Build: NetWork Cell
Artificial Cell--see NEURON Main Menu GUI: Build: NetWork Cell, ArtCellGUI
artificial cell--see artificial spiking cell
artificial neural system  ??? 
  also see biological neural system  ???
artificial neuron--see artificial spiking cell
artificial spiking cell        << artificial >>
  advantages and uses
    computational efficiency
  differences from other point processes
  implemented as point processes
  IntFire1--see IntFire1 class, Example 10.7: IntFire1, a basic integrate and fire model
  IntFire2--see IntFire2 class, Example 10.8: IntFire2, firing rate proportional to input
  IntFire4--see IntFire4 class, Example 10.9: IntFire4, different synaptic time constants
  NetStim--see NetStim class
  also see biophysical neuron model, integrate and fire, IntFire1 class, IntFire2 class, IntFire4 class, NetStim class, NEURON block: ARTIFICIAL_CELL
artificial spiking neuron--see artificial spiking cell
ARTIFICIAL_CELL--see NEURON block: ARTIFICIAL_CELL, artificial spiking cell
ASCII file--see plain text file
ASSIGNED block
  also see PARAMETER block, STATE block
ASSIGNED panel--see Distributed Mechanism GUI: Viewer: Shape Name
ASSIGNED variable  << ASSIGNED >>
  also see PARAMETER variable, STATE variable, ion_style(), state variable: as an ASSIGNED variable
  abrupt change of--see variable: abrupt change of, NetCon class: event(), NET_RECEIVE block: handling abrupt changes and discontinuities
  accuracy
  GLOBAL
    also see NEURON block: GLOBAL
    spatial variation
    vs. RANGE
  initialization
    also see initialization
  is a range variable by default
    also see NEURON block: RANGE, range variable
  v, celsius, t, dt, diam, and area
assigned variable
  also see ASSIGNED variable
assignment operator--see hoc syntax: expressions: operators
assumptions
at_time()--see CVODE: and model descriptions: at_time(), variable: abrupt change of
atol
  also see absolute error: local: tolerance
attaching a section--see connect
attenuation
  at high frequencies
  also see membrane time constant: and attenuation of fast signals, spatial decay of fast signals
Avogadro's number--see units: mole
axial current
  positive current convention
axial resistance
  infinite
    also see diameter: zero or narrow diameter
  also see ri, Ra, cytoplasmic resistivity
axon
  also see squid axon, hh mechanism


BBBB

b_flux--see KINETIC block: b_flux
backward Euler method
  and LONGITUDINAL_DIFFUSION
  iteration coefficient
  local error
  stability
  summary of strengths and weaknesses
  also see modified Euler method, numeric integration: fixed time step
backward flux--see flux: backward, KINETIC block: b_flux
backslash (\)--see \ (backslash)
balance
  charge--see charge: conservation
  mass--see material: conservation
ball and stick
bandpass
barbed wire shape--see stylized specification of geometry: strange shapes
base class--see class: base class, object-oriented programming: polymorphism, object-oriented programming: inheritance
biological neural system  ???
  also see artificial neural system  ???
biological properties
  vs. purely computational issues    << purely numerical issues >>
biological relevance ???   << biologically relevant, significant >>
biological system ???
biophysical mechanism--see distributed mechanism, point process
biophysical model neuron--see biophysical neuron model
biophysical neuron model
  also see artificial spiking cell
biophysical properties
  separating biology from numerical issues
    also see section, range, range variable
  specifying
  also see distributed mechanism, point process
blocks--see NMODL: named blocks
boundary conditions
  effect on accuracy--see accuracy: effect of boundary conditions
  sealed end
branch
  cell
    also see neurite, section
  circuit--see circuit: edge
branched architecture
  also see topology
branched cable--see cable: branched
break--see hoc syntax: flow control: break
BREAKPOINT block  << BREAKPOINT >>
  abrupt change of a variable--see variable: abrupt change of, NetCon class: event(), NET_RECEIVE block: handling abrupt changes and discontinuities
  and computations that must be performed only once per time step
  and counts, flags, and random numbers
  and PROCEDUREs
  and rate functions
  and variables that depend on the number of executions
  at_time()--see CVODE: and model descriptions: at_time(), variable: abrupt change of, NET_RECEIVE block: handling abrupt changes and discontinuities
  currents assigned at end of
  METHOD--see BREAKPOINT block: SOLVE
  SOLVE
    cnexp
    derivimplicit
    is not a function call
    sparse
    also see STATE variable
  state_discontinuity()--see CVODE: and model descriptions: state_discontinuity(), variable: abrupt change of, NET_RECEIVE block: handling abrupt changes and discontinuities
  time-dependent PARAMETER--see variable: time-dependent, Vector class: play()
  translation of
browser--see Plot what?, directory browser, variable browser
buffer
  also see calcium: buffer, active transport, diffusion, ion accumulation
buffering
  with diffusion--See Example 9.8: calcium diffusion with buffering
built-in constants--see hoc syntax: variables: built-in constants
built-in editor--see em
built-in mechanisms--see mechanisms: built-in
bulletproofing against nonsense arguments--see good programming style: bulletproofing against nonsense arguments


CCCC

C code
  embedding--see NMODL: VERBATIM . . . ENDVERBATIM
ca_ion--see ion mechanism: automatically created
CABLE
cable
  branched
  equation--see equation: cable
  passive cylindrical
  unbranched
cadif.mod--see Example 9.8: calcium diffusion with buffering
cagk.mod--see Example 9.5: a calcium-activated, voltage-gated current
cai
  default concentration
    also see ion mechanism: default concentration: specification in hoc
  also see calcium: concentration
cai0_ca_ion--see cai: default concentration, ion mechanism: default concentration: specification in hoc
calcium
  amount of
  buffer
  concentration
    free
    also see cai, cao
  conductance
  current
    effect on concentration
    also see ica
  ion
  permeability
  pump
    also see Example 9.9: a calcium pump
calcium-activated current--see channel: calcium-activated, Example 9.5: a calcium-activated, voltage-gated current
calcium pump--see active transport, Example 9.9: a calcium pump
call by reference--see funcs and procs: arguments: call by reference, NET_RECEIVE block: arguments are call by reference
  also see hoc syntax: pointer operator, funcs and procs: arguments: pointer
call by value--see funcs and procs: arguments: call by reference vs. call by value, FUNCTION block: arguments are call by value, PROCEDURE block: arguments are call by value
call by value vs. call by reference--see funcs and procs: arguments: call by reference, funcs and procs: arguments: call by reference vs. call by value, FUNCTION block: arguments are call by value, PROCEDURE block: arguments are call by value, NET_RECEIVE block: arguments are call by reference
  also see hoc syntax: pointer operator, funcs and procs: arguments: pointer
cao
  default concentration
    also see ion mechanism: default concentration: specification in hoc
  also see calcium: concentration
cao0_ca_ion--see cao: default concentration, ion mechanism: default concentration: specification in hoc
capacitance 
  electrode--see electrode: capacitance
  compensation--see electrode: capacitance: compensation
  membrane--see cm, membrane capacitance, specific membrane capacitance
capacitor
  feedback--see feedback: capacitor
  also see circuit: element: capacitor
capacitive current--see i_cap, membrane current: capacitive
Cell Map--see NetWork Builder: cells: Cell Map
cell time queue--see standard run system: event delivery system: cell time queue
CellBuilder
  bringing up a CellBuilder
  hoc output
    exported cell
    cell class
  root section
    also see section: default section
  spatial grid--see CellBuilder GUI: Geometry page: nseg, d_lambda, or d_X
    also see spatial accuracy, spatial grid
CellBuilder GUI
  Biophysics page
    assigning values
    specifying strategy
  Continuous Create
  Geometry page
    assigning values
    specifying strategy
    nseg
    d_lambda
    d_X
  Management page
    Cell Type
    Export
    Import
  Subsets page
    all subset
    making a new subset
  Topology page
    Basename
    base name
    changing the name of a section
    making a new section
celsius
  as an ASSIGNED variable--see ASSIGNED variable: v, celsius, t, dt, diam, and area
  also see Distributed Mechanism GUI: celsius
central difference method--see Crank-Nicholson method
changing a variable in mid-run--see PARAMETER variable: time-dependent, variable: abrupt change of
changing point process location with hoc code--see point process: loc()
changing standard functions and procedures--see standard run library: redefining functions and procedures, standard GUI library: redefining functions and procedures
channel ??
  analytic integration of states--see numeric integration: analytic integration of channel states
  conductance
  calcium-activated
    also see Example 9.5: a calcium-activated, voltage-gated current
  current
    accuracy--see membrane current: ionic: accuracy, standard run system: fcurrent()
  density
  initialization--see initialization: channel model
  gating model
    HH-type
      also see channel: linear
    under CVODE
  ligand-gated
    also see Example 10.1: graded synaptic transmission, Example 10.5: use-dependent synaptic plasticity, Example 10.6: saturating synapses
  linear
    also see channel: gating model: HH-type
  model
    also see current model
  nonlinear
    under CVODE
  ohmic--see channel: linear
  voltage-gated
    also see Example 9.4: a voltage-gated current, Example 9.5: a calcium-activated, voltage-gated current, Example 9.7: kinetic scheme for a voltage-gated current
chaos and numerical error--see numerical error: chaotic system
chaotic system--see initialization: categories: to a desired state
charge
  balance--see charge: conservation
  conservation
    also see Kirchhoff's current law, gap junction: conservation of charge
  electronic--see e: electronic charge vs. units conversion factor
chemical 
  notation--see kinetic scheme
  reaction--see kinetic scheme
  signal--see signal: chemical
child section--see section: child
chord conductance--see conductance: chord
circuit
  analysis
  edge
  element
    amplifier
    capacitor
    current source
    ground
    resistor
    voltage source
    wire
  equivalent
    also see section: equivalent circuit
  linear--see linear circuit
  node
  parallel RC
  positive current convention
clamp--see current clamp, voltage clamp
class
  base class
    also see object-oriented programming: polymorphism, object-oriented programming: inheritance
  defining a new class--see template: defining an object template
  subclass
    also see object-oriented programming: polymorphism, object-oriented programming: inheritance
  vs. object
  also see template, object, object-oriented programming
class definition--see template, class
Close button--see GUI: tools: Close button
closed end--see boundary conditions: sealed end
closed system
cm                    
  default value
  also see specific membrane capacitance, membrane capacitance
Cm--see cm
cnexp--see DERIVATIVE block, BREAKPOINT block: SOLVE: cnexp
coincidence detection
collection
  of numbers--see hoc syntax: double, Vector class
  of objects--see object: array, List class
  of sections--see SectionList class
command history--see hoc: history function
command potential  
  voltage clamp--see voltage clamp: command potential
COMMENT . . . ENDCOMMENT--see NMODL: comments
comments--see hoc syntax: comments, NMODL: comments
  also see good programming style: comments
comparison of real values--see hoc syntax: float_epsilon
COMPARTMENT--see KINETIC block: COMPARTMENT
compartment
  adjacent  << neighboring >>
  size
  vs. biologically relevant structures
  vs. conceptual clarity     "boxed in by compartments"
  also see segment
compartmental model--see model: compartmental
compartmentalization--see discretization
complexity
compound statement--see hoc syntax: statements: compound statement
computational efficiency  << cost, overhead >>
  and STATEs
  rate tables--see numeric integration: analytic integration of channel states
  staggered time step--see Crank-Nicholson method: staggered time step
  tree topology
  why is NEURON fast?
  also see d_lambda rule, function table, IntFire2 class: firing time: efficient computation, IntFire4 class: firing time: efficient computation, synaptic transmission: spike triggered: computational efficiency in NEURON, discrete event simulation: computational efficiency
computational model--see model: computational
computational solution--see numeric solution
computer display--see GUI: screen
computing
  purpose--see insight
concentration
  and accuracy
  default--see ion mechanism: default concentration
    specification in hoc--see ion mechanism: default concentration: specification in hoc
  extracellular
  gradient
  initialization--see ion mechanism: default concentration, initialization: ion
  intracellular
  specification--see initialization: ion, ion mechanism: default concentration: specification in hoc
  also see ion accumulation, ion mechanism, initialization: ion
conceptual clarity
conceptual model--see model: conceptual
conductance
  absolute
  chord
    also see conductance: slope
  density
    also see channel: density
  ion channel--see channel: conductance
  membrane--see membrane conductance, specific membrane conductance
  slope
    also see conductance: chord
conductance-change synapse--see synapse: conductance-change
conflicts between hoc and GUI tools--see GUI: conflicts with hoc or other GUI tools
connect  
  preserving spatial accuracy
  preventing confusion--see section: child: connect 0 end to parent
connectivity--see NetCon class, List object: managing network connections with
conservation law
  charge--see charge: conservation, Kirchhoff's current law
  material--see material: conservation
CONSERVE--see KINETIC block: CONSERVE
consistency of units--see units: consistency
constant 
  built-in constant--see hoc syntax: variables: built-in constants
  length--see length constant
  membrane time--see membrane time constant
  rate--see rate constant
  time--see time constant
CONSTANT
  vs. PARAMETER or LOCAL variable
CONSTANT block
constant current mechanism
  also see initialization: strategies: injecting a constant current
continuation character--see \ (backslash)
continue--see hoc syntax: flow control: continue
continuerun()--see standard run system: continuerun()
continuous function--see function: continuous
continuous system--see system: continuous
continuous variable
  piecewise linear approximation
    also see range variable: estimating by linear interpolation between nodes
Control C--see hoc: interrupting execution
Control D--see hoc: starting and exiting
Control key--see Graph class: menu_tool()
control--see simulation control
convergence
  also see synaptic transmission: spike-triggered
conversion factor--see scale factor, NMODL: units conversion factor, UNITS block: units scaling
core
correspondence
  between conceptual and computational model--see model: correspondence between conceptual and computational
Crank-Nicholson method
  also see secondorder
  iteration coefficient
  local error
    kinetic scheme
  second order correct plots
  staggered time steps
  summary of strengths and weaknesses
  unstaggered time steps
create 
  also see section
creating an object--see object: creating
creating an object reference--see object reference: declaring
criterion for proper initialization--see initialization: criterion for proper initialization
Ctrl key--see Graph class: menu_tool()
current
  absolute
    also see current: density
  axial--see axial current
  balance--see Kirchhoff's current law
  balance equation--see equation: current balance, Kirchhoff's current law
  capacitive--see membrane current: capacitive, i_cap
  calcium-activated--see channel: calcium-activated
  clamp current--see current clamp: current, voltage clamp: current
  density
    spatial uniformity
    also see current: absolute
  electrode
  ionic--see membrane current: ionic
  membrane--see membrane current
  model--see current model
  sign convention 
    electrical circuit--see circuit: positive current convention
    membrane current--see membrane current: positive current convention
  source
    also see circuit: element: current source
  transmembrane--see membrane current
  voltage-gated--see channel: voltage-gated
current clamp
  current
  preserving spatial accuracy--see point process: preserving spatial accuracy
  also see IClamp class, Example 9.3: an intracellular stimulating electrode
current model
currently accessed section--see section: currently accessed
cursor--see focus: cursor
custom GUI--see user interface: custom GUI
custom initialization--see initialization: categories, initialization: strategies
CVODE  << CVODE >>
  also see numeric integration: adaptive, standard run system: CVODE
  abrupt changes and discontinuities--see CVODE: and model descriptions, variable: abrupt change of 
    NET_RECEIVE block: handling abrupt changes and discontinuities
  and LONGIDUDINAL_DIFFUSION
  and model descriptions
    at_time()
    state_discontinuity()
      also see NET_RECEIVE block: state_discontinuity()
  as generic term for adaptive integration
  default error criteria
  interpolation formulas--see numeric integration: adaptive: interpolation formulas
  local error
  step() under--see standard run system: step(): under CVODE
CVode class
  re-init()
    also see initialization: strategies: changing a state variable
  record()
CVODES
  also see numeric integration: adaptive, CVODE
cytoplasmic resistivity
  also see Ra


DDDD

d_lambda
  also see d_lambda rule, discretization, spatial grid
d_lambda rule
  also see d_lambda, discretization, spatial grid
d_X
  also see d_X rule, discretization, spatial grid
d_X rule
  also see d_X, discretization, spatial grid
DASPK
  also see numeric integration: adaptive, standard run system: DASPK, IDA
daughter section--see section: child
DC length constant--see length constant: DC
declaring an object reference--see object reference: declaring
declaring variables--see NMODL: declaring variables
default section--see access, section: currently accessed: default section
deferred computation--see standard run system: event delivery system: implementing deferred computation
DEFINE--see NMODL: DEFINE
define_shape()
  effect on diam, area, and ri
defining a new class--see template: writing a template
defining a new template--see template: writing a template
delayed action--see standard run system: event delivery system: implementing deferred computation
Delete--see Graph GUI primary menu: Delete
deleting traces--see Graph GUI primary menu: Delete
delta function--see function: delta
demonstration program--see neurondemo
dendritic spine--see spine
density
  current--see current: density
  channel--see channel: density
  material--see material: density
density mechanism--see distributed mechanism
dependent variable--see variable: dependent
DERIVATIVE block
  ' (apostrophe)
  and CVODE
  dependent variable
    is a STATE variable
  also see initialization: channel model: Hodgkin-Huxley style
derivimplicit--see DERIVATIVE block, BREAKPOINT block: SOLVE: derivimplicit
detaching a section--see disconnect()
detail
  also see judgment
developing new GUI tools--see GUI tool development
diam 
  as an ASSIGNED variable--see ASSIGNED variable: v, celsius, t, dt, diam, and area
  calculation from 3-D data--see 3-D specification of geometry: calculation of L, diam, area, and ri
  caution when specifying linear taper
  checking
    also see 3-D specification of geometry: diam3d(): checking
  default value
  effect of creating a Shape--see Shape: creating: effect on diam, area, and ri
  effect of define_shape()--see define_shape(): effect on diam, area, and ri
  specifying  
    stylized specification   ??
    3-D specification--see 3-D specification of geometry: calculation of L, diam, area, and ri
  tapering
  updating from 3-D data
diam3d()--see 3-D specification of geometry: diam3d()
diameter
  abrupt change
  change flag
  checking--see diam: checking, 3-D specification of geometry: diam3d(): checking
  linear taper--see diam: caution when specifying linear taper
  problems--see 3-D specification of geometry: diameter: problems
  zero or narrow diameter
    also see axial resistance: infinite, diam: checking, 3-D specification of geometry: diam3d(): checking
  also see diam, stylized specification of geometry, 3-D specification of geometry: diam3d()
difference equation--see equation: difference
differential algebraic solver--see DASPK
differential equation--see equation: differential
diffusion
  under CVODE
  kinetic scheme
    also see Example 9.8: calcium diffusion with buffering
  longitudinal
    also see Example 9.8: calcium diffusion with buffering
  model geometry--see ion accumulation: initialization: of model geometry
  radial
    also see Example 9.8: calcium diffusion with buffering
  restricted--see Example 9.6: extracellular potassium accumulation
  with buffering--see Example 9.8: calcium diffusion with buffering
  also see active transport, buffer, ion accumulation
dimensionless variable--see units: dimensionless
dimensions--see units
  consistency--see units: consistency
  inconsistent--see units: consistency
directory browser
disconnect()
discontinuity--see variable: abrupt change of, diameter: abrupt change
  also see function: discrete
discrepancy
  between conceptual model and computational model
    also see model: correspondence between conceptual and computational
  between physical system and conceptual model
  between prediction and simulation
discrete event simulation
  computational efficiency
  conditions for
  also see standard run system: fadvance(): global time step integration, standard run system: fadvance(): local time step integration
discrete event system--see standard run system: event delivery system
discrete events and adaptive integration--see standard run system: event delivery system: adaptive integration and, standard run system: fadvance(): global time step integration, standard run system: fadvance(): local time step integration
discrete input event--see event: external
discrete simulation--see discrete event simulation
discrete system--see system: discrete    ?? there isn't a system: discrete yet
discretization
  guidelines
  intent and judgment
  parameter--see nseg
  rule--see d_lambda rule, d_X rule, discretization: guidelines
  spatial
    also see %lambda, length constant, d_lambda, spatial grid, spatial accuracy
  temporal
    also see dt, %DELTA t
  testing--see spatial accuracy: checking, temporal accuracy: checking
discretization interval--see %DELTA x, spatial grid
display--see GUI: screen
distance
  normalized distance along a section--see range
  physical distance along a section
distributed mechanism
  adding new--see mechanisms: user-defined, NMODL
  insert--see insert 
  vs. point process
  also see NEURON block: SUFFIX
Distributed Mechanism GUI
  celsius
  globalRa
  Manager
    Homogeneous Spec
    Inserter
  Viewer
    Globals
    Name Values
    Shape Name
Distributed Mechanism Manager--see Distributed Mechanism GUI: Manager
distributed physical system--see system: continuous
divergence
  also see synaptic transmission: spike-triggered
divide and conquer--see good programming style: divide and conquer
division operator--see hoc syntax: expressions: operators
doEvents()--see standard run system: doEvents()
dot notation
  accessing object members--see object: public members: dot notation
  specifying section properties--see section: currently accessed: dot notation
double--see hoc syntax: variables: double
dt
  as an ASSIGNED variable--see ASSIGNED variable: v, celsius, t, dt, diam, and area
    also see dt: use in NMODL
  fixed--see numeric integration: fixed time step
  use in NMODL
  variable--see numeric integration: adaptive
  also see standard run system: setdt(), standard run system: fadvance(), RunControl GUI: dt, RunControl GUI: Points plotted/ms


EEEE

e
  electronic charge vs. units conversion factor
    also see NMODL: units conversion factor
  also see units: e
e_pas--see pas mechanism
edge--see circuit: edge
efficiency--see computational efficiency
eigenfunction
eigenvalue
eigenvector  ??
elapsed simulation time
  also see t
electrical synapse--see synapse: electrical, synapse: ephaptic, gap junction
electrode
  capacitance
    compensation
  current--see current: electrode
  intracellular stimulating--see Example 9.3: an intracellular stimulating electrode
  resistance
    compensation
  shunting effect of sharp microelectrode--see Example 9.2: a localized shunt
electronic charge--see e: electronic charge vs. units conversion factor
electronic instrumentation--see linear circuit
electrotonic architecture
  spurious effect of changing nseg
electrotonus
else--see hoc syntax: flow control: else
em
  also see emacs, Appendix A2: NEURON's built-in editor
emacs     << emacs >>
  blocks of text
    copying to the kill buffer
    cutting to the kill buffer
    marking
    pasting from the kill buffer
  buffers
  cursor movement
  entering
  exiting
  files
  modes
  repeating commands
    kill current command
    macros
    repeating commands
  search and replace
  send command to OS
  text
    deleting
    inserting
    formatting
  windows
embedding C code--see NMODL: VERBATIM . . . ENDVERBATIM
empty temporal resolution--see temporal accuracy: empty
encapsulating code--see object-oriented programming: encapsulating code
ENDCOMMENT--see NMODL: comments
ENDVERBATIM--see NMODL: VERBATIM . . . ENDVERBATIM
enhancing NEURON--see NMODL
enzymatic breakdown
EOT (^D)--see hoc: starting and exiting
ephapse--see synapse: ephaptic, synapse: electrical, gap junction
ephaptic synapse--see synapse: ephaptic, synapse: electrical, gap junction
equality operator--see hoc syntax: expressions: operators
equation
  algebraic
  cable
  characteristic
  conservation
  current balance
    also see Kirchhoff's current law
  difference
  differential
    coupled vs. independent
    ordinary
    partial
    stiff--see system: stiff
  iteration--see iteration: equation
  node--see equation: current balance, Kirchhoff's current law
  sacred runes
  system--see system equations
equilibrium ??
equilibrium potential
  ASSIGNED vs. PARAMETER--see ASSIGNED variable: when to use for an equilibrium potential
  computation
    also see ion_style(), NEURON block: NONSPECIFIC_CURRENT: equilibrium potential
  initialization--see initialization: ion
    also see ion_style()
equivalent circuit--see circuit: equivalent, section: equivalent circuit
Erase--see Graph GUI: primary menu: Erase
erasing traces--see Graph GUI: primary menu: Erase
error--see numerical error, hoc: error handling, error message
error message
  diam = 0
  no accessed section
  no message for pt3dadd with zero diameter
  also see hoc: error handling
Euler method--see backward Euler method, forward Euler method
event  << event >>
  afferent--see event: external
  delivery
  delivery system--see standard run system: event delivery system
  discrete--see discrete event simulation
  external
    distinguishing from a self-event
  flag
    also see event: external: distinguishing from a self-event
  handler--see NetCon class: event()
  input--see event: external
  logical
  mouse--see mouse: events
  queue--see standard run system: event delivery system: cell time queue, standard run system: event delivery system: event time queue
  self-event
    distinguishing from an external event--see event: external: distinguishing from a self-event
    implementing absolute refractory period--see IntFire1 class: refractory period
    implementing deferred computation--see standard run system: event delivery system: implementing deferred computation
    implementing transmitter release duration--see Example 10.6: saturating synapses
    also see event: external, NET_RECEIVE block: net_move(), NET_RECEIVE block: net_send(), IntFire2 class: firing time: role of self-events, IntFire4 class: firing time: role of self-events
  spike--see event: external
  stream
  times
    notification--see CVODE: and model descriptions: at_time(), NetCon class: event()
    with adaptive integration
      also see NetCon class: event()
    with fixed time step integration--see numeric integration: fixed time step: event aggregation to time step boundaries
    also see standard run system: event delivery system: event time queue
event aggregation to time step boundaries--see numeric integration: fixed time step: event aggregation to time step boundaries
event handler--see NetCon class: event()
event queue--see standard run system: event delivery system: event time queue
event time queue--see standard run system: event delivery system: event time queue
event times--see event: times
event-driven simulation--see discrete event simulation
  also see simulation: continuous system
event()--see NetCon class: event()
<< Example >>
Example 9.1: a passive "leak" current
Example 9.2: a localized shunt
Example 9.3: an intracellular stimulating electrode
Example 9.4: a voltage-gated current
Example 9.5: a calcium-activated, voltage-gated current
Example 9.6: extracellular potassium accumulation
Example 9.7: kinetic scheme for a voltage-gated current
Example 9.8: calcium diffusion with buffering
Example 9.9: a calcium pump
Example 10.1: graded synaptic transmission
Example 10.2: a gap junction
Example 10.3: synapse with exponential decay
Example 10.4: alpha function synapse
Example 10.5: use-dependent synaptic plasticity
Example 10.6: saturating synapses
Example 10.7: IntFire1, a basic integrate and fire model
Example 10.8: IntFire2, firing rate proportional to input
Example 10.9: IntFire4, different synaptic time constants
exiting hoc--see hoc: starting and exiting
exiting NEURON--see NEURON: starting and exiting
exocytosis
Exp2Syn
  computational efficiency
  e
  tau1
  tau2
  also see Example 10.4: alpha function synapse
explicit Euler method--see forward Euler method
explicit flux--see  KINETIC block: << (explicit flux)
exploiting reusable code--see good programming style: exploiting reusable code
exploratory simulations--see GUI: vs. hoc
exponentiation operator--see hoc syntax: expressions: operators
ExpSyn
  e
  tau
  also see Example 10.3: synapse with exponential decay
expsyn1.mod--see Example 10.3: synapse with exponential decay
execute()
  also see hoc: top level of the interpreter
extensive variable--see variable: extensive
external event--see event: external
extracellular field--see extracellular mechanism, system equations: matrix form: extracellular field
extracellular mechanism
  effect of ELECTRODE_CURRENT--see NEURON block: ELECTRODE_CURRENT: effect on extracellular mechanism
  computational efficiency
  initialization--see initialization: extracellular mechanism
  under CVODE
  vext
    also see NEURON block: ELECTRODE_CURRENT: effect on extracellular mechanism
extracellular potassium accumulation--see Example 9.6: extracellular potassium accumulation


FFFF

f_flux--see KINETIC block: f_flux
F-H space--see Example 9.6: extracellular potassium accumulation
factor
  amplification--see amplifier: gain
  conversion--see scale factor, NMODL: units conversion factor, UNITS block: units scaling
  scale--see scale factor, NMODL: units conversion factor, UNITS block: units scaling
fadvance.c
  also see initialization: finitialize()
fadvance()--see standard run system: fadvance()
FALSE--see hoc syntax: expressions: logical expressions
fan-in--see convergence
  also see synaptic transmission: spike-triggered
fan-out--see divergence
  also see synaptic transmission: spike-triggered
faraday--see units: faraday
fast signals
  spatial decay--see spatial decay of fast signals
fast_flushPlot()--see standard run system: fast_flushPlot()
fast_flush_list--see standard run system: plotting system: fast_flush_list
fcurrent()--see standard run system: fcurrent()
feedback
  amplifier
  capacitor
  negative
  positive
field--see extracellular field
file
  hoc file--see hoc file, hoc
  mod file--see mod file, NMODL
  reading and writing--see hoc syntax: basic input and output, File class
  ses file--see session file
  session file--see session file
finitialize()--see initialization: finitialize()
fixed
  %DELTA t--see numeric integration: fixed time step
  dt--see numeric integration: fixed time step
  time step--see numeric integration: fixed time step
float_epsilon--see hoc syntax: float_epsilon
flow control--see hoc syntax: flow control
flushPlot()--see standard run system: flushPlot()
flush_list--see standard run system: plotting system: flush_list
flux
  backward
    also see KINETIC block: b_flux
  forward
    also see KINETIC block: f_flux
  also see KINETIC block: << (explicit flux)
FOCAL
focus
  cursor
for--see hoc syntax: flow control: for
for (x)  
forall  
forsec  
forward Euler method
  also see numerical integration: fixed time step
  iteration coefficient
  local error
  stability
forward flux--see flux: forward, KINETIC block: f_flux
Fourier theory
fprint()--see hoc syntax: basic input and output: fprint()
FROM . . . TO . . . --see NMODL: FROM . . . TO . . . (loop statement)
Frankenhaeuser-Hodgkin space--see Example 9.6: extracellular potassium accumulation
frecord_init()--see initialization: frecord_init()
frequency
  spatial
    also see spatial accuracy, spatial grid, numerical error: spatial
  temporal
fscan()--see hoc syntax: basic input and output: fscan()
funcs and procs  << funcs >>
  $--see funcs and procs: arguments: positional syntax
  $i--see funcs and procs: arguments: symbolic positional syntax
  $o--see funcs and procs: arguments: objref
  $s--see funcs and procs: arguments: strdef
  &--see hoc syntax: pointer operator
  arguments
    call by reference
    call by reference vs. call by value
    numarg()
    object
    objref
    pointer
      also see hoc syntax: pointer operator
    positional syntax
    strdef
    symbolic positional syntax
  defining
  local variable
    also see hoc syntax: names
  recursion
  return
    also see hoc syntax: flow control: return
  returned value--see funcs and procs: return
FUNCTION
  calling from hoc--see hoc: calling an NMODL FUNCTION or PROCEDURE
FUNCTION block
  arguments are call by value
function
  also see funcs and procs, FUNCTION
  continuous
    of space
      also see range variable
    of time
  delta
  discrete ??
  piecewise linear
    also see continuous variable: piecewise linear approximation
  rate--see BREAKPOINT block: and rate functions, KINETIC block: reaction rates: voltage sensitive
  table--see function table
function call operator--see hoc syntax: expressions: operators
function table
  also see NMODL: FUNCTION_TABLE
FUNCTION_TABLE--see NMODL: FUNCTION_TABLE


GGGG

g_pas--see pas mechanism
gain--see amplifier: gain
gap junction
  computational efficiency
  conservation of charge
    also see charge: conservation, equation: current balance, Kirchhoff's current law
  spurious oscillations
  under CVODE
  also see Example 10.2: a gap junction, synapse: electrical, synapse: ephaptic, LinearCircuitBuilder: for gap junctions
gap.mod--see Example 10.2: a gap junction
gating model--see channel: gating model
gating state
  initialization--see initialization: channel model
  custom initialization--see initialization: strategies: changing a state variable
gating variable -- see gating state
Gaussian elimination
generic starting point for GUI tool development--see GUI tool development: generic starting point
GENESIS
geometry
  artifacts
    stylized specification reinterpreted as 3-D specification
    zero diameter
  specifying--see 3-D specification of geometry, stylized specification of geometry
    also see CellBuilder GUI: Geometry page
  zero diameter
  also see topology, anatomical properties
getstr()--see hoc syntax: basic input and output: getstr()
GLOBAL--see NEURON block: GLOBAL, ASSIGNED variable: GLOBAL, PARAMETER variable: is GLOBAL by default, global variable
  also see LOCAL variable: declared outside an equation block: scope and persistence
global--see hoc syntax: names, global variable
global error--see numerical error: global
global time step--see numeric integration: adaptive: global time step
global variable
  also see see hoc syntax: names, NEURON block: GLOBAL, template: writing a template: external
globalRa--see Distributed Mechanism GUI: globalRa
GMODL
good programming style
  bulletproofing against nonsense arguments
  comments
  divide and conquer
  exploiting reusable code
  iterative development
  modular programming
    control--see simulation control
    instrumentation--see instrumentation
    model specification--see model specification
  program organization
  separate model specification from user interface
  testing and revision
  also see hoc: idiom
graded synapse--see synaptic transmission: graded
gradient--see concentration: gradient
gradsyn.mod--see Example 10.1: graded synaptic transmission
Graph
  automatically updating plots and x axis--see standard run system: addplot()
  creating
    Current axis
    Grapher
      also see Grapher
    Phase Plane
    Shape plot   << is spawned from Main Menu >>
    Shape Plot   << a false color plot mapped onto a Shape >>
    Space Plot
    State axis
    Voltage axis
  incorporating into plotting system--see standard run system: plotting system: incorporating Graphs and objects, standard run system: addplot()
  raster--see spike train: recording and plotting
    also see NetWork Builder: buttons: SpikePlot
Graph class
  addexpr()
  addvar()
  begin()
    also see initialization: initPlot(), standard run system: Plot()
  beginline()
  erase_all()
  exec_menu()
  fast_flush()
    also see standard run system: fast_flushPlot()
  flush()
    also see standard run system: flushPlot()
  mark()
  menu_tool()
  plot()
    also see standard run system: Plot()
  save_name()
  size()
  view()
  view_count()
  view_info()
  also see standard run system: addplot()
Graph GUI
  primary menu
    Change Text
    Color/Brush
    Crosshair
    Delete
    Erase
    Keep Lines
    Move Text
    Pick Vector
    Plot what?
  secondary menu
    NewView
    Object Name
    Scene=View
    Set View
    Translate
    View = plot
    Zoom in/out
graph
  raster--see spike trains: recording and plotting, NetWork Builder: buttons: SpikePlot
  also see Graph
graph lists--see standard run system: plotting system: graphLists
graph theory
graphical interface--see user interface: custom GUI, NEURON Main Menu
graphical tools--see NEURON Main Menu, CellBuilder, Graph, PFWM, PointProcessManager, RunControl, Shape plot, Shape Plot, Space Plot, Plot what?, GUI tool development
graphics terminology--see GUI: graphics terminology
greater than operator--see hoc syntax: expressions: operators
greater than or equal to operator--see hoc syntax: expressions: operators
ground--see circuit: element: ground
gsyn.mod--see Example 10.5: use-dependent synaptic plasticity
GUI                  << GUI >>
  combining with hoc
  computer display--see GUI: screen
  conflicts with hoc or other GUI tools
  edit field
  focus
  graphics terminology
  implementing a computational model--see CellBuilder, Channel Builder, Linear Circuit Builder, NetWork Builder
  mapping to the screen--see GUI: screen: mapping to the screen
  model
  model coordinates
    also see GUI: scene coordinates
  numeric field
    checkbox
    default value
    spinner
  scene
  scene coordinates
    making scene and view coordinates equivalent
      also see Graph GUI: secondary menu: Scene=View
    transforming to screen coordinates--see Graph class: view_info()
    vs. screen coordinates
  screen
    mapping to the screen
      also see GUI tool development: mapping to the screen
  screen coordinates
    vs. scene coordinates--see GUI: scene coordinates: vs. screen coordinates
  tools
    are implemented in hoc
    Close button
    developing new tools--see GUI tool development
    work by constructing hoc programs
    also see NEURON Main Menu GUI
  view
    which view contains the mouse--see Graph class: view_info()
  vs. hoc
  also see custom GUI, NEURON Main Menu, standard GUI library
GUI tool development
  basic pattern--see GUI tool development: generic starting point
  box--see VBox, HBox
  Close button--see GUI: tools: Close button
  general issues
    allowing multiple instances
    destroying
    encapsulating
    saving and retrieving
      also see session file, session file: object_push(), session file: object_pop(), GUI: scene coordinates: making scene and view coordinates equivalent
  generic starting point
  graphical model--see GUI: model
  mapping to the screen
    window title
    also see GUI: screen: mapping to the screen, VBox class: map()
  mouse events--see mouse: events
  panel--see xpanel()
  which view contains the mouse--see Graph class: view_info()


HHHH

Hamming, R.W.
HBox
  also see VBox
hh mechanism
hiding information--see object-oriented programming: information hiding
Hinton plot
history function--see hoc: history function
hoc  << hoc >>
  adding new mechanisms--see nrniv: adding new mechanisms, mechanisms: user-defined, NMODL
  calling an NMODL FUNCTION or PROCEDURE
    specifying proper instance with setdata_
  can do anything that a GUI tool can
  combining with GUI
  conflicts with GUI
  efficient simulation--see computational efficiency: why is NEURON fast?
  enhancements and extensions
  error handling
  funcs--see funcs and procs
  functions--see funcs and procs
  history function
  idiom
    forall nseg *= 3
    forall psection()
    load_file("nrngui.hoc")
    also see List class: iteration
  immediate mode
  implementing a computational model
  interrupting execution
    also see hoc: starting and exiting
  Kernighan and Pike
  keywords--see hoc syntax: keywords
  libraries
    also see standard GUI library, standard run library
  oc> prompt
  parse errors--see hoc: error handling
  procedures--see funcs and procs
  procs--see funcs and procs
  run-time errors--see hoc: error handling
  scalar--see hoc syntax: variables: scalars
  scope--see hoc syntax: names, funcs and procs: local variable, LOCAL variable, ASSIGNED variable: GLOBAL, NEURON block: GLOBAL, PARAMETER variable: is GLOBAL by default
    also see template: writing a template: external, object: public members, template: writing a template: public
  speed--see computational efficiency: why is NEURON fast?
  starting and exiting
  stopping--see hoc: interrupting execution
    also see hoc: starting and exiting
  syntax--see hoc syntax
  top level of the interpreter
    also see execute()
  user-defined variable--see hoc syntax: names
  vs. GUI
  also see hoc syntax, Programmer's Reference, good programming style
hoc file
  executing--see NEURON: starting with a specific hoc file, nrngui, nrniv
    also see load_file(), hoc syntax: basic input and output: xopen()
hoc syntax             << hoc syntax >>
  basic input and output
    fprint()
    fscan()
    getstr()
    print
    printf()
    read()
    ropen()
    sprint()
    wopen()
    xopen()
      also see load_file()
    xred()
  comments
  expressions
    logical comparison of real values--see hoc syntax: float_epsilon
    logical expressions
    operators
    precedence--see hoc syntax: expressions: operators
  float_epsilon
  flow control
    break
    continue
    else
    for
    if
    iterator
    iterator_statement
    quit()
    return
      also see funcs and procs: return
    stop
    while
  funcs--see funcs and procs
  functions--see funcs and procs
  keywords
  names
  operators--see hoc syntax: expressions: operators, hoc syntax: pointer operator
  pointer operator
  precedence of operations--see hoc syntax: expressions: operators
  procedures--see funcs and procs
  procs--see funcs and procs
  statements
    compound statement
  variables
    arrays--see hoc syntax: variables: double
    built-in constants
    cannot redefine type
    double
    objref--see object reference: objref
    scalars
    strdef
    strings--see hoc syntax: variables: strdef
  also see hoc: idiom, Programmer's Reference
Hodgkin-Huxley delayed rectifier--see Example 9.4: a voltage-gated current
Hodgkin-Huxley mechanism--see hh mechanism
hypothesis
  testing
  also see model: conceptual


IIII

i_cap  
ica  
IClamp class
  preserving spatial accuracy--see point process: preserving spatial accuracy
iclamp1.mod--see Example 9.3: an intracellular stimulating electrode
IDA
  initialization
  also see numeric integration: adaptive, DASPK, SUNDIALS
idiom--see hoc: idiom
if--see hoc syntax: flow control: if
ifsec  
immediate mode--see hoc: immediate mode
implicit Euler method--see backward Euler method
ina  
iterative development--see good programming style: iterative development
independent variable--see variable: independent
inequality operator--see hoc syntax: expressions: operators
information hiding--see object-oriented programming: information hiding
inheritance--see object-oriented programming: inheritance
init()--see initialization: init()
initPlot()--see initialization: initPlot()
INITIAL block
  initializing STATE variables--see STATE variable: initialization: default vs. explicit, STATE variable: initialization: state0, STATE block: START
  inside NET_RECEIVE block--see NET_RECEIVE block: INITIAL block
  sequence-dependent
  SOLVE
    STEADYSTATE sparse
    also see initialization: channel model: kinetic scheme
  also see initialization, mechanisms: initialization sequence, mechanisms: user-defined: call order
initial condition  ??  not in chap 4 but maybe elsewhere
initial value problem
initialization    << initialization >>
  adaptive integration--see numeric integration: adaptive: initialization, CVode class: re_init(), IDA: initialization
  active transport--see active transport: initialization
  analysis
  ASSIGNED variable--see ASSIGNED variable: initialization
  basic
    also see initialization: finitialize(), initialization: default
  categories
    overview of custom initialization
      also see initialization: init(): custom
    of a chaotic system--see initialization: categories: to a desired state
    of an oscillating system--see initialization: categories: to a desired state
    to a desired state
    to a particular resting potential
    to steady state
    also see initialization: basic, initialization: default
  channel model
    Hodgkin-Huxley style
    kinetic scheme
      also see INITIAL block: SOLVE: STEADYSTATE sparse, initialization: strategies: changing a state variable, initialization: strategies: changing model parameters, initialization: strategies: steady state initialization of complex kinetic schemes
  criterion for proper initialization
  custom--see initialization: categories, initialization: strategies
    also see initialization: init(): custom
  default
    also see initialization: init(), initialization: stdinit(), initialization: basic
  diffusion--see ion accumulation: initialization
  dt--see standard run system: setdt()
  event delivery system--see standard run system: event delivery system: initialization, initialization: finitialize()
  extracellular mechanism
  fcurrent()--see standard run system: fcurrent(): in initialization
  finitialize()
  fixed time step integration--see numeric integration: fixed time step: initialization
  frecord_init()
  init()
    custom
      also see initialization: strategies: changing a state variable
  initPlot()
  internal data structures dependent on topology and geometry
    also see ion accumulation: initialization: of model geometry
  ion
    accumulation--see ion accumulation: initialization
    also see ion mechanism: default concentration, ion_style(), initialization: strategies: changing a state variable
  kinetic scheme
    also see INITIAL block: SOLVE: STEADYSTATE sparse, KINETIC block: CONSERVE: when is it required for initialization?
  linear circuit
  membrane potential--see membrane potential: initialization, initialization: v_init
  NetCon object--see NET_RECEIVE block: INITIAL block
  network
  non-steady state--see initialization: categories: to a desired state
  object--see template: variable initialization
  random number generator
  Random.play()
  recording--see initialization: frecord_init(), Vector class: record(): initialization
  startsw()
    also see run time, standard run system: realtime
  STATE variable--see STATE variable: initialization
  state0--see STATE variable: initialization
  stdinit()
  steady state--see initialization: categories: to steady state, initialization: categories: to a particular resting potential
  strategies
    changing a state variable
      also see STATE variable: initialization, ion mechanism: initialization, ion mechanism: defatult concentration: specification in hoc
    changing model parameters
    changing an equilibrium potential
    groundhog day
    injecting a constant current
    jumping back to move forward
    steady state initialization of complex kinetic schemes
    also see initialization: init(): custom
  synaptic weight vector--see NET_RECEIVE block: INITIAL block
  t
  template--see template: variable initialization
  v_init
    also see membrane potential: initialization
  Vector.play()
  Vector.record()--see initialization: frecord_init(), Vector class: record(): initialization
  weight vector--see NET_RECEIVE block: INITIAL block
  also see RunControl GUI: Init, RunControl GUI: Init & Run, INITIAL block, NET_RECEIVE block: INITIAL block, Graph class: begin(), mechanisms: initialization sequence, mechanisms: user-defined: initialization sequence
initialize microstep--see numeric integration: adaptive: initialize microstep
  also see standard run system: fadvance(): local time step integration()
input and output--see hoc syntax: basic input and output, File class
input event--see event: external
insert <<code>>
  also see uninsert
insight
  "insight, not numbers"--see Hamming, R.W.
instability--see numeric integration: instability
instrumentation
  displaying results
  electronic--see linear circuit
  model parameters
  also see synapse: as instrumentation
integrate and fire
  also see artificial spiking cell
integration--see numeric integration
intensive variable--see variable: intensive
intent--see user's intent
interpolate microstep--see numeric integration: adaptive: interpolate microstep
  also see standard run system: fadvance(): local time step integration()
interpolation--see Vector class: play(): with interpolation
interpreter--see hoc
IntFire1 class            << IntFire1 >>
  effect of an input event
  m--see IntFire1 class: membrane state variable
  M--see IntFire1 class: membrane state variable: visualizing
  membrane state variable
    time constant
    visualizing
  refrac--see IntFire1 class: refractory period
  refractory period
  tau--see IntFire1 class: membrane state variable: time constant
  also see artificial spiking cell, Example 10.7: IntFire1, a basic integrate and fire model
IntFire2 class
  approximate firing rate
  bias--see IntFire2 class: synaptic current state variable: bias
  constraint on time constants
  effect of an external event
  firing time
    efficient computation
    role of self-events
  i--see IntFire2 class: synaptic current state variable
  ib--see IntFire2 class: synaptic current state variable: bias
  m--see IntFire2 class: membrane state variable
  membrane state variable
    time constant
      also see IntFire2 class: constraint on time constants
  role of self-events--see IntFire2 class: firing time: role of self-events
  synaptic current state variable
    bias
    time constant
      also see IntFire2 class: constraint on time constants
  taum--see IntFire2 class: membrane state variable: time constant
  taus--see IntFire2 class: synaptic current state variable: time constant
  also see artificial spiking cell, Example 10.8: IntFire2, firing rate proportional to input
IntFire4 class
  constraint on time constants
  convergence tolerance
  effect of an external event
  eps--see IntFire4 class: convergence tolerance
  firing time
    efficient computation
    role of self-events
  e--see IntFire4 class: synaptic current state variables: excitatory
  i1--see IntFire4 class: synaptic current state variables: inhibitory
  i2--see IntFire4 class: synaptic current state variable: inhibitory
  m--see IntFire4 class: membrane state variable
  mathematical analysis--see Appendix A1: Mathematical analysis of IntFire4
  membrane state variable
    time constant
  synaptic current state variables
    excitatory
    inhibitory
    time constants
      also see IntFire4 class: constraint on time constants
  taue--see IntFire4 class: synaptic current state variables: time constants
  taui1--see IntFire4 class: synaptic current state variables: time constants
  taui2--see IntFire4 class: synaptic current state variables: time constants
  taum--see IntFire4 class: membrane state variable: time constant
  also see artificial spiking cell, Example 10.9: IntFire4, different synaptic time constants
intracellular stimulating electrode--see Example 9.3: an intracellular stimulating electrode
intuition
ion accumulation   << ion accumulation >> << as in specific mechanisms of ion accumulation >>
  initialization
    of model geometry
    also see ion mechanism: default concentration, ion_style(), initialization: strategies: changing a state variable, initialization: strategies: changing model parameters
  kinetic scheme
    also see Example 9.8: calcium diffusion with buffering, Example 9.9: a calcium pump
  under CVODE
  also see active transport, buffer, diffusion, ion mechanism, ion_style(), equilibrium potential, STATE variable: ion concentration as, Example 9.6: extracellular potassium accumulation
ion channel
  also see distributed mechanism
ion concentration--see concentration, ion accumulation, ion mechanism
ion mechanism
  _ion suffix
  automatically created
  default concentration
    for user-created ion names
    name
    specification in hoc
  equilibrium potential--see equilibrium potential: computation
  initialization
    also see initialization: ion
ion_style()
  also see ASSIGNED variable, PARAMETER variable, STATE variable, concentration, initialization: ion
ionic conductance
  also see channel density
ionic current--see membrane current: ionic
ionic equilibrium potential--see equilibrium potential
isopotential--see membrane potential: isopotential, current: density: spatial uniformity
iteration
  coefficient
  equation
  of nonlinear equations--see numeric integration: iteration of nonlinear equation
  over a List--see List class: iteration
  over nodes--see range variable: iterating over nodes
  over sections--see section: iterating over sections
  using iterator--see hoc syntax: flow control: iterator
iterator--see hoc syntax: flow control: iterator
iterator_statement--see hoc syntax: flow control: iterator_statement


JJJJ

Jacobian
  analytic
  approximate
  computing di/dv elements
  nearly singular
  user-supplied
judgment
  also see accuracy, detail, qualitative results


KKKK

k-mole--see units: k-mole
k_ion--see ion mechanism: automatically created
k3st.mod--see Example 9.7: kinetic scheme for a voltage-gated current
kd.mod--see Example 9.4: a voltage-gated current
Keep Lines--see Graph GUI: primary menu: Keep Lines
keep lines--see Graph GUI: primary menu: Keep Lines
Kernighan, B.W.--see hoc: Kernighan and Pike
kext.mod--see Example 9.6: extracellular potassium accumulation
keyboard
  Alt key--see Graph class: menu_tool()
  Control C--see hoc: interrupting execution
  Control D--see hoc: starting and exiting
  Control key--see Graph class: menu_tool()
  Shift key--see Graph class: menu_tool()
keywords--see hoc syntax: keywords, NMODL
ki
  default concentration
    also see ion mechanism: default concentration: specification in hoc
ki0_k_ion--see ki: default concentration, ion mechanism: default concentration: specification in hoc
KINETIC block   << KINETIC >>
  -> (sink reaction indicator)
  ~ (tilde)
  <-> (reaction indicator)
  << (explicit flux)
  and CVODE
  b_flux
  COMPARTMENT
  CONSERVE
    when is it required for initialization?
  dependent variable
    is a STATE variable
    also see KINETIC block: reactants: ASSIGNED or PARAMETER variables as
  f_flux
  initialization--see initialization: channel model: kinetic scheme, INITIAL block: SOLVE: STEADYSTATE sparse
  LONGITUDINAL_DIFFUSION
    also see backward Euler method: and LONGITUDINAL_DIFFUSION, CVODE: and LONGITUDINAL_DIFFUSION
  radial diffusion--see Example 9.8: calcium diffusion with buffering
  reactants
    ASSIGNED or PARAMETER variables as
    also see KINETIC block: dependent variable: is a STATE variable
  reaction rates
    voltage sensitive
    KINETIC block
    STATE-dependent, and instability
    also see kinetic scheme: reaction rates
  also see Crank-Nicholson method: local error: kinetic scheme, BREAKPOINT block: SOLVE: sparse
kinetic scheme
  compartment size
    also see scale factor, NMODL: units conversion factor, KINETIC block: COMPARTMENT
  conservation rules
    also see material: conservation, KINETIC block: CONSERVE
  equivalent differential equations
  initialization--see initialization: channel model: kinetic scheme, initialization: strategies: changing a state variable, initialization: strategies: changing model parameters, KINETIC block: CONSERVE: when is it required for initialization?
  reactants--see KINETIC block: reactants
  reaction rates
    voltage sensitive
  also see KINETIC block
kinetic states
  initialization--see initialization: channel model: kinetic scheme, initialization: strategies: changing a state variable, initialization: strategies: changing model parameters, KINETIC block: CONSERVE: when is it required for initialization?
Kirchhoff's current law
  also see charge: conservation, equation: current balance
ko
  default concentration
    also see ion mechanism: default concentration: specification in hoc
ko0_k_ion--see ko: default concentration, ion mechanism: default concentration: specification in hoc


LLLL

L 
  calculation from 3-D data--see 3-D specification of geometry: calculation of L, diam, area, and ri
  change flag
  default value
  specifying
    stylized specification   ??
    3-D specification--see 3-D specification of geometry: calculation of L, diam, area, and ri
  updating from 3-D data
  also see length
lambda_f()
leak current
  also see pas mechanism
leak.mod--see Example 9.1: a passive "leak" current
legacy code--see troubleshooting: legacy code
length
  arc--see range
  also see L
length constant
  AC
  DC
  also see d_lambda
less than operator--see hoc syntax: expressions: operators
less than or equal to operator--see hoc syntax: expressions: operators
library of mechanisms--see mechanisms: library
linear algebra
LINEAR block
  dependent variable
    is a STATE variable
linear circuit
  also see system equations: matrix form: linear circuit
  computational efficiency
  initialization--see initialization: linear circuit
  under CVODE
linear circuit method--see LinearCircuitBuilder
LinearCircuitBuilder
  for gap junctions
linearity
  also see channel: linear, channel: gating model: HH-type
linear taper--see range variable: linear taper, diam: caution when specifying linear taper
LinearMechanism class
list
  of objects--see List class
  of sections--see SectionList class
List class
  append()
  count()
  iteration
  object stack
  object()
  remove()
  remove_all()
List object
  managing network cells with
  managing network connections with
    also see NetCon
load_file()
  also see hoc syntax: basic input and output: xopen(), hoc: idiom: load_file("nrngui.hoc")
loc()--see point process: loc()
local--see hoc syntax: names, funcs and procs: local variable, LOCAL variable
  also see object: public members: vs. private members, template: writing a template: public
local absolute error--see absolute error: local
local error--see numerical error: local
local relative error--see relative error: local
local time step--see numeric integration: adaptive: local time step
LOCAL variable
  declared outside an equation block
    initial value
    scope and persistence
    also see NEURON block: GLOBAL
  declared within an equation block
    scope and persistence
local variable--see hoc syntax: names, funcs and procs: local variable, LOCAL variable
  also see object: public members: vs. private members, template: writing a template: public
logical comparison of real values--see hoc syntax: float_epsilon
logical comparison operators--see hoc syntax: expressions: operators
logical expressions--see hoc syntax: expressions: logical expressions
logical operators--see hoc syntax: expressions: operators
LONGITUDINAL_DIFFUSION--see KINETIC block: LONGITUDINAL_DIFFUSION
longitudinal diffusion--see diffusion: longitudinal, KINETIC block: LONGITUDINAL_DIFFUSION
lookup table  ??
  also see table lookup  ??
loop statement--see NMODL: FROM . . . TO . . . (loop statement)
  also see hoc syntax: flow control: for, hoc syntax: flow control: while


MMMM

mapping to the screen--see GUI: screen: mapping to the screen
mass
  balance--see material: conservation
  also see material
material
  amount
  concentration
  conservation
  density
Matrix class
mechanisms
  adding new--see mechanisms: user-defined
  built-in
  initialization sequence
  involving delay--see standard run system: event delivery system: implementing deferred computation
  library
  user-defined
    also see nrniv: adding new mechanisms, NMODL
    initialization sequence
  also see distributed mechanism, point process
membrane area
  also see area(), surface area
membrane capacitance
  also see cm, specific membrane capacitance
membrane conductance
  also see sepecific membrane conductance
membrane current
  capacitive
    also see i_cap
  density vs. absolute  ??
  ionic
    accuracy
  positive current convention
membrane potential
  initialization
    also see initialization: v_init, initialization: categories, initialization: strategies
  isopotential
    also see current: density: spatial uniformity
  also see v, membrane state variable
membrane resistance
membrane state variable--see IntFire1 class: membrane state variable, IntFire2 class: membrane state variable, IntFire4 class: membrane state variable
membrane time constant
  and attenuation of fast signals
METHOD--see BREAKPOINT block: SOLVE
microelectrode--see electrode
MicroEMACS
  also see em, emacs
microstep--see numeric integration: adaptive: advance microstep, numeric integration: adaptive: initialize microstep, numeric integration: adaptive: interpolate microstep
miscellaneous_add()--see NEURONMainMenu class: miscellaneous_add()
mistake  
  programming--see hoc: error handling
mknrndll--see NMODL: translator: mknrndll
model
  3-D
    also see 3-D specification of geometry
  ball and stick
  compartmental
  computational
    analysis
    essential steps
    implementation
  conceptual
  correspondence between conceptual and computatonal
    also see discrepancy: between conceptual model and compartmental model
  designing
  description ??
  implementation
  instrumentation--see instrumentation
  network--see network model
  parameters
    also see instrumentation: model parameters
  purpose--see judgment, user's intent
  simulation control--see simulation control
  stylized
    also see stylized specification of geometry
  testing  << evaluating >>
    also see topology: checking
MOdel Description Language--see MODL
model coordinates--see GUI: model coordinates
  vs. screen coordinates--see GUI: scene coordinates: vs. screen coordinates
model description language--see NMODL
modeling
  empirically-based
  rationale
modeling networks--see Chapter 11: Modeling networks
model properties  
  specifying
    also see anatomical properties: specifying, biophysical properties: specifying
model specification  << noun! >>
  as virtual experimental preparation
  vs. user interface--see good programming style: separate model specification from user interface
  also see model properties: specifying
mod file
  compiling
    under MSWindows--see NMODL: translator: mknrndll
    under UNIX/Linux--see NMODL: translator: nrnivmodl
  also see NMODL
modified Euler method
  also see backward Euler method
modifying standard functions and procedures--see standard run library: redefining functions and procedures, standard GUI library: redefining functions and procedures
MODL
  vs. NMODL
modlunit
  also see units: checking
modular programming--see good programming style: modular programming
modulus operator--see hoc syntax: expressions: operators
mole--see units: mole
mole equivalents
morphometric data--see quantitative morphometric data
mouse
  button--see mouse: events
  cursor--see focus
  events
    Alt, Control, or Shift key--see Graph class: menu_tool()
    cursor coordinates
    handling
    also see Graph class: menu_tool()
  which view contains the mouse--see Graph class: view_info()
movie--see Vector: movie
multiplication operator--see hoc syntax: expressions: operators


NNNN

n3d()--see 3-D specification of geometry: n3d()
na_ion--see ion mechanism: automatically created
nai
  default concentration
    also see ion mechanism: default concentration: specification in hoc
nai0_na_ion--see nai: default concentration, ion mechanism: default concentration: specification in hoc
nao
  default concentration
    also see ion mechanism: default concentration: specification in hoc
nao0_na_ion--see nao: default concentration, ion mechanism: default concentration: specification in hoc
National Biomedical Simulation Resource project
(neural modeling is a synonym for computational modeling?)
Nernst equation--see initialization: ion, ion_style()
Nernst potential--see equilibrium potential, initialization: ion, ion_style()
net_event()--see NET_RECEIVE block: net_event()
net_move()--see NET_RECEIVE block: net_move()
NET_RECEIVE block  << NET_RECEIVE >>
  arguments are call by reference
  flag--see event: flag
  handling abrupt changes and discontinuities
  INITIAL block
    also see NetCon: weight vector
  net_event()
  net_move()
  net_send()
  also see Example 10.3: synapse with exponential decay, Example 10.4: alpha function synapse, Example 10.5: use-dependent synaptic plasticity, Example 10.6: saturating synapses, Example 10.7: IntFire1, a basic integrate and fire model, Example 10.8: IntFire2, firing rate proportional to input, Example 10.9: IntFire4, different synaptic time constants
NET_RECEIVE procedure--see NET_RECEIVE block
net_send()--see NET_RECEIVE block: net_send()
NetCon
  and standard run system
NetCon class       << NetCon >>
  delay
  event()
  record()
  source variable
  states--see NetCon class: weight vector
  stream-specificity
  target
  threshold
  weight
    also see NetCon class: weight vector
  weight vector
    initialization
NetCon object
  as a channel for a stream of events
  initialization--see NET_RECEIVE block: INITIAL block
  also see List object: managing network connections with
netcvode.cpp
NetGUI class
  SpikePlot--see NetWork Builder: buttons: SpikePlot
    implementation         << not in this edition >>
  also see NetWork Builder
NetReadyCellGUI
  bringing up a NetReadyCellGUI
  cell names--see NetWork Builder: cells: names
  changing cell parameters--see NetWork Builder: caveats
  also see biophysical neuron model
NetStim class
  also see artificial spiking cell
NetWork Builder   << network >>
  adjusting model parameters
  bringing up a NetWork Builder
  buttons
    Create
    Delays--see NetWork Builder: specifying delays and weights
    Hoc File--see NetWork Builder: exporting reusable code
    Locate--see NetWork Builder: cells: creating
    Show Cell Map--see NetWork Builder: cells: Cell Map
    SpikePlot
    Src -> Tar--see NetWork Builder: cells: connecting
    Weights--see NetWork Builder: specifying delays and weights
  canvas
    dragging
  caveats
  cells
    Cell Map
    connecting--see NetWork Builder: setting up network architecture, NetWork Builder: specifying delays and weights
    creating
    names
      also see NetWork Builder: cells: Cell Map
    types--see NetWork Builder: palette of cell types, ArtCellGUI, NetReadyCellGUI
  changing a network--see NetWork Builder: caveats
  changing cell parameters--see NetWork Builder: caveats
  creating an instance of a network--see NetWork Builder: buttons: Create
  default section--see NetWork Builder: exporting reusable code: acell_home_
  delays and weights--see NetWork Builder: specifying delays and weights
  exploiting reusable code
    also see NetWork Builder: exporting reusable code
  exporting reusable code
    acell_home_
    network cell templates
    network instantiation
    network specification interface
    also see NetWork Builder: exploiting reusable code
  hints
  network architecture--see NetWork Builder: setting up network architecture
  palette of cell types
  plotting spikes--see NetWork Builder: buttons: SpikePlot
  reusable code--see NetWork Builder: exporting reusable code
  saving a hoc file--see NetWork Builder: exporting reusable code
  setting up network architecture
  specifying delays and weights
  synaptic delays and weights--see NetWork Builder: specifying delays and weights
network model
  architecture--see convergence, divergence
    also see NetCon, List object: managing network connections with
  building with GUI--see ArtCellGUI, NetReadyCellGUI, NetWork Builder
  connectivity--see NetCon, List object: managing network connections with
  creating algorithmically
  initialization--see initialization: network, NET_RECEIVE block: INITIAL block
neurite
  also see section
(neuronal modeling is a synonym for computational modeling?)
NEURON    << NEURON >>
  adding new mechanisms--see mechanisms: user-defined, nrniv: adding new mechanisms, NMODL
  last change date--see NEURON: startup banner
  starting and exiting
  starting with a specific hoc file
  startup banner
  version number--see NEURON: startup banner
  also see hoc: starting and exiting
NEURON block
  ARTIFICIAL_CELL
    also see artificial spiking cell, IntFire1 class, IntFire2 class, IntFire4 class, NetStim class
  ELECTRODE_CURRENT
    effect on extracellular mechanism
  GLOBAL
    also see global variable, ASSIGNED variable: GLOBAL, PARAMETER variable: is GLOBAL by default
  NONSPECIFIC_CURRENT
    equilibrium potential
    also see active transport: countering pump current with a NONSPECIFIC_CURRENT
  POINT_PROCESS
    also see point process
  POINTER
    also see POINTER variable
  RANGE
    also see range, range variable, ASSIGNED variable: GLOBAL: vs. RANGE, ASSIGNED variable: is a range variable by default, PARAMETER variable: GLOBAL vs. RANGE, STATE variable: is automatically RANGE
  SUFFIX
    also see distributed mechanism
  USEION
    also see mechanisms: initialization sequence
    effect on initialization order
    READ ex (reading an equilibrium potential)
    READ ix (reading an ionic current)
    READ xi (reading an intracellular concentration)
    READ xo (reading an extracellular concentration)
    WRITE ix (writing an ionic current)
    WRITE xi (writing an intracellular concentration)
    WRITE xo (writing an extracellular concentration)
NEURON demonstration program--see neurondemo
NEURON Main Menu          << Main Menu >>
  adding items--see NEURONMainMenu class: miscellaneous_add()
  creating
NEURON Main Menu GUI
  File
    load dll
    load hoc
    load session
    save session
    working dir
    recent dir
    Print
    Quit
  Build
    single compartment
    Cell Builder
      also see CellBuilder
    Linear Circuit
    NetWork Builder
    NetWork Cell--see ArtCellGUI
  Tools
    adding items--see NEURONMainMenu class: miscellaneous_add()
    Distributed Mechanisms
      also see Distributed Mechanism GUI
    Fitting
    Impedance
    Miscellaneous
    Point Processes
      also see PointProcessManager, PointProcessGroupManager
    RunControl
    VariableStepControl
      also see VariableTimeStep GUI
  Graph
    Voltage axis
    Current axis
    State axis
    Shape plot
    Phase Plane
    Grapher
  Vector
    Save to File
    Retrieve from File
    Gather Values
    Play
    Display
    Draw
  Window
    Print & File Window Manager
    Ungrouped
    Group Manager
NEURON MOdel Description Language--see NMODL
NEURON program group
NEURONMainMenu class
  miscellaneous_add()
NEURONMainMenu object
  is always NEURONMainMenu[0]
NEURON's interpreter--see hoc
neuron.exe
  also see nrniv.exe
neurondemo
NEURONMainMenu
  miscellaneous_add()
new--see object: new, object: creating
NMODL          << NMODL >>
  abrupt change of a variable--see variable: abrupt change of, NET_RECEIVE block: handling abrupt changes and discontinuities
  arrays
    are not dynamic
    index starts at 0
    STATE variable--see STATE variable: array in NMODL
  COMMENT . . . ENDCOMMENT--see NMODL: comments
  comments
  declaring variables
    also see NMODL: named blocks: variable declaration, ASSIGNED block, CONSTANT block, PARAMETER block, STATE block, LOCAL variable, NMODL: DEFINE
    specifying units
  DEFINE
  dt--see dt: use in NMODL
  FROM . . . TO . . . (loop statement)
  function--see FUNCTION block
  FUNCTION_TABLE
  loop statement--see NMODL: FROM . . . TO . . . (loop statement)
  mknrndll--see NMODL: translator: mknrndll
  named blocks
    ASSIGNED--see ASSIGNED block
    BREAKPOINT--see BREAKPOINT block
    CONSTANT--see CONSTANT block
    DERIVATIVE--see DERIVATIVE block
    FUNCTION--see FUNCTION block
    INITIAL--see INITIAL block
    KINETIC--see KINETIC block
    NEURON--see NEURON block
    NONLINEAR--see NONLINEAR block
    PARAMETER--see PARAMETER block
    PROCEDURE--see PROCEDURE block
    equation definition
      also see BREAKPOINT block, DERIVATIVE block, FUNCTION block, INITIAL block, KINETIC block, PROCEDURE block
    general form
    variable declaration
      also see ASSIGNED block, PARAMETER block, STATE block, LOCAL variable
  nocmodl--see NMODL: translator: nocmodl
  nrnivmodl--see NMODL: translator: nrnivmodl
  procedure--see PROCEDURE block
  t--see t: use in NMODL
  translator
    mknrndll
      also see nrnmech.dll, NMODL: translator: nrnivmodl
    nmodl
    nocmodl
    nocmodl.exe
    nrnivmodl
      also see NMODL: translator: mknrndll
  units conversion factor
    parentheses
    also see UNITS block: units scaling, scale factor
  user-defined variable
  VERBATIM . . . ENDVERBATIM
  vs. MODL--see MODL: vs. NMODL
  also see mod file
nmodl--see NMODL: translator: nmodl
nocmodl--see NMODL: translator: nocmodl
nocmodl.exe--see NMODL: translator: nocmodl.exe
node
  circuit--see circuit: node
  equation--see equation: current balance, Kirchhoff's current law
  section--see section: nodes
"nonbiological" model--see artificial spiking cell, integrate and fire
NONLINEAR block
  dependent variable
    is a STATE variable
nonlinearity--see system: nonlinear, channel: nonlinear
noninteractive simulations--see GUI: vs. hoc
NONSPECIFIC_CURRENT--see NEURON block: NONSPECIFIC_CURRENT
normalized distance along a section--see range
NOT operator--see hoc syntax: expressions: operators
notation
  chemical reaction--see kinetic scheme
  circuit--see circuit
nrngui
  loads GUI and standard run library
  also see NEURON: starting and exiting
nrniv
  adding new mechanisms
    also see mechanisms: user-defined, NMODL
  also see nrngui, NEURON: starting and exiting
nrniv.exe
  also see nrniv, neuron.exe
nrnivmodl--see NMODL: translator: nrnivmodl
nrnmech.dll
  also see mknrndll
nrnunits.lib
  also see units: database
nseg 
  effect on spatial accuracy and resolution
  effect on range variable--see range variable: effect of changing nseg, range variable: inhomogeneous: reassert after changing nseg
  repositions internally attached sections and point processes
  vs. number of 3-D points
  why triple nseg?
  why use odd values?
  also see spatial grid, discretization, segment
nstep_steprun--see standard run system: setdt(), RunControl GUI: Points plotted/ms
NULLobject--see object: NULLobject
numarg()--see funcs and procs: arguments: numarg()
numeric integration         << numeric >>
  accuracy--see accuracy, numeric integration: order of accuracy
  adaptive
    also see CVODE, CVODES, DASPK, IDA, SUNDIALS, standard run system: fadvance(): global time step integration, standard run system: fadvance(): local time step integration
    advance microstep
    and events--see event: times: with adaptive integration, standard run system: event delivery system: adaptive integration and, standard run system: fadvance(): global time step integration, standard run system: fadvance(): local time step integration
    and the standard run system--see standard run system: event delivery system: adaptive integration and, standard run system: fadvance(): global time step integration, standard run system: fadvance(): local time step integration
    error control--see numerical error: control
    global time step
      also see standard run system: fadvance(): global time step integration, VariableTimeStep GUI--global vs. local time steps
    global variable time step--see numeric integration: adaptive: global time step
    GUI control--see VariableTimeStep GUI
    initialization
      also see CVode class: re_init(), initialization
    initialize microstep
    interpolate microstep
    interpolation formulas
    local time step
      also see standard run system: fadvance(): local time step integration, standard run system: event time queue, standard run system: cell time queue, CVode class: record(),  VariableTimeStep GUI--global vs. local time steps
    local variable time step--see numeric integration: adaptive: local time step
    microstep--see numeric integration: adaptive: advance microstep, numeric integration: adaptive: initialize microstep, numeric integration: adaptive: interpolate microstep
    switching to fixed time step
    toggling ON and OFF--see VariableTimeStep GUI--toggling adaptive integration ON and OFF
    with discrete events--see standard run system: event delivery system: adaptive integration and, standard run system: fadvance(): global time step integration, standard run system: fadvance(): local time step integration, event: times: with adaptive integration
  analytic integration of channel states
  central difference method--see Crank-Nicholson method
  error--see accuracy, numerical error, numeric integration: order of accuracy
  explicit
    also see forward Euler method
  fixed time step
    also see backward Euler method, forward Euler method, Crank-Nicholson method, standard run system: fadvance(): fixed time step
    event aggregation to time step boundaries
      also see event: times: with adaptive integration
    initialization
      also see initialization
    switching to adaptive
  implicit
    also see backward Euler method, Crank-Nicholson method
  initialization--see numeric integration: adaptive: initialization, numeric integration: fixed time step: initialization, initialization
  instability
    also see numeric integration: stability
  iteration of nonlinear equations
  NEURON's default method--see backward Euler method
  order of accuracy  << accuracy precision >>
    first
      also see backward Euler method, forward Euler method
    second
      also see Crank-Nicholson method, spatial accuracy: second order
    variable
      also see numeric integration: adaptive, CVODE, DASPK
  precision--see numeric integration: order of accuracy
  stability
    also see numeric integration: instability, system: stiff, backward Euler method, forward Euler method, Crank-Nicholson method
    effect of signal sources
      also see system equations: effect of signal sources
  summary
numeric solution
numerical error   << numerical error >>
  also see parameters: sensitivity to, accuracy: physiological, accuracy: qualitative
  absolute--see absolute error
  caused by changing nseg--see nseg: repositions internally attached sections and point processes
  chaotic system
  control
    also see absolute error: local: tolerance, relative error: local: tolerance
  criterion--see absolute error: local: tolerance, relative error: local: tolerance
  cumulative--see numerical error: global
  global
  integrated
    also see numerical error: global
  local
    also see absolute error: local, relative error: local
  message--see error message, hoc: error handling
  oscillations
  programming--see hoc: error handling
  relative--see relative error
  roundoff
  spatial
    also see spatial accuracy
  temporal
    effect of spatial discretization
    also see temporal accuracy
  tolerance--see absolute error: local: tolerance, relative error: local: tolerance
  total--see numerical error: global
numerical oscillations--see numerical error: oscillations, numeric integration: instability
Nyquist sampling theorem


OOOO

object  << object >>
  array
  as an argument--see funcs and procs: arguments: object
  calling a method--see object: public members: accessing from hoc
  collection--see object: array, List class
  creating
  destroying
  dot notation--see object: public members: dot notation
  incorporating into plotting system--see standard run system: plotting system: incorporating Graphs and objects
  initializing variables--see template: variable initialization
  list--see List class
  methods
    calling--see object: public members: accessing from hoc
  name
    how generated
    vs. object reference
  new
  NULLobject
    using the NULLobject
  notifying at every step--see standard run system: plotting system: notifying Graphs and objects
  objref--see object reference: objref
  passing to a func or proc--see funcs and procs: arguments: object
  private vs. public--see object: public members: vs. private members, template: writing a template: public
  public members
    accessing from hoc
    dot notation
    vs. private members
    also see template: writing a template: public
  reference--see object reference, object: reference count
  reference count
  set--see object: array, List class
  specifying attributes--see template: writing, object: public members: dot notation
  stack--see List class: object stack
  state
  this--see object reference: this
  vs. class
  vs. object reference
  also see object reference, class, template, object-oriented programming
  polymorphism
object name--see object: name
object name vs. object reference--see object reference: vs. object name
object reference
  as an argument--see funcs and procs: arguments: objref
  cannot be redefined as scalar, double, or string
  count--see object: reference count
  declaring
  objectvar
    also see object reference: cannot redefine as scalar, double, or string
  objref
    also see object reference: cannot redefine as scalar, double, or string
  passing to a func or proc--see funcs and procs: arguments: objref
  points to an object
  this
  vs. object
  vs. object name
object variable--see object reference: objectvar
object_pop()--see session file: object_pop()
object_push()--see session file: object_push()
object-oriented programming
  class wrapper  ??
  encapsulating code
  information hiding
  inheritance
    also see class: base class, class: subclass
  polymorphism
    also see class: base class, class: subclass
  also see object, object reference, class, template, object-oriented programming
objectvar--see object reference: objectvar
objref--see object reference: objref
oc
  also see nrniv
ocbox_--see session file: ocbox_
Ohm's law
online Programmer's Reference--see Programmer's Reference
operators--see hoc syntax: expressions: operators
operator precedence--see hoc syntax: expressions: operators
OR operator--see hoc syntax: expressions: operators
oscillations--see numerical error: oscillations
oscillating system--see initialization: categories: to a desired state
oscilloscope
optimization
ordinary differential equation--see equation: differential: ordinary
oxymoron


PPPP

panel--see xpanel()
PARAMETER block
  assigning default PARAMETER values
  default value of state0
    also see STATE variable: state0, STATE block: START
  specifying minimum and maximum limits
PARAMETER panel--see Distributed Mechanism GUI: Viewer: Shape Name
PARAMETER variable
  also see ASSIGNED variable, STATE variable, ion_style()
  abrupt change of--see variable: abrupt change of, NetCon class: event(), NET_RECEIVE block: handling abrupt changes and discontinuities
  default value--see PARAMETER block: assigning default PARAMETER values
  GLOBAL vs. RANGE
    also see NEURON block: RANGE
  is global by default
    also see NEURON block: GLOBAL
  RANGE
  specifying minimum and maximum limits--see PARAMETER block: specifying minimum and maximum limits
  time-dependent
  visibility at the hoc level
  when to use for an equilibrium potential
parameters
  also see PARAMETER variable
  adjusting
  biophysical
  geometric
  sensitivity to
parent section--see section: parent
parentheses--see NMODL: variable declaration: specification of units, NMODL: units conversion factor: parentheses, UNITS block: units scaling
parse errors--see hoc: error handling
partial differential equation--see equation: differential: partial
pas mechanism
  e_pas
  g_pas
  i_pas
passing an object as an argument--see funcs and procs: arguments: object
passing an objref as an argument--see funcs and procs: arguments: objref
passive cylindrical cable--see cable: passive cylindrical
passive leak current--see Example 9.1: a passive "leak" current
permeability
  also see calcium: permeability
PFWM
  creating
  is implemented in C
  saving and retrieving session files--see session file: saving: from PFWM, session file: loading: from PFWM
PFWM GUI
  Print
    To Printer
    PostScript
    PS snapshot
    Idraw
    Ascii
    Select Printer
    Window Titles Printed
    Window Decorations Printed
    Land/Port
  Session
    Retrieve
    Save selected
    Save all
    VirtualScreen
  move
  page layout area
  resize
  select
  virtual screen
physical distance--see distance
physical system
  representing by a model
physiological  ????? standalone or paired with something else or below something else?
physiological accuracy--see accuracy: physiological
piecewise linear approximation--see range variable: estimating by linear interpolation between nodes
piecewise linear function--see function: piecewise linear
Pike, R.--see hoc: Kernighan and Pike
plain text file
plasticity
  synaptic--see synaptic plasticity
Plot what? GUI
  creating--see Graph GUI: primary menu: Plot what?
Plot()--see standard run system: Plot()
plot lists--see standard run system: plotting system: fast_flush_list, standard run system: plotting system: flush_list, standard run system: plotting system: graphLists
PlotShape
plotting spike trains--see spike trains: recording and plotting, NetWork Builder: buttons: SpikePlot
plotting system--see standard run system: plotting system
point process
  adding new--see mechanisms: user-defined, NMODL
  attaching--see point process: inserting
  changing location with hoc code--see point process: loc()
  creating
  destroying
  effect of nseg on location
  inserting
  loc()
  preserving spatial accuracy
  specifying attributes
  vs. distributed mechanism
  also see PointProcess, NEURON block: POINT_PROCESS, artificial spiking cell, NEURON block: ARTIFICIAL_CELL
POINTER--see POINTER variable, NEURON block: POINTER, setpointer
pointer--see hoc syntax: pointer operator, NEURON block: POINTER, POINTER variable
POINTER variable
  effect on Jacobian--see Jacobian: approximate
  also see NEURON block: POINTER, setpointer, variable: local vs. nonlocal
Pointer class
pointer operator--see hoc syntax: pointer operator
PointProcess
PointProcessGroupManager
  bringing up a PointProcessGroupManager
PointProcessManager
  configuring as
    AlphaSynapse
      also see PointProcessManager GUI: SelectPointProcess
  creating
  location
    changing
    also see PointProcessManager GUI: Show: Shape
  parameters
    also see PointProcessManager GUI: Show: Parameters
PointProcessManager GUI
  SelectPointProcess
    AlphaSynapse
  Show
    Shape
    Parameters
Points plotted/ms--see RunControl GUI: Points plotted/ms
polymorphism--see object-oriented programming: polymorphism
potassium
  concentration
    also see ki, ko
  conductance
  current
    also see ik
potential
  action--see action potential, spike
  command--see voltage clamp: command potential
  reversal--see synapse: conductance-change: reversal potential, equilibrium potential
  also see membrane potential, voltage
precedence of operations--see hoc syntax: expressions: operators
precision
  and judgment
prediction
print--see hoc syntax: basic input and output: print
Print & File Window Manager--see PFWM
printf()--see hoc syntax: basic input and output: printf()
private vs. public--see object: public members: vs. private members, template: writing a template: public
proc--see funcs and procs
PROCEDURE
  also see BREAKPOINT block: and PROCEDUREs
  calling from hoc--see hoc: calling an NMODL FUNCTION or PROCEDURE
PROCEDURE block
  arguments are call by value
procedure--see funcs and procs, PROCEDURE
Programmer's Reference
programming--see hoc
  good practices--see good programming style
  mistake--see hoc: error handling
program organization--see good programming style: program organization
project management
  also see good programming style
proper initialization--see initialization: criterion for proper initialization
psection()  
pt3d--see 3-D specification of geometry
pt3d data--see 3-D specification of geometry: 3-D information
pt3d list--see 3-D specification of geometry: 3-D information
pt3dadd()--see 3-D specification of geometry: pt3dadd()
pt3dclear()--see 3-D specification of geometry: pt3dclear()
public--see object: public members, template: writing a template: public
pump
  calcium--see calcium: pump
  also see active transport
purpose of computing--see insight
purpose of the model--see user's intent
push_section()   


QQQQ

qualitative results
  also see accuracy, judgment
quantitative morphometric data
  also see 3-D specification of geometry
  bad diameter values--see diameter: zero or narrow diameter
queue
  cell time--see standard run system: event delivery system: cell time queue
  event time--see standard run system: event delivery system: event time queue
Quiet--see RunControl GUI: Quiet
quit()--see hoc syntax: flow control: quit()
quitting NEURON--see NEURON: exiting, hoc syntax: flow control: quit()


RRRR

Ra 
  default value
  also see cytoplasmic resistivity, Distributed Mechanism GUI: globalRa
radial diffusion--see diffusion: radial
ramp clamp--see voltage clamp: ramp clamp
Random class
  play()
    initialization--see initialization: Random.play()
random number generator
  initialization--see initialization: random number generator
RANGE--see NEURON block: RANGE, range, range variable
range
RANGE variable--see range variable, ASSIGNED variable: is a range variable by default, PARAMETER variable: RANGE, STATE variable: is automatically RANGE
range variable
  dot notation--see section: currently accessed: dot notation
  effect of changing nseg
  estimating by linear interpolation between nodes
  inhomogeneous
    reassert after changing nseg
  in which section?--see section: currently accessed
  iterating over nodes
    also see for(x)
  linear taper
  linear variation along a section--see range variable: linear taper
  rangevar(x) returns value at nearest internal node
  also see range, NEURON block: RANGE, ASSIGNED variable: is a range variable by default, PARAMETER variable: RANGE, STATE variable: is automatically RANGE
raster plot--see spike trains: recording and plotting, NetWork Builder: buttons: SpikePlot
rate constant
rate functions--see BREAKPOINT block: and rate functions, KINETIC block: reaction rates: voltage sensitive
re_init()--see CVode class: re_init()
reactants--see KINETIC block: reactants
reaction--see kinetic scheme
  chemical--see kinetic scheme
  rates--see KINETIC block: reaction rates
  reactants--see KINETIC block: reactants
  scheme--see kinetic scheme, KINETIC block
  statement--see KINETIC block: reaction statement
  also see KINETIC block: <-> (reaction indicator)
READ--see NEURON block: USEION
read()--see hoc syntax: basic input and output: read()
reading an ion concentration--see NEURON block: USEION
reading and writing files--see hoc syntax: basic input and output, File class
real model neuron--see oxymoron
realtime--see standard run system: realtime
recording--see CVode class: record(), Vector class: record()
recording spike trains--see NetCon class: record(), spike trains: recording and plotting, NetWork Builder: buttons: SpikePlot
recursion--see funcs and procs: recursion
redefining standard functions and procedures--see standard run library: redefining functions and procedures, standard GUI library: redefining functions and procedures
reference count--see object: reference count
refractory period--see IntFire1 class: refractory period
relative error
  also see absolute error
  local
    also see absolute error: local, numerical error: local
    tolerance
relative local error--see relative error: local
relative tolerance--see relative error: local: tolerance
remainder operator--see hoc syntax: expressions: operators
resistance
  axial--see axial resistance
    also see cytoplasmic resistivity, Ra
  electrode--see electrode: resistance
  compensation--see electrode: resistance: compensation
resistivity--see cytoplasmic resistivity, Ra
resistor--see circuit: element: resistor
restore()--see SaveState class: restore()
restricted diffusion--see Example 9.6: extracellular potassium accumulation
return--see hoc syntax: flow control: return
  also see funcs and procs: return
returned value--see funcs and procs: return
reusable code--see good programming style: exploiting reusable code
reversal potential--see synapse: conductance-change: reversal potential, equilibrium potential, AlphaSynapse: e, ExpSyn: e, Exp2Syn: e
ri
  also see axial resistance
  calculation of--see stylized specification of geometry: calculation of area and ri, 3-D specification of geometry: calculation of L, diam, area, and ri
  effect of creating a Shape--see Shape object: creating: effect on diam, area, and ri
  effect of define_shape()--see define_shape(): effect on diam, area, and ri
  infinite
    also see diameter: zero or narrow diameter
rise time
Rm--see specific membrane resistance
root section--see section: root section
ropen()--see hoc syntax: basic input and output: ropen()
roundoff error--see numerical error: roundoff
run control--see RunControl GUI, simulation control, standard run system
run time
  also see RunControl GUI: Real Time, standard run system: realtime, initialization: startsw()
run time system--see standard run system
run-time errors--see hoc: error handling
run()--see standard run system: run()
RunControl
  creating
RunControl GUI
  Continue for
    also see standard run system: continuerun()
  Continue til
    also see standard run system: continuerun()
  Init
  Init & Run
    also see standard run system: run()
  Points plotted/ms
    also see standard run system: setdt(), standard run system: step()
  Quiet
    also see standard run system: stdrun_quiet
  Real Time
    also see standard run system: continuerun(), standard run system: realtime
  Stop
    also see standard run system: stoprun
  Single Step
    also see standard run system: step
  Tstop
    also see standard run system: tstop
  dt
    also see RunControlGUI: Points plotted/ms, standard run system: setdt()
  t
Runge-Kutta method
  stability
running a simulation
runtime
  error--see hoc: error handling
  system--see standard run system
  also see run time


SSSS

sacred runes--see equation: sacred runes
sampling theorem--see Nyquist sampling theorem
SaveState class
  fread()
  fwrite()
  restore()
  save()
  also see initialization: categories: to a desired state
scalar--see hoc syntax: variables: scalars
scale factor
  also see NMODL: units conversion factor, UNITS block: units scaling
scene--see GUI: scene
scene coordinates--see GUI: scene coordinates
scene coordinates vs. screen coordinates--see GUI: scene coordinates: vs. screen coordinates
screen--see GUI: screen
screen coordinates--see GUI: screen coordinates
screen coordinates vs. scene coordinates--see GUI: scene coordinates: vs. screen coordinates
SCoP
scope--see hoc: names, funcs and procs: local variable, LOCAL variable, ASSIGNED variable: GLOBAL, NEURON block: GLOBAL, PARAMETER variable: is GLOBAL by default
  also see template: writing a template: external, template: writing a template: private, object: public members
sealed end--see boundary conditions: sealed end
SEClamp
  preserving spatial accuracy--see point process: preserving spatial accuracy
  series resistance
  also see voltage clamp
SEClamp class
secname()
second messenger--see Example 10.5: use-dependent synaptic plasticity
  also see calcium
secondorder
  also see Crank-Nicholson method, backward Euler method
section     << section >>
  access--see access, section: currently accessed
  arc length--see range
  area--see area()
  array
  as argument or variable--see SectionRef class
  attaching--see connect
  child
    connect 0 end to parent
  connecting--see connect
  creating--see create
  currently accessed
    default section
    dot notation
    section stack
  daughter--see section: child
  default section 
    vs. root section--see section: root section: vs. default section
    also see section: currently accessed: default
  default parameter values--see cm, diam, L, Ra
  detaching--see disconnect()
  diam--see diam
  diameter--see diameter, diam, 3-D specification of geometry: diam3d()
  disconnecting--see disconnect()
  equivalent circuit
  iterating over sections
    also see forall, forsec, ifsec
  L--see L
  length--see L
  nodes
    internal vs. terminal
    iterating over--see for (x), range variable: iterating over nodes
    locations
      also see nseg: even vs. odd
    zero area
  normalized distance along a section--see range
  nseg--see nseg
  orientation
  parent
  properties  
    specifying--see section: currently accessed, 3-D specification of geometry, stylized specification of geometry, biophysical properties: specifying 
  Ra--see Ra
  root section
    is 3-D origin of cell
    vs. default section
  sets--see SectionList class
  specifying properties--see section: currently accessed, 3-D specification of geometry, stylized specification of geometry, biophysical properties: specifying 
  stack--see section: currently accessed: section stack
  variable--see section variable
section stack--see section: currently accessed: section stack
section variable
  also see L, nseg, Ra
section.h
SectionList class
  append()
SectionRef class
segment
  diameter--see diam
  surface area--see area()
  also see compartment, nseg, section: nodes
self-event--see event: self-event
sensitivity--see parameters: sensitivity to
separating biology from numerical issues
  also see section, range, range variable
ses file--see session file
session file
  loading
    from NEURON Main Menu
    from PFWM
  ocbox_
    also see VBox class: map()
  object_pop()
  object_push()
  saving
    from NEURON Main Menu
    from PFWM
set
  of numbers--see hoc syntax: double, Vector class
  of objects--see object: array, List class
  of sections--see SectionList class, CellBuilder GUI: Subsets page
setdata_--see hoc: calling an NMODL FUNCTION or PROCEDURE: specifying proper instance with setdata_
setdt()--see standard run system: setdt()
setpointer
  also see POINTER variable: setpointer
sets of sections--see SectionList class
Shape class
Shape object
  creating
    effect on diam, area, and ri
shape plot
Shape plot   << is spawned from Main Menu >>
  creating 
    effect on diam, area, and ri
Shape plot GUI
  primary menu
    3D Rotate
    Section
    Shape Style
      Show Diam
      Centroid
      Schematic
    Shape Plot
    Space Plot
      also see Space Plot
    Time Plot
    Plot what?
Shape Plot   << a false color plot mapped onto a Shape >>
shared object--see NMODL: translator: nrnivmodl, nrniv
shell
Shift key--see Graph class: menu_tool()
shunt.mod--see Example 9.2: a localized shunt
sign convention--see circuit: positive current convention,
  membrane current: positive current convention
signal
  chemical
  electrical
signal monitors
  vs. signal sources
signal sources
  effect on system equations--see system equations: effect of signal sources, numeric integration: stability: effect of signal sources
  load--see system equations: effect of signal sources, numeric integration: stability: effect of signal sources
  also see distributed mechanism, point process
simplification
Simulation Control Program--see SCoP
simulation
  continuous system  ??
  control--see simulation control
  event-driven--see discrete event simulation
  interactive vs. noninteractive--see GUI: vs. hoc
  time--see t, elapsed simulation time
simulation control
  initialization--see initialization
  running
  starting
  stopping
  also see standard run system, good programming style: modular programming, good programming style: program organization
simulation environment
  utility of
sink reaction--see KINETIC block: -> (sink reaction indicator)
size--see compartment: size, discretization, nseg
slope conductance--see conductance: slope
sodium
  concentration
    also see nai, nao
  conductance
  current
    also see ina
solution
  analytic--see analytic solution
  computational--see numeric solution
  numeric--see numeric solution
SOLVE--see BREAKPOINT block: SOLVE, INITIAL block: SOLVE: STEADYSTATE sparse
solve.c
source
  current--see current: source, circuit: element: current source
  signal--see signal sources
space
space constant--see %lambda, length constant, d_lambda
space plot
Space Plot
  creating
Space Plot GUI
  primary menu -- is this needed??
    does anything go here???
sparse--see KINETIC block, BREAKPOINT block: SOLVE: sparse, INITIAL block: SOLVE: STEADYSTATE sparse
spatial accuracy
  checking
  second order
    preserving
  also see discretization: spatial, nseg: effect on spatial accuracy and resolution
spatial decay of fast signals
spatial discretization--see discretization: spatial, spatial grid
spatial error--see numerical error: spatial, spatial accuracy
spatial frequency--see frequency: spatial
spatial grid
  also see discretization: spatial
  choosing--see discretization: guidelines, d_lambda rule, d_X rule, CellBuilder GUI: Geometry page: specifying strategy
spatial resolution--see discretization: spatial, numerical error: spatial, spatial accuracy, spatial grid
special--see NMODL: translator: nrnivmodl, nrniv
specific membrane capacitance
  also see cm
specific membrane conductance
  also see membrane conductance
specific membrane resistance
  also see specific membrane conductance
specifying geometry--see 3-D specification of geometry, stylized specification of geometry
  also see geometry, anatomical properties
specifying model properties--see model properties: specifying
specifying object attributes--see template: writing, object: public members: dot notation
specifying section properties--see section: currently accessed, 3-D specification of geometry, stylized specification of geometry, biophysical properties: specifying
specifying the current section--see section: currently accessed
specifying the spatial grid--see discretization: spatial grid, nseg, spatial grid
specifying topology--see topology: specifying
speed--see computational efficiency
speed vs. accuracy--see accuracy: vs. speed
spike
  also see action potential
spike event--see event: external
spike trains
  recording and plotting
    also see NetCon class: record(), NetWork Builder: buttons: SpikePlot
SpikePlot--see NetWork Builder: buttons: SpikePlot
spine
sprint()--see hoc syntax: basic input and output: sprint()
squid axon
  also see hh mechanism
stability--see numeric integration: stability
stack of objects--see List class: object stack
staggered time steps--see Crank-Nicholson method: staggered time steps
standard GUI library   << GUI library >>
  changing functions and procedures--see standard GUI library: redefining functions and procedures
  hoc source accompanies NEURON
  loading--see nrngui, hoc: idiom: load_file("nrngui.hoc")
  not loading--see nrniv
  redefining functions and procedures
  also see stdgui.hoc
standard run library
  changing functions and procedures--see standard run library: redefining functions and procedures
  hoc source accompanies NEURON
  redefining functions and procedures
standard run system  << standard run >>
  addplot()
  addvar()
  advance()
  continuerun()
  discrete events--see standard run system: fadvance(): global time step integration, standard run system: fadvance(): local time step integration
  doEvents()
  event delivery system
    adaptive integration and
    and models with discontinuities--see variable: abrupt change of, event: times
    cell time queue
      also see numeric integration: adaptive: local time step, standard run system: fadvance(): global time step integration, standard run system: fadvance(): local time step integration
    event time queue
      also see numeric integration: adaptive: local time step, standard run system: fadvance(): global time step integration, standard run system: fadvance(): local time step integration
    event times--see event: times, standard run system: event time queue
    external event--see event: external
    implementing deferred computation
      also see event: self-event
    initialization
    input event--see event: external
    self-event--see event: self-event
    also see event, standard run system: fadvance(): global time step integration, standard run system: fadvance(): local time step integration
  fadvance()
    discrete events--see standard run system: fadvance(): global time step integration, standard run system: fadvance(): local time step integration
    fixed time step
    global time step integration
    local time step integration
  fast_flushPlot()
  fcurrent()
    in initialization
  finitialize()--see initialization: finitialize()
  flushPlot()
  graph lists--see standard run system: plotting system: graphLists
  Graphs and objects !
    incorporating--see standard run system: plotting system: incorporating Graphs and objects
    notifying--see standard run system: plotting system: notifying Graphs and objects
  init()--see initialization: init()
  initialization--see initialization
  initialize--see initialization, numeric integration: adaptive: initialize microstep
    also see standard run system: fadvance(): local time step integration()
  initPlot()--see initialization: initPlot()
  is implemented in hoc
  NetCon--see NetCon: and standard run system
  nstep_steprun--see standard run system: setdt(), RunControl GUI: Points plotted/ms
  Plot()
    also see standard run system: step
  plot lists--see standard run system: plotting system: fast_flush_list, standard run system: plotting system: flush_list, standard run system: plotting system: graphLists
  plotting system
    fast_flush_list
    flush_list
    graphLists
    incorporating Graphs and objects
      also see standard run system: plotting system: graphLists, standard run system: addplot()
    notifying Graphs and objects
      also see standard run system: plotting system: graphLists
    special uses
  realtime
  run()
  setdt()
  stdinit()--see initialization: stdinit()
  stdrun_quiet
  step
    also see standard run system: step()
  step()
    under CVODE
    also see standard run system: step
  steprun()
  steps_per_ms--see standard run system: setdt(), standard run system: step, RunControl GUI: Points plotted/ms
  stoprun
  tstop
  also see RunControl GUI, standard run library
START
  see STATE block: START, STATE variable: initialization
starting hoc--see hoc: starting and exiting, NEURON: starting and exiting
starting NEURON--see NEURON: starting and exiting, hoc: starting and exiting
startsw()--see initialization: startsw()
state
  as amount of material
  as concentration
  as density
  as probability
  restoring--see SaveState class: restore(), initialization: categories: to a desired state
  saving--see SaveState class: save()
STATE block         << STATE >>
  also see ASSIGNED block, PARAMETER block
  specifying local absolute error tolerance
  START
    also see STATE variable: initialization, PARAMETER block: default value of state0
STATE panel--see Distributed Mechanism GUI: Viewer: Shape Name
STATE variable
  also see ASSIGNED variable, PARAMETER variable, ion_style(), state variable
  abrupt change of--see variable: abrupt change of, NetCon class: event(), NET_RECEIVE block: handling abrupt changes and discontinuities
  array in NMODL
  and COMPARTMENT statement--see KINETIC block: COMPARTMENT
  conservation--see KINETIC block: CONSERVE
  initialization
    default vs. explicit
    state0
      also see PARAMETER block: default value of state0, STATE block: START
    also see initialization, KINETIC block: CONSERVE
  ion concentration as
  is automatically RANGE
    also see NEURON block: RANGE
  specifying local absolute error tolerance--see STATE block: specifying local absolute error tolerance
  vs. state variable
state variable
  as an ASSIGNED variable
  changing after finitialize()--see initialization: strategies: changing a state variable
  custom initialization--see initialization: strategies: changing a state variable
  initialization--see STATE variable: initialization, initialization
  of a mechanism vs. state variable of a model
  vs. STATE variable--see STATE variable: vs. state variable
state_discontinuity()--see CVODE: and model descriptions: state_discontinuity(), variable: abrupt change of, NET_RECEIVE block: state_discontinuity()
state0--see STATE variable: initialization, INITIAL block
stdgui.hoc
  also see standard GUI library
stdinit()--see initialization: stdinit()
stdlib.hoc
  also see standard run system
stdrun.hoc
  also see standard run system, standard run library
stdrun_quiet--see standard run system: stdrun_quiet
steady state
  also see initialization: steady state, initialization: non-steady state, equilibrium ??
  initialization of complex kinetic schemes--see initialization: strategies: steady state initialization of complex kinetic schemes, INITIAL block: SOLVE: STEADYSTATE sparse
STEADYSTATE--see INITIAL block: SOLVE: STEADYSTATE sparse, initialization
step--see standard run system: step
step()--see standard run system: step()
steprun()--see standard run system: steprun()
stiffness--see system: stiff
stoichiometry
stop--see hoc syntax: flow control: stop
stopping hoc--see hoc: interrupting execution, hoc: starting and exiting
stopping NEURON--see NEURON: starting and exiting, hoc: interrupting execution
stoprun--see standard run system: stoprun
storage oscilloscope
strange shapes--see stylilzed specification of geometry: strange shapes  ??
strdef--see hoc syntax: variables: strdef
stream 
  of events--see event: stream
  of values--see Vector class: play()
  time--see numeric integration: local time step
String class
string--see hoc syntax: variables: strdef
stylized model--see model: stylized, stylized specification of geometry
stylized specification of geometry
  also see 3-D specification of geometry
  calculation of area and ri
  diam--see diam
  L--see L
  reinterpretation as 3-D specification
  strange shapes
subclass--see class: subclass, object-oriented programming: polymorphism, object-oriented programming: inheritance
subtraction operator--see hoc syntax: expressions: operators
SUFFIX--see NEURON block: SUFFIX
SUNDIALS
  also see CVODES, IDA
surface area
  also see area(), membrane area
synapse        << synapse >>
  alpha function--see AlphaSynapse, Exp2Syn, Example 10.4: alpha function synapse
  AMPAergic--see Example 10.3: synapse with exponential decay
    also see Example 10.6: saturating synapses
  as instrumentation
  conductance-change
    alpha function--see AlphaSynapse, Exp2Syn, Example 10.4: alpha function synapse
    conductance
    exponentially decaying--see ExpSyn, Example 10.3: synapse with exponential decay
    reversal potential
    also see Example 10.5: use-dependent synaptic plasticity, Example 10.6: saturating synapses
  electrical
    also see synapse: ephaptic, gap junction
  ephaptic
    also see synapse: electrical, gap junction
  graded--see synaptic transmission: graded
  plasticity--see synaptic plasticity
  saturating--see Example 10.6: saturating synapses
  strength--see NetCon class: weight, NetCon class: weight vector
  weight--see NetCon class: weight, NetCon class: weight vector
  also see AlphaSynapse, ExpSyn, Exp2Syn
synaptic connection--see NetCon class
synaptic convergence--see convergence
  also see synaptic transmission: spike-triggered
synaptic delay--see NetCon class: delay
synaptic divergence--see divergence
  also see synaptic transmission: spike-triggered
synaptic latency--see NetCon class: delay
synaptic plasticity
  stream-specific--see Example 10.5: use-dependent synaptic plasticity, Example 10.6: saturating synapses
synaptic strength--see NetCon class: weight, NetCon class: weight vector
synaptic transmission
  delay--see NetCon class: delay
  graded
    conceptual model
    implementation in NMODL
    also see Example 10.1: graded synaptic transmission
  latency--see NetCon class: delay
  saturating--see Example 10.6: saturating synapses
  spike-triggered
    computational efficiency in NEURON
    conceptual model
    event-based implementation
      also see NetCon class, NET_RECEIVE block, event: external, event: self-event, Example 10.3: synapse with exponential decay, Example 10.4: alpha function synapse, Example 10.5: use-dependent synaptic plasticity, Example 10.6: saturating synapses
  weight--see NetCon class: weight, NetCon class: weight vector
  also see gap junction
synaptic weight--see NetCon class: weight, NetCon class: weight vector
syntax--see hoc syntax, NMODL
  also see Programmer's Reference
syntax error--see hoc: error handling
system
  chaotic--see initialization: categories: to a desired state
  continuous
    piecewise linear approximation--see range variable: estimating by linear interpolation between nodes
  discrete
  discretized
    also see discretization
  electrical ??
  linear
  nonlinear
  oscillating--see initialization: categories: to a desired state
  stiff
    also see numeric integration: stability
system equations
  also see eigenfunction, eigenvalue, eigenvector
  matrix form
    extracellular field
    linear circuit
    also see equation: algebraic
  effect of signal sources
    also see numeric integration: stability: effect of signal sources
  stiff--see system: stiff


TTTT

t
  as an ASSIGNED variable--see ASSIGNED variable: v, celsius, t, dt, diam, and area
    also see t: use in NMODL
  initialization--see initialization: t
  the independent variable in NEURON
  use in NMODL
  also see time
table  
  function--see function table
  lookup--see function table
table_--see NMODL: FUNCTION_TABLE
tapering--see diam: tapering, range variable: linear taper
Taylor's series
temperature--see celsius
template
  cannot be redefined
  direct commands
  names cannot redefine hoc keywords
  this--see object reference: this
  variable initialization
    default initialization
    init() procedure
  visibility--see template: writing a template: public, object: public members
  writing a template
    begintemplate
    endtemplate
    external
    public
      also see object: public members
  also see class, object, object-oriented programming
temporal accuracy
  checking
  empty
  also see discretization: temporal
temporal discretization--see discretization: temporal
temporal frequency--see frequency: temporal
temporal resolution--see temporal accuracy, discretization: temporal
testing and revision--see good programming style: testing and revision
this--see object reference: this
three dimensional specification--see 3-D specification of geometry
threshold  ??
tilde--see KINETIC block: ~ (tilde)
time
  current
  rise--see rise time
  also see t
time constant
  also see membrane time constant
time-dependent variable--see variable: time-dependent, Vector class: play()
time step
  and stability--see numeric integration: stability, backward Euler method, forward Euler method, Crank-Nicholson method
  choosing
  current--see time: current
  fixed--see numeric integration: fixed time step
  also see dt, %DELTA t, discretization: temporal, numeric integration: adaptive
time stream--see numeric integration: local time step
tolerance
  error--see absolute error: local: tolerance, relative error: local: tolerance
top level of the interpreter--see hoc: top level of the interpreter
topology
  artifacts ??
  checking
  loops of sections
  specifying
  viewing
  also see branched architecture
topology()
topology, subsets, geometry, biophysics
total ionic current--see membrane current: ionic
total error--see numerical error: global
transient signals
  spatial decay--see spatial decay of fast signals
transmembrane current--see membrane current
treeset.c
troubleshooting
  conflicts between hoc and GUI--see GUI: conflicts with hoc or other GUI tools
  disappearing section
  Graphs don't work
  legacy code
  no NEURON Main Menu toolbar
  no default section
  strange shapes--see stylized specification of geometry: strange shapes
TRUE--see hoc syntax: expressions: logical expressions
tstop--see standard run system: tstop
Tstop--see RunControl GUI: Tstop, standard run system: tstop


UUUU

unaryminus operator--see hoc syntax: expressions: operators
understanding
uninsert  
UNITS block
  defining new names
  units scaling
units
  checking
    also see modlunit
  consistency
  conversion factor--see scale factor, NMODL: units conversion factor, UNITS block: units scaling
  database
    also see nrnunits.lib
  defining new names--see UNITS block: defining new names
  dimensionless
    (1)
    by default
  disabling checking--see NMODL: UNITSOFF . . . UNITSON
  e
    also see e: electronic charge vs. units conversion factor
  faraday
  k-mole
  mole
  scaling--see UNITS block: units scaling
  specifying
    also see NMODL: declaring variables: specifying units
units scaling--see UNITS block: units scaling
UNITSOFF . . . UNITSON--see NMODL: UNITSOFF . . . UNITSON
UNITSON--see NMODL: UNITSOFF . . . UNITSON
use-dependent synaptic plasticity--see Example 10.5: use-dependent synaptic plasticity, Example 10.6: saturating synapses
USEION--see NEURON block: USEION
user-defined mechanisms--see mechanisms: user-defined
user interface
  as virtual experimental rig
  custom GUI
  vs. model specification--see good programming practice: separate model specification from user interface
user's intent


VVVV

v
  as an ASSIGNED variable--see ASSIGNED variable: v, celsius, t, dt, diam, and area
  is a range variable
  also see membrane potential
v_init--see initialization: v_init
variable  << variable >>
  abrupt change of
    also see CVODE: and model descriptions: at_time(), CVODE: and model descriptions: state_discontinuity(), NetCon class: event(), NET_RECEIVE block: handling abrupt changes and discontinuities
  ASSIGNED--see ASSIGNED variable
  changing in mid-run--see variable: abrupt change of, PARAMETER variable: time-dependent
  CONSTANT--see CONSTANT
  continuous--see continuous variable
  declaring in NMODL--see NMODL: declaring variables, NMODL: named blocks: variable declaration, ASSIGNED block, CONSTANT block, PARAMETER block, STATE block, LOCAL variable, NMODL: DEFINE
  dependent
  dimensionless--see units: dimensionless
  extensive
  global--see global variable
  independent
  initializing--see initialization, template: variable initialization
  intensive
  LOCAL--see LOCAL variable
  local vs. nonlocal
    also see POINTER variable
  names--see hoc syntax: names
  object--see object-oriented programming: object reference
  PARAMETER--see PARAMETER variable
  POINTER--see POINTER variable
  range--see range variable
  scope--see hoc syntax: names, funcs and procs: local variable, global variable, LOCAL variable, ASSIGNED variable: GLOBAL, NEURON block: GLOBAL, PARAMETER variable: is GLOBAL by default
  section--see section variable
  state--see state variable
  state vs. STATE--see STATE variable: vs. state variable
  STATE--see STATE variable
  string--see hoc syntax: variables: strdef
  time-dependent--see PARAMETER variable: time-dependent
    also see Vector class: play()
  user-defined
    in hoc--see hoc: user-defined variable
    in NMODL--see NMODL: user-defined variable
variable browser--see Plot what? GUI
variable order integration--see numeric integration: adaptive
variable order variable time step integration--see numeric integration: adaptive
variable time step method--see numeric integration: adaptive
VariableTimeStep GUI
  bringing up--see NEURON Main Menu: Tools: VariableStepControl
  Details
    Local step--see VariableTimeStep GUI: global vs. local time steps
  global vs. local time steps
    also see numeric integration: adaptive: global time step, numeric integration: adaptive: local time step
  toggling adaptive integration ON and OFF
  Use variable dt checkbox--see VariableTimeStep GUI: toggling adaptive integration ON and OFF
VBox
VBox class
  intercept()
  map()
    also see session file: ocbox_
  mapping to the screen
    window title
  ref()
  save()
Vector
  movie
Vector class
  append()
  c()
  fill()
  mark()
  play()
    initialization--see initialization: Vector.play()
    under adaptive integration
    under fixed time step integration
    with interpolation
    also see variable: time-dependent
  record()
    also see CVode class: record()
    initialization
      also see initialization: frecord_init()
VERBATIM--see NMODL: VERBATIM . . . ENDVERBATIM
version number--see NEURON: startup banner
vext--see extracellular mechanism: vext
view--see GUI: view
virtual experimental preparation
  see model specification: as "virtual experimental preparation"
virtual experimental rig--see user interface: as virtual experimental rig
visibility--see template: writing a template: public, object: public members
Vm--see membrane potential, v
voltage
  membrane--see membrane potential
voltage clamp
  and stability--see numeric integration: stability: effect of signal sources, system equations: effect of signal sources
  command potential
  current
    accuracy
  preserving spatial accuracy--see point process: preserving spatial accuracy
  ramp clamp
  also see SEClamp
voltage-gated current--see channel: voltage-gated
volume--see compartment: size


WWWW

weight--see NetCon class: weight
weight array--see NetCon class: weight: vector
weight vector--see NetCon class: weight: vector
what are the names of things?
which view contains the mouse--see Graph class: view_info()
while--see hoc syntax: flow control: while
why is NEURON fast?--see computational efficiency: why is NEURON fast?
window title--see GUI tool development: mapping to the screen: window title
wopen()--see hoc syntax: basic input and output: wopen()
WRITE--see NEURON block: USEION
writing an ion concentration--see NEURON block: USEION
writing files--see hoc syntax: basic input and output, File class


XXXX

x3d()--see 3-D specification of geometry: x3d(), y3d(), z3d()
x-expression--see standard run system: plotting system: graphLists
xopen()--see hoc syntax: basic input and output: xopen()
xpanel()
xpvalue()
xred()--see hoc syntax: basic input and output: xred()
xvalue()


YYYY

y3d()--see 3-D specification of geometry: x3d(), y3d(), z3d()


ZZZZ

z3d()--see 3-D specification of geometry: x3d(), y3d(), z3d()
zero area node--see section: nodes: zero area
