Synapses

Synapses#

A number of synaptic ComponentTypes for use in NeuroML 2 documents, e.g. expOneSynapse, expTwoSynapse, blockingPlasticSynapse. These extend the baseSynapse ComponentType. Also defined continuously transmitting synapses, e.g. gapJunction and gradedSynapse.

Original ComponentType definitions: Synapses.xml. Schema against which NeuroML based on these should be valid: NeuroML_v2.3.xsd. Generated on 14/08/24 from this commit. Please file any issues or questions at the issue tracker here.

baseSynapse#

extends basePointCurrent

Base type for all synapses, i.e. ComponentTypes which produce a current ( dimension current ) and change Dynamics in response to an incoming event.

Bioportal entry for Computational Neuroscience Ontology related to baseSynapse.

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

in

Direction: in

 
<xs:complexType name="BaseSynapse">
  <xs:complexContent>
    <xs:extension base="Standalone">
      <xs:attribute name="neuroLexId" type="NeuroLexId" use="optional"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import BaseSynapse
from neuroml.utils import component_factory

variable = component_factory(
    BaseSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    extensiontype_=None,
)

baseVoltageDepSynapse#

extends baseSynapse

Base type for synapses with a dependence on membrane potential.

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

v

The current may vary with the voltage exposed by the ComponentType on which this is placed

voltage

in

(from baseSynapse)

Direction: in

 
<xs:complexType name="BaseVoltageDepSynapse">
  <xs:complexContent>
    <xs:extension base="BaseSynapse">

            </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import BaseVoltageDepSynapse
from neuroml.utils import component_factory

variable = component_factory(
    BaseVoltageDepSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    extensiontype_=None,
)

baseSynapseDL#

extends baseVoltageDepPointCurrentDL

Base type for all synapses, i.e. ComponentTypes which produce a dimensionless current and change Dynamics in response to an incoming event.

Bioportal entry for Computational Neuroscience Ontology related to baseSynapseDL.

I

The total (time varying) current produced by this ComponentType (from basePointCurrentDL)

Dimensionless

V

The current may vary with the dimensionless voltage exposed by the ComponentType on which this is placed (from baseVoltageDepPointCurrentDL)

Dimensionless

baseCurrentBasedSynapse#

extends baseSynapse

Synapse model which produces a synaptic current.

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

in

(from baseSynapse)

Direction: in

 
<xs:complexType name="BaseCurrentBasedSynapse">
  <xs:complexContent>
    <xs:extension base="BaseSynapse">

            </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import BaseCurrentBasedSynapse
from neuroml.utils import component_factory

variable = component_factory(
    BaseCurrentBasedSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    extensiontype_=None,
)

alphaCurrentSynapse#

extends baseCurrentBasedSynapse

Alpha current synapse: rise time and decay time are both tau..

ibase

Baseline current increase after receiving a spike

current

tau

Time course for rise and decay

time

weight (default: 1)

Dimensionless

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

in

(from baseSynapse)

Direction: in
State Variables

I: current

J: current

On Start

I = 0

J = 0

On Events

EVENT IN on port: in

   J = J + weight * ibase

Derived Variables

i = I (exposed as i)

Time Derivatives

d I /dt = (2.7182818284590451*J - I)/tau

d J /dt = -J/tau

<xs:complexType name="AlphaCurrentSynapse">
  <xs:complexContent>
    <xs:extension base="BaseCurrentBasedSynapse">
      <xs:attribute name="tau" type="Nml2Quantity_time" use="required"/>
      <xs:attribute name="ibase" type="Nml2Quantity_current" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import AlphaCurrentSynapse
from neuroml.utils import component_factory

variable = component_factory(
    AlphaCurrentSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    tau: 'a Nml2Quantity_time (required)' = None,
    ibase: 'a Nml2Quantity_current (required)' = None,
)

baseConductanceBasedSynapse#

extends baseVoltageDepSynapse

Synapse model which exposes a conductance g in addition to producing a current. Not necessarily ohmic!!

Bioportal entry for Computational Neuroscience Ontology related to baseConductanceBasedSynapse.

erev

Reversal potential of the synapse

voltage

gbase

Baseline conductance, generally the maximum conductance following a single spike

conductance

g

Time varying conductance through the synapse

conductance

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

v

The current may vary with the voltage exposed by the ComponentType on which this is placed (from baseVoltageDepSynapse)

voltage

in

(from baseSynapse)

Direction: in

 
<xs:complexType name="BaseConductanceBasedSynapse">
  <xs:complexContent>
    <xs:extension base="BaseVoltageDepSynapse">
      <xs:attribute name="gbase" type="Nml2Quantity_conductance" use="required"/>
      <xs:attribute name="erev" type="Nml2Quantity_voltage" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import BaseConductanceBasedSynapse
from neuroml.utils import component_factory

variable = component_factory(
    BaseConductanceBasedSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    gbase: 'a Nml2Quantity_conductance (required)' = None,
    erev: 'a Nml2Quantity_voltage (required)' = None,
    extensiontype_=None,
)

baseConductanceBasedSynapseTwo#

extends baseVoltageDepSynapse

Synapse model suited for a sum of two expTwoSynapses which exposes a conductance g in addition to producing a current. Not necessarily ohmic!!

Bioportal entry for Computational Neuroscience Ontology related to baseConductanceBasedSynapseTwo.

erev

Reversal potential of the synapse

voltage

gbase1

Baseline conductance 1

conductance

gbase2

Baseline conductance 2

conductance

g

Time varying conductance through the synapse

conductance

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

v

The current may vary with the voltage exposed by the ComponentType on which this is placed (from baseVoltageDepSynapse)

voltage

in

(from baseSynapse)

Direction: in

 
<xs:complexType name="BaseConductanceBasedSynapseTwo">
  <xs:complexContent>
    <xs:extension base="BaseVoltageDepSynapse">
      <xs:attribute name="gbase1" type="Nml2Quantity_conductance" use="required"/>
      <xs:attribute name="gbase2" type="Nml2Quantity_conductance" use="required"/>
      <xs:attribute name="erev" type="Nml2Quantity_voltage" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import BaseConductanceBasedSynapseTwo
from neuroml.utils import component_factory

variable = component_factory(
    BaseConductanceBasedSynapseTwo,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    gbase1: 'a Nml2Quantity_conductance (required)' = None,
    gbase2: 'a Nml2Quantity_conductance (required)' = None,
    erev: 'a Nml2Quantity_voltage (required)' = None,
    extensiontype_=None,
)

expOneSynapse#

extends baseConductanceBasedSynapse

Ohmic synapse model whose conductance rises instantaneously by ( gbase * weight ) on receiving an event, and which decays exponentially to zero with time course tauDecay.

erev

Reversal potential of the synapse (from baseConductanceBasedSynapse)

voltage

gbase

Baseline conductance, generally the maximum conductance following a single spike (from baseConductanceBasedSynapse)

conductance

tauDecay

Time course of decay

time

weight (default: 1)

Dimensionless

g

Time varying conductance through the synapse (from baseConductanceBasedSynapse)

conductance

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

v

The current may vary with the voltage exposed by the ComponentType on which this is placed (from baseVoltageDepSynapse)

voltage

in

(from baseSynapse)

Direction: in
State Variables

g: conductance  (exposed as g)

On Start

g = 0

On Events

EVENT IN on port: in

   g = g + (weight * gbase)

Derived Variables

i = g * (erev - v) (exposed as i)

Time Derivatives

d g /dt = -g / tauDecay

<xs:complexType name="ExpOneSynapse">
  <xs:complexContent>
    <xs:extension base="BaseConductanceBasedSynapse">
      <xs:attribute name="tauDecay" type="Nml2Quantity_time" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import ExpOneSynapse
from neuroml.utils import component_factory

variable = component_factory(
    ExpOneSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    gbase: 'a Nml2Quantity_conductance (required)' = None,
    erev: 'a Nml2Quantity_voltage (required)' = None,
    tau_decay: 'a Nml2Quantity_time (required)' = None,
)

<expOneSynapse id="syn1" gbase="5nS" erev="0mV" tauDecay="3ms"/>

<expOneSynapse id="syn2" gbase="10nS" erev="0mV" tauDecay="2ms"/>

<expOneSynapse id="syn1" gbase="5nS" erev="0mV" tauDecay="3ms"/>

alphaSynapse#

extends baseConductanceBasedSynapse

Ohmic synapse model where rise time and decay time are both tau. Max conductance reached during this time ( assuming zero conductance before ) is gbase * weight..

erev

Reversal potential of the synapse (from baseConductanceBasedSynapse)

voltage

gbase

Baseline conductance, generally the maximum conductance following a single spike (from baseConductanceBasedSynapse)

conductance

tau

Time course of rise/decay

time

weight (default: 1)

Dimensionless

g

Time varying conductance through the synapse (from baseConductanceBasedSynapse)

conductance

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

v

The current may vary with the voltage exposed by the ComponentType on which this is placed (from baseVoltageDepSynapse)

voltage

in

(from baseSynapse)

Direction: in
State Variables

g: conductance  (exposed as g)

A: conductance

On Start

g = 0

A = 0

On Events

EVENT IN on port: in

   A = A + (gbase*weight)

Derived Variables

i = g * (erev - v) (exposed as i)

Time Derivatives

d g /dt = (2.7182818284590451 * A - g)/tau

d A /dt = -A / tau

<xs:complexType name="AlphaSynapse">
  <xs:complexContent>
    <xs:extension base="BaseConductanceBasedSynapse">
      <xs:attribute name="tau" type="Nml2Quantity_time" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import AlphaSynapse
from neuroml.utils import component_factory

variable = component_factory(
    AlphaSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    gbase: 'a Nml2Quantity_conductance (required)' = None,
    erev: 'a Nml2Quantity_voltage (required)' = None,
    tau: 'a Nml2Quantity_time (required)' = None,
)

<alphaSynapse id="synalpha" gbase="0.5nS" erev="0mV" tau="2ms">
    <notes>An alpha synapse with time for rise equal to decay.</notes>
</alphaSynapse>

expTwoSynapse#

extends baseConductanceBasedSynapse

Ohmic synapse model whose conductance waveform on receiving an event has a rise time of tauRise and a decay time of tauDecay. Max conductance reached during this time ( assuming zero conductance before ) is gbase * weight..

erev

Reversal potential of the synapse (from baseConductanceBasedSynapse)

voltage

gbase

Baseline conductance, generally the maximum conductance following a single spike (from baseConductanceBasedSynapse)

conductance

tauDecay

time

tauRise

time

peakTime

time

   peakTime = log(tauDecay / tauRise) * (tauRise * tauDecay)/(tauDecay - tauRise)

waveformFactor

Dimensionless

   waveformFactor = 1 / (-exp(-peakTime / tauRise) + exp(-peakTime / tauDecay))

weight (default: 1)

Dimensionless

g

Time varying conductance through the synapse (from baseConductanceBasedSynapse)

conductance

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

v

The current may vary with the voltage exposed by the ComponentType on which this is placed (from baseVoltageDepSynapse)

voltage

in

(from baseSynapse)

Direction: in
State Variables

A: Dimensionless

B: Dimensionless

On Start

A = 0

B = 0

On Events

EVENT IN on port: in

   A = A + (weight * waveformFactor)

   B = B + (weight * waveformFactor)

Derived Variables

g = gbase * (B - A) (exposed as g)

i = g * (erev - v) (exposed as i)

Time Derivatives

d A /dt = -A / tauRise

d B /dt = -B / tauDecay

<xs:complexType name="ExpTwoSynapse">
  <xs:complexContent>
    <xs:extension base="BaseConductanceBasedSynapse">
      <xs:attribute name="tauDecay" type="Nml2Quantity_time" use="required"/>
      <xs:attribute name="tauRise" type="Nml2Quantity_time" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import ExpTwoSynapse
from neuroml.utils import component_factory

variable = component_factory(
    ExpTwoSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    gbase: 'a Nml2Quantity_conductance (required)' = None,
    erev: 'a Nml2Quantity_voltage (required)' = None,
    tau_decay: 'a Nml2Quantity_time (required)' = None,
    tau_rise: 'a Nml2Quantity_time (required)' = None,
    extensiontype_=None,
)

<expTwoSynapse id="AMPA" gbase="0.5nS" erev="0mV" tauRise="1ms" tauDecay="2ms"/>

<expTwoSynapse id="synInput" gbase="8nS" erev="20mV" tauRise="1ms" tauDecay="5ms"/>

<expTwoSynapse id="synInputFast" gbase="1nS" erev="20mV" tauRise="0.2ms" tauDecay="1ms"/>

expThreeSynapse#

extends baseConductanceBasedSynapseTwo

Ohmic synapse similar to expTwoSynapse but consisting of two components that can differ in decay times and max conductances but share the same rise time.

erev

Reversal potential of the synapse (from baseConductanceBasedSynapseTwo)

voltage

gbase1

Baseline conductance 1 (from baseConductanceBasedSynapseTwo)

conductance

gbase2

Baseline conductance 2 (from baseConductanceBasedSynapseTwo)

conductance

tauDecay1

time

tauDecay2

time

tauRise

time

peakTime1

time

   peakTime1 = log(tauDecay1 / tauRise) * (tauRise * tauDecay1)/(tauDecay1 - tauRise)

peakTime2

time

   peakTime2 = log(tauDecay2 / tauRise) * (tauRise * tauDecay2)/(tauDecay2 - tauRise)

waveformFactor1

Dimensionless

   waveformFactor1 = 1 / (-exp(-peakTime1 / tauRise) + exp(-peakTime1 / tauDecay1))

waveformFactor2

Dimensionless

   waveformFactor2 = 1 / (-exp(-peakTime2 / tauRise) + exp(-peakTime2 / tauDecay2))

weight (default: 1)

Dimensionless

g

Time varying conductance through the synapse (from baseConductanceBasedSynapseTwo)

conductance

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

v

The current may vary with the voltage exposed by the ComponentType on which this is placed (from baseVoltageDepSynapse)

voltage

in

(from baseSynapse)

Direction: in
State Variables

A: Dimensionless

B: Dimensionless

C: Dimensionless

On Start

A = 0

B = 0

C = 0

On Events

EVENT IN on port: in

   A = A + (gbase1weight * waveformFactor1 + gbase2weight*waveformFactor2 )/(gbase1+gbase2)

   B = B + (weight * waveformFactor1)

   C = C + (weight * waveformFactor2)

Derived Variables

g = gbase1*(B - A) + gbase2*(C-A) (exposed as g)

i = g * (erev - v) (exposed as i)

Time Derivatives

d A /dt = -A / tauRise

d B /dt = -B / tauDecay1

d C /dt = -C / tauDecay2

<xs:complexType name="ExpThreeSynapse">
  <xs:complexContent>
    <xs:extension base="BaseConductanceBasedSynapseTwo">
      <xs:attribute name="tauDecay1" type="Nml2Quantity_time" use="required"/>
      <xs:attribute name="tauDecay2" type="Nml2Quantity_time" use="required"/>
      <xs:attribute name="tauRise" type="Nml2Quantity_time" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import ExpThreeSynapse
from neuroml.utils import component_factory

variable = component_factory(
    ExpThreeSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    gbase1: 'a Nml2Quantity_conductance (required)' = None,
    gbase2: 'a Nml2Quantity_conductance (required)' = None,
    erev: 'a Nml2Quantity_voltage (required)' = None,
    tau_decay1: 'a Nml2Quantity_time (required)' = None,
    tau_decay2: 'a Nml2Quantity_time (required)' = None,
    tau_rise: 'a Nml2Quantity_time (required)' = None,
)

<expThreeSynapse id="synInputFastTwo" gbase1="1.5nS" tauRise="0.1ms" tauDecay1="0.7ms" gbase2="0.5nS" tauDecay2="2.5ms" erev="0mV"/>

<expThreeSynapse id="AMPA" gbase1="1.5nS" tauRise="0.1ms" tauDecay1="0.7ms" gbase2="0.5nS" tauDecay2="2.5ms" erev="0mV">
    <notes>A synapse consisting of one rise and two decay time courses.</notes>
</expThreeSynapse>

baseBlockMechanism#

Base of any ComponentType which produces a varying scaling ( or blockage ) of synaptic strength of magnitude scaling.

blockFactor

Dimensionless

voltageConcDepBlockMechanism#

extends baseBlockMechanism

Synaptic blocking mechanism which varys with membrane potential across the synapse, e.g. in NMDA receptor mediated synapses.

blockConcentration

concentration

scalingConc

concentration

scalingVolt

voltage

species

blockFactor

(from baseBlockMechanism)

Dimensionless

v

voltage
Derived Variables

blockFactor = 1/(1 + (blockConcentration / scalingConc)* exp(-1 * (v / scalingVolt))) (exposed as blockFactor)

basePlasticityMechanism#

Base plasticity mechanism.

plasticityFactor

Dimensionless

in

This is where the plasticity mechanism receives spike events from the parent synapse.

Direction: in

tsodyksMarkramDepMechanism#

extends basePlasticityMechanism

Depression-only Tsodyks-Markram model, as in Tsodyks and Markram 1997.

initReleaseProb

Dimensionless

tauRec

time

plasticityFactor

(from basePlasticityMechanism)

Dimensionless

in

This is where the plasticity mechanism receives spike events from the parent synapse. (from basePlasticityMechanism)

Direction: in
Structure

WITH parent AS a

WITH this AS b

EVENT CONNECTION from a TO b

State Variables

R: Dimensionless

On Start

R = 1

On Events

EVENT IN on port: in

   R = R * (1 - U)

Derived Variables

U = initReleaseProb

plasticityFactor = R * U (exposed as plasticityFactor)

Time Derivatives

d R /dt = (1 - R) / tauRec

tsodyksMarkramDepFacMechanism#

extends basePlasticityMechanism

Full Tsodyks-Markram STP model with both depression and facilitation, as in Tsodyks, Pawelzik and Markram 1998.

initReleaseProb

Dimensionless

tauFac

time

tauRec

time

plasticityFactor

(from basePlasticityMechanism)

Dimensionless

in

This is where the plasticity mechanism receives spike events from the parent synapse. (from basePlasticityMechanism)

Direction: in
Structure

WITH parent AS a

WITH this AS b

EVENT CONNECTION from a TO b

State Variables

R: Dimensionless

U: Dimensionless

On Start

R = 1

U = initReleaseProb

On Events

EVENT IN on port: in

   R = R * (1 - U)

   U = U + initReleaseProb * (1 - U)

Derived Variables

plasticityFactor = R * U (exposed as plasticityFactor)

Time Derivatives

d R /dt = (1 - R) / tauRec

d U /dt = (initReleaseProb - U) / tauFac

blockingPlasticSynapse#

extends expTwoSynapse

Biexponential synapse that allows for optional block and plasticity mechanisms, which can be expressed as child elements.

erev

Reversal potential of the synapse (from baseConductanceBasedSynapse)

voltage

gbase

Baseline conductance, generally the maximum conductance following a single spike (from baseConductanceBasedSynapse)

conductance

tauDecay

(from expTwoSynapse)

time

tauRise

(from expTwoSynapse)

time

peakTime

(from expTwoSynapse)

time

   peakTime = log(tauDecay / tauRise) * (tauRise * tauDecay)/(tauDecay - tauRise)

waveformFactor

(from expTwoSynapse)

Dimensionless

   waveformFactor = 1 / (-exp(-peakTime / tauRise) + exp(-peakTime / tauDecay))

plasticityMechanisms

basePlasticityMechanism

blockMechanisms

baseBlockMechanism

weight (default: 1)

Dimensionless

g

Time varying conductance through the synapse (from baseConductanceBasedSynapse)

conductance

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

v

The current may vary with the voltage exposed by the ComponentType on which this is placed (from baseVoltageDepSynapse)

voltage

in

(from baseSynapse)

Direction: in

relay

Used to relay incoming spikes to child plasticity mechanism

Direction: out
State Variables

A: Dimensionless

B: Dimensionless

On Start

A = 0

B = 0

On Events

EVENT IN on port: in

   A = A + (weight * plasticityFactor * waveformFactor)

   B = B + (weight * plasticityFactor * waveformFactor)

   EVENT OUT on port: relay

Derived Variables

plasticityFactor = plasticityMechanisms[*]->plasticityFactor(reduce method: multiply)

blockFactor = blockMechanisms[*]->blockFactor(reduce method: multiply)

g = blockFactor * gbase * (B - A) (exposed as g)

i = g * (erev - v) (exposed as i)

Time Derivatives

d A /dt = -A / tauRise

d B /dt = -B / tauDecay

<xs:complexType name="BlockingPlasticSynapse">
  <xs:complexContent>
    <xs:extension base="ExpTwoSynapse">
      <xs:sequence>
        <xs:element name="plasticityMechanism" type="PlasticityMechanism" minOccurs="0"/>
        <xs:element name="blockMechanism" type="BlockMechanism" minOccurs="0"/>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import BlockingPlasticSynapse
from neuroml.utils import component_factory

variable = component_factory(
    BlockingPlasticSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    gbase: 'a Nml2Quantity_conductance (required)' = None,
    erev: 'a Nml2Quantity_voltage (required)' = None,
    tau_decay: 'a Nml2Quantity_time (required)' = None,
    tau_rise: 'a Nml2Quantity_time (required)' = None,
    plasticity_mechanism: 'a PlasticityMechanism (optional)' = None,
    block_mechanism: 'a BlockMechanism (optional)' = None,
)

<blockingPlasticSynapse id="NMDA" gbase=".8nS" tauRise="1e-3s" tauDecay="13.3333e-3s" erev="0V">
    <blockMechanism type="voltageConcDepBlockMechanism" species="mg" blockConcentration="1.2mM" scalingConc="1.9205441817997078mM" scalingVolt="0.016129032258064516V"/>
</blockingPlasticSynapse>

<blockingPlasticSynapse id="blockStpSynDep" gbase="1nS" erev="0mV" tauRise="0.1ms" tauDecay="2ms">
    <notes>A biexponential blocking synapse, with STD.</notes>
    <plasticityMechanism type="tsodyksMarkramDepMechanism" initReleaseProb="0.5" tauRec="120 ms"/>
    <blockMechanism type="voltageConcDepBlockMechanism" species="mg" blockConcentration="1.2 mM" scalingConc="1.920544 mM" scalingVolt="16.129 mV"/>
</blockingPlasticSynapse>

<blockingPlasticSynapse id="blockStpSynDepFac" gbase="1nS" erev="0mV" tauRise="0.1ms" tauDecay="2ms">
    <notes>A biexponential blocking synapse with short term
            depression and facilitation.</notes>
    <plasticityMechanism type="tsodyksMarkramDepFacMechanism" initReleaseProb="0.5" tauRec="120 ms" tauFac="10 ms"/>
    <blockMechanism type="voltageConcDepBlockMechanism" species="mg" blockConcentration="1.2 mM" scalingConc="1.920544 mM" scalingVolt="16.129 mV"/>
</blockingPlasticSynapse>

doubleSynapse#

extends baseVoltageDepSynapse

Synapse consisting of two independent synaptic mechanisms ( e.g. AMPA-R and NMDA-R ), which can be easily colocated in connections.

synapse1Path

synapse2Path

synapse1

baseSynapse

synapse2

baseSynapse

weight (default: 1)

Dimensionless

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

v

The current may vary with the voltage exposed by the ComponentType on which this is placed (from baseVoltageDepSynapse)

voltage

in

(from baseSynapse)

Direction: in

relay

Used to relay incoming spikes to child mechanisms

Direction: out
Structure

WITH this AS a

WITH synapse1Path AS b

WITH synapse2Path AS c

CHILD INSTANCE: synapse1

CHILD INSTANCE: synapse2

EVENT CONNECTION from a TO c

EVENT CONNECTION from a TO b

State Variables

weightFactor: Dimensionless

On Events

EVENT IN on port: in

   weightFactor = weight

   EVENT OUT on port: relay

Derived Variables

i1 = synapse1->i

i2 = synapse2->i

i = weightFactor * (i1 + i2) (exposed as i)

<xs:complexType name="DoubleSynapse">
  <xs:complexContent>
    <xs:extension base="BaseVoltageDepSynapse">
      <xs:attribute name="synapse1" type="NmlId" use="required"/>
      <xs:attribute name="synapse2" type="NmlId" use="required"/>
      <xs:attribute name="synapse1Path" type="xs:string" use="required"/>
      <xs:attribute name="synapse2Path" type="xs:string" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import DoubleSynapse
from neuroml.utils import component_factory

variable = component_factory(
    DoubleSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    synapse1: 'a NmlId (required)' = None,
    synapse2: 'a NmlId (required)' = None,
    synapse1_path: 'a string (required)' = None,
    synapse2_path: 'a string (required)' = None,
)

<doubleSynapse id="AMPA_NMDA" synapse1="AMPA" synapse1Path="./AMPA" synapse2="NMDA" synapse2Path="./NMDA">
    <notes>A single "synapse" which contains both AMPA and NMDA. It is planned that the need for extra synapse1Path/synapse2Path attributes can be removed in later versions.</notes>
</doubleSynapse>

stdpSynapse#

extends expTwoSynapse

Spike timing dependent plasticity mechanism, NOTE: EXAMPLE NOT YET WORKING!!!

Bioportal entry for Computational Neuroscience Ontology related to stdpSynapse.

erev

Reversal potential of the synapse (from baseConductanceBasedSynapse)

voltage

gbase

Baseline conductance, generally the maximum conductance following a single spike (from baseConductanceBasedSynapse)

conductance

tauDecay

(from expTwoSynapse)

time

tauRise

(from expTwoSynapse)

time

tsinceRate = 1

Dimensionless

longTime = 1000s

time

peakTime

(from expTwoSynapse)

time

   peakTime = log(tauDecay / tauRise) * (tauRise * tauDecay)/(tauDecay - tauRise)

waveformFactor

(from expTwoSynapse)

Dimensionless

   waveformFactor = 1 / (-exp(-peakTime / tauRise) + exp(-peakTime / tauDecay))

M

Dimensionless

P

Dimensionless

g

Time varying conductance through the synapse (from baseConductanceBasedSynapse)

conductance

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

tsince

time

v

The current may vary with the voltage exposed by the ComponentType on which this is placed (from baseVoltageDepSynapse)

voltage

in

(from baseSynapse)

Direction: in
State Variables

A: Dimensionless

B: Dimensionless

M: Dimensionless  (exposed as M)

P: Dimensionless  (exposed as P)

tsince: time  (exposed as tsince)

On Start

A = 0

B = 0

M = 1

P = 1

tsince = longTime

On Events

EVENT IN on port: in

   A = A + waveformFactor

   B = B + waveformFactor

   tsince = 0

Derived Variables

g = gbase * (B - A) (exposed as g)

i = g * (erev - v) (exposed as i)

Time Derivatives

d A /dt = -A / tauRise

d B /dt = -B / tauDecay

d tsince /dt = tsinceRate

gapJunction#

extends baseSynapse

Gap junction/single electrical connection.

conductance

conductance

weight (default: 1)

Dimensionless

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

v

voltage

in

(from baseSynapse)

Direction: in
Derived Variables

vpeer = peer->v

i = weight * conductance * (vpeer - v) (exposed as i)

<xs:complexType name="GapJunction">
  <xs:complexContent>
    <xs:extension base="BaseSynapse">
      <xs:attribute name="conductance" type="Nml2Quantity_conductance" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import GapJunction
from neuroml.utils import component_factory

variable = component_factory(
    GapJunction,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    conductance: 'a Nml2Quantity_conductance (required)' = None,
)

<gapJunction id="gj1" conductance="10pS"/>

<gapJunction id="gj1" conductance="10pS"/>

baseGradedSynapse#

extends baseSynapse

Base type for graded synapses.

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

in

(from baseSynapse)

Direction: in

silentSynapse#

extends baseGradedSynapse

Dummy synapse which emits no current. Used as presynaptic endpoint for analog synaptic connection.

AMP = 1A

current

weight (default: 1)

Dimensionless

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

v

voltage

in

(from baseSynapse)

Direction: in
Derived Variables

vpeer = peer->v

i = 0 * AMP (exposed as i)

<xs:complexType name="SilentSynapse">
  <xs:complexContent>
    <xs:extension base="BaseSynapse">

            </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import SilentSynapse
from neuroml.utils import component_factory

variable = component_factory(
    SilentSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
)

<silentSynapse id="silent1"/>

<silentSynapse id="silent2"/>

<silentSynapse id="silent1"/>

linearGradedSynapse#

extends baseGradedSynapse

Behaves just like a one way gap junction.

conductance

conductance

weight (default: 1)

Dimensionless

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

v

voltage

in

(from baseSynapse)

Direction: in
Derived Variables

vpeer = peer->v

i = weight * conductance * (vpeer - v) (exposed as i)

<xs:complexType name="LinearGradedSynapse">
  <xs:complexContent>
    <xs:extension base="BaseSynapse">
      <xs:attribute name="conductance" type="Nml2Quantity_conductance" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import LinearGradedSynapse
from neuroml.utils import component_factory

variable = component_factory(
    LinearGradedSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    conductance: 'a Nml2Quantity_conductance (required)' = None,
)

<linearGradedSynapse id="gs1" conductance="5pS"/>

gradedSynapse#

extends baseGradedSynapse

Graded/analog synapse. Based on synapse in Methods of http://www.nature.com/neuro/journal/v7/n12/abs/nn1352.html.

Vth

The half-activation voltage of the synapse

voltage

conductance

conductance

delta

Slope of the activation curve

voltage

erev

The reversal potential of the synapse

voltage

k

Rate constant for transmitter-receptor dissociation rate

per_time

weight (default: 1)

Dimensionless

i

The total (usually time varying) current produced by this ComponentType (from basePointCurrent)

current

inf

Dimensionless

tau

time

v

voltage

in

(from baseSynapse)

Direction: in
State Variables

s: Dimensionless

On Conditions

IF (1-inf) < 1e-4 THEN

   s = inf

Derived Variables

vpeer = peer->v

inf = 1/(1 + exp((Vth - vpeer)/delta)) (exposed as inf)

tau = (1-inf)/k (exposed as tau)

i = weight * conductance * s * (erev-v) (exposed as i)

Conditional Derived Variables

IF (1-inf) > 1e-4 THEN

  s_rate = (inf - s)/tau

OTHERWISE

  s_rate = 0

Time Derivatives

d s /dt = s_rate

<xs:complexType name="GradedSynapse">
  <xs:complexContent>
    <xs:extension base="BaseSynapse">
      <xs:attribute name="conductance" type="Nml2Quantity_conductance" use="required"/>
      <xs:attribute name="delta" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="Vth" type="Nml2Quantity_voltage" use="required"/>
      <xs:attribute name="k" type="Nml2Quantity_pertime" use="required"/>
      <xs:attribute name="erev" type="Nml2Quantity_voltage" use="required"/>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

Go to the libNeuroML documentation

from neuroml import GradedSynapse
from neuroml.utils import component_factory

variable = component_factory(
    GradedSynapse,
    id: 'a NmlId (required)' = None,
    metaid: 'a MetaId (optional)' = None,
    notes: 'a string (optional)' = None,
    properties: 'list of Property(s) (optional)' = None,
    annotation: 'a Annotation (optional)' = None,
    neuro_lex_id: 'a NeuroLexId (optional)' = None,
    conductance: 'a Nml2Quantity_conductance (required)' = None,
    delta: 'a Nml2Quantity_voltage (required)' = None,
    Vth: 'a Nml2Quantity_voltage (required)' = None,
    k: 'a Nml2Quantity_pertime (required)' = None,
    erev: 'a Nml2Quantity_voltage (required)' = None,
)

<gradedSynapse id="gs2" conductance="5pS" delta="5mV" Vth="-55mV" k="0.025per_ms" erev="0mV"/>

<gradedSynapse id="gs1" conductance="0.1nS" delta="5mV" Vth="-35mV" k="0.025per_ms" erev="0mV"/>