From 81e589fcaae0497e75cb049927c76ac41769b6d3 Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Tue, 11 Oct 2022 12:09:55 -0400 Subject: [PATCH 01/93] initial commit of spectra preview sonification --- astronify/series/series.py | 72 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/astronify/series/series.py b/astronify/series/series.py index 0b74d30..cdd79ff 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -307,3 +307,75 @@ def write(self, filepath): self.server.shutdown() self.server.reinit(audio="portaudio") + +class SeriesPreviews(): + """ Previews (or snapshots) of 1d spectra by binning the data into + five equal pieces by assigning a sound to each piece. + """ + + def __init__(self, soniseries): + # Allows access to SoniSeries class methods and variables + self._soniseries = soniseries + + self.pitch_values = [300, 400, 500, 600, 700] + # Amplitudes will be stored as a % between 0-1 + self.amplitudes = np.zeros(5) + # TODO: Make robust + self.n_pitch_values = len(self.pitch_values) + + + def sonify_preview(self): + """ Perform the sonification of the preview """ + data = self._soniseries.data[self._soniseries.val_col] + xdata = np.asarray(self._soniseries.data[self._soniseries.time_col]) + transform = LinearStretch() + + pitch_array = data/max(data)#np.asarray(transform(data)) + #print(data) + #print(pitch_array) + bin_size = int(np.round(len(data) // self.n_pitch_values, 1)) + + total_area = np.trapz(pitch_array, xdata) + print('total area = ', total_area) + + pitch_bins = [pitch_array[i:i+bin_size] for i in range(0, len(pitch_array), bin_size)] + xdata_bins = [xdata[i:i+bin_size] for i in range(0, len(xdata), bin_size)] + + + print('PITCH_BINS') + print(pitch_bins) + + print('XDATA_BINS') + print(xdata_bins) + + std_vals = [] + for idx, (pitch_bin, x) in enumerate(zip(pitch_bins, xdata_bins)): + + std_vals.append(np.std(pitch_bin)) + + #self.amplitudes[idx] = np.trapz(pitch_bins, x)/total_area + #print(np.trapz(pitch_bin, x)) + + self.amplitudes = np.asarray(std_vals) / max(std_vals) + + print('AMPLITUDES') + print(self.amplitudes) + + + def play_preview(self): + + if self._soniseries.server.getIsBooted(): + self._soniseries.server.shutdown() + + self._soniseries.server.boot() + self._soniseries.server.start() + + self.duration = 1.0 + + #env = pyo.Linseg(list=[(0, 0), (0.01, 1), (duration - 0.1, 1), + # (duration - 0.05, 0.5), (duration - 0.005, 0)], + # mul=[self.gain for i in range(len(pitches))]).play( + # delay=list(delays), dur=duration) + MUL = list(self.amplitudes) + #print(MUL) + self.preview_streams = pyo.Sine(self.pitch_values, mul=MUL).out(dur=self.duration) \ No newline at end of file From e2bb7a508c16329ec3dc3e0ea5bc021c513261f7 Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Wed, 12 Oct 2022 11:30:04 -0400 Subject: [PATCH 02/93] . --- astronify/series/series.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index cdd79ff..2329a6b 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -328,13 +328,13 @@ def sonify_preview(self): """ Perform the sonification of the preview """ data = self._soniseries.data[self._soniseries.val_col] xdata = np.asarray(self._soniseries.data[self._soniseries.time_col]) - transform = LinearStretch() pitch_array = data/max(data)#np.asarray(transform(data)) #print(data) #print(pitch_array) bin_size = int(np.round(len(data) // self.n_pitch_values, 1)) + # total_area is no longer needed total_area = np.trapz(pitch_array, xdata) print('total area = ', total_area) @@ -356,7 +356,8 @@ def sonify_preview(self): #self.amplitudes[idx] = np.trapz(pitch_bins, x)/total_area #print(np.trapz(pitch_bin, x)) - self.amplitudes = np.asarray(std_vals) / max(std_vals) + self.amplitudes = [1., 1., 1., 1., 1.] + self.frequencies = np.asarray(std_vals) / max(std_vals) print('AMPLITUDES') print(self.amplitudes) @@ -376,6 +377,9 @@ def play_preview(self): # (duration - 0.05, 0.5), (duration - 0.005, 0)], # mul=[self.gain for i in range(len(pitches))]).play( # delay=list(delays), dur=duration) + #a = LFO(freq=lf, sharp=0, type=3, mul=100, add=300) MUL = list(self.amplitudes) #print(MUL) - self.preview_streams = pyo.Sine(self.pitch_values, mul=MUL).out(dur=self.duration) \ No newline at end of file + self.preview_streams = pyo.Sine(self.pitch_values, mul=MUL).out(dur=self.duration) + + return self.pitch_values \ No newline at end of file From 9ed0116211601b2d4196edc278be70a1ed75e9cf Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 12 Oct 2022 18:09:29 -0400 Subject: [PATCH 03/93] major edit on sonify_preview function, defines amplitude based on area-under-curves, tremolo values based on std dev --- astronify/series/series.py | 99 ++++++++++++++++++++++++-------------- 1 file changed, 64 insertions(+), 35 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 2329a6b..e108e0a 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -316,54 +316,83 @@ class SeriesPreviews(): def __init__(self, soniseries): # Allows access to SoniSeries class methods and variables self._soniseries = soniseries - + # Define the frequencies to use for each piece. self.pitch_values = [300, 400, 500, 600, 700] - # Amplitudes will be stored as a % between 0-1 - self.amplitudes = np.zeros(5) # TODO: Make robust self.n_pitch_values = len(self.pitch_values) - + # Amplitudes will be stored as a % between 0-1. + self.amplitudes = np.zeros(self.n_pitch_values) + # Tremolo values will be stored as a number, typically ranging from some small number + # (avoid 0.0, e.g., 0.1) through ~10. + self.tremolo_vals = np.zeros(self.n_pitch_values) + + def area_of_pieces(self, ydata_bins, xdata_bins): + """ + Given pieces of a series of 1D data, calculate the area-under-the-curve of each piece + such that the total area of all the pieces equals the total area of the entire curve. + """ + area_vals = [] + for idx, (ydata_bin, xdata_bin) in enumerate(zip(ydata_bins, xdata_bins)): + if idx < len(ydata_bins)-1: + # Then you need to include the first (x,y) point from the NEXT bin as well + # when calculating the trapezoidal area so the pieces all add up to the total. + ydata_bin.append(ydata_bins[idx+1][0]) + xdata_bin.append(xdata_bins[idx+1][0]) + area_vals.append(np.trapz(ydata_bin, xdata_bin)) + return area_vals def sonify_preview(self): - """ Perform the sonification of the preview """ - data = self._soniseries.data[self._soniseries.val_col] + """ + Make a "preview-style" sonification. The data is split into even pieces. Each piece + gets assigned a specific frequency. The amplitude is defined by the area under the curve + in this piece, normalized by the total area under the curve. The tremolo is defined + by the standard deviation of data in this piece, normalized by the maximum standard + deviation across all pieces. + """ + # Get a copy of the 'y' and 'x' data. + ydata = np.asarray(self._soniseries.data[self._soniseries.val_col]) xdata = np.asarray(self._soniseries.data[self._soniseries.time_col]) - pitch_array = data/max(data)#np.asarray(transform(data)) - #print(data) - #print(pitch_array) - bin_size = int(np.round(len(data) // self.n_pitch_values, 1)) - - # total_area is no longer needed - total_area = np.trapz(pitch_array, xdata) - print('total area = ', total_area) + # Normalize the y-data by the maximum to constrain values from 0-1. + ydata_norm = ydata/max(ydata) - pitch_bins = [pitch_array[i:i+bin_size] for i in range(0, len(pitch_array), bin_size)] + # Split the data into `n_pitch_values` equal-sized pieces. + bin_size = int(np.round(len(data) // self.n_pitch_values, 1)) + # Split the y-values into pieces. + ydata_bins = [ydata_norm[i:i+bin_size] for i in range(0, len(ydata_norm), bin_size)] + # Split the x-values into pieces. xdata_bins = [xdata[i:i+bin_size] for i in range(0, len(xdata), bin_size)] - - print('PITCH_BINS') - print(pitch_bins) - - print('XDATA_BINS') - print(xdata_bins) + # Calculate the total area under the curve, used to normalize the areas in each piece. + total_area = np.trapz(ydata_norm, xdata) + print('Total area = {0:0f}'.format(total_area)) + # Loop through each piece and calculate the standard deviation of the y-data + # and the area under the curve in each piece. std_vals = [] - for idx, (pitch_bin, x) in enumerate(zip(pitch_bins, xdata_bins)): - - std_vals.append(np.std(pitch_bin)) - - #self.amplitudes[idx] = np.trapz(pitch_bins, x)/total_area - #print(np.trapz(pitch_bin, x)) - - self.amplitudes = [1., 1., 1., 1., 1.] - self.frequencies = np.asarray(std_vals) / max(std_vals) - - print('AMPLITUDES') - print(self.amplitudes) - + for ydata_bin in ydata_bins: + # Calculate standard deviation and add to the list. + std_vals.append(np.std(ydata_bin)) + + # Calculate the area under the curve for each piece. + area_vals = self.area_of_pieces(ydata_bins, xdata_bins) + + # Normalize the standard deviations in each piece by this factor. + std_dev_norm = max(std_vals) + + # Set the amplitude of each pitch to the area under the curve normalized by the total + # area. + self.amplitudes = np.asarray(area_vals) / total_area + # Set the tremolo values based on the standard deviation of the piece normalized by the + # `std_dev_norm` factor. + ## TODO: Add some constraints, don't want to go much larger than ~10 and want to avoid + ## tremolo values of 0 (aim for a minimum of no less than ~0.1?) + self.tremolo_vals = np.asarray(std_vals) / std_dev_norm def play_preview(self): + """ + Play the sound of a "preview-style" sonification. + """ if self._soniseries.server.getIsBooted(): self._soniseries.server.shutdown() @@ -382,4 +411,4 @@ def play_preview(self): #print(MUL) self.preview_streams = pyo.Sine(self.pitch_values, mul=MUL).out(dur=self.duration) - return self.pitch_values \ No newline at end of file + return self.pitch_values From 8fa6db013ae93ad669bb362dd1e9ccca9f0a6a72 Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Wed, 12 Oct 2022 11:45:38 -0400 Subject: [PATCH 04/93] . --- astronify/series/series.py | 1 + 1 file changed, 1 insertion(+) diff --git a/astronify/series/series.py b/astronify/series/series.py index e108e0a..d0e41bc 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -130,6 +130,7 @@ def __init__(self, data, time_col="time", val_col="flux"): self.note_spacing = 0.01 # spacing between notes in seconds self.gain = 0.05 # default gain in the generated sine wave. pyo multiplier, -1 to 1. self.pitch_mapper = PitchMap(data_to_pitch) + self.preview_object = SeriesPreviews() self._init_pyo() From 78e8805bb6b8091af87a497563b69eeca1a52956 Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Wed, 12 Oct 2022 18:15:18 -0400 Subject: [PATCH 05/93] connecting classes --- astronify/series/series.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index d0e41bc..25d3146 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -130,7 +130,7 @@ def __init__(self, data, time_col="time", val_col="flux"): self.note_spacing = 0.01 # spacing between notes in seconds self.gain = 0.05 # default gain in the generated sine wave. pyo multiplier, -1 to 1. self.pitch_mapper = PitchMap(data_to_pitch) - self.preview_object = SeriesPreviews() + self.preview_object = SeriesPreviews(self) self._init_pyo() @@ -401,7 +401,7 @@ def play_preview(self): self._soniseries.server.boot() self._soniseries.server.start() - self.duration = 1.0 + self.duration = 2.0 #env = pyo.Linseg(list=[(0, 0), (0.01, 1), (duration - 0.1, 1), # (duration - 0.05, 0.5), (duration - 0.005, 0)], @@ -410,6 +410,12 @@ def play_preview(self): #a = LFO(freq=lf, sharp=0, type=3, mul=100, add=300) MUL = list(self.amplitudes) #print(MUL) - self.preview_streams = pyo.Sine(self.pitch_values, mul=MUL).out(dur=self.duration) + # self.preview_streams = pyo.Sine([100, 100], add=10) + + # a = pyo.LFO(freq=self.preview_streams, sharp=10, type=3, mul=100, add=1000)#add is the frequency input value (fundamental freq.) + #b = pyo.SineLoop(freq=a, feedback=0, mul=.1).out() - return self.pitch_values + lf = pyo.Sine([300, 400], mul=1, add=10)## Our target variable is mul as the LFO frequency (from 0-flat to different stages) + a = pyo.LFO(freq=lf, sharp=10, type=3, mul=100, add=1000)#add is the frequency input value (fundamental freq.) + b = pyo.SineLoop(freq=a, feedback=0, mul=.1).out() + return self.pitch_values, self.frequencies From 2c01180ed7b41e0dcb189d9dc789aefd049ed4df Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Wed, 12 Oct 2022 19:00:46 -0400 Subject: [PATCH 06/93] updating play() with layered pitches that are delayed at different times --- astronify/series/series.py | 48 +++++++++++++++++++++++--------------- 1 file changed, 29 insertions(+), 19 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 25d3146..0a94924 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -337,8 +337,9 @@ def area_of_pieces(self, ydata_bins, xdata_bins): if idx < len(ydata_bins)-1: # Then you need to include the first (x,y) point from the NEXT bin as well # when calculating the trapezoidal area so the pieces all add up to the total. - ydata_bin.append(ydata_bins[idx+1][0]) - xdata_bin.append(xdata_bins[idx+1][0]) + list(ydata_bin).append(ydata_bins[idx+1][0]) + list(xdata_bin).append(xdata_bins[idx+1][0]) + area_vals.append(np.trapz(ydata_bin, xdata_bin)) return area_vals @@ -358,7 +359,7 @@ def sonify_preview(self): ydata_norm = ydata/max(ydata) # Split the data into `n_pitch_values` equal-sized pieces. - bin_size = int(np.round(len(data) // self.n_pitch_values, 1)) + bin_size = int(np.round(len(xdata) // self.n_pitch_values, 1)) # Split the y-values into pieces. ydata_bins = [ydata_norm[i:i+bin_size] for i in range(0, len(ydata_norm), bin_size)] # Split the x-values into pieces. @@ -389,10 +390,18 @@ def sonify_preview(self): ## TODO: Add some constraints, don't want to go much larger than ~10 and want to avoid ## tremolo values of 0 (aim for a minimum of no less than ~0.1?) self.tremolo_vals = np.asarray(std_vals) / std_dev_norm + print(self.tremolo_vals) + print(self.amplitudes) + print(self.pitch_values) + def play_preview(self): - """ - Play the sound of a "preview-style" sonification. + """ Play the sound of a "preview-style" sonification. + + The assigned pitch for each section of the spectra will begin + to play, with the calculated amplitude and frequency, one + at a time until all pitches are playing together for the full + audio preview of the spectra. """ if self._soniseries.server.getIsBooted(): @@ -403,19 +412,20 @@ def play_preview(self): self.duration = 2.0 - #env = pyo.Linseg(list=[(0, 0), (0.01, 1), (duration - 0.1, 1), - # (duration - 0.05, 0.5), (duration - 0.005, 0)], - # mul=[self.gain for i in range(len(pitches))]).play( - # delay=list(delays), dur=duration) - #a = LFO(freq=lf, sharp=0, type=3, mul=100, add=300) - MUL = list(self.amplitudes) - #print(MUL) - # self.preview_streams = pyo.Sine([100, 100], add=10) + factor = 10 + + lfo1 = pyo.Sine(float(self.tremolo_vals[0]*factor), 0, float(self.amplitudes[0]), 0) + lfo2 = pyo.Sine(float(self.tremolo_vals[1]*factor), 0, float(self.amplitudes[1]), 0) + lfo3 = pyo.Sine(float(self.tremolo_vals[2]*factor), 0, float(self.amplitudes[2]), 0) + lfo4 = pyo.Sine(float(self.tremolo_vals[3]*factor), 0, float(self.amplitudes[3]), 0) + lfo5 = pyo.Sine(float(self.tremolo_vals[4]*factor), 0, float(self.amplitudes[4]), 0) + + sine1 = pyo.Sine(freq=self.pitch_values[0], mul=lfo1).out(dur=4.0) - # a = pyo.LFO(freq=self.preview_streams, sharp=10, type=3, mul=100, add=1000)#add is the frequency input value (fundamental freq.) - #b = pyo.SineLoop(freq=a, feedback=0, mul=.1).out() + sine2 = pyo.Sine(freq=self.pitch_values[1], mul=lfo2).out(delay=0.5, dur=3.5) + + sine3 = pyo.Sine(freq=self.pitch_values[2], mul=lfo3).out(delay=1.0, dur=3.0) + + sine4 = pyo.Sine(freq=self.pitch_values[3], mul=lfo4).out(delay=1.5, dur=2.5) - lf = pyo.Sine([300, 400], mul=1, add=10)## Our target variable is mul as the LFO frequency (from 0-flat to different stages) - a = pyo.LFO(freq=lf, sharp=10, type=3, mul=100, add=1000)#add is the frequency input value (fundamental freq.) - b = pyo.SineLoop(freq=a, feedback=0, mul=.1).out() - return self.pitch_values, self.frequencies + sine5 = pyo.Sine(freq=self.pitch_values[4], mul=lfo5).out(delay=2.0, dur=2.0) From 4ef0c86a707f14079fa979fb688d5e845937ff4d Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Wed, 12 Oct 2022 19:19:55 -0400 Subject: [PATCH 07/93] multiplying amplitude by factor to increase vol --- astronify/series/series.py | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 0a94924..1d4edbf 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -390,9 +390,6 @@ def sonify_preview(self): ## TODO: Add some constraints, don't want to go much larger than ~10 and want to avoid ## tremolo values of 0 (aim for a minimum of no less than ~0.1?) self.tremolo_vals = np.asarray(std_vals) / std_dev_norm - print(self.tremolo_vals) - print(self.amplitudes) - print(self.pitch_values) def play_preview(self): @@ -414,18 +411,21 @@ def play_preview(self): factor = 10 - lfo1 = pyo.Sine(float(self.tremolo_vals[0]*factor), 0, float(self.amplitudes[0]), 0) - lfo2 = pyo.Sine(float(self.tremolo_vals[1]*factor), 0, float(self.amplitudes[1]), 0) - lfo3 = pyo.Sine(float(self.tremolo_vals[2]*factor), 0, float(self.amplitudes[2]), 0) - lfo4 = pyo.Sine(float(self.tremolo_vals[3]*factor), 0, float(self.amplitudes[3]), 0) - lfo5 = pyo.Sine(float(self.tremolo_vals[4]*factor), 0, float(self.amplitudes[4]), 0) + lfo1 = pyo.Sine(float(self.tremolo_vals[0]*factor), 0, float(self.amplitudes[0])*factor, 0) + lfo2 = pyo.Sine(float(self.tremolo_vals[1]*factor), 0, float(self.amplitudes[1])*factor, 0) + lfo3 = pyo.Sine(float(self.tremolo_vals[2]*factor), 0, float(self.amplitudes[2])*factor, 0) + lfo4 = pyo.Sine(float(self.tremolo_vals[3]*factor), 0, float(self.amplitudes[3])*factor, 0) + lfo5 = pyo.Sine(float(self.tremolo_vals[4]*factor), 0, float(self.amplitudes[4])*factor, 0) - sine1 = pyo.Sine(freq=self.pitch_values[0], mul=lfo1).out(dur=4.0) + self.stream1 = pyo.Sine(freq=self.pitch_values[0], mul=lfo1).out(dur=4.0) - sine2 = pyo.Sine(freq=self.pitch_values[1], mul=lfo2).out(delay=0.5, dur=3.5) + self.stream2 = pyo.Sine(freq=self.pitch_values[1], mul=lfo2).out(delay=0.5, dur=3.5) - sine3 = pyo.Sine(freq=self.pitch_values[2], mul=lfo3).out(delay=1.0, dur=3.0) + self.stream3 = pyo.Sine(freq=self.pitch_values[2], mul=lfo3).out(delay=1.0, dur=3.0) - sine4 = pyo.Sine(freq=self.pitch_values[3], mul=lfo4).out(delay=1.5, dur=2.5) + self.stream4 = pyo.Sine(freq=self.pitch_values[3], mul=lfo4).out(delay=1.5, dur=2.5) - sine5 = pyo.Sine(freq=self.pitch_values[4], mul=lfo5).out(delay=2.0, dur=2.0) + self.stream5 = pyo.Sine(freq=self.pitch_values[4], mul=lfo5).out(delay=2.0, dur=2.0) + + #self.preview_streams = pyo.Sine(self.pitch_values, mul=2).out(dur=10) + #self.streams = pyo.Sine([400,500], mul=.2).out(dur=2.0) \ No newline at end of file From b982c88978f66a1d93953632dcbe5fa9bd1ab150 Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Wed, 12 Oct 2022 19:30:37 -0400 Subject: [PATCH 08/93] some updates to duration and delay periods --- astronify/series/series.py | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 1d4edbf..4e55b9e 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -406,10 +406,16 @@ def play_preview(self): self._soniseries.server.boot() self._soniseries.server.start() - - self.duration = 2.0 factor = 10 + + # `step` must go into `stop` 5 times, since we have 5 pitches + #start, stop, step = 0, 2.5, 0.5 + #self.delays = np.arange(start, stop, step) + self.delays = [0., 0.5, 1., 1.5, 2.0] + + # total_duration is in seconds + self.total_duration = 8.0 lfo1 = pyo.Sine(float(self.tremolo_vals[0]*factor), 0, float(self.amplitudes[0])*factor, 0) lfo2 = pyo.Sine(float(self.tremolo_vals[1]*factor), 0, float(self.amplitudes[1])*factor, 0) @@ -417,15 +423,15 @@ def play_preview(self): lfo4 = pyo.Sine(float(self.tremolo_vals[3]*factor), 0, float(self.amplitudes[3])*factor, 0) lfo5 = pyo.Sine(float(self.tremolo_vals[4]*factor), 0, float(self.amplitudes[4])*factor, 0) - self.stream1 = pyo.Sine(freq=self.pitch_values[0], mul=lfo1).out(dur=4.0) + self.stream1 = pyo.Sine(freq=self.pitch_values[0], mul=lfo1).out(dur=self.total_duration-self.delays[0]) - self.stream2 = pyo.Sine(freq=self.pitch_values[1], mul=lfo2).out(delay=0.5, dur=3.5) + self.stream2 = pyo.Sine(freq=self.pitch_values[1], mul=lfo2).out(delay=self.delays[1], dur=self.total_duration-self.delays[1]) - self.stream3 = pyo.Sine(freq=self.pitch_values[2], mul=lfo3).out(delay=1.0, dur=3.0) + self.stream3 = pyo.Sine(freq=self.pitch_values[2], mul=lfo3).out(delay=self.delays[2], dur=self.total_duration-self.delays[2]) - self.stream4 = pyo.Sine(freq=self.pitch_values[3], mul=lfo4).out(delay=1.5, dur=2.5) + self.stream4 = pyo.Sine(freq=self.pitch_values[3], mul=lfo4).out(delay=self.delays[3], dur=self.total_duration-self.delays[3]) - self.stream5 = pyo.Sine(freq=self.pitch_values[4], mul=lfo5).out(delay=2.0, dur=2.0) + self.stream5 = pyo.Sine(freq=self.pitch_values[4], mul=lfo5).out(delay=self.delays[4], dur=self.total_duration-self.delays[4]) #self.preview_streams = pyo.Sine(self.pitch_values, mul=2).out(dur=10) #self.streams = pyo.Sine([400,500], mul=.2).out(dur=2.0) \ No newline at end of file From cb7bca3d1a9614a50ffb6be31ab3598b7b242732 Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Thu, 13 Oct 2022 10:53:43 -0400 Subject: [PATCH 09/93] Constraint added to keep tremolo values at or below 15 --- astronify/series/series.py | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 4e55b9e..6818eed 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -364,7 +364,7 @@ def sonify_preview(self): ydata_bins = [ydata_norm[i:i+bin_size] for i in range(0, len(ydata_norm), bin_size)] # Split the x-values into pieces. xdata_bins = [xdata[i:i+bin_size] for i in range(0, len(xdata), bin_size)] - + print(xdata_bins) # Calculate the total area under the curve, used to normalize the areas in each piece. total_area = np.trapz(ydata_norm, xdata) print('Total area = {0:0f}'.format(total_area)) @@ -373,6 +373,7 @@ def sonify_preview(self): # and the area under the curve in each piece. std_vals = [] for ydata_bin in ydata_bins: + # Calculate standard deviation and add to the list. std_vals.append(np.std(ydata_bin)) @@ -387,9 +388,10 @@ def sonify_preview(self): self.amplitudes = np.asarray(area_vals) / total_area # Set the tremolo values based on the standard deviation of the piece normalized by the # `std_dev_norm` factor. - ## TODO: Add some constraints, don't want to go much larger than ~10 and want to avoid - ## tremolo values of 0 (aim for a minimum of no less than ~0.1?) self.tremolo_vals = np.asarray(std_vals) / std_dev_norm + # Constraint added to keep tremolo values at or below 15, otherwise oscillations are + # more difficult to hear + self.tremolo_vals[self.tremolo_vals > 15] = 15 def play_preview(self): @@ -413,15 +415,17 @@ def play_preview(self): #start, stop, step = 0, 2.5, 0.5 #self.delays = np.arange(start, stop, step) self.delays = [0., 0.5, 1., 1.5, 2.0] - + # total_duration is in seconds self.total_duration = 8.0 - - lfo1 = pyo.Sine(float(self.tremolo_vals[0]*factor), 0, float(self.amplitudes[0])*factor, 0) - lfo2 = pyo.Sine(float(self.tremolo_vals[1]*factor), 0, float(self.amplitudes[1])*factor, 0) - lfo3 = pyo.Sine(float(self.tremolo_vals[2]*factor), 0, float(self.amplitudes[2])*factor, 0) - lfo4 = pyo.Sine(float(self.tremolo_vals[3]*factor), 0, float(self.amplitudes[3])*factor, 0) - lfo5 = pyo.Sine(float(self.tremolo_vals[4]*factor), 0, float(self.amplitudes[4])*factor, 0) + + print('TREMOLO') + print(self.tremolo_vals) + lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0])*factor, 0) + lfo2 = pyo.Sine(float(self.tremolo_vals[1]), 0, float(self.amplitudes[1])*factor, 0) + lfo3 = pyo.Sine(float(self.tremolo_vals[2]), 0, float(self.amplitudes[2])*factor, 0) + lfo4 = pyo.Sine(float(self.tremolo_vals[3]), 0, float(self.amplitudes[3])*factor, 0) + lfo5 = pyo.Sine(float(self.tremolo_vals[4]), 0, float(self.amplitudes[4])*factor, 0) self.stream1 = pyo.Sine(freq=self.pitch_values[0], mul=lfo1).out(dur=self.total_duration-self.delays[0]) From 95f2af5277372fe7b559f431c90dc1e619f97bbf Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Thu, 13 Oct 2022 10:59:58 -0400 Subject: [PATCH 10/93] added some todo items to preview_play --- astronify/series/series.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 6818eed..201703e 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -409,8 +409,10 @@ def play_preview(self): self._soniseries.server.boot() self._soniseries.server.start() + # TODO: Amplitude factor could be fed in as a "volume" setting factor = 10 + # TODO: Generalize the self.delays list # `step` must go into `stop` 5 times, since we have 5 pitches #start, stop, step = 0, 2.5, 0.5 #self.delays = np.arange(start, stop, step) @@ -418,9 +420,8 @@ def play_preview(self): # total_duration is in seconds self.total_duration = 8.0 - - print('TREMOLO') - print(self.tremolo_vals) + + # TODO: Make everything below iterable to it's cleaner and takes up less lines lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0])*factor, 0) lfo2 = pyo.Sine(float(self.tremolo_vals[1]), 0, float(self.amplitudes[1])*factor, 0) lfo3 = pyo.Sine(float(self.tremolo_vals[2]), 0, float(self.amplitudes[2])*factor, 0) @@ -437,5 +438,3 @@ def play_preview(self): self.stream5 = pyo.Sine(freq=self.pitch_values[4], mul=lfo5).out(delay=self.delays[4], dur=self.total_duration-self.delays[4]) - #self.preview_streams = pyo.Sine(self.pitch_values, mul=2).out(dur=10) - #self.streams = pyo.Sine([400,500], mul=.2).out(dur=2.0) \ No newline at end of file From 3810d617e9106c1ba5b4d20446e7462ee62bc786 Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Thu, 13 Oct 2022 11:10:56 -0400 Subject: [PATCH 11/93] Adding a "tremolo factor" which will multiply all tremolo vals by 10 --- astronify/series/series.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 201703e..f80ca13 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -364,7 +364,7 @@ def sonify_preview(self): ydata_bins = [ydata_norm[i:i+bin_size] for i in range(0, len(ydata_norm), bin_size)] # Split the x-values into pieces. xdata_bins = [xdata[i:i+bin_size] for i in range(0, len(xdata), bin_size)] - print(xdata_bins) + # Calculate the total area under the curve, used to normalize the areas in each piece. total_area = np.trapz(ydata_norm, xdata) print('Total area = {0:0f}'.format(total_area)) @@ -388,7 +388,9 @@ def sonify_preview(self): self.amplitudes = np.asarray(area_vals) / total_area # Set the tremolo values based on the standard deviation of the piece normalized by the # `std_dev_norm` factor. - self.tremolo_vals = np.asarray(std_vals) / std_dev_norm + # The final calculated tremolo values are multiplied by a factor of 10 for auditory + # purposes + self.tremolo_vals = (np.asarray(std_vals) / std_dev_norm)*10 # Constraint added to keep tremolo values at or below 15, otherwise oscillations are # more difficult to hear self.tremolo_vals[self.tremolo_vals > 15] = 15 @@ -421,6 +423,7 @@ def play_preview(self): # total_duration is in seconds self.total_duration = 8.0 + print(self.tremolo_vals) # TODO: Make everything below iterable to it's cleaner and takes up less lines lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0])*factor, 0) lfo2 = pyo.Sine(float(self.tremolo_vals[1]), 0, float(self.amplitudes[1])*factor, 0) From 6bbcd073946dbcbd64545cb8cb051f97261ce900 Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Fri, 14 Oct 2022 09:41:07 -0400 Subject: [PATCH 12/93] modulating amplitudes with inverse log; playing notes separately; --- astronify/series/series.py | 61 ++++++++++++++++++++++++++++++-------- 1 file changed, 48 insertions(+), 13 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index f80ca13..19e958a 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -375,6 +375,7 @@ def sonify_preview(self): for ydata_bin in ydata_bins: # Calculate standard deviation and add to the list. + num_range = max(ydata_bin) - min(ydata_bin) std_vals.append(np.std(ydata_bin)) # Calculate the area under the curve for each piece. @@ -385,12 +386,36 @@ def sonify_preview(self): # Set the amplitude of each pitch to the area under the curve normalized by the total # area. + print('area vals') + print(np.asarray(area_vals)) + print('TOTAL AREA') + print(total_area) self.amplitudes = np.asarray(area_vals) / total_area + print('amplitudes') + print(self.amplitudes) + + print('stdvals') + print(np.asarray(std_vals)) + print('stddevnorm') + print(std_dev_norm) + + if std_dev_norm == 0.0: std_dev_norm = 1.0 + # Set the tremolo values based on the standard deviation of the piece normalized by the # `std_dev_norm` factor. + + # TODO: Might be worth trying a different way of calculating the tremolo values other + # than the normalized standard dev. Maybe using RMS vals? + # To more accurately represent all forms of data. + # The final calculated tremolo values are multiplied by a factor of 10 for auditory # purposes + print('before factiring') + print((np.asarray(std_vals) / std_dev_norm)) self.tremolo_vals = (np.asarray(std_vals) / std_dev_norm)*10 + + print('TREMOLO VALS') + print(self.tremolo_vals) # Constraint added to keep tremolo values at or below 15, otherwise oscillations are # more difficult to hear self.tremolo_vals[self.tremolo_vals > 15] = 15 @@ -418,26 +443,36 @@ def play_preview(self): # `step` must go into `stop` 5 times, since we have 5 pitches #start, stop, step = 0, 2.5, 0.5 #self.delays = np.arange(start, stop, step) - self.delays = [0., 0.5, 1., 1.5, 2.0] + self.delays = [0., 2., 4., 6., 8.] # total_duration is in seconds self.total_duration = 8.0 - - print(self.tremolo_vals) + # TODO: Make everything below iterable to it's cleaner and takes up less lines - lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0])*factor, 0) - lfo2 = pyo.Sine(float(self.tremolo_vals[1]), 0, float(self.amplitudes[1])*factor, 0) - lfo3 = pyo.Sine(float(self.tremolo_vals[2]), 0, float(self.amplitudes[2])*factor, 0) - lfo4 = pyo.Sine(float(self.tremolo_vals[3]), 0, float(self.amplitudes[3])*factor, 0) - lfo5 = pyo.Sine(float(self.tremolo_vals[4]), 0, float(self.amplitudes[4])*factor, 0) + lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(1/np.abs(np.log(self.amplitudes[0]))), 0) if self.tremolo_vals[0] > 0 else 0.1 + lfo2 = pyo.Sine(float(self.tremolo_vals[1]), 0, float(1/np.abs(np.log(self.amplitudes[1]))), 0) if self.tremolo_vals[1] > 0 else 0.1 + lfo3 = pyo.Sine(float(self.tremolo_vals[2]), 0, float(1/np.abs(np.log(self.amplitudes[2]))), 0) if self.tremolo_vals[2] > 0 else 0.1 + lfo4 = pyo.Sine(float(self.tremolo_vals[3]), 0, float(1/np.abs(np.log(self.amplitudes[3]))), 0) if self.tremolo_vals[3] > 0 else 0.1 + lfo5 = pyo.Sine(float(self.tremolo_vals[4]), 0, float(1/np.abs(np.log(self.amplitudes[4]))), 0) if self.tremolo_vals[4] > 0 else 0.1 + + self.stream1 = pyo.Sine(freq=self.pitch_values[0], mul=lfo1).out(delay=self.delays[0], dur=2.0) + + self.stream2 = pyo.Sine(freq=self.pitch_values[1], mul=lfo2).out(delay=self.delays[1], dur=2.0) + + self.stream3 = pyo.Sine(freq=self.pitch_values[2], mul=lfo3).out(delay=self.delays[2], dur=2.0) + + self.stream4 = pyo.Sine(freq=self.pitch_values[3], mul=lfo4).out(delay=self.delays[3], dur=2.0) + + self.stream5 = pyo.Sine(freq=self.pitch_values[4], mul=lfo5).out(delay=self.delays[4], dur=2.0) - self.stream1 = pyo.Sine(freq=self.pitch_values[0], mul=lfo1).out(dur=self.total_duration-self.delays[0]) + # All together + self.stream6 = pyo.Sine(freq=self.pitch_values[0], mul=lfo1).out(delay=10, dur=4) - self.stream2 = pyo.Sine(freq=self.pitch_values[1], mul=lfo2).out(delay=self.delays[1], dur=self.total_duration-self.delays[1]) + self.stream7 = pyo.Sine(freq=self.pitch_values[1], mul=lfo2).out(delay=10, dur=4) - self.stream3 = pyo.Sine(freq=self.pitch_values[2], mul=lfo3).out(delay=self.delays[2], dur=self.total_duration-self.delays[2]) + self.stream8 = pyo.Sine(freq=self.pitch_values[2], mul=lfo3).out(delay=10, dur=4) - self.stream4 = pyo.Sine(freq=self.pitch_values[3], mul=lfo4).out(delay=self.delays[3], dur=self.total_duration-self.delays[3]) + self.stream9 = pyo.Sine(freq=self.pitch_values[3], mul=lfo4).out(delay=10, dur=4) - self.stream5 = pyo.Sine(freq=self.pitch_values[4], mul=lfo5).out(delay=self.delays[4], dur=self.total_duration-self.delays[4]) + self.stream10 = pyo.Sine(freq=self.pitch_values[4], mul=lfo5).out(delay=10, dur=4) From 792f6ce670a7c7bb01822883852d6f866d84a68d Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Fri, 14 Oct 2022 10:20:46 -0400 Subject: [PATCH 13/93] snapshots notebook --- notebooks/astronify-snapshots-hack.ipynb | 516 +++++++++++++++++++++++ 1 file changed, 516 insertions(+) create mode 100644 notebooks/astronify-snapshots-hack.ipynb diff --git a/notebooks/astronify-snapshots-hack.ipynb b/notebooks/astronify-snapshots-hack.ipynb new file mode 100644 index 0000000..c96da05 --- /dev/null +++ b/notebooks/astronify-snapshots-hack.ipynb @@ -0,0 +1,516 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "6acbafed", + "metadata": {}, + "outputs": [], + "source": [ + "from astronify.series import SoniSeries\n", + "from astropy.table import Table\n", + "from astropy.io import fits\n", + "\n", + "import numpy as np\n", + "\n", + "from pyo import *" + ] + }, + { + "cell_type": "markdown", + "id": "5e3b44e8", + "metadata": {}, + "source": [ + "### dummy data for testing SeriesPreview" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5bd74c81", + "metadata": {}, + "outputs": [], + "source": [ + "data_table = Table({\"time\": list(range(0, 15, 1)),\n", + " \"flux\": [0.3, 1.30, 0.3, 0.50, 0.5, 0.4, 10.3, 0.2, 0.3, 0.1, 0.4, 0.3, 1.2, 0.3, 1.1]})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bda1d4fd", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c025809", + "metadata": {}, + "outputs": [], + "source": [ + "# Call SoniSeries instance and feed it our data\n", + "data_soni = SoniSeries(data_table)\n", + "# Calling SeriesPreviews from SoniSeries object \n", + "data_soni_preview = data_soni.preview_object\n", + "\n", + "# Sonifying preview of our data + playing\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "644f4ca5", + "metadata": {}, + "outputs": [], + "source": [ + "lfo = Sine(10, 0, 0.91873589, 0)\n", + "Sine(freq=900, mul=lfo).out(dur=4.0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df70bb84", + "metadata": {}, + "outputs": [], + "source": [ + "data_table = Table({\"time\": list(range(0, 15, 1)),\n", + " \"flux\": [0.3, 20.30, 0.3, 0.50, 0.5, 0.4, 0.3, 0.2, 0.3, 0.1, 0.4, 0.3, 30.2, 0.3, 20.1]})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7e9924e9", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5b873f0", + "metadata": {}, + "outputs": [], + "source": [ + "np.sum([0.68211921, 0.03145695, 0.01655629, 0.01986755, 0.84271523])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f6e45c77", + "metadata": {}, + "outputs": [], + "source": [ + "# Call SoniSeries instance and feed it our data\n", + "data_soni = SoniSeries(data_table)\n", + "# Calling SeriesPreviews from SoniSeries object \n", + "data_soni_preview = data_soni.preview_object\n", + "\n", + "# Sonifying preview of our data + playing\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "35e668f9", + "metadata": {}, + "outputs": [], + "source": [ + "data_table = Table({\"time\": list(range(0, 15, 1)),\n", + " \"flux\": [0.3, -20.30, 0.3, 0.50, 0.5, 0.4, 0.3, 0.2, 0.3, 0.1, 0.4, 0.3, 30.2, 0.3, 20.1]})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e49103f1", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5158727c", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: We have a negative area in the first fluctuation (\"absorption\" line)\n", + "\n", + "# Call SoniSeries instance and feed it our data\n", + "data_soni = SoniSeries(data_table)\n", + "# Calling SeriesPreviews from SoniSeries object \n", + "data_soni_preview = data_soni.preview_object\n", + "\n", + "# Sonifying preview of our data + playing\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca540bf1", + "metadata": {}, + "outputs": [], + "source": [ + "x = list(range(0, 15, 1))\n", + "y = np.ones(15)\n", + "\n", + "data_table = Table({\"time\": x,\n", + " \"flux\": y})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fab274ab", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2e12110", + "metadata": {}, + "outputs": [], + "source": [ + "# Call SoniSeries instance and feed it our data\n", + "data_soni = SoniSeries(data_table)\n", + "# Calling SeriesPreviews from SoniSeries object \n", + "data_soni_preview = data_soni.preview_object\n", + "\n", + "# Sonifying preview of our data + playing\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cdfa7243", + "metadata": {}, + "outputs": [], + "source": [ + "x = list(range(0, 15, 1))\n", + "y = x\n", + "\n", + "data_table = Table({\"time\": x,\n", + " \"flux\": y})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "28df65ea", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6557b47e", + "metadata": {}, + "outputs": [], + "source": [ + "# Call SoniSeries instance and feed it our data\n", + "data_soni = SoniSeries(data_table)\n", + "# Calling SeriesPreviews from SoniSeries object \n", + "data_soni_preview = data_soni.preview_object\n", + "\n", + "# Sonifying preview of our data + playing\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "479caf84", + "metadata": {}, + "outputs": [], + "source": [ + "np.exp(amps[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d8fd9ec4", + "metadata": {}, + "outputs": [], + "source": [ + "amps = [0.02040816, 0.08163265, 0.14285714, 0.20408163, 0.26530612]\n", + "\n", + "lfo1 = Sine(10, 0, float(1/np.abs(np.log(amps[0]))), 0)\n", + "#lfo1 = Sine(10, 0, amps[0]*10, 0)\n", + "lfo2 = Sine(10, 0, amps[1], 0)\n", + "lfo3 = Sine(10, 0, amps[2], 0)\n", + "lfo4 = Sine(10, 0, amps[3], 0)\n", + "lfo5 = Sine(10, 0, float(1/np.abs(np.log(amps[4]))), 0)\n", + "#lfo5 = Sine(10, 0, amps[4]*10, 0)\n", + "\n", + "streams1 = Sine(freq=300, mul=lfo1).out(delay=0, dur=2.0)\n", + "streams2 = Sine(freq=300, mul=lfo5).out(delay=2.5, dur=4.0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "91ece8f7", + "metadata": {}, + "outputs": [], + "source": [ + "float(1/np.abs(np.log(amps[0]))), float(1/np.abs(np.log(amps[4])))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "488bcc85", + "metadata": {}, + "outputs": [], + "source": [ + "amps[0]*10, amps[4]*10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "57cf766a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "74339612", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a0973367", + "metadata": {}, + "outputs": [], + "source": [ + "data_table = Table({\"time\": list(range(0, 15, 1)),\n", + " \"flux\": [0.3, 0.30, 0.3, 0.30, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 040.4, 0.3]})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ebec7606", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a3236c14", + "metadata": {}, + "outputs": [], + "source": [ + "# TODO: Normalize range of sound so that it's comfortable to the human ears\n", + "# The sound in blue range is way too loud because the flat ranges are all 0.1 and \n", + "# blue is the only one with a Sine wave for the amp\n", + "\n", + "# Call SoniSeries instance and feed it our data\n", + "data_soni = SoniSeries(data_table)\n", + "# Calling SeriesPreviews from SoniSeries object \n", + "data_soni_preview = data_soni.preview_object\n", + "\n", + "# Sonifying preview of our data + playing\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "markdown", + "id": "7f6999ce", + "metadata": {}, + "source": [ + "### troubleshooting functionality above" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2db3eb27", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", + "\n", + "plt.axvspan(0,3, color='r', alpha=0.5, lw=0)\n", + "plt.axvspan(3,6, color='orange', alpha=0.5, lw=0)\n", + "plt.axvspan(6,9, color='y', alpha=0.5, lw=0)\n", + "plt.axvspan(9,12, color='g', alpha=0.5, lw=0)\n", + "plt.axvspan(12,15, color='royalblue', alpha=0.5, lw=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13ec8825", + "metadata": {}, + "outputs": [], + "source": [ + "tremolo_vals = [0.37796447, 0.37796447, 0.37796447, 1., 0.65465367]\n", + "amplitudes = [0.15909091, 0.21590909, 0.11363636, 0.13636364, 0.10227273]\n", + "pitches = [300, 400, 500, 600, 700]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f07eeffe", + "metadata": {}, + "outputs": [], + "source": [ + "s = Server().boot()\n", + "s.start()\n", + "\n", + "# TODO: probably iterate to create a list of LFOs \n", + "# based on the frequencies calculated\n", + "\n", + "factor = 10\n", + "\n", + "lfo1 = Sine(tremolo_vals[0]*factor, 0, amplitudes[0], 0)\n", + "lfo2 = Sine(tremolo_vals[1]*factor, 0, amplitudes[1], 0)\n", + "lfo3 = Sine(tremolo_vals[2]*factor, 0, amplitudes[2], 0)\n", + "lfo4 = Sine(tremolo_vals[3]*factor, 0, amplitudes[3], 0)\n", + "lfo5 = Sine(tremolo_vals[4]*factor, 0, amplitudes[4], 0)\n", + "\n", + "sine1 = Sine(freq=pitches[0], mul=lfo1).out(dur=4.0)\n", + " \n", + "sine2 = Sine(freq=pitches[1], mul=lfo2).out(delay=0.5, dur=3.5)\n", + "\n", + "sine3 = Sine(freq=pitches[2], mul=lfo3).out(delay=1.0, dur=3.0)\n", + "\n", + "sine4 = Sine(freq=pitches[3], mul=lfo4).out(delay=1.5, dur=2.5)\n", + "\n", + "sine5 = Sine(freq=pitches[4], mul=lfo5).out(delay=2.0, dur=2.0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a39bca37", + "metadata": {}, + "outputs": [], + "source": [ + "np.arange(0,2.5, 0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5c932d82", + "metadata": {}, + "outputs": [], + "source": [ + "s.stop()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d364183c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 15ae515648dea0940d52c4f6108e8352431a4b9c Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Fri, 14 Oct 2022 10:51:04 -0400 Subject: [PATCH 14/93] replacing std with the std error of a linear regression fit --- astronify/series/series.py | 9 +- notebooks/astronify-snapshots-hack.ipynb | 388 +++++++++++++++++++---- 2 files changed, 334 insertions(+), 63 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 19e958a..b449842 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -11,7 +11,7 @@ from inspect import signature, Parameter import numpy as np - +from scipy import stats from astropy.table import Table, MaskedColumn from astropy.time import Time @@ -372,11 +372,12 @@ def sonify_preview(self): # Loop through each piece and calculate the standard deviation of the y-data # and the area under the curve in each piece. std_vals = [] - for ydata_bin in ydata_bins: + for xdata_bin, ydata_bin in zip(xdata_bins, ydata_bins): # Calculate standard deviation and add to the list. - num_range = max(ydata_bin) - min(ydata_bin) - std_vals.append(np.std(ydata_bin)) + _, _, _, _, std_err = stats.linregress(xdata_bin, ydata_bin) + std_vals.append(std_err) + #std_vals.append(np.std(ydata_bin)) # Calculate the area under the curve for each piece. area_vals = self.area_of_pieces(ydata_bins, xdata_bins) diff --git a/notebooks/astronify-snapshots-hack.ipynb b/notebooks/astronify-snapshots-hack.ipynb index c96da05..b447cc4 100644 --- a/notebooks/astronify-snapshots-hack.ipynb +++ b/notebooks/astronify-snapshots-hack.ipynb @@ -2,10 +2,25 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "6acbafed", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "WxPython is not found for the current python version.\n", + "Pyo will use a minimal GUI toolkit written with Tkinter (if available).\n", + "This toolkit has limited functionnalities and is no more\n", + "maintained or updated. If you want to use all of pyo's\n", + "GUI features, you should install WxPython, available here:\n", + "http://www.wxpython.org/\n", + "\n" + ] + } + ], "source": [ "from astronify.series import SoniSeries\n", "from astropy.table import Table\n", @@ -26,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "5bd74c81", "metadata": {}, "outputs": [], @@ -37,10 +52,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "bda1d4fd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", @@ -54,10 +90,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "7c025809", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total area = 1.631068\n", + "area vals\n", + "[0.15533981 0.09223301 0.53398058 0.05825243 0.1407767 ]\n", + "TOTAL AREA\n", + "1.6310679611650483\n", + "amplitudes\n", + "[0.0952381 0.05654762 0.32738095 0.03571429 0.08630952]\n", + "stdvals\n", + "[0.05605342 0.00280267 0.28587246 0.01121068 0.04764541]\n", + "stddevnorm\n", + "0.28587246338515443\n", + "before factiring\n", + "[0.19607843 0.00980392 1. 0.03921569 0.16666667]\n", + "TREMOLO VALS\n", + "[ 1.96078431 0.09803922 10. 0.39215686 1.66666667]\n", + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], "source": [ "# Call SoniSeries instance and feed it our data\n", "data_soni = SoniSeries(data_table)\n", @@ -71,18 +132,7 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "644f4ca5", - "metadata": {}, - "outputs": [], - "source": [ - "lfo = Sine(10, 0, 0.91873589, 0)\n", - "Sine(freq=900, mul=lfo).out(dur=4.0)" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "df70bb84", "metadata": {}, "outputs": [], @@ -93,10 +143,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "7e9924e9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", @@ -110,20 +181,35 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "c5b873f0", - "metadata": {}, - "outputs": [], - "source": [ - "np.sum([0.68211921, 0.03145695, 0.01655629, 0.01986755, 0.84271523])" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "f6e45c77", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total area = 2.129139\n", + "area vals\n", + "[0.68211921 0.03145695 0.01655629 0.01986755 0.84271523]\n", + "TOTAL AREA\n", + "2.1291390728476824\n", + "amplitudes\n", + "[0.32037325 0.01477449 0.00777605 0.00933126 0.39580093]\n", + "stdvals\n", + "[0.38235117 0.00095588 0.00191176 0.00382351 0.47507133]\n", + "stddevnorm\n", + "0.47507133077358277\n", + "before factiring\n", + "[0.80482897 0.00201207 0.00402414 0.00804829 1. ]\n", + "TREMOLO VALS\n", + "[ 8.04828974 0.02012072 0.04024145 0.0804829 10. ]\n", + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], "source": [ "# Call SoniSeries instance and feed it our data\n", "data_soni = SoniSeries(data_table)\n", @@ -137,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "35e668f9", "metadata": {}, "outputs": [], @@ -148,10 +234,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "e49103f1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", @@ -165,10 +272,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "5158727c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total area = 0.784768\n", + "area vals\n", + "[-0.66225166 0.03145695 0.01655629 0.01986755 0.84271523]\n", + "TOTAL AREA\n", + "0.7847682119205299\n", + "amplitudes\n", + "[-0.84388186 0.04008439 0.02109705 0.02531646 1.07383966]\n", + "stdvals\n", + "[0.39382171 0.00095588 0.00191176 0.00382351 0.47507133]\n", + "stddevnorm\n", + "0.47507133077358277\n", + "before factiring\n", + "[0.82897384 0.00201207 0.00402414 0.00804829 1. ]\n", + "TREMOLO VALS\n", + "[ 8.28973843 0.02012072 0.04024145 0.0804829 10. ]\n", + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jmedina/Documents/forks/astronify/astronify/series/series.py:453: RuntimeWarning: invalid value encountered in log\n", + " lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(1/np.abs(np.log(self.amplitudes[0]))), 0) if self.tremolo_vals[0] > 0 else 0.1\n" + ] + } + ], "source": [ "# TODO: We have a negative area in the first fluctuation (\"absorption\" line)\n", "\n", @@ -184,7 +324,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "ca540bf1", "metadata": {}, "outputs": [], @@ -198,10 +338,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "fab274ab", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", @@ -215,10 +376,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "c2e12110", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total area = 14.000000\n", + "area vals\n", + "[2. 2. 2. 2. 2.]\n", + "TOTAL AREA\n", + "14.0\n", + "amplitudes\n", + "[0.14285714 0.14285714 0.14285714 0.14285714 0.14285714]\n", + "stdvals\n", + "[0. 0. 0. 0. 0.]\n", + "stddevnorm\n", + "0.0\n", + "before factiring\n", + "[0. 0. 0. 0. 0.]\n", + "TREMOLO VALS\n", + "[0. 0. 0. 0. 0.]\n", + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], "source": [ "# Call SoniSeries instance and feed it our data\n", "data_soni = SoniSeries(data_table)\n", @@ -232,7 +418,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "cdfa7243", "metadata": {}, "outputs": [], @@ -246,10 +432,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "28df65ea", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", @@ -263,10 +470,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "6557b47e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total area = 7.000000\n", + "area vals\n", + "[0.14285714 0.57142857 1. 1.42857143 1.85714286]\n", + "TOTAL AREA\n", + "6.999999999999999\n", + "amplitudes\n", + "[0.02040816 0.08163265 0.14285714 0.20408163 0.26530612]\n", + "stdvals\n", + "[0. 0. 0. 0. 0.]\n", + "stddevnorm\n", + "0.0\n", + "before factiring\n", + "[0. 0. 0. 0. 0.]\n", + "TREMOLO VALS\n", + "[0. 0. 0. 0. 0.]\n", + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], "source": [ "# Call SoniSeries instance and feed it our data\n", "data_soni = SoniSeries(data_table)\n", @@ -278,16 +510,6 @@ "data_soni_preview.play_preview()" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "479caf84", - "metadata": {}, - "outputs": [], - "source": [ - "np.exp(amps[0])" - ] - }, { "cell_type": "code", "execution_count": null, @@ -402,6 +624,54 @@ "### troubleshooting functionality above" ] }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3e3e6eb6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Slope: 1.0 \n", + "Intercept: 0.0\n" + ] + }, + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from scipy import stats\n", + "\n", + "x = np.arange(0, 10)\n", + "y = x\n", + "\n", + "slope, intercept, r_value, p_value, std_err = stats.linregress(x,y)\n", + "\n", + "print('Slope: ',slope,'\\nIntercept: ',intercept)\n", + "std_err" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "644f4ca5", + "metadata": {}, + "outputs": [], + "source": [ + "lfo = Sine(10, 0, 0.91873589, 0)\n", + "Sine(freq=900, mul=lfo).out(dur=4.0)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -508,7 +778,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.7" + "version": "3.8.13" } }, "nbformat": 4, From f9bdd1215b97696346dc7632edb9bcf62d4ce4b6 Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Fri, 14 Oct 2022 11:22:42 -0400 Subject: [PATCH 15/93] normalizing amplitudes with the max amp for more comfortable hearing range; setting default lfo to min amp for ranges with 0 freq --- astronify/series/series.py | 15 ++-- notebooks/astronify-snapshots-hack.ipynb | 96 +++++++++++++++++------- 2 files changed, 74 insertions(+), 37 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index b449842..1fa3e32 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -437,9 +437,6 @@ def play_preview(self): self._soniseries.server.boot() self._soniseries.server.start() - # TODO: Amplitude factor could be fed in as a "volume" setting - factor = 10 - # TODO: Generalize the self.delays list # `step` must go into `stop` 5 times, since we have 5 pitches #start, stop, step = 0, 2.5, 0.5 @@ -449,12 +446,14 @@ def play_preview(self): # total_duration is in seconds self.total_duration = 8.0 + default = float(min(self.amplitudes))#float((max(self.amplitudes) - min(self.amplitudes))/2) + self.amplitudes = [amp/max(self.amplitudes) for amp in self.amplitudes] # TODO: Make everything below iterable to it's cleaner and takes up less lines - lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(1/np.abs(np.log(self.amplitudes[0]))), 0) if self.tremolo_vals[0] > 0 else 0.1 - lfo2 = pyo.Sine(float(self.tremolo_vals[1]), 0, float(1/np.abs(np.log(self.amplitudes[1]))), 0) if self.tremolo_vals[1] > 0 else 0.1 - lfo3 = pyo.Sine(float(self.tremolo_vals[2]), 0, float(1/np.abs(np.log(self.amplitudes[2]))), 0) if self.tremolo_vals[2] > 0 else 0.1 - lfo4 = pyo.Sine(float(self.tremolo_vals[3]), 0, float(1/np.abs(np.log(self.amplitudes[3]))), 0) if self.tremolo_vals[3] > 0 else 0.1 - lfo5 = pyo.Sine(float(self.tremolo_vals[4]), 0, float(1/np.abs(np.log(self.amplitudes[4]))), 0) if self.tremolo_vals[4] > 0 else 0.1 + lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0]), 0) if self.tremolo_vals[0] > 0 else default + lfo2 = pyo.Sine(float(self.tremolo_vals[1]), 0, float(self.amplitudes[1]), 0) if self.tremolo_vals[1] > 0 else default + lfo3 = pyo.Sine(float(self.tremolo_vals[2]), 0, float(self.amplitudes[2]), 0) if self.tremolo_vals[2] > 0 else default + lfo4 = pyo.Sine(float(self.tremolo_vals[3]), 0, float(self.amplitudes[3]), 0) if self.tremolo_vals[3] > 0 else default + lfo5 = pyo.Sine(float(self.tremolo_vals[4]), 0, float(self.amplitudes[4]), 0) if self.tremolo_vals[4] > 0 else default self.stream1 = pyo.Sine(freq=self.pitch_values[0], mul=lfo1).out(delay=self.delays[0], dur=2.0) diff --git a/notebooks/astronify-snapshots-hack.ipynb b/notebooks/astronify-snapshots-hack.ipynb index b447cc4..a544c5a 100644 --- a/notebooks/astronify-snapshots-hack.ipynb +++ b/notebooks/astronify-snapshots-hack.ipynb @@ -132,7 +132,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 42, "id": "df70bb84", "metadata": {}, "outputs": [], @@ -143,17 +143,17 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 43, "id": "7e9924e9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 17, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" }, @@ -181,7 +181,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 44, "id": "f6e45c77", "metadata": {}, "outputs": [ @@ -223,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 39, "id": "35e668f9", "metadata": {}, "outputs": [], @@ -234,17 +234,17 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 40, "id": "e49103f1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 20, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" }, @@ -272,7 +272,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 41, "id": "5158727c", "metadata": {}, "outputs": [ @@ -299,14 +299,6 @@ "Pyo warning: Portmidi warning: no midi device found!\n", "Portmidi closed.\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jmedina/Documents/forks/astronify/astronify/series/series.py:453: RuntimeWarning: invalid value encountered in log\n", - " lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(1/np.abs(np.log(self.amplitudes[0]))), 0) if self.tremolo_vals[0] > 0 else 0.1\n" - ] } ], "source": [ @@ -418,7 +410,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 36, "id": "cdfa7243", "metadata": {}, "outputs": [], @@ -432,17 +424,17 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 37, "id": "28df65ea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 14, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" }, @@ -470,7 +462,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 38, "id": "6557b47e", "metadata": {}, "outputs": [ @@ -569,7 +561,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "id": "a0973367", "metadata": {}, "outputs": [], @@ -580,10 +572,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "id": "ebec7606", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", @@ -597,10 +610,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "id": "a3236c14", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total area = 1.096535\n", + "area vals\n", + "[0.01485149 0.01485149 0.01485149 0.01485149 1.00742574]\n", + "TOTAL AREA\n", + "1.0965346534653464\n", + "amplitudes\n", + "[0.01354402 0.01354402 0.01354402 0.01354402 0.91873589]\n", + "stdvals\n", + "[0. 0. 0. 0. 0.57306301]\n", + "stddevnorm\n", + "0.5730630147154454\n", + "before factiring\n", + "[0. 0. 0. 0. 1.]\n", + "TREMOLO VALS\n", + "[ 0. 0. 0. 0. 10.]\n", + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], "source": [ "# TODO: Normalize range of sound so that it's comfortable to the human ears\n", "# The sound in blue range is way too loud because the flat ranges are all 0.1 and \n", @@ -627,7 +665,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "3e3e6eb6", + "id": "94b16c0f", "metadata": {}, "outputs": [ { From 7d567fb99bdcfe7a4bdf8eb6ee334f84c87661f0 Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Fri, 14 Oct 2022 11:33:43 -0400 Subject: [PATCH 16/93] changing default lfo to 1.0 --- astronify/series/series.py | 6 ++-- notebooks/astronify-snapshots-hack.ipynb | 36 ++++++++++++------------ 2 files changed, 22 insertions(+), 20 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 1fa3e32..93d814d 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -340,7 +340,9 @@ def area_of_pieces(self, ydata_bins, xdata_bins): list(ydata_bin).append(ydata_bins[idx+1][0]) list(xdata_bin).append(xdata_bins[idx+1][0]) - area_vals.append(np.trapz(ydata_bin, xdata_bin)) + # Taking the absolute value so that emission lines and absorption lines + # have the same amplitude + area_vals.append(np.abs(np.trapz(ydata_bin, xdata_bin))) return area_vals def sonify_preview(self): @@ -446,7 +448,7 @@ def play_preview(self): # total_duration is in seconds self.total_duration = 8.0 - default = float(min(self.amplitudes))#float((max(self.amplitudes) - min(self.amplitudes))/2) + default = 1.0 #float(min(self.amplitudes))#float((max(self.amplitudes) - min(self.amplitudes))/2) self.amplitudes = [amp/max(self.amplitudes) for amp in self.amplitudes] # TODO: Make everything below iterable to it's cleaner and takes up less lines lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0]), 0) if self.tremolo_vals[0] > 0 else default diff --git a/notebooks/astronify-snapshots-hack.ipynb b/notebooks/astronify-snapshots-hack.ipynb index a544c5a..f8d5e33 100644 --- a/notebooks/astronify-snapshots-hack.ipynb +++ b/notebooks/astronify-snapshots-hack.ipynb @@ -132,7 +132,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 48, "id": "df70bb84", "metadata": {}, "outputs": [], @@ -143,17 +143,17 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 49, "id": "7e9924e9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 43, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" }, @@ -181,7 +181,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 50, "id": "f6e45c77", "metadata": {}, "outputs": [ @@ -223,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 45, "id": "35e668f9", "metadata": {}, "outputs": [], @@ -234,17 +234,17 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 46, "id": "e49103f1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 40, + "execution_count": 46, "metadata": {}, "output_type": "execute_result" }, @@ -272,7 +272,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 47, "id": "5158727c", "metadata": {}, "outputs": [ @@ -282,11 +282,11 @@ "text": [ "Total area = 0.784768\n", "area vals\n", - "[-0.66225166 0.03145695 0.01655629 0.01986755 0.84271523]\n", + "[0.66225166 0.03145695 0.01655629 0.01986755 0.84271523]\n", "TOTAL AREA\n", "0.7847682119205299\n", "amplitudes\n", - "[-0.84388186 0.04008439 0.02109705 0.02531646 1.07383966]\n", + "[0.84388186 0.04008439 0.02109705 0.02531646 1.07383966]\n", "stdvals\n", "[0.39382171 0.00095588 0.00191176 0.00382351 0.47507133]\n", "stddevnorm\n", @@ -410,7 +410,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 51, "id": "cdfa7243", "metadata": {}, "outputs": [], @@ -424,17 +424,17 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 52, "id": "28df65ea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 37, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" }, @@ -462,7 +462,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 53, "id": "6557b47e", "metadata": {}, "outputs": [ @@ -665,7 +665,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "94b16c0f", + "id": "0519a630", "metadata": {}, "outputs": [ { From 72d800bd20618da71b9efa090a928b2bda07e2d8 Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Fri, 14 Oct 2022 11:41:29 -0400 Subject: [PATCH 17/93] minor changes --- astronify/series/series.py | 2 +- notebooks/astronify-snapshots-hack.ipynb | 29 ++++++++++++++++++++++-- 2 files changed, 28 insertions(+), 3 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 93d814d..4132dc4 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -445,7 +445,7 @@ def play_preview(self): #self.delays = np.arange(start, stop, step) self.delays = [0., 2., 4., 6., 8.] - # total_duration is in seconds + # `total_duration` is in seconds self.total_duration = 8.0 default = 1.0 #float(min(self.amplitudes))#float((max(self.amplitudes) - min(self.amplitudes))/2) diff --git a/notebooks/astronify-snapshots-hack.ipynb b/notebooks/astronify-snapshots-hack.ipynb index f8d5e33..7f6919f 100644 --- a/notebooks/astronify-snapshots-hack.ipynb +++ b/notebooks/astronify-snapshots-hack.ipynb @@ -462,7 +462,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 54, "id": "6557b47e", "metadata": {}, "outputs": [ @@ -665,7 +665,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "0519a630", + "id": "63758df8", "metadata": {}, "outputs": [ { @@ -710,6 +710,31 @@ "Sine(freq=900, mul=lfo).out(dur=4.0)" ] }, + { + "cell_type": "code", + "execution_count": 56, + "id": "4c028d81", + "metadata": {}, + "outputs": [ + { + "ename": "PyoArgumentTypeError", + "evalue": "bad argument at position 0 to \"Cos\" (PyoObject expected, got )", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mPyoArgumentTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [56], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m lfo \u001b[38;5;241m=\u001b[39m \u001b[43mCos\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.91873589\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2\u001b[0m Sine(freq\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m900\u001b[39m, mul\u001b[38;5;241m=\u001b[39mlfo)\u001b[38;5;241m.\u001b[39mout(dur\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m4.0\u001b[39m)\n", + "File \u001b[0;32m~/miniconda3/envs/astronify38/lib/python3.8/site-packages/pyo-1.0.4-py3.8-macosx-10.9-x86_64.egg/pyo/lib/arithmetic.py:109\u001b[0m, in \u001b[0;36mCos.__init__\u001b[0;34m(self, input, mul, add)\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m, mul\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m, add\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m):\n\u001b[0;32m--> 109\u001b[0m \u001b[43mpyoArgsAssert\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43moOO\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmul\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43madd\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 110\u001b[0m PyoObject\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, mul, add)\n\u001b[1;32m 111\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_input \u001b[38;5;241m=\u001b[39m \u001b[38;5;28minput\u001b[39m\n", + "File \u001b[0;32m~/miniconda3/envs/astronify38/lib/python3.8/site-packages/pyo-1.0.4-py3.8-macosx-10.9-x86_64.egg/pyo/lib/_core.py:537\u001b[0m, in \u001b[0;36mpyoArgsAssert\u001b[0;34m(obj, format, *args)\u001b[0m\n\u001b[1;32m 535\u001b[0m name \u001b[38;5;241m=\u001b[39m obj\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\n\u001b[1;32m 536\u001b[0m err \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbad argument at position \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[38;5;124m to \u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m (\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m expected, got \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m)\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m--> 537\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m PyoArgumentTypeError(err \u001b[38;5;241m%\u001b[39m (i, name, expected, argtype))\n", + "\u001b[0;31mPyoArgumentTypeError\u001b[0m: bad argument at position 0 to \"Cos\" (PyoObject expected, got )" + ] + } + ], + "source": [ + "lfo = Cos(0, 0.91873589)\n", + "Sine(freq=900, mul=lfo).out(dur=4.0)" + ] + }, { "cell_type": "code", "execution_count": null, From 4f2e4cdb1b70222c8d7a35739c5467b1c58d9267 Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Fri, 14 Oct 2022 12:03:49 -0400 Subject: [PATCH 18/93] initial attempt at increasing amplitude for non-oscillating behavior. i.e. zero tremolo, non-zero amp --- astronify/series/series.py | 18 ++++++--- notebooks/astronify-snapshots-hack.ipynb | 49 ++++++++++++++---------- 2 files changed, 42 insertions(+), 25 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 4132dc4..7df230c 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -450,12 +450,20 @@ def play_preview(self): default = 1.0 #float(min(self.amplitudes))#float((max(self.amplitudes) - min(self.amplitudes))/2) self.amplitudes = [amp/max(self.amplitudes) for amp in self.amplitudes] + + a = pyo.Phasor(self.pitch_values[0], mul=np.pi*2) + b = pyo.Phasor(self.pitch_values[1], mul=np.pi*2) + c = pyo.Phasor(self.pitch_values[2], mul=np.pi*2) + d = pyo.Phasor(self.pitch_values[3], mul=np.pi*2) + e = pyo.Phasor(self.pitch_values[4], mul=np.pi*2) + + # TODO: Make everything below iterable to it's cleaner and takes up less lines - lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0]), 0) if self.tremolo_vals[0] > 0 else default - lfo2 = pyo.Sine(float(self.tremolo_vals[1]), 0, float(self.amplitudes[1]), 0) if self.tremolo_vals[1] > 0 else default - lfo3 = pyo.Sine(float(self.tremolo_vals[2]), 0, float(self.amplitudes[2]), 0) if self.tremolo_vals[2] > 0 else default - lfo4 = pyo.Sine(float(self.tremolo_vals[3]), 0, float(self.amplitudes[3]), 0) if self.tremolo_vals[3] > 0 else default - lfo5 = pyo.Sine(float(self.tremolo_vals[4]), 0, float(self.amplitudes[4]), 0) if self.tremolo_vals[4] > 0 else default + lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0]), 0) if self.tremolo_vals[0] > 0 else pyo.Cos(a, mul=float(self.amplitudes[0])) + lfo2 = pyo.Sine(float(self.tremolo_vals[1]), 0, float(self.amplitudes[1]), 0) if self.tremolo_vals[1] > 0 else pyo.Cos(b, mul=float(self.amplitudes[1])) + lfo3 = pyo.Sine(float(self.tremolo_vals[2]), 0, float(self.amplitudes[2]), 0) if self.tremolo_vals[2] > 0 else pyo.Cos(c, mul=float(self.amplitudes[2])) + lfo4 = pyo.Sine(float(self.tremolo_vals[3]), 0, float(self.amplitudes[3]), 0) if self.tremolo_vals[3] > 0 else pyo.Cos(d, mul=float(self.amplitudes[3])) + lfo5 = pyo.Sine(float(self.tremolo_vals[4]), 0, float(self.amplitudes[4]), 0) if self.tremolo_vals[4] > 0 else pyo.Cos(e, mul=float(self.amplitudes[4])) self.stream1 = pyo.Sine(freq=self.pitch_values[0], mul=lfo1).out(delay=self.delays[0], dur=2.0) diff --git a/notebooks/astronify-snapshots-hack.ipynb b/notebooks/astronify-snapshots-hack.ipynb index 7f6919f..afa6733 100644 --- a/notebooks/astronify-snapshots-hack.ipynb +++ b/notebooks/astronify-snapshots-hack.ipynb @@ -410,7 +410,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 73, "id": "cdfa7243", "metadata": {}, "outputs": [], @@ -424,17 +424,17 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 74, "id": "28df65ea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 52, + "execution_count": 74, "metadata": {}, "output_type": "execute_result" }, @@ -462,7 +462,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 77, "id": "6557b47e", "metadata": {}, "outputs": [ @@ -662,10 +662,22 @@ "### troubleshooting functionality above" ] }, + { + "cell_type": "code", + "execution_count": 72, + "id": "9d98f103", + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "a = Phasor([1000], mul=np.pi*2)\n", + "b = Cos(a, mul=.3).out(dur=2.0)" + ] + }, { "cell_type": "code", "execution_count": 6, - "id": "63758df8", + "id": "79ce5d91", "metadata": {}, "outputs": [ { @@ -712,26 +724,23 @@ }, { "cell_type": "code", - "execution_count": 56, - "id": "4c028d81", + "execution_count": 63, + "id": "e909499d", "metadata": {}, "outputs": [ { - "ename": "PyoArgumentTypeError", - "evalue": "bad argument at position 0 to \"Cos\" (PyoObject expected, got )", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mPyoArgumentTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn [56], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m lfo \u001b[38;5;241m=\u001b[39m \u001b[43mCos\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.91873589\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2\u001b[0m Sine(freq\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m900\u001b[39m, mul\u001b[38;5;241m=\u001b[39mlfo)\u001b[38;5;241m.\u001b[39mout(dur\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m4.0\u001b[39m)\n", - "File \u001b[0;32m~/miniconda3/envs/astronify38/lib/python3.8/site-packages/pyo-1.0.4-py3.8-macosx-10.9-x86_64.egg/pyo/lib/arithmetic.py:109\u001b[0m, in \u001b[0;36mCos.__init__\u001b[0;34m(self, input, mul, add)\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m, mul\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m, add\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m):\n\u001b[0;32m--> 109\u001b[0m \u001b[43mpyoArgsAssert\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43moOO\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmul\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43madd\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 110\u001b[0m PyoObject\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, mul, add)\n\u001b[1;32m 111\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_input \u001b[38;5;241m=\u001b[39m \u001b[38;5;28minput\u001b[39m\n", - "File \u001b[0;32m~/miniconda3/envs/astronify38/lib/python3.8/site-packages/pyo-1.0.4-py3.8-macosx-10.9-x86_64.egg/pyo/lib/_core.py:537\u001b[0m, in \u001b[0;36mpyoArgsAssert\u001b[0;34m(obj, format, *args)\u001b[0m\n\u001b[1;32m 535\u001b[0m name \u001b[38;5;241m=\u001b[39m obj\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\n\u001b[1;32m 536\u001b[0m err \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbad argument at position \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[38;5;124m to \u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m (\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m expected, got \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m)\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m--> 537\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m PyoArgumentTypeError(err \u001b[38;5;241m%\u001b[39m (i, name, expected, argtype))\n", - "\u001b[0;31mPyoArgumentTypeError\u001b[0m: bad argument at position 0 to \"Cos\" (PyoObject expected, got )" - ] + "data": { + "text/plain": [ + "< Instance of Sine class >" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "lfo = Cos(0, 0.91873589)\n", + "lfo = LFO(freq=0, type=3, mul=0.2, add=0) # tri\n", "Sine(freq=900, mul=lfo).out(dur=4.0)" ] }, From 0a59077029b7146e9c6d068a79216ad7c3917dad Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Fri, 14 Oct 2022 17:13:48 -0400 Subject: [PATCH 19/93] adding verbose and plotting keyword args to sonify_preview --- astronify/series/series.py | 60 +++++++++----- notebooks/astronify-snapshots-hack.ipynb | 101 +++++++++++++++-------- 2 files changed, 106 insertions(+), 55 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 7df230c..aa9da66 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -15,6 +15,8 @@ from astropy.table import Table, MaskedColumn from astropy.time import Time +import matplotlib.pyplot as plt + import pyo from ..utils.pitch_mapping import data_to_pitch @@ -345,7 +347,19 @@ def area_of_pieces(self, ydata_bins, xdata_bins): area_vals.append(np.abs(np.trapz(ydata_bin, xdata_bin))) return area_vals - def sonify_preview(self): + def plot_preview(self, xdata_bin_ranges): + + plt.plot(self._soniseries.data[self._soniseries.time_col], self._soniseries.data[self._soniseries.val_col], color='k') + + plt.axvspan(xdata_bin_ranges[0][0], xdata_bin_ranges[0][1], color='r', alpha=0.5, lw=0) + plt.axvspan(xdata_bin_ranges[1][0], xdata_bin_ranges[1][1], color='orange', alpha=0.5, lw=0) + plt.axvspan(xdata_bin_ranges[2][0], xdata_bin_ranges[2][1], color='y', alpha=0.5, lw=0) + plt.axvspan(xdata_bin_ranges[3][0], xdata_bin_ranges[3][1], color='g', alpha=0.5, lw=0) + plt.axvspan(xdata_bin_ranges[4][0], xdata_bin_ranges[4][1], color='royalblue', alpha=0.5, lw=0) + + plt.show() + + def sonify_preview(self, plotting=True, verbose=False): """ Make a "preview-style" sonification. The data is split into even pieces. Each piece gets assigned a specific frequency. The amplitude is defined by the area under the curve @@ -369,18 +383,22 @@ def sonify_preview(self): # Calculate the total area under the curve, used to normalize the areas in each piece. total_area = np.trapz(ydata_norm, xdata) - print('Total area = {0:0f}'.format(total_area)) # Loop through each piece and calculate the standard deviation of the y-data # and the area under the curve in each piece. - std_vals = [] + std_vals, xdata_bin_ranges = [], [] for xdata_bin, ydata_bin in zip(xdata_bins, ydata_bins): - - # Calculate standard deviation and add to the list. + + xdata_bin_ranges.append((min(xdata_bin), max(xdata_bin))) + # Calculate standard deviation error and add to the list. _, _, _, _, std_err = stats.linregress(xdata_bin, ydata_bin) std_vals.append(std_err) #std_vals.append(np.std(ydata_bin)) + # Plot the spectra and ranges if in troubleshooting mode + if plotting: + self.plot_preview(xdata_bin_ranges) + # Calculate the area under the curve for each piece. area_vals = self.area_of_pieces(ydata_bins, xdata_bins) @@ -389,18 +407,7 @@ def sonify_preview(self): # Set the amplitude of each pitch to the area under the curve normalized by the total # area. - print('area vals') - print(np.asarray(area_vals)) - print('TOTAL AREA') - print(total_area) self.amplitudes = np.asarray(area_vals) / total_area - print('amplitudes') - print(self.amplitudes) - - print('stdvals') - print(np.asarray(std_vals)) - print('stddevnorm') - print(std_dev_norm) if std_dev_norm == 0.0: std_dev_norm = 1.0 @@ -413,15 +420,26 @@ def sonify_preview(self): # The final calculated tremolo values are multiplied by a factor of 10 for auditory # purposes - print('before factiring') - print((np.asarray(std_vals) / std_dev_norm)) self.tremolo_vals = (np.asarray(std_vals) / std_dev_norm)*10 - print('TREMOLO VALS') - print(self.tremolo_vals) # Constraint added to keep tremolo values at or below 15, otherwise oscillations are # more difficult to hear - self.tremolo_vals[self.tremolo_vals > 15] = 15 + #self.tremolo_vals[self.tremolo_vals > 15] = 15 + + if verbose: + print('Total Expected area = {0:0f}'.format(total_area)) + print(' ') + print('Area Values = ', np.asarray(area_vals)) + print(' ') + #print('Total Calculated area = {0:0f}'.format(np.sum(str(area_vals).split(' ')))) + print(' ') + print('Amplitudes = ', self.amplitudes) + print(' ') + print('Standard Dev. Error Vals = ', np.asarray(std_vals)) + print(' ') + print('Standard Dev. Error MAX = ', std_dev_norm) + print(' ') + print('Tremolo Vals (x10) = ', self.tremolo_vals) def play_preview(self): diff --git a/notebooks/astronify-snapshots-hack.ipynb b/notebooks/astronify-snapshots-hack.ipynb index afa6733..59a9c19 100644 --- a/notebooks/astronify-snapshots-hack.ipynb +++ b/notebooks/astronify-snapshots-hack.ipynb @@ -223,34 +223,46 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 94, "id": "35e668f9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 10.3 -10.3 10.3 10.5 10.5 10.4 10.3 10.2 10.3 10.1 10.4 10.3\n", + " 40.2 10.3 30.1]\n" + ] + } + ], "source": [ + "y = np.asarray([0.3, -20.30, 0.3, 0.50, 0.5, 0.4, 0.3, 0.2, 0.3, 0.1, 0.4, 0.3, 30.2, 0.3, 20.1])+10\n", + "print(y)\n", + " \n", "data_table = Table({\"time\": list(range(0, 15, 1)),\n", - " \"flux\": [0.3, -20.30, 0.3, 0.50, 0.5, 0.4, 0.3, 0.2, 0.3, 0.1, 0.4, 0.3, 30.2, 0.3, 20.1]})" + " \"flux\": y})" ] }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 96, "id": "e49103f1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 46, + "execution_count": 96, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -272,7 +284,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 97, "id": "5158727c", "metadata": {}, "outputs": [ @@ -280,17 +292,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "Total area = 0.784768\n", + "Total area = 4.072139\n", "area vals\n", - "[0.66225166 0.03145695 0.01655629 0.01986755 0.84271523]\n", + "[0. 0.52114428 0.50995025 0.51243781 1.13059701]\n", "TOTAL AREA\n", - "0.7847682119205299\n", + "4.0721393034825875\n", "amplitudes\n", - "[0.84388186 0.04008439 0.02109705 0.02531646 1.07383966]\n", + "[0. 0.12797801 0.12522908 0.12583995 0.27764203]\n", "stdvals\n", - "[0.39382171 0.00095588 0.00191176 0.00382351 0.47507133]\n", + "[0.29585611 0.0007181 0.00143619 0.00287239 0.35689438]\n", "stddevnorm\n", - "0.47507133077358277\n", + "0.3568943828199552\n", "before factiring\n", "[0.82897384 0.00201207 0.00402414 0.00804829 1. ]\n", "TREMOLO VALS\n", @@ -316,7 +328,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 101, "id": "ca540bf1", "metadata": {}, "outputs": [], @@ -330,17 +342,17 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 102, "id": "fab274ab", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 102, "metadata": {}, "output_type": "execute_result" }, @@ -368,7 +380,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 103, "id": "c2e12110", "metadata": {}, "outputs": [ @@ -410,13 +422,13 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 111, "id": "cdfa7243", "metadata": {}, "outputs": [], "source": [ - "x = list(range(0, 15, 1))\n", - "y = x\n", + "x = np.asarray(range(0, 15, 1))\n", + "y = (x*-1)+15\n", "\n", "data_table = Table({\"time\": x,\n", " \"flux\": y})" @@ -424,23 +436,23 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 112, "id": "28df65ea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 74, + "execution_count": 112, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -462,7 +474,28 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 115, + "id": "a9cd036a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.33333335" + ] + }, + "execution_count": 115, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sum([1.86666667, 1.46666667, 1.06666667, 0.66666667, 0.26666667])" + ] + }, + { + "cell_type": "code", + "execution_count": 113, "id": "6557b47e", "metadata": {}, "outputs": [ @@ -470,13 +503,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Total area = 7.000000\n", + "Total area = 7.466667\n", "area vals\n", - "[0.14285714 0.57142857 1. 1.42857143 1.85714286]\n", + "[1.86666667 1.46666667 1.06666667 0.66666667 0.26666667]\n", "TOTAL AREA\n", - "6.999999999999999\n", + "7.466666666666668\n", "amplitudes\n", - "[0.02040816 0.08163265 0.14285714 0.20408163 0.26530612]\n", + "[0.25 0.19642857 0.14285714 0.08928571 0.03571429]\n", "stdvals\n", "[0. 0. 0. 0. 0.]\n", "stddevnorm\n", @@ -665,7 +698,7 @@ { "cell_type": "code", "execution_count": 72, - "id": "9d98f103", + "id": "9e7906f0", "metadata": {}, "outputs": [], "source": [ @@ -677,7 +710,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "79ce5d91", + "id": "e8ecdaf6", "metadata": {}, "outputs": [ { @@ -725,7 +758,7 @@ { "cell_type": "code", "execution_count": 63, - "id": "e909499d", + "id": "9bfd4f96", "metadata": {}, "outputs": [ { From 911703cbbd0bf3fe5b8516f85b34b662f3f442cd Mon Sep 17 00:00:00 2001 From: AdrianGRiber Date: Wed, 30 Nov 2022 19:23:31 +0100 Subject: [PATCH 20/93] only left channel sounding bug fixed --- astronify/series/series.py | 93 +++--- notebooks/astronify-snapshots-hack.ipynb | 397 ++++++++++++++--------- 2 files changed, 281 insertions(+), 209 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index aa9da66..eedb3fd 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -15,7 +15,7 @@ from astropy.table import Table, MaskedColumn from astropy.time import Time -import matplotlib.pyplot as plt +import matplotlib.pyplot as plt import pyo @@ -29,7 +29,7 @@ class PitchMap(): def __init__(self, pitch_func=data_to_pitch, **pitch_args): """ - Class that encapsulates the data value to pitch function + Class that encapsulates the data value to pitch function and associated arguments. Parameters @@ -38,7 +38,7 @@ def __init__(self, pitch_func=data_to_pitch, **pitch_args): Optional. Defaults to `~astronify.utils.data_to_pitch`. If supplying a function it should take a data array as the first parameter, and all other parameters should be optional. - **pitch_args + **pitch_args Default parameters and values for the pitch function. Should include all necessary arguments other than the data values. """ @@ -49,11 +49,11 @@ def __init__(self, pitch_func=data_to_pitch, **pitch_args): "center_pitch": 440, "zero_point": "median", "stretch": "linear"} - + self.pitch_map_func = pitch_func self.pitch_map_args = pitch_args - + def _check_func_args(self): """ Make sure the pitch mapping function and argument dictionary match. @@ -82,7 +82,7 @@ def __call__(self, data): @property def pitch_map_func(self): """ - The pitch mapping function. + The pitch mapping function. """ return self._pitch_map_func @@ -106,7 +106,7 @@ def pitch_map_args(self, new_args): self._pitch_map_args = new_args self._check_func_args() - + class SoniSeries(): @@ -163,7 +163,7 @@ def data(self, data_table): float_col = "asf_time" data_table[float_col] = data_table[self.time_col].jd self.time_col = float_col - + self._data = data_table @property @@ -223,13 +223,13 @@ def note_spacing(self): def note_spacing(self, value): # Add in min value check self._note_spacing = value - + def sonify(self): """ - Perform the sonification, two columns will be added to the data table: asf_pitch, and asf_onsets. + Perform the sonification, two columns will be added to the data table: asf_pitch, and asf_onsets. The asf_pitch column will contain the sonified data in Hz. The asf_onsets column will contain the start time for each note in seconds from the first note. - Metadata will also be added to the table giving information about the duration and spacing + Metadata will also be added to the table giving information about the duration and spacing of the sonified pitches, as well as an adjustable gain. """ data = self.data @@ -238,7 +238,7 @@ def sonify(self): data.meta["asf_exposure_time"] = exptime data.meta["asf_note_duration"] = self.note_duration data.meta["asf_spacing"] = self.note_spacing - + data["asf_pitch"] = self.pitch_mapper(data[self.val_col]) data["asf_onsets"] = [x for x in (data[self.time_col] - data[self.time_col][0])/exptime*self.note_spacing] @@ -273,11 +273,11 @@ def stop(self): """ Stop playing the data sonification. """ - self.streams.stop() + self.streams.stop() def write(self, filepath): """ - Save data sonification to the given file. + Save data sonification to the given file. Currently the only output option is a wav file. Parameters @@ -313,7 +313,7 @@ def write(self, filepath): class SeriesPreviews(): """ Previews (or snapshots) of 1d spectra by binning the data into - five equal pieces by assigning a sound to each piece. + five equal pieces by assigning a sound to each piece. """ def __init__(self, soniseries): @@ -342,12 +342,12 @@ def area_of_pieces(self, ydata_bins, xdata_bins): list(ydata_bin).append(ydata_bins[idx+1][0]) list(xdata_bin).append(xdata_bins[idx+1][0]) - # Taking the absolute value so that emission lines and absorption lines + # Taking the absolute value so that emission lines and absorption lines # have the same amplitude area_vals.append(np.abs(np.trapz(ydata_bin, xdata_bin))) return area_vals - def plot_preview(self, xdata_bin_ranges): + def plot_preview(self, xdata_bin_ranges): plt.plot(self._soniseries.data[self._soniseries.time_col], self._soniseries.data[self._soniseries.val_col], color='k') @@ -380,7 +380,7 @@ def sonify_preview(self, plotting=True, verbose=False): ydata_bins = [ydata_norm[i:i+bin_size] for i in range(0, len(ydata_norm), bin_size)] # Split the x-values into pieces. xdata_bins = [xdata[i:i+bin_size] for i in range(0, len(xdata), bin_size)] - + # Calculate the total area under the curve, used to normalize the areas in each piece. total_area = np.trapz(ydata_norm, xdata) @@ -394,7 +394,7 @@ def sonify_preview(self, plotting=True, verbose=False): _, _, _, _, std_err = stats.linregress(xdata_bin, ydata_bin) std_vals.append(std_err) #std_vals.append(np.std(ydata_bin)) - + # Plot the spectra and ranges if in troubleshooting mode if plotting: self.plot_preview(xdata_bin_ranges) @@ -408,22 +408,22 @@ def sonify_preview(self, plotting=True, verbose=False): # Set the amplitude of each pitch to the area under the curve normalized by the total # area. self.amplitudes = np.asarray(area_vals) / total_area - + if std_dev_norm == 0.0: std_dev_norm = 1.0 # Set the tremolo values based on the standard deviation of the piece normalized by the # `std_dev_norm` factor. - # TODO: Might be worth trying a different way of calculating the tremolo values other - # than the normalized standard dev. Maybe using RMS vals? + # TODO: Might be worth trying a different way of calculating the tremolo values other + # than the normalized standard dev. Maybe using RMS vals? # To more accurately represent all forms of data. - # The final calculated tremolo values are multiplied by a factor of 10 for auditory + # The final calculated tremolo values are multiplied by a factor of 10 for auditory # purposes self.tremolo_vals = (np.asarray(std_vals) / std_dev_norm)*10 - # Constraint added to keep tremolo values at or below 15, otherwise oscillations are - # more difficult to hear + # Constraint added to keep tremolo values at or below 15, otherwise oscillations are + # more difficult to hear #self.tremolo_vals[self.tremolo_vals > 15] = 15 if verbose: @@ -446,26 +446,26 @@ def play_preview(self): """ Play the sound of a "preview-style" sonification. The assigned pitch for each section of the spectra will begin - to play, with the calculated amplitude and frequency, one - at a time until all pitches are playing together for the full + to play, with the calculated amplitude and frequency, one + at a time until all pitches are playing together for the full audio preview of the spectra. """ - + if self._soniseries.server.getIsBooted(): self._soniseries.server.shutdown() - + self._soniseries.server.boot() self._soniseries.server.start() - + # TODO: Generalize the self.delays list # `step` must go into `stop` 5 times, since we have 5 pitches - #start, stop, step = 0, 2.5, 0.5 + #start, stop, step = 0, 2.5, 0.5 #self.delays = np.arange(start, stop, step) self.delays = [0., 2., 4., 6., 8.] # `total_duration` is in seconds - self.total_duration = 8.0 - + self.total_duration = 8.0 + default = 1.0 #float(min(self.amplitudes))#float((max(self.amplitudes) - min(self.amplitudes))/2) self.amplitudes = [amp/max(self.amplitudes) for amp in self.amplitudes] @@ -474,7 +474,7 @@ def play_preview(self): c = pyo.Phasor(self.pitch_values[2], mul=np.pi*2) d = pyo.Phasor(self.pitch_values[3], mul=np.pi*2) e = pyo.Phasor(self.pitch_values[4], mul=np.pi*2) - + # TODO: Make everything below iterable to it's cleaner and takes up less lines lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0]), 0) if self.tremolo_vals[0] > 0 else pyo.Cos(a, mul=float(self.amplitudes[0])) @@ -483,24 +483,23 @@ def play_preview(self): lfo4 = pyo.Sine(float(self.tremolo_vals[3]), 0, float(self.amplitudes[3]), 0) if self.tremolo_vals[3] > 0 else pyo.Cos(d, mul=float(self.amplitudes[3])) lfo5 = pyo.Sine(float(self.tremolo_vals[4]), 0, float(self.amplitudes[4]), 0) if self.tremolo_vals[4] > 0 else pyo.Cos(e, mul=float(self.amplitudes[4])) - self.stream1 = pyo.Sine(freq=self.pitch_values[0], mul=lfo1).out(delay=self.delays[0], dur=2.0) - - self.stream2 = pyo.Sine(freq=self.pitch_values[1], mul=lfo2).out(delay=self.delays[1], dur=2.0) + self.stream1 = pyo.Sine(freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1).out(delay=self.delays[0], dur=2.0) - self.stream3 = pyo.Sine(freq=self.pitch_values[2], mul=lfo3).out(delay=self.delays[2], dur=2.0) + self.stream2 = pyo.Sine(freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2).out(delay=self.delays[1], dur=2.0) - self.stream4 = pyo.Sine(freq=self.pitch_values[3], mul=lfo4).out(delay=self.delays[3], dur=2.0) + self.stream3 = pyo.Sine(freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3).out(delay=self.delays[2], dur=2.0) - self.stream5 = pyo.Sine(freq=self.pitch_values[4], mul=lfo5).out(delay=self.delays[4], dur=2.0) + self.stream4 = pyo.Sine(freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4).out(delay=self.delays[3], dur=2.0) + + self.stream5 = pyo.Sine(freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5).out(delay=self.delays[4], dur=2.0) # All together - self.stream6 = pyo.Sine(freq=self.pitch_values[0], mul=lfo1).out(delay=10, dur=4) - - self.stream7 = pyo.Sine(freq=self.pitch_values[1], mul=lfo2).out(delay=10, dur=4) + self.stream6 = pyo.Sine(freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1).out(delay=10, dur=4) + + self.stream7 = pyo.Sine(freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2).out(delay=10, dur=4) - self.stream8 = pyo.Sine(freq=self.pitch_values[2], mul=lfo3).out(delay=10, dur=4) + self.stream8 = pyo.Sine(freq=[self.pitch_values[2], self.pitch_values[2]],mul=lfo3).out(delay=10, dur=4) - self.stream9 = pyo.Sine(freq=self.pitch_values[3], mul=lfo4).out(delay=10, dur=4) + self.stream9 = pyo.Sine(freq=[self.pitch_values[3], self.pitch_values[3]],mul=lfo4).out(delay=10, dur=4) - self.stream10 = pyo.Sine(freq=self.pitch_values[4], mul=lfo5).out(delay=10, dur=4) - + self.stream10 = pyo.Sine(freq=[self.pitch_values[4], self.pitch_values[4]],mul=lfo5).out(delay=10, dur=4) diff --git a/notebooks/astronify-snapshots-hack.ipynb b/notebooks/astronify-snapshots-hack.ipynb index 59a9c19..dd78d46 100644 --- a/notebooks/astronify-snapshots-hack.ipynb +++ b/notebooks/astronify-snapshots-hack.ipynb @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 2, "id": "5bd74c81", "metadata": {}, "outputs": [], @@ -52,28 +52,32 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 3, "id": "bda1d4fd", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 8, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD4CAYAAAD1jb0+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxU5dk38N+VfZlJyDJLADUKLoioKFp9rCsuVNG4PFp5UHFpaftWq7ZSq7R1qWJbbMW3te3LIwWBCC5YAbUujbVKa6ko2gBRwYU0Q5KZBEhmsk6S+/1j5mSdQDJz5pwzmd/388knyWTmzEVIfrnmPvd9blFKgYiIEk+K2QUQEVF0GOBERAmKAU5ElKAY4ERECYoBTkSUoNKMfLLi4mJVWloa3YP37NG1loRQYHYBxutIwpaisdPsCoyX2eMyuwTDFeWnRv3Y999/v0Ep5Rh8u6EBXlpaii1btkT34Pvv17WWhHCl2QUY7wu72RUY76ndZldgvNLAHWaXYLgbZ4+L+rEiEvGnJAn7HSKisYEBTkSUoBjgREQJigFORJSgGOBERAmKAU6WUP5yJUpnLcGkSQ/gq19dgvXrK80uicjyDJ1GSBRJ+cuVmP/gRrS2BwEAe/Y04d57NwIAysqmmVkakaWxAyfTLfxNRW94a9ragli8uMKkiogSAwOcTFdd1xTx9trayLcTUQgDnEx3qDs/4u0lJZFvJ6IQBjiZ7uHbZiI7c+DpmOzsdCxYMNOkiogSw0EDXET+KCJeEdnW77ZCEXlDRHaG3yfhZZdIL3MvmYYff/Os3s/Hj8/HokWX8gQm0UGMpANfAWDWoNt+BKBCKXUkgIrw50RRO+HovqvTPffczQxvohE4aIArpd4GsHfQzWUAngp//BSAy3Wui5KMx+vv/djb72MiGl60Y+AupVQtAITfO4e7o4jMF5EtIrLF5/NF+XQ01tXUN/d+XFfXfIB7EpEm7icxlVJLlVIzlFIzHI4h1yMnAgB4vM3IzAhd8L6+nh040UhEG+D1IlICAOH3Xv1KomTk8foxdZITaWkpDHCiEYo2wDcAmBf+eB6A9fqUQ8nK4/XjEHceHA4bx8CJRmgk0wjXAHgXwNEiUiMitwD4OYALRGQngAvCnxNFzeNtxgSnHS6XHXV1DHCikTjoxayUUnOG+RJXWZAu2tqD2NfcjgnOPLj2t+Czz3iym2gkuBKTTKdNIQx14DaOgRONEAOcTOfxhqYNTnDmweXKg9/fgdbWTpOrIrI+BjiZbmAHbgfAqYREI8EAJ9MN7MAZ4EQjxQAn03m8fthyMpBny4TbnQeAAU40EgxwMp3H68cEZ6jzdjq1DpzL6YkOhgFOpgvNAQ913nZ7JnJzM9iBE40AA5xMV1Pf3NuBA6EunAFOdHAMcDJVT49CbUMAE115vbe53QxwopFggJOpvHtb0NXVww6cKAoMcDJV/ymEGpfLDq/XD6WUWWURJQQGOJmq/yIejctlR2dnN/btazOrLKKEwAAnU0XuwLW54JxKSHQgDHAylcfrR2qqwFWU23sbV2MSjQwDnEzlqffDXWRDamrfj6LbzQAnGgkGOJmq/yIejcPBACcaCQY4mar/MnpNRkYqiopyOAZOdBAMcDKVx9c8JMABbS54wISKiBIHA5xM09LaiSZ/x5AhFCA0E4UdONGBMcDJNJHmgGu4nJ7o4BjgZJqa+qFzwDVOpx2NjS0IBruNLosoYTDAyTTaIp7+F7LSuN12KAX4fBwHJxoOA5xMc6AhlL6NHTiMQjQcBjiZxuNtRr49E7k5GUO+xq3ViA6OAU6m8Xj9mOAYOnwCcGs1opFggJNpIi3i0RQW5iA9PQV1dezAiYbDACfTRFpGr0lJETgcoeuCE1FkDHAyRXd3D+oaA5jgityBA6GZKOzAiYbHACdT1De2oLtbDTuEAoTGwdmBEw2PAU6miLSRw2Ch1Zg8iUk0nJgCXETuFJHtIrJNRNaISJZehdHYdqA54Bqn045AoBOBQIdRZREllKgDXEQmAPgegBlKqeMApAK4Vq/CaGwbWQce+hqHUYgii3UIJQ1AtoikAcgBsCf2kigZeLx+pKWlwFmYO+x9uLUa0YFFHeBKKQ+ARwFUA6gF0KSUen3w/URkvohsEZEtPp8v+kppTKmpb0ZJsQ0pKTLsfRjgRAcWyxBKAYAyAIcDGA8gV0SuG3w/pdRSpdQMpdQMh8MRfaU0pni8/ogXseqP10MhOrBYhlDOB/CFUsqnlAoCeAHAf+lTFo11B1rEo7HZMmGzZXAmCtEwYgnwagCniUiOiAiAmQCq9CmLxroDLaPvL7QzDy8pSxRJLGPgmwE8D+ADAJXhYy3VqS4aw5oDHQi0do4owEN7Y7IDJ4okplkoSqn7lFLHKKWOU0pdr5TihF06qJFMIdRwOT3R8LgSkww3kkU8GqfTDp/Pj54eFe+yiBIOA5wMN9oOPBjswd69rfEuiyjhMMDJcKPtwAGuxiSKhAFOhvN4m1GQl4XsrPSD3ldbTl9XxxOZRIMxwMlwoSmEBx8+AdiBEx0IA5wMN9I54ADgdNoAgDNRiCJggJPhQqswRxbg6empKCrKZQdOFAEDnAwVDHajriEw4iEUgHPBiYbDACdD1TUGoBQOeiGr/lyuPHbgRBEwwMlQo5lCqHG5bFxOTxQBA5wMNZpFPBqXKw+Nja3o7OyOV1lECYkBToby1EfTgYfu6/NxGIWoPwY4GcrjbUZGeiqKC3JG/BgtwHkik2ggBjgZyuP1Y7zDjtAl5EeGW6sRRcYAJ0ONZhGPxhWescITmUQDMcDJUCPZSm2wgoJsZGSksgMnGoQBToZRSkXVgYtIeGceBjhRfwxwMkyTvwOt7cFRBzgQGgfnYh6igRjgZJho5oBrXC4upycajAFOhuldhekafQfudLIDJxqMAU6GqamPvgN3u+1oaemE3899s4k0DHAyjDaEMt4RzRh4KPTZhRP1YYCTYTxeP4oLcpCVmTbqx/atxuRccCINA5wME80UQg1XYxINxQAnw0SziEfDACcaigFOhomlA8/JyYDdnsnl9ET9MMDJEJ3Bbnj3tkQd4ECoC6+vD+hYFVFiY4CTIWp92nXAoxtCAUIzUdiBE/VhgJMhotlKbbBQB84xcCJNTAEuIuNE5HkR+VhEqkTkdL0Ko7EllmX0GpfLDp8vgJ4epVdZRAkt1g78cQCvKqWOAXACgKrYS6KxSK8OvKurB42NLXqVRZTQog5wEckDcBaAZQCglOpUSu3XqzAaWzzeZmRmpKIwPzvqY3AqIdFAsXTgRwDwAVguIltF5EkRydWpLhpjQlMI80a1ldpgDHCigWIJ8DQAJwH4vVJqOoAWAD8afCcRmS8iW0Rki8/ni+HpKJHV1DfHNHwCcGs1osFiCfAaADVKqc3hz59HKNAHUEotVUrNUErNcDgcMTwdJTKP14+JruhPYAKAw2GDCDtwIk3UAa6UqgPwHxE5OnzTTAA7dKmKxpTQVmqxd+BpaSkoLrYxwInCRn9ZuIFuA1AuIhkAPgdwU+wl0Vizt6kNHZ3dMU0h1HAuOFGfmAJcKfUhgBk61UJjlB5TCDUulx0eT1PMxyEaC7gSk+JOj0U8mlAHzpOYRAADnAygdwe+b18bOjq6Yj4WUaJjgFPcaR14SRRbqQ3GrdWI+jDAKe48Xj+chbnISE+N+VhczEPUhwFOcRfLRg6DMcCJ+jDAKe5i2UptMAY4UR8GOMWdnh34uHHZyMhI5UwUIjDAKc7aO7rQsK9VtwAXEW6tRhTGAKe42qPDVmqDcWs1ohAGOMWVNoUw1gtZ9cfl9EQhDHCKK0+9fot4NFqAK8Wt1Si5McAprvRcRq9xu+1oawvC7+/Q7ZhEiYgBTnHl8fqRk5WOfHumbsd0OjmVkAhggFOcaVMIY9lKbTC3O9TN19XxRCYlNwY4xZWei3g0WgfO66FQsmOAU1zpuYhHo63GrKtjgFNyY4BT3CilsMenf4BnZ6cjLy+LHTglPQY4xU3DvlZ0BvXZSm0wt5tzwYkY4BQ3vRs5uPTtwIHQODgDnJIdA5ziJh5zwDVcTk/EAKc40nMrtcFcLht8vgC6u3t0PzZRomCAU9zU1DdDBHAX2XQ/tsuVh+5uhcbGFt2PTZQoGOAUNx5vM1xFNqTrsJXaYNzYgYgBTnHk8fp1vQphfwxwIgY4xVE8FvFouJyeiAFOcRRaRh+fAC8qykVKinAxDyU1BjjFRVt7EPua2+MyhRAA0tJS4HDYuJyekhoDnOIinlMINU6nnR04JTUGOMVFPBfxaNxuOztwSmoMcIoLduBE8RdzgItIqohsFZGX9CiIxgajOvD9+9vQ3h6M23MQWZkeHfjtAKp0OA6NIR6vH7acDOTZ9NtKbbC+jR0CcXsOIiuLKcBFZCKASwA8qU85NFbEcw64hnPBKdnF2oEvAfBDAMNeUUhE5ovIFhHZ4vP5Ynw6ShTx2EptMG6tRsku6gAXkdkAvEqp9w90P6XUUqXUDKXUDIfDEe3TUYKpqY/fIh6N282t1Si5xdKBnwHgMhH5EsBaAOeJyGpdqqKE1tOjUNsQiHuA5+VlITMzjR04Ja2oA1wpdY9SaqJSqhTAtQDeVEpdp1tllLC8e1vQ1dUTtwtZaUSEc8EpqXEeOOnOiCmEGu7MQ8lMlwBXSr2llJqtx7Eo8RmxiEfDxTyUzNiBk+6M7MC1IRSlVNyfi8hqGOCkO4/Xj9RUgasoN+7P5XTa0dHRhebm9rg/F5HVMMBJd556P9xFNqSmxv/Hi1MJKZkxwEl3Rizi0XAxDyUzBjjpzohl9Boup6dkxgAn3Xl88V+FqXE6bQDYgVNyYoCTrlpaO9Hk7zBsCCUrKx3jxmVzDJySEgOcdGXkHHAN54JTsmKAk65q6o2bA67hcnpKVgxw0lXvIh4XO3CieGOAk676hlCM7cB9vgC6uoa9LD3RmMQAJ115vM3It2fClpNh2HM6nXb09Cg0NHBrNUouDHDSlcfrxwSHcd030DcXvL6ewyiUXBjgpCsjF/FoXOHxdgY4JRsGOOnKyGX0GgY4JSsGOOmmu7sHdY0BQ2egAEBRUS5SU4UbO1DSYYCTbuobW9DdrQwfQklNTYHDYUN9PU9iUnJhgJNujNzIYTBurUbJiAFOujFjGb3G5eJiHko+DHDSjbkdOJfTU/JhgJNuPF4/0tJS4CyM/1ZqgzmddjQ3t6OtLWj4cxOZhQFOuqmpb0ZJsQ0pKWL4c2tbq3EqISUTBjjpJrSIx/jhE6BvazWeyKRkwgAn3Xi8zZjoMifAuZyekhEDnHRjxjJ6DVdjUjJigJMumgMdCLR2mhbgdnsmsrPTGeCUVBjgpAszpxACgIjA5bIzwCmpMMBJF2Yu4tEwwCnZMMBJF2Z34ACX01PyYYCTLqzRgdtQX++HUsq0GoiMFHWAi8ghIvJXEakSke0icruehVFi8XibUZCXheysdNNqcLny0NnZjf3720yrgchIsXTgXQB+oJSaAuA0AN8VkWP1KYsSjZmLeDScSkjJJuoAV0rVKqU+CH/sB1AFYIJehVFiMXMOuIYBTslGlzFwESkFMB3A5ghfmy8iW0Rki8/n0+PpyIJCW6kxwImMFHOAi4gNwDoAdyilhkwBUEotVUrNUErNcDgcsT4dWVAw2I26hoDpQyi8Hgolm5gCXETSEQrvcqXUC/qURImmrjEApcydgQIAmZlpKCjI5nXBKWnEMgtFACwDUKWU+rV+JVGi0aYQmnUhq/5crjzuzENJI5YO/AwA1wM4T0Q+DL9drFNdlECssIhHw9WYlEzSon2gUmoTAOOv3E+W46k3fxGPxuWyY8eOOrPLIDIEV2JSzDzeZmSkp6K4IMfsUuBy2dHQEEAw2G12KURxxwCnmHm8fox32BE6LWIul8sOpYCGhhazSyGKOwY4xcwKi3g0Lpe2Mw+nEtLYxwCnmIUW8Zh/AhPgYh5KLgxwiolSymIdOAOckkfUs1ASVXllJRZWVKC6qQmH5ufj4ZkzMXfaNLPLSlhN/g60tgctE+BFRblIS0thgFNSSKoAL6+sxPyNG9EaDAIAdjc1Yf7GjQDAEI+SleaAA0BKisDhsDHAKSkk1RDKwoqK3vDWtAaDWFhRYVJFia93IweXNTpwgIt5rKzyL5VYcu0S3HRZIe66eRrefes5s0tKaEnVgVc3NY3qdjq4mnprdeBAaCbKZ5/xypdWU/mXSmx8dCOCHaEmqtFXgxW/De0Dc/o5V5tZWsJKmg5cKQVbRkbEr+VnZhpczdihDaGMd1ipA7fxglYWVPFkRW94azo72rBu5YMmVTTUu289h7tunpYwrxCSIsB7lMK3X3oJ/s5OpKUM/CenimB/RwcWVlRwL8UoeLx+FBfkICvTOi/mXK48BAIdaGnpNLsUClM9Ck31kV/pNjZ4DK4msnffeg4rfns7Gn01gFK9rxCsHOJjPsC7enow78UXsfSDD/CjM87AirIyHJafDwFwWH4+lpeV4ZsnnYRFmzbhztdeY4iPkpWmEGo4ldBagh1BPPfA8CE4rsBlYDXDW7fyQXR2DNxP1WqvEAazTtsUB53d3Zizbh1eqKrCQ+eei4VnnQUAmHv88QPud93xxyMnPR2Pb96Mls5O/GH2bKSmjPm/bbqw0iIejRbgXq8fRxxRZHI1yS2wN4C1P14Lz8ceHHf+cfjknU+GDKO0BJpQ9e93MOX4M02qMqTRVxP5dou8QohkzKZUWzCIy9euxQtVVXjsoot6wzsSEQnd58wz8eTWrbjhxRfR1dNjYLWJy8odeF0dl9ObyfelD8u+uwz1n9fj6w9+HVctvAqX3nUp8l35gAiKHBMx5xuL4HAdhl/99EpsqlhjSp1dXUGseXLhsF8vKrbuVr9jsgP3d3TgsrVr8bcvv8T/mz0b808++aCPERE8dN55yE1Px71vvom2YBBrrroKmWlj8luki85gN7x7WywY4KFXBNzYwTyfv/85nr3vWaRnpuOmx2/C+KPHAwCmnT8N086fhtLAHb33/erM/8ETv7gRy5b8H/hqv8Dlc+8x7MJoexs8+P0vb8auqn9h6onnYmfVPwcMo2RkZuOqG35qSC3RGHMd+P72dly4ejXe2b0bq664YkTh3d89Z56Jx2fNwp8+/hiXP/PMkHnj1KfWp10H3FpDKHZ7JnJzMzgTxSRbX9mK8rvLke/Mxy1P3NIb3sPJseXjzvuexZkXXI8NzyzG0l/NR7CzPe51bvvgTdx3+9mo+XIHvv3DZbjrZy/gxlsfR5FjYu8rhBtvfdzSUxzHVHvpa2nBhatXY7vXi+euvhpXTJkS1XG+95WvIDc9Hd/cuBEXl5dj45w5sHOq4RC9i3gs1oEDoQ2O2YEbS/UovLnsTWx6ehMmzZiE/77vv5FlyxrRY9PS0nHTbY/DVXI4nl/5IBp9Nbjt3tWw5+t/DqOnuxsbnlmMDWt/ifGHHI3v3rMSJROPBBCaj27lwB5szHTge/x+nPPUU/i4oQEb5syJOrw1t5x0EsqvvBKbqqtxwapV2NfWdvAHJRmrLaPvz+3makwjdXV2Yd1D67Dp6U04afZJmPPInBGHt0ZEcMnVd+I7P/wjvti5FQ8tuBB1nl261tnc1IBf33811q/5BU4/5xr85Fd/6Q3vRDQmAnz3/v04a/lyVDc14dW5czFr8mRdjjtn2jSsu+YabK2rw7lPPQVvCzcJ6M/qHTgD3Bgt+1uw8vsrsf2v23H+t87H7O/PRmpaatTHO/XMK3D3og1obWnCQwsuxCfb/q5LnTurNuP+28/GJ9v/gRtvXYJv3Pl7ZGbl6nJssyR8gO9sbMSZy5ejsa0Nb1x/Pc4uLdX1+GXHHIMN116LTxsbcfaKFfA0c2aDxuNtRmZGKgrzs80uZQiXKzSEwnn98dVQ3YBl312G2p21uPr+q3HGtWfocgJy8jGn4ie/+gvy8h149CdX4t23no36WEopvPbi7/CLe2YjLT0DP178Os6+aJ4ldpCKVUIH+DavF2cuX462ri78dd48nDZxYlye56LJk/HqddehprkZZy5fji/27YvL82jKKytRumQJUk58AKWzlqD85crYjvdyJUpn6Xc8TWgKYZ4lfxFcLjs6O7uxbx+HvuLlyw+/xLJbl6GzrRPzHpuHY88+VtfjO92lWLj4NUyeciqW/upbWL/ml6P+g9za0oQnHpmHtcsW4oRTLsL9j72FwyYdf/AHJoiEDfD39+zBOStWIEUEb994I050u+P6fGcddhgqbrgB+9rbcdaKFfikoSEuz6Nd8nZ3UxOUAnbXNmH+gxujDt3ylysx/8GN2F2rz/H6q6lvtuTwCcCt1eLto9c+wqoFq2ArtOGWJ27BxGPj0zzl2sbhBw+swxnnzcGLTz+CJx/7DoLBjhE9tvrzSjxw53nYuvkVfP3mn+HWe1chx5YflzrNkpCzUP5eXY2Ln34aBVlZqLjhBkwqLDTkeU+dMAFvzZuHC1atwlkrVuCN66/H8S79lgErpXD3G28MveRtexDffugl/P3D6lEfc9VL/0Zr+9Dj3bn4VUw5ohglxTY4CkKbIIxG+cuVePejGnR196B01hI8fNtMzL3EOtdU71vM48eUKfH9424VlX+pRMWTFWjyNiHfmY+Z35iJaefr+3+ilMJbK97C2yvfxuHTD8c1D14z6pOVo5WWnoFb7ngCzvFH4E+rH0ajrwa33rsKNnvBsI95+43VWP2HBci1FeDuRRtx1NTT41qjWRIuwCs+/xyXrV2LCXY7Km64AYfkG/sX9QS3G2/fdBNmrlyJc1aswGvXXYdTJox+pVZ3Tw8+bWzE1ro6bK2txda6OnxYV4fGYWa7BFo78fwbO0b9PIHWyBd08u1rxcnXLgUQ3gShIAfuYhtKiu1wF9lQ4rD1vS/WPrbDlpPR29V3dYdWq2pdPQDLhLjb3becPhkMvlRrU30TNj4a+j/RK8S7Oruw4ZcbUFlRiRO/diJm3zkbqenRn6wcDRHBZV+/Cw7XYfjj47fi4QUX4s77noWz5PAB9+tob8XqPyzApoqncewJZ+Nbd/0v8sY5DKnRDJYP8PLycixcuBDVu3ejOCcHe9vaMMXhwBvXXw+3zWZKTccUF+OdcIjPXLkSd5x2GlZ+9NGw27S1d3Whsr5+QFj/u74ebV1dAIDM1FRMc7lwxTHHYF1VFfa1D13EcFhJPr589Y4htx9M6awl2F079Cpw7qJc/G7hJahrDKCuIYDahr7323Z5UdcYQFfX0MsJ5Gano6Ozuze8Na3tQSz8TYVlAtzh0Hc5/fr1lVi8uAK1tU0oKcnHggUzUVZmjX8rAFT879BLtQY7gnj1t68i35UPW6EN9iI70rPSR3zM/h19XnEe0jLTsLdmL877xnn46v981ZRzH6efczWKHBPxm4evw8/uugDnfe1m/P3NNWhs8GBcgQuSkoL9jbW47OsLUDbnbqSkGvMHxiyWDvDy8nLMnz8fra2tAABfaysEwK2nnGJaeGuOKCjAOzfdhFOWLsXP3n679/bdTU24Zf16vPLpp0hNScHWujpU+XzoDp98yc/MxIluN7518smYXlKC6W43jikuRnr4B+2cww8fsO0bAORkpePh22ZGVefDt83E/Ac3DhhGyclKx6M/uAhXzBx+rnxPj8LeprZwqPsHhPxjq/8Z8THVddbZGCMjIxVFRTm6dODr11fi3ns3oq0t9D3cs6cJ994b6m7NDPHA3gA+e+8z7Ny8E03eyN/71qZWLP/e8t7PM3IyQmFeaIet0AZbkS30vt+bvciOz977DC/9+qXePwrNvtAfwlMuPwVnzjX3olNHTT0dCx99HY/cfTE2PLO49/b9e+sAAF+78nu44rp7zSrPUJYO8IULF/aGt0YBeGTTJnxrxgxziupnYl7ekOuLA0BHdzee3rYN4+12THe7UXb00ZjudmN6SQkOHzfugJ2L1rkvrKhAdXMTDnXnxzS+rD1u4W8qUF038uOlpAiKC3JQXJCD4450DvjaCxVVEbv6Q93WOUG0fn0lmprasWbNB/jb3z4bVcfc0tIJr9cPny8Any+A++9/pTe8NW1tQTzyyOu49NLjkJJiTCfa090Dz8ce7Ny8E7s270Ltp7UAAFuhDelZ6Qi2D73sg63QhrK7yxDYG+h7awy9r91Vi8C/AugcZpgtkk/f/RQX336xbv+maLnHT0LqMNcp+tc7L+Camx4wuCJzWDrAq6sjn7Sz0hZoHn/kDk8AeL7//aiOOXfatFCQXxlDYf2Pd8k0XYc2huvqo32VoDetY9aGgPbsacI992xEc3M7Tj75kN5w9noDaGgIvQ+Fdej21taRXf/G6w3g+OMfwZQpbhx7bN/bUUc5kanTBhct+1qw671d2LV5Fz7b8hnamtsgKYKJx07EubeciyNPPRLuyW5se3PbgDFwAEjPTMeF37kQk0898MK2zrbOgQG/N4A//98/R7zvcJ2+GfY11ka83cqXf9WbpQP80EMPxe7du4febvCJywM5ND8fuyP8QbFSjXqLtqs3yuLFFUM65vb2IO6775Uh97XbM+Fw2OB02jFt2gQ4HLlwOu1wOGy9bzff/HTEsfRx47JRVjYNO3bU4U9/+girVr0HAEhLS8HkyQ5MnRoK9KlTSzBliht2+8Dr6Wjj6ntq+2aNTD13KvZ8sqe3y97z6R5AAbkFuTjq9KMw+dTJmDRjErLzBi6e0k5URjMLJSM7A4UTClE4oW821z+e+UfEHXTyndb5uS4qnhDxGt5Wvvyr3sTIlWozZsxQW7ZsGfH9B4+BA0BOejqWXnrpgJOEZtLmbQ8Ys9arRp068ETyhQ7TyidNegDD/Vj/7nfXhAPbhuJiG7KzD35Sb/AYOABkZ6dj0aJLe4dlenoUqqv3YceOWmzfXocdO+qwfXstGhr6Lr9w2GEFmDLFjalT3Whqasfq1e+hvb2r9+uSIkjLSEOwPRjqsqdMxOSvTMbkUyej5MgSiEFDNcDQWS1AqKO/9K5LdZnV0v9ystHStkAbfPlXq15B8MbZ46J+rIi8r5QaMm4cUwcuIrMAPA4gFcCTSqmfx3K8webOnQsAvbNQIs3wMNuAMethZqGQsUpK8rFnzxFNJ+wAAAXDSURBVNDucfz4fMyaNfqLnGkhfaBZKCkpgtLSQpSWFuLii6f23u71+sOBHgr2qqo6vPpqVcTnUT2hvzpX/eSqiF22kWLp6I2ihfS6lQ+iscGDouIJuOqGn1oyvOMl6g5cRFIBfArgAgA1AN4DMEcpNexk5dF24APcf390j0tk7MCjMpKO2UzNze2YPv0XkV8lCHDfm/cZXpPR9OjAE008OvBYltKfCmCXUupzpVQngLUAymI4HpEuysqmYdGiSzF+fD5EQp23VcIbAPLyslBSEnks2UpjzGR9sQyhTADwn36f1wD4yuA7ich8APOB0ElJIiOUlU2zTGBHsmDBzCGvEtIz0zHzG9aYyUOJIZYOPNIZlSEvCpVSS5VSM5RSMxyOsbuklWg0+r9KgAD5rnzdThBS8oilA68BcEi/zycC2BNbOUTJQ3uV8NTQmbJEIxJLB/4egCNF5HARyQBwLYAN+pRFREQHE3UHrpTqEpFbAbyG0DTCPyqltutWGRERHVBM88CVUq8AGLq8jYiI4i5hd+QhIkp2DHAiogRl6LVQRMQHINpz7sUA4rMRpX6sXqPV6wOsX6PV6wNYox6sVt9hSqkh87ANDfBYiMiWSEtJrcTqNVq9PsD6NVq9PoA16sHq9Wk4hEJElKAY4ERECSqRAnyp2QWMgNVrtHp9gPVrtHp9AGvUg9XrA5BAY+BERDRQInXgRETUDwOciChBJUSAi8gsEflERHaJyI/Mrqc/ETlERP4qIlUisl1Ebje7puGISKqIbBWRl8yuZTARGSciz4vIx+Hv5elm1zSYiNwZ/j/eJiJrRCTLAjX9UUS8IrKt322FIvKGiOwMvy+wWH2Lw//P/xaRP4lI9FvVxKnGfl+7S0SUiBSbUdvBWD7Aw1u3PQHgawCOBTBHRI41t6oBugD8QCk1BcBpAL5rsfr6ux1A5A0Zzfc4gFeVUscAOAEWq1NEJgD4HoAZSqnjELqA27XmVgUAWAFg1qDbfgSgQil1JICK8OdmWYGh9b0B4Dil1PEIbct4j9FFDbICQ2uEiByC0JaR1UYXNFKWD3BYfOs2pVStUuqD8Md+hIJngrlVDSUiEwFcAuBJs2sZTETyAJwFYBkAKKU6lVL7za0qojQA2SKSBiAHFrj+vVLqbQB7B91cBuCp8MdPAbjc0KL6iVSfUup1pVRX+NN/IrSXgGmG+R4CwGMAfogIG9VYRSIEeKSt2ywXkAAgIqUApgPYbG4lES1B6Iexx+xCIjgCgA/A8vAQz5Mikmt2Uf0ppTwAHkWoG6sF0KSUet3cqoblUkrVAqEGA4DT5HoO5GYAfza7iMFE5DIAHqXUR2bXciCJEOAj2rrNbCJiA7AOwB1KqWaz6+lPRGYD8Cql3je7lmGkATgJwO+VUtMBtMDcl/1DhMeRywAcDmA8gFwRuc7cqhKbiCxEaAiy3Oxa+hORHAALAfzU7FoOJhEC3PJbt4lIOkLhXa6UesHseiI4A8BlIvIlQkNQ54nIanNLGqAGQI1SSnvl8jxCgW4l5wP4QinlU0oFAbwA4L9Mrmk49SJSAgDh916T6xlCROYBmA1grrLeYpRJCP2h/ij8OzMRwAci4ja1qggSIcAtvXWbiAhCY7dVSqlfm11PJEqpe5RSE5VSpQh9/95USlmme1RK1QH4j4gcHb5pJoAdJpYUSTWA00QkJ/x/PhMWO9HazwYA88IfzwOw3sRahhCRWQDuBnCZUqrV7HoGU0pVKqWcSqnS8O9MDYCTwj+nlmL5AA+f7NC2bqsC8KzFtm47A8D1CHW1H4bfLja7qAR0G4ByEfk3gBMBLDK5ngHCrw6eB/ABgEqEfndMX24tImsAvAvgaBGpEZFbAPwcwAUishOhWRQ/t1h9vwVgB/BG+PflD2bVd4AaEwKX0hMRJSjLd+BERBQZA5yIKEExwImIEhQDnIgoQTHAiYgSFAOciChBMcCJiBLU/wfSbkiILryl4QAAAABJRU5ErkJggg==\n", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -90,29 +94,26 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 4, "id": "7c025809", "metadata": {}, "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "Total area = 1.631068\n", - "area vals\n", - "[0.15533981 0.09223301 0.53398058 0.05825243 0.1407767 ]\n", - "TOTAL AREA\n", - "1.6310679611650483\n", - "amplitudes\n", - "[0.0952381 0.05654762 0.32738095 0.03571429 0.08630952]\n", - "stdvals\n", - "[0.05605342 0.00280267 0.28587246 0.01121068 0.04764541]\n", - "stddevnorm\n", - "0.28587246338515443\n", - "before factiring\n", - "[0.19607843 0.00980392 1. 0.03921569 0.16666667]\n", - "TREMOLO VALS\n", - "[ 1.96078431 0.09803922 10. 0.39215686 1.66666667]\n", "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", "Pyo warning: Portmidi warning: no midi device found!\n", "Portmidi closed.\n" @@ -132,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 5, "id": "df70bb84", "metadata": {}, "outputs": [], @@ -143,28 +144,30 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 6, "id": "7e9924e9", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 49, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -181,29 +184,26 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 7, "id": "f6e45c77", "metadata": {}, "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "Total area = 2.129139\n", - "area vals\n", - "[0.68211921 0.03145695 0.01655629 0.01986755 0.84271523]\n", - "TOTAL AREA\n", - "2.1291390728476824\n", - "amplitudes\n", - "[0.32037325 0.01477449 0.00777605 0.00933126 0.39580093]\n", - "stdvals\n", - "[0.38235117 0.00095588 0.00191176 0.00382351 0.47507133]\n", - "stddevnorm\n", - "0.47507133077358277\n", - "before factiring\n", - "[0.80482897 0.00201207 0.00402414 0.00804829 1. ]\n", - "TREMOLO VALS\n", - "[ 8.04828974 0.02012072 0.04024145 0.0804829 10. ]\n", "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", "Pyo warning: Portmidi warning: no midi device found!\n", "Portmidi closed.\n" @@ -223,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 94, + "execution_count": 8, "id": "35e668f9", "metadata": {}, "outputs": [ @@ -246,28 +246,30 @@ }, { "cell_type": "code", - "execution_count": 96, + "execution_count": 9, "id": "e49103f1", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 96, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -284,29 +286,26 @@ }, { "cell_type": "code", - "execution_count": 97, + "execution_count": 11, "id": "5158727c", "metadata": {}, "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "Total area = 4.072139\n", - "area vals\n", - "[0. 0.52114428 0.50995025 0.51243781 1.13059701]\n", - "TOTAL AREA\n", - "4.0721393034825875\n", - "amplitudes\n", - "[0. 0.12797801 0.12522908 0.12583995 0.27764203]\n", - "stdvals\n", - "[0.29585611 0.0007181 0.00143619 0.00287239 0.35689438]\n", - "stddevnorm\n", - "0.3568943828199552\n", - "before factiring\n", - "[0.82897384 0.00201207 0.00402414 0.00804829 1. ]\n", - "TREMOLO VALS\n", - "[ 8.28973843 0.02012072 0.04024145 0.0804829 10. ]\n", "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", "Pyo warning: Portmidi warning: no midi device found!\n", "Portmidi closed.\n" @@ -328,7 +327,7 @@ }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 12, "id": "ca540bf1", "metadata": {}, "outputs": [], @@ -342,28 +341,30 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 13, "id": "fab274ab", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 102, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -380,29 +381,26 @@ }, { "cell_type": "code", - "execution_count": 103, + "execution_count": 14, "id": "c2e12110", "metadata": {}, "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "Total area = 14.000000\n", - "area vals\n", - "[2. 2. 2. 2. 2.]\n", - "TOTAL AREA\n", - "14.0\n", - "amplitudes\n", - "[0.14285714 0.14285714 0.14285714 0.14285714 0.14285714]\n", - "stdvals\n", - "[0. 0. 0. 0. 0.]\n", - "stddevnorm\n", - "0.0\n", - "before factiring\n", - "[0. 0. 0. 0. 0.]\n", - "TREMOLO VALS\n", - "[0. 0. 0. 0. 0.]\n", "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", "Pyo warning: Portmidi warning: no midi device found!\n", "Portmidi closed.\n" @@ -422,7 +420,7 @@ }, { "cell_type": "code", - "execution_count": 111, + "execution_count": 15, "id": "cdfa7243", "metadata": {}, "outputs": [], @@ -436,28 +434,30 @@ }, { "cell_type": "code", - "execution_count": 112, + "execution_count": 16, "id": "28df65ea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 112, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -474,7 +474,7 @@ }, { "cell_type": "code", - "execution_count": 115, + "execution_count": 17, "id": "a9cd036a", "metadata": {}, "outputs": [ @@ -484,7 +484,7 @@ "5.33333335" ] }, - "execution_count": 115, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -495,29 +495,26 @@ }, { "cell_type": "code", - "execution_count": 113, + "execution_count": 18, "id": "6557b47e", "metadata": {}, "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "Total area = 7.466667\n", - "area vals\n", - "[1.86666667 1.46666667 1.06666667 0.66666667 0.26666667]\n", - "TOTAL AREA\n", - "7.466666666666668\n", - "amplitudes\n", - "[0.25 0.19642857 0.14285714 0.08928571 0.03571429]\n", - "stdvals\n", - "[0. 0. 0. 0. 0.]\n", - "stddevnorm\n", - "0.0\n", - "before factiring\n", - "[0. 0. 0. 0. 0.]\n", - "TREMOLO VALS\n", - "[0. 0. 0. 0. 0.]\n", "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", "Pyo warning: Portmidi warning: no midi device found!\n", "Portmidi closed.\n" @@ -537,7 +534,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "d8fd9ec4", "metadata": {}, "outputs": [], @@ -558,20 +555,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "91ece8f7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(0.2569491606212147, 0.7536527950141229)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "float(1/np.abs(np.log(amps[0]))), float(1/np.abs(np.log(amps[4])))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "488bcc85", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(0.20408160000000003, 2.6530612)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "amps[0]*10, amps[4]*10" ] @@ -594,7 +613,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 22, "id": "a0973367", "metadata": {}, "outputs": [], @@ -605,28 +624,30 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 23, "id": "ebec7606", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 34, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -643,29 +664,26 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 24, "id": "a3236c14", "metadata": {}, "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "Total area = 1.096535\n", - "area vals\n", - "[0.01485149 0.01485149 0.01485149 0.01485149 1.00742574]\n", - "TOTAL AREA\n", - "1.0965346534653464\n", - "amplitudes\n", - "[0.01354402 0.01354402 0.01354402 0.01354402 0.91873589]\n", - "stdvals\n", - "[0. 0. 0. 0. 0.57306301]\n", - "stddevnorm\n", - "0.5730630147154454\n", - "before factiring\n", - "[0. 0. 0. 0. 1.]\n", - "TREMOLO VALS\n", - "[ 0. 0. 0. 0. 10.]\n", "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", "Pyo warning: Portmidi warning: no midi device found!\n", "Portmidi closed.\n" @@ -697,7 +715,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 26, "id": "9e7906f0", "metadata": {}, "outputs": [], @@ -709,7 +727,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 27, "id": "e8ecdaf6", "metadata": {}, "outputs": [ @@ -727,7 +745,7 @@ "0.0" ] }, - "execution_count": 6, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -746,10 +764,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "id": "644f4ca5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "< Instance of Sine class >" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "lfo = Sine(10, 0, 0.91873589, 0)\n", "Sine(freq=900, mul=lfo).out(dur=4.0)" @@ -757,7 +786,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 29, "id": "9bfd4f96", "metadata": {}, "outputs": [ @@ -767,7 +796,7 @@ "< Instance of Sine class >" ] }, - "execution_count": 63, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -779,10 +808,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "id": "2db3eb27", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "plt.plot(data_table['time'], data_table['flux'], marker='o', color='k')\n", @@ -796,7 +848,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "id": "13ec8825", "metadata": {}, "outputs": [], @@ -808,10 +860,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "id": "f07eeffe", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], "source": [ "s = Server().boot()\n", "s.start()\n", @@ -840,17 +902,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "id": "a39bca37", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0.5, 1. , 1.5, 2. ])" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "np.arange(0,2.5, 0.5)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "id": "5c932d82", "metadata": {}, "outputs": [], @@ -883,7 +956,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.8.5" } }, "nbformat": 4, From 55cfda483a0b54ea116b489ab191ea6853c3da48 Mon Sep 17 00:00:00 2001 From: AdrianGRiber Date: Thu, 1 Dec 2022 20:29:43 +0100 Subject: [PATCH 21/93] Real spectra demo notebook added --- notebooks/OBAFGKM_demo.ipynb | 498 +++++++++++++++++++++++++++++++++++ 1 file changed, 498 insertions(+) create mode 100644 notebooks/OBAFGKM_demo.ipynb diff --git a/notebooks/OBAFGKM_demo.ipynb b/notebooks/OBAFGKM_demo.ipynb new file mode 100644 index 0000000..d3f12b6 --- /dev/null +++ b/notebooks/OBAFGKM_demo.ipynb @@ -0,0 +1,498 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4aa6cea2", + "metadata": {}, + "source": [ + "## Astronify's Spectrum preview mode with OBAFGKM samples\n", + "Based on data from the MILES library service developed by the Spanish Virtual Observatory in the framework of the IAU Comission G5 Working Group : Spectral Stellar Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6a5a4813", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "WxPython is not found for the current python version.\n", + "Pyo will use a minimal GUI toolkit written with Tkinter (if available).\n", + "This toolkit has limited functionnalities and is no more\n", + "maintained or updated. If you want to use all of pyo's\n", + "GUI features, you should install WxPython, available here:\n", + "http://www.wxpython.org/\n", + "\n" + ] + } + ], + "source": [ + "from astropy.io import fits,ascii\n", + "import numpy as np\n", + "\n", + "from astropy.table import QTable, Table, Column\n", + "from astronify.series import SoniSeries" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "808908c9", + "metadata": {}, + "outputs": [], + "source": [ + "O = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/1-Type_O_Stelib_HD269698.fits\"\n", + "B = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/2-Type_B_HD003369_s0020.fits\"\n", + "A = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/3-Type_A_HD031295_s0166.fits\"\n", + "F = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/4-Type_F_HD222451_s0889.fits\"\n", + "G = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/5-Type_G_HD114606_s0462.fits\"\n", + "K = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/6-Type_K_HD233832_s0410.fits\"\n", + "M = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/7-Type_M_HD036395_s0183.fits\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e71b17db", + "metadata": {}, + "outputs": [], + "source": [ + "hdu_O = fits.open(O)\n", + "hdu_B = fits.open(B)\n", + "hdu_A = fits.open(A)\n", + "hdu_F = fits.open(F)\n", + "hdu_G = fits.open(G)\n", + "hdu_K = fits.open(K)\n", + "hdu_M = fits.open(M)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "003ad226", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/1-Type_O_Stelib_HD269698.fits\n", + "No. Name Ver Type Cards Dimensions Format\n", + " 0 PRIMARY 1 PrimaryHDU 38 (6700,) float32 \n", + "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/2-Type_B_HD003369_s0020.fits\n", + "No. Name Ver Type Cards Dimensions Format\n", + " 0 PRIMARY 1 PrimaryHDU 18 (4367, 1) float32 \n", + "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/3-Type_A_HD031295_s0166.fits\n", + "No. Name Ver Type Cards Dimensions Format\n", + " 0 PRIMARY 1 PrimaryHDU 18 (4367, 1) float32 \n", + "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/4-Type_F_HD222451_s0889.fits\n", + "No. Name Ver Type Cards Dimensions Format\n", + " 0 PRIMARY 1 PrimaryHDU 18 (4367, 1) float32 \n", + "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/5-Type_G_HD114606_s0462.fits\n", + "No. Name Ver Type Cards Dimensions Format\n", + " 0 PRIMARY 1 PrimaryHDU 18 (4367, 1) float32 \n", + "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/6-Type_K_HD233832_s0410.fits\n", + "No. Name Ver Type Cards Dimensions Format\n", + " 0 PRIMARY 1 PrimaryHDU 18 (4367, 1) float32 \n", + "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/7-Type_M_HD036395_s0183.fits\n", + "No. Name Ver Type Cards Dimensions Format\n", + " 0 PRIMARY 1 PrimaryHDU 18 (4367, 1) float32 \n" + ] + } + ], + "source": [ + "hdu_O.info()\n", + "hdu_B.info()\n", + "hdu_A.info()\n", + "hdu_F.info()\n", + "hdu_G.info()\n", + "hdu_K.info()\n", + "hdu_M.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "614162af", + "metadata": {}, + "outputs": [], + "source": [ + "# The lists wave contain the wavelengths of the pixels.\n", + "# The lists flux the corresponding intensities.\n", + "\n", + "#TO DO: Iteration to create the flux and wave list for each star type\n", + "\n", + "flux_O = np.array(hdu_O[0].data)\n", + "flux_O_norm = np.reshape(flux_O/(np.nanmax(flux_O)), (hdu_O[0].header['NAXIS1']))\n", + "wave_O = np.ones(hdu_O[0].header['NAXIS1'], dtype=float)\n", + "for i in range(hdu_O[0].header['NAXIS1']):\n", + " wave_O[i] = hdu_O[0].header['CRVAL1'] + i*hdu_O[0].header['CDELT1']\n", + "hdu_O.close()\n", + "\n", + "flux_B = np.array(hdu_B[0].data)\n", + "flux_B_norm = np.reshape(flux_B/(np.nanmax(flux_B)), (hdu_B[0].header['NAXIS1']))\n", + "wave_B = np.ones(hdu_B[0].header['NAXIS1'], dtype=float)\n", + "for i in range(hdu_B[0].header['NAXIS1']):\n", + " wave_B[i] = hdu_B[0].header['CRVAL1'] + i*hdu_B[0].header['CDELT1']\n", + "hdu_B.close()\n", + "\n", + "flux_A = np.array(hdu_A[0].data)\n", + "flux_A_norm = np.reshape(flux_A/(np.nanmax(flux_A)), (hdu_A[0].header['NAXIS1']))\n", + "wave_A = np.ones(hdu_A[0].header['NAXIS1'], dtype=float)\n", + "for i in range(hdu_A[0].header['NAXIS1']):\n", + " wave_A[i] = hdu_A[0].header['CRVAL1'] + i*hdu_A[0].header['CDELT1']\n", + "hdu_A.close()\n", + "\n", + "flux_F = np.array(hdu_F[0].data)\n", + "flux_F_norm = np.reshape(flux_F/(np.nanmax(flux_F)), (hdu_F[0].header['NAXIS1']))\n", + "wave_F = np.ones(hdu_F[0].header['NAXIS1'], dtype=float)\n", + "for i in range(hdu_F[0].header['NAXIS1']):\n", + " wave_F[i] = hdu_F[0].header['CRVAL1'] + i*hdu_F[0].header['CDELT1']\n", + "hdu_F.close()\n", + "\n", + "flux_G = np.array(hdu_G[0].data)\n", + "flux_G_norm = np.reshape(flux_G/(np.nanmax(flux_G)), (hdu_G[0].header['NAXIS1']))\n", + "wave_G = np.ones(hdu_G[0].header['NAXIS1'], dtype=float)\n", + "for i in range(hdu_G[0].header['NAXIS1']):\n", + " wave_G[i] = hdu_G[0].header['CRVAL1'] + i*hdu_G[0].header['CDELT1']\n", + "hdu_G.close()\n", + "\n", + "flux_K = np.array(hdu_K[0].data)\n", + "flux_K_norm = np.reshape(flux_K/(np.nanmax(flux_K)), (hdu_K[0].header['NAXIS1']))\n", + "wave_K = np.ones(hdu_K[0].header['NAXIS1'], dtype=float)\n", + "for i in range(hdu_K[0].header['NAXIS1']):\n", + " wave_K[i] = hdu_K[0].header['CRVAL1'] + i*hdu_K[0].header['CDELT1']\n", + "hdu_K.close()\n", + "\n", + "flux_M = np.array(hdu_M[0].data)\n", + "flux_M_norm = np.reshape(flux_M/(np.nanmax(flux_M)), (hdu_M[0].header['NAXIS1']))\n", + "wave_M = np.ones(hdu_M[0].header['NAXIS1'], dtype=float)\n", + "for i in range(hdu_M[0].header['NAXIS1']):\n", + " wave_M[i] = hdu_M[0].header['CRVAL1'] + i*hdu_M[0].header['CDELT1']\n", + "hdu_M.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "29f98141", + "metadata": {}, + "outputs": [], + "source": [ + "#TO DO: Iteration to create the table for each star type\n", + "\n", + "spectrum_O = Table()\n", + "spectrum_O['flux'] = flux_O_norm\n", + "spectrum_O['time'] = wave_O\n", + "\n", + "spectrum_B = Table()\n", + "spectrum_B['flux'] = flux_B_norm\n", + "spectrum_B['time'] = wave_B\n", + "\n", + "spectrum_A = Table()\n", + "spectrum_A['flux'] = flux_A_norm\n", + "spectrum_A['time'] = wave_A\n", + "\n", + "spectrum_F = Table()\n", + "spectrum_F['flux'] = flux_F_norm\n", + "spectrum_F['time'] = wave_F\n", + "\n", + "spectrum_G = Table()\n", + "spectrum_G['flux'] = flux_G_norm\n", + "spectrum_G['time'] = wave_G\n", + "\n", + "spectrum_K = Table()\n", + "spectrum_K['flux'] = flux_K_norm\n", + "spectrum_K['time'] = wave_K\n", + "\n", + "spectrum_M = Table()\n", + "spectrum_M['flux'] = flux_M_norm\n", + "spectrum_M['time'] = wave_M" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "445c543e", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "data_soni = SoniSeries(spectrum_O)\n", + "data_soni_preview = data_soni.preview_object\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "82914e78", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "data_soni = SoniSeries(spectrum_B)\n", + "data_soni_preview = data_soni.preview_object\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9de2f2aa", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "data_soni = SoniSeries(spectrum_A)\n", + "data_soni_preview = data_soni.preview_object\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a71a37ec", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "data_soni = SoniSeries(spectrum_F)\n", + "data_soni_preview = data_soni.preview_object\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "50dd60d9", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "data_soni = SoniSeries(spectrum_G)\n", + "data_soni_preview = data_soni.preview_object\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "df882d08", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "data_soni = SoniSeries(spectrum_K)\n", + "data_soni_preview = data_soni.preview_object\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e18f174b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO2dd3gU5fbHvye76Z0klAChSxGkSxEFKYqIIIqiotcKonIFG2KjKNd2xfKzAQKK7SIiCiqKNAWsgFKkCYQWegkkkLa7eX9/bJvZndmd3Z2tnM/z8DDzzjvvHIbk7NnznkJCCDAMwzCxRVy4BWAYhmH0h5U7wzBMDMLKnWEYJgZh5c4wDBODsHJnGIaJQYzhenBubq5o2LChfzcfOqSrLFFBdrgFCD2V56HpcbIq3BKEnsTqWuEWIeTkZBr8vnf9+vUnhBB53uaFTbk3bNgQ69at8+/mSZN0lSUquC7cAoSePenhliD0zNkXbglCT8OzY8MtQsi5Y2CW3/cSkaafkvPQNmIYhol9WLkzDMPEIKzcGYZhYhBW7gzDMDEIK3eGYZgYxKtyJ6LZRHSMiP5WuU5E9H9EtIuINhFRB/3FZBiGYXxBi+X+AYD+Hq5fBaCZ7c9IAO8GLhbDMAwTCF6VuxBiFYBTHqYMBvChsPIbgCwiqqOXgAzDMNHMpnVLcfxI6BMY9PC51wVwQHJeZBtzg4hGEtE6Ilp3/PhxHR7NMAwTuRw5tBuvTb4RE8dehlD3ztBDuZPCmOK/QggxQwjRSQjRKS/Pa/YswzBMVPPMA90BAOXnSvDQ7S3x/ZdvhezZeij3IgD1Jef1AJyHxV8YhmHkmM3OYkFnio/is9nPhOzZeij3RQD+ZYua6QrgjBDisA7rMgzDMH7itXAYEf0PQC8AuURUBGAigHgAEEJMA7AYwAAAuwCUAbgzWMIyDMNEA+VlpYhPSFK8Firfu1flLoS42ct1AeAB3SRiGIaJYkrOnMCYW5sBAJJTM1B+rkR2PVTKnTNUGYZhdOTXlZ85jl0VOwAIUR0SOVi5MwzD6EhScprH62y5MwzDRCGuvvbUdHkbNbbcGYZhgshX/3sJG/74Tvd133t1lOw8PSNXPiFSNlQZhmFikYWfvggAeP/rYt3W3Lx+mduYMT5eds5uGYZhmBBgNpt0WaeqshyvTrrBbTy7hrzUFrtlGIZhgoTUej5Xqo/lXlVVoTieX9ACGVk1FZ8dTFi5Mwxz3mGRWOtnS07qsqbZVKk4HhcXh8bNOzrO2XJnGIYJEtKaL2dLPVU092FNU5XiOMUZQJL6imy5MwzDBAmpn91iseiy5mP3tFUcNxp4Q5VhGCYkSN0yerhJTh47oHrNYIwHkVJl9ODCyp1hmPMOqVtGj7jz7796W3aenumMba9dtym6974p4Gf4Cit3hmHOO+SWe+DKPY7UVWnnHteiY7eBuHnECwE/xxdYuTMMc95x+OBOx7Eebhmh3HwOANxcMuxzZxiGCRKvTx7mONZD2Ypq+QeEko+dFDuSBg9W7gzDnNfoYbnv2PILAKBJ884Br6UXrNwZhjmvcLXUA7Hcy8tK8Mn0x3Fgz98AgOv/paFHKhcOYxiG0R9XFwo8+Mu9MXXCUOzesdZxnpiUojo31OGQbLkzDHNeYak2y86rq/1X7lLFDgDx8Yl+r6U3rNwZhgka21ZvQ9HWonCLIaPaIlfuerpJ4uIMXudwtAzDMFHPvAnzMOuBWeEWQ4bF7GK561jIi+IiR6Wyz51hmPMKSxAtd3IkMxGG3fUcik8ellzU7TGaYOXOMExQOLTjULhFUKTaxefubyhktWRjNq9WA3Tvc7PMLdN/yGj/BNSJyPkOwTBMTLHj5x3hFsENs9mET2Y8IRvz1wf+w8J3HMeXD7gb1978uCa3jKdsVj1h5c4wTFBY9dGqcIvgxqolc7B2zZeyMX+UbWXFOXw22xnTbrfYPdWY4VBIhmGYIFFZWe425h737h1TlbzrUtMW1szUcJT2VYOVO8MwuiN1dcQZIkfNSH3i195idc/445Zx3ZRtYlfuWqJlOBSSYZhoZdPSTY5jiosca1aqfI1Ga4ckfzZUXTdlHevbLHcuHMYwTMwwb+I8fPToRwCAfRv3OcbjDHE4e+psuMSSIVWwBpty98eSlsbKj3/hG/fnRIB7hpU7wzC6sG3VNhSuLwQAbF+z3TFuqjBh6vVTIyI0Uvotwh6T7o+TxGxxNvto3voSpSf5saq+aFLuRNSfiHYQ0S4iGq9wPZOIviaijUS0hYju1F9UhmEiFVOlU9ltX7Md5SXuG5dFW4vw6g2vhi1EsrysFJ9Mf9xxbnfHiOpq3HlNNr74aIrmtdxKGPhAxJQfICIDgLcBXAWgFYCbiaiVy7QHAGwVQrQF0AvAVCJK0FlWhmEilO/+7zvH8WfPfOY4btGjheP4zNEzKD1RirlPz8W2VdtCKt+xI3sxaWwv2Zhduc/7YCIA4Jt5UzWvJ23TJ1/Tg+KOwFDIiwHsEkIUCiGqAMwFMNhljgCQTlZHUxqAUwD8/2hjGCaqKNqiXBys+HCx47ispMxxvPDlhUGXScrnH0zCscOFsrFqiwUAUHrmhM/r/fbTfMVxg8Ga9J9Vo5bPa+qNlvIDdQEckJwXAejiMuctAIsAHAKQDmCYUNiCJqKRAEYCQEFBgT/yMgwTQZSXlGPBfxbg+L7jiteTUpMcx0d3HXUciwDK7PqDMd67I6FzjyGa11v8xRuK45nZtXDXmLdwUce+Hu6OELcMlHcGXKW7EsAGAPkA2gF4i4gy3G4SYoYQopMQolNeXp7PwjIME1ls+H4Ddv2xS/FaWo00GBOc9uPhnc4iWlXlVTi+V/kDQS+EEDh2eA8AwBDnbse27tBHdm4waiu1pabY7Vzadzgys90t90jMUC0CUF9yXg9WC13KnQAWCCu7AOwB0AIMw8Q0FrNF9VrP23t6TO3fvGJzMERysGLxTDw+sgP27toAi0XuI3977l5kZteUjVlMyn50Vz7/YJLjeOCNjwQsZ7DQotzXAmhGRI1sm6Q3weqCkbIfQB8AIKJaAJoDKATDMDFNtYfU/Xb923l0v1SerVS9pgeFO9YDALZtWi3LTH3giQ+RkpopKc9rxWS2yvP7qi9wuGinpme0UAyD9EyoomW8fg8RQpiJaDSAJQAMAGYLIbYQ0Sjb9WkAngPwARFthtWN87gQwvddCoZhogo1V0NBmwIYE4wes1Mry4Kr3E+dOAgAmPf+BNl4p+7XAHAvFWAPb5z233tAcXGYvfCk12eYLdqsfSuhdctocjIJIRYDWOwyNk1yfAjAFfqKxjBMxKNihNrryVw85GIUrlP+El95LrjKvaBRG2zfvEb1ums5AIvF4oigUSsmVuISWaPVlRMOOEOVYRjdsVvszbs3V50jzWINBj8setdtbMrbvzqOlSz3yspzHtcsPS3fBHb15UcS3ImJYRjdiYugXqJS6hY44zxca69bLCZUVpS53iLDXjK4RZseSM/MQ9vOV/osQ8T43BmGYXxFWuY3PTcdpSdKZddTslJQdqYM1Rb9mlP7iut+gMViRkWFsuVuqqrAdwveRP1GFwIAhgx/Ehdc2M2350VgKCTDMIwi504rK0MyOBXZ0AlD3a5fdttlgABeG/YaPp8zOWjyecYpY3pmLqotFlSpWO6rln6ELz95Hl99+iIAICUtMyQSBgIrd4Zh/OLHOT/i9y9+V7wmtdwN8Qa368Z4q9Pg7MmzWDz/9eAI6AWp6ygpKRUWiwnnzp52myeEwMfTxgEAys6eAQCkpAai3CMnQ5VhGMaNnz74SfWaVHEquSNcFX6o/NBSpHHuCUkpsFjMePmpQW7zzCZnVM+JY/sBAKlpWX48j90yDMNEOGq1ZOxILXelWHdpWQJAvcpiINTIrevxujRaJjExxREG6YrSJmtCYkpgwoUAVu4ME+Mc+PsA3rj5DV3jyu0dl1zpMLADANemGAqWu1FuuZtMFbrJBgC/rPwMp04cRKNmHfDfmRsV50jj3BNtbhk7DZu2cxxXVLh3kQrECo+Yeu4Mw0Q3K99fidNHTqNoq3JZXn9wjX6xY3fHeLPcXWvS7Nr2B/7+c4Vu8r336igA1tDH3FrWCrRp6TVkc2SWu80tY0daVsHVcu/Y7Ro/pYrADFWGYaIXi8mqSF1dIYGup4Q9Ssab5W6qkLthXp10AwDg/a+L3eYGwprln+LusW/j+Xd+R2qGi3InF+VulragcFrXRw/JM2yN8fG6yhgsWLkzTIxjV6RKUSv+sPKDlarX7IpcWITbmGyeTfmnZFrj3YNNnfoXuMtAUrdMGsrOnXGcS8sPvPmf4bL7DAZW7gzDhJlzxeccddT18vVWlKr7x0/st9Ze2fjDRlz7xLXWQYlu73J9F9RvXR8tLmmBM8fOIDUrFd++9q0ucilx1XX/Vr0mVe7xCYmoqnR+yAgICCGw/Nv33O4zGANT7uxzZxgmYKbd46jvp1v3o1qN1VvIedu07T+6Py7sdSEM8Qb0/FdPJKUleZzvL3UbtARgzSTVgmszD1FdjU3rfpA11LZzcL9/NXE4FJJhGN04e8oZ6eGvct+0dBOWTlvqOPfUoMOenCTD9tjcBrlul6QbrwBg1ikksqqyHF173YD4BG0fHnEGp8uKiCCEwNlSZf9/MMI2gwErd4aJUVzdHf66A758/kv88tkvDqXuqR5MnNFdpdif61piF3BX7mrp/75SVVmORB9i0eMMzg8lIawuGVOVvuGZkgcEZ10XWLkzTAyxYvYKLHl7Cf789k+sW7ROds2fIl3SDwT7xuypg6dU57sqa+kaSiGRrvO9ldzVwu4d63Cm+Kijf6onht4+ERNfW4mivVscY1bLvRqmKqeL6bpbnwpYLoTYLcMbqgwTI5wsOonVH61Wve6P5f7nt386jk2VJiSlJWH91+tV5yspcLs7SMnn7K7cy32WUUq1xYIpj/YDAGzbtMrr/KuHjrXKKHk37bsMwMH922VJTT363oIFH/8nINlCDVvuDBMjbF7uueG0Pz73b6Z+4zguOV4CU6UXf7PtETfY4talz9WSzBSoW2bxF/4VIYuPT3QcJyQmQ4hqWRy8wZgQkFzhgJU7w8QISj5tKVXlVQGtP/O+mXhvlDM08Obnb3abY1fk8UnOcEGHW0bBcjdXmmXnJaeP48N3HnH0P/WV/Xuc7pWBNzys+T5p7DpRHIQQsgxWY4Dhj1IEV4VkmNhmy5bDKCsLTOECVoW6/L3ljhhzNT6f9HnAzzq+11kw7IJu7olBdsUlVeRZta0VFDsO6ug23/WbwNfzXsHK72bjkTtbByxrm459Nc+VKlwicuuhapRY7nFx/iWDhToUkn3uDBMGzpwpxzXXzAAAFBZODGit4sPFWPOpeiPokGLTkVIXTEpmCiauVP435tTLAWCt4HjqxEFUBehzl5bnNRi0qzepMrda7tWoltSaSUhMdhz36n9HQDKGCrbcGSZEzJ+/AT16vA4hBJ599nvd1pXGsocbT5unStRvXR//nbURD9u+VcT5oJCVOHncWRyNfLCwq6utvv/BNz8OirO6ZdTi2S+74raAZAyRV4aVO8OEinHjFuLQoTOoqrLgyy83OcYtAfYR3b1ud6CiKeJ181QBT/51NXJrFjiSjQp3WMM3s2rU8fnZpqoK7C90vlefLHdh/T8oaHyRI4nJYlP4RslmayB42xPRG1buDBMCpKF2VVXyCJFKl01FXyg9UYpVH3oP+fOHP778w+d7HP9OH/WYa9s6U5Xv7plPZoyXnUu7QXnDLndcHDncMnbL/ZVZyvXgIx1W7gwTAsrLnVZwVZVcmQei3CvOBSmLEkB5qe8K1h/LHQCSUzNk567x7ieO7cf+Qs+hnjv+/kV27ouLx265E8WBiGA2m7D0a2tdnsxs9Vo6/hCqwmG8ocowIeDjj9c6jquqLCgoyMb+/dbaJRUVgVnuweLnT3/2/Sa74e6jcnd1oZhNldZwRNs6j93dFoDneu+uUSy+RLXYm3PYlfvZkpOa79UMFw5jmNhjyRJnJcGqKjNatHBagxUV/heiCma5XE8ohUEC/rtllPClQNc/W37FoQPyao2+KHd7tExcnEGWvBTNxMa/gmEinHbtnM2aTSaLzO++fftRPPTQAmzZctjndetfWF8X+Xwlq06W4ri/bhklTCbtPV9fGD/AbcyfDVUikiUvRTOx8a9gmAgnThL3bTJVwyRpVffAA59j4cLNjrh3X0hIDU5a/Ptj3vd4XVV5++mWkXLLiBcBAGdLTmHvLv83M31R0tV25R4Xhx2blXMGHn/+awy/9yW/5bHDGaoMEyOsXbsfs2b95jjftu2ITLkHQtU59wxXtYQhX9i/ab/j+P4P7td8n6c6Mloxxls/sMaNaIfJD/XCj99/4FxfYTNS2thaij9JTERxqs04WrTpgb4DR2pe05WIbNZBRP2JaAcR7SKi8SpzehHRBiLaQkQ/6SsmwwSfTZsO4fTpwDIkXRFC4Omnv5GNPfroVzhwoBjJyf7VK6ksq8Sch+fg0I5DPkXL+Ktw8xrkKSymPFcPt4xrG7s5bz/kOF7/y9du88vOnnEbA3z0uQu7zz127F2vH21EZADwNoB+AIoArCWiRUKIrZI5WQDeAdBfCLGfiGoGS2CGCRbXXvse6tbNxOrVY3Vbc82aQuzcedxt/PDhEr/XPLLrCPb+tRdL3lniVyy3L6TlpCmvpVJhMpAN1fvGzUZGVp4sy9SVSluf0/KyEhzavwNNWnRW/SDxKRRSYrkHnQgKhbwYwC4hRCEAENFcAIMBbJXMuQXAAiHEfgAQQhzTW1CGCQUHDypbgf5y8mTgzSfUsJgsqDL7UHhMQBZe6AljohHmSjPSspWVu+u4MdGIgtYFSE5PxuF/DiMxxfeszosvHQIA+PVH9QJnOXn18O3nr2H+h886xp6Zukxxri8ffFKfe7AIrVNGm3KvC+CA5LwIQBeXORcAiCeiHwGkA3hDCPGhLhIyTAgIVmKJdCP12WcHYMKExZ7lqBZe3ScWm7/+4DZtZXHjjHHoMKCDtTOTgCYtk5yejNLKUsWyvgDQ/abusvOnvrd2Kqosq0Sbvm2QW+DeL1UrnnzlFrNJptgB4LlHlKs/+hYtY8tQpTgYjPFR0yfVE1o+ppR+FFx/E4wAOgK4GsCVAJ4hIrdAWCIaSUTriGjd8ePuX1UZJhz07fsWmjR51vtEPygtdYbzNW+unuk4aFAbANrquZh8jIvvcHUHpOemA/D+IbZ73W5MvnwySk+UIiUzBRl51szRnrf3lM0zGK3+bNeeqYkpiWh+SXOf5HPFkztl03plK11xHR987iMfno5L+92Khs3awxAX3NzOSMpQLQIgDaatB+CQwpwTQohzAM4R0SoAbQH8I50khJgBYAYAdOrUKUS10RhGmZKSCmRkJKGwUP9sxBMnzmH37uN45hlnklFamjxs8ZVXrsWjj34FAGjUqAYAq3JPSPYc3qj0AfDw/Iex5889OHXIvb+pqHa6YkS1ADzovN8+d0b1lJ1xdkXqdUcv5Bbk4ovnvpDNf2T+IwE3AXHFYFAX8IeF72hexxefe638xrjrwTd9vs8nIrCe+1oAzYioEYCDAG6C1ccuZSGAt4jICCABVrfNa3oKyjB68vLLyzBt2s94550bg7L+uHEL8eOPO2VjCQnyX7e8PKvfOiUlHvn51sJZWqxy1zl5DfKQnpOOi/pdpHwDOSNlvFmNhnh1xarkq0/JTEFKZooXiX1DL+Xqb1ONxKQUVJQHr6xDqPDqlhFCmAGMBrAEwDYA84QQW4hoFBGNss3ZBuB7AJsA/AFgphDi7+CJzTCBMW2atW7KypX/eJnpH+vW7XcbM7q4MKqrBebMuRXLlo12hEVqcsu4zLnm0Ws8zieQw7nqrY+qMd6DYg2R4amklFPTlDNipdRt0NJx/Nb/9vgdjumLrz6S0bQ1LIRYLIS4QAjRRAjxH9vYNCHENMmc/wohWgkhWgsh/OtSyzAhxmwOrJa6GmfPuqfOG41ypdWzZ1NcemkT1K6dgSRbz1HXnqJK/DxXXtCrfmsvJQjIaXWv+ngVVsxeoTpVarn3HSnfqAxVEo5duebVbugYe2zKQq/3Xdp3uONYy4eBGsH2iXOGKsOEAH9CFQsLT+DFF5e6Ndl4882f0LjxZMyfv0HxPvv8+vWz3Frr2ZW7muW+YtYKbF9jzZwsOeaMkc/Oz9Yks90ts+aTNVj90WrVeYYEp3IPdGPUX+JsG5rSD5O0dO//Tr2Usj2hSW+4hyrDhBDXxhlamDTpO6xZU4jBg9ugZcvajvG33rI2zRg3TtnKzM1NBQCMHdvL7ZrDLaPic1/98WoY4g3oMbyHbNyjG0WCVsWyeZmzZrpaOGOLS1toWstf7Buq0oSixKRUr/fZlXJScnpAz7d/SFwx6D7UrtcsoLXCCSt35rzCbK5GcXGZ7FwrK1b8g3vu+Z9f9wJASkqCajNsu3L/eNzHmLB8gizW3a5sLCYLfvpAXtlDs+XuotxP7D+B0hOlaNShkWxci1so2O3i7BuqUpkNRu+qSgiBKW//irT0GgE93/4hMWDoGN0bddgeoP+aCrBbhjmveP75H9Cly1THuVoXpMpKM1q2/A++/HIjNm48iCeeWCRT7IB1Q1SKyeT/1/kEiTvENbSwWuVDZMDYAbh2/LVe17aWsZUr5I8e+wgfPiLPM1z9sbq7BgDSalije+q2qutxXqA4NzSdMhuNzvDQQTeNAwBM+1xepkBUV6NuQQtkZgdW/cRZH0dv9chuGYYJGkuWbJOdb97smrJhpbS0EpWVZkye/D1KSpSLc2mt7Lhgwd2oW9fzBp80TLLaxZd/bK97NY/hLw1H04ubanq+dEPVjtRvb2fFLPWNVgAoaFOAEdNGoE4z35tX+0Kcwy1DeGX2ZlRVlCE+IQlDhj+Jtp2vRIMmF2HI8CcAACMfmY4ZU+8FoN9GZUjrzASR6JaeYXzEW8GuVFt9dC2KW0vy06ZN49GuXT1HTLsaBQVO94rZJP82MW/CPLf5yRnJXp8tRa2kgd1KPVmkLZErv3l+QOV8tWAPhSQi5OTVQ5361mT3QTc9hgZN5LH83XrdiAFDbYXedHJ3DLn1SQBAckpgvvtww8qdYSTYLVx7E2tPERjjxy/yul5amu8FtCwuHyynj552m5Ocrl25E0h1Q9Xu8tmycots/O6379a8frDQugncqfsgAMBFna/Q5bm9B9yN978udtSV15tIKj/AMOcd27Yd1TxXCIE331yl27PLS8uRVVvixlHQBTXq+rZpqGZtm01mGOINiDPI7bx6rer5tL6e2N0iWtP1GzVr77FxdqQQkc06GOZ84/773V0hSixevAXvv/87Xn/9R92ePWOkvN1eQZsC2fmjCx71eU01xWL/luBaACycmG0VGaWbqIzvsOXOMB6QVnUEgKysZFm3ptGj5wddhvJSeXeo1GzvMd8yFDZU7Zht7idp7fMu17tW9A4tuTWtH2aBtLSLaDgUkmECZ//+YqxYob1+DBGwcaN6nfShQ9vpIZZPuCp3X1EKhbRjV+72MEfAumkaTtIzc/D+18Xo0de1PmF0wxmqDKMjV175DiorzY7koYyMJNXQRsD6CzhkyEzV64mJof+VqTzn/Pbg6hvXije3jDT80pjAaiEWYMudiVm6d3/VLUmputpzopEn4+qpp/SJxvAFi9kCU4XJ4SrJqZ/j1zreLHeL2RmhE66aMucLXDiMYQLkyBFnTe5p09YAACwW/3+xrP1HAxbLJwrXFwKwWu83Tr4Rt71ym6b7mnWR1ETx5HO3xdRv/cnZEtlg9K8OOuMFjpZhGP15+eXl+Pvvw26VHF3xVC+mulogJ0d9M/Pdd2/E6NGXYvLkAX7LacceC71y9koAQI/hPdDyspZIz9GWWHPLi7fgivuc3zTULHeLyYJNSzdh1++7AAA3TLohELGZCIKVOxOTKCWKDBo0w2sVSG+ZqcOHd8bUqcr1XIQAHn64N267rbN2QVWwu0sO/3MYAJBZM9PnNexf/z0lMZmrzFjz6RrHeaP2jRTnMdEHK3cmJhk3znv2qBKelP+wYR1gNMZhyJC2itelhcSIgF69/C8Xa6ow6bfJSZ597ikZzjZ5kRTvHqtwhirD+MiLLy5FamoC/v3vnvjiC+WGGf7y6qtDkJnpOeVf+ku7e7dyaV+t6N10Ws1yP3f6HPZt2uc4Z3978Ah2qWRX+GOaiRlmzPgFr732Y1DWNmgIQXQtAewrY8b0dETDmKvMKDtjrTvva6kBBxJx1Cz3b6Z+Izv3N9SSiTz4f5KJCWbP/s1xfOpUmYeZ/uHa3FqJpKTAvgiPGdPL0bfUVGlyKPcBYwPboPUleYaVewjgDFWG0UZJSQWmTFniOO/U6b+6P8Obcr/55o7o0yfw+HC7b91cZcbO33cCANKyPZcLVkPqJgp2mV7GO1w4jGF8xJ8+qL5i9OKLHjmyO+J0UKDxidZ2e+ZKM47tsTbp8Nctk5hiLTdMpB4tw8QurNyZqMdee10NNavbkzJOSDDgjz+c1Re9We41avhYzEsFu+VuqjQhMSURWXWyEJ8U79darXq2QuverdHtxm5suUcQnKHKxCTV1QIPPP8t1m9Vbm/nD94sdzVfuCeFvXz5v5Gbm6pp7saN45Ge7ntTDkWZEp1umaqyKof17Q8pmSm4/pnrkVYjjS33SIDdMkwsc+h4Kd75bB0enbpUtzW9We7Scrbycecv2/Tpw2TX6ta1Jg1lZVnDH+Pj1d0yeil2QOKWqTKjsrwyIOUuRWq5j/nfGIydO1aXdZnIhZU7E1KqbBmgv2w8oN+aXix3NffLiy8Ochzn52ciOdnd/ZGfb1XyCSGqlCh1y1SVVyEhWZ+GFVLLPat2FtJzo7s/KOMdTmJiQsaPa/fi5w37ATiVvB54t9yVlXuTJrmOY6PRoFh3xl5rxpPlrieOaJlKq1smq1aWlzu04epzVwp5vO7p63R5FuMZzlBlYo7L75kTlHW9We6u/ua4OHJLOLrggjxF5W4vEawlzl0PZG6ZskokpOhvuSvxzLJnOMY9yHCGKsP4yB9/7PN4XWq5FxZORF3RYEwAABw0SURBVIsWtQBYc0kWLhyBhQtHgIgUywHbx/QIc9SCwy1TpbNbxia/Wj14VuyxB/+PMmHBYNBPWXprTu2qmKVGbJs2+WjTxtpWrmnTXLjSr581MSkvT55INGxYez8k9Q7FEQzxBqtbJgg+dw6JjAA4Q5UJJ9XVAmfL9C1eJcUYQktRq9X9ySe3u4099lgfrF//GDIykmTjzz9/jS6yKWFMMKLibAVEtUBCks7KXfLJdu979+qyNqORSAyFJKL+RLSDiHYR0XgP8zoTkYWIhuonIhMOHp36A9K7vYBKL5uV/lIZQFbpyy8vw623fqh5vtYYb1frHLAWDMvOTnEbD2bceHxiPMpLrE2x/U1gcsVusUvlrt20Nh754hE8/vXjujyDiSy8bqgSkQHA2wD6ASgCsJaIFgkhtirMewnAEvdVmGjjg0XWkrml56qQGGENk6dN+1nTvH79mmPp0h2qlnugUQuPPto7KFE0xgQjykvLHcd6oGS5A0BaDf/q1jCRjxbL/WIAu4QQhUKIKgBzAQxWmPdvAF8AOKajfEyIOHy8FM+8tcIRRWJ3m+hhuVdXC1DbybKxzhfmB7yunT59LlAct9eDcfe562N133//pRgxorsua0kxJhqDZrmHOGCDUSCSyg/UBSDNOCmyjTkgoroAhgCY5mkhIhpJROuIaN3x48d9lZUJIvc+9w2mvLcaq/+UR56YPPQU1cr0+evcxrTUR9dKssqmo/0ZvkS6JCfH4/LL/e+gpAfxCfEOy90eGqkXXIYgfERiVUgliVw/el4H8LgQwqMjVQgxQwjRSQjRKS8vT6uMTJBY/nshZi74EwBgtsV497pbHouuR7LRll3uH+TeGlVr4dy5KixZsg1//aWc7Rofb/3xdv2latbM+rOXluae2r9ly5OYNeuWgGULBGOCxHJn5c74iRaHXhGA+pLzegBcqz51AjDX9oOTC2AAEZmFEF/pIiUTFPqO/AgAcM91HZAY7/xRkPqiTebAlLvJZMG7n7tb7pYAuxYBQHm5CffdN082dvfdXTFrlrVxh12RuVruU6YMxPXXt0OjRsox3+HGmGB0tNnTyy3jgHV7+AmNV0aT5b4WQDMiakRECQBuAiDrPiyEaCSEaCiEaAhgPoD7WbFHD0IIJCU6lXtFpdPPHqhbZvGanYrt5yzVgVvuSu6Wp566EnXqZHicl5wcj+7dGwX8/GAhTSjSq6epsP0fcJx7+Ii4DFUhhBnAaFijYLYBmCeE2EJEo4hoVLAFZILPG5/8jiRJVMa5cpPj2O6WeXfeWlDbyY5aK1pRyvoEoLrO5p1H8cKs1ZrWVutZarfY7df19O+HAqly1ytz1P5tLNQKhgkfmuKshBCLASx2GVPcPBVC3BG4WEwoeei/8ujVbv+ahePF1v6dJrMFv28qwv3/sf731+r9Co6ueFRzrRW1eWpumU43v4cqkwXj7rgEQBw2bz6E/PxM5OS4N8NQC2W0j2dlWROPevZsiu3bj2qSNxIgSfau3pY2W+7hhwuHMUHFU/bprv2nHMc97nhfdu3UmXL8ue0wDp8oxeDLW3h9jkFFmahtqNq/KVjdQXEYPPg91KqVjrvv7orWrfPx2297HXPVLPfDh0sAAKmpiVi2bDQaNMjG9OnaYuMjAWn9ed0sd7tbhjdUw0eI3z0r9/OU56b/5Pe9d05YiK2Fx2H5a4LXMEM1C33n/lOgtpPx2ctDsedgMcbdeYnMhfPfD37G8EcuAwAcPVqK5593b+4hVe5GYxzeeON62fWzZyvRuHFkbpp6IphuGfbKnD9ElzOS0Y26NTO8T1Jha6E1tPH9r/7yOtc1lPKzl4fitoEXOc6HjZuP8W8sx4btR9D46jcc4xPe+dGrK0Wq3C+6KB9XXdVKdj1UZXr1Ruo60d3nzpb7eUN0/vQzASONjvGXp95a4XWOPcO1RSNJYwwFhVVlsuDAkRLZ2NChsz2ufe5cpeNYSWmFqsGG3kgVum4+crvhzso97ITK587K/Twl0Ph1ACi3hUyazdX4e6d71Yk9RcV4fuYaAEBGqjVhSAihWO53/rKtbmPlkqgdJfr3f9dxrOQeilbLXeZzV+n/6is1G9cEAFxy8yW6rMf4Tqg/V6Pzp58JGD3KCtjj4Z96cznaDH0Xuw+ckl1vfPX/OVw49m8KQgAGBYX1ypxfA5JFSblHq5UqjZbRyy2TnJ6MiSsnolnX8JZWYEIHK/fzFD0sd7s//fOlVqv78PGzEEJg4jsr3Sz5BImLRM9GHXZiSblLrXUOXYxF2C3D6ExZuQnPTf8JWT1exLjXlinOmTVpkOL4Q7d2lSloABjaz7qBuefgaQBWBXvXhEV4dvoqtBn6rmyuTLnr5GqQopYsZeeuu7ri9tsv1v25wSAY0TJM+Am1scGhkOcJMxf8iRGTv/Y6r3XTmorjrz52JXpf3AjXPPg/THv6arwwew1SXOqeVFaZHXXgXUkMsuVu9vJN5Omnr9T9mcEiGG4Z5vyDf3LOE7Qo9nhjHOI9bEJefVkz/DznLowc2hEpSfEorzTJQh17j1DvjhRvq5EiIIJiuUvDIiO5bowWghItw0QMHC3DhJSHbu2KqvXPOJSwEkSE7u3qg4iQnBiPsnITTp0p17S+9BvpyrV7A5TWHaly79ixvtszo4lgRMswkUCEFQ5jop9V6/d5nWNXhHVrpWta02q5mzUr97QUa0ONhHhDUCwXtVIE0Qj73Bk9YJ97jHO6pAI97/rA6zz7Zk92RrKmdZMTjThbXqVJub/66BW4c3B71KuVgWsvb4G3567V9IzzFakrht0yjL+wWRDj9Bmp7geXInVh9Oki91nfO7Sj2/zkpHiUVZhwqkRZuQ+78kIAQJtmNfHQbd2QlZGESff1gsEQB70M94QEpwuJLXcmWmCfO6MLf2477PF6t7b1AABxEu3+zZu34MRPjznOpz0z0O2+lKR4lFc43TL1a8tr1dhDHwtqZ7rdW+3HD3d+vvs60th2qXKvjvIKiBznHptEYg9VJoa51la2V+qOSUo0IicrxeN9yYlGlFWY8M++kwCAzfPvwxvj+juuX9GtCT554Tp89PwQt3u1WNm7vvm343j79qexZs1YbNw4Hvfc080xbpJE6shaA9rGpZZ9NCGLlonSDygm/LDPPYYxeWlufV2flhh908UoOVeJsbd2VZyTn6e8wWoPhXxhlrV2THpqIh4c3gX/vuVirFq/D5d1bKCqmLR8LW1SvwZWrx4DgyHOoaTT0xNlXZWkiUvSNfv2bY4ZM35Bz55NvT4nEqEg5AEwkQQ362D8RAiBV+b8gn5dm3icN6R3C6Qkx2PK6N6K1/9ZNBp52e4dkAAgOcmIk6ed/na7i4SI0LNTQ4/P1eqWqVs3y21MLQFK+m2gU6cCFBZO1PSMSITDH2MUdsswgXL4+FmMe20Z2g+bLhu/8YoLZVmlN9o2PdVo1iAHWRlJitca5jsV7xXdPH+IuOLqlhl1g3XD1lvjD0C992qI9qhCAm+iMnrAP0UxyInTZYrjcXGEsgprGd2Jo3q61YrxBaky9bUImasifnFMXwBWw2bK6Mvx59yRqvfeeGMHxfFYipbhTdTYhqNlGL/pcNN0xXGpArQreX8xS3qgeurHqiiHyw93su3bRLzRgKdGXIb2Leuo3tu4cQ7mzbvTfc0YUu5succmxBmqTKCoVUiUKlW1BtVa6dG+wHF85mylh5nu5GVbI3EeGNYZ9WtnIN4Yh6dHXIpfP7xb0/3K7psYUu7sc2d0gH+KYoiKSjNufWKB6nXp10F/Ys2ldLowH+v+NwIAHOGQWvlwyhBMe/pqvPXkAOxf8hCICM+N7o12LWprul9JubPlzjBy+Kcohlj+eyE+WbxZ9fqgXs0dx3ooww4t62DE9R3ww7RbfbovNzsF997Qye/nKoVYxpJyZ597jMM+d8ZXhjz0meq1Z+/vhX9d09Zx7q25hRaICDMmXIN+PkbLBIpBwbLlaBkm0uFmHYxfVJksin1Rm9TPRmpyAka61IexVAfeQzVcKP2OhCoCgWGiBTYRYoTavV9RHG9avwY2fj4KtXLSAABX9bBmbUazG6Oqyj308vDhkjBIwjC+I7iHKuOJ8goTThQ749mLSyoU57k237DXkgl0QzWclCmEXubkKGfSMkzEwG4ZRgs97/oAa7ccgtjoOc3e6OK/Ndg26/TwuYeLeJfkqyee6Ic+fS4IkzQME5mwco9CVq3fh7VbDgEADhw546bApcTHuyh329xottw7d3bG2H/zzb1o1UpbCCXDnE9ocssQUX8i2kFEu4hovML14US0yfbnFyJqq7QOow/SzkoFV76O/L6vqs79/IetsnN7jHg0+9ylUQes2JloI1Sb/14tdyIyAHgbQD8ARQDWEtEiIYRUa+wB0FMIUUxEVwGYAaBLMARmAsPelMMSxcodAMaM6Rlwli3DhJJQlx/Q4pa5GMAuIUQhABDRXACDATiUuxDiF8n83wDU01NIxslplY1TNa7v21J2HguWOwCMGdMr3CIwTESjxS1TF8AByXmRbUyNuwF8p3SBiEYS0ToiWnf8+HHtUjIOKk1mn+bbo2PsGGJEuTNM1BJBGaqaqzQR0eWwKvfHla4LIWYIIToJITrl5eVpl5IBAPzwy27U7j3Vp3tcm1vYG2mMvrmzXmIxDKOBSMxQLQJQX3JeD8Ah10lEdBGAmQCuEkL4VkmK0cSz03/y+R5XP1/t3DSv4ZNMZNCsS7Nwi8BEMVos97UAmhFRIyJKAHATgEXSCURUAGABgNuEEP/oLyYDKNdU8Qb3V45ektKUu2Ax0U3ENOsQQpgBjAawBMA2APOEEFuIaBQRjbJNmwAgB8A7RLSBiNYFTeIYY8WePSguL/c+Ec5IFykP3nKx53u4wmDUkZGXAQDIbZAbZkkYXYlAtwyEEIsBLHYZmyY5vgfAPfqKFrv8cfAgaqelISc5GX0+/BCX1K+Pd6++GttPnMANF6r3NS05594UIy0lQXY+6oaOmPb5esd5qP18TOA0bNcQd7x+B+q3ru99MsOowBmqIeKfkydRLQRa5Oaiy8yZ1rHRowEAPx84gIumWT8rhYJyHzpvHoalXShrbWcnOTFedu6q7Fm3RycN2jYItwhMlMPKPUQ0f+stAICY6NzMXFpY6DavWgg398sX27bhi8e2ycbaNKuJzTuPISlR/l9ocGnRpuTKYRgmnESIz50JHg8sXuw29p9VqxzHlupq9J4zR/FeuxWf4FL10dXHzm4ZhokMQv27yMo9SOw/cwZPLFuGUd98IxvfeOSIx/sm/PgjzlVZS9oeOXsWK/fuVZyXm2VtMl23VrpsvGOrOrJzA2+oMsx5CbtlgkSD1193HL/Qp4/juN306V7vXW6LoPn6H/Wo0ifvuRQnistwXR9neYEN8+5F2+a1Yf7zGdz+9Ff4ZPFmZGVwOB3DRBIRUziM8R3X/7waL7+sOvfqZs3w7c6dsrHV+/bhlV9/9fiMpAQjbh14kWysbXNrhUSDIQ5vPzkAl3YoQI/2BUq3MwwTciIwFJLRzhUffaS4UaqGfQM0PSEBpTZ3TEFmptf70lMTPF7PTE/CvTd00iwHwzCxBfvcdaSwuNgnxQ4AWUlWt0mvhg0dYyWV7vHsUuZMuRYdW+X7LB/DMOEnVH1y2HLXkTu++srne25o1QpnKirw5lVX4a8jR1BUUoI9p097vOdf13AvFIaJNjhaJko5evYsVu/f73FO/6ZNcXf79nhRssHaODsbX910E+pnZuLAQw8hJzkZaw+51WXzSl52is/3MAwTu7Dl7iddZs5EaWUltj7wAADg7kWLvNwBfDd8OABrotL45csBACnxLhmmCQnYdPSoT7Ls+36sVx88wzDnF2y5+8kfBw9i24kTAIDTFRVuES+udK3nbE4VR4S0BKsyTnVR7tnJyaprdLowH0dWPOI2XlAnE9kZ6vcxDBNJcIZqVCCEQPZLL8nGFtx4o9u8X+66S3ZuslgAuFvurWvWVH1WjYxk1MpJ81dUhmHCCPvco4wyk8ltrEmNGrLz61u2dPuPfffqq1EzNRXJLso9PUHdvVIdqm12hmGiHva5B8isv/6SnXfKz5dZ40lGI+YrWPJ3tm+PO9u3dxv3pNwz0xIDkJRhmEiAM1QjlJLKSjz7k7Pd3Zjvv3cc7x0zBg2ysnCotNTv9dMUlHv1hAl47dxvuH0Qh0AyTPTCGaoRy7tr1+LzrVtVi3k1yMoCIPejT73iCp+eIXXTTOrZE13r1QMR4eF/dfNdYIZhzlvOS+V+sKQEmUlJilbyg999hyqLBdMGDsT2EydwsKQEfRo3RoXZjPsVSvQqkWx0vtb7O3f2STbpvRN79fLpXoZhGDtRrdz3FBejx/vv49tbbkG72rVV5206ehQJBgOa5+Tg6k8/xXe7duGCnBzssHVCOltVha4zZ+JkeTmOnD0LALirfXvc8sUX2F1cjGsuuMBjhUZXEgzWGutTLr/c539TkjGq/0sYhvEC+9w1MGXVKhwqLUX76dNlHY5caWtrYff0pZfiu127AFjb3gHAD7t3Y/Dcuagwm2X3rN63D7uLiwFAk2J/Z8AAxzEReZTHE67RMwzDxAah7psT1cr9jKTA1rpDh9ApPx+Ld+7EvC1bsO/MGfy4dy/WjxzpmDNl9Wq3Na78+GPFtT/evNknWXoU6FNa1+6W4RYbDMMEQlQr92aSePLO772Hc08+ias//VQ2p+OMGar3V9kSiZTY4KVjkiupHkIYfcHulnHthcowTKzAGapeiTfI+4ceP3fOp/sTp0yRneeleC++tebOO/Hj7be7jbtmmvqL3S3Dja0ZJrbgDFUfcM3YvGT2bNW5jbOzva537LHHsGfMGI9zjHFxsjoxdpQib/zB7pYxsHJnGCYAolq5W6qrER8Xhzf69wcAHPSQPDR70CCPa/10xx0AgIa2WHVXVt1xB8Z1745O+flINBqx5NZbZdddC4D5i90tw5Y7w8QmoYqWiWrlXi0EDHFxmtwpPRs2hJg4EZvvu8/tWvvatXFZgwaO89G22PQWubkY06ULAKBjfj5e6tfP4Qu/okkT7B871nGPXl+57G4Z9rkzTKzBGaqasQiBOCL0bdxYdc7ACy7AQ127Os5b16yJl/r2xePLlqne88oVV2B3cTGeu/xytK9TB89cdpmiT71+ZiZ2P/ggdtrCKvWA3TIMw+hBdCv36moYiJCXmoqrmjZ1xLADQK3UVKwbORL1MjLc7nO19KcPHCg7TzQasdjWWAMAcjx8M2icna3Jn6+VjERrcbDrWrbUbU2GYc4/olq5290yAPB8nz4O5V7x1FNI9JDpeXu7dqiRnIwLcnLQMCsrohKHMpOSsG7ECDTPzQ23KAzDBAPOUPWO3S0DABfk5KBXw4Z4vndvj4odsG5WDm7RIhQi+kXH/Pxwi8AwjM5EZCgkEfUnoh1EtIuIxitcJyL6P9v1TUTUQX9R3bG7ZQBrnPnK229Ht/r1Q/FohmGYiMarciciA4C3AVwFoBWAm4molcu0qwA0s/0ZCeBdneVUpFpiuTMMw0QDkVQ47GIAu4QQhQBARHMBDAawVTJnMIAPhVXq34goi4jqCCEO6y3w77//jjcXLEAcET7atEnv5RmGYYLKe6+NQufmJgwbNiyoz9Gi3OsCOCA5LwLQRcOcugBkyp2IRsJq2aPAz0JbJ0+exG9FRY7s1E7sn2YYJgo4deIgAKDk9HHs27cv6M/TotyV/B6u3yu0zIEQYgaAGQDQqVMnv76bDBgwAAMefNC+nj9LMAzDhJzKijIAQL9BozBu3LigP0+Lci8CIN2lrAfgkB9zdCfUu88MwzD+0q3XDThc9A8G3RR8xQ5oi5ZZC6AZETUiogQANwFY5DJnEYB/2aJmugI4Ewx/O8MwTLQSn5CEYXc9h+SU9JA8z6vlLoQwE9FoAEsAGADMFkJsIaJRtuvTACwGMADALgBlAO4MnsgMwzCMNzQlMQkhFsOqwKVj0yTHAsAD+orGMAzD+AuXHmQYholBWLkzDMPEIKzcGYZhYhBW7gzDMDEIK3eGYZgYhJU7wzBMDELhSuEnouMA/C2wkAvghI7i6AnL5h+RKlukygWwbP4SqbJplauBECLP26SwKfdAIKJ1QohO4ZZDCZbNPyJVtkiVC2DZ/CVSZdNbLnbLMAzDxCCs3BmGYWKQaFXuM8ItgAdYNv+IVNkiVS6AZfOXSJVNV7mi0ufOMAzDeCZaLXeGYRjGA6zcGYZhYpCIUO5ElEREfxDRRiLaQkSTbeOTiOggEW2w/RkguecJItpFRDuI6ErJeEci2my79n+kU7smIjIQ0V9E9I3tvAYRLSWinba/syNItoh4b0S017bmBiJaZxsL+3tTkStS3lkWEc0nou1EtI2IukXCO/MgW9jfGxE1lzx/AxGVENHYcL83D3KF5p0JIcL+B9YerGm243gAvwPoCmASgEcV5rcCsBFAIoBGAHYDMNiu/QGgm23N7wBcpZOMDwP4FMA3tvOXAYy3HY8H8FIEyRYR7w3AXgC5LmNhf28qckXKO5sD4B7bcQKArEh4Zx5ki4j3JnmuAcARAA0i5b0pyBWSdxYRlruwctZ2Gm/742mndzCAuUKISiHEHlg7QF1MRHUAZAghfhXWN/IhgGsDlY+I6gG4GsBMFxnm2I7nSJ4TCbKpEVLZPMgQ9vfmo7whkYuIMgBcBmAWAAghqoQQpxEB78yDbGqE6/+zD4DdQoh9iID3piKXGrrKFRHKHXC4FjYAOAZgqRDid9ul0US0iYhmS75W1QVwQHJ7kW2sru3YdTxQXgcwDkC1ZKyWsPWJtf1dM4JkAyLjvQkAPxDReiIaaRuLhPemJBcQ/nfWGMBxAO+T1c02k4hSERnvTE02IPzvTcpNAP5nO46E96YkFxCCdxYxyl0IYRFCtANQD9ZPq9YA3gXQBEA7AIcBTLVNV/I3CQ/jfkNEAwEcE0Ks13qLigyhlC3s783GJUKIDgCuAvAAEV3mYW4oZVOSKxLemRFABwDvCiHaAzgHqztBjUiQLRLem/WBRAkABgH43NtUFRmCIpuCXCF5ZxGj3O3Yvur9CKC/EOKoTelXA3gPwMW2aUUA6ktuqwfgkG28nsJ4IFwCYBAR7QUwF0BvIvoYwFHb1yXY/j4WKbJFyHuDEOKQ7e9jAL60yRH296YkV4S8syIARZJvrfNhVahhf2dqskXIe7NzFYA/hRBHbeeR8N7c5ArZO9NjsyDQPwDyAGTZjpMBrAYwEEAdyZyHYPVHAcCFkG88FMK58bAW1s1Y+8bDAB3l7AXnpuV/Id+seTmCZAv7ewOQCiBdcvwLgP7hfm8e5Ar7O7OtuRpAc9vxJNv7ioifNRXZIuK92dadC+BOyXmkvDdXuULyznRRLDr84y8C8BeATQD+BjDBNv4RgM228UUuL+UpWHeTd0Cycwygk22N3QDegi0LVyc5e8GpQHMALAew0/Z3jQiSLezvDVYf7Ubbny0AnoqE9+ZBrrC/M9ua7QCss8nxFYDscL8zL7JFyntLAXASQKZkLOzvTUWukLwzLj/AMAwTg0Scz51hGIYJHFbuDMMwMQgrd4ZhmBiElTvDMEwMwsqdYRgmBmHlzjAME4OwcmcYholB/h+9JSZUPFhDiQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], + "source": [ + "data_soni = SoniSeries(spectrum_M)\n", + "data_soni_preview = data_soni.preview_object\n", + "data_soni_preview.sonify_preview()\n", + "data_soni_preview.play_preview()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From c41c9c0447fe5cd4abe46a29f77cfe9fdc2df014 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Thu, 15 Dec 2022 18:13:02 -0500 Subject: [PATCH 22/93] WIP: flipped colors in plots to match wavelength order, added two modes for preview type = scan and ensemble, ensemble plays with diff pitches and the combined, scan plays with same pitch and no combined at the end, re-wrote OBAFGKM notebook so it fetches sample spectra from public Box links at STScI, no assumptions made about location on user's computer, still need to finish the BAFGKM stars, but both versions for O star work --- astronify/series/series.py | 53 ++- notebooks/OBAFGKM_demo.ipynb | 465 +++++++---------------- notebooks/astronify-snapshots-hack.ipynb | 2 +- 3 files changed, 159 insertions(+), 361 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index eedb3fd..e4f8631 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -110,7 +110,8 @@ def pitch_map_args(self, new_args): class SoniSeries(): - def __init__(self, data, time_col="time", val_col="flux"): + def __init__(self, data, time_col="time", val_col="flux", + preview_type="scan"): """ Class that encapsulates a sonified data series. @@ -122,10 +123,18 @@ def __init__(self, data, time_col="time", val_col="flux"): Optional, default "time". The data column to be mapped to time. val_col : str Optional, default "flux". The data column to be mapped to pitch. + preview_type : str + Optional, default "scan". The mode of preview/gist sonification to + make, choice of "ensemble" or "scan". Ensemble means each section + is assigned a different pitch, played separately, then all sections + are played together at the end. Scan means each section is assigned + to the same pitch value, played separately, and no combined sound + is made at the end. """ self.time_col = time_col self.val_col = val_col self.data = data + self.preview_type = preview_type # Default specs self.note_duration = 0.5 # note duration in seconds @@ -133,7 +142,6 @@ def __init__(self, data, time_col="time", val_col="flux"): self.gain = 0.05 # default gain in the generated sine wave. pyo multiplier, -1 to 1. self.pitch_mapper = PitchMap(data_to_pitch) self.preview_object = SeriesPreviews(self) - self._init_pyo() def _init_pyo(self): @@ -319,8 +327,10 @@ class SeriesPreviews(): def __init__(self, soniseries): # Allows access to SoniSeries class methods and variables self._soniseries = soniseries - # Define the frequencies to use for each piece. - self.pitch_values = [300, 400, 500, 600, 700] + # Define the frequencies to use for each section. + self.pitch_values = [500]*5 + if self._soniseries.preview_type == "ensemble": + self.pitch_values = [300, 400, 500, 600, 700] # TODO: Make robust self.n_pitch_values = len(self.pitch_values) # Amplitudes will be stored as a % between 0-1. @@ -351,11 +361,11 @@ def plot_preview(self, xdata_bin_ranges): plt.plot(self._soniseries.data[self._soniseries.time_col], self._soniseries.data[self._soniseries.val_col], color='k') - plt.axvspan(xdata_bin_ranges[0][0], xdata_bin_ranges[0][1], color='r', alpha=0.5, lw=0) - plt.axvspan(xdata_bin_ranges[1][0], xdata_bin_ranges[1][1], color='orange', alpha=0.5, lw=0) - plt.axvspan(xdata_bin_ranges[2][0], xdata_bin_ranges[2][1], color='y', alpha=0.5, lw=0) - plt.axvspan(xdata_bin_ranges[3][0], xdata_bin_ranges[3][1], color='g', alpha=0.5, lw=0) - plt.axvspan(xdata_bin_ranges[4][0], xdata_bin_ranges[4][1], color='royalblue', alpha=0.5, lw=0) + plt.axvspan(xdata_bin_ranges[0][0], xdata_bin_ranges[0][1], color='royalblue', alpha=0.5, lw=0) + plt.axvspan(xdata_bin_ranges[1][0], xdata_bin_ranges[1][1], color='green', alpha=0.5, lw=0) + plt.axvspan(xdata_bin_ranges[2][0], xdata_bin_ranges[2][1], color='yellow', alpha=0.5, lw=0) + plt.axvspan(xdata_bin_ranges[3][0], xdata_bin_ranges[3][1], color='orange', alpha=0.5, lw=0) + plt.axvspan(xdata_bin_ranges[4][0], xdata_bin_ranges[4][1], color='red', alpha=0.5, lw=0) plt.show() @@ -441,7 +451,6 @@ def sonify_preview(self, plotting=True, verbose=False): print(' ') print('Tremolo Vals (x10) = ', self.tremolo_vals) - def play_preview(self): """ Play the sound of a "preview-style" sonification. @@ -459,14 +468,11 @@ def play_preview(self): # TODO: Generalize the self.delays list # `step` must go into `stop` 5 times, since we have 5 pitches - #start, stop, step = 0, 2.5, 0.5 - #self.delays = np.arange(start, stop, step) self.delays = [0., 2., 4., 6., 8.] # `total_duration` is in seconds self.total_duration = 8.0 - default = 1.0 #float(min(self.amplitudes))#float((max(self.amplitudes) - min(self.amplitudes))/2) self.amplitudes = [amp/max(self.amplitudes) for amp in self.amplitudes] a = pyo.Phasor(self.pitch_values[0], mul=np.pi*2) @@ -484,22 +490,15 @@ def play_preview(self): lfo5 = pyo.Sine(float(self.tremolo_vals[4]), 0, float(self.amplitudes[4]), 0) if self.tremolo_vals[4] > 0 else pyo.Cos(e, mul=float(self.amplitudes[4])) self.stream1 = pyo.Sine(freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1).out(delay=self.delays[0], dur=2.0) - self.stream2 = pyo.Sine(freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2).out(delay=self.delays[1], dur=2.0) - self.stream3 = pyo.Sine(freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3).out(delay=self.delays[2], dur=2.0) - self.stream4 = pyo.Sine(freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4).out(delay=self.delays[3], dur=2.0) - self.stream5 = pyo.Sine(freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5).out(delay=self.delays[4], dur=2.0) - # All together - self.stream6 = pyo.Sine(freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1).out(delay=10, dur=4) - - self.stream7 = pyo.Sine(freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2).out(delay=10, dur=4) - - self.stream8 = pyo.Sine(freq=[self.pitch_values[2], self.pitch_values[2]],mul=lfo3).out(delay=10, dur=4) - - self.stream9 = pyo.Sine(freq=[self.pitch_values[3], self.pitch_values[3]],mul=lfo4).out(delay=10, dur=4) - - self.stream10 = pyo.Sine(freq=[self.pitch_values[4], self.pitch_values[4]],mul=lfo5).out(delay=10, dur=4) + # All together, if in ensemble mode. + if self._soniseries.preview_type == "ensemble": + self.stream6 = pyo.Sine(freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1).out(delay=10, dur=4) + self.stream7 = pyo.Sine(freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2).out(delay=10, dur=4) + self.stream8 = pyo.Sine(freq=[self.pitch_values[2], self.pitch_values[2]],mul=lfo3).out(delay=10, dur=4) + self.stream9 = pyo.Sine(freq=[self.pitch_values[3], self.pitch_values[3]],mul=lfo4).out(delay=10, dur=4) + self.stream10 = pyo.Sine(freq=[self.pitch_values[4], self.pitch_values[4]],mul=lfo5).out(delay=10, dur=4) diff --git a/notebooks/OBAFGKM_demo.ipynb b/notebooks/OBAFGKM_demo.ipynb index d3f12b6..65c471b 100644 --- a/notebooks/OBAFGKM_demo.ipynb +++ b/notebooks/OBAFGKM_demo.ipynb @@ -11,28 +11,16 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "6a5a4813", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "WxPython is not found for the current python version.\n", - "Pyo will use a minimal GUI toolkit written with Tkinter (if available).\n", - "This toolkit has limited functionnalities and is no more\n", - "maintained or updated. If you want to use all of pyo's\n", - "GUI features, you should install WxPython, available here:\n", - "http://www.wxpython.org/\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "from astropy.io import fits,ascii\n", "import numpy as np\n", + "import os\n", + "import requests\n", + "import matplotlib.pyplot as plt\n", "\n", "from astropy.table import QTable, Table, Column\n", "from astronify.series import SoniSeries" @@ -40,247 +28,152 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "808908c9", "metadata": {}, "outputs": [], "source": [ - "O = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/1-Type_O_Stelib_HD269698.fits\"\n", - "B = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/2-Type_B_HD003369_s0020.fits\"\n", - "A = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/3-Type_A_HD031295_s0166.fits\"\n", - "F = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/4-Type_F_HD222451_s0889.fits\"\n", - "G = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/5-Type_G_HD114606_s0462.fits\"\n", - "K = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/6-Type_K_HD233832_s0410.fits\"\n", - "M = \"/Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/7-Type_M_HD036395_s0183.fits\"" + "# File names to save each file when downloaded for the Miles exmaple spectra.\n", + "ostar_filename = \"1-Type_O_Stelib_HD269698.fits\"\n", + "bstar_filename = \"2-Type_B_HD003369_s0020.fits\"\n", + "astar_filename = \"3-Type_A_HD031295_s0166.fits\"\n", + "fstar_filename = \"4-Type_F_HD222451_s0889.fits\"\n", + "gstar_filename = \"5-Type_G_HD114606_s0462.fits\"\n", + "kstar_filename = \"6-Type_K_HD233832_s0410.fits\"\n", + "mstar_filename = \"7-Type_M_HD036395_s0183.fits\"\n", + "\n", + "all_filenames = np.asarray([ostar_filename, bstar_filename, astar_filename, fstar_filename,\n", + " gstar_filename, kstar_filename, mstar_filename])\n", + "n_stars = len(all_filenames)" ] }, { "cell_type": "code", - "execution_count": 3, - "id": "e71b17db", + "execution_count": null, + "id": "0280bcc1", "metadata": {}, "outputs": [], "source": [ - "hdu_O = fits.open(O)\n", - "hdu_B = fits.open(B)\n", - "hdu_A = fits.open(A)\n", - "hdu_F = fits.open(F)\n", - "hdu_G = fits.open(G)\n", - "hdu_K = fits.open(K)\n", - "hdu_M = fits.open(M)" + "# These \"share\" URLs are used to download the sample files.\n", + "ostar_link = \"https://stsci.box.com/shared/static/v7eecpzpxfnb3fxywy0amve4ofcoz0ns\"\n", + "bstar_link = \"https://stsci.box.com/shared/static/vpoby26z4f7cm9mavlo7fziikb1s3v9n\"\n", + "astar_link = \"https://stsci.box.com/shared/static/wmmwy5im68lnhjcw63iyc8rz3n65f1cr\"\n", + "fstar_link = \"https://stsci.box.com/shared/static/ro5ix00yh19iid9wxlzgi41bjfbremtz\"\n", + "gstar_link = \"https://stsci.box.com/shared/static/yv13duxb5qqtjdfgmsirh8rbyw3r68s2\"\n", + "kstar_link = \"https://stsci.box.com/shared/static/zbqy0bzesz7z8mqu0h0nqzffbnc4h0xg\"\n", + "mstar_link = \"https://stsci.box.com/shared/static/ztq2x6vsx7ickq0zmmimb7qhguu8vz3a\"\n", + "\n", + "all_urls = np.asarray([ostar_link, bstar_link, astar_link, fstar_link, gstar_link,\n", + " kstar_link, mstar_link])" ] }, { "cell_type": "code", - "execution_count": 4, - "id": "003ad226", + "execution_count": null, + "id": "9f205b59", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/1-Type_O_Stelib_HD269698.fits\n", - "No. Name Ver Type Cards Dimensions Format\n", - " 0 PRIMARY 1 PrimaryHDU 38 (6700,) float32 \n", - "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/2-Type_B_HD003369_s0020.fits\n", - "No. Name Ver Type Cards Dimensions Format\n", - " 0 PRIMARY 1 PrimaryHDU 18 (4367, 1) float32 \n", - "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/3-Type_A_HD031295_s0166.fits\n", - "No. Name Ver Type Cards Dimensions Format\n", - " 0 PRIMARY 1 PrimaryHDU 18 (4367, 1) float32 \n", - "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/4-Type_F_HD222451_s0889.fits\n", - "No. Name Ver Type Cards Dimensions Format\n", - " 0 PRIMARY 1 PrimaryHDU 18 (4367, 1) float32 \n", - "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/5-Type_G_HD114606_s0462.fits\n", - "No. Name Ver Type Cards Dimensions Format\n", - " 0 PRIMARY 1 PrimaryHDU 18 (4367, 1) float32 \n", - "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/6-Type_K_HD233832_s0410.fits\n", - "No. Name Ver Type Cards Dimensions Format\n", - " 0 PRIMARY 1 PrimaryHDU 18 (4367, 1) float32 \n", - "Filename: /Users/adrian/Documents/Hack_Week_STScI/OBAFGKMexamples/7-Type_M_HD036395_s0183.fits\n", - "No. Name Ver Type Cards Dimensions Format\n", - " 0 PRIMARY 1 PrimaryHDU 18 (4367, 1) float32 \n" - ] - } - ], + "outputs": [], "source": [ - "hdu_O.info()\n", - "hdu_B.info()\n", - "hdu_A.info()\n", - "hdu_F.info()\n", - "hdu_G.info()\n", - "hdu_K.info()\n", - "hdu_M.info()" + "# Download each sample spectrum to the local working directory.\n", + "odir = \"miles_stellar_spectra\"\n", + "if not os.path.isdir(odir):\n", + " os.makedirs(odir)" ] }, { "cell_type": "code", - "execution_count": 5, - "id": "614162af", + "execution_count": null, + "id": "13223d56", "metadata": {}, "outputs": [], "source": [ - "# The lists wave contain the wavelengths of the pixels.\n", - "# The lists flux the corresponding intensities.\n", - "\n", - "#TO DO: Iteration to create the flux and wave list for each star type\n", - "\n", - "flux_O = np.array(hdu_O[0].data)\n", - "flux_O_norm = np.reshape(flux_O/(np.nanmax(flux_O)), (hdu_O[0].header['NAXIS1']))\n", - "wave_O = np.ones(hdu_O[0].header['NAXIS1'], dtype=float)\n", - "for i in range(hdu_O[0].header['NAXIS1']):\n", - " wave_O[i] = hdu_O[0].header['CRVAL1'] + i*hdu_O[0].header['CDELT1']\n", - "hdu_O.close()\n", - "\n", - "flux_B = np.array(hdu_B[0].data)\n", - "flux_B_norm = np.reshape(flux_B/(np.nanmax(flux_B)), (hdu_B[0].header['NAXIS1']))\n", - "wave_B = np.ones(hdu_B[0].header['NAXIS1'], dtype=float)\n", - "for i in range(hdu_B[0].header['NAXIS1']):\n", - " wave_B[i] = hdu_B[0].header['CRVAL1'] + i*hdu_B[0].header['CDELT1']\n", - "hdu_B.close()\n", - "\n", - "flux_A = np.array(hdu_A[0].data)\n", - "flux_A_norm = np.reshape(flux_A/(np.nanmax(flux_A)), (hdu_A[0].header['NAXIS1']))\n", - "wave_A = np.ones(hdu_A[0].header['NAXIS1'], dtype=float)\n", - "for i in range(hdu_A[0].header['NAXIS1']):\n", - " wave_A[i] = hdu_A[0].header['CRVAL1'] + i*hdu_A[0].header['CDELT1']\n", - "hdu_A.close()\n", - "\n", - "flux_F = np.array(hdu_F[0].data)\n", - "flux_F_norm = np.reshape(flux_F/(np.nanmax(flux_F)), (hdu_F[0].header['NAXIS1']))\n", - "wave_F = np.ones(hdu_F[0].header['NAXIS1'], dtype=float)\n", - "for i in range(hdu_F[0].header['NAXIS1']):\n", - " wave_F[i] = hdu_F[0].header['CRVAL1'] + i*hdu_F[0].header['CDELT1']\n", - "hdu_F.close()\n", - "\n", - "flux_G = np.array(hdu_G[0].data)\n", - "flux_G_norm = np.reshape(flux_G/(np.nanmax(flux_G)), (hdu_G[0].header['NAXIS1']))\n", - "wave_G = np.ones(hdu_G[0].header['NAXIS1'], dtype=float)\n", - "for i in range(hdu_G[0].header['NAXIS1']):\n", - " wave_G[i] = hdu_G[0].header['CRVAL1'] + i*hdu_G[0].header['CDELT1']\n", - "hdu_G.close()\n", - "\n", - "flux_K = np.array(hdu_K[0].data)\n", - "flux_K_norm = np.reshape(flux_K/(np.nanmax(flux_K)), (hdu_K[0].header['NAXIS1']))\n", - "wave_K = np.ones(hdu_K[0].header['NAXIS1'], dtype=float)\n", - "for i in range(hdu_K[0].header['NAXIS1']):\n", - " wave_K[i] = hdu_K[0].header['CRVAL1'] + i*hdu_K[0].header['CDELT1']\n", - "hdu_K.close()\n", - "\n", - "flux_M = np.array(hdu_M[0].data)\n", - "flux_M_norm = np.reshape(flux_M/(np.nanmax(flux_M)), (hdu_M[0].header['NAXIS1']))\n", - "wave_M = np.ones(hdu_M[0].header['NAXIS1'], dtype=float)\n", - "for i in range(hdu_M[0].header['NAXIS1']):\n", - " wave_M[i] = hdu_M[0].header['CRVAL1'] + i*hdu_M[0].header['CDELT1']\n", - "hdu_M.close()" + "# Download the sample spectra.\n", + "for file, url in zip(all_filenames, all_urls):\n", + " print(\"Downloading \" + file + \" via \" + url + \"...\")\n", + " response = requests.get(url)\n", + " open(odir + os.path.sep + file, \"wb\").write(response.content)" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "29f98141", + "execution_count": null, + "id": "e71b17db", "metadata": {}, "outputs": [], "source": [ - "#TO DO: Iteration to create the table for each star type\n", - "\n", - "spectrum_O = Table()\n", - "spectrum_O['flux'] = flux_O_norm\n", - "spectrum_O['time'] = wave_O\n", - "\n", - "spectrum_B = Table()\n", - "spectrum_B['flux'] = flux_B_norm\n", - "spectrum_B['time'] = wave_B\n", - "\n", - "spectrum_A = Table()\n", - "spectrum_A['flux'] = flux_A_norm\n", - "spectrum_A['time'] = wave_A\n", - "\n", - "spectrum_F = Table()\n", - "spectrum_F['flux'] = flux_F_norm\n", - "spectrum_F['time'] = wave_F\n", - "\n", - "spectrum_G = Table()\n", - "spectrum_G['flux'] = flux_G_norm\n", - "spectrum_G['time'] = wave_G\n", - "\n", - "spectrum_K = Table()\n", - "spectrum_K['flux'] = flux_K_norm\n", - "spectrum_K['time'] = wave_K\n", - "\n", - "spectrum_M = Table()\n", - "spectrum_M['flux'] = flux_M_norm\n", - "spectrum_M['time'] = wave_M" + "# Read in the wavelengths and fluxes of each spectrum.\n", + "# We'll store them as a list of dict objects contiaining the wavelengths and fluxes of\n", + "# the seven sample spectra.\n", + "all_spectra = []\n", + "for ii, file in enumerate(all_filenames):\n", + " file = odir + os.path.sep + file\n", + " if os.path.isfile(file):\n", + " with fits.open(file) as hdulist:\n", + " # Read in flux from the data table.\n", + " flux = np.array(hdulist[0].data)\n", + " # Normalize the flux by the maximum value.\n", + " flux_norm = np.reshape(flux/(np.nanmax(flux)), (hdulist[0].header['NAXIS1']))\n", + " # Setup list of wavelengths.\n", + " wave = np.ones(hdulist[0].header[\"NAXIS1\"], dtype=float)\n", + " # Compute the wavelength values from the WCS header keywords.\n", + " for i in range(hdulist[0].header[\"NAXIS1\"]):\n", + " wave[i] = hdulist[0].header[\"CRVAL1\"] + i*hdulist[0].header[\"CDELT1\"]\n", + " hdulist.close()\n", + " # Add this star's wavelength and fluxes to the dict object.\n", + " this_spec = dict()\n", + " this_spec[\"wls\"] = wave\n", + " this_spec[\"fls\"] = flux_norm\n", + " all_spectra.append(this_spec)\n", + " else:\n", + " raise IOError(\"Could not find expected input file: \" + file)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "445c543e", "metadata": { "scrolled": false }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXkAAAD4CAYAAAAJmJb0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhU1f3H8fc3kx0S1rCDGAQkYIOAKLgiiCAqat3QFkUFqRsutUKtYtRal+pj3UBa9/rDharFXdBiq1IVKiiIaATUuLAoioJs4fz+mEmYzEySSTL7fF7Pw8Pcc8+d+w2aT27O3HuOOecQEZHUlBHvAkREJHoU8iIiKUwhLyKSwhTyIiIpTCEvIpLCMuN14rZt27ru3bs37uCvvopoLUmhVbwLiL1taXgJ8u32eFcQezm72se7hJhr08LT6GMXL168wTlXFG7/uIV89+7dWbRoUeMOvuaaiNaSFE6IdwGxt7og3hXE3kOfxbuC2Ov+08XxLiHmzjy6ZaOPNbMG/V+ShtdKIiLpQyEvIpLCFPIiIilMIS8iksIU8iIiKazekDez+81snZktq2W/mdkdZlZuZu+b2YDIlykiIo0RzpX8g8CoOvaPBnr6/kwCZjS9LBERiYR6Q94592/guzq6jAUedl7/BVqaWcdIFdhUFZs28fzHH8e7DBGRuIjEmHxn4Au/7QpfWxAzm2Rmi8xs0fr16yNw6voNue8+jp49OybnEhFJNJEIeQvRFnIlEufcLOfcIOfcoKKisJ/KbZKKTZsA+PrHH9mlBVJEJM1EIuQrgK5+212AhJtcptNttzFx7tx4lyEiElORCPm5wHjfXTYHAD84576OwPtG3P1LlsS7BBGRmKp3gjIzmw0cBrQ1swpgOpAF4JybCbwAHAWUA1uACdEqtjGK8vNZv2VLvMsQEYmLekPeOTeunv0OOD9iFUVYl8JChbyIpK2Uf+I1MyPlv0QRkVqlfALqjhoRSWcpH/Ibt26NdwkiInGT8iGf42n8MlsiIsku5UPeozF5EUljSkARkRSW8iF/2B57xLsEEZG4SfmQL8jJiXcJIiJxk/IhLyKSztIy5HdUVur+eRFJC2kX8je/+SbZ11/PEY88Eu9SRESiLu1C/or58wF4bfXqOFciIhJ9KR/yTsMyIpLGUj7kRUTSmUJeRCSFKeRFRFKYQl5EJIUp5EVEUlhahXxp+/bxLkFEJKbSKuTHl5bW2NbtlSKS6tIq5AF2XnVV9eu73nknjpWIiERfWoW8UXMRkYteeonVGzfGryARkShLr5A3C2o74L774lCJiEhspFXIZ4QI+XWbN/ODFvsWkRSV9iEP0PKmm2JciYhIbKRlyOdnZcW5EhGR2EjLkO/QvHmcKxERiY20Cvkqx/bqFe8SRERiIq1Cvurhp1tGjmRMz54h94mIpJK0Cvmq4ZrMjAyeO+20Gvu+/PHHeJQkIhJVKR/yVdfn5++3H2f0719rv1533hmbgkREYiiskDezUWa20szKzWxqiP0tzOxZM1tqZsvNbELkS228HI+Hu446itzMzBrtfz7iiOrXP+/cGeuyRESirt6QNzMPcDcwGigBxplZSUC384EPnXOlwGHArWaWHeFaI+6yoUO5Y9SoeJchIhI14VzJDwbKnXOrnHPbgceAsQF9HFBg3nkDmgPfAUlxafzMypXxLkFEJGrCCfnOwBd+2xW+Nn93AX2Ar4APgCnOuV2Bb2Rmk8xskZktWr9+fSNLjqyPNmyofj3uH//QXTYiklLCCflQcwEEJuGRwBKgE9AfuMvMCoMOcm6Wc26Qc25QUVFRg4uNhspdu38WPbZsGT9t3x7HakREIiuckK8Auvptd8F7xe5vAvCU8yoHVgN7R6bE6Dq1X78a25W6kheRFBJOyL8L9DSzPX0fpp4KzA3o8zkwHMDM2gO9gVWRLDRaTiqp+Rny9srKOFUiIhJ59Ya8c24ncAHwMrACeMI5t9zMJpvZZF+364ChZvYB8CpwhXNuQ+h3TCwtc3NrbI997LE4VSIiEnmZ9XcB59wLwAsBbTP9Xn8FjIxsabHRt127Gtv/raiIUyUiIpGX8k+8hmPxpEnxLkFEJCoU8kBBdsI/tyUi0igKeaBH69Yc4zf98KfffRfHakREIkchj3d2yr+fcEL19slz5sSxGhGRyFHI+2Rl7P6n+N/XX8exEhGRyFHI++RlZdGzdevq7ZvffDOO1YiIRIZC3s/Qrrsf7L1i/vw4ViIiEhkpH/INmXAs2+Opsf3tli2RLkdEJKZSPuQbIjDk95kxI06ViIhERlqEvFmoiTSD5QSE/Nc//RSNckREYiYtQj5c+3bsGO8SREQiSiHv5/R99ol3CSIiEaWQ92NmQbNSiogkM4V8gNZ5eTW252oNWBFJYgr5ABkBH9JqfnkRSWYK+QCBIS8ikswU8gFChfz8VUmxkqGISBCFfIBQIX/EI4+wdefOOFQjItI0CvkAtQ3X9Ln7bn7YujXG1YiINI1CPoCnlpBf8/33HDN7doyrERFpGoV8gLqmQPjP55+zeft2rnrtNU1eJiJJQSEfoL67a66YP5/r//Mf2t5yS4wqEhFpPIV8gPpCfsGaNbEpREQkAhTyAWobk6+yfP36GFUiItJ0CvkAt44cyd5t27JHixb19n1i+fIYVCQi0ngpH/LhrwvldWC3bqw4/3xO7tu33r6nzJnTuKJERGIk5UO+scKd3GDnrl1RrUNEpCnSIuQbMxtNuKtJfeO3epRzjieXL1fwi0jCSIuQb4xwfzBs8Ltf/qkVKzh5zhxuefPN6BQlItJACvlahLqSH9u7d1DbGc88U/163ebNgPfpWBGRRBBWyJvZKDNbaWblZja1lj6HmdkSM1tuZq9HtszYC3UlP6K4OKjt/bVrq19XDdNkZuhnp4gkhnrTyMw8wN3AaKAEGGdmJQF9WgL3AMc65/oCJ0Wh1pgKdSWf7fGE7DvykUf49Lvv+N43gVleVlZUaxMRCVdmGH0GA+XOuVUAZvYYMBb40K/PacBTzrnPAZxz6yJdaCLIquUKfd6qVex1553V27cuXMgXmzbx+Iknxqo0EZGQwhlX6Ax84bdd4Wvz1wtoZWYLzGyxmY0P9UZmNsnMFpnZovUJ/uRoqCGXhgzD6EEpEUkE4aRWqOHpwGeMMoGBwBjgSOAqM+sVdJBzs5xzg5xzg4qKihpcbCxdNmQIp/brV6PNfwhnv06d6n2PHZWVEa9LRKQhwgn5CqCr33YX4KsQfV5yzm12zm0A/g2URqbE+CjIyWHmmDE12pzb/bPtnYkTuXnEiDrfI/v666nUPfMiEkfhhPy7QE8z29PMsoFTgbkBff4JHGxmmWaWD+wPrIhsqbEXOCNl0K8vYQzf/LR9ewQrEhFpmHpTyjm3E7gAeBlvcD/hnFtuZpPNbLKvzwrgJeB94B3gb865ZdErOzbqm3bY4wv5fTt0qLXPpm3bIlqTiEhDhPVJonPuBedcL+dcD+fcH31tM51zM/363OKcK3HO9XPO3R6tgmMp8DZK/+Ea2P1DoEfr1rW+xyUvvxx0nIhIrOipnToEzi2/KyCs65t7HuAfK1Zw4xtvRLQuEZFwKeTrkJOZyZopUxgXcJdNFU+IMfk2eXlBbVe+9lrEaxMRCYdCvh57tGxJbqb3mbHAQZdQV/JfXnopxwbMcaPBGhGJF4V8GKqiPGi4JsSVfE5mJu3y84PaP9qwIRqliYjUKeVDPpIfegZet9d2901WiDlu5n36acTqEBEJV8qHfCSFM1wDoe+f919cREQkVtIi5MNd5am+4wN/K/Afrrl86NDq++WrQv68QYOq99+gO2xEJA7SIuSbqrYfEf7DNTcfcQT/O/dcYHfIt8nP5+Hjjqvuo7lsRCTWFPJhmHLAAbTNz+foXkFzroVUNYyTYcaJJbun3teQjYjEmkI+DP3atWP95ZfTsaAgrP4ZfiHvv4DItFdfjUp9IiK1UchHQeBdN6Xt2wPw6AcfsFK3UopIDCnkG2jRxIl8etFFQP1j9VX31d8wfHj1vr3vvpvSmTN5f+1azWkjIlGnkG+ggZ06UdyqVZ19AkP+qJ49a+x/f+1aSmfO5MIXX4xOkSIiPgr5KMio5ZbLQHe/+26Tz3Xvk4toe+jNTX4fEUlNCvkmqC3CA6/k62JlZU2662by9c/z7fc/s2uXhn5EJJhCPgqsjpCfdtBBQW2db7utyeesrNQygyISTCHfBPV98Brq2vqG4cP59ne/Y48WLarbwrnir0+lruRFJASFfBTUN1zTOi+PxZMm1Wj7eceOJp1TV/IiEopCPgpqm5rYX5v8fE7bZ5/q7fwbbmjSOXUlLyKhKOSboCpWa1v7tb5hmEdPOIHD99yzevv7rVsbXUvlLl3Ji0gwhXwUVM1OGc5Ye0F2dvXr3zz/fKPPWVmpK3kRCaaQb4KqYZnAqYzDGa6p4j8Fwmfff9/oWnQlLyKhpHzIR/P6tmebNgAc0q1bjfZwH4YKtLCigtUbNzaqFl3Ji0gomfEuIJn179CBzy6+mK6FhTXaQ43Jvz95MtvDmE+++I47ePH00xm111519ltevo5Nm7dVb+/U3TUiEkJahHzT1oWqWze/+92rzxci5PfxzUQZjieXLyfb42G/Tp0oyMkJ2affL2fU2NYtlCISSlqEfKzV9TBUoFB97l+yhPuXLPHunz49rHPqFkoRCSXlx+TjoSrkG/Jh6Oxf/rJJ59QHryISikI+Cvq1awfAwXvsEfYxHjP+ePjhjT6nPngVkVAU8lEwtGtXPrv4YsaXloZ9jCcjg2kHHRT0gauVlYV1vK7kRSQUhXyUhPpAtj5mxounnx40Dm9lZWzfUfedObqSF5FQFPJJImfQ9XXu15W8iIQSVsib2SgzW2lm5WY2tY5++5lZpZmdGLkS00PgbZ7D/ea0qbL32LtqPV5X8iISSr0hb2Ye4G5gNFACjDOzklr63QS8HOki09HFBxwQ1LZyzbcAIVeB0pW8iIQSzpX8YKDcObfKObcdeAwYG6LfhcA/gHURrC9tBMb20b164aZPDxqf/+HHrezYGTw+X9+YvYikp3BCvjPwhd92ha+tmpl1Bo4HZtb1RmY2ycwWmdmi9evXN7TWlFbXU7kzx4ypfn3F7fPZtj040Ldu2xmFqkQk2YUT8qHyJ/DC83bgCudcnZeTzrlZzrlBzrlBRUVF4daY9nIzdz+YfO+cxbQ48MagPj8r5EUkhHCmNagAuvptdwG+CugzCHjMN2dLW+AoM9vpnHsmIlWmgbo+Ns32eOo9XlfyIhJKOCH/LtDTzPYEvgROBU7z7+Ccq74VxMweBJ5TwIcnnMnTMqz+Xlu3K+RFJFi9Ie+c22lmF+C9a8YD3O+cW25mk3376xyHl6YL5+bIZeX6vFtEgoV1n7xz7gXnXC/nXA/n3B99bTNDBbxz7kzn3JxIF5qqwpqp0jdl8dD+XWvtc+vDCyNUkYikkpR/4rWhqzMlsq7tC5kwtn/19tt/P4ezjutfxxEiku40n3yctcvPB6B1Xl6tffx/TN05dTQjDihm3Oh+mBmD9+nMitUbaJaXXevxIpK+0iLkAxfaTiS3HnkkQ7p25dAwpiU2M5rlZ3PaUfvUaF+4tALwLgnYd692UalTRJJTyg/XJLrm2dmc2b9/nT+Iwh1yClwSUEREIZ9EMjLq/41k46afY1CJiCQLhXwSGNmjBx2LmnP5GUND7r9z6ujq160PvjlWZYlIElDIJ4GiZs34av5l9N+7Q8j9F4wbXGN71pzFsShLRJKAQj5FHLRvt+rX5173XBwrEZFEopBPER5PzfH6YWc/lFLPCIhI4yjkU4QFzIKzYNEabtNTsCJpTyGfIlyICRJ+e9u8OFQiIolEIZ9i7rvm2BrbVlrG/U+/p6EbkTSlkE8RVRneoW3zoH1nXzOXx15aFuOKRCQRKORTTLO8LLa8/fug9tOmPkWPMXfEoSIRiSeFfIrwH47Jy83iTxcND+qzqmIjVlrGyHMfYcPGLbEsT0TiRCGfYqrmwLnotP351ZhfhOwz77+r6H/yTL5a9yPbtKKUSEpTyKeIqgv5qnnO8vOyeOSG42vt/+W6H+l8xG3k7vfHGFQnIvGikE8RVcM1gffLV1n9wpRar+yPnPx3Nv20LWq1iUj8pHzIp8uNg/V9nd06tuCRG46n8r2rg/a9svBTWhx4Y3QKE5G4SvmQF6+qaYozMoxti/7Aw9cfF9THSss4e/o/Y12aiERRWoR84q4LFXnhLIKVneXh18eU8sObU4P23f/MEqy0jOf//XEUqhORWEuLkE8HjXmitbB5Dm7pdDa9FRz2R184m2FnP8SuXeky4CWSmhTyKWL33TUN/72loFkO+blZTPzlgBrtCxat4YI/vRCJ8kQkThTyKaL67pqAjC9qlR/W8Zvf/j2zrj4Gt3Q6G/9zRXX7jCcWRaxGEYk9hXyKCbyS/3juhVS8ckmD3qNlYS7P3H7K7vcsLWPfk+/VJGciSUghnyJqy9+Whbl0bl/Y4PcbO2xvzjtlUPX2kpXfkNH/Wgaccm9jSxSROFDIp4jdD0NFzjWTDwtqe++jb7DSMvqfPDOCZxKRaFHIp4hdvpCvuh8+ErKzPACU9m4ftG/pyrUcetaDETuXiESHQj5FVN3q6PFE7j9pi4Jc3nhwAm8+eBZu6XTeevisGvv/vfgzrLSMrds0yZlIolLIp4hKX8hnNOIWyrocuG83muVnAzCktCs/LZzG4H6da/TJG/xHln2yLqLnFZHICCvkzWyUma00s3IzC3pyxsxON7P3fX/eMrPSyJcqdRk1tAcA7ds0i+p5muVn8/aj5/DBnN/UaN/nxBlYaRnLyxX2Iomk3pA3Mw9wNzAaKAHGmVlJQLfVwKHOuV8A1wGzIl2o1O2Gi4ZT8coldCwqiMn5+vVsh1s6Pbj9lzO4dubrMalBROoXzpX8YKDcObfKObcdeAwY69/BOfeWc26jb/O/QJfIlin18XgyGnWrZFOFCvrpMxZgpWWsrtgY4ggRiaVwQr4z8IXfdoWvrTZnAy+G2mFmk8xskZktWr9+ffhVSlK49NcH1NguHnMHj72oBcRF4imckA/1SV7IR2/MbBjekL8i1H7n3Czn3CDn3KCioqLwq5SkcOtvj2Tru1eSn5tV3TZu6j+w0jI+XvNtHCsTSV/hhHwF0NVvuwvwVWAnM/sF8DdgrHNO39FpZMLY/uTmZAKQk53J5rd/z1+nH1OjT++xd2GlZTzz2kfxKFEkbYUT8u8CPc1sTzPLBk4F5vp3MLNuwFPAr51zCTURueZbib77rx3Lz+9cWaPtnBMG4JZO55wT9q3Rfvwlj2OlZTz6/Pv8uFlLDopEW70h75zbCVwAvAysAJ5wzi03s8lmNtnX7WqgDXCPmS0xs4SaurAx0+9KZPx1+rFseP3yoPZf/f5pCofeyMBTZ7H+u81xqEwkPWSG08k59wLwQkDbTL/X5wDnRLY0SRVtWubjlk7HOceuXY7MAddV7/vfiq9pN+zPdOvYglaFuZxweB+unnxoHKsVSS164lVixszweDJwS6fzzWuX1dj3+dc/sHTl2urbL7/45oc4VSmSWhTyEhft2zTHLZ3Op89fxPD99wza3+3I23n99fI4VCaSWhTyElfFXVpxf9nuZ+v878qZMOFRiovLKC4uY+PGLfEoTyTpKeQl7jy+6ZELmmVX35UTaODAWyguLuOYY+5l1SrdoSsSLoW8xF1D7n5avvwbRoy4i+LiMl59dWUUqxJJDQp5ibtQC52MObgnABdeeAgjRvQOedzEiY9xwgl/48Yb5+l5CJFahHULpUg0Vc2B75/Tc+8YR3n+LrJ8q1N59zs2bNjMwoWrufjipwBYsuRLliz5klmz3qJPn/Y8/fREsrM9bNy4hby8LHL9plgIV3n5ekaOvIdnn51E374dm/bFicSZruQl7kJdyWdkWI2AB++wTlFRc449dh9WrZrOlCk176dfsWIte+99PcXFZQwceAv77nsz2xqxatWrr3of2n7qqaUNPlYk0SjkJe4auy7tlCmHsWrVdJ59dhLNm2cH7d+2bSd9+vyRiy6aw4YN4T9Vm5vr/QV369YdjapLJJFouEbirqmzTvTt25H335/G1q07uPnm+fTp04Errtg9vdJzzy3nueeWV29PmXIoEyYcQGFhbsj3+/xz7zz4P/+stWsl+elKXuIuUuvS5uZmcfXVoznppH1ZunQqV189KmS/v/zldfr3v4ni4jImTpzN6tW7b8l0zvHAA28D8Nln30WkLpF40pW8xF3VcE0k75ApKMjhzDP3JyPDuOaakGvYAN7x96ox+EDvvVfBqlXfUlzcJmJ1icSaruQl7qI5S+j48YMpL7+aTz65ik8+uYpVq4IftArljDMGAzBixF3s2FEZtfpEok1X8pIwonWru/c3hd0/SJ588iw+/ngd/ft3oU+f9qxZ8x2HH34nY8b05fnnl1Nc3Ibf/W4EDz30DgC9e18f8n0XLLiIrl1baiprSWgKeYm7WEfkwIFdGThw92Jn3bu3rr7CP/TQvSgp6UBeXhYffvh7SkpuqPV9DjvsjurX5513EJdddniDAn/79krMCLpVVCSSUn64Rs9BJr6qkBt14F5xrgROPLE/JSUdAO8HuZ98chVLl07lvPMOqu4zb975Qcfdc88b9Ohxba3j+4Fmz17M3ntfz6mnPhiRukVqkxZX8vplOrFlZ3kof+5COrcrjHcpQTyeDAoKcvjtb4dTUtKRwsJcevRoW33lv317JS+++CGXXOJ9AnfixNl07tyCL7/8gb/+dRwTJ86u8/3fe6+CW299jcsuOzzqX4ukp5S/kpfk0KNr6+rFwBPVUUeVcNBBxTXasrM9jB27T40PdL/80rvgSX0BX+Xuu//Dxo1bKC4uo2xYGW6X48cNP/LTdz8BWqdYmiaxv6tEUsyQId3p0aMtU6ceQX5+NqNGzeDjj9cxderuh7euHX5tne/RtltbRv5mJJ37dMaT6SGnWU60y5YkppAXiZJBg7px663H0aFDIZs3b2fp0i859NCanzv85S+/ZPToGcybF/60yRs+38D/Tfu/Wvf/4ZU/4NGHueKjkBeJgtmzz2D//btXb7dsmRcU8AB77dW2Qe/bpaQLFR9W1NnnXw/8ixGTRgDw+FWP89EbH9XYf+5fz6Xdnu2wDNPtn2lAIS8SYX/60zE1Ar4uHk/9H4tNmT2FwqJCzAwLMZmb2+WoWFHBN+Xf8MLtL/Dpok/pd3g/1q1eFxTwAPdOvLfO842+aDQd9upAYVEheYV5ZOdmhzyvJAeFvEiEnXLKgAb132+/brz77ufeY687hcevetzbftx+HDXlqHqPtwyja9+udO3blQ8XfMiaJWuCgvycGeew4IEFlL9T/+LoL95R+zQQAENOHsLI34wEdn8orN8IEpdCXiTODjmkB++++zl/+MOReA7am4kzJ/Lzpp/p3r97g98rKyd4kZRJ906iY6+OnH7T6TXa3S7HD+t+YNXiVXww/wPWLFkT1jkWPrGQhU8sDLumwyYcRvGAYpq3aU5us1zyCvNq7N9VWYllZOgHRZQo5EUi5Lbbjmft2h8bfNz48fuzadNWxo0byBProFPvTo2uISvESlgde4Ve3coyjJYdWjJgzAAGjAn+7WNX5S4qd1ay8s2VVO6sZN2qdbz1+FsNrmnBAwtY8MCCOnqU1Xn86BMuZOvPPzFy7Hm4XbvYWbmDrt378s2X5bRu25ms7NzqHxDbtm4hKyuH1195iH77Dqeowx4NrjfVKORFIuS4437RqOMKCnKYNm1kRGoIdSXfWBmeDDI8GfQ7vF9124hzR7DwiYXMmzkvYuepz4tP3QnAv158IKz+Hbv04uuK4CePe/c7kIwMDyve/3eN9lHHX8ApZ13X9EITlEJeJIVk5tb8lj741wdH9P3NjKGnDGXw8YPZ+NVG2nZrW31f//R/hZ7hs2xYGa06teLCv1/IT9/+xJYftvDBqx/QqXcn1n+2npNGPohlGFt/3kxBYRtm3nIOefkFZOfk4ZzjXy/e36AaQwU8wMplb4Zsf+npuyhqvwfDjjo7JYeMFPIiKSTwSn7YhGFROU9mdiZF3YsAOPnak2m3Z7ta+1758pWA9wdEQdsCCtoW0L5H++r9+T+1ACAv3zutxQW/f7jG8b/+zZ+Dwvd/C5/n2/UVjDhmEt+u/4LLzy5t0tfzyMzLeWTm5Tzw7EZ27tzBjdPGMGz0Wfxz9k1M/dNztG7bOeRxO7ZvJSs79ApjiUIhL5JCAsfkY3Fl2ufgPnXuz8xuWsyE+hoGDBlT/bptu25cdet8rrtsRI0+rdp2YuOGr0K+518e+Zh/v/IwnbruzZ03/Kq6fcIxrapff/rRuwBcNqEfB404nTfmP8qlZXPoskcJD941hXYd9mT+c7M4f9rDDBp6TJO+xmhSyIukkKor+YHHDmTMxWPq6Z06insNpF3HYtZ9vYp9BgznnEtnkunJ4okHp7Pv/qO564bx7Ny5HYAzL/gLhS2LOPrkywAYNvqseoeE3pj/KAC3TT8xaN/ihc8q5EUkNqquejOzMlNyfLku19/1Jqs/+R+9+g6tbjvzgtsB+OvTa2s9bvx5tzZ43N/ffxc8ybmXzWr08dEW1iyUZjbKzFaaWbmZTQ2x38zsDt/+982sYU+DiEhEZOdlA1C5M/2WLMzKzq0R8LGyz4DhMT9nQ9Qb8mbmAe4GRgMlwDgzKwnoNhro6fszCZgR4TpFJAyDjh3EsLOHMer8UfEuJalcPP3xoLZDRo4Pajv0yDPo3e9AzrlkBrOe+oZWbTvRonWHWJTYaOEM1wwGyp1zqwDM7DFgLPChX5+xwMPO+4zzf82spZl1dM59HemCX375ZS69556w+3/9Y8MfThFJVhmeDA751SHxLiPplA4ayZ2Pfsrs+67k+NOm0bqoCwAHH3E6HTrtRbOCVuzYvpXsnJpP6+bk5LP4rbmsWrm4Qef77uOJXHrppRGrvy7hhHxn4Au/7Qpg/zD6dAZqhLyZTcJ7pU+3bt0aWisAhYWFlBQVhd2/pKiI/To1/glCEUkPzQtbM/GSmoMQe+09uPp1YMADjDr+QvaUwQYAAAX7SURBVJa991qDz9W+ffv6O0VIOCEf6tObwKVqwumDc24WMAtg0KBBjVruZsiQITx50kmNOVREJKIOPXI8hx4ZPKxTn9OPbhmFakIL54PXCqCr33YXIPDm03D6iIhIjIUT8u8CPc1sTzPLBk4F5gb0mQuM991lcwDwQzTG40VEpGHqHa5xzu00swuAlwEPcL9zbrmZTfbtnwm8ABwFlANbgAnRK1lERMIV1sNQzrkX8Aa5f9tMv9cOOD+ypYmISFOF9TCUiIgkJ4W8iEgKU8iLiKQwhbyISAqzqtXWY35is/XAZyF2tQU2xLicSEjGupOxZkjOupOxZkjOulO95j2cc2E/9h+3kK+NmS1yzg2Kdx0NlYx1J2PNkJx1J2PNkJx1q+aaNFwjIpLCFPIiIiksEUM+cZdYqVsy1p2MNUNy1p2MNUNy1q2a/STcmLyIiEROIl7Ji4hIhCjkRURSWNRD3sxyzewdM1tqZsvNrMzX3trM5pnZJ76/W/kdM823KPhKMzvSr32gmX3g23eHRXk5ejPzmNl7ZvZcEtW8xne+JWa2KInqbmlmc8zsIzNbYWZDErluM+vt+zeu+rPJzC5O5Jp957rE9324zMxm+74/E7pm3/mm+GpebmYX+9oSrm4zu9/M1pnZMr+2iNVpZjlm9riv/W0z615vUc65qP7Bu2pUc9/rLOBt4ADgZmCqr30qcJPvdQmwFMgB9gQ+BTy+fe8AQ3zv+SIwOsq1Xwr8H/CcbzsZal4DtA1oS4a6HwLO8b3OBlomQ92+c3qAb4A9ErlmvEtyrgbyfNtPAGcmcs2+c/UDlgH5eGfOnQ/0TMS6gUOAAcCyaHz/AecBM32vTwUer7emaH8DBPwD5AP/w7tG7Eqgo6+9I7DS93oaMM3vmJd9X2xH4CO/9nHAvVGstQvwKnA4u0M+oWv2nWMNwSGf0HUDhXjDx5Kpbr/zjATeTPSa2b0Wc2u8Yfmcr/aErdn3/icBf/Pbvgr4XaLWDXSnZshHrM6qPr7XmXifkrW66onJmLx5hz2WAOuAec65t4H2zrd6lO/vdr7utS0K3tn3OrA9Wm7H+z/SLr+2RK8ZvGvrvmJmi827cDokft3FwHrgAfMOj/3NzJolQd1VTgVm+14nbM3OuS+BPwOfA1/jXcHtlUSu2WcZcIiZtTGzfLwLFHVNgrqrRLLO6mOcczuBH4A2dZ08JiHvnKt0zvXHe3U82Mz61dG9tkXBw1osPBLM7GhgnXNucbiHhGiLac1+DnTODQBGA+eb2SF19E2UujPx/oo7wzm3L7AZ76+1tUmUujHvkpjHAk/W1zVEW6z/v24FjMU7NNAJaGZmv6rrkFpqi+m/s3NuBXATMA94Ce8Qx846DkmIusPQmDob/DXE9O4a59z3wAJgFLDWzDoC+P5e5+tW26LgFb7Xge3RcCBwrJmtAR4DDjezvyd4zQA4577y/b0OeBoYnAR1VwAVvt/wAObgDf1Erxu8P0z/55xb69tO5JpHAKudc+udczuAp4ChCV4zAM65+5xzA5xzhwDfAZ8kQ90+kayz+hgzywRa4P33qFUs7q4pMrOWvtd5eP9H+wjv4t9n+LqdAfzT93oucKrvU+Q98X7A8o7v15wfzewA3yfN4/2OiSjn3DTnXBfnXHe8v4q/5pz7VSLXDGBmzcysoOo13vHWZYlet3PuG+ALM+vtaxoOfJjodfuMY/dQTVVtiVrz58ABZpbvO9dwYEWC1wyAmbXz/d0NOAHvv3nC1+1XT6Tq9H+vE/FmU92/jUTrwxK/Dw1+AbwHvI83cK72tbfB+8HmJ76/W/sdcyXeT5pX4vfpNzDI9x6fAndRzwcOEar/MHZ/8JrQNeMd217q+7McuDIZ6vadrz+wyPf/yTNAq0SvG++NBN8CLfzaEr3mMrwXWcuAR/De2ZHQNfvO9x+8P/iXAsMT9d8a7w+fr4EdeK+6z45knUAu3qHBcrx34BTXV5OmNRARSWF64lVEJIUp5EVEUphCXkQkhSnkRURSmEJeRCSFKeRFRFKYQl5EJIX9P5DK2f27BLAFAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", - "Pyo warning: Portmidi warning: no midi device found!\n", - "Portmidi closed.\n" - ] - } - ], + "outputs": [], "source": [ - "data_soni = SoniSeries(spectrum_O)\n", - "data_soni_preview = data_soni.preview_object\n", - "data_soni_preview.sonify_preview()\n", - "data_soni_preview.play_preview()" + "# Construct the Sonification object.\n", + "soni_table = Table([all_spectra[0][\"wls\"], all_spectra[0][\"fls\"]],\n", + " names=[\"wavelengths\", \"flux\"])\n", + "\n", + "# In an \"ensemble\" preview, each section is a different pitch frequency. Each section\n", + "# gets played separately, then at the end all sections get played together.\n", + "data_soni_ensemble = SoniSeries(soni_table, time_col=\"wavelengths\", val_col=\"flux\",\n", + " preview_type=\"ensemble\")\n", + "ensemble_prev = data_soni_ensemble.preview_object\n", + "ensemble_prev.sonify_preview()\n", + "ensemble_prev.play_preview()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "243081cd", + "metadata": {}, + "outputs": [], + "source": [ + "# In a \"scan\" preview, each section has the same frequency. Each section gets\n", + "# played separately, and then there is no combined sound made.\n", + "data_soni_scan = SoniSeries(soni_table, time_col=\"wavelengths\", val_col=\"flux\",\n", + " preview_type=\"scan\")\n", + "scan_prev = data_soni_scan.preview_object\n", + "scan_prev.sonify_preview()\n", + "scan_prev.play_preview()" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "82914e78", "metadata": { "scrolled": true }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dd3xUZfb48c+ZyaRCClU6BJCmgIIUFVRQBCzIKmt31UUWv1hWUX+uriL2XcS2ouiia5e1d4qKLtgQUIogYAgIAaSTQBJIe35/TMlkMjMZJpPMncl5v168MnPvc+89c9c988y5z32uGGNQSikVX2zRDkAppVTkaXJXSqk4pMldKaXikCZ3pZSKQ5rclVIqDiVE68DNmjUzHTt2DG/jbdsiGktMyIp2APXvcAPseuwpiXYE9S+pomW0Q6h3TTPsYW+7bNmy3caY5jW1i1py79ixI0uXLg1v43vuiWgsMeEP0Q6g/m1sHO0I6t9Lv0U7gvrX8eBfox1Cvbvy7MywtxWRkP4raYB9I6WUin+a3JVSKg5pcldKqTikyV0ppeKQJnellIpDNSZ3EXlBRHaKyM8B1ouIPCkiOSKyUkSOj3yYSimljkQoPfcXgZFB1o8Curr+TQCeqX1YSimlaqPG5G6MWQjsDdJkDPCycfoeyBSRVpEKMNo25+fzzpo10Q5DKaWOSCRq7m2ALV7v81zLqhGRCSKyVESW7tq1KwKHrntXvv8+F7z1FgcOH452KEopFbJIJHfxs8zvE0CMMc8ZY/obY/o3b17j3bOWsPA3581g+w4dinIkSikVukgk9zygndf7tkDcTP7i/pbK1+SulIohkUjuHwJXuEbNDALyjTHbI7BfS6hwPYawsLQ0ypEopVToapw4TETeAE4FmolIHjAFcAAYY2YCnwKjgRygCLiqroKNpiJN7kqpGFJjcjfGXFzDegNMilhEFvV9Xh7DOnWKdhhKKRUSvUM1RDl7g40GVUopa9HkHkRpebnndZvGzsnFK4whr6AgWiEppVRINLkH8dDXX3teH3Yl+lGvvUa7xx7j94MHoxWWUkrVSJN7EBv27fO8nvbttwDM37ABgFdWrIhKTEopFQpN7kE0SU6utqxTpvPxWLd9/nl9h6OUUiHT5B5E92bNqi1LcTgAaJqSwohXXuH7vLz6DksppWqkyT2IQ2VlVd6XV1Swq7AQgD3FxXyWm8vg55+PRmhKKRWUJvcgSisqqrw/WFLCnuLiKsuSE2q8VUAppeqdJncfpeXlyNSpPL1kiWco5F8HDgRgS0GBZzoCN9/evVJKWYEmd5ct+fn8a/FiVu7YAcCkTz/lYEkJAH2POgqAbQcOANC/desq22qCV0pZjSZ3l9Gvv84Nc+eycf9+z7KHvv4aAdplZACwdvduoHopZnN+fr3FqZRSodDk7vKbK6kXunrr4Jzu12G3e+5O3eCagiA9KanKtvogD6WU1Whydyl31dL3+8zb7rDZSHUNf3RfTJ10wglV2uiMkUopq9Hk7pJgc56KasndbvesK3D10JulplZpo8ldKWU1mtxd3Ak836fE4rDZcNjtVda5e/JumtyVUlajyd0llJ67+1F7qQ4Hz597LjcNGgRAcVkZBw4fJuPhh8l4+GFKvGaTVEqpaNDk7hK05+5TlklzOLj6uOO4efBgwNlzv37OHAoOH6bg8GG2HzjAjXPm8OCiRfX4CZRSqpLeXuni8Omde5b7qbm755dxl2eKSksREc829y1cyPM//QTADQMH0igxsW6DV0opH9pzd7EHKsvYbJ7k7r5Zyf3eO7l7n0h3YgcYM3t2XYWslFIBaXJ3CVZzt9tsCJUP7LC5eulJdjuCM7nv9dnObcHGjVXGziulVH3Q5O7iLssc9EnE7uUJNhtlronE7K7kLiKkOhwUlZayp6iIDJ+bm9xmLl1aV2ErpZRfmtxd3D33Qp9hje5hkO6/UFnCATzJfW9xMR1dD/Lwdctnn0U6XKWUCkqTu4snuQfpubuJ1/pUh4PisjL2HTpEe9ccNG5zLr3U81qfuaqUqk+a3F3cdXTjs9zdY3cnd5tIlZEx7p77obIyWqSlVdnW+wthypdf1kHUSinlnyZ3F9952t3c9XV3D94uUmV9iiu5l5SXV5tQzC7C9QMGALB469ZIh6yUUgE1+OS+bvduej/zDFsKCvyut/uUZWw+yT3VK7knedXl3dv+4/TTAdgXYDSNUkrVhQZ/E9MzS5eyaufOgOvdydxdnvG+mArO5J5/6JAzufvM824TIcXhoEezZvyyezel5eVVLswqpVRdafA998Qakq07uScEKMs4bDbPxGG++3K37dG8OQDr9+ypfcBKKRWCBp/ca3rAtW9y9y3LJHgld39lGYDbTjwRoMpTnpRSqi41+OSeEmJy91xQ9SnL2EPoubds1AiAXYWFABhjMAEu4CqlVCSElNxFZKSIrBORHBG53c/6DBH5SERWiMhqEbkq8qHWjRSfudl9ufvpgcoydpHKnrvPF4X7i6C56+EeO13JveMTT2C7916ueO89ntW7V5VSdaDG5C4idmAGMAroCVwsIj19mk0C1hhj+gCnAtNFJCamQgy1LOO+EBqsLJNot5N/++3Vtk1LTCTV4WBXURFQ+UDtV1auZOInn/Dfn3+OwCdRSqlKofTcBwA5xphcY0wJMBsY49PGAI3FeXdPI2AvUBbRSOtIgi34KXAnaHeP3V9ZptQ150yi3V5lrLt3L79Zaiq7i4o889N4e/ibb8ILXimlAgglubcBtni9z3Mt8/YU0APYBqwCbjTGVMtiIjJBRJaKyNJdu3aFGXJk+bt5qV16umeeGJtPUvdXlnELdEEVoFFiIgdLSvjzhx9WO97y339Hpk71m/iVUiocoSR38bPMNyOeCSwHWgN9gadEJL3aRsY8Z4zpb4zp39w1PDDa/CV3u83mSeqB/nraer0PdEEVnMm9sLSUl1esCBjLI99+e4TRK6WUf6Ek9zygndf7tjh76N6uAt41TjnARqB7ZEKsOzsOHmTpNt+P4kzg9gBJ3bcs413W8XcTk1uaw1FtOmFff/viC77dsiVoG6WUCkUoyX0J0FVEOrkukl4E+NYWNgPDAUSkJdANyI1koHWh59NPV3lqkptNpHpS9/nr5p3sq/Xc/ZRlfE3s16/K+5NeeOFIPoJSSvlVY3I3xpQB1wHzgF+AN40xq0VkoohMdDW7DzhRRFYBXwD/zxizu66CjpS9xcV+l9v9JPdQyjLVau4+ZZmDJSUMbOO8XNG9WTMAhnbogJkyhW033+xpOy8nJ6zPo5RSbiHNLWOM+RT41GfZTK/X24ARkQ0terx77uJ7QdXPaBm3YD33NIeDwpIS0pOSOKtrVw6UlLB2925PKadV48b8qU8fXlqxgpvmzWNNly6R/2BKqQajwd+h6k+VsozXMqhelvGuufsOq/Ru67DbKa2o4FBZWZWx9d5fCP8+5xwAftm9m7wAs1QqpVQoNLn7YbfZPL1u36QerCzj26v3but+BuuhsjJSHA7PKB3vUo73jJHtHnssEh9FKdVAaXL3w98F1UCjZbzfV0v8XuscNhul5eUUl5aSbLd7krtvKee7P//Z87rD44/X9qMopRooTe5+BE3uQcoywW5wcvfcD7vmfXcnd9/53Qe1bet5vTk/n3K9sUkpFQZN7n74Gy3jW6bxbusWtOfuqrmXVVSQYLN5ZoX03QacUxW4/fT777X5KEqpBkqTux+RKsv41twrjKGsogK7iKfn7u/23w8vuogzsrMBOOHf/67dh1FKNUia3P2w22yeHrn4lGOClV6C9erd88EfLiurMtmYv4nLBrdrx/zLL/e8/79PPgn7syilGiZN7n4E67n7m/LXe7tA69y19XJjsIkw2jWOvW16tSl4PF4491zA+ZzX7bsOhPVZlFINkyZ3P/xOPxDCTUzB1vleeL33tNPYPnmy5ylN/lzep4/ndevTH6W8XC+uKqVCo8ndj2DTDxxJWcabw+dLwG6zcVSQxA7VSzb/+WB5CNErpZQmd79sItVGx/jeqerm74Lq3UOHVns2a7Ahk6G6ZupH7NlfFNa2SqmGRZO7H0dSlrH56blPPe00iu68s0o77/Hsvvs4EsMnvBz2tkqphiOkicPi0ZKtWwOu89cbr21ZJtiF12AWXXUVaQ4Hu48vYsTEV1mxbkfI2yqlGq4Gm9wHzJoVcJ138nW/8h0a6RZsnLs3R5hlmZPbt3e+GAxXn9eXD75aR0WFwWYLr7SjlGoYtCzjx5EMhfR+HyxpJwQZVROqIcd3YM/+Yn7JtcbzZ5VS1hXTyX13URHL/Dwmr7bsfh6zF870A96q1NzDvKDar2crAFas19KMUiq4mE7ug59/nv51cHu+TcRTfjmSnntd1Ny9de/YDLtdWL1hp2fZ5u35nHvDG/y++2BY+1RKxaeYTu45e/cC8L9Nm2j04IOMeOWViOzXX8IO+Ji9cGruYZZlHA47HVplsmHLPs+yYde8xEf/W897C34Ja59KqfgU08nd7dSXXqKwtJTPciPzTG5/CTuUh3WE2nMPtywD0LltFhvynMndGONJ9Lc99jnSZyq79haGvW+lVPyIi+TurbCkhEYPPsizS5eGvQ+biGeUTF2UZWozzr1zuyw2bHH+Yvngy3We5QeLSgBocdojYe9bKRU/4i65v7ZqFYWlpUysxUyK3jV33wdkByvLBEva9gj13Du0ymRfwSEKi0oYe9N//bb5461vhb1/pVR8iJvk/u3VVwPwl48/rvW+/JVa3H9907K/MfGh7jMcmY2TAcg/eLjauiYZKQC8NX9N2PtXSsWHmE7uA9q0AeCSY4+t8ng6qHoB09fKHcGHEvortQS8ick7uQdJ2qH28GviTu77DxwiIcHG7Vef5Fn33N1nc/qgbJIS7ZSUlod9DKVU7Ivp5H5Su3Yk2e28OnZstcRaGuTZo31mzgy632CjZXyFmqhDvdmpJhmNkwDYtusAZWUVZKWnYLc795fkSOCaPxzP4ZJyPv7f+rCPoZSKfTGd3AES7faAPeaVO3Zw6bvvep5XGip7kAuqvvsKtcTindAj0XP/bdt+z/skh3MWieSkBIYc75yu4PzJb3LeX2dTqj14pRqkmE/u3jbccEOV931mzuT1Vas46/XXeeTbb2vc3jehe78OlJBD7YVH6oKqO7lv8kruiQ7n3a9JiXZaNW/safvBl+t4avYPYR9LKRW74iq5Z2dlYaZM4f7TTquyfE5ODrd+9hnP//hj0O3dUwQEK8v4/gYIp+demwuqaSmJgLMsA87kblxRuXvw3havCjz7pVIqfsV0cg9Ubmmamup3+fiPPgq6vwSvOdt9px8I1NsOtcQSqQuqSYnOL6Cde50P7cholER5uamy7o7xJzPq5C6c1Lcd213TEixdvY2yMn1Mn1INRUwnd/A/QiU9KSmsfSX4GcvuW6rx/UIJuSwToQuq7hJM/sFDgLMnX1HhTu7OnvsD1w/n0xmX0rV9UzZs2cst0+dzwiX/1hKNUg1ISMldREaKyDoRyRGR2wO0OVVElovIahH5X2TDPDIZXsn9+XPPrbKuIsjFVYdXcvdN6u7edrhlGVuELqi6Sy+FxaUAJCTYKHeNDEpy2Ku0bZKRzN6CYqa//B0AN02bF/ZxlVKxpcYsIyJ2YAYwCugJXCwiPX3aZAJPA+caY3oB4+og1pA19kruVx93HN/9+c+e9zfMmRNwO09Zpg6GQkbqgqq7515Y7JxuIMFuq9Zzd8tolEzxobIqyzbm7UMpFf9CyUwDgBxjTK4xpgSYDYzxaXMJ8K4xZjOAMWYn9SBQHzzBJ+F63+A0Y8mSgPvzV5api6GQtbmgmpBgw2YTig65eu52m+fXiLvm7pbeyOtL7ry+AGSf9SRzv8lhb35x2DEopawvlOTeBtji9T7Ptczb0UCWiHwlIstE5Ap/OxKRCSKyVESW7toVmacJ+UuTHTIyAJh51lmeZf+94IIa9xVstEzAC6rhDIWsRVkGnEncuyzTKNU5giYlyVGlnXs5QJf2TUhOcvbsR/3fazQd+s9axaCUsrZQsoy/7OXbaU4A+gFnAWcCd4nI0dU2MuY5Y0x/Y0z/5s2bH3GwoWqTnk7RHXfwl/79PcvG9ewZZAsn79EybjUNhQy5LBOhC6rgLM24Z4FMsNuY/8zl3HPtKaSmVE3u3jV4mwif/OuSKuvnfP1rreJQSllXKJkpD2jn9b4t4PtsuzxgrjGm0BizG1gI9IlMiOFJcVRNdCLCjxMmBN2mygXVAI/Z81XfF1TBeVHVPXdMgt3GgGPbMGXiqdXbedXgbTZh2MBOvDntAh6+cTgAoye9zp/+/n6tYlFKWVMoWWYJ0FVEOolIInAR8KFPmw+AISKSICKpwECgzh8NdKTTCnTIzAy63t1zFyp/rvgm+bCHQkbgMXtuiV49ckdC4P8JvWvw7mOOG9GL266qnGzs5Y9WsG3ngVrFo5SynhqTuzGmDLgOmIczYb9pjFktIhNFZKKrzS/AXGAl8AMwyxjzc92FXSnYTIy+mqSkBF3vSe51fIdqbcsy3kk7wR74f0LvL4Ee2ZVlMBFh55e3cMMlAwBoc8aj5O0oqFVMSilrCak+YIz51BhztDGmszHmAdeymcaYmV5tphljehpjjjHGPF5XAddWq0aNAq7z1zt3p2Gr3KEK4EjwSu7Beu5e0xGMHtK1yrrmTdJ4/LaRnvftRjxWq5iUUtYS83eoHqnF48cHXFflztQAj9OL9h2qAHZb5fbBeu7uHn6bFo39rhcRyn68y/N+0Y+/1SoupZR1xHRyP7KKu1M71zBJf4KVeAKVX0Iuy0Sw5+7dW7fZAh/ffUE12KUJu93Ghk+cs2kOvepFPvtuQ61iU0pZQ0wndwj+aLtABvs8tSmUfUmAmns4D+uo7QVVd289IcEW9AvJXXMPNuUCQHbbLM48sTMAIya+yhl/eeWIL1Yrpawl5pN7OG476SS/y4MlykBronFB1ZPcg5RkoHIkTSiHm/vMZZ4vg8+/z8XW916KXDdKKaViT0wn90j3Lv3tz3dJuDX3SI5zt4ec3J3JOtTTVPzDnYwbUXmzV9qgB7n10fk6VbBSMSimkzsc2VBIN9+5Z/zuN8R9hdpzlyj23ENlswlvThvH/JmXeZY98tJ3OPrdp3ezKhVjYj65h2N01670btkyaBvfzm5ta+613cabO6nXlLwre+5H9gvnjMGdObz07/xheA/PstGTXvc8t1UpZX0NMrnbRJg8eHDA9d6pUHz+hluW8T1+bbiHQgYb4w6VI2nCqV4lOuy88+gfMSumMHxgJwA6jnqC+579H3v2Fx35DpVS9Sqmk3ttKu5Hml4DlX/CSdS1LsskhFaWqeVhPN6cVjk9/91Pf0WzU6Zx37NRfR6LUqoGMZ3cIbyhkBB+79lKZZmaknvTjFQGHNOGl+4/r1bHa5KRwsBjq87yfPfTX3H3jC9rtV+lVN2J+eQers5NmlRbJgHuQoXaD4X0Vvs7VENL7gkJNha/Np6RJ3Wp1fEAju/RCoBBvSvvEbjvuYWs3bi71vtWSkVeg03ug9q2Ze2kSVWWeSf1UC9ChpOoI3WHak0197pw2VnHYlZM4dT+HQHocd4Mdu4prPc4lFLBxXRyr+04927NmtXYxrfWXu2CahiJOmJ3qNbQc4+kTm2c0yW3auacp+bL5//EpAtPAKDlsEd48rXF9RaLUqpmCTU3sbZwxrmHs69AQyGjckE1Csn95ssH07V9U8ac1s2z7Kk7RlNaVs5z7/zIjf+cy6+b9zDt5hGex/kppaInpnvukVDy978zumvXGtsFGgoZVnKv9R2qzmN6T/1b1+x2G+cN617tC/DZu8/hCdfUwU/NXsKxFzxTbzEppQJr8MndYbcHTNzeIvkLIWI99yjU3P254dKB/PrR9QDkbN6rNXilLMAa2SFMkZpZplpdPci+I3HMWKy516RL+ya88sBYAGa+tTTK0SilrJMdwhSJ/vTwTs47MP0Oj4zgcdwiVZaxUnIHuOzs3px2Qkf+O291tENRqsGzVnaIkhsHDiTvppvo6TV6xuHneaqREo89d7eTj2vP2k27PdMFr9+0B+kzlYXL9ClPStUn62WHKBAR2qSnex5qYRfhsTPP5PoBAxjbvXuVtlZ4iIXVau7ejut+FBUVhlW/7sAYQ7cxTwFwytUvsjpnZ5SjU6rhsF52OAKRTrRlFc55y+02G83T0nhy1CgcdueIlLrowYfLyj337p2cv35yt+7jTZ/yzFOzf2D9pj3RCEupBsd62eEIRTLptm7svEGnXXp6tXXZWVkAnNKhQ8SOF65QH9YRDU0zUgHYV3CIH37eCkD+N7dzxqBsZr61jG5jnuL2xz+PZohKNQh6t4mXa/r1o0VaGuf5lGIAejZvzqYbb6R9kAds1xcr99yz0pMB2JtfTG7efnpmNye9UZLnDleAf/znG774YSNLXr8mWmEqFfeslx2OQKSr3zYRxvboEfDXQIfMTEuUZ9xJ3T1qxkocDjuN0xKdyX3rPrLbOn/xtGiSBlROQLZ09TYee+U7rpn6IfsKiqMWr1LxKqaTO0R2iGKssGJS99YkI4W9BcVs2rafjq2dv3SaZzmTe+d2Wbz32IUA3PzIfGa9+xPTXvw2arEqFa9iPrk3RO6euxV+RfjTJD2FXfuKKDh4mKaZzhp88ybOv4XFpZw3rDsXntnL0/6h57/mcElZVGJVKl5pco+QzOTkejuWFWvt3ppkpLB5ez4A6WlJAKQmO6q0efmBsTxw/TDP+4GXzWJ1zk5LDDVVKh5YO0vUwCqJIPeGG8i5/vp6O54Vx7d7a5yaxNadBc7XaYlA5a8M9w1ciQ47d4wfQumyuwBYsW4Hx5z/DKeNfykKESsVf6ydJUJghdJEp6wsmqam1tvxajt9QV1LSrSzr+AQUNlzr6hw3SDmc70gIcHG/JmXed7/b+lvSJ+pdD7rSQ4f1lKNUuEKKUuIyEgRWSciOSJye5B2J4hIuYhcELkQlS9PzT3KcQSSlFg5wja9kTO5l7tuEBM/UfftdlS1Zbl5+xg7dpZlfp0pFWtqHOcuInZgBnAGkAcsEZEPjTFr/LT7BzCvLgJVlaxelklKrJxnvnGqM7l3bd8UoMrDPtwyG/u/XrF27Q46d76XY45pRb9+7Zg8eRiNXF8WSqngQskSA4AcY0yuMaYEmA2M8dPueuAdoN4mEGmofTq7zdn7tUJJyp9kr557aorzQmrvo1uy88tbuHJM32rtHY7KL4Mt828CoE+3lp5lP/+8nZde+oHevR9m1qzv6ipspeJKKHeotgG2eL3PAwZ6NxCRNsBYYBhwQsSiC4E105t/y//yFw6WlNR6P3aLj5bx7rkneSXu5q4bmfx5/p5zOb5HK9q2TMesmALAxsawadNehg37FzabUFFhePDB+fTu3ZoBA6I/DYRSVhZKcveXP307zY8D/88YU17Dc0gnABMA2rdvH2qMcaPPUdVry+HwzDFv0W8275p7oiO0RwFePfY4v8s7dmxCbq4z2U+fvoAZMxZx0UUvAjB58jAmTRpSu2CVilOhdAHzgHZe79sC23za9Admi8gm4ALgaRE5z3dHxpjnjDH9jTH9mzdvHmbIyuq8e+uhJvdQTJ48jE8+meh5P336AhYsWB+x/SsVT0JJ7kuAriLSSUQSgYuAD70bGGM6GWM6GmM6Am8D/2eMeT/i0fpoqCMprP6pvXvukX6Id48eLVm79u+e9+PHv0FZWUVEj6FUPKgxuRtjyoDrcI6C+QV40xizWkQmisjE4FvXPateVKxL7i81q35275p7JHvunn0m2snNncKoUT0BOPro+9i580DEj6NULAtpyl9jzKfApz7LZgZoe2Xtw1KxLDmMmns4ZswYx6RJbzFnzhoGDXqUVq3S6devPSNHdmf06F4170CpOGbtYRfKL6tXo8K5oBquJ588nxEjnPPvb99ewMcf/8x1173NiSc+SmlpeZ0eWykri+nkbvEcV+csWpWpUpZx1PENV3a7jZkzL2TJklu48soBPPDA2QD8/vsBunW7n3vvnUNRUe2HnyoVa2I6uUNsjXOPNH+38ltBkqOy515fY/KbNk3j7rtHcfHF/fjxx9s8y1988Qeuuuo1ysv1oqtqWGI+uTdE7guqxqK/Xeq6FFOTzMwUcnOnsGbNHYwc2YMlSzbTtet9XHnlq2zblh/V2JSqLzGd3BvqUMjTB2UDMHFc/yhH4p93WSaakpMdzJgxjnbtnM9vXbhwAyef/DjZ2VO5886PKS4ujXKEStWdmE7uYN3hgHWp3VEZmBVTGNS7bbRD8SvaPXdvIsKcOddy7bUnV1n+xhvL6NXrQRYt2hClyJSqWzGf3JX1eI+WsYLU1ERuvXU4ublTyM2dwtdf/5XBgzsB8Kc/vcoDD8xj376iKEepVGRpclcRZ6Weuz+tW2fw2mtXMG2ac3LT55//nhNPfIz33ltBfn5xlKNTKjKs1cU6Qg2z4m59SRZP7m7nn9+XxMQENm/ex/TpC5g82TljxkcfTaBXr1ZRjk6p2onp5A4NeyikVVm95+7tnHOOAWDPnkJefHGxa9lz9O/fnmefvZCsrPp7fKJSkaRlGRVxVqu5h+Luu0eSk3M3HTo0AWDp0s306zeNP/7xP6xbt1PHyauYE3v/L1SWF0s9d282m/Dll9ezbVs+s2Z9xwcfrGTp0s2MGvUMAOPHD6Zly8ZcddUgbDb9zaisLaZ77lpztyarjHMPV+vWGdx990iWLbuNp5/+I0cf3QKAWbO+44EH5tOly728885ynbtGWVpMJ3domOPcrS4xwnO4R9PIkT2YO/daliy5xZPkAW699QO6dbufH3/cEmRrpaIn5pO7sp5YrLnXpGnTNObOvZbc3Ck8+uhYz/ILLniB7OypvPDC91GMTqnqNLmriLPb4/vX1Hnn9Wb9+rv4178u8Cy7//55TJz4X2666V2d1kBZQkwn94Y6t4zVNYRSWUKCjbPO6sWGDXczYcKJAMyfv5YPPlhFr14P8qc/vUpFhf73qaInppM76Dh3FV0iwu23n8EZZ3SrsnzRog106XIvxx77EDt26CMAVaUaNBAAABDlSURBVP2Lv+KoUlHwyCNjKSw8TMuWjdm4cQ+nnz4DgMLCEgYPfhSABx44mwsvPF6HUap6EfM9d6WsoHHjJI46Kh0RITu7Gbm5U/j117s8D/EGuPPOj+nS5V6ys6dy5ZWvsnevTlam6k5MJ3etaCors9ttzJgxjl9+uZOZMy+ssm7hwg307z+N7OypPProAkpKdMy8iqyYL8s0hIt3sejbl6+meVZatMOwhKSkBEaM6E5u7hQANm3ay+jRz3DoUBkATz21iKeeWsTpp3ej9aiBdDyuo/53rWot5pO7sqbBfdpFOwTL6tixCWvW3ElxcSlz567htdeW8uOPeXz++Tr4fB1DrxhKr1N70bRdUwDscXRTmKo/MZ3cdSikimUpKQ7Gju3D2LF9KCkpZ+LE//LVV7+y8OWFLHx5YZW2jZs15ua3bo5SpCoWxXTNHXQopIoPiYl2XnjhEnoM7eF3/YHdB5h62lSmnjaV9d+tp3BfYT1HqGJNTPfclYo3SalJVd7f9fldFOUXMf386Z5lb9zxhuf15Y9cTna/7HqLT8UOTe5KWYj4TN1gs9to1KQRf/v0b6z9ei1zn5pLcUHlowBfueUVALJaZ3H1v66mUZNG9Rqvsq6YTu5acVfxxnuUzPWvXu95nZiSSO8zetP7jN6A83rTolcX8eULXwKwb9s+T+8+86hMrpl5DakZ+hSphiymkzvoUEgVX9KbpQNw/l3n06RNk4DtRIShlw9lyGVD2LVpF7P/Ppt92/YBsP/3/Uw7b5qnbWpGKlc+fiXNOjTT/780IDGf3JWKJydfcjLpLdLpdWqvkNqLCC06teCG124AYMeGHbx979vs3rzb06Yov4inr3oagOx+2ZxzyzlkHpUZ+eCVpYSU3EVkJPAEYAdmGWMe9ll/KfD/XG8PAtcaY1ZEMlClGgK7w85xo44Le/uWnVsy6aVJHDp4iORGyeTvyOfxix/31DBzl+XyxMVPANCmextG3TiK4oJiUjNSad2tdSQ+grKIGpO7iNiBGcAZQB6wREQ+NMas8Wq2ETjFGLNPREYBzwED6yJgbzrOXSn/khslA5DRMoMpC5x3xi6fu5zCfYV8/tznAGxdu5VZ186qst0xw45h+6/bGTdlHC07t6zfoFVEhdJzHwDkGGNyAURkNjAG8CR3Y8y3Xu2/B9pGMshgtIKoVGj6juwLwEkXn0RFeQXfzP6GBbMWVGnz84KfAZg5fiYA/c7px/Dxw0lJT6nfYFWthZLc2wDeD4rMI3iv/M/AHH8rRGQCMAGgffv2IYaolIo0m93GkEuHMOTSIZ5la/63hs+e/YyK8goKdhYAsOyjZSz7aBng/HIYNG4QLbO1Rx8LQknu/jrHfushInIazuR+sr/1xpjncJZs6N+/v9ZUlLKQnqf0pOcplVMU5y7L9YyjB2dZZ/nc5Z73Q68YSvtj2pPdLxvROeotJ5Tkngd4zwLVFtjm20hEegOzgFHGmD2RCS84/XZQqu5k98tmypdTmHraVL/rfee/Ofb0Yxlz2xjsDp3ozApCSe5LgK4i0gnYClwEXOLdQETaA+8Clxtj1kc8yiB03K5Sdct9M1VZSRmpGamITZj7r7kc3HuQTcs3edqt+nwVqz5fRUp6Cq27teYPd/5Bb6SKohqTuzGmTESuA+bhHAr5gjFmtYhMdK2fCdwNNAWediXbMmNM/7oLWylVX/zdTHX+Xed7XpsKw9a1W1ny/hJWfraS4oJiNizZwPQLpnPihScyfPzw+gxXuYQ0zt0Y8ynwqc+ymV6vxwPjIxtaSHHV9yGVUj7EJrTt2Za2Pdty9s1nU3KohJzFOXz/9vd8/drXtMxuyTHDjgFgxbwVpGWlUVZSRtuebXUunDoU83eoalFGKetwJDtwJDvoc2YfegztwUNnPcQX//6CHkN6sPqr1bz/8Pt+tppKWqNMpv9nNXZ7AhUV5SQm6dDL2or55K6UsqbElEQuuv8iZt85m3XfruO9B98DoEWnFuTvzOdw4WFP28KD+5k4rk2V7cdccjs9ew/h6F4n1mvc8UKTu1KqznTu3xmxCYvfXQw4h1uOu2ccABXlFRzYfYDGW8/mvsmnV9v2g9cf5oPXK2c6OXHYRbRp350BJ48lo0lLHI6katuoSjGd3LXirpS1JSQm0LhpYzav3AzA6L+O9qyz2W1ktMygY1o//vnv5dx2TV/SM5vzxCvryfttDdu3rOfpf1xFo/SmHCzYw7cLZgPw1ov3VDnGwKHns3jhO3TvPYQ/3/AU+/f9TvbR/bHZYv5Bc7US08kddCikUlaXeVQmBbsKSM1IJS0zzX+bpkcB8IfL/g5A2w49aduhJ/85+TwAysvLePeV+2mc0Yxdv29iwafPe7ZdvPAdANauXMSt4/tU2a/YbLRt34PjB5/NWRf8FUdicsQ/n1XFfHJXSllb5lGZbF61OejIGIcjif98tC/gers9gXFX3uN5f/m1j3D4UCEHC/aS99saViyZzy8rF/H71l8BSElLp7iwAFNRwZZNq9myaTUfvPEPAE44eSyt2nThxGEXsev3TaRnNad9p2Mj82EtRJO7UqpOZbZyzh2fmJIY0f0mJaeRlJxG0xbt6HPCmdXWFxcV8M2C2WzbvJZ1P39HelZz1q5cxJKvnRd2P/zvtCrtH5q5xJnsM1sAsCnnJ/L37WTwqX+k+VEdAKioqIiZck9MJ3cd566U9WW1ygLgcNHhGlpGVkpqOqefPaHKsvWrv+Xggf3s3rmZLRt/xlRU8M0C5wPH/zbxBL/7ee+1B6st6957CFdcO53PP3qWnn1Ppd/gsyP/AWopppM76Dh3pazO/dSnQwcPRTkSqg2rrCgvx5gKtm1Zz6acnwDof+K5NG3Rjn17tmGzJ/D9V29V28/alYu449oBAJ76f58TzqS4qICLxz9Ixy596/iT1Czmk7tSytoaN2sMOOemsRqb3c41N8/k8KFCJo5zPoZi0t9eqtLmL5OfwxhDyeFiHInJlJYc4rZr+lKwfxd9+o9gxdL5AKxYMg+AqTedht2eQOfuJ9Cp6/FkZLXk8OEidm7LpWPX4zjjnL/Uy2fT5K6UqlPJac4RKqbCumXUpOQ0Hn1xNQX7d/tdLyIkJae62qbyxCuV8yNWlJezY3suFeVlrP35a9579UE6dj2eooP7mff+jCr7+e6rNzluwCggq84+i1tMJ3fr/qeilHJLSU+hUdNGjLh2RLRDCSqraWuymh75c2Rtdjut2nYFoE2HHgw/6xrPusOHCikqdD74ZN77M5j3/gxKSoojE3BNcdXLUeqQjnNXytpsdhuT357MscPjb7hhTZKS08hq2oqspq04uudgAMrLSuvl2DGf3JVSKhbYE5yFkrKykno5niZ3pZSqBzab8wlVpqKifo5XL0epIzrOXSkVK0Sc6baiorxejhfTyR10nLtSKjbY7M6euyZ3pZSKI+6yTIWWZWqmRRmlVKxwz0mjPfcQ6VBIpVQsEL2gqpRS8cemF1SVUir+iE0vqIZMh0IqpWKFXlA9QlpxV0rFAptdyzJKKRV33DcxGaM9d6WUihs2rbmHTivuSqlY4Unu5ZrcQ6Lj3JVSsaBy4jBN7kopFTc8Pfd6GuUXUnIXkZEisk5EckTkdj/rRUSedK1fKSLHRz5UpZSKXWJzVhksU3MXETswAxgF9AQuFpGePs1GAV1d/yYAz0Q4Tr90nLtSKlZYsSwzAMgxxuQaY0qA2cAYnzZjgJeN0/dApoi0inCsAOzatYuFv/3m+Zd/6FBdHEYppSLKndx/WbmIjRs31v3xQmjTBtji9T7PtexI20TEV199xSkvvsgpL77InuJithQU1MVhlFIqohITUwBYvPAdnn322To/XkIIbfwNR/Gth4TSBhGZgLNsQ/v27UM4dHWnnHIKX1xxBQDDX345rH0opVR9S22Uwe0PfUxZaQnjL677h4WHktzzgHZe79sC28JogzHmOeA5gP79+4dVMG/RogXDOnUKZ1OllIqqbsecBECXLpl1fqxQyjJLgK4i0klEEoGLgA992nwIXOEaNTMIyDfGbI9wrEoppUJUY8/dGFMmItcB8wA78IIxZrWITHStnwl8CowGcoAi4Kq6C1kppVRNQinLYIz5FGcC91420+u1ASZFNjSllFLhCim5W9X8yy5jT3FxtMNQSinLienkfkbnztEOQSmlLEnnllFKqTikyV0ppeKQJnellIpDmtyVUioOaXJXSqk4pMldKaXikCZ3pZSKQ5rclVIqDkm0nmYkIruA38LcvBmwO4LhRJLGFh6rxmbVuEBjC5dVYws1rg7GmOY1NYpacq8NEVlqjOkf7Tj80djCY9XYrBoXaGzhsmpskY5LyzJKKRWHNLkrpVQcitXk/ly0AwhCYwuPVWOzalygsYXLqrFFNK6YrLkrpZQKLlZ77koppYLQ5K6UUnHIEsldRJJF5AcRWSEiq0Vkqmv5PSKyVUSWu/6N9trmbyKSIyLrRORMr+X9RGSVa92TIiIRitEuIj+JyMeu901E5DMR+dX1N8tCsVnivInIJtc+l4vIUteyqJ+3AHFZ5ZxlisjbIrJWRH4RkcFWOGdBYov6eRORbl7HXy4iBSLy12iftyBx1c85M8ZE/R8gQCPXawewGBgE3APc4qd9T2AFkAR0AjYAdte6H4DBrn3OAUZFKMabgdeBj13v/wnc7np9O/APC8VmifMGbAKa+SyL+nkLEJdVztlLwHjX60Qg0wrnLEhsljhvXse1A78DHaxy3vzEVS/nzBI9d+N00PXW4foX7ErvGGC2MeawMWYjkAMMEJFWQLox5jvjPCMvA+fVNj4RaQucBczyieEl1+uXvI5jhdgCqdfYgsQQ9fN2hPHWS1wikg4MBZ4HMMaUGGP2Y4FzFiS2QKL1v+dwYIMx5jcscN4CxBVIROOyRHIHT2lhObAT+MwYs9i16joRWSkiL3j9rGoDbPHaPM+1rI3rte/y2nocuA2o8FrW0hizHcD1t4WFYgNrnDcDzBeRZSIywbXMCufNX1wQ/XOWDewC/iPOMtssEUnDGucsUGwQ/fPm7SLgDddrK5w3f3FBPZwzyyR3Y0y5MaYv0Bbnt9UxwDNAZ6AvsB2Y7mrur95kgiwPm4icDew0xiwLdZMAMdRnbFE/by4nGWOOB0YBk0RkaJC29Rmbv7iscM4SgOOBZ4wxxwGFOMsJgVghNiucN+cBRRKBc4G3amoaIIY6ic1PXPVyziyT3N1cP/W+AkYaY3a4kn4F8G9ggKtZHtDOa7O2wDbX8rZ+ltfGScC5IrIJmA0ME5FXgR2un0u4/u60SmwWOW8YY7a5/u4E3nPFEfXz5i8ui5yzPCDP61fr2zgTatTPWaDYLHLe3EYBPxpjdrjeW+G8VYur3s5ZJC4W1PYf0BzIdL1OARYBZwOtvNrchLMeBdCLqhcecqm88LAE58VY94WH0RGM81QqL1pOo+rFmn9aKLaonzcgDWjs9fpbYGS0z1uQuKJ+zlz7XAR0c72+x3W+LPHfWoDYLHHeXPudDVzl9d4q5803rno5ZxFJLBH48L2Bn4CVwM/A3a7lrwCrXMs/9Dkpd+K8mrwOryvHQH/XPjYAT+G6CzdCcZ5KZQJtCnwB/Or628RCsUX9vOGs0a5w/VsN3GmF8xYkrqifM9c++wJLXXG8D2RF+5zVEJtVzlsqsAfI8FoW9fMWIK56OWc6/YBSSsUhy9XclVJK1Z4md6WUikOa3JVSKg5pcldKqTikyV0ppeKQJnellIpDmtyVUioO/X9GHD/PzXZGgAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", - "Pyo warning: Portmidi warning: no midi device found!\n", - "Portmidi closed.\n" - ] - } - ], + "outputs": [], "source": [ "data_soni = SoniSeries(spectrum_B)\n", "data_soni_preview = data_soni.preview_object\n", @@ -290,34 +183,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "9de2f2aa", "metadata": { "scrolled": false }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", - "Pyo warning: Portmidi warning: no midi device found!\n", - "Portmidi closed.\n" - ] - } - ], + "outputs": [], "source": [ "data_soni = SoniSeries(spectrum_A)\n", "data_soni_preview = data_soni.preview_object\n", @@ -327,34 +198,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "a71a37ec", "metadata": { "scrolled": false }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO2dd5gUVdaH3zs9M2QYwkgYwpAkBxVRRFkRAwiKKK6yGHBZEdBVV0UxLWL4VFyzGFBRVIIBAyiCigoYSSJBQAmShQHJApPu90eHqe6prq4O013dc97n4ZnuW7dunSl6fnX63HPPVVprBEEQhNQiLdEGCIIgCLFHxF0QBCEFEXEXBEFIQUTcBUEQUhARd0EQhBQkPVEXrlOnjs7NzY3s5O3bY2pLUlAz0QbEn2Pl0PXYk59oC+JPheK6iTYh7tSu4Yr43CVLluzWWmeH6pcwcc/NzWXx4sWRnXzffTG1JSm4ONEGxJ+N1RJtQfyZtCnRFsSf3EM3J9qEuDOkX1bE5yqlbH1KyqFvJAiCkPqIuAuCIKQgIu6CIAgpiIi7IAhCCiLiLgiCkIKEFHel1ESl1C6l1Mogx5VS6hml1Dql1HKl1ImxN1MQBEEIBzue++tAb4vjfYCWnn/DgBeiN0sQBEGIhpDirrWeD/xp0aU/8IZ28wOQpZSqHysDywsb9u7l8/XrE22GIAgpQixi7jnAFsP7rZ62UiilhimlFiulFufl5cXg0s5l3Lffcvl779nu3/yZZzj3rbfK0CJBEMoTsVihqkzaTHcA0VpPACYAdOnSJaV3Cbnjiy8AmDZwoOnxVbt24UpL444vvqBFTf/aAvuPHqVYa2pWqlTmdgqCkJrEQty3Ao0M7xsC5bD4Swn/t2BByD7tXzCfmjhr0iS++v13APSYMbE0SxCEckQswjIzgKs8WTOnAvu11jtiMG5SUqw1d3/5ZcTne4VdEAQhGuykQk4FvgdaKaW2KqWGKqWGK6WGe7rMAjYA64CXgZFlZm0S8OeRI37vr/rggwRZIghCeSZkWEZrPSjEcQ1cHzOLkpw05T8F8eby5bwxYECCrBEEobwiK1RjTFFxcaJNEARBEHGPNYUi7oIgOAAR9xgTb3F3R8VCk/fnYX5YvrWMrREEwSmIuMeYYhOxnb1uXUThmm6vvooaO5bZ69aZHn/v819I63w/H8/71de2c88h7n3uS7oMmuDXt9ewN+h25au2HwaCICQ3Iu4xpshEPPtMnswT338f9lg/bHV72n2nTKGoqPTDYdpsdy23C26cymffraewsJh6Zz3Ogy8vYMkv/tmoK37bBcCGrXvDtkMQhORDxD3GmHnu4K4dE82Ytz7+mWWfJau3M/2LX0KO1e3KVyO2QxCE5EHEPYZsO3CABZvM965VhhTJYA8AK2Z8vbZUW1FRyTjzFm/i8jumhxwnb+9fYV9bEITkIxblBwQP7V94gX1Hj5oeM2a/FxQVhT12oUlYxviQmPOdVJQUBKEEEfcYEkzYAf4qLATg+UWLmLxiRdhjm4p7sfU3gN+37eP37fuoWb2iX/t198/k7FObcem57cK2QxCE5EDEPU68vmwZr/Xvz/WzZkV0fkGhteduRp/rJ7Nm4+5S7ROmL2XC9KVoEXdBSFkk5h4jft2zJ2Qfb/ZLJBQWFlNUVEybi8b7Jk7NMmiM7Nh90PJ4w3Oe4JulmyO2SRAE5yLiHiN2HLQWUoBF27ZFPP6+g0fZtusgazbu5qq7PwRCh2X2HzxmeXzbroOccc1rbN6xP2K7BEFwJiLuMcKVFvpW3jh7dlTX6Pz3FwE4mu+O30eSdWPGwFvfick4giA4BxH3GBGPlZ97D7gnbL0eeyjP3YzAyVWARau2c/ivfJb8Uq73WBGElELEPQQFRUU8+s03HDhmHeKIlRcdDpFc0/uACOT+l+bRZdDLbPnDHaJ5dOI3qE5jKSgIP21TEITEI+Jugdaapk8/zei5c6nxyCPWfeNkk5F5i80XTEXCB1+uAaDxeU+xI+8gD0yYD8CRY4W+Ppu27+OZyT/G7JqCIJQdIu4WFGnNNhsTpZAYzz2WFBlCPFNmleTh/7Rmhy/k9Lehr3PTuNnsllWuguB4RNwtCKeSo1NL/drFWFDstic+5/CRAgDOHDqJNz9eDsCm7e6QTX5AqOahl+ezat2umNojCEJ0iLhbYFbhMRjGkgJVMjLKwhw/Ck0WNYXiuzf+GdG17nnuS8ZPW+h7f8yTrZNfUMTbs1dyz3NfcdrVEyMaWxCEskHE3QIzz33bgQO8tXx5qfZvt2zxvbaTFhktZuUIQtG4Xo2IrrXljwPc8PCnvvf5he4H2R1Pfe4rVnbgkPWEsyAI8UXE3QIzz/3er77iyg8+YHtALP7hb77xvXYFbJJtRce6df3et6lTx9Z5H31VukpkKBocVy3sc8y44q4PeOCleTz1Vsnkahi/siAIcUDE3QIzz/2LDRuA0pUdB3fo4Hsdjuc+/KST/N7bPffR1761fQ0vKkYKvHjVdv77/Nd+bVqD6jSWT+b/an6SIAhxRcTdAquYe+CRpllZvtfheO7pAWLuPTOrYunFRkYCJzXtkpZWti72Xc9+WabjC4JgDxF3E3YeOgRYZ8AEHjM+COxOwz501lmlPPU0z4OhgstFkxrBY+QFhZGJe0Z62f6Xt861F1YSBKFsEXEP4KM1a6j3+ON8tXEjf3hE3ozAkI3xvd2c91yDt+8lzeD1W4VRzEoA2+FYftmuOG3bXMRdEJyAiHsAi7a766ss2LyZ6z7+OGi/QM+9MAJxN8PoyVsFUCINy1ixZ/7t7J43Kqox7nthXoysEQQhGkTcAzAK6uH8fL9jc9atY8uBAwA8+cMPPPH996ixY5myYgVvr1rl6xdK3NsfdxwAXXNyfG0ta9UC4IzGjUtssfDc8yMMywTivUSzhjWpVaMStbMqkxNlVk2oBVZaaz795reQ9egFQYgcEfcAvLKkKB0792bKAExfvZpbP/sMgBGffOJXpiDUytYBrVujx4yhhUfQAbo3bszGm27iqk6dbNnpXUgUyJjhfzOdNG1Ur7pp/7bNsgGY8vDFvrZoF78Ghn4KCoroM3IyN/zfLBav2s65w9/i/OunkHX6o9FdSBCEoMg2ewF4vU6llKUHbvROAytGhlrZmulymbbnZmXx8x9/2LLz4OF80/b7RpzJX0cLeOz17/zabx58qml/r6kVMmP3UZj66QquuegEAH7btIfjL3zOd2z824t8rw/9lc/n36/nnG7NY3ZtQRDciOduYN/Ro36ee6C4G0V8f4gSwFZkWOSyGydU61SuHNa4m2bfDERWdybdFdymqy+0923Cyz/HzPC9nvvjRsu+V979QVhjC4JgD1virpTqrZRaq5Rap5QabXK8hlJqplLqZ6XUKqXUNbE3tWx5e+VKaj76KEt27ADMPfcJS5fSsLp5eMPImbm59Dv++KDHjZ57YADFGGf/4LLLbFheQuP67tTJaMMqOiAg9Y8+Hfze9+/Zyvf6tfv7c3TR3RQsudd0rKxq1vn6O/ccLhV7Lyoq9itkJghC+IQUd6WUCxgP9AHaAoOUUm0Dul0P/KK17gScCTyulMqMsa1lyuz16wFYvnMn4Im5m6jkmbm5IcdyKcWT550HQPOaNUsdDxaW8V7XS4Nq1fjyqqtMUya9vHZ//1JtJ7dr4HsdatFS9aoVAOt5AuO87vL3hjP1kUvo1qkhALVqVKJCZjrphvz5ru1LJoozMkL7D7V6jPN7//zbi2je9xnWrpVKk4IQKXY8967AOq31Bq11PjANCFQUDVRTbrezKvAnYD7j51C8qYzesIhSynQxkt0ywEUB4xnJsBB3b3/vtXs2bcr4888P2t9sUdJlvdtz/hktAXAFiHtfTztA1cqZvD1uIHcOPZ0OLUtq3HgnWb0Yv010aFmXShUzfFv8mV3/r6MFvtdFRaG/Rhw4dIxf1udx5GgBX/64kRsfde81u2+f1I0XhEixI+45wBbD+62eNiPPAW2A7cAK4CatdSkVVEoNU0otVkotzsvLi9DkssErxt7SAQq4okOHUv2mrlwZcixjSMdM3I2ee6D0maU/WvnewUIwTTwhmsDxzunWzO994/o1+L8be/l5+O/97+98+vxgg02lx/9jj3uBV0Z66QfVynW7+P7nLazekMdlt79nYX0J947/ij7XT6bXsDd8bZkxnOQVhPKGHXE305ZASTkPWAY0ADoDzymlSgWntdYTtNZdtNZdsrOzAw8nFK/n7l1ENHruXGqEqO8SyEv9+gFwa7dutsU9ELP+kRT88qY+1s+u6tduZ1PtrOoVOe+0kgwW5fkI9Dw519fm3bgjb+9h0zFuePhThtz7kW1735+7utS2gYWFxUyc+AM//bSVpUu3sG/fEdvjCUJ5x45rtBVoZHjfELeHbuQa4BHtDlKvU0ptBFoDC0kStnoWJxmLfoWzExNA3SpV0GPGAO667wA9mjRh9e7dfv2ssmXMZDySUl+jru5Om6bZzFvyu19pXmMdeKsMGeMDxfuAMMbSF025ll7D3qB39xam57vSFJkZwR9idigqKubBB+f43rdpU5dPPhke1ZiCUF6w47kvAloqpZp6JkkvB2YE9NkM9AJQStUFWgEbSCK+37oV8P9KEm4ZAWPpgJzq1Vk5YgTP9OlTqp/Rcz+pfn0Azm/hFslYee7p6WlcdFbrUu19zzjer48d2jTLZtk71/HgDWf52rq0a8D+b0dTs3ol03MuObsNFTKjE/ePPvLfFGX16p1RjScI5YmQf91a60LgBmAOsBp4R2u9Sik1XCnldaMeAE5TSq0A5gJ3aK13m4/oTGpXcotUrUolYhXONntQutRvu+OOMw3BGNs61avH4bvu4tJ27YBIYu7h2di2eTZHF90NwMM39rJ9XqdW9UI+DJa9cx3L33N/JPILiqL23N9++6eozheE8oytGSut9SxgVkDbi4bX24FzY2tafMnNymLPkSMRVXf0YnejjUDBr2zYc9XMc481FTLT0T+Pifm4nVrVQ2uNUm5xN5tsFQQhPsgKVQ9eITd66+HG3O0Ks1UqpGnMPQaCH69t8JRSVKyQztH8wqg9dysWLtxEixb3c0j2bhUEU0TcPXhF3eith/Lcq2b6r9OyuwNT2NkyFmNFuRi1TKiQkc6x/OjDMmZMn76MwYMncfnlr1NcrPn6699ifg1BSAUkkdhDsYm4h4q5B9Z0jzQsY8Q05h6F233nP8/g9237+aenkFc82HfwKM9OXcg1/TvHfOxRo/zTKytWzAjSUxDKN+K5e/CFZQyCPX31astzAjfJth2WsVk4zMvJDRqY9LTHcbWr8MFTl1EjRI2XsqCst/QDOHaskMOH85k06Ufy8oLvnCUI5Q0Rdw9ecV+7Z4+vbc9f1svfAz17u2GZcGPu1SpU4LLz2tkaO5Y8fuu5zJs4JOLzQ2XXuFzRTwQUFBRx+ulPMnbsbAYNeh2AVat2UFBQxKFDx9i586D1AIKQokhYxoNZfD1W2TIXt2nD+4ZvAVYefrAQjJUtl57bNurdk8y45apuEZ1Xp2Zldu/9iymzrEs1uNLSKCqKbkepY8cK2b//KAAbNuyhWbOxAAwZ0pXXX1/oaY99ZpAgOB3x3D2YZcYUa031ChVs11UP5rm/e+mlrPv3v33vrcTdt1lIoC2esgF1a1cpdc47j13Kk6N627IxHgw+vwPVqmSy7+BRX9v5hoJlXqxy9O8cerqta91550zT9kWLNvte5+Ud8t2//fuPsHTpFtNzBCGVEHH3YDZ5qnELsd3gQTDRTlPKsoa7kSOF7mKaxtx3KBH3Z0f3oXOreiU2Rlu8vQxId6WVqgZZvYq7tPBr9/enddM6Ice459oeUdlgLDp2yimPM27cFwA89thcBg6cyPr1SbXGThDCRsTdQ7CwjEsp2ytVrbJljMesPPfcrCxGdunCx//4h197ka/ErovTT2hkdqpjSHelUVhUTLOGpWvZV8h0MXHshQzq0963uYgZ0aZR/vTTVr/3U6cuAeCrr9ypk3/8cSCq8QXB6Yi4ewgq7mlp/OsEe2mEVhOqxmNWqY1pSjG+b1/aBlTN9HrurjTlV563amXn7YnicimKiospKCziqgs6cWzxPVze2z0h3KVtA7p1asSURy6xfhgGTLZ265YblU0HDx5j06Y/fd903nnnJ3bvNq9oKQipgIi7h2Axd5dSPHL22bbGsPLIjUIWSY6Ir4RwmvJ7OAw4q00Eo5Ut3rDMlj8OUCHTRWaGi/49W6N/HkPLJrVtjRH4AHzooQuitmvq1CX88Yc7e2bmzJV07fo/DhwomReYM2c1h4NsPC4IyUa5F/dN+/YxY+1aS889UGge7mVecMvSEzWMEUn9GK/n7hZ3d9vJ7RqE3EYvERjvw5cLrTfIBvjo6ctD9qlSJZNGjYJvN2iHCRO+K9X29NNfA7Bz50FGjHiHDh0eZvXqP6K6jiA4gXIv7ie89BL9p00zFXettU+IvfuYZlWsSKva5t6nZVjG6LlHIO7DLz0JgM6t6vlscqKwg39IZf2W0BtdH2/Dm1dK8d57QwEYOdJeJo0dDh06xsGDx+jW7QlfW9++L8VsfEFIFOVe3PcedX8tNxP3Ik9YBkrqrmekpfl53sasFrueeySS7A1r1M+u5ns4OFXcjZuAxMpGrTXZ2VXZsGEM7drVt+xb2yRdNBirV+/kww+Xl2qXgmRCsiOLmDwE1omBkrAMlIRSMl0uP8/bbrjFbraMHbyCGY/ywJHgMoi71W5PBYXuBUx2yhRUNkwcuyzGBMjIsO+zrFy5g5Urd5Rq79jxEVn8JCQ1Iu4e8oOslPSKt1dIM1wuP1E1inYssmXs4D07lMglCpfBW7cS9/YtjmPjtn2+HPhAFi26jYoVMzh6tIAqVYzibn3/0mNUR/7hhz/jzjuTepsCoRwj4u7Bu3gokLRAcQ8Iy7iCCH0g5clzNwq6VX2Zt/7vYpat/YPsWlUYNeQ09h88yoTpS33HveEVo7ADpIWovnn4cGxCKi+//D1duzZh+/YDNGlSkxUrdnDRRR3JyQmeny8ITkHEPQSBYZkMl8svZm5XtNOijLkbcXrM3fiNwirkUr1qBXqc1ASAcf85B621n7gHI/D3XrJkFCed9BgAU6dezfXXvxuJ2aZce+00v/ePP/4l69f/NyYbqAhCWeLM7/UOolRYJsBzD+bFWxF1WMZzumPF3WZYJhDvfWnSwNozDvy9a9Ysqf3TvHk2f/5pXc3TS/361W3bZuTbbzfSvfuT/PzzNhYsWM877/zkS1UVBKcgnnsIAj339IC8d7thGSNRh2VUEoVlwpwX+OqVq2nf4jjLPlYPx8Aw0Kuv/oP27etzyimP+9qaN6/D+vW7I344XnXVmwAMGPCKr2306BlMnz6UE05oGNGYghBryqXnfqywkI17Q+dfQ2nPPT0w5m5zQtVIeQrLDDynbVjnnnlyLnVqWlfhtPq9AyeZe/ZsSXZ21YA+7vOrBJnIjZSbb57Ozz9v82vTWjNx4g9s2vSnbCYixJVyKe7/nDGDZs88w18FBabHT2/c2Pc60EsuJe4RrDyNNizjm1B1qrgb7HrwhrNiPr7V7x1qg5AFC27yPQDuvfe8mNq1Zcs+P28eYNOmvTz44Bx69nzW79uDIJQ15VLcP1qzBoChM2aYHjdug2caljH0dZn0DUW04RTv6c6Udn+BLYtNsq0IlR6ak5PF//53Eeec04quXZv42l9/fXDMbGjWbKxv05Dvv/cvv5CfH93mJIJgl3Ip7t6c9mkrzXcKMgu1BM1zj2RCNTxzS+G9vlMzNoz3L9yYux2satgbHyx9+5pvTdimTT1eeulyMgwPnh49WpTqf9FFHRk8uAuDB3eJyM78/CLuvvtjv7YDB47y4INzWLBgfURjCoJdyqW4F5isRjWSHsJzDxZzt+uRR++5O1PUvRgXGcU7dGS8Xna2/TIEAE89dTGrVt3FAw/0BaBSpQweeKAvWVmVALjppr+Ftfr1vPPG06yZf92cw4ePMXHiD1x99VusXbuLY8cKOXhQSh0IsadcinsozLxxO9ky8Yq5Oz0Vsiy8dSN2N58Kd5MqlyuNSpUyfGmNgfdZKcWCBTfbHm/Tpr1s2LDHr61nz2d9r/v0eYFBg16nU6dH+OmnrWzbti88gwXBgnKXCtnpxRdD9kk38cZDee5pStkW7ajDMj6xiXKgMsLu3ENZYyf3/OmnLyl1H7Whdn7geMdFsBH5ySc39tvT1ciyZe7smksueRWAMV9JPRshNjjjrzCOLN+5M2Qfs0nSoBOqEeScRx2WcexUqptQtV/iRf/+HUL2ueCC9vTr196vLSfHXd65RQv3blgNG7rfN2/u3vv1k0+uC8uO+vVrMG5c/7DOEYRoKXeeux3SrSZUg3ju4chZrFIhnSryZR2WMePTT0ewYsV2AEaMOJ05c1Zz4okle83ef//57Nhhb9/Us85qyZQpV3PKKe5smoEDO9O4cU1fdk2bNvWsTi9FRkYatWpZ5+57WfPNGt6+923+9fy/yGmTE9Z1BMGIrb9CpVRvpdRapdQ6pdToIH3OVEotU0qtUkrNi62Z8cVqQtVlkedul+gXMUU5QBlT1mEZs2yZVq2OY+DAzgCMGtWLL764we/4FVeczKhR5jtoBaKU4tRTc30PYaUUp5ySa/lQfvLJi7nvvj6mx4qKND17trR17bfvfRuAV0a+EqKnIFgT0nNXSrmA8cA5wFZgkVJqhtb6F0OfLOB5oLfWerNSynr9uMOpX7VkRaNXvI0/VQSTqEZiVX7AqSIfaiFRtDixjkv37s38JkQXLbqN1177geef/4biYm36YHj66Uu46abpQcccP2Q8uzftpvXprVnzzRpcGS5unnYzVWtVDXqOIHix81fYFVintd6gtc4HpgGBAcR/AO9rrTcDaK13xdbM+OJSyreQKXBCNU2poKmQdok+W8bpee5la1d+vnl55nhiDLO8994/qVOnii9c1qhRFrVrV6FJk1pA6YfdiBGn89prg7ngAnes/9RTcznxxNI1aXZv2g24QzUARQVFPH7J48x+bnbsfyEh5bATc88BthjebwVOCehzPJChlPoaqAY8rbV+IyYWJoA0paiQnk5Bfn6psIwC07BMOEIbq7CMQ7W9zDcROeOMFgwc2Jn33lvGuee2LtNrBeOjj4axatUOTj+9mW+XKG91yu7dmwEYUipL/qOysir5hYdWrryTjAwX06YtZenSrbau/eP0H+k6oCu1cmrF5HcRUhM74m4mIYHfi9OBk4BeQCXge6XUD1rrX/0GUmoYMAygsaF+S7Q8t3AhD8yfz87bbvO17T1yhAWbN3Nhq1a2x1G4fzGlFBVcLg5RekI1TSnT8gNWqyZLXSdWE6oOVfeynlDNzHQxblz/hGag5OTUKLVpR8OGWXz44bW0auWOSnbp4v6M9+vnXvn6yy93lfo/8z4YrriiC2PGzLJ9/WeveJaKVSty3cvXsWvjLjIrZdKofSNcMdqFSkh+7Ij7VqCR4X1DYLtJn91a68PAYaXUfKAT4CfuWusJwASALl26xCxw+u9PPwWgoKiIDJf7w/2P999n9rp1bPnPf2hY3V7d7vS0NAqKi32eO5SeUC0VlkmAwDo1S8ZLWYdlnEzHjg18r5s3r+O3D2vFihlmpwD+D+pzRpzD5y98HvJaRw8d5elBT/u1DR0/lKq1qpJVLyscs4UUxI6LtQhoqZRqqpTKBC4HAitufQScoZRKV0pVxh22WR1bU0Nz1LBV3gZPSd9D+fm+tplr11qe730wKKCC53Wg565iMKEaLY5fxOTQvV2Thao1g0+YukIUYnv1+ld5etDT7N68O9ZmCUlGyL9CrXUhcAMwB7dgv6O1XqWUGq6UGu7psxqYDSwHFgKvaK3Nq3LFmA2GuuzFWjNhyRLGL1zoS2csNNSRuevLLy3HMk6iej33wAlVrXXUE6rR4lRR95KIPPdUIHCvWDMG/negrbHGXz2eb6Z+w+G9hzkWoz1lheTC1iImrfUsYFZA24sB7x8DHoudaaH5aM0aLnr7bd/7Yq257mN3Fb7WddyrCcMJofg8d0/M3XhOtFvrxRKnL2JyygrVZGPy5Kv5eIdmz5aSejRjvhrDkYNH+Hbqt2z8aSOtT7c/gTx3wlzmTphLlZpVGPbSMCpUrkBGxQzyj+STnpnOoT8PSfgmhUnqFapGYQe3uAe+TlOKA8eOUS0zM2QIxSjkwWLuQNB67vHCK+pO9eCdUlsm2ejYsQE/1cBP3AEqVavE2cPOjnjcw3sP8+Tfn6RWTi0atm3I8s+X+47d8/k9fpOwWpvn5AvJR0r9FZqJ++H8fGo88gi3fvZZyA+tsZSAkz33klRIZ/4RSlimbLlj5h0MmzDMr81OuObPbX/6CTvAc1c9x5ZV7kznvE153H/W/Wxbvc3sdCHJSKm/QjNxv+WzzwB48ocfWLpjh+X5RiGvGMRz96ZK+s5JgJfq/AlVhxqWIlSsWpF6LerRuU9nKlWvRL9b+tGup/nGJKHYt2MfE2+YCMDKue5psvlvzmf/rv0xs1dIDEkt7u2P869y8Om6db7XXnGfv2mT7fF8nrvFhCpgWhUynjjVY/ciYZmyRylF/9v7c/tHt3PSBScBUKeJe57p+knXhz3e2J5jOZDnLqz26/e/8tRlT5F/JD/EWYKTSeq/wpxq/rW1f9tTEqssDnenBgyrTYFMu2GZRHjuDi8/IGGZxDD0uaHcOOVG6jSuE9H5y2Yv83v/8PkPh7U4T3AWSf1X2C472++9Me2xKMRWemb4VpviXwUSAjx3p8Tc435le0hYJjFUrFqRmvVrxnTMeW+UFHj9a/9fPu9ecD5JLe6BPkVdQzXHaDx3Yy57oOdeKs89oYuYnCmiTt3+rzxy7YvXRnX+vNfnsejDRaz8ciWPXfQYT/79SYqLijly4EiMLBTKiqQW90CqZpYsAimMwHNPt+u5G85JxApVp4q6l0Tck1TCm5rYuU/nqMeqVK1S0GPZudml2vrcWLom/aynZzH9gZLSxBOum8C4/uPI25THC0NfYOknS6O2U4g9KSXu+UVFvtcFUYRlig3euQakQb4AABjASURBVOmEaoJj7t44qFM1VDz36GjTow2nDz6d80aeF/EYoz4cxa3TbyUtyPxH5azKjHxtZKn2rgO6hhx753r3VpXPD3meXRt2MfN/MyO2Uyg7klrctdZUzczkxPr1AXfhMC/G13YxhmUC20LluSdi2smpHrxT7UoW0lxp9PpXLypWrRjxGJVrVHZv6hHwX3HaZadx+0e3c9OUmwAYMXGE71jbv7UFoFG7RoTL2J5j+WbKNxHbK8SepBZ3cAvtqNNOA/y99cMFBWGPZfTcvQJvmuduck48cXoCg4RlnIP21JSv17IewyYMo9e1vahUvRKZldwhzOOalqQTD7hrAAC1GkZWJ/7H938sdV0hcSS9uEOJmEQSZzdijLl7MduMI9ETqhKWEexSo24Nzr7ubAY9NIj6LeubhmmGvTSMfrf2Iz3Tvbajx5U9qFanGpmVM0vlzJ874tyg1zq05xBje47l+SHP88A5D1BwNHwHS4gdSV1bxivCXrFduSu63f1MwzImnnniY+4eOxyaDOnUh055RClF98u7W/apf3x96h9f3/e+Vk4tbnn3Ft/7u+fczUPnPQRAlZpVQl4zb1MeAL///DvNuzQPGvcXypakv+uKEnGfujK6KsNe0S7WutSDw6hXiV6h6rPDoSIqYZnUIj0zneGvDGfAXQNsibuXKaOn8PWkr8vOMMGSpBd3iJ2YlIQ7VEnMPWBsJ9Rzd/qqQQnLpB51m9el4zkdaXZSM1/bSReeFPK8dT+uC9lHKBuSWty1oaxvzMf2/AwU71KFwxIRc/f8dKqDLNkyqYtSir+P/TsD7hpAv//0C9l/x6872PGrdcE+L8eOHmbF0rnRmih4SGpxB/eHzY64zxsyJKxxg3nuCidky5R8w3AiDjVLiBFterSh4zkdbfefdMskv/c7ftvB9rXbWfjBQua9MY+jRw4BMOGJ4TwxZiB79wRu0SxEQlJPqHr5dc+ekH16NGnClIsv5h/vvx/W2MZKkV4Sny3j/ulUEXXqQ0eIPUOeHsKc8XN83nnXAV1Z+MFCvz7Gbf5+X/Y7k/7jL/ZFW+/ijHMGs/R79y5qi7+dSaOm7Wjd4fQytj61SQlxPxIipz03y72V2KAOHRg7bx5rgzwMtMnrNJMMmkRny5jZIQiJoEnHJlz7wrWs/W4tjTs0Zv6b8wFoc0YbVi9Y7de3uKi4lLADLPj8TRZ8/qbv/ZSXRwPQvPXJZNfL5bpbJ5Thb5C6JHVYJlhcPBBj3fd8i5WrXgHXxkVMJgIabLVqvHD6hKpQvlBpitant6ZyjcoUe9aaNO7YmH+/9W9fn6LCIo4eOhrWuOvXLOKHr9/li48ncO+/u3PPDaex4delHDv6l6/Pnl1b+HXV97H5RVKMpBZ3cMe/wwmNvHLhhbb6WT04HJMKmbArC4I53pWpKk1RK6cWPa7sAbh3fNq8YrOv371f3Gt7zMkv3cHW339h26bVPHBrL4ZfmsPib2cAcMd1J/Hw6PNj+BukDkkv7gBFYXiyZzVtysxBg0L2C/TcjSGQRIdlxHEXnIovg83zd3Fgt7v++/QHp/P2vSUb2hsXNg254Sm/MVq2OSXkdcY/cjUrlnxBUaGsgg1GUou794OUVdG6wFJ9Q51343mlxjNpM0uFTPiEKt4/IPHdBWeRUSEDgLR0T00mj4gbN/m4cfKNAPS/oz85bXL423lXc+/j7hTICy8bxennXAFA42bWGTlP3Hep7/VTYy/juksasHfPDtavWcThQ/uY//lbfDN3aox+s+Qj6SdUlVJce+KJjPjkk6B9nurdO+LxzWLqZqmQ8YyDl2TLiLgLzqLbpd04eugoHXp1AOCsf57F0o+X0rxLc5Z/vpxzR55LzQbu3aI69+5M596d4RA0O/5E/vvElzTKbceMtx8D4MC+PBrltmPL76tCXvfnxZ8BcMuQtqWONWzSltwWnTjy10E+n/kSfQbcwEfTxtG8VRdOOCV1QzpJL+5gHRo5sX59Kmdk2BrHKNC+mHuICdVEFg4TBKdRPbs6/W/v73tfpWYVKlSpwLG/3OmQFasE/5bdtOUJAHQ9YwAz3/4fVw5/jBO79fUdn/vJy9TObsjmjav4YuZLHNy/25ZNY/9zJgCXD32QD956iPT0DD5590kAnp28nnH39Oe6WyeQ06RNWL+r00nusEyQ9od79fK9To8wJh5Y8teLIvExd58t4rgLSUCFyhVY++1aAA7vPxyyf8MmbXlt5l4/YQfo1fdaOnftw4WX3UaL1qE3FQlk2qv3APD7up99bbM/fI4tG1cy853/hT2e00lqcQfzjJEzGjf2vTYT92APBas8d2N7orNlxHEXkglv7XiAFie3iMmYQ254itrZDalarRYDrrib8wfezL/+84Ktcxd984HvtdeD/3G+e3HjX4f3U5Dvn7JZUHCMAza/JTiJlAjLAOSNGkX2Y+5YnVH7wvHczcIdZtKd6MJhXpxa8lcQjBjFvVqdajEZs3pWNv+buMKvraDgGOvXLGLg1f/lpiuOp7Awnx7nXkWz40/k9eduDjnm68/dzLw57kVWj7y0hLoN3EXShl1cD4AHx39PTuPWvv7bNq+hfsPjfZlBTiOpxd0oxnUqV/a9Lja0RxuW8eJX8tchMXcJywjJgFHcMytmWvSMjoyMClw18nEAnpu6kZ071tO4aQfbtWq8wg4w+rqTGHrTeGrUqutrG3PjGbzyobtWfd4fm7jn+m70vfQ/9B90B2hNRmbk2yKWBUkt7mCeMWIU90yXq9RxO6mQJZUXrfdITcQK1WKHFw4TBCOZlT2CriC9Qnwkp0LFyjRu6s7YqZFVN0Rvc1592n8Xqjp1mwBu/fBO0q766Ws+efdJlFJMnPGnr++hg3vJP/YXterkRHTtWGDLrVVK9VZKrVVKrVNKjbbod7JSqkgpNTB2JoaP0Vs/oV69Usc7mbS1zc7mb02a+N77vOMQ15IJVUGwxuutZ1bMTIhDkuZycecjn/DUG2t4beZe0tJcnNitHxPe/4MX393mJ8pW7Ny+nsLCAj6c8giHD+0D4Pd1PwFuvSg2bPN55/CTufWa9hRblDspa0I+RpVSLmA8cA6wFViklJqhtf7FpN+jwJyyMNSMYN5090aNePTss2lTpw59WrYsdTw3K4vZgwfTe/JkX9uqkSN5cP78UmOH+jCGE5bZedttHCsstN0/GDKhKiQT3rBMRkV7KcllwfHtTvO9fvWj3Wit3X/bHpNe+TCPFUu+YM5Hz7Nm+YKg47z61Eh+mPee6bGD+3fzweT/Y/XyBRw64C5OOO+zN+jZ55rY/SJhYMft7Aqs01pv0FrnA9OA/ib9/g1MB6LbyDRMzKRVKcXt3btzQatWEU2oGkMtsfTcj6tShUY1atjuHwoJywjJgDcsY4y9J5rAvx2XK53OXXtTP8c6myeYsAM8cGsv5s2ZxK4dG3xtbzx/C4+M7uurWR9P7ChTDrDF8H6rp82HUioHGAC8aDWQUmqYUmqxUmpxXl5euLbGFKtYvXGbPS+Fnq9cgQ+LREyotm5aB4DOrUqHlwTBafg89wqJ89zt8vdr7i/V9uqH9tIg9+RtNW1fu+o7Nm9YHpVdkWBH3M3UKzAw8BRwh9baMsCktZ6gte6ite6SnZ1t10bbTL74Yl7o2zd0xyAYc9sDwzIFnthZRqC4JyDm3rt7C1ZOH8HVF3aK+7UFIVx8GTJJ8EWzYqWqtOnYg0ZN2/va0lwuBg97tFTfZq262B530vhbYmJfONiZut4KNDK8bwgE5hZ1AaZ5hLAOcL5SqlBr/WFMrAxCoHf9jw4dohqv2CQs42VI584s2r6d+3v29GtPVMnfdi2OC91JEByAr4iYQ/PBA7n9oY8A2Ll9A0VF7qqTvfpdy/69O/n43Sd8/e4eN4eh/Wuj0tLQhslUM6pnxd6ZDYWdu70IaKmUaqqUygQuB2YYO2itm2qtc7XWucB7wMiyFnYvkcadzdIhjeIemC1TJTOT1y+6iNqGfHpIbLaMICQDxvK+yUTdBs1o0KgV4NaZ9iee5TuWVaseaWlpPDt5Pa984B9i7nHuVdz7+Fyf95/b4gTSMyqwduW3rFvjvwVhWRLSc9daFyqlbsCdBeMCJmqtVymlhnuOW8bZnUolk2Jil7Vrx0MLFnBJmzZ8s9m9sYDdbBlJYBEEc9ISUDm1LMhp4q44ed1tL/uqSVatXsuvz5gnvya3hTtceve42RQWFjD5pTv4cf50Vi51lzV+bebeuNhra0WB1noWMCugzVTUtdZDojfLHtF8VM5o3JhxZ5/N7V984WvrULcueswYoMQjLwiRpyqeuyBY4/Xck13cq1arGVSYK1WuRoWKVX3CDlChYhUqAA0at6K4uERHAmvXlBXJv0I10vOU4vquXf3E3cgjvXqx7cABehgWNpmRiBWqycAXE66kXu2qoTsKKY/ybiqT3NpuyTOT1wc9VqVqTb/3O7b+BpR9plvSi3s0eIXZTKA71K3LsuHDQ46RyD1UnUyvU5ol2gTBIaSK525FenrwNM/A0E1hYX5ZmwMkecnfaD8sXlE/t3nziMfwhmVE4gXBHN+EaupquyWBnnuozJpYkfSeezSrNDNdLpYPH06zmjVDdw6CeO6CYE158NytyMjwX5mr4/SUS2rPPRZ0qFuXKpmRL4uWmLsgWKPK+UbutbIbAtCy7alA/B5ySS3uTvAD0iQVUhAsKe+ee+3shjw5aTUXXHYbEL+wTFKLOyQ+1i3FuwTBmlTJc48G96In794S4rknBRKWEQRryvuEqhel3PehuFjEPSRO8ARE2gXBGm/M3Ql/r4mk5Fu+iLstEh0WEc9dEKxJ1toyscbrucuEapKQ6IeLIDgd34RqnMIRTsUrFVrLhGpSIJ67IFhT3lMhvXgdQfHcbeAEP0A+toJgje/bbTn/Y/GGZeK1CXJSizsk/vOSFuensSAkG+K5e/BoRbGEZZIDr1cisXdBMEf+NtzE+z4ktbg7wVuWmLsgWOP13EXkPUhYxh6J/sDIx1UQrEn036hTUMiEalLh9dzl4ysI5kjM3YOEZeyT+KCMeCWCEAr5G/FHSv7aJNEfG4m5C4I14rm7USWrmOJyvaQX90QjH1tBsEY8dy8SlrGNE8Iy4rkLgjXiufsjE6o2SbRXkOjrC4LTkbUgbiTPPclIkw+uIFgifxuBiOceEicsYpKPrSBY4/s7Led/LFI4LEwS/XmRmLsg2EM8eAnLJBXygRUEIRziFXAQcY8S8dwFwZriIncVxPLuCEmeexgkPuKe+LCQIDidooIiAFwZrgRbklji/XBLj+vVyoBEewNSW0YQrMnOzaZhu4acN/K8RJviCBxVfkAp1VsptVYptU4pNdrk+GCl1HLPv++UUp1ib6ozSfTDRRCcTnpmOkOfG0rDtg0TbUpiibNUhBR3pZQLGA/0AdoCg5RSbQO6bQT+prXuCDwATIi1oWY4IRVSYu6CIISDk1IhuwLrtNYbtNb5wDSgv7GD1vo7rfVez9sfgLg9ohMtrYm+viAIyYG3nruTJlRzgC2G91s9bcEYCnxqdkApNUwptVgptTgvL8++lUmAhGcEQbDEgeUHzCwyffQopXriFvc7zI5rrSdorbtorbtkZ2fbtzIIiQ/KgCvNfQt75uYm1hBBEJKCeE2o2smW2Qo0MrxvCGwP7KSU6gi8AvTRWu+JjXmhSbTHnJ6WxqqRI2lSo0ZC7RAEwdk4sXDYIqClUqqpUioTuByYYeyglGoMvA9cqbX+NfZmOpu22dlUycxMtBmCICQDcYq5h/TctdaFSqkbgDmAC5iotV6llBruOf4i8F+gNvC85+lUqLXuUnZm+2wr60sIgiDEhHhvkG1rEZPWehYwK6DtRcPrfwH/iq1p9khUUKbDccdx4NixBF1dEISkQ1aoJgfLR4xItAmCICQhjlqh6lQkKCMIQrIghcPCJNHZMoIgCHZQUs9dEAQhdXFS+QHHItkygiAkDQ7Mc3c0EpQRBCGZEM9dEAQhhSiZHxRxFwRBSB0kLGMfibgLgpBsSFjGJpIKKQhCMuDEeu6CIAhClDixKqRjkVRIQRCSjXipVlKLO0gqpCAISYJ47oIgCKmLTKjaQIIygiAkCzKhGiaSLSMIQjIgE6qCIAgpjNRzt4FkywiCkDTEOciQ1OIOki0jCEJyIROqgiAIKYRMqIaBBGUEQUgaZEI1PCRbRhCEZELCMoIgCCmE1HMXBEFIQSTPPQwkFVIQhGRDwjI2kYi7IAjJgXjugiAIKYt47jaQoIwgCMmCTKiGiaRCCoKQDMiEqiAIQgrjqLCMUqq3UmqtUmqdUmq0yXGllHrGc3y5UurE2JtaGsmWEQQheXBY+QGllAsYD/QB2gKDlFJtA7r1AVp6/g0DXoixncHti9eFBEEQoiDeYZl0G326Auu01hsAlFLTgP7AL4Y+/YE3tNuV/kEplaWUqq+13hFrg6dPn87gBx8E4FhRUayHFwRBKBPS0zMBePPFUTSuvY8HPTpWZtez0ScH2GJ4vxU4xUafHMBP3JVSw3B79jRu3DhcWwFo2bIlN596KgCPfvttRGMIgiDEm8pVazD89lfZvH453bt3L/Pr2RF3s+8SgUEjO33QWk8AJgB06dIlosBTx44d6Xj22YCIuyAIycUpZ1zMKWdcTJ8+WWV+LTsTqluBRob3DYHtEfQRBEEQ4oQdcV8EtFRKNVVKZQKXAzMC+swArvJkzZwK7C+LeLsgCIJgj5BhGa11oVLqBmAO4AImaq1XKaWGe46/CMwCzgfWAX8B15SdySV8dsUV7DlyJB6XEgRBSCrsxNzRWs/CLeDGthcNrzVwfWxNC805zZvH+5KCIAhJgaxQFQRBSEFE3AVBEFIQEXdBEIQURMRdEAQhBRFxFwRBSEFE3AVBEFIQEXdBEIQURMRdEAQhBVGJ2vBCKZUHbIrw9DrA7hiaE0vEtshwqm1OtQvEtkhxqm127Wqitc4O1Slh4h4NSqnFWusuibbDDLEtMpxqm1PtArEtUpxqW6ztkrCMIAhCCiLiLgiCkIIkq7hPSLQBFohtkeFU25xqF4htkeJU22JqV1LG3AVBEARrktVzFwRBECwQcRcEQUhBHCHuSqmKSqmFSqmflVKrlFJjPe33KaW2KaWWef6dbzjnTqXUOqXUWqXUeYb2k5RSKzzHnlFKmW3eHYmNLqXUT0qpjz3vaymlPldK/eb5WdNBtjnivimlfveMuUwptdjTlvD7FsQup9yzLKXUe0qpNUqp1Uqpbk64Zxa2Jfy+KaVaGa6/TCl1QCl1c6Lvm4Vd8blnWuuE/wMUUNXzOgP4ETgVuA+4zaR/W+BnoALQFFgPuDzHFgLdPGN+CvSJkY23AFOAjz3vxwGjPa9HA486yDZH3Dfgd6BOQFvC71sQu5xyzyYB//K8zgSynHDPLGxzxH0zXNcF/AE0ccp9M7ErLvfMEZ67dnPI8zbD889qprc/ME1rfUxrvRH33q1dlVL1gepa6++1+468AVwUrX1KqYZAX+CVABsmeV5PMlzHCbYFI662WdiQ8PsWpr1xsUspVR3oAbwKoLXO11rvwwH3zMK2YCTq/7MXsF5rvQkH3LcgdgUjpnY5QtzBF1pYBuwCPtda/+g5dINSarlSaqLha1UOsMVw+lZPW47ndWB7tDwF3A4UG9rqaq13AHh+Hucg28AZ900DnymlliilhnnanHDfzOyCxN+zZkAe8Jpyh9leUUpVwRn3LJhtkPj7ZuRyYKrntRPum5ldEId75hhx11oXaa07Aw1xP63aAy8AzYHOwA7gcU93s3iTtmiPGKVUP2CX1nqJ3VOC2BBP2xJ+3zx011qfCPQBrldK9bDoG0/bzOxywj1LB04EXtBanwAcxh1OCIYTbHPCfXNfUKlM4ELg3VBdg9hQJraZ2BWXe+YYcffi+ar3NdBba73TI/rFwMtAV0+3rUAjw2kNge2e9oYm7dHQHbhQKfU7MA04Syn1FrDT83UJz89dTrHNIfcNrfV2z89dwAceOxJ+38zscsg92wpsNXxrfQ+3oCb8ngWzzSH3zUsfYKnWeqfnvRPuWym74nbPYjFZEO0/IBvI8ryuBCwA+gH1DX3+gzseBdAO/4mHDZRMPCzCPRnrnXg4P4Z2nknJpOVj+E/WjHOQbQm/b0AVoJrh9XdA70TfNwu7En7PPGMuAFp5Xt/nuV+O+KwFsc0R980z7jTgGsN7p9y3QLvics9iIiwx+OU7Aj8By4GVwH897W8CKzztMwJuyt24Z5PXYpg5Brp4xlgPPIdnFW6M7DyTEgGtDcwFfvP8rOUg2xJ+33DHaH/2/FsF3O2E+2ZhV8LvmWfMzsBijx0fAjUTfc9C2OaU+1YZ2APUMLQl/L4FsSsu90zKDwiCIKQgjou5C4IgCNEj4i4IgpCCiLgLgiCkICLugiAIKYiIuyAIQgoi4i4IgpCCiLgLgiCkIP8PFeV/V0/11P0AAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", - "Pyo warning: Portmidi warning: no midi device found!\n", - "Portmidi closed.\n" - ] - } - ], + "outputs": [], "source": [ "data_soni = SoniSeries(spectrum_F)\n", "data_soni_preview = data_soni.preview_object\n", @@ -364,36 +213,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "50dd60d9", "metadata": { "scrolled": true }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", - "Pyo warning: Portmidi warning: no midi device found!\n", - "Portmidi closed.\n" - ] - } - ], + "outputs": [], "source": [ - "data_soni = SoniSeries(spectrum_G)\n", + "data_soni = SoniSeries(spectrum_G, flatten=True)\n", "data_soni_preview = data_soni.preview_object\n", "data_soni_preview.sonify_preview()\n", "data_soni_preview.play_preview()" @@ -401,34 +228,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "df882d08", "metadata": { "scrolled": false }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", - "Pyo warning: Portmidi warning: no midi device found!\n", - "Portmidi closed.\n" - ] - } - ], + "outputs": [], "source": [ "data_soni = SoniSeries(spectrum_K)\n", "data_soni_preview = data_soni.preview_object\n", @@ -438,40 +243,34 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "e18f174b", "metadata": { "scrolled": true }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", - "Pyo warning: Portmidi warning: no midi device found!\n", - "Portmidi closed.\n" - ] - } - ], + "outputs": [], "source": [ - "data_soni = SoniSeries(spectrum_M)\n", + "data_soni = SoniSeries(spectrum_M, flatten=True)\n", "data_soni_preview = data_soni.preview_object\n", "data_soni_preview.sonify_preview()\n", "data_soni_preview.play_preview()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f153ae5d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a1d4370", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -490,7 +289,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.15" } }, "nbformat": 4, diff --git a/notebooks/astronify-snapshots-hack.ipynb b/notebooks/astronify-snapshots-hack.ipynb index dd78d46..3d41883 100644 --- a/notebooks/astronify-snapshots-hack.ipynb +++ b/notebooks/astronify-snapshots-hack.ipynb @@ -956,7 +956,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.15" } }, "nbformat": 4, From 836f45867125881f1bc8e73dbf74b45393026deb Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Fri, 16 Dec 2022 13:26:43 -0500 Subject: [PATCH 23/93] updating .gitignore with new generated directory miles_stellar_spectra --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 9b73111..c91ac51 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,7 @@ __pycache__ *.c # Other generated files +notebooks/miles_stellar_spectra */version.py */cython_version.py htmlcov From b69b2f0abf7f3bd23ea7ca006123360927d294eb Mon Sep 17 00:00:00 2001 From: Jennifer Medina Date: Fri, 16 Dec 2022 13:43:06 -0500 Subject: [PATCH 24/93] adding requests and notebook as dependencies of astronify. pinning requests version to 2.28.* --- setup.cfg | 2 ++ tox.ini | 3 +++ 2 files changed, 5 insertions(+) diff --git a/setup.cfg b/setup.cfg index 68ba53f..736e884 100644 --- a/setup.cfg +++ b/setup.cfg @@ -20,6 +20,8 @@ install_requires = astropy pyo thinkx + requests + notebook [options.entry_points] console_scripts = diff --git a/tox.ini b/tox.ini index 6adac5c..c1958e7 100644 --- a/tox.ini +++ b/tox.ini @@ -53,8 +53,11 @@ deps = astropy40: astropy==4.0.* astropylts: astropy==4.0.* + requests228: requests==2.28.* + devdeps: git+https://github.com/numpy/numpy.git#egg=numpy devdeps: git+https://github.com/astropy/astropy.git#egg=astropy + devdeps: git+https://github.com/psf/requests.git # The following indicates which extras_require from setup.cfg will be installed extras = From 5bf6b63f972c19894113df2971fb5c2f8cbac445 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 13 Sep 2024 14:25:41 -0400 Subject: [PATCH 25/93] intermediate checkin --- notebooks/OBAFGKM_demo.ipynb | 92 +++++++++++++++++++++++++++++++----- 1 file changed, 79 insertions(+), 13 deletions(-) diff --git a/notebooks/OBAFGKM_demo.ipynb b/notebooks/OBAFGKM_demo.ipynb index 65c471b..02feb49 100644 --- a/notebooks/OBAFGKM_demo.ipynb +++ b/notebooks/OBAFGKM_demo.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "6a5a4813", "metadata": {}, "outputs": [], @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "808908c9", "metadata": {}, "outputs": [], @@ -49,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "0280bcc1", "metadata": {}, "outputs": [], @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "9f205b59", "metadata": {}, "outputs": [], @@ -82,10 +82,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "13223d56", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading 1-Type_O_Stelib_HD269698.fits via https://stsci.box.com/shared/static/v7eecpzpxfnb3fxywy0amve4ofcoz0ns...\n", + "Downloading 2-Type_B_HD003369_s0020.fits via https://stsci.box.com/shared/static/vpoby26z4f7cm9mavlo7fziikb1s3v9n...\n", + "Downloading 3-Type_A_HD031295_s0166.fits via https://stsci.box.com/shared/static/wmmwy5im68lnhjcw63iyc8rz3n65f1cr...\n", + "Downloading 4-Type_F_HD222451_s0889.fits via https://stsci.box.com/shared/static/ro5ix00yh19iid9wxlzgi41bjfbremtz...\n", + "Downloading 5-Type_G_HD114606_s0462.fits via https://stsci.box.com/shared/static/yv13duxb5qqtjdfgmsirh8rbyw3r68s2...\n", + "Downloading 6-Type_K_HD233832_s0410.fits via https://stsci.box.com/shared/static/zbqy0bzesz7z8mqu0h0nqzffbnc4h0xg...\n", + "Downloading 7-Type_M_HD036395_s0183.fits via https://stsci.box.com/shared/static/ztq2x6vsx7ickq0zmmimb7qhguu8vz3a...\n" + ] + } + ], "source": [ "# Download the sample spectra.\n", "for file, url in zip(all_filenames, all_urls):\n", @@ -96,7 +110,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "e71b17db", "metadata": {}, "outputs": [], @@ -130,12 +144,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "445c543e", "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], "source": [ "# Construct the Sonification object.\n", "soni_table = Table([all_spectra[0][\"wls\"], all_spectra[0][\"fls\"]],\n", @@ -152,10 +186,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "243081cd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pyo warning: Portaudio input device `MacBook Pro Microphone` has fewer channels (1) than requested (2).\n", + "Pyo warning: Portmidi warning: no midi device found!\n", + "Portmidi closed.\n" + ] + } + ], "source": [ "# In a \"scan\" preview, each section has the same frequency. Each section gets\n", "# played separately, and then there is no combined sound made.\n", @@ -243,12 +297,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "e18f174b", "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'spectrum_M' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn [10], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m data_soni \u001b[38;5;241m=\u001b[39m SoniSeries(\u001b[43mspectrum_M\u001b[49m, flatten\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 2\u001b[0m data_soni_preview \u001b[38;5;241m=\u001b[39m data_soni\u001b[38;5;241m.\u001b[39mpreview_object\n\u001b[1;32m 3\u001b[0m data_soni_preview\u001b[38;5;241m.\u001b[39msonify_preview()\n", + "\u001b[0;31mNameError\u001b[0m: name 'spectrum_M' is not defined" + ] + } + ], "source": [ "data_soni = SoniSeries(spectrum_M, flatten=True)\n", "data_soni_preview = data_soni.preview_object\n", From 95f5d6e72542bf5a9646fa3492235047baf36b65 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 13 Sep 2024 17:12:20 -0400 Subject: [PATCH 26/93] removing thinkx, numpy 2.0 fix, updating versions of libraries used in tox test builds --- astronify/simulator/add_transit_signal.py | 2 +- setup.cfg | 5 ++-- tox.ini | 36 ++++++++++++----------- 3 files changed, 23 insertions(+), 20 deletions(-) diff --git a/astronify/simulator/add_transit_signal.py b/astronify/simulator/add_transit_signal.py index 81c98aa..13d9f10 100644 --- a/astronify/simulator/add_transit_signal.py +++ b/astronify/simulator/add_transit_signal.py @@ -40,7 +40,7 @@ def add_transit_signal(fluxes, transit_depth, transit_period, transit_start, # Get the set of start indexes. start_indexes = np.arange(transit_start, n_fluxes+1, transit_period, - dtype=np.int) + dtype=int) # Set transit indexes to 1. for st_ind in start_indexes: if st_ind + transit_width < fluxes.size: diff --git a/setup.cfg b/setup.cfg index 736e884..47a64e2 100644 --- a/setup.cfg +++ b/setup.cfg @@ -14,12 +14,13 @@ github_project = spacetelscope/astronify [options] zip_safe = False packages = find: -python_requires = >=3.7 +python_requires = >=3.9 setup_requires = setuptools_scm install_requires = astropy + scipy + matplotlib pyo - thinkx requests notebook diff --git a/tox.ini b/tox.ini index c1958e7..4d3ff87 100644 --- a/tox.ini +++ b/tox.ini @@ -1,8 +1,8 @@ [tox] envlist = - py{36,37,38}-test{,-alldeps,-devdeps}{,-cov} - py{36,37,38}-test-numpy{116,117,118} - py{36,37,38}-test-astropy{30,40,lts} + py{39,310,311,312}-test{,-alldeps,-devdeps}{,-cov} + py{39,310,311,312}-test-numpy{124,125,126,200,210} + py{39,310,311,312}-test-astropy{50,60,lts} build_docs linkcheck codestyle @@ -15,7 +15,7 @@ isolated_build = true [testenv] # Pass through the following environment variables which may be needed for the CI -passenv = HOME WINDIR LC_ALL LC_CTYPE CC CI TRAVIS +passenv = HOME,WINDIR,LC_ALL,LC_CTYPE,CC,CI,TRAVIS # Run the tests in a temporary directory to make sure that we don't import # this package from the source tree @@ -35,25 +35,27 @@ description = devdeps: with the latest developer version of key dependencies oldestdeps: with the oldest supported version of key dependencies cov: and test coverage - numpy116: with numpy 1.16.* - numpy117: with numpy 1.17.* - numpy118: with numpy 1.18.* - astropy30: with astropy 3.0.* - astropy40: with astropy 4.0.* + numpy124: with numpy 1.24.* + numpy125: with numpy 1.26.* + numpy126: with numpy 1.26.* + numpy200: with numpy 2.0.* + numpy210: with numpy 2.1.* + astropy50: with astropy 5.0.* + astropy60: with astropy 6.0.* astropylts: with the latest astropy LTS # The following provides some specific pinnings for key packages deps = - numpy116: numpy==1.16.* - numpy117: numpy==1.17.* - numpy118: numpy==1.18.* + numpy124: numpy==1.24.* + numpy125: numpy==1.25.* + numpy126: numpy==1.26.* + numpy200: numpy==2.0.* + numpy210: numpy==2.1.* - astropy30: astropy==3.0.* - astropy40: astropy==4.0.* - astropylts: astropy==4.0.* - - requests228: requests==2.28.* + astropy50: astropy==5.0.* + astropy60: astropy==6.0.* + astropylts: astropy==6.0.* devdeps: git+https://github.com/numpy/numpy.git#egg=numpy devdeps: git+https://github.com/astropy/astropy.git#egg=astropy From c3c19ac7b36c84f96966a523e1a19df3cecedd41 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 13 Sep 2024 17:19:55 -0400 Subject: [PATCH 27/93] fixing documentation format error --- astronify/simulator/sim_lc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/astronify/simulator/sim_lc.py b/astronify/simulator/sim_lc.py index 35d9183..937cbf3 100644 --- a/astronify/simulator/sim_lc.py +++ b/astronify/simulator/sim_lc.py @@ -100,7 +100,7 @@ def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, corresponds to "t_1/2" in the Davenport et al. flare template. Returns - -------- + ------- response : `~astropy.table.Table` The time and flux columns. """ From f162357ff5dd25000e29073831c76f0b0f589b27 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 11:21:40 -0500 Subject: [PATCH 28/93] adding new requireemnts in RTD yaml --- .readthedocs.yml | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index 91be621..e1d80e6 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -1,10 +1,10 @@ version: 2 build: - image: latest + os: "ubuntu-24.04" + tools: + python: "3.12" -python: - version: 3.7 install: - method: pip path: . @@ -12,4 +12,5 @@ python: - docs - all -formats: [] +sphinx: + configuration: docs/conf.py From 005732ad6ccd39eccb7058130cb17890a4165e20 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 11:24:24 -0500 Subject: [PATCH 29/93] fixing RTD yaml --- .readthedocs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.readthedocs.yml b/.readthedocs.yml index e1d80e6..250da71 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -5,6 +5,7 @@ build: tools: python: "3.12" +python: install: - method: pip path: . From 0e831b1f194b978dfc509e89d75d7473e7f01ca9 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 11:46:32 -0500 Subject: [PATCH 30/93] fixing RTD yaml --- .readthedocs.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.readthedocs.yml b/.readthedocs.yml index 250da71..244095b 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -4,6 +4,8 @@ build: os: "ubuntu-24.04" tools: python: "3.12" + apt_packages: + - python3-pyaudio python: install: From 720747c2a287d30155cdda123dc51146e07efd7e Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 11:50:46 -0500 Subject: [PATCH 31/93] fixing RTD yaml --- .readthedocs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index 244095b..131fbc3 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -5,7 +5,7 @@ build: tools: python: "3.12" apt_packages: - - python3-pyaudio + - portaudio19-dev python: install: From 97e001f453312853b085f1fd42a3050ad44c6b01 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 11:53:08 -0500 Subject: [PATCH 32/93] fixing RTD yaml --- .readthedocs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.readthedocs.yml b/.readthedocs.yml index 131fbc3..0623f64 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -6,6 +6,7 @@ build: python: "3.12" apt_packages: - portaudio19-dev + - libsndfile1-dev python: install: From f4bdf96dc0b1ab0c3a2fc7d4157304947d3d41b7 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 11:57:41 -0500 Subject: [PATCH 33/93] fixing RTD yaml --- .readthedocs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.readthedocs.yml b/.readthedocs.yml index 0623f64..2a2c8f6 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -7,6 +7,7 @@ build: apt_packages: - portaudio19-dev - libsndfile1-dev + - portmidi python: install: From 6fcf883b28a390707da9fe55eb8be5d7be1aa482 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 12:07:05 -0500 Subject: [PATCH 34/93] fixing RTD yaml --- .readthedocs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index 2a2c8f6..dd155c2 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -7,7 +7,7 @@ build: apt_packages: - portaudio19-dev - libsndfile1-dev - - portmidi + - libportmidi-dev python: install: From 2108c45637069e17063a2045117b101a02143e59 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 12:09:26 -0500 Subject: [PATCH 35/93] fixing RTD yaml --- .readthedocs.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.readthedocs.yml b/.readthedocs.yml index dd155c2..c79129b 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -8,6 +8,7 @@ build: - portaudio19-dev - libsndfile1-dev - libportmidi-dev + - liblo python: install: From 345455a8edd328d0c4632f1a647a29df014baae0 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 12:10:55 -0500 Subject: [PATCH 36/93] fixing RTD yaml --- .readthedocs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index c79129b..d1b37ee 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -8,7 +8,7 @@ build: - portaudio19-dev - libsndfile1-dev - libportmidi-dev - - liblo + - liblo-dev python: install: From d14897b2f87ddf2ad49e862382ec1cdc99baf5b9 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 12:19:52 -0500 Subject: [PATCH 37/93] fixing RTD yaml --- .readthedocs.yml | 1 + docs/conf.py | 3 +-- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index d1b37ee..0fdc4b0 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -17,6 +17,7 @@ python: extra_requirements: - docs - all + - requirements: docs/requirements.txt sphinx: configuration: docs/conf.py diff --git a/docs/conf.py b/docs/conf.py index ef97c78..19755fd 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -49,7 +49,7 @@ highlight_language = 'python3' # If your documentation needs a minimal Sphinx version, state it here. -#needs_sphinx = '1.2' +needs_sphinx = '5.0' # To perform a Sphinx version check that needs to be more specific than # major.minor, call `check_sphinx_version("x.y.z")` here. @@ -113,7 +113,6 @@ def setup_style(app): master_doc='contents' html_extra_path=['index.html', 'CreateWithLight.html'] - # Custom sidebar templates, maps document names to template names. html_sidebars = { '**': ['globaltoc.html', 'localtoc.html', 'searchbox.html'] } From 25f6a4e08f57bbfb48ae2583feac5620ad9661e3 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 12:26:09 -0500 Subject: [PATCH 38/93] adding requirements file for RTD --- docs/requirements.txt | 1 + 1 file changed, 1 insertion(+) create mode 100644 docs/requirements.txt diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 0000000..6c5d5d4 --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1 @@ +sphinx-rtd-theme From 0f8c1c253d426695cdf3b860c07a6f83f1efe13a Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 12:35:52 -0500 Subject: [PATCH 39/93] adding requirements file for RTD --- docs/requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/requirements.txt b/docs/requirements.txt index 6c5d5d4..ad74bf3 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1 +1,2 @@ sphinx-rtd-theme +Sphinx < 6.0.0 From 74da113a49dbf39af350b2dc78272bf76dfc67af Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 12:43:57 -0500 Subject: [PATCH 40/93] adding requirements file for RTD --- docs/requirements.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index ad74bf3..6c5d5d4 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,2 +1 @@ sphinx-rtd-theme -Sphinx < 6.0.0 From aa268a8e5b7365a26052d1c875cf6c2d31a3f4c0 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 12:54:10 -0500 Subject: [PATCH 41/93] adding requirements file for RTD --- docs/conf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/conf.py b/docs/conf.py index 19755fd..35300e8 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -118,7 +118,7 @@ def setup_style(app): # The name of an image file (relative to this directory) to place at the top # of the sidebar. -html_logo = '_static/ASTRONIFY_Ball_white.svg' +logo = '_static/ASTRONIFY_Ball_white.svg' # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 From d3888f6080c80bf50f7d7f79e380202481b102a6 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 13:00:23 -0500 Subject: [PATCH 42/93] adding requirements file for RTD --- docs/conf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/conf.py b/docs/conf.py index 35300e8..95f6a7f 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -49,7 +49,7 @@ highlight_language = 'python3' # If your documentation needs a minimal Sphinx version, state it here. -needs_sphinx = '5.0' +#needs_sphinx = '5.0' # To perform a Sphinx version check that needs to be more specific than # major.minor, call `check_sphinx_version("x.y.z")` here. From 09d32aa4c435b4a5133681b340929e8581bb2c13 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 13:05:41 -0500 Subject: [PATCH 43/93] adding requirements file for RTD --- docs/conf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/conf.py b/docs/conf.py index 95f6a7f..7ec0c49 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -118,7 +118,7 @@ def setup_style(app): # The name of an image file (relative to this directory) to place at the top # of the sidebar. -logo = '_static/ASTRONIFY_Ball_white.svg' +html_logo = '_static/ASTRONIFY_Ball_white.svg' # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 From 43a7585d3718c66ede2f2ac8789b0f81054b6435 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 13:10:39 -0500 Subject: [PATCH 44/93] adding requirements file for RTD --- docs/requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/requirements.txt b/docs/requirements.txt index 6c5d5d4..ad74bf3 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1 +1,2 @@ sphinx-rtd-theme +Sphinx < 6.0.0 From ad3d922575f83ade191239446f9161d06fc8c65a Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 13:49:56 -0500 Subject: [PATCH 45/93] adding requirements file for RTD --- docs/_templates/layout.html | 2 +- docs/requirements.txt | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/_templates/layout.html b/docs/_templates/layout.html index 62a5c54..999cb20 100644 --- a/docs/_templates/layout.html +++ b/docs/_templates/layout.html @@ -2,7 +2,7 @@ {% block sidebartitle %} - + {{ _('Logo') }} {% if theme_display_version %} diff --git a/docs/requirements.txt b/docs/requirements.txt index ad74bf3..6c5d5d4 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,2 +1 @@ sphinx-rtd-theme -Sphinx < 6.0.0 From 11ee49331a5551232da82e7ddcf1d0b53b99f4cf Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 16:46:08 -0500 Subject: [PATCH 46/93] building RTD using Python 3.11 since the package is only good up to there --- .readthedocs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index 0fdc4b0..b65ecd4 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -3,7 +3,7 @@ version: 2 build: os: "ubuntu-24.04" tools: - python: "3.12" + python: "3.11" apt_packages: - portaudio19-dev - libsndfile1-dev From 7f33813d57ba143f3ad0d5cd71954416ea40c08b Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 6 Dec 2024 16:48:37 -0500 Subject: [PATCH 47/93] updated tox.ini file that works locally in Python 3.11 at least --- tox.ini | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tox.ini b/tox.ini index 4d3ff87..1220972 100644 --- a/tox.ini +++ b/tox.ini @@ -9,7 +9,9 @@ envlist = requires = setuptools >= 30.3.0 pip >= 19.3.1 - sphinx_rtd_theme >= 0.5.2 + sphinx < 6 + sphinx_rtd_theme >= 2.0.0 + docutils < 0.19 isolated_build = true [testenv] @@ -78,7 +80,6 @@ description = invoke sphinx-build to build the HTML docs extras = docs deps= sphinx_rtd_theme commands = - pip freeze sphinx-build -b html . _build/html [testenv:linkcheck] @@ -86,7 +87,6 @@ changedir = docs description = check the links in the HTML docs extras = docs commands = - pip freeze sphinx-build -b linkcheck . _build/html [testenv:codestyle] From ea4d96875ee571cecdbe1ac289cf06215e684d2b Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Tue, 14 Jan 2025 22:04:43 -0500 Subject: [PATCH 48/93] adding helpful hints for problems installing pyo dependencies, fixed old reference to astrocut that didn't get replaced with astronify, added YouTube link to Media on front page --- docs/astronify/install.rst | 23 +++++++++++++++++++++-- docs/index.html | 4 +++- 2 files changed, 24 insertions(+), 3 deletions(-) diff --git a/docs/astronify/install.rst b/docs/astronify/install.rst index 68e582e..4e82390 100644 --- a/docs/astronify/install.rst +++ b/docs/astronify/install.rst @@ -3,8 +3,8 @@ Installation ************ -Installing astrocut -=================== +Installing astronify +==================== Using pip --------- @@ -13,6 +13,25 @@ The easiest way to install Astronify is using pip:: pip install astronify +Errors installing dependent packages +------------------------------------ + +You may experience difficulties installing Astronify without some +libraries pre-installed. If you run into problems, we recommend +installing the following dependencies of `pyo` prior to running the +`pip install astronify` step. + +Mac +~~~ +We recommend installing `homebrew` (https://brew.sh) and then running:: + + brew install portaudio portmidi libsndfile liblo + +Linux +~~~~~ +We recommend installing the following with apt-get:: + + apt-get install portaudio19-dev libsndfile1-dev libportmidi-dev liblo-dev From source ----------- diff --git a/docs/index.html b/docs/index.html index a8b57f9..054ded1 100644 --- a/docs/index.html +++ b/docs/index.html @@ -66,7 +66,9 @@

Email Us at astronify@stsci.edu


Media

- Video lecture: How Sonification Deepens our Understanding of the Cosmos and Makes Astronomy More Accessible + Video: Hearing the Light - Astronomy Data Sonification + + Video: How Sonification Deepens our Understanding of the Cosmos and Makes Astronomy More Accessible Podcast: Out of the Blocks- Space Sonification

From e81b16d90e15767d3c7169d3088b9c1a6cdd0666 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 13:57:05 -0500 Subject: [PATCH 49/93] specifying <3.12 in setup.cfg, removing Python 3.12 from tox for what its worth --- setup.cfg | 2 +- tox.ini | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/setup.cfg b/setup.cfg index 47a64e2..bccf19d 100644 --- a/setup.cfg +++ b/setup.cfg @@ -14,7 +14,7 @@ github_project = spacetelscope/astronify [options] zip_safe = False packages = find: -python_requires = >=3.9 +python_requires = >=3.9, <3.12 setup_requires = setuptools_scm install_requires = astropy diff --git a/tox.ini b/tox.ini index 1220972..1c4ae1b 100644 --- a/tox.ini +++ b/tox.ini @@ -1,8 +1,8 @@ [tox] envlist = - py{39,310,311,312}-test{,-alldeps,-devdeps}{,-cov} - py{39,310,311,312}-test-numpy{124,125,126,200,210} - py{39,310,311,312}-test-astropy{50,60,lts} + py{39,310,311}-test{,-alldeps,-devdeps}{,-cov} + py{39,310,311}-test-numpy{124,125,126,200,210} + py{39,310,311}-test-astropy{50,60,lts} build_docs linkcheck codestyle From 00bca20dc25d4b3adc9275b1bbcc8d2cedeca212 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 14:31:01 -0500 Subject: [PATCH 50/93] adding extra installation tips, fixes #74 and fixes #77 --- docs/astronify/install.rst | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/docs/astronify/install.rst b/docs/astronify/install.rst index 4e82390..8e4e78a 100644 --- a/docs/astronify/install.rst +++ b/docs/astronify/install.rst @@ -27,6 +27,22 @@ We recommend installing `homebrew` (https://brew.sh) and then running:: brew install portaudio portmidi libsndfile liblo +Still having issues? +^^^^^^^^^^^^^^^^^^^^ +If you are still unable to install `astronify` (or `pyo`) via `pip`, +it's possible `pip` is looking for them in the wrong spot, depending on +how you've installed other packages in your envionrment. If so, try +adding the following flags to your shell of choice, open a new +terminal, and then run `pip install astronify` again:: + + # Example for .cshrc + setenv CFLAGS '-I/opt/homebrew/include/' + setenv LDFLAGS '-L/opt/homebrew/lib/' + + # Example for .bashrc + export CFLAGS="-I/opt/homebrew/include/" + export LDFLAGS="-L/opt/homebrew/lib/" + Linux ~~~~~ We recommend installing the following with apt-get:: From 5084ff8eabd816cdca09d35480d11b588514b340 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 15:28:51 -0500 Subject: [PATCH 51/93] Adds citation information and ASCL badge to top-level README --- CITATION.cff | 22 ++++++++++++++++++++++ README.rst | 4 ++++ 2 files changed, 26 insertions(+) create mode 100644 CITATION.cff diff --git a/CITATION.cff b/CITATION.cff new file mode 100644 index 0000000..af23c4a --- /dev/null +++ b/CITATION.cff @@ -0,0 +1,22 @@ +cff-version: 1.1.0 +message: "Please cite the following works when using this software: https://ui.adsabs.harvard.edu/abs/2024ascl.soft08005B" +authors: +- family-names: Brasseur + given-names: C. E. +- family-names: Fleming + given-names: S. +- family-names: Kotler + given-names: J. +- family-names: Meredith + given-names: K. +title: "Astronify: Astronomical data sonification" +version: 0.1 +date-released: 2020-11-30 +identifiers: + - type: "ascl-id" + value: "2408.005" + - type: "doi" + value: PLACEHOLDER + - type: "bibcode" + value: "2024ascl.soft08005B" +abstract: "Astronify contains tools for sonifying astronomical data, specifically data series. Data series sonification takes a data table and maps one column to time, and one column to pitch. This technique is commonly used to sonify light curves, where observation time is scaled to listening time and flux is mapped to pitch. While Astronify’s sonification uses the columns “time” and “flux” by default, any two columns can be supplied and a sonification created." diff --git a/README.rst b/README.rst index d41f6c1..5b31380 100644 --- a/README.rst +++ b/README.rst @@ -16,6 +16,10 @@ Sonification of astronomical data. .. image:: https://readthedocs.org/projects/astronify/badge/?version=latest :target: https://astronify.readthedocs.io/en/latest/?badge=latest :alt: Documentation Status + +.. image:: https://img.shields.io/badge/ascl-2408.005-blue.svg?colorB=262255 + :target: https://ascl.net/2408.005 + :alt: ascl:2408.005 Tools for sonifying astronomical data. From 0dae88791ab186d6cb01b199b7b14a0f9ca87201 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 15:44:06 -0500 Subject: [PATCH 52/93] first attempt at updating CI --- .github/workflows/ci_workflows.yml | 113 +++++++++++++++++++++-------- 1 file changed, 84 insertions(+), 29 deletions(-) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index 41012b5..8074433 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -16,37 +16,92 @@ jobs: matrix: include: - - name: Python 3.7 with minimal dependencies + # Python 3.9 suite + + - name: Python 3.9 with minimal dependencies + os: ubuntu-latest + python: 3.9 + toxenv: py39-test + + - name: Python 3.9 with all optional dependencies + os: ubuntu-latest + python: 3.9 + toxenv: py39-test-alldeps + toxargs: -v --develop + toxposargs: --open-files + + - name: Python 3.9 with numpy 1.24 and full coverage + os: ubuntu-latest + python: 3.9 + toxenv: py39-test-alldeps-numpy124-cov + + - name: Python 3.9 with numpy 2.10 and full coverage + os: ubuntu-latest + python: 3.9 + toxenv: py39-test-alldeps-numpy210-cov + + - name: Python 3.9 with oldest supported version of all dependencies + os: ubuntu-16.04 + python: 3.9 + toxenv: py39-test-oldestdeps + + # Python 3.10 suite + + - name: Python 3.10 with minimal dependencies + os: ubuntu-latest + python: 3.10 + toxenv: py310-test + + - name: Python 3.10 with all optional dependencies + os: ubuntu-latest + python: 3.10 + toxenv: py310-test-alldeps + toxargs: -v --develop + toxposargs: --open-files + + - name: Python 3.10 with numpy 1.24 and full coverage + os: ubuntu-latest + python: 3.10 + toxenv: py310-test-alldeps-numpy124-cov + + - name: Python 3.10 with numpy 2.10 and full coverage + os: ubuntu-latest + python: 3.10 + toxenv: py310-test-alldeps-numpy210-cov + + - name: Python 3.10 with oldest supported version of all dependencies + os: ubuntu-16.04 + python: 3.10 + toxenv: py310-test-oldestdeps + + # Python 3.11 suite + + - name: Python 3.11 with minimal dependencies os: ubuntu-latest - python: 3.7 - toxenv: py37-test + python: 3.11 + toxenv: py311-test - - name: Python 3.8 with all optional dependencies + - name: Python 3.11 with all optional dependencies os: ubuntu-latest - python: 3.8 - toxenv: py38-test-alldeps - toxargs: -v --develop - toxposargs: --open-files + python: 3.11 + toxenv: py311-test-alldeps + toxargs: -v --develop + toxposargs: --open-files + + - name: Python 3.11 with numpy 1.24 and full coverage + os: ubuntu-latest + python: 3.11 + toxenv: py311-test-alldeps-numpy124-cov - - name: Python 3.7 with oldest supported version of all dependencies + - name: Python 3.11 with numpy 2.10 and full coverage + os: ubuntu-latest + python: 3.11 + toxenv: py311-test-alldeps-numpy210-cov + + - name: Python 3.11 with oldest supported version of all dependencies os: ubuntu-16.04 - python: 3.7 - toxenv: py37-test-oldestdeps - - - name: Python 3.7 with numpy 1.17 and full coverage - os: ubuntu-latest - python: 3.7 - toxenv: py37-test-alldeps-numpy117-cov - - - name: Python 3.8 with all optional dependencies (Windows) - os: windows-latest - python: 3.8 - toxenv: py38-test-alldeps - - - name: Python 3.7 with all optional dependencies (MacOS X) - os: macos-latest - python: 3.7 - toxenv: py37-test-alldeps + python: 3.11 + toxenv: py311-test-oldestdeps steps: - name: Checkout code @@ -83,10 +138,10 @@ jobs: python: 3.x toxenv: codestyle - - name: (Allowed Failure) Python 3.7 with dev version of key dependencies + - name: (Allowed Failure) Python 3.11 with dev version of key dependencies os: ubuntu-latest - python: 3.7 - toxenv: py37-test-devdeps + python: 3.11 + toxenv: py311-test-devdeps steps: - name: Checkout code From 777e8854970fa37b34a834b829de54c3656c89ee Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 15:45:06 -0500 Subject: [PATCH 53/93] first attempt at updating CI --- .github/workflows/ci_workflows.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index 8074433..c93fe32 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -16,7 +16,7 @@ jobs: matrix: include: - # Python 3.9 suite + # Python 3.9 suite - name: Python 3.9 with minimal dependencies os: ubuntu-latest From 0b2ff1f17d9024357c6ca571135d17b96d8f7823 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 15:45:55 -0500 Subject: [PATCH 54/93] removing comments from yml --- .github/workflows/ci_workflows.yml | 6 ------ 1 file changed, 6 deletions(-) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index c93fe32..cc4a9a6 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -16,8 +16,6 @@ jobs: matrix: include: - # Python 3.9 suite - - name: Python 3.9 with minimal dependencies os: ubuntu-latest python: 3.9 @@ -45,8 +43,6 @@ jobs: python: 3.9 toxenv: py39-test-oldestdeps - # Python 3.10 suite - - name: Python 3.10 with minimal dependencies os: ubuntu-latest python: 3.10 @@ -74,8 +70,6 @@ jobs: python: 3.10 toxenv: py310-test-oldestdeps - # Python 3.11 suite - - name: Python 3.11 with minimal dependencies os: ubuntu-latest python: 3.11 From 4fa4da2cb61c88eecd424c6908105a6841c92c6e Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 15:52:29 -0500 Subject: [PATCH 55/93] Adding hash for Action workflow and update if needed, from PR #78 --- .github/dependabot.yml | 15 +++++++++++++++ .github/workflows/ci_workflows.yml | 10 +++++----- 2 files changed, 20 insertions(+), 5 deletions(-) create mode 100644 .github/dependabot.yml diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..1a218f5 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,15 @@ +# To get started with Dependabot version updates, you'll need to specify which +# package ecosystems to update and where the package manifests are located. +# Please see the documentation for all configuration options: +# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates + +version: 2 +updates: + - package-ecosystem: "github-actions" # See documentation for possible values + directory: ".github/workflows" # Location of package manifests + schedule: + interval: "monthly" + groups: + actions: + patterns: + - "*" diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index cc4a9a6..ac343bb 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -99,11 +99,11 @@ jobs: steps: - name: Checkout code - uses: actions/checkout@v2 + uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938 # v4.2.0 with: fetch-depth: 0 - name: Set up Python - uses: actions/setup-python@v2 + uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3 # v5.2.0 with: python-version: ${{ matrix.python }} - name: Install language-pack-de and tzdata @@ -115,7 +115,7 @@ jobs: run: tox ${{ matrix.toxargs }} -e ${{ matrix.toxenv }} -- ${{ matrix.toxposargs }} - name: Upload coverage to codecov if: ${{ contains(matrix.toxenv,'-cov') }} - uses: codecov/codecov-action@v2 + uses: codecov/codecov-action@e28ff129e5465c2c0dcc6f003fc735cb6ae0c673 # v4.5.0 with: file: ./coverage.xml @@ -139,11 +139,11 @@ jobs: steps: - name: Checkout code - uses: actions/checkout@v2 + uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938 # v4.2.0 with: fetch-depth: 0 - name: Set up Python - uses: actions/setup-python@v2 + uses: actions/setup-python@f677139bbe7f9c59b41e40162b753c062f5d49a3 # v5.2.0 with: python-version: ${{ matrix.python }} - name: Install language-pack-de and tzdata From ee52abc54aaa21890d7672ed5fb56a21e948e736 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 15:56:05 -0500 Subject: [PATCH 56/93] fixing typos as found by contributor in #75 --- docs/astronify/index.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/astronify/index.rst b/docs/astronify/index.rst index 9419563..8361904 100644 --- a/docs/astronify/index.rst +++ b/docs/astronify/index.rst @@ -99,8 +99,8 @@ taking into account any requested clipping, and the requested stretch is applied if the invert argument is set, the array is inverted by subtracting all values from 1. The scaled zero point is then removed from the array which is scaled to the pitch range -such that the scaled zero point become the center pitch value and the entire pitch range -fell within the input pitch range. In practice this means one of two things: +such that the scaled zero point becomes the center pitch value and the entire pitch range +falls within the input pitch range. In practice this means one of two things: The array is scaled such that the 0 corresponds to the minimum of the input pitch range and the scaled zero point corresponds to the center pitch value. Or, the scaled zero point corresponds to the center pitch value and 1 corresponds to the maximum of the input pitch range. Whichever From 95d6e330a02919ed65eb92f213defc86481f654c Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 16:02:33 -0500 Subject: [PATCH 57/93] updates to use dev wheels instead of source, from #73 --- tox.ini | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/tox.ini b/tox.ini index 1c4ae1b..ae7b128 100644 --- a/tox.ini +++ b/tox.ini @@ -15,9 +15,11 @@ requires = isolated_build = true [testenv] +setenv = + devdeps: PIP_EXTRA_INDEX_URL = https://pypi.anaconda.org/astropy/simple https://pypi.anaconda.org/scientific-python-nightly-wheels/simple # Pass through the following environment variables which may be needed for the CI -passenv = HOME,WINDIR,LC_ALL,LC_CTYPE,CC,CI,TRAVIS +passenv = HOME,WINDIR,LC_ALL,LC_CTYPE,CC,CI # Run the tests in a temporary directory to make sure that we don't import # this package from the source tree @@ -59,8 +61,8 @@ deps = astropy60: astropy==6.0.* astropylts: astropy==6.0.* - devdeps: git+https://github.com/numpy/numpy.git#egg=numpy - devdeps: git+https://github.com/astropy/astropy.git#egg=astropy + devdeps: numpy>=0.0.dev0 + devdeps: astropy>=0.0.dev0 devdeps: git+https://github.com/psf/requests.git # The following indicates which extras_require from setup.cfg will be installed From 33f84e8cd0cff86b15e9fa3a63a6024758be7680 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 16:13:44 -0500 Subject: [PATCH 58/93] adding this branch to list to run CI on push --- .github/workflows/ci_workflows.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index ac343bb..0b96a51 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -4,6 +4,7 @@ on: push: branches: - main + - py311 tags: pull_request: From 8f8a7fda87a710a955554fe1b620979cb5cdceb0 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 16:21:09 -0500 Subject: [PATCH 59/93] fixing CI by specifying Python versions correctly --- .github/workflows/ci_workflows.yml | 64 +++++++++++++++--------------- 1 file changed, 32 insertions(+), 32 deletions(-) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index 0b96a51..8d1c823 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -17,85 +17,85 @@ jobs: matrix: include: - - name: Python 3.9 with minimal dependencies + - name: Python 3.9.xx with minimal dependencies os: ubuntu-latest - python: 3.9 + python: 3.9.21 toxenv: py39-test - - name: Python 3.9 with all optional dependencies + - name: Python 3.9.xx with all optional dependencies os: ubuntu-latest - python: 3.9 + python: 3.9.21 toxenv: py39-test-alldeps toxargs: -v --develop toxposargs: --open-files - - name: Python 3.9 with numpy 1.24 and full coverage + - name: Python 3.9.xx with numpy 1.24 and full coverage os: ubuntu-latest - python: 3.9 + python: 3.9.21 toxenv: py39-test-alldeps-numpy124-cov - - name: Python 3.9 with numpy 2.10 and full coverage + - name: Python 3.9.xx with numpy 2.10 and full coverage os: ubuntu-latest - python: 3.9 + python: 3.9.21 toxenv: py39-test-alldeps-numpy210-cov - - name: Python 3.9 with oldest supported version of all dependencies + - name: Python 3.9.xx with oldest supported version of all dependencies os: ubuntu-16.04 - python: 3.9 + python: 3.9.21 toxenv: py39-test-oldestdeps - - name: Python 3.10 with minimal dependencies - os: ubuntu-latest - python: 3.10 - toxenv: py310-test + - name: Python 3.10.xx with minimal dependencies + os: ubuntu-latest + python: 3.10.16 + toxenv: py310-test - - name: Python 3.10 with all optional dependencies + - name: Python 3.10.xx with all optional dependencies os: ubuntu-latest - python: 3.10 + python: 3.10.16 toxenv: py310-test-alldeps toxargs: -v --develop toxposargs: --open-files - - name: Python 3.10 with numpy 1.24 and full coverage + - name: Python 3.10.xx with numpy 1.24 and full coverage os: ubuntu-latest - python: 3.10 + python: 3.10.16 toxenv: py310-test-alldeps-numpy124-cov - - name: Python 3.10 with numpy 2.10 and full coverage + - name: Python 3.10.xx with numpy 2.10 and full coverage os: ubuntu-latest - python: 3.10 + python: 3.10.16 toxenv: py310-test-alldeps-numpy210-cov - - name: Python 3.10 with oldest supported version of all dependencies + - name: Python 3.10.xx with oldest supported version of all dependencies os: ubuntu-16.04 - python: 3.10 + python: 3.10.16 toxenv: py310-test-oldestdeps - - name: Python 3.11 with minimal dependencies + - name: Python 3.11.xx with minimal dependencies os: ubuntu-latest - python: 3.11 + python: 3.11.11 toxenv: py311-test - - name: Python 3.11 with all optional dependencies + - name: Python 3.11.xx with all optional dependencies os: ubuntu-latest - python: 3.11 + python: 3.11.11 toxenv: py311-test-alldeps toxargs: -v --develop toxposargs: --open-files - - name: Python 3.11 with numpy 1.24 and full coverage + - name: Python 3.11.xx with numpy 1.24 and full coverage os: ubuntu-latest - python: 3.11 + python: 3.11.11 toxenv: py311-test-alldeps-numpy124-cov - - name: Python 3.11 with numpy 2.10 and full coverage + - name: Python 3.11.xx with numpy 2.10 and full coverage os: ubuntu-latest - python: 3.11 + python: 3.11.11 toxenv: py311-test-alldeps-numpy210-cov - - name: Python 3.11 with oldest supported version of all dependencies + - name: Python 3.11.xx with oldest supported version of all dependencies os: ubuntu-16.04 - python: 3.11 + python: 3.11.11 toxenv: py311-test-oldestdeps steps: From 6a5d26a86ff2b42a342c6221d3ac12cc8e6e228e Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 16:24:06 -0500 Subject: [PATCH 60/93] fixed imcompatible test of numpy 2.1.x with Python 3.9.x --- .github/workflows/ci_workflows.yml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index 8d1c823..d39d8bc 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -34,11 +34,6 @@ jobs: python: 3.9.21 toxenv: py39-test-alldeps-numpy124-cov - - name: Python 3.9.xx with numpy 2.10 and full coverage - os: ubuntu-latest - python: 3.9.21 - toxenv: py39-test-alldeps-numpy210-cov - - name: Python 3.9.xx with oldest supported version of all dependencies os: ubuntu-16.04 python: 3.9.21 From 2a014518cb99549d67577b1c90a577f45b8da5f6 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 16:30:42 -0500 Subject: [PATCH 61/93] pre-installing pyo dependencies with apt-get --- .github/workflows/ci_workflows.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index d39d8bc..13cf641 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -105,6 +105,9 @@ jobs: - name: Install language-pack-de and tzdata if: startsWith(matrix.os, 'ubuntu') run: sudo apt-get install language-pack-de tzdata + - name: Install pyo dependencies + if: startsWith(matrix.os, 'ubuntu') + run: sudo apt-get install portaudio19-dev libsndfile1-dev libportmidi-dev liblo-dev - name: Install Python dependencies run: python -m pip install --upgrade tox codecov - name: Run tests From e1938c7faaaa955987a8cece22532f842d0e4e2a Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 16:39:33 -0500 Subject: [PATCH 62/93] removes unmaintained pytest-openfiles in favor of pytest -W argument, fixes #71 --- .github/workflows/ci_workflows.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index 13cf641..90447c6 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -27,7 +27,7 @@ jobs: python: 3.9.21 toxenv: py39-test-alldeps toxargs: -v --develop - toxposargs: --open-files + toxposargs: -W error::ResourceWarning - name: Python 3.9.xx with numpy 1.24 and full coverage os: ubuntu-latest @@ -49,7 +49,7 @@ jobs: python: 3.10.16 toxenv: py310-test-alldeps toxargs: -v --develop - toxposargs: --open-files + toxposargs: -W error::ResourceWarning - name: Python 3.10.xx with numpy 1.24 and full coverage os: ubuntu-latest @@ -76,7 +76,7 @@ jobs: python: 3.11.11 toxenv: py311-test-alldeps toxargs: -v --develop - toxposargs: --open-files + toxposargs: -W error::ResourceWarning - name: Python 3.11.xx with numpy 1.24 and full coverage os: ubuntu-latest From 1d48eed9266ac26db251e61bf6851da8e1ff583f Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 16:46:35 -0500 Subject: [PATCH 63/93] fixing the allowed-failure tests by pre-installing the pyo dependencies --- .github/workflows/ci_workflows.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index 90447c6..c94f88a 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -148,6 +148,9 @@ jobs: - name: Install language-pack-de and tzdata if: startsWith(matrix.os, 'ubuntu') run: sudo apt-get install language-pack-de tzdata + - name: Install pyo dependencies + if: startsWith(matrix.os, 'ubuntu') + run: sudo apt-get install portaudio19-dev libsndfile1-dev libportmidi-dev liblo-dev - name: Install Python dependencies run: python -m pip install --upgrade tox codecov - name: Run tests From de4b53a1150655146e19a1d0184654add8092699 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 16:53:59 -0500 Subject: [PATCH 64/93] working on some code style fixes --- astronify/series/series.py | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index e4f8631..560450d 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -320,7 +320,8 @@ def write(self, filepath): class SeriesPreviews(): - """ Previews (or snapshots) of 1d spectra by binning the data into + """ + Previews (or snapshots) of 1d spectra by binning the data into five equal pieces by assigning a sound to each piece. """ @@ -359,7 +360,9 @@ def area_of_pieces(self, ydata_bins, xdata_bins): def plot_preview(self, xdata_bin_ranges): - plt.plot(self._soniseries.data[self._soniseries.time_col], self._soniseries.data[self._soniseries.val_col], color='k') + plt.plot(self._soniseries.data[self._soniseries.time_col], + self._soniseries.data[self._soniseries.val_col], + color='k') plt.axvspan(xdata_bin_ranges[0][0], xdata_bin_ranges[0][1], color='royalblue', alpha=0.5, lw=0) plt.axvspan(xdata_bin_ranges[1][0], xdata_bin_ranges[1][1], color='green', alpha=0.5, lw=0) @@ -403,7 +406,6 @@ def sonify_preview(self, plotting=True, verbose=False): # Calculate standard deviation error and add to the list. _, _, _, _, std_err = stats.linregress(xdata_bin, ydata_bin) std_vals.append(std_err) - #std_vals.append(np.std(ydata_bin)) # Plot the spectra and ranges if in troubleshooting mode if plotting: @@ -434,14 +436,14 @@ def sonify_preview(self, plotting=True, verbose=False): # Constraint added to keep tremolo values at or below 15, otherwise oscillations are # more difficult to hear - #self.tremolo_vals[self.tremolo_vals > 15] = 15 + # self.tremolo_vals[self.tremolo_vals > 15] = 15 if verbose: print('Total Expected area = {0:0f}'.format(total_area)) print(' ') print('Area Values = ', np.asarray(area_vals)) print(' ') - #print('Total Calculated area = {0:0f}'.format(np.sum(str(area_vals).split(' ')))) + # print('Total Calculated area = {0:0f}'.format(np.sum(str(area_vals).split(' ')))) print(' ') print('Amplitudes = ', self.amplitudes) print(' ') @@ -499,6 +501,6 @@ def play_preview(self): if self._soniseries.preview_type == "ensemble": self.stream6 = pyo.Sine(freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1).out(delay=10, dur=4) self.stream7 = pyo.Sine(freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2).out(delay=10, dur=4) - self.stream8 = pyo.Sine(freq=[self.pitch_values[2], self.pitch_values[2]],mul=lfo3).out(delay=10, dur=4) - self.stream9 = pyo.Sine(freq=[self.pitch_values[3], self.pitch_values[3]],mul=lfo4).out(delay=10, dur=4) - self.stream10 = pyo.Sine(freq=[self.pitch_values[4], self.pitch_values[4]],mul=lfo5).out(delay=10, dur=4) + self.stream8 = pyo.Sine(freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3).out(delay=10, dur=4) + self.stream9 = pyo.Sine(freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4).out(delay=10, dur=4) + self.stream10 = pyo.Sine(freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5).out(delay=10, dur=4) From 1569966d22348fdda3e90958dda21a4dc217d882 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 17:04:21 -0500 Subject: [PATCH 65/93] updates for code styling, marking style check to continue on error --- .github/workflows/ci_workflows.yml | 1 + astronify/series/series.py | 10 +++------- 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index c94f88a..e533249 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -127,6 +127,7 @@ jobs: include: - name: Code style checks + continue-on-error: true os: ubuntu-latest python: 3.x toxenv: codestyle diff --git a/astronify/series/series.py b/astronify/series/series.py index 560450d..95173ad 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -110,8 +110,7 @@ def pitch_map_args(self, new_args): class SoniSeries(): - def __init__(self, data, time_col="time", val_col="flux", - preview_type="scan"): + def __init__(self, data, time_col="time", val_col="flux", preview_type="scan"): """ Class that encapsulates a sonified data series. @@ -321,8 +320,7 @@ def write(self, filepath): class SeriesPreviews(): """ - Previews (or snapshots) of 1d spectra by binning the data into - five equal pieces by assigning a sound to each piece. + Previews (or snapshots) of 1d spectra by binning the data into five equal pieces by assigning a sound to each piece. """ def __init__(self, soniseries): @@ -359,10 +357,8 @@ def area_of_pieces(self, ydata_bins, xdata_bins): return area_vals def plot_preview(self, xdata_bin_ranges): - plt.plot(self._soniseries.data[self._soniseries.time_col], - self._soniseries.data[self._soniseries.val_col], - color='k') + self._soniseries.data[self._soniseries.val_col], color='k') plt.axvspan(xdata_bin_ranges[0][0], xdata_bin_ranges[0][1], color='royalblue', alpha=0.5, lw=0) plt.axvspan(xdata_bin_ranges[1][0], xdata_bin_ranges[1][1], color='green', alpha=0.5, lw=0) From 2731f2445697a31269a5a8e458a329e6c50ca7dc Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 17:05:56 -0500 Subject: [PATCH 66/93] undoing mistake in CI yml --- .github/workflows/ci_workflows.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index e533249..c94f88a 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -127,7 +127,6 @@ jobs: include: - name: Code style checks - continue-on-error: true os: ubuntu-latest python: 3.x toxenv: codestyle From 7dab1ed846d45aebe2175fb04a184864e587d4e5 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 17:17:46 -0500 Subject: [PATCH 67/93] removing lynting from flake8, start at switch to black --- .github/workflows/black.yml | 10 ++++++++++ .github/workflows/ci_workflows.yml | 5 ----- tox.ini | 7 ------- 3 files changed, 10 insertions(+), 12 deletions(-) create mode 100644 .github/workflows/black.yml diff --git a/.github/workflows/black.yml b/.github/workflows/black.yml new file mode 100644 index 0000000..81e6a94 --- /dev/null +++ b/.github/workflows/black.yml @@ -0,0 +1,10 @@ +name: Lint + +on: [push, pull_request] + +jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: psf/black@stable diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index c94f88a..3aa4a31 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -126,11 +126,6 @@ jobs: matrix: include: - - name: Code style checks - os: ubuntu-latest - python: 3.x - toxenv: codestyle - - name: (Allowed Failure) Python 3.11 with dev version of key dependencies os: ubuntu-latest python: 3.11 diff --git a/tox.ini b/tox.ini index ae7b128..beea845 100644 --- a/tox.ini +++ b/tox.ini @@ -90,10 +90,3 @@ description = check the links in the HTML docs extras = docs commands = sphinx-build -b linkcheck . _build/html - -[testenv:codestyle] -skip_install = true -changedir = . -description = check code style, e.g. with flake8 -deps = flake8 -commands = flake8 astronify --count --show-source --statistics --ignore=W291,W293,W391,E303,E266,E226,W504 --max-line-length=120 --exclude=astronify/conftest.py From 2c097b38b435e0f9060d752805951f68aa267558 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 17:24:43 -0500 Subject: [PATCH 68/93] removing the CI tests with oldest deps since they never find runners, starting on black lynting --- .github/workflows/ci_workflows.yml | 15 --------------- astronify/__init__.py | 8 ++++---- 2 files changed, 4 insertions(+), 19 deletions(-) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index 3aa4a31..53255d5 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -34,11 +34,6 @@ jobs: python: 3.9.21 toxenv: py39-test-alldeps-numpy124-cov - - name: Python 3.9.xx with oldest supported version of all dependencies - os: ubuntu-16.04 - python: 3.9.21 - toxenv: py39-test-oldestdeps - - name: Python 3.10.xx with minimal dependencies os: ubuntu-latest python: 3.10.16 @@ -61,11 +56,6 @@ jobs: python: 3.10.16 toxenv: py310-test-alldeps-numpy210-cov - - name: Python 3.10.xx with oldest supported version of all dependencies - os: ubuntu-16.04 - python: 3.10.16 - toxenv: py310-test-oldestdeps - - name: Python 3.11.xx with minimal dependencies os: ubuntu-latest python: 3.11.11 @@ -88,11 +78,6 @@ jobs: python: 3.11.11 toxenv: py311-test-alldeps-numpy210-cov - - name: Python 3.11.xx with oldest supported version of all dependencies - os: ubuntu-16.04 - python: 3.11.11 - toxenv: py311-test-oldestdeps - steps: - name: Checkout code uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938 # v4.2.0 diff --git a/astronify/__init__.py b/astronify/__init__.py index 4419fcb..0f7acb4 100644 --- a/astronify/__init__.py +++ b/astronify/__init__.py @@ -4,12 +4,12 @@ # Packages may add whatever they like to this file, but # should keep this content at the top. # ---------------------------------------------------------------------------- -from ._astropy_init import * # noqa +from ._astropy_init import * # noqa # ---------------------------------------------------------------------------- -from . import series # noqa -from . import simulator # noqa +from . import series # noqa +from . import simulator # noqa from . import utils # noqa -__all__ = ['series', 'simulator', 'utils'] # noqa +__all__ = ['series', 'simulator', 'utils'] # noqa From ba18ab03ef560a0b1a8d8b5ae3d706fc852d13d4 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 22:07:07 -0500 Subject: [PATCH 69/93] big round of black lynting --- astronify/__init__.py | 5 +- astronify/_astropy_init.py | 8 +- astronify/conftest.py | 9 +- astronify/series/series.py | 273 +++++++++++++------- astronify/series/tests/test_series.py | 45 ++-- astronify/simulator/add_flare_signal.py | 21 +- astronify/simulator/add_sine_signal.py | 2 +- astronify/simulator/add_transit_signal.py | 10 +- astronify/simulator/check_flare_params.py | 26 +- astronify/simulator/check_transit_params.py | 38 +-- astronify/simulator/sim_lc.py | 103 +++++--- astronify/simulator/sim_lc_config.py | 18 +- astronify/simulator/sim_lc_setup_args.py | 253 +++++++++++------- astronify/utils/__init__.py | 4 +- astronify/utils/exceptions.py | 2 + astronify/utils/pitch_mapping.py | 62 +++-- astronify/utils/tests/test_pitch_mapping.py | 106 ++++---- docs/conf.py | 67 ++--- setup.py | 12 +- 19 files changed, 651 insertions(+), 413 deletions(-) diff --git a/astronify/__init__.py b/astronify/__init__.py index 0f7acb4..d2be38a 100644 --- a/astronify/__init__.py +++ b/astronify/__init__.py @@ -5,11 +5,10 @@ # should keep this content at the top. # ---------------------------------------------------------------------------- from ._astropy_init import * # noqa -# ---------------------------------------------------------------------------- - +# ---------------------------------------------------------------------------- from . import series # noqa from . import simulator # noqa from . import utils # noqa -__all__ = ['series', 'simulator', 'utils'] # noqa +__all__ = ["series", "simulator", "utils"] # noqa diff --git a/astronify/_astropy_init.py b/astronify/_astropy_init.py index fa37a63..4121e7e 100644 --- a/astronify/_astropy_init.py +++ b/astronify/_astropy_init.py @@ -1,18 +1,19 @@ # Licensed under a 3-clause BSD style license - see LICENSE.rst -__all__ = ['__version__'] +__all__ = ["__version__"] # this indicates whether or not we are in the package's setup.py try: _ASTROPY_SETUP_ except NameError: import builtins + builtins._ASTROPY_SETUP_ = False try: from .version import version as __version__ except ImportError: - __version__ = '' + __version__ = "" if not _ASTROPY_SETUP_: # noqa @@ -20,6 +21,7 @@ # Create the test function for self test from astropy.tests.runner import TestRunner + test = TestRunner.make_test_runner_in(os.path.dirname(__file__)) test.__test__ = False - __all__ += ['test'] + __all__ += ["test"] diff --git a/astronify/conftest.py b/astronify/conftest.py index 672b273..4ced7b8 100644 --- a/astronify/conftest.py +++ b/astronify/conftest.py @@ -8,13 +8,15 @@ from astropy.version import version as astropy_version # For Astropy 3.0 and later, we can use the standalone pytest plugin -if astropy_version < '3.0': +if astropy_version < "3.0": from astropy.tests.pytest_plugins import * # noqa + del pytest_report_header ASTROPY_HEADER = True else: try: from pytest_astropy_header.display import PYTEST_HEADER_MODULES, TESTED_VERSIONS + ASTROPY_HEADER = True except ImportError: ASTROPY_HEADER = False @@ -28,10 +30,11 @@ def pytest_configure(config): # Customize the following lines to add/remove entries from the list of # packages for which version numbers are displayed when running the tests. - PYTEST_HEADER_MODULES.pop('Pandas', None) - PYTEST_HEADER_MODULES['scikit-image'] = 'skimage' + PYTEST_HEADER_MODULES.pop("Pandas", None) + PYTEST_HEADER_MODULES['scikit-image'] = "skimage" from . import __version__ + packagename = os.path.basename(os.path.dirname(__file__)) TESTED_VERSIONS[packagename] = __version__ diff --git a/astronify/series/series.py b/astronify/series/series.py index 95173ad..01e8866 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -22,10 +22,10 @@ from ..utils.pitch_mapping import data_to_pitch from ..utils.exceptions import InputWarning -__all__ = ['PitchMap', 'SoniSeries'] +__all__ = ["PitchMap", "SoniSeries"] -class PitchMap(): +class PitchMap: def __init__(self, pitch_func=data_to_pitch, **pitch_args): """ @@ -45,15 +45,16 @@ def __init__(self, pitch_func=data_to_pitch, **pitch_args): # Setting up the default arguments if (not pitch_args) and (pitch_func == data_to_pitch): - pitch_args = {"pitch_range": [100, 10000], - "center_pitch": 440, - "zero_point": "median", - "stretch": "linear"} + pitch_args = { + "pitch_range": [100, 10000], + "center_pitch": 440, + "zero_point": "median", + "stretch": "linear" + } self.pitch_map_func = pitch_func self.pitch_map_args = pitch_args - def _check_func_args(self): """ Make sure the pitch mapping function and argument dictionary match. @@ -64,11 +65,15 @@ def _check_func_args(self): if hasattr(self, "pitch_map_func") and hasattr(self, "pitch_map_args"): # Only check parameters if there is no kwargs argument - param_types = [x.kind for x in signature(self.pitch_map_func).parameters.values()] + param_types = [ + x.kind for x in signature(self.pitch_map_func).parameters.values() + ] if Parameter.VAR_KEYWORD not in param_types: for arg_name in list(self.pitch_map_args): if arg_name not in signature(self.pitch_map_func).parameters: - wstr = "{} is not accepted by the pitch mapping function and will be ignored".format(arg_name) + wstr = "{} is not accepted by the pitch mapping function and will be ignored".format( + arg_name + ) warnings.warn(wstr, InputWarning) del self.pitch_map_args[arg_name] @@ -102,13 +107,13 @@ def pitch_map_args(self): @pitch_map_args.setter def pitch_map_args(self, new_args): - assert isinstance(new_args, dict), "Pitch mapping function args must be in a dictionary." + assert isinstance( + new_args, dict + ), "Pitch mapping function args must be in a dictionary." self._pitch_map_args = new_args self._check_func_args() - - -class SoniSeries(): +class SoniSeries: def __init__(self, data, time_col="time", val_col="flux", preview_type="scan"): """ @@ -138,7 +143,8 @@ def __init__(self, data, time_col="time", val_col="flux", preview_type="scan"): # Default specs self.note_duration = 0.5 # note duration in seconds self.note_spacing = 0.01 # spacing between notes in seconds - self.gain = 0.05 # default gain in the generated sine wave. pyo multiplier, -1 to 1. + # default gain in the generated sine wave. pyo multiplier, -1 to 1. + self.gain = 0.05 self.pitch_mapper = PitchMap(data_to_pitch) self.preview_object = SeriesPreviews(self) self._init_pyo() @@ -149,12 +155,12 @@ def _init_pyo(self): @property def data(self): - """ The data table (~astropy.table.Table). """ + """The data table (~astropy.table.Table).""" return self._data @data.setter def data(self, data_table): - assert isinstance(data_table, Table), 'Data must be a Table.' + assert isinstance(data_table, Table), "Data must be a Table." # Removing any masked values as they interfere with the sonification if isinstance(data_table[self.val_col], MaskedColumn): @@ -175,7 +181,7 @@ def data(self, data_table): @property def time_col(self): - """ The data column mappend to time when sonifying. """ + """The data column mappend to time when sonifying.""" return self._time_col @time_col.setter @@ -185,17 +191,17 @@ def time_col(self, value): @property def val_col(self): - """ The data column mappend to putch when sonifying. """ + """The data column mappend to putch when sonifying.""" return self._val_col @val_col.setter def val_col(self, value): - assert isinstance(value, str), 'Value column name must be a string.' + assert isinstance(value, str), "Value column name must be a string." self._val_col = value @property def pitch_mapper(self): - """ The pitch mapping object that takes data values to pitch values (Hz). """ + """The pitch mapping object that takes data values to pitch values (Hz).""" return self._pitch_mapper @pitch_mapper.setter @@ -204,7 +210,7 @@ def pitch_mapper(self, value): @property def gain(self): - """ Adjustable gain for output. """ + """Adjustable gain for output.""" return self._gain @gain.setter @@ -213,7 +219,7 @@ def gain(self, value): @property def note_duration(self): - """ How long each individual note will be in seconds.""" + """How long each individual note will be in seconds.""" return self._note_duration @note_duration.setter @@ -223,7 +229,7 @@ def note_duration(self, value): @property def note_spacing(self): - """ The spacing of the notes on average (will adjust based on time) in seconds. """ + """The spacing of the notes on average (will adjust based on time) in seconds.""" return self._note_spacing @note_spacing.setter @@ -247,7 +253,9 @@ def sonify(self): data.meta["asf_spacing"] = self.note_spacing data["asf_pitch"] = self.pitch_mapper(data[self.val_col]) - data["asf_onsets"] = [x for x in (data[self.time_col] - data[self.time_col][0])/exptime*self.note_spacing] + data["asf_onsets"] = [ + x for x in (data[self.time_col] - data[self.time_col][0]) / exptime*self.note_spacing + ] def play(self): """ @@ -268,13 +276,19 @@ def play(self): # TODO: This doesn't seem like the best way to do this, but I don't know # how to make it better - env = pyo.Linseg(list=[(0, 0), (0.01, 1), (duration - 0.1, 1), - (duration - 0.05, 0.5), (duration - 0.005, 0)], - mul=[self.gain for i in range(len(pitches))]).play( - delay=list(delays), dur=duration) - - self.streams = pyo.Sine(list(pitches), 0, env).out(delay=list(delays), - dur=duration) + env = pyo.Linseg( + list=[ + (0, 0), + (0.01, 1), + (duration - 0.1, 1), + (duration - 0.05, 0.5), + (duration - 0.005, 0) + ], + mul=[self.gain for i in range(len(pitches))]).play( + delay=list(delays), dur=duration) + + self.streams = pyo.Sine(list(pitches), 0, env).out( + delay=list(delays), dur=duration) def stop(self): """ @@ -304,21 +318,25 @@ def write(self, filepath): self.server.reinit(audio="offline") self.server.boot() - self.server.recordOptions(dur=delays[-1]+duration, filename=filepath) - - env = pyo.Linseg(list=[(0, 0), (0.1, 1), (duration - 0.1, 1), - (duration - 0.05, 0.5), (duration - 0.005, 0)], - mul=[self.gain for i in range(len(pitches))]).play( - delay=list(delays), dur=duration) - sine = pyo.Sine(list(pitches), 0, env).out(delay=list(delays), dur=duration) # noqa: F841 + self.server.recordOptions(dur=delays[-1] + duration, filename=filepath) + + env = pyo.Linseg( + list=[ + (0, 0), + (0.1, 1), + (duration - 0.1, 1), + (duration - 0.05, 0.5), + (duration - 0.005, 0)], + mul=[self.gain for i in range(len(pitches))]).play( + delay=list(delays), dur=duration) + sine = pyo.Sine(list(pitches), 0, env).out(delay=list(delays), dur=duration) # noqa: F841 self.server.start() # Clean up self.server.shutdown() self.server.reinit(audio="portaudio") - -class SeriesPreviews(): +class SeriesPreviews: """ Previews (or snapshots) of 1d spectra by binning the data into five equal pieces by assigning a sound to each piece. """ @@ -327,7 +345,7 @@ def __init__(self, soniseries): # Allows access to SoniSeries class methods and variables self._soniseries = soniseries # Define the frequencies to use for each section. - self.pitch_values = [500]*5 + self.pitch_values = [500] * 5 if self._soniseries.preview_type == "ensemble": self.pitch_values = [300, 400, 500, 600, 700] # TODO: Make robust @@ -345,11 +363,11 @@ def area_of_pieces(self, ydata_bins, xdata_bins): """ area_vals = [] for idx, (ydata_bin, xdata_bin) in enumerate(zip(ydata_bins, xdata_bins)): - if idx < len(ydata_bins)-1: + if idx < len(ydata_bins) - 1: # Then you need to include the first (x,y) point from the NEXT bin as well # when calculating the trapezoidal area so the pieces all add up to the total. - list(ydata_bin).append(ydata_bins[idx+1][0]) - list(xdata_bin).append(xdata_bins[idx+1][0]) + list(ydata_bin).append(ydata_bins[idx + 1][0]) + list(xdata_bin).append(xdata_bins[idx + 1][0]) # Taking the absolute value so that emission lines and absorption lines # have the same amplitude @@ -357,14 +375,45 @@ def area_of_pieces(self, ydata_bins, xdata_bins): return area_vals def plot_preview(self, xdata_bin_ranges): - plt.plot(self._soniseries.data[self._soniseries.time_col], - self._soniseries.data[self._soniseries.val_col], color='k') - - plt.axvspan(xdata_bin_ranges[0][0], xdata_bin_ranges[0][1], color='royalblue', alpha=0.5, lw=0) - plt.axvspan(xdata_bin_ranges[1][0], xdata_bin_ranges[1][1], color='green', alpha=0.5, lw=0) - plt.axvspan(xdata_bin_ranges[2][0], xdata_bin_ranges[2][1], color='yellow', alpha=0.5, lw=0) - plt.axvspan(xdata_bin_ranges[3][0], xdata_bin_ranges[3][1], color='orange', alpha=0.5, lw=0) - plt.axvspan(xdata_bin_ranges[4][0], xdata_bin_ranges[4][1], color='red', alpha=0.5, lw=0) + plt.plot( + self._soniseries.data[self._soniseries.time_col], + self._soniseries.data[self._soniseries.val_col], + color="k" + ) + + plt.axvspan( + xdata_bin_ranges[0][0], + xdata_bin_ranges[0][1], + color="royalblue", + alpha=0.5, + lw=0 + ) + plt.axvspan( + xdata_bin_ranges[1][0], + xdata_bin_ranges[1][1], + color="green", + alpha=0.5, + lw=0 + ) + plt.axvspan( + xdata_bin_ranges[2][0], + xdata_bin_ranges[2][1], + color="yellow", + alpha=0.5, + lw=0 + ) + plt.axvspan( + xdata_bin_ranges[3][0], + xdata_bin_ranges[3][1], + color="orange", + alpha=0.5, + lw=0) + plt.axvspan( + xdata_bin_ranges[4][0], + xdata_bin_ranges[4][1], + color="red", + alpha=0.5, + lw=0) plt.show() @@ -381,14 +430,14 @@ def sonify_preview(self, plotting=True, verbose=False): xdata = np.asarray(self._soniseries.data[self._soniseries.time_col]) # Normalize the y-data by the maximum to constrain values from 0-1. - ydata_norm = ydata/max(ydata) + ydata_norm = ydata / max(ydata) # Split the data into `n_pitch_values` equal-sized pieces. bin_size = int(np.round(len(xdata) // self.n_pitch_values, 1)) # Split the y-values into pieces. - ydata_bins = [ydata_norm[i:i+bin_size] for i in range(0, len(ydata_norm), bin_size)] + ydata_bins = [ydata_norm[i : i+bin_size] for i in range(0, len(ydata_norm), bin_size)] # Split the x-values into pieces. - xdata_bins = [xdata[i:i+bin_size] for i in range(0, len(xdata), bin_size)] + xdata_bins = [xdata[i : i + bin_size] for i in range(0, len(xdata), bin_size)] # Calculate the total area under the curve, used to normalize the areas in each piece. total_area = np.trapz(ydata_norm, xdata) @@ -428,26 +477,26 @@ def sonify_preview(self, plotting=True, verbose=False): # The final calculated tremolo values are multiplied by a factor of 10 for auditory # purposes - self.tremolo_vals = (np.asarray(std_vals) / std_dev_norm)*10 + self.tremolo_vals = (np.asarray(std_vals) / std_dev_norm) * 10 # Constraint added to keep tremolo values at or below 15, otherwise oscillations are # more difficult to hear # self.tremolo_vals[self.tremolo_vals > 15] = 15 if verbose: - print('Total Expected area = {0:0f}'.format(total_area)) - print(' ') - print('Area Values = ', np.asarray(area_vals)) - print(' ') - # print('Total Calculated area = {0:0f}'.format(np.sum(str(area_vals).split(' ')))) - print(' ') - print('Amplitudes = ', self.amplitudes) - print(' ') - print('Standard Dev. Error Vals = ', np.asarray(std_vals)) - print(' ') - print('Standard Dev. Error MAX = ', std_dev_norm) - print(' ') - print('Tremolo Vals (x10) = ', self.tremolo_vals) + print("Total Expected area = {0:0f}".format(total_area)) + print(" ") + print("Area Values = ", np.asarray(area_vals)) + print(" ") + # print("Total Calculated area = {0:0f}".format(np.sum(str(area_vals).split(" ")))) + print(" ") + print("Amplitudes = ", self.amplitudes) + print(" ") + print("Standard Dev. Error Vals = ", np.asarray(std_vals)) + print(" ") + print("Standard Dev. Error MAX = ", std_dev_norm) + print(" ") + print("Tremolo Vals (x10) = ", self.tremolo_vals) def play_preview(self): """ Play the sound of a "preview-style" sonification. @@ -466,37 +515,77 @@ def play_preview(self): # TODO: Generalize the self.delays list # `step` must go into `stop` 5 times, since we have 5 pitches - self.delays = [0., 2., 4., 6., 8.] + self.delays = [0.0, 2.0, 4.0, 6.0, 8.0] # `total_duration` is in seconds self.total_duration = 8.0 - self.amplitudes = [amp/max(self.amplitudes) for amp in self.amplitudes] + self.amplitudes = [amp / max(self.amplitudes) for amp in self.amplitudes] - a = pyo.Phasor(self.pitch_values[0], mul=np.pi*2) - b = pyo.Phasor(self.pitch_values[1], mul=np.pi*2) - c = pyo.Phasor(self.pitch_values[2], mul=np.pi*2) - d = pyo.Phasor(self.pitch_values[3], mul=np.pi*2) - e = pyo.Phasor(self.pitch_values[4], mul=np.pi*2) + a = pyo.Phasor(self.pitch_values[0], mul=np.pi * 2) + b = pyo.Phasor(self.pitch_values[1], mul=np.pi * 2) + c = pyo.Phasor(self.pitch_values[2], mul=np.pi * 2) + d = pyo.Phasor(self.pitch_values[3], mul=np.pi * 2) + e = pyo.Phasor(self.pitch_values[4], mul=np.pi * 2) # TODO: Make everything below iterable to it's cleaner and takes up less lines - lfo1 = pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0]), 0) if self.tremolo_vals[0] > 0 else pyo.Cos(a, mul=float(self.amplitudes[0])) - lfo2 = pyo.Sine(float(self.tremolo_vals[1]), 0, float(self.amplitudes[1]), 0) if self.tremolo_vals[1] > 0 else pyo.Cos(b, mul=float(self.amplitudes[1])) - lfo3 = pyo.Sine(float(self.tremolo_vals[2]), 0, float(self.amplitudes[2]), 0) if self.tremolo_vals[2] > 0 else pyo.Cos(c, mul=float(self.amplitudes[2])) - lfo4 = pyo.Sine(float(self.tremolo_vals[3]), 0, float(self.amplitudes[3]), 0) if self.tremolo_vals[3] > 0 else pyo.Cos(d, mul=float(self.amplitudes[3])) - lfo5 = pyo.Sine(float(self.tremolo_vals[4]), 0, float(self.amplitudes[4]), 0) if self.tremolo_vals[4] > 0 else pyo.Cos(e, mul=float(self.amplitudes[4])) - - self.stream1 = pyo.Sine(freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1).out(delay=self.delays[0], dur=2.0) - self.stream2 = pyo.Sine(freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2).out(delay=self.delays[1], dur=2.0) - self.stream3 = pyo.Sine(freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3).out(delay=self.delays[2], dur=2.0) - self.stream4 = pyo.Sine(freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4).out(delay=self.delays[3], dur=2.0) - self.stream5 = pyo.Sine(freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5).out(delay=self.delays[4], dur=2.0) + lfo1 = ( + pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0]), 0) + if self.tremolo_vals[0] > 0 + else pyo.Cos(a, mul=float(self.amplitudes[0])) + ) + lfo2 = ( + pyo.Sine(float(self.tremolo_vals[1]), 0, float(self.amplitudes[1]), 0) + if self.tremolo_vals[1] > 0 + else pyo.Cos(b, mul=float(self.amplitudes[1])) + ) + lfo3 = ( + pyo.Sine(float(self.tremolo_vals[2]), 0, float(self.amplitudes[2]), 0) + if self.tremolo_vals[2] > 0 + else pyo.Cos(c, mul=float(self.amplitudes[2])) + ) + lfo4 = ( + pyo.Sine(float(self.tremolo_vals[3]), 0, float(self.amplitudes[3]), 0) + if self.tremolo_vals[3] > 0 + else pyo.Cos(d, mul=float(self.amplitudes[3])) + ) + lfo5 = ( + pyo.Sine(float(self.tremolo_vals[4]), 0, float(self.amplitudes[4]), 0) + if self.tremolo_vals[4] > 0 + else pyo.Cos(e, mul=float(self.amplitudes[4])) + ) + + self.stream1 = pyo.Sine( + freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1 + ).out(delay=self.delays[0], dur=2.0) + self.stream2 = pyo.Sine( + freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2 + ).out(delay=self.delays[1], dur=2.0) + self.stream3 = pyo.Sine( + freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3 + ).out(delay=self.delays[2], dur=2.0) + self.stream4 = pyo.Sine( + freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4 + ).out(delay=self.delays[3], dur=2.0) + self.stream5 = pyo.Sine( + freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5 + ).out(delay=self.delays[4], dur=2.0) # All together, if in ensemble mode. if self._soniseries.preview_type == "ensemble": - self.stream6 = pyo.Sine(freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1).out(delay=10, dur=4) - self.stream7 = pyo.Sine(freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2).out(delay=10, dur=4) - self.stream8 = pyo.Sine(freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3).out(delay=10, dur=4) - self.stream9 = pyo.Sine(freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4).out(delay=10, dur=4) - self.stream10 = pyo.Sine(freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5).out(delay=10, dur=4) + self.stream6 = pyo.Sine( + freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1 + ).out(delay=10, dur=4) + self.stream7 = pyo.Sine( + freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2 + ).out(delay=10, dur=4) + self.stream8 = pyo.Sine( + freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3 + ).out(delay=10, dur=4) + self.stream9 = pyo.Sine( + freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4 + ).out(delay=10, dur=4) + self.stream10 = pyo.Sine( + freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5 + ).out(delay=10, dur=4) diff --git a/astronify/series/tests/test_series.py b/astronify/series/tests/test_series.py index f9e7c8a..a4f5df2 100644 --- a/astronify/series/tests/test_series.py +++ b/astronify/series/tests/test_series.py @@ -13,28 +13,32 @@ def test_pitchmap(): """ Testing the PitchMap class. """ - + # Defaults my_pitchmapper = PitchMap() assert isinstance(my_pitchmapper.pitch_map_args, dict) assert "center_pitch" in my_pitchmapper.pitch_map_args.keys() - assert my_pitchmapper.pitch_map_args["zero_point"] == 'median' + assert my_pitchmapper.pitch_map_args["zero_point"] == "median" # Change args - my_pitchmapper.pitch_map_args = {"pitch_range": [100, 10000], - "center_pitch": 440, - "zero_point": "mean", - "stretch": "linear", - "invert": True} + my_pitchmapper.pitch_map_args = { + "pitch_range": [100, 10000], + "center_pitch": 440, + "zero_point": "mean", + "stretch": "linear", + "invert": True + } assert "center_pitch" in my_pitchmapper.pitch_map_args.keys() - assert my_pitchmapper.pitch_map_args["zero_point"] == 'mean' + assert my_pitchmapper.pitch_map_args["zero_point"] == "mean" with pytest.warns(InputWarning): # setting with bad arg - my_pitchmapper.pitch_map_args = {"pitch_range": [100, 10000], - "center_pitch": 440, - "zero_point": "mean", - "stretch": "linear", - "penguin": True} + my_pitchmapper.pitch_map_args = { + "pitch_range": [100, 10000], + "center_pitch": 440, + "zero_point": "mean", + "stretch": "linear", + "penguin": True + } assert "penguin" not in my_pitchmapper.pitch_map_args.keys() @@ -44,9 +48,9 @@ def test_pitchmap(): # Changing function def my_map_func(data): # dummy function data = np.array(data) - return data/2 + return data / 2 - with pytest.warns(InputWarning): # because of different args + with pytest.warns(InputWarning): # because of different args my_pitchmapper.pitch_map_func = my_map_func assert (my_pitchmapper([1, 1]) == [0.5, 0.5]).all() @@ -57,8 +61,7 @@ def test_soniseries(tmpdir): Testing SoniSeries class. """ - data = Table({"time": [0, 1, 2, 3, 4, 5, 6], - "flux": [1, 2, 1, 2, 5, 3, np.nan]}) + data = Table({"time": [0, 1, 2, 3, 4, 5, 6], "flux": [1, 2, 1, 2, 5, 3, np.nan]}) # defaults soni_obj = SoniSeries(data) @@ -73,11 +76,11 @@ def test_soniseries(tmpdir): soni_obj.sonify() assert "asf_pitch" in soni_obj.data.colnames assert "asf_onsets" in soni_obj.data.colnames - assert soni_obj.data.meta['asf_exposure_time'] == 1 - assert soni_obj.data.meta['asf_note_duration'] == soni_obj.note_duration - assert soni_obj.data.meta['asf_spacing'] == soni_obj.note_spacing + assert soni_obj.data.meta["asf_exposure_time"] == 1 + assert soni_obj.data.meta["asf_note_duration"] == soni_obj.note_duration + assert soni_obj.data.meta["asf_spacing"] == soni_obj.note_spacing - onset_spacing = soni_obj.data['asf_onsets'][1:]-soni_obj.data['asf_onsets'][:-1] + onset_spacing = soni_obj.data["asf_onsets"][1:]-soni_obj.data["asf_onsets"][:-1] assert (np.isclose(onset_spacing, soni_obj.note_spacing)).all() pitch_min, pitch_max = soni_obj.pitch_mapper.pitch_map_args["pitch_range"] diff --git a/astronify/simulator/add_flare_signal.py b/astronify/simulator/add_flare_signal.py index 9e688a9..347be3e 100644 --- a/astronify/simulator/add_flare_signal.py +++ b/astronify/simulator/add_flare_signal.py @@ -52,7 +52,7 @@ def add_flare_signal(fluxes, flare_time, flare_amp, flare_halfwidth): # Where "n" = 6 in Davenport et al., where the decay phase is defined from # t_1/2 = [0,6], but we will choose to extend to the end of the light curve # so that the decay gets as close to zero as possible. - n_t12 = int((fluxes_to_add.shape[0] + 1 - flare_time)/flare_halfwidth) + n_t12 = int((fluxes_to_add.shape[0] + 1 - flare_time) / flare_halfwidth) # Create the normalized part of the rise time. # In the Davenport et al. flare template, the rise part of the flare @@ -71,12 +71,16 @@ def add_flare_signal(fluxes, flare_time, flare_amp, flare_halfwidth): # [flare_time-flare_halfwidth+1 : flare_time] # Generate indices in "t_1/2" units. - t12_rise_indices = np.linspace(-1., 0., flare_halfwidth) + t12_rise_indices = np.linspace(-1.0, 0.0, flare_halfwidth) # Compute fluxes for the rise part. - rise_fluxes = (1. + 1.941*t12_rise_indices - 0.175*t12_rise_indices**2. - - 2.246*t12_rise_indices**3. - 1.125*t12_rise_indices**4.) + rise_fluxes = ( + 1.0 + + 1.941 * t12_rise_indices + - 0.175 * t12_rise_indices**2.0 + - 2.246 * t12_rise_indices**3.0 + - 1.125 * t12_rise_indices**4.0) # Insert these fluxes into the correct location in our light curve. - fluxes_to_add[flare_time-flare_halfwidth+1:flare_time+1] = rise_fluxes + fluxes_to_add[flare_time - flare_halfwidth + 1 : flare_time + 1] = rise_fluxes # Create the normalized part of the decay time. # In Davenport et al., they define their Eqn. 4 from t_1/2 = [0, 6]. @@ -91,16 +95,15 @@ def add_flare_signal(fluxes, flare_time, flare_amp, flare_halfwidth): # [flare_time : flare_time + n*flare_halfwidth-1 # Generate indices in "t_1/2" units. - t12_decay_indices = np.linspace(0., n_t12, n_t12*flare_halfwidth) + t12_decay_indices = np.linspace(0.0, n_t12, n_t12 * flare_halfwidth) # Compute fluxes for the decay part. - decay_fluxes = (0.6890*np.exp(-1.600*t12_decay_indices) + - 0.3030*np.exp(-0.2783*t12_decay_indices)) + decay_fluxes = (0.6890 * np.exp(-1.600 * t12_decay_indices) + 0.3030 * np.exp(-0.2783 * t12_decay_indices)) # Insert these fluxes into the correct location in our light curve. # Note: the above index range is correct, but in Python you need to go one # extra when slicing, hence 6*flare_halfwidth-1+1 = 6*flare_halfwidth... - fluxes_to_add[flare_time: flare_time+n_t12*flare_halfwidth] = decay_fluxes + fluxes_to_add[flare_time: flare_time + n_t12 * flare_halfwidth] = decay_fluxes # Scale the fluxes to add (which are normalized at this point) by 'flare_amp' fluxes_to_add *= flare_amp diff --git a/astronify/simulator/add_sine_signal.py b/astronify/simulator/add_sine_signal.py index 42e4530..ed09bef 100644 --- a/astronify/simulator/add_sine_signal.py +++ b/astronify/simulator/add_sine_signal.py @@ -27,7 +27,7 @@ def add_sine_signal(times, fluxes, sine_amp, sine_period): """ # Generate sinusoidal signal. - sine_signal = Sine1D(amplitude=sine_amp, frequency=1./sine_period) + sine_signal = Sine1D(amplitude=sine_amp, frequency=1.0 / sine_period) fluxes += sine_signal(times) diff --git a/astronify/simulator/add_transit_signal.py b/astronify/simulator/add_transit_signal.py index 13d9f10..2c9cf33 100644 --- a/astronify/simulator/add_transit_signal.py +++ b/astronify/simulator/add_transit_signal.py @@ -8,8 +8,8 @@ import numpy as np -def add_transit_signal(fluxes, transit_depth, transit_period, transit_start, - transit_width): +def add_transit_signal( + fluxes, transit_depth, transit_period, transit_start, transit_width): """ :param fluxes: Array of fluxes to add the transit signal to. :type fluxes: numpy.ndarray @@ -39,16 +39,16 @@ def add_transit_signal(fluxes, transit_depth, transit_period, transit_start, transit_indexes = np.zeros(n_fluxes) # Get the set of start indexes. - start_indexes = np.arange(transit_start, n_fluxes+1, transit_period, + start_indexes = np.arange(transit_start, n_fluxes + 1, transit_period, dtype=int) # Set transit indexes to 1. for st_ind in start_indexes: if st_ind + transit_width < fluxes.size: - transit_indexes[st_ind:st_ind+transit_width+1] = 1 + transit_indexes[st_ind : st_ind+transit_width + 1] = 1 else: transit_indexes[st_ind:] = 1 # Set the flux values of the transit indexes to the transit depth. - fluxes[np.where(transit_indexes == 1)] *= (1.-(transit_depth/100.)) + fluxes[np.where(transit_indexes == 1)] *= (1.0 - (transit_depth / 100.0)) return fluxes diff --git a/astronify/simulator/check_flare_params.py b/astronify/simulator/check_flare_params.py index d6ca06b..1ff1c83 100644 --- a/astronify/simulator/check_flare_params.py +++ b/astronify/simulator/check_flare_params.py @@ -24,19 +24,25 @@ def check_flare_params(n_fluxes, flare_time, flare_amp): # Flare time index must be less than total numbr of fluxes. if flare_time > n_fluxes: - raise argparse.ArgumentTypeError("The flare time at peak flux must be" - " less than the total number of fluxes" - " in the simulated light curve." - " Number of fluxes = " + str(n_fluxes) + - ", flare time requested is " + - str(flare_time) + ".") + raise argparse.ArgumentTypeError( + "The flare time at peak flux must be" + " less than the total number of fluxes" + " in the simulated light curve." + " Number of fluxes = " + + str(n_fluxes) + + ", flare time requested is " + + str(flare_time) + + "." + ) # Flare time index must be greater than or equal to zero. if flare_time < 0: - raise argparse.ArgumentTypeError("The flare time at peak flux must be" - " greater than or equal to zero, flare" - " time requested is " + - str(flare_time) + ".") + raise argparse.ArgumentTypeError( + "The flare time at peak flux must be" + " greater than or equal to zero, flare" + " time requested is " + + str(flare_time) + "." + ) # The flare amplitude must be greater than zero. if flare_amp <= 0.: diff --git a/astronify/simulator/check_transit_params.py b/astronify/simulator/check_transit_params.py index c19a7cf..3afc087 100644 --- a/astronify/simulator/check_transit_params.py +++ b/astronify/simulator/check_transit_params.py @@ -30,25 +30,31 @@ def check_transit_params(n_fluxes, transit_period, transit_start, transit_width) # Start index must be less than total numbr of fluxes. if transit_start > n_fluxes: - raise argparse.ArgumentTypeError("The transit start must be less than" - " the total number of fluxes in the" - " simulated light curve." - " Number of fluxes = " + str(n_fluxes) + - ", start index requested is " + - str(transit_start) + ".") + raise argparse.ArgumentTypeError( + "The transit start must be less than" + " the total number of fluxes in the" + " simulated light curve." + " Number of fluxes = " + + str(n_fluxes) + + ", start index requested is " + + str(transit_start) + + "." + ) # The start index must be greater than or equal to zero. if transit_start < 0: - raise argparse.ArgumentTypeError("The transit start must be greater than" - " or equal to zero, start" - " index requested is " + - str(transit_start) + ".") + raise argparse.ArgumentTypeError( + "The transit start must be greater than" + " or equal to zero, start" + " index requested is " + + str(transit_start) + "." + ) # The transit period must be greater than the transit duration (width). if transit_width >= transit_period: - raise argparse.ArgumentTypeError("Transit duration must be less than" - " the transit period. Requested" - " transit duration = " + - str(transit_width) + ", requested" - " transit period = " + - str(transit_period) + ".") + raise argparse.ArgumentTypeError( + "Transit duration must be less than" + " the transit period. Requested" + " transit duration = " + str(transit_width) + ", requested" + " transit period = " + str(transit_period) + "." + ) diff --git a/astronify/simulator/sim_lc.py b/astronify/simulator/sim_lc.py index 937cbf3..8034c27 100644 --- a/astronify/simulator/sim_lc.py +++ b/astronify/simulator/sim_lc.py @@ -22,23 +22,26 @@ from .sim_lc_setup_args import sim_lc_setup_args -__all__ = ["simulated_lc", 'SimLcConfig'] - - -def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, - lc_length=SimLcConfig.sim_lc_length, - lc_noise=SimLcConfig.sim_lc_noise, - visualize=SimLcConfig.sim_lc_visualize, - lc_yoffset=SimLcConfig.sim_lc_yoffset, - transit_depth=SimLcConfig.sim_lc_transit_depth, - transit_period=SimLcConfig.sim_lc_transit_period, - transit_start=SimLcConfig.sim_lc_transit_start, - transit_width=SimLcConfig.sim_lc_transit_width, - sine_amp=SimLcConfig.sim_lc_sine_amp, - sine_period=SimLcConfig.sim_lc_sine_period, - flare_time=SimLcConfig.sim_lc_flare_time, - flare_amp=SimLcConfig.sim_lc_flare_amp, - flare_halfwidth=SimLcConfig.sim_lc_flare_halfwidth): +__all__ = ["simulated_lc", "SimLcConfig"] + + +def simulated_lc( + lc_type, + lc_ofile=SimLcConfig.sim_lc_ofile, + lc_length=SimLcConfig.sim_lc_length, + lc_noise=SimLcConfig.sim_lc_noise, + visualize=SimLcConfig.sim_lc_visualize, + lc_yoffset=SimLcConfig.sim_lc_yoffset, + transit_depth=SimLcConfig.sim_lc_transit_depth, + transit_period=SimLcConfig.sim_lc_transit_period, + transit_start=SimLcConfig.sim_lc_transit_start, + transit_width=SimLcConfig.sim_lc_transit_width, + sine_amp=SimLcConfig.sim_lc_sine_amp, + sine_period=SimLcConfig.sim_lc_sine_period, + flare_time=SimLcConfig.sim_lc_flare_time, + flare_amp=SimLcConfig.sim_lc_flare_amp, + flare_halfwidth=SimLcConfig.sim_lc_flare_halfwidth + ): """ Create light curve with specified parameters as a `~astropy.table.Table`, and optionally writes a FITS file with the same information. @@ -117,11 +120,11 @@ def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, fluxes = add_flare_signal(fluxes, flare_time, flare_amp, flare_halfwidth) elif lc_type == "sine": fluxes = add_sine_signal(times, fluxes, sine_amp, sine_period) - elif lc_type == 'transit': - check_transit_params(fluxes.size, transit_period, transit_start, - transit_width) - fluxes = add_transit_signal(fluxes, transit_depth, transit_period, - transit_start, transit_width) + elif lc_type == "transit": + check_transit_params(fluxes.size, transit_period, transit_start, transit_width) + fluxes = add_transit_signal( + fluxes, transit_depth, transit_period, transit_start, transit_width + ) # Add noise based on standard deviation. fluxes_with_noise = add_lc_noise(fluxes, lc_noise) @@ -129,7 +132,7 @@ def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, # Visualize the light curve, if desired. if visualize: _, ax1 = plt.subplots(1) - ax1.plot(times, fluxes_with_noise, 'bo') + ax1.plot(times, fluxes_with_noise, "bo") plt.show() if lc_ofile: @@ -139,15 +142,23 @@ def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, hdr.append(("LCTYPE", lc_type, "Type of signal.")) hdr.append(("LCLENGTH", lc_length, "Number of fluxes.")) hdr.append(("LCYOFF", lc_yoffset, "Baseline flux value (unitless).")) - hdr.append(("LCNOISE", lc_noise, "Std. dev. of normal dist. used to" - " apply noise.")) + hdr.append( + ("LCNOISE", lc_noise, "Std. dev. of normal dist. used to" + " apply noise.") + ) # Record the flare parameters used if adding a flare. if lc_type == "flare": - hdr.append(("FLARETIM", flare_time, "Index corresponding to the peak" - " of the flare.")) + hdr.append( + ("FLARETIM", + flare_time, + "Index corresponding to the peak of the flare.") + ) hdr.append(("FLAREAMP", flare_amp, "Amplitude of the flare.")) - hdr.append(("FLAREWID", flare_halfwidth, "Flare half-width" - " (number of indices).")) + hdr.append( + ("FLAREWID", + flare_halfwidth, + "Flare half-width (number of indices).") + ) # Record the sinusoidal parameters if adding a sinusoid. if lc_type == "sine": hdr.append(("SINEAMP", sine_amp, "Amplitude of sine.")) @@ -161,9 +172,9 @@ def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, # This builds the primary header, no data, just keywords. primary_hdu = fits.PrimaryHDU(header=hdr) # This sets up the binary table and creates the first extension header. - col1 = fits.Column(name="time", array=times, format='D') - col2 = fits.Column(name="flux", array=fluxes_with_noise, format='D') - col3 = fits.Column(name="flux_pure", array=fluxes, format='D') + col1 = fits.Column(name="time", array=times, format="D") + col2 = fits.Column(name="flux", array=fluxes_with_noise, format="D") + col3 = fits.Column(name="flux_pure", array=fluxes, format="D") hdu1 = fits.BinTableHDU.from_columns([col1, col2, col3]) # If the output directory doesn't exist, create it. if not os.path.isdir(os.path.abspath(os.path.dirname(lc_ofile))): @@ -175,17 +186,29 @@ def simulated_lc(lc_type, lc_ofile=SimLcConfig.sim_lc_ofile, # Return the times and fluxes as an astropy Table so it can be directly # used later in a script. - return Table([times, fluxes_with_noise, fluxes], - names=("time", "flux", "flux_pure")) + return Table( + [times, fluxes_with_noise, fluxes], names=("time", "flux", "flux_pure") + ) if __name__ == "__main__": # Get command-line arguments. INPUT_ARGS = sim_lc_setup_args().parse_args() - simulated_lc(INPUT_ARGS.lc_type, INPUT_ARGS.lc_ofile, INPUT_ARGS.lc_length, - INPUT_ARGS.lc_noise, INPUT_ARGS.visualize, INPUT_ARGS.lc_yoffset, - INPUT_ARGS.transit_depth, INPUT_ARGS.transit_period, - INPUT_ARGS.transit_start, INPUT_ARGS.transit_width, - INPUT_ARGS.sine_amp, INPUT_ARGS.sine_period, INPUT_ARGS.flare_time, - INPUT_ARGS.flare_amp, INPUT_ARGS.flare_halfwidth) + simulated_lc( + INPUT_ARGS.lc_type, + INPUT_ARGS.lc_ofile, + INPUT_ARGS.lc_length, + INPUT_ARGS.lc_noise, + INPUT_ARGS.visualize, + INPUT_ARGS.lc_yoffset, + INPUT_ARGS.transit_depth, + INPUT_ARGS.transit_period, + INPUT_ARGS.transit_start, + INPUT_ARGS.transit_width, + INPUT_ARGS.sine_amp, + INPUT_ARGS.sine_period, + INPUT_ARGS.flare_time, + INPUT_ARGS.flare_amp, + INPUT_ARGS.flare_halfwidth + ) diff --git a/astronify/simulator/sim_lc_config.py b/astronify/simulator/sim_lc_config.py index 7def0cb..2522dd2 100644 --- a/astronify/simulator/sim_lc_config.py +++ b/astronify/simulator/sim_lc_config.py @@ -8,21 +8,21 @@ class SimLcConfig: # General Parameters sim_lc_ofile = "" sim_lc_length = 500 - sim_lc_noise = 0. + sim_lc_noise = 0.0 sim_lc_visualize = False - sim_lc_yoffset = 100. - + sim_lc_yoffset = 100.0 + # Transit Parameters - sim_lc_transit_depth = 10. - sim_lc_transit_period = 50. + sim_lc_transit_depth = 10.0 + sim_lc_transit_period = 50.0 sim_lc_transit_start = 10 sim_lc_transit_width = 5 - + # Sinusoidal Parameters - sim_lc_sine_amp = 10. - sim_lc_sine_period = 50. + sim_lc_sine_amp = 10.0 + sim_lc_sine_period = 50.0 # Flare Parameters sim_lc_flare_time = 10 - sim_lc_flare_amp = 100. + sim_lc_flare_amp = 100.0 sim_lc_flare_halfwidth = 5 diff --git a/astronify/simulator/sim_lc_setup_args.py b/astronify/simulator/sim_lc_setup_args.py index 4483860..0e8b565 100644 --- a/astronify/simulator/sim_lc_setup_args.py +++ b/astronify/simulator/sim_lc_setup_args.py @@ -19,102 +19,173 @@ def sim_lc_setup_args(): parser = argparse.ArgumentParser( description="Create simulated light curves, as FITS files, for use with" " the Astronify sonification software. Types include flat, transit, sine" - " and flare.") - - parser.add_argument("lc_type", action="store", type=str, help="Type of light" - " curve to create.", choices=["flat", "transit", - "sine", "flare"]) - - parser.add_argument("-o", dest="lc_ofile", action="store", type=str, - help="Name of output FITS file to create.", - default=sim_lc_config.sim_lc_ofile) - - parser.add_argument("-l", action="store", type=int, - default=sim_lc_config.sim_lc_length, - dest="lc_length", help="Total number of flux" - " measurements in the light curve. Default =" - " %(default)s.") - - parser.add_argument("-n", action="store", type=float, - default=sim_lc_config.sim_lc_noise, - dest="lc_noise", help="Amount of noise to add to the" - " measurements in the light curve, specified by the" - " standard deviation of the normal distribution to draw" - " from. Set to zero for no noise. Default =" - " %(default)s.") - - parser.add_argument("-v", action="store_true", dest="visualize", - default=sim_lc_config.sim_lc_vizualize, - help="If True, a plot of the light curve" - " that is generated will be plot on the screen. Default" - " = %(default)s.") - - parser.add_argument("-y", action="store", type=float, - default=sim_lc_config.sim_lc_yoffset, - dest="lc_yoffset", help="Baseline (unitless) flux height" - " of the light curve. Used to test sonification of" - " sources with different total brightness. Default =" - " %(default)s.") + " and flare." + ) + + parser.add_argument( + "lc_type", + action="store", + type=str, + help="Type of light curve to create.", + choices=["flat", "transit", "sine", "flare"]) + + parser.add_argument( + "-o", + dest="lc_ofile", + action="store", + type=str, + help="Name of output FITS file to create.", + default=sim_lc_config.sim_lc_ofile + ) + + parser.add_argument( + "-l", + action="store", + type=int, + default=sim_lc_config.sim_lc_length, + dest="lc_length", + help="Total number of flux" + " measurements in the light curve. Default =" + " %(default)s." + ) + + parser.add_argument( + "-n", + action="store", + type=float, + default=sim_lc_config.sim_lc_noise, + dest="lc_noise", + help="Amount of noise to add to the" + " measurements in the light curve, specified by the" + " standard deviation of the normal distribution to draw" + " from. Set to zero for no noise. Default =" + " %(default)s." + ) + + parser.add_argument( + "-v", + action="store_true", + dest="visualize", + default=sim_lc_config.sim_lc_vizualize, + help="If True, a plot of the light curve" + " that is generated will be plot on the screen. Default" + " = %(default)s." + ) + + parser.add_argument( + "-y", + action="store", + type=float, + default=sim_lc_config.sim_lc_yoffset, + dest="lc_yoffset", + help="Baseline (unitless) flux height" + " of the light curve. Used to test sonification of" + " sources with different total brightness. Default =" + " %(default)s." + ) # Transit-related parameters here. - transit_group = parser.add_argument_group("transit", "Parameters for transit" - " signals.") - transit_group.add_argument("--transit_depth", type=float, - default=sim_lc_config.sim_lc_transit_depth, - dest="transit_depth", help="Depth of the transit" - " signal specified as a percent, e.g., set to" - " 10.0 for a 10%% depth transit. Default =" - " %(default)s.") - transit_group.add_argument("--transit_period", type=int, - default=sim_lc_config.sim_lc_transit_period, - dest="transit_period", help="Period of the" - " transit signal, specified as the number of" - " fluxes (bins) between the start of each event." - " Default = %(default)s.") - transit_group.add_argument("--transit_start", type=int, - default=sim_lc_config.sim_lc_transit_start, - dest="transit_start", help="Start of the first" - " transit, specified as the index of the" - " flux (bin) to use as the start of the first" - " transit event. Default = %(default)s.") - transit_group.add_argument("--transit_width", type=int, - default=sim_lc_config.sim_lc_transit_width, - dest="transit_width", help="Width of the" - " transit signal, specified as the number of" - " fluxes (bins) between the start and end of each" - " event. Default = %(default)s.") + transit_group = parser.add_argument_group( + "transit", "Parameters for transit signals.") + + transit_group.add_argument( + "--transit_depth", + type=float, + default=sim_lc_config.sim_lc_transit_depth, + dest="transit_depth", + help="Depth of the transit" + " signal specified as a percent, e.g., set to" + " 10.0 for a 10%% depth transit. Default =" + " %(default)s." + ) + + transit_group.add_argument( + "--transit_period", + type=int, + default=sim_lc_config.sim_lc_transit_period, + dest="transit_period", + help="Period of the" + " transit signal, specified as the number of" + " fluxes (bins) between the start of each event." + " Default = %(default)s." + ) + + transit_group.add_argument( + "--transit_start", + type=int, + default=sim_lc_config.sim_lc_transit_start, + dest="transit_start", + help="Start of the first" + " transit, specified as the index of the" + " flux (bin) to use as the start of the first" + " transit event. Default = %(default)s." + ) + + transit_group.add_argument( + "--transit_width", + type=int, + default=sim_lc_config.sim_lc_transit_width, + dest="transit_width", + help="Width of the" + " transit signal, specified as the number of" + " fluxes (bins) between the start and end of each" + " event. Default = %(default)s." + ) # Sinusoidal-related parameters here. - sine_group = parser.add_argument_group("sinusoidal", "Parameters for" - " sinusoidal signals.") - sine_group.add_argument("--sine_amp", type=float, - default=sim_lc_config.sim_lc_sine_amp, - dest="sine_amp", help="Amplitude of the" - " sinusoidal signal to add. Default =" - " %(default)s.") - sine_group.add_argument("--sine_period", type=float, - default=sim_lc_config.sim_lc_sine_period, - dest="sine_period", help="Period of the" - " sinusoidal signal, specified in the (unitless)" - " time axis (flux bins). Default = %(default)s.") + sine_group = parser.add_argument_group( + "sinusoidal", "Parameters for sinusoidal signals." + ) + + sine_group.add_argument( + "--sine_amp", + type=float, + default=sim_lc_config.sim_lc_sine_amp, + dest="sine_amp", + help="Amplitude of the sinusoidal signal to add. Default =" + " %(default)s." + ) + + sine_group.add_argument( + "--sine_period", + type=float, + default=sim_lc_config.sim_lc_sine_period, + dest="sine_period", + help="Period of the sinusoidal signal, specified in the (unitless)" + " time axis (flux bins). Default = %(default)s." + ) # Flare-related parameters here. - flare_group = parser.add_argument_group("flare", "Parameters for" - " adding flares.") - flare_group.add_argument("--flare_time", type=int, - default=sim_lc_config.sim_lc_flare_time, - dest="flare_time", help="Time corresponding to" - " the maximum flux of the flare, specified" - " as the index of the flux (bin) to use as" - " the peak time. Default = %(default)s.") - flare_group.add_argument("--flare_amp", type=float, - default=sim_lc_config.sim_lc_flare_amp, - dest="flare_amp", help="Amplitude (maximum flux)" - " of the flare to add. Default = %(default)s.") - flare_group.add_argument("--flare_halfwidth", type=int, - default="flare_halfwidth", help="The flare" - " half-width (measured in indices) that" - " corresponds to 't_1/2' in the Davenport et al." - " flare template.") + flare_group = parser.add_argument_group( + "flare", "Parameters for adding flares.") + + flare_group.add_argument( + "--flare_time", + type=int, + default=sim_lc_config.sim_lc_flare_time, + dest="flare_time", + help="Time corresponding to" + " the maximum flux of the flare, specified" + " as the index of the flux (bin) to use as" + " the peak time. Default = %(default)s." + ) + + flare_group.add_argument( + "--flare_amp", + type=float, + default=sim_lc_config.sim_lc_flare_amp, + dest="flare_amp", + help="Amplitude (maximum flux) of the flare to add. Default = %(default)s." + ) + + flare_group.add_argument( + "--flare_halfwidth", + type=int, + default="flare_halfwidth", + help="The flare" + " half-width (measured in indices) that" + " corresponds to 't_1/2' in the Davenport et al." + " flare template." + ) return parser diff --git a/astronify/utils/__init__.py b/astronify/utils/__init__.py index a84c02a..59f574b 100644 --- a/astronify/utils/__init__.py +++ b/astronify/utils/__init__.py @@ -4,6 +4,6 @@ # functions. -from .pitch_mapping import * # noqa: F403 +from .pitch_mapping import * # noqa: F403 -__all__ = ['data_to_pitch'] # noqa: F405 +__all__ = ["data_to_pitch"] # noqa: F405 diff --git a/astronify/utils/exceptions.py b/astronify/utils/exceptions.py index 9a4845b..4a64880 100644 --- a/astronify/utils/exceptions.py +++ b/astronify/utils/exceptions.py @@ -12,6 +12,7 @@ class InvalidInputError(Exception): Exception to be issued when user input is incorrect in a way that prevents the function from running. """ + pass @@ -20,4 +21,5 @@ class InputWarning(AstropyWarning): Warning to be issued when user input is incorrect in some way but doesn't prevent the function from running. """ + pass diff --git a/astronify/utils/pitch_mapping.py b/astronify/utils/pitch_mapping.py index d8f29bb..43ba2cf 100644 --- a/astronify/utils/pitch_mapping.py +++ b/astronify/utils/pitch_mapping.py @@ -10,17 +10,32 @@ import numpy as np -from astropy.visualization import (SqrtStretch, LogStretch, AsinhStretch, SinhStretch, - LinearStretch, MinMaxInterval, ManualInterval, - AsymmetricPercentileInterval) +from astropy.visualization import ( + SqrtStretch, + LogStretch, + AsinhStretch, + SinhStretch, + LinearStretch, + MinMaxInterval, + ManualInterval, + AsymmetricPercentileInterval +) from .exceptions import InputWarning, InvalidInputError -__all__ = ['data_to_pitch'] +__all__ = ["data_to_pitch"] -def data_to_pitch(data_array, pitch_range=[100, 10000], center_pitch=440, zero_point="median", - stretch='linear', minmax_percent=None, minmax_value=None, invert=False): +def data_to_pitch( + data_array, + pitch_range=[100, 10000], + center_pitch=440, + zero_point="median", + stretch='linear', + minmax_percent=None, + minmax_value=None, + invert=False + ): """ Map data array to audible pitches in the given range, and apply stretch and scaling as required. @@ -68,26 +83,29 @@ def data_to_pitch(data_array, pitch_range=[100, 10000], center_pitch=440, zero_p # The center pitch cannot be >= max() pitch range, or <= min() of pitch range. # If it is, fall back to using the mean of the pitch range provided. if center_pitch <= pitch_range[0] or center_pitch >= pitch_range[1]: - warnings.warn("Given center pitch is outside the pitch range, defaulting to the mean.", - InputWarning) + warnings.warn( + "Given center pitch is outside the pitch range, defaulting to the mean.", + InputWarning + ) center_pitch = np.mean(pitch_range) - if (data_array == zero_point).all(): # All values are the same, no more calculation needed + if (data_array == zero_point).all(): + # All values are the same, no more calculation needed return np.full(len(data_array), center_pitch) # Normalizing the data_array and adding the zero point (so it can go through the same transform) data_array = np.append(np.array(data_array), zero_point) # Setting up the transform with the stretch - if stretch == 'asinh': + if stretch == "asinh": transform = AsinhStretch() - elif stretch == 'sinh': + elif stretch == "sinh": transform = SinhStretch() - elif stretch == 'sqrt': + elif stretch == "sqrt": transform = SqrtStretch() - elif stretch == 'log': + elif stretch == "log": transform = LogStretch() - elif stretch == 'linear': + elif stretch == "linear": transform = LinearStretch() else: raise InvalidInputError("Stretch {} is not supported!".format(stretch)) @@ -97,8 +115,10 @@ def data_to_pitch(data_array, pitch_range=[100, 10000], center_pitch=440, zero_p transform += AsymmetricPercentileInterval(*minmax_percent) if minmax_value is not None: - warnings.warn("Both minmax_percent and minmax_value are set, minmax_value will be ignored.", - InputWarning) + warnings.warn( + "Both minmax_percent and minmax_value are set, minmax_value will be ignored.", + InputWarning + ) elif minmax_value is not None: transform += ManualInterval(*minmax_value) else: # Default, scale the entire image range to [0,1] @@ -121,12 +141,12 @@ def data_to_pitch(data_array, pitch_range=[100, 10000], center_pitch=440, zero_p # change user's choice here. May want to consider providing info back to the user about the # distribution of pitches actually used based on their sonification options in some way. if zero_point == 0.0: - zero_point = 1E-6 + zero_point = 1e-6 - if ((1/zero_point)*(center_pitch - pitch_range[0]) + pitch_range[0]) <= pitch_range[1]: - pitch_array = (pitch_array/zero_point)*(center_pitch - pitch_range[0]) + pitch_range[0] + if ( + (1 / zero_point) * (center_pitch - pitch_range[0]) + pitch_range[0]) <= pitch_range[1]: + pitch_array = (pitch_array / zero_point) * (center_pitch - pitch_range[0]) + pitch_range[0] else: - pitch_array = (((pitch_array-zero_point)/(1-zero_point))*(pitch_range[1] - center_pitch) + - center_pitch) + pitch_array = (((pitch_array - zero_point) / (1 - zero_point)) * (pitch_range[1] - center_pitch) + center_pitch) return pitch_array diff --git a/astronify/utils/tests/test_pitch_mapping.py b/astronify/utils/tests/test_pitch_mapping.py index e03e4ce..38f5034 100644 --- a/astronify/utils/tests/test_pitch_mapping.py +++ b/astronify/utils/tests/test_pitch_mapping.py @@ -15,104 +15,108 @@ def test_data_to_pitch(): center_pitch = 450 # basic linear stretch - data_arr = np.array([[1, 0, .25, .75]]) - pitch_arr = data_arr*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + data_arr = np.array([[1.0, 0.0, 0.25, 0.75]]) + pitch_arr = data_arr * (pitch_range[1] - pitch_range[0]) + pitch_range[0] - assert (pitch_arr == data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear')).all() + assert ( + pitch_arr == data_to_pitch(data_arr, pitch_range, center_pitch, + stretch='linear')).all() + # invert - pitch_arr = pitch_range[1] - data_arr*(pitch_range[1]-pitch_range[0]) - assert (pitch_arr == data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear', invert=True)).all() + pitch_arr = pitch_range[1] - data_arr * (pitch_range[1] - pitch_range[0]) + assert ( + pitch_arr == data_to_pitch(data_arr, pitch_range, center_pitch, + stretch='linear', invert=True)).all() # linear stretch where input image must be scaled - data_arr = np.array([10, 20, 12.5, 17.5]) - pitch_arr = ((data_arr - data_arr.min())/(data_arr.max()-data_arr.min()) * - (pitch_range[1]-pitch_range[0])) + pitch_range[0] - assert (pitch_arr == data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear')).all() + data_arr = np.array([10.0, 20.0, 12.5, 17.5]) + pitch_arr = ((data_arr - data_arr.min()) / (data_arr.max() - data_arr.min()) * + (pitch_range[1] - pitch_range[0])) + pitch_range[0] + assert ( + pitch_arr == data_to_pitch(data_arr, pitch_range, center_pitch, + stretch='linear')).all() # linear stretch with non-equal lower/upper pitch ranges - data_arr = np.array([[1, 0, .25, .75]]) - pitch_arr = data_arr*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + data_arr = np.array([[1.0, 0.0, 0.25, 0.75]]) + pitch_arr = data_arr * (pitch_range[1] - pitch_range[0]) + pitch_range[0] pitch_range = [300, 500] - assert (pitch_arr == data_to_pitch(data_arr, [300, 500], - center_pitch, stretch='linear')).all() + assert ( + pitch_arr == data_to_pitch(data_arr, [300, 500], + center_pitch, stretch="linear")).all() pitch_range = [400, 600] - assert (pitch_arr == data_to_pitch(data_arr, [400, 600], - center_pitch, stretch='linear')).all() + assert ( + pitch_arr == data_to_pitch(data_arr, [400, 600], + center_pitch, stretch="linear")).all() pitch_range = [400, 500] # min_max val minval, maxval = 0, 1 data_arr = np.array([1, 0, -1, 2]) - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear', minmax_value=[minval, maxval]) + pitch_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, + stretch="linear", minmax_value=[minval, maxval]) data_arr[data_arr < minval] = minval data_arr[data_arr > maxval] = maxval - manual_pitch_arr = data_arr*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + manual_pitch_arr = data_arr * (pitch_range[1] - pitch_range[0]) + pitch_range[0] assert (manual_pitch_arr == pitch_arr).all() minval, maxval = 0, 1 - data_arr = np.array([1, 0, .25, .75]) + data_arr = np.array([1.0, 0.0, 0.25, 0.75]) pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear', minmax_value=[minval, maxval]) + stretch="linear", minmax_value=[minval, maxval]) data_arr[data_arr < minval] = minval data_arr[data_arr > maxval] = maxval - manual_pitch_arr = data_arr*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + manual_pitch_arr = data_arr * (pitch_range[1] - pitch_range[0]) + pitch_range[0] assert (manual_pitch_arr == pitch_arr).all() # min_max percent - data_arr = np.array([1.1, -0.1, 1, 0, .25, .75]) + data_arr = np.array([1.1, -0.1, 1.0, 0.0, 0.25, 0.75]) pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear', minmax_percent=[20, 80]) - assert (np.isclose(pitch_arr, np.array([500, 400, 500, 400, - 422.22222222, 477.77777778]))).all() + stretch="linear", minmax_percent=[20, 80]) + assert ( + np.isclose(pitch_arr, np.array([500, 400, 500, 400, + 422.22222222, 477.77777778]))).all() # asinh - data_arr = np.array([1, 0, .25, .75]) + data_arr = np.array([1.0, 0.0, 0.25, 0.75]) zero_point = 0.21271901209248895 - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch='asinh') - manual_pitch_arr = np.arcsinh(data_arr*10)/np.arcsinh(10)*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch="asinh") + manual_pitch_arr = np.arcsinh(data_arr * 10) / np.arcsinh(10) * (pitch_range[1] - pitch_range[0]) + pitch_range[0] assert (manual_pitch_arr == pitch_arr).all() # sinh - data_arr = np.array([1, 0, .25, .75]) + data_arr = np.array([1.0, 0.0, 0.25, 0.75]) zero_point = 0.7713965391706435 - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch='sinh') - manual_pitch_arr = np.sinh(data_arr*3)/np.sinh(3)*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch="sinh") + manual_pitch_arr = np.sinh(data_arr * 3) / np.sinh(3) * (pitch_range[1] - pitch_range[0]) + pitch_range[0] assert (manual_pitch_arr == pitch_arr).all() # sqrt - data_arr = np.array([1, 0, .25, .75]) + data_arr = np.array([1.0, 0.0, 0.25, 0.75]) zero_point = 0.25 - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch='sqrt') - manual_pitch_arr = np.sqrt(data_arr)*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch="sqrt") + manual_pitch_arr = np.sqrt(data_arr) * (pitch_range[1] - pitch_range[0]) + pitch_range[0] assert (manual_pitch_arr == pitch_arr).all() # log - data_arr = np.array([1, 0, .25, .75]) + data_arr = np.array([1.0, 0.0, 0.25, 0.75]) zero_point = 0.030638584039112748 - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch='log') - manual_pitch_arr = np.log(1000*data_arr+1)/np.log(1001)*(pitch_range[1]-pitch_range[0]) + pitch_range[0] + pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch="log") + manual_pitch_arr = np.log(1000 * data_arr + 1) / np.log(1001) * (pitch_range[1] - pitch_range[0]) + pitch_range[0] assert (manual_pitch_arr == pitch_arr).all() # Bad stretch with pytest.raises(InvalidInputError): - data_arr = np.array([1, 0, .25, .75]) - data_to_pitch(data_arr, stretch='lin') + data_arr = np.array([1.0, 0.0, 0.25, 0.75]) + data_to_pitch(data_arr, stretch="lin") # Giving both minmax percent and cut - data_arr = np.array([1.1, -0.1, 1, 0, .25, .75]) - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, stretch='linear', minmax_percent=[20, 80]) + data_arr = np.array([1.1, -0.1, 1.0, 0.0, 0.25, 0.75]) + pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, stretch="linear", minmax_percent=[20, 80]) with pytest.warns(InputWarning): - test_arr = data_to_pitch(data_arr, pitch_range, center_pitch, stretch='linear', - minmax_value=[0, 1], minmax_percent=[20, 80]) + test_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, stretch="linear", + minmax_value=[0, 1], minmax_percent=[20, 80]) assert (pitch_arr == test_arr).all() - - - - - diff --git a/docs/conf.py b/docs/conf.py index 7ec0c49..2c432c6 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -33,23 +33,26 @@ try: from sphinx_astropy.conf.v1 import * # noqa except ImportError: - print('ERROR: the documentation requires the sphinx-astropy package to be installed') + print( + 'ERROR: the documentation requires the sphinx-astropy package to be installed' + ) sys.exit(1) # Get configuration information from setup.cfg from configparser import ConfigParser + conf = ConfigParser() -conf.read([os.path.join(os.path.dirname(__file__), '..', 'setup.cfg')]) -setup_cfg = dict(conf.items('metadata')) +conf.read([os.path.join(os.path.dirname(__file__), "..", "setup.cfg")]) +setup_cfg = dict(conf.items("metadata")) # -- General configuration ---------------------------------------------------- # By default, highlight as Python 3. -highlight_language = 'python3' +highlight_language = "python3" # If your documentation needs a minimal Sphinx version, state it here. -#needs_sphinx = '5.0' +# needs_sphinx = '5.0' # To perform a Sphinx version check that needs to be more specific than # major.minor, call `check_sphinx_version("x.y.z")` here. @@ -57,7 +60,7 @@ # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. -#exclude_patterns.append('_templates') +# exclude_patterns.append('_templates') # This is added to the end of RST files - a good place to put substitutions to # be used globally. @@ -67,20 +70,20 @@ # -- Project information ------------------------------------------------------ # This does not *have* to match the package name, but typically does -project = setup_cfg['name'] -author = setup_cfg['author'] -copyright = '{0}, {1}'.format( - datetime.datetime.now().year, setup_cfg['author']) +project = setup_cfg["name"] +author = setup_cfg["author"] +copyright = "{0}, {1}".format( + datetime.datetime.now().year, setup_cfg["author"]) # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. -import_module(setup_cfg['name']) -package = sys.modules[setup_cfg['name']] +import_module(setup_cfg["name"]) +package = sys.modules[setup_cfg["name"]] # The short X.Y version. -version = package.__version__.split('-', 1)[0] +version = package.__version__.split("-", 1)[0] # The full version, including alpha/beta/rc tags. release = package.__version__ @@ -97,7 +100,7 @@ # Add any paths that contain custom themes here, relative to this directory. # To use a different custom theme, add the directory containing the theme. -#html_theme_path = ["_themes",] +# html_theme_path = ["_themes",] # Custome template path, adding custom css and home link templates_path = ["_templates"] @@ -105,25 +108,25 @@ # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. To override the custom theme, set this to the # name of a builtin theme or the name of a custom theme in html_theme_path. -html_theme = 'sphinx_rtd_theme' +html_theme = "sphinx_rtd_theme" def setup_style(app): app.add_stylesheet("astronify.css") -master_doc='contents' -html_extra_path=['index.html', 'CreateWithLight.html'] +master_doc="contents" +html_extra_path=["index.html", "CreateWithLight.html"] # Custom sidebar templates, maps document names to template names. -html_sidebars = { '**': ['globaltoc.html', 'localtoc.html', 'searchbox.html'] } +html_sidebars = { "**": ["globaltoc.html", "localtoc.html", "searchbox.html"] } # The name of an image file (relative to this directory) to place at the top # of the sidebar. -html_logo = '_static/ASTRONIFY_Ball_white.svg' +html_logo = "_static/ASTRONIFY_Ball_white.svg" # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. -html_favicon = '_static/astronify-favicon.png' +html_favicon = "_static/astronify-favicon.png" # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. @@ -131,48 +134,48 @@ def setup_style(app): # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". -html_title = '{0} v{1}'.format(project, release) +html_title = "{0} v{1}".format(project, release) # Output file base name for HTML help builder. -htmlhelp_basename = project + 'doc' +htmlhelp_basename = project + "doc" # Static files to copy after template files -html_static_path = ['_static'] -#html_style = 'astronify.css' +html_static_path = ["_static"] +# html_style = 'astronify.css' -html_css_files = ['astronify.css'] +html_css_files = ["astronify.css"] # -- Options for LaTeX output ------------------------------------------------- # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). -latex_documents = [('index', project + '.tex', project + u' Documentation', - author, 'manual')] +latex_documents = [("index", project + ".tex", project + u" Documentation", + author, "manual")] # -- Options for manual page output ------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). -man_pages = [('index', project.lower(), project + u' Documentation', +man_pages = [("index", project.lower(), project + u" Documentation", [author], 1)] # -- Options for the edit_on_github extension --------------------------------- -if setup_cfg.get('edit_on_github').lower() == 'true': +if setup_cfg.get("edit_on_github").lower() == "true": - extensions += ['sphinx_astropy.ext.edit_on_github'] + extensions += ["sphinx_astropy.ext.edit_on_github"] - edit_on_github_project = setup_cfg['github_project'] + edit_on_github_project = setup_cfg["github_project"] edit_on_github_branch = "main" edit_on_github_source_root = "" edit_on_github_doc_root = "docs" # -- Resolving issue number to links in changelog ----------------------------- -github_issues_url = 'https://github.com/{0}/issues/'.format(setup_cfg['github_project']) +github_issues_url = "https://github.com/{0}/issues/".format(setup_cfg["github_project"]) # -- Turn on nitpicky mode for sphinx (to warn about references not found) ---- # diff --git a/setup.py b/setup.py index 155033f..2925ac5 100755 --- a/setup.py +++ b/setup.py @@ -34,7 +34,7 @@ http://docs.astropy.org/en/latest/development/testguide.html#running-tests """ -if 'test' in sys.argv: +if "test" in sys.argv: print(TEST_HELP) sys.exit(1) @@ -59,7 +59,7 @@ http://docs.astropy.org/en/latest/install.html#builddocs """ -if 'build_docs' in sys.argv or 'build_sphinx' in sys.argv: +if "build_docs" in sys.argv or "build_sphinx" in sys.argv: print(DOCS_HELP) sys.exit(1) @@ -74,5 +74,9 @@ version = '{version}' """.lstrip() -setup(use_scm_version={'write_to': os.path.join('astronify', 'version.py'), - 'write_to_template': VERSION_TEMPLATE}) +setup( + use_scm_version={ + 'write_to': os.path.join('astronify', 'version.py'), + 'write_to_template': VERSION_TEMPLATE + } +) From 2ad1da09ebc7eb75b0195aa371a6eea4d592573c Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 22:17:34 -0500 Subject: [PATCH 70/93] iterating on lynting --- astronify/_astropy_init.py | 4 ++-- astronify/conftest.py | 6 +++--- astronify/series/tests/test_series.py | 10 +++++----- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/astronify/_astropy_init.py b/astronify/_astropy_init.py index 4121e7e..8c1ddc7 100644 --- a/astronify/_astropy_init.py +++ b/astronify/_astropy_init.py @@ -7,7 +7,7 @@ _ASTROPY_SETUP_ except NameError: import builtins - + builtins._ASTROPY_SETUP_ = False try: @@ -21,7 +21,7 @@ # Create the test function for self test from astropy.tests.runner import TestRunner - + test = TestRunner.make_test_runner_in(os.path.dirname(__file__)) test.__test__ = False __all__ += ["test"] diff --git a/astronify/conftest.py b/astronify/conftest.py index 4ced7b8..3a2ee12 100644 --- a/astronify/conftest.py +++ b/astronify/conftest.py @@ -16,7 +16,7 @@ else: try: from pytest_astropy_header.display import PYTEST_HEADER_MODULES, TESTED_VERSIONS - + ASTROPY_HEADER = True except ImportError: ASTROPY_HEADER = False @@ -31,10 +31,10 @@ def pytest_configure(config): # Customize the following lines to add/remove entries from the list of # packages for which version numbers are displayed when running the tests. PYTEST_HEADER_MODULES.pop("Pandas", None) - PYTEST_HEADER_MODULES['scikit-image'] = "skimage" + PYTEST_HEADER_MODULES["scikit-image"] = "skimage" from . import __version__ - + packagename = os.path.basename(os.path.dirname(__file__)) TESTED_VERSIONS[packagename] = __version__ diff --git a/astronify/series/tests/test_series.py b/astronify/series/tests/test_series.py index a4f5df2..fd60083 100644 --- a/astronify/series/tests/test_series.py +++ b/astronify/series/tests/test_series.py @@ -26,18 +26,18 @@ def test_pitchmap(): "center_pitch": 440, "zero_point": "mean", "stretch": "linear", - "invert": True + "invert": True, } assert "center_pitch" in my_pitchmapper.pitch_map_args.keys() assert my_pitchmapper.pitch_map_args["zero_point"] == "mean" - with pytest.warns(InputWarning): # setting with bad arg + with pytest.warns(InputWarning): # setting with bad arg my_pitchmapper.pitch_map_args = { "pitch_range": [100, 10000], "center_pitch": 440, "zero_point": "mean", "stretch": "linear", - "penguin": True + "penguin": True, } assert "penguin" not in my_pitchmapper.pitch_map_args.keys() @@ -46,7 +46,7 @@ def test_pitchmap(): assert isinstance(my_pitchmapper([1, 1, 1, 1]), np.ndarray) # Changing function - def my_map_func(data): # dummy function + def my_map_func(data): # dummy function data = np.array(data) return data / 2 @@ -80,7 +80,7 @@ def test_soniseries(tmpdir): assert soni_obj.data.meta["asf_note_duration"] == soni_obj.note_duration assert soni_obj.data.meta["asf_spacing"] == soni_obj.note_spacing - onset_spacing = soni_obj.data["asf_onsets"][1:]-soni_obj.data["asf_onsets"][:-1] + onset_spacing = soni_obj.data["asf_onsets"][1:] - soni_obj.data["asf_onsets"][:-1] assert (np.isclose(onset_spacing, soni_obj.note_spacing)).all() pitch_min, pitch_max = soni_obj.pitch_mapper.pitch_map_args["pitch_range"] From 4430c8d75ec2456ce6e7ebcfda76428e2c3f3b5b Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 22:27:02 -0500 Subject: [PATCH 71/93] more lynt iterating --- astronify/conftest.py | 1 + astronify/series/tests/test_series.py | 12 ++++++------ astronify/simulator/add_flare_signal.py | 11 +++++++---- astronify/simulator/check_flare_params.py | 18 ++++++++---------- 4 files changed, 22 insertions(+), 20 deletions(-) diff --git a/astronify/conftest.py b/astronify/conftest.py index 3a2ee12..c23b24e 100644 --- a/astronify/conftest.py +++ b/astronify/conftest.py @@ -38,6 +38,7 @@ def pytest_configure(config): packagename = os.path.basename(os.path.dirname(__file__)) TESTED_VERSIONS[packagename] = __version__ + # Uncomment the last two lines in this block to treat all DeprecationWarnings as # exceptions. For Astropy v2.0 or later, there are 2 additional keywords, # as follow (although default should work for most cases). diff --git a/astronify/series/tests/test_series.py b/astronify/series/tests/test_series.py index fd60083..853da66 100644 --- a/astronify/series/tests/test_series.py +++ b/astronify/series/tests/test_series.py @@ -25,7 +25,7 @@ def test_pitchmap(): "pitch_range": [100, 10000], "center_pitch": 440, "zero_point": "mean", - "stretch": "linear", + "stretch": "linear", "invert": True, } assert "center_pitch" in my_pitchmapper.pitch_map_args.keys() @@ -36,21 +36,21 @@ def test_pitchmap(): "pitch_range": [100, 10000], "center_pitch": 440, "zero_point": "mean", - "stretch": "linear", + "stretch": "linear", "penguin": True, } - + assert "penguin" not in my_pitchmapper.pitch_map_args.keys() # Running function assert isinstance(my_pitchmapper([1, 1, 1, 1]), np.ndarray) # Changing function - def my_map_func(data): # dummy function + def my_map_func(data): # dummy function data = np.array(data) return data / 2 - with pytest.warns(InputWarning): # because of different args + with pytest.warns(InputWarning): # because of different args my_pitchmapper.pitch_map_func = my_map_func assert (my_pitchmapper([1, 1]) == [0.5, 0.5]).all() @@ -79,7 +79,7 @@ def test_soniseries(tmpdir): assert soni_obj.data.meta["asf_exposure_time"] == 1 assert soni_obj.data.meta["asf_note_duration"] == soni_obj.note_duration assert soni_obj.data.meta["asf_spacing"] == soni_obj.note_spacing - + onset_spacing = soni_obj.data["asf_onsets"][1:] - soni_obj.data["asf_onsets"][:-1] assert (np.isclose(onset_spacing, soni_obj.note_spacing)).all() diff --git a/astronify/simulator/add_flare_signal.py b/astronify/simulator/add_flare_signal.py index 347be3e..a5fae33 100644 --- a/astronify/simulator/add_flare_signal.py +++ b/astronify/simulator/add_flare_signal.py @@ -78,7 +78,8 @@ def add_flare_signal(fluxes, flare_time, flare_amp, flare_halfwidth): + 1.941 * t12_rise_indices - 0.175 * t12_rise_indices**2.0 - 2.246 * t12_rise_indices**3.0 - - 1.125 * t12_rise_indices**4.0) + - 1.125 * t12_rise_indices**4.0 + ) # Insert these fluxes into the correct location in our light curve. fluxes_to_add[flare_time - flare_halfwidth + 1 : flare_time + 1] = rise_fluxes @@ -96,14 +97,16 @@ def add_flare_signal(fluxes, flare_time, flare_amp, flare_halfwidth): # Generate indices in "t_1/2" units. t12_decay_indices = np.linspace(0.0, n_t12, n_t12 * flare_halfwidth) - + # Compute fluxes for the decay part. - decay_fluxes = (0.6890 * np.exp(-1.600 * t12_decay_indices) + 0.3030 * np.exp(-0.2783 * t12_decay_indices)) + decay_fluxes = 0.6890 * np.exp(-1.600 * t12_decay_indices) + 0.3030 * np.exp( + -0.2783 * t12_decay_indices + ) # Insert these fluxes into the correct location in our light curve. # Note: the above index range is correct, but in Python you need to go one # extra when slicing, hence 6*flare_halfwidth-1+1 = 6*flare_halfwidth... - fluxes_to_add[flare_time: flare_time + n_t12 * flare_halfwidth] = decay_fluxes + fluxes_to_add[flare_time : flare_time + n_t12 * flare_halfwidth] = decay_fluxes # Scale the fluxes to add (which are normalized at this point) by 'flare_amp' fluxes_to_add *= flare_amp diff --git a/astronify/simulator/check_flare_params.py b/astronify/simulator/check_flare_params.py index 1ff1c83..1dba79c 100644 --- a/astronify/simulator/check_flare_params.py +++ b/astronify/simulator/check_flare_params.py @@ -30,9 +30,7 @@ def check_flare_params(n_fluxes, flare_time, flare_amp): " in the simulated light curve." " Number of fluxes = " + str(n_fluxes) - + ", flare time requested is " - + str(flare_time) - + "." + + ", flare time requested is " + str(flare_time) + "." ) # Flare time index must be greater than or equal to zero. @@ -40,13 +38,13 @@ def check_flare_params(n_fluxes, flare_time, flare_amp): raise argparse.ArgumentTypeError( "The flare time at peak flux must be" " greater than or equal to zero, flare" - " time requested is " + - str(flare_time) + "." + " time requested is " + str(flare_time) + "." ) # The flare amplitude must be greater than zero. - if flare_amp <= 0.: - raise argparse.ArgumentTypeError("Flare amplitude must be greater than" - " zero. Requested" - " flare amplitude = " + - str(flare_amp) + ".") + if flare_amp <= 0.0: + raise argparse.ArgumentTypeError( + "Flare amplitude must be greater than" + " zero. Requested" + " flare amplitude = " + str(flare_amp) + "." + ) From d308938f880ef88d7f29c3b6e8b84af53812c5ed Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 22:37:57 -0500 Subject: [PATCH 72/93] lynting iteration --- astronify/series/tests/test_series.py | 4 ++-- astronify/simulator/add_flare_signal.py | 3 +-- astronify/simulator/add_transit_signal.py | 9 ++++----- astronify/simulator/check_flare_params.py | 4 +++- astronify/simulator/check_transit_params.py | 3 +-- astronify/simulator/sim_lc_config.py | 1 - astronify/utils/__init__.py | 4 ++-- astronify/utils/exceptions.py | 2 +- 8 files changed, 14 insertions(+), 16 deletions(-) diff --git a/astronify/series/tests/test_series.py b/astronify/series/tests/test_series.py index 853da66..31e451f 100644 --- a/astronify/series/tests/test_series.py +++ b/astronify/series/tests/test_series.py @@ -31,7 +31,7 @@ def test_pitchmap(): assert "center_pitch" in my_pitchmapper.pitch_map_args.keys() assert my_pitchmapper.pitch_map_args["zero_point"] == "mean" - with pytest.warns(InputWarning): # setting with bad arg + with pytest.warns(InputWarning): # setting with bad arg my_pitchmapper.pitch_map_args = { "pitch_range": [100, 10000], "center_pitch": 440, @@ -50,7 +50,7 @@ def my_map_func(data): # dummy function data = np.array(data) return data / 2 - with pytest.warns(InputWarning): # because of different args + with pytest.warns(InputWarning): # because of different args my_pitchmapper.pitch_map_func = my_map_func assert (my_pitchmapper([1, 1]) == [0.5, 0.5]).all() diff --git a/astronify/simulator/add_flare_signal.py b/astronify/simulator/add_flare_signal.py index a5fae33..9daf461 100644 --- a/astronify/simulator/add_flare_signal.py +++ b/astronify/simulator/add_flare_signal.py @@ -7,7 +7,6 @@ import numpy as np - def add_flare_signal(fluxes, flare_time, flare_amp, flare_halfwidth): """ Model is based on Davenport et al. @@ -102,7 +101,7 @@ def add_flare_signal(fluxes, flare_time, flare_amp, flare_halfwidth): decay_fluxes = 0.6890 * np.exp(-1.600 * t12_decay_indices) + 0.3030 * np.exp( -0.2783 * t12_decay_indices ) - + # Insert these fluxes into the correct location in our light curve. # Note: the above index range is correct, but in Python you need to go one # extra when slicing, hence 6*flare_halfwidth-1+1 = 6*flare_halfwidth... diff --git a/astronify/simulator/add_transit_signal.py b/astronify/simulator/add_transit_signal.py index 2c9cf33..015ff6f 100644 --- a/astronify/simulator/add_transit_signal.py +++ b/astronify/simulator/add_transit_signal.py @@ -9,7 +9,7 @@ def add_transit_signal( - fluxes, transit_depth, transit_period, transit_start, transit_width): + fluxes, transit_depth, transit_period, transit_start, transit_width): """ :param fluxes: Array of fluxes to add the transit signal to. :type fluxes: numpy.ndarray @@ -39,16 +39,15 @@ def add_transit_signal( transit_indexes = np.zeros(n_fluxes) # Get the set of start indexes. - start_indexes = np.arange(transit_start, n_fluxes + 1, transit_period, - dtype=int) + start_indexes = np.arange(transit_start, n_fluxes + 1, transit_period, dtype=int) # Set transit indexes to 1. for st_ind in start_indexes: if st_ind + transit_width < fluxes.size: - transit_indexes[st_ind : st_ind+transit_width + 1] = 1 + transit_indexes[st_ind : st_ind + transit_width + 1] = 1 else: transit_indexes[st_ind:] = 1 # Set the flux values of the transit indexes to the transit depth. - fluxes[np.where(transit_indexes == 1)] *= (1.0 - (transit_depth / 100.0)) + fluxes[np.where(transit_indexes == 1)] *= 1.0 - (transit_depth / 100.0) return fluxes diff --git a/astronify/simulator/check_flare_params.py b/astronify/simulator/check_flare_params.py index 1dba79c..e719411 100644 --- a/astronify/simulator/check_flare_params.py +++ b/astronify/simulator/check_flare_params.py @@ -30,7 +30,9 @@ def check_flare_params(n_fluxes, flare_time, flare_amp): " in the simulated light curve." " Number of fluxes = " + str(n_fluxes) - + ", flare time requested is " + str(flare_time) + "." + + ", flare time requested is " + + str(flare_time) + + "." ) # Flare time index must be greater than or equal to zero. diff --git a/astronify/simulator/check_transit_params.py b/astronify/simulator/check_transit_params.py index 3afc087..61d19d5 100644 --- a/astronify/simulator/check_transit_params.py +++ b/astronify/simulator/check_transit_params.py @@ -46,8 +46,7 @@ def check_transit_params(n_fluxes, transit_period, transit_start, transit_width) raise argparse.ArgumentTypeError( "The transit start must be greater than" " or equal to zero, start" - " index requested is " + - str(transit_start) + "." + " index requested is " + str(transit_start) + "." ) # The transit period must be greater than the transit duration (width). diff --git a/astronify/simulator/sim_lc_config.py b/astronify/simulator/sim_lc_config.py index 2522dd2..d766de3 100644 --- a/astronify/simulator/sim_lc_config.py +++ b/astronify/simulator/sim_lc_config.py @@ -1,4 +1,3 @@ - class SimLcConfig: """ Class that holds the default configuration parameters diff --git a/astronify/utils/__init__.py b/astronify/utils/__init__.py index 59f574b..eb0f7e9 100644 --- a/astronify/utils/__init__.py +++ b/astronify/utils/__init__.py @@ -4,6 +4,6 @@ # functions. -from .pitch_mapping import * # noqa: F403 +from .pitch_mapping import * # noqa: F403 -__all__ = ["data_to_pitch"] # noqa: F405 +__all__ = ["data_to_pitch"] # noqa: F405 diff --git a/astronify/utils/exceptions.py b/astronify/utils/exceptions.py index 4a64880..e6a81d9 100644 --- a/astronify/utils/exceptions.py +++ b/astronify/utils/exceptions.py @@ -9,7 +9,7 @@ class InvalidInputError(Exception): """ - Exception to be issued when user input is incorrect in a + Exception to be issued when user input is incorrect in a way that prevents the function from running. """ From a79ef4aa98b501c13848ad238bc1231116f8f3dd Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 22:48:34 -0500 Subject: [PATCH 73/93] lynting iteration --- astronify/simulator/add_flare_signal.py | 1 + astronify/simulator/add_transit_signal.py | 3 +- astronify/simulator/sim_lc_setup_args.py | 38 +++++++++++------------ astronify/utils/pitch_mapping.py | 19 +++++++----- 4 files changed, 34 insertions(+), 27 deletions(-) diff --git a/astronify/simulator/add_flare_signal.py b/astronify/simulator/add_flare_signal.py index 9daf461..da37fd3 100644 --- a/astronify/simulator/add_flare_signal.py +++ b/astronify/simulator/add_flare_signal.py @@ -7,6 +7,7 @@ import numpy as np + def add_flare_signal(fluxes, flare_time, flare_amp, flare_halfwidth): """ Model is based on Davenport et al. diff --git a/astronify/simulator/add_transit_signal.py b/astronify/simulator/add_transit_signal.py index 015ff6f..735a5c9 100644 --- a/astronify/simulator/add_transit_signal.py +++ b/astronify/simulator/add_transit_signal.py @@ -9,7 +9,8 @@ def add_transit_signal( - fluxes, transit_depth, transit_period, transit_start, transit_width): + fluxes, transit_depth, transit_period, transit_start, transit_width + ): """ :param fluxes: Array of fluxes to add the transit signal to. :type fluxes: numpy.ndarray diff --git a/astronify/simulator/sim_lc_setup_args.py b/astronify/simulator/sim_lc_setup_args.py index 0e8b565..d4bea98 100644 --- a/astronify/simulator/sim_lc_setup_args.py +++ b/astronify/simulator/sim_lc_setup_args.py @@ -27,7 +27,8 @@ def sim_lc_setup_args(): action="store", type=str, help="Type of light curve to create.", - choices=["flat", "transit", "sine", "flare"]) + choices=["flat", "transit", "sine", "flare"], + ) parser.add_argument( "-o", @@ -35,7 +36,7 @@ def sim_lc_setup_args(): action="store", type=str, help="Name of output FITS file to create.", - default=sim_lc_config.sim_lc_ofile + default=sim_lc_config.sim_lc_ofile, ) parser.add_argument( @@ -46,7 +47,7 @@ def sim_lc_setup_args(): dest="lc_length", help="Total number of flux" " measurements in the light curve. Default =" - " %(default)s." + " %(default)s.", ) parser.add_argument( @@ -59,7 +60,7 @@ def sim_lc_setup_args(): " measurements in the light curve, specified by the" " standard deviation of the normal distribution to draw" " from. Set to zero for no noise. Default =" - " %(default)s." + " %(default)s.", ) parser.add_argument( @@ -69,7 +70,7 @@ def sim_lc_setup_args(): default=sim_lc_config.sim_lc_vizualize, help="If True, a plot of the light curve" " that is generated will be plot on the screen. Default" - " = %(default)s." + " = %(default)s.", ) parser.add_argument( @@ -81,12 +82,13 @@ def sim_lc_setup_args(): help="Baseline (unitless) flux height" " of the light curve. Used to test sonification of" " sources with different total brightness. Default =" - " %(default)s." + " %(default)s.", ) # Transit-related parameters here. transit_group = parser.add_argument_group( - "transit", "Parameters for transit signals.") + "transit", "Parameters for transit signals." + ) transit_group.add_argument( "--transit_depth", @@ -96,7 +98,7 @@ def sim_lc_setup_args(): help="Depth of the transit" " signal specified as a percent, e.g., set to" " 10.0 for a 10%% depth transit. Default =" - " %(default)s." + " %(default)s.", ) transit_group.add_argument( @@ -107,7 +109,7 @@ def sim_lc_setup_args(): help="Period of the" " transit signal, specified as the number of" " fluxes (bins) between the start of each event." - " Default = %(default)s." + " Default = %(default)s.", ) transit_group.add_argument( @@ -118,7 +120,7 @@ def sim_lc_setup_args(): help="Start of the first" " transit, specified as the index of the" " flux (bin) to use as the start of the first" - " transit event. Default = %(default)s." + " transit event. Default = %(default)s.", ) transit_group.add_argument( @@ -129,7 +131,7 @@ def sim_lc_setup_args(): help="Width of the" " transit signal, specified as the number of" " fluxes (bins) between the start and end of each" - " event. Default = %(default)s." + " event. Default = %(default)s.", ) # Sinusoidal-related parameters here. @@ -142,8 +144,7 @@ def sim_lc_setup_args(): type=float, default=sim_lc_config.sim_lc_sine_amp, dest="sine_amp", - help="Amplitude of the sinusoidal signal to add. Default =" - " %(default)s." + help="Amplitude of the sinusoidal signal to add. Default = %(default)s." ) sine_group.add_argument( @@ -152,12 +153,11 @@ def sim_lc_setup_args(): default=sim_lc_config.sim_lc_sine_period, dest="sine_period", help="Period of the sinusoidal signal, specified in the (unitless)" - " time axis (flux bins). Default = %(default)s." + " time axis (flux bins). Default = %(default)s.", ) # Flare-related parameters here. - flare_group = parser.add_argument_group( - "flare", "Parameters for adding flares.") + flare_group = parser.add_argument_group("flare", "Parameters for adding flares.") flare_group.add_argument( "--flare_time", @@ -167,7 +167,7 @@ def sim_lc_setup_args(): help="Time corresponding to" " the maximum flux of the flare, specified" " as the index of the flux (bin) to use as" - " the peak time. Default = %(default)s." + " the peak time. Default = %(default)s.", ) flare_group.add_argument( @@ -175,7 +175,7 @@ def sim_lc_setup_args(): type=float, default=sim_lc_config.sim_lc_flare_amp, dest="flare_amp", - help="Amplitude (maximum flux) of the flare to add. Default = %(default)s." + help="Amplitude (maximum flux) of the flare to add. Default = %(default)s.", ) flare_group.add_argument( @@ -185,7 +185,7 @@ def sim_lc_setup_args(): help="The flare" " half-width (measured in indices) that" " corresponds to 't_1/2' in the Davenport et al." - " flare template." + " flare template.", ) return parser diff --git a/astronify/utils/pitch_mapping.py b/astronify/utils/pitch_mapping.py index 43ba2cf..f19c8ab 100644 --- a/astronify/utils/pitch_mapping.py +++ b/astronify/utils/pitch_mapping.py @@ -18,7 +18,7 @@ LinearStretch, MinMaxInterval, ManualInterval, - AsymmetricPercentileInterval + AsymmetricPercentileInterval, ) from .exceptions import InputWarning, InvalidInputError @@ -34,7 +34,7 @@ def data_to_pitch( stretch='linear', minmax_percent=None, minmax_value=None, - invert=False + invert=False, ): """ Map data array to audible pitches in the given range, and apply stretch and scaling @@ -85,7 +85,7 @@ def data_to_pitch( if center_pitch <= pitch_range[0] or center_pitch >= pitch_range[1]: warnings.warn( "Given center pitch is outside the pitch range, defaulting to the mean.", - InputWarning + InputWarning, ) center_pitch = np.mean(pitch_range) @@ -117,7 +117,7 @@ def data_to_pitch( if minmax_value is not None: warnings.warn( "Both minmax_percent and minmax_value are set, minmax_value will be ignored.", - InputWarning + InputWarning, ) elif minmax_value is not None: transform += ManualInterval(*minmax_value) @@ -144,9 +144,14 @@ def data_to_pitch( zero_point = 1e-6 if ( - (1 / zero_point) * (center_pitch - pitch_range[0]) + pitch_range[0]) <= pitch_range[1]: - pitch_array = (pitch_array / zero_point) * (center_pitch - pitch_range[0]) + pitch_range[0] + (1 / zero_point) * (center_pitch - pitch_range[0]) + pitch_range[0] + ) <= pitch_range[1]: + pitch_array = (pitch_array / zero_point) * ( + center_pitch - pitch_range[0] + ) + pitch_range[0] else: - pitch_array = (((pitch_array - zero_point) / (1 - zero_point)) * (pitch_range[1] - center_pitch) + center_pitch) + pitch_array = ((pitch_array - zero_point) / (1 - zero_point)) * ( + pitch_range[1] - center_pitch + ) + center_pitch return pitch_array From 0282c6fcd1cde067c0eadfd1ec8e4f022bf01f96 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 23:12:25 -0500 Subject: [PATCH 74/93] lynting series.py --- astronify/series/series.py | 522 +++++++++++++++++++------------------ 1 file changed, 267 insertions(+), 255 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 01e8866..0bb07e6 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -49,7 +49,7 @@ def __init__(self, pitch_func=data_to_pitch, **pitch_args): "pitch_range": [100, 10000], "center_pitch": 440, "zero_point": "median", - "stretch": "linear" + "stretch": "linear", } self.pitch_map_func = pitch_func @@ -113,6 +113,7 @@ def pitch_map_args(self, new_args): self._pitch_map_args = new_args self._check_func_args() + class SoniSeries: def __init__(self, data, time_col="time", val_col="flux", preview_type="scan"): @@ -186,7 +187,7 @@ def time_col(self): @time_col.setter def time_col(self, value): - assert isinstance(value, str), 'Time column name must be a string.' + assert isinstance(value, str), "Time column name must be a string." self._time_col = value @property @@ -254,7 +255,9 @@ def sonify(self): data["asf_pitch"] = self.pitch_mapper(data[self.val_col]) data["asf_onsets"] = [ - x for x in (data[self.time_col] - data[self.time_col][0]) / exptime*self.note_spacing + x for x in (data[self.time_col] - data[self.time_col][0]) + / exptime + * self.note_spacing ] def play(self): @@ -282,13 +285,14 @@ def play(self): (0.01, 1), (duration - 0.1, 1), (duration - 0.05, 0.5), - (duration - 0.005, 0) + (duration - 0.005, 0), ], - mul=[self.gain for i in range(len(pitches))]).play( - delay=list(delays), dur=duration) + mul=[self.gain for i in range(len(pitches))], + ).play(delay=list(delays), dur=duration) self.streams = pyo.Sine(list(pitches), 0, env).out( - delay=list(delays), dur=duration) + delay=list(delays), dur=duration + ) def stop(self): """ @@ -326,266 +330,274 @@ def write(self, filepath): (0.1, 1), (duration - 0.1, 1), (duration - 0.05, 0.5), - (duration - 0.005, 0)], - mul=[self.gain for i in range(len(pitches))]).play( - delay=list(delays), dur=duration) - sine = pyo.Sine(list(pitches), 0, env).out(delay=list(delays), dur=duration) # noqa: F841 + (duration - 0.005, 0), + ], + mul=[self.gain for i in range(len(pitches))], + ).play(delay=list(delays), dur=duration) + sine = pyo.Sine(list(pitches), 0, env).out( + delay=list(delays), dur=duration + ) # noqa: F841 self.server.start() # Clean up self.server.shutdown() self.server.reinit(audio="portaudio") + class SeriesPreviews: + """ + Previews (or snapshots) of 1d spectra by binning the data into five equal pieces by assigning a sound to each piece. + """ + + def __init__(self, soniseries): + # Allows access to SoniSeries class methods and variables + self._soniseries = soniseries + # Define the frequencies to use for each section. + self.pitch_values = [500] * 5 + if self._soniseries.preview_type == "ensemble": + self.pitch_values = [300, 400, 500, 600, 700] + # TODO: Make robust + self.n_pitch_values = len(self.pitch_values) + # Amplitudes will be stored as a % between 0-1. + self.amplitudes = np.zeros(self.n_pitch_values) + # Tremolo values will be stored as a number, typically ranging from some small number + # (avoid 0.0, e.g., 0.1) through ~10. + self.tremolo_vals = np.zeros(self.n_pitch_values) + + def area_of_pieces(self, ydata_bins, xdata_bins): + """ + Given pieces of a series of 1D data, calculate the area-under-the-curve of each piece + such that the total area of all the pieces equals the total area of the entire curve. + """ + area_vals = [] + for idx, (ydata_bin, xdata_bin) in enumerate(zip(ydata_bins, xdata_bins)): + if idx < len(ydata_bins) - 1: + # Then you need to include the first (x,y) point from the NEXT bin as well + # when calculating the trapezoidal area so the pieces all add up to the total. + list(ydata_bin).append(ydata_bins[idx + 1][0]) + list(xdata_bin).append(xdata_bins[idx + 1][0]) + + # Taking the absolute value so that emission lines and absorption lines + # have the same amplitude + area_vals.append(np.abs(np.trapz(ydata_bin, xdata_bin))) + return area_vals + + def plot_preview(self, xdata_bin_ranges): + plt.plot( + self._soniseries.data[self._soniseries.time_col], + self._soniseries.data[self._soniseries.val_col], + color="k" + ) + + plt.axvspan( + xdata_bin_ranges[0][0], + xdata_bin_ranges[0][1], + color="royalblue", + alpha=0.5, + lw=0 + ) + + plt.axvspan( + xdata_bin_ranges[1][0], + xdata_bin_ranges[1][1], + color="green", + alpha=0.5, + lw=0 + ) + + plt.axvspan( + xdata_bin_ranges[2][0], + xdata_bin_ranges[2][1], + color="yellow", + alpha=0.5, + lw=0 + ) + + plt.axvspan( + xdata_bin_ranges[3][0], + xdata_bin_ranges[3][1], + color="orange", + alpha=0.5, + lw=0) + + plt.axvspan( + xdata_bin_ranges[4][0], + xdata_bin_ranges[4][1], + color="red", + alpha=0.5, + lw=0) + + plt.show() + + def sonify_preview(self, plotting=True, verbose=False): + """ + Make a "preview-style" sonification. The data is split into even pieces. Each piece + gets assigned a specific frequency. The amplitude is defined by the area under the curve + in this piece, normalized by the total area under the curve. The tremolo is defined + by the standard deviation of data in this piece, normalized by the maximum standard + deviation across all pieces. """ - Previews (or snapshots) of 1d spectra by binning the data into five equal pieces by assigning a sound to each piece. + # Get a copy of the 'y' and 'x' data. + ydata = np.asarray(self._soniseries.data[self._soniseries.val_col]) + xdata = np.asarray(self._soniseries.data[self._soniseries.time_col]) + + # Normalize the y-data by the maximum to constrain values from 0-1. + ydata_norm = ydata / max(ydata) + + # Split the data into `n_pitch_values` equal-sized pieces. + bin_size = int(np.round(len(xdata) // self.n_pitch_values, 1)) + # Split the y-values into pieces. + ydata_bins = [ydata_norm[i : i+bin_size] for i in range(0, len(ydata_norm), bin_size)] + # Split the x-values into pieces. + xdata_bins = [xdata[i : i + bin_size] for i in range(0, len(xdata), bin_size)] + + # Calculate the total area under the curve, used to normalize the areas in each piece. + total_area = np.trapz(ydata_norm, xdata) + + # Loop through each piece and calculate the standard deviation of the y-data + # and the area under the curve in each piece. + std_vals, xdata_bin_ranges = [], [] + for xdata_bin, ydata_bin in zip(xdata_bins, ydata_bins): + + xdata_bin_ranges.append((min(xdata_bin), max(xdata_bin))) + # Calculate standard deviation error and add to the list. + _, _, _, _, std_err = stats.linregress(xdata_bin, ydata_bin) + std_vals.append(std_err) + + # Plot the spectra and ranges if in troubleshooting mode + if plotting: + self.plot_preview(xdata_bin_ranges) + + # Calculate the area under the curve for each piece. + area_vals = self.area_of_pieces(ydata_bins, xdata_bins) + + # Normalize the standard deviations in each piece by this factor. + std_dev_norm = max(std_vals) + + # Set the amplitude of each pitch to the area under the curve normalized by the total + # area. + self.amplitudes = np.asarray(area_vals) / total_area + + if std_dev_norm == 0.0: std_dev_norm = 1.0 + + # Set the tremolo values based on the standard deviation of the piece normalized by the + # `std_dev_norm` factor. + + # TODO: Might be worth trying a different way of calculating the tremolo values other + # than the normalized standard dev. Maybe using RMS vals? + # To more accurately represent all forms of data. + + # The final calculated tremolo values are multiplied by a factor of 10 for auditory + # purposes + self.tremolo_vals = (np.asarray(std_vals) / std_dev_norm) * 10 + + # Constraint added to keep tremolo values at or below 15, otherwise oscillations are + # more difficult to hear + # self.tremolo_vals[self.tremolo_vals > 15] = 15 + + if verbose: + print("Total Expected area = {0:0f}".format(total_area)) + print(" ") + print("Area Values = ", np.asarray(area_vals)) + print(" ") + # print("Total Calculated area = {0:0f}".format(np.sum(str(area_vals).split(" ")))) + print(" ") + print("Amplitudes = ", self.amplitudes) + print(" ") + print("Standard Dev. Error Vals = ", np.asarray(std_vals)) + print(" ") + print("Standard Dev. Error MAX = ", std_dev_norm) + print(" ") + print("Tremolo Vals (x10) = ", self.tremolo_vals) + + def play_preview(self): + """ Play the sound of a "preview-style" sonification. + + The assigned pitch for each section of the spectra will begin + to play, with the calculated amplitude and frequency, one + at a time until all pitches are playing together for the full + audio preview of the spectra. """ - def __init__(self, soniseries): - # Allows access to SoniSeries class methods and variables - self._soniseries = soniseries - # Define the frequencies to use for each section. - self.pitch_values = [500] * 5 - if self._soniseries.preview_type == "ensemble": - self.pitch_values = [300, 400, 500, 600, 700] - # TODO: Make robust - self.n_pitch_values = len(self.pitch_values) - # Amplitudes will be stored as a % between 0-1. - self.amplitudes = np.zeros(self.n_pitch_values) - # Tremolo values will be stored as a number, typically ranging from some small number - # (avoid 0.0, e.g., 0.1) through ~10. - self.tremolo_vals = np.zeros(self.n_pitch_values) - - def area_of_pieces(self, ydata_bins, xdata_bins): - """ - Given pieces of a series of 1D data, calculate the area-under-the-curve of each piece - such that the total area of all the pieces equals the total area of the entire curve. - """ - area_vals = [] - for idx, (ydata_bin, xdata_bin) in enumerate(zip(ydata_bins, xdata_bins)): - if idx < len(ydata_bins) - 1: - # Then you need to include the first (x,y) point from the NEXT bin as well - # when calculating the trapezoidal area so the pieces all add up to the total. - list(ydata_bin).append(ydata_bins[idx + 1][0]) - list(xdata_bin).append(xdata_bins[idx + 1][0]) - - # Taking the absolute value so that emission lines and absorption lines - # have the same amplitude - area_vals.append(np.abs(np.trapz(ydata_bin, xdata_bin))) - return area_vals - - def plot_preview(self, xdata_bin_ranges): - plt.plot( - self._soniseries.data[self._soniseries.time_col], - self._soniseries.data[self._soniseries.val_col], - color="k" - ) - - plt.axvspan( - xdata_bin_ranges[0][0], - xdata_bin_ranges[0][1], - color="royalblue", - alpha=0.5, - lw=0 - ) - plt.axvspan( - xdata_bin_ranges[1][0], - xdata_bin_ranges[1][1], - color="green", - alpha=0.5, - lw=0 - ) - plt.axvspan( - xdata_bin_ranges[2][0], - xdata_bin_ranges[2][1], - color="yellow", - alpha=0.5, - lw=0 - ) - plt.axvspan( - xdata_bin_ranges[3][0], - xdata_bin_ranges[3][1], - color="orange", - alpha=0.5, - lw=0) - plt.axvspan( - xdata_bin_ranges[4][0], - xdata_bin_ranges[4][1], - color="red", - alpha=0.5, - lw=0) - - plt.show() - - def sonify_preview(self, plotting=True, verbose=False): - """ - Make a "preview-style" sonification. The data is split into even pieces. Each piece - gets assigned a specific frequency. The amplitude is defined by the area under the curve - in this piece, normalized by the total area under the curve. The tremolo is defined - by the standard deviation of data in this piece, normalized by the maximum standard - deviation across all pieces. - """ - # Get a copy of the 'y' and 'x' data. - ydata = np.asarray(self._soniseries.data[self._soniseries.val_col]) - xdata = np.asarray(self._soniseries.data[self._soniseries.time_col]) - - # Normalize the y-data by the maximum to constrain values from 0-1. - ydata_norm = ydata / max(ydata) - - # Split the data into `n_pitch_values` equal-sized pieces. - bin_size = int(np.round(len(xdata) // self.n_pitch_values, 1)) - # Split the y-values into pieces. - ydata_bins = [ydata_norm[i : i+bin_size] for i in range(0, len(ydata_norm), bin_size)] - # Split the x-values into pieces. - xdata_bins = [xdata[i : i + bin_size] for i in range(0, len(xdata), bin_size)] - - # Calculate the total area under the curve, used to normalize the areas in each piece. - total_area = np.trapz(ydata_norm, xdata) - - # Loop through each piece and calculate the standard deviation of the y-data - # and the area under the curve in each piece. - std_vals, xdata_bin_ranges = [], [] - for xdata_bin, ydata_bin in zip(xdata_bins, ydata_bins): - - xdata_bin_ranges.append((min(xdata_bin), max(xdata_bin))) - # Calculate standard deviation error and add to the list. - _, _, _, _, std_err = stats.linregress(xdata_bin, ydata_bin) - std_vals.append(std_err) - - # Plot the spectra and ranges if in troubleshooting mode - if plotting: - self.plot_preview(xdata_bin_ranges) - - # Calculate the area under the curve for each piece. - area_vals = self.area_of_pieces(ydata_bins, xdata_bins) - - # Normalize the standard deviations in each piece by this factor. - std_dev_norm = max(std_vals) - - # Set the amplitude of each pitch to the area under the curve normalized by the total - # area. - self.amplitudes = np.asarray(area_vals) / total_area - - if std_dev_norm == 0.0: std_dev_norm = 1.0 - - # Set the tremolo values based on the standard deviation of the piece normalized by the - # `std_dev_norm` factor. - - # TODO: Might be worth trying a different way of calculating the tremolo values other - # than the normalized standard dev. Maybe using RMS vals? - # To more accurately represent all forms of data. - - # The final calculated tremolo values are multiplied by a factor of 10 for auditory - # purposes - self.tremolo_vals = (np.asarray(std_vals) / std_dev_norm) * 10 - - # Constraint added to keep tremolo values at or below 15, otherwise oscillations are - # more difficult to hear - # self.tremolo_vals[self.tremolo_vals > 15] = 15 - - if verbose: - print("Total Expected area = {0:0f}".format(total_area)) - print(" ") - print("Area Values = ", np.asarray(area_vals)) - print(" ") - # print("Total Calculated area = {0:0f}".format(np.sum(str(area_vals).split(" ")))) - print(" ") - print("Amplitudes = ", self.amplitudes) - print(" ") - print("Standard Dev. Error Vals = ", np.asarray(std_vals)) - print(" ") - print("Standard Dev. Error MAX = ", std_dev_norm) - print(" ") - print("Tremolo Vals (x10) = ", self.tremolo_vals) - - def play_preview(self): - """ Play the sound of a "preview-style" sonification. - - The assigned pitch for each section of the spectra will begin - to play, with the calculated amplitude and frequency, one - at a time until all pitches are playing together for the full - audio preview of the spectra. - """ - - if self._soniseries.server.getIsBooted(): - self._soniseries.server.shutdown() - - self._soniseries.server.boot() - self._soniseries.server.start() - - # TODO: Generalize the self.delays list - # `step` must go into `stop` 5 times, since we have 5 pitches - self.delays = [0.0, 2.0, 4.0, 6.0, 8.0] - - # `total_duration` is in seconds - self.total_duration = 8.0 - - self.amplitudes = [amp / max(self.amplitudes) for amp in self.amplitudes] - - a = pyo.Phasor(self.pitch_values[0], mul=np.pi * 2) - b = pyo.Phasor(self.pitch_values[1], mul=np.pi * 2) - c = pyo.Phasor(self.pitch_values[2], mul=np.pi * 2) - d = pyo.Phasor(self.pitch_values[3], mul=np.pi * 2) - e = pyo.Phasor(self.pitch_values[4], mul=np.pi * 2) - - - # TODO: Make everything below iterable to it's cleaner and takes up less lines - lfo1 = ( - pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0]), 0) - if self.tremolo_vals[0] > 0 - else pyo.Cos(a, mul=float(self.amplitudes[0])) - ) - lfo2 = ( - pyo.Sine(float(self.tremolo_vals[1]), 0, float(self.amplitudes[1]), 0) - if self.tremolo_vals[1] > 0 - else pyo.Cos(b, mul=float(self.amplitudes[1])) - ) - lfo3 = ( - pyo.Sine(float(self.tremolo_vals[2]), 0, float(self.amplitudes[2]), 0) - if self.tremolo_vals[2] > 0 - else pyo.Cos(c, mul=float(self.amplitudes[2])) - ) - lfo4 = ( - pyo.Sine(float(self.tremolo_vals[3]), 0, float(self.amplitudes[3]), 0) - if self.tremolo_vals[3] > 0 - else pyo.Cos(d, mul=float(self.amplitudes[3])) - ) - lfo5 = ( - pyo.Sine(float(self.tremolo_vals[4]), 0, float(self.amplitudes[4]), 0) - if self.tremolo_vals[4] > 0 - else pyo.Cos(e, mul=float(self.amplitudes[4])) - ) - - self.stream1 = pyo.Sine( + if self._soniseries.server.getIsBooted(): + self._soniseries.server.shutdown() + + self._soniseries.server.boot() + self._soniseries.server.start() + + # TODO: Generalize the self.delays list + # `step` must go into `stop` 5 times, since we have 5 pitches + self.delays = [0.0, 2.0, 4.0, 6.0, 8.0] + + # `total_duration` is in seconds + self.total_duration = 8.0 + + self.amplitudes = [amp / max(self.amplitudes) for amp in self.amplitudes] + + a = pyo.Phasor(self.pitch_values[0], mul=np.pi * 2) + b = pyo.Phasor(self.pitch_values[1], mul=np.pi * 2) + c = pyo.Phasor(self.pitch_values[2], mul=np.pi * 2) + d = pyo.Phasor(self.pitch_values[3], mul=np.pi * 2) + e = pyo.Phasor(self.pitch_values[4], mul=np.pi * 2) + + + # TODO: Make everything below iterable to it's cleaner and takes up less lines + lfo1 = ( + pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0]), 0) + if self.tremolo_vals[0] > 0 + else pyo.Cos(a, mul=float(self.amplitudes[0])) + ) + lfo2 = ( + pyo.Sine(float(self.tremolo_vals[1]), 0, float(self.amplitudes[1]), 0) + if self.tremolo_vals[1] > 0 + else pyo.Cos(b, mul=float(self.amplitudes[1])) + ) + lfo3 = ( + pyo.Sine(float(self.tremolo_vals[2]), 0, float(self.amplitudes[2]), 0) + if self.tremolo_vals[2] > 0 + else pyo.Cos(c, mul=float(self.amplitudes[2])) + ) + lfo4 = ( + pyo.Sine(float(self.tremolo_vals[3]), 0, float(self.amplitudes[3]), 0) + if self.tremolo_vals[3] > 0 + else pyo.Cos(d, mul=float(self.amplitudes[3])) + ) + lfo5 = ( + pyo.Sine(float(self.tremolo_vals[4]), 0, float(self.amplitudes[4]), 0) + if self.tremolo_vals[4] > 0 + else pyo.Cos(e, mul=float(self.amplitudes[4])) + ) + + self.stream1 = pyo.Sine( + freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1 + ).out(delay=self.delays[0], dur=2.0) + self.stream2 = pyo.Sine( + freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2 + ).out(delay=self.delays[1], dur=2.0) + self.stream3 = pyo.Sine( + freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3 + ).out(delay=self.delays[2], dur=2.0) + self.stream4 = pyo.Sine( + freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4 + ).out(delay=self.delays[3], dur=2.0) + self.stream5 = pyo.Sine( + freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5 + ).out(delay=self.delays[4], dur=2.0) + + # All together, if in ensemble mode. + if self._soniseries.preview_type == "ensemble": + self.stream6 = pyo.Sine( freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1 - ).out(delay=self.delays[0], dur=2.0) - self.stream2 = pyo.Sine( + ).out(delay=10, dur=4) + self.stream7 = pyo.Sine( freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2 - ).out(delay=self.delays[1], dur=2.0) - self.stream3 = pyo.Sine( + ).out(delay=10, dur=4) + self.stream8 = pyo.Sine( freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3 - ).out(delay=self.delays[2], dur=2.0) - self.stream4 = pyo.Sine( + ).out(delay=10, dur=4) + self.stream9 = pyo.Sine( freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4 - ).out(delay=self.delays[3], dur=2.0) - self.stream5 = pyo.Sine( + ).out(delay=10, dur=4) + self.stream10 = pyo.Sine( freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5 - ).out(delay=self.delays[4], dur=2.0) - - # All together, if in ensemble mode. - if self._soniseries.preview_type == "ensemble": - self.stream6 = pyo.Sine( - freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1 - ).out(delay=10, dur=4) - self.stream7 = pyo.Sine( - freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2 - ).out(delay=10, dur=4) - self.stream8 = pyo.Sine( - freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3 - ).out(delay=10, dur=4) - self.stream9 = pyo.Sine( - freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4 - ).out(delay=10, dur=4) - self.stream10 = pyo.Sine( - freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5 - ).out(delay=10, dur=4) + ).out(delay=10, dur=4) From 0e1397f334eeba1dede3fb02b167e506e7bc177c Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 23:17:43 -0500 Subject: [PATCH 75/93] lynting series.py --- astronify/series/series.py | 51 +++++++++++++++++++++----------------- 1 file changed, 28 insertions(+), 23 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 0bb07e6..6fd84ce 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -255,7 +255,8 @@ def sonify(self): data["asf_pitch"] = self.pitch_mapper(data[self.val_col]) data["asf_onsets"] = [ - x for x in (data[self.time_col] - data[self.time_col][0]) + x + for x in (data[self.time_col] - data[self.time_col][0]) / exptime * self.note_spacing ] @@ -288,7 +289,7 @@ def play(self): (duration - 0.005, 0), ], mul=[self.gain for i in range(len(pitches))], - ).play(delay=list(delays), dur=duration) + ).play(delay=list(delays), dur=duration) self.streams = pyo.Sine(list(pitches), 0, env).out( delay=list(delays), dur=duration @@ -336,7 +337,7 @@ def write(self, filepath): ).play(delay=list(delays), dur=duration) sine = pyo.Sine(list(pitches), 0, env).out( delay=list(delays), dur=duration - ) # noqa: F841 + ) # noqa: F841 self.server.start() # Clean up @@ -386,7 +387,7 @@ def plot_preview(self, xdata_bin_ranges): plt.plot( self._soniseries.data[self._soniseries.time_col], self._soniseries.data[self._soniseries.val_col], - color="k" + color="k", ) plt.axvspan( @@ -394,7 +395,7 @@ def plot_preview(self, xdata_bin_ranges): xdata_bin_ranges[0][1], color="royalblue", alpha=0.5, - lw=0 + lw=0, ) plt.axvspan( @@ -402,7 +403,7 @@ def plot_preview(self, xdata_bin_ranges): xdata_bin_ranges[1][1], color="green", alpha=0.5, - lw=0 + lw=0, ) plt.axvspan( @@ -410,7 +411,7 @@ def plot_preview(self, xdata_bin_ranges): xdata_bin_ranges[2][1], color="yellow", alpha=0.5, - lw=0 + lw=0, ) plt.axvspan( @@ -418,14 +419,16 @@ def plot_preview(self, xdata_bin_ranges): xdata_bin_ranges[3][1], color="orange", alpha=0.5, - lw=0) + lw=0, + ) plt.axvspan( xdata_bin_ranges[4][0], xdata_bin_ranges[4][1], color="red", alpha=0.5, - lw=0) + lw=0, + ) plt.show() @@ -447,7 +450,9 @@ def sonify_preview(self, plotting=True, verbose=False): # Split the data into `n_pitch_values` equal-sized pieces. bin_size = int(np.round(len(xdata) // self.n_pitch_values, 1)) # Split the y-values into pieces. - ydata_bins = [ydata_norm[i : i+bin_size] for i in range(0, len(ydata_norm), bin_size)] + ydata_bins = [ + ydata_norm[i : i + bin_size] for i in range(0, len(ydata_norm), bin_size) + ] # Split the x-values into pieces. xdata_bins = [xdata[i : i + bin_size] for i in range(0, len(xdata), bin_size)] @@ -478,7 +483,8 @@ def sonify_preview(self, plotting=True, verbose=False): # area. self.amplitudes = np.asarray(area_vals) / total_area - if std_dev_norm == 0.0: std_dev_norm = 1.0 + if std_dev_norm == 0.0: + std_dev_norm = 1.0 # Set the tremolo values based on the standard deviation of the piece normalized by the # `std_dev_norm` factor. @@ -511,7 +517,7 @@ def sonify_preview(self, plotting=True, verbose=False): print("Tremolo Vals (x10) = ", self.tremolo_vals) def play_preview(self): - """ Play the sound of a "preview-style" sonification. + """Play the sound of a "preview-style" sonification. The assigned pitch for each section of the spectra will begin to play, with the calculated amplitude and frequency, one @@ -540,7 +546,6 @@ def play_preview(self): d = pyo.Phasor(self.pitch_values[3], mul=np.pi * 2) e = pyo.Phasor(self.pitch_values[4], mul=np.pi * 2) - # TODO: Make everything below iterable to it's cleaner and takes up less lines lfo1 = ( pyo.Sine(float(self.tremolo_vals[0]), 0, float(self.amplitudes[0]), 0) @@ -570,34 +575,34 @@ def play_preview(self): self.stream1 = pyo.Sine( freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1 - ).out(delay=self.delays[0], dur=2.0) + ).out(delay=self.delays[0], dur=2.0) self.stream2 = pyo.Sine( freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2 - ).out(delay=self.delays[1], dur=2.0) + ).out(delay=self.delays[1], dur=2.0) self.stream3 = pyo.Sine( freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3 - ).out(delay=self.delays[2], dur=2.0) + ).out(delay=self.delays[2], dur=2.0) self.stream4 = pyo.Sine( freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4 - ).out(delay=self.delays[3], dur=2.0) + ).out(delay=self.delays[3], dur=2.0) self.stream5 = pyo.Sine( freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5 - ).out(delay=self.delays[4], dur=2.0) + ).out(delay=self.delays[4], dur=2.0) # All together, if in ensemble mode. if self._soniseries.preview_type == "ensemble": self.stream6 = pyo.Sine( freq=[self.pitch_values[0], self.pitch_values[0]], mul=lfo1 - ).out(delay=10, dur=4) + ).out(delay=10, dur=4) self.stream7 = pyo.Sine( freq=[self.pitch_values[1], self.pitch_values[1]], mul=lfo2 - ).out(delay=10, dur=4) + ).out(delay=10, dur=4) self.stream8 = pyo.Sine( freq=[self.pitch_values[2], self.pitch_values[2]], mul=lfo3 - ).out(delay=10, dur=4) + ).out(delay=10, dur=4) self.stream9 = pyo.Sine( freq=[self.pitch_values[3], self.pitch_values[3]], mul=lfo4 - ).out(delay=10, dur=4) + ).out(delay=10, dur=4) self.stream10 = pyo.Sine( freq=[self.pitch_values[4], self.pitch_values[4]], mul=lfo5 - ).out(delay=10, dur=4) + ).out(delay=10, dur=4) From 87139b7e1207cbbf6a0fc583647738ced04d8b40 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 23:35:34 -0500 Subject: [PATCH 76/93] more lynting --- astronify/series/series.py | 2 +- astronify/utils/tests/test_pitch_mapping.py | 111 ++++++++++++++------ 2 files changed, 78 insertions(+), 35 deletions(-) diff --git a/astronify/series/series.py b/astronify/series/series.py index 6fd84ce..b49ba6c 100644 --- a/astronify/series/series.py +++ b/astronify/series/series.py @@ -484,7 +484,7 @@ def sonify_preview(self, plotting=True, verbose=False): self.amplitudes = np.asarray(area_vals) / total_area if std_dev_norm == 0.0: - std_dev_norm = 1.0 + std_dev_norm = 1.0 # Set the tremolo values based on the standard deviation of the piece normalized by the # `std_dev_norm` factor. diff --git a/astronify/utils/tests/test_pitch_mapping.py b/astronify/utils/tests/test_pitch_mapping.py index 38f5034..0315491 100644 --- a/astronify/utils/tests/test_pitch_mapping.py +++ b/astronify/utils/tests/test_pitch_mapping.py @@ -17,24 +17,32 @@ def test_data_to_pitch(): # basic linear stretch data_arr = np.array([[1.0, 0.0, 0.25, 0.75]]) pitch_arr = data_arr * (pitch_range[1] - pitch_range[0]) + pitch_range[0] - + assert ( - pitch_arr == data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear')).all() + pitch_arr + == data_to_pitch(data_arr, pitch_range, center_pitch, stretch='linear') + ).all() # invert pitch_arr = pitch_range[1] - data_arr * (pitch_range[1] - pitch_range[0]) assert ( - pitch_arr == data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear', invert=True)).all() + pitch_arr + == data_to_pitch( + data_arr, pitch_range, center_pitch, stretch='linear', invert=True + ) + ).all() - # linear stretch where input image must be scaled + # linear stretch where input image must be scaled data_arr = np.array([10.0, 20.0, 12.5, 17.5]) - pitch_arr = ((data_arr - data_arr.min()) / (data_arr.max() - data_arr.min()) * - (pitch_range[1] - pitch_range[0])) + pitch_range[0] + pitch_arr = ( + (data_arr - data_arr.min()) + / (data_arr.max() - data_arr.min()) + * (pitch_range[1] - pitch_range[0]) + ) + pitch_range[0] assert ( - pitch_arr == data_to_pitch(data_arr, pitch_range, center_pitch, - stretch='linear')).all() + pitch_arr + == data_to_pitch(data_arr, pitch_range, center_pitch, stretch='linear') + ).all() # linear stretch with non-equal lower/upper pitch ranges data_arr = np.array([[1.0, 0.0, 0.25, 0.75]]) @@ -42,20 +50,24 @@ def test_data_to_pitch(): pitch_range = [300, 500] assert ( - pitch_arr == data_to_pitch(data_arr, [300, 500], - center_pitch, stretch="linear")).all() + pitch_arr == data_to_pitch(data_arr, [300, 500], center_pitch, stretch="linear") + ).all() pitch_range = [400, 600] assert ( - pitch_arr == data_to_pitch(data_arr, [400, 600], - center_pitch, stretch="linear")).all() + pitch_arr == data_to_pitch(data_arr, [400, 600], center_pitch, stretch="linear") + ).all() pitch_range = [400, 500] # min_max val minval, maxval = 0, 1 data_arr = np.array([1, 0, -1, 2]) pitch_arr = data_to_pitch( - data_arr, pitch_range, center_pitch, - stretch="linear", minmax_value=[minval, maxval]) + data_arr, + pitch_range, + center_pitch, + stretch="linear", + minmax_value=[minval, maxval] + ) data_arr[data_arr < minval] = minval data_arr[data_arr > maxval] = maxval manual_pitch_arr = data_arr * (pitch_range[1] - pitch_range[0]) + pitch_range[0] @@ -63,8 +75,13 @@ def test_data_to_pitch(): minval, maxval = 0, 1 data_arr = np.array([1.0, 0.0, 0.25, 0.75]) - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, - stretch="linear", minmax_value=[minval, maxval]) + pitch_arr = data_to_pitch( + data_arr, + pitch_range, + center_pitch, + stretch="linear", + minmax_value=[minval, maxval] + ) data_arr[data_arr < minval] = minval data_arr[data_arr > maxval] = maxval manual_pitch_arr = data_arr * (pitch_range[1] - pitch_range[0]) + pitch_range[0] @@ -72,38 +89,58 @@ def test_data_to_pitch(): # min_max percent data_arr = np.array([1.1, -0.1, 1.0, 0.0, 0.25, 0.75]) - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, - stretch="linear", minmax_percent=[20, 80]) + pitch_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, stretch="linear", minmax_percent=[20, 80] + ) assert ( - np.isclose(pitch_arr, np.array([500, 400, 500, 400, - 422.22222222, 477.77777778]))).all() + np.isclose( + pitch_arr, np.array([500, 400, 500, 400, 422.22222222, 477.77777778])) + ).all() # asinh data_arr = np.array([1.0, 0.0, 0.25, 0.75]) zero_point = 0.21271901209248895 - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch="asinh") - manual_pitch_arr = np.arcsinh(data_arr * 10) / np.arcsinh(10) * (pitch_range[1] - pitch_range[0]) + pitch_range[0] + pitch_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, zero_point, stretch="asinh" + ) + manual_pitch_arr = ( + np.arcsinh(data_arr * 10) / np.arcsinh(10) * (pitch_range[1] - pitch_range[0]) + + pitch_range[0] + ) assert (manual_pitch_arr == pitch_arr).all() # sinh data_arr = np.array([1.0, 0.0, 0.25, 0.75]) zero_point = 0.7713965391706435 - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch="sinh") - manual_pitch_arr = np.sinh(data_arr * 3) / np.sinh(3) * (pitch_range[1] - pitch_range[0]) + pitch_range[0] + pitch_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, zero_point, stretch="sinh" + ) + manual_pitch_arr = ( + np.sinh(data_arr * 3) / np.sinh(3) * (pitch_range[1] - pitch_range[0]) + + pitch_range[0] + ) assert (manual_pitch_arr == pitch_arr).all() # sqrt data_arr = np.array([1.0, 0.0, 0.25, 0.75]) zero_point = 0.25 - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch="sqrt") - manual_pitch_arr = np.sqrt(data_arr) * (pitch_range[1] - pitch_range[0]) + pitch_range[0] + pitch_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, zero_point, stretch="sqrt" + ) + manual_pitch_arr = ( + np.sqrt(data_arr) * (pitch_range[1] - pitch_range[0]) + pitch_range[0] + ) assert (manual_pitch_arr == pitch_arr).all() # log data_arr = np.array([1.0, 0.0, 0.25, 0.75]) zero_point = 0.030638584039112748 - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, zero_point, stretch="log") - manual_pitch_arr = np.log(1000 * data_arr + 1) / np.log(1001) * (pitch_range[1] - pitch_range[0]) + pitch_range[0] + pitch_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, zero_point, stretch="log" + ) + manual_pitch_arr = ( + np.log(1000 * data_arr + 1) / np.log(1001) * (pitch_range[1] - pitch_range[0]) + pitch_range[0] + ) assert (manual_pitch_arr == pitch_arr).all() # Bad stretch @@ -113,10 +150,16 @@ def test_data_to_pitch(): # Giving both minmax percent and cut data_arr = np.array([1.1, -0.1, 1.0, 0.0, 0.25, 0.75]) - pitch_arr = data_to_pitch(data_arr, pitch_range, center_pitch, stretch="linear", minmax_percent=[20, 80]) + pitch_arr = data_to_pitch( + data_arr, pitch_range, center_pitch, stretch="linear", minmax_percent=[20, 80] + ) with pytest.warns(InputWarning): test_arr = data_to_pitch( - data_arr, pitch_range, center_pitch, stretch="linear", - minmax_value=[0, 1], minmax_percent=[20, 80]) + data_arr, + pitch_range, + center_pitch, + stretch="linear", + minmax_value=[0, 1], + minmax_percent=[20, 80] + ) assert (pitch_arr == test_arr).all() - From c008d9a2838f36ec6845152519918e42589cccb1 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 23:49:01 -0500 Subject: [PATCH 77/93] lynt iterating --- astronify/simulator/add_transit_signal.py | 2 +- astronify/simulator/sim_lc.py | 43 ++++++++++------------- astronify/simulator/sim_lc_setup_args.py | 2 +- astronify/utils/pitch_mapping.py | 22 ++++++------ 4 files changed, 32 insertions(+), 37 deletions(-) diff --git a/astronify/simulator/add_transit_signal.py b/astronify/simulator/add_transit_signal.py index 735a5c9..cebc682 100644 --- a/astronify/simulator/add_transit_signal.py +++ b/astronify/simulator/add_transit_signal.py @@ -10,7 +10,7 @@ def add_transit_signal( fluxes, transit_depth, transit_period, transit_start, transit_width - ): +): """ :param fluxes: Array of fluxes to add the transit signal to. :type fluxes: numpy.ndarray diff --git a/astronify/simulator/sim_lc.py b/astronify/simulator/sim_lc.py index 8034c27..4496f34 100644 --- a/astronify/simulator/sim_lc.py +++ b/astronify/simulator/sim_lc.py @@ -26,22 +26,22 @@ def simulated_lc( - lc_type, - lc_ofile=SimLcConfig.sim_lc_ofile, - lc_length=SimLcConfig.sim_lc_length, - lc_noise=SimLcConfig.sim_lc_noise, - visualize=SimLcConfig.sim_lc_visualize, - lc_yoffset=SimLcConfig.sim_lc_yoffset, - transit_depth=SimLcConfig.sim_lc_transit_depth, - transit_period=SimLcConfig.sim_lc_transit_period, - transit_start=SimLcConfig.sim_lc_transit_start, - transit_width=SimLcConfig.sim_lc_transit_width, - sine_amp=SimLcConfig.sim_lc_sine_amp, - sine_period=SimLcConfig.sim_lc_sine_period, - flare_time=SimLcConfig.sim_lc_flare_time, - flare_amp=SimLcConfig.sim_lc_flare_amp, - flare_halfwidth=SimLcConfig.sim_lc_flare_halfwidth - ): + lc_type, + lc_ofile=SimLcConfig.sim_lc_ofile, + lc_length=SimLcConfig.sim_lc_length, + lc_noise=SimLcConfig.sim_lc_noise, + visualize=SimLcConfig.sim_lc_visualize, + lc_yoffset=SimLcConfig.sim_lc_yoffset, + transit_depth=SimLcConfig.sim_lc_transit_depth, + transit_period=SimLcConfig.sim_lc_transit_period, + transit_start=SimLcConfig.sim_lc_transit_start, + transit_width=SimLcConfig.sim_lc_transit_width, + sine_amp=SimLcConfig.sim_lc_sine_amp, + sine_period=SimLcConfig.sim_lc_sine_period, + flare_time=SimLcConfig.sim_lc_flare_time, + flare_amp=SimLcConfig.sim_lc_flare_amp, + flare_halfwidth=SimLcConfig.sim_lc_flare_halfwidth +): """ Create light curve with specified parameters as a `~astropy.table.Table`, and optionally writes a FITS file with the same information. @@ -143,21 +143,16 @@ def simulated_lc( hdr.append(("LCLENGTH", lc_length, "Number of fluxes.")) hdr.append(("LCYOFF", lc_yoffset, "Baseline flux value (unitless).")) hdr.append( - ("LCNOISE", lc_noise, "Std. dev. of normal dist. used to" - " apply noise.") + "LCNOISE", lc_noise, "Std. dev. of normal dist. used to apply noise.", ) # Record the flare parameters used if adding a flare. if lc_type == "flare": hdr.append( - ("FLARETIM", - flare_time, - "Index corresponding to the peak of the flare.") + "FLARETIM", flare_time, "Index corresponding to the peak of the flare.", ) hdr.append(("FLAREAMP", flare_amp, "Amplitude of the flare.")) hdr.append( - ("FLAREWID", - flare_halfwidth, - "Flare half-width (number of indices).") + "FLAREWID", flare_halfwidth, "Flare half-width (number of indices).", ) # Record the sinusoidal parameters if adding a sinusoid. if lc_type == "sine": diff --git a/astronify/simulator/sim_lc_setup_args.py b/astronify/simulator/sim_lc_setup_args.py index d4bea98..0455bf7 100644 --- a/astronify/simulator/sim_lc_setup_args.py +++ b/astronify/simulator/sim_lc_setup_args.py @@ -144,7 +144,7 @@ def sim_lc_setup_args(): type=float, default=sim_lc_config.sim_lc_sine_amp, dest="sine_amp", - help="Amplitude of the sinusoidal signal to add. Default = %(default)s." + help="Amplitude of the sinusoidal signal to add. Default = %(default)s.", ) sine_group.add_argument( diff --git a/astronify/utils/pitch_mapping.py b/astronify/utils/pitch_mapping.py index f19c8ab..c3ffca1 100644 --- a/astronify/utils/pitch_mapping.py +++ b/astronify/utils/pitch_mapping.py @@ -27,15 +27,15 @@ def data_to_pitch( - data_array, - pitch_range=[100, 10000], - center_pitch=440, - zero_point="median", - stretch='linear', - minmax_percent=None, - minmax_value=None, - invert=False, - ): + data_array, + pitch_range=[100, 10000], + center_pitch=440, + zero_point="median", + stretch='linear', + minmax_percent=None, + minmax_value=None, + invert=False, +): """ Map data array to audible pitches in the given range, and apply stretch and scaling as required. @@ -145,13 +145,13 @@ def data_to_pitch( if ( (1 / zero_point) * (center_pitch - pitch_range[0]) + pitch_range[0] - ) <= pitch_range[1]: + ) <= pitch_range[1]: pitch_array = (pitch_array / zero_point) * ( center_pitch - pitch_range[0] ) + pitch_range[0] else: pitch_array = ((pitch_array - zero_point) / (1 - zero_point)) * ( pitch_range[1] - center_pitch - ) + center_pitch + ) + center_pitch return pitch_array From 00c0f72b0e1ee34b81e831764d09fc51303c8700 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Wed, 15 Jan 2025 23:57:40 -0500 Subject: [PATCH 78/93] another round of lynting --- astronify/simulator/sim_lc.py | 10 +++++----- astronify/utils/pitch_mapping.py | 2 +- docs/conf.py | 21 ++++++++++++--------- setup.py | 4 ++-- 4 files changed, 20 insertions(+), 17 deletions(-) diff --git a/astronify/simulator/sim_lc.py b/astronify/simulator/sim_lc.py index 4496f34..83c0655 100644 --- a/astronify/simulator/sim_lc.py +++ b/astronify/simulator/sim_lc.py @@ -40,7 +40,7 @@ def simulated_lc( sine_period=SimLcConfig.sim_lc_sine_period, flare_time=SimLcConfig.sim_lc_flare_time, flare_amp=SimLcConfig.sim_lc_flare_amp, - flare_halfwidth=SimLcConfig.sim_lc_flare_halfwidth + flare_halfwidth=SimLcConfig.sim_lc_flare_halfwidth, ): """ Create light curve with specified parameters as a `~astropy.table.Table`, @@ -143,16 +143,16 @@ def simulated_lc( hdr.append(("LCLENGTH", lc_length, "Number of fluxes.")) hdr.append(("LCYOFF", lc_yoffset, "Baseline flux value (unitless).")) hdr.append( - "LCNOISE", lc_noise, "Std. dev. of normal dist. used to apply noise.", + ("LCNOISE", lc_noise, "Std. dev. of normal dist. used to apply noise.") ) # Record the flare parameters used if adding a flare. if lc_type == "flare": hdr.append( - "FLARETIM", flare_time, "Index corresponding to the peak of the flare.", + ("FLARETIM", flare_time, "Index corresponding to the peak of the flare.") ) hdr.append(("FLAREAMP", flare_amp, "Amplitude of the flare.")) hdr.append( - "FLAREWID", flare_halfwidth, "Flare half-width (number of indices).", + ("FLAREWID", flare_halfwidth, "Flare half-width (number of indices).") ) # Record the sinusoidal parameters if adding a sinusoid. if lc_type == "sine": @@ -205,5 +205,5 @@ def simulated_lc( INPUT_ARGS.sine_period, INPUT_ARGS.flare_time, INPUT_ARGS.flare_amp, - INPUT_ARGS.flare_halfwidth + INPUT_ARGS.flare_halfwidth, ) diff --git a/astronify/utils/pitch_mapping.py b/astronify/utils/pitch_mapping.py index c3ffca1..45ce6d5 100644 --- a/astronify/utils/pitch_mapping.py +++ b/astronify/utils/pitch_mapping.py @@ -31,7 +31,7 @@ def data_to_pitch( pitch_range=[100, 10000], center_pitch=440, zero_point="median", - stretch='linear', + stretch="linear", minmax_percent=None, minmax_value=None, invert=False, diff --git a/docs/conf.py b/docs/conf.py index 2c432c6..b73c32c 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -34,7 +34,7 @@ from sphinx_astropy.conf.v1 import * # noqa except ImportError: print( - 'ERROR: the documentation requires the sphinx-astropy package to be installed' + "ERROR: the documentation requires the sphinx-astropy package to be installed" ) sys.exit(1) @@ -110,14 +110,15 @@ # name of a builtin theme or the name of a custom theme in html_theme_path. html_theme = "sphinx_rtd_theme" + def setup_style(app): app.add_stylesheet("astronify.css") -master_doc="contents" -html_extra_path=["index.html", "CreateWithLight.html"] +master_doc = "contents" +html_extra_path = ["index.html", "CreateWithLight.html"] # Custom sidebar templates, maps document names to template names. -html_sidebars = { "**": ["globaltoc.html", "localtoc.html", "searchbox.html"] } +html_sidebars = {"**": ["globaltoc.html", "localtoc.html", "searchbox.html"]} # The name of an image file (relative to this directory) to place at the top # of the sidebar. @@ -130,7 +131,7 @@ def setup_style(app): # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. -#html_last_updated_fmt = '' +# html_last_updated_fmt = '' # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". @@ -150,16 +151,18 @@ def setup_style(app): # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). -latex_documents = [("index", project + ".tex", project + u" Documentation", - author, "manual")] +latex_documents = [ + ("index", project + ".tex", project + u" Documentation", author, "manual") +] # -- Options for manual page output ------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). -man_pages = [("index", project.lower(), project + u" Documentation", - [author], 1)] +man_pages = [ + ("index", project.lower(), project + u" Documentation", [author], 1) +] # -- Options for the edit_on_github extension --------------------------------- diff --git a/setup.py b/setup.py index 2925ac5..b0c4979 100755 --- a/setup.py +++ b/setup.py @@ -76,7 +76,7 @@ setup( use_scm_version={ - 'write_to': os.path.join('astronify', 'version.py'), - 'write_to_template': VERSION_TEMPLATE + "write_to": os.path.join("astronify", "version.py"), + "write_to_template": VERSION_TEMPLATE } ) From e39226e02f8f68a408add686f9782cec71aca150 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Thu, 16 Jan 2025 00:06:04 -0500 Subject: [PATCH 79/93] almost last round of lynting --- astronify/simulator/sim_lc.py | 6 +++++- astronify/utils/tests/test_pitch_mapping.py | 20 +++++++++++--------- docs/conf.py | 10 ++++------ setup.py | 2 +- 4 files changed, 21 insertions(+), 17 deletions(-) diff --git a/astronify/simulator/sim_lc.py b/astronify/simulator/sim_lc.py index 83c0655..a798ace 100644 --- a/astronify/simulator/sim_lc.py +++ b/astronify/simulator/sim_lc.py @@ -148,7 +148,11 @@ def simulated_lc( # Record the flare parameters used if adding a flare. if lc_type == "flare": hdr.append( - ("FLARETIM", flare_time, "Index corresponding to the peak of the flare.") + ( + "FLARETIM", + flare_time, + "Index corresponding to the peak of the flare.", + ) ) hdr.append(("FLAREAMP", flare_amp, "Amplitude of the flare.")) hdr.append( diff --git a/astronify/utils/tests/test_pitch_mapping.py b/astronify/utils/tests/test_pitch_mapping.py index 0315491..95b953e 100644 --- a/astronify/utils/tests/test_pitch_mapping.py +++ b/astronify/utils/tests/test_pitch_mapping.py @@ -20,7 +20,7 @@ def test_data_to_pitch(): assert ( pitch_arr - == data_to_pitch(data_arr, pitch_range, center_pitch, stretch='linear') + == data_to_pitch(data_arr, pitch_range, center_pitch, stretch="linear") ).all() # invert @@ -28,7 +28,7 @@ def test_data_to_pitch(): assert ( pitch_arr == data_to_pitch( - data_arr, pitch_range, center_pitch, stretch='linear', invert=True + data_arr, pitch_range, center_pitch, stretch="linear", invert=True ) ).all() @@ -41,7 +41,7 @@ def test_data_to_pitch(): ) + pitch_range[0] assert ( pitch_arr - == data_to_pitch(data_arr, pitch_range, center_pitch, stretch='linear') + == data_to_pitch(data_arr, pitch_range, center_pitch, stretch="linear") ).all() # linear stretch with non-equal lower/upper pitch ranges @@ -57,7 +57,7 @@ def test_data_to_pitch(): pitch_arr == data_to_pitch(data_arr, [400, 600], center_pitch, stretch="linear") ).all() pitch_range = [400, 500] - + # min_max val minval, maxval = 0, 1 data_arr = np.array([1, 0, -1, 2]) @@ -66,7 +66,7 @@ def test_data_to_pitch(): pitch_range, center_pitch, stretch="linear", - minmax_value=[minval, maxval] + minmax_value=[minval, maxval], ) data_arr[data_arr < minval] = minval data_arr[data_arr > maxval] = maxval @@ -80,7 +80,7 @@ def test_data_to_pitch(): pitch_range, center_pitch, stretch="linear", - minmax_value=[minval, maxval] + minmax_value=[minval, maxval], ) data_arr[data_arr < minval] = minval data_arr[data_arr > maxval] = maxval @@ -94,7 +94,8 @@ def test_data_to_pitch(): ) assert ( np.isclose( - pitch_arr, np.array([500, 400, 500, 400, 422.22222222, 477.77777778])) + pitch_arr, np.array([500, 400, 500, 400, 422.22222222, 477.77777778]) + ) ).all() # asinh @@ -139,7 +140,8 @@ def test_data_to_pitch(): data_arr, pitch_range, center_pitch, zero_point, stretch="log" ) manual_pitch_arr = ( - np.log(1000 * data_arr + 1) / np.log(1001) * (pitch_range[1] - pitch_range[0]) + pitch_range[0] + np.log(1000 * data_arr + 1) / np.log(1001) * (pitch_range[1] - pitch_range[0]) + + pitch_range[0] ) assert (manual_pitch_arr == pitch_arr).all() @@ -160,6 +162,6 @@ def test_data_to_pitch(): center_pitch, stretch="linear", minmax_value=[0, 1], - minmax_percent=[20, 80] + minmax_percent=[20, 80], ) assert (pitch_arr == test_arr).all() diff --git a/docs/conf.py b/docs/conf.py index b73c32c..5f9d614 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -72,8 +72,7 @@ # This does not *have* to match the package name, but typically does project = setup_cfg["name"] author = setup_cfg["author"] -copyright = "{0}, {1}".format( - datetime.datetime.now().year, setup_cfg["author"]) +copyright = "{0}, {1}".format(datetime.datetime.now().year, setup_cfg["author"]) # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the @@ -114,6 +113,7 @@ def setup_style(app): app.add_stylesheet("astronify.css") + master_doc = "contents" html_extra_path = ["index.html", "CreateWithLight.html"] @@ -152,7 +152,7 @@ def setup_style(app): # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [ - ("index", project + ".tex", project + u" Documentation", author, "manual") + ("index", project + ".tex", project + " Documentation", author, "manual") ] @@ -160,9 +160,7 @@ def setup_style(app): # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). -man_pages = [ - ("index", project.lower(), project + u" Documentation", [author], 1) -] +man_pages = [("index", project.lower(), project + " Documentation", [author], 1)] # -- Options for the edit_on_github extension --------------------------------- diff --git a/setup.py b/setup.py index b0c4979..40b1e12 100755 --- a/setup.py +++ b/setup.py @@ -77,6 +77,6 @@ setup( use_scm_version={ "write_to": os.path.join("astronify", "version.py"), - "write_to_template": VERSION_TEMPLATE + "write_to_template": VERSION_TEMPLATE, } ) From 1006608f82600027d4a53bee2478f4bcdadc1660 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Thu, 16 Jan 2025 00:08:04 -0500 Subject: [PATCH 80/93] last lynting --- astronify/simulator/sim_lc.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/astronify/simulator/sim_lc.py b/astronify/simulator/sim_lc.py index a798ace..91a679c 100644 --- a/astronify/simulator/sim_lc.py +++ b/astronify/simulator/sim_lc.py @@ -149,9 +149,9 @@ def simulated_lc( if lc_type == "flare": hdr.append( ( - "FLARETIM", - flare_time, - "Index corresponding to the peak of the flare.", + "FLARETIM", + flare_time, + "Index corresponding to the peak of the flare.", ) ) hdr.append(("FLAREAMP", flare_amp, "Amplitude of the flare.")) From 79a6aa342f7d0ef11a0a35975a02ee70fa153f52 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Thu, 16 Jan 2025 10:23:44 -0500 Subject: [PATCH 81/93] adding Pey-Lian as a contributing author --- setup.cfg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.cfg b/setup.cfg index bccf19d..22a95f7 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,6 +1,6 @@ [metadata] name = astronify -author = Clara Brasseur, Scott Fleming, Jennifer Kotler, Kate Meredith +author = Clara Brasseur, Scott Fleming, Jennifer Kotler, Kate Meredith, Pey-Lian Lim author_email = astronify@stsci.edu license = BSD 3-Clause license_file = licenses/LICENSE.rst From b4883e296f7e8a15fda96d4d18fecf5012d5741d Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Thu, 16 Jan 2025 15:56:25 -0500 Subject: [PATCH 82/93] adding CODEOWNERS file so merges into main require approval from at least one code owner --- .github/CODEOWNERS | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 .github/CODEOWNERS diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..e4995c3 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1,8 @@ +# This is a comment. +# Each line is a file pattern followed by one or more owners. + +# These owners will be the default owners for everything in +# the repo. Unless a later match takes precedence, +# these owners will be requested for +# review when someone opens a pull request. +* @ceb8 @scfleming From e589c786acba09f547e8c005c3a8146f876ad6f2 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Thu, 16 Jan 2025 16:14:23 -0500 Subject: [PATCH 83/93] splitting developer documentation from main doc, adding some links to tutorials in case people are coming from here and not the web homepage --- DEVELOPER_DOC.rst | 65 +++++++++++++++++++++++++++++++++++++++++++ README.rst | 71 ++++++----------------------------------------- 2 files changed, 73 insertions(+), 63 deletions(-) create mode 100644 DEVELOPER_DOC.rst diff --git a/DEVELOPER_DOC.rst b/DEVELOPER_DOC.rst new file mode 100644 index 0000000..491ebff --- /dev/null +++ b/DEVELOPER_DOC.rst @@ -0,0 +1,65 @@ +Developer Documentation +----------------------- + +This documentation is intended for code maintainers and developers as a guide, especially when preparing to merge and release a new version of the code. + +Installation +^^^^^^^^^^^^ + +.. code-block:: bash + + $ git clone https://github.com/spacetelescope/astronify.git + $ cd astronify + $ pip install . + +For active development, install in develop mode + +.. code-block:: bash + + $ pip install -e . + + +Testing +^^^^^^^ +Testing is run with `tox `_ (``pip install tox``). +Tests can be found in ``tests/`` sub-directories. + +.. code-block:: bash + + $ tox -e test + +Tests can also be run directly with pytest: + +.. code-block:: bash + + $ pip install -e .[test] + $ pytest + + + +Documentation +^^^^^^^^^^^^^ + +Documentation files are found in ``docs/``. + +We build the documentation with `tox `_ (``pip install tox``): + +.. code-block:: bash + + $ tox -e build_docs + +You can also build the documentation with Sphinx directly using: + +.. code-block:: bash + + $ pip install -e .[docs] + $ cd docs + $ make html + +The built docs will be in ``docs/_build/html/``, to view them go to ``file:///path/to/astronify/repo/docs/_build/html/index.html`` in the browser of your choice. + + +Release Protocol +^^^^^^^^^^^^^^^^ + +Coming soon. diff --git a/README.rst b/README.rst index 5b31380..6c5c0b0 100644 --- a/README.rst +++ b/README.rst @@ -37,74 +37,19 @@ Project Status :target: https://codecov.io/gh/spacetelescope/astronify :alt: Astronify's Codecov coverage status -Developer Documentation ------------------------ - -Installation -^^^^^^^^^^^^ - -.. code-block:: bash - - $ git clone https://github.com/spacetelescope/astronify.git - $ cd astronify - $ pip install . - -For active development, install in develop mode - -.. code-block:: bash - - $ pip install -e . - - -Testing -^^^^^^^ -Testing is run with `tox `_ (``pip install tox``). -Tests can be found in ``tests/`` sub-directories. - -.. code-block:: bash - - $ tox -e test - -Tests can also be run directly with pytest: - -.. code-block:: bash - - $ pip install -e .[test] - $ pytest - - - -Documentation -^^^^^^^^^^^^^ - -Documentation files are found in ``docs/``. - -We build the documentation with `tox `_ (``pip install tox``): - -.. code-block:: bash - - $ tox -e build_docs - -You can also build the documentation with Sphinx directly using: - -.. code-block:: bash - - $ pip install -e .[docs] - $ cd docs - $ make html - -The built docs will be in ``docs/_build/html/``, to view them go to ``file:///path/to/astronify/repo/docs/_build/html/index.html`` in the browser of your choice. - - -Release Protocol -^^^^^^^^^^^^^^^^ - -Follow the `Astropy template release instructions `_. +Getting Started +--------------- +[Install Instructions](docs/astronify/install.rst) +[Tutorials](docs/notebooks/Intro_Astronify_Series.ipynb) Contributing ------------ +If you are a maintainer of the code, refer to the [developer +documentation](DEVELOPER_DOC.rst) for guidelines on how to release a +new version. + We love contributions! Astronify is open source, built on open source, and we'd love to have you hang out in our community. From 3800b4303bed59b9e1cd2a4396c81d2a78f58092 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Thu, 16 Jan 2025 16:27:13 -0500 Subject: [PATCH 84/93] trying to fix links --- README.rst | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/README.rst b/README.rst index 6c5c0b0..4723a81 100644 --- a/README.rst +++ b/README.rst @@ -39,15 +39,14 @@ Project Status Getting Started --------------- -[Install Instructions](docs/astronify/install.rst) +`Install Instructions ` -[Tutorials](docs/notebooks/Intro_Astronify_Series.ipynb) +`Tutorials ` Contributing ------------ -If you are a maintainer of the code, refer to the [developer -documentation](DEVELOPER_DOC.rst) for guidelines on how to release a +If you are a maintainer of the code, refer to the `developer documentation ` for guidelines on how to release a new version. We love contributions! Astronify is open source, From 34b37fbc4ce1ff799c344b58d8514108f0ee71d0 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Thu, 16 Jan 2025 16:31:19 -0500 Subject: [PATCH 85/93] trying to fix links --- README.rst | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.rst b/README.rst index 4723a81..4df06cc 100644 --- a/README.rst +++ b/README.rst @@ -39,14 +39,15 @@ Project Status Getting Started --------------- -`Install Instructions ` +Install instructions: https://astronify.readthedocs.io/en/latest/astronify/install.html -`Tutorials ` +Tutorials: https://astronify.readthedocs.io/en/latest/astronify/tutorials.html Contributing ------------ -If you are a maintainer of the code, refer to the `developer documentation ` for guidelines on how to release a +If you are a maintainer of the code, refer to the developer +documentation (DEVELOPER_DOC.rst file) for guidelines on how to release a new version. We love contributions! Astronify is open source, From b3599326398966991853a0ce1bcc99d23cfa38d7 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Thu, 16 Jan 2025 16:51:18 -0500 Subject: [PATCH 86/93] adding better tip of how to build docs locally with sphinx directly --- DEVELOPER_DOC.rst | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/DEVELOPER_DOC.rst b/DEVELOPER_DOC.rst index 491ebff..5cf1ad0 100644 --- a/DEVELOPER_DOC.rst +++ b/DEVELOPER_DOC.rst @@ -34,7 +34,6 @@ Tests can also be run directly with pytest: $ pip install -e .[test] $ pytest - Documentation @@ -52,11 +51,10 @@ You can also build the documentation with Sphinx directly using: .. code-block:: bash - $ pip install -e .[docs] $ cd docs - $ make html + $ sphinx-build -M html . _build/ -The built docs will be in ``docs/_build/html/``, to view them go to ``file:///path/to/astronify/repo/docs/_build/html/index.html`` in the browser of your choice. +The built docs will be in ``docs/_build/html/``, to view them go to ``file://docs/_build/html/index.html`` in the browser of your choice. Release Protocol From 40a5b70ff00a882892b06d6f578e16bf8e5b6fff Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Thu, 16 Jan 2025 17:27:10 -0500 Subject: [PATCH 87/93] adding some work-in-progress dev steps, adding __version__, updating change log --- CHANGES.rst | 7 +++++-- CITATION.cff | 6 ++---- DEVELOPER_DOC.rst | 12 +++++++++++- astronify/__init__.py | 1 + setup.cfg | 1 + 5 files changed, 20 insertions(+), 7 deletions(-) diff --git a/CHANGES.rst b/CHANGES.rst index e2c090a..33d57a5 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,7 +1,10 @@ -0.2 (unreleased) +0.11 (2025-01-24) ---------------- -- No changes yet +- Fixes installation via pypi, confirmed to work with modern Python + (e.g., 3.11), updated installation instructions and tips, + infrastructure improvements in CI, fixes automated documentation + builds, added __version__. 0.1 (2020-11-25) ---------------- diff --git a/CITATION.cff b/CITATION.cff index af23c4a..b3ffda5 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -10,13 +10,11 @@ authors: - family-names: Meredith given-names: K. title: "Astronify: Astronomical data sonification" -version: 0.1 -date-released: 2020-11-30 +version: 0.11 +date-released: 2025-01-24 identifiers: - type: "ascl-id" value: "2408.005" - - type: "doi" - value: PLACEHOLDER - type: "bibcode" value: "2024ascl.soft08005B" abstract: "Astronify contains tools for sonifying astronomical data, specifically data series. Data series sonification takes a data table and maps one column to time, and one column to pitch. This technique is commonly used to sonify light curves, where observation time is scaled to listening time and flux is mapped to pitch. While Astronify’s sonification uses the columns “time” and “flux” by default, any two columns can be supplied and a sonification created." diff --git a/DEVELOPER_DOC.rst b/DEVELOPER_DOC.rst index 5cf1ad0..dfc4551 100644 --- a/DEVELOPER_DOC.rst +++ b/DEVELOPER_DOC.rst @@ -60,4 +60,14 @@ The built docs will be in ``docs/_build/html/``, to view them go to ``file://

Date: Fri, 31 Jan 2025 12:13:31 -0500 Subject: [PATCH 88/93] Preparing release 0.11 --- CHANGES.rst | 4 ++-- CITATION.cff | 2 +- DEVELOPER_DOC.rst | 26 ++++++++++++++++++++++++++ setup.cfg | 2 +- 4 files changed, 30 insertions(+), 4 deletions(-) diff --git a/CHANGES.rst b/CHANGES.rst index 33d57a5..353bc48 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,8 +1,8 @@ -0.11 (2025-01-24) +0.11 (2025-01-31) ---------------- - Fixes installation via pypi, confirmed to work with modern Python - (e.g., 3.11), updated installation instructions and tips, + (e.g., 3.11, 3.12), updated installation instructions and tips, infrastructure improvements in CI, fixes automated documentation builds, added __version__. diff --git a/CITATION.cff b/CITATION.cff index b3ffda5..fd76fd3 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -11,7 +11,7 @@ authors: given-names: K. title: "Astronify: Astronomical data sonification" version: 0.11 -date-released: 2025-01-24 +date-released: 2025-01-31 identifiers: - type: "ascl-id" value: "2408.005" diff --git a/DEVELOPER_DOC.rst b/DEVELOPER_DOC.rst index dfc4551..880ab90 100644 --- a/DEVELOPER_DOC.rst +++ b/DEVELOPER_DOC.rst @@ -71,3 +71,29 @@ TO-BE-FINALIZED - Update the "CHANGES.rst" file to add the new version, release date, and summary of what's changing in this version. + +- Make a final commit to the branch, doing things like double checking + Python versions, release dates, spell check documentation files, + etc. Commit the final release with: + +.. code-block:: bash + + $ git commit -m "Preparing release " + +- Tag the commit with the version + +.. code-block:: bash + + $ git tag -a -m "Release version " + +- Make sure the `build` package is up-to-date: + +.. code-block:: bash + + $ python -m build --sdist --outdir dist . + +- Twine upload. + +.. code-block:: bash + + twine upload dist/ diff --git a/setup.cfg b/setup.cfg index 8588e89..c8c6c43 100644 --- a/setup.cfg +++ b/setup.cfg @@ -15,7 +15,7 @@ github_project = spacetelscope/astronify [options] zip_safe = False packages = find: -python_requires = >=3.9, <3.12 +python_requires = >=3.9 setup_requires = setuptools_scm install_requires = astropy From 70aa31a3c1c7ca79424b7da6ade4cb950f16117e Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 31 Jan 2025 12:26:28 -0500 Subject: [PATCH 89/93] Preparing release 0.11 --- .github/workflows/ci_workflows.yml | 40 ++++++++++++++++++++++++------ DEVELOPER_DOC.rst | 4 +++ 2 files changed, 36 insertions(+), 8 deletions(-) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index 53255d5..21de101 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -7,6 +7,8 @@ on: - py311 tags: pull_request: + branches: + - main jobs: tests: @@ -19,12 +21,12 @@ jobs: - name: Python 3.9.xx with minimal dependencies os: ubuntu-latest - python: 3.9.21 + python: 3.9.21 toxenv: py39-test - name: Python 3.9.xx with all optional dependencies os: ubuntu-latest - python: 3.9.21 + python: 3.9.21 toxenv: py39-test-alldeps toxargs: -v --develop toxposargs: -W error::ResourceWarning @@ -57,27 +59,49 @@ jobs: toxenv: py310-test-alldeps-numpy210-cov - name: Python 3.11.xx with minimal dependencies - os: ubuntu-latest - python: 3.11.11 + os: ubuntu-latest + python: 3.11.11 toxenv: py311-test - name: Python 3.11.xx with all optional dependencies - os: ubuntu-latest - python: 3.11.11 + os: ubuntu-latest + python: 3.11.11 toxenv: py311-test-alldeps toxargs: -v --develop toxposargs: -W error::ResourceWarning - name: Python 3.11.xx with numpy 1.24 and full coverage os: ubuntu-latest - python: 3.11.11 + python: 3.11.11 toxenv: py311-test-alldeps-numpy124-cov - name: Python 3.11.xx with numpy 2.10 and full coverage os: ubuntu-latest - python: 3.11.11 + python: 3.11.11 toxenv: py311-test-alldeps-numpy210-cov + - name: Python 3.12.xx with minimal dependencies + os: ubuntu-latest + python: 3.12.8 + toxenv: py312-test + + - name: Python 3.12.xx with all optional dependencies + os: ubuntu-latest + python: 3.12.8 + toxenv: py312-test-alldeps + toxargs: -v --develop + toxposargs: -W error::ResourceWarning + + - name: Python 3.12.xx with numpy 1.24 and full coverage + os: ubuntu-latest + python: 3.12.8 + toxenv: py312-test-alldeps-numpy124-cov + + - name: Python 3.12.xx with numpy 2.10 and full coverage + os: ubuntu-latest + python: 3.12.8 + toxenv: py312-test-alldeps-numpy210-cov + steps: - name: Checkout code uses: actions/checkout@d632683dd7b4114ad314bca15554477dd762a938 # v4.2.0 diff --git a/DEVELOPER_DOC.rst b/DEVELOPER_DOC.rst index 880ab90..8041f55 100644 --- a/DEVELOPER_DOC.rst +++ b/DEVELOPER_DOC.rst @@ -62,6 +62,10 @@ Release Protocol TO-BE-FINALIZED +- Update the ``ci_workflows.yml`` under ``.github/workflows/`` to + remove any inactive branches and add your new development branch, + under the ``push`` section towards the top of the file. + - Update the __init__.py file under the "astronify/" folder to update the __version__ variable to match the upcoming release version. This should be specified as a string. From f8bf669bc0fec8bb7a7adfbace02d2e1ebd421df Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 31 Jan 2025 12:31:57 -0500 Subject: [PATCH 90/93] Preparing release 0.11 --- .github/workflows/ci_workflows.yml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/.github/workflows/ci_workflows.yml b/.github/workflows/ci_workflows.yml index 21de101..e9bd04c 100644 --- a/.github/workflows/ci_workflows.yml +++ b/.github/workflows/ci_workflows.yml @@ -92,11 +92,6 @@ jobs: toxargs: -v --develop toxposargs: -W error::ResourceWarning - - name: Python 3.12.xx with numpy 1.24 and full coverage - os: ubuntu-latest - python: 3.12.8 - toxenv: py312-test-alldeps-numpy124-cov - - name: Python 3.12.xx with numpy 2.10 and full coverage os: ubuntu-latest python: 3.12.8 From 33edb992b2f08ecc7ec1f5c39a8403eb8774f346 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 31 Jan 2025 14:51:56 -0500 Subject: [PATCH 91/93] fixing conflict merge issues --- DEVELOPER_DOC.rst | 5 +++-- astronify/series/tests/test_series.py | 10 +++++----- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/DEVELOPER_DOC.rst b/DEVELOPER_DOC.rst index 8041f55..e480ed7 100644 --- a/DEVELOPER_DOC.rst +++ b/DEVELOPER_DOC.rst @@ -84,11 +84,12 @@ TO-BE-FINALIZED $ git commit -m "Preparing release " -- Tag the commit with the version +- Tag the commit with the version, using the "v' in front of the tag, + even if the version in the __init__.py file does not. .. code-block:: bash - $ git tag -a -m "Release version " + $ git tag -a v -m "Release version " - Make sure the `build` package is up-to-date: diff --git a/astronify/series/tests/test_series.py b/astronify/series/tests/test_series.py index 2e74ca7..eeeff98 100644 --- a/astronify/series/tests/test_series.py +++ b/astronify/series/tests/test_series.py @@ -58,13 +58,13 @@ def my_map_func(data): # dummy function class TestSoniSeries(object): - @classmethod - def setup_class(cls): +# @classmethod +# def setup_class(cls): - cls.data = Table({"time": [0, 1, 2, 3, 4, 5, 6], - "Flux": [1, 2, 1, 2, 5, 3, np.nan]}) +# cls.data = Table({"time": [0, 1, 2, 3, 4, 5, 6], +# "Flux": [1, 2, 1, 2, 5, 3, np.nan]}) - cls.soni_obj = SoniSeries(cls.data) +# cls.soni_obj = SoniSeries(cls.data) data = Table({"time": [0, 1, 2, 3, 4, 5, 6], "flux": [1, 2, 1, 2, 5, 3, np.nan]}) From e81f6cf9124075793e79dd1df3a93cc0ace0f3eb Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 31 Jan 2025 14:56:53 -0500 Subject: [PATCH 92/93] fixing conflict merge issues --- astronify/series/tests/test_series.py | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-) diff --git a/astronify/series/tests/test_series.py b/astronify/series/tests/test_series.py index eeeff98..c003244 100644 --- a/astronify/series/tests/test_series.py +++ b/astronify/series/tests/test_series.py @@ -57,15 +57,6 @@ def my_map_func(data): # dummy function class TestSoniSeries(object): - -# @classmethod -# def setup_class(cls): - -# cls.data = Table({"time": [0, 1, 2, 3, 4, 5, 6], -# "Flux": [1, 2, 1, 2, 5, 3, np.nan]}) - -# cls.soni_obj = SoniSeries(cls.data) - data = Table({"time": [0, 1, 2, 3, 4, 5, 6], "flux": [1, 2, 1, 2, 5, 3, np.nan]}) # defaults @@ -92,7 +83,9 @@ def test_server_class(self): assert isinstance(self.soni_obj.server, Server) def test_nans_removed(self): - assert len(self.soni_obj.data) == len(self.data) - 1 # nan row should be removed + assert ( + len(self.soni_obj.data) == len(self.data) - 1 + ) # nan row should be removed assert ~np.isnan(self.soni_obj.data["flux"]).any() def test_flux_type_correct(self): @@ -106,12 +99,16 @@ def test_sonify_new_columns_exist(self): assert "asf_onsets" in self.soni_obj.data.colnames def test_sonify_metadata(self): - assert self.soni_obj.data.meta['asf_exposure_time'] == 1 - assert self.soni_obj.data.meta['asf_note_duration'] == self.soni_obj.note_duration - assert self.soni_obj.data.meta['asf_spacing'] == self.soni_obj.note_spacing + assert self.soni_obj.data.meta["asf_exposure_time"] == 1 + assert ( + self.soni_obj.data.meta["asf_note_duration"] == self.soni_obj.note_duration + ) + assert self.soni_obj.data.meta["asf_spacing"] == self.soni_obj.note_spacing def test_onset_spacing(self): - onset_spacing = self.soni_obj.data['asf_onsets'][1:]-self.soni_obj.data['asf_onsets'][:-1] + onset_spacing = ( + self.soni_obj.data["asf_onsets"][1:] - self.soni_obj.data["asf_onsets"][:-1] + ) assert (np.isclose(onset_spacing, self.soni_obj.note_spacing)).all() def test_pitch_min_max(self): From 0c96a8b606a8ada7fdc031012220bff917e56499 Mon Sep 17 00:00:00 2001 From: Scott Fleming Date: Fri, 31 Jan 2025 14:58:17 -0500 Subject: [PATCH 93/93] another round of fixing conflict merge issues --- astronify/series/tests/test_series.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/astronify/series/tests/test_series.py b/astronify/series/tests/test_series.py index c003244..6e8e8bd 100644 --- a/astronify/series/tests/test_series.py +++ b/astronify/series/tests/test_series.py @@ -119,5 +119,3 @@ def test_pitch_min_max(self): # TODO: change args and test # TODO: test write - -