Exemplo n.º 1
0
def loadAndRun(solver=True):
    simtime = 500e-3
    model = moose.loadModel('../data/h10.CNG.swc', '/cell')
    comp = moose.element('/cell/apical_e_177_0')
    soma = moose.element('/cell/soma')
    for i in range(10):
        moose.setClock(i, dt)
    if solver:
        solver = moose.HSolve('/cell/solver')
        solver.target = soma.path
        solver.dt = dt
    stim = moose.PulseGen('/cell/stim')
    stim.delay[0] = 50e-3
    stim.delay[1] = 1e9
    stim.level[0] = 1e-9
    stim.width[0] = 2e-3
    moose.connect(stim, 'output', comp, 'injectMsg')
    tab = moose.Table('/cell/Vm')
    moose.connect(tab, 'requestOut', comp, 'getVm')
    tab_soma = moose.Table('/cell/Vm_soma')
    moose.connect(tab_soma, 'requestOut', soma, 'getVm')
    moose.reinit()
    print('[INFO] Running for %s' % simtime)
    moose.start(simtime )
    vec = tab_soma.vector
    moose.delete( '/cell' )
    return vec
Exemplo n.º 2
0
def test_elec_alone():
    eeDt = 2e-6
    hSolveDt = 2e-5
    runTime = 0.02

    make_spiny_compt()
    make_elec_plots()
    head2 = moose.element( '/n/head2' )
    moose.setClock( 0, 2e-6 )
    moose.setClock( 1, 2e-6 )
    moose.setClock( 2, 2e-6 )
    moose.setClock( 8, 0.1e-3 )
    moose.useClock( 0, '/n/##[ISA=Compartment]', 'init' )
    moose.useClock( 1, '/n/##[ISA=Compartment]', 'process' )
    moose.useClock( 2, '/n/##[ISA=ChanBase],/n/##[ISA=SynBase],/n/##[ISA=CaConc],/n/##[ISA=SpikeGen]','process')
    moose.useClock( 8, '/graphs/elec/#', 'process' )
    moose.reinit()
    moose.start( runTime )
    dump_plots( 'instab.png' )
    # make Hsolver and rerun
    hsolve = moose.HSolve( '/n/hsolve' )
    moose.useClock( 1, '/n/hsolve', 'process' )
    hsolve.dt = 20e-6
    hsolve.target = '/n/compt'
    moose.le( '/n' )
    for dt in ( 20e-6, 50e-6, 100e-6 ):
        print(('running at dt =', dt))
        moose.setClock( 0, dt )
        moose.setClock( 1, dt )
        moose.setClock( 2, dt )
        hsolve.dt = dt
        moose.reinit()
        moose.start( runTime )
        dump_plots( 'h_instab' + str( dt ) + '.png' )
Exemplo n.º 3
0
def testNeuroMeshMultiscale():
    useHsolve = 1
    runtime = 0.5
    if useHsolve:
        elecDt = 50e-6
    else:
        elecDt = 10e-6
    chemDt = 0.005
    ePlotDt = 0.5e-3
    cPlotDt = 0.005
    plotName = 'nm.plot'
    makeNeuroMeshModel()
    print("after model is completely done")
    for i in moose.wildcardFind('/model/chem/#/#/#/transloc#'):
        print((i[0].name, i[0].Kf, i[0].Kb, i[0].kf, i[0].kb))

    makeChemPlots()
    makeElecPlots()
    makeCaPlots()
    moose.setClock(0, elecDt)
    moose.setClock(1, elecDt)
    moose.setClock(2, elecDt)
    moose.setClock(4, chemDt)
    moose.setClock(5, chemDt)
    moose.setClock(6, chemDt)
    moose.setClock(7, cPlotDt)
    moose.setClock(8, ePlotDt)
    if useHsolve:
        hsolve = moose.HSolve('/model/elec/hsolve')
        moose.useClock(1, '/model/elec/hsolve', 'process')
        hsolve.dt = elecDt
        hsolve.target = '/model/elec/compt'
        moose.reinit()
    else:
        moose.useClock(0, '/model/elec/##[ISA=Compartment]', 'init')
        moose.useClock(1, '/model/elec/##[ISA=Compartment]', 'process')
        moose.useClock(
            2,
            '/model/elec/##[ISA=ChanBase],/model/##[ISA=SynBase],/model/##[ISA=CaConc]',
            'process')

        moose.useClock(1, '/model/elec/##[ISA=SpikeGen]', 'process')
        moose.useClock(2, '/model/##[ISA=SynBase],/model/##[ISA=CaConc]',
                       'process')

    moose.useClock(4, '/model/chem/#/dsolve', 'process')
    moose.useClock(4, '/model/chem/#/ksolve', 'init')
    moose.useClock(5, '/model/chem/#/ksolve', 'process')
    moose.useClock(6, '/model/chem/spine/adaptCa', 'process')
    moose.useClock(6, '/model/chem/dend/DEND/adaptCa', 'process')
    moose.useClock(7, '/graphs/chem/#', 'process')
    moose.useClock(8, '/graphs/elec/#,/graphs/ca/#', 'process')
    moose.element('/model/elec/soma').inject = 2e-10
    moose.element('/model/chem/psd/Ca').concInit = 0.001
    moose.element('/model/chem/spine/Ca').concInit = 0.002
    moose.element('/model/chem/dend/DEND/Ca').concInit = 0.003
    moose.reinit()

    moose.start(runtime)
    makeGraphics(cPlotDt, ePlotDt)
Exemplo n.º 4
0
def main():
    """
    A toy compartmental neuronal + chemical model that causes bad things
    to happen to the hsolver, as of 28 May 2013. Hopefully this will
    become irrelevant soon
    
    """
    fineDt = 1e-5
    coarseDt = 5e-5
    make_spiny_compt()
    make_plots()
    for i in range(8):
        moose.setClock(i, fineDt)
    moose.setClock(8, coarseDt)
    moose.reinit()
    moose.start(0.1)
    display_plots('instab.plot')
    # make Hsolver and rerun
    hsolve = moose.HSolve('/n/hsolve')
    for i in range(8):
        moose.setClock(i, coarseDt)
    hsolve.dt = coarseDt
    hsolve.target = '/n/compt'
    moose.reinit()
    moose.start(0.1)
    display_plots('h_instab.plot')
    pylab.show()
Exemplo n.º 5
0
def setup_model(model_path, synapse_locations, passive=False, solver='hsolve'):
    """Set up a single cell model under `model_path` with synapses
    created in the compartments listed in `synapse_locations`.


    `model_path` - location where the model should be created.

    `synapse_locations`: compartment names for the synapses.

    """
    cell = moose.copy(make_prototype(passive), model_path)
    if solver.lower() == 'hsolve':
        hsolve = moose.HSolve('%s/solve' % (cell.path))
        hsolve.dt = simdt
        hsolve.target = cell.path
    syninfo_list = []
    for compname in synapse_locations:
        comppath = '%s/%s' % (cell.path, compname)
        print('1111 Creating synapse in', comppath)
        compartment = moose.element(comppath)
        syninfo = make_synapse(compartment)
        syninfo_list.append(syninfo)
        # connect  pulse stimulus
        stim_path = '%s/%s/stim' % (cell.path, compname)
        print('2222 Creating stimuls in', stim_path)
        stim = moose.PulseGen(stim_path)
        moose.connect(stim, 'output', syninfo['spike'], 'Vm')
        syninfo['stimulus'] = stim
    return {'neuron': cell, 'syninfo': syninfo_list}
Exemplo n.º 6
0
 def setupSolver(self, path='/hsolve'):
     """Setting up HSolver """
     hsolve = moose.HSolve(path)
     hsolve.dt = self.simDt
     moose.setClock(1, self.simDt)
     moose.useClock(1, hsolve.path, 'process')
     hsolve.target = self.cablePath
Exemplo n.º 7
0
def testNeuroMeshMultiscale():
    runtime = 0.5
    #elecDt = 0.2e-6
    elecDt = 10e-6
    chemDt = 0.0025
    ePlotDt = 0.5e-3
    cPlotDt = 0.0025
    plotName = 'nm.plot'

    makeNeuroMeshModel()
    print("after model is completely done")
    for i in moose.wildcardFind('/model/chem/#/#/#/transloc#'):
        print((i[0].name, i[0].Kf, i[0].Kb, i[0].kf, i[0].kb))

    makeChemPlots()
    makeElecPlots()
    makeCaPlots()
    hsolve = moose.HSolve('/model/elec/hsolve')
    hsolve.dt = elecDt
    hsolve.target = '/model/elec/compt'
    plotlist = makeGraphics()
    moose.reinit()
    moose.element('/model/elec/soma').inject = 2e-10
    moose.element('/model/chem/psd/Ca').concInit = 0.001
    moose.element('/model/chem/spine/Ca').concInit = 0.002
    moose.element('/model/chem/dend/DEND/Ca').concInit = 0.003
    moose.reinit()

    numDivs = 200
    partialRuntime = runtime / numDivs
    for i in range(numDivs):
        moose.start(partialRuntime)
    updateGraphics(plotlist)
    finalizeGraphics(plotlist, cPlotDt, ePlotDt)
Exemplo n.º 8
0
def assign_clocks(model_container_list, simdt, plotdt, hsolveYN, name_soma):
    log.info('SimDt={}, PlotDt={}', simdt, plotdt)
    for tab in moose.wildcardFind(DATA_NAME + '/##[TYPE=Table]'):
        moose.setClock(tab.tick, plotdt)
    for tick in range(0, 13):
        moose.setClock(tick, simdt)
        # 1 - CaConc, DifShell, DifBuffer
        # 2 — channels and synchans
        # 4 — compartments
        # 5 - SpikeGen
        # 6 — hsolver
        # 7 - TimeTables for moose_nerp (see ttables.py)
        # 8 - Tables
        # 12 - Function
    # problem if TimeTable uses plotdt?
    moose.setClock(8, plotdt)
    # 8 — hdf5datawriter, tables

    for path in model_container_list:
        if hsolveYN:
            hsolve = moose.HSolve(path + '/hsolve')
            hsolve.dt = simdt
            # Compartment is transformed into zombiecompartment after below statement.
            hsolve.target = path + '/' + name_soma
            log.info("Using HSOLVE for {} clock {}", hsolve.path, hsolve.tick)
    moose.reinit()
Exemplo n.º 9
0
def assign_clocks(model_container, data_container, solver='euler'):
    """Assign clockticks to elements.
    
    Parameters
    ----------
    model_container: element

    All model components are under this element. The model elements
    are assigned clocks as required to maintain the right update
    sequence. 

    INITCLOCK = 0 calls `init` method in Compartments

    ELECCLOCK = 1 calls `process` method of Compartments

    CHANCLOCK = 2 calls `process` method for HHChannels

    POOLCLOCK = 3 is not used in electrical simulation

    LOOKUPCLOCK = 6 is not used in these simulations.

    STIMCLOCK = 7 calls `process` method in stimulus objects like
    PulseGen.

    data_container: element     
    All data recording tables are under this element. They are
    assigned PLOTCLOCK, the clock whose update interval is plotdt.

    PLOTCLOCK = 8 calls `process` method of Table elements under
    data_container

    """
    moose.useClock(STIMCLOCK,
                   model_container.path+'/##[TYPE=PulseGen]',
                   'process')
    moose.useClock(PLOTCLOCK,
                   data_container.path+'/##[TYPE=Table]',
                   'process')
    if solver == 'hsolve':
        for neuron in moose.wildcardFind('%s/##[TYPE=Neuron]'):
            solver = moose.HSolve(neuron.path+'/solve')
            solver.dt = moose.element('/clock/tick[0]').dt
            solver.target = neuron.path
        moose.useClock(INITCLOCK,
                       model_container.path+'/##[TYPE=HSolve]',
                       'process')
    else:
        moose.useClock(INITCLOCK, 
                       model_container.path+'/##[TYPE=Compartment]', 
                       'init')
        moose.useClock(ELECCLOCK,
                       model_container.path+'/##[TYPE=Compartment]', 
                       'process')
        moose.useClock(CHANCLOCK, 
                       model_container.path+'/##[TYPE=HHChannel]',
                       'process')
        moose.useClock(POOLCLOCK,
                       model_container.path+'/##[TYPE=CaConc]',
                       'process')
Exemplo n.º 10
0
 def __init__(self, path):
     if not moose.exists(path):
         path_tokens = path.rpartition('/')
         moose.copy(self.prototype, path_tokens[0], path_tokens[-1])
     moose.Neutral.__init__(self, path)
     self.solver = moose.HSolve('{}/solver'.format(path, 'solver'))
     self.solver.target = path
     self.solver.dt = config.simulationSettings.simulationDt
Exemplo n.º 11
0
def testNeuroMeshMultiscale():
    runtime = 0.5
    #elecDt = 0.2e-6
    elecDt = 10e-6
    chemDt = 0.0025
    ePlotDt = 0.5e-3
    cPlotDt = 0.0025
    plotName = 'nm.plot'

    makeNeuroMeshModel()
    print "after model is completely done"
    for i in moose.wildcardFind('/model/chem/#/#/#/transloc#'):
        print i[0].name, i[0].Kf, i[0].Kb, i[0].kf, i[0].kb

    makeChemPlots()
    makeElecPlots()
    makeCaPlots()
    for i in range(10):
        moose.setClock(i, elecDt)
    for i in range(10, 20):
        moose.setClock(i, chemDt)
    moose.setClock(8, ePlotDt)
    moose.setClock(18, cPlotDt)
    moose.useClock(8, '/graphs/elec/#,/graphs/ca/#', 'process')
    moose.useClock(18, '/graphs/chem/#', 'process')
    hsolve = moose.HSolve('/model/elec/hsolve')
    hsolve.dt = elecDt
    hsolve.target = '/model/elec/compt'
    plotlist = makeGraphics()
    moose.reinit()
    moose.element('/model/elec/soma').inject = 2e-10
    moose.element('/model/chem/psd/Ca').concInit = 0.001
    moose.element('/model/chem/spine/Ca').concInit = 0.002
    moose.element('/model/chem/dend/DEND/Ca').concInit = 0.003
    moose.reinit()

    numDivs = 200
    partialRuntime = runtime / numDivs
    max_voxel = find_max_voxel()
    voxel_val_dict = {
        'spine': numpy.zeros((max_voxel, numDivs)),
        'dend': numpy.zeros((max_voxel, numDivs)),
        'elec': numpy.zeros((max_voxel, numDivs)),
        'spineCaM': numpy.zeros((max_voxel, numDivs)),
        'psdCaM': numpy.zeros((max_voxel, numDivs))
    }
    for i in range(numDivs):
        moose.start(partialRuntime)
        voxel_val_dict = updateGraphics(plotlist, voxel_val_dict,
                                        i)  #Edited by Chaitanya


#        moose.element( '/model/elec/soma' ).inject = 0
#	moose.start( 0.25 )
    save_NSDF(cPlotDt, ePlotDt, voxel_val_dict,
              [max_voxel, numDivs, partialRuntime])  #Edited by Chaitanya
    finalizeGraphics(plotlist, cPlotDt, ePlotDt)
Exemplo n.º 12
0
    def __init__(self, path):
        self.path = path
        if not moose.exists(self.path):
            path_tokens = path.rpartition('/')
            moose.copy(self.prototype, path_tokens[0], path_tokens[-1])

        self.name = path.split('/')[-1]
        self.solver = moose.HSolve('{}/solver'.format(path))
        self.solver.target = path
        self.solver.dt = config.simulationSettings.simulationDt
Exemplo n.º 13
0
 def _configureClocks( self ):
     for i in range( 0, 8 ):
         moose.setClock( i, self.elecDt )
     moose.setClock( 10, self.diffDt )
     for i in range( 11, 18 ):
         moose.setClock( i, self.chemDt )
     moose.setClock( 18, self.chemDt * 5.0 )
     hsolve = moose.HSolve( self.elecid.path + '/hsolve' )
     hsolve.dt = self.elecDt
     hsolve.target = self.soma.path
Exemplo n.º 14
0
def test_hsolve_calcium():
    for tick in range(0, 7):
        moose.setClock(tick, 10e-6)
    moose.setClock(8, 0.005)

    lib = moose.Neutral('/library')
    model = moose.loadModel(p_file, 'neuron')
    assert model, model
    pulse = moose.PulseGen('/neuron/pulse')
    inject = 100e-10
    chan_proto.chan_proto('/library/SK', param_chan.SK)
    chan_proto.chan_proto('/library/CaL12', param_chan.Cal)
    pulse.delay[0] = 8.
    pulse.width[0] = 500e-12
    pulse.level[0] = inject
    pulse.delay[1] = 1e9

    for comp in moose.wildcardFind('/neuron/#[TYPE=Compartment]'):
        new_comp = moose.element(comp)
        new_comp.initVm = -.08
        difs, difb = td.add_difshells_and_buffers(new_comp, difshell_no,
                                                  difbuf_no)
        for name in cond:
            chan = td.addOneChan(name, cond[name], new_comp)
            if 'Ca' in name:
                moose.connect(chan, "IkOut", difs[0], "influx")

            if 'SK' in name:
                moose.connect(difs[0], 'concentrationOut', chan, 'concen')

    data = moose.Neutral('/data')
    vmtab = moose.Table('/data/Vm')
    shelltab = moose.Table('/data/Ca')
    caltab = moose.Table('/data/CaL_Gk')
    sktab = moose.Table('/data/SK_Gk')
    moose.connect(vmtab, 'requestOut', moose.element('/neuron/soma'), 'getVm')
    moose.connect(shelltab, 'requestOut', difs[0], 'getC')
    moose.connect(caltab, 'requestOut', moose.element('/neuron/soma/CaL12'),
                  'getGk')
    moose.connect(sktab, 'requestOut', moose.element('/neuron/soma/SK'),
                  'getGk')

    hsolve = moose.HSolve('/neuron/hsolve')
    hsolve.dt = 10e-6
    hsolve.target = ('/neuron/soma')
    t_stop = 10.
    moose.reinit()
    moose.start(t_stop)
    vec1 = sktab.vector
    vec2 = shelltab.vector
    assert_stat(vec1, [0.0, 5.102834e-22, 4.79066e-22, 2.08408e-23])
    assert_stat(vec2, [5.0e-5, 5.075007e-5, 5.036985e-5, 2.1950117e-7])
    assert len(np.where(sktab.vector < 1e-19)[0]) == 2001
    assert len(np.where(shelltab.vector > 50e-6)[0]) == 2000
Exemplo n.º 15
0
 def schedule(self, simdt, plotdt, solver):
     config.logger.info('Scheduling: simdt=%g, plotdt=%g, solver=%s' % (simdt, plotdt, solver))
     self.simdt = simdt
     self.plotdt = plotdt
     self.solver = solver
     if self.solver == 'hsolve':
         self.hsolve = moose.HSolve('%s/solver' % (self.cell.path))
         self.hsolve.dt = simdt
         self.hsolve.target = self.cell.path
     mutils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
     mutils.assignDefaultTicks(modelRoot=self.model_container.path, 
                              dataRoot=self.data_container.path, 
                              solver=self.solver)        
Exemplo n.º 16
0
def testNeuroMeshMultiscale():
    elecDt = 50e-6
    chemDt = 2e-3
    plotDt = 5e-4
    plotName = 'nm.plot'

    makeNeuroMeshModel()
    """
    moose.le( '/model/chem/spineMesh/ksolve' )
    print 'Neighbors:'
    for t in moose.element( '/model/chem/spineMesh/ksolve/junction' ).neighbors['masterJunction']:
        print 'masterJunction <-', t.path
    for t in moose.wildcardFind( '/model/chem/#Mesh/ksolve' ):
        k = moose.element( t[0] )
        print k.path + ' localVoxels=', k.numLocalVoxels, ', allVoxels= ', k.numAllVoxels
    """

    makeChemPlots()
    makeElecPlots()
    moose.setClock(0, elecDt)
    moose.setClock(1, elecDt)
    moose.setClock(2, elecDt)
    moose.setClock(5, chemDt)
    moose.setClock(6, chemDt)
    moose.setClock(7, plotDt)
    moose.setClock(8, plotDt)
    moose.useClock(0, '/model/elec/##[ISA=Compartment]', 'init')
    moose.useClock(1, '/model/elec/##[ISA=SpikeGen]', 'process')
    moose.useClock(
        2,
        '/model/elec/##[ISA=ChanBase],/model/##[ISA=SynBase],/model/##[ISA=CaConc]',
        'process')
    moose.useClock(
        5,
        '/model/chem/##[ISA=PoolBase],/model/##[ISA=ReacBase],/model/##[ISA=EnzBase]',
        'process')
    moose.useClock(6, '/model/chem/##[ISA=Adaptor]', 'process')
    moose.useClock(7, '/graphs/#', 'process')
    moose.useClock(8, '/graphs/elec/#', 'process')
    moose.useClock(5, '/model/chem/#Mesh/ksolve', 'init')
    moose.useClock(6, '/model/chem/#Mesh/ksolve', 'process')
    hsolve = moose.HSolve('/model/elec/hsolve')
    moose.useClock(1, '/model/elec/hsolve', 'process')
    hsolve.dt = elecDt
    hsolve.target = '/model/elec/compt'
    moose.reinit()
    moose.reinit()

    moose.start(1.0)
    dumpPlots(plotName)
Exemplo n.º 17
0
def makeSolvers(elecDt):
    # Put in the solvers, see how they fare.
    # Here we kludge in a single chem solver for the whole system.
    ksolve = moose.Ksolve('/model/ksolve')
    stoich = moose.Stoich('/model/stoich')
    stoich.compartment = moose.element('/model/chem/neuroMesh')
    stoich.ksolve = ksolve
    stoich.path = '/model/chem/##'
    moose.useClock(5, '/model/ksolve', 'init')
    moose.useClock(6, '/model/ksolve', 'process')
    # Here is the elec solver
    hsolve = moose.HSolve('/model/hsolve')
    moose.useClock(1, '/model/hsolve', 'process')
    hsolve.dt = elecDt
    hsolve.target = '/model/elec/compt'
Exemplo n.º 18
0
def run_model():
    model = moose.Neutral('/model')
    data = moose.Neutral('/data')
    cell = TuftedIB('/model/TuftedIB')
    stim = alpha_stimulus('/model/stim', 1.0e-9, 15e-3, 20e-3, simtime, simdt)
    stim.startTime = 1e9
    p1 = cell.path + '/' + d1
    p2 = cell.path + '/' + d2
    comp_d1 = moose.element(p1) if moose.exists(p1) else moose.Compartment(p1)
    comp_d2 = moose.element(p2) if moose.exists(p2) else moose.Compartment(p2)
    s = '%s/%s' % (cell.path, 'comp_1')
    comp_soma = moose.element(s) if moose.exists(s) else moose.Compartment(s)
    comp_soma.inject = -0.2e-9
    moose.connect(stim, 'output', comp_d1, 'injectMsg')
    tab_d1 = moose.Table('%s/d1_Vm' % (data.path))
    tab_d2 = moose.Table('%s/d2_Vm' % (data.path))
    tab_soma = moose.Table('%s/soma_Vm' % (data.path))
    tab_stim = moose.Table('%s/stim' % (data.path))
    moose.connect(tab_d1, 'requestOut', comp_d1, 'getVm')
    moose.connect(tab_d2, 'requestOut', comp_d2, 'getVm')
    moose.connect(tab_soma, 'requestOut', comp_soma, 'getVm')
    moose.connect(stim, 'output', tab_stim, 'input')
    solver = moose.HSolve('%s/solver' % (cell.path))
    solver.dt = simdt
    solver.target = cell.path
    utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
    utils.assignDefaultTicks()
    moose.reinit()
    utils.stepRun(simtime, 1e5 * simdt, logger=config.logger)
    pylab.subplot(211)
    pylab.plot(np.linspace(0, simtime, len(tab_d1.vector)),
               tab_d1.vector * 1e3,
               label='D1 Vm (mV)')
    pylab.plot(np.linspace(0, simtime, len(tab_d2.vector)),
               tab_d2.vector * 1e3,
               label='D2 Vm (mV)')
    pylab.plot(np.linspace(0, simtime, len(tab_soma.vector)),
               tab_soma.vector * 1e3,
               label='SOMA Vm (mV)')
    pylab.legend()
    pylab.subplot(212)
    pylab.plot(np.linspace(0, simtime, len(tab_stim.vector)),
               tab_stim.vector * 1e9,
               label='Stimulus (nA)')
    pylab.legend()
    pylab.savefig('fig_a4c.png')
    pylab.show()
Exemplo n.º 19
0
def main():
    """
    Demonstrates how one can visualise morphology of a neuron using the MOOSE.
    """
    app = QtGui.QApplication(sys.argv)
    filename = 'barrionuevo_cell1zr.CNG.swc'
    moose.Neutral('/library')
    moose.Neutral('/model')
    cell = moose.loadModel(filename, '/model/testSwc')
    for i in range(8):
        moose.setClock(i, simdt)
    hsolve = moose.HSolve('/model/testSwc/hsolve')
    hsolve.dt = simdt
    hsolve.target = '/model/testSwc/soma'
    moose.le(cell)
    moose.reinit()

    # Now we set up the display
    compts = moose.wildcardFind("/model/testSwc/#[ISA=CompartmentBase]")
    compts[0].inject = inject
    ecomptPath = [x.path for x in compts]
    morphology = moogli.extensions.moose.read(path="/model/testSwc",
                                              vertices=15)
    viewer = moogli.Viewer("Viewer")
    viewer.attach_shapes(morphology.shapes.values())
    view = moogli.View("main-view")
    viewer.attach_view(view)

    # morphology = moogli.read_morphology_from_moose(name = "", path = "/model/testSwc")
    # morphology.create_group( "group_all", ecomptPath, -0.08, 0.02, \
    #         [0.0, 0.5, 1.0, 1.0], [1.0, 0.0, 0.0, 0.9] )

    # viewer = moogli.DynamicMorphologyViewerWidget(morphology)
    def callback(morphology, viewer):
        moose.start(frameRunTime)
        Vm = [moose.element(x).Vm for x in compts]
        morphology.set_color("group_all", Vm)
        currTime = moose.element('/clock').currentTime
        #print currTime, compts[0].Vm
        if (currTime < runtime):
            return True
        return False

    #viewer.set_callback( callback, idletime = 0 )
    #viewer.showMaximized()
    viewer.show()
    app.exec_()
def testCubeMultiscale(useSolver):
    elecDt = 10e-6
    chemDt = 1e-4
    plotDt = 5e-4
    plotName = 'cm.plot'
    if (useSolver):
        elecDt = 50e-6
        chemDt = 2e-3
        plotName = 'solve_cm.plot'

    makeModelInCubeMesh()
    makeChemPlots()
    makeElecPlots()
    '''
    moose.setClock( 0, elecDt )
    moose.setClock( 1, elecDt )
    moose.setClock( 2, elecDt )
    moose.setClock( 5, chemDt )
    moose.setClock( 6, chemDt )
    moose.setClock( 7, plotDt )
    moose.setClock( 8, plotDt )
    moose.useClock( 1, '/n/##[ISA=SpikeGen]', 'process' )
    moose.useClock( 2, '/n/##[ISA=SynBase]','process')
    moose.useClock( 6, '/n/##[ISA=Adaptor]', 'process' )
    moose.useClock( 7, '/graphs/#', 'process' )
    moose.useClock( 8, '/graphs/elec/#', 'process' )
    moose.useClock( 0, '/n/##[ISA=Compartment]', 'init' )
    moose.useClock( 1, '/n/##[ISA=Compartment]', 'process' )
    moose.useClock( 2, '/n/##[ISA=ChanBase],/n/##[ISA=SynBase],/n/##[ISA=CaConc]','process')
    moose.useClock( 5, '/n/##[ISA=PoolBase],/n/##[ISA=ReacBase],/n/##[ISA=EnzBase]', 'process' )
    '''
    if (useSolver):
        ksolve = moose.Ksolve('/n/ksolve')
        stoich = moose.Stoich('/n/stoich')
        stoich.compartment = moose.element('/n/chem/neuroMesh')
        stoich.ksolve = ksolve
        stoich.path = '/n/##'
        ksolve.method = 'rk5'
        #moose.useClock( 5, '/n/ksolve', 'process' )
        hsolve = moose.HSolve('/n/hsolve')
        #moose.useClock( 1, '/n/hsolve', 'process' )
        hsolve.dt = elecDt
        hsolve.target = '/n/compt'
    moose.reinit()
    moose.start(1)
    displayPlots()
Exemplo n.º 21
0
def run_current_pulse(amps,
                      delay=100e-3,
                      dur=100e-3,
                      trail=100e-3,
                      outfile='f_i_curves_data.h5'):
    models = []
    model = moose.Neutral('/model')
    data = moose.Neutral('/data')
    ddict = defaultdict(list)
    for ii, amp in enumerate(amps):
        mc = moose.Neutral('{}/mc_{}'.format(model.path, ii))
        models.append(mc)
        stim = moose.PulseGen('{}/stim_{}'.format(mc.path, ii))
        stim.delay[0] = delay
        stim.width[0] = dur
        stim.level[0] = amp
        stim.delay[
            1] = 1e9  # make delay so large that it does not activate again
        for celltype in [SpinyStellate, DeepBasket, DeepLTS]:
            cell = celltype('{}/{}_{}'.format(mc.path, celltype.__name__, ii))
            solver = moose.HSolve('{}/solver'.format(cell.path))
            solver.dt = simdt
            solver.target = cell.path
            stim.connect('output', cell.soma, 'injectMsg')
            tab = moose.Table('/data/Vm_{}'.format(cell.name))
            ddict[ii].append(tab)
            tab.connect('requestOut', cell.soma, 'getVm')
    mutils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
    mutils.assignDefaultTicks(modelRoot='/model',
                              dataRoot='/data',
                              solver='hsolve')
    moose.reinit()
    print('Finished scheduling')
    moose.start(delay + dur + trail)
    print('Finished simulation')
    # Save data
    fd = h5.File(outfile, 'w')
    for ii, tabs in ddict.items():
        for tab in tabs:
            print('Table', tab.name)
            node = fd.create_dataset(tab.name, data=tab.vector)
            node.attrs['current'] = amps[ii]
            node.attrs['delay'] = delay
            node.attrs['width'] = dur
    fd.close()
    print('Finished saving data in file', outfile)
Exemplo n.º 22
0
 def _configureClocks(self):
     if self.turnOffElec:
         elecDt = 1e6
         diffDt = 0.1
         chemDt = 0.1
     else:
         elecDt = self.elecDt
         diffDt = self.diffDt
         chemDt = self.chemDt
     for i in range(0, 9):
         moose.setClock(i, elecDt)
     moose.setClock(10, diffDt)
     for i in range(11, 18):
         moose.setClock(i, chemDt)
     moose.setClock(18, chemDt * 5.0)
     hsolve = moose.HSolve(self.elecid.path + '/hsolve')
     hsolve.dt = elecDt
     hsolve.target = self.soma.path
Exemplo n.º 23
0
def setup_model(root='/', hsolve=True):
    moose.ce(root)
    model = moose.Neutral('model')
    data = moose.Neutral('data')
    cell = DeepBasket('%s/deepbasket' % (model.path))
    soma = moose.Compartment('%s/comp_1' % (cell.path))
    if hsolve:
        solver = moose.HSolve('%s/solve' % (cell.path))
        solver.dt = simdt
        solver.target = cell.path
    pulse = moose.PulseGen('%s/stimulus' % (model.path))
    moose.connect(pulse, 'output', soma, 'injectMsg')
    tab_vm = moose.Table('%s/spinystellate_soma_Vm' % (data.path))
    moose.connect(tab_vm, 'requestOut', soma, 'getVm')
    tab_stim = moose.Table('%s/spinystellate_soma_inject' % (data.path))
    moose.connect(tab_stim, 'requestOut', pulse, 'getOutputValue')
    utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
    utils.assignDefaultTicks(model, data)
    return {'stimulus': pulse, 'tab_vm': tab_vm, 'tab_stim': tab_stim}
Exemplo n.º 24
0
 def simulateSelected(self):
     cellnames = [str(c.text()) for c in self.cellListWidget.selectedItems()]
     assert(len(cellnames) == 1)        
     name = cellnames[0]
     params = self.createCell(name)
     print 'Here ......'
     hsolve = moose.HSolve('%s/solver' % (params['cell'].path))
     hsolve.dt = simdt
     hsolve.target = params['cell'].path
     mutils.setDefaultDt(elecdt=simdt, plotdt2=plotdt)
     mutils.assignDefaultTicks(modelRoot=params['modelRoot'],
                               dataRoot=params['dataRoot'],
                               solver='hsolve')
     delay = float(str(self.delayText.text()))
     width =  float(str(self.widthText.text()))
     level =  float(str(self.ampText.text()))
     params['stimulus'].delay[0] = delay * 1e-3
     params['stimulus'].width[0] = width * 1e-3
     params['stimulus'].level[0] = level * 1e-12
     moose.reinit()
     simtime = float(str(self.simtimeEdit.text()))*1e-3
     ts = datetime.now()
     moose.start(simtime)
     te = datetime.now()
     td = te - ts
     print 'Simulating %g s took %g s of computer time' % (simtime, td.days * 86400 + td.seconds + td.microseconds * 1e-6)
     ts = np.linspace(0, simtime, len(params['somaVm'].vec))
     vm = params['somaVm'].vec
     stim = params['injectionCurrent'].vec
     self.vmAxes.clear()       
     self.vmAxes.set_title('membrane potential at soma')
     self.vmAxes.set_ylabel('mV')            
     self.vmAxes.plot(ts * 1e3, vm * 1e3, 'b-', label='Vm (mV)')
     self.vmAxes.get_xaxis().set_visible(False)
     self.stimAxes.clear()
     self.stimAxes.set_title('current injected at soma')
     self.stimAxes.set_ylabel('pA')
     self.stimAxes.set_xlabel('ms')
     self.stimAxes.plot(ts * 1e3, stim * 1e12, 'r-', label='Current (pA)')
     self.gs.tight_layout(self.plotFigure)
     # self.plotFigure.tight_layout()
     self.plotCanvas.draw()
Exemplo n.º 25
0
def assign_clocks(model_container_list, simdt, plotdt, hsolveYN, name_soma):
    log.info('SimDt={}, PlotDt={}', simdt, plotdt)
    for tab in moose.wildcardFind(DATA_NAME + '/##[TYPE=Table]'):
        moose.setClock(tab.tick, plotdt)
    for tick in range(0, 7):
        moose.setClock(tick, simdt)
        # 2 — channels
        # 4 — compartments
        # 6 — hsolver

    moose.setClock(8, plotdt)
    # 8 — hdf5datawriter

    for path in model_container_list:
        if hsolveYN:
            hsolve = moose.HSolve(path + '/hsolve')
            hsolve.dt = simdt
            hsolve.target = path + '/' + name_soma
            log.info("Using HSOLVE for {} clock {}", hsolve.path, hsolve.tick)
    moose.reinit()
Exemplo n.º 26
0
def main():
    fineDt = 1e-5
    coarseDt = 5e-5
    make_spiny_compt()
    make_plots()
    for i in range(8):
        moose.setClock(i, fineDt)
    moose.setClock(8, coarseDt)
    moose.reinit()
    moose.start(0.1)
    display_plots('instab.plot')
    # make Hsolver and rerun
    hsolve = moose.HSolve('/n/hsolve')
    for i in range(8):
        moose.setClock(i, coarseDt)
    hsolve.dt = coarseDt
    hsolve.target = '/n/compt'
    moose.reinit()
    moose.start(0.1)
    display_plots('h_instab.plot')
    pylab.show()
Exemplo n.º 27
0
def testNeuroMeshMultiscale():
    useHsolve = 0
    runtime = 0.5
    elecDt = 10e-6
    chemDt = 0.005
    ePlotDt = 0.5e-3
    cPlotDt = 0.005
    plotName = 'nm.plot'

    makeNeuroMeshModel()
    print("after model is completely done")
    for i in moose.wildcardFind('/model/chem/#/#/#/transloc#'):
        print((i[0].name, i[0].Kf, i[0].Kb, i[0].kf, i[0].kb))

    makeChemPlots()
    makeElecPlots()
    makeCaPlots()
    for i in range(10):
        moose.setClock(i, elecDt)
    for i in range(10, 20):
        moose.setClock(i, chemDt)
    moose.setClock(8, ePlotDt)
    moose.setClock(18, cPlotDt)
    if useHsolve:
        hsolve = moose.HSolve('/model/elec/hsolve')
    #moose.useClock( 1, '/model/elec/hsolve', 'process' )
    hsolve.dt = elecDt
    hsolve.target = '/model/elec/compt'
    moose.reinit()
    #soma = moose.element( '/model/elec/soma' )
    moose.useClock(18, '/graphs/chem/#', 'process')
    moose.useClock(8, '/graphs/elec/#,/graphs/ca/#', 'process')
    moose.element('/model/elec/soma').inject = 2e-10
    moose.element('/model/chem/psd/Ca').concInit = 0.001
    moose.element('/model/chem/spine/Ca').concInit = 0.002
    moose.element('/model/chem/dend/DEND/Ca').concInit = 0.003
    moose.reinit()

    moose.start(runtime)
    makeGraphics(cPlotDt, ePlotDt)
Exemplo n.º 28
0
def main():
    app = QtGui.QApplication(sys.argv)
    filename = 'barrionuevo_cell1zr.CNG.swc'
    moose.Neutral('/library')
    moose.Neutral('/model')
    cell = moose.loadModel(filename, '/model/testSwc')
    for i in range(8):
        moose.setClock(i, simdt)
    hsolve = moose.HSolve('/model/testSwc/hsolve')
    hsolve.dt = simdt
    hsolve.target = '/model/testSwc/soma'
    moose.le(cell)
    moose.reinit()

    # Now we set up the display
    compts = moose.wildcardFind("/model/testSwc/#[ISA=CompartmentBase]")
    compts[0].inject = inject
    ecomptPath = map(lambda x: x.path, compts)
    morphology = moogli.read_morphology_from_moose(name="",
                                                   path="/model/testSwc")
    morphology.create_group( "group_all", ecomptPath, -0.08, 0.02, \
            [0.0, 0.5, 1.0, 1.0], [1.0, 0.0, 0.0, 0.9] )

    viewer = moogli.DynamicMorphologyViewerWidget(morphology)

    def callback(morphology, viewer):
        moose.start(frameRunTime)
        Vm = map(lambda x: moose.element(x).Vm, compts)
        morphology.set_color("group_all", Vm)
        currTime = moose.element('/clock').currentTime
        #print currTime, compts[0].Vm
        if (currTime < runtime):
            return True
        return False

    viewer.set_callback(callback, idletime=0)
    viewer.showMaximized()
    viewer.show()
    app.exec_()
Exemplo n.º 29
0
dt = 50e-6
moose.setClock( 0, dt )
moose.setClock( 1, dt )
moose.setClock( 2, dt )
moose.setClock( 3, 2e-4 )
moose.useClock( 0, '/cell/##[ISA=Compartment]', 'init' )
moose.useClock( 1, '/cell/##[ISA=Compartment]', 'process' )
moose.useClock( 2, '/cell/##[ISA!=Compartment]', 'process' )
moose.useClock( 3, '/graphs/soma,/graphs/ca', 'process' )

print 2
moose.reinit()
print 3
moose.start( 0.1 )
dumpPlots( '50usec.plot' )
print 4
moose.reinit()
hsolve = moose.HSolve( '/cell/hsolve' )
moose.useClock( 1, '/cell/hsolve', 'process' )
hsolve.dt = dt
hsolve.target = '/cell/soma'
moose.reinit()
moose.reinit()
print 5
moose.start( 0.1 )
print 6

dumpPlots( 'h50usec.plot' )

print 7
Exemplo n.º 30
0
def loadFile(filename, target, solver="gsl", merge=True):
    """Try to load a model from specified `filename` under the element
    `target`.

    if `merge` is True, the contents are just loaded at target. If
    false, everything is deleted from the parent of target unless the
    parent is root.

    Returns
    -------
    a dict containing at least these three entries:

    modeltype: type of the loaded model.

    subtype: subtype of the loaded model, None if no specific subtype

    modelroot: root element of the model, None if could not be located - as is the case with Python scripts
    """
    num = 1
    newTarget = target
    while moose.exists(newTarget):
        newTarget = target + "-" + str(num)
        num = num + 1
    target = newTarget
    istext = True
    with open(filename, 'rb') as infile:
        istext = mtypes.istextfile(infile)
    if not istext:
        print 'Cannot handle any binary formats yet'
        return None
    parent, child = posixpath.split(target)
    p = moose.Neutral(parent)
    if not merge and p.path != '/':
        for ch in p.children:
            moose.delete(ch)
    try:
        modeltype = mtypes.getType(filename)
        subtype = mtypes.getSubtype(filename, modeltype)
    except KeyError:
        raise FileLoadError('Do not know how to handle this filetype: %s' %
                            (filename))
    pwe = moose.getCwe()
    #self.statusBar.showMessage('Loading model, please wait')
    # app = QtGui.qApp
    # app.setOverrideCursor(QtGui.QCursor(Qt.Qt.BusyCursor)) #shows a hourglass - or a busy/working arrow
    if modeltype == 'genesis':
        if subtype == 'kkit' or subtype == 'prototype':
            model, modelpath = loadGenCsp(target, filename, solver)
            if moose.exists(moose.element(modelpath).path):
                moose.Annotator(moose.element(modelpath).path +
                                '/info').modeltype = "kkit"
            else:
                print " path doesn't exists"
            moose.le(modelpath)
        else:
            print 'Only kkit and prototype files can be loaded.'

    elif modeltype == 'cspace':
        model, modelpath = loadGenCsp(target, filename)
        if moose.exists(modelpath):
            moose.Annotator(
                (moose.element(modelpath).path + '/info')).modeltype = "cspace"
        addSolver(modelpath, 'gsl')

    elif modeltype == 'xml':
        if subtype == 'neuroml':
            popdict, projdict = neuroml.loadNeuroML_L123(filename)
            # Circus to get the container of populations from loaded neuroml
            for popinfo in popdict.values():
                for cell in popinfo[1].values():
                    solver = moose.HSolve(cell.path + "/hsolve")
                    solver.target = cell.path
                    # model = cell.parent
                    # break
                # break

            # Moving model to a new location under the model name
            # model name is the filename without extension

            model = moose.Neutral("/" + splitext(basename(filename))[0])
            element = moose.Neutral(model.path + "/model")
            if (moose.exists("/cells")): moose.move("/cells", element.path)
            if (moose.exists("/elec")): moose.move("/elec", model.path)
            if (moose.exists("/library")): moose.move("/library", model.path)

            # moose.move("cells/", cell.path)
        elif subtype == 'sbml':
            if target != '/':
                if moose.exists(target):
                    moose.delete(target)
            model = mooseReadSBML(filename, target)
            if moose.exists(moose.element(model).path):
                moose.Annotator(moose.element(model).path +
                                '/info').modeltype = "sbml"
            addSolver(target, 'gsl')
    else:
        raise FileLoadError('Do not know how to handle this filetype: %s' %
                            (filename))
    moose.setCwe(
        pwe
    )  # The MOOSE loadModel changes the current working element to newly loaded model. We revert that behaviour

    # TODO: check with Aditya how to specify the target for
    # neuroml reader
    # app.restoreOverrideCursor()
    return {'modeltype': modeltype, 'subtype': subtype, 'model': model}