time info widget, rebinning and lightcurves save

modules/DataLoading/DataIngestion.py

@@ -7,7 +7,7 @@ import os
 import stat
 import numpy as np
 from bokeh.models import Tooltip
-from utils.globals import loaded_event_data
+from utils.globals import loaded_event_data, loaded_light_curve
 from utils.DashboardClasses import (
     MainHeader,
     MainArea,
@@ -359,7 +359,7 @@ def preview_loaded_files(
     time_limit=10,
 ):
     """
-    Preview the loaded event data files.
+    Preview the loaded event data files and light curves.
 
     Args:
         event: The event object triggering the function.
@@ -368,29 +368,38 @@ def preview_loaded_files(
         warning_handler (WarningHandler): The handler for warnings.
         time_limit (int): The number of time entries to preview.
     """
-    if not loaded_event_data:
-        output_box_container[:] = [
-            create_loadingdata_output_box("No files loaded to preview.")
-        ]
-        return
-
     preview_data = []
-    for file_name, event_list in loaded_event_data:
-        try:
-            time_data = f"Times (first {time_limit}): {event_list.time[:time_limit]}"
-            mjdref = f"MJDREF: {event_list.mjdref}"
-            gti = f"GTI: {event_list.gti}"
-            preview_data.append(f"File: {file_name}\n{time_data}\n{mjdref}\n{gti}\n")
-        except Exception as e:
-            warning_handler.warn(str(e), category=RuntimeWarning)
 
+    # Preview EventList data
+    if loaded_event_data:
+        for file_name, event_list in loaded_event_data:
+            try:
+                time_data = f"Times (first {time_limit}): {event_list.time[:time_limit]}"
+                mjdref = f"MJDREF: {event_list.mjdref}"
+                gti = f"GTI: {event_list.gti}"
+                preview_data.append(f"Event List - {file_name}:\n{time_data}\n{mjdref}\n{gti}\n")
+            except Exception as e:
+                warning_handler.warn(str(e), category=RuntimeWarning)
+
+    # Preview Lightcurve data
+    if loaded_light_curve:
+        for lc_name, lightcurve in loaded_light_curve:
+            try:
+                time_data = f"Times (first {time_limit}): {lightcurve.time[:time_limit]}"
+                counts_data = f"Counts (first {time_limit}): {lightcurve.counts[:time_limit]}"
+                dt = f"dt: {lightcurve.dt}"
+                preview_data.append(f"Light Curve - {lc_name}:\n{time_data}\n{counts_data}\n{dt}\n")
+            except Exception as e:
+                warning_handler.warn(str(e), category=RuntimeWarning)
+
+    # Display preview data or message if no data available
     if preview_data:
         output_box_container[:] = [
             create_loadingdata_output_box("\n\n".join(preview_data))
         ]
     else:
         output_box_container[:] = [
-            create_loadingdata_output_box("No valid files loaded for preview.")
+            create_loadingdata_output_box("No valid files or light curves loaded for preview.")
         ]
 
     if warning_handler.warnings:
@@ -405,26 +414,42 @@ def preview_loaded_files(
 
 def clear_loaded_files(event, output_box_container, warning_box_container):
     """
-    Clear all loaded event data files from memory.
+    Clear all loaded event data files and light curves from memory.
 
     Args:
         event: The event object triggering the function.
         output_box_container (OutputBox): The container for output messages.
         warning_box_container (WarningBox): The container for warning messages.
     """
-    global loaded_event_data
-    if not loaded_event_data:
-        output_box_container[:] = [
-            create_loadingdata_output_box("No files loaded to clear.")
-        ]
-    else:
+    global loaded_event_data, loaded_light_curve
+    event_data_cleared = False
+    light_curve_data_cleared = False
+
+    # Clear EventList data
+    if loaded_event_data:
         loaded_event_data.clear()
-        output_box_container[:] = [
-            create_loadingdata_output_box("Loaded files have been cleared.")
-        ]
+        event_data_cleared = True
+
+    # Clear Lightcurve data
+    if loaded_light_curve:
+        loaded_light_curve.clear()
+        light_curve_data_cleared = True
+
+    # Create appropriate messages based on what was cleared
+    messages = []
+    if event_data_cleared:
+        messages.append("Loaded event files have been cleared.")
+    if light_curve_data_cleared:
+        messages.append("Loaded light curves have been cleared.")
+    if not messages:
+        messages.append("No files or light curves loaded to clear.")
+
+    # Update the output and warning containers
+    output_box_container[:] = [create_loadingdata_output_box("\n".join(messages))]
     warning_box_container[:] = [create_loadingdata_warning_box("No warnings.")]
 
 
+
 def create_event_list(
     event,
     times_input,

modules/Home/HomeContent.py

@@ -53,17 +53,26 @@ def create_home_main_area():
 
     # Path to the data files
     data_dir = os.path.join(os.getcwd(), "files", "data")
-    target_file = "nomission.evt"
-    file_path = os.path.join(data_dir, target_file)
+    target_file1 = "nomission.evt"
+    file_path1 = os.path.join(data_dir, target_file1)
+    target_file2 = "xte_test.evt.gz"
+    file_path2 = os.path.join(data_dir, target_file2)
 
     # Check if the file is already loaded
     if not any(file_name == "nomission" for file_name, _ in loaded_event_data):
         try:
-            event_list = EventList.read(file_path, "ogip")
+            event_list = EventList.read(file_path1, "ogip")
             loaded_event_data.append(("nomission", event_list))
-            print(f"File '{target_file}' loaded successfully.")
+            print(f"File '{target_file1}' loaded successfully.")
+        except Exception as e:
+            print(f"Failed to load file '{target_file1}': {e}")
+    if not any(file_name == "xte_test" for file_name, _ in loaded_event_data):
+        try:
+            event_list = EventList.read(file_path2, "ogip")
+            loaded_event_data.append(("xte_test.evt.gz", event_list))
+            print(f"File '{target_file2}' loaded successfully.")
         except Exception as e:
-            print(f"Failed to load file '{target_file}': {e}")
+            print(f"Failed to load file '{target_file2}': {e}")
 
     tab1_content = pn.pane.Markdown(HOME_STINGRAY_TAB_STRING)
     tab2_content = pn.pane.Markdown(HOME_HOLOVIZ_TAB_STRING)

modules/QuickLook/AveragePowerSpectrum.py

@@ -19,12 +19,29 @@ from utils.DashboardClasses import (
 from stingray import AveragedPowerspectrum
 
 colors = [
-    "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", "#8c564b",
-    "#e377c2", "#7f7f7f", "#bcbd22", "#17becf", "#aec7e8", "#ffbb78",
-    "#98df8a", "#ff9896", "#c5b0d5", "#c49c94", "#f7b6d2", "#c7c7c7",
-    "#dbdb8d", "#9edae5"
+    "#1f77b4",
+    "#ff7f0e",
+    "#2ca02c",
+    "#d62728",
+    "#9467bd",
+    "#8c564b",
+    "#e377c2",
+    "#7f7f7f",
+    "#bcbd22",
+    "#17becf",
+    "#aec7e8",
+    "#ffbb78",
+    "#98df8a",
+    "#ff9896",
+    "#c5b0d5",
+    "#c49c94",
+    "#f7b6d2",
+    "#c7c7c7",
+    "#dbdb8d",
+    "#9edae5",
 ]
 
+
 # Create a warning handler
 def create_warning_handler():
     warning_handler = WarningHandler()
@@ -33,6 +50,8 @@ def create_warning_handler():
 
 
 """ Header Section """
+
+
 def create_quicklook_avg_powerspectrum_header(
     header_container,
     main_area_container,
@@ -51,21 +70,29 @@ def create_quicklook_avg_powerspectrum_header(
 
 
 """ Output Box Section """
+
+
 def create_loadingdata_output_box(content):
     return OutputBox(output_content=content)
 
 
 """ Warning Box Section """
+
+
 def create_loadingdata_warning_box(content):
     return WarningBox(warning_content=content)
 
 
 """ Float Panel """
+
+
 def create_floatpanel_area(content, title):
     return FloatingPlot(content=content, title=title)
 
 
 """ Main Area Section """
+
+
 def create_avg_powerspectrum_tab(
     output_box_container,
     warning_box_container,
@@ -94,9 +121,7 @@ def create_avg_powerspectrum_tab(
         value="leahy",
     )
 
-    segment_size_input = pn.widgets.FloatInput(
-        name="Segment Size", value=10, step=1
-    )
+    segment_size_input = pn.widgets.FloatInput(name="Segment Size", value=10, step=1)
 
     multi_event_select = pn.widgets.MultiSelect(
         name="Or Select Event List(s) to Combine",
@@ -111,9 +136,59 @@ def create_avg_powerspectrum_tab(
     dataframe_checkbox = pn.widgets.Checkbox(
         name="Add DataFrame to FloatingPanel", value=False
     )
-    
+
     rasterize_checkbox = pn.widgets.Checkbox(name="Rasterize Plots", value=True)
 
+    # New Checkboxes for Rebinning
+
+    linear_rebin_checkbox = pn.widgets.Checkbox(name="Linear Rebinning", value=False)
+
+    log_rebin_checkbox = pn.widgets.Checkbox(name="Logarithmic Rebinning", value=False)
+
+    rebin_with_original_checkbox = pn.widgets.Checkbox(
+        name="Plot Rebin with Original", value=False
+    )
+
+    # Input for Rebin Size
+
+    rebin_size_input = pn.widgets.FloatInput(
+        name="Rebin Size",
+        value=0.1,
+        step=0.000001,
+        start=0.01,
+        end=1000.0,
+    )
+
+    time_info_pane = pn.pane.Markdown(
+        "Select an event list to see time range", width=600
+    )
+
+    # Update time info when an event list is selected
+
+    def update_time_info(event):
+
+        selected_index = event_list_dropdown.value
+
+        if selected_index is not None:
+
+            event_list_name = loaded_event_data[selected_index][0]
+
+            event_list = loaded_event_data[selected_index][1]
+
+            start_time = event_list.time[0]
+
+            end_time = event_list.time[-1]
+
+            time_info_pane.object = (
+                f"**Event List:** {event_list_name} \n"
+                f"**Start Time:** {start_time} \n"
+                f"**End Time:** {end_time}"
+            )
+
+        else:
+
+            time_info_pane.object = "Select an event list to see time range"
+
     # Internal functions to encapsulate functionality
     def create_dataframe(selected_event_list_index, dt, norm, segment_size):
         if selected_event_list_index is not None:
@@ -160,7 +235,8 @@ def create_avg_powerspectrum_tab(
                         create_loadingdata_output_box(
                             f"Error generating Averaged Power Spectrum: {e}. "
                             "Try using a different segment size."
-                        )]
+                        )
+                    ]
                 return None, None
         return None, None
 
@@ -179,9 +255,7 @@ def create_avg_powerspectrum_tab(
 
         if color_key:
             if rasterize_checkbox.value:
-                return hd.rasterize(
-                    plot, line_width=3, pixel_ratio=2
-                ).opts(
+                return hd.rasterize(plot, line_width=3, pixel_ratio=2).opts(
                     tools=["hover"],
                     cmap=[color_key],
                     width=600,
@@ -192,9 +266,7 @@ def create_avg_powerspectrum_tab(
                 return plot
         else:
             if rasterize_checkbox.value:
-                return hd.rasterize(
-                    plot, line_width=3, pixel_ratio=2
-                ).opts(
+                return hd.rasterize(plot, line_width=3, pixel_ratio=2).opts(
                     tools=["hover"],
                     width=600,
                     height=600,
@@ -204,7 +276,23 @@ def create_avg_powerspectrum_tab(
             else:
                 return plot
 
-    def create_holoviews_plots_no_colorbar(ps, title, dt, norm, segment_size, color_key=None):
+    def rebin_powerspectrum(ps):
+
+        rebin_size = rebin_size_input.value
+
+        if linear_rebin_checkbox.value:
+
+            return ps.rebin(rebin_size, method="mean")
+
+        elif log_rebin_checkbox.value:
+
+            return ps.rebin_log(f=rebin_size)
+
+        return None
+
+    def create_holoviews_plots_no_colorbar(
+        ps, title, dt, norm, segment_size, color_key=None
+    ):
         label = f"{title} (dt={dt}, norm={norm}, segment={segment_size})"
         plot = hv.Curve((ps.freq, ps.power), label=label).opts(
             xlabel="Frequency (Hz)",
@@ -216,9 +304,7 @@ def create_avg_powerspectrum_tab(
 
         if color_key:
             if rasterize_checkbox.value:
-                return hd.rasterize(
-                    plot, line_width=3, pixel_ratio=2
-                ).opts(
+                return hd.rasterize(plot, line_width=3, pixel_ratio=2).opts(
                     tools=["hover"],
                     cmap=[color_key],
                     width=600,
@@ -229,9 +315,7 @@ def create_avg_powerspectrum_tab(
                 return plot
         else:
             if rasterize_checkbox.value:
-                return hd.rasterize(
-                    plot, line_width=3, pixel_ratio=2
-                ).opts(
+                return hd.rasterize(plot, line_width=3, pixel_ratio=2).opts(
                     tools=["hover"],
                     width=600,
                     height=600,
@@ -243,7 +327,9 @@ def create_avg_powerspectrum_tab(
 
     def create_dataframe_panes(df, title, dt, norm, segment_size):
         return pn.FlexBox(
-            pn.pane.Markdown(f"**{title} (dt={dt}, norm={norm}, segment={segment_size})**"),
+            pn.pane.Markdown(
+                f"**{title} (dt={dt}, norm={norm}, segment={segment_size})**"
+            ),
             pn.pane.DataFrame(df, width=600, height=600),
             align_items="center",
             justify_content="center",
@@ -271,14 +357,14 @@ def create_avg_powerspectrum_tab(
         df, ps = create_dataframe(selected_event_list_index, dt, norm, segment_size)
         if df is not None:
             plot_title = f"Averaged Power Spectrum for {loaded_event_data[selected_event_list_index][0]}"
-            plot_hv = create_holoviews_plots(ps, title=plot_title, dt=dt, norm=norm, segment_size=segment_size)
+            plot_hv = create_holoviews_plots(
+                ps, title=plot_title, dt=dt, norm=norm, segment_size=segment_size
+            )
             holoviews_output = create_holoviews_panes(plot_hv)
 
             if floatpanel_plots_checkbox.value:
                 float_panel_container.append(
-                    create_floatpanel_area(
-                        content=holoviews_output, title=plot_title
-                    )
+                    create_floatpanel_area(content=holoviews_output, title=plot_title)
                 )
             else:
                 markdown_content = f"## {plot_title}"
@@ -293,11 +379,15 @@ def create_avg_powerspectrum_tab(
                     )
                 )
             output_box_container[:] = [
-                create_loadingdata_output_box("Averaged Power Spectrum generated successfully.")
+                create_loadingdata_output_box(
+                    "Averaged Power Spectrum generated successfully."
+                )
             ]
         else:
             output_box_container[:] = [
-                create_loadingdata_output_box("Failed to create averaged power spectrum.")
+                create_loadingdata_output_box(
+                    "Failed to create averaged power spectrum."
+                )
             ]
 
     def show_dataframe(event=None):
@@ -319,7 +409,13 @@ def create_avg_powerspectrum_tab(
         segment_size = segment_size_input.value
         df, ps = create_dataframe(selected_event_list_index, dt, norm, segment_size)
         if df is not None:
-            dataframe_output = create_dataframe_panes(df, f"{loaded_event_data[selected_event_list_index][0]}", dt, norm, segment_size)
+            dataframe_output = create_dataframe_panes(
+                df,
+                f"{loaded_event_data[selected_event_list_index][0]}",
+                dt,
+                norm,
+                segment_size,
+            )
             if dataframe_checkbox.value:
                 float_panel_container.append(
                     create_floatpanel_area(
@@ -355,7 +451,13 @@ def create_avg_powerspectrum_tab(
             df, ps = create_dataframe(index, dt, norm, segment_size)
             if df is not None:
                 event_list_name = loaded_event_data[index][0]
-                plot_hv = create_holoviews_plots_no_colorbar(ps, title=event_list_name, dt=dt, norm=norm, segment_size=segment_size)
+                plot_hv = create_holoviews_plots_no_colorbar(
+                    ps,
+                    title=event_list_name,
+                    dt=dt,
+                    norm=norm,
+                    segment_size=segment_size,
+                )
                 combined_plots.append(plot_hv)
                 combined_title.append(event_list_name)
 
@@ -414,7 +516,9 @@ def create_avg_powerspectrum_tab(
         floatpanel_plots_checkbox,
         dataframe_checkbox,
         rasterize_checkbox,
-        pn.Row(generate_powerspectrum_button, show_dataframe_button, combine_plots_button),
+        pn.Row(
+            generate_powerspectrum_button, show_dataframe_button, combine_plots_button
+        ),
     )
     return tab_content
 

modules/QuickLook/LightCurve.py

@@ -1,8 +1,8 @@
 import panel as pn
 import holoviews as hv
 import holoviews.operation.datashader as hd
-from holoviews.operation.timeseries import rolling, rolling_outlier_std 
-from utils.globals import loaded_event_data
+from holoviews.operation.timeseries import rolling, rolling_outlier_std
+from utils.globals import loaded_event_data, loaded_light_curve
 import pandas as pd
 import warnings
 import hvplot.pandas
@@ -124,6 +124,35 @@ def create_lightcurve_tab(
     )
     rasterize_checkbox = pn.widgets.Checkbox(name="Rasterize Plots", value=True)
 
+    save_lightcurve_checkbox = pn.widgets.Checkbox(
+        name="Save Generated Light Curve in RAM", value=False
+    )
+
+    time_info_pane = pn.pane.Markdown(
+        "Select an event list to see time range", width=600
+    )
+
+    gti_input = pn.widgets.TextInput(
+        name="Specify GTIs (Good Time Intervals)",
+        placeholder="e.g., 0 4; 6 10",
+    )
+
+    # Callback to update the time information
+    def update_time_info(event):
+        selected_index = event_list_dropdown.value
+        if selected_index is not None:
+            event_list_name = loaded_event_data[selected_index][0]
+            event_list = loaded_event_data[selected_index][1]
+            start_time = event_list.time[0]
+            end_time = event_list.time[-1]
+            time_info_pane.object = (
+                f"**Event List:** {event_list_name} \n"
+                f"**Start Time:** {start_time} \n"
+                f"**End Time:** {end_time}"
+            )
+        else:
+            time_info_pane.object = "Select an event list to see time range"
+
     def create_holoviews_panes(plot):
         return pn.pane.HoloViews(plot, width=600, height=600, linked_axes=False)
 
@@ -229,10 +258,38 @@ def create_lightcurve_tab(
             flex_direction="column",
         )
 
-    def create_dataframe(selected_event_list_index, dt):
+    def create_dataframe(selected_event_list_index, dt, eventlist_name):
         if selected_event_list_index is not None:
             event_list = loaded_event_data[selected_event_list_index][1]
-            lc_new = event_list.to_lc(dt=dt)
+
+
+            # Parse GTIs from input if provided
+            gti = None
+            if gti_input.value:
+                try:
+                    gti = [
+                        [float(start), float(end)]
+                        for start, end in (
+                            interval.split() for interval in gti_input.value.split(";")
+                        )
+                    ]
+                except ValueError:
+                    output_box_container[:] = [
+                        create_loadingdata_output_box("Invalid GTI format. Use 'start end; start end'.")
+                    ]
+                    return None
+                
+            if gti_input.value:
+                lc_new = event_list.to_lc(dt=dt).apply_gtis(gti)
+            else:
+                lc_new = event_list.to_lc(dt=dt)
+            
+
+            lightcurve_name = f"{eventlist_name}_lightcurve"
+
+            # Append the generated light curve to loaded_light_curve if the checkbox is checked
+            if save_lightcurve_checkbox.value:
+                loaded_light_curve.append((lightcurve_name, lc_new))
 
             df = pd.DataFrame(
                 {
@@ -296,7 +353,11 @@ def create_lightcurve_tab(
             return
 
         dt = dt_input.value
-        df = create_dataframe(selected_event_list_index, dt)
+        df = create_dataframe(
+            selected_event_list_index,
+            dt,
+            loaded_event_data[selected_event_list_index][0],
+        )
         if df is not None:
             event_list_name = loaded_event_data[selected_event_list_index][0]
             plot_hv = create_holoviews_plots(df, label=event_list_name, dt=dt)
@@ -396,13 +457,19 @@ def create_lightcurve_tab(
     )
     show_dataframe_button.on_click(show_dataframe)
 
+    event_list_dropdown.param.watch(update_time_info, 'value')
+
+
     tab1_content = pn.Column(
         event_list_dropdown,
+        time_info_pane, 
         dt_input,
+        gti_input,
         multi_event_select,
         floatpanel_plots_checkbox,
         dataframe_checkbox,
         rasterize_checkbox,
+        save_lightcurve_checkbox,
         pn.Row(generate_lightcurve_button, show_dataframe_button, combine_plots_button),
     )
     return tab1_content

modules/QuickLook/PowerSpectrum.py

@@ -115,6 +115,11 @@ def create_powerspectrum_tab(
     )
     
     rasterize_checkbox = pn.widgets.Checkbox(name="Rasterize Plots", value=True)
+
+    time_info_pane = pn.pane.Markdown(
+    "Select an event list to see time range", width=600
+    )
+
     
     # New Checkboxes for Rebinning
     linear_rebin_checkbox = pn.widgets.Checkbox(name="Linear Rebinning", value=False)
@@ -125,11 +130,27 @@ def create_powerspectrum_tab(
     rebin_size_input = pn.widgets.FloatInput(
         name="Rebin Size",
         value=0.1,
-        step=0.01,
+        step=0.000001,
         start=0.01,
-        end=100.0,
+        end=1000.0,
     )
 
+    def update_time_info(event):
+        selected_index = event_list_dropdown.value
+        if selected_index is not None:
+            event_list_name = loaded_event_data[selected_index][0]
+            event_list = loaded_event_data[selected_index][1]
+            start_time = event_list.time[0]
+            end_time = event_list.time[-1]
+            time_info_pane.object = (
+                f"**Event List:** {event_list_name} \n"
+                f"**Start Time:** {start_time} \n"
+                f"**End Time:** {end_time}"
+            )
+        else:
+            time_info_pane.object = "Select an event list to see time range"
+
+
     def create_holoviews_panes(plot):
         return pn.pane.HoloViews(plot, width=600, height=600, linked_axes=False)
 
@@ -443,8 +464,12 @@ def create_powerspectrum_tab(
     )
     show_dataframe_button.on_click(show_dataframe)
 
+    event_list_dropdown.param.watch(update_time_info, 'value')
+
+
     tab_content = pn.Column(
         event_list_dropdown,
+        time_info_pane, 
         dt_input,
         norm_select,
         multi_event_select,

utils/globals.py

@@ -1,2 +1,3 @@
 # Global variable to store loaded event data
 loaded_event_data = []
+loaded_light_curve = []