# -*- coding: utf-8 -*-
"""

"""
import matplotlib
matplotlib.use('Agg')

from mpi4py import MPI 
#from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments_cortical_stimulation_luminance_excinh
from model import SelfSustainedPushPull
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet


mpi_comm = MPI.COMM_WORLD

data_store,model = run_workflow('CorticalStimulationModel',SelfSustainedPushPull,create_experiments_cortical_stimulation_luminance_excinh)
data_store.save() 

if mpi_comm.rank == 0:
   print "Starting visualization" 
   perform_analysis_and_visualization(data_store,gratings=False,cort_stim=True,nat_stim=False,tp=1)
# -*- coding: utf-8 -*-
"""

"""
import matplotlib
matplotlib.use('Agg')
from mpi4py import MPI 
#from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments_short,create_experiments_old,create_experiments,create_experiments_tmp
from model import SelfSustainedPushPull
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet

mpi_comm = MPI.COMM_WORLD

if True:
    data_store,model = run_workflow('CorticalStimulationModel',SelfSustainedPushPull,create_experiments)
    data_store.save() 
else: 
    setup_logging()
    data_store = PickledDataStore(load=True,parameters=ParameterSet({'root_directory':'CorticalStimulationModel_visual_stimulation_____base_weight:0.0022_inhibitory_connection_ratio:0.5_layer23_aff_ratio:0.4_stdev:2.7','store_stimuli' : False}),replace=True)

if mpi_comm.rank == 0:
   print "Starting visualization" 
   perform_analysis_and_visualization(data_store,gratings=True,cort_stim=False,nat_stim=False,tp=0)
Beispiel #3
0
"""
import matplotlib
matplotlib.use('Agg')
from mpi4py import MPI 
from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments,create_experiments_bar,create_experiments_short,create_experiments_old
from model import SelfSustainedPushPull
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet


mpi_comm = MPI.COMM_WORLD

if True:
    data_store,model = run_workflow('MorganTaylorModel',SelfSustainedPushPull,create_experiments)
    data_store.save() 
else: 
    setup_logging()
    data_store = PickledDataStore(load=True,parameters=ParameterSet({'root_directory':'MorganTaylorModel_visual_space_update=1ms_RF_resolution=1ms','store_stimuli' : False}),replace=True)

if mpi_comm.rank == 0:
   print "Starting visualization" 
   perform_analysis_and_visualization(data_store,gratings=True,bars=True)
#   data_store.save() 
Beispiel #4
0
logger = mozaik.getMozaikLogger()


# Manage what is executed
# a set of variable here to manage the type of experiment and whether the pgn, cortex are there or not.
withPGN = True  # 
withV1 = True  # 
withFeedback_CxPGN = True # closed loop
withFeedback_CxLGN = True # closed loop

# Model execution
if True:
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_luminance )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_contrast )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_spatial )
    data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_temporal )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_size )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_orientation )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_combined )

    if False: # save connections
        if withPGN: # PGN
            model.connectors['LGN_PGN_ConnectionOn'].store_connections(data_store)    
            model.connectors['LGN_PGN_ConnectionOff'].store_connections(data_store)    
            model.connectors['PGN_PGN_Connection'].store_connections(data_store)    
            model.connectors['PGN_LGN_ConnectionOn'].store_connections(data_store)    
            model.connectors['PGN_LGN_ConnectionOff'].store_connections(data_store)    
        if withV1: # CORTEX
            model.connectors['V1AffConnectionOn'].store_connections(data_store)    
            model.connectors['V1AffConnectionOff'].store_connections(data_store)    
            model.connectors['V1AffInhConnectionOn'].store_connections(data_store)    
Beispiel #5
0
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from parameters import ParameterSet

from model_V1_full import ThalamoCorticalModel

from experiments import create_experiments_size

try:
    from mpi4py import MPI
except ImportError:
    MPI = None
if MPI:
    mpi_comm = MPI.COMM_WORLD
MPI_ROOT = 0

logger = mozaik.getMozaikLogger()

# Manage what is executed
# a set of variable here to manage the type of experiment and whether the pgn, cortex are there or not.
withPGN = True  #
withV1 = True  # open-loop
withFeedback_CxPGN = True  # closed loop
withFeedback_CxLGN = True  # closed loop

withRandomV1conns = False

# Model execution
data_store, model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel,
                                 create_experiments_size)
data_store.save()
Beispiel #6
0
The Journal of neuroscience : the official journal of the Society for Neuroscience, 25(46), 10786–95. 
"""
from pyNN import nest
import sys
import mozaik
from mozaik.controller import run_workflow, setup_logging
from experiments import create_experiments
from model import KumarEtAl2007
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization

from mpi4py import MPI
mpi_comm = MPI.COMM_WORLD

if True:
    logger = mozaik.getMozaikLogger()
    data_store, model = run_workflow('KumarEtAl2007', KumarEtAl2007,
                                     create_experiments)
else:
    setup_logging()
    data_store = PickledDataStore(load=True,
                                  parameters=ParameterSet(
                                      {'root_directory': 'A'}),
                                  replace=True)
    logger.info('Loaded data store')

if mpi_comm.rank == 0:
    print "Starting visualization"
    perform_analysis_and_visualization(data_store)
    data_store.save()
Beispiel #7
0
from model import SSCorrelationConnectivity
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet

try:
    from mpi4py import MPI
except ImportError:
    MPI = None
if MPI:
    mpi_comm = MPI.COMM_WORLD
MPI_ROOT = 0

if True:
    data_store, model = run_workflow('SSCorrelationConnectivity',
                                     SSCorrelationConnectivity,
                                     create_experiments)
    data_store.save()
else:
    setup_logging()
    data_store = PickledDataStore(
        load=True,
        parameters=ParameterSet({
            'root_directory':
            '/home/jan/cluster/dev/pkg/mozaik/mozaik/contrib/SSCorrelationConn/20140313-113338[param_sd.defaults]CombinationParamSearch{7}/SSCorrelationConnectivity_ParameterSearch_____base_weight:0.00045_sigma:0.5_base_weight:0.0007_rand_struct_ratio:0.5_ExcInhAfferentRatio:1.0_base_weight:0.0007_gain:15.0',
            'store_stimuli': False
        }),
        replace=True)

if mpi_comm.rank == 0:
    print "Starting visualization"
Beispiel #8
0
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet


try:
    from mpi4py import MPI
except ImportError:
    MPI = None
if MPI:
    mpi_comm = MPI.COMM_WORLD
MPI_ROOT = 0

logger = mozaik.getMozaikLogger()

if True:
    data_store,model = run_workflow('FFI',PushPullCCModel,create_experiments)
    model.connectors['V1L4ExcL4ExcConnection'].store_connections(data_store)    
    model.connectors['V1L4ExcL4InhConnection'].store_connections(data_store)    
    model.connectors['V1L4InhL4ExcConnection'].store_connections(data_store)    
    model.connectors['V1L4InhL4InhConnection'].store_connections(data_store)    
    model.connectors['V1AffConnectionOn'].store_connections(data_store)    
    model.connectors['V1AffConnectionOff'].store_connections(data_store)    
    model.connectors['V1AffInhConnectionOn'].store_connections(data_store)    
    model.connectors['V1AffInhConnectionOff'].store_connections(data_store)    
    data_store.save()
    
else: 
    setup_logging()
    data_store = PickledDataStore(load=True,parameters=ParameterSet({'root_directory':'FFI_test_____', 'store_stimuli' : False}),replace=True)
    logger.info('Loaded data store')
    data_store.save()
Beispiel #9
0
MPI_ROOT = 0

logger = mozaik.getMozaikLogger()


# Manage what is executed
# a set of variable here to manage the type of experiment and whether the pgn, cortex are there or not.
withPGN = True  # 
withV1 = False  # open-loop
withFeedback_CxPGN = False # closed loop
withFeedback_CxLGN = False # closed loop

# Model execution
if True:
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_spontaneous )
    data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_luminance )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_contrast )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_spatial )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_temporal )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_size )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_orientation )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_combined )

    if False: # save connections
        if withPGN: # PGN
            model.connectors['LGN_PGN_ConnectionOn'].store_connections(data_store)    
            model.connectors['LGN_PGN_ConnectionOff'].store_connections(data_store)    
            model.connectors['PGN_PGN_Connection'].store_connections(data_store)    
            model.connectors['PGN_LGN_ConnectionOn'].store_connections(data_store)    
            model.connectors['PGN_LGN_ConnectionOff'].store_connections(data_store)    
        if withV1: # CORTEX
Beispiel #10
0
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet

try:
    from mpi4py import MPI
except ImportError:
    MPI = None
if MPI:
    mpi_comm = MPI.COMM_WORLD
MPI_ROOT = 0

logger = mozaik.getMozaikLogger()

if True:
    data_store, model = run_workflow('FFI', PushPullCCModel,
                                     create_experiments)
    #model.connectors['V1L4ExcL4ExcConnection'].store_connections(data_store)
    #model.connectors['V1L4ExcL4InhConnection'].store_connections(data_store)
    #model.connectors['V1L4InhL4ExcConnection'].store_connections(data_store)
    #model.connectors['V1L4InhL4InhConnection'].store_connections(data_store)
    #model.connectors['V1AffConnection'].store_connections(data_store)
    #model.connectors['V1AffInhConnection'].store_connections(data_store)

else:
    setup_logging()
    data_store = PickledDataStore(
        load=True,
        parameters=ParameterSet({
            'root_directory': 'FFI_combined-high_resolution_3000_21_____',
            'store_stimuli': False
        }),
Beispiel #11
0
Vogels, T. P., & Abbott, L. F. (2005). 
Signal propagation and logic gating in networks of integrate-and-fire neurons. 
The Journal of neuroscience : the official journal of the Society for Neuroscience, 25(46), 10786–95. 
"""
from pyNN import nest
import sys
import mozaik
from mozaik.controller import run_workflow, setup_logging
from experiments import create_experiments
from model import KumarEtAl2007
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization

from mpi4py import MPI

mpi_comm = MPI.COMM_WORLD


if True:
    logger = mozaik.getMozaikLogger()
    data_store, model = run_workflow("KumarEtAl2007", KumarEtAl2007, create_experiments)
else:
    setup_logging()
    data_store = PickledDataStore(load=True, parameters=ParameterSet({"root_directory": "A"}), replace=True)
    logger.info("Loaded data store")

if mpi_comm.rank == 0:
    print "Starting visualization"
    perform_analysis_and_visualization(data_store)
    data_store.save()
Beispiel #12
0
Journal of physiology, Paris, 101(1-3), 99–109.
"""
from pyNN import nest
import sys
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments
from model import Boustani2007
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization

from mpi4py import MPI
mpi_comm = MPI.COMM_WORLD

if True:
    logger = mozaik.getMozaikLogger()
    data_store, model = run_workflow('Boustani2007', Boustani2007,
                                     create_experiments)
else:
    setup_logging()
    data_store = PickledDataStore(load=True,
                                  parameters=ParameterSet(
                                      {'root_directory': 'A'}),
                                  replace=True)
    logger.info('Loaded data store')

if mpi_comm.rank == 0:
    print "Starting visualization"
    perform_analysis_and_visualization(data_store)
    data_store.save()
Beispiel #13
0
El Boustani, S., Pospischil, M., Rudolph-Lilith, M., & Destexhe, A. (n.d.). 
Activated cortical states: experiments, analyses and models. 
Journal of physiology, Paris, 101(1-3), 99–109.
"""
from pyNN import nest
import sys
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments
from model import Boustani2007
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization

from mpi4py import MPI 
mpi_comm = MPI.COMM_WORLD


if True:
    logger = mozaik.getMozaikLogger()
    data_store,model = run_workflow('Boustani2007',Boustani2007,create_experiments)
else: 
    setup_logging()
    data_store = PickledDataStore(load=True,parameters=ParameterSet({'root_directory':'A'}),replace=True)
    logger.info('Loaded data store')

if mpi_comm.rank == 0:
   print "Starting visualization" 
   perform_analysis_and_visualization(data_store)
   data_store.save() 
Beispiel #14
0
# -*- coding: utf-8 -*-
"""
This is implementation of model of self-sustained activitity in balanced networks from: 
Vogels, T. P., & Abbott, L. F. (2005). 
Signal propagation and logic gating in networks of integrate-and-fire neurons. 
The Journal of neuroscience : the official journal of the Society for Neuroscience, 25(46), 10786–95. 
"""
from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments_octc
from model import SelfSustainedPushPull
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization_octc
from parameters import ParameterSet

from mpi4py import MPI 
mpi_comm = MPI.COMM_WORLD


if True:
    data_store,model = run_workflow('SelfSustainedPushPull',SelfSustainedPushPull,create_experiments_octc)
    data_store.save() 

if mpi_comm.rank == 0:
   print "Starting visualization" 
   perform_analysis_and_visualization_octc(data_store)
   data_store.save() 
Beispiel #15
0
import sys
from pyNN import nest
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments
from model import SSCorrelationConnectivity
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet

try:
    from mpi4py import MPI
except ImportError:
    MPI = None
if MPI:
    mpi_comm = MPI.COMM_WORLD
MPI_ROOT = 0

if True:
    data_store,model = run_workflow('SSCorrelationConnectivity',SSCorrelationConnectivity,create_experiments)
    data_store.save() 
else: 
    setup_logging()
    data_store = PickledDataStore(load=True,parameters=ParameterSet({'root_directory':'/home/jan/cluster/dev/pkg/mozaik/mozaik/contrib/SSCorrelationConn/20140313-113338[param_sd.defaults]CombinationParamSearch{7}/SSCorrelationConnectivity_ParameterSearch_____base_weight:0.00045_sigma:0.5_base_weight:0.0007_rand_struct_ratio:0.5_ExcInhAfferentRatio:1.0_base_weight:0.0007_gain:15.0', 'store_stimuli' : False}),replace=True)

if mpi_comm.rank == 0:
   print "Starting visualization" 
   perform_analysis_and_visualization(data_store)
#   data_store.save() 
Beispiel #16
0
    MPI_ROOT = 0

    from model import PushPullCCModel
    from experiments import create_experiments

from parameters import ParameterSet
import mozaik
from mozaik.controller import run_workflow, setup_logging
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
print mozaik.__file__
print sys.path

logger = mozaik.getMozaikLogger()

if True:
    data_store, model = run_workflow('FeedForwardInhibition', PushPullCCModel,
                                     create_experiments)
    #model.connectors['V1L4ExcL4ExcConnection'].store_connections(data_store)
    #model.connectors['V1L4ExcL4InhConnection'].store_connections(data_store)
    #model.connectors['V1L4InhL4ExcConnection'].store_connections(data_store)
    #model.connectors['V1L4InhL4InhConnection'].store_connections(data_store)
    #model.connectors['V1AffConnectionOn'].store_connections(data_store)
    #model.connectors['V1AffConnectionOff'].store_connections(data_store)
    #model.connectors['V1AffInhConnectionOn'].store_connections(data_store)
    #model.connectors['V1AffInhConnectionOff'].store_connections(data_store)
    data_store.save()
    if mpi_comm.rank == MPI_ROOT:
        from analysis_and_visualization import perform_analysis_and_visualization
        perform_analysis_and_visualization(data_store)

else:
    setup_logging()
Beispiel #17
0
# Manage what is executed
# a set of variable here to manage the type of experiment and whether the pgn, cortex are there or not.
withPGN = True  #
withV1 = True  # open-loop
withFeedback_CxPGN = False  # closed loop
withFeedback_CxLGN = False  # closed loop

# Model execution
if False:
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_spontaneous )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_luminance )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_contrast )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_spatial )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_temporal )
    data_store, model = run_workflow("ThalamoCorticalModel", ThalamoCorticalModel, create_experiments_size)
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_orientation )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_combined )

    if False:  # save connections
        if withPGN:  # PGN
            model.connectors["LGN_PGN_ConnectionOn"].store_connections(data_store)
            model.connectors["LGN_PGN_ConnectionOff"].store_connections(data_store)
            model.connectors["PGN_PGN_Connection"].store_connections(data_store)
            model.connectors["PGN_LGN_ConnectionOn"].store_connections(data_store)
            model.connectors["PGN_LGN_ConnectionOff"].store_connections(data_store)
        # if withV1: # CORTEX
        #     # model.connectors['V1AffConnectionOn'].store_connections(data_store)
        #     # model.connectors['V1AffConnectionOff'].store_connections(data_store)
        #     # model.connectors['V1AffInhConnectionOn'].store_connections(data_store)
        #     # model.connectors['V1AffInhConnectionOff'].store_connections(data_store)
# -*- coding: utf-8 -*-
"""

"""
import matplotlib
matplotlib.use('Agg')

from mpi4py import MPI 
#from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments_cortical_stimulation_or_exc_LumBased
from model import SelfSustainedPushPull
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet


mpi_comm = MPI.COMM_WORLD

data_store,model = run_workflow('CorticalStimulationModel',SelfSustainedPushPull,create_experiments_cortical_stimulation_or_exc_LumBased)
data_store.save() 

if mpi_comm.rank == 0:
   print "Starting visualization" 
   perform_analysis_and_visualization(data_store,gratings=False,cort_stim=True,nat_stim=False,tp=1)
Beispiel #19
0
# -*- coding: utf-8 -*-
"""

"""
#from mpi4py import MPI 
from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments_cs,create_experiments_bar
from model import SelfSustainedPushPull
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization_bar,perform_analysis_and_visualization_contrast_sensitivity,perform_analysis_and_visualization_small
from parameters import ParameterSet


#mpi_comm = MPI.COMM_WORLD

if True:
    data_store,model = run_workflow('TestLGN',SelfSustainedPushPull,create_experiments_bar)
    data_store.save() 
else: 
    data_store = PickledDataStore(load=True,parameters=ParameterSet({'root_directory':'TestLGN_rup=28;rfr=7_____','store_stimuli' : False}),replace=True)

#if mpi_comm.rank == 0:
#   print "Starting visualization" 
perform_analysis_and_visualization_small(data_store)

"""
import matplotlib
matplotlib.use('Agg')

from mpi4py import MPI
#from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments_cortical_stimulation_or_exc_LumBased
from model import SelfSustainedPushPull
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet

mpi_comm = MPI.COMM_WORLD

data_store, model = run_workflow(
    'CorticalStimulationModel', SelfSustainedPushPull,
    create_experiments_cortical_stimulation_or_exc_LumBased)
data_store.save()

if mpi_comm.rank == 0:
    print "Starting visualization"
    perform_analysis_and_visualization(data_store,
                                       gratings=False,
                                       cort_stim=True,
                                       nat_stim=False,
                                       tp=1)
Beispiel #21
0
    mpi_comm = MPI.COMM_WORLD
MPI_ROOT = 0

logger = mozaik.getMozaikLogger()

# Manage what is executed
# a set of variable here to manage the type of experiment and whether the pgn, cortex are there or not.
withPGN = True  #
withV1 = True  # open-loop
withFeedback_CxPGN = True  # closed loop
withFeedback_CxLGN = True  # closed loop

# Model execution
if True:
    data_store, model = run_workflow(
        'ThalamoCorticalModel', ThalamoCorticalModel,
        create_experiments_size_V1_inactivated_nonoverlapping)
    data_store.save()

# or only load pickled data
else:
    setup_logging()
    # data_store = PickledDataStore(load=True,parameters=ParameterSet({'root_directory':'Deliverable/ThalamoCorticalModel_data_size_nonoverlapping_____', 'store_stimuli' : False}),replace=True)
    data_store = PickledDataStore(
        load=True,
        parameters=ParameterSet({
            'root_directory':
            'ThalamoCorticalModel_data_size_nonoverlapping_____',
            'store_stimuli': False
        }),
        replace=True)
Beispiel #22
0
from mpi4py import MPI
from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments_cs, create_experiments_bar
from model import SelfSustainedPushPull
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization_bar, perform_analysis_and_visualization_contrast_sensitivity, perform_analysis_and_visualization_small
from parameters import ParameterSet

#mpi_comm = MPI.COMM_WORLD

if True:
    data_store, model = run_workflow('TestLGN', SelfSustainedPushPull,
                                     create_experiments_cs)
    data_store.save()
else:
    data_store = PickledDataStore(load=True,
                                  parameters=ParameterSet({
                                      'root_directory':
                                      'TestLGN_test_____',
                                      'store_stimuli':
                                      False
                                  }),
                                  replace=True)

#if mpi_comm.rank == 0:
#   print "Starting visualization"
perform_analysis_and_visualization_contrast_sensitivity(data_store)
Beispiel #23
0
from parameters import ParameterSet

try:
    from mpi4py import MPI
except ImportError:
    MPI = None
if MPI:
    mpi_comm = MPI.COMM_WORLD
MPI_ROOT = 0

logger = mozaik.getMozaikLogger()

print sys.argv

if False:
    data_store, model = run_workflow('T05', T05_Model, create_experiments)
    model.connectors['LGN_PGN_ConnectionOn'].store_connections(data_store)
    model.connectors['LGN_PGN_ConnectionOff'].store_connections(data_store)
    model.connectors['PGN_PGN_Connection'].store_connections(data_store)
    model.connectors['PGN_LGN_ConnectionOn'].store_connections(data_store)
    model.connectors['PGN_LGN_ConnectionOff'].store_connections(data_store)

else:
    setup_logging()
    data_store = PickledDataStore(load=True,
                                  parameters=ParameterSet({
                                      'store_stimuli':
                                      False,
                                      'root_directory':
                                      'T05_data_____'
                                  }),
Beispiel #24
0
logger = mozaik.getMozaikLogger()


# Manage what is executed
# a set of variable here to manage the type of experiment and whether the pgn, cortex are there or not.
withPGN = True  # 
withV1 = False  # open-loop
withFeedback_CxPGN = False # closed loop
withFeedback_CxLGN = False # closed loop

# Model execution
if True:
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_spontaneous )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_luminance )
    data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_contrast )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_spatial )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_temporal )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_size )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_orientation )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_combined )

    if False: # save connections
        if withPGN: # PGN
            model.connectors['LGN_PGN_ConnectionOn'].store_connections(data_store)    
            model.connectors['LGN_PGN_ConnectionOff'].store_connections(data_store)    
            model.connectors['PGN_PGN_Connection'].store_connections(data_store)    
            model.connectors['PGN_LGN_ConnectionOn'].store_connections(data_store)    
            model.connectors['PGN_LGN_ConnectionOff'].store_connections(data_store)    
        if withV1: # CORTEX
            model.connectors['V1AffConnectionOn'].store_connections(data_store)    
Beispiel #25
0
from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments
from model import VogelsAbbottPushPullFixedK
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization

from mpi4py import MPI
mpi_comm = MPI.COMM_WORLD

if True:
    logger = mozaik.getMozaikLogger()
    data_store, model = run_workflow('VogeslAbbott2005PushPullFixedK',
                                     VogelsAbbottPushPullFixedK,
                                     create_experiments)
else:
    setup_logging()
    data_store = PickledDataStore(load=True,
                                  parameters=ParameterSet(
                                      {'root_directory': 'A'}),
                                  replace=True)
    logger.info('Loaded data store')

if mpi_comm.rank == 0:
    print "Starting visualization"
    perform_analysis_and_visualization(data_store)
    data_store.save()
# Manage what is executed
# a set of variable here to manage the type of experiment and whether the pgn, cortex are there or not.
withPGN = True  # 
withV1 = True  # open-loop
withFeedback_CxPGN = True # closed loop
withFeedback_CxLGN = True # closed loop

# Model execution
if True:
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_spontaneous )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_luminance )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_contrast )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_spatial )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_temporal )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_size )
    data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_size_V1_inactivated_overlapping )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_orientation )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_combined )

    # if False: # save connections
    #     if withPGN: # PGN
    #         model.connectors['LGN_PGN_ConnectionOn'].store_connections(data_store)    
    #         model.connectors['LGN_PGN_ConnectionOff'].store_connections(data_store)    
    #         model.connectors['PGN_PGN_Connection'].store_connections(data_store)    
    #         model.connectors['PGN_LGN_ConnectionOn'].store_connections(data_store)    
    #         model.connectors['PGN_LGN_ConnectionOff'].store_connections(data_store)    
        # if withV1: # CORTEX
        #     # model.connectors['V1AffConnectionOn'].store_connections(data_store)    
        #     # model.connectors['V1AffConnectionOff'].store_connections(data_store)    
        #     # model.connectors['V1AffInhConnectionOn'].store_connections(data_store)    
        #     # model.connectors['V1AffInhConnectionOff'].store_connections(data_store)    
Beispiel #27
0
Signal propagation and logic gating in networks of integrate-and-fire neurons. 
The Journal of neuroscience : the official journal of the Society for Neuroscience, 25(46), 10786–95. 
"""
from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments
from model import VogelsAbbottPushPull
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization

from mpi4py import MPI

mpi_comm = MPI.COMM_WORLD


if True:
    logger = mozaik.getMozaikLogger()
    data_store, model = run_workflow("VogeslAbbott2005PushPull", VogelsAbbottPushPull, create_experiments)
else:
    setup_logging()
    data_store = PickledDataStore(load=True, parameters=ParameterSet({"root_directory": "A"}), replace=True)
    logger.info("Loaded data store")

if mpi_comm.rank == 0:
    print "Starting visualization"
    perform_analysis_and_visualization(data_store)
    data_store.save()
Beispiel #28
0
# -*- coding: utf-8 -*-
"""

"""
import matplotlib
matplotlib.use('Agg')
from mpi4py import MPI 
#from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments_short,create_experiments_old,create_experiments,create_experiments_tmp
from model import SelfSustainedPushPull
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet

mpi_comm = MPI.COMM_WORLD

if True:
    data_store,model = run_workflow('CorticalStimulationModel',SelfSustainedPushPull,create_experiments_tmp)
    data_store.save() 
else: 
    setup_logging()
    data_store = PickledDataStore(load=True,parameters=ParameterSet({'root_directory':'CorticalStimulationModel_visual_stimulation_____base_weight:0.0022_inhibitory_connection_ratio:0.5_layer23_aff_ratio:0.4_stdev:2.7','store_stimuli' : False}),replace=True)

if mpi_comm.rank == 0:
   print "Starting visualization" 
   perform_analysis_and_visualization(data_store,gratings=True,cort_stim=False,nat_stim=False,tp=0)
Beispiel #29
0
import sys
import mozaik
from mozaik.controller import run_workflow, setup_logging
from experiments import create_experiments
from model import VogelsAbbott
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization

from mpi4py import MPI

mpi_comm = MPI.COMM_WORLD


if True:
    logger = mozaik.getMozaikLogger()
    data_store, model = run_workflow("VogeslAbbott2005", VogelsAbbott, create_experiments)
    print model.connectors
    model.connectors["V1L4ExcL4ExcConnection"].store_connections(data_store)
    model.connectors["V1L4ExcL4InhConnection"].store_connections(data_store)
    model.connectors["V1L4InhL4ExcConnection"].store_connections(data_store)
    model.connectors["V1L4InhL4InhConnection"].store_connections(data_store)

else:
    setup_logging()
    data_store = PickledDataStore(load=True, parameters=ParameterSet({"root_directory": "A"}), replace=True)
    logger.info("Loaded data store")

if mpi_comm.rank == 0:
    print "Starting visualization"
    perform_analysis_and_visualization(data_store)
    data_store.save()
Beispiel #30
0
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet


try:
    from mpi4py import MPI
except ImportError:
    MPI = None
if MPI:
    mpi_comm = MPI.COMM_WORLD
MPI_ROOT = 0

logger = mozaik.getMozaikLogger()

print sys.argv

if True:
    data_store,model = run_workflow( 'T0', T0_Model, create_experiments )
else: 
    setup_logging()
    data_store = PickledDataStore(
        load=True,
        parameters=ParameterSet({ 'store_stimuli':False, 'root_directory':'T0_data_____' })
        ,replace=True
    )
    logger.info('Loaded data store')


if mpi_comm.rank == MPI_ROOT:
    perform_analysis_and_visualization(data_store)
Beispiel #31
0
from parameters import ParameterSet
import mozaik
from mozaik.controller import run_workflow, setup_logging
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
print mozaik.__file__
print sys.path





logger = mozaik.getMozaikLogger()

if True:
    data_store,model = run_workflow('FeedForwardInhibition',PushPullCCModel,create_experiments)
    #model.connectors['V1L4ExcL4ExcConnection'].store_connections(data_store)    
    #model.connectors['V1L4ExcL4InhConnection'].store_connections(data_store)    
    #model.connectors['V1L4InhL4ExcConnection'].store_connections(data_store)    
    #model.connectors['V1L4InhL4InhConnection'].store_connections(data_store)    
    #model.connectors['V1AffConnectionOn'].store_connections(data_store)    
    #model.connectors['V1AffConnectionOff'].store_connections(data_store)    
    #model.connectors['V1AffInhConnectionOn'].store_connections(data_store)    
    #model.connectors['V1AffInhConnectionOff'].store_connections(data_store)    
    data_store.save()
    if mpi_comm.rank == MPI_ROOT:
	from analysis_and_visualization import perform_analysis_and_visualization
        perform_analysis_and_visualization(data_store)
    
else: 
    setup_logging()
Beispiel #32
0
from analysis_and_visualization import perform_analysis_and_visualization
from model import SelfSustainedPushPull
from experiments import create_experiments_RF_estimation
import mozaik
from mozaik.controller import run_workflow, setup_logging
import mozaik.controller
import sys
from pyNN import nest
import matplotlib
matplotlib.use('Agg')

mpi_comm = MPI.COMM_WORLD

if True:
    data_store, model = run_workflow('SelfSustainedPushPull',
                                     SelfSustainedPushPull,
                                     create_experiments_RF_estimation)
    if False:
        model.connectors['V1AffConnectionOn'].store_connections(data_store)
        model.connectors['V1AffConnectionOff'].store_connections(data_store)
        model.connectors['V1AffInhConnectionOn'].store_connections(data_store)
        model.connectors['V1AffInhConnectionOff'].store_connections(data_store)
        model.connectors['V1L4ExcL4ExcConnection'].store_connections(
            data_store)
        model.connectors['V1L4ExcL4InhConnection'].store_connections(
            data_store)
        model.connectors['V1L4InhL4ExcConnection'].store_connections(
            data_store)
        model.connectors['V1L4InhL4InhConnection'].store_connections(
            data_store)
        model.connectors['V1L4ExcL4ExcConnectionRand'].store_connections(
Beispiel #33
0
# -*- coding: utf-8 -*-

import matplotlib

matplotlib.use("Agg")
from model import SelfSustainedPushPull
from experiments import create_experiments
import mozaik
from mozaik.controller import run_workflow

data_store, model = run_workflow("LSV1M", SelfSustainedPushPull,
                                 create_experiments)
data_store.save()
Beispiel #34
0
# -*- coding: utf-8 -*-
"""

"""
import matplotlib
matplotlib.use('Agg')
from mpi4py import MPI 
from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments,create_experiments_bar,create_experiments_short,create_experiments_old,create_experiments_old_short
from model import SelfSustainedPushPull
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet


mpi_comm = MPI.COMM_WORLD

data_store,model = run_workflow('MorganTaylorModel',SelfSustainedPushPull,create_experiments_old)
data_store.save() 

if mpi_comm.rank == 0:
   print "Starting visualization" 
   perform_analysis_and_visualization(data_store,gratings=True,bars=False,nat_movies=True)

Beispiel #35
0
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet

try:
    from mpi4py import MPI
except ImportError:
    MPI = None
if MPI:
    mpi_comm = MPI.COMM_WORLD
MPI_ROOT = 0

logger = mozaik.getMozaikLogger()

if True:
    data_store, model = run_workflow('TestStimuliModel', TestStimuliModel,
                                     create_experiments)
    data_store.save()

else:
    setup_logging()
    data_store = PickledDataStore(load=True,
                                  parameters=ParameterSet({
                                      'root_directory':
                                      'TestStimuliModel_test_____',
                                      'store_stimuli':
                                      False
                                  }),
                                  replace=True)
    logger.info('Loaded data store')
    data_store.save()
Beispiel #36
0
logger = mozaik.getMozaikLogger()


# Manage what is executed
# a set of variable here to manage the type of experiment and whether the pgn, cortex are there or not.
withPGN = True  # 
# withV1 = False  # open-loop
# withFeedback_CxPGN = False # closed loop
# withFeedback_CxLGN = False # closed loop
withV1 = True  # open-loop
withFeedback_CxPGN = True # closed loop
withFeedback_CxLGN = True # closed loop

# Model execution
if False:
    data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_spontaneous )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_luminance )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_contrast )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_spatial )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_temporal )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_size )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_orientation )
    # data_store,model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel, create_experiments_combined )

    if True: # save connections
        # if withPGN: # PGN
        #     model.connectors['LGN_PGN_ConnectionOn'].store_connections(data_store)    
        #     model.connectors['LGN_PGN_ConnectionOff'].store_connections(data_store)    
        #     model.connectors['PGN_PGN_Connection'].store_connections(data_store)    
        #     model.connectors['PGN_LGN_ConnectionOn'].store_connections(data_store)    
        #     model.connectors['PGN_LGN_ConnectionOff'].store_connections(data_store)    
Beispiel #37
0
Vogels, T. P., & Abbott, L. F. (2005). 
Signal propagation and logic gating in networks of integrate-and-fire neurons. 
The Journal of neuroscience : the official journal of the Society for Neuroscience, 25(46), 10786–95. 
"""
from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments
from model import VogelsAbbottPushPullFixedK
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization

from mpi4py import MPI 
mpi_comm = MPI.COMM_WORLD


if True:
    logger = mozaik.getMozaikLogger()
    data_store,model = run_workflow('VogeslAbbott2005PushPullFixedK',VogelsAbbottPushPullFixedK,create_experiments)
else: 
    setup_logging()
    data_store = PickledDataStore(load=True,parameters=ParameterSet({'root_directory':'A'}),replace=True)
    logger.info('Loaded data store')

if mpi_comm.rank == 0:
   print "Starting visualization" 
   perform_analysis_and_visualization(data_store)
   data_store.save() 
Beispiel #38
0
The Journal of neuroscience : the official journal of the Society for Neuroscience, 25(46), 10786–95. 
"""
from pyNN import nest
import sys
import mozaik
from mozaik.controller import run_workflow, setup_logging
from experiments import create_experiments
from model import VogelsAbbott
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization

from mpi4py import MPI
mpi_comm = MPI.COMM_WORLD

if True:
    logger = mozaik.getMozaikLogger()
    data_store, model = run_workflow('VogeslAbbott2005', VogelsAbbott,
                                     create_experiments)
else:
    setup_logging()
    data_store = PickledDataStore(load=True,
                                  parameters=ParameterSet(
                                      {'root_directory': 'A'}),
                                  replace=True)
    logger.info('Loaded data store')

if mpi_comm.rank == 0:
    print "Starting visualization"
    perform_analysis_and_visualization(data_store)
    data_store.save()
Beispiel #39
0
mpirun python run.py simulator_name number_processors parameters name_of_test

For example:
mpirun python run.py nest 2 param/defaults 'test'
"""
from mpi4py import MPI 
from pyNN import nest
import sys
import mozaik
from mozaik.controller import run_workflow, setup_logging
from experiments import create_experiments
from model import VogelsAbbott
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet

mpi_comm = MPI.COMM_WORLD
logger = mozaik.getMozaikLogger()

if True:
    data_store,model = run_workflow('VogelsAbbott2005',VogelsAbbott,create_experiments)
else: 
    setup_logging()
    data_store = PickledDataStore(load=True,parameters=ParameterSet({'root_directory':'VogelsAbbott2005_test_____', 'store_stimuli' : False}),replace=True)
    logger.info('Loaded data store')

if mpi_comm.rank == 0:
   print "Starting visualization" 
   perform_analysis_and_visualization(data_store)
   data_store.save() 
Beispiel #40
0
from mozaik.cli import parse_workflow_args
from mozaik.controller import run_workflow, setup_logging
from mozaik.tools.misc import result_directory_name
from experiments import create_experiments
from model import VogelsAbbott
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization
from parameters import ParameterSet

#mpi_comm = MPI.COMM_WORLD
logger = mozaik.getMozaikLogger()
simulation_name = "VogelsAbbott2005"
simulation_run_name, _, _, _, modified_parameters = parse_workflow_args()

if True:
    data_store,model = run_workflow(simulation_name,VogelsAbbott,create_experiments)
    model.connectors['ExcExcConnection'].store_connections(data_store)    
else: 
    setup_logging()
    data_store = PickledDataStore(
        load=True,
        parameters=ParameterSet(
            {
                "root_directory": result_directory_name(
                    simulation_run_name, simulation_name, modified_parameters
                ),
                "store_stimuli": False,
            }
        ),
        replace=True,
    )
Beispiel #41
0
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from parameters import ParameterSet

from model_feedforward import ThalamoCorticalModel

from experiments import create_interrupted_bar

try:
    from mpi4py import MPI
except ImportError:
    MPI = None
if MPI:
    mpi_comm = MPI.COMM_WORLD
MPI_ROOT = 0

logger = mozaik.getMozaikLogger()

# Manage what is executed
# a set of variable here to manage the type of experiment and whether the pgn, cortex are there or not.
withPGN = True  #
withV1 = True  # open-loop
withFeedback_CxPGN = False  # ffw loop
withFeedback_CxLGN = False  # ffw loop

withRandomV1conns = False

# Model execution
data_store, model = run_workflow('ThalamoCorticalModel', ThalamoCorticalModel,
                                 create_interrupted_bar)
data_store.save()
Beispiel #42
0
# -*- coding: utf-8 -*-
"""
This is implementation of model of self-sustained activitity in balanced networks from: 
Vogels, T. P., & Abbott, L. F. (2005). 
Signal propagation and logic gating in networks of integrate-and-fire neurons. 
The Journal of neuroscience : the official journal of the Society for Neuroscience, 25(46), 10786–95. 
"""
from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments_spont
from model import SelfSustainedPushPull
from mozaik.storage.datastore import Hdf5DataStore, PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization_spont
from parameters import ParameterSet

from mpi4py import MPI
mpi_comm = MPI.COMM_WORLD

data_store, model = run_workflow('SelfSustainedPushPull',
                                 SelfSustainedPushPull,
                                 create_experiments_spont)
data_store.save()

perform_analysis_and_visualization_spont(data_store)
Beispiel #43
0
Vogels, T. P., & Abbott, L. F. (2005). 
Signal propagation and logic gating in networks of integrate-and-fire neurons. 
The Journal of neuroscience : the official journal of the Society for Neuroscience, 25(46), 10786–95. 
"""
from pyNN import nest
import sys
import mozaik.controller
from mozaik.controller import run_workflow, setup_logging
import mozaik
from experiments import create_experiments
from model import VogelsAbbottPushPullFixedKBackgroundCurrent
from mozaik.storage.datastore import Hdf5DataStore,PickledDataStore
from analysis_and_visualization import perform_analysis_and_visualization

from mpi4py import MPI 
mpi_comm = MPI.COMM_WORLD


if True:
    logger = mozaik.getMozaikLogger()
    data_store,model = run_workflow('VogeslAbbott2005PushPullFixedKBackgroundCurrent',VogelsAbbottPushPullFixedKBackgroundCurrent,create_experiments)
else: 
    setup_logging()
    data_store = PickledDataStore(load=True,parameters=ParameterSet({'root_directory':'A'}),replace=True)
    logger.info('Loaded data store')

if mpi_comm.rank == 0:
   print "Starting visualization" 
   perform_analysis_and_visualization(data_store)
   data_store.save()