Python loop Examples

Example #1

File: eNeuro_fig_07_sim_nuclei_80000.py Project: mickelindahl/bgmodel

        'no_oscillations_control':True,
        
        'op_pert_add':op_neuclei.get([0,7]),
        
        'path_rate_runs':path_rate_runs,
        'path_results':dr.HOME_DATA+ '/'+ FILE_NAME + '/',
        'perturbation_list':ops,
        
        'sim_time':100000.0,
        'size':80000.0 ,
        'STN_amp_mod':STN_amp_mod,
        
        'tuning_freq_amp_to':'M2',
        
        'wrapper_process':WRAPPER_PROCESS, #user defined wrapper of subprocesses

        }

p_list = pert_add_oscillations(**kwargs)
p_list=pert_add(p_list, **kwargs)

for i, p in enumerate(p_list): 
    print i, p
    
a_list=get_args_list_oscillation(p_list, **kwargs)
k_list=get_kwargs_list_indv_nets(len(p_list), kwargs)


loop(8,[num_sim, num_sim, NUM_RUNS], a_list, k_list )

        

Example #2

    'l_minutes': ['15', '10', '5'],
    'l_seconds': ['00', '00', '00'],
    'lower': 1,
    'local_num_threads': LOCAL_NUM_THREADS,
    'module': module,
    'nets': ['Net_{}'.format(i) for i in range(NUM_NETS)],
    'resolution': 5,
    'repetitions': 1,
    'path_results': dr.HOME_DATA + '/' + FILE_NAME + '/',
    'perturbation_list': ops,
    'size': 3000,
    'upper': 3,
    'wrapper_process': WRAPPER_PROCESS,  #user defined wrapper of subprocesses
}

p_list = pert_add_inhibition(**kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_inhibition(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

for obj in a_list:
    print obj.kwargs['setup'].nets_to_run

# for i, a in enumerate(args_list):
#     print i, a
loop(min(num_sim, 10), [num_sim, num_sim, NUM_RUNS], a_list, k_list,
     **{'config': config})

Example #3

File: simulate_Go_NoGo_XXX_no_ss_scaling_ST_v2.py Project: sunzhe839/bgmodel

        1.,
        1.,
    ],
    'p_subsamp': [
        1.,
        1.,
        1.,
        1.,
        1.,
    ],
    'res':
    10,
    'rep':
    40,
    'time_bin':
    100,
}

d_process_and_thread = par_process_and_thread(**kwargs)
kwargs.update(d_process_and_thread)

p_list = pert_add_go_nogo_ss(**kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_Go_NoGo_compete(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(3, [25, 25, 5], a_list, k_list)

Example #4

File: eNeuro_fig_06_scale_rest_7x7_80000.py Project: mickelindahl/bgmodel

if my_socket.determine_computer()=='milner':
    kw_add={
            'duration':[907.,100.0],            
            'laptime':1007.0,
            'res':7,
            'rep':10,
            'time_bin':100.,

            }
elif my_socket.determine_computer() in ['thalamus','supermicro']:
    kw_add={
            'duration':[357., 100.0],
            'laptime':457.,
            'res':3, 
            'rep':5,
            'time_bin':1000./256,
            }


kwargs.update(kw_add)

p_list=pert_add_go_nogo_ss(**kwargs)

for i, p in enumerate(p_list): print i, p

a_list=get_args_list_Go_NoGo_compete_oscillation(p_list, **kwargs)
k_list=get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(3, [num_sims, num_sims, NUM_RUNS], a_list, k_list )
        

Example #5

File: optimization_single_ST_0.py Project: mickelindahl/bgmodel

        'path_results':dr.HOME_DATA+ '/'+ FILE_NAME + '/',
        'perturbation_list':ops,
        
        
        'sim_time':20000.0,
        'single_unit':['ST']*n_ops, #Same size as ops
        'size':1.0 ,
#         'STN_amp_mod':STN_amp_mod,
        
        'tp_names':['beta']*(n_ops/2)+['sw']*(n_ops/2), #Same size as ops
#         'tuning_freq_amp_to':'M2',
        
        'wrapper_process':WRAPPER_PROCESS, #user defined wrapper of subprocesses
        }


p_list = pert_add_single(**kwargs)

for i, p in enumerate(p_list): 
    print i, p

a_list=get_args_list_opt_single(p_list, **kwargs)
k_list=get_kwargs_list_indv_nets(len(p_list), kwargs)

for i, obj in enumerate(a_list):
    print i, obj.kwargs['from_disk']

loop(4,[num_sims], a_list, k_list )

Example #6

    for i, p in enumerate(p_list):

        # #         if i<n-9:
        if i != 0:
            continue

        script_name = (__file__.split('/')[-1][0:-3] + '/script_' + str(i) +
                       '_' + p.name + '_' + type_of_run)
        setup = simulate_beta.Setup(1000.0 / 20.0, threads)
        obj = simulate_beta.Main(
            **{
                'builder': Builder,
                'from_disk': j,
                'perturbation_list': p,
                'script_name': script_name,
                'setup': setup
            })
        #         obj.do()
        args_list.append([obj, script_name])

# for i, a in enumerate(args_list):
#     print i, a

loop(
    args_list, path, 1, **{
        'type_of_run': type_of_run,
        'threads': threads,
        'i0': j0,
        'debug': False
    })

Example #7

                                     FILE_NAME),
        'perturbation_list':[op.get()[4+3]],
        'proportion_connected':[0.2]*1, #related to toal number fo runs
        
        'pulses':[5],
        'p_sizes':[
                    1,
                ],
        'p_subsamp':[
                     1., 
                    ],
        'res':10,
        'rep':80,

       'time_bin':200,
        }

d_process_and_thread=par_process_and_thread(**kwargs)
kwargs.update(d_process_and_thread)

p_list=pert_add_go_nogo_ss(**kwargs)

for i, p in enumerate(p_list): print i, p

a_list=get_args_list_Go_NoGo_compete(p_list, **kwargs)
k_list=get_kwargs_list_indv_nets(len(p_list), kwargs)

# loop(get_loop_index(5, [15,15,3]), a_list, k_list )
        
loop(1, [NUM_NETS,NUM_NETS,1], a_list, k_list )

Example #8

File: simulate_slow_wave_ZZZ2.py Project: sunzhe839/bgmodel

    return ll, threads


p_list, threads = perturbations()
for i, p in enumerate(p_list):
    print i, p
args_list = []

from os.path import expanduser
home = expanduser("~")

path = (home + '/results/papers/inhibition/network/' +
        __file__.split('/')[-1][0:-3] + '/')

for j in range(1, 3):
    for i, p in enumerate(p_list):

        #         if i<5:
        #             continue
        #
        from_disk = j

        fun = simulate_slow_wave.main
        script_name = (__file__.split('/')[-1][0:-3] + '/script_' + str(i) +
                       '_' + p.name)
        #         fun(*[Builder, from_disk, p, script_name, threads])
        args_list.append([fun, script_name] +
                         [Builder, from_disk, p, script_name, threads])

loop(args_list, path, 4)

Example #9

File: simulate_Go_NoGo_XXX_no_ss.py Project: sunzhe839/bgmodel

    'other_scenario':
    False,
    'path_code':
    default_params.HOME_CODE,
    'path_results':
    get_path_logs(LOAD_MILNER_ON_SUPERMICRO, FILE_NAME),
    'perturbation_list': [op.get()[4 + 3]],
    'proportion_connected': [0.08] * 4,  #related to toal number fo runs
    'p_sizes': [1.],
    'p_subsamp': [1.],
    'res':
    10,
    'rep':
    40,
    'time_bin':
    100,
}

d_process_and_thread = par_process_and_thread(**kwargs)
kwargs.update(d_process_and_thread)

p_list = pert_add_go_nogo_ss(**kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_Go_NoGo_compete(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(get_loop_index(5, [5, 5, 1]), a_list, k_list)

Example #10

File: simulate_Go_NoGo_XXX_nodop_FS_recovery.py Project: sunzhe839/bgmodel

    'local_threads_milner': 40,
    'local_threads_superm': 4,
    'max_size': 20000.,
    'module': module,
    'nets': ['Net_0', 'Net_1', 'Net_2', 'Net_3'],
    'op_pert_add': [op_dop.get()[5]],
    'path_code': default_params.HOME_CODE,
    'path_results': get_path_logs(LOAD_MILNER_ON_SUPERMICRO, FILE_NAME),
    'perturbation_list': [op.get()[7]],
    'proportion_connected': [0.08] * 4,  #related to toal number fo runs
    'p_sizes': [1.],
    'p_subsamp': [1.],
    'res': 10,
    'rep': 40,
    'time_bin': 100,
}

d_process_and_thread = par_process_and_thread(**kwargs)
kwargs.update(d_process_and_thread)

p_list = pert_add_go_nogo_ss(**kwargs)
p_list = pert_add(p_list, **kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_Go_NoGo_compete(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(get_loop_index(4, [4, 4, 1]), a_list, k_list)

Example #11

File: simulate_beta_ZZZ151_slow.py Project: sunzhe839/bgmodel

    'module': module,
    'nets': ['Net_0', 'Net_1'],  #The nets for each run
    'no_oscillations_control': True,
    'path_code': default_params.HOME_CODE,
    'path_rate_runs': path_rate_runs,
    'path_results': get_path_logs(LOAD_MILNER_ON_SUPERMICRO, FILE_NAME),
    'perturbation_list': op.get(),
    'sim_time': 40000.0,
    'size': 20000.0,
    'STN_amp_mod': [1.0],
}

d_process_and_thread = par_process_and_thread(**kwargs)
pp(d_process_and_thread)
kwargs.update(d_process_and_thread)

p_list = pert_add_oscillations(**kwargs)
p_list = pert_set_data_path_to_milner_on_supermicro(p_list,
                                                    LOAD_MILNER_ON_SUPERMICRO)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_oscillation(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

for i, obj in enumerate(a_list):
    print i, obj.kwargs['from_disk']

loop(20, [num_sims, num_sims, num_runs], a_list, k_list)

Example #12

File: simulate_Go_NoGo_XXX_nodop_FS_recovery2_v2.py Project: sunzhe839/bgmodel

    'local_threads_superm': 4,
    'max_size': 20000.,
    'module': module,
    'nets': ['Net_0'],
    'op_pert_add': op_pert_add,
    'other_scenario': True,
    'path_code': default_params.HOME_CODE,
    'path_results': get_path_logs(LOAD_MILNER_ON_SUPERMICRO, FILE_NAME),
    'perturbation_list': [op.get()[7]],
    'proportion_connected': [0.2] * NUM_NETS,  #related to toal number fo runs
    'p_sizes': [1.],
    'p_subsamp': [1.],
    'res': 10,
    'rep': 40,
    'time_bin': 100,
}

d_process_and_thread = par_process_and_thread(**kwargs)
kwargs.update(d_process_and_thread)

p_list = pert_add_go_nogo_ss(**kwargs)
p_list = pert_add(p_list, **kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_Go_NoGo_compete(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(2, [NUM_NETS, NUM_NETS, NUM_NETS], a_list, k_list)

Example #13

   
path=(home + '/results/papers/inhibition/network/'
      +__file__.split('/')[-1][0:-3]+'/')

n=len(p_list)



for j in range(0,3):
    for i, p in enumerate(p_list):
        
# #         if i<n-9:
#         if i>18:
#             continue

        from_disk=j

        fun=inhibition_striatum.main
        script_name=(__file__.split('/')[-1][0:-3]+'/script_'+str(i)+'_'+p.name)
#         fun(*[Builder, from_disk, p, script_name, 
#               Setup(threads, res, rep, low, upp)])
        args_list.append([fun,script_name]
                         +[Builder, from_disk, p, 
                           script_name, 
                           Setup(threads, res, rep, low, upp)])

# for i, a in enumerate(args_list):
#     print i, a

loop(args_list, path, 8)
        

Example #14

    'max_size': 20000,
    'module': module,
    'nets': ['Net_0'],
    'nets_to_run': ['Net_0'],
    'other_scenario': True,
    'path_rate_runs': path_rate_runs,
    'path_results': dr.HOME_DATA + '/' + FILE_NAME + '/',
    'perturbation_list': ops,
    'proportion_connected':
    proportion_connected,  #related to toal number fo runs
    'p_pulses': [5] * NUM_NETS,  #size of labels
    'p_sizes': [1.] * NUM_RUNS,
    'p_subsamp': [1.] * NUM_RUNS,
    'res': 10,
    'rep': 40,
    'time_bin': 100,
    'wrapper_process': WRAPPER_PROCESS,  #user defined wrapper of subprocesses
}

p_list = pert_add_go_nogo_ss(**kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_Go_NoGo_compete(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

# loop(get_loop_index(5, [15,15,3]), a_list, k_list )

loop(3, [num_sims, num_sims, 1], a_list, k_list)

Example #15

        'path_code':default_params.HOME_CODE,
        'path_results':get_path_logs(LOAD_MILNER_ON_SUPERMICRO, 
                                     FILE_NAME),
        'perturbation_list':op.get(),
        
        'size':3000,
        
        'upper':3}

d_process_and_thread=par_process_and_thread(**kwargs)
pp(d_process_and_thread)
kwargs.update(d_process_and_thread)

p_list = pert_add_inhibition(**kwargs)
p_list = pert_set_data_path_to_milner_on_supermicro(p_list,
                                                  LOAD_MILNER_ON_SUPERMICRO)

for i, p in enumerate(p_list): print i, p

a_list=get_args_list_inhibition(p_list, **kwargs)
k_list=get_kwargs_list_indv_nets(len(p_list), kwargs)

for obj in a_list:
    print obj.kwargs['setup'].nets_to_run

# for i, a in enumerate(args_list):
#     print i, a
loop(min(num_sim, 10),[num_sim, num_sim, NUM_RUNS], a_list, k_list )
# loop(args_list, path, 1)

Example #16

File: simulate_Go_NoGo_XXX_nodop_FS.py Project: sunzhe839/bgmodel

    'laptime': 1000.0,
    'local_threads_milner': 40,
    'local_threads_superm': 4,
    'max_size': 20000.,
    'module': module,
    'nets': ['Net_0', 'Net_1', 'Net_2', 'Net_3'],
    'path_code': default_params.HOME_CODE,
    'path_results': get_path_logs(LOAD_MILNER_ON_SUPERMICRO, FILE_NAME),
    'perturbation_list': [op.get()[4 + 3]],
    'proportion_connected': [0.08] * 4,  #related to toal number fo runs
    'p_sizes': [1.],
    'p_subsamp': [1.],
    'res': 10,
    'rep': 40,
    'time_bin': 100,
}

d_process_and_thread = par_process_and_thread(**kwargs)
kwargs.update(d_process_and_thread)

p_list = pert_add_go_nogo_ss(**kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_Go_NoGo_compete(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

ch = get_loop_index(4, [4, 4, 1], FROM_DISK_0)
loop(ch, a_list, k_list)

Example #17

    'local_threads_superm': 1,
    'module': module,
    'nets': ['Net_0', 'Net_1'],  #The nets for each run
    'no_oscillations_control': True,
    'path_code': default_params.HOME_CODE,
    'path_rate_runs': path_rate_runs,
    'path_results': get_path_logs(LOAD_MILNER_ON_SUPERMICRO, FILE_NAME),
    'perturbation_list': [op.get()[2]],
    'sim_time': 10000.0,
    'size': 20000.0,
}

d_process_and_thread = par_process_and_thread(**kwargs)
pp(d_process_and_thread)
kwargs.update(d_process_and_thread)

p_list = pert_add_oscillations(**kwargs)
p_list = pert_set_data_path_to_milner_on_supermicro(p_list,
                                                    LOAD_MILNER_ON_SUPERMICRO)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_oscillation(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

for i, obj in enumerate(a_list):
    print i, obj.kwargs['from_disk']

loop(10, [num_sims, num_sims, num_sims / 2], a_list, k_list)

Example #18

                   1.,
                   1.,
                   1.,
                   1.,
                   1.,
                  ],
        'p_subsamp':[
                     1.,
                     1.,
                     1.,
                     1.,
                     1.,
                     ],
        'res':10,
        'rep':40,
        
        'time_bin':100,
        }

d_process_and_thread=par_process_and_thread(**kwargs)
kwargs.update(d_process_and_thread)

p_list=pert_add_go_nogo_ss(**kwargs)

for i, p in enumerate(p_list): print i, p

a_list=get_args_list_Go_NoGo_compete(p_list, **kwargs)
k_list=get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(get_loop_index(5, [25,25,5]), a_list, k_list )
        

Example #19

File: simulate_slow_wave_ZZZ_conn_effect_perturb_ii.py Project: sunzhe839/bgmodel

    'nets': ['Net_' + str(i) for i in range(2)],  #The nets for each run
    'op_pert_add': op_conns.get(),
    'path_code': default_params.HOME_CODE,
    'path_rate_runs': path_rate_runs,
    'path_results': get_path_logs(LOAD_MILNER_ON_SUPERMICRO, FILE_NAME),
    'perturbation_list': op.get(),
    'sim_time': 40000.0,
    'size': 20000.0,
}

d_process_and_thread = par_process_and_thread(**kwargs)
pp(d_process_and_thread)
kwargs.update(d_process_and_thread)

pp(kwargs)

p_list = pert_add_oscillations(**kwargs)

p_list = pert_add(p_list, **kwargs)

for i, p in enumerate(p_list):
    print i, p
#     for l in p.list:
#         if len(l.val)==2:
#             print l

a_list = get_args_list_oscillation(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(30, [NUM_NETS, NUM_NETS, NUM_NETS / 2], a_list, k_list)

Example #20

File: eNeuro_fig_01_and_02_sim_inh.py Project: sunzhe839/bgmodel

    'l_minutes': ['15', '10', '5'],
    'l_seconds': ['00', '00', '00'],
    'lower': 1,
    'local_num_threads': LOCAL_NUM_THREADS,
    'module': module,
    'nets': ['Net_{}'.format(i) for i in range(NUM_NETS)],
    'nets_to_run': ['Net_{}'.format(i) for i in range(NUM_NETS)],
    'resolution': 5,
    'repetitions': 1,
    'path_results': dr.HOME_DATA + '/' + FILE_NAME + '/',
    'perturbation_list': ops,
    'size': 3000,
    'upper': 3,
    'wrapper_process': WRAPPER_PROCESS,  #user defined wrapper of subprocesses
}

p_list = pert_add_inhibition(**kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_inhibition(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

for obj in a_list:
    print obj.kwargs['setup'].nets_to_run

# for i, a in enumerate(args_list):
#     print i, a
loop(10, [NUM_RUNS, NUM_RUNS, NUM_RUNS], a_list, k_list, **{'config': config})

Example #21

    'job_name': 'eNf7_nuc',
    'l_hours': ['01', '02', '00'],
    'l_minutes': ['00', '00', '5'],
    'l_seconds': ['00', '00', '00'],
    'local_num_threads': LOCAL_NUM_THREADS,
    'module': module,
    'nets': ['Net_' + str(i) for i in range(NUM_NETS)],  #The nets for each run
    'nets_to_run': ['Net_0', 'Net_1'],
    'no_oscillations_control': True,
    'op_pert_add': op_neuclei.get(),
    'path_rate_runs': path_rate_runs,
    'path_results': dr.HOME_DATA + '/' + FILE_NAME + '/',
    'perturbation_list': ops,
    'sim_time': 40000.0,
    'size': 20000.0,
    'STN_amp_mod': STN_amp_mod,
    'tuning_freq_amp_to': 'M2',
    'wrapper_process': WRAPPER_PROCESS,  #user defined wrapper of subprocesses
}

p_list = pert_add_oscillations(**kwargs)
p_list = pert_add(p_list, **kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_oscillation(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(num_sim, [num_sim, num_sim, NUM_RUNS], a_list, k_list)

Example #22

File: eNeuro_fig_07_recovery_cases_7x7.py Project: sunzhe839/bgmodel

if my_socket.determine_computer()=='milner':
    kw_add={
            'duration':[907.,100.0],            
            'laptime':1007.0,
            'res':7,
            'rep':10,
            'time_bin':10000.,

            }
elif my_socket.determine_computer() in ['thalamus','supermicro']:
    kw_add={
            'duration':[357., 100.0],
            'laptime':457.,
            'res':3, 
            'rep':5,
            'time_bin':1000/256.,
            }

kwargs.update(kw_add)

p_list=pert_add_go_nogo_ss(**kwargs)
p_list=pert_add(p_list, **kwargs)

for i, p in enumerate(p_list): print i, p

a_list=get_args_list_Go_NoGo_compete_oscillation(p_list, **kwargs)
k_list=get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(NUM_RUNS, [NUM_RUNS,NUM_RUNS,NUM_RUNS], a_list, k_list )
        

Example #23

    'laptime': 1000.0,
    'local_threads_milner': 40,
    'local_threads_superm': 4,
    'max_size': 4000,
    'module': module,
    'nets': ['Net_0', 'Net_1', 'Net_2', 'Net_3', 'Net_4'],
    'other_scenario': True,
    'path_code': default_params.HOME_CODE,
    'path_results': get_path_logs(LOAD_MILNER_ON_SUPERMICRO, FILE_NAME),
    'perturbation_list': [op.get()[4 + 3]],
    'p_sizes': [0.200, 0.161, 0.123, 0.085],
    'p_subsamp': [6.25, 8.3, 12.5, 25],
    'res': 10,
    'rep': 80,
    'to_memory': False,
    'to_file': True
}

d_process_and_thread = par_process_and_thread(**kwargs)
kwargs.update(d_process_and_thread)

p_list = pert_add_go_nogo_ss(**kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_Go_NoGo_compete(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(5, a_list, k_list)

Example #24

File: eNeuro_fig_06_0.2_ST_pulse_7x7_80000.py Project: mickelindahl/bgmodel

        }

if my_socket.determine_computer()=='milner':
    kw_add={
            'duration':[907.,100.0],            
            'laptime':1007.0,
            'res':7,
            'rep':10,
            'time_bin':100.,

            }
elif my_socket.determine_computer() in ['thalamus','supermicro']:
    kw_add={
            'duration':[357., 100.0],
            'laptime':457.,
            'res':3, 
            'rep':5,
            'time_bin':1000./256,
            }

kwargs.update(kw_add)
p_list=pert_add_go_nogo_ss(**kwargs)

for i, p in enumerate(p_list): print i, p

a_list=get_args_list_Go_NoGo_compete_oscillation(p_list, **kwargs)
k_list=get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(1, [NUM_NETS,NUM_NETS,NUM_NETS], a_list, k_list )

Example #25

File: eNeuro_fig_07_sim_conn.py Project: mickelindahl/bgmodel

        'no_oscillations_control':True,
                
        'op_pert_add':op_add.get([0,6]),

        'path_rate_runs':path_rate_runs,
        'path_results':dr.HOME_DATA+ '/'+ FILE_NAME + '/',
        'perturbation_list':ops,
        
        'sim_time':40000.0,
        'size':20000.0 ,
        
        'STN_amp_mod':STN_amp_mod,

        'tuning_freq_amp_to':'M2',
        
        'wrapper_process':WRAPPER_PROCESS, #user defined wrapper of subprocesses

        }

p_list = pert_add_oscillations(**kwargs)
p_list=pert_add(p_list, **kwargs)
    
for i, p in enumerate(p_list): print i, p

a_list=get_args_list_oscillation(p_list, **kwargs)
k_list=get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(num_sims,[num_sims, num_sims, num_sims/2], a_list, k_list )

        

Example #26

for j in range(0, 3):
    for i, p in enumerate(p_list):

        #         if i<n-12:
        if i < 4:
            continue

        from_disk = j

        fun = inhibition_striatum.main
        script_name = (__file__.split('/')[-1][0:-3] + '/script_' + str(i) +
                       '_' + p.name)
        #         fun(*[Builder, from_disk, p, script_name,
        #               Setup(threads, res, rep, low, upp)])
        args_list.append([fun, script_name] + [
            Builder, from_disk, p, script_name,
            Setup(
                **{
                    'threads': threads,
                    'resolution': res,
                    'repetition': rep,
                    'lower': low,
                    'upper': upp
                })
        ])

# for i, a in enumerate(args_list):
#     print i, a

loop(args_list, path, 6)

Example #27

File: fig_06_0.2_ST_pulse.py Project: sunzhe839/bgmodel

    'module': module,
    'nets': ['Net_0'],
    'nets_to_run': ['Net_0'],
    'other_scenario': True,
    'path_rate_runs': path_rate_runs,
    'path_results': dr.HOME_DATA + '/' + FILE_NAME + '/',
    'perturbation_list': ops,
    'proportion_connected': [0.2] * 1,  #related to toal number fo runs
    'p_pulses': [5],
    'p_sizes': [
        1,
    ],
    'p_subsamp': [
        1.,
    ],
    'res': 10,
    'rep': 80,
    'time_bin': 100,
    'wrapper_process': WRAPPER_PROCESS,  #user defined wrapper of subprocesses
}

p_list = pert_add_go_nogo_ss(**kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_Go_NoGo_compete(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(1, [num_sims, num_sims, NUM_RUNS], a_list, k_list)

Example #28

        #         if i!=1:
        #             continue

        from_disk = j

        fun = Go_NoGo_compete.main
        script_name = (__file__.split('/')[-1][0:-3] + '/script_' + str(i) +
                       '_' + p.name)
        fun(*[
            Builder, from_disk, p, script_name,
            Setup(**{
                'threads': threads,
                'resolution': res,
                'repetition': rep
            })
        ])

        args_list.append([fun, script_name] + [
            Builder, from_disk, p, script_name,
            Setup(**{
                'threads': threads,
                'resolution': res,
                'repetition': rep
            })
        ])

# for i, a in enumerate(args_list):
#     print i, a

loop(args_list, path, 2)

Example #29

File: simulate_beta_ZZZ21.py Project: sunzhe839/bgmodel

    'module': module,
    'nets': ['Net_0', 'Net_1'],  #The nets for each run
    'no_oscillations_control': True,
    'path_code': default_params.HOME_CODE,
    'path_rate_runs': path_rate_runs,
    'path_results': get_path_logs(LOAD_MILNER_ON_SUPERMICRO, FILE_NAME),
    'perturbation_list': op.get(),
    'sim_time': 40000.0,
    'size': 20000.0,
    'STN_amp_mod': [1.0],
}

d_process_and_thread = par_process_and_thread(**kwargs)
pp(d_process_and_thread)
kwargs.update(d_process_and_thread)

p_list = pert_add_oscillations(**kwargs)
p_list = pert_set_data_path_to_milner_on_supermicro(p_list,
                                                    LOAD_MILNER_ON_SUPERMICRO)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_oscillation(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

for i, obj in enumerate(a_list):
    print i, obj.kwargs['from_disk']

loop(21, [num_sims, num_sims, num_sims / 2], a_list, k_list)

Example #30

File: optimization_single_ST_0_control.py Project: sunzhe839/bgmodel

    #         'path_rate_runs':path_rate_runs,
    'path_results':
    dr.HOME_DATA + '/' + FILE_NAME + '/',
    'perturbation_list':
    ops,
    'sim_time':
    20000.0,
    'single_unit': ['ST'] * n_ops,  #Same size as ops
    'size':
    1.0,
    #         'STN_amp_mod':STN_amp_mod,
    'tp_names':
    ['beta'] * (n_ops / 2) + ['sw'] * (n_ops / 2),  #Same size as ops
    #         'tuning_freq_amp_to':'M2',
    'wrapper_process':
    WRAPPER_PROCESS,  #user defined wrapper of subprocesses
}

p_list = pert_add_single(**kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_opt_single(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

for i, obj in enumerate(a_list):
    print i, obj.kwargs['from_disk']

loop(4, [num_sims], a_list, k_list)

Example #31

    'p_sizes': [
        1,
        0.523,
        0.4278185787,
    ],
    'p_subsamp': [
        1.,
        2.5,
        5.,
    ],
    'res':
    10,
    'rep':
    10,
    'time_bin':
    50,
}

d_process_and_thread = par_process_and_thread(**kwargs)
kwargs.update(d_process_and_thread)

p_list = pert_add_go_nogo_ss(**kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_Go_NoGo_compete(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(get_loop_index(5, [15, 15, 3]), a_list, k_list)

Example #32

home = expanduser("~")

path = (home + '/results/papers/inhibition/network/' +
        __file__.split('/')[-1][0:-3] + '/')

n = len(p_list)

for j in range(0, 3):
    for i, p in enumerate(p_list):

        if i < n - 12:
            #         if i>18:
            continue

        from_disk = j

        fun = inhibition_striatum.main
        script_name = (__file__.split('/')[-1][0:-3] + '/script_' + str(i) +
                       '_' + p.name)
        #         fun(*[Builder, from_disk, p, script_name,
        #               Setup(threads, res, rep, low, upp)])
        args_list.append([fun, script_name] + [
            Builder, from_disk, p, script_name,
            Setup(threads, res, rep, low, upp)
        ])

# for i, a in enumerate(args_list):
#     print i, a

loop(args_list, path, 7)

Example #33

for j in range(0, 3):
    for i, p in enumerate(p_list):
#         
        if i<2:
#         if i!=1:
            continue

        from_disk=j

        fun=Go_NoGo_compete.main
        script_name=(__file__.split('/')[-1][0:-3]+'/script_'+str(i)+'_'+p.name)
#         fun(*[Builder, from_disk, p, script_name, 
#               Setup(**{'threads':threads,
#                        'resolution':res,
#                        'repetition':rep})])

        args_list.append([fun,script_name]
                         +[Builder, from_disk, p, 
                           script_name, 
                           Setup(**{'threads':threads,
                                    'resolution':res,
                                    'repetition':rep})])

# for i, a in enumerate(args_list):
#     print i, a

loop(args_list, path, 1)
        

Example #34

    'module': module,
    'nets': ['Net_' + str(i) for i in range(2)],  #The nets for each run
    'op_pert_add': op_dop,
    'path_code': default_params.HOME_CODE,
    'path_rate_runs': get_path_rate_runs('simulate_inhibition_ZZZ4/'),
    'path_results': get_path_logs(LOAD_MILNER_ON_SUPERMICRO, FILE_NAME),
    'perturbation_list': [op.get()[7]],
    'sim_time': 40000.0,
    'size': 20000.0,
}

d_process_and_thread = par_process_and_thread(**kwargs)
pp(d_process_and_thread)
kwargs.update(d_process_and_thread)

pp(kwargs)

p_list = pert_add_oscillations(**kwargs)
p_list = pert_set_data_path_to_milner_on_supermicro(p_list,
                                                    LOAD_MILNER_ON_SUPERMICRO)
p_list = pert_add(p_list, **kwargs)

for i, p in enumerate(p_list):
    print i, p

a_list = get_args_list_oscillation(p_list, **kwargs)
k_list = get_kwargs_list_indv_nets(len(p_list), kwargs)

loop(get_loop_index(NUM_NETS / 2, [NUM_NETS, NUM_NETS, NUM_NETS / 2]), a_list,
     k_list)

Example #35

File: eNeuro_fig_01_and_02_sim_inh.py Project: mickelindahl/bgmodel

        
        'resolution':5,
        'repetitions':1,
        
        'path_results':dr.HOME_DATA+ '/'+ FILE_NAME + '/',
        'perturbation_list':ops,
                
        'size':3000,
        
        'upper':3,
        
        'wrapper_process':WRAPPER_PROCESS, #user defined wrapper of subprocesses
        }


p_list = pert_add_inhibition(**kwargs)

for i, p in enumerate(p_list): print i, p

a_list=get_args_list_inhibition(p_list, **kwargs)
k_list=get_kwargs_list_indv_nets(len(p_list), kwargs)

for obj in a_list:
    print obj.kwargs['setup'].nets_to_run

# for i, a in enumerate(args_list):
#     print i, a
loop(10,[NUM_RUNS, NUM_RUNS, NUM_RUNS], a_list, k_list, **{'config':config} )

Example #36

File: fig_01_and_02_sim_inh.py Project: sunzhe839/bgmodel

        
        'resolution':5,
        'repetitions':1,
        
        'path_results':dr.HOME_DATA+ '/'+ FILE_NAME + '/',
        'perturbation_list':ops,
                
        'size':3000,
        
        'upper':3,
        
        'wrapper_process':WRAPPER_PROCESS, #user defined wrapper of subprocesses
        }


p_list = pert_add_inhibition(**kwargs)

for i, p in enumerate(p_list): print i, p

a_list=get_args_list_inhibition(p_list, **kwargs)
k_list=get_kwargs_list_indv_nets(len(p_list), kwargs)

for obj in a_list:
    print obj.kwargs['setup'].nets_to_run

# for i, a in enumerate(args_list):
#     print i, a
loop(min(1, 12),[NUM_RUNS, NUM_RUNS, NUM_RUNS], a_list, k_list, **{'config':config} )