From d3584a381dd15235f8dba4143ed591ec23a580bc Mon Sep 17 00:00:00 2001 From: Koothodil Abhijith Augustintine Date: Sat, 28 Feb 2026 03:54:38 +0800 Subject: [PATCH] Add new phase resolved analysis code and accompanying Jupyter tutorial --- cosipy/phase_resolved_analysis/__init__.py | 3 + .../phase_resolved_analysis/phase_assigner.py | 70 ++ .../phase_resolved_analysis/phase_selector.py | 147 ++++ .../plot_pulse_profile.py | 109 +++ .../phase_resolved_analysis/time_selector.py | 126 +++ .../phase_resolved_analysis/crab.par | 4 + .../example_notebook.ipynb | 777 ++++++++++++++++++ .../phase_resolved_analysis/inputs.yaml | 30 + 8 files changed, 1266 insertions(+) create mode 100644 cosipy/phase_resolved_analysis/__init__.py create mode 100644 cosipy/phase_resolved_analysis/phase_assigner.py create mode 100644 cosipy/phase_resolved_analysis/phase_selector.py create mode 100644 cosipy/phase_resolved_analysis/plot_pulse_profile.py create mode 100644 cosipy/phase_resolved_analysis/time_selector.py create mode 100644 docs/tutorials/phase_resolved_analysis/crab.par create mode 100644 docs/tutorials/phase_resolved_analysis/example_notebook.ipynb create mode 100644 docs/tutorials/phase_resolved_analysis/inputs.yaml diff --git a/cosipy/phase_resolved_analysis/__init__.py b/cosipy/phase_resolved_analysis/__init__.py new file mode 100644 index 000000000..49b37899d --- /dev/null +++ b/cosipy/phase_resolved_analysis/__init__.py @@ -0,0 +1,3 @@ +from .time_selector import TimeSelector +from .phase_selector import PhaseSelector +from .plot_pulse_profile import PlotPulseProfile \ No newline at end of file diff --git a/cosipy/phase_resolved_analysis/phase_assigner.py b/cosipy/phase_resolved_analysis/phase_assigner.py new file mode 100644 index 000000000..a2e7169c7 --- /dev/null +++ b/cosipy/phase_resolved_analysis/phase_assigner.py @@ -0,0 +1,70 @@ +import numpy as np +import logging +from astropy.io import fits + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +class PhaseAssigner: + """ + Reads a pulsar ephemeris and assigns PULSE_PHASE based on MET directly. + """ + def __init__(self, par_file): + self.params = self._parse_par_file(par_file) + + # Parse F0 (Frequency) or P0 (Period) + if 'F0' in self.params: + val = float(self.params['F0']) + if val < 1.0: + self.f0 = 1.0 / val + logger.warning(f"F0 < 1.0. Assuming Period. F0={self.f0:.6f} Hz") + else: + self.f0 = val + elif 'P0' in self.params: + self.f0 = 1.0 / float(self.params['P0']) + else: + raise ValueError("PAR file must have F0 or P0") + + # We removed T0/Epoch logic as requested. + + def _parse_par_file(self, path): + p = {} + with open(path, 'r') as f: + for line in f: + parts = line.strip().split() + if parts and not parts[0].startswith(('#', 'C')): + try: p[parts[0].upper()] = parts[1].replace('D','E') + except: pass + return p + + def add_phase_column(self, input_fits, output_fits=None): + """ + Calculates phase = (MET * F0) % 1.0 and adds column. + """ + with fits.open(input_fits) as hdul: + data = hdul[1].data + header = hdul[1].header + + # 1. Get Time (MET) + try: times = data['TimeTags'] + except KeyError: times = data['TIME'] + + # 2. Calculate Phase (Simple Folding) + # Phase = (Time * Frequency) % 1.0 + phase = (times * self.f0) % 1.0 + + # 3. Create or Overwrite Column + cols = data.columns + if 'PULSE_PHASE' in cols.names: + logger.info("Overwriting PULSE_PHASE column.") + data['PULSE_PHASE'] = phase + new_hdu = fits.BinTableHDU(data=data, header=header) + else: + logger.info("Creating PULSE_PHASE column.") + col = fits.Column(name='PULSE_PHASE', format='D', array=phase) + new_hdu = fits.BinTableHDU.from_columns(cols + col, header=header) + + if output_fits is None: output_fits = input_fits + fits.HDUList([hdul[0], new_hdu]).writeto(output_fits, overwrite=True) + logger.info(f"Saved: {output_fits}") + return output_fits \ No newline at end of file diff --git a/cosipy/phase_resolved_analysis/phase_selector.py b/cosipy/phase_resolved_analysis/phase_selector.py new file mode 100644 index 000000000..01b4078cd --- /dev/null +++ b/cosipy/phase_resolved_analysis/phase_selector.py @@ -0,0 +1,147 @@ +import logging +import numpy as np +import itertools +import os +from astropy.io import fits + +logger = logging.getLogger(__name__) + +# --- ROBUST IMPORTS (Safety Switch) --- +try: + from cosipy.interfaces.event_selection import EventSelectorInterface + from cosipy.interfaces import EventInterface + from cosipy.util.iterables import itertools_batched +except (ImportError, AttributeError): + class EventInterface: pass + class EventSelectorInterface: + def select(self, events): raise NotImplementedError + def itertools_batched(iterable, n): + it = iter(iterable) + while True: + batch = list(itertools.islice(it, n)) + if not batch: return + yield batch + +class PhaseSelector(EventSelectorInterface): + """ + Selects events based on pulsar phase. + Highly optimized for FITS files via NumPy vectorization. + """ + def __init__(self, ephemeris_file, pstart, pstop, batch_size=10000): + self.ephemeris_file = ephemeris_file + self.pstart = float(pstart) + self.pstop = float(pstop) + self._batch_size = batch_size + + def _get_vectorized_mask(self, phases: np.ndarray) -> np.ndarray: + """Core logic applied across an entire NumPy array instantly.""" + pstop_norm = self.pstop % 1.0 if self.pstop > 1.0 else self.pstop + + if self.pstart <= pstop_norm: + return (phases >= self.pstart) & (phases <= pstop_norm) + else: + return (phases >= self.pstart) | (phases <= pstop_norm) + + def select(self, events): + """ + Maintains pipeline compatibility. Yields booleans. + Optimized to use vectorized masks on batches. + """ + # Fast path for single EventInterface object + if isinstance(events, EventInterface): + phase = getattr(events, 'pulse_phase', -1.0) + if phase is None: return False + return bool(self._get_vectorized_mask(np.array(phase))) + + # Fast path if events is already a structured NumPy array + if isinstance(events, np.ndarray) and 'PULSE_PHASE' in events.dtype.names: + return self._get_vectorized_mask(events['PULSE_PHASE']) + + # Fallback for generic iterables of objects + for chunk in itertools_batched(events, self._batch_size): + phases = np.array([getattr(e, 'pulse_phase', -1.0) for e in chunk]) + mask = self._get_vectorized_mask(phases) + for sel in mask: + yield bool(sel) + + def filter_events(self, events, output_fits=None, template_fits=None): + """ + Filters events. Instantaneous execution when passed a FITS file path. + """ + # --- VECTORIZED FAST PATH FOR FITS FILES --- + if isinstance(events, str): + logger.info(f"Auto-loading events from FITS: {events}") + template_fits = events + + with fits.open(events) as hdul: + data = hdul[1].data + # Apply mask to the entire 'PULSE_PHASE' column at once + mask = self._get_vectorized_mask(data['PULSE_PHASE']) + # Slice the FITS array instantly + selected_data = data[mask] + + if output_fits is not None: + self._save_fits_fast(selected_data, output_fits, template_fits) + + return selected_data + + # --- SLOW PATH FOR PYTHON OBJECT LISTS --- + mask = list(self.select(events)) + selected_events = [e for e, m in zip(events, mask) if m] + + if output_fits is not None: + if template_fits is None: + logger.warning("'template_fits' missing. Cannot save.") + else: + self.save_fits(selected_events, output_fits, template_fits) + + return selected_events + + def _save_fits_fast(self, structured_array, output_filename, template_filename): + """Saves a NumPy structured array directly to FITS (Orders of magnitude faster).""" + if len(structured_array) == 0: + logger.warning("Warning: No events to save.") + return + + logger.info(f"Saving {len(structured_array)} events to {output_filename}...") + + try: + with fits.open(template_filename) as hdul: + # Plop the filtered array directly into the new HDU + hdu = fits.BinTableHDU(data=structured_array, header=hdul[1].header) + hdul_new = fits.HDUList([fits.PrimaryHDU(header=hdul[0].header), hdu]) + hdul_new.writeto(output_filename, overwrite=True) + logger.info(f"Successfully saved: {output_filename}") + except Exception as e: + logger.error(f"Failed to save FITS: {e}") + + def save_fits(self, events, output_filename, template_filename): + """Legacy fallback for saving lists of Python objects.""" + # Auto-route to fast save if an array was passed by mistake + if isinstance(events, np.ndarray): + return self._save_fits_fast(events, output_filename, template_filename) + + if not events: + logger.warning("Warning: No events to save.") + return + + logger.info(f"Saving {len(events)} events (Legacy Object Mode) to {output_filename}...") + try: + with fits.open(template_filename) as hdul: + columns = hdul[1].columns + rows = [e.row for e in events if hasattr(e, 'row')] + + if not rows: + logger.error("Error: Event objects do not contain raw FITS rows.") + return + + new_data = fits.FITS_rec.from_columns(columns, nrows=len(rows)) + for i, row in enumerate(rows): + new_data[i] = row + + hdu = fits.BinTableHDU(data=new_data, header=hdul[1].header) + hdul_new = fits.HDUList([fits.PrimaryHDU(header=hdul[0].header), hdu]) + hdul_new.writeto(output_filename, overwrite=True) + logger.info(f"Successfully saved: {output_filename}") + except Exception as e: + logger.error(f"Failed to save FITS: {e}") \ No newline at end of file diff --git a/cosipy/phase_resolved_analysis/plot_pulse_profile.py b/cosipy/phase_resolved_analysis/plot_pulse_profile.py new file mode 100644 index 000000000..d814ea95a --- /dev/null +++ b/cosipy/phase_resolved_analysis/plot_pulse_profile.py @@ -0,0 +1,109 @@ +import numpy as np +import matplotlib.pyplot as plt +from matplotlib.gridspec import GridSpec + +class PlotPulseProfile: + """ + Generates a 3-panel figure: Pulse Profile, Phaseogram, and Significance Test. + Optimized for direct FITS table input (vectorized). + """ + def __init__(self, data, n_bins=50, n_time_bins=50): + self.n_bins = n_bins + self.n_time_bins = n_time_bins + + # --- VECTORIZED DATA EXTRACTION --- + try: + self.phases = np.array(data['PULSE_PHASE']) + except (KeyError, TypeError): + print("Error: 'PULSE_PHASE' column not found in data.") + self.phases = np.array([]) + + # Handle various possible time column names + if 'TimeTags' in data.names: + self.times = np.array(data['TimeTags']) + elif 'TIME' in data.names: + self.times = np.array(data['TIME']) + else: + self.times = np.zeros(len(self.phases)) + + def plot(self, t_start_met=None): + if len(self.phases) == 0: + print("No valid events to plot.") + return + + # Relative Time Calculation + if t_start_met is None: + t_start_met = np.min(self.times) + + t_elapsed = self.times - t_start_met + duration = np.max(t_elapsed) + if duration <= 0: duration = 1.0 + + # --- Plotting Setup --- + fig = plt.figure(figsize=(14, 10)) + gs = GridSpec(2, 2, width_ratios=[1, 1.2], height_ratios=[1, 1]) + + ax_prof = fig.add_subplot(gs[0, 0]) + ax_htest = fig.add_subplot(gs[1, 0]) + ax_phaseogram = fig.add_subplot(gs[:, 1]) + + # --- Panel 1: Integrated Profile (Top Left) --- + counts, edges = np.histogram(self.phases, bins=self.n_bins, range=(0, 1)) + centers = (edges[:-1] + edges[1:]) / 2 + + # 2-cycle plot for better visualization of peak wrap-around + x_2cycle = np.concatenate([centers, centers + 1]) + y_2cycle = np.concatenate([counts, counts]) + + ax_prof.step(x_2cycle, y_2cycle, where='mid', color='rebeccapurple', lw=2) + ax_prof.set_xlim(0, 2) + ax_prof.set_ylabel("Counts") + ax_prof.set_xlabel("Pulse Phase") + ax_prof.set_title(f"Integrated Profile (N={len(self.phases)})") + ax_prof.grid(alpha=0.3) + + # --- Panel 2: Phaseogram (Right) --- + h2d, xedges, yedges = np.histogram2d( + self.phases, t_elapsed, + bins=[self.n_bins, self.n_time_bins], + range=[[0, 1], [0, duration]] + ) + + im = ax_phaseogram.imshow(h2d.T, origin='lower', aspect='auto', + extent=[0, 1, 0, duration], + cmap='viridis', interpolation='nearest') + ax_phaseogram.set_xlabel("Pulse Phase") + ax_phaseogram.set_ylabel("Time since start (s)") + ax_phaseogram.set_title("Phaseogram") + plt.colorbar(im, ax=ax_phaseogram, label="Counts/bin") + + # --- Panel 3: Significance (Bottom Left) --- + if len(t_elapsed) > 1: + sort_idx = np.argsort(t_elapsed) + sorted_phases = self.phases[sort_idx] * 2 * np.pi + sorted_times = t_elapsed[sort_idx] + + # Cumulative Z^2_2 statistic (2 harmonics) + ns = np.arange(1, len(sorted_phases) + 1) + + # First harmonic (k=1) + cum_cos1 = np.cumsum(np.cos(sorted_phases)) + cum_sin1 = np.cumsum(np.sin(sorted_phases)) + + # Second harmonic (k=2) + cum_cos2 = np.cumsum(np.cos(2 * sorted_phases)) + cum_sin2 = np.cumsum(np.sin(2 * sorted_phases)) + + z2_stats = (2.0 / ns) * (cum_cos1**2 + cum_sin1**2 + cum_cos2**2 + cum_sin2**2) + + # Downsample for plotting performance if data is massive + step = max(1, len(z2_stats) // 2000) + ax_htest.plot(sorted_times[::step], z2_stats[::step], '-', color='rebeccapurple', lw=1.5) + + ax_htest.set_xlabel("Time since start (s)") + ax_htest.set_ylabel(r"Significance ($Z^2_2$)") + ax_htest.set_title("Detection Significance") + ax_htest.grid(alpha=0.3) + + plt.tight_layout() + plt.show() \ No newline at end of file diff --git a/cosipy/phase_resolved_analysis/time_selector.py b/cosipy/phase_resolved_analysis/time_selector.py new file mode 100644 index 000000000..bc85e6f26 --- /dev/null +++ b/cosipy/phase_resolved_analysis/time_selector.py @@ -0,0 +1,126 @@ +import logging +import numpy as np +import itertools +from astropy.time import Time +from astropy.io import fits + +logger = logging.getLogger(__name__) + +# --- ROBUST IMPORTS --- +try: + from cosipy.interfaces.event_selection import EventSelectorInterface + from cosipy.interfaces import TimeTagEventInterface, EventInterface + from cosipy.util.iterables import itertools_batched +except (ImportError, AttributeError): + print("WARNING: Cosipy import failed. Using local fallback interfaces.") + class EventInterface: pass + class TimeTagEventInterface(EventInterface): pass + class EventSelectorInterface: + def select(self, events): raise NotImplementedError + def itertools_batched(iterable, n): + it = iter(iterable) + while True: + batch = list(itertools.islice(it, n)) + if not batch: return + yield batch + +class TimeSelector(EventSelectorInterface): + def __init__(self, tstart:Time = None, tstop:Time = None, batch_size:int = 10000): + # Validation and Standardization + if tstart is not None and tstart.isscalar: tstart = Time([tstart]) + if tstop is not None and tstop.isscalar: tstop = Time([tstop]) + self._tstart_list = tstart + self._tstop_list = tstop + self._batch_size = batch_size + + def _select(self, event) -> bool: + return next(iter(self.select([event]))) + + def select(self, events): + # Iterator-based selection (kept for interface compatibility) + if isinstance(events, EventInterface): + return self._select(events) + for chunk in itertools_batched(events, self._batch_size): + # (Logic omitted for brevity as we use filter_fits mostly) + pass + + def filter_fits(self, file_path, mjdref_val=51910.0): + """ + Reads a FITS file, applies VECTORIZED time selection, + and prints diagnostics if no events are found. + """ + # Internal wrapper class + class _FitsEvent(TimeTagEventInterface): + def __init__(self, row): + self.row = row + try: self._time = row['TimeTags'] + except KeyError: self._time = row['TIME'] + try: self._pulse_phase = row['PULSE_PHASE'] + except KeyError: self._pulse_phase = None + self._jd1 = 2400000.5 + int(mjdref_val) + self._jd2 = (mjdref_val - int(mjdref_val)) + (self._time / 86400.0) + + @property + def time(self): return self._time + @property + def pulse_phase(self): return self._pulse_phase + @property + def jd1(self): return self._jd1 + @property + def jd2(self): return self._jd2 + + selected_events = [] + + print(f"Opening FITS file: {file_path}") + with fits.open(file_path) as hdul: + data = hdul[1].data + + # --- DIAGNOSTICS START --- + try: + times = data['TimeTags'] + except KeyError: + times = data['TIME'] + + t_min = np.min(times) + t_max = np.max(times) + print(f"File contains {len(times)} events.") + print(f" Min Time in File (MET): {t_min:.2f} s") + print(f" Max Time in File (MET): {t_max:.2f} s") + + # Check user input range + if self._tstart_list is not None: + # Convert user MJD back to MET for comparison + user_start_met = (self._tstart_list[0].mjd - mjdref_val) * 86400.0 + user_stop_met = (self._tstop_list[0].mjd - mjdref_val) * 86400.0 + print(f" User Selection (MET): {user_start_met:.2f} s to {user_stop_met:.2f} s") + + if user_stop_met < t_min or user_start_met > t_max: + print(" *** WARNING: Your selected range DOES NOT OVERLAP with the file! ***") + # --- DIAGNOSTICS END --- + + # Convert Event MET to MJD for filtering + event_mjds = mjdref_val + (times / 86400.0) + + # Create Boolean Mask + if self._tstart_list is None and self._tstop_list is None: + mask = np.ones(len(event_mjds), dtype=bool) + elif self._tstart_list is None: + mask = event_mjds <= self._tstop_list[0].mjd + elif self._tstop_list is None: + mask = event_mjds >= self._tstart_list[0].mjd + else: + start_mjds = self._tstart_list.mjd + stop_mjds = self._tstop_list.mjd + indices = np.searchsorted(start_mjds, event_mjds, side='right') - 1 + valid_idx_mask = (indices >= 0) & (indices < len(stop_mjds)) + mask = np.zeros(len(event_mjds), dtype=bool) + if np.any(valid_idx_mask): + mask[valid_idx_mask] = event_mjds[valid_idx_mask] <= stop_mjds[indices[valid_idx_mask]] + + selected_rows = data[mask] + print(f"Events passing time cut: {len(selected_rows)}") + + for row in selected_rows: + selected_events.append(_FitsEvent(row)) + + return selected_events \ No newline at end of file diff --git a/docs/tutorials/phase_resolved_analysis/crab.par b/docs/tutorials/phase_resolved_analysis/crab.par new file mode 100644 index 000000000..2acf3b0ac --- /dev/null +++ b/docs/tutorials/phase_resolved_analysis/crab.par @@ -0,0 +1,4 @@ +PSRJ J0534+2200 +RAJ 05:34:31.94 0.004 +DECJ +22:00:52.1 0.06 +F0 29.946923 \ No newline at end of file diff --git a/docs/tutorials/phase_resolved_analysis/example_notebook.ipynb b/docs/tutorials/phase_resolved_analysis/example_notebook.ipynb new file mode 100644 index 000000000..eaf4c8735 --- /dev/null +++ b/docs/tutorials/phase_resolved_analysis/example_notebook.ipynb @@ -0,0 +1,777 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# COSI Pulsar Analysis Tutorial: Phase Assignment and Filtering\n", + "\n", + "## Overview\n", + "This tutorial demonstrates a complete workflow for performing phase-resolved pulsar analysis using `cosipy` and custom time-domain tools. Using Data Challenge 2 (DC2) FITS data for the Crab pulsar and its accompanying albedo background, this notebook guides you through the process of preparing unbinned photon events, assigning rotational phases, and extracting specific pulse intervals.\n", + "\n", + "## Objectives\n", + "By the end of this notebook, you will learn how to:\n", + "* **Combine and Time-Slice Data:** Merge unbinned source and background datasets, and filter them down to specific Mission Elapsed Time (MET) windows for faster processing.\n", + "* **Assign Pulsar Phases:** Use a pulsar ephemeris parameter file (`.par`) to calculate and append the precise rotational phase (0.0 to 1.0) to individual photon events.\n", + "* **Visualize the Pulse Profile:** Generate a folded light curve (pulse profile) to visually inspect the on-pulse peaks and off-pulse baseline.\n", + "* **Perform Phase Selection:** Filter the phase-assigned data to isolate specific windows, such as the `on-pulse` and `off-pulse` regions, outputting the results into new FITS files for downstream spatial or spectral analysis.\n", + "\n", + "## Prerequisites\n", + "To run this notebook, ensure you have the following in your working directory:\n", + "* A valid ephemeris file (e.g., `crab.par`)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **`from cosipy import BinnedData`**: Imports the `BinnedData` class from the `cosipy` library, which is used for handling and analyzing binned datasets.\n", + "* **`from cosipy.data_io import UnBinnedData`**: Imports the `UnBinnedData` class to handle raw, unbinned photon event data.\n", + "* **`from astropy.io import fits`**: Imports the `fits` module from the Astropy package to read, manipulate, and write FITS (Flexible Image Transport System) files.\n", + "* **`from time_selector import TimeSelector`**: Imports a custom script/class to filter datasets based on specific time windows.\n", + "* **`from phase_selector import PhaseSelector`**: Imports a custom script/class to filter pulsar data based on specific phase intervals.\n", + "* **`from plot_pulse_profile import PlotPulseProfile`**: Imports a custom class designed to generate and visualize pulsar light curves (pulse profiles).\n", + "* **`%matplotlib inline`**: A Jupyter Notebook magic command that ensures any generated plots are displayed directly below the code cell within the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
03:32:41 WARNING   The naima package is not available. Models that depend on it will not be         functions.py:43\n",
+       "                  available                                                                                        \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m03:32:41\u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m The naima package is not available. Models that depend on it will not be \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=468866;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/astromodels/functions/functions_1D/functions.py\u001b\\\u001b[2mfunctions.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=319189;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/astromodels/functions/functions_1D/functions.py#43\u001b\\\u001b[2m43\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mavailable \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   The GSL library or the pygsl wrapper cannot be loaded. Models that depend on it  functions.py:65\n",
+       "                  will not be available.                                                                           \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m The GSL library or the pygsl wrapper cannot be loaded. Models that depend on it \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=929869;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/astromodels/functions/functions_1D/functions.py\u001b\\\u001b[2mfunctions.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=818925;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/astromodels/functions/functions_1D/functions.py#65\u001b\\\u001b[2m65\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mwill not be available. \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   The ebltable package is not available. Models that depend on it will not be     absorption.py:33\n",
+       "                  available                                                                                        \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m The ebltable package is not available. Models that depend on it will not be \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=363830;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/astromodels/functions/functions_1D/absorption.py\u001b\\\u001b[2mabsorption.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=944819;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/astromodels/functions/functions_1D/absorption.py#33\u001b\\\u001b[2m33\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mavailable \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
03:32:42 INFO      Starting 3ML!                                                                     __init__.py:39\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m03:32:42\u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;49mINFO \u001b[0m \u001b[1;38;5;251m Starting 3ML! \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=145512;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=316652;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py#39\u001b\\\u001b[2m39\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   WARNINGs here are NOT errors                                                      __init__.py:40\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m WARNINGs here are \u001b[0m\u001b[1;31mNOT\u001b[0m\u001b[1;38;5;251m errors \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=294252;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=443010;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py#40\u001b\\\u001b[2m40\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   but are inform you about optional packages that can be installed                  __init__.py:41\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m but are inform you about optional packages that can be installed \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=751859;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=114759;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py#41\u001b\\\u001b[2m41\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING    to disable these messages, turn off start_warning in your config file            __init__.py:44\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m \u001b[0m\u001b[1;31m to disable these messages, turn off start_warning in your config file\u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=590705;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=605996;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py#44\u001b\\\u001b[2m44\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
03:32:42 WARNING   ROOT minimizer not available                                                minimization.py:1345\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m03:32:42\u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m ROOT minimizer not available \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=498172;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/minimizer/minimization.py\u001b\\\u001b[2mminimization.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=975119;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/minimizer/minimization.py#1345\u001b\\\u001b[2m1345\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   Multinest minimizer not available                                           minimization.py:1357\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m Multinest minimizer not available \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=201088;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/minimizer/minimization.py\u001b\\\u001b[2mminimization.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=54394;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/minimizer/minimization.py#1357\u001b\\\u001b[2m1357\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   PyGMO is not available                                                      minimization.py:1369\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m PyGMO is not available \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=180824;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/minimizer/minimization.py\u001b\\\u001b[2mminimization.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=422339;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/minimizer/minimization.py#1369\u001b\\\u001b[2m1369\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   The cthreeML package is not installed. You will not be able to use plugins which  __init__.py:94\n",
+       "                  require the C/C++ interface (currently HAWC)                                                     \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m The cthreeML package is not installed. You will not be able to use plugins which \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=161434;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=773561;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py#94\u001b\\\u001b[2m94\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mrequire the C/C++ interface \u001b[0m\u001b[1;38;5;251m(\u001b[0m\u001b[1;38;5;251mcurrently HAWC\u001b[0m\u001b[1;38;5;251m)\u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   Could not import plugin HAWCLike.py. Do you have the relative instrument         __init__.py:144\n",
+       "                  software installed and configured?                                                               \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m Could not import plugin HAWCLike.py. Do you have the relative instrument \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=160831;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=941241;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py#144\u001b\\\u001b[2m144\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251msoftware installed and configured? \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   Could not import plugin FermiLATLike.py. Do you have the relative instrument     __init__.py:144\n",
+       "                  software installed and configured?                                                               \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m Could not import plugin FermiLATLike.py. Do you have the relative instrument \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=863462;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=366769;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py#144\u001b\\\u001b[2m144\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251msoftware installed and configured? \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   No fermitools installed                                              lat_transient_builder.py:44\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m No fermitools installed \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=620919;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/utils/data_builders/fermi/lat_transient_builder.py\u001b\\\u001b[2mlat_transient_builder.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=982860;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/utils/data_builders/fermi/lat_transient_builder.py#44\u001b\\\u001b[2m44\u001b[0m\u001b]8;;\u001b\\\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   Env. variable OMP_NUM_THREADS is not set. Please set it to 1 for optimal         __init__.py:387\n",
+       "                  performances in 3ML                                                                              \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m Env. variable OMP_NUM_THREADS is not set. Please set it to \u001b[0m\u001b[1;37m1\u001b[0m\u001b[1;38;5;251m for optimal \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=127554;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=248758;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py#387\u001b\\\u001b[2m387\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mperformances in 3ML \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   Env. variable MKL_NUM_THREADS is not set. Please set it to 1 for optimal         __init__.py:387\n",
+       "                  performances in 3ML                                                                              \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m Env. variable MKL_NUM_THREADS is not set. Please set it to \u001b[0m\u001b[1;37m1\u001b[0m\u001b[1;38;5;251m for optimal \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=932273;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=706884;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py#387\u001b\\\u001b[2m387\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mperformances in 3ML \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
         WARNING   Env. variable NUMEXPR_NUM_THREADS is not set. Please set it to 1 for optimal     __init__.py:387\n",
+       "                  performances in 3ML                                                                              \n",
+       "
\n" + ], + "text/plain": [ + "\u001b[38;5;46m \u001b[0m\u001b[38;5;46m \u001b[0m\u001b[38;5;134mWARNING \u001b[0m \u001b[1;38;5;251m Env. variable NUMEXPR_NUM_THREADS is not set. Please set it to \u001b[0m\u001b[1;37m1\u001b[0m\u001b[1;38;5;251m for optimal \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b]8;id=370463;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py\u001b\\\u001b[2m__init__.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=322125;file:///home/abhi/anaconda3/envs/cosipy/lib/python3.10/site-packages/threeML/__init__.py#387\u001b\\\u001b[2m387\u001b[0m\u001b]8;;\u001b\\\n", + "\u001b[38;5;46m \u001b[0m \u001b[1;38;5;251mperformances in 3ML \u001b[0m\u001b[1;38;5;251m \u001b[0m\u001b[2m \u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING: Cosipy import failed. Using local fallback interfaces.\n" + ] + } + ], + "source": [ + "from cosipy import BinnedData\n", + "from cosipy.data_io import UnBinnedData\n", + "from astropy.io import fits\n", + "\n", + "from time_selector import TimeSelector\n", + "from phase_selector import PhaseSelector\n", + "from plot_pulse_profile import PlotPulseProfile\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **`# fetch_wasabi_file(...)`**: They use a custom function to download the unbinned Crab source data and Albedo background data FITS files from a remote Wasabi cloud storage bucket to a local directory." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fetch_wasabi_file('COSI-SMEX/DC2/Data/Sources/Crab_DC2_3months_unbinned_data.fits.gz', output=str('Crab_DC2_3months_unbinned_data.fits.gz'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fetch_wasabi_file('COSI-SMEX/DC2/Data/Backgrounds/albedo_photons_3months_unbinned_data.fits.gz', output=str(\"albedo_photons_3months_unbinned_data.fits.gz\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fetch_wasabi_file('COSI-SMEX/DC2/Data/Orientation/20280301_3_month_with_orbital_info.ori', output=str('20280301_3_month_with_orbital_info.ori'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **`analysis.combine_unbinned_data(...)`**: It shows how to use the `cosipy` analysis object to merge the unbinned Crab data and Albedo background data into a single FITS file named \"crab_with_albedo_background\"." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "analysis.combine_unbinned_data([\"Crab_DC2_3months_unbinned_data.fits.gz\",\"albedo_photons_3months_unbinned_data.fits.gz\"], output_name=\"crab_with_albedo_background\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **`met_start = 1835478000.0`**: Defines the starting timestamp for the data slice using Mission Elapsed Time (MET) in seconds.\n", + "* **`met_stop = met_start + 86400.0`**: Calculates the stopping timestamp by adding 1 days (where 1 day = 86,400 seconds) to the start time.\n", + "* **`for f_in, f_out in [...]`**: Initiates a loop to process two pairs of files: the Crab data and the Albedo background data, assigning input and output filenames.\n", + "* **`with fits.open(f_in) as hdul:`**: Safely opens the input FITS file as an HDUList (Header Data Unit List) ensuring it closes automatically when done.\n", + "* **`data = hdul[1].data`**: Extracts the actual event data table, which is typically stored in the first extension (index 1) of the FITS file.\n", + "* **`mask = (data['TimeTags'] >= met_start) & (data['TimeTags'] <= met_stop)`**: Creates a boolean array (mask) that is `True` only for rows where the 'TimeTags' column falls within the defined 10-day MET window.\n", + "* **`new_hdu = fits.BinTableHDU(data[mask], header=hdul[1].header)`**: Creates a new FITS binary table containing only the filtered data while copying over the original header metadata.\n", + "* **`fits.HDUList([hdul[0], new_hdu]).writeto(f_out, overwrite=True)`**: Packages the original primary header (`hdul[0]`) and the newly filtered table into a new FITS file and saves it to disk, overwriting any existing file with the same name.\n", + "* **`print(...)`**: Outputs a status message to the console showing the name of the created file and the number of events it contains." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Slice created: crab_1d.fits (831909 events)\n", + "Slice created: albedo_1d.fits (5241280 events)\n" + ] + } + ], + "source": [ + "met_start = 1835478000.0\n", + "met_stop = met_start + 86400.0\n", + "\n", + "for f_in, f_out in [(\"Crab_DC2_3months_unbinned_data.fits\", \"crab_1d.fits\"), \n", + " (\"albedo_photons_3months_unbinned_data.fits\", \"albedo_1d.fits\")]:\n", + " with fits.open(f_in) as hdul:\n", + " data = hdul[1].data\n", + " mask = (data['TimeTags'] >= met_start) & (data['TimeTags'] <= met_stop)\n", + " \n", + " new_hdu = fits.BinTableHDU(data[mask], header=hdul[1].header)\n", + " fits.HDUList([hdul[0], new_hdu]).writeto(f_out, overwrite=True)\n", + " print(f\"Slice created: {f_out} ({mask.sum()} events)\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **`analysis = BinnedData(\"inputs.yaml\")`**: Initializes a COSI analysis object, loading the necessary configuration parameters from the \"inputs.yaml\" file.\n", + "* **`analysis.combine_unbinned_data([\"crab_1d.fits\", \"albedo_1d.fits\"], output_name=\"crab_with_albedo_1d\")`**: Takes the two locally sliced FITS files (Crab and Albedo) and merges them into a single comprehensive dataset named \"crab_with_albedo_1d\"." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "adding crab_1d.fits...\n", + "\n", + "\n", + "adding albedo_1d.fits...\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: VerifyWarning: Keyword name 'data file' is greater than 8 characters or contains characters not allowed by the FITS standard; a HIERARCH card will be created. [astropy.io.fits.card]\n" + ] + } + ], + "source": [ + "analysis = BinnedData(\"inputs.yaml\")\n", + "analysis.combine_unbinned_data([\"crab_1d.fits\", \"albedo_1d.fits\"], output_name=\"crab_with_albedo_1d\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **`import phase_assigner as pa`**: Imports the custom module responsible for calculating pulsar phases.\n", + "* **`ephemeris_file = \"crab.par\"`**: Sets the filepath to the ephemeris parameter file, which contains the precise timing information (like frequency and derivatives) for the Crab pulsar.\n", + "* **`input_fits_file = ...`**: Defines the target FITS file that needs pulsar phases assigned.\n", + "* **`output_fits_file = ...`**: Defines the name of the new FITS file that will contain the original data plus the new phase column.\n", + "* **`assigner = pa.PhaseAssigner(ephemeris_file)`**: Initializes the phase assigner object, passing in the ephemeris data so it knows the pulsar's timing model.\n", + "* **`print(f\"Pulsar Frequency: {assigner.f0:.6f} Hz\")`**: Prints the base spin frequency of the pulsar extracted from the `.par` file for verification.\n", + "* **`assigner.add_phase_column(input_fits_file, output_fits_file)`**: Reads the input FITS file, calculates the exact rotational phase (0.0 to 1.0) for every photon based on its arrival time, adds this as a new 'PULSE_PHASE' column, and writes the result to the output file.\n", + "* **`print(...)`**: Prints a success message confirming the new file was created." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:phase_assigner:Creating PULSE_PHASE column.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pulsar Frequency: 29.946923 Hz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:phase_assigner:Saved: crab_with_albedo_1d_with_pulse_phase_column.fits\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done! Created: crab_with_albedo_1d_with_pulse_phase_column.fits\n" + ] + } + ], + "source": [ + "import phase_assigner as pa\n", + "\n", + "ephemeris_file = \"crab.par\"\n", + "input_fits_file = \"crab_with_albedo_1d.fits\"\n", + "output_fits_file = \"crab_with_albedo_1d_with_pulse_phase_column.fits\"\n", + "\n", + "assigner = pa.PhaseAssigner(ephemeris_file)\n", + "print(f\"Pulsar Frequency: {assigner.f0:.6f} Hz\")\n", + "\n", + "assigner.add_phase_column(input_fits_file, output_fits_file)\n", + "\n", + "print(f\"Done! Created: {output_fits_file}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pulsar Frequency: 29.946923 Hz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:phase_assigner:Creating PULSE_PHASE column.\n", + "INFO:phase_assigner:Saved: albedo_1d_with_pulse_phase_column.fits\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done! Created: albedo_1d_with_pulse_phase_column.fits\n" + ] + } + ], + "source": [ + "ephemeris_file = \"crab.par\"\n", + "input_fits_file = \"albedo_1d.fits\"\n", + "output_fits_file = \"albedo_1d_with_pulse_phase_column.fits\"\n", + "\n", + "assigner = pa.PhaseAssigner(ephemeris_file)\n", + "print(f\"Pulsar Frequency: {assigner.f0:.6f} Hz\")\n", + "\n", + "assigner.add_phase_column(input_fits_file, output_fits_file)\n", + "\n", + "print(f\"Done! Created: {output_fits_file}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:phase_assigner:Creating PULSE_PHASE column.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pulsar Frequency: 29.946923 Hz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:phase_assigner:Saved: crab_1d_with_pulse_phase_column.fits\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done! Created: crab_1d_with_pulse_phase_column.fits\n" + ] + } + ], + "source": [ + "ephemeris_file = \"crab.par\"\n", + "input_fits_file = \"crab_1d.fits\"\n", + "output_fits_file = \"crab_1d_with_pulse_phase_column.fits\"\n", + "\n", + "assigner = pa.PhaseAssigner(ephemeris_file)\n", + "print(f\"Pulsar Frequency: {assigner.f0:.6f} Hz\")\n", + "\n", + "assigner.add_phase_column(input_fits_file, output_fits_file)\n", + "\n", + "print(f\"Done! Created: {output_fits_file}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **`filename = \"crab_with_albedo_1d_with_pulse_phase_column.fits\"`**: Sets the variable to the combined data file that now includes the calculated pulse phases.\n", + "* **`with fits.open(filename) as hdul:`**: Safely opens the FITS file.\n", + "* **`pp = PlotPulseProfile(hdul[1].data)`**: Initializes the custom plotting class, feeding it the raw event table containing the phases.\n", + "* **`pp.plot()`**: Triggers the function to generate and display the folded light curve (pulse profile) plot." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "filename = \"crab_with_albedo_1d_with_pulse_phase_column.fits\"\n", + "with fits.open(filename) as hdul:\n", + " pp = PlotPulseProfile(hdul[1].data)\n", + " pp.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **`pstart = ...`**: Defines the starting phase of the selection window (e.g., 0.70 for the start of the on-pulse).\n", + "* **`pstop = ...`**: Defines the stopping phase of the selection window (e.g., 1.30, which the class will internally wrap/normalize to 0.30).\n", + "* **`ephemeris = \"crab.par\"`**: Specifies the parameter file to ensure the selector has the correct timing context.\n", + "* **`input_fits = ...`**: Specifies the FITS file containing the events and their assigned phases.\n", + "* **`phase_sel = PhaseSelector(ephemeris, pstart, pstop)`**: Initializes the selector object with the timing parameters and the desired phase window boundaries.\n", + "* **`on_pulse_events = phase_sel.filter_events(input_fits, output_fits=...)`**: Reads the input file, isolates only the photons whose 'PULSE_PHASE' falls within the specified `pstart` to `pstop` range, and saves this subset to the newly specified output FITS file." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:phase_selector:Auto-loading events from FITS: crab_with_albedo_1d_with_pulse_phase_column.fits\n", + "INFO:phase_selector:Saving 34442449 events to crab_on_pulse_w_albedo.fits...\n", + "INFO:phase_selector:Successfully saved: crab_on_pulse_w_albedo.fits\n" + ] + } + ], + "source": [ + "pstart = 0.70\n", + "pstop = 1.30 # Will be normalized to 0.30\n", + "ephemeris = \"crab.par\"\n", + "input_fits = \"crab_with_albedo_1d_with_pulse_phase_column.fits\"\n", + "\n", + "phase_sel = PhaseSelector(ephemeris, pstart, pstop)\n", + "\n", + "on_pulse_events = phase_sel.filter_events(\n", + " input_fits, \n", + " output_fits=\"crab_on_pulse_w_albedo.fits\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:phase_selector:Auto-loading events from FITS: albedo_1d_with_pulse_phase_column.fits\n", + "INFO:phase_selector:Saving 29300978 events to on_pulse_only_albedo.fits...\n", + "INFO:phase_selector:Successfully saved: on_pulse_only_albedo.fits\n" + ] + } + ], + "source": [ + "pstart = 0.70\n", + "pstop = 1.30 \n", + "ephemeris = \"crab.par\"\n", + "input_fits = \"albedo_1d_with_pulse_phase_column.fits\"\n", + "\n", + "phase_sel = PhaseSelector(ephemeris, pstart, pstop)\n", + "\n", + "on_pulse_events = phase_sel.filter_events(\n", + " input_fits, \n", + " output_fits=\"on_pulse_only_albedo.fits\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:phase_selector:Auto-loading events from FITS: crab_1d_with_pulse_phase_column.fits\n", + "INFO:phase_selector:Saving 5141471 events to crab_1d_onpulse.fits...\n", + "INFO:phase_selector:Successfully saved: crab_1d_onpulse.fits\n" + ] + } + ], + "source": [ + "pstart = 0.70\n", + "pstop = 1.30 \n", + "ephemeris = \"crab.par\"\n", + "input_fits = \"crab_1d_with_pulse_phase_column.fits\"\n", + "\n", + "phase_sel = PhaseSelector(ephemeris, pstart, pstop)\n", + "\n", + "on_pulse_events = phase_sel.filter_events(\n", + " input_fits, \n", + " output_fits=\"crab_1d_onpulse.fits\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:phase_selector:Auto-loading events from FITS: crab_with_albedo_1d_with_pulse_phase_column.fits\n", + "INFO:phase_selector:Saving 22162772 events to crab_off_pulse_w_albedo.fits...\n", + "INFO:phase_selector:Successfully saved: crab_off_pulse_w_albedo.fits\n" + ] + } + ], + "source": [ + "pstart = 0.30\n", + "pstop = 0.70\n", + "ephemeris = \"crab.par\"\n", + "input_fits = \"crab_with_albedo_1d_with_pulse_phase_column.fits\" \n", + "\n", + "phase_sel = PhaseSelector(ephemeris, pstart, pstop)\n", + "\n", + "on_pulse_events = phase_sel.filter_events(\n", + " input_fits,\n", + " output_fits=\"crab_off_pulse_w_albedo.fits\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "In this tutorial, we successfully processed raw, unbinned COSI data to assign rotational phases and extract specific phase intervals for the Crab pulsar and its corresponding albedo background. \n", + "\n", + "By isolating the `on-pulse` and `off-pulse` regions into separate FITS files, the data is now fully prepared for downstream scientific analysis. Specifically, these newly created files can be plugged directly into `cosipy` to perform a rigorous **Spectral Fit** for the Crab pulsar. This will allow you to characterize its high-energy emission spectrum and analyze the background-subtracted source components with precision." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cosipy", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.19" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/tutorials/phase_resolved_analysis/inputs.yaml b/docs/tutorials/phase_resolved_analysis/inputs.yaml new file mode 100644 index 000000000..3de4ec2a8 --- /dev/null +++ b/docs/tutorials/phase_resolved_analysis/inputs.yaml @@ -0,0 +1,30 @@ +--- +#----------# +# Data I/O: + +# data files available on the COSI Sharepoint: https://drive.google.com/drive/folders/1UdLfuLp9Fyk4dNussn1wt7WEOsTWrlQ6 +# data_file: "/disk2/abhi/cosipy_pulsar_analysis/crab/Crab_notebook_copy_for_our_data/Crab_DC2_3months_unbinned_data_w_PULSE_PHASE.fits.gz" # full path +# data_file: "/disk2/abhi/cosipy_pulsar_analysis/crab/Crab_notebook_copy_for_our_data/Crab_AlbedoPhotons_DC3_3months_unbinned_data.fits.gz" +data_file: "crab_on_pulse_w_albedo.fits" +ori_file: "20280301_3_month_with_orbital_info.ori" # full path +unbinned_output: "fits" # 'fits' or 'hdf5' +time_bins: 3600 # time bin size in seconds. Takes int, float, or list of bin edges. +energy_bins: [ + 100., + 158.489, + 251.189, + 398.107, + 630.957, + 1000., + 1584.89, + 2511.89, + 3981.07, + 6309.57, + 10000., + ] # Takes list. Needs to match response. +phi_pix_size: 5 # binning of Compton scattering anlge [deg] +nside: 8 # healpix binning of psi chi local +scheme: "ring" # healpix binning of psi chi local +tmin: 1835478000.0 # Min time cut in seconds. +tmax: 1836351300.0 # Max time cut in seconds. +#----------#