From 1e6c5438a8c44e67605f49a708d63c4ece11a545 Mon Sep 17 00:00:00 2001 From: noonu Date: Thu, 10 Mar 2022 13:28:21 +0500 Subject: [PATCH 1/3] initial commit * created the light_curves.py file * changed the numpy version in requirements.txt * removed the __init__.py files from other two directories --- black_body_radiation/__init__.py | 3 -- conversions/__init__.py | 3 -- grbs/light_curves.py | 77 ++++++++++++++++++++++++++++++++ requirements.txt | 2 +- 4 files changed, 78 insertions(+), 7 deletions(-) delete mode 100644 black_body_radiation/__init__.py delete mode 100644 conversions/__init__.py create mode 100644 grbs/light_curves.py diff --git a/black_body_radiation/__init__.py b/black_body_radiation/__init__.py deleted file mode 100644 index 67dbf6b..0000000 --- a/black_body_radiation/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -""" -Created on Feb 09 23:37:22 2022 -""" diff --git a/conversions/__init__.py b/conversions/__init__.py deleted file mode 100644 index c6855f8..0000000 --- a/conversions/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -""" -Created on Feb 09 23:37:53 2022 -""" diff --git a/grbs/light_curves.py b/grbs/light_curves.py new file mode 100644 index 0000000..397e4ea --- /dev/null +++ b/grbs/light_curves.py @@ -0,0 +1,77 @@ +""" +Created on Mar 10 13:06:50 2022 +""" + +import numpy as np + + +def lightcurve_data(dat_file: str, energy_low: float, energy_high: float, errors=False): + """ + Get the time, rate, and background from the RMFIT .dat file within a specific energy boundary. + + Parameters + ---------- + dat_file: str + RMFIT .dat file. + energy_low: float + The lower bound on energy. + energy_high: float + The upper bound on energy. + errors: bool + + Returns + ------- + time: + Time measurements for the burst duration. + data_rate: + Rate of data accumulation within the energy bounds for the burst duration + data_background: + Estimated background for the energy bounds specified. + errs: + Errors on data_rate, and data_background + + """ + + # Initialization + data_rate, data_background, channel_number = 0, 0, 128 + data_rate_error, data_background_error = 0, 0 + detector_file, detector_data, low_energy_channel, high_energy_channel = [], [], [], [] + + # reading the detector data + with open(dat_file) as f: + detector_file.append(f.readlines()) + + detector_file = detector_file[0] + + # separating energy data from real data + energy_channels, data = detector_file[11:11 + channel_number], detector_file[12 + channel_number:] + + for data_item in data: + detector_data.append(np.genfromtxt(data_item.split())) + + detector_data = np.array(detector_data) + + # getting time data + time = detector_data[:, 0] + + # separating low and high energy channel + for iterator in energy_channels: + low_channel, high_channel = iterator.split() + low_energy_channel.append(float(low_channel)) + high_energy_channel.append(float(high_channel)) + + low_energy_channel, high_energy_channel = np.array(low_energy_channel), np.array(high_energy_channel) + + number_of_low_energy_channels = len(np.where(low_energy_channel < energy_low)[0]) + number_of_high_energy_channels = len(np.where(high_energy_channel < energy_high)[0]) + 1 + + # getting the data + for x in range(number_of_low_energy_channels, number_of_high_energy_channels): + data_rate += detector_data[:, 4 * x + 2] + data_background += detector_data[:, 4 * x + 4] + if errors: + data_rate_error += detector_data[:, 4 * x + 3] + data_background_error += detector_data[:, 4 * x * 5] + + # return + return time, data_rate, data_background if not errors else time, data_rate, data_background, (data_rate_error, data_background_error) diff --git a/requirements.txt b/requirements.txt index d5ee514..618d22d 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,4 +2,4 @@ # - setup.cfg # - environment.yml # - install.rst -numpy <= 1.21.4' +numpy>=1.21.4 From baa8922b4649b2d4fe6898b403e721050907bc23 Mon Sep 17 00:00:00 2001 From: Noonuu Date: Fri, 29 Apr 2022 07:12:23 +0500 Subject: [PATCH 2/3] major changes # 1 * modified the standard_grb_models.py * added astropy v4 to requirements.txt --- grbs/standard_grb_models.py | 275 ++++++++++++++++++++++++++++++++++++ requirements.txt | 3 + 2 files changed, 278 insertions(+) create mode 100644 grbs/standard_grb_models.py diff --git a/grbs/standard_grb_models.py b/grbs/standard_grb_models.py new file mode 100644 index 0000000..609ac45 --- /dev/null +++ b/grbs/standard_grb_models.py @@ -0,0 +1,275 @@ +""" +Created on Mar 18 16:33:03 2022 +""" + +import numpy as np +import scipy.integrate as si +from astropy.cosmology import FlatLambdaCDM + +""" +RMFIT order of models + +PL: PL +PL_BB: PL + BB +SBPL: SBPL +SBPL_PL: PL + SBPL +SBPL_BB: SBPL + BB +SBPL_PL_BB: PL + SBPL + BB +CPL: CPL +CPL_PL: PL + CPL +CPL_BB: CPL + BB +CPL_PL_BB: PL + CPL + BB +BAND: BAND +BAND_PL: PL + BAND +BAND_BB: BAND + BB +BAND_PL_BB: PL + BAND + BB + +""" + + +class SpectralModels: + + def __init__(self, energy, pars, t_start, t_stop, model: str = 'pl', + model_type: str = 'counts', flux_energy=None, + isotropic_energy=None, redshift=None, h0=67.4, omega_m=0.315): + + self.energy = energy + self.pars = pars + + self.t_start = t_start + self.t_stop = t_stop + + self.model = model + self.model_type = model_type + + self.f_ene = [10, int(1e7)] if flux_energy is None else flux_energy + self.f_iso = [1, int(1e4)] if isotropic_energy is None else isotropic_energy + + self.z = 0 if redshift is None else redshift + + self.h0 = h0 + self.omega_m = omega_m + self.keVtoErg = 1.6021766208e-09 + + self.__raise_error() + + def __luminosity_distance(self, z_int): + return FlatLambdaCDM(H0=self.h0, + Om0=self.omega_m).luminosity_distance(z_int).cgs.value + + def __luminosity_integral(self): + return si.quad(self.__luminosity_distance, 0, self.z)[0] + + def __raise_error(self): + types_ = ['counts', 'energy', 'integrate', 'bolometric'] + if self.model_type not in types_: + raise TypeError('Model type must be in ' + ', '.join(types_[:-1]) + + f' or {types_[-1]}.') + + def __time_difference(self): + return self.t_stop - self.t_start + + def __vals(self): + return self.energy, self.pars, self.model_type, self.f_ene, self.f_iso, self.z, \ + self.keVtoErg + + def powerlaw(self, joint_pars=None): + energy, pars, mt, f_ene, f_iso, z, kev_ = self.__vals() + + pars = pars if joint_pars is None else joint_pars + + def f_pl(_e=energy, out_ene=True): + [amp, e_piv, ind] = pars + out = amp * (_e * e_piv**-1)**ind + + return _e * out if out_ene else out + + def int_pl(_range=f_ene): + return si.quad(f_pl, _range[0], _range[1])[0] * kev_ + + def bol_pl(): + _bol_range = [i / (1 + z) for i in f_iso] + return int_pl(_range=_bol_range) * self.__time_difference() + + return f_pl(out_ene=False) if mt == 'counts' else f_pl() if \ + mt == 'energy' else int_pl() if mt == 'integrate' else bol_pl() + + def blackbody(self, joint_pars=None): + energy, pars, mt, f_ene, f_iso, z, kev_ = self.__vals() + + pars = pars if joint_pars is None else joint_pars + + def f_bb(_e=energy, out_ene=True): + [amp, kt] = pars + out = amp * _e**2 * (np.exp(_e / kt) - 1)**-1 + return _e * out if out_ene else out + + def int_bb(_range=f_ene): + return si.quad(f_bb, _range[0], _range[1])[0] * kev_ + + def bol_bb(): + _bol_range = [i / (1 + z) for i in f_iso] + return int_bb(_bol_range) * self.__time_difference() + + return f_bb(out_ene=False) if mt == 'counts' else f_bb() if \ + mt == 'energy' else int_bb() if mt == 'integrate' else bol_bb() + + def cutoff_powerlaw(self, joint_pars=None): + energy, pars, mt, f_ene, f_iso, z, kev_ = self.__vals() + + pars = pars if joint_pars is None else joint_pars + + def f_cpl(_e=energy, out_ene=True): + [amp, e_peak, i1, e_piv] = pars + out = amp * np.exp(-1 * _e * (2 + i1) * e_peak**-1) * (_e * e_piv**-1)**i1 + + return _e * out if out_ene else out + + def int_cpl(_range=f_ene): + return si.quad(f_cpl, _range[0], _range[1])[0] * kev_ + + def bol_cpl(): + _bol_range = [i / (1 + z) for i in f_iso] + return int_cpl(_bol_range) * self.__time_difference() + + return f_cpl(out_ene=False) if mt == 'counts' else f_cpl() if \ + mt == 'energy' else int_cpl() if mt == 'integrate' else bol_cpl() + + def smoothly_broken_powerlaw(self, joint_pars=None): + energy, pars, mt, f_ene, f_iso, z, kev_ = self.__vals() + + pars = pars if joint_pars is None else joint_pars + + def f_sbpl(_e=energy, out_ene=True): + [amp, e_piv, i1, b_ene, b_scale, i2] = pars + + m = 0.5 * (i2 - i1) + b = 0.5 * (i1 + i2) + + a_piv = np.log10(e_piv * b_ene**-1) * b_scale**-1 + + beta_piv_ = np.exp(a_piv) + np.exp(-1 * a_piv) + beta_piv = m * b_scale * np.log(0.5 * beta_piv_) + + a = b_scale**-1 * np.log10(_e * b_ene**-1) + + beta_ = np.exp(a) + np.exp(-1 * a) + beta = m * b_scale * np.log(0.5 * beta_) + + out = amp * (_e * e_piv**-1)**b * 10**(beta - beta_piv) + + return _e * out if out_ene else out + + def int_sbpl(_range=f_ene): + return si.quad(f_sbpl, _range[0], _range[1])[0] * kev_ + + def bol_sbpl(): + _bol_range = [i / (1 + z) for i in f_iso] + return int_sbpl(_bol_range) * self.__time_difference() + + return f_sbpl(out_ene=False) if mt == 'counts' else f_sbpl() if \ + mt == 'energy' else int_sbpl() if mt == 'integrate' else bol_sbpl() + + def band_grb_function(self, joint_pars=None): + energy, pars, mt, f_ene, f_iso, z, kev_ = self.__vals() + + pars = pars if joint_pars is None else joint_pars + + def f_band(_e=energy, out_ene=True): + [amp, e_peak, i1, i2] = pars + cond = (i1 - i2) * (2 + i1)**-1 * e_peak + + out = [amp * (_en * 0.01)**i2 * np.exp(i2 - i1) * ( + (i1 - i2) * e_peak * 0.01 * (i1 + 2)**-1)**(i1 - i2) if + _en > cond else amp * (_en * 0.01)**i1 * np.exp( + -(2 + i1) * _en * e_peak**-1) for _en in _e] + + return _e * out if out_ene else out + + def int_band(_range=f_ene): + return si.quad(f_band, _range[0], _range[1])[0] * kev_ + + def bol_band(): + _bol_range = [i / (1 + z) for i in f_iso] + return int_band(_bol_range) * self.__time_difference() + + return f_band(out_ene=False) if mt == 'counts' else f_band() if \ + mt == 'energy' else int_band() if mt == 'integrate' else bol_band() + + def pl_bb(self): + pl_ = self.powerlaw(self.pars[:3]) + bb_ = self.blackbody(self.pars[3:]) + + return pl_, bb_, pl_ + bb_ + + def cpl_pl(self): + pl_, cpl_ = self.powerlaw(self.pars[:3]), self.cutoff_powerlaw(self.pars[3:]) + + return cpl_, pl_, cpl_ + pl_ + + def cpl_bb(self): + cpl_, bb_ = self.cutoff_powerlaw(self.pars[:-2]), self.blackbody(self.pars[-2:]) + + return cpl_, bb_, cpl_ + bb_ + + def cpl_pl_bb(self): + pl_ = self.powerlaw(self.pars[:3]) + cpl_ = self.cutoff_powerlaw(self.pars[3:-2]) + bb_ = self.blackbody(self.pars[-2:]) + + return cpl_, pl_, bb_, cpl_ + pl_ + bb_ + + def band_pl(self): + pl_, band_ = self.powerlaw(self.pars[:3]), self.band_grb_function(self.pars[3:]) + + return band_, pl_, band_ + pl_ + + def band_bb(self): + band_ = self.band_grb_function(self.pars[:-2]) + bb_ = self.blackbody(self.pars[-2:]) + + return band_, bb_, band_ + bb_ + + def band_pl_bb(self): + pl_ = self.powerlaw(self.pars[:3]) + band_ = self.band_grb_function(self.pars[3:-2]) + bb_ = self.blackbody(self.pars[-2:]) + + return band_, pl_, bb_, band_ + pl_ + bb_ + + def sbpl_pl(self): + pl_ = self.powerlaw(self.pars[:3]) + sbpl_ = self.smoothly_broken_powerlaw(self.pars[3:]) + + return pl_, sbpl_, sbpl_ + pl_ + + def sbpl_bb(self): + sbpl_ = self.smoothly_broken_powerlaw(self.pars[:-2]) + bb_ = self.blackbody(self.pars[-2:]) + + return sbpl_, bb_, sbpl_ + bb_ + + def sbpl_pl_bb(self): + pl_ = self.powerlaw(self.pars[:3]) + sbpl_ = self.smoothly_broken_powerlaw(self.pars[3:-2]) + bb_ = self.blackbody(self.pars[-2:]) + + return sbpl_, pl_, bb_, sbpl_ + pl_ + bb_ + + def get_values(self): + model = self.model + + return [self.powerlaw() if model == 'pl' else + self.blackbody() if model == 'bb' else + self.pl_bb() if model == 'pl_bb' else + self.cutoff_powerlaw() if model == 'cpl' else + self.cpl_pl() if model == 'cpl_pl' else + self.cpl_bb() if model == 'cpl_bb' else + self.cpl_pl_bb() if model == 'cpl_pl_bb' else + self.band_grb_function() if model == 'band' else + self.band_pl() if model == 'band_pl' else + self.band_bb() if model == 'band_bb' else + self.band_pl_bb() if model == 'band_pl_bb' else + self.smoothly_broken_powerlaw() if model == 'sbpl' else + self.sbpl_pl() if model == 'sbpl_pl' else + self.sbpl_bb() if model == 'sbpl_bb' else self.sbpl_pl_bb()][0] diff --git a/requirements.txt b/requirements.txt index 618d22d..ffc2a93 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,3 +3,6 @@ # - environment.yml # - install.rst numpy>=1.21.4 + +scipy>=1.7.3 +astropy>=4.3.1 From 4e7bb3a6f5949b80be862495e3fcb4c03b03a17e Mon Sep 17 00:00:00 2001 From: noonu Date: Fri, 29 Apr 2022 12:18:42 +0500 Subject: [PATCH 3/3] minor changes * added standard_grb_models.py --- grbs/standard_grb_models.py | 268 ++++++++++++++++++++++++++++++++++++ requirements.txt | 3 + 2 files changed, 271 insertions(+) create mode 100644 grbs/standard_grb_models.py diff --git a/grbs/standard_grb_models.py b/grbs/standard_grb_models.py new file mode 100644 index 0000000..d7d69c8 --- /dev/null +++ b/grbs/standard_grb_models.py @@ -0,0 +1,268 @@ +""" +Created on Mar 18 16:33:03 2022 +""" + +import numpy as np +import scipy.integrate as si +from astropy.cosmology import FlatLambdaCDM + +""" +RMFIT order of models + +PL: PL +PL_BB: PL + BB +SBPL: SBPL +SBPL_PL: PL + SBPL +SBPL_BB: SBPL + BB +SBPL_PL_BB: PL + SBPL + BB +CPL: CPL +CPL_PL: PL + CPL +CPL_BB: CPL + BB +CPL_PL_BB: PL + CPL + BB +BAND: BAND +BAND_PL: PL + BAND +BAND_BB: BAND + BB +BAND_PL_BB: PL + BAND + BB + +""" + + +class SpectralModels: + + def __init__(self, energy, pars, t_start, t_stop, model: str = 'pl', model_type: str = 'counts', flux_energy=None, + isotropic_energy=None, redshift=None, h0=67.4, omega_m=0.315): + + self.energy = energy + self.pars = pars + + self.t_start = t_start + self.t_stop = t_stop + + self.model = model + self.model_type = model_type + + self.f_ene = [10, int(1e7)] if flux_energy is None else flux_energy + self.f_iso = [1, int(1e4)] if isotropic_energy is None else isotropic_energy + + self.z = 0 if redshift is None else redshift + + self.h0 = h0 + self.omega_m = omega_m + self.keVtoErg = 1.6021766208e-09 + + self.__raise_error() + + def __luminosity_distance(self, z_int): + return FlatLambdaCDM(H0=self.h0, Om0=self.omega_m).luminosity_distance(z_int).cgs.value + + def __luminosity_integral(self): + return si.quad(self.__luminosity_distance, 0, self.z)[0] + + def __raise_error(self): + types_ = ['counts', 'energy', 'integrate', 'bolometric'] + if self.model_type not in types_: + raise TypeError('Model type must be in ' + ', '.join(types_[:-1]) + f' or {types_[-1]}.') + + def __time_difference(self): + return self.t_stop - self.t_start + + def __vals(self): + return self.energy, self.pars, self.model_type, self.f_ene, self.f_iso, self.z, self.keVtoErg + + def powerlaw(self, joint_pars=None): + energy, pars, mt, f_ene, f_iso, z, kev_ = self.__vals() + + pars = pars if joint_pars is None else joint_pars + + def f_pl(_e=energy, out_ene=True): + [amp, e_piv, ind] = pars + out = amp * (_e * e_piv**-1)**ind + + return _e * out if out_ene else out + + def int_pl(_range=f_ene): + return si.quad(f_pl, _range[0], _range[1])[0] * kev_ + + def bol_pl(): + _bol_range = [i / (1 + z) for i in f_iso] + return int_pl(_range=_bol_range) * self.__time_difference() + + return f_pl(out_ene=False) if mt == 'counts' else f_pl() if mt == 'energy' else int_pl() if mt == 'integrate' \ + else bol_pl() + + def blackbody(self, joint_pars=None): + energy, pars, mt, f_ene, f_iso, z, kev_ = self.__vals() + + pars = pars if joint_pars is None else joint_pars + + def f_bb(_e=energy, out_ene=True): + [amp, kt] = pars + out = amp * _e**2 * (np.exp(_e / kt) - 1)**-1 + return _e * out if out_ene else out + + def int_bb(_range=f_ene): + return si.quad(f_bb, _range[0], _range[1])[0] * kev_ + + def bol_bb(): + _bol_range = [i / (1 + z) for i in f_iso] + return int_bb(_bol_range) * self.__time_difference() + + return f_bb(out_ene=False) if mt == 'counts' else f_bb() if mt == 'energy' else int_bb() if mt == 'integrate' \ + else bol_bb() + + def cutoff_powerlaw(self, joint_pars=None): + energy, pars, mt, f_ene, f_iso, z, kev_ = self.__vals() + + pars = pars if joint_pars is None else joint_pars + + def f_cpl(_e=energy, out_ene=True): + [amp, e_peak, i1, e_piv] = pars + out = amp * np.exp(-1 * _e * (2 + i1) * e_peak**-1) * (_e * e_piv**-1)**i1 + + return _e * out if out_ene else out + + def int_cpl(_range=f_ene): + return si.quad(f_cpl, _range[0], _range[1])[0] * kev_ + + def bol_cpl(): + _bol_range = [i / (1 + z) for i in f_iso] + return int_cpl(_bol_range) * self.__time_difference() + + return f_cpl(out_ene=False) if mt == 'counts' else f_cpl() if mt == 'energy' else int_cpl() if \ + mt == 'integrate' else bol_cpl() + + def smoothly_broken_powerlaw(self, joint_pars=None): + energy, pars, mt, f_ene, f_iso, z, kev_ = self.__vals() + + pars = pars if joint_pars is None else joint_pars + + def f_sbpl(_e=energy, out_ene=True): + [amp, e_piv, i1, b_ene, b_scale, i2] = pars + + m = 0.5 * (i2 - i1) + b = 0.5 * (i1 + i2) + + a_piv = np.log10(e_piv * b_ene**-1) * b_scale**-1 + + beta_piv_ = np.exp(a_piv) + np.exp(-1 * a_piv) + beta_piv = m * b_scale * np.log(0.5 * beta_piv_) + + a = b_scale**-1 * np.log10(_e * b_ene**-1) + + beta_ = np.exp(a) + np.exp(-1 * a) + beta = m * b_scale * np.log(0.5 * beta_) + + out = amp * (_e * e_piv**-1)**b * 10**(beta - beta_piv) + + return _e * out if out_ene else out + + def int_sbpl(_range=f_ene): + return si.quad(f_sbpl, _range[0], _range[1])[0] * kev_ + + def bol_sbpl(): + _bol_range = [i / (1 + z) for i in f_iso] + return int_sbpl(_bol_range) * self.__time_difference() + + return f_sbpl(out_ene=False) if mt == 'counts' else f_sbpl() if mt == 'energy' else int_sbpl() if \ + mt == 'integrate' else bol_sbpl() + + def band_grb_function(self, joint_pars=None): + energy, pars, mt, f_ene, f_iso, z, kev_ = self.__vals() + + pars = pars if joint_pars is None else joint_pars + + def f_band(_e=energy, out_ene=True): + [amp, e_peak, i1, i2] = pars + cond = (i1 - i2) * (2 + i1)**-1 * e_peak + + out = [amp * (_en * 0.01)**i2 * np.exp(i2 - i1) * ((i1 - i2) * e_peak * 0.01 * (i1 + 2)**-1)**(i1 - i2) if + _en > cond else amp * (_en * 0.01)**i1 * np.exp(-(2 + i1) * _en * e_peak**-1) for _en in _e] + + return _e * out if out_ene else out + + def int_band(_range=f_ene): + return si.quad(f_band, _range[0], _range[1])[0] * kev_ + + def bol_band(): + _bol_range = [i / (1 + z) for i in f_iso] + return int_band(_bol_range) * self.__time_difference() + + return f_band(out_ene=False) if mt == 'counts' else f_band() if mt == 'energy' else int_band() if \ + mt == 'integrate' else bol_band() + + def pl_bb(self): + pl_ = self.powerlaw(self.pars[:3]) + bb_ = self.blackbody(self.pars[3:]) + + return pl_, bb_, pl_ + bb_ + + def cpl_pl(self): + pl_, cpl_ = self.powerlaw(self.pars[:3]), self.cutoff_powerlaw(self.pars[3:]) + + return cpl_, pl_, cpl_ + pl_ + + def cpl_bb(self): + cpl_, bb_ = self.cutoff_powerlaw(self.pars[:-2]), self.blackbody(self.pars[-2:]) + + return cpl_, bb_, cpl_ + bb_ + + def cpl_pl_bb(self): + pl_ = self.powerlaw(self.pars[:3]) + cpl_ = self.cutoff_powerlaw(self.pars[3:-2]) + bb_ = self.blackbody(self.pars[-2:]) + + return cpl_, pl_, bb_, cpl_ + pl_ + bb_ + + def band_pl(self): + pl_, band_ = self.powerlaw(self.pars[:3]), self.band_grb_function(self.pars[3:]) + + return band_, pl_, band_ + pl_ + + def band_bb(self): + band_, bb_ = self.band_grb_function(self.pars[:-2]), self.blackbody(self.pars[-2:]) + + return band_, bb_, band_ + bb_ + + def band_pl_bb(self): + pl_ = self.powerlaw(self.pars[:3]) + band_ = self.band_grb_function(self.pars[3:-2]) + bb_ = self.blackbody(self.pars[-2:]) + + return band_, pl_, bb_, band_ + pl_ + bb_ + + def sbpl_pl(self): + pl_ = self.powerlaw(self.pars[:3]) + sbpl_ = self.smoothly_broken_powerlaw(self.pars[3:]) + + return pl_, sbpl_, sbpl_ + pl_ + + def sbpl_bb(self): + sbpl_ = self.smoothly_broken_powerlaw(self.pars[:-2]) + bb_ = self.blackbody(self.pars[-2:]) + + return sbpl_, bb_, sbpl_ + bb_ + + def sbpl_pl_bb(self): + pl_ = self.powerlaw(self.pars[:3]) + sbpl_ = self.smoothly_broken_powerlaw(self.pars[3:-2]) + bb_ = self.blackbody(self.pars[-2:]) + + return sbpl_, pl_, bb_, sbpl_ + pl_ + bb_ + + def get_values(self): + model = self.model + + return [self.powerlaw() if model == 'pl' else + self.blackbody() if model == 'bb' else + self.pl_bb() if model == 'pl_bb' else + self.cutoff_powerlaw() if model == 'cpl' else + self.cpl_pl() if model == 'cpl_pl' else + self.cpl_bb() if model == 'cpl_bb' else + self.cpl_pl_bb() if model == 'cpl_pl_bb' else + self.band_grb_function() if model == 'band' else + self.band_pl() if model == 'band_pl' else + self.band_bb() if model == 'band_bb' else + self.band_pl_bb() if model == 'band_pl_bb' else + self.smoothly_broken_powerlaw() if model == 'sbpl' else + self.sbpl_pl() if model == 'sbpl_pl' else + self.sbpl_bb() if model == 'sbpl_bb' else self.sbpl_pl_bb()][0] diff --git a/requirements.txt b/requirements.txt index 618d22d..ffc2a93 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,3 +3,6 @@ # - environment.yml # - install.rst numpy>=1.21.4 + +scipy>=1.7.3 +astropy>=4.3.1