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(
