AstroToolkit 1.5.1__tar.gz → 1.5.2__tar.gz

{astrotoolkit-1.5.1/src/AstroToolkit.egg-info → astrotoolkit-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: AstroToolkit
-Version: 1.5.1
+Version: 1.5.2
 Summary: A package for the gathering and plotting of astronomical data.
 Author-email: Ethan Moorfield <ethan.moorfield@hotmail.co.uk>
 Project-URL: Homepage, https://github.com/WD-planets/AstroToolkit

{astrotoolkit-1.5.1 → astrotoolkit-1.5.2}/pyproject.toml

@@ -7,7 +7,7 @@ include-package-data = true
 
 [project]
 name = "AstroToolkit"
-version = "1.5.1"
+version = "1.5.2"
 authors = [
   { name="Ethan Moorfield", email="ethan.moorfield@hotmail.co.uk"},
 ]

astrotoolkit-1.5.2/src/AstroToolkit/Configuration/baseconfig.py

@@ -0,0 +1,162 @@
+import configparser
+import os
+
+
+class ConfigStruct(object):
+    def __init__(self):
+        from importlib_resources import files
+
+        self.config_file = files("AstroToolkit.Configuration").joinpath("ATKConfig.ini")
+        if not os.path.isfile(self.config_file):
+            print("No ATKConfig.ini found. Making new one with default values\n")
+            self.set_default_config()
+            self.write_config()
+
+    @property
+    def supported_keys(self):
+        keys = []
+        for key, val in vars(self).items():
+            if key != "config_file":
+                keys.append(key)
+        return keys
+
+    def set_default_config(self):
+        from ..Data.dataquery import SurveyInfo
+
+        overlay_info = SurveyInfo().overlay_param_names
+
+        self.enable_notifications = "True"
+        self.query_data_radius = "3"
+        self.query_phot_radius = "3"
+        self.query_bulkphot_radius = "3"
+        self.query_lightcurve_radius = "3"
+        self.query_spectrum_radius = "3"
+        self.query_sed_radius = "3"
+        self.query_reddening_radius = "5"
+        self.query_image_size = "30"
+        self.query_image_overlays = "gaia"
+        self.query_image_band = "g"
+        self.query_lightcurve_atlas_username = "None"
+        self.query_lightcurve_atlas_password = "None"
+        self.unit_size = "400"
+        self.search_radius = "3"
+        self.datapage_search_button_radius = "3"
+        self.gaia_overlay_mag = overlay_info["gaia"]["default_overlay_mag"]
+        self.galex_overlay_mag = overlay_info["galex"]["default_overlay_mag"]
+        self.wise_overlay_mag = overlay_info["wise"]["default_overlay_mag"]
+        self.sdss_overlay_mag = overlay_info["sdss"]["default_overlay_mag"]
+        self.twomass_overlay_mag = overlay_info["twomass"]["default_overlay_mag"]
+        self.skymapper_overlay_mag = overlay_info["skymapper"]["default_overlay_mag"]
+        self.panstarrs_overlay_mag = overlay_info["panstarrs"]["default_overlay_mag"]
+        self.datapage_datatable_radius = "3"
+        self.datapage_grid_size = "250"
+
+    def read_config(self):
+        Config = configparser.ConfigParser()
+        Config.read(self.config_file)
+
+        sections = []
+        sections.append(Config["global_settings"])
+        sections.append(Config["query_settings"])
+        sections.append(Config["image_overlay_settings"])
+        sections.append(Config["search_settings"])
+        sections.append(Config["datapage_settings"])
+
+        for section in sections:
+            for key, val in section.items():
+                setattr(self, key, val)
+
+    def write_config(self):
+        config = configparser.ConfigParser()
+
+        config.add_section("global_settings")
+        config.set("global_settings", "enable_notifications", self.enable_notifications)
+        config.set("global_settings", "unit_size", self.unit_size)
+
+        config.add_section("query_settings")
+        config.set("query_settings", "query_data_radius", self.query_data_radius)
+        config.set("query_settings", "query_phot_radius", self.query_phot_radius)
+        config.set(
+            "query_settings", "query_bulkphot_radius", self.query_bulkphot_radius
+        )
+        config.set(
+            "query_settings", "query_lightcurve_radius", self.query_lightcurve_radius
+        )
+        config.set(
+            "query_settings", "query_spectrum_radius", self.query_spectrum_radius
+        )
+        config.set("query_settings", "query_sed_radius", self.query_sed_radius)
+        config.set(
+            "query_settings", "query_reddening_radius", self.query_reddening_radius
+        )
+        config.set("query_settings", "query_image_size", self.query_image_size)
+        config.set("query_settings", "query_image_overlays", self.query_image_overlays)
+        config.set("query_settings", "query_image_band", self.query_image_band)
+        config.set(
+            "query_settings",
+            "query_lightcurve_atlas_username",
+            self.query_lightcurve_atlas_username,
+        )
+        config.set(
+            "query_settings",
+            "query_lightcurve_atlas_password",
+            self.query_lightcurve_atlas_password,
+        )
+
+        config.add_section("image_overlay_settings")
+        config.set("image_overlay_settings", "gaia_overlay_mag", self.gaia_overlay_mag)
+        config.set(
+            "image_overlay_settings", "galex_overlay_mag", self.galex_overlay_mag
+        )
+        config.set("image_overlay_settings", "wise_overlay_mag", self.wise_overlay_mag)
+        config.set("image_overlay_settings", "sdss_overlay_mag", self.sdss_overlay_mag)
+        config.set(
+            "image_overlay_settings", "twomass_overlay_mag", self.twomass_overlay_mag
+        )
+        config.set(
+            "image_overlay_settings",
+            "skymapper_overlay_mag",
+            self.skymapper_overlay_mag,
+        )
+        config.set(
+            "image_overlay_settings",
+            "panstarrs_overlay_mag",
+            self.panstarrs_overlay_mag,
+        )
+
+        config.add_section("search_settings")
+        config.set("search_settings", "search_radius", self.search_radius)
+
+        config.add_section("datapage_settings")
+        config.set(
+            "datapage_settings",
+            "datapage_search_button_radius",
+            self.datapage_search_button_radius,
+        )
+        config.set(
+            "datapage_settings",
+            "datapage_datatable_radius",
+            self.datapage_datatable_radius,
+        )
+        config.set("datapage_settings", "datapage_grid_size", self.datapage_grid_size)
+
+        with open(self.config_file, "w") as file:
+            config.write(file)
+
+    def edit_config(self, key, value):
+        self.read_config()
+        if not isinstance(value, str):
+            try:
+                value = str(value)
+            except:
+                raise Exception("ATKConfig.ini options must be strings.")
+        setattr(self, key, value)
+        self.write_config()
+
+        self.output_config()
+
+    def output_config(self):
+        self.read_config()
+        for key, val in vars(self).items():
+            if key != "config_file":
+                print(f"{key} = {val}")

astrotoolkit-1.5.2/src/AstroToolkit/Data/bin_lightcurves.py

@@ -0,0 +1,106 @@
+def binning(data, bins=None, bin_size=None):
+    import numpy as np
+
+    ra = data["ra"]
+    dec = data["dec"]
+
+    mag = data["mag"]
+    mag_err = data["mag_err"]
+    if "mjd_ori" in data:
+        time = data["mjd_ori"]
+        time_unit = "mjd_ori"
+    else:
+        time = data["hjd_ori"]
+        time_unit = "hjd_ori"
+
+    bin_edges_arr = []
+
+    if bins:
+        bin_edge_lower = 0
+        bin_size = int(len(time) / bins)
+        bin_edge_higher = bin_size
+
+        while True:
+            reached_end = False
+            if bin_edge_higher + bin_size >= len(time):
+                bin_edge_higher = len(time) - 1
+                reached_end = True
+
+            bin_edges_arr.append([bin_edge_lower, bin_edge_higher])
+            bin_edge_lower = bin_edge_higher
+            bin_edge_higher += bin_size
+
+            if reached_end:
+                break
+
+        for i, val in enumerate(bin_edges_arr):
+            bin_edges_arr[i][0] = time[val[0]]
+            bin_edges_arr[i][1] = time[val[1]]
+
+    elif bin_size:
+        bin_edge_lower = min(time)
+
+        try:
+            bin_unit = bin_size[-1]
+            bin_size = float(bin_size[:-1])
+        except:
+            raise Exception("No binsize unit given.")
+
+        if bin_unit == "d":
+            bin_size = bin_size
+        elif bin_unit == "h":
+            bin_size = bin_size / 24
+        elif bin_unit == "m":
+            bin_size = bin_size / (24 * 60)
+        else:
+            raise Exception("Invalid binsize unit.")
+
+        bin_edge_higher = bin_edge_lower + bin_size
+
+        while True:
+            reached_end = False
+            if bin_edge_higher + bin_size >= max(time):
+                bin_edge_higher = max(time)
+                reached_end = True
+
+            bin_edges_arr.append([bin_edge_lower, bin_edge_higher])
+            bin_edge_lower = bin_edge_higher
+            bin_edge_higher += bin_size
+
+            if reached_end:
+                break
+
+    final_mags, final_times, final_errors, final_ra, final_dec = [], [], [], [], []
+    for bin_edges in bin_edges_arr:
+        mask = [i for i, val in enumerate(time) if bin_edges[0] <= val < bin_edges[1]]
+
+        if len(mask) == 0:
+            continue
+
+        binned_mags = [val for i, val in enumerate(mag) if i in mask]
+        binned_ra = [val for i, val in enumerate(ra) if i in mask]
+        binned_dec = [val for i, val in enumerate(dec) if i in mask]
+
+        weights = [1 / pow(err, 2) for i, err in enumerate(mag_err) if i in mask]
+
+        weighted_mean, norm = np.average(binned_mags, weights=weights, returned=True)
+
+        mean_ra = sum(binned_ra) / len(binned_ra)
+        mean_dec = sum(binned_dec) / len(binned_dec)
+
+        final_mags.append(weighted_mean)
+        final_ra.append(mean_ra)
+        final_dec.append(mean_dec)
+        final_times.append((bin_edges[1] + bin_edges[0]) / 2)
+        final_errors.append(1 / np.sqrt(norm))
+
+    base_time_unit = time_unit[:-4]
+
+    data["mag"] = final_mags
+    data[time_unit] = final_times
+    data["mag_err"] = final_errors
+    data[base_time_unit] = [t - min(final_times) for t in final_times]
+    data["ra"] = final_ra
+    data["dec"] = final_dec
+
+    return data

{astrotoolkit-1.5.1 → astrotoolkit-1.5.2}/src/AstroToolkit/Data/dataquery.py

@@ -46,6 +46,7 @@ class SurveyInfo:
             "gaia_lc": [2016, 0],
             "asassn": [2015, 0],
             "crts": [2000, 0],
+            "tess": [2020, 0],
         }
         self.catalogues = {
             "gaia": "I/355/gaiadr3",
@@ -255,7 +256,7 @@ class SurveyInfo:
             "ztf",
         ]
 
-        self.lightcurve_surveys = ["atlas", "ztf", "crts", "asassn", "gaia"]
+        self.lightcurve_surveys = ["atlas", "ztf", "crts", "asassn", "gaia", "tess"]
 
         self.reddening_surveys = ["stilism", "gdre"]
 

{astrotoolkit-1.5.1 → astrotoolkit-1.5.2}/src/AstroToolkit/Data/fetch_crts.py

@@ -19,7 +19,7 @@ if not os.path.isfile(str(TIMER)):
         timer.write(current_time)
 
 
-# Adapted from codee given by Keith, as CRTS interface is not well-suited to scripted queries
+# Adapted from code given by Keith, as CRTS interface is not well-suited to scripted queries
 def get_CRTS_lightcurve(pos, radius):
     ra, dec = pos[0], pos[1]
 

astrotoolkit-1.5.2/src/AstroToolkit/Data/fetch_tess.py

@@ -0,0 +1,75 @@
+# Adapted from code given by Keith
+def get_TESS_lightcurve(pos, radius):
+    """
+    Note on converting to magnitudes:
+
+    https://heasarc.gsfc.nasa.gov/docs/tess/observing-technical.html
+    says that 15000 e/s gives a magnitude of 10
+
+    Tess returns data in astropy quantities - flux in e/s
+
+    u.Magnitude(lc['flux']) is the same as -2.5*log10(lc['flux'])
+
+    so plugging in 15000 and m=10 gives zp=20.44*u.ABmag
+    """
+
+    import warnings
+
+    import astropy.units as u
+    import lightkurve as lk
+    import numpy as np
+    from astropy.table import Table, vstack
+
+    ra, dec = pos
+
+    Search = lk.search_lightcurve(
+        str(ra) + " " + str(dec), mission="TESS", radius=radius
+    )
+
+    if len(Search) > 0:
+        lcurve = []
+        for s in Search:
+            try:
+                lqq = s.download_all()
+                lcurve += lqq
+            except:
+                print("Note: experiencing issues with TESS.")
+        sectors = []
+        LC = Table([])
+        for lc in lcurve:
+            if lc.meta["SECTOR"] not in sectors:
+                sectors += [lc.meta["SECTOR"]]
+                warnings.simplefilter("ignore")
+                lc = lc[lc["flux"] > 0]
+                lc["mag"] = u.Magnitude(lc["flux"]) + 20.44 * u.ABmag
+                lc["mjd"] = lc["time"].mjd.astype("float")
+                try:
+                    tab = lc.to_table()[
+                        [
+                            "time",
+                            "flux",
+                            "flux_err",
+                            "sap_flux",
+                            "quality",
+                            "mag",
+                            "mjd",
+                        ]
+                    ]
+                except:
+                    tab = lc.to_table()[
+                        ["time", "flux", "flux_err", "quality", "mag", "mjd"]
+                    ]
+                    tab["sap_flux"] = 0
+                has_nan = np.zeros(len(tab), dtype=bool)
+                for col in tab.itercols():
+                    if col.info.dtype.kind in ["f", "i"]:
+                        has_nan |= np.isnan(col)
+                tab_nonan = tab[~has_nan]
+                if len(LC) == 0:
+                    LC = tab_nonan
+                else:
+                    LC = vstack([LC, tab_nonan])
+        return LC.to_pandas()
+    else:
+        print("Note: TESS query returned no data.")
+        return None

{astrotoolkit-1.5.1 → astrotoolkit-1.5.2}/src/AstroToolkit/Data/lightcurvequery.py

@@ -12,10 +12,12 @@ class LightcurveStruct(object):
     def __str__(self):
         return "<ATK Lightcurve Structure>"
 
-    def plot(self, kind="lightcurve", colours=None, bands=None, freq=None):
+    def plot(self, kind="lightcurve", colours=None, bands=None, freq=None, bins=None):
         from ..Plotting.plotmap import map_to_plot
 
-        return map_to_plot(self, kind=kind, colours=colours, bands=bands, freq=freq)
+        return map_to_plot(
+            self, kind=kind, colours=colours, bands=bands, freq=freq, bins=bins
+        )
 
     def sigmaclip(self, sigma=3):
         from .sigmaclip import sigma_clip
@@ -27,6 +29,21 @@ class LightcurveStruct(object):
             ]
         return self
 
+    def bin(self, bins=None, binsize=None):
+        from .bin_lightcurves import binning
+
+        if not bins and not binsize:
+            raise Exception("Must provide bins or binsize.")
+        elif bins and binsize:
+            raise Exception("Both bins and binsize provided.")
+
+        if self.data:
+            self.data = [
+                binning(band, bins, binsize) if band is not None else None
+                for band in self.data
+            ]
+        return self
+
 
 class GeneralQuery(object):
     def __init__(self, survey, radius, pos, username, password, pmra, pmdec):
@@ -256,6 +273,10 @@ class AtlasQuery(GeneralQuery):
             data["duJy"].tolist(),
         )
 
+        chi_arr = [float(x) for x in chi_arr]
+        flux = [float(x) for x in flux]
+        flux_err = [float(x) for x in flux_err]
+
         # abs(flux) < 3
         bad_indices_flux = set(
             [i for i, element in enumerate(flux) if abs(element) < 3]
@@ -751,6 +772,57 @@ class CrtsQuery(GeneralQuery):
         return [data_dict]
 
 
+class TessQuery(GeneralQuery):
+    def get_data(self):
+        from .fetch_tess import get_TESS_lightcurve
+
+        data = get_TESS_lightcurve(self.pos, self.radius)
+        return data
+
+    def format_data(self, data):
+        import math
+
+        import numpy as np
+
+        mjd_ori = data["mjd"].tolist()
+        mjd = [t - min(mjd_ori) for t in mjd_ori]
+        mag = data["mag"].tolist()
+        ra_arr = [self.pos[0]] * len(mag)
+        dec_arr = [self.pos[1]] * len(mag)
+        flux = data["flux"].tolist()
+        flux_err = data["flux_err"].tolist()
+
+        mag_err = (
+            (2.5 / np.log(10)) * (np.asarray(flux_err) / np.asarray(flux))
+        ) ** 2 + 0.05**2
+        mag_err = [math.sqrt(x) for x in mag_err]
+
+        mask = [i for i, val in enumerate(mag_err) if val > 1]
+
+        def filter_data(arr, mask):
+            filtered_arr = [val for i, val in enumerate(arr) if i not in mask]
+            return filtered_arr
+
+        mjd_ori = filter_data(mjd_ori, mask)
+        mjd = filter_data(mjd, mask)
+        mag = filter_data(mag, mask)
+        mag_err = filter_data(mag_err, mask)
+        ra_arr = filter_data(ra_arr, mask)
+        dec_arr = filter_data(dec_arr, mask)
+
+        data_dict = {
+            "band": "i",
+            "ra": ra_arr,
+            "dec": dec_arr,
+            "mjd": mjd,
+            "mjd_ori": mjd_ori,
+            "mag": mag,
+            "mag_err": mag_err,
+        }
+
+        return [data_dict]
+
+
 def query(survey, source, pos, radius, username=None, password=None):
     f_return = LightcurveStruct(survey=survey, source=source, pos=pos, data=None)
 
@@ -770,7 +842,7 @@ def query(survey, source, pos, radius, username=None, password=None):
                 data = query_object.get_data(source=source)
             else:
                 data = query_object.get_data(pos=pos)
-        elif survey == "crts":
+        elif survey in ["crts", "tess"]:
             data = query_object.get_data()
         else:
             query_object.set_url()

{astrotoolkit-1.5.1 → astrotoolkit-1.5.2}/src/AstroToolkit/Examples/datapage.py

@@ -32,14 +32,6 @@ lightcurves = query(kind="lightcurve", survey="ztf", source=source).plot(
 # get SIMBAD and Vizier buttons
 buttons = buttons(source=source, grid_size=grid_size)
 
-# make a custom metadatatable entry
-custom_entry = {
-    "parameters": ["one"],
-    "values": ["two"],
-    "errors": ["three"],
-    "notes": ["four"],
-}
-
 # get a metadata table with default parameters for various surveys
 metadata = datatable(
     source=source,
@@ -51,7 +43,6 @@ metadata = datatable(
         "sdss": "default",
         "wise": "default",
         "twomass": "default",
-        "custom": custom_entry,
     },
 )
 

{astrotoolkit-1.5.1 → astrotoolkit-1.5.2}/src/AstroToolkit/Plotting/imageplotting.py

@@ -6,7 +6,7 @@ from bokeh.plotting import figure
 
 def plot_image(struct):
     plot = figure(
-        width=400, height=400, title=f'{struct.survey} Image ({struct.data['size']}")'
+        width=400, height=400, title=f'{struct.survey} Image ({struct.data["size"]}")'
     )
 
     plot.min_border = 75

{astrotoolkit-1.5.1 → astrotoolkit-1.5.2}/src/AstroToolkit/Plotting/lightcurveplotting.py

@@ -65,12 +65,10 @@ class SupportedColours(object):
 
 
 def plot_data(plot, band, colour, time_min, survey):
-    if "hjd_ori" in band:
-        time = band["hjd_ori"]
-    elif "mjd_ori" in band:
-        time = band["mjd_ori"]
-
-    time = [x - time_min for x in time]
+    if using_original_times:
+        time = [x - time_min for x in band[time_unit]]
+    else:
+        time = band[time_unit]
 
     palette, error_colour = SupportedColours(colour).get_cmap
     source = ColumnDataSource(data={"time": time, "mag": band["mag"]})
@@ -127,14 +125,25 @@ def plot_lightcurve(struct, colours, bands):
         y_axis_label=f"{lightcurve_bands}",
     )
 
+    global using_original_times, time_unit
+    using_original_times = False
+
+    if "hjd_ori" in band:
+        time_unit = "hjd"
+        if band["hjd_ori"]:
+            time_unit += "_ori"
+            using_original_times = True
+    elif "mjd_ori" in band:
+        time_unit = "mjd"
+        if band["mjd_ori"]:
+            time_unit += "_ori"
+            using_original_times = True
+
     combined_times = []
     for band in data:
-        if "hjd_ori" in band:
-            combined_times += band["hjd_ori"]
-        elif "mjd_ori" in band:
-            combined_times += band["mjd_ori"]
+        combined_times += band[time_unit]
 
-        time_min = min(combined_times)
+    time_min = min(combined_times)
 
     for band, colour in zip(data, colours):
         plot = plot_data(plot, band, colour, time_min, struct.survey)

{astrotoolkit-1.5.1 → astrotoolkit-1.5.2}/src/AstroToolkit/Plotting/plotmap.py

@@ -12,6 +12,7 @@ def map_to_plot(
     spectrum_overlay=False,
     survey=None,
     freq=None,
+    bins=None,
 ):
     if not struct.data:
         print("Note: Plot() missing data, suggests that no data was returned")
@@ -20,6 +21,7 @@ def map_to_plot(
     else:
         plot_success = True
 
+    suffix = None
     if plot_success:
         if struct.kind == "lightcurve":
             if kind == "lightcurve":
@@ -32,11 +34,13 @@ def map_to_plot(
 
                 plot = lomb_scargle(struct.data, freq).powspec_plot
                 dimensions = Dimensions(height=1, width=1)
+                suffix = "powspec"
             elif kind == "phase":
                 from ..Timeseries.lomb_scargle import lomb_scargle
 
-                plot = lomb_scargle(struct.data, freq).phasefold_plot
+                plot = lomb_scargle(struct.data, freq, bins).phasefold_plot
                 dimensions = Dimensions(height=1, width=1)
+                suffix = "phasefold"
             else:
                 raise Exception("Invalid plotting kind for ATK Lightcurve data.")
         elif struct.kind == "image":
@@ -77,10 +81,11 @@ def map_to_plot(
         plot.height = int(config.unit_size) * dimensions.height
         plot.output_backend = "svg"
 
-    if hasattr(struct, "subkind"):
-        suffix = struct.subkind
-    else:
-        suffix = struct.kind
+    if not suffix:
+        if hasattr(struct, "subkind"):
+            suffix = struct.subkind
+        else:
+            suffix = struct.kind
 
     if hasattr(struct, "source"):
         if struct.source:

{astrotoolkit-1.5.1 → astrotoolkit-1.5.2}/src/AstroToolkit/Timeseries/lomb_scargle.py

@@ -8,7 +8,7 @@ from bokeh.plotting import figure
 newline = "\n"
 
 
-def lomb_scargle(data, freq=None):
+def lomb_scargle(data, freq=None, bins=None):
     class timeseries_data(object):
         def __init__(self, time, mag, mag_err, power, frequency, freq):
             self.time = time
@@ -17,6 +17,7 @@ def lomb_scargle(data, freq=None):
             self.power = power
             self.frequency = frequency
             self.phase_freq = freq
+            self.phase_bins = bins
 
         @property
         def powspec_plot(self):
@@ -54,18 +55,41 @@ def lomb_scargle(data, freq=None):
 
         @property
         def phasefold_plot(self):
+            # code for this function adapted from Keith
+            def do_binning(bins, phase, mag, mag_err):
+                bin_phase = []
+                bin_y = []
+                bin_y_err = []
+
+                mag = np.asarray(mag)
+                mag_err = np.asarray(mag_err)
+
+                for bphase in np.linspace(0, 1 - 1 / bins, num=bins):
+                    mask = (phase < bphase + 1 / bins) & (phase >= bphase)
+                    if len(mag[mask]) > 0:
+                        bin_phase += [bphase + 0.5 / bins]
+                        weights = 1 / (mag_err[mask] ** 2)
+                        baverage, norm = np.average(
+                            mag[mask], weights=weights, returned=True
+                        )
+                        bin_y += [baverage]
+                        bin_y_err += [1 / np.sqrt(norm)]
+
+                return bin_phase, bin_y, bin_y_err
+
             if not self.phase_freq:
                 best_frequency = self.frequency[np.nanargmax(self.power)]
             else:
                 best_frequency = self.phase_freq / u.day
 
-            t_fit = np.linspace(0, 1, 1000) * u.day
+            t_fit = np.linspace(0, 1 / best_frequency.value, 1000) * u.day
             ls = LombScargle(self.time, self.mag, self.mag_err)
             y_fit = ls.model(t=t_fit, frequency=best_frequency)
 
             phase = (self.time % (1 / best_frequency)) * best_frequency
 
             t_fit = t_fit * best_frequency
+
             cut_indices = [i for i, val in enumerate(t_fit) if val > 1]
 
             t_fit_formatted = [
@@ -83,10 +107,14 @@ def lomb_scargle(data, freq=None):
             y_fit_formatted = [x.value - median_mag for x in y_fit_formatted]
             self.mag_err = [x.value for x in self.mag_err]
 
+            mag = self.mag
+            mag_err = self.mag_err
+
+            if self.phase_bins:
+                phase, mag, mag_err = do_binning(self.phase_bins, phase, mag, mag_err)
+
             err_xs = [[x, x] for x in phase]
-            err_ys = [
-                [y - y_err, y + y_err] for y, y_err in zip(self.mag, self.mag_err)
-            ]
+            err_ys = [[y - y_err, y + y_err] for y, y_err in zip(mag, mag_err)]
 
             plot = figure(
                 width=400,
@@ -94,14 +122,15 @@ def lomb_scargle(data, freq=None):
                 x_axis_label="Phase",
                 y_axis_label="Magnitude (relative to median)",
             )
-            plot.scatter(x=phase, y=self.mag, level="guide")
+            plot.scatter(x=phase, y=mag, level="guide")
             plot.line(
                 x=t_fit_formatted,
                 y=y_fit_formatted,
-                line_width=2,
+                line_width=3,
                 line_color="black",
-                level="underlay",
+                level="overlay",
                 legend_label=f"Period: {round(24/(best_frequency.value),2)} h",
+                alpha=0.75,
             )
             plot.multi_line(
                 xs=err_xs,

{astrotoolkit-1.5.1 → astrotoolkit-1.5.2}/src/AstroToolkit/Tools.py

@@ -2,17 +2,18 @@ from .Configuration.baseconfig import ConfigStruct
 
 """
 Changelog:
-- fixed bug with CRTS light curve queries
-- Can now choose a frequency to plot in phase folded light curves
-- fixed a bug in input checking that made readfits unusable
-- fixed ATLAS light curve queries, extended MJD
-- changed GALEX time from [2007,0] to [2006,8], seems to fit high PM object detections better.
+- fixed a bug which seemed to only affect linux where " and ' in an f-string would raise an error
+- improved phase fold plots, sine wave now always goes from 0 to 1. High periods previously truncated this line
+- added support for TESS light curve queries
+- added light curve binning + phase fold binning functionality
 - other bug fixes
-- added reddening to README, forgot in last version
 """
 
 """
 To-Do:
+- add a special thanks to Keith in the README
+- turn savedata into a method on plot objects
+- include survey name in plot file names, also change name based on subkind
 - fix (especially tracer) query radius in overlays
 - update README
 - input validation for config values
@@ -21,10 +22,10 @@ To-Do:
 - add check for missing data in savedata
 - currently, incorrect username/password in ATLAS just says experiencing issues
 - allow user to choose a file name to save file as
-- check atlas query + powspec
 - add piggyback radius to config for image detection overlays
 - add a config option for font size
 - add a config option for svg/png output
+- raw data output (add raw flag that overrides any data filtering, plot tools might need to do some basic filtering to work)
 """
 
 config = ConfigStruct()

{astrotoolkit-1.5.1 → astrotoolkit-1.5.2/src/AstroToolkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: AstroToolkit
-Version: 1.5.1
+Version: 1.5.2
 Summary: A package for the gathering and plotting of astronomical data.
 Author-email: Ethan Moorfield <ethan.moorfield@hotmail.co.uk>
 Project-URL: Homepage, https://github.com/WD-planets/AstroToolkit

{astrotoolkit-1.5.1 → astrotoolkit-1.5.2}/src/AstroToolkit.egg-info/SOURCES.txt

@@ -10,8 +10,11 @@ src/AstroToolkit.egg-info/SOURCES.txt
 src/AstroToolkit.egg-info/dependency_links.txt
 src/AstroToolkit.egg-info/requires.txt
 src/AstroToolkit.egg-info/top_level.txt
+src/AstroToolkit/Configuration/baseconfig.py
+src/AstroToolkit/Data/bin_lightcurves.py
 src/AstroToolkit/Data/dataquery.py
 src/AstroToolkit/Data/fetch_crts.py
+src/AstroToolkit/Data/fetch_tess.py
 src/AstroToolkit/Data/hrdquery.py
 src/AstroToolkit/Data/imageoverlay.py
 src/AstroToolkit/Data/imagequery.py