www.neuron.yale.edu

Code: Select all

# Create a dictionary with recorded variable names as keys and values as h.Vectors
rec_dict = create_rec_dict(section_list)

# Chunk end times is a list of end times for each chunk
# For example if I was running a 5000 ms simulation in chunks of 1000 ms
# it would be the list [1000, 2000, 3000, 4000, 5000]
for chunk_end_time in chunk_end_times:
	
	# Run simulation until the end of the next time chunk
	h.continuerun(chunk_end_time)
	
	# Save chunk data... Omitting code for brevity 
	
	# Resize recording vectors so that max amount of memory consumed is close to
	# the amount required to store one time chunks worth of data
	h.frecord_init()

Code: Select all

import multiprocessing as mp

# Create a dictionary with recorded variable names as keys and values as h.Vectors
rec_dict = create_rec_dict(section_list)

# Create multiprocessing manager to manage data queue
with mp.Manager() as manager:
                
	# Create data queue
	data_queue = manager.Queue()
	
	# Create writer process that will get processed data arrays from the data queue and write them to disk
	data_writer = mp.Process(target=data_writer_func, args=(data_writer_args))
	
	# Create multiprocessing pool to handle data_processor worker processes
	with mp.Pool() as pool:

		# Chunk end times is a list of end times for each chunk
		# For example if I was running a 5000 ms simulation in chunks of 1000 ms
		# it would be the list [1000, 2000, 3000, 4000, 5000]
		for chunk_end_time in chunk_end_times:
	
			# Run simulation until the end of the next time chunk
			h.continuerun(chunk_end_time)
			
			# Convert time vector to numpy array
			time_array = rec_dict["Time"].as_numpy()
			
			# Save chunk data
			for var, vec in rec_dict.items():
				
				if var == "Time":
					continue
					
				# Convert vector to numpy array
				var_array = vec.as_numpy()
				
				# Create worker process to process this data before passing it the data writer
				pool.apply_async(target=data_processor, args=(var, var_array, time_array))
	
			# Resize recording vectors so that max amount of memory consumed is close to
			# the amount required to store one time chunks worth of data
			h.frecord_init()

Code: Select all

import time
# Sleep for 10 seconds
time.sleep(10)

Code: Select all

from neuron import h
h.load_file("stdrun.hoc")

# Create test section
sec = h.Section(name="sec")

# Set simulation run time in ms
run_time = 500.0

# Set desired final dt (i.e., sampling rate) in ms
dt = 0.1

# Create time vector with desired sampling rate
time_vec = h.Vector().indgen(0, run_time, dt)

# Insert hh mechanism
sec.insert(h.hh)

# Enable variable timestep integration
cvode = h.CVode()
cvode.active(True)

# Create three time vectors, one using our prespecified time vector above, 
# one using dt, and another with variable timestep
t_time_vec = h.Vector().record(h._ref_t, time_vec)
t_dt = h.Vector().record(h._ref_t, dt)
t = h.Vector().record(h._ref_t)            

# Create three corresponding Vm recording vectors
v_time_vec = h.Vector().record(sec(0.5)._ref_v, time_vec)
v_dt = h.Vector().record(sec(0.5)._ref_v, dt)
v = h.Vector().record(sec(0.5)._ref_v)

# Run simulation until provided run time
h.finitialize()
h.continuerun(run_time)

Code: Select all

print(t_time_vec.to_python())

Code: Select all

print(t_dt.to_python())

Code: Select all

from neuron import h
h.load_file("stdrun.hoc")

# Create dummy variables representing values set in config file not present here
use_cvode = True
num_chunks = 5
chunk_size = 5000 # in ms

# Create Section
soma = h.Section("soma")

# Create recording vector
t = h.Vector().record(h._ref_t)
h.CVode().active(use_cvode)

h.finitialize(-65)

# Run simulation in chunks of size chunk_size
for chunk_num in range(num_chunks):
	
	# Get start and stop times for this chunk
	chunk_start_time = chunk_num * chunk_size
	chunk_stop_time = (chunk_num + 1) * chunk_size
	
	# If NEURONs h.t not equal to our chunk start time, then make them equal
	if use_cvode:
		if h.t != chunk_start_time:
			h.t = chunk_start_time
			
			# Re-initialize
			h.CVode().re_init()
		
		# Create event so simulation stops at chunk_end_time
		h.CVode().event(chunk_stop_time)
	
	# Run simulation until chunk stop time
	h.continuerun(chunk_stop_time)
	
	# Use custom function to resample recording vectors to desired Dt and save them
	save_chunk_data()
	
	# Resize recording vectors
	h.frecord_init()

Code: Select all

python: /home/conda/feedstock_root/build_artifacts/neuron_1717659302460/work/src/nrncvode/netcvode.cpp:2269: int NetCvode::global_microstep(): Assertion `tdiff == 0.0 || (gcv_->tstop_begin_ <= tt && tt <= gcv_->tstop_end_)' failed.
Aborted (core dumped)

Code: Select all

...
	# If the difference between h.t and chunk_start_time is greater than Dt, set them equal to each other.
	if use_cvode:
		if abs(h.t - chunk_start_time) > Dt:
			h.t = chunk_start_time
			
			# Re-initialize
			h.CVode().re_init()
		
		# Create event so simulation stops at chunk_end_time
		h.CVode().event(chunk_stop_time)
...