redback 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

redback/transient/afterglow.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 from os.path import join
 from typing import Union
+import re
 
 import numpy as np
 import pandas as pd
@@ -26,7 +27,8 @@ class Afterglow(Transient):
             flux_density_err: np.ndarray = None, magnitude: np.ndarray = None, magnitude_err: np.ndarray = None,
             redshift: float = np.nan, photon_index: float = np.nan, frequency: np.ndarray = None,
             bands: np.ndarray = None, system: np.ndarray = None, active_bands: Union[np.ndarray, str] = 'all',
-            use_phase_model: bool = False, optical_data: bool = False, **kwargs: None) -> None:
+            plotting_order: Union[np.ndarray, str] = None, use_phase_model: bool = False,
+            optical_data: bool = False, **kwargs: None) -> None:
 
         """
         This is a general constructor for the Afterglow class. Note that you only need to give data corresponding to
@@ -57,7 +59,7 @@ class Afterglow(Transient):
         :type flux: np.ndarray, optional
         :type flux_err: np.ndarray, optional
         :param flux_err: Flux error values.
-        :param flux_density:Flux density values.
+        :param flux_density: Flux density values.
         :type flux_density: np.ndarray, optional
         :param flux_density_err: Flux density error values.
         :type flux_density_err: np.ndarray, optional
@@ -81,6 +83,8 @@ class Afterglow(Transient):
         :type bands: np.ndarray, optional
         :param active_bands: List or array of active bands to be used in the analysis. Use all available bands if 'all' is given.
         :type active_bands: Union[list, np.ndarray]
+        :param plotting_order: Order in which to plot the bands/and how unique bands are stored.
+        :type plotting_order: Union[np.ndarray, str], optional
         :param kwargs:
             Additional classes that can be customised to fulfil the truncation on flux to luminosity conversion:
             FluxToLuminosityConverter: Conversion class to convert fluxes to luminosities.
@@ -99,7 +103,8 @@ class Afterglow(Transient):
                          Lum50=Lum50, Lum50_err=Lum50_err, flux=flux, flux_err=flux_err, flux_density=flux_density,
                          flux_density_err=flux_density_err, use_phase_model=use_phase_model, optical_data=optical_data,
                          magnitude=magnitude, magnitude_err=magnitude_err, frequency=frequency, redshift=redshift,
-                         photon_index=photon_index, system=system, bands=bands, active_bands=active_bands, **kwargs)
+                         photon_index=photon_index, system=system, bands=bands, active_bands=active_bands,
+                         plotting_order=plotting_order, **kwargs)
         self._set_data()
         self._set_photon_index()
         self._set_t90()
@@ -244,7 +249,8 @@ class Afterglow(Transient):
                 'BAT Photon Index (15-150 keV) (PL = simple power-law, CPL = cutoff power-law)'].fillna(0)
             self.meta_data = meta_data
         except FileNotFoundError:
-            logger.warning("Meta data does not exist for this event.")
+            logger.info("Metadata does not exist for this event.")
+            logger.info("Setting metadata to None. This is not an error, but a warning that no metadata could be found online.")
             self.meta_data = None
 
     def _set_photon_index(self) -> None:
@@ -305,9 +311,13 @@ class Afterglow(Transient):
         :return: The cleaned string converted into a float.
         :rtype: float
         """
-        for r in ["PL", "CPL", ",", "C", "~", " ", 'Gemini:emission', '()']:
-            string = string.replace(r, "")
-        return float(string)
+        try:
+            for r in ["PL", "CPL", ",", "C", "~", " ", 'Gemini:emission', '()']:
+                string = string.replace(r, "")
+                new_float = float(string)
+        except ValueError:
+            new_float = float(re.findall("\d+\.\d+", string)[0])
+        return new_float
 
     def analytical_flux_to_luminosity(self) -> None:
         """Converts flux to luminosity using the analytical method."""

redback/transient/kilonova.py

@@ -20,7 +20,8 @@ class Kilonova(OpticalTransient):
             flux_density: np.ndarray = None, flux_density_err: np.ndarray = None, magnitude: np.ndarray = None,
             magnitude_err: np.ndarray = None, redshift: float = np.nan, photon_index: float = np.nan,
             bands: np.ndarray = None, system: np.ndarray = None, active_bands: Union[np.ndarray, str] = 'all',
-            use_phase_model: bool = False, optical_data: bool = True, **kwargs: None) -> None:
+            plotting_order: Union[np.ndarray, str] = None, use_phase_model: bool = False,
+            optical_data: bool = True, **kwargs: None) -> None:
         """This is a general constructor for the Kilonova class. Note that you only need to give data corresponding to
         the data mode you are using. For luminosity data provide times in the rest frame, if using a phase model
         provide time in MJD, else use the default time (observer frame).
@@ -50,7 +51,7 @@ class Kilonova(OpticalTransient):
         :type flux: np.ndarray, optional
         :type flux_err: np.ndarray, optional
         :param flux_err: Flux error values.
-        :param flux_density:Flux density values.
+        :param flux_density: Flux density values.
         :type flux_density: np.ndarray, optional
         :param flux_density_err: Flux density error values.
         :type flux_density_err: np.ndarray, optional
@@ -74,6 +75,8 @@ class Kilonova(OpticalTransient):
         :type bands: np.ndarray, optional
         :param active_bands: List or array of active bands to be used in the analysis. Use all available bands if 'all' is given.
         :type active_bands: Union[list, np.ndarray]
+        :param plotting_order: Order in which to plot the bands/and how unique bands are stored.
+        :type plotting_order: Union[np.ndarray, str], optional
         :param kwargs: Additional callables:
                         bands_to_frequency: Conversion function to convert a list of bands to frequencies. Use
                         redback.utils.bands_to_frequency if not given.
@@ -85,7 +88,7 @@ class Kilonova(OpticalTransient):
                          Lum50_err=Lum50_err, flux_density=flux_density, flux_density_err=flux_density_err,
                          magnitude=magnitude, magnitude_err=magnitude_err, data_mode=data_mode, name=name, bands=bands,
                          system=system, active_bands=active_bands, use_phase_model=use_phase_model, redshift=redshift,
-                         photon_index=photon_index, optical_data=optical_data, **kwargs)
+                         photon_index=photon_index, optical_data=optical_data, plotting_order=plotting_order, **kwargs)
         self.directory_structure = redback.get_data.directory.open_access_directory_structure(
             transient=name, transient_type="kilonova")
         self._set_data()

redback/transient/prompt.py

@@ -8,7 +8,7 @@ import pandas as pd
 from typing import Union
 
 from redback.get_data.utils import get_batse_trigger_from_grb
-from redback.get_data.directory import swift_prompt_directory_structure
+from redback.get_data.directory import swift_prompt_directory_structure, batse_prompt_directory_structure
 from redback.transient.transient import Transient
 
 dirname = os.path.dirname(__file__)
@@ -61,7 +61,12 @@ class PromptTimeSeries(Transient):
         self.channels = channels
         self.instrument = instrument
         self._set_data()
-        self.directory_structure = swift_prompt_directory_structure(grb=self.name, bin_size=self.bin_size)
+        if self.instrument == "batse":
+            self.directory_structure = batse_prompt_directory_structure(grb=self.name)
+        elif self.instrument == "swift":
+            self.directory_structure = swift_prompt_directory_structure(grb=self.name, bin_size=self.bin_size)
+        else:
+            raise ValueError("Instrument must be either 'batse' or 'swift'.")
 
     @classmethod
     def from_batse_grb_name(
@@ -95,8 +100,9 @@ class PromptTimeSeries(Transient):
         :rtype tuple:
         """
         name = f"GRB{name.lstrip('GRB')}"
-        directory_structure = swift_prompt_directory_structure(grb=name)
-        _time_series_data = np.genfromtxt(directory_structure.processed_file_path, delimiter=",")[1:]
+        directory_structure = batse_prompt_directory_structure(grb=name)
+        path = directory_structure.directory_path + name.lstrip('GRB') + '_BATSE_lc.csv'
+        _time_series_data = np.genfromtxt(path, delimiter=",")[1:]
 
         bin_left = _time_series_data[:, 0]
         bin_right = _time_series_data[:, 1]
@@ -150,6 +156,8 @@ class PromptTimeSeries(Transient):
         :type kwargs: None
         """
         plt.step(self.time, self.counts / self.bin_size)
+        plt.ylabel('Counts')
+        plt.xlabel('Time')
         plt.show()
         plt.clf()
 
@@ -177,6 +185,8 @@ class PromptTimeSeries(Transient):
         plt.clf()
         plt.step(self.time, self.counts / self.bin_size)
         plt.plot(self.time, model(self.time, **dict(posterior.iloc[-1])))
+        plt.ylabel('Counts')
+        plt.xlabel('Time')
         plt.show()
         plt.clf()
 

redback/transient/supernova.py

@@ -15,7 +15,8 @@ class Supernova(OpticalTransient):
             flux_density: np.ndarray = None, flux_density_err: np.ndarray = None, magnitude: np.ndarray = None,
             magnitude_err: np.ndarray = None, redshift: float = np.nan, photon_index: float = np.nan,
             bands: np.ndarray = None, system: np.ndarray = None, active_bands: Union[np.ndarray, str] = 'all',
-            use_phase_model: bool = False, optical_data:bool = True, **kwargs: None) -> None:
+            plotting_order: Union[np.ndarray, str] = None, use_phase_model: bool = False,
+            optical_data:bool = True, **kwargs: None) -> None:
         """
         This is a general constructor for the Supernova class. Note that you only need to give data corresponding to
         the data mode you are using. For luminosity data provide times in the rest frame, if using a phase model
@@ -45,7 +46,7 @@ class Supernova(OpticalTransient):
         :type flux: np.ndarray, optional
         :type flux_err: np.ndarray, optional
         :param flux_err: Flux error values.
-        :param flux_density:Flux density values.
+        :param flux_density: Flux density values.
         :type flux_density: np.ndarray, optional
         :param flux_density_err: Flux density error values.
         :type flux_density_err: np.ndarray, optional
@@ -69,6 +70,8 @@ class Supernova(OpticalTransient):
         :type bands: np.ndarray, optional
         :param active_bands: List or array of active bands to be used in the analysis. Use all available bands if 'all' is given.
         :type active_bands: Union[list, np.ndarray]
+        :param plotting_order: Order in which to plot the bands/and how unique bands are stored.
+        :type plotting_order: Union[np.ndarray, str], optional
         :param kwargs: Additional callables:
                         bands_to_frequency: Conversion function to convert a list of bands to frequencies. Use
                         redback.utils.bands_to_frequency if not given.
@@ -80,7 +83,8 @@ class Supernova(OpticalTransient):
                          Lum50_err=Lum50_err, flux_density=flux_density, flux_density_err=flux_density_err,
                          magnitude=magnitude, magnitude_err=magnitude_err, data_mode=data_mode, name=name,
                          use_phase_model=use_phase_model, bands=bands, system=system, active_bands=active_bands,
-                         redshift=redshift, photon_index=photon_index, **kwargs)
+                         redshift=redshift, photon_index=photon_index, optical_data=optical_data,
+                         plotting_order=plotting_order, **kwargs)
         self.directory_structure = redback.get_data.directory.open_access_directory_structure(
             transient=name, transient_type="supernova")
         self._set_data()

redback/transient/tde.py

@@ -15,7 +15,8 @@ class TDE(OpticalTransient):
             flux_density: np.ndarray = None, flux_density_err: np.ndarray = None, magnitude: np.ndarray = None,
             magnitude_err: np.ndarray = None, redshift: float = np.nan, photon_index: float = np.nan,
             bands: np.ndarray = None, system: np.ndarray = None, active_bands: Union[np.ndarray, str] = 'all',
-            use_phase_model: bool = False, optical_data:bool = True, **kwargs: None) -> None:
+            plotting_order: Union[np.ndarray, str] = None, use_phase_model: bool = False,
+            optical_data:bool = True, **kwargs: None) -> None:
         """
 
         :param name: Name of the transient.
@@ -42,7 +43,7 @@ class TDE(OpticalTransient):
         :type flux: np.ndarray, optional
         :type flux_err: np.ndarray, optional
         :param flux_err: Flux error values.
-        :param flux_density:Flux density values.
+        :param flux_density: Flux density values.
         :type flux_density: np.ndarray, optional
         :param flux_density_err: Flux density error values.
         :type flux_density_err: np.ndarray, optional
@@ -66,6 +67,8 @@ class TDE(OpticalTransient):
         :type bands: np.ndarray, optional
         :param active_bands: List or array of active bands to be used in the analysis. Use all available bands if 'all' is given.
         :type active_bands: Union[list, np.ndarray]
+        :param plotting_order: Order in which to plot the bands/and how unique bands are stored.
+        :type plotting_order: Union[np.ndarray, str], optional
         :param kwargs: Additional callables:
                         bands_to_frequency: Conversion function to convert a list of bands to frequencies. Use
                         redback.utils.bands_to_frequency if not given.
@@ -77,7 +80,7 @@ class TDE(OpticalTransient):
                          magnitude=magnitude, magnitude_err=magnitude_err, data_mode=data_mode, name=name,
                          use_phase_model=use_phase_model, optical_data=optical_data, bands=bands,
                          system=system, active_bands=active_bands,redshift=redshift,
-                         photon_index=photon_index, **kwargs)
+                         photon_index=photon_index, plotting_order=plotting_order, **kwargs)
         self.directory_structure = redback.get_data.directory.open_access_directory_structure(
             transient=self.name, transient_type="tidal_disruption_event")
         self._set_data()

redback/transient/transient.py

@@ -38,7 +38,7 @@ class Transient(object):
             ttes: np.ndarray = None, bin_size: float = None, redshift: float = np.nan, data_mode: str = None,
             name: str = '', photon_index: float = np.nan, use_phase_model: bool = False,
             optical_data: bool = False, frequency: np.ndarray = None, system: np.ndarray = None, bands: np.ndarray = None,
-            active_bands: Union[np.ndarray, str] = None, **kwargs: None) -> None:
+            active_bands: Union[np.ndarray, str] = None, plotting_order: Union[np.ndarray, str] = None, **kwargs: None) -> None:
         """This is a general constructor for the Transient class. Note that you only need to give data corresponding to
         the data mode you are using. For luminosity data provide times in the rest frame, if using a phase model
         provide time in MJD, else use the default time (observer frame).
@@ -98,6 +98,8 @@ class Transient(object):
         :param active_bands: List or array of active bands to be used in the analysis.
                              Use all available bands if 'all' is given.
         :type active_bands: Union[list, np.ndarray], optional
+        :param plotting_order: Order in which to plot the bands/and how unique bands are stored.
+        :type plotting_order: Union[np.ndarray, str], optional
         :param kwargs: Additional callables:
                        bands_to_frequency: Conversion function to convert a list of bands to frequencies.
                                            Use redback.utils.bands_to_frequency if not given.
@@ -137,11 +139,12 @@ class Transient(object):
         self.system = system
         self.data_mode = data_mode
         self.active_bands = active_bands
-        self.sncosmo_bands = redback.utils.sncosmo_bandname_from_band(self.bands, warning_style='soft')
+        self.sncosmo_bands = redback.utils.sncosmo_bandname_from_band(self.bands)
         self.redshift = redshift
         self.name = name
         self.use_phase_model = use_phase_model
         self.optical_data = optical_data
+        self.plotting_order = plotting_order
 
         self.meta_data = None
         self.photon_index = photon_index
@@ -179,7 +182,7 @@ class Transient(object):
     @classmethod
     def from_lasair_data(
             cls, name: str, data_mode: str = "magnitude", active_bands: Union[np.ndarray, str] = 'all',
-            use_phase_model: bool = False) -> Transient:
+            use_phase_model: bool = False, plotting_order: Union[np.ndarray, str] = None) -> Transient:
         """Constructor method to built object from LASAIR data.
 
         :param name: Name of the transient.
@@ -189,6 +192,8 @@ class Transient(object):
         :param active_bands: Sets active bands based on array given.
                              If argument is 'all', all unique bands in `self.bands` will be used.
         :type active_bands: Union[np.ndarray, str]
+        :param plotting_order: Order in which to plot the bands/and how unique bands are stored.
+        :type plotting_order: Union[np.ndarray, str], optional
         :param use_phase_model: Whether to use a phase model.
         :type use_phase_model: bool, optional
 
@@ -214,12 +219,12 @@ class Transient(object):
         return cls(name=name, data_mode=data_mode, time=time_days, time_err=None, time_mjd=time_mjd,
                    flux_density=flux_density, flux_density_err=flux_density_err, magnitude=magnitude,
                    magnitude_err=magnitude_err, flux=flux, flux_err=flux_err, bands=bands, active_bands=active_bands,
-                   use_phase_model=use_phase_model, optical_data=True)
+                   use_phase_model=use_phase_model, optical_data=True, plotting_order=plotting_order)
 
     @classmethod
     def from_simulated_optical_data(
             cls, name: str, data_mode: str = "magnitude", active_bands: Union[np.ndarray, str] = 'all',
-            use_phase_model: bool = False) -> Transient:
+            plotting_order: Union[np.ndarray, str] = None, use_phase_model: bool = False) -> Transient:
         """Constructor method to built object from SimulatedOpticalTransient.
 
         :param name: Name of the transient.
@@ -229,6 +234,8 @@ class Transient(object):
         :param active_bands: Sets active bands based on array given.
                              If argument is 'all', all unique bands in `self.bands` will be used.
         :type active_bands: Union[np.ndarray, str]
+        :param plotting_order: Order in which to plot the bands/and how unique bands are stored.
+        :type plotting_order: Union[np.ndarray, str], optional
         :param use_phase_model: Whether to use a phase model.
         :type use_phase_model: bool, optional
 
@@ -250,7 +257,7 @@ class Transient(object):
         return cls(name=name, data_mode=data_mode, time=time_days, time_err=None, time_mjd=time_mjd,
                    flux_density=flux_density, flux_density_err=flux_density_err, magnitude=magnitude,
                    magnitude_err=magnitude_err, flux=flux, flux_err=flux_err, bands=bands, active_bands=active_bands,
-                   use_phase_model=use_phase_model, optical_data=True)
+                   use_phase_model=use_phase_model, optical_data=True, plotting_order=plotting_order)
 
     @property
     def _time_attribute_name(self) -> str:
@@ -501,7 +508,10 @@ class Transient(object):
         :return: All bands that we get from the data, eliminating all duplicates.
         :rtype: np.ndarray
         """
-        return np.unique(self.bands)
+        if self.plotting_order is not None:
+            return self.plotting_order
+        else:
+            return np.unique(self.bands)
 
     @property
     def unique_frequencies(self) -> np.ndarray:
@@ -789,7 +799,8 @@ class OpticalTransient(Transient):
             flux_density_err: np.ndarray = None, magnitude: np.ndarray = None, magnitude_err: np.ndarray = None,
             redshift: float = np.nan, photon_index: float = np.nan, frequency: np.ndarray = None,
             bands: np.ndarray = None, system: np.ndarray = None, active_bands: Union[np.ndarray, str] = 'all',
-            use_phase_model: bool = False, optical_data:bool = True, **kwargs: None) -> None:
+            plotting_order: Union[np.ndarray, str] = None, use_phase_model: bool = False,
+            optical_data:bool = True, **kwargs: None) -> None:
         """This is a general constructor for the Transient class. Note that you only need to give data corresponding to
         the data mode you are using. For luminosity data provide times in the rest frame, if using a phase model
         provide time in MJD, else use the default time (observer frame).
@@ -839,6 +850,8 @@ class OpticalTransient(Transient):
         :param active_bands: List or array of active bands to be used in the analysis.
                              Use all available bands if 'all' is given.
         :type active_bands: Union[list, np.ndarray], optional
+        :param plotting_order: Order in which to plot the bands/and how unique bands are stored.
+        :type plotting_order: Union[np.ndarray, str], optional
         :param use_phase_model: Whether we are using a phase model.
         :type use_phase_model: bool, optional
         :param optical_data: Whether we are fitting optical data, useful for plotting.
@@ -855,14 +868,15 @@ class OpticalTransient(Transient):
                          flux=flux, flux_err=flux_err, redshift=redshift, photon_index=photon_index,
                          flux_density=flux_density, flux_density_err=flux_density_err, magnitude=magnitude,
                          magnitude_err=magnitude_err, data_mode=data_mode, name=name,
-                         use_phase_model=use_phase_model, optical_data=optical_data, system=system, bands=bands,
+                         use_phase_model=use_phase_model, optical_data=optical_data,
+                         system=system, bands=bands, plotting_order=plotting_order,
                          active_bands=active_bands, **kwargs)
         self.directory_structure = None
 
     @classmethod
     def from_open_access_catalogue(
             cls, name: str, data_mode: str = "magnitude", active_bands: Union[np.ndarray, str] = 'all',
-            use_phase_model: bool = False) -> OpticalTransient:
+            plotting_order: Union[np.ndarray, str] = None, use_phase_model: bool = False) -> OpticalTransient:
         """Constructor method to built object from Open Access Catalogue
 
         :param name: Name of the transient.
@@ -873,6 +887,8 @@ class OpticalTransient(Transient):
             Sets active bands based on array given.
             If argument is 'all', all unique bands in `self.bands` will be used.
         :type active_bands: Union[np.ndarray, str]
+        :param plotting_order: Order in which to plot the bands/and how unique bands are stored.
+        :type plotting_order: Union[np.ndarray, str], optional
         :param use_phase_model: Whether to use a phase model.
         :type use_phase_model: bool, optional
 
@@ -890,7 +906,8 @@ class OpticalTransient(Transient):
         return cls(name=name, data_mode=data_mode, time=time_days, time_err=None, time_mjd=time_mjd,
                    flux_density=flux_density, flux_density_err=flux_density_err, magnitude=magnitude,
                    magnitude_err=magnitude_err, bands=bands, system=system, active_bands=active_bands,
-                   use_phase_model=use_phase_model, optical_data=True, flux=flux, flux_err=flux_err)
+                   use_phase_model=use_phase_model, optical_data=True, flux=flux, flux_err=flux_err,
+                   plotting_order=plotting_order)
 
     @property
     def event_table(self) -> str:
@@ -906,7 +923,7 @@ class OpticalTransient(Transient):
             meta_data = pd.read_csv(self.event_table, on_bad_lines='skip', delimiter=',', dtype='str')
         except FileNotFoundError as e:
             redback.utils.logger.warning(e)
-            redback.utils.logger.warning("Setting metadata to None")
+            redback.utils.logger.warning("Setting metadata to None. This is not an error, but a warning that no metadata could be found online.")
             meta_data = None
         self.meta_data = meta_data