def start(): """ Initialize Arrays """ global center_arrays center_arrays = {} for i, size_name in enumerate(size_names): center_arrays[size_name] = mp_array('d', len(frame_range))
def np_array_backed_by_mp_array( shape: Sequence[int], dtype) -> Tuple[np.ndarray, mp_array]: """Returns a np_array backed by a multiproceessing.Array buffer.""" ctype_type = np.ctypeslib.as_ctypes(np.empty((1,), dtype=np.dtype(dtype))).__class__ length = int(np.product(shape)) # the cast to int is required by multiprocessing.Array. backing_array = mp_array(ctype_type, length) unshaped_np_array = np.frombuffer(backing_array.get_obj(), dtype) shaped_np_array = unshaped_np_array.reshape(shape) return shaped_np_array, backing_array
def test_wrapped_shmem_numpy_array(nitems: int = 10): """ Try to share a numpy array based on a multiprocessing Array object. The array object is wrapped in a container class and passed to the worker process. The worker process reconstitutes the numpy array from that memory buffer and writes to the reconstituted numpy array. Writes in the worker process should be visible in the parent process. """ buffer = mp_array(ctypes.c_uint8, nitems) array = _decode_array_to_numpy_array(buffer) array.fill(0) _start_process_to_test_shmem(array_holder=TestWrappedArray(buffer), decoder=_decode_wrapped_array_to_numpy_array, nitems=nitems) for ix in range(nitems): assert array[ix] == ix
if "low_mass" in directory: azimuthal_profile /= (0.3) # low-mass case maxima_over_time[i] = np.percentile(azimuthal_profile, 90) minima_over_time[i] = np.percentile(azimuthal_profile, 5) contrasts_over_time[i] = maxima_over_time[i] / minima_over_time[i] differences_over_time[i] = maxima_over_time[i] - minima_over_time[i] print i, frame, differences_over_time[i], maxima_over_time[ i], minima_over_time[i], contrasts_over_time[i] ############################################################################### maxima_over_time = mp_array("d", 10 * len(util.get_frame_range(frame_ranges[0]))) minima_over_time = mp_array("d", 10 * len(util.get_frame_range(frame_ranges[0]))) contrasts_over_time = mp_array("d", 10 * len(util.get_frame_range(frame_ranges[0]))) differences_over_time = mp_array( "d", 10 * len(util.get_frame_range(frame_ranges[0]))) ############################################################################### ##### PLOTTING ##### colors = ['k', 'cornflowerblue', 'darkorange', 'r', 'purple'] labelsize = 19 size = 100 alpha = 0.8
threshold=threshold, sliver_width=sliver_width) # Convert to degrees extent *= (180.0 / np.pi) # Store (extents[grain_i])[i] = extent ############################################################################### # Data extents = [] for i, grain in enumerate(grain_sizes): extents.append(mp_array("f", len(frame_range))) for grain_i, grain in enumerate(grain_sizes): directory = "../%s-size" % grain pool_args = [(grain_i, i, directory, frame) for i, frame in enumerate(frame_range)] p = Pool(num_cores) p.map(get_extent, pool_args) p.terminate() ##### PLOTTING ##### colors = [ '#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf'
print "%d, %.2f, %.3f" % (frame, max_density, min_vortensity) #return max_density, min_vortensity maximum_densities[i] = max_density minimum_vortensities[i] = min_vortensity ## Use These Frames ## rate = 5 # 5 works better, but is very slow start_of_vortex = 0 max_frame = util.find_max_frame() if max_frame > 6000: max_frame = np.max([3000, 1.5 * int(mass_taper)]) frame_range = range(start_of_vortex, max_frame, rate) maximum_densities = mp_array("d", len(frame_range)) minimum_vortensities = mp_array("d", len(frame_range)) #for i, frame in enumerate(frame_range): # find_extrema(i, frame) pool_args = [(i, frame) for i, frame in enumerate(frame_range)] p = Pool(10) p.map(find_extrema, pool_args) p.terminate() ## Smooth Each Array ## kernel_size = 5 smoothed_maximum_densities = smooth(maximum_densities, kernel_size)
left_theta = theta[left_index] * (180.0 / np.pi) right_theta = theta[right_index] * (180.0 / np.pi) center_theta = left_theta + (right_theta - left_theta) / 2.0 peak_theta = theta[peak_phi_i] * (180.0 / np.pi) peak_offset = peak_theta - center_theta # Store in mp_array peak_offsets[i] = peak_offset ############################################################################### ##### PLOTTING ##### peak_offsets = mp_array("d", len(frame_range)) def make_plot(show = False): fig = plot.figure(figsize = (7, 5), dpi = dpi) ax = fig.add_subplot(111) # Get Data if num_cores == 1: if measure: for i, frame in enumerate(frame_range): measure_peak_offset((i, frame, threshold)) else: for i, frame in enumerate(frame_range): get_peak_offset((i, frame)) else: # Pool
# Calculate and store total mass total_mass = np.sum(density_annulus) total_masses[i] = total_mass ############################################################################### ### Get Data ### if num_cores == 1: total_masses = np.zeros(len(frame_range)) for (i, frame) in enumerate(frame_range): get_total_mass(i, frame) else: # Multi-Core! total_masses = mp_array("d", len(frame_range)) pool_args = [(i, frame) for (i, frame) in enumerate(frame_range)] # Pool p = Pool(num_cores) p.map(get_total_mass, pool_args) p.terminate() ##### PLOTTING ##### def make_plot(show=False): # Set up figure fig = plot.figure(figsize=(7, 6), dpi=dpi) ax = fig.add_subplot(111)
# Add up Angular Momentum Excess total_angular_momentum = np.sum(rad[:, None] * angular_momentum * dr * dtheta) excess_angular_momentum_over_time[i] = total_angular_momentum print i, frame, angular_momentum_over_time[ i], excess_angular_momentum_over_time[i] ## Use These Frames ## rate = 1 # 5 works better, but is very slow start = 50 max_frame = 100 #util.find_max_frame() #frame_range = np.array(range(start, max_frame + 1, rate)) angular_momentum_over_time = mp_array("d", len(frame_range)) excess_angular_momentum_over_time = mp_array("d", len(frame_range)) for i, frame in enumerate(frame_range): get_angular_momentum((i, frame)) pool_args = [(i, frame) for i, frame in enumerate(frame_range)] #p = Pool(num_cores) #p.map(get_extents, pool_args) #p.terminate() ##### Helper Functions ##### def make_patch_spines_invisible(ax):
####### Radii ####### rs[i] = peak_rad ## Use These Frames ## rate = 5 # 5 works better, but is very slow start = 10 max_frame = util.find_max_frame() frame_range = np.array(range(start, max_frame + 1, rate)) # Store These Values thresholds = [0.05, 0.1, 0.2, 0.5, 1.0] az_widths0 = mp_array("d", len(frame_range)) # 0.05 az_widths1 = mp_array("d", len(frame_range)) # 0.1 az_widths2 = mp_array("d", len(frame_range)) # 0.2 az_widths5 = mp_array("d", len(frame_range)) # 0.5 az_widths10 = mp_array("d", len(frame_range)) # 1.0 r_widths0 = mp_array("d", len(frame_range)) # 0.05 r_widths1 = mp_array("d", len(frame_range)) # 0.1 r_widths2 = mp_array("d", len(frame_range)) # 0.2 r_widths5 = mp_array("d", len(frame_range)) # 0.5 r_widths10 = mp_array("d", len(frame_range)) # 1.0 rs = mp_array("d", len(frame_range)) # Track 'r' for aspect ratio # Call Function Over Time pool_args = [(i, frame) for i, frame in enumerate(frame_range)]
# Print Update print "%d: %.4f" % (frame, total_vorticity) # Store Data vorticity_over_time[i] = total_vorticity ## Use These Frames ## rate = 10 # 5 works better, but is very slow start = 10 max_frame = util.find_max_frame() frame_range = np.array(range(start, max_frame + 1, rate)) # Gather Here (with multiprocessing) vorticity_over_time = mp_array("d", len(frame_range)) pool_args = [(i, frame) for i, frame in enumerate(frame_range)] #for i, frame in enumerate(frame_range): # sum_vorticity((i, frame)) p = Pool(10) p.map(sum_vorticity, pool_args) p.terminate() ## Pickle to combine later ## pickle.dump( np.array(frame_range), open("integrated_disk_vorticity_frames_taper%d.p" % taper_time, "wb"))
peak_count = len(peaks) # Convert to degrees extent *= (180.0 / np.pi) print i, frame, extent, peak_count # Store extents[i] = extent peak_counts[i] = peak_count ############################################################################### # Data extents = mp_array("f", len(frame_range)) peak_counts = mp_array("f", len(frame_range)) pool_args = [(i, frame) for i, frame in enumerate(frame_range)] p = Pool(num_cores) p.map(get_extent, pool_args) p.terminate() ##### PLOTTING ##### colors = [ '#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf' ] colors = ['#d8db20', '#197229', '#519ba3',
azimuthal_extent_over_time[i] = azimuthal_extent * (180.0 / np.pi) radial_extent_over_time[i] = radial_extent / scale_height radial_peak_over_time[i] = radial_peak radial_peak_over_time_a[i] = radial_peak_a print i, frame, azimuthal_extent_over_time[i], radial_extent_over_time[ i], radial_peak_over_time[i], radial_peak_over_time_a[i] ## Use These Frames ## rate = 1 # 5 works better, but is very slow start = 50 max_frame = 100 #util.find_max_frame() #frame_range = np.array(range(start, max_frame + 1, rate)) azimuthal_extent_over_time = mp_array("d", len(frame_range)) radial_extent_over_time = mp_array("d", len(frame_range)) radial_peak_over_time = mp_array("d", len(frame_range)) radial_peak_over_time_a = mp_array("d", len(frame_range)) for i, frame in enumerate(frame_range): get_extents((i, frame)) pool_args = [(i, frame) for i, frame in enumerate(frame_range)] #p = Pool(num_cores) #p.map(get_extents, pool_args) #p.terminate() ##### Helper Functions #####
i, frame = args # Get data and measure extent intensity = util.read_data(frame, 'polar_intensity', fargo_par, id_number = id_number) extent, azimuthal_profile = az.get_extent(intensity, fargo_par, normalize = True, threshold = threshold, sliver_width = sliver_width) # Convert to degrees extent *= (180.0 / np.pi) # Store extents[i] = extent ############################################################################### # Data extents = mp_array("f", len(frame_range)) pool_args = [(i, frame) for i, frame in enumerate(frame_range)] p = Pool(num_cores) p.map(get_extent, pool_args) p.terminate() ##### PLOTTING ##### colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf'] colors = ['#d8db20', '#197229', '#519ba3', '#240f77'] # Ugly Yellow, Green, Slate Blue, Dark Blue
i], outer_rossby_rad_over_time[i] print i, frame, "Diff:", rossby_rad_difference_over_time[ i], inner_peak_difference_over_time[ i], outer_peak_difference_over_time[i] print i, frame, "Val: ", inner_rossby_value_over_time[ i], outer_rossby_value_over_time[i] #print i, frame, azimuthal_extent_over_time[i], radial_extent_over_time[i], radial_peak_over_time[i], radial_peak_over_time_a[i], contrasts_over_time[i] ## Use These Frames ## rate = 1 # 5 works better, but is very slow start = 50 max_frame = 100 #util.find_max_frame() #frame_range = np.array(range(start, max_frame + 1, rate)) inner_rossby_rad_over_time = mp_array("d", len(frame_range)) outer_rossby_rad_over_time = mp_array("d", len(frame_range)) peak_rad_over_time = mp_array("d", len(frame_range)) rossby_rad_difference_over_time = mp_array("d", len(frame_range)) inner_peak_difference_over_time = mp_array("d", len(frame_range)) outer_peak_difference_over_time = mp_array("d", len(frame_range)) inner_rossby_value_over_time = mp_array("d", len(frame_range)) outer_rossby_value_over_time = mp_array("d", len(frame_range)) #for i, frame in enumerate(frame_range): # get_rossby_criteria((i, frame)) pool_args = [(i, frame) for i, frame in enumerate(frame_range)]
track50[i] = m50 track75[i] = m75 track90[i] = m90 track99[i] = m99 # Print Update print "%d: %.4f, %.4f, %.4f, %.4f" % (frame, m50, m75, m90, m99) ## Use These Frames ## rate = 5 # 5 works better, but is very slow start = 10 max_frame = util.find_max_frame() frame_range = np.array(range(start, max_frame + 1, rate)) track50 = mp_array("d", len(frame_range)) track75 = mp_array("d", len(frame_range)) track90 = mp_array("d", len(frame_range)) track99 = mp_array("d", len(frame_range)) pool_args = [(i, frame) for i, frame in enumerate(frame_range)] p = Pool(10) p.map(get_quartiles, pool_args) p.terminate() ##### PLOTTING ##### # Plot Parameters linewidth = 4 fontsize = 14
averaged_vorticity = np.average(vorticity, axis=1) # Get Minima min_density = find_rossby_density(normalized_density, averaged_vorticity) # Print Update print "%d: %.3f, %.3f" % (frame, min_density, 1.0 / min_density) # Store Data gap_depth_over_time[i] = 1.0 / min_density ############################################################################### gap_depth_over_time = mp_array("d", 10 * len(util.get_frame_range(frame_ranges[0]))) ############################################################################### ##### PLOTTING ##### colors = ['k', 'cornflowerblue', 'darkorange', 'r', 'green', 'purple'] labelsize = 19 size = 100 rc['xtick.labelsize'] = labelsize rc['ytick.labelsize'] = labelsize def make_plot(show=False): # Set up figure
maxima_over_time[i] = np.percentile(azimuthal_profile, 90) minima_over_time[i] = np.percentile(azimuthal_profile, 5) contrasts_over_time[i] = maxima_over_time[i] / minima_over_time[i] differences_over_time[i] = maxima_over_time[i] - minima_over_time[i] print i, frame, differences_over_time[i], maxima_over_time[i], minima_over_time[i], contrasts_over_time[i] ## Use These Frames ## rate = 1 # 5 works better, but is very slow start = 50 max_frame = 100 #util.find_max_frame() #frame_range = np.array(range(start, max_frame + 1, rate)) maxima_over_time = mp_array("d", len(frame_range)) minima_over_time = mp_array("d", len(frame_range)) contrasts_over_time = mp_array("d", len(frame_range)) differences_over_time = mp_array("d", len(frame_range)) for i, frame in enumerate(frame_range): get_contrasts((i, frame)) pool_args = [(i, frame) for i, frame in enumerate(frame_range)] #p = Pool(num_cores) #p.map(get_extents, pool_args) #p.terminate() ##### Helper Functions #####
num_cores ) # default number of processes is multiprocessing.cpu_count() p.map(get_shift, pool_args) p.terminate() else: for i, frame in enumerate(frame_range): get_shift((i, frame, size_label, reference_label)) # Save Data frame_array_np = np.array(frame_range) shift_array_np = np.array(shift_array) theta_shift_array_np = np.array(theta_shift_array) pickle.dump(frame_array_np, open("../%s-size/frame_lookup.p" % size_label, 'w')) pickle.dump(shift_array_np, open("../%s-size/shift_lookup.p" % size_label, 'w')) pickle.dump(theta_shift_array_np, open("../%s-size/theta_lookup.p" % size_label, 'w')) ### Make each call ### for size_i, size_label_i in zip(sizes, size_labels): # Storage Arrays shift_array = mp_array("d", len(frame_range)) theta_shift_array = mp_array("d", len(frame_range)) # Save Data save_shifts(size_label_i, reference_label=reference_label)
rossby_number_over_time[i] = np.min(azimuthal_profile) rossby_number_over_time_98[i] = np.percentile(azimuthal_profile, 0.2) rossby_number_over_time_95[i] = np.percentile(azimuthal_profile, 0.5) print i, frame, rossby_number_over_time[i], rossby_number_over_time_98[ i], rossby_number_over_time_95[i] ## Use These Frames ## rate = 1 # 5 works better, but is very slow start = 50 max_frame = 100 #util.find_max_frame() #frame_range = np.array(range(start, max_frame + 1, rate)) rossby_number_over_time = mp_array("d", len(frame_range)) rossby_number_over_time_98 = mp_array("d", len(frame_range)) rossby_number_over_time_95 = mp_array("d", len(frame_range)) #maxima_over_time = mp_array("d", len(frame_range)) #minima_over_time = mp_array("d", len(frame_range)) #contrasts_over_time = mp_array("d", len(frame_range)) #for i, frame in enumerate(frame_range): # get_contrasts((i, frame)) pool_args = [(i, frame) for i, frame in enumerate(frame_range)] p = Pool(num_cores) p.map(get_contrasts, pool_args) p.terminate()
# Pickle pickle.dump(lifespans, open("lifespans.p", "wb")) pickle.dump(total_lifetime, open("lifetime.p", "wb")) ## Use These Frames ## rate = 10 # 5 works better, but is very slow start = 10 max_frame = util.find_max_frame() frame_range = np.array(range(start, max_frame + 1, rate)) #mass_over_time = np.zeros(len(frame_range)) #peak_over_time = np.zeros(len(frame_range)) mass_over_time = mp_array("d", len(frame_range)) peak_over_time = mp_array("d", len(frame_range)) #for i, frame in enumerate(frame_range): # get_excess_mass((i, frame)) pool_args = [(i, frame) for i, frame in enumerate(frame_range)] p = Pool(10) p.map(get_excess_mass, pool_args) p.terminate() max_mass = np.max(mass_over_time) max_peak = np.max(peak_over_time) ## Measure Lifetime ##
#vorticity, shift_c = shift_data(vorticity, fargo_par, reference_density = density) # Find minimum start_rad = min([peak_rad - 0.05, 1.5]) start_rad_i = np.searchsorted(rad, start_rad) # Is this necessary? end_rad_i = np.searchsorted(rad, 2.5) azimuthal_profile = vorticity[start_rad_i:end_rad_i] rossby_number_over_time[i] = np.percentile(azimuthal_profile, 0.25) print i, frame, rossby_number_over_time[i] ############################################################################### rossby_number_over_time = mp_array( "d", 10 * len(util.get_frame_range(frame_ranges[0]))) ############################################################################### ##### PLOTTING ##### colors = ['k', 'cornflowerblue', 'darkorange', 'r', 'green'] labelsize = 19 size = 100 rc['xtick.labelsize'] = labelsize rc['ytick.labelsize'] = labelsize def make_plot(show=False): # Set up figure
print i, frame, rad[front_i], radial_center, rad[ back_i], "Final Radial: Left, Center, Right" print i, frame, theta[left_i] * ( 180.0 / np.pi), azimuthal_center, theta[right_i] * ( 180.0 / np.pi), "Final Azimuthal: Left, Center, Right" #contrasts_over_time[i] = az.get_contrast(density, fargo_par) print i, frame, azimuthal_extent_over_time[i], radial_extent_over_time[ i], radial_peak_over_time[i] #print i, frame, azimuthal_extent_over_time[i], radial_extent_over_time[i], radial_peak_over_time[i], radial_peak_over_time_a[i], contrasts_over_time[i] ############################################################################### azimuthal_extent_over_time = mp_array( "d", 10 * len(util.get_frame_range(frame_ranges[0]))) radial_extent_over_time = mp_array( "d", 10 * len(util.get_frame_range(frame_ranges[0]))) radial_peak_over_time = mp_array( "d", 10 * len(util.get_frame_range(frame_ranges[0]))) ############################################################################### ##### PLOTTING ##### colors = ['k', 'cornflowerblue', 'darkorange', 'r', 'purple'] labelsize = 19 size = 100 alpha = 0.8 rc['xtick.labelsize'] = labelsize
inner_rossby_value_over_time[i] = inner_rossby_value outer_rossby_value_over_time[i] = outer_rossby_value print i, frame, "Rad: ", inner_rossby_rad_over_time[i], peak_rad_over_time[ i], outer_rossby_rad_over_time[i] print i, frame, "Diff:", rossby_rad_difference_over_time[ i], inner_peak_difference_over_time[ i], outer_peak_difference_over_time[i] print i, frame, "Val: ", inner_rossby_value_over_time[ i], outer_rossby_value_over_time[i] #print i, frame, azimuthal_extent_over_time[i], radial_extent_over_time[i], radial_peak_over_time[i], radial_peak_over_time_a[i], contrasts_over_time[i] ############################################################################### inner_rossby_rad_over_time = mp_array( "d", 10 * len(util.get_frame_range(frame_ranges[0]))) outer_rossby_rad_over_time = mp_array( "d", 10 * len(util.get_frame_range(frame_ranges[0]))) peak_rad_over_time = mp_array("d", 10 * len(util.get_frame_range(frame_ranges[0]))) rossby_rad_difference_over_time = mp_array( "d", 10 * len(util.get_frame_range(frame_ranges[0]))) inner_peak_difference_over_time = mp_array( "d", 10 * len(util.get_frame_range(frame_ranges[0]))) outer_peak_difference_over_time = mp_array( "d", 10 * len(util.get_frame_range(frame_ranges[0]))) inner_rossby_value_over_time = mp_array( "d", 10 * len(util.get_frame_range(frame_ranges[0]))) outer_rossby_value_over_time = mp_array(
def start(): """ Initialize Arrays """ global contrasts contrasts = mp_array('d', len(frame_range))
# Print Update print "%d: %.4f" % (frame, total_vorticity) # Store Data vorticity_over_time[i] = total_vorticity ## Use These Frames ## rate = 10 # 5 works better, but is very slow start = 10 max_frame = util.find_max_frame() frame_range = np.array(range(start, max_frame + 1, rate)) # Gather Here (with multiprocessing) vorticity_over_time = mp_array("d", len(frame_range)) pool_args = [(i, frame) for i, frame in enumerate(frame_range)] #for i, frame in enumerate(frame_range): # sum_vorticity((i, frame)) p = Pool(10) p.map(sum_vorticity, pool_args) p.terminate() ## Pickle to combine later ## pickle.dump(np.array(frame_range), open("integrated_disk_vorticity_frames_taper%d.p" % taper_time, "wb")) pickle.dump(np.array(vorticity_over_time), open("integrated_disk_vorticity_values_taper%d.p" % taper_time, "wb"))
if args.compare: kinetic_energy_over_time_compare[i] = kinetic_energy_compare ############################################################################### ## Use These Frames ## rate = 1 # 5 works better, but is very slow start = 50 max_frame = 100 #util.find_max_frame() #frame_range = np.array(range(start, max_frame + 1, rate)) #mass_over_time = np.zeros(len(frame_range)) #peak_over_time = np.zeros(len(frame_range)) kinetic_energy_over_time = mp_array("d", len(frame_range)) kinetic_energy_over_time_compare = mp_array("d", len(frame_range)) for i, frame in enumerate(frame_range): get_kinetic_energy((i, frame)) #pool_args = [(i, frame) for i, frame in enumerate(frame_range)] #p = Pool(num_cores) #p.map(get_kinetic_energy, pool_args) #p.terminate() #max_mass = np.max(kinetic_energy) #max_peak = np.max(peak_over_time)
i, frame = args # Get data and measure extent dust_density = util.read_data(frame, 'dust', fargo_par, id_number = id_number, directory = ".") extent = az.get_extent(dust_density, fargo_par, normalize = True, threshold = threshold, sliver_width = sliver_width) # Convert to degrees extent *= (180.0 / np.pi) # Store extents[i] = extent ############################################################################### # Data extents = mp_array("f", len(frame_range)) # Track 'r' for aspect ratio pool_args = [(i, frame) for i, frame in enumerate(frame_range)] p = Pool(num_cores) p.map(get_extent, pool_args) p.terminate() ##### PLOTTING ##### colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf'] def make_plot(show = False): fig = plot.figure(figsize = (7, 5), dpi = dpi) ax = fig.add_subplot(111)
amplitude_over_time[i] = amplitude / averagedDensity_zero[start_i + amplitude_i] width_over_time[i] = width / 2.0 print i, frame, amplitude_over_time[i], width_over_time[ i], left_r, amplitude_r, right_r ## Use These Frames ## rate = 1 # 5 works better, but is very slow start = 50 max_frame = 100 #util.find_max_frame() #frame_range = np.array(range(start, max_frame + 1, rate)) amplitude_over_time = mp_array("d", len(frame_range)) width_over_time = mp_array("d", len(frame_range)) #contrasts_over_time = mp_array("d", len(frame_range)) for i, frame in enumerate(frame_range): get_criteria((i, frame)) pool_args = [(i, frame) for i, frame in enumerate(frame_range)] #p = Pool(num_cores) #p.map(get_extents, pool_args) #p.terminate() ##### Helper Functions #####