Gap junction coupled network of striatal fast spiking interneurons (Hjorth et al. 2009)

 Download zip file 
Help downloading and running models
Accession:118389
Gap junctions between striatal FS neurons has very weak ability to synchronise spiking. Input uncorrelated between neighbouring neurons is shunted, while correlated input is not.
Reference:
1 . Hjorth J, Blackwell KT, Kotaleski JH (2009) Gap junctions between striatal fast-spiking interneurons regulate spiking activity and synchronization as a function of cortical activity. J Neurosci 29:5276-86 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network; Neuron or other electrically excitable cell; Synapse; Channel/Receptor; Dendrite;
Brain Region(s)/Organism: Basal ganglia;
Cell Type(s): Neostriatum fast spiking interneuron;
Channel(s): I A; I_K,Na;
Gap Junctions: Gap junctions;
Receptor(s):
Gene(s):
Transmitter(s): Gaba; Glutamate;
Simulation Environment: GENESIS; MATLAB;
Model Concept(s): Activity Patterns; Ion Channel Kinetics; Synchronization; Detailed Neuronal Models;
Implementer(s): Hjorth, Johannes [hjorth at csc.kth.se];
Search NeuronDB for information about:  I A; I_K,Na; Gaba; Glutamate;
/
FSGJ_Hjorth2009
FIGS5
BlueGene
FIGS
INDATA
UTDATA
a_channel.g *
a_channel_MOD.g
ampa_channel.g *
channelsMOD.g
channelsSobol.g
channelsSobolSynch.g
checkAllEqual.m *
findSpikes.m *
fsConnect.g *
fsInhomogeneNeurons.g *
fsInputFromFile.g
fsInputInject.g *
fsNeuron.g *
fsSomaOutput.g *
gaba_channel.g *
inspectTrace.m
k13_channel.g *
k13_channel_MOD.g
k3132_channel.g *
k3132_channel_MOD.g
makeAllSynapticInput.m
makeCorrPairFigure.m
makeDaughterNoise.m *
makeFSMorph.m
makeFSMorphMOD.m
makeFSrandomNetwork.m
makeShuffleCorrCrossCorr.m
makeShuntingSensitivityFigure.m
makeTrainNoise.m *
na_channel.g *
na_channel_MOD.g
poissonMaxTime.m *
protodefs.g
protodefsInhomogene.g
protodefsMOD.g
protodefsSobol.g
protodefsSobolSynch.g
readTenFSsensitivity.m
readTenFSsensitivityOLD.m
runFSsensitivity.m
runTenFSsensitivity.m
simFourFSsaveGJcur.g
writeFSMODinfo.m
writeInput.m *
writeSobolSynchInfo.m
                            
//
// fsConnect.g - Functions to connect two fs-neurons through gap-junctions
//
// Johannes Hjorth, July 2005
// hjorth@nada.kth.se
//
// Updated by Lennart Hedlund (hedlund@kth.se), July 2006
// Added reciprocalGABAinhib
//

//////////////////////////////////////////////////////////////////////////////
//
// Connects two compartments by gapjunction
//
//////////////////////////////////////////////////////////////////////////////


function connectGap(compA, compB, resistance)

    str compA
    str compB
    float resistance

    // Gap junctions go both ways...
    addmsg {compA} {compB} RAXIAL {resistance} Vm
    addmsg {compB} {compA} RAXIAL {resistance} Vm
end


//////////////////////////////////////////////////////////////////////////////
//
// Connects two somas by GABA
//
//////////////////////////////////////////////////////////////////////////////


function reciprocalGABAinhib(cellA, cellB, delay, weight)

    str cellA
    str cellB
    float delay

    // create spike train 
    if(!{exists {cellB}/spikes})
      create spikegen {cellB}/spikes
      setfield {cellB}/spikes output_amp 1 thresh 0.0 abs_refract 0.001
    end

    addmsg {cellA} {cellB}/spikes INPUT Vm

    if({getmsg {cellB}/spikes -out -count} < 1)
      addmsg {cellB}/spikes {cellB}/GABA_channel SPIKE
    end

    setfield {cellB}/GABA_channel synapse[0].weight {weight} synapse[0].delay {delay}
end

//////////////////////////////////////////////////////////////////////////////
//
// Connects two random compartments of typeA in cellA and 
// typeB in cellB with a gapjunction.
//
//
// Ex. To connect a random primary dendrite in cell 0 with a 
//     random secondary dendrite in cell 1, resistance 3e7 ohm
// 
//     randomDendGap /fs[0] prim /fs[1] sec 3e7
//
// Valid types: soma, prim, sec, tert
//
//////////////////////////////////////////////////////////////////////////////


function randomDendGap(cellA, typeA, cellB, typeB, resistance)

    str cellA, typeA
    str cellB, typeB
    float resistance

    int numA = {getarg {el {cellA}/{typeA}#} \
                       {el {cellA}/{typeA}#/{typeA}#} \
                       -count}

    int numB = {getarg {el {cellB}/{typeB}#} \
                       {el {cellB}/{typeB}#/{typeB}#} \
                       -count}

    int idxA = {rand 1 {numA}}
    int idxB = {rand 1 {numB}}

    str pathA = {getarg {el {cellA}/{typeA}#} \
                        {el {cellA}/{typeA}#/{typeA}#} \
                        -arg {idxA}}

    str pathB = {getarg {el {cellB}/{typeB}#} \
                        {el {cellB}/{typeB}#/{typeB}#} \
                        -arg {idxB}}

    echo "Connecting "{pathA}" with "{pathB}" using gapjunction (res="{resistance}" ohm)"

    // Gap junctions go both ways...
    addmsg {pathA} {pathB} RAXIAL {resistance} Vm
    addmsg {pathB} {pathA} RAXIAL {resistance} Vm

end


//////////////////////////////////////////////////////////////////////////////

function clearGap(compA, compB)

  str compA, compB
  int msgId

  echo "Removing gapjuncton "{compA}" <-> "{compB}

  msgId = {getmsg {compA} -in -find {compB} RAXIAL}
  deletemsg {compA} {msgId} -in

  msgId = {getmsg {compB} -in -find {compA} RAXIAL}
  deletemsg {compB} {msgId} -in  

end


//////////////////////////////////////////////////////////////////////////////
//
// makeSpiking adds a spikegen object to the cell if needed
//
//
//////////////////////////////////////////////////////////////////////////////


function makeSpiking(cellPath, asbRefract)

    str cellPath
    float absRefract

    str somaPath = {cellPath}@"/soma"
    str spikePath = {somaPath}@"/spike"

    if(!{exists {somaPath}})
        error "The object "@{somaPAth}@" does not exist!"
    end

    if(!{exists {spikePath}})
        create spikegen {spikePath}
        setfield {spikePath} thresh 0 abs_refract {absRefract} output_amp 1
        addmsg {somaPath} {spikePath} INPUT Vm
    else
        echo "makeSpiking: Spike object already exists: "{spikePath}", ignoring"
    end
end


//////////////////////////////////////////////////////////////////////////////
//
// connectGABA connects the sourceCell with destCompartment 
// using weight and delay.
//
// A spikegen object must be created first in sourceCell using makeSpiking
//
//////////////////////////////////////////////////////////////////////////////


function connectGABA(sourceCell, destCompartment, weight, delay)

    str sourceCell
    str destCompartment
    float weight
    float delay

    int i = 0
    int inMsg = 0
    int inSpikes = 0

    str sourceSpike = {sourceCell}@"/soma/spike"
    str destChannel = {destCompartment}@"/GABA_channel"

    addmsg {sourceSpike} {destChannel} SPIKE

    inMsg = {getmsg {destChannel} -in -count}

    for(i = 0; i < inMsg; i = i + 1)
        if({{strcmp SPIKE {getmsg {destChannel} -type {i}}} == 0})
            inSpikes = {{inSpikes} + 1}
        end
    end

    
    int msgIdx = {{inSpikes} - 1} //First element is zero

    setfield {destChannel} synapse[{msgIdx}].weight {weight} \
                           synapse[{msgIdx}].delay {delay}

end



Loading data, please wait...