Esempio n. 1
0
        'singleDataRoot':
        None,
        'noise_sigmas': [0, 150, 300],
        'even_shape':
        None,
        'output_dir':
        'panels',
    })
    env = NoiseEnvironment(user_config=new_config)
    env.register_class(
        noisefigs.plotters.Generic2DPBumpPlotter,
        config={
            'Generic2DPBumpPlotter': {
                'fname': "bumps_pbumps_Iext_e_theta_vs_Iext_e_const_{ns}.pdf",
                'normalize_ticks': (False, False),  # (Y, X)
                'normalize_type': (None, None),
                'xlabel': 'Constant amplitude\n(pA)',
                'ylabel': '$\\theta$ amplitude (pA)',
                'bbox': (.15, .2, .85, .9),
                'yticks': [1, 0, 0],
                'cbar': [0, 0, 1],
            },
        })
    env.plot()

if args.pbumps_Iext_e_vs_uni_GABA or args.all:
    new_config = deepcopy(config.get_config())
    new_config.update({
        'grids_data_root':
        None,
        'bump_data_root': ('simulation_data/i_surround/'
                           'Iext_e_const_vs_uni_GABA/gamma_bump'),
Esempio n. 2
0
if args.bumps_g_II or args.all:
    new_config = deepcopy(config.get_config())
    new_config.update({
        'grids_data_root': None,
        'bump_data_root': os.path.join('simulation_data',
                                       'ii_connections',
                                       'g_II_total_sweep',
                                       'gamma_bump'),
        'vel_data_root':  None,
        'const_pos_data_root': None,
        'singleDataRoot': None,

        'noise_sigmas': [150],
        'even_shape': None,
    })
    env = NoiseEnvironment(user_config=new_config, space_cls=JobTrialSpace1D)
    env.register_class(
        noisefigs.plotters.Generic1DPBumpPlotter,
        config={
            'Generic1DPBumpPlotter' : {
                'fname' : 'bumps_Pbumps_g_II_{ns}.pdf',
                'normalize_ticks': False,
                'xlim': (-10, 410),
                'ylim': (-0.05, 1.05),
            },
        }
    )
    env.plot()


Esempio n. 3
0
 env.register_class(
     noisefigs.plotters.Generic2DPBumpPlotter,
     config={
         'Generic2DPBumpPlotter': {
             'fname':
             "bumps_Pbumps_gEE_pEE_sigma_{ns}.pdf",
             'normalize_ticks': (True, False),  # (Y, X)
             'normalize_type': ('E', None),
             'xlabel':
             '$\sigma_{E{\\rightarrow}E}$',
             'ylabel':
             '$g_{E{\\rightarrow}E}$',
             'bbox': (.2, .17, .85, .9),
             'cbar': [0, 0, 1],
             'ann': [
                 None,
                 [
                     dict(txt='',
                          rc=(20, 5),
                          xytext_offset=(0.03, 1.5),
                          color='black')
                 ],
                 None,
             ],
             'vmin':
             0,
             'vmax':
             0.959,
             'cbar_kw':
             dict(ticks=ti.MultipleLocator(0.2), ),
         },
     })
Esempio n. 4
0
 env = NoiseEnvironment(user_config=new_config)
 env.register_class(
     noisefigs.plotters.GenericGammaPlotter,
     config={
         'GenericGammaPlotter': {
             'what':
             'acVal',
             'fname':
             "gamma_power_Iext_e_theta_vs_Iext_e_const_{ns}.pdf",
             'normalize_ticks': (False, False),  # (Y, X)
             'normalize_type': (None, None),
             'xlabel':
             '',
             'ylabel':
             '$\\theta$ amplitude (pA)',
             'xticks': [0, 0, 0],
             'bbox': (.15, .2, .85, .9),
             'cbar_kw':
             dict(label='$1^{st}$ autocorrelation\npeak',
                  location='right',
                  shrink=0.8,
                  pad=.05,
                  ticks=ti.MultipleLocator(0.1),
                  rasterized=True),
             'vmin':
             0,
             'vmax':
             0.43,
         },
     })
 env.register_class(
        'const_pos_data_root': None,
        'singleDataRoot': None,

        'noise_sigmas': [0, 150, 300],
        'even_shape': None,
        'output_dir': 'panels',
    })
    env = NoiseEnvironment(user_config=new_config)
    env.register_class(
        noisefigs.plotters.Generic2DPBumpPlotter,
        config={
            'Generic2DPBumpPlotter': {
                'fname': "bumps_pbumps_Iext_e_theta_vs_Iext_e_const_{ns}.pdf",
                'normalize_ticks': (False, False),  # (Y, X)
                'normalize_type': (None, None),
                'xlabel': 'Constant amplitude\n(pA)',
                'ylabel': '$\\theta$ amplitude (pA)',
                'bbox': (.15, .2, .85, .9),

                'yticks': [1, 0, 0],
                'cbar': [0, 0, 1],
            },
        })
    env.plot()


if args.pbumps_Iext_e_vs_uni_GABA or args.all:
    new_config = deepcopy(config.get_config())
    new_config.update({
        'grids_data_root': None,
        'bump_data_root': ('simulation_data/i_surround/'
                      'ee_connections_ei_flat',
                      'standard_sweep_g_EE_3060_pEE_sigma_0_0833',
                      'gamma_bump', '0pA')
    sp_0 = JobTrialSpace2D(shape, output_dir_0)
    new_config = deepcopy(config.get_config())
    env = MplEnvironment(config=new_config)
    env.register_class(
        noisefigs.plotters.PopulationActivityPlotter,
        config={
            'data_root'     : output_dir_0,
            'data_file_name': sp_0[1][22].file_name_base,
            'output_dir'    : 'panels_standard_gEE_3060',

            'PopulationActivityPlotter': {
                'fname_prefix': '0pA_r1_c22_',
                'raster_rect': (.075, 0.35, 0.93, 0.97),
                'fig_saver': SeparateMultipageSaver(None, 'pdf'),
                'fig_size': (8, 6),
                't_limits': (0, 5e3),

                'snapshot_tstep': 4,
                'e_snapshots_rect': (.075, .15, 0.93, 0.25),
                'i_snapshots_rect': (.075, .02, 0.93, 0.12),
            },
        })
    env.plot()


    output_dir = join('simulation_data',
                      'ee_connections_ei_flat',
                      'standard_sweep_g_EE_3060_pEE_sigma_0_0833',
Esempio n. 7
0
            "const_pos_data_root": None,
            "singleDataRoot": None,
            "noise_sigmas": [0, 150, 300],
            "even_shape": None,
        }
    )
    env = NoiseEnvironment(user_config=new_config)
    env.register_class(
        noisefigs.plotters.Generic2DPBumpPlotter,
        config={
            "Generic2DPBumpPlotter": {
                "fname": "bumps_Pbumps_gEE_pEE_sigma_{ns}.pdf",
                "normalize_ticks": (True, False),  # (Y, X)
                "normalize_type": ("E", None),
                "xlabel": "$\sigma_{E{\\rightarrow}E}$",
                "ylabel": "$g_{E{\\rightarrow}E}$",
                "bbox": (0.2, 0.17, 0.85, 0.9),
                "cbar": [0, 0, 1],
                "ann": [None, [dict(txt="", rc=(20, 5), xytext_offset=(0.03, 1.5), color="black")], None],
                "vmin": 0,
                "vmax": 0.959,
                "cbar_kw": dict(ticks=ti.MultipleLocator(0.2)),
            }
        },
    )
    env.plot()


if args.rasters_gEE_EE_sigma or args.all:
    shape = (31, 11)
    output_dir = join("simulation_data", "ee_connections_ei_flat", "g_EE_total_vs_pEE_sigma", "gamma_bump", "150pA")
    sp = JobTrialSpace2D(shape, output_dir)
Esempio n. 8
0
 env.register_class(
     noisefigs.plotters.GenericGammaPlotter,
     config={
         'GenericGammaPlotter': {
             'scale_factor':
             .7,
             'what':
             'acVal',
             'fname':
             "gamma_sweeps{ns}.pdf",
             'normalize_ticks': (True, True),  # (Y, X)
             'normalize_type': ('E', 'I'),
             'xlabel':
             '',
             'xticks': [False, False, False],
             'ylabel':
             None,
             'yticks': [True, False, False],
             'bbox': (.2, .17, .85, .87),
             'vmin':
             .0,
             'vmax':
             .505,
             'cbar': [0, 0, 1],
             'cbar_kw':
             dict(ticks=ti.MultipleLocator(0.1), ),
             'plot_grid_contours': [0, 0, 0],
             'ann': [
                 dict(
                     txt='b',
                     rc=(5, 15),
                     xytext_offset=(.1, 0),
                     color='white',
                 ),
                 dict(
                     txt='a',
                     rc=(15, 5),
                     xytext_offset=(-.05, 20.),
                     color='white',
                 ),
             ],
         },
     })
        'output_dir': 'panels',
    })
    env = NoiseEnvironment(user_config=new_config)
    env.register_class(
        noisefigs.plotters.GenericGammaPlotter,
        config={
            'GenericGammaPlotter': {
                'what': 'acVal',
                'fname': "gamma_power_Iext_e_theta_vs_Iext_e_const_{ns}.pdf",
                'normalize_ticks': (False, False),  # (Y, X)
                'normalize_type': (None, None),
                'xlabel': '',
                'ylabel': '$\\theta$ amplitude (pA)',
                'xticks': [0, 0, 0],
                'bbox': (.15, .2, .85, .9),

                'cbar_kw': dict(
                    label      = '$1^{st}$ autocorrelation\npeak',
                    location    = 'right',
                    shrink      = 0.8,
                    pad         = .05,
                    ticks      = ti.MultipleLocator(0.1),
                    rasterized  = True
                ),

                'vmin': 0,
                'vmax': 0.43,
            },
        })
    env.register_class(
        noisefigs.plotters.GenericGammaPlotter,
        config={
    env.register_class(
        noisefigs.plotters.GenericGammaPlotter,
        config={
            'GenericGammaPlotter': {
                'scale_factor': .7,
                'what': 'acVal',
                'fname': "gamma_sweeps{ns}.pdf",
                'normalize_ticks': (True, True),  # (Y, X)
                'normalize_type': ('E', 'I'),
                'xlabel': '',
                'xticks': [False, False, False],
                'ylabel': None,
                'yticks': [True, False, False],
                'bbox': (.2, .17, .85, .87),
                'vmin': .0,
                'vmax': .505,
                'cbar': [0, 0, 1],
                'cbar_kw': dict(
                    ticks = ti.MultipleLocator(0.1),
                ),
                'plot_grid_contours': [0, 0, 0],

                'ann': [
                    dict(
                        txt='b',
                        rc=(5, 15),
                        xytext_offset=(.1, 0),
                        color='white',
                    ),
                    dict(
                        txt='a',
                        rc=(15, 5),
                        xytext_offset=(-.05, 20.),
                        color='white',
                    ),
                ],
            },
        })
Esempio n. 11
0
        'const_pos_data_root':
        None,
        'singleDataRoot':
        None,
        'noise_sigmas': [150],
        'even_shape':
        None,
        'output_dir':
        'panels',
    })
    env = NoiseEnvironment(user_config=new_config)
    env.register_class(noisefigs.plotters.GridSweepsPlotter,
                       config={
                           'GridSweepsPlotter': {
                               'fname_prefix': "pastoll_pc_weight_3_",
                               'vmin': -0.4286,
                               'vmax': 0.8582,
                               'ann': None,
                           },
                       })
    env.plot()

if args.grids_pastoll_pc_weight or args.all:
    new_config = deepcopy(config.get_config())
    new_config.update({
        'bump_data_root':
        None,
        'grids_data_root':
        os.path.join('simulation_data', 'i_surround',
                     'pastoll_et_al_pc_max_rate_vs_weight', 'grids'),
        'vel_data_root':
Esempio n. 12
0
        'bump_data_root': ('simulation_data/g_EE_total_vs_pEE_sigma/'
                           'gamma_bump'),
        'vel_data_root':  None,
        'const_pos_data_root': None,
        'singleDataRoot': None,

        'noise_sigmas': [150],
        'even_shape': None,
    })
    env = NoiseEnvironment(user_config=new_config)
    env.register_class(
        noisefigs.plotters.Generic2DPBumpPlotter,
        config={
            'Generic2DPBumpPlotter': {
                'fname': "bumps_Pbumps_gEE_pEE_sigma_{ns}.pdf",
                'normalize_ticks': (True, False),  # (Y, X)
                'normalize_type': ('E', None),
                'xlabel': '$\sigma_{E{\\rightarrow}E}$',
                'ylabel': '$g_{E{\\rightarrow}E}$',
                'bbox': (.2, .17, .85, .9),
            },
        })
    env.plot()

if args.pbumps_gAMPA_AMPA_sigma or args.all:
    new_config = deepcopy(config.get_config())
    new_config.update({
        'grids_data_root': None,
        'bump_data_root': 'simulation_data/g_AMPA_total_vs_pAMPA_sigma/',
        'vel_data_root':  None,
        'const_pos_data_root': None,
        'singleDataRoot': None,
Esempio n. 13
0
from noisefigs.env import NoiseEnvironment

import config

parser = flagparse.FlagParser()
parser.add_flag('--pbumps')
parser.add_flag('--pbumps_narrow_sigma')
args = parser.parse_args()


env = NoiseEnvironment(user_config=config.get_config())

if args.pbumps or args.all:
    env.register_plotter(noisefigs.plotters.GEProfileWidthBumpPlotter)

if args.pbumps_narrow_sigma or args.all:
    new_config = deepcopy(config.get_config())
    new_config['bump_data_root'] = ('simulation_data/pAMPA_sigma/'
                                    'sigma_sweep_narrow_range')
    narrow_env = NoiseEnvironment(user_config=new_config)
    narrow_env.register_class(
        noisefigs.plotters.GEProfileWidthBumpPlotter,
        config={
            'GEProfileWidthBumpPlotter': {
                'fname': "bumps_Pbumps_gE_pAMPA_sigma_narrow{ns}.pdf"
            },
        })

env.plot()
narrow_env.plot()
Esempio n. 14
0
     None,
     'const_pos_data_root':
     None,
     'singleDataRoot':
     None,
     'noise_sigmas': [150],
     'even_shape':
     None,
 })
 env = NoiseEnvironment(user_config=new_config, space_cls=JobTrialSpace1D)
 env.register_class(noisefigs.plotters.Generic1DGammaPlotter,
                    config={
                        'Generic1DGammaPlotter': {
                            'what': 'acVal',
                            'fname': 'gamma_power_g_II_{ns}.pdf',
                            'normalize_ticks': False,
                            'ylabel': '$1^{st}$ autocorrelation peak',
                            'xlim': (-10, 410),
                            'ylim': (-0.04, 0.58),
                        },
                    })
 env.register_class(noisefigs.plotters.Generic1DGammaPlotter,
                    config={
                        'Generic1DGammaPlotter': {
                            'what': 'freq',
                            'fname': 'gamma_freq_g_II_{ns}.pdf',
                            'normalize_ticks': False,
                            'ylabel': 'Frequency (Hz)',
                            'xlim': (-10, 410),
                            'ylim': (22, 175),
                        },
    output_dir_0 = join('simulation_data', 'ee_connections_ei_flat',
                        'standard_sweep_g_EE_3060_pEE_sigma_0_0833',
                        'gamma_bump', '0pA')
    sp_0 = JobTrialSpace2D(shape, output_dir_0)
    new_config = deepcopy(config.get_config())
    env = MplEnvironment(config=new_config)
    env.register_class(noisefigs.plotters.PopulationActivityPlotter,
                       config={
                           'data_root': output_dir_0,
                           'data_file_name': sp_0[1][22].file_name_base,
                           'output_dir': 'panels_standard_gEE_3060',
                           'PopulationActivityPlotter': {
                               'fname_prefix': '0pA_r1_c22_',
                               'raster_rect': (.075, 0.35, 0.93, 0.97),
                               'fig_saver':
                               SeparateMultipageSaver(None, 'pdf'),
                               'fig_size': (8, 6),
                               't_limits': (0, 5e3),
                               'snapshot_tstep': 4,
                               'e_snapshots_rect': (.075, .15, 0.93, 0.25),
                               'i_snapshots_rect': (.075, .02, 0.93, 0.12),
                           },
                       })
    env.plot()

    output_dir = join('simulation_data', 'ee_connections_ei_flat',
                      'standard_sweep_g_EE_3060_pEE_sigma_0_0833',
                      'gamma_bump', '150pA')
    sp = JobTrialSpace2D(shape, output_dir)
    new_config = deepcopy(config.get_config())
Esempio n. 16
0
        'const_pos_data_root': None,
        'singleDataRoot': None,

        'noise_sigmas': [150],
        'even_shape': None,
    })
    env = NoiseEnvironment(user_config=new_config)
    env.register_class(
        noisefigs.plotters.GenericGammaPlotter,
        config={
            'GenericGammaPlotter': {
                'what': 'acVal',
                'fname': "gamma_power_gEE_pEE_sigma_{ns}.pdf",
                'normalize_ticks': (True, False),  # (Y, X)
                'normalize_type': ('E', None),
                'xlabel': '$\sigma_{E{\\rightarrow}E}$',
                'ylabel': '$g_{E{\\rightarrow}E}$',
                'bbox': (.2, .17, .85, .9),
                'vmin': .0,
                'vmax': .505,
                'cbar_kw': dict(
                    ticks = ti.MultipleLocator(0.1),
                )
                },
        })
    env.register_class(
        noisefigs.plotters.GenericGammaPlotter,
        config={
            'GenericGammaPlotter': {
                'what': 'freq',
                'fname': "gamma_freq_gEE_pEE_sigma_{ns}.pdf",
                'normalize_ticks': (True, False),  # (Y, X)
                                        'pastoll_et_al',
                                        'grids_pc_weight_3'),
        'vel_data_root':  None,
        'const_pos_data_root': None,
        'singleDataRoot': None,

        'noise_sigmas': [150],
        'even_shape': None,
        'output_dir': 'panels',
    })
    env = NoiseEnvironment(user_config=new_config)
    env.register_class(noisefigs.plotters.GridSweepsPlotter,
                       config={

                           'GridSweepsPlotter': {
                               'fname_prefix': "pastoll_pc_weight_3_",
                               'vmin': -0.4286,
                               'vmax': 0.8582,
                               'ann': None,
                           },
                       })
    env.plot()


if args.grids_pastoll_pc_weight or args.all:
    new_config = deepcopy(config.get_config())
    new_config.update({
        'bump_data_root': None,
        'grids_data_root': os.path.join('simulation_data',
                                        'i_surround',
                                        'pastoll_et_al_pc_max_rate_vs_weight',
                                        'grids'),
Esempio n. 18
0
                                       'gamma_bump'),
        'vel_data_root':  None,
        'const_pos_data_root': None,
        'singleDataRoot': None,

        'noise_sigmas': [150],
        'even_shape': None,
    })
    env = NoiseEnvironment(user_config=new_config, space_cls=JobTrialSpace1D)
    env.register_class(
        noisefigs.plotters.Generic1DGammaPlotter,
        config={
            'Generic1DGammaPlotter' : {
                'what': 'acVal',
                'fname' : 'gamma_power_g_II_{ns}.pdf',
                'normalize_ticks': False,
                'ylabel': '$1^{st}$ autocorrelation peak',
                'xlim': (-10, 410),
                'ylim': (-0.04, 0.58),
            },
        }
    )
    env.register_class(
        noisefigs.plotters.Generic1DGammaPlotter,
        config={
            'Generic1DGammaPlotter' : {
                'what': 'freq',
                'fname' : 'gamma_freq_g_II_{ns}.pdf',
                'normalize_ticks': False,
                'ylabel': 'Frequency (Hz)',
                'xlim': (-10, 410),