From 545dccf9b73d1c9794e7f47821a1331c3b18bc86 Mon Sep 17 00:00:00 2001 From: Meet Vyas <87984759+Meet-Vyas-Dev@users.noreply.github.com> Date: Sat, 12 Jul 2025 18:32:08 +0530 Subject: [PATCH 1/2] Add RT Model simulation notebook and output archive Introduced RT_Model_simulations.ipynb for microlensing light curve simulations and integration with RTModel, including data download, extraction, and repository setup steps. Added output.tar.xz archive containing simulation data for analysis which can be used to run on any cluster. --- .gitattributes | 1 + .../RT_Model_simulations.ipynb | 4164 +++++++++++++++++ group_4_ampel_filter/output.tar.xz | 3 + 3 files changed, 4168 insertions(+) create mode 100644 .gitattributes create mode 100644 group_4_ampel_filter/RT_Model_simulations.ipynb create mode 100644 group_4_ampel_filter/output.tar.xz diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..51c7726 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +output.tar.xz filter=lfs diff=lfs merge=lfs -text diff --git a/group_4_ampel_filter/RT_Model_simulations.ipynb b/group_4_ampel_filter/RT_Model_simulations.ipynb new file mode 100644 index 0000000..d81a40c --- /dev/null +++ b/group_4_ampel_filter/RT_Model_simulations.ipynb @@ -0,0 +1,4164 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fd15ca06", + "metadata": {}, + "source": [ + "### Real-Time Modelling of Simulations using [RTModel](https://github.com/valboz/RTModel) for the LSST Vera C. Rubin Microlensing Subgroup, for the Purpose of Developing a Microlensing Filter using the AMPEL Broker. The RTModel Paper (A&A, 2024) can be accessed [here](https://www.aanda.org/articles/aa/pdf/2024/08/aa50450-24.pdf). \n", + "\n", + "- This notebook presents microlensing light curve simulations toward the Galactic Bulge, developed using the PyLIMA package (Bachelet et al.). The simulations were originally produced by Daniel Goldiens, Anibal Varela, and members of the LSST Microlensing Subgroup.\n", + "\n", + "- The current notebook was developed during the LSST Microlensing Subgroup Sprint Week by Meet J. Vyas, with significant support from Stela Ishitani Silva (for contributions to the notebook implementation and RTModel integration).\n", + "\n", + "- We gratefully acknowledge Markus Hundertmark for his valuable discussions and guidance on microlensing filter criteria, and the broader microlensing subgroup for their insightful suggestions and feedback throughout the development process." + ] + }, + { + "cell_type": "markdown", + "id": "34945117", + "metadata": {}, + "source": [ + "> #### 1. We will first download the tar zip from the google drive link using the python library gdown " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "892b76c5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading...\n", + "From (original): https://drive.google.com/uc?id=1-arXORvd7EGYeI0xA1gz_1O_kzUoCMEk\n", + "From (redirected): https://drive.google.com/uc?id=1-arXORvd7EGYeI0xA1gz_1O_kzUoCMEk&confirm=t&uuid=ccef2672-2fde-4ff4-b1ed-61fb4266c0eb\n", + "To: c:\\Users\\Meet\\OneDrive\\Desktop\\Summer 2025\\RTModel\\jupyter\\downloaded_file.tar.xz\n", + "100%|██████████| 514M/514M [01:39<00:00, 5.16MB/s] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extraction complete!\n" + ] + } + ], + "source": [ + "import gdown\n", + "import tarfile\n", + "\n", + "# Google Drive file ID\n", + "file_id = '1-arXORvd7EGYeI0xA1gz_1O_kzUoCMEk'\n", + "url = f'https://drive.google.com/uc?id={file_id}'\n", + "\n", + "# Correct output filename\n", + "output = 'downloaded_file.tar.xz'\n", + "\n", + "# Download\n", + "gdown.download(url, output, quiet=False)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "293a40aa", + "metadata": {}, + "source": [ + "> #### 2. Once the file is downloaded we then unzip it using tar " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ee1ddd68", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract the file \n", + "with tarfile.open(output, 'r:xz') as tar_ref:\n", + " tar_ref.extractall('./downloaded_file')\n", + " print(\"Extraction complete!\")" + ] + }, + { + "cell_type": "markdown", + "id": "4883fcb9", + "metadata": {}, + "source": [ + "> #### 3. Clone the RT Model Repository" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "712f9cf4", + "metadata": {}, + "outputs": [], + "source": [ + "!git clone https://github.com/valboz/RTModel.git" + ] + }, + { + "cell_type": "markdown", + "id": "9369a747", + "metadata": {}, + "source": [ + "> ##### 3.1 Once the RT Model is cloned, we can now build the library by changing the directory to the RT Model repository and then building the package through python package installer (pip)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dfbf42f0", + "metadata": {}, + "outputs": [], + "source": [ + "!cd RTModel\n", + "!pip install -e ." + ] + }, + { + "cell_type": "markdown", + "id": "e08ec23d", + "metadata": {}, + "source": [ + "> #### 4. Check the size and shape of the data by looking at the simulations" + ] + }, + { + "cell_type": "markdown", + "id": "d03d386d", + "metadata": {}, + "source": [ + "> #### 4.1 First print the total number of simulations in all the three folders" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9cf48806", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FSPL Simulations: 38030\n", + "PSPL Simulations: 35787\n", + "USBL Simulations: 12767\n", + "Total Simulations: 86584\n" + ] + } + ], + "source": [ + "import os\n", + "\n", + "# --- Define folder paths ---\n", + "fspl_dir = 'downloaded_file/microlensing_lightcurves/FSPL'\n", + "pspl_dir = 'downloaded_file/microlensing_lightcurves/PSPL'\n", + "usbl_dir = 'downloaded_file/microlensing_lightcurves/USBL'\n", + "\n", + "# --- Count .npz files in each directory ---\n", + "def count_npz_files(directory):\n", + " return len([f for f in os.listdir(directory) if f.endswith('.npz')])\n", + "\n", + "fspl_count = count_npz_files(fspl_dir)\n", + "pspl_count = count_npz_files(pspl_dir)\n", + "usbl_count = count_npz_files(usbl_dir)\n", + "\n", + "total_count = fspl_count + pspl_count + usbl_count\n", + "\n", + "# --- Print results ---\n", + "print(f\"FSPL Simulations: {fspl_count}\")\n", + "print(f\"PSPL Simulations: {pspl_count}\")\n", + "print(f\"USBL Simulations: {usbl_count}\")\n", + "print(f\"Total Simulations: {total_count}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "d856daa2", + "metadata": {}, + "source": [ + "> #### 4.2 We shall look at the contents of a sample file for each folder " + ] + }, + { + "cell_type": "markdown", + "id": "f1b4127a", + "metadata": {}, + "source": [ + "> #### 4.2.1 Print the keys for a sample FSPL event" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "820f8f57", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Keys in the file: ['event_id', 'fblend_W149', 'fblend_g', 'fblend_i', 'fblend_r', 'fblend_u', 'fblend_y', 'fblend_z', 'fsource_W149', 'fsource_g', 'fsource_i', 'fsource_r', 'fsource_u', 'fsource_y', 'fsource_z', 'ftotal_W149', 'ftotal_g', 'ftotal_i', 'ftotal_r', 'ftotal_u', 'ftotal_y', 'ftotal_z', 'gblend_W149', 'gblend_g', 'gblend_i', 'gblend_r', 'gblend_u', 'gblend_y', 'gblend_z', 'piEE', 'piEN', 'rho', 't0', 'tE', 'u0', 'u_time', 'u_flux', 'u_err_flux', 'u_mag', 'u_err_mag', 'g_time', 'g_flux', 'g_err_flux', 'g_mag', 'g_err_mag', 'r_time', 'r_flux', 'r_err_flux', 'r_mag', 'r_err_mag', 'i_time', 'i_flux', 'i_err_flux', 'i_mag', 'i_err_mag', 'z_time', 'z_flux', 'z_err_flux', 'z_mag', 'z_err_mag', 'y_time', 'y_flux', 'y_err_flux', 'y_mag', 'y_err_mag']\n", + "\n", + "Key: event_id\n", + "Shape: ()\n", + "Data Type: #### 4.2.2 Print the keys for a sample PSPL event" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a30b0a92", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Keys in the file: ['event_id', 'fblend_W149', 'fblend_g', 'fblend_i', 'fblend_r', 'fblend_u', 'fblend_y', 'fblend_z', 'fsource_W149', 'fsource_g', 'fsource_i', 'fsource_r', 'fsource_u', 'fsource_y', 'fsource_z', 'ftotal_W149', 'ftotal_g', 'ftotal_i', 'ftotal_r', 'ftotal_u', 'ftotal_y', 'ftotal_z', 'gblend_W149', 'gblend_g', 'gblend_i', 'gblend_r', 'gblend_u', 'gblend_y', 'gblend_z', 'piEE', 'piEN', 't0', 'tE', 'u0', 'g_time', 'g_flux', 'g_err_flux', 'g_mag', 'g_err_mag', 'r_time', 'r_flux', 'r_err_flux', 'r_mag', 'r_err_mag', 'i_time', 'i_flux', 'i_err_flux', 'i_mag', 'i_err_mag', 'z_time', 'z_flux', 'z_err_flux', 'z_mag', 'z_err_mag', 'y_time', 'y_flux', 'y_err_flux', 'y_mag', 'y_err_mag']\n", + "\n", + "Key: event_id\n", + "Shape: ()\n", + "Data Type: #### 4.2.3 Print the keys for a sample USBL event" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1d7650af", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Keys in the file: ['event_id', 'alpha', 'fblend_W149', 'fblend_g', 'fblend_i', 'fblend_r', 'fblend_u', 'fblend_y', 'fblend_z', 'fsource_W149', 'fsource_g', 'fsource_i', 'fsource_r', 'fsource_u', 'fsource_y', 'fsource_z', 'ftotal_W149', 'ftotal_g', 'ftotal_i', 'ftotal_r', 'ftotal_u', 'ftotal_y', 'ftotal_z', 'gblend_W149', 'gblend_g', 'gblend_i', 'gblend_r', 'gblend_u', 'gblend_y', 'gblend_z', 'mass_ratio', 'piEE', 'piEN', 'rho', 'separation', 't0', 'tE', 't_center', 'u0', 'u_center', 'u_time', 'u_flux', 'u_err_flux', 'u_mag', 'u_err_mag', 'g_time', 'g_flux', 'g_err_flux', 'g_mag', 'g_err_mag', 'r_time', 'r_flux', 'r_err_flux', 'r_mag', 'r_err_mag', 'i_time', 'i_flux', 'i_err_flux', 'i_mag', 'i_err_mag', 'z_time', 'z_flux', 'z_err_flux', 'z_mag', 'z_err_mag', 'y_time', 'y_flux', 'y_err_flux', 'y_mag', 'y_err_mag']\n", + "\n", + "Key: event_id\n", + "Shape: ()\n", + "Data Type: #### 4.3 We can also look at the lightcurves of all three event types by generating random light curves for each event given the criterion that we only select events with more than 10 points and 3 filters" + ] + }, + { + "cell_type": "markdown", + "id": "7a9b0111", + "metadata": {}, + "source": [ + "> #### 4.3.1 We first generate a random lightcurve for the FSPL events" + ] + }, + { + "cell_type": "markdown", + "id": "616d5f53", + "metadata": {}, + "source": [ + "### Code Explanation\n", + "\n", + "#### Objective\n", + "- This notebook visualizes a random FSPL (Finite Source Point Lens) microlensing event from a set of simulation files. The purpose is to:\n", + " - Select a scientifically valid event that meets minimum data quality requirements.\n", + " - Plot the light curve in multiple filters centered on the peak event time.\n", + "\n", + "- Event Selection Criteria\n", + " - From a directory of .npz files, a random FSPL event is selected that satisfies the following:\n", + " - Contains at least 10 photometric points within ±3 × Einstein timescale (t_E) of the event peak (t₀).\n", + " - Has data available in at least 3 different photometric filters (from u, g, r, i, z, y).\n", + "\n", + "#### Parameters Used\n", + "- $t_{0}$: Time of maximum magnification (event center)\n", + "\n", + "- $t_{E}$: Einstein crossing time (characteristic duration of the event)\n", + "\n", + "- $u_{0}$: Minimum impact parameter (source-lens separation in units of Einstein radius)\n", + "\n", + "#### Plot Description\n", + "\n", + "- The selected event's light curve is plotted as follows:\n", + " - X-axis: Time in days, relative to t₀, i.e., (t - t₀)\n", + " - Y-axis: Observed magnitude (inverted so that brighter objects appear higher)\n", + " - Markers: Each filter’s photometric measurements are shown with error bars.\n", + " - A vertical dashed line at t = 0 marks the event peak.\n", + " - An annotation box provides the event-specific values of t_E and u₀.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "796e7852", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "import random\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# --- Path to your FSPL directory ---\n", + "fspl_dir = 'downloaded_file/microlensing_lightcurves/FSPL'\n", + "\n", + "# --- Create a directory to save the plots ---\n", + "save_dir = \"lightcurve_plots/FSPL\"\n", + "os.makedirs(save_dir, exist_ok=True)\n", + "\n", + "# --- List all available .npz files ---\n", + "all_files = [f for f in os.listdir(fspl_dir) if f.endswith('.npz')]\n", + "if not all_files:\n", + " raise FileNotFoundError(\"No .npz files found in FSPL folder.\")\n", + "\n", + "# --- Try random files until a valid one is found ---\n", + "valid_file = None\n", + "while all_files:\n", + " candidate = random.choice(all_files)\n", + " file_path = os.path.join(fspl_dir, candidate)\n", + " data = np.load(file_path)\n", + "\n", + " t0 = float(data['t0'])\n", + " tE = float(data['tE'])\n", + " u0 = float(data['u0'])\n", + " zoom_range = 3 * tE\n", + "\n", + " filters = ['u', 'g', 'r', 'i', 'z', 'y']\n", + " filter_count = 0\n", + " total_points = 0\n", + "\n", + " for f in filters:\n", + " try:\n", + " t = data[f\"{f}_time\"] - t0\n", + " mag = data[f\"{f}_mag\"]\n", + " err_mag = data[f\"{f}_err_mag\"]\n", + " mask = (t >= -zoom_range) & (t <= zoom_range)\n", + " n_points = np.sum(mask)\n", + " if n_points >= 1:\n", + " filter_count += 1\n", + " total_points += n_points\n", + " except KeyError:\n", + " continue\n", + "\n", + " if total_points >= 10 and filter_count >= 3:\n", + " valid_file = file_path\n", + " break\n", + " else:\n", + " all_files.remove(candidate)\n", + "\n", + "if valid_file is None:\n", + " raise RuntimeError(\"No valid FSPL event found with ≥10 points in ≥3 filters.\")\n", + "\n", + "# --- Plotting ---\n", + "data = np.load(valid_file)\n", + "t0 = float(data['t0'])\n", + "tE = float(data['tE'])\n", + "u0 = float(data['u0'])\n", + "zoom_range = 3 * tE\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "for f in filters:\n", + " try:\n", + " t = data[f\"{f}_time\"] - t0\n", + " mag = data[f\"{f}_mag\"]\n", + " err_mag = data[f\"{f}_err_mag\"]\n", + "\n", + " mask = (t >= -zoom_range) & (t <= zoom_range)\n", + " if np.sum(mask) == 0:\n", + " continue\n", + "\n", + " t = t[mask]\n", + " mag = mag[mask]\n", + " err_mag = err_mag[mask]\n", + "\n", + " plt.errorbar(t, mag, yerr=err_mag, fmt='.', label=f\"{f}-band\")\n", + " except KeyError:\n", + " continue\n", + "\n", + "plt.axvline(0, color='gray', linestyle='--', label='$t_0$')\n", + "plt.xlabel(\"Time [days relative to $t_0$]\")\n", + "plt.ylabel(\"Magnitude\")\n", + "plt.title(f\"Random FSPL Event: {os.path.basename(valid_file)}\")\n", + "plt.gca().invert_yaxis()\n", + "plt.grid(True)\n", + "plt.legend()\n", + "\n", + "plt.text(0.02, 0.95, f\"$t_E$ = {tE:.2f} d\\n$u_0$ = {u0:.3f}\", \n", + " transform=plt.gca().transAxes, fontsize=10, va='top', ha='left',\n", + " bbox=dict(boxstyle=\"round\", facecolor=\"white\", alpha=0.8))\n", + "\n", + "plt.tight_layout()\n", + "event_name = os.path.splitext(os.path.basename(valid_file))[0]\n", + "save_path = os.path.join(save_dir, f\"{event_name}.png\")\n", + "plt.savefig(save_path)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "a423b01f", + "metadata": {}, + "source": [ + "> #### 4.3.2 Now we generate a random lightcurve for the PSPL events" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1401c70", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "import random\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "pspl_dir = 'downloaded_file/microlensing_lightcurves/PSPL'\n", + "\n", + "# --- Create a directory to save the plots ---\n", + "save_dir = \"lightcurve_plots/PSPL\"\n", + "os.makedirs(save_dir, exist_ok=True)\n", + "\n", + "all_files = [f for f in os.listdir(pspl_dir) if f.endswith('.npz')]\n", + "if not all_files:\n", + " raise FileNotFoundError(\"No .npz files found in PSPL folder.\")\n", + "\n", + "valid_file = None\n", + "while all_files:\n", + " candidate = random.choice(all_files)\n", + " file_path = os.path.join(pspl_dir, candidate)\n", + " data = np.load(file_path)\n", + "\n", + " try:\n", + " t0 = float(data['t0'])\n", + " tE = float(data['tE'])\n", + " u0 = float(data['u0'])\n", + " except KeyError:\n", + " all_files.remove(candidate)\n", + " continue\n", + "\n", + " filters = ['g', 'r', 'i', 'z', 'y']\n", + " zoom_range = 3 * tE\n", + " total_points = 0\n", + " filter_count = 0\n", + "\n", + " for f in filters:\n", + " try:\n", + " t = data[f\"{f}_time\"] - t0\n", + " mask = (t >= -zoom_range) & (t <= zoom_range)\n", + " if np.sum(mask) > 0:\n", + " filter_count += 1\n", + " total_points += np.sum(mask)\n", + " except KeyError:\n", + " continue\n", + "\n", + " if total_points >= 10 and filter_count >= 3:\n", + " valid_file = file_path\n", + " break\n", + " else:\n", + " all_files.remove(candidate)\n", + "\n", + "if valid_file is None:\n", + " raise RuntimeError(\"No valid PSPL event found.\")\n", + "\n", + "# --- Plotting ---\n", + "data = np.load(valid_file)\n", + "t0 = float(data['t0'])\n", + "tE = float(data['tE'])\n", + "u0 = float(data['u0'])\n", + "zoom_range = 3 * tE\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "for f in filters:\n", + " try:\n", + " t = data[f\"{f}_time\"] - t0\n", + " mag = data[f\"{f}_mag\"]\n", + " err_mag = data[f\"{f}_err_mag\"]\n", + " mask = (t >= -zoom_range) & (t <= zoom_range)\n", + " if np.sum(mask) == 0:\n", + " continue\n", + " plt.errorbar(t[mask], mag[mask], yerr=err_mag[mask], fmt='.', label=f\"{f}-band\")\n", + " except KeyError:\n", + " continue\n", + "\n", + "plt.axvline(0, color='gray', linestyle='--', label='$t_0$')\n", + "plt.xlabel(\"Time [days relative to $t_0$]\")\n", + "plt.ylabel(\"Magnitude\")\n", + "plt.title(f\"Random PSPL Event: {os.path.basename(valid_file)}\")\n", + "plt.gca().invert_yaxis()\n", + "plt.grid(True)\n", + "plt.legend()\n", + "\n", + "# Annotation\n", + "plt.text(0.02, 0.95, f\"$t_E$ = {tE:.2f} d\\n$u_0$ = {u0:.3f}\",\n", + " transform=plt.gca().transAxes, fontsize=10, va='top', ha='left',\n", + " bbox=dict(boxstyle=\"round\", facecolor=\"white\", alpha=0.8))\n", + "\n", + "plt.tight_layout()\n", + "event_name = os.path.splitext(os.path.basename(valid_file))[0]\n", + "save_path = os.path.join(save_dir, f\"{event_name}.png\")\n", + "plt.savefig(save_path)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "f951868e", + "metadata": {}, + "source": [ + "> #### 4.3.3 Nopw we generate a random lightcurve for the USBL events" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf2e7978", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "import random\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "usbl_dir = 'downloaded_file/microlensing_lightcurves/USBL'\n", + "\n", + "# --- Create a directory to save the plots ---\n", + "save_dir = \"lightcurve_plots/USBL\"\n", + "os.makedirs(save_dir, exist_ok=True)\n", + "\n", + "all_files = [f for f in os.listdir(usbl_dir) if f.endswith('.npz')]\n", + "if not all_files:\n", + " raise FileNotFoundError(\"No .npz files found in USBL folder.\")\n", + "\n", + "valid_file = None\n", + "while all_files:\n", + " candidate = random.choice(all_files)\n", + " file_path = os.path.join(usbl_dir, candidate)\n", + " data = np.load(file_path)\n", + "\n", + " try:\n", + " t0 = float(data['t0'])\n", + " tE = float(data['tE'])\n", + " u0 = float(data['u0'])\n", + " except KeyError:\n", + " all_files.remove(candidate)\n", + " continue\n", + "\n", + " filters = ['u', 'g', 'r', 'i', 'z', 'y']\n", + " zoom_range = 3 * tE\n", + " total_points = 0\n", + " filter_count = 0\n", + "\n", + " for f in filters:\n", + " try:\n", + " t = data[f\"{f}_time\"] - t0\n", + " mask = (t >= -zoom_range) & (t <= zoom_range)\n", + " if np.sum(mask) > 0:\n", + " filter_count += 1\n", + " total_points += np.sum(mask)\n", + " except KeyError:\n", + " continue\n", + "\n", + " if total_points >= 10 and filter_count >= 3:\n", + " valid_file = file_path\n", + " break\n", + " else:\n", + " all_files.remove(candidate)\n", + "\n", + "if valid_file is None:\n", + " raise RuntimeError(\"No valid USBL event found.\")\n", + "\n", + "# --- Plotting ---\n", + "data = np.load(valid_file)\n", + "t0 = float(data['t0'])\n", + "tE = float(data['tE'])\n", + "u0 = float(data['u0'])\n", + "zoom_range = 3 * tE\n", + "\n", + "mass_ratio = data.get('mass_ratio', None)\n", + "separation = data.get('separation', None)\n", + "rho = data.get('rho', None)\n", + "alpha = data.get('alpha', None)\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "for f in filters:\n", + " try:\n", + " t = data[f\"{f}_time\"] - t0\n", + " mag = data[f\"{f}_mag\"]\n", + " err_mag = data[f\"{f}_err_mag\"]\n", + " mask = (t >= -zoom_range) & (t <= zoom_range)\n", + " if np.sum(mask) == 0:\n", + " continue\n", + " plt.errorbar(t[mask], mag[mask], yerr=err_mag[mask], fmt='.', label=f\"{f}-band\")\n", + " except KeyError:\n", + " continue\n", + "\n", + "plt.axvline(0, color='gray', linestyle='--', label='$t_0$')\n", + "plt.xlabel(\"Time [days relative to $t_0$]\")\n", + "plt.ylabel(\"Magnitude\")\n", + "plt.title(f\"Random USBL Event: {os.path.basename(valid_file)}\")\n", + "plt.gca().invert_yaxis()\n", + "plt.grid(True)\n", + "plt.legend()\n", + "\n", + "# --- Annotation box with USBL parameters ---\n", + "annotation = f\"$t_E$ = {tE:.2f} d\\n$u_0$ = {u0:.3f}\"\n", + "if mass_ratio is not None:\n", + " annotation += f\"\\n$q$ = {mass_ratio:.3f}\"\n", + "if separation is not None:\n", + " annotation += f\"\\n$s$ = {separation:.2f}\"\n", + "if rho is not None:\n", + " annotation += f\"\\n$\\\\rho$ = {rho:.3f}\"\n", + "if alpha is not None:\n", + " annotation += f\"\\n$\\\\alpha$ = {alpha:.2f}\"\n", + "\n", + "plt.text(0.02, 0.95, annotation,\n", + " transform=plt.gca().transAxes, fontsize=10, va='top', ha='left',\n", + " bbox=dict(boxstyle=\"round\", facecolor=\"white\", alpha=0.8))\n", + "\n", + "plt.tight_layout()\n", + "event_name = os.path.splitext(os.path.basename(valid_file))[0]\n", + "save_path = os.path.join(save_dir, f\"{event_name}.png\")\n", + "plt.savefig(save_path)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e62106e8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os\n", + "import random\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "usbl_dir = 'downloaded_file/microlensing_lightcurves/USBL'\n", + "\n", + "all_files = [f for f in os.listdir(usbl_dir) if f.endswith('.npz')]\n", + "if not all_files:\n", + " raise FileNotFoundError(\"No .npz files found in USBL folder.\")\n", + "\n", + "valid_file = None\n", + "while all_files:\n", + " candidate = random.choice(all_files)\n", + " file_path = os.path.join(usbl_dir, candidate)\n", + " data = np.load(file_path)\n", + "\n", + " try:\n", + " t0 = float(data['t0'])\n", + " tE = float(data['tE'])\n", + " u0 = float(data['u0'])\n", + " except KeyError:\n", + " all_files.remove(candidate)\n", + " continue\n", + "\n", + " filters = ['u', 'g', 'r', 'i', 'z', 'y']\n", + " zoom_range = 3 * tE\n", + " total_points = 0\n", + " filter_count = 0\n", + "\n", + " for f in filters:\n", + " try:\n", + " t = data[f\"{f}_time\"] - t0\n", + " mask = (t >= -zoom_range) & (t <= zoom_range)\n", + " if np.sum(mask) > 0:\n", + " filter_count += 1\n", + " total_points += np.sum(mask)\n", + " except KeyError:\n", + " continue\n", + "\n", + " if total_points >= 20 and filter_count >= 3:\n", + " valid_file = file_path\n", + " break\n", + " else:\n", + " all_files.remove(candidate)\n", + "\n", + "if valid_file is None:\n", + " raise RuntimeError(\"No valid USBL event found.\")\n", + "\n", + "# --- Plotting ---\n", + "data = np.load(valid_file)\n", + "t0 = float(data['t0'])\n", + "tE = float(data['tE'])\n", + "u0 = float(data['u0'])\n", + "zoom_range = 3 * tE\n", + "\n", + "mass_ratio = data.get('mass_ratio', None)\n", + "separation = data.get('separation', None)\n", + "rho = data.get('rho', None)\n", + "alpha = data.get('alpha', None)\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "for f in filters:\n", + " try:\n", + " t = data[f\"{f}_time\"] - t0\n", + " mag = data[f\"{f}_mag\"]\n", + " err_mag = data[f\"{f}_err_mag\"]\n", + " mask = (t >= -zoom_range) & (t <= zoom_range)\n", + " if np.sum(mask) == 0:\n", + " continue\n", + " plt.errorbar(t[mask], mag[mask], yerr=err_mag[mask], fmt='.', label=f\"{f}-band\")\n", + " except KeyError:\n", + " continue\n", + "\n", + "plt.axvline(0, color='gray', linestyle='--', label='$t_0$')\n", + "plt.xlabel(\"Time [days relative to $t_0$]\")\n", + "plt.ylabel(\"Magnitude\")\n", + "plt.title(f\"Random USBL Event: {os.path.basename(valid_file)}\")\n", + "plt.gca().invert_yaxis()\n", + "plt.grid(True)\n", + "plt.legend()\n", + "\n", + "# --- Annotation box with USBL parameters ---\n", + "annotation = f\"$t_E$ = {tE:.2f} d\\n$u_0$ = {u0:.3f}\"\n", + "if mass_ratio is not None:\n", + " annotation += f\"\\n$q$ = {mass_ratio:.3f}\"\n", + "if separation is not None:\n", + " annotation += f\"\\n$s$ = {separation:.2f}\"\n", + "if rho is not None:\n", + " annotation += f\"\\n$\\\\rho$ = {rho:.3f}\"\n", + "if alpha is not None:\n", + " annotation += f\"\\n$\\\\alpha$ = {alpha:.2f}\"\n", + "\n", + "plt.text(0.02, 0.95, annotation,\n", + " transform=plt.gca().transAxes, fontsize=10, va='top', ha='left',\n", + " bbox=dict(boxstyle=\"round\", facecolor=\"white\", alpha=0.8))\n", + "\n", + "plt.tight_layout()\n", + "plt.savefig(\"random_usbl_lightcurve.png\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "fcb87528", + "metadata": {}, + "source": [ + "> #### 5. Microlensing Lightcurve Data Conversion and Organization for running fits on RT Model \n", + "\n", + "This section of the workflow focuses on processing microlensing lightcurve data stored in `.npz` format. The purpose is to extract photometric data across multiple filters, convert galactic coordinates to equatorial coordinates, and organize the output data into structured folders with accompanying metadata.\n", + "\n", + "---\n", + "\n", + "### **Overview of the Workflow**\n", + "\n", + "- The input consists of multiple microlensing event models, specifically `FSPL`, `PSPL`, and `USBL`, each contained within its respective folder.\n", + "- Each folder contains `.npz` files, where each file represents a distinct microlensing event with photometric data across several filters: `u`, `g`, `r`, `i`, `z`, and `y`.\n", + "- The goal is to parse these files, convert the time series data into a human-readable `.dat` format, and write the sky coordinates for each event alongside the data.\n", + "\n", + "---\n", + "\n", + "### **Coordinate Conversion**\n", + "\n", + "- The script uses galactic coordinates `(l = 0.5°, b = -1.25°)` as input.\n", + "- These are converted into equatorial coordinates `(Right Ascension, Declination)` using Astropy's coordinate transformation tools.\n", + "- The resulting RA and Dec are formatted in a standardized string format: \n", + "`HH:MM:SS.S +DD:MM:SS.S`\n", + "- This coordinate information is saved into a file named `event.coordinates` for each event, ensuring that each dataset includes its precise sky position.\n", + "\n", + "---\n", + "\n", + "### **Directory and File Structure**\n", + "\n", + "- The output is organized into a main `output` folder within the parent directory.\n", + "- For each event (identified by its filename), a subfolder is created following the structure: \n", + "`output/EventName/Data/`\n", + "- Inside each `Data` folder:\n", + " - A `event.coordinates` file contains the RA and Dec.\n", + " - Separate `.dat` files exist for each photometric filter (`u`, `g`, `r`, `i`, `z`, `y`), named with the convention: \n", + " `RubinFilterband.dat`\n", + "\n", + "---\n", + "\n", + "### **Time Conversion**\n", + "\n", + "- The time data in the `.npz` files is originally in Julian Date (JD).\n", + "- To simplify, the script converts it to a relative Heliocentric Julian Date (HJD) by subtracting 2450000 from all time entries.\n", + "\n", + "---\n", + "\n", + "### **Data Format and File Contents**\n", + "\n", + "- Each output `.dat` file contains three columns:\n", + " 1. **Magnitude (Mag)** – The observed brightness in the specific filter.\n", + " 2. **Magnitude Error (err)** – The uncertainty associated with each magnitude measurement.\n", + " 3. **Time (HJD)** – The observation time in modified Heliocentric Julian Date.\n", + "\n", + "- A header line `# Mag err HJD` is included at the top of each file to indicate the column meanings.\n", + "\n", + "---\n", + "\n", + "### **Error Handling and Robustness**\n", + "\n", + "- The script is robust against missing data:\n", + " - If a specific filter's data is not present in a `.npz` file, the script detects it and prints a warning but continues processing the remaining filters.\n", + " - General exceptions such as failed file reads are caught and logged with an error message, ensuring that one problematic file does not halt the entire process.\n", + "\n", + "---\n", + "\n", + "### **Logging and Console Output**\n", + "\n", + "- Throughout execution, the script provides informative logs:\n", + " - It announces how many files are being processed for each event type.\n", + " - It confirms when coordinate files and photometric `.dat` files are successfully saved.\n", + " - It reports missing filters or any errors encountered during processing.\n", + "\n", + "---\n", + "\n", + "### **Final Directory Example**\n", + "\n", + "At the end of execution, the output folder looks like this:\n", + "\n", + "```\n", + "microlensing_lightcurves/\n", + "├── FSPL/\n", + "│ └── *.npz\n", + "├── PSPL/\n", + "│ └── *.npz\n", + "├── USBL/\n", + "│ └── *.npz\n", + "└── output/\n", + " ├── Event1/\n", + " │ └── Data/\n", + " │ ├── Rubinu.dat\n", + " │ ├── Rubing.dat\n", + " │ ├── ...\n", + " │ └── event.coordinates\n", + " └── Event2/\n", + " └── Data/\n", + " ├── ...\n", + "```\n", + "\n", + "---\n", + "\n", + "This process converts the microlensing lightcurve data for the RTModel runs by:\n", + "\n", + "- Converting raw `.npz` datasets into clean, readable `.dat` files.\n", + "- Including sky position metadata with each dataset.\n", + "- Structuring the outputs in an organized folder hierarchy for easy access and further scientific analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "83db01be", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Event Types: 0%| | 0/3 [00:00 ##### 5.1 Now we will tar compress this incase someone just wants to use the models on a cluster" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f73a860c", + "metadata": {}, + "outputs": [], + "source": [ + "# Compress with maximum efficiency\n", + "!tar -cJf output.tar.xz downloaded_file/microlensing_lightcurves/output" + ] + }, + { + "cell_type": "markdown", + "id": "9fe37301", + "metadata": {}, + "source": [ + "> #### 6. Import RT Model to start working with the model files" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "4f631242", + "metadata": {}, + "outputs": [], + "source": [ + "import RTModel" + ] + }, + { + "cell_type": "markdown", + "id": "2deb84ab", + "metadata": {}, + "source": [ + "> #### 7. Test the number of processors available to use for RTModel" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "fde4043c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*********************\n", + "**** RTModel ****\n", + "*********************\n", + "Number of processors: 16\n" + ] + } + ], + "source": [ + "rtm = RTModel.RTModel()" + ] + }, + { + "cell_type": "markdown", + "id": "f70938f6", + "metadata": {}, + "source": [ + "> #### 8. Run the event model for a sample event to check the fits" + ] + }, + { + "cell_type": "markdown", + "id": "f98c50e0", + "metadata": {}, + "source": [ + "> #### 8.1 Set the eventname " + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "c4fefe10", + "metadata": {}, + "outputs": [], + "source": [ + "eventname = r\"C:\\Users\\Meet\\OneDrive\\Desktop\\Summer 2025\\RTModel\\jupyter\\downloaded_file\\microlensing_lightcurves\\output\\FSPL_7\" \n", + "rtm.set_event(eventname)" + ] + }, + { + "cell_type": "markdown", + "id": "811904d9", + "metadata": {}, + "source": [ + "> #### 8.2 Run the event " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a63f91fc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "o Sat Jun 28 23:21:52 2025\n", + "- Analyzing event: C:\\Users\\Meet\\OneDrive\\Desktop\\Summer 2025\\RTModel\\jupyter\\downloaded_file\\microlensing_lightcurves\\output\\FSPL_7\n", + "- Launching: Reader\n", + " Pre-processing data...\n", + " OK\n", + "o Sat Jun 28 23:21:53 2025\n", + "- Launching: InitCond\n", + " Setting initial conditions...\n", + "Peaks: 11964.7500 13082.4700 \n", + " OK\n", + "o Sat Jun 28 23:21:53 2025\n", + "- Single-lens-Single-source fits\n", + "Fits completed: 53%|\u001b[32m█████▎ \u001b[0m| 64/120 [40:19<35:16, 37.80s/it] " + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mKeyboardInterrupt\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[19]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mrtm\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\OneDrive\\Desktop\\Summer 2025\\RTModel\\RTModel\\RTModel.py:453\u001b[39m, in \u001b[36mRTModel.run\u001b[39m\u001b[34m(self, event, cleanup)\u001b[39m\n\u001b[32m 451\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m phase%\u001b[32m2\u001b[39m == \u001b[32m1\u001b[39m:\n\u001b[32m 452\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m(\u001b[38;5;28mself\u001b[39m.InitCond_modelcategories == \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m.modelcodes[phase//\u001b[32m2\u001b[39m-\u001b[32m1\u001b[39m] \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m.InitCond_modelcategories):\n\u001b[32m--> \u001b[39m\u001b[32m453\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mlaunch_fits\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mmodelcodes\u001b[49m\u001b[43m[\u001b[49m\u001b[43mphase\u001b[49m\u001b[43m/\u001b[49m\u001b[43m/\u001b[49m\u001b[32;43m2\u001b[39;49m\u001b[43m-\u001b[49m\u001b[32;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m \n\u001b[32m 454\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mo \u001b[39m\u001b[33m\"\u001b[39m + time.asctime())\n\u001b[32m 455\u001b[39m phase += \u001b[32m1\u001b[39m \n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\OneDrive\\Desktop\\Summer 2025\\RTModel\\RTModel\\RTModel.py:351\u001b[39m, in \u001b[36mRTModel.launch_fits\u001b[39m\u001b[34m(self, modelcode)\u001b[39m\n\u001b[32m 349\u001b[39m pbar.update(finitcond - \u001b[38;5;28mmax\u001b[39m(finitcondold,\u001b[32m0\u001b[39m))\n\u001b[32m 350\u001b[39m finitcondold =finitcond\n\u001b[32m--> \u001b[39m\u001b[32m351\u001b[39m \u001b[43mtime\u001b[49m\u001b[43m.\u001b[49m\u001b[43msleep\u001b[49m\u001b[43m(\u001b[49m\u001b[32;43m0.1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 352\u001b[39m pbar.close()\n\u001b[32m 353\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m(crashes>\u001b[32m0\u001b[39m):\n", + "\u001b[31mKeyboardInterrupt\u001b[39m: " + ] + } + ], + "source": [ + "rtm.run()" + ] + }, + { + "cell_type": "markdown", + "id": "8105f7a1", + "metadata": {}, + "source": [ + "> #### 9. Run the model looping through all the possible events with atleast data files for 3 filters and 20 points" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f1b01589", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Skipping FSPL_10000 - only 1 filters available\n", + "Skipping FSPL_100000 - only 2 filters available\n", + "Skipping FSPL_100010 - only 1 filters available\n", + "Skipping FSPL_100018 - only 1 filters available\n", + "Skipping FSPL_100019 - only 1 filters available\n", + "Skipping FSPL_10002 - only 2 filters available\n", + "Skipping FSPL_100023 - only 1 filters available\n", + "Skipping FSPL_100028 - only 2 filters available\n", + "Skipping FSPL_100035 - only 1 filters available\n", + "Skipping FSPL_100042 - only 1 filters available\n", + "Skipping FSPL_100047 - only 1 filters available\n", + "Processing event: FSPL_100051 with 6 filters\n", + "o Sun Jun 29 00:17:13 2025\n", + "- Analyzing event: C:\\Users\\Meet\\OneDrive\\Desktop\\Summer 2025\\RTModel\\jupyter\\downloaded_file\\microlensing_lightcurves\\output\\FSPL_100051\n", + "- Launching: Reader\n", + " Pre-processing data...\n", + " OK\n", + "o Sun Jun 29 00:17:13 2025\n", + "- Launching: InitCond\n", + " Setting initial conditions...\n", + "Peaks: 13082.7800 11179.8400 \n", + " OK\n", + "o Sun Jun 29 00:17:14 2025\n", + "- Single-lens-Single-source fits\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mKeyboardInterrupt\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[21]\u001b[39m\u001b[32m, line 26\u001b[39m\n\u001b[32m 23\u001b[39m rtm.set_event(event_folder)\n\u001b[32m 25\u001b[39m \u001b[38;5;66;03m# Run the model for this event\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m26\u001b[39m \u001b[43mrtm\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 28\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 29\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mSkipping \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mos.path.basename(event_folder)\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m - only \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mlen\u001b[39m(dat_files)\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m filters available\u001b[39m\u001b[33m\"\u001b[39m)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\OneDrive\\Desktop\\Summer 2025\\RTModel\\RTModel\\RTModel.py:453\u001b[39m, in \u001b[36mRTModel.run\u001b[39m\u001b[34m(self, event, cleanup)\u001b[39m\n\u001b[32m 451\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m phase%\u001b[32m2\u001b[39m == \u001b[32m1\u001b[39m:\n\u001b[32m 452\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m(\u001b[38;5;28mself\u001b[39m.InitCond_modelcategories == \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m.modelcodes[phase//\u001b[32m2\u001b[39m-\u001b[32m1\u001b[39m] \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m.InitCond_modelcategories):\n\u001b[32m--> \u001b[39m\u001b[32m453\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mlaunch_fits\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mmodelcodes\u001b[49m\u001b[43m[\u001b[49m\u001b[43mphase\u001b[49m\u001b[43m/\u001b[49m\u001b[43m/\u001b[49m\u001b[32;43m2\u001b[39;49m\u001b[43m-\u001b[49m\u001b[32;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m \n\u001b[32m 454\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mo \u001b[39m\u001b[33m\"\u001b[39m + time.asctime())\n\u001b[32m 455\u001b[39m phase += \u001b[32m1\u001b[39m \n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\OneDrive\\Desktop\\Summer 2025\\RTModel\\RTModel\\RTModel.py:351\u001b[39m, in \u001b[36mRTModel.launch_fits\u001b[39m\u001b[34m(self, modelcode)\u001b[39m\n\u001b[32m 349\u001b[39m pbar.update(finitcond - \u001b[38;5;28mmax\u001b[39m(finitcondold,\u001b[32m0\u001b[39m))\n\u001b[32m 350\u001b[39m finitcondold =finitcond\n\u001b[32m--> \u001b[39m\u001b[32m351\u001b[39m \u001b[43mtime\u001b[49m\u001b[43m.\u001b[49m\u001b[43msleep\u001b[49m\u001b[43m(\u001b[49m\u001b[32;43m0.1\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 352\u001b[39m pbar.close()\n\u001b[32m 353\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m(crashes>\u001b[32m0\u001b[39m):\n", + "\u001b[31mKeyboardInterrupt\u001b[39m: " + ] + } + ], + "source": [ + "import os\n", + "from glob import glob\n", + "\n", + "# Parent output directory\n", + "output_dir = r\"C:\\Users\\Meet\\OneDrive\\Desktop\\Summer 2025\\RTModel\\jupyter\\downloaded_file\\microlensing_lightcurves\\output\"\n", + "\n", + "# Get all event folders inside output (e.g., FSPL_7, PSPL_3, etc.)\n", + "event_folders = [os.path.join(output_dir, d) for d in os.listdir(output_dir) if os.path.isdir(os.path.join(output_dir, d))]\n", + "\n", + "# Loop through each event\n", + "for event_folder in event_folders:\n", + " data_folder = os.path.join(event_folder, 'Data')\n", + "\n", + " if os.path.exists(data_folder):\n", + " # Find all .dat files in Data folder\n", + " dat_files = glob(os.path.join(data_folder, 'Rubin*band.dat'))\n", + "\n", + " # Check if at least 3 filters are present\n", + " if len(dat_files) >= 3:\n", + " total_points = 0\n", + "\n", + " # Count the total number of data points across all filters\n", + " for file in dat_files:\n", + " with open(file, 'r') as f:\n", + " # Skip header lines and count data lines\n", + " lines = [line for line in f if line.strip() and not line.startswith(\"#\")]\n", + " total_points += len(lines)\n", + "\n", + " if total_points >= 20:\n", + " print(f\"Processing event: {os.path.basename(event_folder)} with {len(dat_files)} filters and {total_points} data points\")\n", + "\n", + " # Loop through the events in the output directory\n", + " rtm.set_event(event_folder)\n", + "\n", + " # Run the model for this event\n", + " rtm.run()\n", + " else:\n", + " print(f\"Skipping {os.path.basename(event_folder)} - only {total_points} data points available\")\n", + " else:\n", + " print(f\"Skipping {os.path.basename(event_folder)} - only {len(dat_files)} filters available\")\n", + " else:\n", + " print(f\"Skipping {os.path.basename(event_folder)} - Data folder missing\")\n", + "\n", + "print(\"Finished processing all valid events.\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/group_4_ampel_filter/output.tar.xz b/group_4_ampel_filter/output.tar.xz new file mode 100644 index 0000000..42403fa --- /dev/null +++ b/group_4_ampel_filter/output.tar.xz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0fd7c06b68250b2f07f973271d70b0bcf60d42c539db064f536ab1e86d7f91ed +size 116376132 From 6645e6de2137eb3f242faa46766c5b39e3c339bb Mon Sep 17 00:00:00 2001 From: Meet Vyas <87984759+Meet-Vyas-Dev@users.noreply.github.com> Date: Fri, 18 Jul 2025 18:17:03 +0530 Subject: [PATCH 2/2] Clarify lightcurve generation and model run criteria Updated markdown cell descriptions to specify magnification, time window, and minimum data points for FSPL, PSPL, and USBL event lightcurve generation. Also clarified the model run criteria to require at least 20 points across all filters. --- group_4_ampel_filter/RT_Model_simulations.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/group_4_ampel_filter/RT_Model_simulations.ipynb b/group_4_ampel_filter/RT_Model_simulations.ipynb index d81a40c..492c2d7 100644 --- a/group_4_ampel_filter/RT_Model_simulations.ipynb +++ b/group_4_ampel_filter/RT_Model_simulations.ipynb @@ -3102,7 +3102,7 @@ "id": "7a9b0111", "metadata": {}, "source": [ - "> #### 4.3.1 We first generate a random lightcurve for the FSPL events" + " > #### 4.3.1 We first generate a random lightcurve for the FSPL events with a magnification and time window of $3*tE$ and a minimum of 10 points across all bands " ] }, { @@ -3263,7 +3263,7 @@ "id": "a423b01f", "metadata": {}, "source": [ - "> #### 4.3.2 Now we generate a random lightcurve for the PSPL events" + "> #### 4.3.2 Now we generate a random lightcurve for the PSPL events with a magnification and time window of $3*tE$ and a minimum of 10 points across all bands " ] }, { @@ -3382,7 +3382,7 @@ "id": "f951868e", "metadata": {}, "source": [ - "> #### 4.3.3 Nopw we generate a random lightcurve for the USBL events" + "> #### 4.3.3 Nopw we generate a random lightcurve for the USBL events with a magnification and time window of $3*tE$ and a minimum of 10 points across all bands " ] }, { @@ -4039,7 +4039,7 @@ "id": "8105f7a1", "metadata": {}, "source": [ - "> #### 9. Run the model looping through all the possible events with atleast data files for 3 filters and 20 points" + "> #### 9. Run the model looping through all the possible events with atleast data files for 3 filters and 20 points across all filters " ] }, {