예제 #1
0
def create_olm_network():
    """Create the network

    :returns: name of network nml file
    """
    net_doc = NeuroMLDocument(id="network", notes="OLM cell network")
    net_doc_fn = "olm_example_net.nml"
    net_doc.includes.append(IncludeType(href=create_olm_cell()))
    # Create a population: convenient to create many cells of the same type
    pop = Population(id="pop0",
                     notes="A population for our cell",
                     component="olm",
                     size=1,
                     type="populationList")
    pop.instances.append(Instance(id=1, location=Location(0., 0., 0.)))
    # Input
    pulsegen = PulseGenerator(id="pg_olm",
                              notes="Simple pulse generator",
                              delay="100ms",
                              duration="100ms",
                              amplitude="0.08nA")

    exp_input = ExplicitInput(target="pop0[0]", input="pg_olm")

    net = Network(id="single_olm_cell_network",
                  note="A network with a single population")
    net_doc.pulse_generators.append(pulsegen)
    net.explicit_inputs.append(exp_input)
    net.populations.append(pop)
    net_doc.networks.append(net)

    pynml.write_neuroml2_file(nml2_doc=net_doc,
                              nml2_file_name=net_doc_fn,
                              validate=True)
    return net_doc_fn
예제 #2
0
def writeConnections():
    net_id = "MuscleConnections"
    nml_network_doc = NeuroMLDocument(id=net_id)

    # Create a NeuroML Network data structure to hold on to all the neuron-
    # muscle connection info.
    net = Network(id=net_id)
    nml_network_doc.networks.append(net)

    pop0 = Population(id=muscles[0].name, component=muscles[0].name, size=1)
    inst = Instance(id="0")
    inst.location = Location(x="0.0", y="0.0", z="0.0")
    pop0.instances.append(inst)

    # put that Population into the Network data structure from above
    net.populations.append(pop0)

    for (pre_cell, post_cell, close_pairs) in connect_list:

        # take information about each connection and package it into a
        # NeuroML Projection data structure
        proj_id = "NCXLS_%s_%s" % (pre_cell, post_cell)
        proj0 = Projection(id=proj_id,
                           presynaptic_population=pre_cell,
                           postsynaptic_population=post_cell)
        #synapse=conn.synclass)
        for conn0 in close_pairs:
            proj0.connections.append(conn0)

        net.projections.append(proj0)
    nml_file = 'Output/' + net_id + '.nml'
    writers.NeuroMLWriter.write(nml_network_doc, nml_file)
예제 #3
0
def run():
    ########################   Build the network   ####################################
    
    nml_doc = NeuroMLDocument(id="IafNet")
    
    IaFCell0 = IaFCell(id="iaf0", C="1.0 nF", thresh = "-50mV", reset="-65mV", leak_conductance="10 nS", leak_reversal="-65mV")
    nml_doc.iaf_cells.append(IaFCell0)
    
    IaFCell1 = IaFCell(id="iaf1", C="1.0 nF", thresh = "-50mV", reset="-65mV", leak_conductance="20 nS", leak_reversal="-65mV")
    nml_doc.iaf_cells.append(IaFCell1)
    
    syn0 = ExpOneSynapse(id="syn0", gbase="65nS", erev="0mV", tau_decay="3ms")
    nml_doc.exp_one_synapses.append(syn0)
    
    
    net = Network(id="IafNet")
    nml_doc.networks.append(net)
    
    size0 = 5
    pop0 = Population(id="IafPop0", component=IaFCell0.id, size=size0)
    net.populations.append(pop0)
    
    size1 = 5
    pop1 = Population(id="IafPop1", component=IaFCell0.id, size=size1)
    net.populations.append(pop1)
    
    prob_connection = 0.5
    
    for pre in range(0,size0):
    
        pg = PulseGenerator(id="pulseGen_%i"%pre, delay="0ms", duration="100ms", amplitude="%f nA"%(0.1*random()))
        nml_doc.pulse_generators.append(pg)
    
        net.explicit_inputs.append(ExplicitInput(target="%s[%i]"%(pop0.id,pre), input=pg.id))
    
        for post in range(0,size1):
            # fromxx is used since from is Python keyword
            if random() <= prob_connection:
                net.synaptic_connections.append(SynapticConnection(from_="%s[%i]"%(pop0.id,pre), synapse=syn0.id, to="%s[%i]"%(pop1.id,post)))
    
    
    nml_file = 'tmp/testnet.nml'
    writers.NeuroMLWriter.write(nml_doc, nml_file)
    

    print("Written network file to: "+nml_file)


    ###### Validate the NeuroML ######    

    from utils import validateNeuroML2

    validateNeuroML2(nml_file)
예제 #4
0
def generateLEMS(population, n_units, max_amplitude, min_amplitude):
    def generatePulse(population, idx, amplitude):
        pulse = PulseGenerator(id='baseline_%s%d' % (population, idx),
                               delay='0ms',
                               duration='200ms',
                               amplitude='%.02f pA' % amplitude)
        nml_doc.pulse_generators.append(pulse)

    def generatePopulation(population, n_units, net):
        population_uc = population.upper()
        pop = Population(id='%sPop' % population,
                         component='%s' % population_uc,
                         size=n_units)
        net.populations.append(pop)

    def generateExmplicitInput(population, idx, net):
        exp_input = ExplicitInput(target='%sPop[%d]' % (population, idx),
                                  input='baseline_%s%d' % (population, idx),
                                  destination='synapses')
        net.explicit_inputs.append(exp_input)

    nml_doc = NeuroMLDocument(id='fI_%s' % population)

    # Add silent synapsis
    silent_syn = SilentSynapse(id='silent1_%s' % population)
    nml_doc.silent_synapses.append(silent_syn)

    step = (max_amplitude - min_amplitude) / n_units
    amplitudes = np.arange(min_amplitude, max_amplitude, step)

    net = Network(id='net_%s' % population)
    nml_doc.networks.append(net)
    generatePopulation('%s' % population, n_units, net)

    for idx, amplitude in enumerate(amplitudes):
        generatePulse('%s' % population, idx, amplitude)

        generateExmplicitInput('%s' % population, idx, net)

    # Write to file
    nml_file = 'fI_%s.nml' % population
    writers.NeuroMLWriter.write(nml_doc, nml_file)
    print('Written network file to: %s' % nml_file)

    # Validate the NeuroML
    from neuroml.utils import validate_neuroml2
    validate_neuroml2(nml_file)
예제 #5
0
                   leak_reversal="-65mV")

nml_doc.iaf_cells.append(IafCell1)

syn0 = ExpOneSynapse(id="syn0", gbase="65nS", erev="0mV", tau_decay="3ms")

nml_doc.exp_one_synapses.append(syn0)

pfs = PoissonFiringSynapse(id='pfs',
                           average_rate='50Hz',
                           synapse=syn0.id,
                           spike_target="./%s" % syn0.id)

nml_doc.poisson_firing_synapses.append(pfs)

net = Network(id="IafNet")

net.notes = "Netw notes"

nml_doc.networks.append(net)

size0 = 5 * scale
pop0 = Population(id="IafPop0", component=IafCell0.id, size=size0)

net.populations.append(pop0)

size1 = 5 * scale
pop1 = Population(id="IafPop1", component=IafCell0.id, size=size1)

net.populations.append(pop1)
예제 #6
0
def create_network(cell, tauSyn, syn_ex, syn_ih, inputs):

    g = 5.0  # ratio inhibitory weight/excitatory weight
    eta = 2.0  # external rate relative to threshold rate
    epsilon = 0.1  # connection probability

    order = 10
    NE = 4*order  # number of excitatory neurons
    NI = 1*order  # number of inhibitory neurons
    N_neurons = NE+NI   # number of neurons in total

    CE = int(epsilon*NE)  # number of excitatory synapses per neuron
    CI = int(epsilon*NI)  # number of inhibitory synapses per neuron
    C_tot = int(CI+CE)    # total number of synapses per neuron

    net = Network(id="net")

    nodes_ex = Population(id="nodes_ex",  component=cell.id, size=NE)
    nodes_inh = Population(id="nodes_inh", component=cell.id, size=NI)
    noise = Population(id="noise", component=inputs.id, size=1)
    net.populations.append(nodes_ex)
    net.populations.append(nodes_inh)
    net.populations.append(noise)

    g = 5.0  # ratio inhibitory weight/excitatory weight
    J = 0.1  # postsynaptic amplitude in mV
    J_unit = computePSPnorm(cell.tauMem, cell.CMem, tauSyn)
    J_ex = J / J_unit  # amplitude of excitatory postsynaptic current
    J_in = -g * J_ex   # amplitude of inhibitory postsynaptic current

    ex_ibase = str(J_ex) + 'nA'
    in_ibase = str(J_in) + 'nA'
    delay = "1.5 ms"
    
    proj = Projection(id="Proj0", synapse=syn_ex.id,
                        presynaptic_population=noise.id, 
                        postsynaptic_population=nodes_ex.id)
                        
    net.projections.append(proj)
    
    proj.connection_wds.extend(
        all_to_all(noise, nodes_ex, syn_ex, 1, delay))

    #net.synaptic_current_weight_delays.extend(
    #    all_to_all(noise, nodes_inh, synapse, in_weight, delay))
    '''
    random.seed(1234)
    sources_ex = random.random_integers(1, NE, (N_neurons, CE))
    sources_in = random.random_integers(NE+1, N_neurons, (N_neurons, CI))

    ex_ex = sources_ex[:NE] - 1
    ex_in = sources_ex[NE:] - 1
    in_ex = sources_in[:NE] - NE - 1
    in_in = sources_in[NE:] - NE - 1
    
    net.synaptic_current_weight_delays.extend(
        connect_from_list(ex_ex, 'nodes_ex', 'nodes_ex', synapse, 1, delay))

    net.synaptic_current_weight_delays.extend(
        connect_from_list(ex_in, 'nodes_ex', 'nodes_inh', synapse, 1, delay))

    net.synaptic_current_weight_delays.extend(
        connect_from_list(in_ex, 'nodes_inh', 'nodes_ex', synapse, 1, delay))

    net.synaptic_current_weight_delays.extend(
        connect_from_list(in_in, 'nodes_inh', 'nodes_inh', synapse, 1, delay))'''

    return net, ex_ibase, in_ibase
def generate_example_network(network_id,
                             numCells_exc,
                             numCells_inh,
                             x_size = 1000,
                             y_size = 100, 
                             z_size = 1000,
                             exc_group_component = "SimpleIaF",
                             inh_group_component = "SimpleIaF_inh",
                             validate = True,
                             random_seed = 1234,
                             generate_lems_simulation = False,
                             connections = True,
                             connection_probability_exc_exc =   0.4,
                             connection_probability_inh_exc =   0.4,
                             connection_probability_exc_inh =   0.4,
                             connection_probability_inh_inh =   0.4,
                             inputs = False,
                             input_firing_rate = 50, # Hz
                             input_offset_min = 0, # nA
                             input_offset_max = 0, # nA
                             num_inputs_per_exc = 4,
                             duration = 500,  # ms
                             dt = 0.05,
                             temperature="32.0 degC"):

    seed(random_seed)

    nml_doc = NeuroMLDocument(id=network_id)

    net = Network(id = network_id, 
                  type = "networkWithTemperature",
                  temperature = temperature)
                  
    net.notes = "Network generated using libNeuroML v%s"%__version__
    nml_doc.networks.append(net)
    
    for cell_comp in set([exc_group_component, inh_group_component]): # removes duplicates
        nml_doc.includes.append(IncludeType(href='%s.cell.nml'%cell_comp))

    # The names of the Exc & Inh groups/populations 
    exc_group = "Exc" 
    inh_group = "Inh" 

    # The names of the network connections 
    net_conn_exc_inh = "NetConn_Exc_Inh"
    net_conn_inh_exc = "NetConn_Inh_Exc"
    net_conn_exc_exc = "NetConn_Exc_Exc"
    net_conn_inh_inh = "NetConn_Inh_Inh"

    # The names of the synapse types (should match names at Cell Mechanism/Network tabs in neuroConstruct)
    exc_inh_syn = "AMPAR"
    inh_exc_syn = "GABAA"
    exc_exc_syn = "AMPAR"
    inh_inh_syn = "GABAA"

    for syn in [exc_inh_syn, inh_exc_syn]:
        nml_doc.includes.append(IncludeType(href='%s.synapse.nml'%syn))


    # Generate excitatory cells 

    exc_pop = Population(id=exc_group, component=exc_group_component, type="populationList", size=numCells_exc)
    net.populations.append(exc_pop)

    for i in range(0, numCells_exc) :
            index = i
            inst = Instance(id=index)
            exc_pop.instances.append(inst)
            inst.location = Location(x=str(x_size*random()), y=str(y_size*random()), z=str(z_size*random()))

    # Generate inhibitory cells
    inh_pop = Population(id=inh_group, component=inh_group_component, type="populationList", size=numCells_inh)
    net.populations.append(inh_pop)

    for i in range(0, numCells_inh) :
            index = i
            inst = Instance(id=index)
            inh_pop.instances.append(inst)
            inst.location = Location(x=str(x_size*random()), y=str(y_size*random()), z=str(z_size*random()))

    if connections:

        proj_exc_exc = Projection(id=net_conn_exc_exc, presynaptic_population=exc_group, postsynaptic_population=exc_group, synapse=exc_exc_syn)
        net.projections.append(proj_exc_exc)
        
        proj_exc_inh = Projection(id=net_conn_exc_inh, presynaptic_population=exc_group, postsynaptic_population=inh_group, synapse=exc_inh_syn)
        net.projections.append(proj_exc_inh)
        
        proj_inh_exc = Projection(id=net_conn_inh_exc, presynaptic_population=inh_group, postsynaptic_population=exc_group, synapse=inh_exc_syn)
        net.projections.append(proj_inh_exc)
        
        proj_inh_inh = Projection(id=net_conn_inh_inh, presynaptic_population=inh_group, postsynaptic_population=inh_group, synapse=inh_inh_syn)
        net.projections.append(proj_inh_inh)

        count_exc_inh = 0
        count_inh_exc = 0
        count_exc_exc = 0
        count_inh_inh = 0


        for i in range(0, numCells_exc):
            for j in range(0, numCells_inh):
                if i != j:
                    if random()<connection_probability_exc_inh:
                        add_connection(proj_exc_inh, count_exc_inh, exc_group, exc_group_component, i, 0, inh_group, inh_group_component, j, 0)
                        count_exc_inh+=1
                        
                    if random()<connection_probability_inh_exc:

                        add_connection(proj_inh_exc, count_inh_exc, inh_group, inh_group_component, j, 0, exc_group, exc_group_component, i, 0)
                        count_inh_exc+=1
                        
        for i in range(0, numCells_exc):
            for j in range(0, numCells_exc):
                if i != j:
                        
                    if random()<connection_probability_exc_exc:

                        add_connection(proj_exc_exc, count_exc_exc, exc_group, exc_group_component, i, 0, exc_group, exc_group_component, j, 0)
                        count_exc_exc+=1
                    

        for i in range(0, numCells_inh):
            for j in range(0, numCells_inh):
                if i != j:

                    if random()<connection_probability_inh_inh:

                        add_connection(proj_inh_inh, count_inh_inh, inh_group, inh_group_component, j, 0, inh_group, inh_group_component, i, 0)
                        count_inh_inh+=1

    if inputs:
        
        
        if input_firing_rate>0:
            mf_input_syn = "AMPAR"
            if mf_input_syn!=exc_inh_syn and mf_input_syn!=inh_exc_syn:
                nml_doc.includes.append(IncludeType(href='%s.synapse.nml'%mf_input_syn))

            rand_spiker_id = "input_%sHz"%input_firing_rate
            
            pfs = PoissonFiringSynapse(id=rand_spiker_id,
                                       average_rate="%s per_s"%input_firing_rate,
                                       synapse=mf_input_syn,
                                       spike_target="./%s"%mf_input_syn)

            nml_doc.poisson_firing_synapses.append(pfs)

            input_list = InputList(id="Input_0",
                                 component=rand_spiker_id,
                                 populations=exc_group)

            count = 0
            for i in range(0, numCells_exc):

                for j in range(num_inputs_per_exc):
                    input = Input(id=count, 
                                  target="../%s/%i/%s"%(exc_group, i, exc_group_component), 
                                  destination="synapses")  
                    input_list.input.append(input)

                count += 1

            net.input_lists.append(input_list)
            
        if input_offset_max != 0 or input_offset_min != 0:
            

            for i in range(0, numCells_exc):

                pg = PulseGenerator(id="PulseGenerator_%i"%i,
                                    delay="0ms",
                                    duration="%sms"%duration,
                                    amplitude="%fnA"%(input_offset_min+(input_offset_max-input_offset_min)*random()))
                nml_doc.pulse_generators.append(pg)

                input_list = InputList(id="Input_Pulse_List_%i"%i,
                                     component=pg.id,
                                     populations=exc_group)

                input = Input(id=0, 
                              target="../%s/%i/%s"%(exc_group, i, exc_group_component), 
                              destination="synapses")  
                input_list.input.append(input)


                net.input_lists.append(input_list)


    #######   Write to file  ######    

    print("Saving to file...")
    nml_file = network_id+'.net.nml'
    writers.NeuroMLWriter.write(nml_doc, nml_file)

    print("Written network file to: "+nml_file)


    if validate:

        ###### Validate the NeuroML ######    

        from neuroml.utils import validate_neuroml2
        validate_neuroml2(nml_file) 
        
    if generate_lems_simulation:
        # Create a LEMSSimulation to manage creation of LEMS file
        
        ls = LEMSSimulation("Sim_%s"%network_id, duration, dt)

        # Point to network as target of simulation
        ls.assign_simulation_target(net.id)
        
        # Include generated/existing NeuroML2 files
        ls.include_neuroml2_file('%s.cell.nml'%exc_group_component)
        ls.include_neuroml2_file('%s.cell.nml'%inh_group_component)
        ls.include_neuroml2_file(nml_file)
        

        # Specify Displays and Output Files
        disp_exc = "display_exc"
        ls.create_display(disp_exc, "Voltages Exc cells", "-80", "50")

        of_exc = 'Volts_file_exc'
        ls.create_output_file(of_exc, "v_exc.dat")
        
        disp_inh = "display_inh"
        ls.create_display(disp_inh, "Voltages Inh cells", "-80", "50")

        of_inh = 'Volts_file_inh'
        ls.create_output_file(of_inh, "v_inh.dat")

        for i in range(numCells_exc):
            quantity = "%s/%i/%s/v"%(exc_group, i, exc_group_component)
            ls.add_line_to_display(disp_exc, "Exc %i: Vm"%i, quantity, "1mV", pynml.get_next_hex_color())
            ls.add_column_to_output_file(of_exc, "v_%i"%i, quantity)
            
        for i in range(numCells_inh):
            quantity = "%s/%i/%s/v"%(inh_group, i, inh_group_component)
            ls.add_line_to_display(disp_inh, "Inh %i: Vm"%i, quantity, "1mV", pynml.get_next_hex_color())
            ls.add_column_to_output_file(of_inh, "v_%i"%i, quantity)

        # Save to LEMS XML file
        lems_file_name = ls.save_to_file()
        
    print "-----------------------------------"
                                delay='0ms',
                                duration='%sms' % duration,
                                amplitude=args.ie0,
                                period='25ms')
        nml_doc.sine_generator_dls.append(pulse)
    else:
        pulse = SineGenerator(id='mod_%s' % pop,
                              phase='0',
                              delay='0ms',
                              duration='%sms' % duration,
                              amplitude='%snA' % args.ie0,
                              period='25ms')
        nml_doc.sine_generators.append(pulse)

# Create the network
net = Network(id='net1')

net.properties.append(Property('recommended_dt_ms', dt))
net.properties.append(Property('recommended_duration_ms', duration))

nml_doc.networks.append(net)

nml_doc.includes.append(IncludeType('WC_Parameters%s.xml' % dl_str))

colours = ['1 0 0', '0 0 1']
for pop_idx, pop in enumerate(pops):
    population = Population(id='%sPop' % pop,
                            component=(pops[pop_idx]),
                            size=n_pops[pop_idx],
                            type='populationList')
    net.populations.append(population)
예제 #9
0
    return proj_id


if __name__ == "__main__":

    # Use the spreadsheet reader to give a list of all cells and a list of all connections
    # This could be replaced with a call to "DatabaseReader" or "OpenWormNeuroLexReader" in future...
    cell_names, conns = SpreadsheetDataReader.readDataFromSpreadsheet()

    net_id = "CElegansConnectome"

    nml_network_doc = NeuroMLDocument(id=net_id)

    # Create a NeuroML Network data structure to hold on to all the connection info.
    net = Network(id=net_id)
    nml_network_doc.networks.append(net)

    # To hold all Cell NeuroML objects vs. names
    all_cells = {}
    
    for cell in cell_names:
    	# build a Population data structure out of the cell name
        pop0 = Population(id=cell, component=cell, size=1)
        inst = Instance(id="0")
        # Each of these cells is at (0,0,0), i.e. segment 3D info in each cell is absolute
        inst.location = Location(x="0.0", y="0.0", z="0.0")
        pop0.instances.append(inst)
        
        # put that Population into the Network data structure from above
        net.populations.append(pop0)
def generate_granule_cell_layer(network_id,
                                x_size = 0,     # um
                                y_size = 0,     # um
                                z_size = 0,     # um
                                numCells_grc = 0,
                                numCells_gol = 0,
                                connections = True,
                                connections_method = 'random',
                                connection_probability_grc_gol =   0.2,
                                connection_probability_gol_grc =   0.1,
                                inputs = False,
                                input_firing_rate = 50, # Hz
                                num_inputs_per_grc = 4,
                                validate = True,
                                random_seed = 1234,
                                generate_lems_simulation = False,
                                max_plotted_cells_per_pop = 10,
                                duration = 500,  # ms
                                dt = 0.025,
                                temperature="32.0 degC"):

    seed(random_seed)

    nml_doc = NeuroMLDocument(id=network_id)

    net = Network(id = network_id, 
                  type = "networkWithTemperature",
                  temperature = temperature)
                  
    net.notes = "Network generated using libNeuroML v%s"%__version__
    nml_doc.networks.append(net)

    # The names of the cell type/component used in the populations (Cell Type in neuroConstruct)
    grc_group_component = "Granule_98"
    gol_group_component = "Golgi_98"

    nml_doc.includes.append(IncludeType(href='%s.cell.nml'%grc_group_component))
    nml_doc.includes.append(IncludeType(href='%s.cell.nml'%gol_group_component))

    # The names of the Exc & Inh groups/populations (Cell Group in neuroConstruct)
    grc_group = "Grans" 
    gol_group = "Golgis" 

    # The names of the network connections 
    net_conn_grc_gol = "NetConn_Grans_Golgis"
    net_conn_gol_grc = "NetConn_Golgis_Grans"

    # The names of the synapse types (should match names at Cell Mechanism/Network tabs in neuroConstruct)
    grc_gol_syn = "AMPA_GranGol"
    gol_grc_syn = "GABAA"

    for syn in [grc_gol_syn, gol_grc_syn]:
        nml_doc.includes.append(IncludeType(href='%s.synapse.nml'%syn))

        
    if network_id == 'Solinas2010':
        # Set size and cell numbers for Solinas 2010 network 
        import sys,os
        NEURON_sim_path = '../NEURON'
        sys.path.append(NEURON_sim_path)
        local_path = os.getcwd()
        os.chdir(NEURON_sim_path)
        print os.getcwd()
        import GenerateSolinas2010 as GS2010
        structure = GS2010.GenerateSolinas2010(generate=True)
        os.chdir(local_path)
        goc_data = structure['Golgis']
        grc_data = structure['Granules']
        grc_pos = grc_data['positions']['data']
        goc_pos = goc_data['positions']['data']
        numCells_grc = grc_pos.shape[0]
        numCells_gol = goc_pos.shape[0]
        
    # Generate excitatory cells 

    grc_pop = Population(id=grc_group, component=grc_group_component, type="populationList", size=numCells_grc)
    net.populations.append(grc_pop)

    for i in range(0, numCells_grc) :
            index = i
            inst = Instance(id=index)
            grc_pop.instances.append(inst)
            inst.location = Location(x=str(grc_pos[i,0]), y=str(grc_pos[i,1]), z=str(grc_pos[i,2]))

    # Generate inhibitory cells
    gol_pop = Population(id=gol_group, component=gol_group_component, type="populationList", size=numCells_gol)
    net.populations.append(gol_pop)

    for i in range(0, numCells_gol) :
            index = i
            inst = Instance(id=index)
            gol_pop.instances.append(inst)
            inst.location = Location(x=str(goc_pos[i,0]), y=str(goc_pos[i,1]), z=str(goc_pos[i,2]))
    
    if connections:

        proj_grc_gol = Projection(id=net_conn_grc_gol, presynaptic_population=grc_group, postsynaptic_population=gol_group, synapse=grc_gol_syn)
        net.projections.append(proj_grc_gol)
        proj_gol_grc = Projection(id=net_conn_gol_grc, presynaptic_population=gol_group, postsynaptic_population=grc_group, synapse=gol_grc_syn)
        net.projections.append(proj_gol_grc)

        count_grc_gol = 0
        count_gol_grc = 0

        # Generate exc -> *  connections

        def add_connection(projection, id, pre_pop, pre_component, pre_cell_id, pre_seg_id, post_pop, post_component, post_cell_id, post_seg_id):

            connection = Connection(id=id, \
                                    pre_cell_id="../%s/%i/%s"%(pre_pop, pre_cell_id, pre_component), \
                                    pre_segment_id=pre_seg_id, \
                                    pre_fraction_along=0.5,
                                    post_cell_id="../%s/%i/%s"%(post_pop, post_cell_id, post_component), \
                                    post_segment_id=post_seg_id,
                                    post_fraction_along=0.5)

            projection.connections.append(connection)

        # Connect Granule cells to Golgi cells
        for i in range(0, numCells_grc):
            # get targets for grc[i] from the structure dict
            # print 'Granule ', i , structure['Granules']['divergence_to_goc']['data'][i][1:]
            for j in structure['Granules']['divergence_to_goc']['data'][i][1:]:
                add_connection(proj_grc_gol, count_grc_gol, grc_group, grc_group_component, i, 0, gol_group, gol_group_component, j, 0)
                count_grc_gol+=1

        # Connect Golgi cells to Granule cells
        for i in range(0, numCells_gol):
            # get targets glomeruli for goc[i] from the lol in structure dict
            # print 'Golgi ', i
            # print structure['Golgis']['divergence_to_glom']['data'][i][1:]
            for k in structure['Golgis']['divergence_to_glom']['data'][i][1:]:
                # get target granule cells for glom[k] from the lol in structure dict
                # print 'Glom ', k
                # print structure['Glomeruli']['divergence_to_grc']['data'][k]
                for j in structure['Glomeruli']['divergence_to_grc']['data'][k][1:]:
                    # print 'Granule ', j
                    add_connection(proj_gol_grc, count_gol_grc, gol_group, gol_group_component, i, 0, grc_group, grc_group_component, j, 0)
                    count_gol_grc+=1

    if inputs:
        
        mf_input_syn = "MF_AMPA"
        nml_doc.includes.append(IncludeType(href='%s.synapse.nml'%mf_input_syn))
        
        rand_spiker_id = "input50Hz"
        
        
        #<poissonFiringSynapse id="Input_8" averageRate="50.0 per_s" synapse="MFSpikeSyn" spikeTarget="./MFSpikeSyn"/>
        pfs = PoissonFiringSynapse(id="input50Hz",
                                   average_rate="%s per_s"%input_firing_rate,
                                   synapse=mf_input_syn,
                                   spike_target="./%s"%mf_input_syn)
                                   
        nml_doc.poisson_firing_synapses.append(pfs)
        
        input_list = InputList(id="Input_0",
                             component=rand_spiker_id,
                             populations=grc_group)
                             
        count = 0
        for i in range(0, numCells_grc):
            
            for j in range(num_inputs_per_grc):
                input = Input(id=count, 
                              target="../%s/%i/%s"%(grc_group, i, grc_group_component), 
                              destination="synapses")  
                input_list.input.append(input)
            
            count += 1
                             
        net.input_lists.append(input_list)


    #######   Write to file  ######    

    print("Saving to file...")
    nml_file = network_id+'.net.nml'
    writers.NeuroMLWriter.write(nml_doc, nml_file)

    print("Written network file to: "+nml_file)


    if validate:

        ###### Validate the NeuroML ######    

        from neuroml.utils import validate_neuroml2
        validate_neuroml2(nml_file) 
        
    if generate_lems_simulation:
        # Create a LEMSSimulation to manage creation of LEMS file
        
        ls = LEMSSimulation("Sim_%s"%network_id, duration, dt)

        # Point to network as target of simulation
        ls.assign_simulation_target(net.id)
        
        # Include generated/existing NeuroML2 files
        ls.include_neuroml2_file('%s.cell.nml'%grc_group_component)
        ls.include_neuroml2_file('%s.cell.nml'%gol_group_component)
        ls.include_neuroml2_file(nml_file)
        

        # Specify Displays and Output Files
        disp_grc = "display_grc"
        ls.create_display(disp_grc, "Voltages Granule cells", "-95", "-38")

        of_grc = 'Volts_file_grc'
        ls.create_output_file(of_grc, "v_grc.dat")
        
        disp_gol = "display_gol"
        ls.create_display(disp_gol, "Voltages Golgi cells", "-95", "-38")

        of_gol = 'Volts_file_gol'
        ls.create_output_file(of_gol, "v_gol.dat")

        for i in range(min(numCells_grc,max_plotted_cells_per_pop)):
            quantity = "%s/%i/%s/v"%(grc_group, i, grc_group_component)
            ls.add_line_to_display(disp_grc, "GrC %i: Vm"%i, quantity, "1mV", pynml.get_next_hex_color())
            ls.add_column_to_output_file(of_grc, "v_%i"%i, quantity)
            
        for i in range(min(numCells_gol,max_plotted_cells_per_pop)):
            quantity = "%s/%i/%s/v"%(gol_group, i, gol_group_component)
            ls.add_line_to_display(disp_gol, "Golgi %i: Vm"%i, quantity, "1mV", pynml.get_next_hex_color())
            ls.add_column_to_output_file(of_gol, "v_%i"%i, quantity)

        # Save to LEMS XML file
        lems_file_name = ls.save_to_file()
        
    print "-----------------------------------"
예제 #11
0
def generatePopulationLEMS(pops, n_pops, amplitudes, baseline, sim_length,
                           delay):
    def generatePopulationProjection(from_pop, to_pop, n_from_pop, n_to_pop,
                                     w_to_from_pop, p_to_from_pop, net):
        connection_count = 0
        projection = ContinuousProjection(
            id='%s_%s' % (from_pop, to_pop),
            presynaptic_population='%sPop' % from_pop,
            postsynaptic_population='%sPop' % to_pop)
        for idx_from_pop in range(n_from_pop):
            for idx_to_pop in range(n_to_pop):
                if random.random() <= p_to_from_pop:
                    pre_comp = from_pop.upper()
                    to_comp = to_pop.upper()
                    connection = ContinuousConnectionInstanceW(
                        id=connection_count,
                        pre_cell='../%sPop/%i/%s' %
                        (from_pop, idx_from_pop, pre_comp),
                        post_cell='../%sPop/%i/%s' %
                        (to_pop, idx_to_pop, to_comp),
                        pre_component='silent1',
                        post_component='rs',
                        weight=w_to_from_pop / (p_to_from_pop * n_from_pop))
                    projection.continuous_connection_instance_ws.append(
                        connection)
                    connection_count += 1
        if connection_count > 0:
            net.continuous_projections.append(projection)

    # Connection probabilities for each pop in the population
    w_to_from_pops = np.array([[2.42, -.33, -0.80, 0], [2.97, -3.45, -2.13, 0],
                               [4.64, 0, 0, -2.79], [0.71, 0, -0.16, 0]])

    # p_to_from_pop = np.array([[1, 1,    1,     0],
    #                           [1, 1, 1,     0],
    #                           [1, 0,    0,  1],
    #                           [1, 0,  1,     0]])
    p_to_from_pop = np.array([[0.02, 1, 1, 0], [0.01, 1, 0.85, 0],
                              [0.01, 0, 0, 0.55], [0.01, 0, 0.5, 0]])

    nml_doc = NeuroMLDocument(id='RandomPopulation')

    # Add silent synapsis
    silent_syn = SilentSynapse(id='silent1')
    nml_doc.silent_synapses.append(silent_syn)

    for pop_idx, pop in enumerate(pops):
        pulse = PulseGenerator(id='baseline_%s' % pop,
                               delay='0ms',
                               duration=str(sim_length) + 'ms',
                               amplitude=amplitudes[pop_idx])
        nml_doc.pulse_generators.append(pulse)

        if pop == 'vip':
            # time point when additional current is induced
            pulse_mod = PulseGenerator(id='modVIP',
                                       delay=str(delay) + 'ms',
                                       duration=str(sim_length - delay) + 'ms',
                                       amplitude='10 pA')
            nml_doc.pulse_generators.append(pulse_mod)

    # Create the network and add the 4 different populations
    net = Network(id='net2')
    nml_doc.networks.append(net)

    colours = ['0 0 1', '1 0 0', '.5 0 .5', '0 1 0']
    centres = [(0, 0, 0), (-1200, 0, 0), (-800, 800, 0), (0, 1200, 0)]
    radii = [800, 200, 200, 200]
    # Populate the network with the 4 populations
    for pop_idx, pop in enumerate(pops):
        pop = Population(id='%sPop' % pop,
                         component=(pops[pop_idx]).upper(),
                         size=n_pops[pop_idx],
                         type='populationList')
        net.populations.append(pop)
        pop.properties.append(Property(tag='color', value=colours[pop_idx]))
        pop.properties.append(Property(tag='radius', value=10))

        for n_pop in range(n_pops[pop_idx]):
            inst = Instance(id=n_pop)
            pop.instances.append(inst)
            x, y, z = centres[pop_idx]
            r = (random.random() * radii[pop_idx]**3)**(1. / 3)
            theta = random.random() * math.pi
            phi = random.random() * math.pi * 2

            inst.location = Location(
                x=str(x + r * math.sin(theta) * math.cos(phi)),
                y=str(y + r * math.sin(theta) * math.sin(phi)),
                z=str(z + r * math.cos(theta)))

    for from_idx, from_pop in enumerate(pops):
        for to_idx, to_pop in enumerate(pops):
            generatePopulationProjection(pops[from_idx], pops[to_idx],
                                         n_pops[from_idx], n_pops[to_idx],
                                         w_to_from_pops[to_idx, from_idx],
                                         p_to_from_pop[to_idx, from_idx], net)
    # Add inputs
    for pop_idx, pop in enumerate(pops):

        input_list = InputList(id='baseline_%s' % pop,
                               component='baseline_%s' % pops[pop_idx],
                               populations='%sPop' % pop)
        net.input_lists.append(input_list)

        if pop == 'vip':
            input_list_mod = InputList(id='modulation_%s' % pop,
                                       component='modVIP',
                                       populations='%sPop' % pop)
            net.input_lists.append(input_list_mod)

        for n_idx in range(n_pops[pop_idx]):
            input = Input(id=n_idx,
                          target='../%sPop/%i/%s' % (pop, n_idx, pop.upper()),
                          destination='synapses')
            input_list.input.append(input)

            # if vip add modulatory input
            if pop == 'vip':

                mod_input = Input(id=n_idx,
                                  target='../vipPop/%i/VIP' % n_idx,
                                  destination='synapses')
                input_list_mod.input.append(mod_input)

    nml_file = 'RandomPopulationRate_%s_baseline.nml' % baseline
    writers.NeuroMLWriter.write(nml_doc, nml_file)
    print('Written network file to: %s' % nml_file)

    # Validate the NeuroML
    from neuroml.utils import validate_neuroml2
    validate_neuroml2(nml_file)
from neuroml import Location
from neuroml import Network
from neuroml import NeuroMLDocument
from neuroml import PoissonFiringSynapse
from neuroml import Population
from neuroml import Projection
from neuroml import Property
import neuroml.writers as writers
import random
import math

nml_doc = NeuroMLDocument(id="Example2")

nml_doc.notes = "Demo of cell with spines"

net = Network(id=nml_doc.id)

net.notes = nml_doc.notes

nml_doc.networks.append(net)
populations = {}


def add_instance(name, x, y, z):

    pop = populations[name]
    inst = Instance(id=len(pop.instances))
    pop.size = pop.size + 1
    pop.instances.append(inst)
    inst.location = Location(x=x, y=y, z=z)
예제 #13
0
def tune_izh_model(acq_list: List, metrics_from_data: Dict,
                   currents: Dict) -> Dict:
    """Tune networks model against the data.

    Here we generate a network with the necessary number of Izhikevich cells,
    one for each current stimulus, and tune them against the experimental data.

    :param acq_list: list of indices of acquisitions/sweeps to tune against
    :type acq_list: list
    :param metrics_from_data: dictionary with the sweep number as index, and
        the dictionary containing metrics generated from the analysis
    :type metrics_from_data: dict
    :param currents: dictionary with sweep number as index and stimulus current
        value
    """

    # length of simulation of the cells---should match the length of the
    # experiment
    sim_time = 1500.0
    # Create a NeuroML template network simulation file that we will use for
    # the tuning
    template_doc = NeuroMLDocument(id="IzhTuneNet")
    # Add an Izhikevich cell with some parameters to the document
    template_doc.izhikevich2007_cells.append(
        Izhikevich2007Cell(
            id="Izh2007",
            C="100pF",
            v0="-60mV",
            k="0.7nS_per_mV",
            vr="-60mV",
            vt="-40mV",
            vpeak="35mV",
            a="0.03per_ms",
            b="-2nS",
            c="-50.0mV",
            d="100pA",
        ))
    template_doc.networks.append(Network(id="Network0"))
    # Add a cell for each acquisition list
    popsize = len(acq_list)
    template_doc.networks[0].populations.append(
        Population(id="Pop0", component="Izh2007", size=popsize))

    # Add a current source for each cell, matching the currents that
    # were used in the experimental study.
    counter = 0
    for acq in acq_list:
        template_doc.pulse_generators.append(
            PulseGenerator(
                id="Stim{}".format(counter),
                delay="80ms",
                duration="1000ms",
                amplitude="{}pA".format(currents[acq]),
            ))
        template_doc.networks[0].explicit_inputs.append(
            ExplicitInput(target="Pop0[{}]".format(counter),
                          input="Stim{}".format(counter)))
        counter = counter + 1

    # Print a summary
    print(template_doc.summary())

    # Write to a neuroml file and validate it.
    reference = "TuneIzhFergusonPyr3"
    template_filename = "{}.net.nml".format(reference)
    write_neuroml2_file(template_doc, template_filename, validate=True)

    # Now for the tuning bits

    # format is type:id/variable:id/units
    # supported types: cell/channel/izhikevich2007cell
    # supported variables:
    #  - channel: vShift
    #  - cell: channelDensity, vShift_channelDensity, channelDensityNernst,
    #  erev_id, erev_ion, specificCapacitance, resistivity
    #  - izhikevich2007Cell: all available attributes

    # we want to tune these parameters within these ranges
    # param: (min, max)
    parameters = {
        "izhikevich2007Cell:Izh2007/C/pF": (100, 300),
        "izhikevich2007Cell:Izh2007/k/nS_per_mV": (0.01, 2),
        "izhikevich2007Cell:Izh2007/vr/mV": (-70, -50),
        "izhikevich2007Cell:Izh2007/vt/mV": (-60, 0),
        "izhikevich2007Cell:Izh2007/vpeak/mV": (35, 70),
        "izhikevich2007Cell:Izh2007/a/per_ms": (0.001, 0.4),
        "izhikevich2007Cell:Izh2007/b/nS": (-10, 10),
        "izhikevich2007Cell:Izh2007/c/mV": (-65, -10),
        "izhikevich2007Cell:Izh2007/d/pA": (50, 500),
    }  # type: Dict[str, Tuple[float, float]]

    # Set up our target data and so on
    ctr = 0
    target_data = {}
    weights = {}
    for acq in acq_list:
        # data to fit to:
        # format: path/to/variable:metric
        # metric from pyelectro, for example:
        # https://pyelectro.readthedocs.io/en/latest/pyelectro.html?highlight=mean_spike_frequency#pyelectro.analysis.mean_spike_frequency
        mean_spike_frequency = "Pop0[{}]/v:mean_spike_frequency".format(ctr)
        average_last_1percent = "Pop0[{}]/v:average_last_1percent".format(ctr)
        first_spike_time = "Pop0[{}]/v:first_spike_time".format(ctr)

        # each metric can have an associated weight
        weights[mean_spike_frequency] = 1
        weights[average_last_1percent] = 1
        weights[first_spike_time] = 1

        # value of the target data from our data set
        target_data[mean_spike_frequency] = metrics_from_data[acq][
            "{}:mean_spike_frequency".format(acq)]
        target_data[average_last_1percent] = metrics_from_data[acq][
            "{}:average_last_1percent".format(acq)]
        target_data[first_spike_time] = metrics_from_data[acq][
            "{}:first_spike_time".format(acq)]

        # only add these if the experimental data includes them
        # these are only generated for traces with spikes
        if "{}:average_maximum".format(acq) in metrics_from_data[acq]:
            average_maximum = "Pop0[{}]/v:average_maximum".format(ctr)
            weights[average_maximum] = 1
            target_data[average_maximum] = metrics_from_data[acq][
                "{}:average_maximum".format(acq)]
        if "{}:average_minimum".format(acq) in metrics_from_data[acq]:
            average_minimum = "Pop0[{}]/v:average_minimum".format(ctr)
            weights[average_minimum] = 1
            target_data[average_minimum] = metrics_from_data[acq][
                "{}:average_minimum".format(acq)]

        ctr = ctr + 1

    # simulator to use
    simulator = "jNeuroML"

    return run_optimisation(
        # Prefix for new files
        prefix="TuneIzh",
        # Name of the NeuroML template file
        neuroml_file=template_filename,
        # Name of the network
        target="Network0",
        # Parameters to be fitted
        parameters=list(parameters.keys()),
        # Our max and min constraints
        min_constraints=[v[0] for v in parameters.values()],
        max_constraints=[v[1] for v in parameters.values()],
        # Weights we set for parameters
        weights=weights,
        # The experimental metrics to fit to
        target_data=target_data,
        # Simulation time
        sim_time=sim_time,
        # EC parameters
        population_size=100,
        max_evaluations=500,
        num_selected=30,
        num_offspring=50,
        mutation_rate=0.9,
        num_elites=3,
        # Seed value
        seed=12345,
        # Simulator
        simulator=simulator,
        dt=0.025,
        show_plot_already='-nogui' not in sys.argv,
        save_to_file="fitted_izhikevich_fitness.png",
        save_to_file_scatter="fitted_izhikevich_scatter.png",
        save_to_file_hist="fitted_izhikevich_hist.png",
        save_to_file_output="fitted_izhikevich_output.png",
        num_parallel_evaluations=4,
    )
예제 #14
0
def run_fitted_cell_simulation(sweeps_to_tune_against: List,
                               tuning_report: Dict,
                               simulation_id: str) -> None:
    """Run a simulation with the values obtained from the fitting

    :param tuning_report: tuning report from the optimser
    :type tuning_report: Dict
    :param simulation_id: text id of simulation
    :type simulation_id: str

    """
    # get the fittest variables
    fittest_vars = tuning_report["fittest vars"]
    C = str(fittest_vars["izhikevich2007Cell:Izh2007/C/pF"]) + "pF"
    k = str(
        fittest_vars["izhikevich2007Cell:Izh2007/k/nS_per_mV"]) + "nS_per_mV"
    vr = str(fittest_vars["izhikevich2007Cell:Izh2007/vr/mV"]) + "mV"
    vt = str(fittest_vars["izhikevich2007Cell:Izh2007/vt/mV"]) + "mV"
    vpeak = str(fittest_vars["izhikevich2007Cell:Izh2007/vpeak/mV"]) + "mV"
    a = str(fittest_vars["izhikevich2007Cell:Izh2007/a/per_ms"]) + "per_ms"
    b = str(fittest_vars["izhikevich2007Cell:Izh2007/b/nS"]) + "nS"
    c = str(fittest_vars["izhikevich2007Cell:Izh2007/c/mV"]) + "mV"
    d = str(fittest_vars["izhikevich2007Cell:Izh2007/d/pA"]) + "pA"

    # Create a simulation using our obtained parameters.
    # Note that the tuner generates a graph with the fitted values already, but
    # we want to keep a copy of our fitted cell also, so we'll create a NeuroML
    # Document ourselves also.
    sim_time = 1500.0
    simulation_doc = NeuroMLDocument(id="FittedNet")
    # Add an Izhikevich cell with some parameters to the document
    simulation_doc.izhikevich2007_cells.append(
        Izhikevich2007Cell(
            id="Izh2007",
            C=C,
            v0="-60mV",
            k=k,
            vr=vr,
            vt=vt,
            vpeak=vpeak,
            a=a,
            b=b,
            c=c,
            d=d,
        ))
    simulation_doc.networks.append(Network(id="Network0"))
    # Add a cell for each acquisition list
    popsize = len(sweeps_to_tune_against)
    simulation_doc.networks[0].populations.append(
        Population(id="Pop0", component="Izh2007", size=popsize))

    # Add a current source for each cell, matching the currents that
    # were used in the experimental study.
    counter = 0
    for acq in sweeps_to_tune_against:
        simulation_doc.pulse_generators.append(
            PulseGenerator(
                id="Stim{}".format(counter),
                delay="80ms",
                duration="1000ms",
                amplitude="{}pA".format(currents[acq]),
            ))
        simulation_doc.networks[0].explicit_inputs.append(
            ExplicitInput(target="Pop0[{}]".format(counter),
                          input="Stim{}".format(counter)))
        counter = counter + 1

    # Print a summary
    print(simulation_doc.summary())

    # Write to a neuroml file and validate it.
    reference = "FittedIzhFergusonPyr3"
    simulation_filename = "{}.net.nml".format(reference)
    write_neuroml2_file(simulation_doc, simulation_filename, validate=True)

    simulation = LEMSSimulation(
        sim_id=simulation_id,
        duration=sim_time,
        dt=0.1,
        target="Network0",
        simulation_seed=54321,
    )
    simulation.include_neuroml2_file(simulation_filename)
    simulation.create_output_file("output0", "{}.v.dat".format(simulation_id))
    counter = 0
    for acq in sweeps_to_tune_against:
        simulation.add_column_to_output_file("output0",
                                             "Pop0[{}]".format(counter),
                                             "Pop0[{}]/v".format(counter))
        counter = counter + 1
    simulation_file = simulation.save_to_file()
    # simulate
    run_lems_with_jneuroml(simulation_file,
                           max_memory="2G",
                           nogui=True,
                           plot=False)
예제 #15
0
def run():

    cell_num = 10
    x_size = 500
    y_size = 500
    z_size = 500

    nml_doc = NeuroMLDocument(id="Net3DExample")

    syn0 = ExpOneSynapse(id="syn0", gbase="65nS", erev="0mV", tau_decay="3ms")
    nml_doc.exp_one_synapses.append(syn0)

    net = Network(id="Net3D")
    nml_doc.networks.append(net)

    proj_count = 0
    #conn_count = 0

    for cell_id in range(0, cell_num):

        cell = Cell(id="Cell_%i" % cell_id)

        cell.morphology = generateRandomMorphology()

        nml_doc.cells.append(cell)

        pop = Population(id="Pop_%i" % cell_id,
                         component=cell.id,
                         type="populationList")
        net.populations.append(pop)
        pop.properties.append(Property(tag="color", value="1 0 0"))

        inst = Instance(id="0")
        pop.instances.append(inst)

        inst.location = Location(x=str(x_size * random()),
                                 y=str(y_size * random()),
                                 z=str(z_size * random()))

        prob_connection = 0.5
        for post in range(0, cell_num):
            if post is not cell_id and random() <= prob_connection:

                from_pop = "Pop_%i" % cell_id
                to_pop = "Pop_%i" % post

                pre_seg_id = 0
                post_seg_id = 1

                projection = Projection(id="Proj_%i" % proj_count,
                                        presynaptic_population=from_pop,
                                        postsynaptic_population=to_pop,
                                        synapse=syn0.id)
                net.projections.append(projection)
                connection = Connection(id=proj_count, \
                                        pre_cell_id="%s[%i]"%(from_pop,0), \
                                        pre_segment_id=pre_seg_id, \
                                        pre_fraction_along=random(),
                                        post_cell_id="%s[%i]"%(to_pop,0), \
                                        post_segment_id=post_seg_id,
                                        post_fraction_along=random())

                projection.connections.append(connection)
                proj_count += 1
                #net.synaptic_connections.append(SynapticConnection(from_="%s[%i]"%(from_pop,0),  to="%s[%i]"%(to_pop,0)))

    #######   Write to file  ######

    nml_file = 'tmp/net3d.nml'
    writers.NeuroMLWriter.write(nml_doc, nml_file)

    print("Written network file to: " + nml_file)

    ###### Validate the NeuroML ######

    from neuroml.utils import validate_neuroml2

    validate_neuroml2(nml_file)
예제 #16
0
                         conductance="0.5pS",
                         delta="5mV",
                         Vth="-55mV",
                         k="0.025per_ms",
                         erev="0mV")
nml_doc.graded_synapses.append(grad_syn)

pfs = PoissonFiringSynapse(id='pfs',
                           average_rate='150Hz',
                           synapse=syn0.id,
                           spike_target="./%s" % syn0.id)

nml_doc.poisson_firing_synapses.append(pfs)

net = Network(id="CompleteNet",
              type="networkWithTemperature",
              temperature="6.3 degC")

net.notes = "Network notes..."

nml_doc.networks.append(net)

size0 = int(5 * scale)
pop0 = Population(id="IafPop0", component=IafCell0.id, size=size0)

net.populations.append(pop0)

size1 = int(5 * scale)
pop1 = Population(id="IafPop1", component=IafCell1.id, size=size1)

net.populations.append(pop1)
def generate_granule_cell_layer(network_id,
                                x_size,     # um
                                y_size,     # um
                                z_size,     # um
                                numCells_mf,
                                numCells_grc,
                                numCells_gol,
                                mf_group_component = "MossyFiber",
                                grc_group_component = "Granule_98",
                                gol_group_component = "Golgi_98",
                                connections = True,
                                connection_probability_grc_gol =   0.2,
                                connection_probability_gol_grc =   0.1,
                                inputs = False,
                                input_firing_rate = 50, # Hz
                                num_inputs_per_mf = 4,
                                validate = True,
                                random_seed = 1234,
                                generate_lems_simulation = False,
                                duration = 500,  # ms
                                dt = 0.005,
                                temperature="32.0 degC"):

    seed(random_seed)

    nml_doc = NeuroMLDocument(id=network_id)

    net = Network(id = network_id, 
                  type = "networkWithTemperature",
                  temperature = temperature)
                  
    net.notes = "Network generated using libNeuroML v%s"%__version__
    nml_doc.networks.append(net)

    if numCells_mf>0:
        nml_doc.includes.append(IncludeType(href='%s.cell.nml'%mf_group_component))
    if numCells_grc>0:
        nml_doc.includes.append(IncludeType(href='%s.cell.nml'%grc_group_component))
    if numCells_gol>0:
        nml_doc.includes.append(IncludeType(href='%s.cell.nml'%gol_group_component))

    # The names of the groups/populations 
    mf_group = "MossyFibers" 
    grc_group = "Grans" 
    gol_group = "Golgis" 


    # The names of the synapse types (should match names at Cell Mechanism/Network tabs in neuroConstruct)=
    mf_grc_syn = "MF_AMPA"
    grc_gol_syn = "AMPA_GranGol"
    gol_grc_syn = "GABAA"

    for syn in [mf_grc_syn, grc_gol_syn, gol_grc_syn]:
        nml_doc.includes.append(IncludeType(href='%s.synapse.nml'%syn))


    # Generate Gran cells 
    if numCells_mf>0:
        add_population_in_rectangular_region(net, mf_group, mf_group_component, numCells_mf, 0, 0, 0, x_size, y_size, z_size, color="0 0 1")
        

    # Generate Gran cells 
    if numCells_grc>0:
        add_population_in_rectangular_region(net, grc_group, grc_group_component, numCells_grc, 0, 0, 0, x_size, y_size, z_size, color="1 0 0")
        
        
    # Generate Golgi cells
    if numCells_gol>0:
        add_population_in_rectangular_region(net, gol_group, gol_group_component, numCells_gol, 0, 0, 0, x_size, y_size, z_size, color="0 1 0")

    if connections:

        add_probabilistic_projection(net, mf_group, mf_group_component, grc_group, grc_group_component, 'NetConn', mf_grc_syn, numCells_mf, numCells_grc, 0.01)
    
        add_probabilistic_projection(net, grc_group, grc_group_component, gol_group, gol_group_component, 'NetConn', grc_gol_syn, numCells_grc, numCells_gol, connection_probability_grc_gol)
        
        add_probabilistic_projection(net, gol_group, gol_group_component, grc_group, grc_group_component, 'NetConn', gol_grc_syn, numCells_gol, numCells_grc, connection_probability_gol_grc)
    

    if inputs:
        
        mf_input_syn = "MFSpikeSyn"
        nml_doc.includes.append(IncludeType(href='%s.synapse.nml'%mf_input_syn))
        
        rand_spiker_id = "input%sHz"%input_firing_rate
        
        
        #<poissonFiringSynapse id="Input_8" averageRate="50.0 per_s" synapse="MFSpikeSyn" spikeTarget="./MFSpikeSyn"/>
        pfs = PoissonFiringSynapse(id=rand_spiker_id,
                                   average_rate="%s per_s"%input_firing_rate,
                                   synapse=mf_input_syn,
                                   spike_target="./%s"%mf_input_syn)
                                   
        nml_doc.poisson_firing_synapses.append(pfs)
        
        input_list = InputList(id="Input_0",
                             component=rand_spiker_id,
                             populations=mf_group)
                             
        count = 0
        for i in range(0, numCells_mf):
            
            for j in range(num_inputs_per_mf):
                input = Input(id=count, 
                              target="../%s/%i/%s"%(mf_group, i, mf_group_component), 
                              destination="synapses")  
                input_list.input.append(input)
            
            count += 1
                             
        net.input_lists.append(input_list)


    #######   Write to file  ######    

    print("Saving to file...")
    nml_file = network_id+'.net.nml'
    writers.NeuroMLWriter.write(nml_doc, nml_file)

    print("Written network file to: "+nml_file)


    if validate:

        ###### Validate the NeuroML ######    

        from neuroml.utils import validate_neuroml2
        validate_neuroml2(nml_file) 
        
    if generate_lems_simulation:
        # Create a LEMSSimulation to manage creation of LEMS file
        
        ls = LEMSSimulation("Sim_%s"%network_id, duration, dt)

        # Point to network as target of simulation
        ls.assign_simulation_target(net.id)
        
        # Include generated/existing NeuroML2 files
        ls.include_neuroml2_file('%s.cell.nml'%grc_group_component)
        ls.include_neuroml2_file('%s.cell.nml'%gol_group_component)
        ls.include_neuroml2_file(nml_file)
        

        # Specify Displays and Output Files
        if numCells_mf>0:
            disp_mf = "display_mf"
            ls.create_display(disp_mf, "Voltages Mossy fibers", "-70", "10")

            of_mf = 'Volts_file_mf'
            ls.create_output_file(of_mf, "v_mf.dat")


            for i in range(numCells_mf):
                quantity = "%s/%i/%s/v"%(mf_group, i, mf_group_component)
                ls.add_line_to_display(disp_mf, "MF %i: Vm"%i, quantity, "1mV", pynml.get_next_hex_color())
                ls.add_column_to_output_file(of_mf, "v_%i"%i, quantity)

        # Specify Displays and Output Files
        if numCells_grc>0:
            disp_grc = "display_grc"
            ls.create_display(disp_grc, "Voltages Granule cells", "-75", "30")

            of_grc = 'Volts_file_grc'
            ls.create_output_file(of_grc, "v_grc.dat")


            for i in range(numCells_grc):
                quantity = "%s/%i/%s/v"%(grc_group, i, grc_group_component)
                ls.add_line_to_display(disp_grc, "GrC %i: Vm"%i, quantity, "1mV", pynml.get_next_hex_color())
                ls.add_column_to_output_file(of_grc, "v_%i"%i, quantity)
        
        if numCells_gol>0:
            disp_gol = "display_gol"
            ls.create_display(disp_gol, "Voltages Golgi cells", "-75", "30")

            of_gol = 'Volts_file_gol'
            ls.create_output_file(of_gol, "v_gol.dat")

            for i in range(numCells_gol):
                quantity = "%s/%i/%s/v"%(gol_group, i, gol_group_component)
                ls.add_line_to_display(disp_gol, "Golgi %i: Vm"%i, quantity, "1mV", pynml.get_next_hex_color())
                ls.add_column_to_output_file(of_gol, "v_%i"%i, quantity)

        # Save to LEMS XML file
        lems_file_name = ls.save_to_file()
    else:
        
        ls = None
        
    print "-----------------------------------"
    
    return nml_doc, ls
예제 #18
0
syn0 = ExpOneSynapse(id="syn0",
                     gbase="65nS",
                     erev="0mV",
                     tau_decay="3ms")

nml_doc.exp_one_synapses.append(syn0)


pfs = PoissonFiringSynapse(id='pfs',
                                   average_rate='50Hz',
                                   synapse=syn0.id, 
                                   spike_target="./%s"%syn0.id)

nml_doc.poisson_firing_synapses.append(pfs)

net = Network(id="IafNet")

net.notes = "Netw notes"

nml_doc.networks.append(net)

size0 = 5*scale
pop0 = Population(id="IafPop0",
                  component=IafCell0.id,
                  size=size0)

net.populations.append(pop0)

size1 = 5*scale
pop1 = Population(id="IafPop1",
                  component=IafCell0.id,
예제 #19
0
                         v0="-60mV",
                         C="100pF",
                         k="0.7nS_per_mV",
                         vr="-60mV",
                         vt="-40mV",
                         vpeak="35mV",
                         a="0.03per_ms",
                         b="-2nS",
                         c="-50.0mV",
                         d="100pA")
nml_doc.izhikevich2007_cells.append(iz0)

syn0 = ExpOneSynapse(id="syn0", gbase="65nS", erev="0mV", tau_decay="3ms")
nml_doc.exp_one_synapses.append(syn0)

net = Network(id="IzNet")
nml_doc.networks.append(net)

size0 = 5
pop0 = Population(id="IzPop0", component=iz0.id, size=size0)
# Set optional color property. Note: used later when generating graphs etc.
pop0.properties.append(Property(tag='color', value='0 0 .8'))
net.populations.append(pop0)

size1 = 5
pop1 = Population(id="IzPop1", component=iz0.id, size=size1)
pop1.properties.append(Property(tag='color', value='.8 0 0'))
net.populations.append(pop1)

proj = Projection(id='proj',
                  presynaptic_population=pop0.id,
예제 #20
0
def generate(net_id,
             params,
             cells = None,
             cells_to_plot = None,
             cells_to_stimulate = None,
             include_muscles=False,
             conn_number_override = None,
             conn_number_scaling = None,
             duration = 500,
             dt = 0.01,
             vmin = -75,
             vmax = 20,
             seed = 1234,
             validate=True, test=False):

    random.seed(seed)

    info = "\n\nParameters and setting used to generate this network:\n\n"+\
           "    Cells:                         %s\n" % (cells if cells is not None else "All cells")+\
           "    Cell stimulated:               %s\n" % (cells_to_stimulate if cells_to_stimulate is not None else "All cells")+\
           "    Connection numbers overridden: %s\n" % (conn_number_override if conn_number_override is not None else "None")+\
           "    Connection numbers scaled:     %s\n" % (conn_number_scaling if conn_number_scaling is not None else "None")+\
           "    Include muscles:               %s\n" % include_muscles
    info += "\n%s\n"%(bioparameter_info("    "))

    nml_doc = NeuroMLDocument(id=net_id, notes=info)

    nml_doc.iaf_cells.append(params.generic_cell)

    net = Network(id=net_id)


    nml_doc.networks.append(net)

    nml_doc.pulse_generators.append(params.offset_current)

    # Use the spreadsheet reader to give a list of all cells and a list of all connections
    # This could be replaced with a call to "DatabaseReader" or "OpenWormNeuroLexReader" in future...
    # If called from unittest folder ammend path to "../../../../"
    spreadsheet_location = "../../../../" if test else "../../../"

    cell_names, conns = SpreadsheetDataReader.readDataFromSpreadsheet(spreadsheet_location, include_nonconnected_cells=True)

    cell_names.sort()

    # To hold all Cell NeuroML objects vs. names
    all_cells = {}

    # lems_file = ""
    lems_info = {"comment":    info,
                 "reference":  net_id,
                 "duration":   duration,
                 "dt":         dt,
                 "vmin":       vmin,
                 "vmax":       vmax,
                 "cell_component":    params.generic_cell.id}

    lems_info["plots"] = []
    lems_info["activity_plots"] = []
    lems_info["muscle_plots"] = []
    lems_info["muscle_activity_plots"] = []

    lems_info["to_save"] = []
    lems_info["activity_to_save"] = []
    lems_info["muscles_to_save"] = []
    lems_info["muscles_activity_to_save"] = []
    lems_info["cells"] = []
    lems_info["muscles"] = []
    lems_info["includes"] = []

    if hasattr(params.generic_cell, 'custom_component_type_definition'):
        lems_info["includes"].append(params.generic_cell.custom_component_type_definition)

    backers_dir = "../../../../OpenWormBackers/" if test else "../../../OpenWormBackers/"
    sys.path.append(backers_dir)
    import backers
    cells_vs_name = backers.get_adopted_cell_names(backers_dir)

    populations_without_location = isinstance(params.elec_syn, GapJunction)

    count = 0
    for cell in cell_names:

        if cells is None or cell in cells:

            inst = Instance(id="0")

            if not populations_without_location:
                # build a Population data structure out of the cell name
                pop0 = Population(id=cell,
                                  component=params.generic_cell.id,
                                  type="populationList")
                pop0.instances.append(inst)

            else:
                # build a Population data structure out of the cell name
                pop0 = Population(id=cell,
                                  component=params.generic_cell.id,
                                  size="1")


            # put that Population into the Network data structure from above
            net.populations.append(pop0)

            if cells_vs_name.has_key(cell):
                p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[cell])
                pop0.properties.append(p)

            # also use the cell name to grab the morphology file, as a NeuroML data structure
            #  into the 'all_cells' dict
            cell_file_path = "../../../" if test else "../../" #if running test
            cell_file = cell_file_path+'generatedNeuroML2/%s.nml'%cell
            doc = loaders.NeuroMLLoader.load(cell_file)
            all_cells[cell] = doc.cells[0]
            location = doc.cells[0].morphology.segments[0].proximal
            print("Loaded morphology file from: %s, with id: %s, location: (%s, %s, %s)"%(cell_file, all_cells[cell].id, location.x, location.y, location.z))


            inst.location = Location(float(location.x), float(location.y), float(location.z))

            target = "%s/0/%s"%(pop0.id, params.generic_cell.id)
            if populations_without_location:
                target = "%s[0]" % (cell)

            exp_input = ExplicitInput(target=target, input=params.offset_current.id)

            if cells_to_stimulate is None or cell in cells_to_stimulate:
                net.explicit_inputs.append(exp_input)

            if cells_to_plot is None or cell in cells_to_plot:
                plot = {}

                plot["cell"] = cell
                plot["colour"] = get_random_colour_hex()
                plot["quantity"] = "%s/0/%s/v" % (cell, params.generic_cell.id)
                if populations_without_location:
                    plot["quantity"] = "%s[0]/v" % (cell)
                lems_info["plots"].append(plot)

                if hasattr(params.generic_cell, 'custom_component_type_definition'):
                    plot = {}

                    plot["cell"] = cell
                    plot["colour"] = get_random_colour_hex()
                    plot["quantity"] = "%s/0/%s/activity" % (cell, params.generic_cell.id)
                    if populations_without_location:
                        plot["quantity"] = "%s[0]/activity" % (cell)
                    lems_info["activity_plots"].append(plot)

            save = {}
            save["cell"] = cell
            save["quantity"] = "%s/0/%s/v" % (cell, params.generic_cell.id)
            if populations_without_location:
                save["quantity"] = "%s[0]/v" % (cell)
            lems_info["to_save"].append(save)

            if hasattr(params.generic_cell, 'custom_component_type_definition'):
                save = {}
                save["cell"] = cell
                save["quantity"] = "%s/0/%s/activity" % (cell, params.generic_cell.id)
                if populations_without_location:
                    save["quantity"] = "%s[0]/activity" % (cell)
                lems_info["activity_to_save"].append(save)

            lems_info["cells"].append(cell)

            count+=1

    print("Finished loading %i cells"%count)

    mneurons, all_muscles, muscle_conns = SpreadsheetDataReader.readMuscleDataFromSpreadsheet(spreadsheet_location)

    muscles = get_muscle_names()

    if include_muscles:

        muscle_count = 0
        for muscle in muscles:

            inst = Instance(id="0")

            if not populations_without_location:
                # build a Population data structure out of the cell name
                pop0 = Population(id=muscle,
                                  component=params.generic_cell.id,
                                  type="populationList")
                pop0.instances.append(inst)

            else:
                # build a Population data structure out of the cell name
                pop0 = Population(id=muscle,
                                  component=params.generic_cell.id,
                                  size="1")

            # put that Population into the Network data structure from above
            net.populations.append(pop0)

            if cells_vs_name.has_key(muscle):
                # No muscles adopted yet, but just in case they are in future...
                p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[muscle])
                pop0.properties.append(p)

            inst.location = Location(100, 10*muscle_count, 100)

            target = "%s/0/%s"%(pop0.id, params.generic_cell.id)
            if populations_without_location:
                target = "%s[0]" % (muscle)

            plot = {}

            plot["cell"] = muscle
            plot["colour"] = get_random_colour_hex()
            plot["quantity"] = "%s/0/%s/v" % (muscle, params.generic_cell.id)
            if populations_without_location:
                plot["quantity"] = "%s[0]/v" % (muscle)
            lems_info["muscle_plots"].append(plot)

            if hasattr(params.generic_cell, 'custom_component_type_definition'):
                plot = {}

                plot["cell"] = muscle
                plot["colour"] = get_random_colour_hex()
                plot["quantity"] = "%s/0/%s/activity" % (muscle, params.generic_cell.id)
                if populations_without_location:
                    plot["quantity"] = "%s[0]/activity" % (muscle)
                lems_info["muscle_activity_plots"].append(plot)

            save = {}
            save["cell"] = muscle
            save["quantity"] = "%s/0/%s/v" % (muscle, params.generic_cell.id)
            if populations_without_location:
                save["quantity"] = "%s[0]/v" % (muscle)
            lems_info["muscles_to_save"].append(save)

            if hasattr(params.generic_cell, 'custom_component_type_definition'):
                save = {}
                save["cell"] = muscle
                save["quantity"] = "%s/0/%s/activity" % (muscle, params.generic_cell.id)
                if populations_without_location:
                    save["quantity"] = "%s[0]/activity" % (muscle)
                lems_info["muscles_activity_to_save"].append(save)

            lems_info["muscles"].append(muscle)

            muscle_count+=1

        print("Finished creating %i muscles"%muscle_count)

    for conn in conns:

        if conn.pre_cell in lems_info["cells"] and conn.post_cell in lems_info["cells"]:
            # take information about each connection and package it into a
            # NeuroML Projection data structure
            proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype)

            elect_conn = False
            syn0 = params.exc_syn
            if 'GABA' in conn.synclass:
                syn0 = params.inh_syn
            if '_GJ' in conn.synclass:
                syn0 = params.elec_syn
                elect_conn = isinstance(params.elec_syn, GapJunction)

            number_syns = conn.number
            conn_shorthand = "%s-%s"%(conn.pre_cell, conn.post_cell)

            if conn_number_override is not None and (conn_number_override.has_key(conn_shorthand)):
                number_syns = conn_number_override[conn_shorthand]
            elif conn_number_scaling is not None and (conn_number_scaling.has_key(conn_shorthand)):
                number_syns = conn.number*conn_number_scaling[conn_shorthand]
            '''
            else:
                print conn_shorthand
                print conn_number_override
                print conn_number_scaling'''

            if number_syns != conn.number:
                magnitude, unit = split_neuroml_quantity(syn0.gbase)
                cond0 = "%s%s"%(magnitude*conn.number, unit)
                cond1 = "%s%s"%(magnitude*number_syns, unit)
                print(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
                     (conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1))


            syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc)

            if not elect_conn:

                if not populations_without_location:
                    proj0 = Projection(id=proj_id, \
                                       presynaptic_population=conn.pre_cell,
                                       postsynaptic_population=conn.post_cell,
                                       synapse=syn_new.id)

                    net.projections.append(proj0)

                    # Add a Connection with the closest locations

                    pre_cell_id="../%s/0/%s"%(conn.pre_cell, params.generic_cell.id)
                    post_cell_id="../%s/0/%s"%(conn.post_cell, params.generic_cell.id)

                    conn0 = Connection(id="0", \
                               pre_cell_id=pre_cell_id,
                               post_cell_id=post_cell_id)

                    proj0.connections.append(conn0)

                if populations_without_location:
                    #         <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/>
                    pre_cell_id="%s[0]"%(conn.pre_cell)
                    post_cell_id="%s[0]"%(conn.post_cell)

                    conn0 = SynapticConnection(from_=pre_cell_id,
                               to=post_cell_id,
                               synapse=syn_new.id,
                               destination="synapses")

                    net.synaptic_connections.append(conn0)


            else:
                proj0 = ElectricalProjection(id=proj_id, \
                                   presynaptic_population=conn.pre_cell,
                                   postsynaptic_population=conn.post_cell)

                net.electrical_projections.append(proj0)

                # Add a Connection with the closest locations
                conn0 = ElectricalConnection(id="0", \
                           pre_cell="0",
                           post_cell="0",
                           synapse=syn_new.id)

                proj0.electrical_connections.append(conn0)


    if include_muscles:
      for conn in muscle_conns:

        if conn.pre_cell in lems_info["cells"] and conn.post_cell in muscles:
            # take information about each connection and package it into a
            # NeuroML Projection data structure
            proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype)

            elect_conn = False
            syn0 = params.exc_syn
            if 'GABA' in conn.synclass:
                syn0 = params.inh_syn
            if '_GJ' in conn.synclass:
                syn0 = params.elec_syn
                elect_conn = isinstance(params.elec_syn, GapJunction)

            number_syns = conn.number
            conn_shorthand = "%s-%s"%(conn.pre_cell, conn.post_cell)

            if conn_number_override is not None and (conn_number_override.has_key(conn_shorthand)):
                number_syns = conn_number_override[conn_shorthand]
            elif conn_number_scaling is not None and (conn_number_scaling.has_key(conn_shorthand)):
                number_syns = conn.number*conn_number_scaling[conn_shorthand]
            '''
            else:
                print conn_shorthand
                print conn_number_override
                print conn_number_scaling'''

            if number_syns != conn.number:
                magnitude, unit = split_neuroml_quantity(syn0.gbase)
                cond0 = "%s%s"%(magnitude*conn.number, unit)
                cond1 = "%s%s"%(magnitude*number_syns, unit)
                print(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
                     (conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1))


            syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc)

            if not elect_conn:

                if not populations_without_location:
                    proj0 = Projection(id=proj_id, \
                                       presynaptic_population=conn.pre_cell,
                                       postsynaptic_population=conn.post_cell,
                                       synapse=syn_new.id)

                    net.projections.append(proj0)

                    # Add a Connection with the closest locations

                    pre_cell_id="../%s/0/%s"%(conn.pre_cell, params.generic_cell.id)
                    post_cell_id="../%s/0/%s"%(conn.post_cell, params.generic_cell.id)

                    conn0 = Connection(id="0", \
                               pre_cell_id=pre_cell_id,
                               post_cell_id=post_cell_id)

                    proj0.connections.append(conn0)

                if populations_without_location:
                    #         <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/>
                    pre_cell_id="%s[0]"%(conn.pre_cell)
                    post_cell_id="%s[0]"%(conn.post_cell)

                    conn0 = SynapticConnection(from_=pre_cell_id,
                               to=post_cell_id,
                               synapse=syn_new.id,
                               destination="synapses")

                    net.synaptic_connections.append(conn0)


            else:
                proj0 = ElectricalProjection(id=proj_id, \
                                   presynaptic_population=conn.pre_cell,
                                   postsynaptic_population=conn.post_cell)

                net.electrical_projections.append(proj0)

                # Add a Connection with the closest locations
                conn0 = ElectricalConnection(id="0", \
                           pre_cell="0",
                           post_cell="0",
                           synapse=syn_new.id)

                proj0.electrical_connections.append(conn0)

    # import pprint
    # pprint.pprint(lems_info)
    template_path = '../' if test else '' # if running test
    write_to_file(nml_doc, lems_info, net_id, template_path, validate=validate)


    return nml_doc
예제 #21
0
def generate(net_id,
             params,
             data_reader = "SpreadsheetDataReader",
             cells = None,
             cells_to_plot = None,
             cells_to_stimulate = None,
             muscles_to_include=[],
             conns_to_include=[],
             conn_number_override = None,
             conn_number_scaling = None,
             conn_polarity_override = None,
             duration = 500,
             dt = 0.01,
             vmin = None,
             vmax = None,
             seed = 1234,
             test=False,
             verbose=True,
             param_overrides={},
             target_directory='./'):
                 
    validate = not (params.is_level_B() or params.is_level_C0())
                
    root_dir = os.path.dirname(os.path.abspath(__file__))
    for k in param_overrides.keys():
        v = param_overrides[k]
        print_("Setting parameter %s = %s"%(k,v))
        params.set_bioparameter(k, v, "Set with param_overrides", 0)
    

    params.create_models()
    
    if vmin==None:
        if params.is_level_A():
            vmin=-72
        elif params.is_level_B():
            vmin=-52 
        elif params.is_level_C():
            vmin=-60
        elif params.is_level_D():
            vmin=-60
        else:
            vmin=-52 
            
    
    if vmax==None:
        if params.is_level_A():
            vmax=-48
        elif params.is_level_B():
            vmax=-28
        elif params.is_level_C():
            vmax=25
        elif params.is_level_D():
            vmax=25
        else:
            vmax=-28
    
    random.seed(seed)

    info = "\n\nParameters and setting used to generate this network:\n\n"+\
           "    Data reader:                    %s\n" % data_reader+\
           "    Cells:                          %s\n" % (cells if cells is not None else "All cells")+\
           "    Cell stimulated:                %s\n" % (cells_to_stimulate if cells_to_stimulate is not None else "All neurons")+\
           "    Connection:                     %s\n" % (conns_to_include if conns_to_include is not None else "All connections") + \
           "    Connection numbers overridden:  %s\n" % (conn_number_override if conn_number_override is not None else "None")+\
           "    Connection numbers scaled:      %s\n" % (conn_number_scaling if conn_number_scaling is not None else "None")+ \
           "    Connection polarities override: %s\n" % conn_polarity_override + \
           "    Muscles:                        %s\n" % (muscles_to_include if muscles_to_include is not None else "All muscles")
    if verbose: print_(info)
    info += "\n%s\n"%(params.bioparameter_info("    "))

    nml_doc = NeuroMLDocument(id=net_id, notes=info)

    if params.is_level_A() or params.is_level_B() or params.level == "BC1":
        nml_doc.iaf_cells.append(params.generic_muscle_cell) 
        nml_doc.iaf_cells.append(params.generic_neuron_cell) 
    elif params.is_level_C():
        nml_doc.cells.append(params.generic_muscle_cell)
        nml_doc.cells.append(params.generic_neuron_cell)
    elif params.is_level_D():
        nml_doc.cells.append(params.generic_muscle_cell)
         

    net = Network(id=net_id)


    nml_doc.networks.append(net)

    nml_doc.pulse_generators.append(params.offset_current)

    if is_cond_based_cell(params):
        nml_doc.fixed_factor_concentration_models.append(params.concentration_model)

    cell_names, conns = get_cell_names_and_connection(data_reader)

    # To hold all Cell NeuroML objects vs. names
    all_cells = {}

    # lems_file = ""
    lems_info = {"comment":    info,
                 "reference":  net_id,
                 "duration":   duration,
                 "dt":         dt,
                 "vmin":       vmin,
                 "vmax":       vmax}

    lems_info["plots"] = []
    lems_info["activity_plots"] = []
    lems_info["muscle_plots"] = []
    lems_info["muscle_activity_plots"] = []

    lems_info["to_save"] = []
    lems_info["activity_to_save"] = []
    lems_info["muscles_to_save"] = []
    lems_info["muscles_activity_to_save"] = []
    lems_info["cells"] = []
    lems_info["muscles"] = []
    lems_info["includes"] = []

    if params.custom_component_types_definitions:
        if isinstance(params.custom_component_types_definitions, str):
            params.custom_component_types_definitions = [params.custom_component_types_definitions]
        for ctd in params.custom_component_types_definitions:
            lems_info["includes"].append(ctd)
            if target_directory != './':
                def_file = "%s/%s"%(os.path.dirname(os.path.abspath(__file__)), ctd)
                shutil.copy(def_file, target_directory)
            nml_doc.includes.append(IncludeType(href=ctd))
    
    
    backers_dir = root_dir+"/../../../../OpenWormBackers/" if test else root_dir+"/../../../OpenWormBackers/"
    sys.path.append(backers_dir)
    import backers
    cells_vs_name = backers.get_adopted_cell_names(backers_dir)


    count = 0
    for cell in cell_names:

        if cells is None or cell in cells:

            inst = Instance(id="0")

            if not params.is_level_D():
                # build a Population data structure out of the cell name
                pop0 = Population(id=cell,
                                  component=params.generic_neuron_cell.id,
                                  type="populationList")
                cell_id = params.generic_neuron_cell.id
            else:
                # build a Population data structure out of the cell name
                pop0 = Population(id=cell,
                                  component=cell,
                                  type="populationList")
                cell_id = cell
                                  
            pop0.instances.append(inst)



            # put that Population into the Network data structure from above
            net.populations.append(pop0)
            
            if cells_vs_name.has_key(cell):
                p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[cell])
                pop0.properties.append(p)

            # also use the cell name to grab the morphology file, as a NeuroML data structure
            #  into the 'all_cells' dict
            cell_file_path = root_dir+"/../../../" if test else root_dir+"/../../" #if running test
            cell_file = cell_file_path+'generatedNeuroML2/%s.cell.nml'%cell
            doc = loaders.NeuroMLLoader.load(cell_file)
            all_cells[cell] = doc.cells[0]
            
            
            if params.is_level_D():
                new_cell = params.create_neuron_cell(cell, doc.cells[0].morphology)
                
                nml_cell_doc = NeuroMLDocument(id=cell)
                nml_cell_doc.cells.append(new_cell)
                new_cell_file = 'cells/'+cell+'_D.cell.nml'
                nml_file = target_directory+'/'+new_cell_file
                print_("Writing new cell to: %s"%os.path.realpath(nml_file))
                writers.NeuroMLWriter.write(nml_cell_doc, nml_file)
                
                nml_doc.includes.append(IncludeType(href=new_cell_file))
                lems_info["includes"].append(new_cell_file)
                
                inst.location = Location(0,0,0)
            else:
                location = doc.cells[0].morphology.segments[0].proximal
            
                inst.location = Location(float(location.x), float(location.y), float(location.z))
            
            if verbose: 
                print_("Loaded morphology: %s; id: %s; placing at location: (%s, %s, %s)"%(os.path.realpath(cell_file), all_cells[cell].id, inst.location.x, inst.location.y, inst.location.z))


                
            if cells_to_stimulate is None or cell in cells_to_stimulate:

                target = "../%s/0/%s"%(pop0.id, cell_id)
                if params.is_level_D():
                    target+="/0"
                
                input_list = InputList(id="Input_%s_%s"%(cell,params.offset_current.id),
                                     component=params.offset_current.id,
                                     populations='%s'%cell)

                input_list.input.append(Input(id=0, 
                              target=target, 
                              destination="synapses"))

                net.input_lists.append(input_list)


            if cells_to_plot is None or cell in cells_to_plot:
                plot = {}

                plot["cell"] = cell
                plot["colour"] = get_random_colour_hex()
                plot["quantity"] = "%s/0/%s/v" % (cell, cell_id)
                lems_info["plots"].append(plot)

                if params.is_level_B():
                    plot = {}

                    plot["cell"] = cell
                    plot["colour"] = get_random_colour_hex()
                    plot["quantity"] = "%s/0/%s/activity" % (cell, cell_id)
                    lems_info["activity_plots"].append(plot)

                if is_cond_based_cell(params):
                    plot = {}

                    plot["cell"] = cell
                    plot["colour"] = get_random_colour_hex()
                    plot["quantity"] = "%s/0/%s/caConc" % (cell, cell_id)
                    lems_info["activity_plots"].append(plot)

            save = {}
            save["cell"] = cell
            save["quantity"] = "%s/0/%s/v" % (cell, cell_id)
            lems_info["to_save"].append(save)

            if params.is_level_B():
                save = {}
                save["cell"] = cell
                save["quantity"] = "%s/0/%s/activity" % (cell, cell_id)
                lems_info["activity_to_save"].append(save)
            if is_cond_based_cell(params):
                save = {}
                save["cell"] = cell
                save["quantity"] = "%s/0/%s/caConc" % (cell, cell_id)
                lems_info["activity_to_save"].append(save)

            lems_info["cells"].append(cell)

            count+=1

    if verbose: 
        print_("Finished loading %i cells"%count)

    
    mneurons, all_muscles, muscle_conns = get_cell_muscle_names_and_connection(data_reader)

    #if data_reader == "SpreadsheetDataReader":
    #    all_muscles = get_muscle_names()
        
    if muscles_to_include == None or muscles_to_include == True:
        muscles_to_include = all_muscles
    elif muscles_to_include == False:
        muscles_to_include = []
        
    for m in muscles_to_include:
        assert m in all_muscles

    if len(muscles_to_include)>0:

        muscle_count = 0
        for muscle in muscles_to_include:

            inst = Instance(id="0")

            # build a Population data structure out of the cell name
            pop0 = Population(id=muscle,
                              component=params.generic_muscle_cell.id,
                              type="populationList")
            pop0.instances.append(inst)


            # put that Population into the Network data structure from above
            net.populations.append(pop0)

            if cells_vs_name.has_key(muscle):
                # No muscles adopted yet, but just in case they are in future...
                p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[muscle])
                pop0.properties.append(p)

            x, y, z = get_muscle_position(muscle, data_reader)
            print_('Positioning muscle: %s at (%s,%s,%s)'%(muscle,x,y,z))
            inst.location = Location(x,y,z)

            #target = "%s/0/%s"%(pop0.id, params.generic_muscle_cell.id) # unused

            plot = {}

            plot["cell"] = muscle
            plot["colour"] = get_random_colour_hex()
            plot["quantity"] = "%s/0/%s/v" % (muscle, params.generic_muscle_cell.id)
            lems_info["muscle_plots"].append(plot)

            if params.generic_muscle_cell.__class__.__name__ == 'IafActivityCell':
                plot = {}

                plot["cell"] = muscle
                plot["colour"] = get_random_colour_hex()
                plot["quantity"] = "%s/0/%s/activity" % (muscle, params.generic_muscle_cell.id)
                lems_info["muscle_activity_plots"].append(plot)
                
            if params.generic_muscle_cell.__class__.__name__ == 'Cell':
                plot = {}

                plot["cell"] = muscle
                plot["colour"] = get_random_colour_hex()
                plot["quantity"] = "%s/0/%s/caConc" % (muscle, params.generic_muscle_cell.id)
                lems_info["muscle_activity_plots"].append(plot)

            save = {}
            save["cell"] = muscle
            save["quantity"] = "%s/0/%s/v" % (muscle, params.generic_muscle_cell.id)
            lems_info["muscles_to_save"].append(save)

            if params.generic_muscle_cell.__class__.__name__ == 'IafActivityCell':
                save = {}
                save["cell"] = muscle
                save["quantity"] = "%s/0/%s/activity" % (muscle, params.generic_muscle_cell.id)
                lems_info["muscles_activity_to_save"].append(save)
            if params.generic_muscle_cell.__class__.__name__ == 'Cell':
                save = {}
                save["cell"] = muscle
                save["quantity"] = "%s/0/%s/caConc" % (muscle, params.generic_muscle_cell.id)
                lems_info["muscles_activity_to_save"].append(save)

            lems_info["muscles"].append(muscle)

            muscle_count+=1
            
            if muscle in cells_to_stimulate:

                target = "../%s/0/%s"%(pop0.id, params.generic_muscle_cell.id)
                if params.is_level_D():
                    target+="/0"
                
                input_list = InputList(id="Input_%s_%s"%(muscle,params.offset_current.id),
                                     component=params.offset_current.id,
                                     populations='%s'%pop0.id)

                input_list.input.append(Input(id=0, 
                              target=target, 
                              destination="synapses"))

                net.input_lists.append(input_list)

        if verbose: 
            print_("Finished creating %i muscles"%muscle_count)
        
    
    existing_synapses = {}

    for conn in conns:

        if conn.pre_cell in lems_info["cells"] and conn.post_cell in lems_info["cells"]:
            # take information about each connection and package it into a
            # NeuroML Projection data structure
            proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype)
            conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell)

            elect_conn = False
            analog_conn = False
            syn0 = params.neuron_to_neuron_exc_syn
            orig_pol = "exc"
            
            if 'GABA' in conn.synclass:
                syn0 = params.neuron_to_neuron_inh_syn
                orig_pol = "inh"
            if '_GJ' in conn.synclass:
                syn0 = params.neuron_to_neuron_elec_syn
                elect_conn = isinstance(params.neuron_to_neuron_elec_syn, GapJunction)
                conn_shorthand = "%s-%s_GJ" % (conn.pre_cell, conn.post_cell)

            if conns_to_include and conn_shorthand not in conns_to_include:
                continue

            print conn_shorthand + " " + str(conn.number) + " " + orig_pol + " " + conn.synclass

            polarity = None
            if conn_polarity_override and conn_polarity_override.has_key(conn_shorthand):
                polarity = conn_polarity_override[conn_shorthand]

            if polarity and not elect_conn:
                if polarity == 'inh':
                    syn0 = params.neuron_to_neuron_inh_syn
                else:
                    syn0 = params.neuron_to_neuron_exc_syn
                if verbose and polarity != orig_pol:
                    print_(">> Changing polarity of connection %s -> %s: was: %s, becomes %s " % \
                       (conn.pre_cell, conn.post_cell, orig_pol, polarity))
                
                
                
            if isinstance(syn0, GradedSynapse) or isinstance(syn0, GradedSynapse2):
                analog_conn = True
                if len(nml_doc.silent_synapses)==0:
                    silent = SilentSynapse(id="silent")
                    nml_doc.silent_synapses.append(silent)

            number_syns = conn.number

            if conn_number_override is not None and (conn_number_override.has_key(conn_shorthand)):
                number_syns = conn_number_override[conn_shorthand]
            elif conn_number_scaling is not None and (conn_number_scaling.has_key(conn_shorthand)):
                number_syns = conn.number*conn_number_scaling[conn_shorthand]
            '''
            else:
                print conn_shorthand
                print conn_number_override
                print conn_number_scaling'''
            """if polarity:
                print "%s %s num:%s" % (conn_shorthand, polarity, number_syns)
            elif elect_conn:
                print "%s num:%s" % (conn_shorthand, number_syns)
            else:
                print "%s %s num:%s" % (conn_shorthand, orig_pol, number_syns)"""
            
            if number_syns != conn.number:
                if analog_conn or elect_conn:
                    magnitude, unit = bioparameters.split_neuroml_quantity(syn0.conductance)
                else:
                    magnitude, unit = bioparameters.split_neuroml_quantity(syn0.gbase)
                cond0 = "%s%s"%(magnitude*conn.number, unit)
                cond1 = "%s%s" % (get_str_from_expnotation(magnitude * number_syns), unit)
                gj = "" if not elect_conn else " GapJunction"
                if verbose: 
                    print_(">> Changing number of effective synapses connection %s -> %s%s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
                     (conn.pre_cell, conn.post_cell, gj, conn.number, cond0, number_syns, cond1))

            #print "######## %s-%s %s %s" % (conn.pre_cell, conn.post_cell, conn.synclass, number_syns)
            #known_motor_prefixes = ["VA"]
            #if conn.pre_cell.startswith(tuple(known_motor_prefixes)) or conn.post_cell.startswith(tuple(known_motor_prefixes)):
            #    print "######### %s-%s %s %s" % (conn.pre_cell, conn.post_cell, number_syns, conn.synclass)

            syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc, existing_synapses)

            if elect_conn:

                proj0 = ElectricalProjection(id=proj_id, \
                                   presynaptic_population=conn.pre_cell,
                                   postsynaptic_population=conn.post_cell)

                net.electrical_projections.append(proj0)

                pre_cell_id=get_cell_id_string(conn.pre_cell, params)
                post_cell_id= get_cell_id_string(conn.post_cell, params)

                #print_("Conn %s -> %s"%(pre_cell_id,post_cell_id))

                # Add a Connection with the closest locations
                conn0 = ElectricalConnectionInstance(id="0", \
                           pre_cell=pre_cell_id,
                           post_cell=post_cell_id,
                           synapse=syn_new.id)

                proj0.electrical_connection_instances.append(conn0)
                
            elif analog_conn:
        
                proj0 = ContinuousProjection(id=proj_id, \
                                   presynaptic_population=conn.pre_cell,
                                   postsynaptic_population=conn.post_cell)

                net.continuous_projections.append(proj0)

                pre_cell_id= get_cell_id_string(conn.pre_cell, params)
                post_cell_id= get_cell_id_string(conn.post_cell, params)

                conn0 = ContinuousConnectionInstance(id="0", \
                           pre_cell=pre_cell_id,
                           post_cell=post_cell_id,
                           pre_component="silent",
                           post_component=syn_new.id)

                proj0.continuous_connection_instances.append(conn0)
                
                
            else:

                proj0 = Projection(id=proj_id, \
                                   presynaptic_population=conn.pre_cell,
                                   postsynaptic_population=conn.post_cell,
                                   synapse=syn_new.id)

                net.projections.append(proj0)

                pre_cell_id= get_cell_id_string(conn.pre_cell, params)
                post_cell_id= get_cell_id_string(conn.post_cell, params)

                conn0 = ConnectionWD(id="0", \
                           pre_cell_id=pre_cell_id,
                           post_cell_id=post_cell_id,
                           weight = number_syns,
                           delay = '0ms')

                proj0.connection_wds.append(conn0)



    if len(muscles_to_include)>0:
        for conn in muscle_conns:
            if not conn.post_cell in muscles_to_include:
                continue
            if not conn.pre_cell in lems_info["cells"] and not conn.pre_cell in muscles_to_include:
                continue

            # take information about each connection and package it into a
            # NeuroML Projection data structure
            proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype)
            conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell)

            elect_conn = False
            analog_conn = False
            syn0 = params.neuron_to_muscle_exc_syn
            orig_pol = "exc"
            if 'GABA' in conn.synclass:
                syn0 = params.neuron_to_muscle_inh_syn
                orig_pol = "inh"
            
            if '_GJ' in conn.synclass :
                elect_conn = isinstance(params.neuron_to_muscle_elec_syn, GapJunction)
                conn_shorthand = "%s-%s_GJ" % (conn.pre_cell, conn.post_cell)
                if conn.pre_cell in lems_info["cells"]:
                    syn0 = params.neuron_to_muscle_elec_syn
                elif conn.pre_cell in muscles_to_include:
                    try:
                        syn0 = params.muscle_to_muscle_elec_syn
                    except:
                        syn0 = params.neuron_to_muscle_elec_syn

            if conns_to_include and conn_shorthand not in conns_to_include:
                continue
                
            print conn_shorthand + " " + str(conn.number) + " " + orig_pol + " " + conn.synclass

            polarity = None
            if conn_polarity_override and conn_polarity_override.has_key(conn_shorthand):
                polarity = conn_polarity_override[conn_shorthand]

            if polarity and not elect_conn:
                if polarity == 'inh':
                    syn0 = params.neuron_to_neuron_inh_syn
                else:
                    syn0 = params.neuron_to_neuron_exc_syn
                if verbose and polarity != orig_pol:
                    print_(">> Changing polarity of connection %s -> %s: was: %s, becomes %s " % \
                       (conn.pre_cell, conn.post_cell, orig_pol, polarity))

            if isinstance(syn0, GradedSynapse) or isinstance(syn0, GradedSynapse2):
                analog_conn = True
                if len(nml_doc.silent_synapses)==0:
                    silent = SilentSynapse(id="silent")
                    nml_doc.silent_synapses.append(silent)
                    
            number_syns = conn.number
            
            if conn_number_override is not None and (conn_number_override.has_key(conn_shorthand)):
                number_syns = conn_number_override[conn_shorthand]
            elif conn_number_scaling is not None and (conn_number_scaling.has_key(conn_shorthand)):
                number_syns = conn.number*conn_number_scaling[conn_shorthand]
            '''
            else:
                print conn_shorthand
                print conn_number_override
                print conn_number_scaling'''
            """if polarity:
                print "%s %s num:%s" % (conn_shorthand, polarity, number_syns)
            elif elect_conn:
                print "%s num:%s" % (conn_shorthand, number_syns)
            else:
                print "%s %s num:%s" % (conn_shorthand, orig_pol, number_syns)"""

            if number_syns != conn.number:
                
                if analog_conn or elect_conn:
                    magnitude, unit = bioparameters.split_neuroml_quantity(syn0.conductance)
                else:
                    magnitude, unit = bioparameters.split_neuroml_quantity(syn0.gbase)
                cond0 = "%s%s"%(magnitude*conn.number, unit)
                cond1 = "%s%s" % (get_str_from_expnotation(magnitude * number_syns), unit)
                gj = "" if not elect_conn else " GapJunction"
                if verbose: 
                    print_(">> Changing number of effective synapses connection %s -> %s%s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
                     (conn.pre_cell, conn.post_cell, gj, conn.number, cond0, number_syns, cond1))


            syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc, existing_synapses)

            if elect_conn:

                proj0 = ElectricalProjection(id=proj_id, \
                                   presynaptic_population=conn.pre_cell,
                                   postsynaptic_population=conn.post_cell)

                net.electrical_projections.append(proj0)

                pre_cell_id= get_cell_id_string(conn.pre_cell, params)
                post_cell_id= get_cell_id_string(conn.post_cell, params, muscle=True)

                #print_("Conn %s -> %s"%(pre_cell_id,post_cell_id))

                # Add a Connection with the closest locations
                conn0 = ElectricalConnectionInstance(id="0", \
                           pre_cell=pre_cell_id,
                           post_cell=post_cell_id,
                           synapse=syn_new.id)

                proj0.electrical_connection_instances.append(conn0)
                
            elif analog_conn:
        
                proj0 = ContinuousProjection(id=proj_id, \
                                   presynaptic_population=conn.pre_cell,
                                   postsynaptic_population=conn.post_cell)

                net.continuous_projections.append(proj0)

                pre_cell_id= get_cell_id_string(conn.pre_cell, params)
                post_cell_id= get_cell_id_string(conn.post_cell, params, muscle=True)

                conn0 = ContinuousConnectionInstance(id="0", \
                           pre_cell=pre_cell_id,
                           post_cell=post_cell_id,
                           pre_component="silent",
                           post_component=syn_new.id)

                proj0.continuous_connection_instances.append(conn0)

            else:

                proj0 = Projection(id=proj_id, \
                                   presynaptic_population=conn.pre_cell,
                                   postsynaptic_population=conn.post_cell,
                                   synapse=syn_new.id)

                net.projections.append(proj0)

                # Add a Connection with the closest locations

                pre_cell_id= get_cell_id_string(conn.pre_cell, params)
                post_cell_id= get_cell_id_string(conn.post_cell, params, muscle=True)

                conn0 = Connection(id="0", \
                           pre_cell_id=pre_cell_id,
                           post_cell_id=post_cell_id)

                proj0.connections.append(conn0)



    # import pprint
    # pprint.pprint(lems_info)
    template_path = root_dir+'/../' if test else root_dir+'/' # if running test
    write_to_file(nml_doc, lems_info, net_id, template_path, validate=validate, verbose=verbose, target_directory=target_directory)


    return nml_doc
예제 #22
0
def generate(net_id,
             params,
             cells=None,
             cells_to_plot=None,
             cells_to_stimulate=None,
             include_muscles=False,
             conn_number_override=None,
             conn_number_scaling=None,
             duration=500,
             dt=0.01,
             vmin=None,
             vmax=None,
             seed=1234,
             validate=True,
             test=False,
             verbose=True,
             target_directory='./'):

    root_dir = os.path.dirname(os.path.abspath(__file__))

    params.create_models()

    if vmin == None:
        if params.level == 'A':
            vmin = -72
        elif params.level == 'B':
            vmin = -52
        elif params.level == 'C':
            vmin = -60
        else:
            vmin = -52

    if vmax == None:
        if params.level == 'A':
            vmax = -48
        elif params.level == 'B':
            vmax = -28
        elif params.level == 'C':
            vmax = 25
        else:
            vmax = -28

    random.seed(seed)

    info = "\n\nParameters and setting used to generate this network:\n\n"+\
           "    Cells:                         %s\n" % (cells if cells is not None else "All cells")+\
           "    Cell stimulated:               %s\n" % (cells_to_stimulate if cells_to_stimulate is not None else "All cells")+\
           "    Connection numbers overridden: %s\n" % (conn_number_override if conn_number_override is not None else "None")+\
           "    Connection numbers scaled:     %s\n" % (conn_number_scaling if conn_number_scaling is not None else "None")+\
           "    Include muscles:               %s\n" % include_muscles
    print_(info)
    info += "\n%s\n" % (params.bioparameter_info("    "))

    nml_doc = NeuroMLDocument(id=net_id, notes=info)

    if params.level == "A" or params.level == "B" or params.level == "BC1":
        nml_doc.iaf_cells.append(params.generic_muscle_cell)
        nml_doc.iaf_cells.append(params.generic_neuron_cell)
    elif params.level == "C":
        nml_doc.cells.append(params.generic_muscle_cell)
        nml_doc.cells.append(params.generic_neuron_cell)

    net = Network(id=net_id)

    nml_doc.networks.append(net)

    nml_doc.pulse_generators.append(params.offset_current)

    if params.level == "C" or params.level == "C1":
        nml_doc.fixed_factor_concentration_models.append(
            params.concentration_model)

    cell_names, conns = get_cell_names_and_connection()

    # To hold all Cell NeuroML objects vs. names
    all_cells = {}

    # lems_file = ""
    lems_info = {
        "comment": info,
        "reference": net_id,
        "duration": duration,
        "dt": dt,
        "vmin": vmin,
        "vmax": vmax,
        "cell_component": params.generic_neuron_cell.id
    }

    lems_info["plots"] = []
    lems_info["activity_plots"] = []
    lems_info["muscle_plots"] = []
    lems_info["muscle_activity_plots"] = []

    lems_info["to_save"] = []
    lems_info["activity_to_save"] = []
    lems_info["muscles_to_save"] = []
    lems_info["muscles_activity_to_save"] = []
    lems_info["cells"] = []
    lems_info["muscles"] = []
    lems_info["includes"] = []

    if params.custom_component_types_definitions:
        lems_info["includes"].append(params.custom_component_types_definitions)
        if target_directory != './':
            def_file = "%s/%s" % (os.path.dirname(os.path.abspath(__file__)),
                                  params.custom_component_types_definitions)
            shutil.copy(def_file, target_directory)
        nml_doc.includes.append(
            IncludeType(href=params.custom_component_types_definitions))

    backers_dir = root_dir + "/../../../../OpenWormBackers/" if test else root_dir + "/../../../OpenWormBackers/"
    sys.path.append(backers_dir)
    import backers
    cells_vs_name = backers.get_adopted_cell_names(backers_dir)

    populations_without_location = False  # isinstance(params.elec_syn, GapJunction)

    count = 0
    for cell in cell_names:

        if cells is None or cell in cells:

            inst = Instance(id="0")

            if not populations_without_location:
                # build a Population data structure out of the cell name
                pop0 = Population(id=cell,
                                  component=params.generic_neuron_cell.id,
                                  type="populationList")
                pop0.instances.append(inst)

            else:
                # build a Population data structure out of the cell name
                pop0 = Population(id=cell,
                                  component=params.generic_neuron_cell.id,
                                  size="1")

            # put that Population into the Network data structure from above
            net.populations.append(pop0)

            if cells_vs_name.has_key(cell):
                p = Property(tag="OpenWormBackerAssignedName",
                             value=cells_vs_name[cell])
                pop0.properties.append(p)

            # also use the cell name to grab the morphology file, as a NeuroML data structure
            #  into the 'all_cells' dict
            cell_file_path = root_dir + "/../../../" if test else root_dir + "/../../"  #if running test
            cell_file = cell_file_path + 'generatedNeuroML2/%s.cell.nml' % cell
            doc = loaders.NeuroMLLoader.load(cell_file)
            all_cells[cell] = doc.cells[0]
            location = doc.cells[0].morphology.segments[0].proximal
            if verbose:
                print_(
                    "Loaded morphology: %s; id: %s; location: (%s, %s, %s)" %
                    (os.path.realpath(cell_file), all_cells[cell].id,
                     location.x, location.y, location.z))

            inst.location = Location(float(location.x), float(location.y),
                                     float(location.z))

            target = "../%s/0/%s" % (pop0.id, params.generic_neuron_cell.id)
            if populations_without_location:
                target = "../%s[0]" % (cell)

            if cells_to_stimulate is None or cell in cells_to_stimulate:
                input_list = InputList(id="Input_%s_%s" %
                                       (cell, params.offset_current.id),
                                       component=params.offset_current.id,
                                       populations='%s' % cell)

                input_list.input.append(
                    Input(id=0, target=target, destination="synapses"))

                net.input_lists.append(input_list)

            if cells_to_plot is None or cell in cells_to_plot:
                plot = {}

                plot["cell"] = cell
                plot["colour"] = get_random_colour_hex()
                plot["quantity"] = "%s/0/%s/v" % (
                    cell, params.generic_neuron_cell.id)
                if populations_without_location:
                    plot["quantity"] = "%s[0]/v" % (cell)
                lems_info["plots"].append(plot)

                if params.generic_neuron_cell.__class__.__name__ == 'IafActivityCell':
                    plot = {}

                    plot["cell"] = cell
                    plot["colour"] = get_random_colour_hex()
                    plot["quantity"] = "%s/0/%s/activity" % (
                        cell, params.generic_neuron_cell.id)
                    if populations_without_location:
                        plot["quantity"] = "%s[0]/activity" % (cell)
                    lems_info["activity_plots"].append(plot)

                if params.generic_neuron_cell.__class__.__name__ == 'Cell':
                    plot = {}

                    plot["cell"] = cell
                    plot["colour"] = get_random_colour_hex()
                    plot["quantity"] = "%s/0/%s/caConc" % (
                        cell, params.generic_neuron_cell.id)
                    if populations_without_location:
                        plot["quantity"] = "%s[0]/caConc" % (cell)
                    lems_info["activity_plots"].append(plot)

            save = {}
            save["cell"] = cell
            save["quantity"] = "%s/0/%s/v" % (cell,
                                              params.generic_neuron_cell.id)
            if populations_without_location:
                save["quantity"] = "%s[0]/v" % (cell)
            lems_info["to_save"].append(save)

            if params.generic_neuron_cell.__class__.__name__ == 'IafActivityCell':
                save = {}
                save["cell"] = cell
                save["quantity"] = "%s/0/%s/activity" % (
                    cell, params.generic_neuron_cell.id)
                if populations_without_location:
                    save["quantity"] = "%s[0]/activity" % (cell)
                lems_info["activity_to_save"].append(save)
            if params.generic_neuron_cell.__class__.__name__ == 'Cell':
                save = {}
                save["cell"] = cell
                save["quantity"] = "%s/0/%s/caConc" % (
                    cell, params.generic_neuron_cell.id)
                if populations_without_location:
                    save["quantity"] = "%s[0]/caConc" % (cell)
                lems_info["activity_to_save"].append(save)

            lems_info["cells"].append(cell)

            count += 1

    if verbose:
        print_("Finished loading %i cells" % count)

    mneurons, all_muscles, muscle_conns = get_cell_muscle_names_and_connection(
    )

    muscles = get_muscle_names()

    if include_muscles:

        muscle_count = 0
        for muscle in muscles:

            inst = Instance(id="0")

            if not populations_without_location:
                # build a Population data structure out of the cell name
                pop0 = Population(id=muscle,
                                  component=params.generic_muscle_cell.id,
                                  type="populationList")
                pop0.instances.append(inst)

            else:
                # build a Population data structure out of the cell name
                pop0 = Population(id=muscle,
                                  component=params.generic_muscle_cell.id,
                                  size="1")

            # put that Population into the Network data structure from above
            net.populations.append(pop0)

            if cells_vs_name.has_key(muscle):
                # No muscles adopted yet, but just in case they are in future...
                p = Property(tag="OpenWormBackerAssignedName",
                             value=cells_vs_name[muscle])
                pop0.properties.append(p)

            x = 80 * (-1 if muscle[1] == 'V' else 1)
            z = 80 * (-1 if muscle[2] == 'L' else 1)
            y = -300 + 30 * int(muscle[3:5])
            print_('Positioning muscle: %s at (%s,%s,%s)' % (muscle, x, y, z))
            inst.location = Location(x, y, z)

            target = "%s/0/%s" % (pop0.id, params.generic_muscle_cell.id)
            if populations_without_location:
                target = "%s[0]" % (muscle)

            plot = {}

            plot["cell"] = muscle
            plot["colour"] = get_random_colour_hex()
            plot["quantity"] = "%s/0/%s/v" % (muscle,
                                              params.generic_muscle_cell.id)
            if populations_without_location:
                plot["quantity"] = "%s[0]/v" % (muscle)
            lems_info["muscle_plots"].append(plot)

            if params.generic_muscle_cell.__class__.__name__ == 'IafActivityCell':
                plot = {}

                plot["cell"] = muscle
                plot["colour"] = get_random_colour_hex()
                plot["quantity"] = "%s/0/%s/activity" % (
                    muscle, params.generic_muscle_cell.id)
                if populations_without_location:
                    plot["quantity"] = "%s[0]/activity" % (muscle)
                lems_info["muscle_activity_plots"].append(plot)

            if params.generic_muscle_cell.__class__.__name__ == 'Cell':
                plot = {}

                plot["cell"] = muscle
                plot["colour"] = get_random_colour_hex()
                plot["quantity"] = "%s/0/%s/caConc" % (
                    muscle, params.generic_muscle_cell.id)
                if populations_without_location:
                    plot["quantity"] = "%s[0]/caConc" % (muscle)
                lems_info["muscle_activity_plots"].append(plot)

            save = {}
            save["cell"] = muscle
            save["quantity"] = "%s/0/%s/v" % (muscle,
                                              params.generic_muscle_cell.id)
            if populations_without_location:
                save["quantity"] = "%s[0]/v" % (muscle)
            lems_info["muscles_to_save"].append(save)

            if params.generic_muscle_cell.__class__.__name__ == 'IafActivityCell':
                save = {}
                save["cell"] = muscle
                save["quantity"] = "%s/0/%s/activity" % (
                    muscle, params.generic_muscle_cell.id)
                if populations_without_location:
                    save["quantity"] = "%s[0]/activity" % (muscle)
                lems_info["muscles_activity_to_save"].append(save)
            if params.generic_muscle_cell.__class__.__name__ == 'Cell':
                save = {}
                save["cell"] = muscle
                save["quantity"] = "%s/0/%s/caConc" % (
                    muscle, params.generic_muscle_cell.id)
                if populations_without_location:
                    save["quantity"] = "%s[0]/caConc" % (muscle)
                lems_info["muscles_activity_to_save"].append(save)

            lems_info["muscles"].append(muscle)

            muscle_count += 1

        if verbose:
            print_("Finished creating %i muscles" % muscle_count)

    existing_synapses = {}

    for conn in conns:

        if conn.pre_cell in lems_info["cells"] and conn.post_cell in lems_info[
                "cells"]:
            # take information about each connection and package it into a
            # NeuroML Projection data structure
            proj_id = get_projection_id(conn.pre_cell, conn.post_cell,
                                        conn.synclass, conn.syntype)

            elect_conn = False
            analog_conn = False
            syn0 = params.neuron_to_neuron_exc_syn
            if 'GABA' in conn.synclass:
                syn0 = params.neuron_to_neuron_inh_syn
            if '_GJ' in conn.synclass:
                syn0 = params.neuron_to_neuron_elec_syn
                elect_conn = isinstance(params.neuron_to_neuron_elec_syn,
                                        GapJunction)

            if isinstance(syn0, GradedSynapse):
                analog_conn = True
                if len(nml_doc.silent_synapses) == 0:
                    silent = SilentSynapse(id="silent")
                    nml_doc.silent_synapses.append(silent)

            number_syns = conn.number
            conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell)

            if conn_number_override is not None and (
                    conn_number_override.has_key(conn_shorthand)):
                number_syns = conn_number_override[conn_shorthand]
            elif conn_number_scaling is not None and (
                    conn_number_scaling.has_key(conn_shorthand)):
                number_syns = conn.number * conn_number_scaling[conn_shorthand]
            '''
            else:
                print conn_shorthand
                print conn_number_override
                print conn_number_scaling'''

            if number_syns != conn.number:
                magnitude, unit = bioparameters.split_neuroml_quantity(
                    syn0.gbase)
                cond0 = "%s%s" % (magnitude * conn.number, unit)
                cond1 = "%s%s" % (magnitude * number_syns, unit)
                if verbose:
                    print_(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
                     (conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1))

            syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc,
                                                  existing_synapses)

            if elect_conn:

                if populations_without_location:
                    proj0 = ElectricalProjection(id=proj_id, \
                                       presynaptic_population=conn.pre_cell,
                                       postsynaptic_population=conn.post_cell)

                    net.electrical_projections.append(proj0)

                    # Add a Connection with the closest locations
                    conn0 = ElectricalConnection(id="0", \
                               pre_cell="0",
                               post_cell="0",
                               synapse=syn_new.id)

                    proj0.electrical_connections.append(conn0)
                else:
                    proj0 = ElectricalProjection(id=proj_id, \
                                       presynaptic_population=conn.pre_cell,
                                       postsynaptic_population=conn.post_cell)

                    net.electrical_projections.append(proj0)

                    pre_cell_id = "../%s/0/%s" % (
                        conn.pre_cell, params.generic_neuron_cell.id)
                    post_cell_id = "../%s/0/%s" % (
                        conn.post_cell, params.generic_neuron_cell.id)

                    #print_("Conn %s -> %s"%(pre_cell_id,post_cell_id))

                    # Add a Connection with the closest locations
                    conn0 = ElectricalConnectionInstance(id="0", \
                               pre_cell=pre_cell_id,
                               post_cell=post_cell_id,
                               synapse=syn_new.id)

                    proj0.electrical_connection_instances.append(conn0)

            elif analog_conn:

                proj0 = ContinuousProjection(id=proj_id, \
                                   presynaptic_population=conn.pre_cell,
                                   postsynaptic_population=conn.post_cell)

                net.continuous_projections.append(proj0)

                pre_cell_id = "../%s/0/%s" % (conn.pre_cell,
                                              params.generic_neuron_cell.id)
                post_cell_id = "../%s/0/%s" % (conn.post_cell,
                                               params.generic_neuron_cell.id)

                conn0 = ContinuousConnectionInstance(id="0", \
                           pre_cell=pre_cell_id,
                           post_cell=post_cell_id,
                           pre_component="silent",
                           post_component=syn_new.id)

                proj0.continuous_connection_instances.append(conn0)

            else:

                if not populations_without_location:
                    proj0 = Projection(id=proj_id, \
                                       presynaptic_population=conn.pre_cell,
                                       postsynaptic_population=conn.post_cell,
                                       synapse=syn_new.id)

                    net.projections.append(proj0)

                    pre_cell_id = "../%s/0/%s" % (
                        conn.pre_cell, params.generic_neuron_cell.id)
                    post_cell_id = "../%s/0/%s" % (
                        conn.post_cell, params.generic_neuron_cell.id)

                    conn0 = ConnectionWD(id="0", \
                               pre_cell_id=pre_cell_id,
                               post_cell_id=post_cell_id,
                               weight = number_syns,
                               delay = '0ms')

                    proj0.connection_wds.append(conn0)

                if populations_without_location:
                    raise NotImplementedError
                    '''
                    #         <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/>
                    pre_cell_id="%s[0]"%(conn.pre_cell)
                    post_cell_id="%s[0]"%(conn.post_cell)

                    conn0 = SynapticConnection(from_=pre_cell_id,
                               to=post_cell_id,
                               synapse=syn_new.id,
                               destination="synapses")

                    net.synaptic_connections.append(conn0)'''

    if include_muscles:
        for conn in muscle_conns:

            if conn.pre_cell in lems_info[
                    "cells"] and conn.post_cell in muscles:
                # take information about each connection and package it into a
                # NeuroML Projection data structure
                proj_id = get_projection_id(conn.pre_cell, conn.post_cell,
                                            conn.synclass, conn.syntype)

                elect_conn = False
                analog_conn = False
                syn0 = params.neuron_to_muscle_exc_syn
                if 'GABA' in conn.synclass:
                    syn0 = params.neuron_to_muscle_inh_syn
                if '_GJ' in conn.synclass:
                    syn0 = params.neuron_to_muscle_elec_syn
                    elect_conn = isinstance(params.neuron_to_muscle_elec_syn,
                                            GapJunction)

                if isinstance(syn0, GradedSynapse):
                    analog_conn = True
                    if len(nml_doc.silent_synapses) == 0:
                        silent = SilentSynapse(id="silent")
                        nml_doc.silent_synapses.append(silent)

                number_syns = conn.number
                conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell)

                if conn_number_override is not None and (
                        conn_number_override.has_key(conn_shorthand)):
                    number_syns = conn_number_override[conn_shorthand]
                elif conn_number_scaling is not None and (
                        conn_number_scaling.has_key(conn_shorthand)):
                    number_syns = conn.number * conn_number_scaling[
                        conn_shorthand]
                '''
            else:
                print conn_shorthand
                print conn_number_override
                print conn_number_scaling'''

                if number_syns != conn.number:
                    magnitude, unit = bioparameters.split_neuroml_quantity(
                        syn0.gbase)
                    cond0 = "%s%s" % (magnitude * conn.number, unit)
                    cond1 = "%s%s" % (magnitude * number_syns, unit)
                    if verbose:
                        print_(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
                         (conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1))

                syn_new = create_n_connection_synapse(syn0, number_syns,
                                                      nml_doc,
                                                      existing_synapses)

                if elect_conn:

                    if populations_without_location:
                        proj0 = ElectricalProjection(id=proj_id, \
                                           presynaptic_population=conn.pre_cell,
                                           postsynaptic_population=conn.post_cell)

                        net.electrical_projections.append(proj0)

                        # Add a Connection with the closest locations
                        conn0 = ElectricalConnection(id="0", \
                                   pre_cell="0",
                                   post_cell="0",
                                   synapse=syn_new.id)

                        proj0.electrical_connections.append(conn0)
                    else:
                        proj0 = ElectricalProjection(id=proj_id, \
                                           presynaptic_population=conn.pre_cell,
                                           postsynaptic_population=conn.post_cell)

                        net.electrical_projections.append(proj0)

                        pre_cell_id = "../%s/0/%s" % (
                            conn.pre_cell, params.generic_neuron_cell.id)
                        post_cell_id = "../%s/0/%s" % (
                            conn.post_cell, params.generic_muscle_cell.id)

                        #print_("Conn %s -> %s"%(pre_cell_id,post_cell_id))

                        # Add a Connection with the closest locations
                        conn0 = ElectricalConnectionInstance(id="0", \
                                   pre_cell=pre_cell_id,
                                   post_cell=post_cell_id,
                                   synapse=syn_new.id)

                        proj0.electrical_connection_instances.append(conn0)

                elif analog_conn:

                    proj0 = ContinuousProjection(id=proj_id, \
                                       presynaptic_population=conn.pre_cell,
                                       postsynaptic_population=conn.post_cell)

                    net.continuous_projections.append(proj0)

                    pre_cell_id = "../%s/0/%s" % (
                        conn.pre_cell, params.generic_neuron_cell.id)
                    post_cell_id = "../%s/0/%s" % (
                        conn.post_cell, params.generic_muscle_cell.id)

                    conn0 = ContinuousConnectionInstance(id="0", \
                               pre_cell=pre_cell_id,
                               post_cell=post_cell_id,
                               pre_component="silent",
                               post_component=syn_new.id)

                    proj0.continuous_connection_instances.append(conn0)

                else:

                    if not populations_without_location:
                        proj0 = Projection(id=proj_id, \
                                           presynaptic_population=conn.pre_cell,
                                           postsynaptic_population=conn.post_cell,
                                           synapse=syn_new.id)

                        net.projections.append(proj0)

                        # Add a Connection with the closest locations

                        pre_cell_id = "../%s/0/%s" % (
                            conn.pre_cell, params.generic_neuron_cell.id)
                        post_cell_id = "../%s/0/%s" % (
                            conn.post_cell, params.generic_muscle_cell.id)

                        conn0 = Connection(id="0", \
                                   pre_cell_id=pre_cell_id,
                                   post_cell_id=post_cell_id)

                        proj0.connections.append(conn0)

                    if populations_without_location:
                        #         <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/>
                        pre_cell_id = "%s[0]" % (conn.pre_cell)
                        post_cell_id = "%s[0]" % (conn.post_cell)

                        conn0 = SynapticConnection(from_=pre_cell_id,
                                                   to=post_cell_id,
                                                   synapse=syn_new.id,
                                                   destination="synapses")

                        net.synaptic_connections.append(conn0)

    # import pprint
    # pprint.pprint(lems_info)
    template_path = root_dir + '/../' if test else root_dir + '/'  # if running test
    write_to_file(nml_doc,
                  lems_info,
                  net_id,
                  template_path,
                  validate=validate,
                  verbose=verbose,
                  target_directory=target_directory)

    return nml_doc
예제 #23
0
    def createModel(self):

        # File names of all components
        pyr_file_name = "../ACnet2_NML2/Cells/pyr_4_sym.cell.nml"
        bask_file_name = "../ACnet2_NML2/Cells/bask.cell.nml"

        exc_exc_syn_names = '../ACnet2_NML2/Synapses/AMPA_syn.synapse.nml'
        exc_inh_syn_names = '../ACnet2_NML2/Synapses/AMPA_syn_inh.synapse.nml'
        inh_exc_syn_names = '../ACnet2_NML2/Synapses/GABA_syn.synapse.nml'
        inh_inh_syn_names = '../ACnet2_NML2/Synapses/GABA_syn_inh.synapse.nml'
        bg_exc_syn_names = '../ACnet2_NML2/Synapses/bg_AMPA_syn.synapse.nml'

        nml_doc = NeuroMLDocument(id=self.filename + '_doc')
        net = Network(id=self.filename + '_net')
        nml_doc.networks.append(net)

        nml_doc.includes.append(IncludeType(pyr_file_name))
        nml_doc.includes.append(IncludeType(bask_file_name))
        nml_doc.includes.append(IncludeType(exc_exc_syn_names))
        nml_doc.includes.append(IncludeType(exc_inh_syn_names))
        nml_doc.includes.append(IncludeType(inh_exc_syn_names))
        nml_doc.includes.append(IncludeType(inh_inh_syn_names))
        nml_doc.includes.append(IncludeType(bg_exc_syn_names))

        # Create a LEMSSimulation to manage creation of LEMS file
        ls = LEMSSimulation(self.filename, self.sim_time, self.dt)

        # Point to network as target of simulation
        ls.assign_simulation_target(net.id)

        # The names of the cell type/component used in the Exc & Inh populations
        exc_group_component = "pyr_4_sym"
        inh_group_component = "bask"

        # The names of the Exc & Inh groups/populations
        exc_group = "pyramidals"  #"pyramidals48x48"
        inh_group = "baskets"  #"baskets24x24"

        # The names of the network connections
        net_conn_exc_exc = "pyr_pyr"
        net_conn_exc_inh = "pyr_bask"
        net_conn_inh_exc = "bask_pyr"
        net_conn_inh_inh = "bask_bask"

        # The names of the synapse types
        exc_exc_syn = "AMPA_syn"
        exc_exc_syn_seg_id = 3  # Middle apical dendrite
        exc_inh_syn = "AMPA_syn_inh"
        exc_inh_syn_seg_id = 1  # Dendrite
        inh_exc_syn = "GABA_syn"
        inh_exc_syn_seg_id = 6  # Basal dendrite
        inh_inh_syn = "GABA_syn_inh"
        inh_inh_syn_seg_id = 0  # Soma

        aff_exc_syn = "AMPA_aff_syn"
        aff_exc_syn_seg_id = 5  # proximal apical dendrite

        bg_exc_syn = "bg_AMPA_syn"
        bg_exc_syn_seg_id = 7  # Basal dendrite

        # Excitatory Parameters
        XSCALE_ex = 24  #48
        ZSCALE_ex = 24  #48
        xSpacing_ex = 40  # 10^-6m
        zSpacing_ex = 40  # 10^-6m

        # Inhibitory Parameters
        XSCALE_inh = 12  #24
        ZSCALE_inh = 12  #24
        xSpacing_inh = 80  # 10^-6m
        zSpacing_inh = 80  # 10^-6m

        numCells_ex = XSCALE_ex * ZSCALE_ex
        numCells_inh = XSCALE_inh * ZSCALE_inh

        # Connection probabilities (initial value)
        connection_probability_ex_ex = 0.15
        connection_probability_ex_inh = 0.45
        connection_probability_inh_ex = 0.6
        connection_probability_inh_inh = 0.6

        # Generate excitatory cells

        exc_pop = Population(id=exc_group,
                             component=exc_group_component,
                             type="populationList",
                             size=XSCALE_ex * ZSCALE_ex)
        net.populations.append(exc_pop)

        exc_pos = np.zeros((XSCALE_ex * ZSCALE_ex, 2))

        for i in range(0, XSCALE_ex):
            for j in range(0, ZSCALE_ex):
                # create cells
                x = i * xSpacing_ex
                z = j * zSpacing_ex
                index = i * ZSCALE_ex + j

                inst = Instance(id=index)
                exc_pop.instances.append(inst)

                inst.location = Location(x=x, y=0, z=z)

                exc_pos[index, 0] = x
                exc_pos[index, 1] = z

        # Generate inhibitory cells

        inh_pop = Population(id=inh_group,
                             component=inh_group_component,
                             type="populationList",
                             size=XSCALE_inh * ZSCALE_inh)
        net.populations.append(inh_pop)

        inh_pos = np.zeros((XSCALE_inh * ZSCALE_inh, 2))

        for i in range(0, XSCALE_inh):
            for j in range(0, ZSCALE_inh):
                # create cells
                x = i * xSpacing_inh
                z = j * zSpacing_inh
                index = i * ZSCALE_inh + j

                inst = Instance(id=index)
                inh_pop.instances.append(inst)

                inst.location = Location(x=x, y=0, z=z)

                inh_pos[index, 0] = x
                inh_pos[index, 1] = z

        proj_exc_exc = Projection(id=net_conn_exc_exc,
                                  presynaptic_population=exc_group,
                                  postsynaptic_population=exc_group,
                                  synapse=exc_exc_syn)
        net.projections.append(proj_exc_exc)
        proj_exc_inh = Projection(id=net_conn_exc_inh,
                                  presynaptic_population=exc_group,
                                  postsynaptic_population=inh_group,
                                  synapse=exc_inh_syn)
        net.projections.append(proj_exc_inh)
        proj_inh_exc = Projection(id=net_conn_inh_exc,
                                  presynaptic_population=inh_group,
                                  postsynaptic_population=exc_group,
                                  synapse=inh_exc_syn)
        net.projections.append(proj_inh_exc)
        proj_inh_inh = Projection(id=net_conn_inh_inh,
                                  presynaptic_population=inh_group,
                                  postsynaptic_population=inh_group,
                                  synapse=inh_inh_syn)
        net.projections.append(proj_inh_inh)

        # Generate exc -> *  connections

        exc_exc_conn = np.zeros((numCells_ex, numCells_ex))
        exc_inh_conn = np.zeros((numCells_ex, numCells_inh))

        count_exc_exc = 0
        count_exc_inh = 0
        for i in range(0, XSCALE_ex):
            for j in range(0, ZSCALE_ex):
                x = i * xSpacing_ex
                y = j * zSpacing_ex
                index = i * ZSCALE_ex + j
                #print("Looking at connections for exc cell at (%i, %i)"%(i,j))

                # exc -> exc  connections
                conn_type = net_conn_exc_exc
                for k in range(0, XSCALE_ex):
                    for l in range(0, ZSCALE_ex):

                        # calculate distance from pre- to post-synaptic neuron
                        xk = k * xSpacing_ex
                        yk = l * zSpacing_ex
                        distance = math.sqrt((x - xk)**2 + (y - yk)**2)
                        connection_probability = connection_probability_ex_ex * math.exp(
                            -(distance / (10.0 * xSpacing_ex))**2)

                        # create a random number between 0 and 1, if it is <= connection_probability
                        # accept connection otherwise refuse
                        a = random.random()
                        if 0 < a <= connection_probability:
                            index2 = k * ZSCALE_ex + l
                            count_exc_exc += 1

                            add_connection(proj_exc_exc, count_exc_exc,
                                           exc_group, exc_group_component,
                                           index, 0, exc_group,
                                           exc_group_component, index2,
                                           exc_exc_syn_seg_id)

                            exc_exc_conn[index, index2] = 1

                # exc -> inh  connections
                conn_type = net_conn_exc_inh
                for k in range(0, XSCALE_inh):
                    for l in range(0, ZSCALE_inh):

                        # calculate distance from pre- to post-synaptic neuron
                        xk = k * xSpacing_inh
                        yk = l * zSpacing_inh
                        distance = math.sqrt((x - xk)**2 + (y - yk)**2)
                        connection_probability = connection_probability_ex_inh * math.exp(
                            -(distance / (10.0 * xSpacing_ex))**2)

                        # create a random number between 0 and 1, if it is <= connection_probability
                        # accept connection otherwise refuse
                        a = random.random()
                        if 0 < a <= connection_probability:
                            index2 = k * ZSCALE_inh + l
                            count_exc_inh += 1

                            add_connection(proj_exc_inh, count_exc_inh,
                                           exc_group, exc_group_component,
                                           index, 0, inh_group,
                                           inh_group_component, index2,
                                           exc_inh_syn_seg_id)

                            exc_inh_conn[index, index2] = 1

        inh_exc_conn = np.zeros((numCells_inh, numCells_ex))
        inh_inh_conn = np.zeros((numCells_inh, numCells_inh))

        count_inh_exc = 0
        count_inh_inh = 0
        for i in range(0, XSCALE_inh):
            for j in range(0, ZSCALE_inh):

                x = i * xSpacing_inh
                y = j * zSpacing_inh
                index = i * ZSCALE_inh + j
                #print("Looking at connections for inh cell at (%i, %i)"%(i,j))

                # inh -> exc  connections
                conn_type = net_conn_inh_exc
                for k in range(0, XSCALE_ex):
                    for l in range(0, ZSCALE_ex):

                        # calculate distance from pre- to post-synaptic neuron
                        xk = k * xSpacing_ex
                        yk = l * zSpacing_ex
                        distance = math.sqrt((x - xk)**2 + (y - yk)**2)
                        connection_probability = connection_probability_inh_ex * math.exp(
                            -(distance / (10.0 * xSpacing_ex))**2)

                        # create a random number between 0 and 1, if it is <= connection_probability
                        # accept connection otherwise refuse
                        a = random.random()
                        if 0 < a <= connection_probability:
                            index2 = k * ZSCALE_ex + l
                            count_inh_exc += 1

                            add_connection(proj_inh_exc, count_inh_exc,
                                           inh_group, inh_group_component,
                                           index, 0, exc_group,
                                           exc_group_component, index2,
                                           inh_exc_syn_seg_id)

                            inh_exc_conn[index, index2] = 1

                # inh -> inh  connections
                conn_type = net_conn_inh_inh
                for k in range(0, XSCALE_inh):
                    for l in range(0, ZSCALE_inh):

                        # calculate distance from pre- to post-synaptic neuron
                        xk = k * xSpacing_inh
                        yk = l * zSpacing_inh
                        distance = math.sqrt((x - xk)**2 + (y - yk)**2)
                        connection_probability = connection_probability_inh_inh * math.exp(
                            -(distance / (10.0 * xSpacing_ex))**2)

                        # create a random number between 0 and 1, if it is <= connection_probability
                        # accept connection otherwise refuse
                        a = random.random()
                        if 0 < a <= connection_probability:
                            index2 = k * ZSCALE_inh + l
                            count_inh_inh += 1

                            add_connection(proj_inh_inh, count_inh_inh,
                                           inh_group, inh_group_component,
                                           index, 0, inh_group,
                                           inh_group_component, index2,
                                           inh_inh_syn_seg_id)

                            inh_inh_conn[index, index2] = 1

        print(
            "Generated network with %i exc_exc, %i exc_inh, %i inh_exc, %i inh_inh connections"
            % (count_exc_exc, count_exc_inh, count_inh_exc, count_inh_inh))

        #######   Create Input   ######
        # Create a sine generator
        sgE = SineGenerator(id="sineGen_0",
                            phase="0",
                            delay="0ms",
                            duration=str(self.sim_time) + "ms",
                            amplitude=str(self.Edrive_weight) + "nA",
                            period=str(self.Drive_period) + "ms")
        sgI = SineGenerator(id="sineGen_1",
                            phase="0",
                            delay="0ms",
                            duration=str(self.sim_time) + "ms",
                            amplitude=str(self.Idrive_weight) + "nA",
                            period=str(self.Drive_period) + "ms")

        nml_doc.sine_generators.append(sgE)
        nml_doc.sine_generators.append(sgI)
        # Create an input object for each excitatory cell
        for i in range(0, XSCALE_ex):
            exp_input = ExplicitInput(target="%s[%i]" % (exc_pop.id, i),
                                      input=sgE.id)
            net.explicit_inputs.append(exp_input)

        # Create an input object for a percentage of inhibitory cells
        input_probability = 0.65
        for i in range(0, XSCALE_inh):
            ran = random.random()
            if 0 < ran <= input_probability:
                inh_input = ExplicitInput(target="%s[%i]" % (inh_pop.id, i),
                                          input=sgI.id)
                net.explicit_inputs.append(inh_input)

        # Define Poisson noise input

        # Ex

        #nml_doc.includes.append(IncludeType('Synapses/bg_AMPA_syn.synapse.nml'))

        pfs1 = PoissonFiringSynapse(id="poissonFiringSyn1",
                                    average_rate=str(self.bg_noise_frequency) +
                                    "Hz",
                                    synapse=bg_exc_syn,
                                    spike_target="./%s" % bg_exc_syn)
        nml_doc.poisson_firing_synapses.append(pfs1)

        pfs_input_list1 = InputList(id="pfsInput1",
                                    component=pfs1.id,
                                    populations=exc_pop.id)
        net.input_lists.append(pfs_input_list1)
        for i in range(0, numCells_ex):
            pfs_input_list1.input.append(
                Input(id=i,
                      target='../%s/%i/%s' %
                      (exc_pop.id, i, exc_group_component),
                      segment_id=bg_exc_syn_seg_id,
                      destination="synapses"))

        #######   Write to file  ######

        print("Saving to file...")
        nml_file = '../ACnet2_NML2/' + self.filename + '_doc' + '.net.nml'
        writers.NeuroMLWriter.write(nml_doc, nml_file)

        print("Written network file to: " + nml_file)

        ###### Validate the NeuroML ######

        from neuroml.utils import validate_neuroml2
        validate_neuroml2(nml_file)
        print "-----------------------------------"

        ###### Output #######

        # Output membrane potential
        # Ex population
        Ex_potentials = 'V_Ex'
        ls.create_output_file(Ex_potentials,
                              "../ACnet2_NML2/Results/v_exc.dat")
        for j in range(numCells_ex):
            quantity = "%s[%i]/v" % (exc_pop.id, j)
            v = 'v' + str(j)
            ls.add_column_to_output_file(Ex_potentials, v, quantity)

        # Inh population
        #Inh_potentials = 'V_Inh'
        #ls.create_output_file(Inh_potentials, "../ACnet2_NML2/Results/v_inh.dat")
        #for j in range(numCells_inh):
        #	quantity = "%s[%i]/v"%(inh_pop.id, j)
        #	v = 'v'+str(j)
        #	ls.add_column_to_output_file(Inh_potentials,v, quantity)

        # include generated network
        ls.include_neuroml2_file(nml_file)

        # Save to LEMS XML file
        lems_file_name = ls.save_to_file(file_name='../ACnet2_NML2/LEMS_' +
                                         self.filename + '.xml')
예제 #24
0
nml_doc.iaf_cells.append(IafCell0)

IafCell1 = IafCell(id="iaf1",
                   C="1.0 nF",
                   thresh="-50mV",
                   reset="-65mV",
                   leak_conductance="20 nS",
                   leak_reversal="-65mV")

nml_doc.iaf_cells.append(IafCell1)

syn0 = ExpOneSynapse(id="syn0", gbase="65nS", erev="0mV", tau_decay="3ms")

nml_doc.exp_one_synapses.append(syn0)

net = Network(id="IafNet")

nml_doc.networks.append(net)

size0 = 5
pop0 = Population(id="IafPop0", component=IafCell0.id, size=size0)

net.populations.append(pop0)

size1 = 5
pop1 = Population(id="IafPop1", component=IafCell0.id, size=size1)

net.populations.append(pop1)

prob_connection = 0.5
예제 #25
0
cells = [
    '467703703', '471141261', '320207387', '471141261', '324493977',
    '464326095'
]
cell_files = glob.glob('*.cell.nml')
cells = [c.split('.')[0] for c in cell_files]

problematic = [
    '314642645', '469704261', '466664172', '314822529', '320654829',
    '324025371', '397353539', '469704261', '469753383'
]

net_ref = "Net"
net_doc = NeuroMLDocument(id=net_ref)

net = Network(id=net_ref)
net_doc.networks.append(net)


def rotate_z(x, y, theta):

    x_ = x * math.cos(theta) - y * math.sin(theta)
    y_ = x * math.sin(theta) + y * math.cos(theta)

    return x_, y_


count = 0
for cell in cells:

    suffix = '_trans'
예제 #26
0
def generate(net_id, params, cells = None, cells_to_plot=None, cells_to_stimulate=None, duration=500, dt=0.01, vmin=-75, vmax=20):
    
    nml_doc = NeuroMLDocument(id=net_id)

    nml_doc.iaf_cells.append(params.generic_cell)

    net = Network(id=net_id)

    nml_doc.networks.append(net)

    nml_doc.pulse_generators.append(params.offset_current)

    # Use the spreadsheet reader to give a list of all cells and a list of all connections
    # This could be replaced with a call to "DatabaseReader" or "OpenWormNeuroLexReader" in future...
    cell_names, conns = SpreadsheetDataReader.readDataFromSpreadsheet("../../../")

    cell_names.sort()

    # To hold all Cell NeuroML objects vs. names
    all_cells = {}

    # lems_file = ""
    lems_info = {"reference":  net_id,
                 "duration":   duration,
                 "dt":         dt,
                 "vmin":       vmin,
                 "vmax":       vmax,
                 "cell_component":    params.generic_cell.id}
    
    lems_info["plots"] = []
    lems_info["cells"] = []

    for cell in cell_names:
        
        if cells is None or cell in cells:
            # build a Population data structure out of the cell name
            pop0 = Population(id=cell, 
                              component=params.generic_cell.id,
                              type="populationList")

            inst = Instance(id="0")
            pop0.instances.append(inst)

            # put that Population into the Network data structure from above
            net.populations.append(pop0)

            # also use the cell name to grab the morphology file, as a NeuroML data structure
            #  into the 'all_cells' dict
            cell_file = '../../generatedNeuroML2/%s.nml'%cell
            doc = loaders.NeuroMLLoader.load(cell_file)
            all_cells[cell] = doc.cells[0]
            location = doc.cells[0].morphology.segments[0].proximal
            print("Loaded morphology file from: %s, with id: %s, location: (%s, %s, %s)"%(cell_file, all_cells[cell].id, location.x, location.y, location.z))

            inst.location = Location(float(location.x), float(location.y), float(location.z))

            exp_input = ExplicitInput(target="%s/0/%s"%(pop0.id, params.generic_cell.id),
                                                     input=params.offset_current.id)

            if cells_to_stimulate is None or cell in cells_to_stimulate:
                net.explicit_inputs.append(exp_input)
                
            if cells_to_plot is None or cell in cells_to_plot:
                plot = {}
                
                plot["cell"] = cell
                plot["colour"] = get_random_colour_hex()
                lems_info["plots"].append(plot)
                
            lems_info["cells"].append(cell)
            
    
    for conn in conns:

        if conn.pre_cell in lems_info["cells"] and conn.post_cell in lems_info["cells"]:
            # take information about each connection and package it into a 
            # NeuroML Projection data structure
            proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype)

            syn0 = params.exc_syn
            if 'GABA' in conn.synclass:
                syn0 = params.inh_syn
                
            syn_new = create_n_connection_synapse(syn0, conn.number, nml_doc)

            proj0 = Projection(id=proj_id, \
                               presynaptic_population=conn.pre_cell, 
                               postsynaptic_population=conn.post_cell, 
                               synapse=syn_new.id)

            # Get the corresponding Cell for each 
            # pre_cell = all_cells[conn.pre_cell]
            # post_cell = all_cells[conn.post_cell]

            net.projections.append(proj0)

            # Add a Connection with the closest locations
            conn0 = Connection(id="0", \
                       pre_cell_id="../%s/0/%s"%(conn.pre_cell, params.generic_cell.id),
                       post_cell_id="../%s/0/%s"%(conn.post_cell, params.generic_cell.id))

            proj0.connections.append(conn0)

    

    write_to_file(nml_doc, lems_info, net_id)
예제 #27
0
from pyneuroml import pynml
from pyneuroml.lems import LEMSSimulation
import numpy as np


# Create a new NeuroML model document
nml_doc = NeuroMLDocument(id="IzhSingleNeuron")

# Define the Izhikevich cell and add it to the model in the document
izh0 = Izhikevich2007Cell(
    id="izh2007RS0", v0="-60mV", C="100pF", k="0.7nS_per_mV", vr="-60mV",
    vt="-40mV", vpeak="35mV", a="0.03per_ms", b="-2nS", c="-50.0mV", d="100pA")
nml_doc.izhikevich2007_cells.append(izh0)

# Create a network and add it to the model
net = Network(id="IzhNet")
nml_doc.networks.append(net)

# Create a population of defined cells and add it to the model
size0 = 1
pop0 = Population(id="IzhPop0", component=izh0.id, size=size0)
net.populations.append(pop0)

# Define an external stimulus and add it to the model
pg = PulseGenerator(
    id="pulseGen_%i" % 0, delay="0ms", duration="1000ms",
    amplitude="0.07 nA"
)
nml_doc.pulse_generators.append(pg)
exp_input = ExplicitInput(target="%s[%i]" % (pop0.id, 0), input=pg.id)
net.explicit_inputs.append(exp_input)