axon

type ActAvgParams struct {

	// [min: 0] [step: 0.01] [typically 0.01 - 0.2] nominal estimated average activity level in the layer, which is used in computing the scaling factor on sending projections from this layer.  In general it should roughly match the layer ActAvg.ActMAvg value, which can be logged using the axon.LogAddDiagnosticItems function.  If layers receiving from this layer are not getting enough Ge excitation, then this Nominal level can be lowered to increase projection strength (fewer active neurons means each one contributes more, so scaling factor goes as the inverse of activity level), or vice-versa if Ge is too high.  It is also the basis for the target activity level used for the AdaptGi option -- see the Offset which is added to this value.
	Nominal float32 `` /* 745-byte string literal not displayed */

	// enable adapting of layer inhibition Gi multiplier factor (stored in layer GiMult value) to maintain a Target layer level of ActAvg.ActMAvg.  This generally works well and improves the long-term stability of the models.  It is not enabled by default because it depends on having established a reasonable Nominal + Offset target activity level.
	AdaptGi slbool.Bool `` /* 349-byte string literal not displayed */

	// [def: 0] [viewif: AdaptGi] [min: 0] [step: 0.01] offset to add to Nominal for the target average activity that drives adaptation of Gi for this layer.  Typically the Nominal level is good, but sometimes Nominal must be adjusted up or down to achieve desired Ge scaling, so this Offset can compensate accordingly.
	Offset float32 `` /* 315-byte string literal not displayed */

	// [def: 0] [viewif: AdaptGi] tolerance for higher than Target target average activation as a proportion of that target value (0 = exactly the target, 0.2 = 20% higher than target) -- only once activations move outside this tolerance are inhibitory values adapted.
	HiTol float32 `` /* 266-byte string literal not displayed */

	// [def: 0.8] [viewif: AdaptGi] tolerance for lower than Target target average activation as a proportion of that target value (0 = exactly the target, 0.5 = 50% lower than target) -- only once activations move outside this tolerance are inhibitory values adapted.
	LoTol float32 `` /* 266-byte string literal not displayed */

	// [def: 0.1] [viewif: AdaptGi] rate of Gi adaptation as function of AdaptRate * (Target - ActMAvg) / Target -- occurs at spaced intervals determined by Network.SlowInterval value -- slower values such as 0.01 may be needed for large networks and sparse layers.
	AdaptRate float32 `` /* 263-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ActAvgVals struct {

	// running-average minus-phase activity integrated at Dt.LongAvgTau -- used for adapting inhibition relative to target level
	ActMAvg float32 `` /* 141-byte string literal not displayed */

	// running-average plus-phase activity integrated at Dt.LongAvgTau
	ActPAvg float32 `inactive:"+" desc:"running-average plus-phase activity integrated at Dt.LongAvgTau"`

	// running-average max of minus-phase Ge value across the layer integrated at Dt.LongAvgTau
	AvgMaxGeM float32 `inactive:"+" desc:"running-average max of minus-phase Ge value across the layer integrated at Dt.LongAvgTau"`

	// running-average max of minus-phase Gi value across the layer integrated at Dt.LongAvgTau
	AvgMaxGiM float32 `inactive:"+" desc:"running-average max of minus-phase Gi value across the layer integrated at Dt.LongAvgTau"`

	// multiplier on inhibition -- adapted to maintain target activity level
	GiMult float32 `inactive:"+" desc:"multiplier on inhibition -- adapted to maintain target activity level"`

	// adaptive threshold -- only used for specialized layers, e.g., VSPatch
	AdaptThr float32 `inactive:"+" desc:"adaptive threshold -- only used for specialized layers, e.g., VSPatch"`
	// contains filtered or unexported fields
}

type ActInitParams struct {

	// [def: 0.3] initial membrane potential -- see Erev.L for the resting potential (typically .3)
	Vm float32 `def:"0.3" desc:"initial membrane potential -- see Erev.L for the resting potential (typically .3)"`

	// [def: 0] initial activation value -- typically 0
	Act float32 `def:"0" desc:"initial activation value -- typically 0"`

	// [def: 0] baseline level of excitatory conductance (net input) -- Ge is initialized to this value, and it is added in as a constant background level of excitatory input -- captures all the other inputs not represented in the model, and intrinsic excitability, etc
	GeBase float32 `` /* 268-byte string literal not displayed */

	// [def: 0] baseline level of inhibitory conductance (net input) -- Gi is initialized to this value, and it is added in as a constant background level of inhibitory input -- captures all the other inputs not represented in the model
	GiBase float32 `` /* 235-byte string literal not displayed */

	// [def: 0] variance (sigma) of gaussian distribution around baseline Ge values, per unit, to establish variability in intrinsic excitability.  value never goes < 0
	GeVar float32 `` /* 167-byte string literal not displayed */

	// [def: 0] variance (sigma) of gaussian distribution around baseline Gi values, per unit, to establish variability in intrinsic excitability.  value never goes < 0
	GiVar float32 `` /* 167-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ActParams struct {

	// [view: inline] Spiking function parameters
	Spikes SpikeParams `view:"inline" desc:"Spiking function parameters"`

	// [view: inline] dendrite-specific parameters
	Dend DendParams `view:"inline" desc:"dendrite-specific parameters"`

	// [view: inline] initial values for key network state variables -- initialized in InitActs called by InitWts, and provides target values for DecayState
	Init ActInitParams `` /* 155-byte string literal not displayed */

	// [view: inline] amount to decay between AlphaCycles, simulating passage of time and effects of saccades etc, especially important for environments with random temporal structure (e.g., most standard neural net training corpora)
	Decay DecayParams `` /* 233-byte string literal not displayed */

	// [view: inline] time and rate constants for temporal derivatives / updating of activation state
	Dt DtParams `view:"inline" desc:"time and rate constants for temporal derivatives / updating of activation state"`

	// [view: inline] [Defaults: 1, .2, 1, 1] maximal conductances levels for channels
	Gbar chans.Chans `view:"inline" desc:"[Defaults: 1, .2, 1, 1] maximal conductances levels for channels"`

	// [view: inline] [Defaults: 1, .3, .25, .1] reversal potentials for each channel
	Erev chans.Chans `view:"inline" desc:"[Defaults: 1, .3, .25, .1] reversal potentials for each channel"`

	// [view: inline] how external inputs drive neural activations
	Clamp ClampParams `view:"inline" desc:"how external inputs drive neural activations"`

	// [view: inline] how, where, when, and how much noise to add
	Noise SpikeNoiseParams `view:"inline" desc:"how, where, when, and how much noise to add"`

	// [view: inline] range for Vm membrane potential -- [0.1, 1.0] -- important to keep just at extreme range of reversal potentials to prevent numerical instability
	VmRange minmax.F32 `` /* 165-byte string literal not displayed */

	// [view: inline] M-type medium time-scale afterhyperpolarization mAHP current -- this is the primary form of adaptation on the time scale of multiple sequences of spikes
	Mahp chans.MahpParams `` /* 173-byte string literal not displayed */

	// [view: inline] slow time-scale afterhyperpolarization sAHP current -- integrates CaSpkD at theta cycle intervals and produces a hard cutoff on sustained activity for any neuron
	Sahp chans.SahpParams `` /* 182-byte string literal not displayed */

	// [view: inline] sodium-gated potassium channel adaptation parameters -- activates a leak-like current as a function of neural activity (firing = Na influx) at two different time-scales (Slick = medium, Slack = slow)
	KNa chans.KNaMedSlow `` /* 220-byte string literal not displayed */

	// [view: inline] NMDA channel parameters used in computing Gnmda conductance for bistability, and postsynaptic calcium flux used in learning.  Note that Learn.Snmda has distinct parameters used in computing sending NMDA parameters used in learning.
	NMDA chans.NMDAParams `` /* 252-byte string literal not displayed */

	// [view: inline] NMDA channel parameters used in computing Gnmda conductance for bistability, and postsynaptic calcium flux used in learning.  Note that Learn.Snmda has distinct parameters used in computing sending NMDA parameters used in learning.
	MaintNMDA chans.NMDAParams `` /* 252-byte string literal not displayed */

	// [view: inline] GABA-B / GIRK channel parameters
	GabaB chans.GABABParams `view:"inline" desc:"GABA-B / GIRK channel parameters"`

	// [view: inline] voltage gated calcium channels -- provide a key additional source of Ca for learning and positive-feedback loop upstate for active neurons
	VGCC chans.VGCCParams `` /* 159-byte string literal not displayed */

	// [view: inline] A-type potassium (K) channel that is particularly important for limiting the runaway excitation from VGCC channels
	AK chans.AKsParams `` /* 135-byte string literal not displayed */

	// [view: inline] small-conductance calcium-activated potassium channel produces the pausing function as a consequence of rapid bursting.
	SKCa chans.SKCaParams `` /* 140-byte string literal not displayed */

	// [view: inline] Attentional modulation parameters: how Attn modulates Ge
	AttnMod AttnParams `view:"inline" desc:"Attentional modulation parameters: how Attn modulates Ge"`

	// [view: inline] provides encoding population codes, used to represent a single continuous (scalar) value, across a population of units / neurons (1 dimensional)
	PopCode PopCodeParams `` /* 165-byte string literal not displayed */
}

type AttnParams struct {

	// is attentional modulation active?
	On slbool.Bool `desc:"is attentional modulation active?"`

	// [viewif: On] minimum act multiplier if attention is 0
	Min float32 `viewif:"On" desc:"minimum act multiplier if attention is 0"`

	// threshold on CaSpkP for determining the reaction time for the Layer -- starts after MaxCycStart to ensure that prior trial activity has had a chance to dissipate.
	RTThr float32 `` /* 169-byte string literal not displayed */
	// contains filtered or unexported fields
}

type AvgMaxI32 struct {

	// Average, from Calc when last computed as Sum / N
	Avg float32 `inactive:"+" desc:"Average, from Calc when last computed as Sum / N"`

	// Maximum value, copied from CurMax in Calc
	Max float32 `inactive:"+" desc:"Maximum value, copied from CurMax in Calc"`

	// sum for computing average -- incremented in UpdateVal, reset in Calc
	Sum int32 `inactive:"+" desc:"sum for computing average -- incremented in UpdateVal, reset in Calc"`

	// current maximum value, updated via UpdateVal, reset in Calc
	CurMax int32 `inactive:"+" desc:"current maximum value, updated via UpdateVal, reset in Calc"`

	// number of items in the sum -- this must be set in advance to a known value and it is used in computing the float <-> int conversion factor to maximize precision.
	N int32 `` /* 181-byte string literal not displayed */
	// contains filtered or unexported fields
}

type AvgMaxPhases struct {

	// [view: inline] updated every cycle -- this is the source of all subsequent time scales
	Cycle AvgMaxI32 `view:"inline" desc:"updated every cycle -- this is the source of all subsequent time scales"`

	// [view: inline] at the end of the minus phase
	Minus AvgMaxI32 `view:"inline" desc:"at the end of the minus phase"`

	// [view: inline] at the end of the plus phase
	Plus AvgMaxI32 `view:"inline" desc:"at the end of the plus phase"`

	// [view: inline] at the end of the previous plus phase
	Prev AvgMaxI32 `view:"inline" desc:"at the end of the previous plus phase"`
}

type AxonLayer interface {
	emer.Layer

	// AsAxon returns this layer as a axon.Layer -- so that the AxonLayer
	// interface does not need to include accessors to all the basic stuff
	AsAxon() *Layer

	// PostBuild performs special post-Build() configuration steps for specific algorithms,
	// using configuration data set in BuildConfig during the ConfigNet process.
	PostBuild()
}

type AxonNetwork interface {
	emer.Network

	// AsAxon returns this network as a axon.Network -- so that the
	// AxonNetwork interface does not need to include accessors
	// to all the basic stuff
	AsAxon() *Network
}

type AxonPrjn interface {
	emer.Prjn

	// AsAxon returns this prjn as a axon.Prjn -- so that the AxonPrjn
	// interface does not need to include accessors to all the basic stuff.
	AsAxon() *Prjn
}

type AxonPrjns []*Prjn

type BLAPrjnParams struct {

	// [def: 0.01,1] use 0.01 for acquisition (don't unlearn) and 1 for extinction -- negative delta learning rate multiplier
	NegDeltaLRate float32 `def:"0.01,1" desc:"use 0.01 for acquisition (don't unlearn) and 1 for extinction -- negative delta learning rate multiplier"`

	// [def: 0.1] threshold on this layer's ACh level for trace learning updates
	AChThr float32 `def:"0.1" desc:"threshold on this layer's ACh level for trace learning updates"`

	// [def: 0,0.5] proportion of US time stimulus activity to use for the trace component of
	USTrace float32 `def:"0,0.5" desc:"proportion of US time stimulus activity to use for the trace component of "`
	// contains filtered or unexported fields
}

type BurstParams struct {

	// [def: 0.1] [max: 1] Relative component of threshold on superficial activation value, below which it does not drive Burst (and above which, Burst = CaSpkP).  This is the distance between the average and maximum activation values within layer (e.g., 0 = average, 1 = max).  Overall effective threshold is MAX of relative and absolute thresholds.
	ThrRel float32 `` /* 348-byte string literal not displayed */

	// [def: 0.1] [min: 0] [max: 1] Absolute component of threshold on superficial activation value, below which it does not drive Burst (and above which, Burst = CaSpkP).  Overall effective threshold is MAX of relative and absolute thresholds.
	ThrAbs float32 `` /* 241-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CTParams struct {

	// [def: 0.05,0.1,1,2] gain factor for context excitatory input, which is constant as compared to the spiking input from other projections, so it must be downscaled accordingly.  This can make a difference and may need to be scaled up or down.
	GeGain float32 `` /* 246-byte string literal not displayed */

	// [def: 0,50] decay time constant for context Ge input -- if > 0, decays over time so intrinsic circuit dynamics have to take over.  For single-step copy-based cases, set to 0, while longer-time-scale dynamics should use 50
	DecayTau float32 `` /* 227-byte string literal not displayed */

	// [view: -] 1 / tau
	DecayDt float32 `view:"-" json:"-" xml:"-" desc:"1 / tau"`
	// contains filtered or unexported fields
}

type CaLrnParams struct {

	// [def: 80] denomenator used for normalizing CaLrn, so the max is roughly 1 - 1.5 or so, which works best in terms of previous standard learning rules, and overall learning performance
	Norm float32 `` /* 188-byte string literal not displayed */

	// [def: true] use spikes to generate VGCC instead of actual VGCC current -- see SpkVGCCa for calcium contribution from each spike
	SpkVGCC slbool.Bool `` /* 133-byte string literal not displayed */

	// [def: 35] multiplier on spike for computing Ca contribution to CaLrn in SpkVGCC mode
	SpkVgccCa float32 `def:"35" desc:"multiplier on spike for computing Ca contribution to CaLrn in SpkVGCC mode"`

	// [def: 10] time constant of decay for VgccCa calcium -- it is highly transient around spikes, so decay and diffusion factors are more important than for long-lasting NMDA factor.  VgccCa is integrated separately int VgccCaInt prior to adding into NMDA Ca in CaLrn
	VgccTau float32 `` /* 268-byte string literal not displayed */

	// [view: inline] time constants for integrating CaLrn across M, P and D cascading levels
	Dt kinase.CaDtParams `view:"inline" desc:"time constants for integrating CaLrn across M, P and D cascading levels"`

	// [def: 0.01,0.02,0.5] Threshold on CaSpkP CaSpkD value for updating synapse-level Ca values (SynCa) -- this is purely a performance optimization that excludes random infrequent spikes -- 0.05 works well on larger networks but not smaller, which require the .01 default.
	UpdtThr float32 `` /* 274-byte string literal not displayed */

	// [view: -] rate = 1 / tau
	VgccDt float32 `view:"-" json:"-" xml:"-" inactive:"+" desc:"rate = 1 / tau"`

	// [view: -] = 1 / Norm
	NormInv float32 `view:"-" json:"-" xml:"-" inactive:"+" desc:"= 1 / Norm"`
	// contains filtered or unexported fields
}

type CaSpkParams struct {

	// [def: 8,12] gain multiplier on spike for computing CaSpk: increasing this directly affects the magnitude of the trace values, learning rate in Target layers, and other factors that depend on CaSpk values: RLRate, UpdtThr.  Prjn.KinaseCa.SpikeG provides an additional gain factor specific to the synapse-level trace factors, without affecting neuron-level CaSpk values.  Larger networks require higher gain factors at the neuron level -- 12, vs 8 for smaller.
	SpikeG float32 `` /* 464-byte string literal not displayed */

	// [def: 30] [min: 1] time constant for integrating spike-driven calcium trace at sender and recv neurons, CaSyn, which then drives synapse-level integration of the joint pre * post synapse-level activity, in cycles (msec).  Note: if this param is changed, then there will be a change in effective learning rate that can be compensated for by multiplying PrjnParams.Learn.KinaseCa.SpikeG by sqrt(30 / sqrt(SynTau)
	SynTau float32 `` /* 415-byte string literal not displayed */

	// [view: -] rate = 1 / tau
	SynDt float32 `view:"-" json:"-" xml:"-" inactive:"+" desc:"rate = 1 / tau"`

	// [view: inline] time constants for integrating CaSpk across M, P and D cascading levels -- these are typically the same as in CaLrn and Prjn level for synaptic integration, except for the M factor.
	Dt kinase.CaDtParams `` /* 202-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ClampParams struct {

	// is this a clamped input layer?  set automatically based on layer type at initialization
	IsInput slbool.Bool `inactive:"+" desc:"is this a clamped input layer?  set automatically based on layer type at initialization"`

	// is this a target layer?  set automatically based on layer type at initialization
	IsTarget slbool.Bool `inactive:"+" desc:"is this a target layer?  set automatically based on layer type at initialization"`

	// [def: 0.8,1.5] amount of Ge driven for clamping -- generally use 0.8 for Target layers, 1.5 for Input layers
	Ge float32 `def:"0.8,1.5" desc:"amount of Ge driven for clamping -- generally use 0.8 for Target layers, 1.5 for Input layers"`

	// [def: false] [view: add external conductance on top of any existing -- generally this is not a good idea for target layers (creates a main effect that learning can never match), but may be ok for input layers]
	Add slbool.Bool `` /* 207-byte string literal not displayed */

	// [def: 0.5] threshold on neuron Act activity to count as active for computing error relative to target in PctErr method
	ErrThr float32 `def:"0.5" desc:"threshold on neuron Act activity to count as active for computing error relative to target in PctErr method"`
	// contains filtered or unexported fields
}

type Context struct {

	// current evaluation mode, e.g., Train, Test, etc
	Mode etime.Modes `desc:"current evaluation mode, e.g., Train, Test, etc"`

	// if true, the model is being run in a testing mode, so no weight changes or other associated computations are needed.  this flag should only affect learning-related behavior.  Is automatically updated based on Mode != Train
	Testing slbool.Bool `` /* 242-byte string literal not displayed */

	// phase counter: typicaly 0-1 for minus-plus but can be more phases for other algorithms
	Phase int32 `desc:"phase counter: typicaly 0-1 for minus-plus but can be more phases for other algorithms"`

	// true if this is the plus phase, when the outcome / bursting is occurring, driving positive learning -- else minus phase
	PlusPhase slbool.Bool `` /* 126-byte string literal not displayed */

	// cycle within current phase -- minus or plus
	PhaseCycle int32 `desc:"cycle within current phase -- minus or plus"`

	// cycle counter: number of iterations of activation updating (settling) on the current state -- this counts time sequentially until reset with NewState
	Cycle int32 `` /* 156-byte string literal not displayed */

	// [def: 200] length of the theta cycle in terms of 1 msec Cycles -- some network update steps depend on doing something at the end of the theta cycle (e.g., CTCtxtPrjn).
	ThetaCycles int32 `` /* 173-byte string literal not displayed */

	// total cycle count -- increments continuously from whenever it was last reset -- typically this is number of milliseconds in simulation time -- is int32 and not uint32 b/c used with Synapse CaUpT which needs to have a -1 case for expired update time
	CyclesTotal int32 `` /* 255-byte string literal not displayed */

	// accumulated amount of time the network has been running, in simulation-time (not real world time), in seconds
	Time float32 `desc:"accumulated amount of time the network has been running, in simulation-time (not real world time), in seconds"`

	// total trial count -- increments continuously in NewState call *only in Train mode* from whenever it was last reset -- can be used for synchronizing weight updates across nodes
	TrialsTotal int32 `` /* 182-byte string literal not displayed */

	// [def: 0.001] amount of time to increment per cycle
	TimePerCycle float32 `def:"0.001" desc:"amount of time to increment per cycle"`

	// [def: 100] how frequently to perform slow adaptive processes such as synaptic scaling, inhibition adaptation, associated in the brain with sleep, in the SlowAdapt method.  This should be long enough for meaningful changes to accumulate -- 100 is default but could easily be longer in larger models.  Because SlowCtr is incremented by NData, high NData cases (e.g. 16) likely need to increase this value -- e.g., 400 seems to produce overall consistent results in various models.
	SlowInterval int32 `` /* 484-byte string literal not displayed */

	// counter for how long it has been since last SlowAdapt step.  Note that this is incremented by NData to maintain consistency across different values of this parameter.
	SlowCtr int32 `` /* 186-byte string literal not displayed */

	// synaptic calcium counter, which drives the CaUpT synaptic value to optimize updating of this computationally expensive factor. It is incremented by 1 for each cycle, and reset at the SlowInterval, at which point the synaptic calcium values are all reset.
	SynCaCtr float32 `` /* 274-byte string literal not displayed */

	// [view: inline] indexes and sizes of current network
	NetIdxs NetIdxs `view:"inline" desc:"indexes and sizes of current network"`

	// [view: -] stride offsets for accessing neuron variables
	NeuronVars NeuronVarStrides `view:"-" desc:"stride offsets for accessing neuron variables"`

	// [view: -] stride offsets for accessing neuron average variables
	NeuronAvgVars NeuronAvgVarStrides `view:"-" desc:"stride offsets for accessing neuron average variables"`

	// [view: -] stride offsets for accessing neuron indexes
	NeuronIdxs NeuronIdxStrides `view:"-" desc:"stride offsets for accessing neuron indexes"`

	// [view: -] stride offsets for accessing synapse variables
	SynapseVars SynapseVarStrides `view:"-" desc:"stride offsets for accessing synapse variables"`

	// [view: -] stride offsets for accessing synapse Ca variables
	SynapseCaVars SynapseCaStrides `view:"-" desc:"stride offsets for accessing synapse Ca variables"`

	// [view: -] stride offsets for accessing synapse indexes
	SynapseIdxs SynapseIdxStrides `view:"-" desc:"stride offsets for accessing synapse indexes"`

	// random counter -- incremented by maximum number of possible random numbers generated per cycle, regardless of how many are actually used -- this is shared across all layers so must encompass all possible param settings.
	RandCtr slrand.Counter `` /* 226-byte string literal not displayed */
	// contains filtered or unexported fields
}

type CorSimStats struct {

	// correlation (centered cosine aka normalized dot product) activation difference between ActP and ActM on this alpha-cycle for this layer -- computed by CorSimFmActs called by PlusPhase
	Cor float32 `` /* 203-byte string literal not displayed */

	// running average of correlation similarity between ActP and ActM -- computed with CorSim.Tau time constant in PlusPhase
	Avg float32 `` /* 138-byte string literal not displayed */

	// running variance of correlation similarity between ActP and ActM -- computed with CorSim.Tau time constant in PlusPhase
	Var float32 `` /* 139-byte string literal not displayed */
	// contains filtered or unexported fields
}

type DAModTypes int32

type DecayParams struct {

	// [def: 0,0.2,0.5,1] [min: 0] [max: 1] proportion to decay most activation state variables toward initial values at start of every ThetaCycle (except those controlled separately below) -- if 1 it is effectively equivalent to full clear, resetting other derived values.  ISI is reset every AlphaCycle to get a fresh sample of activations (doesn't affect direct computation -- only readout).
	Act float32 `` /* 391-byte string literal not displayed */

	// [def: 0,0.6] [min: 0] [max: 1] proportion to decay long-lasting conductances, NMDA and GABA, and also the dendritic membrane potential -- when using random stimulus order, it is important to decay this significantly to allow a fresh start -- but set Act to 0 to enable ongoing activity to keep neurons in their sensitive regime.
	Glong float32 `` /* 332-byte string literal not displayed */

	// [def: 0] [min: 0] [max: 1] decay of afterhyperpolarization currents, including mAHP, sAHP, and KNa -- has a separate decay because often useful to have this not decay at all even if decay is on.
	AHP float32 `` /* 198-byte string literal not displayed */

	// [def: 0] [min: 0] [max: 1] decay of Ca variables driven by spiking activity used in learning: CaSpk* and Ca* variables. These are typically not decayed but may need to be in some situations.
	LearnCa float32 `` /* 194-byte string literal not displayed */

	// decay layer at end of ThetaCycle when there is a global reward -- true by default for PTPred, PTMaint and PFC Super layers
	OnRew slbool.Bool `` /* 129-byte string literal not displayed */
	// contains filtered or unexported fields
}

type DendParams struct {

	// [def: 0.2,0.5] dendrite-specific strength multiplier of the exponential spiking drive on Vm -- e.g., .5 makes it half as strong as at the soma (which uses Gbar.L as a strength multiplier per the AdEx standard model)
	GbarExp float32 `` /* 221-byte string literal not displayed */

	// [def: 3,6] dendrite-specific conductance of Kdr delayed rectifier currents, used to reset membrane potential for dendrite -- applied for Tr msec
	GbarR float32 `` /* 150-byte string literal not displayed */

	// [def: 0,2] SST+ somatostatin positive slow spiking inhibition level specifically affecting dendritic Vm (VmDend) -- this is important for countering a positive feedback loop from NMDA getting stronger over the course of learning -- also typically requires SubMean = 1 for TrgAvgAct and learning to fully counter this feedback loop.
	SSGi float32 `` /* 337-byte string literal not displayed */

	// set automatically based on whether this layer has any recv projections that have a GType conductance type of Modulatory -- if so, then multiply GeSyn etc by GModSyn
	HasMod slbool.Bool `` /* 184-byte string literal not displayed */

	// multiplicative gain factor on the total modulatory input -- this can also be controlled by the PrjnScale.Abs factor on ModulatoryG inputs, but it is convenient to be able to control on the layer as well.
	ModGain float32 `` /* 210-byte string literal not displayed */

	// baseline modulatory level for modulatory effects -- net modulation is ModBase + ModGain * GModSyn
	ModBase float32 `desc:"baseline modulatory level for modulatory effects -- net modulation is ModBase + ModGain * GModSyn"`
	// contains filtered or unexported fields
}

type DriveParams struct {

	// minimum effective drive value -- this is an automatic baseline ensuring that a positive US results in at least some minimal level of reward.  Unlike Base values, this is not reflected in the activity of the drive values -- applies at the time of reward calculation as a minimum baseline.
	DriveMin float32 `` /* 294-byte string literal not displayed */

	// baseline levels for each drive -- what they naturally trend toward in the absence of any input.  Set inactive drives to 0 baseline, active ones typically elevated baseline (0-1 range).
	Base []float32 `` /* 191-byte string literal not displayed */

	// time constants in ThetaCycle (trial) units for natural update toward Base values -- 0 values means no natural update.
	Tau []float32 `desc:"time constants in ThetaCycle (trial) units for natural update toward Base values -- 0 values means no natural update."`

	// decrement in drive value when US is consumed, thus partially satisfying the drive -- positive values are subtracted from current Drive value.
	Satisfaction []float32 `` /* 148-byte string literal not displayed */

	// [view: -] 1/Tau
	Dt []float32 `view:"-" desc:"1/Tau"`
}

type DtParams struct {

	// [def: 1,0.5] [min: 0] overall rate constant for numerical integration, for all equations at the unit level -- all time constants are specified in millisecond units, with one cycle = 1 msec -- if you instead want to make one cycle = 2 msec, you can do this globally by setting this integ value to 2 (etc).  However, stability issues will likely arise if you go too high.  For improved numerical stability, you may even need to reduce this value to 0.5 or possibly even lower (typically however this is not necessary).  MUST also coordinate this with network.time_inc variable to ensure that global network.time reflects simulated time accurately
	Integ float32 `` /* 649-byte string literal not displayed */

	// [def: 2.81] [min: 1] membrane potential time constant in cycles, which should be milliseconds typically (tau is roughly how long it takes for value to change significantly -- 1.4x the half-life) -- reflects the capacitance of the neuron in principle -- biological default for AdEx spiking model C = 281 pF = 2.81 normalized
	VmTau float32 `` /* 328-byte string literal not displayed */

	// [def: 5] [min: 1] dendritic membrane potential time constant in cycles, which should be milliseconds typically (tau is roughly how long it takes for value to change significantly -- 1.4x the half-life) -- reflects the capacitance of the neuron in principle -- biological default for AdEx spiking model C = 281 pF = 2.81 normalized
	VmDendTau float32 `` /* 335-byte string literal not displayed */

	// [def: 2] [min: 1] number of integration steps to take in computing new Vm value -- this is the one computation that can be most numerically unstable so taking multiple steps with proportionally smaller dt is beneficial
	VmSteps int32 `` /* 223-byte string literal not displayed */

	// [def: 5] [min: 1] time constant for decay of excitatory AMPA receptor conductance.
	GeTau float32 `def:"5" min:"1" desc:"time constant for decay of excitatory AMPA receptor conductance."`

	// [def: 7] [min: 1] time constant for decay of inhibitory GABAa receptor conductance.
	GiTau float32 `def:"7" min:"1" desc:"time constant for decay of inhibitory GABAa receptor conductance."`

	// [def: 40] [min: 1] time constant for integrating values over timescale of an individual input state (e.g., roughly 200 msec -- theta cycle), used in computing ActInt, GeInt from Ge, and GiInt from GiSyn -- this is used for scoring performance, not for learning, in cycles, which should be milliseconds typically (tau is roughly how long it takes for value to change significantly -- 1.4x the half-life),
	IntTau float32 `` /* 409-byte string literal not displayed */

	// [def: 20] [min: 1] time constant for integrating slower long-time-scale averages, such as nrn.ActAvg, Pool.ActsMAvg, ActsPAvg -- computed in NewState when a new input state is present (i.e., not msec but in units of a theta cycle) (tau is roughly how long it takes for value to change significantly) -- set lower for smaller models
	LongAvgTau float32 `` /* 336-byte string literal not displayed */

	// [def: 10] [min: 0] cycle to start updating the SpkMaxCa, SpkMax values within a theta cycle -- early cycles often reflect prior state
	MaxCycStart int32 `` /* 138-byte string literal not displayed */

	// [view: -] nominal rate = Integ / tau
	VmDt float32 `view:"-" json:"-" xml:"-" desc:"nominal rate = Integ / tau"`

	// [view: -] nominal rate = Integ / tau
	VmDendDt float32 `view:"-" json:"-" xml:"-" desc:"nominal rate = Integ / tau"`

	// [view: -] 1 / VmSteps
	DtStep float32 `view:"-" json:"-" xml:"-" desc:"1 / VmSteps"`

	// [view: -] rate = Integ / tau
	GeDt float32 `view:"-" json:"-" xml:"-" desc:"rate = Integ / tau"`

	// [view: -] rate = Integ / tau
	GiDt float32 `view:"-" json:"-" xml:"-" desc:"rate = Integ / tau"`

	// [view: -] rate = Integ / tau
	IntDt float32 `view:"-" json:"-" xml:"-" desc:"rate = Integ / tau"`

	// [view: -] rate = 1 / tau
	LongAvgDt float32 `view:"-" json:"-" xml:"-" desc:"rate = 1 / tau"`
}

type GPLayerTypes int32

type GPParams struct {

	// [view: inline] [viewif: LayType=GPLayer] type of GP Layer -- must set during config using SetBuildConfig of GPType.
	GPType GPLayerTypes `viewif:"LayType=GPLayer" view:"inline" desc:"type of GP Layer -- must set during config using SetBuildConfig of GPType."`
	// contains filtered or unexported fields
}

type GPU struct {

	// if true, actually use the GPU
	On          bool `desc:"if true, actually use the GPU"`
	RecFunTimes bool `` /* 284-byte string literal not displayed */

	// if true, process each cycle one at a time.  Otherwise, 10 cycles at a time are processed in one batch.
	CycleByCycle bool `desc:"if true, process each cycle one at a time.  Otherwise, 10 cycles at a time are processed in one batch."`

	// [view: -] the network we operate on -- we live under this net
	Net *Network `view:"-" desc:"the network we operate on -- we live under this net"`

	// [view: -] the context we use
	Ctx *Context `view:"-" desc:"the context we use"`

	// [view: -] the vgpu compute system
	Sys *vgpu.System `view:"-" desc:"the vgpu compute system"`

	// [view: -] VarSet = 0: the uniform LayerParams
	Params *vgpu.VarSet `view:"-" desc:"VarSet = 0: the uniform LayerParams"`

	// [view: -] VarSet = 1: the storage indexes and PrjnParams
	Idxs *vgpu.VarSet `view:"-" desc:"VarSet = 1: the storage indexes and PrjnParams"`

	// [view: -] VarSet = 2: the Storage buffer for RW state structs and neuron floats
	Structs *vgpu.VarSet `view:"-" desc:"VarSet = 2: the Storage buffer for RW state structs and neuron floats"`

	// [view: -] Varset = 3: the Storage buffer for synapses
	Syns *vgpu.VarSet `view:"-" desc:"Varset = 3: the Storage buffer for synapses"`

	// [view: -] Varset = 4: the Storage buffer for SynCa banks
	SynCas *vgpu.VarSet `view:"-" desc:"Varset = 4: the Storage buffer for SynCa banks"`

	// [view: -] for sequencing commands
	Semaphores map[string]vk.Semaphore `view:"-" desc:"for sequencing commands"`

	// [def: 64] [view: -] number of warp threads -- typically 64 -- must update all hlsl files if changed!
	NThreads int `view:"-" inactive:"-" def:"64" desc:"number of warp threads -- typically 64 -- must update all hlsl files if changed!"`

	// [view: -] maximum number of bytes per individual storage buffer element, from GPUProps.Limits.MaxStorageBufferRange
	MaxBufferBytes uint32 `view:"-" desc:"maximum number of bytes per individual storage buffer element, from GPUProps.Limits.MaxStorageBufferRange"`

	// [view: -] bank of floats for GPU access
	SynapseCas0 []float32 `view:"-" desc:"bank of floats for GPU access"`

	// [view: -] bank of floats for GPU access
	SynapseCas1 []float32 `view:"-" desc:"bank of floats for GPU access"`

	// [view: -] bank of floats for GPU access
	SynapseCas2 []float32 `view:"-" desc:"bank of floats for GPU access"`

	// [view: -] bank of floats for GPU access
	SynapseCas3 []float32 `view:"-" desc:"bank of floats for GPU access"`

	// [view: -] bank of floats for GPU access
	SynapseCas4 []float32 `view:"-" desc:"bank of floats for GPU access"`

	// [view: -] bank of floats for GPU access
	SynapseCas5 []float32 `view:"-" desc:"bank of floats for GPU access"`

	// [view: -] bank of floats for GPU access
	SynapseCas6 []float32 `view:"-" desc:"bank of floats for GPU access"`

	// [view: -] bank of floats for GPU access
	SynapseCas7 []float32 `view:"-" desc:"bank of floats for GPU access"`

	// [view: -] tracks var binding
	DidBind map[string]bool `view:"-" desc:"tracks var binding"`
}

type GScaleVals struct {

	// scaling factor for integrating synaptic input conductances (G's), originally computed as a function of sending layer activity and number of connections, and typically adapted from there -- see Prjn.PrjnScale adapt params
	Scale float32 `` /* 240-byte string literal not displayed */

	// normalized relative proportion of total receiving conductance for this projection: PrjnScale.Rel / sum(PrjnScale.Rel across relevant prjns)
	Rel float32 `` /* 159-byte string literal not displayed */
	// contains filtered or unexported fields
}

type GiveUpParams struct {

	// [def: 1] threshold factor that multiplies integrated pvNeg value to establish a threshold for whether the integrated pvPos value is good enough to drive overall net positive reward
	NegThr float32 `` /* 186-byte string literal not displayed */

	// [def: 10] multiplier on pos - neg for logistic probability function -- higher gain values produce more binary give up behavior and lower values produce more graded stochastic behavior around the threshold
	Gain float32 `` /* 210-byte string literal not displayed */

	// minimum estimated PVpos value -- deals with any errors in the estimation process to make sure that erroneous GiveUp doesn't happen.
	MinPVposEst float32 `` /* 138-byte string literal not displayed */
}

type GlobalVars int32

type HipConfig struct {

	// size of EC2
	EC2Size evec.Vec2i `nest:"+" desc:"size of EC2"`

	// number of EC3 pools (outer dimension)
	EC3NPool evec.Vec2i `nest:"+" desc:"number of EC3 pools (outer dimension)"`

	// number of neurons in one EC3 pool
	EC3NNrn evec.Vec2i `nest:"+" desc:"number of neurons in one EC3 pool"`

	// number of neurons in one CA1 pool
	CA1NNrn evec.Vec2i `nest:"+" desc:"number of neurons in one CA1 pool"`

	// size of CA3
	CA3Size evec.Vec2i `nest:"+" desc:"size of CA3"`

	// [def: 2.236] size of DG / CA3
	DGRatio float32 `def:"2.236" desc:"size of DG / CA3"`

	// [def: 0.1] percent connectivity from EC3 to EC2
	EC3ToEC2PCon float32 `def:"0.1" desc:"percent connectivity from EC3 to EC2"`

	// [def: 0.25] percent connectivity from EC2 to DG
	EC2ToDGPCon float32 `def:"0.25" desc:"percent connectivity from EC2 to DG"`

	// [def: 0.25] percent connectivity from EC2 to CA3
	EC2ToCA3PCon float32 `def:"0.25" desc:"percent connectivity from EC2 to CA3"`

	// [def: 0.25] percent connectivity from CA3 to CA1
	CA3ToCA1PCon float32 `def:"0.25" desc:"percent connectivity from CA3 to CA1"`

	// [def: 0.02] percent connectivity into CA3 from DG
	DGToCA3PCon float32 `def:"0.02" desc:"percent connectivity into CA3 from DG"`

	// lateral radius of connectivity in EC2
	EC2LatRadius int `desc:"lateral radius of connectivity in EC2"`

	// lateral gaussian sigma in EC2 for how quickly weights fall off with distance
	EC2LatSigma float32 `desc:"lateral gaussian sigma in EC2 for how quickly weights fall off with distance"`

	// [def: 1] proportion of full mossy fiber strength (PrjnScale.Rel) for CA3 EDL in training, applied at the start of a trial to reduce DG -> CA3 strength.  1 = fully reduce strength, .5 = 50% reduction, etc
	MossyDelta float32 `` /* 209-byte string literal not displayed */

	// [def: 0.75] proportion of full mossy fiber strength (PrjnScale.Rel) for CA3 EDL in testing, applied during 2nd-3rd quarters to reduce DG -> CA3 strength.  1 = fully reduce strength, .5 = 50% reduction, etc
	MossyDeltaTest float32 `` /* 211-byte string literal not displayed */

	// [def: 0.9] low theta modulation value for temporal difference EDL -- sets PrjnScale.Rel on CA1 <-> EC prjns consistent with Theta phase model
	ThetaLow float32 `` /* 147-byte string literal not displayed */

	// [def: 1] high theta modulation value for temporal difference EDL -- sets PrjnScale.Rel on CA1 <-> EC prjns consistent with Theta phase model
	ThetaHigh float32 `` /* 146-byte string literal not displayed */

	// [def: true] flag for clamping the EC5 from EC5ClampSrc
	EC5Clamp bool `def:"true" desc:"flag for clamping the EC5 from EC5ClampSrc"`

	// [def: EC3] source layer for EC5 clamping activations in the plus phase -- biologically it is EC3 but can use an Input layer if available
	EC5ClampSrc string `` /* 142-byte string literal not displayed */

	// [def: true] clamp the EC5 from EC5ClampSrc during testing as well as training -- this will overwrite any target values that might be used in stats (e.g., in the basic hip example), so it must be turned off there
	EC5ClampTest bool `` /* 217-byte string literal not displayed */

	// [def: 0.1] threshold for binarizing EC5 clamp values -- any value above this is clamped to 1, else 0 -- helps produce a cleaner learning signal.  Set to 0 to not perform any binarization.
	EC5ClampThr float32 `` /* 193-byte string literal not displayed */
}

type HipPrjnParams struct {

	// [def: 0] Hebbian learning proportion
	Hebb float32 `def:"0" desc:"Hebbian learning proportion"`

	// [def: 1] EDL proportion
	Err float32 `def:"1" desc:"EDL proportion"`

	// [def: 0.4:0.8] [min: 0] [max: 1] proportion of correction to apply to sending average activation for hebbian learning component (0=none, 1=all, .5=half, etc)
	SAvgCor float32 `` /* 161-byte string literal not displayed */

	// [def: 0.01] [min: 0] threshold of sending average activation below which learning does not occur (prevents learning when there is no input)
	SAvgThr float32 `` /* 144-byte string literal not displayed */

	// [def: 0.1] [min: 0] sending layer Nominal (need to manually set it to be the same as the sending layer)
	SNominal float32 `def:"0.1" min:"0" desc:"sending layer Nominal (need to manually set it to be the same as the sending layer)"`
	// contains filtered or unexported fields
}

type InhibParams struct {

	// [view: inline] layer-level and pool-level average activation initial values and updating / adaptation thereof -- initial values help determine initial scaling factors.
	ActAvg ActAvgParams `` /* 173-byte string literal not displayed */

	// [view: inline] inhibition across the entire layer -- inputs generally use Gi = 0.8 or 0.9, 1.3 or higher for sparse layers.  If the layer has sub-pools (4D shape) then this is effectively between-pool inhibition.
	Layer fsfffb.GiParams `` /* 218-byte string literal not displayed */

	// [view: inline] inhibition within sub-pools of units, for layers with 4D shape -- almost always need this if the layer has pools.
	Pool fsfffb.GiParams `` /* 134-byte string literal not displayed */
}

type LDTParams struct {

	// [def: 0.05] threshold per input source, on absolute value (magnitude), to count as a significant reward event, which then drives maximal ACh -- set to 0 to disable this nonlinear behavior
	SrcThr float32 `` /* 193-byte string literal not displayed */

	// [def: true] use the global Context.NeuroMod.HasRew flag -- if there is some kind of external reward being given, then ACh goes to 1, else 0 for this component
	Rew slbool.Bool `` /* 164-byte string literal not displayed */

	// [def: 2] extent to which active maintenance (via Context.NeuroMod.NotMaint PTNotMaintLayer activity) inhibits ACh signals -- when goal engaged, distractability is lower.
	MaintInhib float32 `` /* 175-byte string literal not displayed */

	// [def: 0.4] maximum NeuroMod.NotMaint activity for computing Maint as 1-NotMaint -- when NotMaint is >= NotMaintMax, then Maint = 0.
	NotMaintMax float32 `` /* 137-byte string literal not displayed */

	// idx of Layer to get max activity from -- set during Build from BuildConfig SrcLay1Name if present -- -1 if not used
	SrcLay1Idx int32 `` /* 135-byte string literal not displayed */

	// idx of Layer to get max activity from -- set during Build from BuildConfig SrcLay2Name if present -- -1 if not used
	SrcLay2Idx int32 `` /* 135-byte string literal not displayed */

	// idx of Layer to get max activity from -- set during Build from BuildConfig SrcLay3Name if present -- -1 if not used
	SrcLay3Idx int32 `` /* 135-byte string literal not displayed */

	// idx of Layer to get max activity from -- set during Build from BuildConfig SrcLay4Name if present -- -1 if not used
	SrcLay4Idx int32 `` /* 135-byte string literal not displayed */
}