From 1f38e28ed5ee004ce250ca39c5d92e9bdaf5b82d Mon Sep 17 00:00:00 2001 From: Schmidt Fabian Date: Wed, 31 Jul 2024 13:17:50 +0200 Subject: [PATCH 01/18] figured out oscillation issues --- simulations/notebooks/sim_peak_tests.py | 30 +++++++++++++++++++++++++ tests/settings.py | 6 ++++- tests/test_peak_detect.py | 2 +- 3 files changed, 36 insertions(+), 2 deletions(-) create mode 100644 simulations/notebooks/sim_peak_tests.py diff --git a/simulations/notebooks/sim_peak_tests.py b/simulations/notebooks/sim_peak_tests.py new file mode 100644 index 0000000..8f98150 --- /dev/null +++ b/simulations/notebooks/sim_peak_tests.py @@ -0,0 +1,30 @@ +#%% +from neurodsp.sim import sim_oscillation +import matplotlib.pyplot as plt +from pyrasa.utils.peak_utils import get_peak_params +import scipy.signal as dsp +import numpy as np +# %% +f_range = [1, 250] +n_secs = 5*60 +fs = 200 +osc_freq = 98 +f_range4plot = [80, 110] + +ts = sim_oscillation(n_seconds=n_secs, fs=fs, freq=osc_freq) +plt.plot(ts[:100]) + +#%% +freqs, psd = dsp.welch(ts, fs, nperseg=int(4 * fs)) +plt.plot(freqs, psd) + +freq_logical = np.logical_and(freqs >= f_range[0], freqs <= f_range[1]) +freqs, psd = freqs[freq_logical], psd[freq_logical] +# %% +pe_params = get_peak_params(psd[np.newaxis, :], freqs, min_peak_height=0.1) +pe_params +# %% + +freq_logical = np.logical_and(freqs >= f_range4plot[0], freqs <= f_range4plot[1]) +plt.plot(freqs[freq_logical], psd[freq_logical]) +# %% diff --git a/tests/settings.py b/tests/settings.py index e6d9e30..f9babdd 100644 --- a/tests/settings.py +++ b/tests/settings.py @@ -4,14 +4,18 @@ N_SECONDS = 60 FS = [500, 750, 1000] + OSC_FREQ = [5, 10, 20] MANY_OSC_FREQ = np.arange(2, 30, 1) +# through a bug in neurodsp #223 there is a systematic error in generating spectra with high frequency peaks +# where the actual simulated center frequency is biased. +# This bias increases as the simulated center frequency gets closer to the sampling rate used in the simulation. +# If you want to play around with this check: simulations/notebooks/sim_peak_tests.py EXPONENT = [-1, -1.5, -2.0] KNEE_FREQ = 15 # There seems to be a higher error in knee fits for knee and exponent estimates when # the difference in pre and post knee exponent is low. This kinda makes sense # TODO: Test this systematically -> see whether this is an issue with irasa or slope fitting in general - EXP_KNEE_COMBO = [ (1.0, 10.0), (1.0, 15.0), diff --git a/tests/test_peak_detect.py b/tests/test_peak_detect.py index c8ac781..78adc33 100644 --- a/tests/test_peak_detect.py +++ b/tests/test_peak_detect.py @@ -37,7 +37,7 @@ def test_no_peak_detection(fixed_aperiodic_signal, fs): @pytest.mark.parametrize('osc_freq, fs', [(10, 500)], scope='session') -def test_peak_detection_setings(oscillation, fs, osc_freq): +def test_peak_detection_settings(oscillation, fs, osc_freq): f_range = [1, 250] # test whether recombining periodic and aperiodic spectrum is equivalent to the original spectrum freqs, psd = dsp.welch(oscillation, fs, nperseg=int(4 * fs)) From 4b8e6b3b80247e7be77811de96bca84cb6932573 Mon Sep 17 00:00:00 2001 From: Schmidt Fabian Date: Wed, 31 Jul 2024 14:49:43 +0200 Subject: [PATCH 02/18] added custom slope fitting --- pyrasa/utils/aperiodic_utils.py | 166 ++++++++++++++++++-------------- tests/settings.py | 1 + tests/test_compute_slope.py | 63 ++++++++---- tests/test_mne.py | 36 +++---- 4 files changed, 154 insertions(+), 112 deletions(-) diff --git a/pyrasa/utils/aperiodic_utils.py b/pyrasa/utils/aperiodic_utils.py index 09669e3..33977a1 100644 --- a/pyrasa/utils/aperiodic_utils.py +++ b/pyrasa/utils/aperiodic_utils.py @@ -1,7 +1,7 @@ """Utilities for slope fitting.""" import warnings -from collections.abc import Iterable +from collections.abc import Callable, Iterable import numpy as np import pandas as pd @@ -30,22 +30,24 @@ def knee_model(x: np.ndarray, b0: float, k: float, b1: float, b2: float) -> np.n return y_hat -def _get_gof(psd: np.ndarray, psd_pred: np.ndarray, fit_func: str) -> pd.DataFrame: +def _get_gof(psd: np.ndarray, psd_pred: np.ndarray, k: int, fit_func: str, psd_log: bool = True) -> pd.DataFrame: """ get goodness of fit (i.e. mean squared error and R2) BIC and AIC currently assume OLS https://machinelearningmastery.com/probabilistic-model-selection-measures/ """ + # k number of parameters in curve fitting function - residuals = np.log10(psd) - psd_pred - ss_res = np.sum(residuals**2) - ss_tot = np.sum((np.log10(psd) - np.mean(np.log10(psd))) ** 2) - mse = np.mean(residuals**2) - - if fit_func == 'knee': - k = 3 # k -> number of params - elif fit_func == 'fixed': - k = 1 # k -> number of params + if psd_log: + residuals = np.log10(psd) - psd_pred + ss_res = np.sum(residuals**2) + ss_tot = np.sum((np.log10(psd) - np.mean(np.log10(psd))) ** 2) + mse = np.mean(residuals**2) + else: + residuals = psd - psd_pred + ss_res = np.sum(residuals**2) + ss_tot = np.sum((psd - np.mean(psd)) ** 2) + mse = np.mean(residuals**2) n = len(psd) bic = n * np.log(mse) + k * np.log(n) @@ -58,74 +60,83 @@ def _get_gof(psd: np.ndarray, psd_pred: np.ndarray, fit_func: str) -> pd.DataFra def _compute_slope( aperiodic_spectrum: np.ndarray, freq: np.ndarray, - fit_func: str, + fit_func: str | Callable, fit_bounds: tuple | None = None, scale_factor: float | int = 1, -) -> tuple[pd.DataFrame, pd.DataFrame]: - """get the slope of the aperiodic spectrum""" - - curv_kwargs = { + curv_kwargs: dict = { 'maxfev': 10_000, 'ftol': 1e-5, 'xtol': 1e-5, 'gtol': 1e-5, - } - - off_guess = [aperiodic_spectrum[0]] if fit_bounds is None else fit_bounds[0] - exp_guess = ( - [np.abs(np.log10(aperiodic_spectrum[0] / aperiodic_spectrum[-1]) / np.log10(freq[-1] / freq[0]))] - if fit_bounds is None - else fit_bounds[1] - ) - - valid_slope_functions = ['fixed', 'knee'] - assert fit_func in valid_slope_functions, f'The slope fitting function has to be in {valid_slope_functions}' - - if fit_func == 'fixed': - fit_f = fixed_model - - p, _ = curve_fit(fit_f, freq, np.log10(aperiodic_spectrum)) - - params = pd.DataFrame( - { - 'Offset': p[0], - 'Exponent': p[1], - 'fit_type': 'fixed', - }, - index=[0], - ) - psd_pred = fit_f(freq, *p) - - elif fit_func == 'knee': - fit_f = knee_model # type: ignore - # curve_fit_specs - cumsum_psd = np.cumsum(aperiodic_spectrum) - half_pw_freq = freq[np.abs(cumsum_psd - (0.5 * cumsum_psd[-1])).argmin()] - # make the knee guess the point where we have half the power in the spectrum seems plausible to me - knee_guess = [half_pw_freq ** (exp_guess[0] + exp_guess[0])] - # convert knee freq to knee val which should be 2*exp_1 but this seems good enough - curv_kwargs['p0'] = np.array(off_guess + knee_guess + exp_guess + exp_guess) # type: ignore - # print(curv_kwargs['p0']) - # make this optional - curv_kwargs['bounds'] = ((0, 0, 0, 0), (np.inf, np.inf, np.inf, np.inf)) # type: ignore - # knee value should always be positive at least intuitively - p, _ = curve_fit(fit_f, freq, np.log10(aperiodic_spectrum), **curv_kwargs) - - params = pd.DataFrame( - { - 'Offset': p[0] / scale_factor, - 'Knee': p[1], - 'Exponent_1': p[2], - 'Exponent_2': p[3], - 'Knee Frequency (Hz)': p[1] ** (1.0 / (2 * p[2] + p[3])), - 'fit_type': 'knee', - }, - index=[0], + }, + psd_log: bool = True, +) -> tuple[pd.DataFrame, pd.DataFrame]: + """get the slope of the aperiodic spectrum""" + + if isinstance(fit_func, str): + off_guess = [aperiodic_spectrum[0]] if fit_bounds is None else fit_bounds[0] + exp_guess = ( + [np.abs(np.log10(aperiodic_spectrum[0] / aperiodic_spectrum[-1]) / np.log10(freq[-1] / freq[0]))] + if fit_bounds is None + else fit_bounds[1] ) - psd_pred = fit_f(freq, *p) + valid_slope_functions = ['fixed', 'knee'] + assert fit_func in valid_slope_functions, f'The slope fitting function has to be in {valid_slope_functions}' + + if fit_func == 'fixed': + fit_f = fixed_model + + curv_kwargs['p0'] = np.array(off_guess + exp_guess) + curv_kwargs['bounds'] = ((0, -np.inf), (np.inf, np.inf)) # type: ignore + p, _ = curve_fit(fit_f, freq, np.log10(aperiodic_spectrum)) + + params = pd.DataFrame( + { + 'Offset': p[0], + 'Exponent': p[1], + 'fit_type': 'fixed', + }, + index=[0], + ) + psd_pred = fit_f(freq, *p) + + elif fit_func == 'knee': + fit_f = knee_model # type: ignore + # curve_fit_specs + cumsum_psd = np.cumsum(aperiodic_spectrum) + half_pw_freq = freq[np.abs(cumsum_psd - (0.5 * cumsum_psd[-1])).argmin()] + # make the knee guess the point where we have half the power in the spectrum seems plausible to me + knee_guess = [half_pw_freq ** (exp_guess[0] + exp_guess[0])] + # convert knee freq to knee val which should be 2*exp_1 but this seems good enough + curv_kwargs['p0'] = np.array(off_guess + knee_guess + exp_guess + exp_guess) # type: ignore + # make this optional + curv_kwargs['bounds'] = ((0, 0, 0, 0), (np.inf, np.inf, np.inf, np.inf)) # type: ignore + # knee value should always be positive at least intuitively + p, _ = curve_fit(fit_f, freq, np.log10(aperiodic_spectrum), **curv_kwargs) + + params = pd.DataFrame( + { + 'Offset': p[0] / scale_factor, + 'Knee': p[1], + 'Exponent_1': p[2], + 'Exponent_2': p[3], + 'Knee Frequency (Hz)': p[1] ** (1.0 / (2 * p[2] + p[3])), + 'fit_type': 'knee', + }, + index=[0], + ) + psd_pred = fit_f(freq, *p) + + gof = _get_gof(aperiodic_spectrum, psd_pred, len(p), fit_func) + gof['fit_type'] = fit_func - gof = _get_gof(aperiodic_spectrum, psd_pred, fit_func) - gof['fit_type'] = fit_func + else: + p, _ = curve_fit(fit_func, freq, aperiodic_spectrum, **curv_kwargs) + psd_pred = fit_func(freq, *p) + p_keys = [f'param_{ix}' for ix, _ in enumerate(p)] + params = pd.DataFrame(dict(zip(p_keys, p)), index=[0]) + gof = _get_gof(aperiodic_spectrum, psd_pred, len(p), 'custom', psd_log=psd_log) + gof['fit_type'] = 'custom' return params, gof @@ -133,10 +144,17 @@ def _compute_slope( def compute_slope( aperiodic_spectrum: np.ndarray, freqs: np.ndarray, - fit_func: str, + fit_func: str | Callable, ch_names: Iterable = (), scale: bool = False, fit_bounds: tuple[float, float] | None = None, + curv_kwargs: dict = { + 'maxfev': 10_000, + 'ftol': 1e-5, + 'xtol': 1e-5, + 'gtol': 1e-5, + }, + psd_log: bool = True, ) -> tuple[pd.DataFrame, pd.DataFrame]: """ This function can be used to extract aperiodic parameters from the aperiodic spectrum extracted from IRASA. @@ -185,7 +203,7 @@ def compute_slope( assert fit_bounds[0] > fmin, f'The selected lower bound is lower than the lowest frequency of {fmin}Hz' assert fit_bounds[1] < fmax, f'The selected upper bound is higher than the highest frequency of {fmax}Hz' - if freqs[0] == 0: + if np.logical_and(psd_log, freqs[0] == 0): warnings.warn( 'The first frequency appears to be 0 this will result in slope fitting problems. ' + 'Frequencies will be evaluated starting from the next highest in Hz' @@ -215,6 +233,8 @@ def num_zeros(decimal: int) -> float: fit_func=fit_func, scale_factor=scale_factor, fit_bounds=fit_bounds, + curv_kwargs=curv_kwargs, + psd_log=psd_log, ) params['ch_name'] = ch_name diff --git a/tests/settings.py b/tests/settings.py index f9babdd..2554378 100644 --- a/tests/settings.py +++ b/tests/settings.py @@ -28,6 +28,7 @@ (2.0, 625.0), ] # we test exp + knee combined as both relate to each other TOLERANCE = 0.3 # 0.15 +HIGH_TOLERANCE = 0.5 KNEE_TOLERANCE = 5 MIN_R2 = 0.8 # seems like a sensible minimum MIN_R2_SPRINT = 0.7 diff --git a/tests/test_compute_slope.py b/tests/test_compute_slope.py index 02c3f3f..50c9775 100644 --- a/tests/test_compute_slope.py +++ b/tests/test_compute_slope.py @@ -4,7 +4,7 @@ from pyrasa.utils.aperiodic_utils import compute_slope -from .settings import EXPONENT, FS, MIN_R2, TOLERANCE +from .settings import EXPONENT, FS, HIGH_TOLERANCE, MIN_R2, TOLERANCE # Test slope fitting functionality @@ -66,23 +66,44 @@ def test_slope_fitting_settings( compute_slope(psd[freq_logical], freqs[freq_logical], fit_func='fixed') -# Takes too long need to pregenerate -# @pytest.mark.parametrize('exponent, fs, knee_freq', [(-1, 500, 15)], scope='session') -# def test_slope_fitting_knee(knee_aperiodic_signal, fs, exponent): -# f_range = [1, 200] -# # test whether recombining periodic and aperiodic spectrum is equivalent to the original spectrum -# freqs, psd = dsp.welch(knee_aperiodic_signal, fs, nperseg=int(4 * fs)) -# freq_logical = np.logical_and(freqs >= f_range[0], freqs <= f_range[1]) -# freqs, psd = freqs[freq_logical], psd[freq_logical] -# # test whether we can reconstruct the exponent correctly -# ap_params_k, gof_k = compute_slope(psd, freqs, fit_func='knee') -# ap_params_f, gof_f = compute_slope(psd, freqs, fit_func='fixed') -# # assert pytest.approx(ap_params_k['Exponent_1'][0], abs=TOLERANCE) == 0 -# assert bool(np.isclose(ap_params_k['Exponent_2'][0], np.abs(exponent), atol=TOLERANCE)) -# assert bool(np.isclose(ap_params_k['Knee Frequency (Hz)'][0], KNEE_FREQ, atol=KNEE_TOLERANCE)) -# # test goodness of fit -# assert gof_k['r_squared'][0] > MIN_R2 -# assert gof_k['r_squared'][0] > gof_f['r_squared'][0] # r2 for knee model should be higher than knee if knee -# # bic and aic for knee model should be better if knee -# assert gof_k['AIC'][0] < gof_f['AIC'][0] -# assert gof_k['BIC'][0] < gof_f['BIC'][0] +# test custom slope fitting functions +@pytest.mark.parametrize('exponent, fs', [(-1, 500)], scope='session') +def test_custom_slope_fitting( + fixed_aperiodic_signal, + exponent, + fs, +): + f_range = [1, 300] + # test whether recombining periodic and aperiodic spectrum is equivalent to the original spectrum + freqs, psd = dsp.welch(fixed_aperiodic_signal, fs, nperseg=int(4 * fs)) + freq_logical = np.logical_and(freqs >= f_range[0], freqs <= f_range[1]) + psd, freqs = psd[freq_logical], freqs[freq_logical] + + def lin_reg(x, a, b): + """ + Linear fit w/o knee + NOTE: Data should be in loglog coordinates before running this + """ + + y_hat = a + b * x + + return y_hat + + psd_log = np.log10(psd) + freqs_log = np.log10(freqs) + off_guess = psd_log[0] + + curv_kwargs = { + 'maxfev': 10_000, + 'ftol': 1e-5, + 'xtol': 1e-5, + 'gtol': 1e-5, + } + curv_kwargs['p0'] = np.array(off_guess) + curv_kwargs['bounds'] = ((-np.inf, -np.inf), (np.inf, np.inf)) # type: ignore + + ap_params, gof = compute_slope(psd_log, freqs_log, fit_func=lin_reg, psd_log=False) + + # add a high tolerance + + assert pytest.approx(np.abs(ap_params['param_1'][0]), abs=HIGH_TOLERANCE) == np.abs(exponent) diff --git a/tests/test_mne.py b/tests/test_mne.py index aad426c..2f163c6 100644 --- a/tests/test_mne.py +++ b/tests/test_mne.py @@ -1,24 +1,24 @@ -import pytest -from neurodsp.utils.sim import set_random_seed +# import pytest +# from neurodsp.utils.sim import set_random_seed -from pyrasa.irasa_mne import irasa_epochs, irasa_raw +# from pyrasa.irasa_mne import irasa_epochs, irasa_raw -set_random_seed(42) +# set_random_seed(42) -@pytest.mark.filterwarnings('ignore:RuntimeWarning') -@pytest.mark.filterwarnings('ignore:UserWarning') -def test_mne(gen_mne_data_raw): - mne_data, epochs = gen_mne_data_raw +# @pytest.mark.filterwarnings('ignore:RuntimeWarning') +# @pytest.mark.filterwarnings('ignore:UserWarning') +# def test_mne(gen_mne_data_raw): +# mne_data, epochs = gen_mne_data_raw - # test raw - aperiodic_mne, periodic_mne = irasa_raw( - mne_data, band=(0.25, 50), duration=2, hset_info=(1.0, 2.0, 0.05), as_array=False - ) - aperiodic_mne.get_slopes(fit_func='fixed') - periodic_mne.get_peaks(smoothing_window=2) +# # test raw +# aperiodic_mne, periodic_mne = irasa_raw( +# mne_data, band=(0.25, 50), duration=2, hset_info=(1.0, 2.0, 0.05), as_array=False +# ) +# aperiodic_mne.get_slopes(fit_func='fixed') +# periodic_mne.get_peaks(smoothing_window=2) - # test epochs - aperiodic, periodic = irasa_epochs(epochs, band=(0.5, 50), hset_info=(1.0, 2.0, 0.05), as_array=False) - aperiodic.get_slopes(fit_func='fixed', scale=True) - periodic.get_peaks(smoothing_window=2) +# # test epochs +# aperiodic, periodic = irasa_epochs(epochs, band=(0.5, 50), hset_info=(1.0, 2.0, 0.05), as_array=False) +# aperiodic.get_slopes(fit_func='fixed', scale=True) +# periodic.get_peaks(smoothing_window=2) From a267701efa989655129804f86f175d566dc42cd7 Mon Sep 17 00:00:00 2001 From: Schmidt Fabian Date: Wed, 31 Jul 2024 14:56:40 +0200 Subject: [PATCH 03/18] added custom slope fitting --- tests/test_mne.py | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/tests/test_mne.py b/tests/test_mne.py index 2f163c6..aad426c 100644 --- a/tests/test_mne.py +++ b/tests/test_mne.py @@ -1,24 +1,24 @@ -# import pytest -# from neurodsp.utils.sim import set_random_seed +import pytest +from neurodsp.utils.sim import set_random_seed -# from pyrasa.irasa_mne import irasa_epochs, irasa_raw +from pyrasa.irasa_mne import irasa_epochs, irasa_raw -# set_random_seed(42) +set_random_seed(42) -# @pytest.mark.filterwarnings('ignore:RuntimeWarning') -# @pytest.mark.filterwarnings('ignore:UserWarning') -# def test_mne(gen_mne_data_raw): -# mne_data, epochs = gen_mne_data_raw +@pytest.mark.filterwarnings('ignore:RuntimeWarning') +@pytest.mark.filterwarnings('ignore:UserWarning') +def test_mne(gen_mne_data_raw): + mne_data, epochs = gen_mne_data_raw -# # test raw -# aperiodic_mne, periodic_mne = irasa_raw( -# mne_data, band=(0.25, 50), duration=2, hset_info=(1.0, 2.0, 0.05), as_array=False -# ) -# aperiodic_mne.get_slopes(fit_func='fixed') -# periodic_mne.get_peaks(smoothing_window=2) + # test raw + aperiodic_mne, periodic_mne = irasa_raw( + mne_data, band=(0.25, 50), duration=2, hset_info=(1.0, 2.0, 0.05), as_array=False + ) + aperiodic_mne.get_slopes(fit_func='fixed') + periodic_mne.get_peaks(smoothing_window=2) -# # test epochs -# aperiodic, periodic = irasa_epochs(epochs, band=(0.5, 50), hset_info=(1.0, 2.0, 0.05), as_array=False) -# aperiodic.get_slopes(fit_func='fixed', scale=True) -# periodic.get_peaks(smoothing_window=2) + # test epochs + aperiodic, periodic = irasa_epochs(epochs, band=(0.5, 50), hset_info=(1.0, 2.0, 0.05), as_array=False) + aperiodic.get_slopes(fit_func='fixed', scale=True) + periodic.get_peaks(smoothing_window=2) From ca152803499bc29014cb2b6233046a4ad65a8f76 Mon Sep 17 00:00:00 2001 From: Schmidt Fabian Date: Wed, 31 Jul 2024 15:30:53 +0200 Subject: [PATCH 04/18] improved parameter labels --- pyrasa/utils/aperiodic_utils.py | 24 ++++++++++++++---------- tests/test_compute_slope.py | 5 ++--- 2 files changed, 16 insertions(+), 13 deletions(-) diff --git a/pyrasa/utils/aperiodic_utils.py b/pyrasa/utils/aperiodic_utils.py index 33977a1..fb3799a 100644 --- a/pyrasa/utils/aperiodic_utils.py +++ b/pyrasa/utils/aperiodic_utils.py @@ -30,7 +30,7 @@ def knee_model(x: np.ndarray, b0: float, k: float, b1: float, b2: float) -> np.n return y_hat -def _get_gof(psd: np.ndarray, psd_pred: np.ndarray, k: int, fit_func: str, psd_log: bool = True) -> pd.DataFrame: +def _get_gof(psd: np.ndarray, psd_pred: np.ndarray, k: int, fit_func: str, semi_log: bool = True) -> pd.DataFrame: """ get goodness of fit (i.e. mean squared error and R2) BIC and AIC currently assume OLS @@ -38,16 +38,16 @@ def _get_gof(psd: np.ndarray, psd_pred: np.ndarray, k: int, fit_func: str, psd_l """ # k number of parameters in curve fitting function - if psd_log: + if semi_log: residuals = np.log10(psd) - psd_pred ss_res = np.sum(residuals**2) ss_tot = np.sum((np.log10(psd) - np.mean(np.log10(psd))) ** 2) - mse = np.mean(residuals**2) else: residuals = psd - psd_pred ss_res = np.sum(residuals**2) ss_tot = np.sum((psd - np.mean(psd)) ** 2) - mse = np.mean(residuals**2) + + mse = np.mean(residuals**2) n = len(psd) bic = n * np.log(mse) + k * np.log(n) @@ -69,7 +69,7 @@ def _compute_slope( 'xtol': 1e-5, 'gtol': 1e-5, }, - psd_log: bool = True, + semi_log: bool = True, ) -> tuple[pd.DataFrame, pd.DataFrame]: """get the slope of the aperiodic spectrum""" @@ -131,11 +131,15 @@ def _compute_slope( gof['fit_type'] = fit_func else: - p, _ = curve_fit(fit_func, freq, aperiodic_spectrum, **curv_kwargs) + if semi_log: + p, _ = curve_fit(fit_func, freq, np.log10(aperiodic_spectrum), **curv_kwargs) + else: + p, _ = curve_fit(fit_func, freq, aperiodic_spectrum, **curv_kwargs) + psd_pred = fit_func(freq, *p) p_keys = [f'param_{ix}' for ix, _ in enumerate(p)] params = pd.DataFrame(dict(zip(p_keys, p)), index=[0]) - gof = _get_gof(aperiodic_spectrum, psd_pred, len(p), 'custom', psd_log=psd_log) + gof = _get_gof(aperiodic_spectrum, psd_pred, len(p), 'custom', semi_log=semi_log) gof['fit_type'] = 'custom' return params, gof @@ -154,7 +158,7 @@ def compute_slope( 'xtol': 1e-5, 'gtol': 1e-5, }, - psd_log: bool = True, + semi_log: bool = True, ) -> tuple[pd.DataFrame, pd.DataFrame]: """ This function can be used to extract aperiodic parameters from the aperiodic spectrum extracted from IRASA. @@ -203,7 +207,7 @@ def compute_slope( assert fit_bounds[0] > fmin, f'The selected lower bound is lower than the lowest frequency of {fmin}Hz' assert fit_bounds[1] < fmax, f'The selected upper bound is higher than the highest frequency of {fmax}Hz' - if np.logical_and(psd_log, freqs[0] == 0): + if freqs[0] == 0: warnings.warn( 'The first frequency appears to be 0 this will result in slope fitting problems. ' + 'Frequencies will be evaluated starting from the next highest in Hz' @@ -234,7 +238,7 @@ def num_zeros(decimal: int) -> float: scale_factor=scale_factor, fit_bounds=fit_bounds, curv_kwargs=curv_kwargs, - psd_log=psd_log, + semi_log=semi_log, ) params['ch_name'] = ch_name diff --git a/tests/test_compute_slope.py b/tests/test_compute_slope.py index 50c9775..f15f156 100644 --- a/tests/test_compute_slope.py +++ b/tests/test_compute_slope.py @@ -73,7 +73,7 @@ def test_custom_slope_fitting( exponent, fs, ): - f_range = [1, 300] + f_range = [1.5, 300] # test whether recombining periodic and aperiodic spectrum is equivalent to the original spectrum freqs, psd = dsp.welch(fixed_aperiodic_signal, fs, nperseg=int(4 * fs)) freq_logical = np.logical_and(freqs >= f_range[0], freqs <= f_range[1]) @@ -102,8 +102,7 @@ def lin_reg(x, a, b): curv_kwargs['p0'] = np.array(off_guess) curv_kwargs['bounds'] = ((-np.inf, -np.inf), (np.inf, np.inf)) # type: ignore - ap_params, gof = compute_slope(psd_log, freqs_log, fit_func=lin_reg, psd_log=False) + ap_params, gof = compute_slope(psd_log, freqs_log, fit_func=lin_reg, semi_log=False) # add a high tolerance - assert pytest.approx(np.abs(ap_params['param_1'][0]), abs=HIGH_TOLERANCE) == np.abs(exponent) From 673e7a1fec60265cccd74545662ef514238cdfd0 Mon Sep 17 00:00:00 2001 From: Fabi Date: Sun, 4 Aug 2024 08:48:45 +0200 Subject: [PATCH 05/18] getting fit objects to work --- examples/basic_func_fun.py | 19 ++--- pyrasa/utils/aperiodic_utils.py | 124 +++++++++++--------------------- pyrasa/utils/fit_funcs.py | 103 ++++++++++++++++++++++++++ 3 files changed, 152 insertions(+), 94 deletions(-) create mode 100644 pyrasa/utils/fit_funcs.py diff --git a/examples/basic_func_fun.py b/examples/basic_func_fun.py index da06aa6..432ce86 100644 --- a/examples/basic_func_fun.py +++ b/examples/basic_func_fun.py @@ -34,7 +34,7 @@ #from pyrasa.irasa import irasa #%% -freq_irasa, psd_ap, psd_p = irasa(sig, +irasa_result = irasa(sig, fs=fs, band=(1, 100), psd_kwargs={'nperseg': duration*fs, @@ -44,26 +44,21 @@ f, axes = plt.subplots(ncols=2, figsize=(8, 4)) axes[0].set_title('Periodic') -axes[0].plot(freq_irasa, psd_p[0,:]) +axes[0].plot(irasa_result.freqs, irasa_result.periodic[0,:]) axes[0].set_ylabel('Power (a.u.)') axes[0].set_xlabel('Frequency (Hz)') axes[1].set_title('Aperiodic') -axes[1].loglog(freq_irasa, psd_ap[0,:]) +axes[1].loglog(irasa_result.freqs, irasa_result.aperiodic[0,:]) axes[1].set_ylabel('Power (a.u.)') axes[1].set_xlabel('Frequency (Hz)') f.tight_layout() # %% get periodic stuff -from pyrasa.utils.peak_utils import get_peak_params -get_peak_params(psd_p, freqs=freq_irasa) -# %% -from pyrasa.utils.aperiodic_utils import compute_slope -ap_params, gof_params = compute_slope(aperiodic_spectrum=psd_ap, - freqs=freq_irasa-1, - fit_func='fixed', - #fit_bounds=[0, 40] - ) +pe_params = irasa_result.get_peaks() +pe_params +#%% get aperiodics +ap_params = irasa_result.get_slopes(fit_func='fixed') ap_params # %% diff --git a/pyrasa/utils/aperiodic_utils.py b/pyrasa/utils/aperiodic_utils.py index c1c89ac..10400c2 100644 --- a/pyrasa/utils/aperiodic_utils.py +++ b/pyrasa/utils/aperiodic_utils.py @@ -1,12 +1,12 @@ """Utilities for slope fitting.""" import warnings -from collections.abc import Callable, Iterable +from collections.abc import Iterable import numpy as np import pandas as pd -from scipy.optimize import curve_fit +from pyrasa.utils.fit_funcs import AbstractFitFun, FixedFitFun, KneeFitFun from pyrasa.utils.types import SlopeFit @@ -40,14 +40,10 @@ def _get_gof(psd: np.ndarray, psd_pred: np.ndarray, k: int, fit_func: str, semi_ """ # k number of parameters in curve fitting function - if semi_log: - residuals = np.log10(psd) - psd_pred - ss_res = np.sum(residuals**2) - ss_tot = np.sum((np.log10(psd) - np.mean(np.log10(psd))) ** 2) - else: - residuals = psd - psd_pred - ss_res = np.sum(residuals**2) - ss_tot = np.sum((psd - np.mean(psd)) ** 2) + # add np.log10 to psd + residuals = psd - psd_pred + ss_res = np.sum(residuals**2) + ss_tot = np.sum((psd - np.mean(psd)) ** 2) mse = np.mean(residuals**2) @@ -62,78 +58,50 @@ def _get_gof(psd: np.ndarray, psd_pred: np.ndarray, k: int, fit_func: str, semi_ def _compute_slope( aperiodic_spectrum: np.ndarray, freq: np.ndarray, - fit_func: str | Callable, - fit_bounds: tuple | None = None, + fit_func: AbstractFitFun, scale_factor: float | int = 1, - curv_kwargs: dict = {}, semi_log: bool = True, ) -> tuple[pd.DataFrame, pd.DataFrame]: """get the slope of the aperiodic spectrum""" - if isinstance(fit_func, str): - off_guess = [aperiodic_spectrum[0]] if fit_bounds is None else fit_bounds[0] - exp_guess = ( - [np.abs(np.log10(aperiodic_spectrum[0] / aperiodic_spectrum[-1]) / np.log10(freq[-1] / freq[0]))] - if fit_bounds is None - else fit_bounds[1] + if fit_func == 'fixed': + fit_f = FixedFitFun(np.log10(aperiodic_spectrum), freq) + p = fit_f.fit_func() + params = pd.DataFrame( + { + 'Offset': p[0], + 'Exponent': p[1], + 'fit_type': 'fixed', + }, + index=[0], ) - valid_slope_functions = ['fixed', 'knee'] - assert fit_func in valid_slope_functions, f'The slope fitting function has to be in {valid_slope_functions}' - - if fit_func == 'fixed': - fit_f = fixed_model - - curv_kwargs['p0'] = np.array(off_guess + exp_guess) - curv_kwargs['bounds'] = ((0, -np.inf), (np.inf, np.inf)) # type: ignore - p, _ = curve_fit(fit_f, freq, np.log10(aperiodic_spectrum)) - - params = pd.DataFrame( - { - 'Offset': p[0], - 'Exponent': p[1], - 'fit_type': 'fixed', - }, - index=[0], - ) - psd_pred = fit_f(freq, *p) - - elif fit_func == 'knee': - fit_f = knee_model # type: ignore - # curve_fit_specs - cumsum_psd = np.cumsum(aperiodic_spectrum) - half_pw_freq = freq[np.abs(cumsum_psd - (0.5 * cumsum_psd[-1])).argmin()] - # make the knee guess the point where we have half the power in the spectrum seems plausible to me - knee_guess = [half_pw_freq ** (exp_guess[0] + exp_guess[0])] - # convert knee freq to knee val which should be 2*exp_1 but this seems good enough - curv_kwargs['p0'] = np.array(off_guess + knee_guess + exp_guess + exp_guess) # type: ignore - # make this optional - curv_kwargs['bounds'] = ((0, 0, 0, 0), (np.inf, np.inf, np.inf, np.inf)) # type: ignore - # knee value should always be positive at least intuitively - p, _ = curve_fit(fit_f, freq, np.log10(aperiodic_spectrum), **curv_kwargs) - - params = pd.DataFrame( - { - 'Offset': p[0] / scale_factor, - 'Knee': p[1], - 'Exponent_1': p[2], - 'Exponent_2': p[3], - 'Knee Frequency (Hz)': p[1] ** (1.0 / (2 * p[2] + p[3])), - 'fit_type': 'knee', - }, - index=[0], - ) - psd_pred = fit_f(freq, *p) + psd_pred = fit_f.func(freq, *p) gof = _get_gof(aperiodic_spectrum, psd_pred, len(p), fit_func) gof['fit_type'] = fit_func - else: - if semi_log: - p, _ = curve_fit(fit_func, freq, np.log10(aperiodic_spectrum), **curv_kwargs) - else: - p, _ = curve_fit(fit_func, freq, aperiodic_spectrum, **curv_kwargs) + elif fit_func == 'knee': + fit_f = KneeFitFun(np.log10(aperiodic_spectrum), freq) + p = fit_f.fit_func() + params = pd.DataFrame( + { + 'Offset': p[0] / scale_factor, + 'Knee': p[1], + 'Exponent_1': p[2], + 'Exponent_2': p[3], + 'Knee Frequency (Hz)': p[1] ** (1.0 / (2 * p[2] + p[3])), + 'fit_type': 'knee', + }, + index=[0], + ) + psd_pred = fit_f.func(freq, *p) - psd_pred = fit_func(freq, *p) + gof = _get_gof(aperiodic_spectrum, psd_pred, len(p), fit_func) + gof['fit_type'] = fit_func + + else: + p = fit_func(np.log10(aperiodic_spectrum), freq) + psd_pred = fit_func.fit_func(freq, *p) p_keys = [f'param_{ix}' for ix, _ in enumerate(p)] params = pd.DataFrame(dict(zip(p_keys, p)), index=[0]) gof = _get_gof(aperiodic_spectrum, psd_pred, len(p), 'custom', semi_log=semi_log) @@ -145,17 +113,10 @@ def _compute_slope( def compute_slope( aperiodic_spectrum: np.ndarray, freqs: np.ndarray, - fit_func: str | Callable, + fit_func: str | AbstractFitFun = 'fixed', ch_names: Iterable | None = None, scale: bool = False, fit_bounds: tuple[float, float] | None = None, - semi_log: bool = True, - curv_kwargs: dict = { - 'maxfev': 10_000, - 'ftol': 1e-5, - 'xtol': 1e-5, - 'gtol': 1e-5, - }, ) -> SlopeFit: """ This function can be used to extract aperiodic parameters from the aperiodic spectrum extracted from IRASA. @@ -203,6 +164,8 @@ def compute_slope( fmin, fmax = freqs.min(), freqs.max() assert fit_bounds[0] > fmin, f'The selected lower bound is lower than the lowest frequency of {fmin}Hz' assert fit_bounds[1] < fmax, f'The selected upper bound is higher than the highest frequency of {fmax}Hz' + freq_logical = np.logical_and(freqs >= fit_bounds[0], freqs <= fit_bounds[1]) + aperiodic_spectrum, freqs = aperiodic_spectrum[:, freq_logical], freqs[freq_logical] if freqs[0] == 0: warnings.warn( @@ -233,9 +196,6 @@ def num_zeros(decimal: int) -> float: freq=freqs, fit_func=fit_func, scale_factor=scale_factor, - fit_bounds=fit_bounds, - curv_kwargs=curv_kwargs, - semi_log=semi_log, ) params['ch_name'] = ch_name diff --git a/pyrasa/utils/fit_funcs.py b/pyrasa/utils/fit_funcs.py new file mode 100644 index 0000000..f02bca8 --- /dev/null +++ b/pyrasa/utils/fit_funcs.py @@ -0,0 +1,103 @@ +import numpy as np +from attrs import define +from scipy.optimize import curve_fit + + +@define +class AbstractFitFun: + x: np.ndarray + y: np.ndarray + + def func(self, *args: float, **kwargs: float) -> np.ndarray: + pass + + def curve_kwargs(self, *args: float, **kwargs: float) -> dict[str, any]: + return {} + + def fit_func(self, *args: float, **kwargs: float) -> np.ndarray: + curve_kwargs = self.curve_kwargs + p, _ = curve_fit(self.func, self.x, self.y, **curve_kwargs) + return p + + +# class AbstractFitFun(abc.ABC): +# def __init__(self, aperiodic_spectrum: np.ndarray, freq: np.ndarray): +# self.aperiodic_spectrum = aperiodic_spectrum +# self.freq = freq + +# @abc.abstractmethod +# def fit_func(self, *args: float, **kwargs: float) -> np.ndarray: +# pass + +# @property +# def curve_kwargs(self) -> dict[str, any]: +# return {} + +# def __call__(self) -> np.ndarray: +# p, _ = curve_fit(self.fit_func, self.aperiodic_spectrum, self.freq, **self.curv_kwargs) +# return p + + +class FixedFitFun(AbstractFitFun): + def func(self, x: np.ndarray, b0: float, b: float) -> np.ndarray: + """ + Specparams fixed fitting function. + Use this to model aperiodic activity without a spectral knee + """ + y_hat = b0 - np.log10(x**b) + + return y_hat + + @property + def curve_kwargs(self) -> dict[str, any]: + off_guess = self.x[0] + exp_guess = [np.abs(np.log10(self.x[0] / self.x[-1]) / np.log10(self.y[-1] / self.y[0]))] + return { + 'maxfev': 10_000, + 'ftol': 1e-5, + 'xtol': 1e-5, + 'gtol': 1e-5, + 'p0': np.array(off_guess + exp_guess), + 'bounds': ((-np.inf, -np.inf), (np.inf, np.inf)), + } + + +class KneeFitFun(AbstractFitFun): + def func( + self, + x: np.ndarray, + b0: float, + k: float, + b1: float, + b2: float, + ) -> np.ndarray: + """ + Model aperiodic activity with a spectral knee and a pre-knee slope. + Use this to model aperiodic activity with a spectral knee + """ + y_hat = b0 - np.log10(x**b1 * (k + x**b2)) + + return y_hat + + @property + def curve_kwargs(self) -> dict[str, any]: + off_guess = self.aperiodic_spectrum[0] + exp_guess = [ + np.abs( + np.log10(self.aperiodic_spectrum[0] / self.aperiodic_spectrum[-1]) + / np.log10(self.freq[-1] / self.freq[0]) + ) + ] + cumsum_psd = np.cumsum(self.aperiodic_spectrum) + half_pw_freq = self.freq[np.abs(cumsum_psd - (0.5 * cumsum_psd[-1])).argmin()] + # make the knee guess the point where we have half the power in the spectrum seems plausible to me + knee_guess = [half_pw_freq ** (exp_guess[0] + exp_guess[0])] + + return { + 'maxfev': 10_000, + 'ftol': 1e-5, + 'xtol': 1e-5, + 'gtol': 1e-5, + 'p0': np.array(off_guess + knee_guess + exp_guess + exp_guess), + 'bounds': ((0, 0, 0, 0), (np.inf, np.inf, np.inf, np.inf)), + } From 9c85729a6c877097d676239a170e11fda410c747 Mon Sep 17 00:00:00 2001 From: Fabi Date: Sun, 4 Aug 2024 09:44:44 +0200 Subject: [PATCH 06/18] some changes --- pyrasa/utils/aperiodic_utils.py | 6 +++--- pyrasa/utils/fit_funcs.py | 17 ++++++++--------- 2 files changed, 11 insertions(+), 12 deletions(-) diff --git a/pyrasa/utils/aperiodic_utils.py b/pyrasa/utils/aperiodic_utils.py index 10400c2..108a06e 100644 --- a/pyrasa/utils/aperiodic_utils.py +++ b/pyrasa/utils/aperiodic_utils.py @@ -65,7 +65,7 @@ def _compute_slope( """get the slope of the aperiodic spectrum""" if fit_func == 'fixed': - fit_f = FixedFitFun(np.log10(aperiodic_spectrum), freq) + fit_f = FixedFitFun(freq, np.log10(aperiodic_spectrum)) p = fit_f.fit_func() params = pd.DataFrame( { @@ -81,7 +81,7 @@ def _compute_slope( gof['fit_type'] = fit_func elif fit_func == 'knee': - fit_f = KneeFitFun(np.log10(aperiodic_spectrum), freq) + fit_f = KneeFitFun(freq, np.log10(aperiodic_spectrum)) p = fit_f.fit_func() params = pd.DataFrame( { @@ -100,7 +100,7 @@ def _compute_slope( gof['fit_type'] = fit_func else: - p = fit_func(np.log10(aperiodic_spectrum), freq) + p = fit_func(freq, np.log10(aperiodic_spectrum)) psd_pred = fit_func.fit_func(freq, *p) p_keys = [f'param_{ix}' for ix, _ in enumerate(p)] params = pd.DataFrame(dict(zip(p_keys, p)), index=[0]) diff --git a/pyrasa/utils/fit_funcs.py b/pyrasa/utils/fit_funcs.py index f02bca8..4951d03 100644 --- a/pyrasa/utils/fit_funcs.py +++ b/pyrasa/utils/fit_funcs.py @@ -5,8 +5,8 @@ @define class AbstractFitFun: - x: np.ndarray - y: np.ndarray + freq: np.ndarray + aperiodic: np.ndarray def func(self, *args: float, **kwargs: float) -> np.ndarray: pass @@ -16,7 +16,7 @@ def curve_kwargs(self, *args: float, **kwargs: float) -> dict[str, any]: def fit_func(self, *args: float, **kwargs: float) -> np.ndarray: curve_kwargs = self.curve_kwargs - p, _ = curve_fit(self.func, self.x, self.y, **curve_kwargs) + p, _ = curve_fit(self.func, self.freq, self.aperiodic, **curve_kwargs) return p @@ -39,19 +39,19 @@ def fit_func(self, *args: float, **kwargs: float) -> np.ndarray: class FixedFitFun(AbstractFitFun): - def func(self, x: np.ndarray, b0: float, b: float) -> np.ndarray: + def func(self, b0: float, b: float) -> np.ndarray: """ Specparams fixed fitting function. Use this to model aperiodic activity without a spectral knee """ - y_hat = b0 - np.log10(x**b) + y_hat = b0 - np.log10(self.freq**b) return y_hat @property def curve_kwargs(self) -> dict[str, any]: - off_guess = self.x[0] - exp_guess = [np.abs(np.log10(self.x[0] / self.x[-1]) / np.log10(self.y[-1] / self.y[0]))] + off_guess = self.aperiodic[0] + exp_guess = [np.abs(np.log10(self.aperiodic[0] / self.aperiodic[-1]) / np.log10(self.freq[-1] / self.freq[0]))] return { 'maxfev': 10_000, 'ftol': 1e-5, @@ -65,7 +65,6 @@ def curve_kwargs(self) -> dict[str, any]: class KneeFitFun(AbstractFitFun): def func( self, - x: np.ndarray, b0: float, k: float, b1: float, @@ -75,7 +74,7 @@ def func( Model aperiodic activity with a spectral knee and a pre-knee slope. Use this to model aperiodic activity with a spectral knee """ - y_hat = b0 - np.log10(x**b1 * (k + x**b2)) + y_hat = b0 - np.log10(self.x**b1 * (k + self.x**b2)) return y_hat From 9af38da6e51befe91696211e18d5bfbe53d6ae59 Mon Sep 17 00:00:00 2001 From: Fabi Date: Sun, 4 Aug 2024 09:58:20 +0200 Subject: [PATCH 07/18] solved aperiodic bug 1 --- examples/basic_func_fun.py | 2 +- pyrasa/utils/aperiodic_utils.py | 4 ++-- pyrasa/utils/fit_funcs.py | 20 +++++++++++++------- 3 files changed, 16 insertions(+), 10 deletions(-) diff --git a/examples/basic_func_fun.py b/examples/basic_func_fun.py index 432ce86..9471526 100644 --- a/examples/basic_func_fun.py +++ b/examples/basic_func_fun.py @@ -60,5 +60,5 @@ pe_params #%% get aperiodics ap_params = irasa_result.get_slopes(fit_func='fixed') -ap_params +ap_params.gof # %% diff --git a/pyrasa/utils/aperiodic_utils.py b/pyrasa/utils/aperiodic_utils.py index 108a06e..01108af 100644 --- a/pyrasa/utils/aperiodic_utils.py +++ b/pyrasa/utils/aperiodic_utils.py @@ -77,7 +77,7 @@ def _compute_slope( ) psd_pred = fit_f.func(freq, *p) - gof = _get_gof(aperiodic_spectrum, psd_pred, len(p), fit_func) + gof = _get_gof(np.log10(aperiodic_spectrum), psd_pred, len(p), fit_func) gof['fit_type'] = fit_func elif fit_func == 'knee': @@ -96,7 +96,7 @@ def _compute_slope( ) psd_pred = fit_f.func(freq, *p) - gof = _get_gof(aperiodic_spectrum, psd_pred, len(p), fit_func) + gof = _get_gof(np.log10(aperiodic_spectrum), psd_pred, len(p), fit_func) gof['fit_type'] = fit_func else: diff --git a/pyrasa/utils/fit_funcs.py b/pyrasa/utils/fit_funcs.py index 4951d03..fedfa39 100644 --- a/pyrasa/utils/fit_funcs.py +++ b/pyrasa/utils/fit_funcs.py @@ -6,7 +6,7 @@ @define class AbstractFitFun: freq: np.ndarray - aperiodic: np.ndarray + aperiodic_spectrum: np.ndarray def func(self, *args: float, **kwargs: float) -> np.ndarray: pass @@ -16,7 +16,7 @@ def curve_kwargs(self, *args: float, **kwargs: float) -> dict[str, any]: def fit_func(self, *args: float, **kwargs: float) -> np.ndarray: curve_kwargs = self.curve_kwargs - p, _ = curve_fit(self.func, self.freq, self.aperiodic, **curve_kwargs) + p, _ = curve_fit(self.func, self.freq, self.aperiodic_spectrum, **curve_kwargs) return p @@ -39,19 +39,24 @@ def fit_func(self, *args: float, **kwargs: float) -> np.ndarray: class FixedFitFun(AbstractFitFun): - def func(self, b0: float, b: float) -> np.ndarray: + def func(self, x: np.ndarray, b0: float, b: float) -> np.ndarray: """ Specparams fixed fitting function. Use this to model aperiodic activity without a spectral knee """ - y_hat = b0 - np.log10(self.freq**b) + y_hat = b0 - np.log10(x**b) return y_hat @property def curve_kwargs(self) -> dict[str, any]: - off_guess = self.aperiodic[0] - exp_guess = [np.abs(np.log10(self.aperiodic[0] / self.aperiodic[-1]) / np.log10(self.freq[-1] / self.freq[0]))] + off_guess = self.aperiodic_spectrum[0] + exp_guess = [ + np.abs( + np.log10(self.aperiodic_spectrum[0] / self.aperiodic_spectrum[-1]) + / np.log10(self.freq[-1] / self.freq[0]) + ) + ] return { 'maxfev': 10_000, 'ftol': 1e-5, @@ -65,6 +70,7 @@ def curve_kwargs(self) -> dict[str, any]: class KneeFitFun(AbstractFitFun): def func( self, + x: np.ndarray, b0: float, k: float, b1: float, @@ -74,7 +80,7 @@ def func( Model aperiodic activity with a spectral knee and a pre-knee slope. Use this to model aperiodic activity with a spectral knee """ - y_hat = b0 - np.log10(self.x**b1 * (k + self.x**b2)) + y_hat = b0 - np.log10(x**b1 * (k + x**b2)) return y_hat From 692b5b8637da275e657cd0a4a387d12713e0c77a Mon Sep 17 00:00:00 2001 From: Fabi Date: Sun, 4 Aug 2024 11:30:09 +0200 Subject: [PATCH 08/18] slope fitting works again --- examples/basic_func_fun.py | 2 +- pyrasa/utils/fit_funcs.py | 18 +++++++----------- 2 files changed, 8 insertions(+), 12 deletions(-) diff --git a/examples/basic_func_fun.py b/examples/basic_func_fun.py index 9471526..294b711 100644 --- a/examples/basic_func_fun.py +++ b/examples/basic_func_fun.py @@ -59,6 +59,6 @@ pe_params = irasa_result.get_peaks() pe_params #%% get aperiodics -ap_params = irasa_result.get_slopes(fit_func='fixed') +ap_params = irasa_result.get_slopes(fit_func='knee') ap_params.gof # %% diff --git a/pyrasa/utils/fit_funcs.py b/pyrasa/utils/fit_funcs.py index fedfa39..b8db7ab 100644 --- a/pyrasa/utils/fit_funcs.py +++ b/pyrasa/utils/fit_funcs.py @@ -50,12 +50,10 @@ def func(self, x: np.ndarray, b0: float, b: float) -> np.ndarray: @property def curve_kwargs(self) -> dict[str, any]: - off_guess = self.aperiodic_spectrum[0] + aperiodic_nolog = 10**self.aperiodic_spectrum + off_guess = [aperiodic_nolog[0]] exp_guess = [ - np.abs( - np.log10(self.aperiodic_spectrum[0] / self.aperiodic_spectrum[-1]) - / np.log10(self.freq[-1] / self.freq[0]) - ) + np.abs(np.log10(aperiodic_nolog[0] / aperiodic_nolog[-1]) / np.log10(self.freq[-1] / self.freq[0])) ] return { 'maxfev': 10_000, @@ -86,14 +84,12 @@ def func( @property def curve_kwargs(self) -> dict[str, any]: - off_guess = self.aperiodic_spectrum[0] + aperiodic_nolog = 10**self.aperiodic_spectrum + off_guess = [aperiodic_nolog[0]] exp_guess = [ - np.abs( - np.log10(self.aperiodic_spectrum[0] / self.aperiodic_spectrum[-1]) - / np.log10(self.freq[-1] / self.freq[0]) - ) + np.abs(np.log10(aperiodic_nolog[0] / aperiodic_nolog[-1]) / np.log10(self.freq[-1] / self.freq[0])) ] - cumsum_psd = np.cumsum(self.aperiodic_spectrum) + cumsum_psd = np.cumsum(aperiodic_nolog) half_pw_freq = self.freq[np.abs(cumsum_psd - (0.5 * cumsum_psd[-1])).argmin()] # make the knee guess the point where we have half the power in the spectrum seems plausible to me knee_guess = [half_pw_freq ** (exp_guess[0] + exp_guess[0])] From c1161d315b73ac2d6ad11a2d44537228a8813631 Mon Sep 17 00:00:00 2001 From: Fabi Date: Mon, 5 Aug 2024 11:16:13 +0200 Subject: [PATCH 09/18] implemented custom, fit func --- examples/custom_fit_functions.py | 50 +++++++++++++++ pyrasa/utils/aperiodic_utils.py | 76 +++------------------- pyrasa/utils/fit_funcs.py | 104 +++++++++++++++++++++++-------- tests/test_compute_slope.py | 54 ++++++++-------- 4 files changed, 166 insertions(+), 118 deletions(-) create mode 100644 examples/custom_fit_functions.py diff --git a/examples/custom_fit_functions.py b/examples/custom_fit_functions.py new file mode 100644 index 0000000..7ef2e0c --- /dev/null +++ b/examples/custom_fit_functions.py @@ -0,0 +1,50 @@ +#%% +import scipy.signal as dsp +from pyrasa.utils.aperiodic_utils import compute_slope +from pyrasa.utils.fit_funcs import AbstractFitFun +import numpy as np +from neurodsp.sim import sim_powerlaw +from typing import Any + +n_secs = 60 +fs=500 +f_range = [1.5, 300] +exponent = -1.5 + +sig = sim_powerlaw(n_seconds=n_secs, fs=fs, exponent=exponent) + +# test whether recombining periodic and aperiodic spectrum is equivalent to the original spectrum +freqs, psd = dsp.welch(sig, fs, nperseg=int(4 * fs)) +freq_logical = np.logical_and(freqs >= f_range[0], freqs <= f_range[1]) +psd, freqs = psd[freq_logical], freqs[freq_logical] + + +class CustomFitFun(AbstractFitFun): + def func(self, x: np.ndarray, a: float, b: float) -> np.ndarray: + """ + Specparams fixed fitting function. + Use this to model aperiodic activity without a spectral knee + """ + y_hat = a + b * x + + return y_hat + + @property + def curve_kwargs(self) -> dict[str, Any]: + aperiodic_nolog = 10**self.aperiodic_spectrum + off_guess = [aperiodic_nolog[0]] + exp_guess = [ + np.abs(np.log10(aperiodic_nolog[0] / aperiodic_nolog[-1]) / np.log10(self.freq[-1] / self.freq[0])) + ] + return { + 'maxfev': 10_000, + 'ftol': 1e-5, + 'xtol': 1e-5, + 'gtol': 1e-5, + 'p0': np.array(off_guess + exp_guess), + 'bounds': ((-np.inf, -np.inf), (np.inf, np.inf)), + } + +#%% +slope_fit = compute_slope(np.log10(psd), np.log10(freqs), fit_func=CustomFitFun) +# %% diff --git a/pyrasa/utils/aperiodic_utils.py b/pyrasa/utils/aperiodic_utils.py index 01108af..fc082ce 100644 --- a/pyrasa/utils/aperiodic_utils.py +++ b/pyrasa/utils/aperiodic_utils.py @@ -32,80 +32,24 @@ def knee_model(x: np.ndarray, b0: float, k: float, b1: float, b2: float) -> np.n return y_hat -def _get_gof(psd: np.ndarray, psd_pred: np.ndarray, k: int, fit_func: str, semi_log: bool = True) -> pd.DataFrame: - """ - get goodness of fit (i.e. mean squared error and R2) - BIC and AIC currently assume OLS - https://machinelearningmastery.com/probabilistic-model-selection-measures/ - """ - # k number of parameters in curve fitting function - - # add np.log10 to psd - residuals = psd - psd_pred - ss_res = np.sum(residuals**2) - ss_tot = np.sum((psd - np.mean(psd)) ** 2) - - mse = np.mean(residuals**2) - - n = len(psd) - bic = n * np.log(mse) + k * np.log(n) - aic = n * np.log(mse) + 2 * k - - gof = pd.DataFrame({'mse': mse, 'r_squared': 1 - (ss_res / ss_tot), 'BIC': bic, 'AIC': aic}, index=[0]) - return gof - - def _compute_slope( aperiodic_spectrum: np.ndarray, freq: np.ndarray, - fit_func: AbstractFitFun, + fit_func: str | AbstractFitFun, scale_factor: float | int = 1, - semi_log: bool = True, ) -> tuple[pd.DataFrame, pd.DataFrame]: """get the slope of the aperiodic spectrum""" - if fit_func == 'fixed': - fit_f = FixedFitFun(freq, np.log10(aperiodic_spectrum)) - p = fit_f.fit_func() - params = pd.DataFrame( - { - 'Offset': p[0], - 'Exponent': p[1], - 'fit_type': 'fixed', - }, - index=[0], - ) - psd_pred = fit_f.func(freq, *p) - - gof = _get_gof(np.log10(aperiodic_spectrum), psd_pred, len(p), fit_func) - gof['fit_type'] = fit_func - - elif fit_func == 'knee': - fit_f = KneeFitFun(freq, np.log10(aperiodic_spectrum)) - p = fit_f.fit_func() - params = pd.DataFrame( - { - 'Offset': p[0] / scale_factor, - 'Knee': p[1], - 'Exponent_1': p[2], - 'Exponent_2': p[3], - 'Knee Frequency (Hz)': p[1] ** (1.0 / (2 * p[2] + p[3])), - 'fit_type': 'knee', - }, - index=[0], - ) - psd_pred = fit_f.func(freq, *p) - - gof = _get_gof(np.log10(aperiodic_spectrum), psd_pred, len(p), fit_func) - gof['fit_type'] = fit_func - + if isinstance(fit_func, str) and fit_func == 'fixed': + fit_f = FixedFitFun(freq, np.log10(aperiodic_spectrum), scale_factor=scale_factor) + elif isinstance(fit_func, str) and fit_func == 'knee': + fit_f = KneeFitFun(freq, np.log10(aperiodic_spectrum), scale_factor=scale_factor) + elif issubclass(fit_func, AbstractFitFun): + fit_f = fit_func(freq, aperiodic_spectrum, scale_factor=scale_factor) else: - p = fit_func(freq, np.log10(aperiodic_spectrum)) - psd_pred = fit_func.fit_func(freq, *p) - p_keys = [f'param_{ix}' for ix, _ in enumerate(p)] - params = pd.DataFrame(dict(zip(p_keys, p)), index=[0]) - gof = _get_gof(aperiodic_spectrum, psd_pred, len(p), 'custom', semi_log=semi_log) - gof['fit_type'] = 'custom' + raise ValueError('fit_func must be either "fixed" or "knee" or a subclass of "AbstractFitFun".') + + params, gof = fit_f.fit_func() return params, gof diff --git a/pyrasa/utils/fit_funcs.py b/pyrasa/utils/fit_funcs.py index b8db7ab..f09e6ff 100644 --- a/pyrasa/utils/fit_funcs.py +++ b/pyrasa/utils/fit_funcs.py @@ -1,55 +1,97 @@ +import abc +import inspect +from collections.abc import Callable +from typing import Any + import numpy as np +import pandas as pd from attrs import define from scipy.optimize import curve_fit +def get_args(f: Callable) -> list: + return inspect.getfullargspec(f)[0][2:] + + +def _get_gof(psd: np.ndarray, psd_pred: np.ndarray, k: int, fit_type: str) -> pd.DataFrame: + """ + get goodness of fit (i.e. mean squared error and R2) + BIC and AIC currently assume OLS + https://machinelearningmastery.com/probabilistic-model-selection-measures/ + """ + # k number of parameters in curve fitting function + + # add np.log10 to psd + residuals = psd - psd_pred + ss_res = np.sum(residuals**2) + ss_tot = np.sum((psd - np.mean(psd)) ** 2) + + mse = np.mean(residuals**2) + + n = len(psd) + bic = n * np.log(mse) + k * np.log(n) + aic = n * np.log(mse) + 2 * k + + gof = pd.DataFrame({'mse': mse, 'r_squared': 1 - (ss_res / ss_tot), 'BIC': bic, 'AIC': aic}, index=[0]) + gof['fit_type'] = fit_type + return gof + + @define -class AbstractFitFun: +class AbstractFitFun(abc.ABC): freq: np.ndarray aperiodic_spectrum: np.ndarray + scale_factor: int | float + label: str = 'custom' + @abc.abstractmethod def func(self, *args: float, **kwargs: float) -> np.ndarray: pass - def curve_kwargs(self, *args: float, **kwargs: float) -> dict[str, any]: + def curve_kwargs(self, *args: float, **kwargs: float) -> dict[str, Any]: return {} - def fit_func(self, *args: float, **kwargs: float) -> np.ndarray: + def add_infos_to_df(self, df_params: pd.DataFrame) -> pd.DataFrame: + return df_params + + def handle_scaling(self, df_params: pd.DataFrame, scale_factor: float) -> pd.DataFrame: + if 'Offset' in df_params.columns: + df_params['Offset'] /= scale_factor + elif scale_factor != 1.0: + raise ValueError('Scale Factor not handled. You need to overwrite the handle_scaling method.') + return df_params + + def fit_func(self, *args: float, **kwargs: float) -> tuple[pd.DataFrame, pd.DataFrame]: curve_kwargs = self.curve_kwargs p, _ = curve_fit(self.func, self.freq, self.aperiodic_spectrum, **curve_kwargs) - return p - -# class AbstractFitFun(abc.ABC): -# def __init__(self, aperiodic_spectrum: np.ndarray, freq: np.ndarray): -# self.aperiodic_spectrum = aperiodic_spectrum -# self.freq = freq + my_args = get_args(self.func) + df_params = pd.DataFrame(dict(zip(my_args, p)), index=[0]) + df_params['fit_type'] = self.label -# @abc.abstractmethod -# def fit_func(self, *args: float, **kwargs: float) -> np.ndarray: -# pass + pred = self.func(self.freq, *p) + df_gof = _get_gof(self.aperiodic_spectrum, pred, len(p), self.label) -# @property -# def curve_kwargs(self) -> dict[str, any]: -# return {} + df_params = self.add_infos_to_df(df_params) + df_params = self.handle_scaling(df_params, scale_factor=self.scale_factor) -# def __call__(self) -> np.ndarray: -# p, _ = curve_fit(self.fit_func, self.aperiodic_spectrum, self.freq, **self.curv_kwargs) -# return p + return df_params, df_gof class FixedFitFun(AbstractFitFun): - def func(self, x: np.ndarray, b0: float, b: float) -> np.ndarray: + label: str = 'fixed' + + def func(self, x: np.ndarray, Offset: float, Exponent: float) -> np.ndarray: # noqa N803 """ Specparams fixed fitting function. Use this to model aperiodic activity without a spectral knee """ - y_hat = b0 - np.log10(x**b) + y_hat = Offset - np.log10(x**Exponent) return y_hat @property - def curve_kwargs(self) -> dict[str, any]: + def curve_kwargs(self) -> dict[str, Any]: aperiodic_nolog = 10**self.aperiodic_spectrum off_guess = [aperiodic_nolog[0]] exp_guess = [ @@ -66,24 +108,32 @@ def curve_kwargs(self) -> dict[str, any]: class KneeFitFun(AbstractFitFun): + label: str = 'knee' + def func( self, x: np.ndarray, - b0: float, - k: float, - b1: float, - b2: float, + Offset: float, # noqa N803 + Knee: float, # noqa N803 + Exponent_1: float, # noqa N803 + Exponent_2: float, # noqa N803 ) -> np.ndarray: """ Model aperiodic activity with a spectral knee and a pre-knee slope. Use this to model aperiodic activity with a spectral knee """ - y_hat = b0 - np.log10(x**b1 * (k + x**b2)) + y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2)) return y_hat + def add_infos_to_df(self, df_params: pd.DataFrame) -> pd.DataFrame: + df_params['Knee Frequency (Hz)'] = df_params['Knee'] ** ( + 1.0 / (2 * df_params['Exponent_1'] + df_params['Exponent_2']) + ) + return df_params + @property - def curve_kwargs(self) -> dict[str, any]: + def curve_kwargs(self) -> dict[str, Any]: aperiodic_nolog = 10**self.aperiodic_spectrum off_guess = [aperiodic_nolog[0]] exp_guess = [ diff --git a/tests/test_compute_slope.py b/tests/test_compute_slope.py index 4b01cc3..a71f5c8 100644 --- a/tests/test_compute_slope.py +++ b/tests/test_compute_slope.py @@ -3,6 +3,7 @@ import scipy.signal as dsp from pyrasa.utils.aperiodic_utils import compute_slope +from pyrasa.utils.fit_funcs import AbstractFitFun from .settings import EXPONENT, FS, HIGH_TOLERANCE, MIN_R2, TOLERANCE @@ -79,30 +80,33 @@ def test_custom_slope_fitting( freq_logical = np.logical_and(freqs >= f_range[0], freqs <= f_range[1]) psd, freqs = psd[freq_logical], freqs[freq_logical] - def lin_reg(x, a, b): - """ - Linear fit w/o knee - NOTE: Data should be in loglog coordinates before running this - """ - - y_hat = a + b * x - - return y_hat - - psd_log = np.log10(psd) - freqs_log = np.log10(freqs) - off_guess = psd_log[0] - - curv_kwargs = { - 'maxfev': 10_000, - 'ftol': 1e-5, - 'xtol': 1e-5, - 'gtol': 1e-5, - } - curv_kwargs['p0'] = np.array(off_guess) - curv_kwargs['bounds'] = ((-np.inf, -np.inf), (np.inf, np.inf)) # type: ignore - - slope_fit = compute_slope(psd_log, freqs_log, fit_func=lin_reg, semi_log=False) + class CustomFitFun(AbstractFitFun): + def func(self, x: np.ndarray, a: float, b: float) -> np.ndarray: + """ + Specparams fixed fitting function. + Use this to model aperiodic activity without a spectral knee + """ + y_hat = a + b * x + + return y_hat + + @property + def curve_kwargs(self) -> dict[str, any]: + aperiodic_nolog = self.aperiodic_spectrum + off_guess = [aperiodic_nolog[0]] + exp_guess = [ + np.abs(np.log10(aperiodic_nolog[0] / aperiodic_nolog[-1]) / np.log10(self.freq[-1] / self.freq[0])) + ] + return { + 'maxfev': 10_000, + 'ftol': 1e-5, + 'xtol': 1e-5, + 'gtol': 1e-5, + 'p0': np.array(off_guess + exp_guess), + 'bounds': ((-np.inf, -np.inf), (np.inf, np.inf)), + } + + slope_fit = compute_slope(np.log10(psd), np.log10(freqs), fit_func=CustomFitFun) # add a high tolerance - assert pytest.approx(np.abs(slope_fit.aperiodic_params['param_1'][0]), abs=HIGH_TOLERANCE) == np.abs(exponent) + assert pytest.approx(np.abs(slope_fit.aperiodic_params['b'][0]), abs=HIGH_TOLERANCE) == np.abs(exponent) From 973a98e49e73ad211ecc92ceb8df9e5b6bbd8c19 Mon Sep 17 00:00:00 2001 From: Thomas Hartmann Date: Mon, 5 Aug 2024 13:15:49 +0200 Subject: [PATCH 10/18] simplify _compute_slope --- pyrasa/utils/aperiodic_utils.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/pyrasa/utils/aperiodic_utils.py b/pyrasa/utils/aperiodic_utils.py index fc082ce..96ab8a7 100644 --- a/pyrasa/utils/aperiodic_utils.py +++ b/pyrasa/utils/aperiodic_utils.py @@ -2,6 +2,7 @@ import warnings from collections.abc import Iterable +from typing import Type import numpy as np import pandas as pd @@ -35,20 +36,17 @@ def knee_model(x: np.ndarray, b0: float, k: float, b1: float, b2: float) -> np.n def _compute_slope( aperiodic_spectrum: np.ndarray, freq: np.ndarray, - fit_func: str | AbstractFitFun, + fit_func: str | Type[AbstractFitFun], scale_factor: float | int = 1, ) -> tuple[pd.DataFrame, pd.DataFrame]: """get the slope of the aperiodic spectrum""" if isinstance(fit_func, str) and fit_func == 'fixed': - fit_f = FixedFitFun(freq, np.log10(aperiodic_spectrum), scale_factor=scale_factor) + fit_func = FixedFitFun elif isinstance(fit_func, str) and fit_func == 'knee': - fit_f = KneeFitFun(freq, np.log10(aperiodic_spectrum), scale_factor=scale_factor) - elif issubclass(fit_func, AbstractFitFun): - fit_f = fit_func(freq, aperiodic_spectrum, scale_factor=scale_factor) - else: - raise ValueError('fit_func must be either "fixed" or "knee" or a subclass of "AbstractFitFun".') + fit_func = KneeFitFun + fit_f = fit_func(freq, aperiodic_spectrum, scale_factor=scale_factor) params, gof = fit_f.fit_func() return params, gof From 58ca09c59c625224b8be169817eb9b0f20c89637 Mon Sep 17 00:00:00 2001 From: Thomas Hartmann Date: Mon, 5 Aug 2024 13:23:48 +0200 Subject: [PATCH 11/18] have green tests --- pyrasa/utils/fit_funcs.py | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/pyrasa/utils/fit_funcs.py b/pyrasa/utils/fit_funcs.py index f09e6ff..6fe0cc7 100644 --- a/pyrasa/utils/fit_funcs.py +++ b/pyrasa/utils/fit_funcs.py @@ -1,7 +1,7 @@ import abc import inspect from collections.abc import Callable -from typing import Any +from typing import Any, ClassVar import numpy as np import pandas as pd @@ -42,12 +42,21 @@ class AbstractFitFun(abc.ABC): freq: np.ndarray aperiodic_spectrum: np.ndarray scale_factor: int | float - label: str = 'custom' + label: ClassVar[str] = 'custom' + log10_aperiodic: ClassVar[bool] = False + log10_freq: ClassVar[bool] = False + + def __attrs_post_init__(self): + if self.log10_aperiodic: + self.aperiodic_spectrum = np.log10(self.aperiodic_spectrum) + if self.log10_freq: + self.freq = np.log10(self.freq) @abc.abstractmethod def func(self, *args: float, **kwargs: float) -> np.ndarray: pass + @property def curve_kwargs(self, *args: float, **kwargs: float) -> dict[str, Any]: return {} @@ -80,6 +89,7 @@ def fit_func(self, *args: float, **kwargs: float) -> tuple[pd.DataFrame, pd.Data class FixedFitFun(AbstractFitFun): label: str = 'fixed' + log10_aperiodic = True def func(self, x: np.ndarray, Offset: float, Exponent: float) -> np.ndarray: # noqa N803 """ @@ -109,6 +119,7 @@ def curve_kwargs(self) -> dict[str, Any]: class KneeFitFun(AbstractFitFun): label: str = 'knee' + log10_aperiodic = True def func( self, From 38aa658a2c0bfdefeae1c0dd7c98bad5a3a8f2e8 Mon Sep 17 00:00:00 2001 From: Thomas Hartmann Date: Mon, 5 Aug 2024 13:27:36 +0200 Subject: [PATCH 12/18] linter happy --- pyrasa/utils/aperiodic_utils.py | 3 +-- pyrasa/utils/fit_funcs.py | 8 ++++---- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/pyrasa/utils/aperiodic_utils.py b/pyrasa/utils/aperiodic_utils.py index 96ab8a7..4e9869e 100644 --- a/pyrasa/utils/aperiodic_utils.py +++ b/pyrasa/utils/aperiodic_utils.py @@ -2,7 +2,6 @@ import warnings from collections.abc import Iterable -from typing import Type import numpy as np import pandas as pd @@ -36,7 +35,7 @@ def knee_model(x: np.ndarray, b0: float, k: float, b1: float, b2: float) -> np.n def _compute_slope( aperiodic_spectrum: np.ndarray, freq: np.ndarray, - fit_func: str | Type[AbstractFitFun], + fit_func: str | type[AbstractFitFun], scale_factor: float | int = 1, ) -> tuple[pd.DataFrame, pd.DataFrame]: """get the slope of the aperiodic spectrum""" diff --git a/pyrasa/utils/fit_funcs.py b/pyrasa/utils/fit_funcs.py index 6fe0cc7..5178d59 100644 --- a/pyrasa/utils/fit_funcs.py +++ b/pyrasa/utils/fit_funcs.py @@ -46,7 +46,7 @@ class AbstractFitFun(abc.ABC): log10_aperiodic: ClassVar[bool] = False log10_freq: ClassVar[bool] = False - def __attrs_post_init__(self): + def __attrs_post_init__(self) -> None: if self.log10_aperiodic: self.aperiodic_spectrum = np.log10(self.aperiodic_spectrum) if self.log10_freq: @@ -57,7 +57,7 @@ def func(self, *args: float, **kwargs: float) -> np.ndarray: pass @property - def curve_kwargs(self, *args: float, **kwargs: float) -> dict[str, Any]: + def curve_kwargs(self) -> dict[str, Any]: return {} def add_infos_to_df(self, df_params: pd.DataFrame) -> pd.DataFrame: @@ -88,7 +88,7 @@ def fit_func(self, *args: float, **kwargs: float) -> tuple[pd.DataFrame, pd.Data class FixedFitFun(AbstractFitFun): - label: str = 'fixed' + label = 'fixed' log10_aperiodic = True def func(self, x: np.ndarray, Offset: float, Exponent: float) -> np.ndarray: # noqa N803 @@ -118,7 +118,7 @@ def curve_kwargs(self) -> dict[str, Any]: class KneeFitFun(AbstractFitFun): - label: str = 'knee' + label = 'knee' log10_aperiodic = True def func( From ad4d407ee8b825c3cf6efef520ebffd28f5bd6ec Mon Sep 17 00:00:00 2001 From: Thomas Hartmann Date: Mon, 5 Aug 2024 13:28:51 +0200 Subject: [PATCH 13/18] fixed setting fit_func --- pyrasa/utils/aperiodic_utils.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/pyrasa/utils/aperiodic_utils.py b/pyrasa/utils/aperiodic_utils.py index 4e9869e..7451def 100644 --- a/pyrasa/utils/aperiodic_utils.py +++ b/pyrasa/utils/aperiodic_utils.py @@ -40,10 +40,13 @@ def _compute_slope( ) -> tuple[pd.DataFrame, pd.DataFrame]: """get the slope of the aperiodic spectrum""" - if isinstance(fit_func, str) and fit_func == 'fixed': - fit_func = FixedFitFun - elif isinstance(fit_func, str) and fit_func == 'knee': - fit_func = KneeFitFun + if isinstance(fit_func, str): + if fit_func == 'fixed': + fit_func = FixedFitFun + elif fit_func == 'knee': + fit_func = KneeFitFun + else: + raise ValueError('fit_func should be either "fixed" or "knee"') fit_f = fit_func(freq, aperiodic_spectrum, scale_factor=scale_factor) params, gof = fit_f.fit_func() From c2e20384f9747f398aa90eba18629a6dcb8977dc Mon Sep 17 00:00:00 2001 From: Thomas Hartmann Date: Mon, 5 Aug 2024 13:31:58 +0200 Subject: [PATCH 14/18] down to two type errors --- pyrasa/utils/aperiodic_utils.py | 3 ++- pyrasa/utils/fit_funcs.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/pyrasa/utils/aperiodic_utils.py b/pyrasa/utils/aperiodic_utils.py index 7451def..3752bab 100644 --- a/pyrasa/utils/aperiodic_utils.py +++ b/pyrasa/utils/aperiodic_utils.py @@ -2,6 +2,7 @@ import warnings from collections.abc import Iterable +from typing import Type import numpy as np import pandas as pd @@ -57,7 +58,7 @@ def _compute_slope( def compute_slope( aperiodic_spectrum: np.ndarray, freqs: np.ndarray, - fit_func: str | AbstractFitFun = 'fixed', + fit_func: str | Type[AbstractFitFun] = 'fixed', ch_names: Iterable | None = None, scale: bool = False, fit_bounds: tuple[float, float] | None = None, diff --git a/pyrasa/utils/fit_funcs.py b/pyrasa/utils/fit_funcs.py index 5178d59..aa2d17f 100644 --- a/pyrasa/utils/fit_funcs.py +++ b/pyrasa/utils/fit_funcs.py @@ -53,7 +53,7 @@ def __attrs_post_init__(self) -> None: self.freq = np.log10(self.freq) @abc.abstractmethod - def func(self, *args: float, **kwargs: float) -> np.ndarray: + def func(self, *args: np.ndarray, **kwargs: np.ndarray) -> np.ndarray: pass @property From bc5f81323e928c7891b45ea3b06c6619be69a68b Mon Sep 17 00:00:00 2001 From: Thomas Hartmann Date: Mon, 5 Aug 2024 14:00:13 +0200 Subject: [PATCH 15/18] removed unnecessary arguments --- pyrasa/utils/fit_funcs.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pyrasa/utils/fit_funcs.py b/pyrasa/utils/fit_funcs.py index aa2d17f..b3fb516 100644 --- a/pyrasa/utils/fit_funcs.py +++ b/pyrasa/utils/fit_funcs.py @@ -53,7 +53,7 @@ def __attrs_post_init__(self) -> None: self.freq = np.log10(self.freq) @abc.abstractmethod - def func(self, *args: np.ndarray, **kwargs: np.ndarray) -> np.ndarray: + def func(self, x: np.ndarray, *args: float, **kwargs: float) -> np.ndarray: pass @property @@ -70,7 +70,7 @@ def handle_scaling(self, df_params: pd.DataFrame, scale_factor: float) -> pd.Dat raise ValueError('Scale Factor not handled. You need to overwrite the handle_scaling method.') return df_params - def fit_func(self, *args: float, **kwargs: float) -> tuple[pd.DataFrame, pd.DataFrame]: + def fit_func(self) -> tuple[pd.DataFrame, pd.DataFrame]: curve_kwargs = self.curve_kwargs p, _ = curve_fit(self.func, self.freq, self.aperiodic_spectrum, **curve_kwargs) @@ -91,7 +91,7 @@ class FixedFitFun(AbstractFitFun): label = 'fixed' log10_aperiodic = True - def func(self, x: np.ndarray, Offset: float, Exponent: float) -> np.ndarray: # noqa N803 + def func(self, x: np.ndarray, Offset: float, Exponent: float, *args: float, **kwargs: float) -> np.ndarray: # noqa N803 """ Specparams fixed fitting function. Use this to model aperiodic activity without a spectral knee From 1ed9ff905b0c114f6216ad4fe18600e4ae31d91a Mon Sep 17 00:00:00 2001 From: Thomas Hartmann Date: Mon, 5 Aug 2024 14:05:58 +0200 Subject: [PATCH 16/18] simply ignore the type error --- pyrasa/utils/aperiodic_utils.py | 3 +-- pyrasa/utils/fit_funcs.py | 7 ++++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/pyrasa/utils/aperiodic_utils.py b/pyrasa/utils/aperiodic_utils.py index 3752bab..84317c7 100644 --- a/pyrasa/utils/aperiodic_utils.py +++ b/pyrasa/utils/aperiodic_utils.py @@ -2,7 +2,6 @@ import warnings from collections.abc import Iterable -from typing import Type import numpy as np import pandas as pd @@ -58,7 +57,7 @@ def _compute_slope( def compute_slope( aperiodic_spectrum: np.ndarray, freqs: np.ndarray, - fit_func: str | Type[AbstractFitFun] = 'fixed', + fit_func: str | type[AbstractFitFun] = 'fixed', ch_names: Iterable | None = None, scale: bool = False, fit_bounds: tuple[float, float] | None = None, diff --git a/pyrasa/utils/fit_funcs.py b/pyrasa/utils/fit_funcs.py index b3fb516..d71253a 100644 --- a/pyrasa/utils/fit_funcs.py +++ b/pyrasa/utils/fit_funcs.py @@ -1,7 +1,7 @@ import abc import inspect from collections.abc import Callable -from typing import Any, ClassVar +from typing import Any, ClassVar, no_type_check import numpy as np import pandas as pd @@ -53,7 +53,8 @@ def __attrs_post_init__(self) -> None: self.freq = np.log10(self.freq) @abc.abstractmethod - def func(self, x: np.ndarray, *args: float, **kwargs: float) -> np.ndarray: + @no_type_check + def func(self, x: np.ndarray, *args: float) -> np.ndarray: pass @property @@ -91,7 +92,7 @@ class FixedFitFun(AbstractFitFun): label = 'fixed' log10_aperiodic = True - def func(self, x: np.ndarray, Offset: float, Exponent: float, *args: float, **kwargs: float) -> np.ndarray: # noqa N803 + def func(self, x: np.ndarray, Offset: float, Exponent: float) -> np.ndarray: # noqa N803 """ Specparams fixed fitting function. Use this to model aperiodic activity without a spectral knee From 6a47208dea58e915290a21934c855d20407b31ad Mon Sep 17 00:00:00 2001 From: Fabi Date: Mon, 5 Aug 2024 14:20:32 +0200 Subject: [PATCH 17/18] drop legacy fit functions --- examples/irasa_mne.ipynb | 22 ++++++++++++++-------- pyrasa/utils/aperiodic_utils.py | 22 ---------------------- 2 files changed, 14 insertions(+), 30 deletions(-) diff --git a/examples/irasa_mne.ipynb b/examples/irasa_mne.ipynb index e4b2f5e..8a86183 100644 --- a/examples/irasa_mne.ipynb +++ b/examples/irasa_mne.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -58,7 +58,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Opening raw data file /Users/fabian.schmidt/mne_data/MNE-sample-data/MEG/sample/sample_audvis_raw.fif...\n", + "Opening raw data file /Users/fabian.schmidt/mne_data/MNE-sample-data/MEG/sample/sample_audvis_raw.fif...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ " Read a total of 3 projection items:\n", " PCA-v1 (1 x 102) idle\n", " PCA-v2 (1 x 102) idle\n", @@ -203,14 +209,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "aperiodic_mne, periodic_mne = irasa_raw(raw, band=(.25, 50), \n", - " duration=2, \n", - " hset_info=(1.,2.,.05),\n", - " as_array=False)" + "irasa_results = irasa_raw(raw, \n", + " band=(.25, 50), \n", + " duration=2, \n", + " hset_info=(1.,2.,.05))" ] }, { @@ -875,7 +881,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.12.4" } }, "nbformat": 4, diff --git a/pyrasa/utils/aperiodic_utils.py b/pyrasa/utils/aperiodic_utils.py index 84317c7..1e43f08 100644 --- a/pyrasa/utils/aperiodic_utils.py +++ b/pyrasa/utils/aperiodic_utils.py @@ -10,28 +10,6 @@ from pyrasa.utils.types import SlopeFit -def fixed_model(x: np.ndarray, b0: float, b: float) -> np.ndarray: - """ - Specparams fixed fitting function. - Use this to model aperiodic activity without a spectral knee - """ - - y_hat = b0 - np.log10(x**b) - - return y_hat - - -def knee_model(x: np.ndarray, b0: float, k: float, b1: float, b2: float) -> np.ndarray: - """ - Model aperiodic activity with a spectral knee and a pre-knee slope. - Use this to model aperiodic activity with a spectral knee - """ - - y_hat = b0 - np.log10(x**b1 * (k + x**b2)) - - return y_hat - - def _compute_slope( aperiodic_spectrum: np.ndarray, freq: np.ndarray, From c6e4dea3c105c2719be595286baaa86b3e23ae86 Mon Sep 17 00:00:00 2001 From: Fabi Date: Mon, 5 Aug 2024 15:36:24 +0200 Subject: [PATCH 18/18] figured out weird warning --- examples/irasa_mne.ipynb | 5658 +++++++++++++++++++++++++++++++--- pyrasa/irasa_mne/mne_objs.py | 13 +- pyrasa/utils/fit_funcs.py | 11 +- tests/test_mne.py | 6 +- 4 files changed, 5306 insertions(+), 382 deletions(-) diff --git a/examples/irasa_mne.ipynb b/examples/irasa_mne.ipynb index 8a86183..380c96f 100644 --- a/examples/irasa_mne.ipynb +++ b/examples/irasa_mne.ipynb @@ -58,13 +58,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Opening raw data file /Users/fabian.schmidt/mne_data/MNE-sample-data/MEG/sample/sample_audvis_raw.fif...\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Opening raw data file /Users/fabian.schmidt/mne_data/MNE-sample-data/MEG/sample/sample_audvis_raw.fif...\n", " Read a total of 3 projection items:\n", " PCA-v1 (1 x 102) idle\n", " PCA-v2 (1 x 102) idle\n", @@ -209,7 +203,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -230,7 +224,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -247,20 +241,18 @@ "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/6x/k2wvgw51691cj5qd77pzcrfw0000gn/T/ipykernel_52883/3776130424.py:4: FutureWarning: The value of `amplitude='auto'` will be removed in MNE 1.8.0, and the new default will be `amplitude=False`.\n", - " raw.compute_psd(method='welch', n_per_seg=nperseg, n_overlap=nperseg//2, fmin=0.25, fmax=50).plot(axes=axes[0])\n", - "/var/folders/6x/k2wvgw51691cj5qd77pzcrfw0000gn/T/ipykernel_52883/3776130424.py:5: FutureWarning: The value of `amplitude='auto'` will be removed in MNE 1.8.0, and the new default will be `amplitude=False`.\n", - " aperiodic_mne.plot(axes=axes[1])\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/irasa_mne/mne_objs.py:54: UserWarning: Zero value in PSD for channels MEG 0111, MEG 0121, MEG 0131, MEG 0141, MEG 0211, MEG 0221, MEG 0231, MEG 0241, MEG 0311, MEG 0321, MEG 0331, MEG 0341, MEG 0411, MEG 0421, MEG 0431, MEG 0441, MEG 0511, MEG 0521, MEG 0531, MEG 0541, MEG 0611, MEG 0621, MEG 0631, MEG 0641, MEG 0711, MEG 0721, MEG 0731, MEG 0741, MEG 0811, MEG 0821, MEG 0911, MEG 0921, MEG 0931, MEG 0941, MEG 1011, MEG 1021, MEG 1031, MEG 1041, MEG 1111, MEG 1121, MEG 1131, MEG 1141, MEG 1211, MEG 1221, MEG 1231, MEG 1241, MEG 1311, MEG 1321, MEG 1331, MEG 1341, MEG 1411, MEG 1421, MEG 1431, MEG 1441, MEG 1511, MEG 1521, MEG 1531, MEG 1541, MEG 1611, MEG 1621, MEG 1631, MEG 1641, MEG 1711, MEG 1721, MEG 1731, MEG 1741, MEG 1811, MEG 1821, MEG 1831, MEG 1841, MEG 1911, MEG 1921, MEG 1931, MEG 1941, MEG 2011, MEG 2021, MEG 2031, MEG 2041, MEG 2111, MEG 2121, MEG 2131, MEG 2141, MEG 2211, MEG 2221, MEG 2231, MEG 2241, MEG 2311, MEG 2321, MEG 2331, MEG 2341, MEG 2411, MEG 2421, MEG 2431, MEG 2441, MEG 2511, MEG 2521, MEG 2531, MEG 2541, MEG 2611, MEG 2621, MEG 2631, MEG 2641.\n", + "/Users/fabian.schmidt/git/pyrasa/.pixi/envs/default/lib/python3.12/site-packages/mne/viz/utils.py:167: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " (fig or plt).show(**kwargs)\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/irasa_mne/mne_objs.py:64: UserWarning: Zero value in PSD for channels MEG 0111, MEG 0121, MEG 0131, MEG 0141, MEG 0211, MEG 0221, MEG 0231, MEG 0241, MEG 0311, MEG 0321, MEG 0331, MEG 0341, MEG 0411, MEG 0421, MEG 0431, MEG 0441, MEG 0511, MEG 0521, MEG 0531, MEG 0541, MEG 0611, MEG 0621, MEG 0631, MEG 0641, MEG 0711, MEG 0721, MEG 0731, MEG 0741, MEG 0811, MEG 0821, MEG 0911, MEG 0921, MEG 0931, MEG 0941, MEG 1011, MEG 1021, MEG 1031, MEG 1041, MEG 1111, MEG 1121, MEG 1131, MEG 1141, MEG 1211, MEG 1221, MEG 1231, MEG 1241, MEG 1311, MEG 1321, MEG 1331, MEG 1341, MEG 1411, MEG 1421, MEG 1431, MEG 1441, MEG 1511, MEG 1521, MEG 1531, MEG 1541, MEG 1611, MEG 1621, MEG 1631, MEG 1641, MEG 1711, MEG 1721, MEG 1731, MEG 1741, MEG 1811, MEG 1821, MEG 1831, MEG 1841, MEG 1911, MEG 1921, MEG 1931, MEG 1941, MEG 2011, MEG 2021, MEG 2031, MEG 2041, MEG 2111, MEG 2121, MEG 2131, MEG 2141, MEG 2211, MEG 2221, MEG 2231, MEG 2241, MEG 2311, MEG 2321, MEG 2331, MEG 2341, MEG 2411, MEG 2421, MEG 2431, MEG 2441, MEG 2511, MEG 2521, MEG 2531, MEG 2541, MEG 2611, MEG 2621, MEG 2631, MEG 2641.\n", "These channels might be dead.\n", " super().plot(\n", - "/var/folders/6x/k2wvgw51691cj5qd77pzcrfw0000gn/T/ipykernel_52883/3776130424.py:12: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/var/folders/6x/k2wvgw51691cj5qd77pzcrfw0000gn/T/ipykernel_37697/1044382114.py:12: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " f.tight_layout()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -274,8 +266,8 @@ "\n", "nperseg = int(raw.info['sfreq']*2)\n", "raw.compute_psd(method='welch', n_per_seg=nperseg, n_overlap=nperseg//2, fmin=0.25, fmax=50).plot(axes=axes[0])\n", - "aperiodic_mne.plot(axes=axes[1])\n", - "periodic_mne.plot(axes=axes[2])\n", + "irasa_results.aperiodic.plot(axes=axes[1])\n", + "irasa_results.periodic.plot(axes=axes[2])\n", "\n", "axes[0].set_title('PSD')\n", "axes[1].set_title('Aperiodic Spectrum')\n", @@ -302,60 +294,22 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n" - ] - }, { "data": { "text/plain": [ "Text(0.5, 0, 'R2')" ] }, - "execution_count": 7, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -365,15 +319,49 @@ } ], "source": [ - "df_ap_f, df_gof_f = aperiodic_mne.get_slopes(fit_func='fixed')\n", - "df_ap_k, df_gof_k = aperiodic_mne.get_slopes(fit_func='knee', scale=True);\n", + "fixed_model = irasa_results.aperiodic.get_slopes(fit_func='fixed', scale=True, fit_bounds=[.5, 45])\n", + "knee_model = irasa_results.aperiodic.get_slopes(fit_func='knee', scale=True, fit_bounds=[.5, 45]);\n", "\n", "\n", "f, ax = plt.subplots(ncols=2, figsize=(8,4))\n", - "ax[0].hist(df_gof_k['r_squared']);#\n", + "ax[0].hist(fixed_model.gof['r_squared']);\n", "ax[0].set_xlabel('R2')\n", - "ax[1].hist(df_gof_f['r_squared']);\n", - "ax[1].set_xlabel('R2')" + "ax[1].hist(knee_model.gof['r_squared']);#\n", + "ax[1].set_xlabel('R2')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([ 6., 8., 11., 17., 17., 16., 9., 12., 4., 2.]),\n", + " array([ 8.14227952, 9.53481945, 10.92735938, 12.31989931, 13.71243924,\n", + " 15.10497917, 16.4975191 , 17.89005903, 19.28259896, 20.67513888,\n", + " 22.06767881]),\n", + " )" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(knee_model.aperiodic_params['Knee Frequency (Hz)'])" ] }, { @@ -393,7 +381,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -435,33 +423,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 17, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/fabian.schmidt/miniforge3/envs/pyrasa/lib/python3.12/site-packages/scipy/signal/_spectral_py.py:600: UserWarning: nperseg = 256 is greater than input length = 248, using nperseg = 248\n", - " freqs, _, Pxy = _spectral_helper(x, y, fs, window, nperseg, noverlap,\n", - "/Users/fabian.schmidt/miniforge3/envs/pyrasa/lib/python3.12/site-packages/scipy/signal/_spectral_py.py:600: UserWarning: nperseg = 256 is greater than input length = 241, using nperseg = 241\n", - " freqs, _, Pxy = _spectral_helper(x, y, fs, window, nperseg, noverlap,\n", - "/Users/fabian.schmidt/miniforge3/envs/pyrasa/lib/python3.12/site-packages/scipy/signal/_spectral_py.py:600: UserWarning: nperseg = 256 is greater than input length = 234, using nperseg = 234\n", - " freqs, _, Pxy = _spectral_helper(x, y, fs, window, nperseg, noverlap,\n", - "/Users/fabian.schmidt/miniforge3/envs/pyrasa/lib/python3.12/site-packages/scipy/signal/_spectral_py.py:600: UserWarning: nperseg = 256 is greater than input length = 228, using nperseg = 228\n", - " freqs, _, Pxy = _spectral_helper(x, y, fs, window, nperseg, noverlap,\n", - "/Users/fabian.schmidt/miniforge3/envs/pyrasa/lib/python3.12/site-packages/scipy/signal/_spectral_py.py:600: UserWarning: nperseg = 256 is greater than input length = 222, using nperseg = 222\n", - " freqs, _, Pxy = _spectral_helper(x, y, fs, window, nperseg, noverlap,\n", - "/Users/fabian.schmidt/miniforge3/envs/pyrasa/lib/python3.12/site-packages/scipy/signal/_spectral_py.py:600: UserWarning: nperseg = 256 is greater than input length = 216, using nperseg = 216\n", - " freqs, _, Pxy = _spectral_helper(x, y, fs, window, nperseg, noverlap,\n" - ] - } - ], + "outputs": [], "source": [ - "aperiodic, periodic = irasa_epochs(epochs, \n", + "irasa_epoched = irasa_epochs(epochs, \n", " band=(.5, 50), \n", - " hset_info=(1.,2.,.05), \n", - " as_array=False)" + " hset_info=(1.,2.,.05))" ] }, { @@ -473,303 +441,5243 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:114: RuntimeWarning: overflow encountered in scalar power\n", - " 'Knee Frequency (Hz)': p[1] ** (1.0 / (2 * p[2] + p[3])),\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:114: RuntimeWarning: overflow encountered in scalar power\n", - " 'Knee Frequency (Hz)': p[1] ** (1.0 / (2 * p[2] + p[3])),\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in multiply\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:114: RuntimeWarning: overflow encountered in scalar power\n", - " 'Knee Frequency (Hz)': p[1] ** (1.0 / (2 * p[2] + p[3])),\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:114: RuntimeWarning: overflow encountered in scalar power\n", - " 'Knee Frequency (Hz)': p[1] ** (1.0 / (2 * p[2] + p[3])),\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:114: RuntimeWarning: overflow encountered in scalar power\n", - " 'Knee Frequency (Hz)': p[1] ** (1.0 / (2 * p[2] + p[3])),\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:114: RuntimeWarning: overflow encountered in scalar power\n", - " 'Knee Frequency (Hz)': p[1] ** (1.0 / (2 * p[2] + p[3])),\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n", - "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/aperiodic_utils.py:27: RuntimeWarning: overflow encountered in power\n", - " y_hat = b0 - np.log10(x**b1 * (k + x**b2))\n" + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in power\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n", + "/Users/fabian.schmidt/git/pyrasa/pyrasa/utils/fit_funcs.py:137: RuntimeWarning: overflow encountered in multiply\n", + " y_hat = Offset - np.log10(x**Exponent_1 * (Knee + x**Exponent_2))\n" ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
OffsetKneeExponent_1Exponent_2Knee Frequency (Hz)fit_typech_nameevent_id
01.384293e-271.327888e+134.514556e-017.82537031.880262kneeMEG 0111Auditory/Left
03.031858e-284.417963e+012.857408e-131.9810886.768057kneeMEG 0121Auditory/Left
04.071002e-283.109493e+031.255273e-142.46743826.032316kneeMEG 0131Auditory/Left
01.790656e-281.480185e+014.554958e-101.12267911.026333kneeMEG 0141Auditory/Left
03.958079e-286.873358e+022.709892e-132.65479011.713811kneeMEG 0211Auditory/Left
\n", - "
" - ], - "text/plain": [ - " Offset Knee Exponent_1 Exponent_2 Knee Frequency (Hz) \\\n", - "0 1.384293e-27 1.327888e+13 4.514556e-01 7.825370 31.880262 \n", - "0 3.031858e-28 4.417963e+01 2.857408e-13 1.981088 6.768057 \n", - "0 4.071002e-28 3.109493e+03 1.255273e-14 2.467438 26.032316 \n", - "0 1.790656e-28 1.480185e+01 4.554958e-10 1.122679 11.026333 \n", - "0 3.958079e-28 6.873358e+02 2.709892e-13 2.654790 11.713811 \n", - "\n", - " fit_type ch_name event_id \n", - "0 knee MEG 0111 Auditory/Left \n", - "0 knee MEG 0121 Auditory/Left \n", - "0 knee MEG 0131 Auditory/Left \n", - "0 knee MEG 0141 Auditory/Left \n", - "0 knee MEG 0211 Auditory/Left " - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ - "ap_slope, ap_gof = aperiodic.get_slopes(fit_func='knee', scale=True)\n", - "ap_slope.head()" + "knee_epoched = irasa_epoched.aperiodic.get_slopes(fit_func='knee', scale=True, fit_bounds=[1, 45])" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -778,13 +5686,13 @@ "" ] }, - "execution_count": 14, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -794,7 +5702,7 @@ } ], "source": [ - "ap_data = ap_slope.groupby(['event_id', 'ch_name'])['Knee Frequency (Hz)'].mean().reset_index()\n", + "ap_data = knee_epoched.aperiodic_params.groupby(['event_id', 'ch_name'])['Knee Frequency (Hz)'].mean().reset_index()\n", "ap_data\n", "sns.pointplot(ap_data, x='event_id', y='Knee Frequency (Hz)')" ] diff --git a/pyrasa/irasa_mne/mne_objs.py b/pyrasa/irasa_mne/mne_objs.py index b5ce0ed..7ce3380 100644 --- a/pyrasa/irasa_mne/mne_objs.py +++ b/pyrasa/irasa_mne/mne_objs.py @@ -1,4 +1,5 @@ # %% inherit from spectrum array + import matplotlib import mne import numpy as np @@ -10,6 +11,8 @@ from pyrasa.utils.peak_utils import get_peak_params from pyrasa.utils.types import SlopeFit +# FutureWarning: + class PeriodicSpectrumArray(SpectrumArray): """Subclass of SpectrumArray""" @@ -170,7 +173,10 @@ def __init__( ) def get_slopes( - self: SpectrumArray, fit_func: str = 'fixed', scale: bool = False, fit_bounds: tuple[float, float] | None = None + self: SpectrumArray, + fit_func: str = 'fixed', + scale: bool = False, + fit_bounds: tuple[float, float] | None = None, ) -> SlopeFit: """ This method can be used to extract aperiodic parameters from the aperiodic spectrum extracted from IRASA. @@ -393,7 +399,10 @@ def __init__( ) def get_slopes( - self: SpectrumArray, fit_func: str = 'fixed', scale: bool = False, fit_bounds: tuple[float, float] | None = None + self: SpectrumArray, + fit_func: str = 'fixed', + scale: bool = False, + fit_bounds: tuple[float, float] | None = None, ) -> SlopeFit: """ This method can be used to extract aperiodic parameters from the aperiodic spectrum extracted from IRASA. diff --git a/pyrasa/utils/fit_funcs.py b/pyrasa/utils/fit_funcs.py index d71253a..f58020e 100644 --- a/pyrasa/utils/fit_funcs.py +++ b/pyrasa/utils/fit_funcs.py @@ -9,7 +9,7 @@ from scipy.optimize import curve_fit -def get_args(f: Callable) -> list: +def _get_args(f: Callable) -> list: return inspect.getfullargspec(f)[0][2:] @@ -59,7 +59,12 @@ def func(self, x: np.ndarray, *args: float) -> np.ndarray: @property def curve_kwargs(self) -> dict[str, Any]: - return {} + return { + 'maxfev': 10_000, + 'ftol': 1e-5, + 'xtol': 1e-5, + 'gtol': 1e-5, + } def add_infos_to_df(self, df_params: pd.DataFrame) -> pd.DataFrame: return df_params @@ -75,7 +80,7 @@ def fit_func(self) -> tuple[pd.DataFrame, pd.DataFrame]: curve_kwargs = self.curve_kwargs p, _ = curve_fit(self.func, self.freq, self.aperiodic_spectrum, **curve_kwargs) - my_args = get_args(self.func) + my_args = _get_args(self.func) df_params = pd.DataFrame(dict(zip(my_args, p)), index=[0]) df_params['fit_type'] = self.label diff --git a/tests/test_mne.py b/tests/test_mne.py index 46bd47c..6b8ae9d 100644 --- a/tests/test_mne.py +++ b/tests/test_mne.py @@ -1,5 +1,6 @@ import pytest from neurodsp.utils.sim import set_random_seed +from scipy.optimize import OptimizeWarning from pyrasa.irasa_mne import irasa_epochs, irasa_raw @@ -13,8 +14,9 @@ def test_mne(gen_mne_data_raw): # test raw irasa_raw_result = irasa_raw(mne_data, band=(0.25, 50), duration=2, hset_info=(1.0, 2.0, 0.05)) - irasa_raw_result.aperiodic.get_slopes(fit_func='fixed') - irasa_raw_result.periodic.get_peaks(smoothing_window=2) + with pytest.warns(OptimizeWarning): + irasa_raw_result.aperiodic.get_slopes(fit_func='fixed') + irasa_raw_result.periodic.get_peaks(smoothing_window=2) # test epochs irasa_epoched_result = irasa_epochs(epochs, band=(0.5, 50), hset_info=(1.0, 2.0, 0.05))