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 #####
