def from_file(filepath, **kwargs):
result = TVBConnectivity.from_file(filepath)
if isinstance(result, TVBConnectivity):
return Connectivity.from_tvb_instance(result, **kwargs)
else:
return Connectivity.from_instance(result, **kwargs)
def configure(self,
dt=2**-3,
model=ModelsEnum.GENERIC_2D_OSCILLATOR.get_class(),
speed=4.0,
coupling_strength=0.00042,
method=HeunDeterministic,
surface_sim=False,
default_connectivity=True,
with_stimulus=False):
"""
Create an instance of the Simulator class, by default use the
generic plane oscillator local dynamic model and the deterministic
version of Heun's method for the numerical integration.
"""
self.method = method
if default_connectivity:
white_matter = Connectivity.from_file()
region_mapping = RegionMapping.from_file(
source_file="regionMapping_16k_76.txt")
else:
white_matter = Connectivity.from_file(
source_file="connectivity_192.zip")
region_mapping = RegionMapping.from_file(
source_file="regionMapping_16k_192.txt")
region_mapping.surface = CorticalSurface.from_file()
white_matter_coupling = coupling.Linear(
a=numpy.array([coupling_strength]))
white_matter.speed = numpy.array(
[speed]) # no longer allow scalars to numpy array promotion
dynamics = model()
if issubclass(method, IntegratorStochastic):
hisss = noise.Additive(nsig=numpy.array([2**-11]))
integrator = method(dt=dt, noise=hisss)
else:
integrator = method(dt=dt)
if surface_sim:
local_coupling_strength = numpy.array([2**-10])
default_cortex = Cortex.from_file()
default_cortex.region_mapping_data = region_mapping
default_cortex.coupling_strength = local_coupling_strength
if default_connectivity:
default_cortex.local_connectivity = LocalConnectivity.from_file(
)
else:
default_cortex.local_connectivity = LocalConnectivity()
default_cortex.local_connectivity.surface = default_cortex.region_mapping_data.surface
# TODO stimulus
else:
default_cortex = None
if with_stimulus:
weights = StimuliRegion.get_default_weights(
white_matter.weights.shape[0])
weights[self.stim_nodes] = 1.
stimulus = StimuliRegion(temporal=Linear(parameters={
"a": 0.0,
"b": self.stim_value
}),
connectivity=white_matter,
weight=weights)
# Order of monitors determines order of returned values.
self.sim = simulator.Simulator()
self.sim.surface = default_cortex
self.sim.model = dynamics
self.sim.integrator = integrator
self.sim.connectivity = white_matter
self.sim.coupling = white_matter_coupling
self.sim.monitors = self.monitors
if with_stimulus:
self.sim.stimulus = stimulus
self.sim.configure()
def configure(self,
dt=2**-3,
model=models.Generic2dOscillator,
speed=4.0,
coupling_strength=0.00042,
method=HeunDeterministic,
surface_sim=False,
default_connectivity=True):
"""
Create an instance of the Simulator class, by default use the
generic plane oscillator local dynamic model and the deterministic
version of Heun's method for the numerical integration.
"""
self.method = method
if default_connectivity:
white_matter = Connectivity.from_file()
region_mapping = RegionMapping.from_file(
source_file="regionMapping_16k_76.txt")
else:
white_matter = Connectivity.from_file(
source_file="connectivity_192.zip")
region_mapping = RegionMapping.from_file(
source_file="regionMapping_16k_192.txt")
region_mapping.surface = CorticalSurface.from_file()
white_matter_coupling = coupling.Linear(
a=numpy.array([coupling_strength]))
white_matter.speed = numpy.array(
[speed]) # no longer allow scalars to numpy array promotion
dynamics = model()
if issubclass(method, IntegratorStochastic):
hisss = noise.Additive(nsig=numpy.array([2**-11]))
integrator = method(dt=dt, noise=hisss)
else:
integrator = method(dt=dt)
if surface_sim:
local_coupling_strength = numpy.array([2**-10])
default_cortex = Cortex.from_file()
default_cortex.region_mapping_data = region_mapping
default_cortex.coupling_strength = local_coupling_strength
if default_connectivity:
default_cortex.local_connectivity = LocalConnectivity.from_file(
)
else:
default_cortex.local_connectivity = LocalConnectivity()
default_cortex.local_connectivity.surface = default_cortex.region_mapping_data.surface
else:
default_cortex = None
# Order of monitors determines order of returned values.
self.sim = simulator.Simulator()
self.sim.surface = default_cortex
self.sim.model = dynamics
self.sim.integrator = integrator
self.sim.connectivity = white_matter
self.sim.coupling = white_matter_coupling
self.sim.monitors = self.monitors
self.sim.configure()
import matplotlib as mpl
mpl.use('Agg')
from tvb.datatypes.connectivity import Connectivity
from tvb_nest.config import Config
config = Config(output_base="outputs/")
config.figures.SAVE_FLAG = False
config.figures.SHOW_FLAG = False
config.figures.MATPLOTLIB_BACKEND = "Agg"
from tvb_nest.examples.example import main_example
from tvb_nest.nest_models.builders.models.red_ww_exc_io_inh_i import RedWWExcIOInhIBuilder
from tvb_nest.interfaces.builders.models.red_ww_exc_io_inh_i \
import RedWWexcIOinhIBuilder as InterfaceRedWWexcIOinhIBuilder
from tvb.simulator.models.reduced_wong_wang_exc_io_inh_i import ReducedWongWangExcIOInhI
# 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(config.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)
main_example(ReducedWongWangExcIOInhI, RedWWExcIOInhIBuilder, InterfaceRedWWexcIOinhIBuilder,
nest_nodes_ids, nest_populations_order=100, connectivity=connectivity,
simulation_length=50.0, exclusive_nodes=True, config=config)
from tvb.simulator.monitors import Raw
from tvb_timeseries.model.timeseries import Timeseries
from tvb_nest.base.config import *
from tvb_nest.plot.plotter import Plotter
from tvb_nest.base.simulator import Simulator
from tvb_nest.tvb_models.reduced_wong_wang_exc_io_inh_i import ReducedWongWangExcIOInhI
from tvb_nest.nest_models_builders.red_ww_exc_io_inh_i import RedWWExcIOInhIBuilder
from tvb_nest.interface_builders.red_ww_exc_io_inh_i import RedWWexcIOinhIBuilder
config = Config(output_base="outputs/")
config.figures.SAVE_FLAG = False
config.figures.SHOW_FLAG = False
config.figures.MATPLOTLIB_BACKEND = "Agg"
plotter = Plotter(config)
connectivity = Connectivity.from_file(
os.path.join(DEFAULT_SUBJECT_PATH, DEFAULT_CONNECTIVITY_ZIP))
connectivity.configure()
#plotter.plot_tvb_connectivity(connectivity)
# Create a TVB simulator and set all desired inputs
# (connectivity, model, surface, stimuli etc)
# We choose all defaults in this example
simulator = Simulator()
simulator.model = ReducedWongWangExcIOInhI()
simulator.connectivity = connectivity
simulator.integrator.dt = float(
int(np.round(simulator.integrator.dt /
config.nest.NEST_MIN_DT))) * config.nest.NEST_MIN_DT
# Some extra monitors for neuroimaging measures:
mon_raw = Raw(period=simulator.integrator.dt)
simulator.monitors = (mon_raw, ) # mon_bold, mon_eeg
tvb_state_variables_labels=simulator.model.
variables_of_interest,
plot_per_neuron=False,
plotter=plotter,
config=config)
except Exception as e:
print("Error in plotting or writing to files!:\n%s" % str(e))
return tvb_results, simulator
if __name__ == "__main__":
# 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, label in enumerate(connectivity.region_labels):
if label.find("cereb") > 0:
nest_nodes_ids.append(id)
if len(nest_nodes_ids) == 0:
nest_nodes_ids = [
0
] # if the connectivity doesn't have cerebellum, just set a region for testing
tvb_model = ReducedWongWangExcIO # ReducedWongWangExcIOInhI
model_params = {}
main_example(
tvb_model,
CerebBuilder,
def create_time_series_region_object():
config = CONFIGURED
connectivity = Connectivity.from_file(config.DEFAULT_CONNECTIVITY_ZIP)
connectivity.configure()
simulator = Simulator()
simulator.model = ReducedWongWangExcIOInhI()
def boundary_fun(state):
state[state < 0] = 0.0
state[state > 1] = 1.0
return state
simulator.boundary_fun = boundary_fun
simulator.connectivity = connectivity
simulator.integrator.dt = \
float(int(numpy.round(simulator.integrator.dt /
config.nest.NEST_MIN_DT))) * config.nest.NEST_MIN_DT
mon_raw = Raw(period=simulator.integrator.dt)
simulator.monitors = (mon_raw, )
number_of_regions = simulator.connectivity.region_labels.shape[0]
nest_nodes_ids = []
for id in range(number_of_regions):
if simulator.connectivity.region_labels[id].find("hippo") > 0:
nest_nodes_ids.append(id)
nest_model_builder = \
RedWWExcIOInhIBuilder(simulator, nest_nodes_ids, config=config)
nest_network = nest_model_builder.build_nest_network()
tvb_nest_builder = \
RedWWexcIOinhIBuilder(simulator, nest_network, nest_nodes_ids, config=config)
tvb_nest_builder.tvb_to_nest_interfaces = \
[{"model": "current", "parameter": "I_e", "sign": 1,
"connections": {"S_e": ["E", "I"]}}]
connections = OrderedDict()
connections["r_e"] = "E"
connections["r_i"] = "I"
tvb_nest_builder.nest_to_tvb_interfaces = \
[{"model": "spike_detector", "params": {}, "connections": connections}]
tvb_nest_model = tvb_nest_builder.build_interface()
simulator.configure(tvb_nest_interface=tvb_nest_model)
results = simulator.run(simulation_length=100.0)
time = results[0][0]
source = results[0][1]
source_ts = TimeSeriesRegion(
data=source,
time=time,
connectivity=simulator.connectivity,
labels_ordering=[
"Time", "Synaptic Gating Variable", "Region", "Neurons"
],
labels_dimensions={
"Synaptic Gating Variable": ["S_e", "S_i"],
"Region": simulator.connectivity.region_labels.tolist()
},
sample_period=simulator.integrator.dt)
return source_ts
#
"""
Demo script on how to use tvb-framework default read/write capabilities
.. moduleauthor:: Lia Domide <*****@*****.**>
"""
from tvb.core.neocom import h5
from tvb.adapters.datatypes.h5.connectivity_h5 import ConnectivityH5
from tvb.datatypes.connectivity import Connectivity
if __name__ == '__main__':
from tvb.interfaces.command.lab import *
# Read from a ZIP
conn_ht = Connectivity.from_file()
conn_ht.configure()
# Store in a given folder the HasTraits entity
PATH = "."
h5.store_complete(conn_ht, PATH)
# Reproduce the just written file name containing GUID
file_name = h5.path_for(PATH, ConnectivityH5, conn_ht.gid)
# Load back from a file name a HasTraits instance
conn_back = h5.load(file_name)
# Check that the loaded and written entities are correct
assert conn_ht.number_of_regions == 76
assert conn_ht.number_of_regions == conn_back.number_of_regions
class sim:
integrator = integrator_
connectivity = Connectivity.from_file()
model = MontbrioPazoRoxin()
def prepare_launch_default_simulation():
config = Config(output_base="outputs/")
config.SAVE_FLAG = False
config.SHOW_FLAG = False
config.MATPLOTLIB_BACKEND = "Agg"
plotter = Plotter(config)
connectivity = Connectivity.from_file(os.path.join(Config.DEFAULT_SUBJECT_PATH, Config.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.model = ReducedWongWangExcIOInhI()
simulator.connectivity = connectivity
simulator.integrator.dt = float(
int(np.round(simulator.integrator.dt / config.nest.NEST_MIN_DT))) * config.nest.NEST_MIN_DT
# Some extra monitors for neuroimaging measures:
mon_raw = Raw(period=simulator.integrator.dt)
simulator.monitors = (mon_raw,) # mon_bold, mon_eeg
# Select the regions for the fine scale modeling with NEST spiking networks
number_of_regions = simulator.connectivity.region_labels.shape[0]
nest_nodes_ids = [] # the indices of fine scale regions modeled with NEST
# In this example, we model parahippocampal cortices (left and right) with NEST
for rid in range(number_of_regions):
if simulator.connectivity.region_labels[rid].find("hippo") > 0:
nest_nodes_ids.append(rid)
# Build a NEST network model with the corresponding builder
# Using all default parameters for this example
nest_model_builder = RedWWExcIOInhIBuilder(simulator, nest_nodes_ids)
nest_model_builder.populations_names = ["E", "I"]
nest_model_builder.populations_scales = [1.0, 0.7]
nest_model_builder.default_synapse["params"]["rule"] = "fixed_indegree"
# Connection weights
# Choosing the values resulting from J_N = 150 pA and J_i = 1000 pA
w_ee = 150.0
w_ei = -1000.0
w_ie = 150.0
w_ii = -1000.0
# Within node connections' weights
# TODO: take care of J_N units conversion from TVB to NEST!
nest_model_builder.population_connectivity_synapses_weights = np.array(
[[w_ee, w_ei], # exc_i -> exc_i, inh_i -> exc_i
[w_ie, w_ii]]) # exc_i -> inh_i, inh_i -> inh_i
nest_model_builder.population_connectivity_synapses_delays = np.array(nest_model_builder.tvb_dt / 4)
# Between node connections
# Given that w_ee == w_ie = J_N, we need only one connection type
nest_model_builder.node_connections = [{"src_population": "E", "trg_population": ["E", "I"],
"model": nest_model_builder.default_synapse["model"],
"params": nest_model_builder.default_synapse["params"],
"weight": w_ee, # weight scaling the TVB connectivity weight
"delay": 0.0}] # additional delay to the one of TVB connectivity
connections = OrderedDict()
connections["E"] = "E"
connections["I"] = "I"
nest_model_builder.output_devices = [{"model": "spike_detector",
"props": config.nest.NEST_OUTPUT_DEVICES_PARAMS_DEF["spike_detector"],
"nodes": None, "connections": connections}]
nest_network = nest_model_builder.build_nest_network()
# Build a TVB-NEST interface with all the appropriate connections between the
# TVB and NEST modelled regions
# Using all default parameters for this example
tvb_nest_builder = RedWWexcIOinhIBuilder(simulator, nest_network, nest_nodes_ids)
# NEST -> TVB:
# For current transmission from TVB to NEST,
# either choose a NEST dc_generator device:
# tvb_nest_builder.tvb_to_nest_interfaces = [{"model": "dc_generator", "sign": 1,
# "connections": {"S_e": ["E", "I"]}}]
# or modify directly the external current stimulus parameter:
tvb_nest_builder.tvb_to_nest_interfaces = [{"model": "current", "parameter": "I_e", "sign": 1,
"connections": {"S_e": ["E", "I"]}}]
# NEST -> TVB:
# Use S_e and S_i instead of r_e and r_i
# for transmitting to the TVB state variables directly
connections = OrderedDict()
connections["r_e"] = "E"
connections["r_i"] = "I"
tvb_nest_builder.nest_to_tvb_interfaces = [{"model": "spike_detector", "params": {}, "connections": connections}]
tvb_nest_model = tvb_nest_builder.build_interface()
# Configure the simulator with the TVB-NEST interface...
simulator.configure(tvb_nest_interface=tvb_nest_model)
# ...and simulate!
t = time.time()
results = simulator.run(simulation_length=100.0)
return connectivity.weights, connectivity.tract_lengths, results[0][1]
def _config_connectivity(self, test_simulator):
test_simulator.connectivity = Connectivity.from_file()
test_simulator.connectivity.configure()
test_simulator.connectivity.set_idelays(test_simulator.integrator.dt)
test_simulator.horizon = test_simulator.connectivity.idelays.max() + 1
def main_example(tvb_sim_model,
nest_model_builder,
tvb_nest_builder,
nest_nodes_ids,
nest_populations_order=100,
connectivity=None,
connectivity_zip=CONFIGURED.DEFAULT_CONNECTIVITY_ZIP,
simulation_length=100.0,
tvb_state_variable_type_label="Synaptic Gating Variable",
delays=True,
dt=0.1,
noise_strength=0.001,
exclusive_nodes=False,
config=CONFIGURED):
plotter = Plotter(config)
# --------------------------------------1. Load TVB connectivity----------------------------------------------------
if connectivity is None:
connectivity = Connectivity.from_file(connectivity_zip)
connectivity.configure()
plotter.plot_tvb_connectivity(connectivity)
if not delays:
connectivity.tract_lengths /= 100000.0
connectivity.configure()
plotter.base.plot_regions2regions(connectivity.delays,
connectivity.region_labels, 111,
"Delays")
plotter.base._save_figure(figure_name="Delays")
# ----------------------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.dt = dt
simulator.integrator.noise.nsig = np.array([noise_strength])
simulator.model = tvb_sim_model
simulator.connectivity = connectivity
mon_raw = Raw(period=simulator.integrator.dt)
simulator.monitors = (mon_raw, )
# ------3. Build the NEST network model (fine-scale regions' nodes, stimulation devices, spike_detectors etc)-------
print("Building NEST network...")
tic = time.time()
# Build a NEST network model with the corresponding builder
# Using all default parameters for this example
nest_model_builder = nest_model_builder(simulator,
nest_nodes_ids,
config=config)
# Common order of neurons' number per population:
nest_model_builder.populations_order = nest_populations_order
nest_network = nest_model_builder.build_nest_network()
print("Done! in %f min" % ((time.time() - tic) / 60))
# -----------------------------------4. Build the TVB-NEST interface model -----------------------------------------
print("Building TVB-NEST interface...")
tic = time.time()
# Build a TVB-NEST interface with all the appropriate connections between the
# TVB and NEST modelled regions
# Using all default parameters for this example
tvb_nest_builder = tvb_nest_builder(simulator, nest_network,
nest_nodes_ids, exclusive_nodes)
tvb_nest_model = tvb_nest_builder.build_interface()
print("Done! in %f min" % ((time.time() - tic) / 60))
# -----------------------------------5. Simulate and gather results-------------------------------------------------
# Configure the simulator with the TVB-NEST interface...
simulator.configure(tvb_nest_interface=tvb_nest_model)
# ...and simulate!
t_start = time.time()
results = simulator.run(simulation_length=simulation_length)
# Integrate NEST one more NEST time step so that multimeters get the last time point
# unless you plan to continue simulation later
simulator.run_spiking_simulator(
simulator.tvb_nest_interface.nest_instance.GetKernelStatus(
"resolution"))
# Clean-up NEST simulation
if simulator.run_spiking_simulator == simulator.tvb_nest_interface.nest_instance.Run:
simulator.tvb_nest_interface.nest_instance.Cleanup()
print("\nSimulated in %f secs!" % (time.time() - t_start))
# -------------------------------------------6. Plot results--------------------------------------------------------
plot_results(results, simulator, tvb_nest_model,
tvb_state_variable_type_label,
simulator.model.variables_of_interest, plotter)
return connectivity, results
def generate_region_demo_data(file_path=os.path.join(os.getcwd(), "demo_data_region_16s_2048Hz.npy")):
"""
Generate 16 seconds of 2048Hz data at the region level, stochastic integration.
``Run time``: approximately 4 minutes (workstation circa 2010)
``Memory requirement``: < 1GB
``Storage requirement``: ~ 19MB
.. moduleauthor:: Stuart A. Knock <*****@*****.**>
"""
##----------------------------------------------------------------------------##
##- Perform the simulation -##
##----------------------------------------------------------------------------##
LOG.info("Configuring...")
# Initialise a Model, Coupling, and Connectivity.
pars = {'a': np.array([1.05]),
'b': np.array([-1]),
'c': np.array([0.0]),
'd': np.array([0.1]),
'e': np.array([0.0]),
'f': np.array([1 / 3.]),
'g': np.array([1.0]),
'alpha': np.array([1.0]),
'beta': np.array([0.2]),
'tau': np.array([1.25]),
'gamma': np.array([-1.0])}
oscillator = Generic2dOscillator(**pars)
white_matter = Connectivity.from_file()
white_matter.speed = np.array([4.0])
white_matter_coupling = Linear(a=np.array([0.033]))
# Initialise an Integrator
hiss = Additive(nsig=np.array([2 ** -10, ]))
heunint = HeunStochastic(dt=0.06103515625, noise=hiss)
# Initialise a Monitor with period in physical time
what_to_watch = TemporalAverage(period=0.48828125) # 2048Hz => period=1000.0/2048.0
# Initialise a Simulator -- Model, Connectivity, Integrator, and Monitors.
sim = Simulator(model=oscillator, connectivity=white_matter,
coupling=white_matter_coupling,
integrator=heunint, monitors=[what_to_watch])
sim.configure()
# Perform the simulation
tavg_data = []
tavg_time = []
LOG.info("Starting simulation...")
for tavg in sim(simulation_length=16000):
if tavg is not None:
tavg_time.append(tavg[0][0]) # TODO:The first [0] is a hack for single monitor
tavg_data.append(tavg[0][1]) # TODO:The first [0] is a hack for single monitor
LOG.info("Finished simulation.")
##----------------------------------------------------------------------------##
##- Save the data to a file -##
##----------------------------------------------------------------------------##
# Make the list a numpy.array.
LOG.info("Converting result to array...")
TAVG = np.array(tavg_data)
# Save it
LOG.info("Saving array to %s..." % file_path)
np.save(file_path, TAVG)
LOG.info("Done.")
