def test_server_fire_simulation(self, mocker, connectivity_factory): input_folder = self.files_helper.get_project_folder(self.test_project) sim_dir = os.path.join(input_folder, 'test_sim') if not os.path.isdir(sim_dir): os.makedirs(sim_dir) simulator = Simulator() simulator.connectivity = connectivity_factory() sim_serializer = SimulatorSerializer() sim_serializer.serialize_simulator(simulator, simulator.gid.hex, None, sim_dir) zip_filename = shutil.make_archive(sim_dir, 'zip', input_folder) # Mock flask.request.files to return a dictionary request_mock = mocker.patch.object(flask, 'request') fp = open(zip_filename, 'rb') request_mock.files = { 'file': FileStorage(fp, os.path.basename(zip_filename)) } def launch_sim(self, user_id, project, algorithm, zip_folder_path, simulator_file): return Operation('', '', '', {}) # Mock simulation launch mocker.patch.object(SimulatorService, 'prepare_simulation_on_server', launch_sim) operation_gid, status = self.simulation_resource.post( self.test_project.gid) fp.close() assert type(operation_gid) is str assert status == 201
def _prepare_simulator_from_view_model(self, view_model): simulator = Simulator() simulator.gid = view_model.gid conn = self.load_traited_by_gid(view_model.connectivity) simulator.connectivity = conn simulator.conduction_speed = view_model.conduction_speed simulator.coupling = view_model.coupling rm_surface = None if view_model.surface: simulator.surface = Cortex() rm_index = self.load_entity_by_gid( view_model.surface.region_mapping_data.hex) rm = h5.load_from_index(rm_index) rm_surface_index = self.load_entity_by_gid(rm_index.fk_surface_gid) rm_surface = h5.load_from_index(rm_surface_index, CorticalSurface) rm.surface = rm_surface rm.connectivity = conn simulator.surface.region_mapping_data = rm if simulator.surface.local_connectivity: lc = self.load_traited_by_gid( view_model.surface.local_connectivity) assert lc.surface.gid == rm_index.fk_surface_gid lc.surface = rm_surface simulator.surface.local_connectivity = lc if view_model.stimulus: stimulus_index = self.load_entity_by_gid(view_model.stimulus.hex) stimulus = h5.load_from_index(stimulus_index) simulator.stimulus = stimulus if isinstance(stimulus, StimuliSurface): simulator.stimulus.surface = rm_surface else: simulator.stimulus.connectivity = simulator.connectivity simulator.model = view_model.model simulator.integrator = view_model.integrator simulator.initial_conditions = view_model.initial_conditions simulator.monitors = view_model.monitors simulator.simulation_length = view_model.simulation_length # TODO: why not load history here? # if view_model.history: # history_index = dao.get_datatype_by_gid(view_model.history.hex) # history = h5.load_from_index(history_index) # assert isinstance(history, SimulationHistory) # history.fill_into(self.algorithm) return simulator
def deserialize_simulator(simulator_gid, storage_path): simulator_in_path = h5.path_for(storage_path, SimulatorH5, simulator_gid) simulator_in = Simulator() with SimulatorH5(simulator_in_path) as simulator_in_h5: simulator_in_h5.load_into(simulator_in) connectivity_gid = simulator_in_h5.connectivity.load() stimulus_gid = simulator_in_h5.stimulus.load() simulation_state_gid = simulator_in_h5.simulation_state.load() conn_index = dao.get_datatype_by_gid(connectivity_gid.hex) conn = h5.load_from_index(conn_index) simulator_in.connectivity = conn if simulator_in.surface: cortex_path = h5.path_for(storage_path, CortexH5, simulator_in.surface.gid) with CortexH5(cortex_path) as cortex_h5: local_conn_gid = cortex_h5.local_connectivity.load() region_mapping_gid = cortex_h5.region_mapping_data.load() region_mapping_index = dao.get_datatype_by_gid( region_mapping_gid.hex) region_mapping_path = h5.path_for_stored_index( region_mapping_index) region_mapping = RegionMapping() with RegionMappingH5(region_mapping_path) as region_mapping_h5: region_mapping_h5.load_into(region_mapping) region_mapping.gid = region_mapping_h5.gid.load() surf_gid = region_mapping_h5.surface.load() surf_index = dao.get_datatype_by_gid(surf_gid.hex) surf_h5 = h5.h5_file_for_index(surf_index) surf = CorticalSurface() surf_h5.load_into(surf) surf_h5.close() region_mapping.surface = surf simulator_in.surface.region_mapping_data = region_mapping if local_conn_gid: local_conn_index = dao.get_datatype_by_gid(local_conn_gid.hex) local_conn = h5.load_from_index(local_conn_index) simulator_in.surface.local_connectivity = local_conn if stimulus_gid: stimulus_index = dao.get_datatype_by_gid(stimulus_gid.hex) stimulus = h5.load_from_index(stimulus_index) simulator_in.stimulus = stimulus return simulator_in, simulation_state_gid
def test(dt=0.1, noise_strength=0.001, config=CONFIGURED): # Select the regions for the fine scale modeling with NEST spiking networks nest_nodes_ids = [] # the indices of fine scale regions modeled with NEST # In this example, we model parahippocampal cortices (left and right) with NEST connectivity = Connectivity.from_file(CONFIGURED.DEFAULT_CONNECTIVITY_ZIP) for id in range(connectivity.region_labels.shape[0]): if connectivity.region_labels[id].find("hippo") > 0: nest_nodes_ids.append(id) connectivity.configure() # Create a TVB simulator and set all desired inputs # (connectivity, model, surface, stimuli etc) # We choose all defaults in this example simulator = Simulator() simulator.integrator.dt = dt simulator.integrator.noise.nsig = np.array([noise_strength]) simulator.model = ReducedWongWangExcIOInhI() simulator.connectivity = connectivity mon_raw = Raw(period=simulator.integrator.dt) simulator.monitors = (mon_raw, ) # Build a NEST network model with the corresponding builder # Using all default parameters for this example nest_model_builder = RedWWExcIOInhIMultisynapseBuilder(simulator, nest_nodes_ids, config=config) nest_model_builder.configure() for prop in [ "min_delay", "tvb_dt", "tvb_model", "tvb_connectivity", "tvb_weights", "tvb_delays", "number_of_nodes", "number_of_spiking_nodes", "spiking_nodes_labels", "number_of_populations", "populations_models", "populations_nodes", "populations_scales", "populations_sizes", "populations_params", "populations_connections_labels", "populations_connections_models", "populations_connections_nodes", "populations_connections_weights", "populations_connections_delays", "populations_connections_receptor_types", "populations_connections_conn_spec", "nodes_connections_labels", "nodes_connections_models", "nodes_connections_source_nodes", "nodes_connections_target_nodes", "nodes_connections_weights", "nodes_connections_delays", "nodes_connections_receptor_types", "nodes_connections_conn_spec" ]: print("%s:\n%s\n\n" % (prop, str(getattr(nest_model_builder, prop))))
def build(self, **model_params): # Load, normalize and configure connectivity if isinstance(self.connectivity, string_types): connectivity = Connectivity.from_file(self.connectivity) else: connectivity = self.connectivity if self.scale_connectivity_weights is not None: if isinstance(self.scale_connectivity_weights, string_types): connectivity.weights = connectivity.scaled_weights( mode=self.scale_connectivity_weights) else: connectivity.weights /= self.scale_connectivity_weights if not self.delays_flag: connectivity.configure() # to set speed # Given that # idelays = numpy.rint(delays / dt).astype(numpy.int32) # and delays = tract_lengths / speed connectivity.tract_lengths = 0.1 * self.dt * connectivity.speed connectivity.configure() # Build model: model = self.model(**model_params) # Build integrator integrator = self.integrator(dt=self.dt) integrator.noise.nsig = np.array(ensure_list(self.noise_strength)) # Build monitors: assert Raw in self.monitors monitors = [] for monitor in self.monitors: monitors.append(monitor(period=self.dt)) monitors = tuple(monitors) # Build simulator simulator = Simulator() simulator._config = self.config simulator.connectivity = connectivity simulator.model = model simulator.integrator = integrator simulator.monitors = monitors return simulator
def test(dt=0.1, noise_strength=0.001, config=CONFIGURED): # Select the regions for the fine scale modeling with ANNarchy spiking networks anarchy_nodes_ids = list( range(10)) # the indices of fine scale regions modeled with ANNarchy # In this example, we model parahippocampal cortices (left and right) with ANNarchy connectivity = Connectivity.from_file(CONFIGURED.DEFAULT_CONNECTIVITY_ZIP) connectivity.configure() # Create a TVB simulator and set all desired inputs # (connectivity, model, surface, stimuli etc) # We choose all defaults in this example simulator = Simulator() simulator.integrator.dt = dt # simulator.integrator.noise.nsig = np.array([noise_strength]) simulator.model = ReducedWongWangExcIOInhI() simulator.connectivity = connectivity mon_raw = Raw(period=simulator.integrator.dt) simulator.monitors = (mon_raw, ) # Build a ANNarchy network model with the corresponding builder # Using all default parameters for this example anarchy_model_builder = BasalGangliaIzhikevichBuilder(simulator, anarchy_nodes_ids, config=config) anarchy_model_builder.configure() for prop in [ "min_delay", "tvb_dt", "tvb_model", "tvb_connectivity", "tvb_weights", "tvb_delays", "number_of_nodes", "number_of_spiking_nodes", "spiking_nodes_labels", "number_of_populations", "populations_models", "populations_nodes", "populations_scales", "populations_sizes", "populations_params", "populations_connections_labels", "populations_connections_models", "populations_connections_nodes", "populations_connections_weights", "populations_connections_delays", "populations_connections_receptor_types", "populations_connections_conn_spec", "nodes_connections_labels", "nodes_connections_models", "nodes_connections_source_nodes", "nodes_connections_target_nodes", "nodes_connections_weights", "nodes_connections_delays", "nodes_connections_receptor_types", "nodes_connections_conn_spec" ]: print("%s:\n%s\n\n" % (prop, str(getattr(anarchy_model_builder, prop))))
def main_example(tvb_sim_model, connectivity_zip=CONFIGURED.DEFAULT_CONNECTIVITY_ZIP, dt=0.1, noise_strength=0.001, simulation_length=100.0, config=CONFIGURED): plotter = Plotter(config) # --------------------------------------1. Load TVB connectivity---------------------------------------------------- connectivity = Connectivity.from_file(connectivity_zip) connectivity.configure() plotter.plot_tvb_connectivity(connectivity) # ----------------------2. Define a TVB simulator (model, integrator, monitors...)---------------------------------- # Create a TVB simulator and set all desired inputs # (connectivity, model, surface, stimuli etc) # We choose all defaults in this example simulator = Simulator() simulator.integrator = HeunStochastic(dt=dt) simulator.integrator.noise.nsig = np.array(ensure_list(noise_strength)) simulator.model = tvb_sim_model simulator.connectivity = connectivity mon_raw = Raw(period=simulator.integrator.dt) simulator.monitors = (mon_raw, ) # -----------------------------------3. Simulate and gather results------------------------------------------------- # Configure the simulator with the TVB-NEST interface... # simulator.configure(tvb_nest_interface=tvb_nest_model) simulator.configure() # ...and simulate! t_start = time.time() results = simulator.run(simulation_length=simulation_length) print("\nSimulated in %f secs!" % (time.time() - t_start)) # -------------------------------------------6. Plot results-------------------------------------------------------- plot_results(results, simulator, None, "State Variables", simulator.model.variables_of_interest, plotter) return connectivity, results
def test_server_fire_simulation(self, mocker, connectivity_factory): self._mock_user(mocker) input_folder = self.files_helper.get_project_folder(self.test_project) sim_dir = os.path.join(input_folder, 'test_sim') if not os.path.isdir(sim_dir): os.makedirs(sim_dir) simulator = Simulator() simulator.connectivity = connectivity_factory() sim_serializer = SimulatorSerializer() sim_serializer.serialize_simulator(simulator, None, sim_dir) zip_filename = os.path.join(input_folder, RequestFileKey.SIMULATION_FILE_NAME.value) FilesHelper().zip_folder(zip_filename, sim_dir) # Mock flask.request.files to return a dictionary request_mock = mocker.patch.object(flask, 'request') fp = open(zip_filename, 'rb') request_mock.files = { RequestFileKey.SIMULATION_FILE_KEY.value: FileStorage(fp, os.path.basename(zip_filename)) } def launch_sim(self, user_id, project, algorithm, zip_folder_path, simulator_file): return Operation('', '', '', {}) # Mock simulation launch and current user mocker.patch.object(SimulatorService, 'prepare_simulation_on_server', launch_sim) operation_gid, status = self.simulation_resource.post( project_gid=self.test_project.gid) fp.close() assert type(operation_gid) is str assert status == 201
# (to have a default project, user and connectivity) if __name__ == "__main__": TvbProfile.set_profile(TvbProfile.COMMAND_PROFILE) log = get_logger(__name__) # This ID of a project needs to exists in DB, and it can be taken from the WebInterface: project = dao.get_project_by_id(1) # Find a structural Connectivity and load it in memory connectivity_index = dao.get_generic_entity( ConnectivityIndex, DataTypeMetaData.DEFAULT_SUBJECT, "subject")[0] connectivity = h5.load_from_index(connectivity_index) # Prepare a Simulator instance with defaults and configure it to use the previously loaded Connectivity simulator = Simulator() simulator.connectivity = connectivity # Configure the Simulator to use a Scaling type coupling simulator.coupling = Scaling() # Choose a higher value for the 'tau' parameter of the Generic2dOscillator model simulator.model.tau = numpy.array([2.0]) # Configure the simulation length simulator.simulation_length = 100 # Load the SimulatorAdapter algorithm from DB cached_simulator_algorithm = AlgorithmService( ).get_algorithm_by_module_and_class(IntrospectionRegistry.SIMULATOR_MODULE, IntrospectionRegistry.SIMULATOR_CLASS) # Instantiate a SimulatorService and launch the configured simulation simulator_service = SimulatorService() launched_operation = simulator_service.async_launch_and_prepare_simulation(