diff --git a/gw_eccentricity/__init__.py b/gw_eccentricity/__init__.py index 8581acf2..a038d851 100644 --- a/gw_eccentricity/__init__.py +++ b/gw_eccentricity/__init__.py @@ -8,3 +8,4 @@ from .gw_eccentricity import measure_eccentricity from .gw_eccentricity import get_available_methods +from .gw_eccentricity import truncate_at_flow diff --git a/gw_eccentricity/eccDefinition.py b/gw_eccentricity/eccDefinition.py index 73649535..1bbfbb87 100644 --- a/gw_eccentricity/eccDefinition.py +++ b/gw_eccentricity/eccDefinition.py @@ -440,6 +440,7 @@ def get_default_extra_kwargs(self): "treat_mid_points_between_pericenters_as_apocenters": False, "refine_extrema": False, "kwargs_for_fits_methods": {}, # Gets overriden in fits methods + "num_cycles_suggested": 6, } return default_extra_kwargs @@ -468,6 +469,9 @@ def drop_extra_extrema_at_ends(self, pericenters, apocenters): apocenters/pericenters before the first pericenters/apocenters then drop the extra apocenters/pericenters. """ + # If apocenters or pericenetrs is None then skip the whole thing + if apocenters is None or pericenters is None: + return pericenters, apocenters # At the end of the data pericenters_at_end = pericenters[pericenters > apocenters[-1]] if len(pericenters_at_end) > 1: @@ -672,6 +676,9 @@ def get_good_extrema(self, pericenters, apocenters, We also discard extrema before and after a jump (due to an extremum being missed) in the detected extrema. + NOTE: If apocenters/pericenters is NOT needed to be checked, provide it + as None + To retain only the good extrema, we first remove the extrema before/after jumps and then remove any extra extrema at the ends. This order is important because if we remove the extrema at the ends first @@ -710,14 +717,17 @@ def get_good_extrema(self, pericenters, apocenters, apocenters: 1d array of apocenters after dropping apocenters as necessary. """ - pericenters = self.drop_extrema_if_extrema_jumps( - pericenters, max_r_delta_phase22_extrema, "pericenters") - apocenters = self.drop_extrema_if_extrema_jumps( - apocenters, max_r_delta_phase22_extrema, "apocenters") - pericenters = self.drop_extrema_if_too_close( - pericenters, extrema_type="pericenters") - apocenters = self.drop_extrema_if_too_close( - apocenters, extrema_type="apocenters") + # Perform the drop extrema only when the input extrema is not None + if pericenters is not None: + pericenters = self.drop_extrema_if_extrema_jumps( + pericenters, max_r_delta_phase22_extrema, "pericenters") + pericenters = self.drop_extrema_if_too_close( + pericenters, extrema_type="pericenters") + if apocenters is not None: + apocenters = self.drop_extrema_if_extrema_jumps( + apocenters, max_r_delta_phase22_extrema, "apocenters") + apocenters = self.drop_extrema_if_too_close( + apocenters, extrema_type="apocenters") pericenters, apocenters = self.drop_extra_extrema_at_ends( pericenters, apocenters) return pericenters, apocenters @@ -771,26 +781,150 @@ def interp_extrema(self, extrema_type="pericenters"): self.omega22[extrema]) else: raise Exception( - f"Sufficient number of {extrema_type} are not found." - " Can not create an interpolant.") + f"Number of {extrema_type} is {len(extrema)}. " + "Cannot build interpolant.") + + def get_omega22_interpolants_at_extrema(self, extrema_type="both"): + """Get omega22 interpolants at the extrema. + + Parameters: + ----------- + extrema_type: str + Can be one of the followings: + - "pericenters": To get omega22_p(t), the interpolant of omega22 values + at the pericenters. + - "apocenters": To get omega22_a(t), the interpolant of omega22 values + at the apocenters. + - "both": To get the both omega22_p(t) and omega22_a(t) - def check_num_extrema(self, extrema, extrema_type="extrema"): - """Check number of extrema.""" + Returns: + -------- + A dictionary with the following keys: + "pericenters": Interpolant of omega22 at the pericenters. + Included when `extrema_type` is "pericenters" or "both". + "apocenters": Interpolant of omega22 at the apocenters. + Included when `extrema_type` is "apocenters" or "both". + """ + # Get the pericenters and apocenters + if extrema_type in ["both", "pericenters"]: + pericenters = self.find_extrema("pericenters") + # make a copy to compare it after passing through chekcks + # and dropping bad ones along the way. + original_pericenters = pericenters.copy() + # in case no extrema are found but the data has enough cycles, + # it is assumed that the waveform is quasicircular + self.check_quasicircular(pericenters, "pericenters") + if self.is_quasicircular: + # when the waveform is assumed to be quasicircular, + # there are no unique locations of pericenters/apoceneters + # and pericenrers should be the same as the apoceneters. + # Therefore, we can choose the peri-/apocenters to be + # num_cycles equidistant points. + self.pericenters_location = np.linspace(0, len(self.t)-1, int(self.num_cycles)).astype(int) + else: + pericenters = None + original_pericenters = pericenters + if extrema_type in ["both", "apocenters"]: + # In some cases it is easier to find the pericenters than finding + # the apocenters. For such cases, one can only find the pericenters + # and use the mid points between two consecutive pericenters as the + # location of the apocenters. + if self.extra_kwargs[ + "treat_mid_points_between_pericenters_as_apocenters"]: + apocenters = self.get_apocenters_from_pericenters(pericenters) + else: + apocenters = self.find_extrema("apocenters") + original_apocenters = apocenters.copy() + self.check_quasicircular(apocenters, "apocenters") + if self.is_quasicircular: + self.apocenters_location = np.linspace(0, len(self.t)-1, int(self.num_cycles)).astype(int) + else: + apocenters = None + original_apocenters = apocenters + if not self.is_quasicircular: + # Choose good extrema + self.pericenters_location, self.apocenters_location \ + = self.get_good_extrema(pericenters, apocenters) + # Check if we dropped too many extrema. + self.check_if_dropped_too_many_extrema(original_pericenters, + self.pericenters_location, + "pericenters", 0.5) + self.check_if_dropped_too_many_extrema(original_apocenters, + self.apocenters_location, + "apocenters", 0.5) + if extrema_type == "both": + # check that pericenters and apocenters are appearing alternately + self.check_pericenters_and_apocenters_appear_alternately() + # check extrema separation and build interpolants + interpolants_dict = {} + if extrema_type in ["both", "pericenters"]: + if not self.is_quasicircular: + self.orb_phase_diff_at_pericenters, \ + self.orb_phase_diff_ratio_at_pericenters \ + = self.check_extrema_separation(self.pericenters_location, + "pericenters") + interpolants_dict.update( + {"pericenters": self.interp_extrema("pericenters")}) + if extrema_type in ["both", "apocenters"]: + if not self.is_quasicircular: + self.orb_phase_diff_at_apocenters, \ + self.orb_phase_diff_ratio_at_apocenters \ + = self.check_extrema_separation(self.apocenters_location, + "apocenters") + interpolants_dict.update( + {"apocenters": self.interp_extrema("apocenters")}) + return interpolants_dict + + def check_quasicircular(self, extrema, extrema_type="extrema"): + """Check if the waveform is quasicircular. + + This function checks the number of extrema and approximate number + of cycles in the waveform to decide whether the waveform + could be assumed to be quasicircular in case of no extrema. + """ + # by default we always take the waveform to be NOT quasicircular + self.is_quasicircular = False num_extrema = len(extrema) - if num_extrema <= 2: - message = f"Only {num_extrema}" \ - if num_extrema > 0 else "No" - recommended_methods = ["ResidualAmplitude", "AmplitudeFits"] - if self.method not in recommended_methods: - method_message = (f" Possibly `{self.method}` method is not " - f"efficient to detect the {extrema_type}." - f" Try one of {recommended_methods}.") + if num_extrema < 2: + # check if the waveform is quasicircular + # Number of extrema could be < 2 if the waveform is quasicircular + # To decide that, we check the number of cycles in the data. If it + # is > num_cycles_suggested, then it is assumed to be quasicircular. + if not hasattr(self, "num_cycles_suggested"): + self.num_cycles_suggested = self.extra_kwargs["num_cycles_suggested"] + if not hasattr(self, "num_cycles"): + self.num_cycles = abs(self.phase22[-1] - self.phase22[0]) / (4 * np.pi) + if self.num_cycles < self.num_cycles_suggested: + warnings.warn(f"Number of cycles = {self.num_cycles} < suggested {self.num_cycles_suggested}.\n") + raise Exception( + f"{len(extrema)} {extrema_type} found. Can not create interpolants.\n") else: - method_message = "" - warnings.warn(f"{message} {extrema_type} found. There can be " - "problem when building interpolant through the " - f"{extrema_type}.{method_message}") - + warnings.warn( + f"Number of cycles = {self.num_cycles} >= suggested {self.num_cycles_suggested}" + f" but number of {extrema_type} is {len(extrema)}.") + # TODO check the width for find_peaks. It should not be > number of index for 4pi phase22 diff. + # amp and freq methods are not always the best choice, issue warning to suggest better methods. + if self.method in ["Amplitude", "Frequency"]: + recommended = ["ResidualAmplitude", "AmplitudeFits"] + message = (f"{self.method} method might not be efficient in detecting " + "extrema for small eccentricity (< 1e-3). " + f"Using {recommended} method might give better result.") + # residual methods are more robust compared to fits. Issue warning to suggest residual methods. + elif "Fits" in self.method: + recommended = ["ResidualAmplitude", "ResidualFrequency"] + message = ("Using {recommended} method might give better result.") + else: + message = "" + if len(extrema) == 0: + warnings.warn( + "Assuming the waveform to be quasicircular.\n" + f"{message}") + self.is_quasicircular = True + else: + raise Exception( + f"Only {len(extrema)} {extrema_type} found. Can not create interpolants.\n" + f"{message}") + def check_if_dropped_too_many_extrema(self, original_extrema, new_extrema, extrema_type="extrema", threshold_fraction=0.5): @@ -810,6 +944,8 @@ def check_if_dropped_too_many_extrema(self, original_extrema, new_extrema, When num_dropped_extrema > threshold_fraction * len(original_extrema), an warning is raised. """ + if original_extrema is None: + return num_dropped_extrema = len(original_extrema) - len(new_extrema) if num_dropped_extrema > (threshold_fraction * len(original_extrema)): warnings.warn(f"More than {threshold_fraction * 100}% of the " @@ -899,47 +1035,10 @@ def measure_ecc(self, tref_in=None, fref_in=None): Measured mean anomaly at tref_out/fref_out. Same type as tref_out/fref_out. """ - # Get the pericenters and apocenters - pericenters = self.find_extrema("pericenters") - original_pericenters = pericenters.copy() - self.check_num_extrema(pericenters, "pericenters") - # In some cases it is easier to find the pericenters than finding the - # apocenters. For such cases, one can only find the pericenters and use - # the mid points between two consecutive pericenters as the location of - # the apocenters. - if self.extra_kwargs[ - "treat_mid_points_between_pericenters_as_apocenters"]: - apocenters = self.get_apocenters_from_pericenters(pericenters) - else: - apocenters = self.find_extrema("apocenters") - original_apocenters = apocenters.copy() - self.check_num_extrema(apocenters, "apocenters") - # Choose good extrema - self.pericenters_location, self.apocenters_location \ - = self.get_good_extrema(pericenters, apocenters) - - # Check if we dropped too many extrema. - self.check_if_dropped_too_many_extrema(original_pericenters, - self.pericenters_location, - "pericenters", 0.5) - self.check_if_dropped_too_many_extrema(original_apocenters, - self.apocenters_location, - "apocenters", 0.5) - # check that pericenters and apocenters are appearing alternately - self.check_pericenters_and_apocenters_appear_alternately() - # check extrema separation - self.orb_phase_diff_at_pericenters, \ - self.orb_phase_diff_ratio_at_pericenters \ - = self.check_extrema_separation(self.pericenters_location, - "pericenters") - self.orb_phase_diff_at_apocenters, \ - self.orb_phase_diff_ratio_at_apocenters \ - = self.check_extrema_separation(self.apocenters_location, - "apocenters") - # Build the interpolants of omega22 at the extrema - self.omega22_pericenters_interp = self.interp_extrema("pericenters") - self.omega22_apocenters_interp = self.interp_extrema("apocenters") + interpolant_dict = self.get_omega22_interpolants_at_extrema("both") + self.omega22_pericenters_interp = interpolant_dict["pericenters"] + self.omega22_apocenters_interp = interpolant_dict["apocenters"] self.t_pericenters = self.t[self.pericenters_location] self.t_apocenters = self.t[self.apocenters_location] @@ -1603,6 +1702,8 @@ def get_omega22_average(self, method=None): - t_average_pericenters: temporal midpoints between pericenters. These are associated with orbit_averaged_omega22_pericenters """ + if self.is_quasicircular: + return self.t, self.omega22 if method is None: method = self.extra_kwargs["omega22_averaging_method"] if method != "orbit_averaged_omega22": @@ -2746,3 +2847,95 @@ def get_width_for_peak_finder_for_dimless_units( Minimal width to separate consecutive peaks. """ return int(width_for_unit_timestep / (self.t[1] - self.t[0])) + + def truncate_at_flow(self, flow, m_max=None): + """Truncate waveform data at flow. + + Eccentric waveforms have a non-monotonic instantaneous frequency. + Therefore, truncating the waveform by demanding that the truncated + waveform should contain all frequencies that are greater than or equal + to a given minimum frequency, say flow, must be done carefully since + the instantaneous frequency can be equal to the given flow at multiple + points in time. + + We need to find the time tlow, such that all the frequencies at t < + tlow are < flow and therefore the t >= tlow part of the waveform would + retain all the frequencies that are >= flow. Note that the t >= tlow + part could contain some frequencies < flow but that is fine, all we + need is not to lose any frequencies >= flow. + + This can be done by using the frequency interpolant omega22_p(t) + through the pericenters because + 1. It is a monotonic function of time. + 2. If at a time tlow, omega22_p(tlow) * (m_max/2) = 2*pi*flow, then all + frequencies >= flow will be included in the waveform truncated at + t=tlow. The m_max/2 factor ensures that this statement is true for all + modes, as the frequency of the h_{l, m} mode scales approximately as + m/2 * omega_22/(2*pi). + + Thus, we find tlow such that omega22_p(tlow) * (m_max/2) = 2*pi*flow + and truncate the waveform by keeping only the part where t >= tlow. + + Parameters: + ----------- + flow: float + Lower cutoff frequency to truncate the given waveform modes. + The truncated waveform modes will contain all the frequencies >= flow. + + m_max: int + Maximum m (index of h_{l, m}) to account for while setting the tlow + for truncation. If None, then it is set using the highest available + m from the modes in the dataDict. + Default is None. + """ + if not hasattr(self, "omega22_pericenters_interp"): + interpolant_dict = self.get_omega22_interpolants_at_extrema("pericenters") + self.omega22_pericenters_interp = interpolant_dict["pericenters"] + # If m_max is not provided, get the highest available m from the dataDict + if m_max is None: + modes = self.dataDict["hlm"].keys() + m_max = max([m for (l, m) in modes]) + # Find time where omega22_apocenter_interp(tlow) = 2 * pi * flow + tmin = self.t[self.pericenters_location[0]] + tmax = self.t[self.pericenters_location[-1]] + + self.t_pericenters_interp = self.t[ + np.logical_and(self.t >= tmin, + self.t <= tmax)] + self.f22_pericenters_interp \ + = self.omega22_pericenters_interp(self.t_pericenters_interp)/2/np.pi + + self.flow_for_truncating = flow + # check if the waveform is long enough to contain any frequency above flow + idx_arr = np.where( + self.f22_pericenters_interp * (m_max/2) >= self.flow_for_truncating)[0] + if len(idx_arr) == 0: + max_freq = self.f22_pericenters_interp[-1] + raise Exception("The waveform is too short. Found no frequency >= " + f"{self.flow_for_truncating}. Maximum (2, 2) mode frequency is {max_freq}") + else: + idx_low = idx_arr[0] + # check if the frequency at the first pericenter is higher than flow. + # This would imply that the waveform should be generated using a smaller + # initial frequency. + freq_at_first_peri = self.omega22[self.pericenters_location[0]]/2/np.pi + if freq_at_first_peri > self.flow_for_truncating: + raise Exception("The waveform is not long enough. The (2, 2) frequency at the " + f"first pericenter = {freq_at_first_peri} is greater than" + f" flow = {self.flow_for_truncating}. Try generating the waveform" + " using a smaller initial frequency.") + + self.tlow_for_truncating = self.t_pericenters_interp[idx_low] + + # truncate dataDict + self.dataDict_trucated_at_flow = copy.deepcopy(self.dataDict) + for mode in self.dataDict_trucated_at_flow["hlm"]: + self.dataDict_trucated_at_flow["hlm"][mode] \ + = self.dataDict_trucated_at_flow["hlm"][mode][ + self.dataDict_trucated_at_flow["t"] >= self.tlow_for_truncating] + self.dataDict_trucated_at_flow["t"] = self.dataDict_trucated_at_flow["t"][ + self.dataDict_trucated_at_flow["t"] >= self.tlow_for_truncating] + + return self.dataDict_trucated_at_flow + + diff --git a/gw_eccentricity/gw_eccentricity.py b/gw_eccentricity/gw_eccentricity.py index 4d098837..c4b5ec37 100644 --- a/gw_eccentricity/gw_eccentricity.py +++ b/gw_eccentricity/gw_eccentricity.py @@ -339,3 +339,81 @@ def measure_eccentricity(tref_in=None, else: raise Exception(f"Invalid method {method}, has to be one of" f" {list(available_methods.keys())}") + + +def truncate_at_flow(flow, + m_max=None, + method="Amplitude", + dataDict=None, + extra_kwargs=None): + """Truncate waveform at flow. + + Eccentric waveforms have a non-monotonic instantaneous frequency. + Therefore, truncating the waveform by demanding that the truncated + waveform should contain all frequencies that are greater than or equal + to a given minimum frequency, say flow, must be done carefully since + the instantaneous frequency can be equal to the given flow at multiple + points in time. + + We need to find the time tlow, such that all the frequencies at t < + tlow are < flow and therefore the t >= tlow part of the waveform would + retain all the frequencies that are >= flow. Note that the t >= tlow + part could contain some frequencies < flow but that is fine, all we + need is not to lose any frequencies >= flow. + + This can be done by using the frequency interpolant omega22_p(t) + through the pericenters because + 1. It is a monotonic function of time. + 2. If at a time tlow, omega22_p(tlow) * (m_max/2) = 2*pi*flow, then all + frequencies >= flow will be included in the waveform truncated at + t=tlow. The m_max/2 factor ensures that this statement is true for all + modes, as the frequency of the h_{l, m} mode scales approximately as + m/2 * omega_22/(2*pi). + + Thus, we find tlow such that omega22_p(tlow) * (m_max/2) = 2*pi*flow + and truncate the waveform by keeping only the part where t >= tlow. + + Parameters: + ----------- + flow: float + Lower cutoff frequency to truncate the given waveform modes. + The truncated waveform modes will contain all the frequencies >= flow. + + m_max: int + Maximum m (index of h_{l, m}) to account for while setting the tlow + for truncation. If None, then it is set using the highest available + m from the modes in the dataDict. + Default is None. + + method: str + Method to use for finding extrema locations. + See under `measure_eccentricity` for more details. + + dataDict: dict + Dictionary containing waveform modes. + See under `measure_eccentricity` for more details. + + extra_kwargs: dict + Dictionary of kwargs used to find the extrema or build the interpolants. + See under `measure_eccentricity` for more details. + + Returns: + truncatedDataDict: dict + Dictionary containing waveform data truncated at flow. + + gwecc_object: obj + Object used for truncating data. + """ + available_methods = get_available_methods(return_dict=True) + + if method in available_methods: + gwecc_object = available_methods[method]( + dataDict, num_orbits_to_exclude_before_merger=0, + extra_kwargs=extra_kwargs) + truncatedDataDict = gwecc_object.truncate_at_flow(flow, m_max) + return truncatedDataDict, gwecc_object + else: + raise Exception(f"Invalid method {method}, has to be one of" + f" {list(available_methods.keys())}") + + diff --git a/gw_eccentricity/truncate_waveform_by_flow.py b/gw_eccentricity/truncate_waveform_by_flow.py deleted file mode 100644 index 87306e15..00000000 --- a/gw_eccentricity/truncate_waveform_by_flow.py +++ /dev/null @@ -1,117 +0,0 @@ -"""Truncate waveform by flow.""" -from gw_eccentricity import get_available_methods -import numpy as np -import copy - - -def truncate_waveform_by_flow(dataDict=None, - flow=None, - m_max=None, - method="Amplitude", - extra_kwargs=None): - """Truncate waveform by flow. - - Eccentric waveforms have a non-monotonic instantaneous frequency. - Therefore, truncating the waveform by demanding that the truncated waveform - should contain all frequencies that are greater than or equal to a given - minimum frequency, say flow, must be done carefully since the instantaneous - frequency can be equal to the given flow at multiple points in time. - - We need to find the time tlow, such that all the frequencies at t < tlow - are < flow and therefore the t >= tlow part of the waveform would - retain all the frequencies that are >= flow. Note that the t >= tlow part - could contain some frequencies < flow but that is fine, all we need is not - to lose any frequencies >= flow. - - This could be done by using the frequency interpolant omega22_p(t) through - the pericenters because - 1. It is a monotonic function of time. - 2. If at a time tlow, omega22_p(tlow) * (m_max/2) = 2*pi*flow, then all - frequencies >= flow will be included in the waveform truncated at - t=tlow. The m_max/2 factor ensures that this statement is true for all - modes, as the frequency of the h_{l, m} mode scales approximately as m/2 * - omega_22/(2*pi). - - Thus, we find tlow such that omega22_a(tlow) * (m_max/2) = 2*pi*flow and - truncate the waveform by keeping only the part where t >= tlow. - - Paramerers: - ----------- - datadict: dict - Dictionary containing waveform data in the following format: - dataDict = {"t": t, - "hlm": hlm}, - where t is the time array and hlm is a dictionary of waveform modes - of the following format: - hlm = {(l, m): lm_mode} - flow: float - Lower cutoff frequency to truncate the given waveform modes. - The truncated waveform would have all the frequencies that are >= flow. - m_max: int - Maximum m (index of h_{l, m}) to account for while setting the tlow - for truncation. If None, then it is set using the highest available - m from the modes in the dataDict. - Default is None. - method: str - Method to find the locations of the apocenters. Default is "Amplitude". - See gw_eccentricity.get_available_modes for available modes. - extra_kwargs: dict - Dictionary of arguments that might be used for extrema finding routine. - Default values are set using eccDefinition.get_default_extra_kwargs. - - Returns: - -------- - truncatedDict: dict - Dictionary containing the truncated waveform. - Has the same type as dataDict. - gwecc_object: obj - Object used to truncate the dataDict. - """ - if dataDict is None: - raise ValueError("dataDict can not be None.") - available_methods = get_available_methods(return_dict=True) - - if method in available_methods: - gwecc_object = available_methods[method](dataDict, - extra_kwargs=extra_kwargs) - # Get the pericenters - pericenters = gwecc_object.find_extrema("pericenters") - original_pericenters = pericenters.copy() - gwecc_object.check_num_extrema(pericenters, "pericenters") - # Get the good pericenters - pericenters = gwecc_object.drop_extrema_if_extrema_jumps( - pericenters, 1.5, "pericenters") - gwecc_object.pericenters_location = gwecc_object.drop_extrema_if_too_close( - pericenters, extrema_type="pericenters") - # Build the interpolants of omega22 at the extrema - gwecc_object.omega22_pericenters_interp = gwecc_object.interp_extrema("pericenters") - # If m_max is not provided, get the highest available m from the dataDict - if m_max is None: - modes = gwecc_object.dataDict["hlm"].keys() - m_max = max([m for (l, m) in modes]) - # Find time where omega22_apocenter_interp(tlow) = 2 * pi * flow - tmin = gwecc_object.t[gwecc_object.pericenters_location[0]] - tmax = gwecc_object.t[gwecc_object.pericenters_location[-1]] - gwecc_object.t_pericenters_interp = gwecc_object.t[ - np.logical_and(gwecc_object.t >= tmin, - gwecc_object.t <= tmax)] - gwecc_object.f22_pericenters_interp \ - = gwecc_object.omega22_pericenters_interp(gwecc_object.t_pericenters_interp)/2/np.pi - - idx_low = np.where( - gwecc_object.f22_pericenters_interp * (m_max/2) >= flow)[0][0] - tlow = gwecc_object.t_pericenters_interp[idx_low] - - truncatedDict = copy.deepcopy(dataDict) - for mode in truncatedDict["hlm"]: - truncatedDict["hlm"][mode] \ - = truncatedDict["hlm"][mode][truncatedDict["t"] >= tlow] - truncatedDict["t"] = truncatedDict["t"][truncatedDict["t"] >= tlow] - - gwecc_object.method = method - gwecc_object.m_max = m_max - gwecc_object.tlow_for_trucating = tlow - gwecc_object.truncatedDict = truncatedDict - gwecc_object.f_low_for_truncating = flow - - return truncatedDict, gwecc_object diff --git a/notebook/truncate_waveform_at_flow.ipynb b/notebook/truncate_waveform_at_flow.ipynb new file mode 100644 index 00000000..fa716322 --- /dev/null +++ b/notebook/truncate_waveform_at_flow.ipynb @@ -0,0 +1,305 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "359ce4e3-567a-4f45-9f25-553f7af87906", + "metadata": {}, + "source": [ + "### Example notebook on how to truncate waveform by `flow`" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e72a7544-cd62-4d2a-99c6-f4fd0d029871", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "import sys\n", + "sys.path.append(\"../\")\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "from gw_eccentricity.plot_settings import use_fancy_plotsettings, labelsDict, colorsDict\n", + "from gw_eccentricity import measure_eccentricity, truncate_at_flow\n", + "from gw_eccentricity.utils import amplitude_using_all_modes, peak_time_via_quadratic_fit\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "sys.path.append(\"/home1/md.shaikh/Eccentricity/EccTests/EOBTests/\")\n", + "import seobnrv4ehm as seob" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "067a3b07-dc99-4265-8816-3b24322c0a4d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "q = 4\n", + "chi1 = 0.6\n", + "chi2 = -0.4\n", + "ecc = 0.0005\n", + "f_min = 30\n", + "M = 50\n", + "EccIC=-1\n", + "mean_anomaly = np.pi/2\n", + "t, hlm = seob.get_modes(q=q, chi1=chi1, chi2=chi2, eccentricity=ecc, eccentric_anomaly=mean_anomaly, f_min=f_min, M_fed=M, physical_units=True, EccIC=EccIC, save=False)\n", + "plt.plot(t, np.abs(hlm[(2, 2)]))" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "5c619b6a-3f0b-446f-9c32-380e4cba3d04", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.0, 50.0)" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(t, np.gradient(-np.unwrap(np.angle(hlm[(2, 2)])), t)/(2*np.pi))\n", + "plt.ylim(0, 50)" + ] + }, + { + "cell_type": "markdown", + "id": "3b0a48c4-4526-41d7-a708-23e7abe7ee5d", + "metadata": {}, + "source": [ + "Truncate at `flow=20`" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "76092de4-bb84-47e2-9c96-db01cdd6911c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home1/md.shaikh/Eccentricity/notebook/../gw_eccentricity/eccDefinition.py:919: UserWarning: Assuming the waveform to be quasicircular.\n", + "Frequency method might not be efficient in detecting extrema for small eccentricity (< 1e-3). Using ['ResidualAmplitude', 'AmplitudeFits'] method might give better result.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAEQCAYAAABFtIg2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAApnklEQVR4nO3deXhb5Zk28PsN2WwnQbaTkIWERCaQsKRBtglQthKJfkzTMhQpLNOhhWnkoVOmQ9uxSIeBfO3XBpm2M9PSGaQwpaUtEKzSQtppghQoU9bEFjsJIVICJCGLYyurk9jx8/2ho4Os+NiWLfscSffvunTZes/26MQ5j97lnFeJCIiIiHoywuwAiIjIupgkiIjIEJMEEREZYpIgIiJDTBJERGSISYKIiAwxSRARkSFTkoRSyq2UsmWU2ZVSAW2ZP315b8uIiGjojBzOg2kXdy8AP4AqAIm0xWEALhGJK6XiAJq1dfpaRkREQ2RYaxIikhCRhsxypZRbWx7XfkYBVCilnL0tG77IiYiK07DWJHpRCyCeUdYKwAGgspdlkcwdzZs3T1paWvT3c+fOxbx583IaLBEVjuPH23Hw5UdRcfltUErlbL/rtm/COeVTMbXs1Jztc6isXLkyIiKunpZZJUnY0b3pCdr7yj6WneSyyy5DMBjMaXBEVLje2/gX7H7gGVz+s5U53e9Nax/C7eddgcunz8npfofCypUrtxots8ropjgAW0aZDUCsj2VERIOyY3QZfn/Z7WaHYVlWSRIbkKwxpKsA0NTHMiKiQdm9bzvGV840OwzLskSSEJEQoI9+glLKAaBJRKK9LTMnWiIqJGUv/woXfvCy2WFYlllDYAHArZQKikhCe+8C4FdKNQOoBlCXtmlvy4iIBky1bUfJ7Gqzw7CsYU0SWkJo0F6Zy+IwuPj3toyIaDDG7t+N8qlnmx2GZVmiuYmIyCzhKedhyiyH2WFYFpMEERWt9s7j+O3U+Tht4gyzQ7EsJgkiKlofbVmPB6K/xgjFS6ERnhkiKlotOzcCY8eZHYalMUkQUdHav2MjOip4j0RvmCSIqGjt7uwAZteaHYalMUkQUdEKT1uAsotuMjsMS2OSsLBIJILy8nKUl5fD5/OhoaEBPp8P1dXV8Pl8vW4bjUbh8/kQCoV6fG8VDQ0NCAaDqKqqQiKRMDscKjJX/eVBzB7Jy2BveHYszOl0wul0wm63w+/3o76+Hn6/H83Nzais7PEhuDqHw4FoNIoNGzb0+N4KQqEQYrEYvF4vwuEwbDab2SFREWlvP4SFO9/AjIlnmB2KpTFJWFxFRUWP5fX19X1um3nRtdpFOD1h2e2Zz3AkGlofbnsN+0orMGrUGLNDsTQmiTyUamoKBoNQSiEejyORSMDj8aC6Ovtn0IRCISilEAqFkEgkUF1djerqar35x+Px6M1UPp8PkUgEPp9PjyMSiUAppb9P7SMajer7DwaD8Hg83baJRCJoampCMBjUjxWJRPQmKI/Hg0gkou+jurpab5pqaGhANBpFdXU1GhoaUFdXp5dHIhHU1dWhvLxcj4Eo064d7+CgbbrZYVieVSYdMs3pD9817Mfcfut9Wa0fj8f1i2soFILTmZy51ev1oq4u+Ugrm80Gl8uFQCCQdTxutxsOhwOtra2w2Wzw+/3weDx6zcNut8PtdiORSCAUCsHv98PpdEIppf/u9XoRj8f1WJxOp97EtWrVKjQ2NmLJkiUoLy+Hy+WC0+lETU2N/jmAT/pNmpubASSb26qqqhCLxeB2u+HxeJBIJPTlNptNTy6BQEBPGrFYDIFAADabDStWrEBjY2PW54QK39uT56Jt8b1YbHYgFlf0SSLbC7YZUn0SAOD3+/vstB6IZcuWwefzwev1IhqNoqKiApFIBBUVFaitTQ4RtNlsiMViiMfj+jf0RCIBm80Gn8+ndz6nvskDwKpVqwBAny0wlWx6smrVqm7NTna7HXa7HZFIRE8kTqezW7OZzWbTt8n8WVVVpddEiDJ1vbUGZ8+uMTsMy2NzUx5KJYxccrvdaG1tRSQSwb59++Dz+eD3+7Fq1Sq43W4A0Ju0UuunS9U2VqxYgXg8rl+oE4kE7HY7vF4vvF4vGhsbT9o2Xao2kmK1fhQqHGc3hzALHWaHYXlMEhbX2tra5zqpC2uqGWagvF4vPB4Pli1bBq/Xi6ampm6jqJ544glEo1HY7fYeawPLli1DQ0MDHI5PnqjpcrkQDAb1mkc8Hjecg7yurg7RaLRbokgkEliyZIlhzD3FwaG01Jeuri5M3r8D9rMvNTsUy2OSsLBQKIRIJIJoNGp4Ya2vr4fH44HH40FVVRWAZNt++ivVPJT+viep5JD69p56n5LqC3G5XIhEInA4HFi6dKm+3OFwwOv16usByRqH1+vFokWLUFVVhUAgoDdppTqvU01Cdrsd4XAYPp8PwWAQDQ0NaGxshM1m0zvOA4GAngRSnyUcDiORSOjnKNURHg6HEY/HDT8vFa/t29/G0ZFjUFnJp7/2RYmI2THklNfrFaMLKhERAETir+OP65/Cv91475Ad46a1D+H2867A5dPnDNkxckUptVJEvD0tY02CiIrOBx+9jalTh/7iLcj/L+FMEkRUdCY9H4Bj7+YhPYaCGtL9D5eiHwJLRMVnfMtWTDxzodlh5AXWJIioqBw/fhQTD+2F/axPmx1KXmCSIKKi8n7Ldqw6/1qUlU4wO5S8wCRBREXlzcTHOOj4otlh5A0mCSIqKmWrv4+rt/PBj/3FJEFERaX0402YNudis8PIGxzdRERFo739ECYf+BhV537G7FDyBmsSNOz4mAwyy3u73scL9k+jrMxmdih5g0nCwlwuF6qrq1FXV4fq6mp9Yp+6ujp9sqF84/F44HK5zA6jG86zXTzeOHoUsSu/ZnYYeYXNTRaWeuAdkLyQxeNx/THhA5mBLtfi8TgqKiqyepx3XV2dPteEFaTm2Q4EAifNVUGFp+SPK3DF3CvNDiOvsCZhYb3NG+H1ek2dFzoej1siUQ0W59kuLlO2voozz5hvdhh5hUnCwvr6VtvTvM+9zXsdiUT09VNzQKcewZ1aHgwGEQwG4XK59KaXnua1Tu0/fa6InuayTu03FZvR9KqcZ5uG2u7dMYw7dghnzbvC7FDyi4gU1Gvp0qWSjb1PLpf3vjxCf7VvbZL2rU3dyvY+uVxERLZ8Y7petu2eGhER2fVzb7d1O1p3yMHo093K2p4LiIh021e2/H6/2Gy2k8oBiN/vl7a2Nmlra9PLYrGYiIgEAgFxOBz6+jabTQKBgL7P1LJYLCZut1tfz+v1Sjgclra2NrHb7d2Ol/576pjNzc369m1tbQJAwuGwxGKxbscPBALd9pfO4XDosYXD4W6ft76+Xt+3UTxer7fbZ0htYxRbahuv16tv09zc3C3eWCzW7Xz2dL7tdrv4/X59+/T16+vru8VE5gm/8Kg8/t3Lh+14N615SP68/b1hO95gAAiKwTW16PskJl53LyZed/Iz5c/6xYmTyqr+fftJZafdGsBpt3b/djyufFqP2/dUlgvZtqWnmlUcDof+zT4QCOhzWafepxjNa53OaC7rUCiEmppP5hHurUmH82zTUHph5DhMvHa52WHkHUs1NymlnEopv1LKq5QKKKUcacvsWplbW8dmYqgFJ5FIIBaL9VhuNK915no9zWUdi8X6NQVrav+cZ5uGyunP/AgLx5aYHUbesVSSANAoIj4RCQIIAFiZtiwMwC8iIQCrAAxuQuc8s2/fvqyGZ2Y773VqLurUt97UVKd9zWudOo7RXNYul0vvZwCSF+zekgbn2aahcOBgC2q3vYLzZ55vdij5x6gdyowXAAHg0H53Aghov7sBxDLWbQPgzNxHtn0S+SAcDovdbu/WHi4i0tjYKADE6/XqZSLJdnCbzSZut1vvd2hubpZwOCwApL6+Xtra2sTtdgsAaW5uFpFP+j1sNpvexh6LxcRut4vT6ZTGxkZxOBx6G7vX6xWHwyGNjY3djmu32/X+gFS53W4Xt9utb5PqE8jU1tbWbdv0z9tXPCnpfQyZ5yQ9tubmZrHb7WK327vFEw6Hxe12SyAQEL/fr5+fns53qg8iVeb3+7v9O7ndbrHZbHofBZnjxXUrZc235gzrMQulT8JSc1wrpeoB+AH4AFSKiE8r9yOZPFxp68aQTCIN6fvgHNdElKnxv76MkhGnYHHdz4ftmDev/W/UnXcZrph+1rAdc6DyZo5r7YIfQjJR2NIW2QEkMlZPAKjMKMPGjRtRU1Ojv5gwiOjBKQsw/a/vMTuMvGSp0U1KqQCSfRE+AGGlVKOIeADEATgyVrcBOKmndd68eUwMRKTb+fFmLNy4FvOv/YbZoeQly9QktNFKS0QkIiJxAC4Abq18A5K1iXQVAJqGNUgiyjvvvvQYLj6WwCkjLHO5yyuWPWtaokiISEKSI5pSiQTa0NgmEeGtrETUqyPvRDD6nEVmh5G3LNPcJCIJpdRSrcmpGUA1AE/aKi4AfqVUapl1nhJHRJbUeeIEJu94E1Nv+akpx7fOsKCBs0ySAACtxhAyWBYHEwMRZeH1lu34/lX1WD1rwbAfWw37EYeGZZubiIgG680/P4RrJk0zO4y8xiRBRAWpq6sLc54P4LKKKWaHkteYJIioIG3Z/CJGdnXg3PmfNTuUvGapPgkiolzZ/JdfoevMT2MEh74OCs9eHkpNiGOFaUAjkQhcLhfKy8tPmru6t2Xp61RVVUEphYaGT56w0tDQAKUUH7VNAxaceDYmXsu7rAeLSSLPBINB2Gw2/WmpZkokEkgkEgiHw2hra+v2dNXelqVzOp1wu92w2Wyor6/Xy1O/u91uOJ3O4flAVDDejzVh0vY3sbCqpu+VqVdFnySUUlCq+2C1z3/+81BKYfXq1XpZalrQ1MQzALBz504opTBtWvfRE9XV1VBKdXtM9/Lly086zkD4/X79sdVmXzxtNlu3eRkcDoc+wVBvy7LZf/pjwon6a9Oaf8e1nQd5l3UOsE8iT0SjUX22uCeeeAJTpkzBpk2bun37HqhEIoEVK1b0uk5lZWWvxwoGg7Db7d3mcejPsv6KRqNYsWKFPve2z+frc/IgKk5dXV0of2ctTvU+YnYoBaHok0RPj0pPr0GkpGY1Szdt2rQet+9pop/ly5dj+fLlA47T4XCgqqpKjwUA7rzzzpwkCZvNBr/fP+Dtg8EgGhsbEYlETkomvS1Ll7rwZ5alx9jY2AggOYmQ2+1mgqAevdG8GidGjOSoplwxmmgiX1+FOOlQitvt1if4ERGx2+0mRnOy1KRF2S5LTQiUKX3yo5RAICA2m63bRERE6er/0igPvrDK7DDk5jUPyXMFMOlQ0dck8kkkEjH8xu/z+VBbW4twOAy/349gMIhwOIzGxkZUV1fD7/fD7XbD5XIhHA532zYXzU1AsoaTahLLZll/JRIJ1NXVIRwOc95p6tGBgy049uIjuPaOX5sdSsFgksgTqaYXuz3zienJ4aK1tbVwu91obW2Fz+dDIBBAIBDQO5BTczb3NGx2MM1NiURCv2A3NTV1239vy/q773379unvPR4PvF6v3mEfiURM77wna3n5D/fDeXgXppROMDuUgsGu/zzR1NRkeEHcsGGD/rvT6URTU5P+ezQaRWVlJVatWoVQKJTTdvxoNIrq6mp4PB6EQsnnMqZqG70tSxeJRBAKhZBIJLoNkU3dMxEKhRCNRhEMBvV7KoLBIBoaGvQ+CiIg2WE96pVHUbnodrNDKSisSeSJcDhseENabW0tNmzYoNcYUsmkrq4OHo8H4XAYGzZs0NfJFYfDgVjspMkB+1yWzul09rhefX19t6TicDhOGjhAlO7Nd57FqI6juPDSvzU7lILCmoTFpe42jkaj3S6SkUgE8Xgc8Xgc9fX1SCQS+rfuZcuWAUheWN1uN+x2O+rq6nDDDTeY8hmIhsNDrS1479Zf4pRT+N03l3g2Lc7v9yORSJzUZ+B0OrsNvzXqFE5tx7Z7KmQffvAGbC88jCX//JTZoRQcJgmLyxyJREQnez10Dy4cNwETRo81O5SCwyRBRHltX+t2TN8YwZT/22R2KAWJfRJElNfWPPtzbLdfgunT55kdSkFikiCivNV29DDuOw7M/9qjZodSsJgkiChvPf/ff4+vd+7HbNsks0MpWOyTIKK8tHt3DDNe/x1q7nnV7FAKGpMEEeWlV391J3D2Vaieca7ZoRhKH6aer9jcRER5Z3PbLrxz+AAu/vJPzA7FWA4mGbMCJgkiyitdXV34ybqHMcn9/zBp0iyzwyl4TBJElFdeWhfA9c//FLecvdDsUIoC+ySIKG8caT8I+d29GOP+PkaPHGV2OEWBNQkiyhtrHvkGEpPsuOSqpWaHUjSYJIgoL7zbuhP+0mmo/YfHzQ6lqDBJEJHldXZ2oOknHnzr/CswZfIss8MpKr32SSilvjjA/SZE5NkBbktE1M0zv/4mJh9pxdXzF5kdStHpq+M6NMD9hgEwSRDRoG165zlMevEXqLzrWYwYwcaP4dbXGQ+KyIhsXwBeG47giaiwHTvRif94+Uns+6tlsFfVmh1OUeqrJtE8wP32PblxH5RSNgB2EYkOdl9ElJ8efqoBnWfU4LPOW8wOpWj1VZOIDHC/A90OSim7UioAwAsgnlmulHIrpfxaEiGiAvXq//4Sn1p7P+5zXAVVII+4yEe91iREZGv6e6XUBBE5kFE2G8AFSOusztyuv5RSDgDrACzqoQYRBuASkbhSKo5kLadqIMchImvb/tE7wG/+ESP+5gFUVs4wO5yilm0v0Fal1HXpBVpC2AagMQfxNCLZD9ItQSil3Nqx4trPKIAKpZQzB8ckIgs52tmB0GN3oeXCm7Hw8r81O5yil22SKAcQUkqtUUqNTxVqF+1BJQntgm8HYNOalWJKKa+2uBZpTU+aVgCOzP1s3LgRNTU1+isYDA4mLCIaRl1dXfjBuoexseYGXHPrz8wOh5D9s5sakOyUDgDYppT6qoj8TlvWNshYHADiIlIH6E1PzUqpCJLJI5GxfgJAZeZO5s2bx8RAlKfCq/4Fl6x/HJ/2b+RwV4vI9l9BRGQlgAoAUXxSq5iQo3gSaQeKIll7cGo/bRnr2pCDUVREZA2vbfg9Kp57AHO+9hjGjx5rdjikyTZJ2ABARBIi4gJwO4CrkaxFDPZWyCiSNYZMrQA29LCsAkDTII9JRBaw+/AB7PnVHTi2pAFVcy4yOxxKk22SuEEp9e3UGxEJInmxfhZA9WACEZEIgFatmSmlAkBEREKAfu9EqimqifdQEOW/9vZDqHv2EWz8m5/hUuftZodDGbLqkxCRih7KEgBcSqnrcxCPC4BfKRVGstaySNt/+rJmJBNSXQ6OR0Qm6urqQviHn8PnT52GWxd/zexwqAd9PeBvgYi83s99Dbp/QBvi6ullGRMDUYHo7OzA//x0CUr3fYAbv/kURih2VFtRX/8q/vShrn1YNthgiKg4HOk4jn/75Z0YvXMjLrjnBZSV2cwOiQz01dzkApDgLfFElCs7dmzEijX/hdFzLsc/ful+jBlTYnZI1Iv+1O8UgP0Atqa9VA/viYh69fbra/Dh9y7B1acIfnSZp+AThJgdQA70OZ+EiCzJLFRKPSMiV2eUPZjTyIiooDz/7EMofexOHL/uu/jCX91pdjhDrlC+OfeVJHwG5T0lSP8gYyGiAnTiRCd+2rwGaz54Dw23P4Zax2KzQ6IsZPUU2FytS0TFoa3tY7z0w89hzISpeOSOxzG5tL/jYMgqeu2T6OVxGyfVpHL4aA4iKgCb3v0z3r77U+gsn47b/qmRCSJP9TkE1qC8p+YmDoElIgDA6q1v4r+f/hGOLboD1357NcaMKTU7JBqgvvok6pRSi5AcwZSuRim1Nu19BZJPcWWiICpi7e0HEX7gJvypZBL+YemDOK9yutkh0SD157EcZ2qvTK6M94Uw2ouIBij2/ivY9sASKNs0/OCrK1FePtXskCgH+koSUQBLcfKEP5mqANyVk4iIKO88GXsNxwJfQcVFN+FzN6zgXBAFpK8ksUJEXuvHfqJKqRW5CIiI8sfBg/vwp5Vfxc+nXoAf3xXBORNPNzskyrG+0n1zf3eUnkyUUrMGGhAR5Yfml5/AG765GHv0ABoX/wMTRIHqK0k4B7jfgW5HRBZ3tLMD9//5Nzj6y7+H/PVyfOE76zB+/EkzCVOB6Ku5qWqA+x3odkRkYRtefBTrXngUWy+8Cbf9MIbKceVmh0RDrM/HciilvFnu0wYgMrBwiMiKdu+O4dXgbZi44y1cfO298F15M/h06OLQ530SA9xv6wC3IyILOXL0CH7x/ga0/P67WDBhMs7/p/fZtFRk+np208rhCoSIrKOj4xieffJ7GP/cf2LrNf+Cujsew5m2yWaHRSbIao5rIipsx0504n9eeRKVj94BKatA2dJf4v7qz5sdFpmISYKIcOBgC14ILcej7ccwcpYDX7vpx7j0kpt4UxwxSRAVs5YDe/Dyr76JKa8/hRPTz8ddnu/jvHM/Y3ZYZCFMEkRF6INtr+PJNyL4+YGDuKfjKCrveha1VbVmh0UWlPMkoZSaICIHcr1fIhq8Te88h81PLsf0D5sx7eIvI3LjCpxWyqlgyNiAk4RS6qtI3jS3QUSeTFtUpZQKigi/lhBZRFOsCQ9sfRtXr23AhLMvg/3rj6OaT2mlfhhQklBKPQhgCYAnANyolKoD4BGRAyLymlLKkcsgiSh7J0504uXnVuLwmn/Dsa4uLPL+GteteAMlI0eZHRrlkYHWJDwAFmU81O9BpdSDIvI6epjelIiGx+Fj7QjFX8fxx74J+/4dGL3o67jqmm9g1KgxZodGeWigSaIt8xHiIvL3SqnrVfJefU5ARDTMtmx+Ge/+6cewbXoOL13XgFtvexAXzjyfw1hpUAaaJHxKqW+LyA/TC0Xkt0qp68GaBNGw2PHxFqxu2Ykjf7ofn479BZi7CDPr1yIwu9rs0AiASP5/Xx5QktCSwWyl1FUi8mwPyzKnNiWiHGnZsxXR8M+A6FM49eBubPubB/EF9/dQPfNcjGR/g2WoAvmuPODRTSKyFcDWzHJtCOy6QUVFRN20tHyI9S89ht+MnYQz1j+OhV3tqPg/38KnLr8FC8eUmh0eFTAOgSWyqL3tB/HKuiBO+cvDmNYSg0yfj5u+9FN85jOrUcZOaBomHAJLZCE7d27CG8+uRPum5/Gvcz+HW0Ycx0WX/x3mXPkVLCjjBD80/DgElshEXV1d2LQ1inWHDmLknxpw4Zb/RccZNZh0+a1ouvLvUDJ6rNkhUpHrNUkopRYAqMjsnMYwDIFVSsUAVItIQntvB+ADEAZQC2BFahlRPmnvPI6mF36DtldXYeLW9TgyuhR7bvoZrv7ru3Hu7AtQzT4GspC+ahINAJ4BkJkkhnQIrFKqHoA9ozgMwCUicaVUHEAzOJc25YGuri5s2fwStqwPYfeuLfBPq0ZdyyacNflMTLr2blSddQmcvJeBLKqvJNGYPjudUuqLIvLkUA6BVUo5kTFHtlLKre07rv2MKqUqlFJOEeF82mQ5u3fH0LylCeEuhUt/fzemHW7BiZkOzLrg83j1Ki9OHVNidohE/dJXkrAppf4LwBMi8hwAF4AnAeMhsNqyAQ2BVUrZADhEpCFjkvVaAPGM1VsBOJCRUIjM0N55HK/u2or9v70b42Mvw3akDS1nX4UFi7+DBd/6I2ZPqeKdz5SX+prj+n6t6WedUqoNQKtS6lsA1mkd1Lm2TER8PZTbASQyyhIATpqRfePGjaipqdHfe71eeL3eHIZIBBztOIZ3oqvx8ZtrMPL9l/D62HKsv+hvcXPlTJRfcjPOW/BXcHCYKhWAPkc3iUgDgAallBfAfQDuBwCllACIAmhCsn/gicHMI6HtP2CwOI5krSGdDUAsc8V58+YhGAwONAyiHh0+vB/vvLYae94K48WxFVitSvDjNx6HzJiPca478LWLPLhr/ESzwyTKuX4PgRWRoFLKoY1isiN50a7Rft4AIKB1KD8oIj8aQCweJDvE08ualVIBABsAuDPWr0AyQRHlVGdnJ+Lx9fjw3efw6rip2LZnK76+7n4kTj0dXbOqcU3NlVj2qc9iwld+YHaoREMu2/sk/IDegRwHEEotUErNhpYwlFLvIzkSaVt/dywi3Tq7tZpK+hBYv1LKJiIJ7Wa9JhGJZhk/UTddXV344MO3sPWddXip8ky0v70W17/yCxwdNRbHJs/BrCtvx6Irb4H9C3fiU+MqzA6XaNhllSS0zurelm0F8FsAUEp9G8APjdYfABcAv1KqGUA1gLoc7puKgIhgx64t2Bxbj/UllSh58RFc/PYfoAAcm3QmJn3hHpz7mdsw69p6VEw6w+xwiSwh53NcA4BS6j4AF2AQSUJEVMb7OJgYqJ9EBHt2vY9NOzejacQYTF77I1RtexVjO4/j8JS5GH29H5+68jaccf3dmDxtHjKaOYlIMyRJAskO5fAQ7Zuom66uLnz00VvYlGjBGx0dmPf7f8Fpe7ZghJxAvOpSdLj+CdMvvxUzb7wP02bOh4NDUYn6bUiSRPoNeES5dGT/Hmzb8io2jx6H9/d+gHPW/hCntW7DiREj8e6CL0ItvBHjr7odU+ZchNOnn4MaJgSiQRmqmgTRgIkIDrftwLbNr2DvB6/h1apPA289g6te+QVGdx7D7vGn4fVL/g6Tq2pRcfU/Yua5V2HylDOx0OzAiQoQkwSZqmXXFnz0/ito/eA1tB5O4I9Vl2Hh/wZx4c43sPvUqWivPAOlsy/CmQvdsF15C2bNnI8Fp4zEZ80OnKhIMEnQkDvR1YWPEruwo/kpHPjoLZz4eBM2jZuMX00+F/+6/mGUjByN9omzoGYswI1zajHnAidm2qZg1Cn88yQyG/8XUs4cPLAX244exYfbopD1q6D2xFDW9hEePuMSbJ02H3e9GULHZDtGn3kRLj37cnzprEtw2o13c2QRkYUxSVC/iQjaDuzF9g/fwt59H+K9SjtGRX+PGe+uhS2xE6UdR/E9pw9nlYzDwlNGYVzt9Zg06wL8Z9VClJVOAG6+x+yPQERZYpKgbo50HMdH+/dgzzsRHNj5Ho7tjeODsafifyafg7rnf4Kz9+9AW1klDky0o+WauzB3xnyMn3k+ptprcPrp56CRTUREhUVECuqF5Kx4km7x4sUCQJ5++mm9LBAICABZunSpXrZjxw4BIFOnTu22vcPhEADS1NSkl917770CQO699169rKmpSQCIw+Hotv3UqVMFgOzYsUMvW7p0qQCQQCCglz399NMCQBYvXtxt+1x+puMnOmXr/hY56/xzBYDc9ROf/O57V8gfvj1XvlJdIgBktnuRPPPPc+UP318k//GdawWAzJt/vuxr3SFdJ05Y7jOlFNK/Ez9T/n+m87/0hXz6TEExuKbya18BOtJxHOt3b8OHB1vxdnwzAKDt2BEsfOI+7G0/iMml47Gn/SAAQI0pw4S5V6D8tDNR3vEC0BzELedeCtfy5QCA5uZm4AdPoWTkKFSUTzPrIxHlnULpaVPJJFQ4vF6vFOqjwju6TmDPkYPYdWQ/Pj5yALsO78du7f2uIwew68gB7DycwPhRYzFjfDlmjqvAjPHlmDGuAjPHl2Pm+ApMK7Nh1IhTzP4oRAXvlvDD+PLci7FoxlyzQ+mTUmqliPQ48Q5rEhYgIth/vF2/0O86/MlFf9eRTxJB29EjqCwZhymlE7TXqZhaNgFn2SZjSlny/fQyG0pHjTb7IxFRgWCSGGLHT3Ri95ED3b7xf6xd/HcdTiaC3UcOYNSIEZhSeqp2sZ+A00onYG75FFw5/axkQig7FZPGjsMpfMwEEQ0jJokB6uw6gdajR9By9CB2aQlg95ED+oU/lRAOHD+KSSXjMKX0VJxWOj6ZCEon4JyKqZhSOgFTtYRQxqkuiciCmCTStHd2oO3YEbQePYS97YfQ0n4Ie48eQkv7QextP6S9DqLl6CHsP9YO25hSTCwZh9NKxuvNPedVTsOiGXP15qCJJWUYofjtn4jyE5OEpv7FJxHa0ozysWWoGFOKSSXjMbFkHCaVjMfkkgk4p2IaJpWM017jUTGmjE0/RFTwmCQ037/4WvgvuY6PiCAiSsMkoeGwUCKik7G9hIiIDDFJEBGRISYJIiIyxCRBRESGmCSIiMgQkwQRERlikiAiIkNMEkREZIhJgoiIDDFJEBGRISYJIiIyxCRBRESGmCSIiMgQkwQRERlikiAiGiICMTuEQWOSICIaAgqFMYGZpZKEUsqplIoppUQp1aiUsqUtsyulAkopt1LKn76MiIiGhmVmplNK2QG4RKRK+z0MYCUAj7ZKWFseV0rFATQDqDInWiKi4mClmoRdRHwAICJxAH4AdgBQSrnTyiEiUQAVSimnSbESERUFyyQJEYlkFFUBSJXVAohnLG8F4Mjcz8aNG1FTU6O/gsFg7oMlIioSlmlu6oEDnzQ12QEkMpYnAFRmbjRv3jwmBiKiHLFMTSKdUqoegE9EElpRHIAtYzUbgNjwRUVEVHwslyS0foao1u+QsgFa/0SaCgBNwxYYEVERslSSSHVEp/onlFI2pZRTREKp99pPB4CmjERCREQ5Zpk+CS1BhLXf0xeVaz9dAPxKqWYA1QDqhjVAIqIiZJkkodUeDG9R1Ia/MjEQEQ0jSzU3ERGRtTBJEBGRISYJIiIyxCRBRESGmCSIiMgQkwQRERlikiAiIkNMEkREZIhJgoiIDDFJEBGRISYJIiIyxCRBRESGmCSIiIaIiJgdwqAxSRARDQFl+Ezr/MIkQUREhpgkiIjIEJMEEREZYpIgIiJDTBJERGSISYKIiAwxSRARkSEmCSIiMsQkQUREhpgkiIjIEJMEEREZYpIgIiJDTBJERGSISYKIiAwxSRARkSEmCSIiMsQkQUREhpgkiIjIEJMEEREZypskoZSyK6UCSim3UsqvlLKZHRMRUaHLmyQBIAzALyIhAKsANJscT9aCwaDZIeQ1nr/B4fkbvGI8h3mRJJRSbgAQkbj2MwqgQinlNDWwLBXjH1gu8fwNDs/f4BXjORxpdgD9VAsgnlHWCsABIDL84RAR9W7HoQRuXfcIrpx+1rAc75yKqfhOzTU5368SkZzvNNeUUo0AICKetLJmABER8WWs+y6ASWlFGwFsGo44+2EurBNLPuL5Gxyev8Er1HM4W0RcPS3Il5pEHMlaQzobgFjmiiJyznAERERUDPKiTwLABgD2jLIKAE0mxEJEVDTyIkloI5qQGvaqlHIAaNI6sAuSUsqmfU4iItPkRZLQuAD4lVJeAHXay/Kyvb8jtT4AL07urC86A70/RikV47002Z0/pZRTO2+ilGosxvOX5fkqjnu3RISvIXwh2W9i1353AIj1sq4DQBsAh9lxW+WVzflL26YegACwmR2/2a/+nj8km3P9ab/HADSaHb9Vz1e26+bzK59qEnlnAPd3NAIISgE3o2VjIPfHaMs4LBpZnz+7aCMFtfX9OLkfsKBlc74K5d6t/mCSGFq93d/RjfbHZQdg06qwMa1prZj1+/wBep+Vg0lW1+/zJyKZibUKxZdss/l7y+pvM5/lyxDYfGUHkMgoSwCo7GFdB4C4iNQBeud8s1Iqkvq2UoSyOX8AsEwy7pspctmev3QOAJ4+1yos2ZyvwZzbvMIkMQDaN/yqXlYJa9/M+n1/hyaR+kVEokqpOAAngIJ6FsBQnD9tn4FcxWhlQ/j3l9p/PQCfiCQGEWY+yuZ8Dejc5iMmiQEQkf5etDcAcGeUGd3fEQWwrIfy1ixCywtDdP48AHxKqfSyZqVUQEQaso/Suobo/AHQmz2jRdpkl835yvrc5iv2SQwh6eP+DqWUQyll19aNAGjNuDeiAsXXLqzL8vy5RKQq9dJ2UV1oCSIb2Zw/7b1T2y6S2q4QO2KNZPn3VjT3brEmMfRS93c0A6hG9/s7liH5jaQhY90wklXXRUVY5c+Uzfmjk/Xr/GnJIAwAGbWx8mGK0yoG8v+1p3ULRl484I+IiMzB5iYiIjLEJEFERIaYJIiIyBCTBBERGWKSICIiQ0wSRERkiEmCiIgMMUkQEZEhJgkiIjLEJEE0jLRpLgtuzgEqXHwsB9EwSc1dLiKqz5WJLII1CaJhoM3R4AQQ12YeLKqpQSl/sSZBNEyUUm0AVhTz48sp/7AmQTQMtJqDDUU8PwjlJyYJouHhBJAoxElpqLAxSRANDxdYi6A8xCRBNDycAMKp6S6J8gWTBNEQS+uPiAOoMTcaouwwSRANPRuABACXiLDJifIKh8ASEZEh1iSIiMgQkwQRERlikiAiIkNMEkREZIhJgoiIDDFJEBGRISYJIiIyxCRBRESGmCSIiMjQ/wf3kyNlxyYJ7gAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "flow = 33\n", + "tpeak = peak_time_via_quadratic_fit(t, amplitude_using_all_modes(hlm))[0]\n", + "t = t - tpeak\n", + "dataDict = {\"t\": t, \"hlm\": {(2, 2): hlm[(2, 2)]}}\n", + "truncatedDict, gwecc_object = truncate_at_flow(\n", + " flow=flow,\n", + " method=\"Frequency\",\n", + " dataDict=dataDict)\n", + "use_fancy_plotsettings()\n", + "plt.plot(dataDict[\"t\"], -np.gradient(np.unwrap(np.angle(dataDict[\"hlm\"][(2, 2)]))/2/np.pi, dataDict[\"t\"]), label=\"Full waveform\")\n", + "plt.plot(truncatedDict[\"t\"], -np.gradient(np.unwrap(np.angle(truncatedDict[\"hlm\"][(2, 2)])), truncatedDict[\"t\"])/2/np.pi, ls=\"--\", c=colorsDict[\"brown\"], label=\"Truncated waveform\")\n", + "plt.ylim(0, 100)\n", + "plt.axhline(flow, ls=\":\", c=\"k\", lw=2, label=f\"$f_{{\\mathrm{{low}}}}={flow}$ Hz\")\n", + "plt.xlabel(labelsDict[\"t\"])\n", + "plt.ylabel(\"$f_{22}$ [Hz]\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "099e8015-2e69-4048-afdb-7223c1452cf2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 30.01199124, 30.02141471, 30.03080416, ..., 228.91710519,\n", + " 231.81504722, 234.74575703])" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gwecc_object.omega22_pericenters_interp(gwecc_object.t_pericenters_interp)/(2*np.pi)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "098b7b1d-8c62-469a-a3da-e0210f60c6c6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home1/md.shaikh/Eccentricity/notebook/../gw_eccentricity/eccDefinition.py:902: UserWarning: Number of cycles = 15.16306242146014 >= suggested 6 but number of apocenters is 0.\n", + " warnings.warn(\n", + "/home1/md.shaikh/Eccentricity/notebook/../gw_eccentricity/eccDefinition.py:1332: UserWarning: Ecc(t) is non monotonic.\n", + " warnings.warn(\"Ecc(t) is non monotonic.\")\n" + ] + }, + { + "data": { + "text/plain": [ + "{'eccentricity': array([2.22044605e-16, 2.22044605e-16, 2.22044605e-16, ...,\n", + " 2.22044605e-16, 2.22044605e-16, 2.22044605e-16]),\n", + " 'mean_anomaly': array([0. , 0.06544985, 0.13089969, ..., 6.15363509, 6.2184102 ,\n", + " 0. ]),\n", + " 'tref_out': array([-6.60784845e-01, -6.60296564e-01, -6.59808283e-01, ...,\n", + " -1.60515782e-03, -1.11687657e-03, -6.28595320e-04])}" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gwecc_object.measure_ecc(dataDict[\"t\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "80e24c30-a556-45cc-ad20-7127ff6af797", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(
,\n", + " )" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "gwecc_object.plot_mean_ano()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b9fc9423-944a-408b-a7fe-7c9f8348ed59", + "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.8.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebook/truncate_waveform_by_flow.ipynb b/notebook/truncate_waveform_by_flow.ipynb deleted file mode 100644 index 1b9d12b3..00000000 --- a/notebook/truncate_waveform_by_flow.ipynb +++ /dev/null @@ -1,560 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "359ce4e3-567a-4f45-9f25-553f7af87906", - "metadata": {}, - "source": [ - "### Example notebook on how to truncate waveform by `flow`" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "bf1417b8-0dbc-4b94-be6d-4849901bfc64", - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "sys.path.append(\"../\")\n", - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "c4e0ee0d-34be-4917-8de9-171790184cc8", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home1/md.shaikh/miniconda3/envs/eccimrct/lib/python3.8/site-packages/gwtools/rotations.py:63: UserWarning: Could not import GWFrames, needed for rotations module\n", - " _warnings.warn(\"Could not import GWFrames, needed for rotations module\")\n", - "/home1/md.shaikh/miniconda3/envs/eccimrct/lib/python3.8/site-packages/gwtools/__init__.py:11: UserWarning: Could not import rotations, decompositions, or fitfuncs. These are not needed by GWSurrogate.\n", - " _warnings.warn(\"Could not import rotations, decompositions, or fitfuncs. These are not needed by GWSurrogate.\")\n" - ] - } - ], - "source": [ - "from gw_eccentricity.truncate_waveform_by_flow import truncate_waveform_by_flow\n", - "from gw_eccentricity.load_data import load_waveform\n", - "from gw_eccentricity.plot_settings import use_fancy_plotsettings, labelsDict" - ] - }, - { - "cell_type": "markdown", - "id": "7ebea60a-c75b-4a86-9314-0b59e33a32d9", - "metadata": {}, - "source": [ - "Load an eccentric eob waveform" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "5252c3be-9e34-4736-a175-bc93d4b4bf88", - "metadata": {}, - "outputs": [], - "source": [ - "kwargs = {\"filepath\": \"../data/ecc_waveforms/Non-Precessing/EOB/EccTest_q1.00_chi1z0.00_chi2z0.00_EOBecc0.1973794859_Momega00.010_meanAno1.571.h5\"}\n", - "dataDict = load_waveform(\"EOB\", **kwargs)" - ] - }, - { - "cell_type": "markdown", - "id": "94f5f3b1-5777-4107-8ddf-eb74a6d9aaa1", - "metadata": {}, - "source": [ - "Plot and see how the f22 looks" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "cf648191-ea4d-4a7b-ba8f-d28893ed9d3c", - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "7d94d198-7fc4-48ec-b41f-51ad11d67f22", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, '$f_{22}$ [1/$M$]')" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuIAAAEQCAYAAAD1URGwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABpTElEQVR4nO3deXxcd3U3/s+ZkSzb8aLN1mgkWZv37LazEJZA4rBDKU0oLbSl/UFCn64UHgL0gbZ0gYS2dG+TtDxPF55CE3iAUrYkUEJYEq+J492SbO374k22ljm/P773Xo1m7p27zEiy5M/79fLL9syd7726lu0zZ873HFFVEBERERHR/Iot9AUQEREREV2NGIgTERERES0ABuJERERERAuAgTgRERER0QJgIE5EREREtAAYiBMRERERLQAG4kREREREC2DeA3ERaRKRR0TkXhF5SERKox5nPVca9nVERERERAutaAHO+SSAe1S1VURaAewD0BzmOCu4vh/AQ9ZjoxHWJyIiIiJaMPOaEReRewFAVVutn/cDKBeR3WGOU9VRVX046vpERERERAttvjPitwBozXhsGMAOAE9FOC7q+ti2bZsODg46v9+6dSu2bdvmc/lERERElE5VgZFRYPVqSPHs0FJHx6DP74HsuAlSWTkn50/95HlIyTLIzTfNyfqF8Nhjjz2lqvdkPj7fgXgTZpeRwPp9RcTjoq6PV77ylXj00Ud9liMiIiKiXFI/fg6ph/4M0rgJ8U98dPZzz+1B6lOfQfwzn4Y0N83J+ac++BFIWSni/+sjc7J+ITz22GNtbo/P92bNVgClGY+VAmiJeFzU9YmIiIioAPSZZ83P+w9Ax87OfnJszPy8du08X9XiMN+B+B6YrHW6cgB7Ix4XdX0iIiIiKgBtaQXWmbITPXps9pN2YL52zTxf1eIwr4G4qj4BOF1PICI7AOy1NlU67Qj9jou6PhEREREVjl64CPQPQF5zJxCPQ0/NLkLQsTFg5UpIcfECXeGVbSHaF94D4CER2QdgJ4AH0p57CMCDAJ7IdVxa+0IAuFdEHlXV0QDrExEREVGhdHUBAGRjM7SuFmjNKIUeGwNKWZbiZd4Dcau1oGtwrKrNAY8bBfCw9SPw+kRERERUODoyCgCQ8jJIfR30SEZpyuhZlqXkwBH3RERERBTNqLUZs7QUUlsLDAxCxy85T+vYGIQbNT0xECciIiKiaEZHzc9r1wJ1tebXVrmK8zwz4p4YiBMRERFRJDo2Bqy6BlJcBKmtMY91mEBcL08AZ89BKvzGwFy9GIgTERERUTQjo0Bpqfl1ogooikM7O83vh4bMz+vmZqLmUsBAnIiIiIgi0dExZ1iPFBUB1dVAhwnEdWDQHFTJjLgXBuJEREREFM3YGCStPaHU1ULbO8xvBk1GXCqZEffCQJyIiIiIohkdndUnXBobgN4+6IWL0P5+QASoKF+wy7vSMRAnIiIiotB0YgK4OA6xa8QBoKnR/Nx22pSoVK2HLFu2EJe3KDAQJyIiIqLw0nqI26TZBOLa2grt7ILYLQ3JFQNxIiIiIgrPCcTTSlNKS4GKcujBQ0BXN1C/YWGubZFgIE5EREREoak1zCd9syYAyI6bofsPANPTkOuuXYArWzwYiBMRERFRePZUzfQacQCx3a8xmzTXVUKu2z7vl7WYFC30BRARERHRImSXpmSMsJctmxH/7GeA0rWmtzh54t0hIiIiotB0dAxYudK1K4o0sDY8CJamEBEREVF4o6NAWelCX8WixkCciIiIiELTsbFZHVMoPAbiRERERBTe6BhkLQPxfDAQJyIiIqLwRseyOqZQOAzEiYiIiCgUnZwELlzI6iFO4TAQJyIiIqJwXKZqUngMxImIiIgoHI9hPhQOA3EiIiIiCkWtjLgwEM8LA3EiIiIicuj0NKb/8f8g9f1nvQ9iaUpBcLImERERETn02R9Dv/4NKADZeRNk1arsg5zSFAbi+WBGnIiIiIgcevCFmV8fOux+zNgYsHKF63h7Co6BOBERERE59PgJyK4dwLJl0CNH3Q9iD/GCYCBORERERAAAnZoCevuAxgagvg440+F+4OgYwKmaeWMgTkRERERGXz+QSkGqE5ANddAz7a6H6egoh/kUAANxIiIiIgIAaHcPAECS1ZD6DcDYmNOqcJaRUaCsbH4vbgli1xQiIiIiMnpMII7qamB83Py6s2tWdxS9PGHG25eVzv/1LTHMiBMRERERAEAHh4CSEmDNakhtrXmsq2v2QXbrQgbieWMgTkRERETGyAhQVgoRASrKgZISaEdGID4yan5maUreGIgTEREREQBAh0ecAFtiMaAmaUpT0o8ZGTHPMyOeNwbiRERERGSMjELKZzLdUleTXZrCjHjBMBAnIiIiIiMtIw7A1IkPDELHLzmP6cgIEBNgzZqFuMIlhYE4EREREUHHx4FLlyDlpTMP1iTNz13dM4+NjAJr10LiDCPzxTtIRERERCYbDszOiNdZnVM6O2eOGxwCKirm88qWLAbiRERERORe+51IALEYNC0jrv39kPXr5vfaligG4kREREQ00w0lfbNmcRFQnQA6TEZcUylgYBBYv35BrnGpYSBORERERKaHOJDVDUVqklC7heHoGDA5yYx4gTAQJyIiIiLTQ7y4GFh1zewn6mqB3l7o1BTQ328eYyBeEAzEiYiIiMhkxEutqZpppLYGmJoG+vqdWnGpTizEFS45DMSJiIiIlrDpP/8rTP3mB6EXL+Y+cHgUKM8e0iO1NQAA7eiEnmkHli0zmzgpbwzEiYiIiJYoPd0OfeZZoL0D+t8/yH3syIj72Pr0XuKn24G6WvYQL5B5v4si0iQij4jIvSLykIiUhj3O57nd1mP3W8fsmPMvioiIiOgKpC8dNr8oKoIefCH3wSOjgEsgLitXAhUV0OMnoCdOQDZtLPh1Xq2KFuCcTwK4R1VbRaQVwD4AzSGPy/Xc46paBgBWEP4YgJ1z9+UQERERXZn0VAtQVgq56QbowUPex01MABcuQMqyS1MAQG7ZAf3Wk+bXN90wJ9d6NZrXjLiI3AsAqtpq/bwfQLmI7A56XIA1StOy4OUA9s7tV0VERER0ZdLTZyBNjZCGBmBkBDo65n6g2zCfNLHXv87UhtfWQHax2KBQ5jsjfguA1ozHhgHsAPBUwOMqfNZ4EMA+EXkQQIWqPlCYSyciIiJaZAYHgW1bgIZ6AICeOQMpdcloj46an91qxAFIwwbE//HvgJLlkKKFKKhYmua7RrwJwGjGY6MwwXXQ43KuoaoPA3gCwEMASr0u5OjRo9i1a5fz49FHHw30BRAREREtBnrpEnD+AqSiAlJnOp+gq8f9WCsj7rpZ0yJr1kBKlhX4Kq9u8/2WphUmc52uFEBLyOM8nxORRwA8ApMZf1JEHlfV+zIvZNu2bQy+iYiIaOkaGjY/V1SYkpNly6C9ve7HOqUppfNxZWSZ74z4HpiMdjq3Ou5cx3k+Z3VPeYeqPmXVkN8D4F6vzixERERES5UOW4F4ZbkZ0lOdAHrcA3EdHQVEgLVr5+8CaX4DcVV9AgDswNjaVLnX2nAJqx1haa7j/NbIOF8rgFFVHZ3br4yIiIjoCjNoAnGpMBXAUp2AegTiGB4B1qyBxOPzdXWEhWlfeA+Ah0RkH0xbwfTNlA/BlJQ84XOc63OqOioi77PKU+znsspSiIiIiJa8oSHzc0W5+bk6AezdD51OZQ/kGR1lWcoCmPdA3MpSu3YyUdXmgMfleu4JmECeiIiI6KqlQ0PA6lWQkhIAVkZ8asoE6OvXzT52dDTnRk2aG5xPSkRERLQUDQ0D5eUzv69OAAC0ty/72OFRoLR0Xi6LZjAQJyIiIlqCdHDIqQ8HAEmYQDxzw6amUsDYKFDuPsyH5g4DcSIiIqKlaHh4pj4cML8uLs7esHn2HDA1zdKUBcBAnIiIiGgR0GMnMPU/fgup733f/9jJKWB0DFKZlhGPxYBEFZDZS3xw0Py8bnbdOM09BuJEREREi0Dq8S8B3T1I/du/Q1VzH2z3EE/PiMO9haEOmEBc1lUW7FopGAbiRERERFc4nZyEHjoMLC8xmzDbO3K/IH2qZrqEGeozK5C3AnFUMhCfbwzEiYiIiK50ZzqAiQnE3vEzAAA9fiLn4Wr1EBeXjDgmJoCRkZljBweBkhJg9aoCXzT5YSBOREREdIXTjk4AgOzaCSxfDj19JvcLvDLi1S6dUwYGgXWVEJECXS0FxUCciIiI6AqnnZ1APA4kq4GGemhb7kBch4aA5cuBlStmPS52L/G0QFwHBiEsS1kQDMSJiIiIrnQdnUCyGlJUBNlQB3R15T5+aBiorMjOcldWAEVxJxBXVaCr2wT4NO8YiBMRERFd4bS3z8lmS6IKOHsOeuGi9/FDQ1n14QAg8Tiwfj3Q3WMeGBkFxschNcm5uGzywUCciIiI6Eo3ODTT1cSu887sBz7r+OHs+nCL1G9waszVzqwzEF8QDMSJiIiIrmA6Pg5cvAipNBlutzrvWcdPp0xXFJeMOADIxmbTwvD8eaDd2gTKQHxBMBAnIiIiupINmlaEqLAy4okq83Nvn/vxY6NAKuVamgIA2NgEANCWNuiJk0BZqakdp3lXlOtJEXl7xHVHVfW7EV9LREREtKTp1BSkKGcYNnOs1YrQyYgvXw6UlXpmxDHo0brQIs1NQEygLx2GHjsO2byJrQsXiN93wBMR130SAANxIiIiogzTj30O+t3vI/6HnzBlIn4GrcmX6YF1IgH1qBGfGebjEYivWgW59lro4182v//ptwa/eCoov9KUR1U1FvYHgAPzcfFEREREi4mePQv9r28B4+NIffXrwV7kDOeZKTWRRJV3acrQUNbxmeQNrzW/uOYayMvvCHYdVHB+GfF9Eddtifg6IiIioiVLXzhkflFbA33xEFTVtyxEB4eAtWshxcXOY5Kogn7v+9DLE5CSZdnHLysG1qz2XDN2x+3AH3wcUlkB4Wj7BeOXEe+JuO5TEV9HREREtGRpaxtQVITYm94AjJ2d6eedy9BQ9mZKu4Vhn0tW3Gp16Bfgx268nt1SFphfIP57IlIfdlFVbYt4PURERERLV+tpYEMdZNNGAICeafd9iQ5mD+eRhNXC0KU8RQcGPevD6criF4jvBNAqIkMi8nci8nYRWTMfF0ZERES01OiZM5CGeqCuBhAB2jv8X5Q+zMfmtDB02bA5OASsq8x+nK44foH40wDE+vF+AI8DGBGR50XkUyJyl32giLx37i6TiIiIaHHT8UvA6BikOgEpKQGq1kN9AvHMYT6O1auAlSuzWhjq9DQwMsy+4ItEzs2aqnqPiNwP4F4A/wCgGcBrAdwNYBeAD1v1R/sBNAH4xzm9WiIiIqLFqr/f/Fy1HgAgtTXQru7crxly7wkuIqZOPLM0ZXgESCmEgfii4DtZU1UfBXAfTEZcVfUeq0XhTgAfBXDQ+nXp3F0mERER0eKm/QMAALECcSQSQF8fVNX7NdZUTbfAWhJV2TXiA1bPcZamLAqBRtyr6piqvhbAmIh8W0RuVNUDqvqwqu4EUA72DiciIqKrhI6dhZ44Fe5FfRkZ8cR64NJl0z3Fi9MT3CXDnagC+gdMOYp9XVYgLpk15XRFChSI21T1MQA/C+AzIvKptMdHAXzK63VERERES4WqYvqTf4LpD38MqR8/F/x1/f1ASQmwdq15wOp84jmYBzAbLwHX4TxSnQCmp2ey4ADQ02M2gdpZd7qihQrEARN0W9nxvSKyR0RutB7/UsGvjoiIiOhK09oGtLQCAPSp7wZ/XV8/sH6d09/bLlFRt17gFrdhPja3Foba3QOsq4QsW5Z1PF15QgXiIrJGRG6yuqWUAWgDsF9E/m5Oro6IiIjoCqOHjwAA5PZboS8dmVUakvN1ff0z9eEAsN76da6M+NCw96h6u4Vh2lAg7e6BJDmkZ7HIGYiLyBetrPeQiEwDGIEZe/8UgEdhuqkIgNeKyBfn/GqJiIiIFpgeOwFUrYe87Dbg8mWgoyvYCwcHZ22ilJJlQHmZ61Ae51yDg94dUCrKTQtDqwWiqgLd3UCyOvDXQgsrZ/tCmG4pgGlP2Gr9aLF+HgbQqqpjc3d5RERERFcW7euH1CQhG5vN71taIA0bcr/m0iXg/IXsTZSJRM5AHEPDwHXbXZ8SEUhTI9Qqk8HgEHBxHFLLjPhi4Vea8hSAB2AC71IACqBFVZ+2uqY4QTgnbhIREdFVoX8AWL/OlIYUFUE7A2TE7X7gGdltqVoPeNSI6/gl4MKF3D3BmxuB02egU1NOQG6/QaArn18g/qCqPqaq77A2aD4FU4ay12pj+CERuck69qNzeqVEREREC0zHx4Fz5yDr10HicTNUx28oD9L6gWcO5qlOAMMj0MuXs1+Uq3Wh/fqmJmByEmjvhJ5qAWIxoL4++BdECypnIK6qBzJ+/7SqfkRVdwF4B8xmzY+JSArAh+fuMomIiIgKS8/m6N/txRrKY2+0lJqk/3RMwLsNob3h0qU8RYfcg/d0cr0pW9H9B6AvHAI2Npvac1oUQrcvtFlDfr6kqu+AGejD9oVERES0KKS+/k1M/+J7kXr8y6Fe50zHXL/OPFCTBHr7oFNTuV845B6Iu7UgdAy6l7PMen15ObCpGan/+BJw8hRit+z0/yLoihE5EE9nDfR5XyHWIiIiIppLqorUV/8TAJD62tcDtx8EAAzYGXETiEtN0gzVsadmep1zcAhYuya7v3d1jqE+g9agHq/2hZbYW98MTEwAy0sgd7/G90ugK0fOrikicgrA4wC+qKoHcx3L7ilERES0KLR3AAODkBuvN+UcLW3A5o2BXqr9A8CyYmc6pliBtPb0mqDcy9CQa623rF4FXHMNtLc3+1yDg57DfGat8Yo7EFu9GlJeBikvC/R10JXBLyO+E6ZjysNWL/G/t4b5EBERES1KTneRe99ufn/sWPAX9w8A69c70zFRbfXs7skOpGedc2jYu/tJogroccmI9/bN1JDnICKI3XQDZEOd77F0ZfHbrDlmdU15rapWwHRNeb8VlH9RRN4+P5dJREREVBh6+gywrBiyfStQVgptOxP8tf0DM/XhALB2DbByBdQnEMfgoGeJiVQn3DPivX2QAIE4LV6hasTtzZlWUP4oTCvDU1Yrw/eylzgRERFd8U63Axs2QOJxSEO9CcyD6u936sMBk41GIgH09Hi+xHOYjy1RBQwMztrwqZOTptMKA/ElLZ+uKU+r6vtVdSOAjwDYCGC/iOwRkQ8V7AqJiIiIMujUFPTc+Wiv7eiA1FtlHPUbgI5O6HTK/3Xjl4Cz5yDr1s16XJLVuTPi9jAfr4x4osps+BwYnHmwfwBQZUZ8iStU15QDVn/xjQB+FoAUYl0iIiKiTDo1henfeRDT7/vVYD280197eQIYGYVUmQBXktXA1BQwPOz/4oyOKY7qBNA/4NnC0Bnm45ERdzZ8ppWn2IE9A/GlrSCBeDpVbVXVzxR6XSIiIiIA0P0HTeeTS5eR+vaT4V5stwS0g2k7CO72Li1xzpvZQ9wi1QkglfJuYejRQ9xRW2t+PtMx85j9BiOZoxMLLXoFC8S5cZOIiIjmgx580fTMvuF68+swr+03wbJdXmIP1IHLZsks1mvtqZo2SZrOKZ7lKV5TNe3Xr10DVJTPqlXX02eAslLzHC1Zfn3E7wJQGnCtBwCEG09FREREFJIeOw7ZtBFy/bXQz38BevYcZM3qYC/uz8iIV5QDxcX+XU+Q1kO8dO3sJ+xg3mMNz2E+aaSxAdp2euY1Z9ohGzb4XhMtbjkDcQDvgJmYGaTmW/O/nMISkVIATaq6f6GvhYiIiPKnk1PA6TPAT78V2NhsHjvTDrn+2mCv7+8H4nGg3GSnJRaz+ngHyYgPAOvWzfQQtzktDD3KW/r6s+vKMzU2APsPQicmgFgM6OwEXv86/2uiRc0vEH8IQDmAT/kcJzCdU3yJSBOABwE8CeAWAJ9S1dEwx/mtkfZ8C0ybRSIiIrpCaCoFTE/7Tox0NTgIpFKQZBJSb2WM2zuAgIE4+geAygpIfKY6V6oTgTPimfXhgNXCsLraOyPe3w9pasy5tmzaCE2loMdPmvsyMQnZutn3mmhxyxmIq2qbiDyiqgf8FhKRRwKe80kA96hqq4i0AtgHoDnkcZ7PicgOAE8DuJuZcCIioiuLTk5h+oMPAmNjiH/2YUi5xwZGr9dbGyKlaj1QVgqsXgU90x789QOD2cF0IgEcfBGqmp3tTtffDzS7B9RSnYCebMk+33TKdFt52W05r0uu2w7E49CDLwArVpjHtm/L/cXQoue7WVNVnw6yUJDjRORe69hW6+f9AMpFZHfQ4wKs8TiARxmEExERXXn0J8+ZDPbYWeh3AoUYs9mdSaqsMfN1ddCOjtyvSdefXSYiiSpgYgIYGfG+bruHeMZGTUd1AhjoN6Uz6YaHgalpp12iF1m5ErJ9K/TZHyH1/R8AmzZCMmvRyZtecRXSgRS8faGPWwC0Zjw2DGBHiOM8n7OC8SYApSLyiIi0iMj9bhdy9OhR7Nq1y/nx6KOsYCEiIpprevBFYNU1wJbNSO3z/cA9+/X9/UBRWo13dRXQ2xfstZOTwPBI1kAeVFtBck+Odbx6iFtMC0Od6axiS3vj4Efe9AZzfEcnYm94re/xZMn1KcYVzq9rSoOqng67aI7XNQEYzXhsFEBFiONyPbcDQKuqPmBdxw4A+0TkKTuDbtu2bRuDbyIionmmh4+Ykou6WuhX/hN6+TKkpCT4An39QGWlU+MtiQR0ZBR66RJk+fLcr7XbCGZlxGcG6si17uUgXj3EnTXSWhhKzUzv71mlND7ktlsQ+7UHgMsTkNfc6Xs8LX5+GfHdPs+HfV0rstshlsJsqgx6nN8ao/aDVnlKa47rISIionmilyeA3j5IcxNky2Yz1r3tjP8L09fo658d1NqTJ3s9humkv9bOVmdmxNdVArEYNFdm3aOHuKPaBOKZGza1txeICeAxVTOdiCB2z92IvfkNuWvVacnwC8TdNlEG4fW6PTAZ7XTlAPaGOC7Xc/tdngNM6QoRERHlIXXwRUz/4aeg7SFqstPZwWyiCrKhDgDC1Xfba6QFw/YIeA00kMf0EM+ajFlUZILzHGt49hC3rVnt3sKwoxNIJCDFfo3q6GrkF4g/KCJDIX9MI7vmGwCgqk8ATn9vu3Rkr72xUkTuFZHSXMf5PPcUgGHrMVs5gKci3BsiIiKyaCqF1F//HXTfAaT+979EW8PKOEuiypSHlJSECup1/BIwdnZ2Rrw6+GRM7e83PborMytizTVprhpxuyTGI1PttDDszsiId3Y5bzqIMvm9PXsg4rq5MtD3AHhIRPYB2Jlxjodg+n8/4XNckOeehClZudutTzkRERGFcOIUMDQMrKuEvnAIev4CZNU14dboswLdqiozSKe2BmjvDPH6mYy6TVatAlZdk7usxNY/AFSUQ+Lx7OeqE8CzP/R8qfb1O7XkXiSZgJ6YqbbVySmgu8e3dSFdvfz6iD9W6BNamyZdA3xVbQ54nN9z9+V/pURERGTTw0cAALH/7z1IffpPoUePQW7ZGW6N3n5geYmZRAlAamucdQO93iptyWohmEjk7nhiv35g0LvrSaIKev4C9Nx5yOpV2Qf09QNbNuU+QSIB/PDH0MkpU4rS3W2GD9XW+l4bXZ3mu30hERERLQCdTuX3+pZW07v7xhtMu7iWzE7CAfT2mmy4Vd4h1QlgaNi0FQzCoxWgJKoCZsT7s1sX2pxNn9klLnr+PHDhgn8v8A11poWhNWBIT54yj3sMASJiIE5ERLSEaSqF6Y9/EtPvfb/Tgi/SOm2nIU2NkBXLgZoktLUt/BqZHU+qqswglj7/jif267G8xGyMTJeoAgYGoFNT7i+EVSYyPJy7DzjgHtD3ZpfEuK6xbatZ48hR8/PxE6ZnutXakCgTA3EiIqIlTF84BD30EjAyitTXvxFtjfFxoKcX0tgAAJDGeujpkG0HVU2NeFqdtVTbHU+CDeSxO6Zkbpg0w3RSwMCg92uHhoCUevYBn8mIZ1+LZ0lMBqmsAKrWO+U2euQYZPMmUw9P5ILfGUREREuYPr8HWLECcuP10L37oy1iB6f2oJpkEhgYhE5MBF9jZBSYmIQk3HqAB5yMmZlRtwRpYajOZEz3YFpKSoCyMmiPyxr29QUZynPjDdAXXoSeagW6uiE7bvZ9DV29Ch6Ii8iaQq9JRERE0eixE5DNG01A2N0DHQ4/WmNmOqQJeKUmaUpK3IJWL70zHVMca9cCy0sCZcTVLmFxC4btFoa5rsdnMiYAwKPWXHt6gdWrIdes9L3O2F13ApcuY/rjfwDE4xB2TKEcIgfiIvJeEfmUiLw946lmEdmT53URERFd1VLf/A6mf/+PofZY9gh0/BJw5gywZTNko2lMpq2nwy/ktA00QbA9wl27uoNfS19aD3GLiJjAPMgwnnPngEuX3MtDysqAZctyBvTaP2AmXFZk9xB3rqc64b5Zs7MTqAvY+WTLZsgdtwPj45C3vQVSUR7sdXRVihSIi8g/AHgYQBmAd4rIt+1MuKoegMdAHyIiIvKno6NIPfZP0IMvIPXFx6Mv1N1t6qIb6oGGevNY2+nw19PXB6xcaXp2AzObD8ME4r19pttK5lTLoB1PXHqIO2uImMf9RtSXleeccCnJamB4BHr+wsx1qwIdnZANwQJxEUHsQ7+N+D/+PWLv/rlAr6GrV9SM+H0wg3Ler6rvUNXXAXhYRG6ynncfO0VERES+dM9+0wavoR76k+cjtx6cmWSZMGUVVetDb7IEYILg9Ez2ihVAeRm0uyfHi1zWqCiHFBfPfjxRBfT1Q1O5v0anPMarxjtR5V7fbb++f8CzY4rD2oyK9Hs0MgqcvxCqF7jEYpDKCs8pnES2qIH4iJX5dqjq+2HKUm4GoHlfGRER0VVKX3wRqKhA7KffCpw7D3QEHwM/i50htrqTSF1tqHIS53rcNklWV+cMfLPX6JtdH26RRAKYnDQBby797j3EHYkE0NfnHdD3D+auDwcgTabfd3prRrXvPcfU0xyIGog/KCIfynxQVb8EoAnMiBMR0VVGe/sw9cCvY/rTf2rKGfJZq6UNsqkZstlMctQTJyNeUy+wdo3JYAOmpKSn1zf7PGuNVMraJDk7iJZkAugJkRHv7ZvdMcUWZKMlrIz4mtWmj7kLqU4AE5PA8Ej2aycngSHvqZrOGmWlQFkptC2tR7o1uEgaNuR8LVEUkQJxK+D+kojc5fHcPfleGBER0WKS+sp/mhKLnzwPWANdotDxSzM9uxNVwOpVphVeFL0ZJSXV1cDly67BqqeRUWByMisjLtXVwNhZ6IWLvkvo5cvAyKjrZEpnkI5fdr3Xo2OKLVcrxN4+Uytvt1/MQRobZ91vPX4SSFZD1rApHBVe5K4pqtqmqt/NfFxE1qjq0/ldFhER0eKhqtDn9kB27QCKipB6fm/0xU6fNq0BGxtMjXFtLbSzK9p19fbNDn6TdtAbsrYbcDqmOAJmsmev4TKZsrICKIrn7AEOmNKWXCPmcwX0djlOoED82m1ARyd0eMT8uR4/4XwyQVRobF9IRERXJZ1OIfWNbztTEPPS2weMjEB27oBs3QI9dDj6dXV0AgCk3pRCSF0t0NERutxFJ6dMOUZ6RjxpBaLdIWu7gawgWKpN55QgQf3MplGXjHg8bobs5NpoOT1tpmbmGjG/rhKIewT03VZdfDJAIH7TDeacLxwCWtqA0THI9df5vo4oCrYvJCKiq5I+9TRSj/4Tpj/xh9DR0fzWOnYCACDbtgJbNgFn2k1dcpS1evuAojhQWWnWrK0xGzbHzoZbqL/flGOkB68V5cCy4lAZcaft4LqM+mprA2iojLhHRlsSidylKYNDwPR07ox4PG6y9NYbmXTa1Q2Urg00kAeNDUBFOfT7P0Dq2R8BMYHcwrCG5gbbFxIR0VUp9b1ngHgcmJ6G/ui5vNbS7m4gFgNqk6a2e3oa6IhWToLePmD9ekjc+i+6rsacwyXAzHlNdru/RMJ5TGIx010kbNvByoqs/ttSUmIC1kAZ8V5g+XJgzWr3A6qrzCZSj6y/k+XOlRGH+RTBrT2jdvUAAcpSAHOPYq9/LfTgC9CvfA3ysttZH05zJmcgLiI3uW3IBNsXEhHRPNOhYaQOvJB3RxIA0LPngOMnELvv7UB1AnrgYH4L9vYC69dBiopMIA5AT5+Odm29fbOnT9rlFGHquu1rArKC18ADdOzr6es3pSMupLoaGqTMxepD7tVXW6oTwKVLwNiY++t77TcVPoF4Qz3QPzBrA6mmUkB7O6QuePtB+ak3Q+64HXLdtYj9yi8Ffh1RWH4Z8YfhXmbC9oVERDRvdHIK0x/7PaT+4I+h33kq//Va28yGyG1bIVs3Q0+eyivA154+Z7MgEglT/nGmPfw6qiaATg84KyutzYzBg2fAKilZtgwoK539RLIa6A3RwrDPo+0gYDLZAcbTZ765yJLIvfFTe3uBoiKg3GdcvD2QJ/3e9/UDF8chzY2+12mTZcsQ//DvIP5Hv8cR9TSn/ALxx1X1T+3f2Bsz2b6QiIjmk77wImBtGkx968n8F2y1ekM3NUI2bQJGx8xmwCjXpmpKPaxAXOJW+UeIYTeOc+dM0JieEY/HTEY6ZCCO3j7XLLTTb3to2HcJvTwBDI941mYHaWGoqZSpV/fIqjvXBHi/2ejtM584xHOHLdJQb9ZpOz1zfms4jz2sh+hK4heIl4rI34vIa6zfOwG2V/tC6zm2LyQiuorpiVNIff/ZgpSRAIDu2QusWIHYu94JtJ2GBggic67X0mYCu9WrnExppNHvgNlIefHi7FrsZHW48e82OxBNWwsIX04C5MhCJ+ygN8AbhYEB87NX/+6k6ZySs2xmeASYmDQDgLysXw/ExHPDpvb0znzikEtFOVBeBj12bOa1p1rM5ldOxqQrUM5AXFU/A6ANwNMiMgRgt4h8MG1TJhER0Sw6Oorpj30Cqc/+FfSZZwuz5skWyOZNkBuvN78/fiK/9c60O9lT1NaanzvDbYZ02AFteqCYrAZ6+6DTwSdYAqbEBXCphU6YEpCgb2xMiUuf6+ZGCdH/O1fbQfO4/zAe57kcgbQUFwHr1gMu/dJ1ehro6gbqan2vV0Qg110LPXTYuVd66DCwaROkuNj39UTzzbdriqo+rKoxAB8FUAHgMwD2i8i0iOyxMubvtdsXEhHR1U2feRaYmjK/fsr1g9Nw601MmJrfjU2mBrioCHriVPT1plMmSLU2Qco1K4GyMmjELid2oJmesZXqanMPBkOWu9hBfWbP7kQVcHHclK4EMTIKTEy4B9CVFUBxcfBNli7X47BbGObK/ltfkyRyZ7SlYYN7XX1vn5nsGXCzpVx/rSk16uiEnjsPtLZCbmAfcLoyBW5fqKqPAvgPKyjfCOBnATwNoBlmU+eIiJwUkQ/OyZUSEVHB6eGjmP7EHyL14kuFW/PAC8CGOsjPvA16+IgZ2Z6P02dMD+mNzSarWb8BaGuLvt7QEDA1NatUQmprIk+vRE+v6bOdVr5hrx22PEX7+oHyMkjJstlP2EFs0PIUjxIXwGphWLU+2CbLvj6gpARY655rMy0MK/wz4ml90T011AM9PdDLl2e/3h5wtME/Iw4AsvNmICZIPfMs9Ec/AVKK2C72AacrU9g+4g8BgKq2quoTqvoRVX2tqpbDBOcfAXCbFZA3FPhaiYiogFQV03/7D9AXDyH1t48E76KRa81UCnriFGTrFjPcJqWmRjefNds7AMxsxJMN0Ue+A2mTINNLJepqgM6uSDXt2tMLVFbOLn2wpk6G6tcNqxTELXi2Mtt26Yr/OnYW2muTpc8AHVtvH1C13rPt4MxaOb7Onl6gqsp/o2X9BiCl2QN57N/XBgzEy8shO26GfuPbSH3hcfPGbWNzoNcSzbdQgbiqeqYgrM2bX7IG/GwCcG/eV0dERAAAPX8BqUMvFSRYdpzpMIHitdtNR5KT0cs9HF3dwIULkC2bIJs3mcdOnsxrSe3pNYN31pvJjlJbCwwN5+zUkZNTSlLtPCQ1NcD4ODAyEv76enuzA96yUmD58lATLAEAvb0Qt42RdmlIkA2WsAL6mMs0TFt1IucAHWedvn7f3t32Wp5rBNxo6XQ8ydg0q22nzZuBFct917DFfund5hfnziH23vfkfCNBtJCiTtbMSUQ+DbYwJCIqCFXF9Cf/BKmPfxL6/75WuHWtITbx9/2y+f1LR/Jf02obJ83NkDWrgfXroG0Ru5HYenpNIBaPm9/bm/a6ItZ0d/cCy4qB8rKZB62pi9oVodNJT2/WRkQRMY8FqcO2r8tuFei2wbJkmekGErQ0pa8PqKjMmobprFddDUyY83lej6pZx6tjir1Wsho4ew56/oL7Gr3Z98dVVRWwvATa0jp7jRMnIZs3+r8+/ZrqahH/x79D/J/+AbHrWR9OV645CcQBtMDUjRMRXVUK1a5vllMtwAmTVU791zdDd+Lwou3tQEW5yUTW1kCPHM1/0YwOGbKhLvRo9kymDV9aPbcViEdet7cXSCRMrbS9ZjJiKcn5C8DZc64ZX6lOBGsRaOu3NkZ6ZaATicCBuO8AnSCdU8bGgEuXPXuIZ6/lcu8Gh8waSf/x8hKPQbZsgR5Jaz04PAwMDple7yHJypUQj9p2oivFnATiqvoYe4kT0dUmte8Apt/5i5j+3D8Xdt3n9gDxOGLvfY/JYJ7JM8Ns0e4eJwCV5kbo6fCTILPW7OkFKipmNhvW1gJd3ZHfPKiqlXFOCwbXrzedUyLWiWt3T3bgXFlhpmF2dYdbzA6M3TK+1Qmgr9+03wtyXVaHEs/hOYmq4Js1e3q9A3qkDdDJFYj3+rwxCLCW3QVF6jfkXMNZ67rtwJl26FnTHUaPHjePbwkfiBMtBnOVESciuuqkPv8F4PJl6Nf+CxpxSqOrYyeApkbIbbcCwKyMYV66e5yBLNLQAAwNmXZvedCentndSOpqgcnJmWxvWGNngfHx2a0B4zGr7CN8GYnTujCzlCQWMxssu8MF4pqjNZ8kq4HpaaB/INhiTqcT91IQqU4AIyO+XWicLH2y2vugygqgKJ4zY++0ZfSrEc81nr7denMXcJiOXLfdnPuQ6eKj+w4Aq67hZktashiIE9FVJfW9ZzD16x9A6sALBV1Xe3qB1jbIG15rfv+T5wuzbioFbW2FbGyCrKsEKivyHmYDAHr2LHDuPMSqjUaDyVhGni5p6+md6RiCtDISq/NJaF6TJpPV4bPXwEzrwursIDXSNEw7+HQJnu1zBOpOgvRWgWvdD7D/rPw2gObK0tvXFo+bmuwcX692dppNsn4Z8ZJlQNV61+8dPdMBVFZAVl2T+5ptmzcBpWuhzzwLnZyE7tkHufmmmf0BREsMA3Eiumro5ctI/eP/Bjq7kHrscwWt57brq2NvfL0JSgpRbw2YQO/iOKS5CYDpLOE69CQsOwCzh9rYpQNRA2Z41EvbwWOUoBnuw3KcdXt7A5d9OOs5gb1LcFmTNNMwrWFEga+vvAyy3KWjh33NQYP7vv6crQLtOmu/Nwu5svSz1vNrYdjZBVQnIEXuGz5nrbVpo2ubSj3TDtkQrCwFMG8Q5M5XQvfuR+qRfwLOnYPsfk3g1xMtNgzEieiKoh2dmPrt/4npf/+Pwq996LBprfeKO0xwdCZ60Jm19slTwMqVQE0SsnUz9NjxggT6TheSJhOIo36DqbmeDB4suq5rdQdxyhfKyqK120vn0p9brllpMpxRO5z09po2fOtnZ5ylJglMhSj7sOXory3JaiCVmpkmGeT6XDqmOErXmnsaouVgoA2Wfm9qnA2zAUpKer1bGGpnF6S2JvcaFtnYDAwMQkdHZ14/fsmUpmwKV1YSe/vbgFXXQJ/6LuTG6yE3XB/q9USLCQNxIgqtUF073KT+9f8Cp89Av/hE4I/0g9L9B4HlJYi9653m9wcLV56iJ05BNjVDYjHIpo1mxPjIaP4L20FXTVrmeno6cobZpt3dpuzAak0nIqZePES7vaw17ex1Zm1yTTJaW0DABJXr1mW14ROn3WDImu6+fvN1u0x5jLRmb69n5jlMC0PTKrA/Z6tAKVkGrKs0f3a51urpNd1wSkpyHifJauDSZdPZJHONySlz74MG4ptMe0E9OZMV15OngJRCtm4OtIaz1to1iP/ppxH7nd9E7KP/kz3AaUljIE5EoaS+8S1M/9wvIPWNbxd8bb1wEbr/IOTlLzO/f/ZHhV3/zBmgscGUOVRVQU/kN2jGWXc6ZUo6mhrNA1aZR+S66PS1u3uAdZVOFxL7Y35tz7M8pasbSFTNqr2V6oRvkJeT/cYpo+uHJJN5laa4BrpOu8GQ6/b0AuvXuU95tFvsBVxTxy8BI6M5h9UEbmE4NgZc9m8VKMmkf2lKT6/rdM6stZoazPHWpy6z9PYCqVTgjDiaG00nm5cOzzx29BggEq314LpKxF71CveSH6IlhIE40RKjbaeh5/PrfOG59uUJpD7/RWBiEql/+3fo5GRh1z9yFJiaQuwNrwMa6qGHC1RnbevsdupspbkR2uI5LDicgQGzAdBe266JzTdYhj2VMC3DnEwAItE2Kqavm9a6cGbtaqC/P3LZi3b3mI15dutCi9QkgXPnnJZ0oXgMg5E1a4DVqyJlxD3Hvq9eBaxZHTx7bwfYuYbVBG1hGLBVIGqqTWlSrrKnnh7/TicAUF8PiACt2X8P7I2XQeu7ZflyyLXbTJcTS2r/AdPtJ+hGTaKrEANxoiUk9eyPMP2BD2P6w7+bdw2xG33hRVNj/VNvBi5ehL5wqLDrnzxl6oE3NkG2bTF11iE343muff4CMDbmlB9IYwPQ1+c6DTD02j2z661l7Rpg7VrTMSJf3d0m+LbIsmWmrCLMoJgMOp0ymWF7I6W9djIJpDRyq0Ht7XXtRuKcJ2xrwHPnTWcXr6AymQTClrz09mVl7DPXDNo5xXMjaZqgLQydDZa+UyyTwMVxk0F3W+fsOWB0zOlWk3OtFcuBZLVrRlxPtQDFxcAG/3Wc9XbuADq7oN090OER4MQpxG7dFfj1RFcjBuJE80T7+jH9j/+nIENTvKS+/FXzi+4e6J69BV9fjxwFiooQu+9nTA/iw/mPRJ/l5ClgwwaTXdu8Cbh0KVKvaFfds2ut0dhgfi5EBxI7GEzLMBdkouTZc8D5C1mZa0kmzJj2qAYHgclJ13WB8HXXjm6P7HXEem6/jLPUJEOtqefPmzeSuQbd1IToJd6dvTk1a72ALQy1qxuIxfxLSmqsPzOvr7vDevNXH7Bvd2MDtPV09vWcajVlXAE6pjhrveJlQDyO1H99E6lvfhtQNRujicgTA3EimAyhpuZuAyIATP/F30C//g1M/+ln52QMug6PAK1tiL3758xH9s/PQSB+9BiwaaP5qLm5CXos/37Ws9ZvaZ1p02fXWRciUMZMEOhkxK3a17xqou21e3qA5ctNlwxbMuHf79mP04UkI8tcnd/a9tecNXbcqZGOMCjn/HnTai7pEkhWrTdv3MKWkfhknCVZbQbcXLwYbMEA5R+STAIjo4HW1J4eoKwMsmKF90FBWxh2dpma/eLcga+zR8DjDb39KUzgkpLmJmBgAJq2sVhTKdMTf2NToDWctcrLIXfdCf2vb0Ef/zLkjttn+tQTkSsG4nTV07bTmH73L2P645+cs24g2tVtNi5tqDP/4RZok+Csc1jZabnpBsj11xW8vlqnp4GWNsgW0wFBNm8CWloLds/07FnTg9qewFdbA8RihQ3EY7GZsoR164DiCCPN3fT0AsnqWd0dpLoaOHc+r0mVdolEVua6uho4fyFazTUwk8HPLE1Zvcq8iYsS5Dst81wG5cTjJtMb9l57bP50OCUvQdsDBpgU6WwC9b8H2t0zq2zIVcAWhtrVHWxjZHmZqWN3qesGrA3C11xjjgvAmWSZvsmy7bSZZro5/CbL2K+8B3LPXZBXvwqx978v9OuJrjYMxOmKpcMjmP6Xz7t+bFpIqS8+AYyPA4ePQPftn5Nz6MEXAQDx3/4Ns9HO+n1Bz3HsuMnKNjaY/0AHBqCj7nWkkfT0mg2J1kfeUr8BmJiIPro8U2abvmXLTFBUoEDc6RJiZRydMemd0fpbp9Muj42PQJ6Z6x7z5iGjh7aTZY24tnb3ACtWzM7g2yK2MLRLZXJlryNlxF02fzprhi15sfuD52oR6KwZ4N529+YeI49gLQx1etqUwwQIxEUE0tjo3ukEViC+oTZ4y7+mJmDlSuiLL82sYe39iNK/W1YsR/zX3o/4b/86ZM3q0K8nutowEKfQdHS0IBvc/KT+/lHol7+K6U9/Zu4y1ZcuQfcfgLz+tSYTWKCx5FnnOXYcqCgHGuuB+g3Qo8cLf5LOLqCuxkymc3r6nirY8na9s9RZgfiGuS0dMefIv846ff2szHJN8I15nutOTgED/bPqw4GZgDSvXujdPabVXmYPbetckevEu7qzMvjO2tURxrwDpp5bxLvsI8IkTNMxxqcjiUjg8iLt7QXWrs1dSpKoCrSmXrhoNv+6bU7NIDVJMy7eS18/MDUNqQnYKrCpAWhvz9qQrdMpoLXVbEQOSOIxyPXXQvcfcP6dTe07AGyogwTMqhNRdAzEKRRtacX0e/8Hpn/rQ+Y/ork6z+iYyU7X1gD9A9AXC9udwznP8RPAxCTktl2mnOOFQ3NTv338BGTLZpPN2roFevxEwc9jAk0riLX6A+czrjyLvVatdQ67K0OBzqFd3UBREbB+3cyDyWrT+i3EyHHXtT26hKC2xow0z6fDTF+fGVqSGZA5AV0eGfEej4xr1XogJoEnNmat293jWbsryWpgaAh6+XLoNVFZYT7JcFs3yiTMnh7XUhdnzeJi8/0SNCPe2wckfLqSLFtm1vQL7u1PI3wy4gAgDfXm3zGPBIZan8oEraeWpkZzLzsy/u51dACXLjvlY0HJK18ODA1DX3oJ2j8AHD6CmNXLn4jmFgPxJUBPn8HU7zw40zFjDqW+9BVgasr8R/3d/56z8+i+A0BKEf/1XzVDIg4UbgLiLNYUONm0EbJ9GzA0BIyMFPQUevYc0D8A2Wyy1NLYYEphwo7mznWOS5eAwaGZjYgrVgAVFQXLJgNWRrxqvTNgQ1YsB6rWF2RoDQATTFUnMgbMWCPH871XdpcQ13Z9qfxaAdp13DUZGfHiYtNmMGJGXFVNRtytC4m9dpRNlZcngMFB75IKp6Qm3HV7Dt6xhC0j0fMXzJ6BXBlxhOuc4to73W3NZLVvaYr9fJD10FBvfj5zxv35ttPm04SgnU6s2m09cmz2NVl7T8LWdsutu4A1q5H698eR+pfPA0VxyGvuDLUGEUXDQHwJSH3uX4DWNqT+9f+abMYc0akp6IEXIK/dDWyom5OuHM65TpwAVq4ENm80/aQL3SbPPs/JU+Yj+lWrIM1mKmLBhrzY7BrkurTaahSupAPATP1pellHXW3BA/HM3sRSW1OYzY5wz9LawW3e5SMuZS/pv89rfaeFncsmxWQi2sZHABgdAy5dyu5s4qydjFb20tMLqHpmcmfKXkJed0/PTGs9N/a9D5O9BnIPywFMp5fuHt9PmPTiRWBoGFIboC92jf+a2tlptRv0H5wzM8HSPRDXttPmTWiukpn09arWA+vXzd5gCZiStzWrA13TrPWWLUPsPb8AHDsOffZHkJ96CyT9kykimjMMxBc5HR6BHnrJZC9UoT/88dyd7MQps5N+x02QHTdBjx4t+GRFm55sgWxqhsRiwMZm4Ex2PWRBznOqFbKx2fymocFzylxe57BqQ52OCPaAjAIG4k47uvRAs67GDNcoQFtGnU6ZACpzM1l1NdDjHwT5rj815V46Yge3+fYSz9gI6rA7XuRVPtIDrF5lOo5kqjYbHyPdH6cLiUcgmjT9rsOu7fq9ki5ou730Nc+eM4N3cpWRhJyE6QxJCpARx+XLwNBw7gW9vgfc1kxWmx72uT4dO9Nu3sR7lOLMUlYGrF3jvcGypc1JBAQl118Lfemw8/dbUynogYOQG68PvlEzTeyuVyP2yU8g9uAHEXvXO0O/noiimfdAXESaROQREblXRB4SkdKwx4VYo8XruaVCDx0GVBF7yxuBulrooZf8XxT1XFbgKJs2mo8+p6aB0x4fteZznssTZl3r41VpbjLlMAXM7gJ2hmzIaZcnK5YD1QnP/ywjn6ezCygpAdZVmvOsXAmsWwctwPhzR1e3eRORFghJba0JUAaH8l9/cNB0TMkq7UgAly4DaT2II+nrB6ans7O/a1abjg559uPWrm7zCcva2V1CZNUqEyDl00u8uzdHdjkBXLgARGhhGKiHdo4Ji566c9c2y4oVQFlZuHvu9Dv3z14H/gTFfiPil921M/g+62qn9QYkSIvApH8ZjZ5pN7XfAYgIpKHBteWgnj0HDAxAmkL27L7pRuD8BcAuT2ltMxM1d+wItU662A3XIfay20wChIjmxUL8bXsSwEOq+gSALwLYF+E43zVE5MMAwv3LtgjpiRPA8hKgfgPkuu3QI8fmrsNIZ6dpj1de5mSR1aqxLqiOTiCVcnb+S5NVMtLaWtjzeJVzFKjUwtHZBdQkZ/3nJnW1TmBQCNrVDVRWzmrzZpeRFKI8xamDzhosk3+LvlnrZwb6IpHb6c3S1W3+DNwyhcmIXUIs2t3jnQnOI6Ovvb2m9MF6A5fFmbAYbm3t6vYfQpNMhLonTutCn2yz1CQDT63Unl6gogJSUuK/JuBb8qKdnUA8HqyUxOlP7n4PdHwc6Ot3yswC2boZOHMma5O7XdeN5pCB+K27gOXLkfre9wEAqe/+N1BcDNl5c6h1iGhhzWsgLiL3AoCqtlo/7wdQLiK7gx4XZA3r10/N/Ve08PTEScjGjTMt6y5dymvjWU6dpjRBRExwsGY1tKXAwTEA7bI6CNiZq0QVsKy4oPXO5jwuH9HXJE2pRYgWa77n6ejKzsIlC1PS4Zyjqzs7CKoNWZObi0eZROR64qz17Syty8bEZHX+GfFul/uTtn7U0hS9fNl8quJbbx3hz6Cn17Qu9Bgxbn96EPbe5+qY4qxdHe7Nj3Z3AzHJ7neeuW5NiKmV3d2+ZSkATFvQ5SX+98HeDBxkZHtFObBsmfeb8jP2GPnggbhcux1IqZlOm0ZfOgIUFUG2hNxgWVICedUroN9/Bqn9B6FP/zfk5S9j726iRWa+M+K3AMiM3IYBZH6Wluu4nGtYpSg7rAB9SdOpKbPbfpPJTktDg3m8wKUVzvm6ZgJKEQHq6py2W4U9j/WfuvWfsMRi5qPiAmeqtdsu55j5z15qakzJjT34I99zXLpkPnbOCMRnSjry79CiqlbGN6Nrh1OTW4CBNT09prwms69wZaXpapPvZsqeXjMNcLVLEFGdAAYGoRMT0dYev2Q26XkF4iGCwyz2GxSvzhlV64F4+NHugJ1pzxGIOvc+5NrdPb4t9yRZDYyNBW9R2tMLrF/vO5496IZNVTWfjG3w31hpPjXxz7RrR2fw9oCxmNkP4bW50vp0LlS/7i2bgKJ41sZzfekwsHmTb+bfTeyd9wIrViD1yT8B4jHEfu4dodcgooU134F4E4DRjMdGAVSEOM5vjY+q6sN+F3L06FHs2rXL+fHoo4/6veTK09tnhkBYg1VQV2v+oZ+DQFzHZ7fHA6zSh86uwvfd7uoG1q03Ldrsc9UkCx/0d3Vbw1LSzmNlkQt2LjvgyMqIhxvNndPIiOmu4RZkJJOhSxdc9fSabGJGaYfEra4R+QytAcx9cFkfsIJC1ZkuGqHX9tmkl8xdhpCL1wh6mxQVmWA8bNZa1XyylWvzoz0ZNNSmyrPAuXP+LfdCTgUN3BYwaAvDwSHg4rgzPMp3XZ+pnXrpkrlPAWu6AUC2boaePOX66ZgeP2HelFZm/teVY72SEsjWrdA9+5x/M3VkFGhpReyG6wKvM2vN8nLEP/1HiL3rnYh/+o9MNxUiWlTmOxBvBVCa8VgpgMxC41zHeT4nIvcDeCTIhWzbtg179+51ftx///1BXnZFcYZA1FlZ6uIioLZ2TjZQugWUUltjNqLlu1Evg3Z1OwGxo7YG6O+PnBV1PY/bR/RObWjhWvIByNqE6ExdLMB5NEc3CKlNFigj3gvxqK2V6nD1xK7r93pPUMy3xaBTguTZBtDe7Bdhfad1Ye7+2aGv/ew5E4j6dQwJW9/e6fHG0GVdINg9cfqdB+mnnagyg4j8MuL2FNcAGXEA5nu/f8D734fT7YCq2fgdkGzZYkr9XLob6bGZAV1hyMtfZvaMWKUt+uOfmOu64/ZQ68xasyaJ2H1vdzadE9HiMt+B+B5kb6AsB5DZkDrXcbmeuw/Ak1a3FDu432dt3Fx67JrpmtnBccE3G8KlbhtwJisWMlOtqZT5T92t33NK88+82udRNcF2ZoC8ahWwdm3hNlI6gVpGEFtZCRQXRx9Rni5HoOmUXeQxBVWnp830SK9Aq7rajC6P2CbRjIgfyN2mD4j85kidjjIe6wccae66dndPgI2P1n6AMPfHr3XhrLV7A2/Qdv4e1/kEuNY9CZQRH7Y+kQmSES8uNnXkfv9G2R2FAmfEk+ZTE4+/T5FKSbZtMa89dnz2WiOjZqPm1i2B13LWfNltQFEcqW98C5pKIfWNbwMN9Qyiia5i8xqIW11O7DpuiMgOAHvtem6rHWFpruN8nrtHVZvtH9ZpdwYpVVmMtLPLjJResXzmwZqkyRwXuL+3dnZZwyvS6qmtTHxB2woODQMTE9ndM6w3AAV7kzE0bEZBu5Ur1BQmiwx4d35wSjoKlREvKTEbzDLZb9LyuW8Dg6YEyqNMQpIJYGLSv4+zl/5+9xHx9vorVwJlpdH/7LutEqS0jjKz1l+2zGw+jlKa0hOk3jpp7k+INpJ+rQtnrT01ZdpLBlm3owtYZk3lzLWudU+C/D1w2poG3LgY5BMCbe8EStcG3njoDMw5ecp9vdbTphVmiFISrKsEKiugL85uCasHzZRfuXZ78LXs6yxdC7nnbujT30PqM58FOrsQ+5m3hV6HiJaOhWhfeA+Ah6wykgesH7aHAOwOcFyu564a2tllNhemMSO786in9dLZBSSqZm/GKisDVq5wBtYUgpNdz8zu2sFOgbLvTlDnEkRJTXXBNoZqT48JVF2ELivw0mWCQbfev2HHirvxDQqtADrSlEekl+/kCDrzuFfaFaBLSDJC+QgAdHv/+TprR/gzmOlCknu6YeiuLF1dQDJp3gj6kPoN0NMBet3bpRsbAnYQsadW5viEQE+fmdn7EnTN1auystfOeidOQpqbQpWSiAhk107ogRfMbAN7rb37gbJSwAr+w4q96+eAhnroj5+D3P1qyCvuiLQOES0N8x6Iq2qrqj6gqo9aP7emPddsZ7x9jvN8LuNcoqqjc/5FLQDTKaPLTE9MU4jAy/V8Xd3ZnT9ETMa1EJsBbV6jyJcvByoqCvd1efStdh47ew4aYQhL9nlybLirrgZ6+/Lu++7autCWqLK6duTxBiZHa0EgbaNi1Ox+gDIMidg1R1PWRFCP+nBHTXWgMemz1j5/Hhg761l77nDuT4i/Jx2dQCIxayOxK6eXeMDe3J3Zf489NdQDXV2zglDXNc+0m9kCbpNFXUhNEpiYMJ+0uK03MWGC+03Nrs+7rhmLQbZsdg3E9exZoL0Dsn1b4PWcdW+7Bbh82cmC6/gl6P6DkJ07Ig+9kVXXIP6ZP0H8/zyG+G/8j0hTMIlo6eD4rMVqcMiUVmT+pxryP+YgdHraBFku/4GbzYAFPFd3N7Byhck4ZZ6rJlmQzY2ATzmHHVjl+XXp+fNWhwqvTYjVocoKXM8xOQkM9Ht2BHG6duSTEe/uNfeqrMz9ALuPc8S6eu3p8W5daJGa6mhvjoaGgcseJUjp6yeTwPh4uI3H3QHruMtKgeXLQ33vameXfx03YCaFrl7llIfkXPPyhCkDCtrCr7HBfLrW0ZF73TPtoQbb2NMoPWcQtJ02U1Y3bQy8JgDItq1AVzd0dPakUbUmT8p1EUpJrr8WqCiHfuNbZq1nngXGxxG7+9Wh15q1biwGKV3rfyARLXkMxBepmU4ZGVlqezx1ITPiff2mRrjGJRBPJoGhITNprhByTUC0SkYK0i6xu9uUc7i1y3O6dOR5D51AbQ6Gvdh6ek19dY6sbN4beHu9WwsC6X3eI2bde/pyrg8grcVguK/DKXXK7MKTtX74rLU9ZMg3yBcxwW/AT450ctJcR4ANfGZ0ej00SKekrm7ToSNIgI+ZjY3q0UsbsN6kd3aFGmyDpiYzoMurjMSq87an9wYlN15vXr//wOz1Dr5o3khuDBfYA+aNbOzNb4S+cAipL38VqS/8B7BpIxBhoyYRkRsG4ouVFZC4fcwsNQXOUtttEt2CGfv8BSpP0a5u757MNUng4jiQkfGKdp4cdcN5DGGZdQ47UPPazBdwuEnOc3iU8syStGpyI5bA+A6WQX7fc9oTbH0gQsmV872bO/iM8qbI6cYSoHez1CaD76Xo7gFSKd9rdjQ2AGc6fP98ta3NXEvQziFV600mP9dcgjMdwOQkpLEx2Jqw2qxu3Ag96lXPfcp8+uL2aVUuzU0me/38TBMuTaWgz+2B7LjJf9iQ1/W++Y3Als1I/cvngUuXEf/V+1lOQkQFw0B8kdLuHmD5csDt482a6oL1wQYws0HSLSNewG4mevmyGRrkld0tQOAKpJVz5BrCkqjK/zzdPSZQ8+i/jbVrgZUr82uV6HwykmPwS63VWaM//LRQ07rQ+17NnKPGTL/0qSfOWn9yMnfrQpv95ijsYJyuLlP24lcG4LSTDLF+e4fJ5C9z78aSTurrgcGhQKU1Tg/toJnrhnpTc+3TalBb24DlJf732l43FgMa671LSADoyZPm2LDj2bdtAVrbzN/59PVUoS8egly3PXyPbhHIrbug+w+asjAAevgoMDICuf22UGvNWre4CPE/+j3EPv5RxP/ms06HFiKiQmAgvlhZAzTcSytqgHPnzSalAtCuLqCsFLLqmuwnnQEdBehmYm/a86p3ThZoI2pvn1XOkSN4LURHk+4eYF2l54Y7ETGfKOSbES/P3cc6rw28/QOmXjfhE7zVWH2cA05idHT3mD8LvwEzEWvdtaMLqK3xDeoiTals7wje/9ku8zh92n/djk7TMSVoLXeDvXbu8hRtPQ00NITaZChbtgAtLZ5vsPT4SWDtmkCfCsxa99rtwPQ09NDh2U+0dwCjY06ZSVix1+4GJiag33rSXN/Xvg6sXgW5/ZZI6znXW1yM2M6bIWGz9EREPhiIL1KmtMKn5KFAQ2m0s9u1PhywBnRUVRWkraDfuHCsqzS1pYXIVMOnnKMmGWpQiut5eno9e2PbpKY6rzcxppuNT+Y0j17iTumLT421E+yH/D4Ik/2N9OaosytwlxBJVge+fr182bxxDNo7u9EarZ6rzMN2+ozpmOLR9zxLXY35tKC1zfMQTaWAttOhs7myfSswNQ149ec+cRKyeVP47PX115qyl+dnz3LT/QfN8zfeEGo9Z93GBsiuHUg9/mVMf+5foHv2IfbWN2f18SciulIwEF+EzCTCfs+WbIVsYaiqJsjOEcxEGuHtxr5er82NsZh5Lu9NlPa0yxwZ8ZokYJdNRDAz9tuv9rkGGB6JtNnV/Nl0+m5ElDWrgdWro30/2MOa/IL9ZLUpwwmdsbayv34tAAHzPdjdY8plgqx97jwwNjYzeMqHNNSbN1/jl/wP7ug0Gx+DBuKlpWYoUY6NjzY91Rpqo6IUFwONDSY77aW7x0y/bApeyw1YnUgA6JGj2dc5PGLe6GyLMGGyuBiy4ybo83tm/XmmnnkW2LQRsi73wKFcYr96v7nXX/s65MYbIG97a+S1iIjmGgPxxajPKq3wqvVct87UuxZiw+bYGHDhQu6MaE0S6O6OPOLcpt09VpnFcs9jCrERVbu7gbVr3Utt7PPkWwZz9hxw8aJvRjyvuveRUeDiuOenFZnnifK1aGenKUvy6REtJSVAZWX4c3R0AlVVgbK/0lBv3hwFPUdnwDcRtqZGU15zJkCwHHKaJGCytTk3PgLQ0VFgaAjS3BR4XcCquT550rxJd1vXCqTtwDrwuqtXAfUbsqZLApiZMHnTjaHWdNa+85XA6Bj0J8+b9U61AG2nEXvVKyKt56xbUY74X/854n/7F4j9/u9G3qRJRDQfGIgvQjMlHB4ZcafetQCBuF3ekiPYk9oaM8LbY0BHUNrd4z8cpSYJ9PV7BhyBztPlP5Y8742h9r0PsskR0QL+mdZ8/oG41ERrL6gdIUo7apORSlOCb0psMK8JkFVOPy5w1trKFucq8XDWPtMOFBcDfrXz6RobgI7OnBta9ZTZGCkbwwbiW83fwVb3jZV65JjZHOz3fe+29i07oUeOZu050QMHzSZYqy946HV37QQSVUh98Qno5Qmk/u0LwDXXQPLs0Q1YGXevNqhERFcQBuKLkRPk5ZpEWF2Y0hQrq5grGCvYJspu/wBZkkkglTK9rSOfx7tFomPtGuCaayL3+Nb2gLXP9mbXKDX2Tmu+gIH46Bj0/IXAy6uqyVgHDJRRVwd0dgYvHZmaMn/mQdevTQJFRYE2PAJWu77Vq4DKimDrV5QDa1ZDWwIE4qdagcaGQKPibbJlMzDtXW8NADjVYkp8IpeQHHO/3iNHIdu2RApMY7ffBqRSs9sCjl+C7tkHuWVn9AmT8Rhi7/1loL0D0+99P/TgC4i962chK1dGWo+IaDFiIL4IaVcPsHYNZFWOcoGapBmfPhU9cwyYjZpY7jGB0mYHgnls2NSz56wplH6bG/ML+vXCRdOVocBDWLLO09Fphoj41Lo6m12jZsRXrADKPSZeprP/jMK8sRgeAcbHA/ezlqYGk5UN+rX09JqOLEHXLyoyQXvQjHjraUhTY+DgU0QgjY3+5SPT00BLK2RzhMmPcK+3dtY+cgzYUJezC47r2mWlQF1t1jAbwPq70j8AueG6UGs6mhuB6gRSTz7tDNPSH/0YuHQZsde8OtqaltiuHYh96LchWzYj9r5fgbzhdXmtR0S02DAQX4Q0SOa4Jmmyb33he0fP0tkFJJO5s15rVpsx23lNiLQC3qAlI1HPFfQ8sDqaRD1PR6dpmxcgWxi57r2rC6gN9vF7lDcwdkcTBN3s6ExiPB1sfas/deABM4A1RdJ/fZ2aAs60AyEGzQAANjYB7e1Z/a1nOdMBXL4M2RSyd/bqVcCGOu+s9eQk9NgxyPXRAma5dRf08NGsXuX63B7z/C27oq0rgthb3ggcPwl98RB0chKpL33FdIyJsFEzU+wVdyD+vz6C2Jtez1ISIrrqMBBfjHp6ArTFK0y5iHb61/CKWF0v8miXGKilIAC5ZiVQujZ6Rry9w6wTpJwjmQSGhoN10cg8T4D75qitBbq6Q396oe2dgeu3nYE4YT61sALewBsSa2tMe8kANdaAFYgvWxY40AesoH10DDo8nPvAjk5gaip8u75tpl1frg4kzgj2kBlxwLQD1GPH3fc4nDgJTEya1n4RxG67JauEBABSP/4J0NSYVycSufs1Jiv+F3+D1B8/DHT3IPaL72LgTESUJwbii4yOXwKGR/xrnAsxPv3iRTPpMkiP59pkfv2wOzqBoniwwSA1SVOeE+U87R1mk12Q6YIRs+964SIwNAzZELDkorHBTL4MESTr6KiZGBgwmxxlWqi2tJmBRGvWBDtHPG6ypIFLR9qAxnrzuoBkq8nA6rETudc+YQXLIdoAAlbf7JhADx/xXvvwEbPx0Wtiaq71d9wMXLoEfelw1nOp/QeBWAxy7bbQ6wIANm0EamuQ+ta3Z661tQ042YLYXXdGW9MiJSWIf+RDZhLskaOIvecXENt5c15rEhERA/HFxw52/TLHq1YBa9fklxG3M9xBAvGaJDAyaoLQKM60AzU1JmD0O1cyGf0NRnsHUFcbKPhzOprYJRpBBe29bZ/HytoGLekwx1rBbojSC6nfEDhbDZiMdei+0w0N0LY2p5bYc+1UCmg9HbpNH5oagGXLPMs7nPWPHDUdPQKOc7fJypXmnh52r+NWVegLhyA3Xh8pGyw33gCUlDjlIrPW/fFzkOuvzb33I9faIoi98fXAyRYT1ANIfeFxYPlyyKtfFWnNWevXb0D8bz6L+L//C2Jve0ve6xEREQPxRccprQgyWjuZX8/tMFMP85neCIQbFy41SeDcuax2aoHOc6Y9+FjymqRVanE63DnarR7TQUtTkkkTXIYIktFmjnUmNgYgmzcC/QPQ0THfY/XiRaC7J3wgvqkZOHfef1R8d4/ZCBp2/aIiyJZN0KN+gfgxyLat0YLl67ZDj59wL0k6026GBEWd/FiyzAyy+fFzs8tT2k6b+/2y2yKt66x/z10mK/5Xf4vpv/576PN7EXvH2yMH91nri4TqFENERLnxX9RFRts7AbvMwIdYg3Yin6uj05RxBCgXmemHHaFX9cWLwMBg8Fpkq29x0H7SznnOn7dKRgIG/PE4UF/vBL2Bz9PSCqxcGbh0QeKxUCUdgJU9X7cuVIBlby7UXO3zbPa1hB0ss92UVQTKWCP8gBkAwLatQFub5zRSHRgEBgacawkrdusuYHISum9/9tp79gEA5KZogTgAyGvvBsbGoD/8kfNY6r++CZSUQF5xR+R1AdOFJ/7gB834+Ke/B9l9F+SnOFmSiOhKxUB8HumJU5h68HfDlzqka+8w3TgClVYkgbGzpjVgFJ2dQE0yWA2vvRkwSkbc6rmNoAGyvQEvZICMM+bTBISZhtjUAG097VtqkU5b2yDNwdvmOedpC34ebTsTeiMimhtN/XOAQFxPms2KYQfLoCZpSqJytOgDrDrr0ogDZq6/Dkgp9OCL7mvbEx8jdh/B1q3A2rXQHz+X9VTqBz8Etm2B5Grn6UNuvAGoq0XqC49DL1+Gnm6Hfu8ZyN2vKUjmWupqEf+7v0T83/8Z8V9/PzPYRERXMP4LPZ+WFZsWYCFqgTNpR/ASDtRbmePT4TLHM+fqhARtXWdn6SP0Eg87LlzWrAEqK8KXjFijywPfP1jTFi9cAPoHgp1jago43R4+k2yfp7fP/xznzwOdXeE3Ii5fDmzYAJwIEIgfPgokqyGlpeHOIQLZtjV3r2xV6EtHIdduj1Y6sm0LsOoaJzudtf7ze4F164D64H/Os9aPxyAvvx36/F7o2Ez5k7a0Au0diL3y5ZHWddaPxRC7/1eA3j5M/+7vY/oP/wRYvQqxd96X17qZ5wjbi5yIiOYfA/H5VFMDFMWjB8Z2CUfQkeB2R40Igb9euAj09UM2hMgeb6iL9LXpmXZg+XLf4TezztXUGK6mGoCebDHdLoJOWkS4secATHZ/cjL0JkSnG4hP7TOQ1jFka/gezrJlk6l/ztEqUVMpU2MdsbRDrtsO9PVDvd5UdPcAQ0OQa7dHW7+oCLLzZujefVlTPHX8ktlMeevOvFrrxd74emBy0pSMWFJf+gqwcgXkzvw3Psauvw6xD/wGMHYWKC1F/Pd+F7Jmdd7rEhHR4sJAfB5JcZEZAx4yk+uwS1qCZo5L1wLlZdEy8PZrQmymk43NZprn+fP+B6fRFmtceJhR2Y0Npvf2peA9vvVUC2RTc7gArX6DKbk51RLsHC3muNDdQOpqTZbXp7YaAPTYcSAej9bH+sYbgPHx3Fnx9g7gwoXIbfRk105znc/vcX3e7nMtt+yMtD4AyB0vA86ey8qK67M/AiYm8s9a19ZA7rgd+v++Bm09jdTze6E/+gnkzW80vewLIHbnK1H02N+i6M8+HXrTKhERLQ0MxOeZqTluDVVzbNPTVglHmNKKxobQmWMA0FZr6mFziADBKpXQU63BzzM1BbS1QTaFHBfe3ASoAgEz8HrxoinnCHueZcuAjU2+Nc/OeY4cNZNGw7bNi8UgW7cEOo8ePQY0NUBKSkKdA4AZcx4TpF5wr68GAD1g1VhfF22wjCSqgIZ6pJ5zD8RTz+3Jf8DMrh1ARQX0m2k9s1WR+ua3zZuaLZsjr22Lve9XgNWrMP2hjyD1Jw8DTY2I3fvTea9LRERkYyA+z6SpCTh7DhjymQzoQltagWuuCTb0xtbUCHR2QScmwp+rojxUjbATtAfMHgMw2deJSdP2LgQ7oNZjxwMdry2tJnAPGYgDVieQk6dyjz23z3P4KGT7tmi1z9u3Ad090JFR7/XHLwHHT0YvG1m1CmhudoJtN6nn95pPKPIIlGO33wocOQbt65/1uPb0AseOI5Zvm754HLG3vAH6wiGnZ7b+4IdAaxtib3trQSY+Slkp4g//CeStb0bsnfch/slPmDdmREREBcJAfJ45w1uiZKlPtUA2NoXrxtHYAKRSJuANc66WtvB1zqtWAdWJwGUcgFW3DYTPVJeVAslqs6kwCKuuOuwGRwCmlnlqGnrCe+w5YLXN6x+IXvt8041mHZe2ec45Dr1kRrfv3BHpHIDVnu/ESajLBlQdOwscPw65dVfk9QFrJLoIUt9+ctbjqW8/aaZH3v3qvNYHAHnTG4CaJFKf/WukvvgEUv/wGLBpIwoxvMY5R2UF4u95N2LvvA+y6pqCrUtERAQwEJ9/DQ2ASOgNlDoxAbRH6MZhl4v4BJGzzjU+DnR1R6pblY3N0JOngrfhO3ESWL0qXJbfPte126BHjpkpjX7neekwUL8h0oY42bYVEIG+5D323JzjiHNdkTTWm24wVg216zn2HzCTEqP037bIq15h1vrBD7PX//4PgJQi9rLbI68PALKuEnL7rdBvfcfJ8OvIKPRb34G8/HZIefT2f845iosR/18fAdauQerf/wNIJBB/8INs10dERIsG/8eaZ7JiuckatwSvowZgJvpNTYfP6K6rNLW0Abpx2PTYCVPGEaUrx7XbTNlNgDZ8gOknHXkC4vbtpuWfT7ZfJyehR4+Z+ugI5JqVwOZN0L3emWoA0L37gLJSZ+BQ6POIQG7dBT34omsZjE5PQ3/yPOTmG83G34ikaj2wbStS33l6VtcRTaWQevJpYPMmSEPwbjleYu/+OWBiEqm//Fvo4BBSf/HXwNQ0Yj//zrzXtkl1AvG//DPEP/cI4n/2aUiIjjhEREQLjYH4ApDNVgu5MENiTkbrxiEikO1bTOY4aJb6yFFTPhBhw5s9REVffMn/PAODQG9f5MErcp0pAfEa7OKc59gJU4cedcALgNhttwAtreaa3c4xOQXdfxCya2e47i+Z57njZcDEBPSHP84+x8EXgdExyJ2vjLy+c563vQXo6zMZcHv9H/0E6OhE7E2vz3t9AJBkNWIPvBd68AVMv/dXoS++hNiv3g8JuZHV9zzxGKS8rCB14URERPOJgfgCkGu3mf7BIaZQ6pGjQHkZsH5d+PNt22qy1EGH0hw5arparFge+lxIVpuWiS8FCMQPmWMiB+LrKk13jj3epRyAVXNdFI9cuw0ActstZi2PTiD6wovA+HheLfkAANduM3XPGbXVAKDf+g6wenVe9eE2uWUnsLEZqf/9r9D+AejwMFL/9M+mfOcV+bX+Sxe75y7EH/5jxH7x583PBagNJyIiWioYiC8Au+NF0I2GZhLhYch110acRGjqiQO1xpuYAE6egmyPVoMsIpDrr4O+eNi3dlsPvgisXQNsCDagyPV8t+4Cjh6Dnj3r+ryqQn/8HOSGG/Lq/yw1SaCxAamnv+f6yYI+/T1gzWrIzTdFPgdg7l/sDa8Djp9E6sDBmfVb26B79iH25jfkVZbinCcWQ/y3fg2YnsL0b38I07/xQWD8IuK//esFr7GWzZsQe/vbQm/IJSIiWuoYiC+EZDVQujZwb2p095iShKgZ3foN5nz7Dvgeqi8dMWUcN94Q7VywejyPjTmdSlzPMzkF3bsv/1KOW28BUgr9yfPuB7S0mQmhd+TXLg8AYq+/x2yyPT5746sODkGf3wt59Z2FCZJftxuoqkLq0c9Bz5+HXr6M6b99BFi7BlKgshEAkLpaxB/6Y8htt0B27UD80380M42ViIiI5hwD8QVg6ra3QQ+9FKhu2663tmuiQ58vFoPs3AHdfzDnaHPA2nBYUgK5PtowF8AKxIuLkfpRdp2zc55DLwEXxyF59pNGcyOwoQ6pbz/l+nTqyaeAZcWQ227N7zwA5FWvBFavQur/fnHWn1vq8S8BgsLVVhcXm2z1wACmP/BhTH/gw0BbG2K/9n7TIrKApK4W8d/6dcQ/8BuQiJtMiYiIKBoG4gtEdu4AhkdMxtaH7t1n2vslq6Of75adwMWLObunqCp0z37IjdfnNbhEVqyA7LgJ+qOfzOrKMetc338GWLkycicT51wiJlPd0mo2Zaaf49x56H//APLKV0BW5x/AyorliP3sfdAXD0G/8zQAIHXgBeh3noa87h7TjaRAZPtWxP/g45BEAli7FrGPPWj6fxMREdGSwUB8gciuHWbUuN9Gw/FL0Bdfgty6K6+uEHLjDUBJCfQHP/I+6NhxYGAAcnsBssd3vRoYHnHd3KhjZ6E//AnkNa8qyKRCec2dwNq1mP7Xz2dnqicnEHvrm/I+h3OuN7wWcvONSP39o5j63d9H6o8fAupqEfuFny/YOZxzXbsd8T/8BIo+9UnEduW/QZOIiIiuLAzEF4isXQNs2eLZhcOmBw4Ck5P5TzpcsRxyx+3QH/wQeumS6zGp7/63GRZzR37DXABAdu00dc5f/c+s8pvUf30TmJpC7HX35H0ewGTgYz//s8Dho9An/p85x9790K9/A7L7bkh9/j2xnXPF44h95EOQt70VuHgR8upXIf5HvwdZHqHDDBEREV3V8t9ZRpHFXnEHUo99DtrS6tkfXJ/+HlBe5nRayet8u+/C9Pe+D/3+s2ZDYPp5xs5Cn/kh5BV3FCSolHgMsbf/FFJ//6hZ905rmmP/APSrXzfn2VCX93mc8732bsihl5D6/BeQ+u9ngJ4eYMMGxH75Fwt2DudcJSWIv+fdBV+XiIiIri7MiC8gufMVwLJiM83QhQ4OQQ8chNz9Gkg8nv8Jt28FNm9C6okvQycnZz2V+up/AhMTiP30W/M/j0V23wVsakbqkcegR49BR0Yx/ek/BeKxgpdyiAhiH/hNxH7llyBV6yE/9RbE//gPovVCJyIiIpoHDMQXkKxaBXn5HdDvPQMdGc16PvWVrwEQxHbfVZjziSD2rncCA4NIfeFx53FtOw392tchd74SUltTkHMBJisef/BDwKpVmP7oJzD9y/ebyY2/81sF3diYfr7YW9+E+Cc+hvgvvTuvvuFEREREc42lKQssdt/bMf39HyD1hf9A/Ffvdx7Xnl7ot5+CvObOggatsRuvh95zF/RLX8F0LAap34DU5/4ZWL1mbso4KisQ/+xnoE9/17QrfOXLzXAcIiIioqscA/EFJslqyJteD/3PbyB1042Ivew26KVLmP7zvwKKixH7uXcU/Jyx9/0KUhMT0Me/DAWAqirEP/Y/zQbSOSDXrIS89c1zsjYRERHRYsVA/AoQ+4Wfx/SxE0h95s+ht98GPX0G6O1F7MMfhFRWFPx8smwZ4h/4Teh9PwOcPQdsaoYUFxf8PERERETkjYH4FUCWLUP8kx9H6p//DbpnH1BehtjHP4rYzTfN7XkLWA9OREREROEwEL9CyIoViL//fcD737fQl0JERERE84BdU4iIiIiIFgADcSIiIiKiBTDvgbiINInIIyJyr4g8JCKlYY/zeW63iLSIiIrI417rExEREREtpIXIiD8J4CFVfQLAFwHsi3Cc63Mi0gTgHlVtBtAMYAeAx+bkqyBfjz766EJfwpLHezw/eJ/nHu/x/OB9nnu8x/NjqdzneQ3EReReAFDVVuvn/QDKRWR30ON81mhS1QfTnn8IQNN8fG2Uban8JbmS8R7PD97nucd7PD94n+ce7/H8WCr3eb4z4rcAaM14bBgmcx30OM/nVPWpjMebAWQ+RkRERERLiS70BUQz3+0LmwCMZjw2CiBzak2u44KuAZjA/T63C3nssceOPvbYY+vSHjoK4JjbsRTZVhHhPZ1bvMfzg/d57vEezw/e57nHezw/su/z731sgS4lkEa3B+c7EG9Fdva7FEBLyON81xCRDwN4UFVH3S5EVbcHuF4iIiIiojkx36Upe5Bds10OYG+I43zXsOrF91v140REREREV5x5DcStLiewWwqKyA4Ae+2A2WpHWJrruABr7LbO9ZR9XOZmUJp7bBu5sHj/aTHj929h8D4uPP4ZkJ+FaF94D4CHROR+AA9YP2wPAdgd4DjX56yA+0kAT1p9xBXACLIz7pQH+w2Ty+Mtaff98bTHo/aED9Rzfilyu8d+PfILff+vBh73ueDfr7zP0mR/b2b8KE07ht+/BcB/h+ce/y1eOEvyPqkqf/BHoB8wtfgfhtmb3JTx3G4Auz1e12IfD1Pf35Lvc0v1h9c9hinHeijt1y0AHp/L+7+Uf/h8Lxf8+/Vqvc9pX//9Gd/PpQD2pf2e37+Fuc/8d3ju7zH/LV7Y+7/k7tOCXwB/LL4fHsHLPph3/vdnPH5v5l8UmE8pdkd9bqG//oW4x5lftxXYpAcyBb3/C/31L+B9Lvj3K++z632/H8CH037P79/C3Ff+Ozz395j/Fi/cvV+S92khSlNoaXoEpp/7QyIykvZxUaSe8D7PXXXUv0d+oe//1Wouvl95n7M9ACB9Gge/fwuD/w7PMf5bvKCW5H1iIE4FoaqPquoDqloG8xflMeupqD3hw/SLvxrtAPAp+zdzcP+vVnPx/cr7nMYOTDSttSy/fwuD/w4vCP5bPH+W5H2a7z7idAWy/mN82uPpYVW9J+SS78PMBpV8esIH6Tm/KBTyHotPj3wU7v4vOgW4z3P1/bqk7nO6CPf8HQC+mGPJq/b710vE72v+OxxS2PvMf4vnXdBZNIsKA3GyM1M7C7hkK2bete6BqetKZ/d9H4743KJTqHsswXrkF+L+L0oFuM9z8f265O5zugj3/AEAd+d4/qr9/vUS8fua/w6HFOY+89/iBZHrHi5aLE2hvInp1V6a9tA7ADwI5O4dH/W5efiSrkji0SN/Lu7/vHxBV6C5+H7lfZ7hVpbC79/C4L/D84f/Fi+MpXqfmBGnwKxv/vut394rIo9a/6HuAvC4iDwF85Fza8aGFrvv+z6YbINbT/iwzy1JXvdYZnrkQ0TSX1KGubv/S1aO72Vgbr5fr8r77OJ+ZJel8Pu3MPjv8Dzgv8ULbsndJ7HavxARERER0TxiaQoRERER0QJgIE5EREREtAAYiBMRERERLQAG4kREREREC4CBOBERERHRAmAgTkRERES0ABiIExGRQ0TuFxEVkYesXzdlPL9DRJ60jnk8xzr2MftE5K3WWo9Yj2VOxyMiuipxoA8REWUaVdUH3Z5Q1f1WAL4bQJPbMSJyv/U8ANynqq0ZzxEREZgRJyK6qliZ7h15LnMPgP1wCcStqaX3ARiFCehbM48hIiKDgTgR0VVCRB4B8GFV3Z/nUqUAWq2fMz0O4BHruf/I8zxEREsaA3EioquAiHwYplyk1arVdi0rCbDObphseKv1+9K05+4H8CRmMuVP5nPNRERLHQNxIqKrgKo+DKAcwCOq+kAeJSP3wATYLdbvm4CZkhTrPPdYzz0V/YqJiJY+BuJERFcBKwNeivyD492q+hSsjDhMcA+YkhR7g+duAPtVdTTPcxERLWkMxImIrg67YTZPRq4Pt7Lew9Zv7Z+brHaE+62OKvZGUGbDiYh8sH0hEdHV4R4UIBuOmbpvOyN+D4AmVd2ZdgzA+nAiIl/MiBMRXR12A3gyfXNlBD8LK5hPKzu5F8D7Mo6BVb5CREQ5MBAnIlri0urDWwHsirhGKYB7M0pbWgE8aj9mHbMDpqsKERH5YCBORLT0lcIM2LknSqbaCrAfs379UFpWfb+qPmA9fi+Ap63HmzhBk4jIn6jqQl8DERFdIawA+iFVLZuj9RWmzeETc7E+EdFiwow4ERFlKl3oCyAiuhqwawoREaUbBvCUiDwEM7TnqTyG/wBwatR3A2iG2ew5mu9FEhEtBSxNISIiIiJaACxNISIiIiJaAAzEiYiIiIgWAANxIiIiIqIFwECciIiIiGgBMBAnIiIiIloADMSJiIiIiBYAA3EiIiIiogXw/wO8UiIwPkrz2AAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "use_fancy_plotsettings()\n", - "fig, ax = plt.subplots(figsize=(12, 4))\n", - "ax.plot(dataDict[\"t\"], -np.gradient(np.unwrap(np.angle(dataDict[\"hlm\"][(2, 2)])))/2/np.pi)\n", - "ax.set_ylim(0.002, 0.01)\n", - "ax.set_xlabel(labelsDict[\"t_dimless\"])\n", - "ax.set_ylabel(\"$f_{22}$ [1/$M$]\")" - ] - }, - { - "cell_type": "markdown", - "id": "70ee4dd5-e1d1-46a4-a70a-7e837271bf46", - "metadata": {}, - "source": [ - "Let's trucate the waveform using `flow=0.003`" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "4143b44d-9074-414b-be6c-e109b4d0240e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\u001b[0;31mSignature:\u001b[0m\n", - "\u001b[0mtruncate_waveform_by_flow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mdataDict\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mflow\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Amplitude'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mspline_kwargs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mextra_kwargs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mDocstring:\u001b[0m\n", - "Truncate waveform by flow.\n", - "\n", - "Eccentric waveforms have a non-monotonic instantaneous frequency.\n", - "Therefore, truncating waveform by demanding that the truncated waveform\n", - "should contain all frequencies that are greater than or equal to a given\n", - "minimum frequency, say flow, must be done carefully since the instantaneous\n", - "frequency can be equal to the given flow at multiple points in time.\n", - "\n", - "We need to find the time tlow, such that all the frequencies at t < tlow\n", - "are < flow and therefore the t >= tlow part of the waveform would\n", - "retain all the frequencies that are >= flow. Note that the t >= tlow part\n", - "could contain some frequencies < flow but that is fine, all we need is not\n", - "to loose any frequencies >= flow.\n", - "\n", - "This could be done by using the frequency interpolant omega22_p(t) through\n", - "the pericenters because\n", - "1. It is monotonic function of time.\n", - "2. If at a time tlow, omega22_p(tlow) = 2*pi*flow, then all frequencies\n", - "that are >= flow would be at t >= tlow.\n", - "\n", - "Thus, we find tlow such that omega22_a(tlow) = 2*pi*flow and truncate the\n", - "waveform by retaing only the part where t >= tlow.\n", - "\n", - "Paramerers:\n", - "-----------\n", - "datadict: dict\n", - " Dictionary containing waveform data in the following format:\n", - " dataDict = {\"t\": t,\n", - " \"hlm\": hlm},\n", - " where t is the time array and hlm is a dictionary of waveform modes\n", - " of the following format:\n", - " hlm = {(l, m): lm_mode}\n", - "flow: float\n", - " Lower cutoff frequency to truncate the given waveform modes.\n", - " The truncated waveform would have all the frequencies that are >= flow.\n", - "method: str\n", - " Method to find the locations of the apocenters.\n", - " See gw_eccentricity.get_available_modes for available modes.\n", - "spline_kwargs: dict\n", - " Dictionary of arguments to be provided the the\n", - " scipy.interpolate.InterpolatedUnivariatespline interpolant\n", - " to create an interpolant of omega22 at the apocenters.\n", - " Default values are set using eccDefinition.get_default_spline_kwargs.\n", - "extra_kwargs: dict\n", - " Dictionary of arguments that might be used for extrema finding routine.\n", - " Default values are set using eccDefinition.get_default_extra_kwargs.\n", - "\n", - "Returns:\n", - "--------\n", - "truncatedDict: dict\n", - " Dictionary containing the truncated waveform.\n", - " Has the same type as dataDict.\n", - "gwecc_object: obj\n", - " Object used to truncate the dataDict.\n", - "\u001b[0;31mFile:\u001b[0m ~/Eccentricity/gw_eccentricity/truncate_waveform_by_flow.py\n", - "\u001b[0;31mType:\u001b[0m function\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "?truncate_waveform_by_flow" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "bd3ca7b1-e9ba-4651-ab12-10d8382d526b", - "metadata": {}, - "outputs": [], - "source": [ - "flow = 0.005\n", - "truncatedDict, gwecc_object = truncate_waveform_by_flow(\n", - " dataDict=dataDict,\n", - " flow=flow)" - ] - }, - { - "cell_type": "markdown", - "id": "c10e69d1-3bc7-47dd-bb85-568bd8a96049", - "metadata": {}, - "source": [ - "Now let's have a look at the f22 of these waveforms again" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "edad9736-db0b-4923-b102-7d3cdd74395e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=(12, 4))\n", - "ax.plot(dataDict[\"t\"], -np.gradient(np.unwrap(np.angle(dataDict[\"hlm\"][(2, 2)])))/2/np.pi, label=\"original\")\n", - "ax.plot(truncatedDict[\"t\"], -np.gradient(np.unwrap(np.angle(truncatedDict[\"hlm\"][(2, 2)])))/2/np.pi, ls=\"--\", lw=2, label=\"truncated\")\n", - "ax.set_ylim(0.002, 0.01)\n", - "ax.set_ylabel(\"$f_{22}$\")\n", - "ax.axhline(flow, c=\"tab:cyan\", ls=\"--\", label=f\"$f_{{low}}={flow}$\")\n", - "ax.set_xlabel(labelsDict[\"t_dimless\"])\n", - "ax.set_ylabel(\"$f_{22}$ [1/$M$]\")\n", - "ax.legend(loc=\"upper left\")" - ] - }, - { - "cell_type": "markdown", - "id": "b7dd8315-9a22-47b2-b2cb-82cb163dd387", - "metadata": {}, - "source": [ - "Try a different `flow`" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "86304ad9-178b-4304-a5dc-d6f678998f54", - "metadata": {}, - "outputs": [], - "source": [ - "flow = 0.007\n", - "truncatedDict, gwecc_object = truncate_waveform_by_flow(\n", - " dataDict=dataDict,\n", - " flow=flow)" - ] - }, - { - "cell_type": "markdown", - "id": "941b9589-e931-4e29-bc1a-b7de500a0a9e", - "metadata": {}, - "source": [ - "Now let's have a look at the f22 of these waveforms again" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "19f72a14-8ceb-4c91-bbf1-91967ced147d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=(12, 4))\n", - "ax.plot(dataDict[\"t\"], -np.gradient(np.unwrap(np.angle(dataDict[\"hlm\"][(2, 2)])))/2/np.pi, label=\"original\")\n", - "ax.plot(truncatedDict[\"t\"], -np.gradient(np.unwrap(np.angle(truncatedDict[\"hlm\"][(2, 2)])))/2/np.pi, ls=\"--\", lw=2, label=\"truncated\")\n", - "ax.set_ylim(0.002, 0.01)\n", - "ax.set_ylabel(\"$f_{22}$\")\n", - "ax.axhline(flow, c=\"tab:cyan\", ls=\"--\", label=f\"$f_{{low}}={flow}$\")\n", - "ax.set_xlabel(labelsDict[\"t_dimless\"])\n", - "ax.set_ylabel(\"$f_{22}$ [1/$M$]\")\n", - "ax.legend(loc=\"upper left\")" - ] - }, - { - "cell_type": "markdown", - "id": "1d4f8ddb-cac7-437c-b9cb-db1cfc9a84f9", - "metadata": {}, - "source": [ - "Last one" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "39715963-64ca-4da0-92d3-b4aabb6f029d", - "metadata": {}, - "outputs": [], - "source": [ - "flow = 0.006\n", - "truncatedDict, gwecc_object = truncate_waveform_by_flow(\n", - " dataDict=dataDict,\n", - " flow=flow)" - ] - }, - { - "cell_type": "markdown", - "id": "029099e9-7706-4455-9fa9-ffe735f14d74", - "metadata": {}, - "source": [ - "Now let's have a look at the f22 of these waveforms again" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "8140eef0-6e7f-446f-9c31-47b861a134ce", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=(12, 4))\n", - "ax.plot(dataDict[\"t\"], -np.gradient(np.unwrap(np.angle(dataDict[\"hlm\"][(2, 2)])))/2/np.pi, label=\"original\")\n", - "ax.plot(truncatedDict[\"t\"], -np.gradient(np.unwrap(np.angle(truncatedDict[\"hlm\"][(2, 2)])))/2/np.pi, ls=\"--\", lw=2, label=\"truncated\")\n", - "ax.set_ylim(0.002, 0.01)\n", - "ax.set_ylabel(\"$f_{22}$\")\n", - "ax.axhline(flow, c=\"tab:cyan\", ls=\"--\", label=f\"$f_{{low}}={flow}$\")\n", - "ax.set_xlabel(labelsDict[\"t_dimless\"])\n", - "ax.set_ylabel(\"$f_{22}$ [1/$M$]\")\n", - "ax.legend(loc=\"upper left\")" - ] - }, - { - "cell_type": "markdown", - "id": "676b4573-65c6-4349-bcbb-715768ad1161", - "metadata": {}, - "source": [ - "Access info in `gwecc_object`" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "151a9d62-2236-42d6-b73d-2d58b01b8a53", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'Amplitude'" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gwecc_object.method" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "db74946a-4072-4473-858f-061e05ea8615", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.0025, -15999.046027714583)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gwecc_object.f_low_for_truncating, gwecc_object.tlow_for_trucating" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "19733d20-35fb-4aee-8be0-6c1e01c1065f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([0.00420699, 0.00420705, 0.00420711, ..., 0.0116272 , 0.01163429,\n", - " 0.01164138]),\n", - " array([-15999.04602771, -15998.04602771, -15997.04602771, ...,\n", - " -456.04602771, -455.04602771, -454.04602771]))" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "gwecc_object.f22_pericenters_interp, gwecc_object.t_pericenters_interp" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "089e54be-c1d0-4dbe-ae46-c53f3f024eea", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=(12, 4))\n", - "ax.plot(gwecc_object.t_pericenters_interp, gwecc_object.f22_pericenters_interp, label=r\"$f^a_{22}$\")\n", - "ax.set_ylabel(r\"$f_{22}$ [$1/M$]\")\n", - "ax.set_xlabel(labelsDict[\"t_dimless\"])\n", - "ax.plot(dataDict[\"t\"], -np.gradient(np.unwrap(np.angle(dataDict[\"hlm\"][(2, 2)])))/2/np.pi, label=r\"$f_{22}$\")\n", - "ax.set_ylim(0.002, 0.01)\n", - "ax.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0376ec20-8c4c-4cfa-9c5c-0a162b83f8fb", - "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.8.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}