def generatePopulationSimulationLEMS(n_pops, baseline, pops, duration, dt, dl):
# Create simulation
# Create LEMS file
dl_str = 'DL' if dl else ''
sim_file = 'LEMS_WC_%s%s.xml' % (baseline, dl_str)
sim_id = 'WC_%s%s' % (baseline, dl_str)
ls = LEMSSimulation(sim_id, duration, dt, 'net1')
colours = ['#ff0000', '#0000ff']
colours2 = ['#ff7777', '#7777ff']
# Add additional LEMS files
# Add Wilson and Cowan Components
ls.include_lems_file('WC_Parameters%s.xml' % dl_str, include_included=True)
# Add the network definition
ls.include_lems_file('WC_%s%s.net.nml' % (baseline, dl_str),
include_included=True)
ls.set_report_file('report.txt')
disp2 = 'd2'
ls.create_display(disp2, 'Rates', -.1, 1.2)
for pop_idx, pop in enumerate(pops):
for n_pop in range(n_pops[pop_idx]):
ls.add_line_to_display(disp2,
'r_%s' % pop,
'%sPop/%d/%s/%s' %
(pop, n_pop, pop, 'R' if dl else 'r'),
color=colours[pop_idx])
disp1 = 'd1'
ls.create_display(disp1, 'iSyn', -2, 8)
for pop_idx, pop in enumerate(pops):
for n_pop in range(n_pops[pop_idx]):
ls.add_line_to_display(disp1,
'iSyn_%s' % pop,
'%sPop/%d/%s/iSyn' % (pop, n_pop, pop),
color=colours[pop_idx],
scale=1 if dl else '1nA')
ls.add_line_to_display(disp1,
'f_%s' % pop,
'%sPop/%d/%s/f' % (pop, n_pop, pop),
color=colours2[pop_idx])
of1 = 'of_%s' % pop
ls.create_output_file(of1, 'WC_%s%s.dat' % (baseline, dl_str))
for pop_idx, pop in enumerate(pops):
# save rates in output file
for n_pop in range(n_pops[pop_idx]):
ls.add_column_to_output_file(
of1, 'r_%s' % pop,
'%sPop/%d/%s/%s' % (pop, n_pop, pop, 'R' if dl else 'r'))
save_path = os.path.join(sim_file)
ls.save_to_file(file_name=save_path)
def generatefISimulationLEMS(population, units):
# Create LEMS file
sim_id = 'LEMS_fISim_%s.xml' % population
ls = LEMSSimulation(sim_id, 200, 0.1, 'net_%s' % population)
# Add additional LEMS file
# Add Rate Base Components
ls.include_lems_file('../RateBased.xml', include_included=True)
ls.include_lems_file('../CellDefinition.xml', include_included=True)
# Add specifications for these Rate Based Components
ls.include_lems_file('../RateBasedSpecifications_high_baseline.xml',
include_included=True)
# Add the network definition
ls.include_lems_file('fI_%s.nml' % population, include_included=True)
# Display outputs and check the results plot the lowest, middle and highest values
middle = math.ceil(units / 2)
disp0 = 'Rate'
ls.create_display(disp0, 'Rates', '-2', '45')
ls.add_line_to_display(disp0,
'%s0' % population,
'%sPop[0]/r' % population,
color='#0000ff')
ls.add_line_to_display(disp0,
'%s%d' % (population, middle),
'%sPop[%d]/r' % (population, middle),
color='#DDA0DD')
ls.add_line_to_display(disp0,
'%s19' % population,
'%sPop[19]/r' % population,
color='#00ff00')
disp1 = 'Voltage'
ls.create_display(disp1, 'Voltages', '-.072', '-.035')
ls.add_line_to_display(disp1,
'%s0' % population,
'%sPop[0]/V' % population,
color='#0000ff')
ls.add_line_to_display(disp1,
'%s%d' % (population, middle),
'%sPop[%d]/V' % (population, middle),
color='#DDA0DD')
ls.add_line_to_display(disp1,
'%s19' % population,
'%sPop[19]/V' % population,
color='#00ff00')
# Create output file
of1 = 'of1'
ls.create_output_file(of1, 'fI_%s.dat' % population)
for unit in range(units):
ls.add_column_to_output_file(of1, 'r%d' % unit,
'%sPop[%d]/r' % (population, unit))
ls.add_column_to_output_file(of1, 'V%d' % unit,
'%sPop[%d]/V' % (population, unit))
save_path = os.path.join(sim_id)
ls.save_to_file(file_name=save_path)
def generatePopulationSimulationLEMS(n_pops, baseline, pops, sim_length):
# Create LEMS file
sim_id = 'LEMS_PopulationSim%sBaseline.xml' % baseline
dt = 0.1
ls = LEMSSimulation(sim_id, sim_length, dt, 'net2')
colours = ['#0000ff', '#ff0000', '#DDA0DD', '#00ff00']
# Add additional LEMS files
# Add Rate Base Components
ls.include_lems_file('../RateBased.xml', include_included=True)
ls.include_lems_file('../CellDefinition.xml', include_included=True)
# Add specifications for the Rate Base Components
ls.include_lems_file('../RateBasedSpecifications_%s_baseline.xml' %
baseline,
include_included=True)
# Add the network definition
ls.include_lems_file('RandomPopulationRate_%s_baseline.nml' % baseline,
include_included=True)
for pop_idx, pop in enumerate(pops):
disp1 = '%s' % pop
ls.create_display(disp1, '%s' % pop, -1, 12)
for n_pop in range(n_pops[pop_idx]):
ls.add_line_to_display(disp1,
'%s%d' % (pop, n_pop),
'%sPop/%d/%s/r' % (pop, n_pop, pop.upper()),
color=colours[pop_idx])
for pop_idx, pop in enumerate(pops):
# Create output file
of1 = 'of_%s' % pop
ls.create_output_file(
of1, 'Population_%s_%s_baseline.dat' % (pop, baseline))
for n_pop in range(n_pops[pop_idx]):
ls.add_column_to_output_file(
of1, 'r_%s_%d' % (pop, n_pop),
'%sPop/%d/%s/r' % (pop, n_pop, pop.upper()))
save_path = os.path.join(sim_id)
ls.save_to_file(file_name=save_path)
def generate_grc_layer_network(
runID,
correlationRadius,
NADT,
duration,
dt,
minimumISI, # ms
ONRate, # Hz
OFFRate, # Hz
run=False):
########################################
# Load parameters for this run
file = open('../params_file.pkl', 'r')
p = pkl.load(file)
N_syn = p['N_syn'][int(runID) - 1]
f_mf = p['f_mf'][int(runID) - 1]
run_num = p['run_num'][int(runID) - 1]
file.close()
#################################################################################
# Get connectivity matrix between cells
file = open('../../network_structures/GCLconnectivity_' + str(N_syn) +
'.pkl')
p = pkl.load(file)
conn_mat = p['conn_mat']
N_mf, N_grc = conn_mat.shape
assert (np.all(conn_mat.sum(
axis=0) == N_syn)), 'Connectivity matrix is incorrect.'
# Get MF activity pattern
if correlationRadius == 0: # Activate MFs randomly
N_mf_ON = int(N_mf * f_mf)
mf_indices_ON = random.sample(range(N_mf), N_mf_ON)
mf_indices_ON.sort()
elif correlationRadius > 0: # Spatially correlated MFs
f_mf_range = np.linspace(.05, .95, 19)
f_mf_ix = np.where(f_mf_range == f_mf)[0][0]
p = io.loadmat('../../input_statistics/mf_patterns_r' +
str(correlationRadius) + '.mat')
R = p['Rs'][:, :, f_mf_ix]
g = p['gs'][f_mf_ix]
t = np.dot(R.transpose(), np.random.randn(N_mf))
S = (t > -g * np.ones(N_mf))
mf_indices_ON = np.where(S)[0]
N_mf_ON = len(mf_indices_ON)
#
N_mf_OFF = N_mf - N_mf_ON
mf_indices_OFF = [x for x in range(N_mf) if x not in mf_indices_ON]
mf_indices_OFF.sort()
#################################################################################
# load NeuroML components, LEMS components and LEMS componentTypes from external files
# Spike generator (for Poisson MF spiking)
spike_generator_file_name = "../../grc_lemsDefinitions/spikeGenerators.xml"
spike_generator_doc = pynml.read_lems_file(spike_generator_file_name)
# Integrate-and-fire GC model
# if NADT = 1, loads model GC
iaf_nml2_file_name = "../../grc_lemsDefinitions/IaF_GrC.nml" if NADT == 0 else "../../grc_lemsDefinitions/IaF_GrC_" + '{:.2f}'.format(
f_mf) + ".nml"
iaF_GrC_doc = pynml.read_neuroml2_file(iaf_nml2_file_name)
iaF_GrC = iaF_GrC_doc.iaf_ref_cells[0]
# AMPAR and NMDAR mediated synapses
ampa_syn_filename = "../../grc_lemsDefinitions/RothmanMFToGrCAMPA_" + str(
N_syn) + ".xml"
nmda_syn_filename = "../../grc_lemsDefinitions/RothmanMFToGrCNMDA_" + str(
N_syn) + ".xml"
rothmanMFToGrCAMPA_doc = pynml.read_lems_file(ampa_syn_filename)
rothmanMFToGrCNMDA_doc = pynml.read_lems_file(nmda_syn_filename)
#
# Define components from the componentTypes we just loaded
# Refractory poisson input -- representing active MF
spike_generator_ref_poisson_type = spike_generator_doc.component_types[
'spikeGeneratorRefPoisson']
lems_instances_doc = lems.Model()
spike_generator_on = lems.Component("mossySpikerON",
spike_generator_ref_poisson_type.name)
spike_generator_on.set_parameter("minimumISI", "%s ms" % minimumISI)
spike_generator_on.set_parameter("averageRate", "%s Hz" % ONRate)
lems_instances_doc.add(spike_generator_on)
# Refractory poisson input -- representing silent MF
spike_generator_off = lems.Component("mossySpikerOFF",
spike_generator_ref_poisson_type.name)
spike_generator_off.set_parameter("minimumISI", "%s ms" % minimumISI)
spike_generator_off.set_parameter("averageRate", "%s Hz" % OFFRate)
lems_instances_doc.add(spike_generator_off)
# Synapses
rothmanMFToGrCAMPA = rothmanMFToGrCAMPA_doc.components[
'RothmanMFToGrCAMPA'].id
rothmanMFToGrCNMDA = rothmanMFToGrCNMDA_doc.components[
'RothmanMFToGrCNMDA'].id
#
# Create ON MF, OFF MF, and GC populations
GrCPop = nml.Population(id="GrCPop", component=iaF_GrC.id, size=N_grc)
mossySpikersPopON = nml.Population(id=spike_generator_on.id + "Pop",
component=spike_generator_on.id,
size=N_mf_ON)
mossySpikersPopOFF = nml.Population(id=spike_generator_off.id + "Pop",
component=spike_generator_off.id,
size=N_mf_OFF)
#
# Create network and add populations
net = nml.Network(id="network")
net_doc = nml.NeuroMLDocument(id=net.id)
net_doc.networks.append(net)
net.populations.append(GrCPop)
net.populations.append(mossySpikersPopON)
net.populations.append(mossySpikersPopOFF)
#
# MF-GC connectivity
# First connect ON MFs to GCs
for mf_ix_ON in range(N_mf_ON):
mf_ix = mf_indices_ON[mf_ix_ON]
# Find which GCs are neighbors
innervated_grcs = np.where(conn_mat[mf_ix, :] == 1)[0]
for grc_ix in innervated_grcs:
# Add AMPAR and NMDAR mediated synapses
for synapse in [rothmanMFToGrCAMPA, rothmanMFToGrCNMDA]:
connection = nml.SynapticConnection(
from_='{}[{}]'.format(mossySpikersPopON.id, mf_ix_ON),
synapse=synapse,
to='GrCPop[{}]'.format(grc_ix))
net.synaptic_connections.append(connection)
#
# Now connect OFF MFs to GCs
for mf_ix_OFF in range(N_mf_OFF):
mf_ix = mf_indices_OFF[mf_ix_OFF]
# Find which GCs are neighbors
innervated_grcs = np.where(conn_mat[mf_ix, :] == 1)[0]
for grc_ix in innervated_grcs:
# Add AMPAR and NMDAR mediated synapses
for synapse in [rothmanMFToGrCAMPA, rothmanMFToGrCNMDA]:
connection = nml.SynapticConnection(
from_='{}[{}]'.format(mossySpikersPopOFF.id, mf_ix_OFF),
synapse=synapse,
to='GrCPop[{}]'.format(grc_ix))
net.synaptic_connections.append(connection)
#
# Write network to file
net_file_name = 'generated_network_' + runID + '.net.nml'
pynml.write_neuroml2_file(net_doc, net_file_name)
# Write LEMS instances to file
lems_instances_file_name = 'instances_' + runID + '.xml'
pynml.write_lems_file(lems_instances_doc,
lems_instances_file_name,
validate=False)
# Create a LEMSSimulation to manage creation of LEMS file
ls = LEMSSimulation('sim_' + runID,
duration,
dt,
lems_seed=int(np.round(1000 * random.random())))
# Point to network as target of simulation
ls.assign_simulation_target(net.id)
# Include generated/existing NeuroML2 files
ls.include_neuroml2_file(iaf_nml2_file_name)
ls.include_lems_file(spike_generator_file_name, include_included=False)
ls.include_lems_file(lems_instances_file_name)
ls.include_lems_file(ampa_syn_filename, include_included=False)
ls.include_lems_file(nmda_syn_filename, include_included=False)
ls.include_neuroml2_file(net_file_name)
# Specify Displays and Output Files
# Details for saving output files
basedir = '../data_r' + str(
correlationRadius) + '/' if NADT == 0 else '../data_r' + str(
correlationRadius) + '_NADT/'
end_filename = str(N_syn) + '_{:.2f}'.format(f_mf) + '_' + str(
run_num) # Add parameter values to spike time filename
# Save MF spike times under basedir + MF_spikes_ + end_filename
eof0 = 'MFspikes_file'
ls.create_event_output_file(eof0,
basedir + "MF_spikes_" + end_filename + ".dat")
# ON MFs
for i in range(mossySpikersPopON.size):
ls.add_selection_to_event_output_file(
eof0, mf_indices_ON[i], "%s[%i]" % (mossySpikersPopON.id, i),
'spike')
# OFF MFs
for i in range(mossySpikersPopOFF.size):
ls.add_selection_to_event_output_file(
eof0, mf_indices_OFF[i], "%s[%i]" % (mossySpikersPopOFF.id, i),
'spike')
# Save GC spike times under basedir + GrC_spikes_ + end_filename
eof1 = 'GrCspikes_file'
ls.create_event_output_file(
eof1, basedir + "GrC_spikes_" + end_filename + ".dat")
#
for i in range(GrCPop.size):
ls.add_selection_to_event_output_file(eof1, i,
"%s[%i]" % (GrCPop.id, i),
'spike')
#
lems_file_name = ls.save_to_file()
#
if run:
results = pynml.run_lems_with_jneuroml(lems_file_name,
max_memory="8G",
nogui=True,
load_saved_data=False,
plot=False)
return results
def generate_grc_layer_network(
p_mf_ON,
duration,
dt,
minimumISI, # ms
ONRate, # Hz
OFFRate, # Hz
run=False):
# Load connectivity matrix
file = open('GCLconnectivity.pkl')
p = pkl.load(file)
conn_mat = p['conn_mat']
N_mf, N_grc = conn_mat.shape
assert (np.all(conn_mat.sum(
axis=0) == 4)), 'Connectivity matrix is incorrect.'
# Load GrC and MF rosette positions
grc_pos = p['grc_pos']
glom_pos = p['glom_pos']
# Choose which mossy fibers are on, which are off
N_mf_ON = int(N_mf * p_mf_ON)
mf_indices_ON = random.sample(range(N_mf), N_mf_ON)
mf_indices_ON.sort()
N_mf_OFF = N_mf - N_mf_ON
mf_indices_OFF = [x for x in range(N_mf) if x not in mf_indices_ON]
mf_indices_OFF.sort()
# load NeuroML components, LEMS components and LEMS componentTypes from external files
##spikeGeneratorRefPoisson is now a standard nml type...
##spike_generator_doc = pynml.read_lems_file(spike_generator_file_name)
iaF_GrC = nml.IafRefCell(id="iaF_GrC",
refract="2ms",
C="3.22pF",
thresh="-40mV",
reset="-63mV",
leak_conductance="1.498nS",
leak_reversal="-79.67mV")
ampa_syn_filename = "RothmanMFToGrCAMPA.xml"
nmda_syn_filename = "RothmanMFToGrCNMDA.xml"
rothmanMFToGrCAMPA_doc = pynml.read_lems_file(ampa_syn_filename)
rothmanMFToGrCNMDA_doc = pynml.read_lems_file(nmda_syn_filename)
# define some components from the componentTypes we just loaded
##spike_generator_ref_poisson_type = spike_generator_doc.component_types['spikeGeneratorRefPoisson']
lems_instances_doc = lems.Model()
spike_generator_ref_poisson_type_name = 'spikeGeneratorRefPoisson'
spike_generator_on = lems.Component("mossySpikerON",
spike_generator_ref_poisson_type_name)
spike_generator_on.set_parameter("minimumISI", "%s ms" % minimumISI)
spike_generator_on.set_parameter("averageRate", "%s Hz" % ONRate)
lems_instances_doc.add(spike_generator_on)
spike_generator_off = lems.Component(
"mossySpikerOFF", spike_generator_ref_poisson_type_name)
spike_generator_off.set_parameter("minimumISI", "%s ms" % minimumISI)
spike_generator_off.set_parameter("averageRate", "%s Hz" % OFFRate)
lems_instances_doc.add(spike_generator_off)
rothmanMFToGrCAMPA = rothmanMFToGrCAMPA_doc.components[
'RothmanMFToGrCAMPA'].id
rothmanMFToGrCNMDA = rothmanMFToGrCNMDA_doc.components[
'RothmanMFToGrCNMDA'].id
# create populations
GrCPop = nml.Population(id=iaF_GrC.id + "Pop",
component=iaF_GrC.id,
type="populationList",
size=N_grc)
GrCPop.properties.append(nml.Property(tag='color', value='0 0 0.8'))
GrCPop.properties.append(nml.Property(tag='radius', value=2))
mossySpikersPopON = nml.Population(id=spike_generator_on.id + "Pop",
component=spike_generator_on.id,
type="populationList",
size=N_mf_ON)
mossySpikersPopON.properties.append(
nml.Property(tag='color', value='0.8 0 0'))
mossySpikersPopON.properties.append(nml.Property(tag='radius', value=2))
mossySpikersPopOFF = nml.Population(id=spike_generator_off.id + "Pop",
component=spike_generator_off.id,
size=N_mf_OFF)
mossySpikersPopOFF.properties.append(
nml.Property(tag='color', value='0 0.8 0'))
mossySpikersPopOFF.properties.append(nml.Property(tag='radius', value=2))
# create network and add populations
net = nml.Network(id="network")
net_doc = nml.NeuroMLDocument(id=net.id)
net_doc.networks.append(net)
net_doc.iaf_ref_cells.append(iaF_GrC)
net.populations.append(GrCPop)
net.populations.append(mossySpikersPopON)
net.populations.append(mossySpikersPopOFF)
#net_doc.includes.append(nml.IncludeType(href=iaf_nml2_file_name))
# Add locations for GCs
for grc in range(N_grc):
inst = nml.Instance(id=grc)
GrCPop.instances.append(inst)
inst.location = nml.Location(x=grc_pos[grc, 0],
y=grc_pos[grc, 1],
z=grc_pos[grc, 2])
# ON MFs: locations and connectivity
ONprojectionAMPA = nml.Projection(
id="ONProjAMPA",
presynaptic_population=mossySpikersPopON.id,
postsynaptic_population=GrCPop.id,
synapse=rothmanMFToGrCAMPA)
ONprojectionNMDA = nml.Projection(
id="ONProjNMDA",
presynaptic_population=mossySpikersPopON.id,
postsynaptic_population=GrCPop.id,
synapse=rothmanMFToGrCNMDA)
net.projections.append(ONprojectionAMPA)
net.projections.append(ONprojectionNMDA)
ix = 0
for mf_ix_ON in range(N_mf_ON):
mf_ix = mf_indices_ON[mf_ix_ON]
inst = nml.Instance(id=mf_ix_ON)
mossySpikersPopON.instances.append(inst)
inst.location = nml.Location(x=glom_pos[mf_ix, 0],
y=glom_pos[mf_ix, 1],
z=glom_pos[mf_ix, 2])
# find which granule cells are neighbors
innervated_grcs = np.where(conn_mat[mf_ix, :] == 1)[0]
for grc_ix in innervated_grcs:
for synapse in [rothmanMFToGrCAMPA, rothmanMFToGrCNMDA]:
connection = nml.Connection(
id=ix,
pre_cell_id='../{}/{}/{}'.format(mossySpikersPopON.id,
mf_ix_ON,
spike_generator_on.id),
post_cell_id='../{}/{}/{}'.format(GrCPop.id, grc_ix,
iaF_GrC.id))
ONprojectionAMPA.connections.append(connection)
ONprojectionNMDA.connections.append(connection)
ix = ix + 1
# OFF MFs: locations and connectivity
OFFprojectionAMPA = nml.Projection(
id="OFFProjAMPA",
presynaptic_population=mossySpikersPopOFF.id,
postsynaptic_population=GrCPop.id,
synapse=rothmanMFToGrCAMPA)
OFFprojectionNMDA = nml.Projection(
id="OFFProjNMDA",
presynaptic_population=mossySpikersPopOFF.id,
postsynaptic_population=GrCPop.id,
synapse=rothmanMFToGrCNMDA)
net.projections.append(OFFprojectionAMPA)
net.projections.append(OFFprojectionNMDA)
ix = 0
for mf_ix_OFF in range(N_mf_OFF):
mf_ix = mf_indices_OFF[mf_ix_OFF]
inst = nml.Instance(id=mf_ix_OFF)
mossySpikersPopOFF.instances.append(inst)
inst.location = nml.Location(x=glom_pos[mf_ix, 0],
y=glom_pos[mf_ix, 1],
z=glom_pos[mf_ix, 2])
# find which granule cells are neighbors
innervated_grcs = np.where(conn_mat[mf_ix, :] == 1)[0]
for grc_ix in innervated_grcs:
for synapse in [rothmanMFToGrCAMPA, rothmanMFToGrCNMDA]:
connection = nml.Connection(
id=ix,
pre_cell_id='../{}/{}/{}'.format(mossySpikersPopOFF.id,
mf_ix_OFF,
spike_generator_on.id),
post_cell_id='../{}/{}/{}'.format(GrCPop.id, grc_ix,
iaF_GrC.id))
OFFprojectionAMPA.connections.append(connection)
OFFprojectionNMDA.connections.append(connection)
ix = ix + 1
# Write network to file
net_file_name = 'OSBnet.nml'
pynml.write_neuroml2_file(net_doc, net_file_name)
# Write LEMS instances to file
lems_instances_file_name = 'instances.xml'
pynml.write_lems_file(lems_instances_doc,
lems_instances_file_name,
validate=False)
# Create a LEMSSimulation to manage creation of LEMS file
ls = LEMSSimulation(
'sim', duration, dt,
simulation_seed=123) # int(np.round(1000*random.random())))
# Point to network as target of simulation
ls.assign_simulation_target(net.id)
# Include generated/existing NeuroML2 files
###ls.include_lems_file(spike_generator_file_name, include_included=False)
ls.include_lems_file(lems_instances_file_name)
ls.include_lems_file(ampa_syn_filename, include_included=False)
ls.include_lems_file(nmda_syn_filename, include_included=False)
ls.include_neuroml2_file(net_file_name)
# Specify Displays and Output Files
basedir = ''
eof0 = 'Volts_file'
ls.create_event_output_file(eof0, basedir + "MF_spikes.dat")
for i in range(mossySpikersPopON.size):
ls.add_selection_to_event_output_file(
eof0, mf_indices_ON[i], '{}/{}/{}'.format(mossySpikersPopON.id, i,
spike_generator_on.id),
'spike')
for i in range(mossySpikersPopOFF.size):
ls.add_selection_to_event_output_file(
eof0, mf_indices_OFF[i],
'{}/{}/{}'.format(mossySpikersPopOFF.id, i,
spike_generator_on.id), 'spike')
eof1 = 'GrCspike_file'
ls.create_event_output_file(eof1, basedir + "GrC_spikes.dat")
for i in range(GrCPop.size):
ls.add_selection_to_event_output_file(
eof1, i, '{}/{}/{}'.format(GrCPop.id, i, iaF_GrC.id), 'spike')
lems_file_name = ls.save_to_file()
if run:
print('Running the generated LEMS file: %s for simulation of %sms' %
(lems_file_name, duration))
results = pynml.run_lems_with_jneuroml(lems_file_name,
max_memory="8G",
nogui=True,
load_saved_data=False,
plot=False)
return results
