From cf830516e772afb9f8cba10e6db6d044824f46e0 Mon Sep 17 00:00:00 2001 From: Claudio Galelli Date: Fri, 23 Aug 2024 12:33:07 +0200 Subject: [PATCH 01/13] Add files via upload --- ...wer spectral density of a lightcurve.ipynb | 744 ++++++++++++++++++ recipes/env.yml | 13 + 2 files changed, 757 insertions(+) create mode 100644 recipes/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb create mode 100644 recipes/env.yml diff --git a/recipes/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb b/recipes/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb new file mode 100644 index 0000000..5632c59 --- /dev/null +++ b/recipes/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb @@ -0,0 +1,744 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b4ca33d6-129c-4a59-89d7-f57e39cacfc0", + "metadata": {}, + "source": [ + "# Generating synthetic lightcurves and fitting the power spectral density of a lightcurve #\n", + "\n", + "This notebook presents the advanced Emmanoulopoulos algorithm for the simulation of synthetic lightcurves. The original paper describing the algorithm is linked [here](https://arxiv.org/pdf/1305.0304.pdf). The version implemented here is compatible with the Gammapy implementation of the Timmer-Koenig algorithm.\n", + "The Timmer-Koenig algorithm generates synthetic lightcurve from a chosen power spectral density (PSD) shape. However, it can only generate time series with a gaussian probability density function (PDF). This is adequate for high-statistics astrophysical domains such as the optical or X-rays, but can be in issue when trying to reproduce curves in the gamma-ray domain, where photon counts are lower and statistics are generally Poissonian. The Emmanoulopoulos algorithm tries to solve this issue, combining a requested PSD and PDF in the simulation. It provides accurate synthetic lightcurves in a range of spectral indexes between -1 and -2 for power-law or similar PSDs.\n", + "\n", + "Together with the simulation algorithm the notebook adds a function to compute the PSD envelope for a lightcurve using either the Timmer-Koenig or the Emmanoulopoulos algorithm. This envelope is then used to fit the PSD fot he observed lightcurve, by passing through a tailored chi-squared-like cost function. This complex fitting is necessary to account for the fact that the periodogram of the observed lightcurve is only a possible realization of the PSD model, moreover convoluted with Poissonian noise and instrumental responses. This can lead to biases or deformation due to random fluctuation of the realization if extracted with a simple curve fit of the periodogram.\n", + "\n", + "The results are satisfactory for power-law or broken-power-law PSDs in a physical interval of spectral indexes, between -1 and -2. Using the Emmanoulopoulos algorithm shows consistently better PSD reconstruction over the Timmer-Koenig - this is due to the injected non-gaussian PDF." + ] + }, + { + "cell_type": "markdown", + "id": "b693b292-fa5c-4afa-b013-464389e4092a", + "metadata": {}, + "source": [ + "## Imports ##\n", + "\n", + "The first step is importing some usual packages, needed Astropy utilities, scipy tools for PDFs and minimization, and Gammapy functions and classes for the observational part." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4678c090-734e-430d-a81e-ff77cf5ef8a0", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "import inspect\n", + "\n", + "import astropy.units as u\n", + "from astropy.coordinates import SkyCoord, AltAz\n", + "\n", + "from regions import PointSkyRegion\n", + "\n", + "from gammapy.estimators import LightCurveEstimator, FluxPoints\n", + "from gammapy.makers import SpectrumDatasetMaker\n", + "from gammapy.data import Observation, observatory_locations, FixedPointingInfo\n", + "from gammapy.datasets import Datasets, SpectrumDataset\n", + "from gammapy.irf import load_irf_dict_from_file\n", + "from gammapy.maps import MapAxis, RegionGeom, TimeMapAxis, RegionNDMap\n", + "from gammapy.modeling.models import SkyModel, PowerLawSpectralModel, LightCurveTemplateTemporalModel\n", + "from gammapy.estimators.utils import compute_lightcurve_fvar\n", + "from gammapy.utils.random import get_random_state\n", + "\n", + "from scipy.optimize import minimize\n", + "from scipy.signal import periodogram\n", + "from scipy.stats import lognorm" + ] + }, + { + "cell_type": "markdown", + "id": "6ff44b6c-f786-4f7d-bf7c-c27cac5a78dc", + "metadata": {}, + "source": [ + "## Reference Lightcurve ##\n", + "\n", + "As a reference, the notebook uses the H.E.S.S. dataset for the PKS2155 AGN flare of 2006. Data properties such as mean and standard deviation fo the norm, number of points, sampling frequency, are taken from this flare. The synthetic lightcurve will be oversampled by a factor 10." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "330ee851-fcc3-47ad-8b1a-e5bd06d78869", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAH4CAYAAAC8ImIAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAABRuElEQVR4nO3deZyNdf/H8feZjRmzoBhElhg1JBqybzGGbkWU5U5Juu/Efecmt9R93yp3pfJLm0GblPZNKndEGVuSbYgpS1kHI2EGg9m+vz80V46xnDnXmTnLvJ6Px3mYc51rrvM9bzPnfOZ7fa/v12GMMQIAAMBFBXm7AQAAAP6CwgkAAMBFFE4AAAAuonACAABwEYUTAACAiyicAAAAXEThBAAA4KIQbzcg0BQUFGjv3r2KioqSw+HwdnMAAIALjDE6evSoatSooaCg8/crUTh52N69e1WrVi1vNwMAALhh9+7dqlmz5nkfp3DysKioKEmng4+OjvZyawAAgCuysrJUq1Yt63P8fCicPKzw9Fx0dDSFEwAAfuZiw2wYHA4AAOAiCicAAAAXUTgBAAC4iDFOAAC/kJ+fr9zcXG83A34qNDRUwcHBto9D4QQA8GnGGO3fv19HjhzxdlPg5ypWrKhq1arZmmeRwgkA4NMKi6aqVasqIiKCyYVRbMYYZWdn68CBA5Kk6tWru30sCicAgM/Kz8+3iqZLLrnE282BHwsPD5ckHThwQFWrVnX7tB2DwwEAPqtwTFNERISXW4JAUPhzZGesHIUTAMDncXoOnuCJnyMKJwBAwMvOyVOdcXNVZ9xcZefkebs58GMUTgAAAC6icAIAAHARhRMAAB62ZMkS3XjjjapRo4YcDoc+/fRTl74vOTlZV111lcLDw9WwYUO9+eabTo9v2rRJffv2VZ06deRwOPTcc895vvHnsHjxYiUkJKh8+fKqV6+epk+fXmSfjz/+WPHx8SpXrpzi4+M1e/bs8x7vzjvvlMPhuODtfP7+97+rQYMG53wsPT1dwcHB+uSTT4r/Il1E4QQACHgL0jKsr3snL9e8jftK9PmOHz+ua665RlOmTHH5e6ZNm6YHH3xQjzzyiDZt2qRHH31UI0aM0Oeff27tk52drXr16unJJ59UtWrVPNLWlJQU1alT57yPb9++XTfccIPat2+vdevW6aGHHtJ9992njz/+2NpnxYoV6t+/v26//XatX79et99+u/r166eVK1ee85jPP/+89u3bZ90k6fXXXy+y7VyGDh2qbdu2aenSpUUemzlzpi655BLdeOONLr56Nxh4VGZmppFkMjMzvd0UXMTxU7mm9gNfmNoPfGGOn8r1dnMAnMOJEydMWlqaOXHihMvfc/xUrtPt03V7rN/12g98Yer8/u+n6/Y47VdSJJnZs2dfdL/WrVubMWPGOG0bOXKkadu27Tn3r127tnn22WeLbC8oKDBPPfWUqVu3rilfvrxp0qSJ+fDDD8/7vIsWLTK1a9c+7+Njx441V155pdO2e+65x7Rq1cq6369fP9O9e3enfZKSksyAAQPOe9wznZ3Rnj17TL9+/UzFihVN5cqVzU033WS2b99uPX7ttdeaO++8s8hx6tevb+6///7zPs+Ffp5c/fxmAkwAQECJHz//go+b3/8d+V6q0/YdT/6pZBrkolOnTql8+fJO28LDw/X9998rNzdXoaGhLh3n3//+tz755BNNmzZNDRo00JIlSzRo0CBVqVJFHTt2LHa7VqxYoW7dujltS0pK0muvvWa1a8WKFRo1alSRfdw5lZidna3OnTurffv2WrJkiUJCQvTYY4+pe/fu2rBhg8LCwjR06FCNHTtWL774oiIjIyWdPp24bds23XXXXcV+zuLgVB0AAD4gKSlJr776qtasWSNjjFavXq0ZM2YoNzdXBw8edOkYx48f1+TJkzVjxgwlJSWpXr16uvPOOzVo0CC99NJLbrVr//79io2NddoWGxurvLw8q13n22f//v3Ffr733ntPQUFBevXVV3X11Vfrqquu0uuvv65du3YpJSVFkvTnP/9Z+fn5+vDDD63vmzFjhlq3bq34+PhiP2dx0OMEAAgoaROSnO73Tl6urRnHrJ4mSXI4pLjYKM0e3qZ0G3cB//nPf7R//361atVKxhjFxsbqzjvv1NNPP+3y8iBpaWk6efKkEhMTnbbn5OSoWbNm1v3CXhrp9LI2p06dctrWvn17ffnll9b9swdrnz675rz9XPu4M+HkmjVrtG3bNkVFRTltP3nypH7++WdJpxfr7dOnj2bMmKEhQ4bo6NGj+vjjj0tlsDyFEwAgoESEOX+0jU6M07C31lr3HQ7JGGlU17gi+3pTeHi4ZsyYoZdeekkZGRmqXr26Xn75ZUVFRenSSy916RgFBQWSpLlz5+qyyy5zeqxcuXLW16mpqdbXK1eu1AMPPGD15hS2pVC1atWK9BwdOHBAISEh1vqB59vn7F4oV19DQkKC3n777SKPValSxfp66NCh6tKli7Zu3arFixdLkvr371/s5ysu3/mJAfxEdk6eNYYibUKST73xAiiqe+Pqen5AU2tMU1xslEZ1jVP3xp65Ks3TQkNDVbNmTUmnT1v17NlTQUGujawpnA5g165dFxzPVL9+fevrPXv2KCQkxGnbmVq3bu10ZZ8kffXVV2revLk17qp169ZasGCB0zinr776Sm3aFL9H79prr9X777+vqlWrKjo6+rz7de7cWfXq1dPMmTO1aNEi9evXr0gvVUngHR9l1tmXJ49OjFP3xtW92CIAJSUx/o+ej9nD25T4HzzHjh3Ttm3brPvbt29XamqqKleurMsvv1yS9OCDDyo9Pd2aq2nLli36/vvv1bJlSx0+fFiTJ0/Wxo0b9cYbb1jHycnJUVpamvV1enq6UlNTFRkZqfr16ysqKkpjxozRqFGjVFBQoHbt2ikrK0vffvutIiMjNXjw4GK/lmHDhmnKlCkaPXq0/vKXv2jFihV67bXX9O6771r7jBw5Uh06dNBTTz2lXr16ac6cOVq4cKGWLVtW7Oe77bbbNGnSJPXq1UsTJkxQzZo1tWvXLn3yySf65z//aRWVDodDQ4YM0eTJk3X48GFNmjSp2M/llgtfIIjiYjoC3+Wpy5OZxgAoPe5MR3Aupf17u2jRIqPTF/A53QYPHmztM3jwYNOxY0frflpammnatKkJDw830dHRplevXuann35yOu727dvPedwzj1NQUGCef/5507BhQxMaGmqqVKlikpKSzOLFi8/b1gtNR2CMMSkpKaZZs2YmLCzM1KlTx0ybNq3IPh9++KH1nFdeeaX5+OOPL5pTIZ01HcG+ffvMHXfcYS699FJTrlw5U69ePfOXv/ylyGfr7t27TVBQkGnYsKFLz+OJ6QgcvzcYHpKVlaWYmBhlZmZesIsRpa/OuLnF/p5zXZ7MqTqg9Jw8eVLbt29X3bp1i1yqXxz83kK68M+Tq5/f/OQAAAJeRFiI1+dpQmCgcEKZceYlyv5yeTIAwLcwASbKjIiwEOs2OjGuSNF05uXJhbdzKe01rwAAvoPCCWVS4eXJheJiozR9UEKRy5Ozc/KcbnNS052WadiacUzD3lqrOanp1j4API/huPAET/wccaoOZZYrlye7s+YV4ygAzymcJyg7O9tpUkbAHdnZ2ZLk8rp/50LhBADwWcHBwapYsaIOHDggSYqIiHBrGQ+UbcYYZWdn68CBA6pYsaLLS9icC4UTcAH+uuYVEEiqVTt9Cr2weALcVbFiRevnyV0UTsAF+OuaV0AgcTgcql69uqpWrarc3FxvNwd+KjQ01FZPUyHe6YFi8Lc1r4BAEhwc7JEPPsAOCieUWe5OiFfaa14BAHwH0xEAAAC4iMIJAADARRROAAAALqJwAgAAcBGFEwAAgIu4HAg+Jzsnz1rqJG1Cks9dtebu1XgAAP9HjxMAAICLKJyAUpCdk6c64+aqzri5ys7J83ZzAABuonACAABwEYUTAACAiyicAAAAXEThBAAA4CIKJ/icBWkZ1te9k5dr3sZ9XmwNAAB/oHCCV2Xn5Dnd5qSma+R7qdbjWzOOadhbazUnNd3aBwAAb/GtmQVR5hROdHk+5vd/zyymmHwSAOAt9Dh5SHJysuLj49WiRQtvNwU+yJ3Tj8z9BAC+x2GMMRffDa7KyspSTEyMMjMzFR0d7e3m+LyzC4Leycu1NeOYzvyhdDikuNgozR7eRpJ8bgmWs539mhakZTj1mDl0uift+QFNlRgfK+ncr8nXl54BgEDi6uc378TwqrOLgdGJcRr21lrrvsMhGSON6hrnN4UDpx8BIHBxqg4+pXvj6np+QFPrflxslKYPSlD3xtW81ygAAH7nH3/Co0wpPH0lSbOHt/GbnqZCaROSnO67cvoRAOAf6HECPCwiLMTpNjoxrkjRdObpR38rDAGgLKNwAkoYpx8BIHBQOAGl4OzTj64UTcygDgC+h8IJ8AHuzKDO3E4AUPoYXAH4AHemMJCYxgAAShuFE3xORFgIBQEAwCdROAE+gCkMAMA/MMYJ8AHuTGHANAYAUPoonAAfxBQGAOCb+JMV8FH+PoM6AAQi3omBUsCAdwAIDJyqAwAAcBGFEwAAgIsonAAAAFxE4QQAAOAiBocDPooB5QDge+hxAgAAcBGFEwAAgIsonAAAAFxE4QQAAOAiCicAAAAXUTghIGTn5KnOuLmqM26usnPyvN0cAECAonACAABwEYUTAACAiyicAAAAXEThBAAA4CIKJwAAABdROAEAALiIwgkAAMBFFE4AAAAuonBCQFiQlmF93Tt5ueZt3OfF1gAAAhWFE1ziSzNzZ+fkOd3mpKZr5Hup1uNbM45p2FtrNSc13Wk/AADsCvF2A4Diih8//4KPm9//PbOYkqQdT/6pZBoEACgz6HFCifKlnioAAOyixwl+J21CktP93snLtTXjmNXTJEkOhxQXG6XZw9uUbuMAAAGNHif4nYiwEKfb6MS4IkWTMdKornFO+wEAYBeFE/xe98bV9fyAptb9uNgoTR+UoO6Nq3mvUQCAgMSf4QgIifGx1tezh7ehhwkAUCLocQIAAHARhRMAAICLKJwAAABcROEEAADgIgonuMTdteBYQw4AEEgonHBO7qwF584acgAA+BOu2cY5XWg9uPOtBXcx5/o+1o8DAPgTepwAAABc5DDGmIvvBldlZWUpJiZGmZmZio6O9nZz3HbmaTR314Jz5fuYqBIA4Atc/fymxwnn5M5acO6sIQfPys7JU51xc1Vn3FzGkAFACaBwwkW5uxYca8gBAAINf/LDJe6uBccacgCAQEKPEwAAgIsonAAAAFxE4QQAAOAiCicAAAAXuTVS97PPPiv29yQmJio8PNydpwMAAPAJbhVOvXv3Ltb+DodDW7duVb169dx5OgAAAJ/g9qm6/fv3q6CgwKVbRESEJ9sM4DwWpGVYX/dOXq55G/d5sTUAEHjc6nEaPHhwsU67DRo0yK+XH4H7IsJCWMi3BJ05O/iCtAynBZS3ZhzTsLfW6vkBTZ3m02IuLQBwn1vvoK+//nqx9p82bZo7TwPgIuLHzz/vY4XL3ZxZTEkqM4Vsdk6elU/ahCQKRgAeUexTdSdOnFB6enqR7Zs2bfJIgwAAAHxVsf4E++ijjzRq1ChVrlxZxhi98soratmypSTp9ttv19q1a0ukkfA+Trn5prQJSdbXvZOXa2vGsSILK8fFRmn28Dal3zgACEDF6nF67LHHtHbtWq1fv14zZszQXXfdpXfeeUeSZIy5yHcD8LSIsBDrNjoxrkjRZIw0qmuc037elJ2Tpzrj5qrOuLlO47MAwF8U6100NzdXVapUkSQ1b95cS5YsUZ8+fbRt2zY5HI4SaSAA13RvXF3PD2hqjWmKi43SqK5x6t64mncbBgABpFg9TlWrVtWGDRus+5dccokWLFigH3/80Wk7AO848+q52cPbUDQBgIcVq3CaNWuWqlat6rQtLCxM7777rhYvXuzRhgEAAPiaYhVONWvWVLVqf/wFu3//fuvrtm3beq5VAAAAPsjWIr/dunXzVDsAAAB8nq3CiSvpgLLL16+QY/kZACXBVuHElXQAfEF2Tp7TbU5q+jmXn5mTmm7tAwDuYA0CAH7vQkvPSOdefoYJXQG4w1aPEwAAQFliq8cpLCzMU+0A4AG+vjTO2eOORifGqXvj6raPe+bSM4XHZvkZACXBVo/T6tWrPdUOAAHGnXFH7o49OnNJGVeXnwEAd/DuAUDZOXnWOKG0CUkeKSzcGXckeWbsEcvPACgpHimcTp48qQ0bNujAgQMqKChweuymm27yxFMAQLGcvfwMvUwAPMH2O8m8efN0xx136ODBg0Ueczgcys/Pt/sUAPwQ444ABCLbV9X97W9/06233qp9+/apoKDA6UbRBJRd7ow7olcIgK+zXTgdOHBAo0ePVmxs7MV3BhAwijszd+G4o0JxsVGaPiiBcUcA/IrtwumWW25RSkqKB5oCwFd5ambus8cdUTQB8De2+8WnTJmiW2+9VUuXLtXVV1+t0NBQp8fvu+8+u08BwMuYmRsATrNdOL3zzjuaP3++wsPDlZKS4rR+ncPhoHACAAABw3bh9O9//1sTJkzQuHHjFBTECi7+oCTm7EFg4wo5ADjNdqWTk5Oj/v37UzQBAYyZuQHgNNvVzuDBg/X+++97oi0A/ARXyAEoq2z/WZifn6+nn35a8+fPV5MmTYoMDp88ebLdpwDgg3x9Zm5fX/AYgH+y/U73ww8/qFmzZpKkjRs3Oj125kBxAL7r7DmZRifGqXvj6l5sEbyJcZDA+dn+bVi0aJEn2gGglJw9x9KCtIxzzsn0/ICmVq8SH5wAcBrvhkAZ4805mTh9BsDf2R4cPnHiRM2YMaPI9hkzZuipp56ye3gAAACfYbvH6aWXXtI777xTZHujRo00YMAAPfDAA3afAoAHMScTALjPdo/T/v37Vb160UGkVapU0b59F170E0Dp87c5mbJz8lRn3FzVGTf3vGvgAUBpsV041apVS8uXLy+yffny5apRo4bdwwMoYczJBACus/2n5N13361//OMfys3N1fXXXy9J+vrrrzV27Fjdf//9thsIoOT5+pxMAOArbL87jh07VocOHdLw4cOVk5MjSSpfvrweeOABPfjgg7YbCMA3cYUcgLLIduHkcDj01FNP6T//+Y9+/PFHhYeHq0GDBipXrpwn2gcAAOAzPNYfHxkZqRYtWnjqcAAAAD7H9uBwAACAsoLCCQAAwEUeK5zWrFnjqUMBAAD4JI8VTjfffLOnDoUStiAtw/q6d/JyzdvIRKUAALiiWIPD+/Xrd87txhgdOnTIIw2CZ5090/KCtAynxVu3ZhzTsLfW6vkBTZ3m8mEeHwAAiirWp+PChQs1a9YsRUZGOm03xmjJkiUebVhJu/nmm5WSkqIuXbroo48+cvkxfxM/fv4FHy9cauPMYkoS8/MAAHAOxTpV16lTJ0VGRqpjx45Ot06dOqlZs2Yl1cYScd999+nNN98s9mMAEOg4nQ+cn8MYYy6+W2BKSUnRlClTztmrdKHHLiQrK0sxMTHKzMxUdHS0p5p6Xtk5eVavUtqEpCKn2M4+Vdc7ebm2ZhwrsqhrXGyUZg9vY23jVB18xZzUdKtHNC42UqMT49S9cdGFxeG+M98nzj6d79DpnmlO5yPQufr5bWtw+P79++18+3ktWbJEN954o2rUqCGHw6FPP/20yD5Tp05V3bp1Vb58eSUkJGjp0qUl0hZ/V7i6feFtdGJckaLJGGlU1zin/QBvyc7Js25nFk3SH2Py5qSmO+0He+LHz7duZ5+2P/N0/pn7AWWVrU/Ibt26acOGDZ5qi+X48eO65pprNGTIEPXt27fI4++//77+8Y9/aOrUqWrbtq1eeukl9ejRQ2lpabr88sslSQkJCTp16lSR7/3qq69Uo0YNj7X11KlTTs+TlZXlsWOXhO6Nq+v5AU3P+As+SqO6xql742rebRjwuwt9KDMmD4C32SqcSuosX48ePdSjR4/zPj558mQNHTpUd999tyTpueee0/z58zVt2jRNnDhRUunNKzVx4kQ9+uijpfJcnnJmd/vs4W3oYQLKuLQJSdbXrp7OB8oqW5+YDofDU+1wWU5OjtasWaNx48Y5be/WrZu+/fbbUm/Pgw8+qNGjR1v3s7KyVKtWrVJvBxAo+BAvfWf+8TQ6MU7D3lpr3T/7dD5Q1vndkisHDx5Ufn6+YmNjnbbHxsYWa8xVUlKSbr31Vv3vf/9TzZo1tWrVKpceO1u5cuUUHR3tdAPgPsbkeVfh6fxCcbFRmj4ogdP5wO/89h3n7N4uY0yxesDmzz//OIoLPQag9DAmzzs4nQ+cn63fhrCwME+1w2WXXnqpgoODi/QuHThwoEgvFAD/x4c4AF9i61Td6tWrPdUOl4WFhSkhIUELFixw2r5gwQK1acOYBwAAUHJs/+l24sQJGWMUEREhSdq5c6dmz56t+Ph4devWza1jHjt2TNu2bbPub9++XampqapcubIuv/xyjR49WrfffruaN2+u1q1b6+WXX9auXbs0bNgwuy8HAADgvGwXTr169VKfPn00bNgwHTlyRC1btlRoaKgOHjyoyZMn69577y32MVevXq3OnTtb9wuvWhs8eLBmzpyp/v3767ffftOECRO0b98+NW7cWP/73/9Uu3Ztuy8HAADgvGxfVbd27Vq1b99ekvTRRx8pNjZWO3fu1JtvvqkXXnjBrWN26tRJxpgit5kzZ1r7DB8+XDt27NCpU6e0Zs0adejQwe5LAQAAuCDbhVN2draioqIknZ6Vu0+fPgoKClKrVq20c+dO2w0EAADwFbYLp/r16+vTTz/V7t27NX/+fGtc04EDB5jTCAAABBTbhdP48eM1ZswY1alTRy1btlTr1q0lne59atasme0GAgAA+Arbg8NvueUWtWvXTvv27dM111xjbe/SpYtuvvlmu4cHAADwGR6ZSa5atWqqVs15Jt/rrrvOE4cGgFKTnZOn+PGnVw5Im5DEZJsAivC7teoAAAC8hcIJAADARR4rnNasWeOpQwEAAPgkjxVOZX0geHJysuLj49WiRYtSfd4FaRnW172Tl2vexn2l+vxASYsIC9GOJ/+kHU/+iTFHALyuWO9C/fr1O+d2Y4wOHTrkkQb5qxEjRmjEiBHKyspSTExMiTxHdk6e0/0FaRka+V6qdX9rxjENe2utnh/Q1FpR/lwfNIUfRAAAoHiKVTgtXLhQs2bNUmRkpNN2Y4yWLFni0YahqMKrfc7H/P7vmcUUBRIAAJ5TrMKpU6dOioyMVMeOHYs8xmSXABAY6JUGzq9YhdMnn3xy3sfmzZtnuzG4sLQJSU73eycv19aMY1ZPkyQ5HFJcbJRmD29Tuo0DAKAMsDU4fP/+/Z5qB1wQERbidBudGFekaDJGGtU1ztoHAAB4jq3CqXBBX3hH98bV9fyAptb9uNgoTR+UoO6Nq53/mwAAgNtsdUkYYy6+E0pU4dVzkjR7eBt6mQAAKEG2epwcDoen2gEAAODzWHIFAH7HhLIALobCCUCZlJ2T53Sbk5p+zgll56SmO+0HoGyzNSAmLCzMU+0AgFLlzoSyEpPKAmWdrR6n1atXe6odAAAAPs/tHqfU1FQ1bdrUg00BgNLDhLIA3OF2j9O1116rhIQETZs2TZmZmZ5sEwCUOHcmlGW6DwBuF07Lly/Xtddeq3Hjxql69eoaNGiQFi1a5Mm2AUCpYUJZAK5wu3Bq3bq1XnnlFe3fv1/Tpk3Tnj171LVrV11xxRV6/PHHtWfPHk+2EwBK3NkTylI0ATib7ekIwsPDNXjwYKWkpGjLli0aOHCgXnrpJdWtW1c33HCDJ9oIAADgEzw6j9MVV1yhcePG6V//+peio6M1f/6FL/cFAADwJx4rnBYvXqzBgwerWrVqGjt2rPr06aPly5d76vA+Lzk5WfHx8WrRooW3mwIA8KLsnDzVGTdXdcbNZdLUAGTrEpHdu3dr5syZmjlzprZv3642bdroxRdfVL9+/VShQgVPtdEvjBgxQiNGjFBWVpZiYmK83RwAAFAC3C6cEhMTtWjRIlWpUkV33HGH7rrrLjVs2NCTbQMAAPApbhdO4eHh+vjjj9WzZ08FBwd7sk0AAAA+ye0xTp999pl69eql4OBgLV26VIMGDVLr1q2Vnp4uSZo1a5aWLVvmsYYCAAB4m+3B4R9//LGSkpIUHh6udevW6dSpU5Kko0eP6oknnrDdQAAAAF9hu3B67LHHNH36dL3yyisKDQ21trdp00Zr1661e3gAAACfYbtw2rx5szp06FBke3R0tI4cOWL38AAAwIOYLsEe24VT9erVtW3btiLbly1bpnr16tk9PAAAgM+wvdT3Pffco5EjR2rGjBlyOBzau3evVqxYoTFjxmj8+PGeaCMuICIsRDue/JO3mwEEBH6fAFyM7cJp7NixyszMVOfOnXXy5El16NBB5cqV05gxY/S3v/3NE20EAABnyc7JU/z400ubpU1IUkSY7Y90uMAjKT/++OP617/+pbS0NBUUFCg+Pl6RkZGeODQAAIDPcHuM01133aWjR49a9yMiItS8eXNdd911FE0AACAguV04vfHGGzpx4oQn2wIAAODT3C6cjDGebAcAAIDPszUdgcPh8FQ7AAAAfJ6tweFxcXEXLZ4OHTpk5ykAAPArC9IyrK97Jy/X6MQ4dW9c3YstgifZKpweffRRxcTEeKotAAD4lbNn3l6QlqGR76Va97dmHNOwt9bq+QFNlRgfK0lMG+DnbP3vDRgwQFWrVvVUWwAA8CuF8yidT+Fo4DOLKSZZ9W9uj3FifBMAAChr3O5x4qo6AEBZlzYhyel+7+Tl2ppxTGd+QjocUlxslGYPb1O6jUOJcKvHacOGDcrNzXX5NN2mTZuUlxfYKzAnJycrPj5eLVq08HZTAAClJCIsxOk2OjGuSNFkjDSqa5y1D/ybW4VTs2bNinW1XOvWrbVr1y53nspvjBgxQmlpaVq1apW3mwIA8JLujavr+QFNrftxsVGaPihB3RtX816j4FFulb7GGP3nP/9RRESES/vn5OS48zQAAPidwqvnJGn28Db0MgUYt/43O3TooM2bN7u8f+vWrRUeHu7OUwEAgHNwd74o5pmyx63CKSUlxcPNAAAAF3LmnFGuzBd1LswzZR/pAADgBy40Z9S55otyBfNMFZ+tteoAAADKEnqcAADwA2fOGeXufFHMM2UfPU4AAPiB4s4Xda4b80zZR+EEAAEsOydPdcbNVZ1xc4ssSOuPz4PT3J0vinmm7PNI4bR06VINGjRIrVu3Vnp6uiRp1qxZWrZsmScODwAAznL2fFGuFj/ufh9Os104ffzxx0pKSlJ4eLjWrVunU6dOSZKOHj2qJ554wnYDAQAIdPTY+Q/bhdNjjz2m6dOn65VXXlFoaKi1vU2bNlq7dq3dwwMAAPgM24XT5s2b1aFDhyLbo6OjdeTIEbuHBwAA8Bm2C6fq1atr27ZtRbYvW7ZM9erVs3t4AAAAn2G7cLrnnns0cuRIrVy5Ug6HQ3v37tXbb7+tMWPGaPjw4Z5oIwAAFsYDwZtsT9gwduxYZWZmqnPnzjp58qQ6dOigcuXKacyYMfrb3/7miTYCAAD4BI/MdPX444/rX//6l9LS0lRQUKD4+HhFRkZ64tAAAAA+w2NThEZERKh58+aeOhwAAH4pIiyEhXIDmFuF0+jRo13ed/Lkye48BQAAgM9xq3Bat26d0/01a9YoPz9fDRs2lCRt2bJFwcHBSkhIsN9CAAAAH+FW4bRo0SLr68mTJysqKkpvvPGGKlWqJEk6fPiwhgwZovbt23umlQAAAD7A9nQEzzzzjCZOnGgVTZJUqVIlPfbYY3rmmWfsHh4AAMBn2C6csrKylJGRUWT7gQMHdPToUbuHBwCfxpxCQNli+6q6m2++WUOGDNEzzzyjVq1aSZK+++47/fOf/1SfPn1sNxAAAG/JzslT/Pj5kqS0CUmKCPPYxei2cfWed9jucZo+fbr+9Kc/adCgQapdu7Zq166t2267TT169NDUqVM90Ua/kJycrPj4eLVo0cLbTQGAUrcg7Y8zD72Tl2vexn1ebA1QcmyXzhEREZo6daomTZqkn3/+WcYY1a9fXxUqVPBE+/zGiBEjNGLECGVlZSkmJsbbzQGAEnXmackFaRka+V6qdX9rxjENe2utnh/QVInxsdZ2X+qtKcvoqbLHYz/FFSpUUJMmTTx1OACADys8fXUu5vd/zyymJPFhfQFn99iNToxT98bVvdginI9HCqevv/5aX3/9tQ4cOKCCggKnx2bMmOGJpwAAICCcfREBPXb+xfb/wqOPPqoJEyaoefPmql69uhwOhyfaBQDwYWkTkqyveycv19aMY1ZPkyQ5HFJcbJRmD29T+o3zcRfqrZPKdo+dLw/GL2S7RdOnT9fMmTN1++23e6I9AAA/cOYH2ujEOA17a6113+GQjJFGdY3zyQ8+wA7bP9E5OTlq04a/KACgrOreuLqeH9DU6iGJi43SqK5x6t64mncb5qPO7K2T6LHzN7anI7j77rv1zjvveKItAAAPK61pAs4cizN7eBuKpguICAtxuo1OjCtSNJ3ZY1d4g2+w/T9x8uRJvfzyy1q4cKGaNGmi0NBQp8cnT55s9ykAAC5g0LF/osfOv9j+bdmwYYOaNm0qSdq4caPdwwEA3FRWBh0H4qX7Z/fYUcz6Ltv/M4sWLfJEOwAAKIJeNPgat36yRo8e7dJ+DodDzzzzjDtPAQAopkAcdFxWetHgP9wqnNatW+d0f82aNcrPz1fDhg0lSVu2bFFwcLASEhLstxAA4JKze1mYJgDwPLd+c848PTd58mRFRUXpjTfeUKVKlSRJhw8f1pAhQ9S+fXvPtBIAUGyBMOg4EHvR4N9sT0fwzDPPaOLEiVbRJEmVKlXSY489xmk6APAyf58mgEv34WtsF05ZWVnKyMgosv3AgQM6evSo3cMDAH6XnZOnOuPmqs64uUUGTZcVhb1oheJiozR9UILfFYTwX7YLp5tvvllDhgzRRx99pD179mjPnj366KOPNHToUPXp08cTbQQAwFKavWilNYEo/IdH1qobM2aMBg0apNzc3NMHDQnR0KFDNWnSJNsNBACgNLgz9QGnBcse2//jERERmjp1qiZNmqSff/5ZxhjVr19fFSpU8ET7AMCnBeJkjGWVO1MfMO1B2eOxUrlChQpq0qSJpw4HAD7pzF4JJmMEyh5+mwGgGC7UK8FkjP6NqQ/gCtuDwwEACATuTH2Asof/dQAohjN7JeiRsC87J8/qxUubkORTxUggTCAKz/Odn1AA8ANnfrCzpMkfIsJCAvKU5NlTH5S1/1cUxak6AHATkzHCUwoLzx1P/qlMF2f+MG8WhRMA2ODvS5oAriipWeuzc/Ks25zU9HNepTonNd1pP28ru2UtAADwKn+8SpUeJwAAABfR4wQAALzCH69SpcfJQ5KTkxUfH68WLVp4uykAAPiF4s6b5QsD5ymcPGTEiBFKS0vTqlWrvN0UAAD8jr9cper90g0AAED+MW8WPU4AAAAuonACAD/hD5MDAoGOwgkAfNCZE/65OjkggJLneycPAQAXnBhQOvfkgN6eGBAoCyicAAB+JVAXFIZ/oHACAB905sSAkv9MDggEOsY4AYAPOnPCP1cnBwRQ8vhNA4BSlp2TZ41hSpuQ5FLRUzg5YOGYprjYKI3qGnfRyQE5rQV4FoUTAPgJf5gcsLjOnmJhdGKcujeu7sUWOaPwxNk4VQcAKBVMsYBA4P9/rgAA/AJTLCAQ0OMEAAAuiFnr/0CPEwDYwBgY1zHFgn84+xTpgrSMc55SfX5AU2vcXSCMt3NV2XmlAACvOvvDdXRinIa9tda6f/YUC/AOTqleGKfqAABeUTjFQqG42ChNH5Rw0SkWAG+ipAcAeE0gTrHg7zilemH0OAEAAAuz1l8YhRMAADgvTqk6K1tlIgAAKLbSOqXqD1ep0uMEAADgIgonAAAAF1E4AQAAuIjCCQAAwEUUTgAAwOOyc/JUZ9xc1Rk3t8gyLv6MwgkAAMBFTEcAAH7CHy7VBgIdPU4AAAAuonACgFK2IC3D+rp38nLN27jPi60BUBwUTgBQwrJz8qzbnNR0jXwv1Xpsa8YxDXtrreakpjvtB88K1IHKKH2McQKAEhY/fv55HytcPPXMYkoSY5kAH0WPEwAAgIvocQKAEpY2Icn6unfycm3NOGb1NEmSw3F6xfnZw9uUfuMAFAs9TgBQwiLCQqzb6MS4IkWTMdKornFO+wHwTRROHpKcnKz4+Hi1aNHC200B4MO6N66u5wc0te7HxUZp+qAEdW9czXuN8qLCual2PPknCkb4BQonDxkxYoTS0tK0atUqbzcFgI9LjI+1vp49vE2ZLZoAf0ThBAAA4CL6RQEAwAWx3M8f6HECAABwEYUTAACAiyicAAAAXEThBAAA4CIKJwAAABdROAEAALiIwgkAAHjcgrQM6+veycs1b+M+L7bGcyicAACALdk5eU63OanpGvleqvX41oxjGvbWWs1JTXfazx8xASYAALAlfvz8Cz5euLD1mcWUJL+cVJMeJwAAABfR4wQAAGxJm5DkdL938nJtzThm9TRJksMhxcVGafbwNqXbOA+jxwkAANgSERbidBudGFekaDJGGtU1zmk/f0ThBAAIeIF6hZev6t64up4f0NS6HxcbpemDEtS9cTXvNcpDKJwAAAGnrFzh5csS42Otr2cPbxMQRZPEGCcAQAC60FVegXSFF0ofPU4AAAAuoscJAEpZRFgIvRsl7MyrvAL5Ci+UPnqcAAABp6xc4YXSR+EEAAhogXyFF0ofJTYAIOCdfYUXPUxwFz1OAAAALqJwAgAAcBGFEwAAgIsonAAAAFxE4QQAAOAiCicAAAAXUTgBAAC4iMIJAADARRROAAAALqJwAgAAcBGFEwAAgIsonAAAAFxE4QQAAOAilocGAAAeFxEWoh1P/snbzfA4epwAAABcROEEAADgIgonAAAAF1E4AQAAuIjCCQAAwEUUTgAAAC5iOgIAQMAL1EvjUfrocQIAAHARhZOHJCcnKz4+Xi1atPB2UwAAQAlxGGOMtxsRSLKyshQTE6PMzExFR0d7uzkAAMAFrn5+0+MEAADgIgonAAAAF1E4AQAAuIjCCQAAwEUUTgAAAC6icAIAAHARhRMAAICLKJwAAABcROEEAADgIgonAAAAF1E4AQAAuIjCCQAAwEUh3m5AoClcMzkrK8vLLQEAAK4q/Nwu/Bw/HwonDzt69KgkqVatWl5uCQAAKK6jR48qJibmvI87zMVKKxRLQUGB9u7dq6ioKDkcDm83p8RlZWWpVq1a2r17t6Kjo73dHL9DfvaQn/vIzh7yc5+vZmeM0dGjR1WjRg0FBZ1/JBM9Th4WFBSkmjVrersZpS46OtqnfgH8DfnZQ37uIzt7yM99vpjdhXqaCjE4HAAAwEUUTgAAAC6icIIt5cqV08MPP6xy5cp5uyl+ifzsIT/3kZ095Oc+f8+OweEAAAAuoscJAADARRROAAAALqJwAgAAcBGFEwAAgIsonAAAAFxE4QQAAOAillxBsf3000+aNm2aGjRooKuuukpdunTxdpP8Cvm5j+zsIT/3kZ09gZQfPU5wSeF0X88995yaNWumX375RW+//baSkpKUnJysI0eOeLeBPo783Ed29pCf+8jOnoDNzwAuOnbsmElISDDTp0+3tj3++OPmyiuvNC+88IIXW+YfyM99ZGcP+bmP7OwJxPzocYLL1q1bp7179+rKK6+0tj300ENKSEjQnDlz9N1333mxdb6P/NxHdvaQn/vIzp5AzI/CCed04MABbdmyRVlZWda2mjVrav/+/QoLC5MknTp1SpI0fPhwZWZmat68eSooKPBKe30N+bmP7OwhP/eRnT1lJj9vd3nB94wcOdJUrFjRNG7c2NSpU8fMmzfPHD161BhjTLt27cxNN91kjDEmPz/f+p4hQ4aYLl26mCNHjnilzb6E/NxHdvaQn/vIzp6ylB+FE5xMmjTJNGnSxKSkpJjvvvvO3HbbbSYuLs68+OKLxhhj3n77bRMaGmqWLl1qjDHm5MmTxhhjli1bZsLCwsyhQ4e81nZfQH7uIzt7yM99ZGdPWcuPwglOunbtaoYMGeK07a9//atp2bKlWblypTl58qS56aabTMOGDc2pU6esfV555RXTqFEjs3//flNQUFDazfYZ5Oc+srOH/NxHdvaUtfwY4wTLkSNHdOjQITVq1EiSrPPOQ4cOVVRUlKZNm6Zy5crpmWeeUWZmpnr16qWXX35ZK1eu1NSpU9W+fXvFxsbK4XB482V4Dfm5j+zsIT/3kZ09ZTE/CqcyLj8/X9Lp+TYqVqyoOnXqaO7cuZJk/SBfd9116tChg7Zs2aLvvvtO9evX19y5c1WhQgU999xz6tOnjxISEvTiiy967XV4C/m5j+zsIT/3kZ09ZT4/b3Z3wXcUnnNevHixcTgc5uuvvzbGGJObm2uMMSYtLc1ccsklZuHChU7ft3v3brN///7SbawPIj/3kZ095Oc+srOnrOZHj1MZsWnTJr3yyitasWKFDh8+LOn0Xw0nT55U9+7dNWPGDEmn/0ro06ePRo0apezsbIWEnF6V58orr1R+fr527drldNyaNWsqNja2dF+MF5Cf+8jOHvJzH9nZQ37n4e3KDSUrNzfXjBgxwpQvX960b9/exMTEmO7duztV+zfffLO5+eabzYkTJ4wxxmzZssVUrlzZ3HvvvWbjxo3GGGNmz55trr76arN9+3ZvvAyvIT/3kZ095Oc+srOH/C6MwinALV++3DRs2NCkpKSY/Px887///c+0bt3atG/f3hw7dswYY8zRo0etH/5CX3zxhWncuLGpUqWKuemmm0y5cuXMmDFjnObgKAvIz31kZw/5uY/s7CG/C6NwCjBnX9I5cuRIc8011zht27RpkwkPDzdPP/30BY+1detW89Zbb5lHHnnEpKamerqpPon83Ed29pCf+8jOHvIrHgqnAHLo0KEifwFMnjzZ1K1b1/rFyMvLM8YYM2HCBFO1alWTkZFh7fvrr7+ad955x/qLoqwhP/eRnT3k5z6ys4f8io/B4QEgPz9ff/3rX9WmTRt169ZNDz30kLUeULVq1XTJJZfogw8+kCQFBZ3+L//73/8uSXr33Xet46xZs0a33Xabli1bVsqvwLvIz31kZw/5uY/s7CE/91E4+bmTJ0+qT58+2rBhg5599lklJCTogw8+0M0336zc3Fx17dpVUVFRmjt3rg4cOCCHw6GCggJVrFhRN954o5YuXWodKykpSZMmTVLr1q29+IpKF/m5j+zsIT/3kZ095GeTt7u8YM/GjRtNvXr1zPz5861tP/zwgylXrpx59NFHjTHGvPzyyyYhIcE8+eSTTt/btm1bM2LECGOMCbjBe64iP/eRnT3k5z6ys4f87KFw8nPLli0zQUFB1irUOTk5xhhj/vvf/5pLL73UrF+/3uTm5pqRI0eaWrVqmenTp5udO3eapUuXmkaNGpn33nvPm833OvJzH9nZQ37uIzt7yM8eCic/dGaVv23bNlOvXj3zwgsvGGP+mLHVGGMuu+wyM2rUKGOMMTt37jT//e9/TWRkpImPjzcRERFm9OjRpdtwH0F+7iM7e8jPfWRnD/l5DoWTn9u/f78ZPHiwSUxMNAcPHjTGGOsKiWeeecZUq1bNaf8dO3aYb775xqSnp5d6W30R+bmP7OwhP/eRnT3kZw+Dw31YZmamtdL0mXbv3q0///nPOnjwoGJjY9W5c2dlZmZq+vTpkqRy5cpJkqpUqaKoqCj98ssv1vfWrl1bnTt3Vo0aNUrnRXjRjh07tG/fPh0/flzS6QUpJfJzxebNm7Vq1Sqlp6c7bSc71/z000/auHGjDh486LSd/C6O9z17eN8reRROPigzM1O33Xabevfu7fTDW2j9+vVKSUnRm2++KUnq27ev2rZtq9dff11Lly61VqfetGmT6tevr3r16pVq+73t8OHDGjhwoLp06aIePXqoc+fO2rlzp5VLamoq+Z3H4cOH1b9/f3Xs2FH33HOPrr32Wn355ZfWmy8/exd27Ngx9evXTy1bttTAgQOVkJCgzz77THl5eZKktWvXkt958L5nD+97pcjLPV44yw8//GA6d+5smjdvbhwOh5k8ebI5deqUMeaPc9TZ2dlmxYoVTuelt23bZgYPHmzKly9v+vfvbwYOHGgiIyPNjBkzjDFFZ4YNVN98841p1KiR6dmzp1m9erX57LPPTHx8vOnTp4+VAfmd2/z58039+vVNr169zA8//GB27txpEhMTTbdu3fjZc9H48eNNu3btTGpqqklLSzMDBgwwTZs2NZMnTzbGGJOVlUV+58D7nj2875UuCicfs2TJEjNixAiza9cu869//cvExsaa9evXu/z9U6ZMMSNHjjS33Xab2bRpUwm21Dfdd9995u677zaZmZnWtq+//tpERUU5bTufspzfzJkzzQsvvGCysrKsD6upU6eanj17WjMHX0hZzs4YY06ePGkaNWpkxo0bZ207dOiQGT16tGnQoIH56aefLvj9ZTk/3vfs4X2vdFE4ednZFf2hQ4ecBuDFxsaa4cOHW5eNni09Pb1YbzCB5uz8lixZYlavXu20bc6cOeaqq64yBw8eLDLvSFnO7+zsDhw4YA4dOmTd37Bhg2nYsKEZMmSIefbZZ51WRjembGdnjLF6RArt3bvXtG7d2jz33HNO21euXGk6dOhg7rjjDqftZTm/s7Pjfa94zs5v8eLFvO+VIgonLzl+/LgZN26cGTVqlJk4cWKRdX4K59V45513TGhoqFm4cGGRYxw5csT89a9/NZdddlmptNmXXCw/Y/7I8PnnnzfXXHNNkUKhrObnSnazZs0yDofD9O3b14wbN87UrVvX9OjRw6xZs8YYc/qDrixmZ8zp/P7617+aW265xYwYMcJs3rzZeqxdu3amb9++Jjs729qWl5dnnnrqKXPttddai54ePny4TOZ3oeyM4X3vYs7O71y9mLzvlTwGh3vBzJkzVbt2ba1Zs0ZHjx7VhAkTNHToUO3Zs8faJzQ0VJI0cOBANW3aVJMmTdKvv/7qdJyYmBi1bdtWQ4YMUW5urjWAN9C5kp8kBQcHS5IWLVqkG264QQ6HwymjmJgYtWvXrkzl52p2HTt2VGpqqj766CNNnDhRH3zwgfbt26fU1FRJUqVKldS+ffsylZ0kbdmyRddcc402b96s5s2ba+7cubrjjjusK5PGjh2rTz/9VKtXr7a+Jzg4WO3atVNWVpaysrIkSRUrVixz+Z0vu9dee03S6bXTeN87v3PlN3jwYCu/wgsQeN8rBd6r2cqmBQsWmE6dOpnk5GRr29q1a01ERIT5/vvvnfYtHMS3bt0643A4zDvvvGMOHjxoZs6caRYtWmSMMS6NPQkkruR35l9YR48eNfHx8ebrr7+2ti1dutTs2rXLGFO28itudsb8MTD3wIEDJjw83Lz88stFHitLnnvuOdOqVSurl27//v3mb3/7m4mNjTW7d+82xhjTvn1706FDB7N3717r+w4ePGiCg4PNl19+aW0ra/ldKLvC03R5eXm8752HK/kV/kzxvley6HEqZXl5eWrUqJEGDhxo3W/WrJkuvfRSbdy40WnfkJAQFRQUqGnTpho0aJD+8Y9/qEmTJnrwwQetOTcK/7ooK1zJr/CyWun0yt3Z2dlKSEjQ0qVLddVVV+mOO+5Qbm6upLKVX3Gzk/5YFX3OnDlq1aqVkpKSijxWluzevVsFBQWqUKGCJCk2NlYjRoxQzZo1NXz4cEnSa6+9ptWrV2vixIlav369JOmTTz5R8+bN1bRpU+tYZS2/82VXq1Yt3XvvvZJOZ8L73rm5kl8h3vdKmLcrN5ye1r5GjRomLS2tyGP5+fnmhx9+MNdff70JDQ0148eP90ILfdu58ivsOZk0aZKJi4szAwcONEFBQeb+++/3VjN90oV+9r777juzZs0a07dvX1O1alUzffp0L7TQt4wZM8Z07drV/Pzzz9a2/Px88/bbb5vo6GizbNkyY4wxr7/+umnXrp2pWLGi6dixoylfvrw1JUFZdbHsvvvuO2sb73tFuZqfMbzvlbQQbxduZVVBQYH1F+fOnTtVqVIl1ahRw2m7JP36668aPHiwIiIitGfPHlWtWtVbTfYpF8uvsOfkyy+/1NatW3XNNddo9+7dzHwr13/2Zs2apYULF6pRo0Zav369qlWr5q0me11hNj169NCrr76q1NRU1a1bVw6HQ0FBQWrRooUSEhL06aefqm3btrrzzjvVvXt3LV++XOnp6XrvvffKbH6uZvfJJ5+oZcuWCgoKUkZGBu97vytufhLveyXNYQwjwzxpy5YtqlSpkqKiolS+fPkL7pufn6/g4GA9/PDDSklJUUpKivWBf+zYMUVGRionJ0eHDh0qM2+6nsrvyJEjqlixor755huFhoaqffv2pdF8r/JUdpmZmYqJidEvv/yivLw8xcXFlUbzvW7z5s2KiopSpUqVFB4eft79OnfuLGOMXn/9ddWtW9fa3r59e7Vt21ZPPvlkkSI00HkyO+n0aeSDBw+Wmfc9T+e3ePFiBQUFlYn3PW8oO7/ZJezXX39Vz5491alTJ910003q0qWLNm3aZD1+rvq08DzzvHnz1K9fPzkcDq1atUo9evSwpsUPCwsrE28ens7v7bffliRdf/31Af/mUVLZ1atXr0wUTb/99pt69uypdu3aqVu3burYsaN++OEH6/HC/PLz8yVJ06dP1/r16/XKK6/o6NGjkqTc3FwVFBQoJiZGUtkZv1QS2Umnx3eWhfe9ksqvY8eOAf++501l47e7hP3222+67bbbFBUVpYULF+rZZ5+Vw+HQnXfeqa+++krSuT+8pNMD/hwOh66++moNGTJErVu3VrVq1YoM9gtkJZFf4UDdQMfPnj25ubkaPXq0CgoKtHDhQiUnJysoKEjDhw/X559/LumP/IKDg1VQUKCGDRvq3//+t+bNm6cuXbrozTff1O23367du3erZ8+e3nw5pYrs7CE/P1bqo6oC0MKFC01cXJxZu3atte2nn34yISEhplu3bubXX381xpz78uM5c+YYh8NhHA6Hadu2rdm2bVuptdtXkJ/7yM6ejIwMc9lll5lXX33V2vbzzz+b3r17m6SkJJORkWGM+SO/wosOCgoKzIoVK0yvXr1M586dTY8ePcwvv/xS+i/Ai8jOHvLzX/Q4ecCuXbt0+PBhNWvWzOmv+7p162rv3r169dVXJZ27+z4/P1+NGjXSokWLtGzZMl1xxRWl1m5fQX7uI7viKbwcu1B6erqCg4NVu3ZtSaf/wq9Xr5769++vw4cPW5MLFuZXOA7M4XCoVatWmj17tj799FP973//cxpzEojIzh7yCxwMDi+GI0eO6JlnnlFYWJguu+wy3XXXXZKkffv26corr9R9992n4cOHq1KlSurfv7/Kly+vU6dOqXz58nrppZeczkGXReTnPrKz58iRI/rPf/6jEydO6NJLL9Xo0aOtK7Vq166tQYMG6fHHH7cGzR8/flx///vf9dtvv2n69OmqXr26l1+B95CdPeQXgLzX2eVfXnjhBRMdHW1uuOEG07NnTxMUFGTGjh1rzcA6c+ZMEx0dbRo0aGBCQkJM165djTHGTJs2zdSpU8daP+hsZ8/UHKjIz31kZ8/kyZNNTEyMueGGG8xDDz1koqKizG233WZ+++03Y8zpOW+io6PNwYMHjTF/zKr81ltvmZo1azotPlvWkJ095BeYKJxcMGvWLNO6dWvz1ltvWds++OADEx4ebv3AG2PMli1bzMcff2x++OEHa9uMGTNMgwYNzOHDh0uzyT6F/NxHdva899575vrrrzfvvvuute3DDz805cqVM5mZmcYYY3bv3m0aNGhghgwZ4vS9GzduNEFBQWbjxo2l2mZfQXb2kF/gYgJMF+Tl5alp06bq27evpNMTkrVu3VoxMTHauHGjOnbsKElq0KCBGjRoYH1fTk6OZs+erRtvvFEVK1b0RtN9Avm5j+zsady4sf7973+rbdu21rbMzEzdfffdOnHihKKjo1WzZk393//9n3r37q1mzZqpd+/eqlWrlj788EN17drVKdeyhOzsIb8A5u3KzZdd6FTGypUrTY0aNcyRI0eKPPbjjz+aJUuWmBtuuMHUq1fPfPvttyXZTJ9Ffu4jO887efKkGThwoHE4HKZZs2amSpUq5sknn7QW43344YdNgwYNzBVXXGE6d+5sKlSoYGbOnOnlVvsGsrOH/AILPU5nMcY4Xb1w5rYzZwNev369rrjiCsXExCgvL08hIX9EuXz5ciUnJ+uKK67QqlWrVLly5dJ/IV5Cfu4jO3vOzO9c1q5dq0OHDumbb75RvXr19NFHH2nWrFmSpAceeECPPPKI+vbtq+XLl+vQoUP66KOPykx+ZGcP+ZUxXivZfMjixYtNYmJikbkwCgoKrMF6hU6dOmWMMaZ///7mrrvucnrsxIkTxhhj9u/fb/bs2VOCLfYt5Oc+srOnOPmday6rZs2amQcffND6nrKE7Owhv7KrTM/j9Msvv6hdu3bq1KmTFi5cqN27d1uP5efny+FwKDg4WBkZGdqxY4ek00ugnDx5Ut9995369+8vSVq6dKluuukmLV26VJIUGxuryy67rNRfT2kjP/eRnT3FyW/79u3nPMaePXuUn5+vyy+/XJIu2GMQSMjOHvJDmSycjDG6++67FRcXp4YNG2rbtm2qVKmSsrKyJJ0egBscHCxjjEaOHKkrrrjCae2v9evXq2rVqqpVq5b69eunzp07q0aNGkpMTPTWSypV5Oc+srPHnfzS0tIkOU8CunPnTt1///2qVKlSmVmqguzsIT9YvNPR5T3Hjx83AwcONC1btjTff/+9McaY7Oxs06pVK3PfffdZ+/3222+mdevWplmzZuabb75xOsbTTz9tHA6HCQ0NNZ07dza7d+8u1dfgTeTnPrKzx25++fn55plnnjH33HOPqVixornxxhvN/v37S/11eAPZ2UN+OFOZGxweERGhiRMnWtPcS1JoaKg107L5fZBfZGSkXn31VTVs2NBaSb7wseDgYNWsWVMffPCBWrVq5a2X4hXk5z6ys8dufkFBQbrqqqu0efNmff7552rXrp23XkqpIzt7yA9nCvglVw4cOKA5c+aoXr16uvrqq62p7gsVTnN///33a/78+dq4ceN5j2UucuVEICI/95GdPeTnPrKzh/xwIQE9xmny5MmqXbu23njjDfXp00d9+/bVihUrnPYp/KsgLi5Oubm52rZt23mPd+Yl4mUB+bmP7OwpqfzKArKzh/xwMQFbOO3Zs0dvvPGGpk6dqmXLlunzzz+3BtTu3bvX2q/wg+jSSy/VkSNHFBoaetFjl4VfBPJzH9nZU5L5BTqys4f84JJSGUnlBa+//rqpVKmSyc7OtrYdPHjQ1KtXzwwZMsSaE6dw/oz09HQTFRVlPv30U2PMuefdKEvIz31kZw/5uY/s7CE/uCLgepzM738J1KxZUwUFBTpw4ICk02t+XXLJJZo8ebJmzZqlH374wen78vLydMUVV2jr1q2SnC8fLUvIz31kZw/5uY/s7CE/FEfA/S8XnsoIDw9XfHy83n//fUlSSEiIjDHq1auXmjdvrueee07S6bk3JOnyyy9XVlZWkUGAZQ35uY/s7CE/95GdPeSH4vDbwmnDhg3nHCibn58vSWrVqpUuv/xypaSkWH8lFP6w33rrrdq0aZOOHj2q4OBga/u6det0xx13lNIr8C7ycx/Z2UN+7iM7e8gPnuB3hdPmzZvVpUsXDRgwQAsWLHB6LC8vz7raITg4WCNHjlRGRoZmzJhhbZOkn376SRUrVlRERIQ1x4YkRUdHl+Ir8Q7ycx/Z2UN+7iM7e8gPnuRXE2B+/fXXuuOOO5SYmKjp06crKirK6fGQkBDl5ORo5MiR2r9/v2bPnq1bbrlFr7/+usLCwjRs2DDl5uYqLS1NSUlJ1i9EWUF+7iM7e8jPfWRnD/nB40pvHLp9d911lxkzZox1f/fu3SYnJ8e6//bbb5uKFSuaDh06mBUrVhhjjDl8+LB58803TXR0tGnUqJGJiooyffv2NUePHi319nsb+bmP7OwhP/eRnT3kB0/zi8KpoKDAHDlyxLRs2dLMnTvXrFmzxrRq1co0bdrUXHnllWbKlCnGGGMWLFhgZs2aZV0qeqbdu3ebb7/91vzwww+l3XyvIz/3kZ095Oc+srOH/FBSfPJU3W+//aaTJ0+qSpUqCgsLk8PhUEFBgbZs2aJjx47pv//9r7p27ar27dvrm2++0YQJE3TixAmNGjXqvN2oNWvWVM2aNUv5lXgH+bmP7OwhP/eRnT3kh1Lj7crtbCNHjjRVq1Y1TZo0MS1btjTr1q2zulVvuOEGExUVZTp16mSysrKs77n33ntNhw4dzE8//eStZvsM8nMf2dlDfu4jO3vID6XJp66qe+ihh5SSkqIPPvhAEyZMUOXKlTVgwAB9+eWXkqQ777xTklS1alVFRERY3zdq1Ch99913ZX7yMfJzH9nZQ37uIzt7yA+lztuVmzGnz0WfOHHCtGrVyjz44IPW9vz8fNO1a1fTs2dP89NPP5msrCxz6623murVq5sff/zR2m/hwoWmfv36ZfYvB/JzH9nZQ37uIzt7yA/e4rVS25wxCZnD4dCRI0e0a9cuXXvttZKknJwcBQUF6f7779e+ffv0/vvvKyoqShMnTlRISIiGDx+uKVOmaOXKlXr44YfVqlUrNWjQwFsvp9SRn/vIzh7ycx/Z2UN+8AneqNaeeOIJc++995pnn33W6Zxz27ZtzS233GKMMSY3N9faftddd5nExETz888/G2OMSU1NNX/+85/N1VdfbS6//HLzl7/8xWn/QEd+7iM7e8jPfWRnD/nBV5Rq4bR161bTpEkT07hxYzN48GBTpUoVc91115kvv/zSGGPMzJkzTUhIiElLSzPGGHPixAljjDErV6405cuXN5s2bXI63r59+0xGRkZpvgSvIj/3kZ095Oc+srOH/OBrSrVwmjJlimnevLnJzs42xhiTmZlpOnXqZLp162Z++uknk5mZadq1a2c6dOjg9H2//vqriYmJMXPmzHHafq55NwIZ+bmP7OwhP/eRnT3kB19TKmOcjDHKz8/X+vXrrTk2pNNr/Dz44IM6ceKEXnjhBUVHR+vhhx/WypUr9d///lf79++XJM2bN09169ZVmzZtnI5buKJ1oCM/95GdPeTnPrKzh/zgq0qscNq4caOysrIknf5BDQ4OVk5Ojk6ePKmCggJrNepu3bqpU6dOWrNmjb799lt17dpVU6dOVXJysjp27Khbb71Vd999t2688UZdcskl51zZOhCRn/vIzh7ycx/Z2UN+8Aue7sL64osvTJMmTUyjRo1M/fr1zUMPPWR1sS5dutQEBQWZ77//3hjzx0C+VatWmauvvtpMnTrVOs63335rXnzxRTNq1CizZs0aTzfTZ5Gf+8jOHvJzH9nZQ37wJx4rnE6cOGHGjx9vatasaSZNmmRWrlxpnnvuOeNwOMwXX3xhjDHm+PHj5vrrrzedO3c2xjifa27atKm5//77PdUcv0N+7iM7e8jPfWRnD/nBH3mscPr5559Nq1atzCeffGKM+eOHu3v37ub222+39lu2bJkJCwszL7zwgsnLyzPGnP7FaNWqlZk4caKnmuN3yM99ZGcP+bmP7OwhP/gjjy3yW69ePQ0bNkzdu3d32h4ZGakqVapY99u2basJEybo0Ucf1dq1a3X77bfryy+/1J49e4p8b1lCfu4jO3vIz31kZw/5wS+VVEVWuMDiNddcY1588cUij0+ZMsV07NjRXHPNNaZJkyZm+fLlJdUUv0R+7iM7e8jPfWRnD/nBHziMKbnLDXbs2KE2bdro+++/V82aNc9VtGnnzp2qU6dOSTXBr5Gf+8jOHvJzH9nZQ37wdSU6j9O3336r6tWrWz/8Bw8e1PLly61LSh0OBz/8F0B+7iM7e8jPfWRnD/nB15VI4VT4A75w4UK1aNFCkjRx4kRVrVpVn332mQoKCkriaQMG+bmP7OwhP/eRnT3kB3/hscHhZwoODlZubq42btyoOnXq6Morr9TJkyf1+eef609/+lNJPGVAIT/3kZ095Oc+srOH/OA3Smrw1I8//mgcDoe59NJLzdNPP11STxOwyM99ZGcP+bmP7OwhP/iDEh0cnpycrKFDh6p8+fIl9RQBjfzcR3b2kJ/7yM4e8oOvK9HCCQAAIJCU6FV1AAAAgYTCCQAAwEUUTgAAAC6icAIAAHARhRMAAICLKJwAAABcROEEAADgIgonAAHhkUceUdOmTUv9eVNSUuRwOORwONS7d29re6dOnfSPf/zDI8+xY8cO6zm88RoB/KFE1qoDAE9yOBwXfHzw4MGaMmWK/v73v5dSi4ravHmzqlatat3/5JNPFBoa6pFj16pVS/v27dP//d//aeHChR45JgD3UDgB8Hn79u2zvn7//fc1fvx4bd682doWHh6uyMhIRUZGeqN5kqSqVauqYsWK1v3KlSt77NjBwcGqVq2aV18fgNM4VQfA51WrVs26xcTEyOFwFNl29qm6O++8U71799YTTzyh2NhYVaxYUY8++qjy8vL0z3/+U5UrV1bNmjU1Y8YMp+dKT09X//79ValSJV1yySXq1auXduzYUew2n32qburUqWrQoIHKly+v2NhY3XLLLdZjp06d0n333aeqVauqfPnyateunVatWlXs5wRQ8iicAASsb775Rnv37tWSJUs0efJkPfLII+rZs6cqVaqklStXatiwYRo2bJh2794tScrOzlbnzp0VGRmpJUuWaNmyZYqMjFT37t2Vk5PjdjtWr16t++67TxMmTNDmzZs1b948dejQwXp87Nix+vjjj/XGG29o7dq1ql+/vpKSknTo0CHbGQDwLAonAAGrcuXKeuGFF9SwYUPdddddatiwobKzs/XQQw+pQYMGevDBBxUWFqbly5dLkt577z0FBQXp1Vdf1dVXX62rrrpKr7/+unbt2qWUlBS327Fr1y5VqFBBPXv2VO3atdWsWTPdd999kqTjx49r2rRpmjRpknr06KH4+Hi98sorCg8P12uvveaJGAB4EGOcAASsRo0aKSjoj78PY2Nj1bhxY+t+cHCwLrnkEh04cECStGbNGm3btk1RUVFOxzl58qR+/vlnt9uRmJio2rVrq169eurevbu6d++um2++WREREfr555+Vm5urtm3bWvuHhobquuuu048//uj2cwIoGRROAALW2Ve1ORyOc24rKCiQJBUUFCghIUFvv/12kWNVqVLF7XZERUVp7dq1SklJ0VdffaXx48frkUce0apVq2SMsdpxJmPMRa8mBFD6OFUHAL+79tprtXXrVlWtWlX169d3usXExNg6dkhIiLp27aqnn35aGzZs0I4dO/TNN9+ofv36CgsL07Jly6x9c3NztXr1al111VV2XxIAD6NwAoDf3Xbbbbr00kvVq1cvLV26VNu3b9fixYs1cuRI7dmzx+3jfvHFF3rhhReUmpqqnTt36s0331RBQYEaNmyoChUq6N5779U///lPzZs3T2lpafrLX/6i7OxsDR061IOvDoAncKoOAH4XERGhJUuW6IEHHlCfPn109OhRXXbZZerSpYuio6PdPm7FihX1ySef6JFHHtHJkyfVoEEDvfvuu2rUqJEk6cknn1RBQYFuv/12HT16VM2bN9f8+fNVqVIlT700AB7iMIUn2AEAxZaSkqLOnTvr8OHDThNgloRHHnlEn376qVJTU0v0eQCcH6fqAMADatasqYEDB5bIsXft2qXIyEg98cQTJXJ8AK6jxwkAbDhx4oTS09MlSZGRkapWrZrHnyMvL8+avbxcuXKqVauWx58DgGsonAAAAFzEqToAAAAXUTgBAAC4iMIJAADARRROAAAALqJwAgAAcBGFEwAAgIsonAAAAFxE4QQAAOCi/wfgSACw0biCdAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "lc_path = Path(\"$GAMMAPY_DATA/estimators/\")\n", + "lc_filename = \"pks2155_hess_lc/pks2155_hess_lc.fits\"\n", + "\n", + "lc = FluxPoints.read(lc_path/lc_filename, format=\"lightcurve\")\n", + "odata = lc.norm.data.flatten()\n", + "omean = odata.mean()\n", + "ostd = odata.std()\n", + "npoints = len(lc.norm.data)*10\n", + "times = lc.geom.axes[\"time\"].edges\n", + "tref = lc.geom.axes[\"time\"].reference_time\n", + "smax = np.diff(times).max()/10\n", + "lc.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "530fa958-3965-4753-a119-21af155999df", + "metadata": {}, + "source": [ + "## Function definition ##\n", + "\n", + "Some simple function definitions for PSD and PDF models, with their default parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d68f9022-debe-4a0f-b484-f23c7fa04de4", + "metadata": {}, + "outputs": [], + "source": [ + "def emm_gammalognorm(x, wgamma, a, s, loc, scale):\n", + " return wgamma*gamma.pdf(x, a) + (1-wgamma)*lognorm.pdf(x, s, loc, scale)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "9b95c838-5a0e-4739-90aa-53b91bd712e1", + "metadata": {}, + "outputs": [], + "source": [ + "def bpl(x, norm, aup, adn, x0):\n", + " return norm*(x**(-adn))/(1+((x/x0)**(aup-adn)))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "cadd0727-4527-40eb-99ca-b802a9306b71", + "metadata": {}, + "outputs": [], + "source": [ + "def pl(x, index):\n", + " return x**index" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "8b70ce94-ba71-43ef-80be-70b15e1a1d6f", + "metadata": {}, + "outputs": [], + "source": [ + "bpl_params = {\"norm\":1, \"aup\":2.4, \"adn\":3, \"x0\":0.1}\n", + "gl_params = {\"wgamma\":0.82,\"a\":5.67, \"s\":0.31, \"loc\":2.14, \"scale\":1}\n", + "ln_params = {'s': 0.5, 'loc': 1.5, 'scale': 1}\n", + "pl_params = {\"index\": -1.4}" + ] + }, + { + "cell_type": "markdown", + "id": "25dd6825-abbb-436e-9c12-b4886daf5c05", + "metadata": {}, + "source": [ + "## The Emmanoulopoulos algorithm ##\n", + "\n", + "The algorithm requires a PDF and PSD shape, the number of points to simulate and spacing between the points (as an astropy Quantity). Optionally can be passed: parameters for the PSD and PDF, random state for reproducibility, maximum number of iterations for the internal loop, number of chunk factor by which the length is multiplicated to avoid red noise leakage, target mean and standard deviation of the time series, whether to add poissonian noise internally to simulate observational effects." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "6570bb6c", + "metadata": {}, + "outputs": [], + "source": [ + "def TimmerKonig_lightcurve_simulator(\n", + " power_spectrum,\n", + " npoints,\n", + " spacing,\n", + " nchunks=10,\n", + " random_state=\"random-seed\",\n", + " power_spectrum_params=None,\n", + " mean=0.0,\n", + " std=1.0,\n", + " poisson=False,\n", + "):\n", + "\n", + " if not callable(power_spectrum):\n", + " raise ValueError(\n", + " \"The power spectrum has to be provided as a callable function.\"\n", + " )\n", + "\n", + " if not isinstance(npoints * nchunks, int):\n", + " raise TypeError(\"npoints and nchunks must be integers\")\n", + "\n", + " if poisson:\n", + " if isinstance(mean, u.Quantity):\n", + " wmean = mean.value * spacing.value\n", + " else:\n", + " wmean = mean * spacing.value\n", + " if wmean < 1.0:\n", + " raise Warning(\n", + " \"Poisson noise was requested but the target mean is too low - resulting counts will likely be 0.\"\n", + " )\n", + "\n", + " random_state = get_random_state(random_state)\n", + "\n", + " npoints_ext = npoints * nchunks\n", + "\n", + " frequencies = np.fft.fftfreq(npoints_ext, spacing.value)\n", + "\n", + " # To obtain real data only the positive or negative part of the frequency is necessary.\n", + " real_frequencies = np.sort(np.abs(frequencies[frequencies < 0]))\n", + "\n", + " if power_spectrum_params:\n", + " periodogram = power_spectrum(real_frequencies, **power_spectrum_params)\n", + " else:\n", + " periodogram = power_spectrum(real_frequencies)\n", + "\n", + " real_part = random_state.normal(0, 1, len(periodogram) - 1)\n", + " imaginary_part = random_state.normal(0, 1, len(periodogram) - 1)\n", + "\n", + " # Nyquist frequency component handling\n", + " if npoints_ext % 2 == 0:\n", + " idx0 = -2\n", + " random_factor = random_state.normal(0, 1)\n", + " else:\n", + " idx0 = -1\n", + " random_factor = random_state.normal(0, 1) + 1j * random_state.normal(0, 1)\n", + "\n", + " fourier_coeffs = np.concatenate(\n", + " [\n", + " np.sqrt(0.5 * periodogram[:-1]) * (real_part + 1j * imaginary_part),\n", + " np.sqrt(0.5 * periodogram[-1:]) * random_factor,\n", + " ]\n", + " )\n", + " fourier_coeffs = np.concatenate(\n", + " [fourier_coeffs, np.conjugate(fourier_coeffs[idx0::-1])]\n", + " )\n", + "\n", + " fourier_coeffs = np.insert(fourier_coeffs, 0, 0)\n", + " time_series = np.fft.ifft(fourier_coeffs).real\n", + "\n", + " ndiv = npoints_ext // (2 * nchunks)\n", + " setstart = npoints_ext // 2 - ndiv\n", + " setend = npoints_ext // 2 + ndiv\n", + " if npoints % 2 != 0:\n", + " setend = setend + 1\n", + " time_series = time_series[setstart:setend]\n", + "\n", + " time_series = (time_series - time_series.mean()) / time_series.std()\n", + " time_series = time_series * std + mean\n", + "\n", + " if poisson:\n", + " time_series = (\n", + " random_state.poisson(\n", + " np.where(time_series >= 0, time_series, 0) * spacing.value\n", + " )\n", + " / spacing.value\n", + " )\n", + "\n", + " time_axis = np.linspace(0, npoints * spacing.value, npoints) * spacing.unit\n", + "\n", + " return time_series, time_axis\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "58c4545b-8713-4c40-9f80-e495c3299633", + "metadata": {}, + "outputs": [], + "source": [ + "def Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints, spacing, pdf_params=None, psd_params=None, random_state=\"random-seed\", imax = 1000, nchunks=10, mean=0.0, std=1.0, poisson=False):\n", + " \n", + " target_cps = 0.2\n", + " lc_norm, taxis = TimmerKonig_lightcurve_simulator(psd, npoints, spacing, nchunks = nchunks, power_spectrum_params=psd_params, random_state=random_state)\n", + "\n", + " random_state = get_random_state(random_state)\n", + " \n", + " fft_norm = np.fft.rfft(lc_norm)\n", + "\n", + " a_norm = np.abs(fft_norm)/npoints\n", + " phi_norm = np.angle(fft_norm)\n", + "\n", + " if \"scale\" in pdf_params: scale = pdf_params.get(\"scale\")\n", + " else: scale = 1\n", + " \n", + " xx = np.linspace(0, scale*10, 1000)\n", + " lc_sim = np.interp(random_state.rand(npoints), np.cumsum(pdf(xx, **pdf_params))/np.sum(pdf(xx, **pdf_params)), xx)\n", + " lc_sim = (lc_sim - lc_sim.mean())/lc_sim.std()\n", + "\n", + " nconv = True\n", + " i=0\n", + " while nconv and i= 0, lc_sim, 0) * spacing.decompose().value*target_cps\n", + " )\n", + " / (spacing.decompose().value*target_cps)\n", + " )\n", + " \n", + " return lc_sim, taxis" + ] + }, + { + "cell_type": "markdown", + "id": "6bbdf21a-5463-4730-b1bd-4f72fbd4b029", + "metadata": {}, + "source": [ + "## Envelope and fitting ##\n", + "\n", + "The envelope function returns a set of periodogram extracted from a number of simulations nsims that use the same parameters.\n", + "\n", + "These envelopes can then be used via the x2_fit function to fit the requested PSD to an observed periodogram." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "4d6c825e-1d05-46fc-beeb-4cfd3f2a0d42", + "metadata": {}, + "outputs": [], + "source": [ + "def lightcurve_psd_envelope(psd, npoints, spacing, pdf=None, nsims=10000, pdf_params=None, psd_params=None, simulator=\"TK\", mean=0., std=1., oversample=10, poisson=False):\n", + " npoints_ext = npoints*oversample\n", + " spacing_ext = spacing/oversample\n", + " if simulator== \"TK\" : tseries, taxis = TimmerKonig_lightcurve_simulator(psd, npoints_ext, spacing_ext, power_spectrum_params=psd_params, mean=mean, std=std, poisson=poisson)\n", + " elif simulator== \"EMM\": tseries, taxis = Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints_ext, spacing_ext, pdf_params=pdf_params, psd_params=psd_params, mean=mean, std=std, poisson=poisson)\n", + " freqs, pg = periodogram(tseries, 1/spacing_ext.value)\n", + " envelopes_psd = np.empty((nsims, npoints//2))\n", + " envelopes_psd[0] = pg[1:npoints//2+1]\n", + " \n", + " for _ in range(1, nsims):\n", + " if simulator== \"TK\" : tseries, taxis = TimmerKonig_lightcurve_simulator(psd, npoints_ext, spacing_ext, power_spectrum_params=psd_params, mean=mean, std=std, poisson=poisson)\n", + " else: tseries, taxis = Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints_ext, spacing_ext, pdf_params=pdf_params, psd_params=psd_params, mean=mean, std=std, poisson=poisson)\n", + "\n", + " freqs, pg = periodogram(tseries, 1/spacing_ext.value)\n", + " envelopes_psd[_] = pg[1:npoints//2+1]\n", + "\n", + " return envelopes_psd, freqs[1:npoints//2+1]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "068ae572-491e-44f4-9835-24c9db07ec2f", + "metadata": {}, + "outputs": [], + "source": [ + "def x2_fit(psd_params_list, pgram, npoints, spacing, psd, pdf=None, pdf_params=None, simulator=\"TK\", nsims=10000, mean=None, std=None, poisson=False):\n", + "\n", + " psd_params_keys = list(inspect.signature(psd).parameters.keys())\n", + "\n", + " if len(psd_params_keys[1:]) != len(psd_params_list): raise ValueError(\"parameter values do not correspond to the request from the psd function\")\n", + " \n", + " psd_params = dict(zip(psd_params_keys[1:], psd_params_list))\n", + " \n", + " envelopes, freqs = lightcurve_psd_envelope(psd, npoints, spacing, pdf=pdf, pdf_params=pdf_params, psd_params=psd_params, simulator=simulator, nsims=nsims, mean=mean, std=std, poisson=poisson)\n", + " \n", + " if len(envelopes[0])!= len(pgram): raise ValueError(\"required length is different than data length!\")\n", + " \n", + " obs = (pgram - envelopes.mean(axis=0))**2/envelopes.std(axis=0)**2\n", + " sim = (envelopes - envelopes.mean(axis=0))**2/envelopes.std(axis=0)**2\n", + " sumobs = np.sum(obs)\n", + " sumsim = np.sum(sim, axis=-1)\n", + " sign = len(np.where(sumobs>=sumsim)[0])/nsims\n", + " \n", + " return sign" + ] + }, + { + "cell_type": "markdown", + "id": "78dd6fa2-c725-42b8-a854-5eefaaec5be2", + "metadata": {}, + "source": [ + "## Simulation ##\n", + "\n", + "The simulation call for the algorithm. Both the TK and EMM algorithms are called with the same power-law PSD. The EMM algorithm uses a lognormal PDF. The difference between TK and EMM algorithms is shown in the leftmost and rightmost plot, where the gaussian vs lognormal shape is evident. The middle plot shows the perfect compatibility in the periodogram. Seed is fixed for reproducibility. " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "9fa4aa20-d5e4-4352-8a7c-6348d5c882cc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1.47301407 -7.35992191] [-1.41604412 -6.92936994]\n", + "CPU times: user 45 ms, sys: 7.22 ms, total: 52.2 ms\n", + "Wall time: 57.5 ms\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "seed = 532019\n", + "#seed = \"random-seed\"\n", + "lctk2, taxis2 = Emmanoulopoulos_lightcurve_simulator(lognorm.pdf, pl, npoints, smax, pdf_params=ln_params, psd_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", + "lctk, taxis = TimmerKonig_lightcurve_simulator(pl, npoints, smax, power_spectrum_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", + "freqstk, pgramtk = periodogram(lctk, 1/smax.value)\n", + "freqstk2, pgramtk2 = periodogram(lctk2, 1/smax.value)\n", + "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15,3))\n", + "ax1.plot(taxis, lctk)\n", + "ax2.loglog(freqstk[1:], pgramtk[1:])\n", + "ax3.hist(lctk)\n", + "ax1.plot(taxis2, lctk2)\n", + "ax2.loglog(freqstk2[1:], pgramtk2[1:])\n", + "ax3.hist(lctk2)\n", + "coeff = np.polyfit(np.log(freqstk[1:]), np.log(pgramtk[1:]), 1)\n", + "coeff2 = np.polyfit(np.log(freqstk2[1:]), np.log(pgramtk2[1:]), 1)\n", + "\n", + "print(coeff, coeff2)" + ] + }, + { + "cell_type": "markdown", + "id": "592cd9e0-55d1-4bbf-93f4-e873b011d43d", + "metadata": {}, + "source": [ + "## Gammapy setup and simulation ##\n", + "\n", + "Setup of geometry for the Gammapy simulation. Generic setup for pointing, energy binning, and IRFs. For realistic simulations, choose IRFs that are consistent with the instrument and observational conditions." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "79fc7316-39ef-490d-9cf9-d714afe9249e", + "metadata": {}, + "outputs": [], + "source": [ + "TimeMapAxis.time_format = \"iso\"\n", + "\n", + "path = Path(\"$GAMMAPY_DATA/cta-caldb\")\n", + "irf_filename = \"Prod5-South-20deg-AverageAz-14MSTs37SSTs.180000s-v0.1.fits.gz\"\n", + "\n", + "irfs = load_irf_dict_from_file(path / irf_filename)\n", + "\n", + "energy_axis = MapAxis.from_energy_bounds(\n", + " energy_min=0.1 * u.TeV, energy_max=100 * u.TeV, nbin=1\n", + ")\n", + "\n", + "energy_axis_true = MapAxis.from_edges(\n", + " np.logspace(-1.2, 2.0, 31), unit=\"TeV\", name=\"energy_true\", interp=\"log\"\n", + ")\n", + "\n", + "time_axis = MapAxis.from_nodes(taxis, name=\"time\", interp=\"lin\")\n", + "\n", + "geom = RegionGeom.create(\"galactic;circle(107.65, -40.17, 5)\", axes=[energy_axis])\n", + "\n", + "pointing_position = SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\")\n", + "pointing = FixedPointingInfo(\n", + " fixed_icrs=SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\").icrs,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8d9aec9b-9f38-4f9b-903e-e5189c7edf6c", + "metadata": {}, + "source": [ + "The time series generated via EMM is taken as a LightCurveTemplateTemporalModel" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "c900eb8e-87ce-4771-8ccc-db627c7a541f", + "metadata": {}, + "outputs": [], + "source": [ + "gti_t0 = tref\n", + "\n", + "spectral_model = PowerLawSpectralModel(amplitude = 1e-10 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", + "\n", + "m = RegionNDMap.create(\n", + " region=PointSkyRegion(center=pointing_position),\n", + " axes=[time_axis],\n", + " unit=\"cm-2s-1TeV-1\",\n", + ")\n", + "\n", + "m.quantity = lctk2\n", + "\n", + "temporal_model = LightCurveTemplateTemporalModel(m, t_ref=gti_t0)\n", + "\n", + "model_simu = SkyModel(\n", + " spectral_model=spectral_model,\n", + " temporal_model=temporal_model,\n", + " name=\"model-simu\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "7ccc6acb-5054-4879-bba9-ae0bd14e6b02", + "metadata": {}, + "source": [ + "Observation timing setup and simulation fo the datasets. The \"observational\" sampling is taken to be much sparser than the synthetic lightcurve, to avoid aliasing." + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "bd889da2-54be-461f-b9a4-a34959e994a7", + "metadata": {}, + "outputs": [], + "source": [ + "lvtm = 10 * u.min\n", + "tstart = gti_t0 + np.arange(npoints/10)*lvtm\n", + "altaz = pointing_position.transform_to(AltAz(obstime = tstart, location = observatory_locations[\"cta_south\"]))" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "f142057c-852f-4605-88d3-b27d63417803", + "metadata": {}, + "outputs": [], + "source": [ + "datasets = Datasets()\n", + "\n", + "empty = SpectrumDataset.create(\n", + "geom=geom, energy_axis_true=energy_axis_true, name=\"empty\"\n", + ")\n", + "\n", + "maker = SpectrumDatasetMaker(selection=[\"exposure\", \"background\", \"edisp\"])\n", + "\n", + "for idx in range(len(tstart)):\n", + " obs = Observation.create(\n", + " pointing=pointing,\n", + " livetime=lvtm,\n", + " tstart=tstart[idx],\n", + " irfs=irfs,\n", + " reference_time=gti_t0,\n", + " obs_id=idx,\n", + " location=observatory_locations[\"cta_south\"],\n", + " )\n", + " empty_i = empty.copy(name=f\"dataset-{idx}\")\n", + " dataset = maker.run(empty_i, obs)\n", + " dataset.models = model_simu\n", + " dataset.fake()\n", + " datasets.append(dataset)\n", + "\n", + "\n", + "spectral_model = PowerLawSpectralModel(amplitude = 7e-11 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", + "model_fit = SkyModel(spectral_model=spectral_model, name=\"model-fit\")\n", + "datasets.models = model_fit" + ] + }, + { + "cell_type": "markdown", + "id": "725f0466-21c4-4da2-a5da-21486ef0a43d", + "metadata": {}, + "source": [ + "Lightcurve estimator setup and run." + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "6150efce-4ced-4237-bf53-12fbd5fe9a30", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "lc_maker_1d = LightCurveEstimator(\n", + " energy_edges=[0.1, 100] * u.TeV,\n", + " source=\"model-fit\",\n", + " selection_optional=[\"ul\"],\n", + ")\n", + "\n", + "lc_1d = lc_maker_1d.run(datasets)\n", + "lc_1d.plot();" + ] + }, + { + "cell_type": "markdown", + "id": "b27cd811-a990-48c1-93af-baee1198432c", + "metadata": {}, + "source": [ + "Assessment of the properties of the \"observed\" lightcurve in the time and frequency domain." + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "e2ee2f7b-c8ee-4251-b276-75d4cd247b66", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4034358347577256\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = lc_1d.norm.data.flatten()\n", + "dmean = data.mean()\n", + "dstd = data.std()\n", + "dnpoints = len(data)\n", + "dtimes = lc_1d.geom.axes[\"time\"].edges\n", + "dsmax = np.diff(dtimes).max()\n", + "ffreqs, pgram = periodogram(data, 1/dsmax.value)\n", + "coeff = np.polyfit(np.log(ffreqs[1:]), np.log(pgram[1:]), 1)\n", + "print(coeff[0])\n", + "plt.loglog(ffreqs[1:], pgram[1:])" + ] + }, + { + "cell_type": "markdown", + "id": "759e1ddd-98dc-4854-8ba7-c1e58facbb87", + "metadata": {}, + "source": [ + "### Fitting ###\n", + "\n", + "The x2_fit function is used as a cost function with the scipy minimizer, providing a fit of the spectral index for the \"observed\" lightcurve assuming a power-law PSD. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b08789fe-2a0a-4056-8b38-1aaea9946059", + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'pgram' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m:2\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'pgram' is not defined" + ] + } + ], + "source": [ + "%%time\n", + "initial_pars = [-2]\n", + "results = minimize(x2_fit, initial_pars, args=(pgram[1:], dnpoints, dsmax, pl, lognorm.pdf, ln_params, \"EMM\", 10000, dmean, dstd, False), method=\"Powell\", options={\"disp\": True})\n", + "print(results)\n", + "envelopes, freqs = lightcurve_psd_envelope(pl, dnpoints, dsmax, psd_params={\"index\": results.x}, simulator=\"EMM\", pdf = lognorm.pdf, pdf_params = ln_params , nsims=10000, mean=dmean, std=dstd, poisson=False)\n", + "plt.violinplot(envelopes, freqs, widths=np.diff(freqs).min(), showmedians=True);\n", + "plt.plot(freqs, pgram[1:], linewidth=0.7, marker=\"d\")\n", + "plt.yscale(\"log\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "939d6039", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/recipes/env.yml b/recipes/env.yml new file mode 100644 index 0000000..dc7d48b --- /dev/null +++ b/recipes/env.yml @@ -0,0 +1,13 @@ +# Declare your specific environment + +name: fit-psd-lightcurve + +channels: + - conda-forge + +dependencies: + - gammapy=1.2 + - python=3.11 + - scipy + - jupyter + - matplotlib From 5487cbca923e2f32689ef098d8213d610f71b82e Mon Sep 17 00:00:00 2001 From: Claudio Galelli Date: Fri, 23 Aug 2024 12:36:33 +0200 Subject: [PATCH 02/13] Move env --- recipes/{ => fit-psd-lightcurve}/env.yml | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename recipes/{ => fit-psd-lightcurve}/env.yml (100%) diff --git a/recipes/env.yml b/recipes/fit-psd-lightcurve/env.yml similarity index 100% rename from recipes/env.yml rename to recipes/fit-psd-lightcurve/env.yml From ab915253a778056c31c9823371d80c12eff87997 Mon Sep 17 00:00:00 2001 From: Claudio Galelli Date: Fri, 23 Aug 2024 12:38:23 +0200 Subject: [PATCH 03/13] move nb to folder --- .../fit-psd-lightcurve.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename recipes/{Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb => fit-psd-lightcurve/fit-psd-lightcurve.ipynb} (100%) diff --git a/recipes/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb b/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb similarity index 100% rename from recipes/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb rename to recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb From 0b7259136f6e9005fdd30b99ba87fc76ee42c7ba Mon Sep 17 00:00:00 2001 From: Claudio Galelli Date: Fri, 23 Aug 2024 12:41:04 +0200 Subject: [PATCH 04/13] Delete recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb --- .../fit-psd-lightcurve.ipynb | 744 ------------------ 1 file changed, 744 deletions(-) delete mode 100644 recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb diff --git a/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb b/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb deleted file mode 100644 index 5632c59..0000000 --- a/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb +++ /dev/null @@ -1,744 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "b4ca33d6-129c-4a59-89d7-f57e39cacfc0", - "metadata": {}, - "source": [ - "# Generating synthetic lightcurves and fitting the power spectral density of a lightcurve #\n", - "\n", - "This notebook presents the advanced Emmanoulopoulos algorithm for the simulation of synthetic lightcurves. The original paper describing the algorithm is linked [here](https://arxiv.org/pdf/1305.0304.pdf). The version implemented here is compatible with the Gammapy implementation of the Timmer-Koenig algorithm.\n", - "The Timmer-Koenig algorithm generates synthetic lightcurve from a chosen power spectral density (PSD) shape. However, it can only generate time series with a gaussian probability density function (PDF). This is adequate for high-statistics astrophysical domains such as the optical or X-rays, but can be in issue when trying to reproduce curves in the gamma-ray domain, where photon counts are lower and statistics are generally Poissonian. The Emmanoulopoulos algorithm tries to solve this issue, combining a requested PSD and PDF in the simulation. It provides accurate synthetic lightcurves in a range of spectral indexes between -1 and -2 for power-law or similar PSDs.\n", - "\n", - "Together with the simulation algorithm the notebook adds a function to compute the PSD envelope for a lightcurve using either the Timmer-Koenig or the Emmanoulopoulos algorithm. This envelope is then used to fit the PSD fot he observed lightcurve, by passing through a tailored chi-squared-like cost function. This complex fitting is necessary to account for the fact that the periodogram of the observed lightcurve is only a possible realization of the PSD model, moreover convoluted with Poissonian noise and instrumental responses. This can lead to biases or deformation due to random fluctuation of the realization if extracted with a simple curve fit of the periodogram.\n", - "\n", - "The results are satisfactory for power-law or broken-power-law PSDs in a physical interval of spectral indexes, between -1 and -2. Using the Emmanoulopoulos algorithm shows consistently better PSD reconstruction over the Timmer-Koenig - this is due to the injected non-gaussian PDF." - ] - }, - { - "cell_type": "markdown", - "id": "b693b292-fa5c-4afa-b013-464389e4092a", - "metadata": {}, - "source": [ - "## Imports ##\n", - "\n", - "The first step is importing some usual packages, needed Astropy utilities, scipy tools for PDFs and minimization, and Gammapy functions and classes for the observational part." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "4678c090-734e-430d-a81e-ff77cf5ef8a0", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from pathlib import Path\n", - "import matplotlib.pyplot as plt\n", - "import inspect\n", - "\n", - "import astropy.units as u\n", - "from astropy.coordinates import SkyCoord, AltAz\n", - "\n", - "from regions import PointSkyRegion\n", - "\n", - "from gammapy.estimators import LightCurveEstimator, FluxPoints\n", - "from gammapy.makers import SpectrumDatasetMaker\n", - "from gammapy.data import Observation, observatory_locations, FixedPointingInfo\n", - "from gammapy.datasets import Datasets, SpectrumDataset\n", - "from gammapy.irf import load_irf_dict_from_file\n", - "from gammapy.maps import MapAxis, RegionGeom, TimeMapAxis, RegionNDMap\n", - "from gammapy.modeling.models import SkyModel, PowerLawSpectralModel, LightCurveTemplateTemporalModel\n", - "from gammapy.estimators.utils import compute_lightcurve_fvar\n", - "from gammapy.utils.random import get_random_state\n", - "\n", - "from scipy.optimize import minimize\n", - "from scipy.signal import periodogram\n", - "from scipy.stats import lognorm" - ] - }, - { - "cell_type": "markdown", - "id": "6ff44b6c-f786-4f7d-bf7c-c27cac5a78dc", - "metadata": {}, - "source": [ - "## Reference Lightcurve ##\n", - "\n", - "As a reference, the notebook uses the H.E.S.S. dataset for the PKS2155 AGN flare of 2006. Data properties such as mean and standard deviation fo the norm, number of points, sampling frequency, are taken from this flare. The synthetic lightcurve will be oversampled by a factor 10." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "330ee851-fcc3-47ad-8b1a-e5bd06d78869", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "lc_path = Path(\"$GAMMAPY_DATA/estimators/\")\n", - "lc_filename = \"pks2155_hess_lc/pks2155_hess_lc.fits\"\n", - "\n", - "lc = FluxPoints.read(lc_path/lc_filename, format=\"lightcurve\")\n", - "odata = lc.norm.data.flatten()\n", - "omean = odata.mean()\n", - "ostd = odata.std()\n", - "npoints = len(lc.norm.data)*10\n", - "times = lc.geom.axes[\"time\"].edges\n", - "tref = lc.geom.axes[\"time\"].reference_time\n", - "smax = np.diff(times).max()/10\n", - "lc.plot()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "530fa958-3965-4753-a119-21af155999df", - "metadata": {}, - "source": [ - "## Function definition ##\n", - "\n", - "Some simple function definitions for PSD and PDF models, with their default parameters." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "d68f9022-debe-4a0f-b484-f23c7fa04de4", - "metadata": {}, - "outputs": [], - "source": [ - "def emm_gammalognorm(x, wgamma, a, s, loc, scale):\n", - " return wgamma*gamma.pdf(x, a) + (1-wgamma)*lognorm.pdf(x, s, loc, scale)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "9b95c838-5a0e-4739-90aa-53b91bd712e1", - "metadata": {}, - "outputs": [], - "source": [ - "def bpl(x, norm, aup, adn, x0):\n", - " return norm*(x**(-adn))/(1+((x/x0)**(aup-adn)))" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "cadd0727-4527-40eb-99ca-b802a9306b71", - "metadata": {}, - "outputs": [], - "source": [ - "def pl(x, index):\n", - " return x**index" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "8b70ce94-ba71-43ef-80be-70b15e1a1d6f", - "metadata": {}, - "outputs": [], - "source": [ - "bpl_params = {\"norm\":1, \"aup\":2.4, \"adn\":3, \"x0\":0.1}\n", - "gl_params = {\"wgamma\":0.82,\"a\":5.67, \"s\":0.31, \"loc\":2.14, \"scale\":1}\n", - "ln_params = {'s': 0.5, 'loc': 1.5, 'scale': 1}\n", - "pl_params = {\"index\": -1.4}" - ] - }, - { - "cell_type": "markdown", - "id": "25dd6825-abbb-436e-9c12-b4886daf5c05", - "metadata": {}, - "source": [ - "## The Emmanoulopoulos algorithm ##\n", - "\n", - "The algorithm requires a PDF and PSD shape, the number of points to simulate and spacing between the points (as an astropy Quantity). Optionally can be passed: parameters for the PSD and PDF, random state for reproducibility, maximum number of iterations for the internal loop, number of chunk factor by which the length is multiplicated to avoid red noise leakage, target mean and standard deviation of the time series, whether to add poissonian noise internally to simulate observational effects." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "6570bb6c", - "metadata": {}, - "outputs": [], - "source": [ - "def TimmerKonig_lightcurve_simulator(\n", - " power_spectrum,\n", - " npoints,\n", - " spacing,\n", - " nchunks=10,\n", - " random_state=\"random-seed\",\n", - " power_spectrum_params=None,\n", - " mean=0.0,\n", - " std=1.0,\n", - " poisson=False,\n", - "):\n", - "\n", - " if not callable(power_spectrum):\n", - " raise ValueError(\n", - " \"The power spectrum has to be provided as a callable function.\"\n", - " )\n", - "\n", - " if not isinstance(npoints * nchunks, int):\n", - " raise TypeError(\"npoints and nchunks must be integers\")\n", - "\n", - " if poisson:\n", - " if isinstance(mean, u.Quantity):\n", - " wmean = mean.value * spacing.value\n", - " else:\n", - " wmean = mean * spacing.value\n", - " if wmean < 1.0:\n", - " raise Warning(\n", - " \"Poisson noise was requested but the target mean is too low - resulting counts will likely be 0.\"\n", - " )\n", - "\n", - " random_state = get_random_state(random_state)\n", - "\n", - " npoints_ext = npoints * nchunks\n", - "\n", - " frequencies = np.fft.fftfreq(npoints_ext, spacing.value)\n", - "\n", - " # To obtain real data only the positive or negative part of the frequency is necessary.\n", - " real_frequencies = np.sort(np.abs(frequencies[frequencies < 0]))\n", - "\n", - " if power_spectrum_params:\n", - " periodogram = power_spectrum(real_frequencies, **power_spectrum_params)\n", - " else:\n", - " periodogram = power_spectrum(real_frequencies)\n", - "\n", - " real_part = random_state.normal(0, 1, len(periodogram) - 1)\n", - " imaginary_part = random_state.normal(0, 1, len(periodogram) - 1)\n", - "\n", - " # Nyquist frequency component handling\n", - " if npoints_ext % 2 == 0:\n", - " idx0 = -2\n", - " random_factor = random_state.normal(0, 1)\n", - " else:\n", - " idx0 = -1\n", - " random_factor = random_state.normal(0, 1) + 1j * random_state.normal(0, 1)\n", - "\n", - " fourier_coeffs = np.concatenate(\n", - " [\n", - " np.sqrt(0.5 * periodogram[:-1]) * (real_part + 1j * imaginary_part),\n", - " np.sqrt(0.5 * periodogram[-1:]) * random_factor,\n", - " ]\n", - " )\n", - " fourier_coeffs = np.concatenate(\n", - " [fourier_coeffs, np.conjugate(fourier_coeffs[idx0::-1])]\n", - " )\n", - "\n", - " fourier_coeffs = np.insert(fourier_coeffs, 0, 0)\n", - " time_series = np.fft.ifft(fourier_coeffs).real\n", - "\n", - " ndiv = npoints_ext // (2 * nchunks)\n", - " setstart = npoints_ext // 2 - ndiv\n", - " setend = npoints_ext // 2 + ndiv\n", - " if npoints % 2 != 0:\n", - " setend = setend + 1\n", - " time_series = time_series[setstart:setend]\n", - "\n", - " time_series = (time_series - time_series.mean()) / time_series.std()\n", - " time_series = time_series * std + mean\n", - "\n", - " if poisson:\n", - " time_series = (\n", - " random_state.poisson(\n", - " np.where(time_series >= 0, time_series, 0) * spacing.value\n", - " )\n", - " / spacing.value\n", - " )\n", - "\n", - " time_axis = np.linspace(0, npoints * spacing.value, npoints) * spacing.unit\n", - "\n", - " return time_series, time_axis\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "58c4545b-8713-4c40-9f80-e495c3299633", - "metadata": {}, - "outputs": [], - "source": [ - "def Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints, spacing, pdf_params=None, psd_params=None, random_state=\"random-seed\", imax = 1000, nchunks=10, mean=0.0, std=1.0, poisson=False):\n", - " \n", - " target_cps = 0.2\n", - " lc_norm, taxis = TimmerKonig_lightcurve_simulator(psd, npoints, spacing, nchunks = nchunks, power_spectrum_params=psd_params, random_state=random_state)\n", - "\n", - " random_state = get_random_state(random_state)\n", - " \n", - " fft_norm = np.fft.rfft(lc_norm)\n", - "\n", - " a_norm = np.abs(fft_norm)/npoints\n", - " phi_norm = np.angle(fft_norm)\n", - "\n", - " if \"scale\" in pdf_params: scale = pdf_params.get(\"scale\")\n", - " else: scale = 1\n", - " \n", - " xx = np.linspace(0, scale*10, 1000)\n", - " lc_sim = np.interp(random_state.rand(npoints), np.cumsum(pdf(xx, **pdf_params))/np.sum(pdf(xx, **pdf_params)), xx)\n", - " lc_sim = (lc_sim - lc_sim.mean())/lc_sim.std()\n", - "\n", - " nconv = True\n", - " i=0\n", - " while nconv and i= 0, lc_sim, 0) * spacing.decompose().value*target_cps\n", - " )\n", - " / (spacing.decompose().value*target_cps)\n", - " )\n", - " \n", - " return lc_sim, taxis" - ] - }, - { - "cell_type": "markdown", - "id": "6bbdf21a-5463-4730-b1bd-4f72fbd4b029", - "metadata": {}, - "source": [ - "## Envelope and fitting ##\n", - "\n", - "The envelope function returns a set of periodogram extracted from a number of simulations nsims that use the same parameters.\n", - "\n", - "These envelopes can then be used via the x2_fit function to fit the requested PSD to an observed periodogram." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "4d6c825e-1d05-46fc-beeb-4cfd3f2a0d42", - "metadata": {}, - "outputs": [], - "source": [ - "def lightcurve_psd_envelope(psd, npoints, spacing, pdf=None, nsims=10000, pdf_params=None, psd_params=None, simulator=\"TK\", mean=0., std=1., oversample=10, poisson=False):\n", - " npoints_ext = npoints*oversample\n", - " spacing_ext = spacing/oversample\n", - " if simulator== \"TK\" : tseries, taxis = TimmerKonig_lightcurve_simulator(psd, npoints_ext, spacing_ext, power_spectrum_params=psd_params, mean=mean, std=std, poisson=poisson)\n", - " elif simulator== \"EMM\": tseries, taxis = Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints_ext, spacing_ext, pdf_params=pdf_params, psd_params=psd_params, mean=mean, std=std, poisson=poisson)\n", - " freqs, pg = periodogram(tseries, 1/spacing_ext.value)\n", - " envelopes_psd = np.empty((nsims, npoints//2))\n", - " envelopes_psd[0] = pg[1:npoints//2+1]\n", - " \n", - " for _ in range(1, nsims):\n", - " if simulator== \"TK\" : tseries, taxis = TimmerKonig_lightcurve_simulator(psd, npoints_ext, spacing_ext, power_spectrum_params=psd_params, mean=mean, std=std, poisson=poisson)\n", - " else: tseries, taxis = Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints_ext, spacing_ext, pdf_params=pdf_params, psd_params=psd_params, mean=mean, std=std, poisson=poisson)\n", - "\n", - " freqs, pg = periodogram(tseries, 1/spacing_ext.value)\n", - " envelopes_psd[_] = pg[1:npoints//2+1]\n", - "\n", - " return envelopes_psd, freqs[1:npoints//2+1]" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "068ae572-491e-44f4-9835-24c9db07ec2f", - "metadata": {}, - "outputs": [], - "source": [ - "def x2_fit(psd_params_list, pgram, npoints, spacing, psd, pdf=None, pdf_params=None, simulator=\"TK\", nsims=10000, mean=None, std=None, poisson=False):\n", - "\n", - " psd_params_keys = list(inspect.signature(psd).parameters.keys())\n", - "\n", - " if len(psd_params_keys[1:]) != len(psd_params_list): raise ValueError(\"parameter values do not correspond to the request from the psd function\")\n", - " \n", - " psd_params = dict(zip(psd_params_keys[1:], psd_params_list))\n", - " \n", - " envelopes, freqs = lightcurve_psd_envelope(psd, npoints, spacing, pdf=pdf, pdf_params=pdf_params, psd_params=psd_params, simulator=simulator, nsims=nsims, mean=mean, std=std, poisson=poisson)\n", - " \n", - " if len(envelopes[0])!= len(pgram): raise ValueError(\"required length is different than data length!\")\n", - " \n", - " obs = (pgram - envelopes.mean(axis=0))**2/envelopes.std(axis=0)**2\n", - " sim = (envelopes - envelopes.mean(axis=0))**2/envelopes.std(axis=0)**2\n", - " sumobs = np.sum(obs)\n", - " sumsim = np.sum(sim, axis=-1)\n", - " sign = len(np.where(sumobs>=sumsim)[0])/nsims\n", - " \n", - " return sign" - ] - }, - { - "cell_type": "markdown", - "id": "78dd6fa2-c725-42b8-a854-5eefaaec5be2", - "metadata": {}, - "source": [ - "## Simulation ##\n", - "\n", - "The simulation call for the algorithm. Both the TK and EMM algorithms are called with the same power-law PSD. The EMM algorithm uses a lognormal PDF. The difference between TK and EMM algorithms is shown in the leftmost and rightmost plot, where the gaussian vs lognormal shape is evident. The middle plot shows the perfect compatibility in the periodogram. Seed is fixed for reproducibility. " - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "9fa4aa20-d5e4-4352-8a7c-6348d5c882cc", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-1.47301407 -7.35992191] [-1.41604412 -6.92936994]\n", - "CPU times: user 45 ms, sys: 7.22 ms, total: 52.2 ms\n", - "Wall time: 57.5 ms\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "%%time\n", - "seed = 532019\n", - "#seed = \"random-seed\"\n", - "lctk2, taxis2 = Emmanoulopoulos_lightcurve_simulator(lognorm.pdf, pl, npoints, smax, pdf_params=ln_params, psd_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", - "lctk, taxis = TimmerKonig_lightcurve_simulator(pl, npoints, smax, power_spectrum_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", - "freqstk, pgramtk = periodogram(lctk, 1/smax.value)\n", - "freqstk2, pgramtk2 = periodogram(lctk2, 1/smax.value)\n", - "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15,3))\n", - "ax1.plot(taxis, lctk)\n", - "ax2.loglog(freqstk[1:], pgramtk[1:])\n", - "ax3.hist(lctk)\n", - "ax1.plot(taxis2, lctk2)\n", - "ax2.loglog(freqstk2[1:], pgramtk2[1:])\n", - "ax3.hist(lctk2)\n", - "coeff = np.polyfit(np.log(freqstk[1:]), np.log(pgramtk[1:]), 1)\n", - "coeff2 = np.polyfit(np.log(freqstk2[1:]), np.log(pgramtk2[1:]), 1)\n", - "\n", - "print(coeff, coeff2)" - ] - }, - { - "cell_type": "markdown", - "id": "592cd9e0-55d1-4bbf-93f4-e873b011d43d", - "metadata": {}, - "source": [ - "## Gammapy setup and simulation ##\n", - "\n", - "Setup of geometry for the Gammapy simulation. Generic setup for pointing, energy binning, and IRFs. For realistic simulations, choose IRFs that are consistent with the instrument and observational conditions." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "79fc7316-39ef-490d-9cf9-d714afe9249e", - "metadata": {}, - "outputs": [], - "source": [ - "TimeMapAxis.time_format = \"iso\"\n", - "\n", - "path = Path(\"$GAMMAPY_DATA/cta-caldb\")\n", - "irf_filename = \"Prod5-South-20deg-AverageAz-14MSTs37SSTs.180000s-v0.1.fits.gz\"\n", - "\n", - "irfs = load_irf_dict_from_file(path / irf_filename)\n", - "\n", - "energy_axis = MapAxis.from_energy_bounds(\n", - " energy_min=0.1 * u.TeV, energy_max=100 * u.TeV, nbin=1\n", - ")\n", - "\n", - "energy_axis_true = MapAxis.from_edges(\n", - " np.logspace(-1.2, 2.0, 31), unit=\"TeV\", name=\"energy_true\", interp=\"log\"\n", - ")\n", - "\n", - "time_axis = MapAxis.from_nodes(taxis, name=\"time\", interp=\"lin\")\n", - "\n", - "geom = RegionGeom.create(\"galactic;circle(107.65, -40.17, 5)\", axes=[energy_axis])\n", - "\n", - "pointing_position = SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\")\n", - "pointing = FixedPointingInfo(\n", - " fixed_icrs=SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\").icrs,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "8d9aec9b-9f38-4f9b-903e-e5189c7edf6c", - "metadata": {}, - "source": [ - "The time series generated via EMM is taken as a LightCurveTemplateTemporalModel" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "c900eb8e-87ce-4771-8ccc-db627c7a541f", - "metadata": {}, - "outputs": [], - "source": [ - "gti_t0 = tref\n", - "\n", - "spectral_model = PowerLawSpectralModel(amplitude = 1e-10 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", - "\n", - "m = RegionNDMap.create(\n", - " region=PointSkyRegion(center=pointing_position),\n", - " axes=[time_axis],\n", - " unit=\"cm-2s-1TeV-1\",\n", - ")\n", - "\n", - "m.quantity = lctk2\n", - "\n", - "temporal_model = LightCurveTemplateTemporalModel(m, t_ref=gti_t0)\n", - "\n", - "model_simu = SkyModel(\n", - " spectral_model=spectral_model,\n", - " temporal_model=temporal_model,\n", - " name=\"model-simu\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "7ccc6acb-5054-4879-bba9-ae0bd14e6b02", - "metadata": {}, - "source": [ - "Observation timing setup and simulation fo the datasets. The \"observational\" sampling is taken to be much sparser than the synthetic lightcurve, to avoid aliasing." - ] - }, - { - "cell_type": "code", - "execution_count": 100, - "id": "bd889da2-54be-461f-b9a4-a34959e994a7", - "metadata": {}, - "outputs": [], - "source": [ - "lvtm = 10 * u.min\n", - "tstart = gti_t0 + np.arange(npoints/10)*lvtm\n", - "altaz = pointing_position.transform_to(AltAz(obstime = tstart, location = observatory_locations[\"cta_south\"]))" - ] - }, - { - "cell_type": "code", - "execution_count": 101, - "id": "f142057c-852f-4605-88d3-b27d63417803", - "metadata": {}, - "outputs": [], - "source": [ - "datasets = Datasets()\n", - "\n", - "empty = SpectrumDataset.create(\n", - "geom=geom, energy_axis_true=energy_axis_true, name=\"empty\"\n", - ")\n", - "\n", - "maker = SpectrumDatasetMaker(selection=[\"exposure\", \"background\", \"edisp\"])\n", - "\n", - "for idx in range(len(tstart)):\n", - " obs = Observation.create(\n", - " pointing=pointing,\n", - " livetime=lvtm,\n", - " tstart=tstart[idx],\n", - " irfs=irfs,\n", - " reference_time=gti_t0,\n", - " obs_id=idx,\n", - " location=observatory_locations[\"cta_south\"],\n", - " )\n", - " empty_i = empty.copy(name=f\"dataset-{idx}\")\n", - " dataset = maker.run(empty_i, obs)\n", - " dataset.models = model_simu\n", - " dataset.fake()\n", - " datasets.append(dataset)\n", - "\n", - "\n", - "spectral_model = PowerLawSpectralModel(amplitude = 7e-11 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", - "model_fit = SkyModel(spectral_model=spectral_model, name=\"model-fit\")\n", - "datasets.models = model_fit" - ] - }, - { - "cell_type": "markdown", - "id": "725f0466-21c4-4da2-a5da-21486ef0a43d", - "metadata": {}, - "source": [ - "Lightcurve estimator setup and run." - ] - }, - { - "cell_type": "code", - "execution_count": 102, - "id": "6150efce-4ced-4237-bf53-12fbd5fe9a30", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "lc_maker_1d = LightCurveEstimator(\n", - " energy_edges=[0.1, 100] * u.TeV,\n", - " source=\"model-fit\",\n", - " selection_optional=[\"ul\"],\n", - ")\n", - "\n", - "lc_1d = lc_maker_1d.run(datasets)\n", - "lc_1d.plot();" - ] - }, - { - "cell_type": "markdown", - "id": "b27cd811-a990-48c1-93af-baee1198432c", - "metadata": {}, - "source": [ - "Assessment of the properties of the \"observed\" lightcurve in the time and frequency domain." - ] - }, - { - "cell_type": "code", - "execution_count": 103, - "id": "e2ee2f7b-c8ee-4251-b276-75d4cd247b66", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-1.4034358347577256\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 103, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "data = lc_1d.norm.data.flatten()\n", - "dmean = data.mean()\n", - "dstd = data.std()\n", - "dnpoints = len(data)\n", - "dtimes = lc_1d.geom.axes[\"time\"].edges\n", - "dsmax = np.diff(dtimes).max()\n", - "ffreqs, pgram = periodogram(data, 1/dsmax.value)\n", - "coeff = np.polyfit(np.log(ffreqs[1:]), np.log(pgram[1:]), 1)\n", - "print(coeff[0])\n", - "plt.loglog(ffreqs[1:], pgram[1:])" - ] - }, - { - "cell_type": "markdown", - "id": "759e1ddd-98dc-4854-8ba7-c1e58facbb87", - "metadata": {}, - "source": [ - "### Fitting ###\n", - "\n", - "The x2_fit function is used as a cost function with the scipy minimizer, providing a fit of the spectral index for the \"observed\" lightcurve assuming a power-law PSD. " - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "b08789fe-2a0a-4056-8b38-1aaea9946059", - "metadata": { - "tags": [ - "nbsphinx-thumbnail" - ] - }, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'pgram' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m:2\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'pgram' is not defined" - ] - } - ], - "source": [ - "%%time\n", - "initial_pars = [-2]\n", - "results = minimize(x2_fit, initial_pars, args=(pgram[1:], dnpoints, dsmax, pl, lognorm.pdf, ln_params, \"EMM\", 10000, dmean, dstd, False), method=\"Powell\", options={\"disp\": True})\n", - "print(results)\n", - "envelopes, freqs = lightcurve_psd_envelope(pl, dnpoints, dsmax, psd_params={\"index\": results.x}, simulator=\"EMM\", pdf = lognorm.pdf, pdf_params = ln_params , nsims=10000, mean=dmean, std=dstd, poisson=False)\n", - "plt.violinplot(envelopes, freqs, widths=np.diff(freqs).min(), showmedians=True);\n", - "plt.plot(freqs, pgram[1:], linewidth=0.7, marker=\"d\")\n", - "plt.yscale(\"log\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "939d6039", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From a207d3241b2a0c2c55a21838cad297cf5dbe3344 Mon Sep 17 00:00:00 2001 From: Claudio Galelli Date: Fri, 23 Aug 2024 12:41:34 +0200 Subject: [PATCH 05/13] Add files via upload --- .../fit-psd-lightcurve.ipynb | 744 ++++++++++++++++++ 1 file changed, 744 insertions(+) create mode 100644 recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb diff --git a/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb b/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb new file mode 100644 index 0000000..5632c59 --- /dev/null +++ b/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb @@ -0,0 +1,744 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b4ca33d6-129c-4a59-89d7-f57e39cacfc0", + "metadata": {}, + "source": [ + "# Generating synthetic lightcurves and fitting the power spectral density of a lightcurve #\n", + "\n", + "This notebook presents the advanced Emmanoulopoulos algorithm for the simulation of synthetic lightcurves. The original paper describing the algorithm is linked [here](https://arxiv.org/pdf/1305.0304.pdf). The version implemented here is compatible with the Gammapy implementation of the Timmer-Koenig algorithm.\n", + "The Timmer-Koenig algorithm generates synthetic lightcurve from a chosen power spectral density (PSD) shape. However, it can only generate time series with a gaussian probability density function (PDF). This is adequate for high-statistics astrophysical domains such as the optical or X-rays, but can be in issue when trying to reproduce curves in the gamma-ray domain, where photon counts are lower and statistics are generally Poissonian. The Emmanoulopoulos algorithm tries to solve this issue, combining a requested PSD and PDF in the simulation. It provides accurate synthetic lightcurves in a range of spectral indexes between -1 and -2 for power-law or similar PSDs.\n", + "\n", + "Together with the simulation algorithm the notebook adds a function to compute the PSD envelope for a lightcurve using either the Timmer-Koenig or the Emmanoulopoulos algorithm. This envelope is then used to fit the PSD fot he observed lightcurve, by passing through a tailored chi-squared-like cost function. This complex fitting is necessary to account for the fact that the periodogram of the observed lightcurve is only a possible realization of the PSD model, moreover convoluted with Poissonian noise and instrumental responses. This can lead to biases or deformation due to random fluctuation of the realization if extracted with a simple curve fit of the periodogram.\n", + "\n", + "The results are satisfactory for power-law or broken-power-law PSDs in a physical interval of spectral indexes, between -1 and -2. Using the Emmanoulopoulos algorithm shows consistently better PSD reconstruction over the Timmer-Koenig - this is due to the injected non-gaussian PDF." + ] + }, + { + "cell_type": "markdown", + "id": "b693b292-fa5c-4afa-b013-464389e4092a", + "metadata": {}, + "source": [ + "## Imports ##\n", + "\n", + "The first step is importing some usual packages, needed Astropy utilities, scipy tools for PDFs and minimization, and Gammapy functions and classes for the observational part." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4678c090-734e-430d-a81e-ff77cf5ef8a0", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "import inspect\n", + "\n", + "import astropy.units as u\n", + "from astropy.coordinates import SkyCoord, AltAz\n", + "\n", + "from regions import PointSkyRegion\n", + "\n", + "from gammapy.estimators import LightCurveEstimator, FluxPoints\n", + "from gammapy.makers import SpectrumDatasetMaker\n", + "from gammapy.data import Observation, observatory_locations, FixedPointingInfo\n", + "from gammapy.datasets import Datasets, SpectrumDataset\n", + "from gammapy.irf import load_irf_dict_from_file\n", + "from gammapy.maps import MapAxis, RegionGeom, TimeMapAxis, RegionNDMap\n", + "from gammapy.modeling.models import SkyModel, PowerLawSpectralModel, LightCurveTemplateTemporalModel\n", + "from gammapy.estimators.utils import compute_lightcurve_fvar\n", + "from gammapy.utils.random import get_random_state\n", + "\n", + "from scipy.optimize import minimize\n", + "from scipy.signal import periodogram\n", + "from scipy.stats import lognorm" + ] + }, + { + "cell_type": "markdown", + "id": "6ff44b6c-f786-4f7d-bf7c-c27cac5a78dc", + "metadata": {}, + "source": [ + "## Reference Lightcurve ##\n", + "\n", + "As a reference, the notebook uses the H.E.S.S. dataset for the PKS2155 AGN flare of 2006. Data properties such as mean and standard deviation fo the norm, number of points, sampling frequency, are taken from this flare. The synthetic lightcurve will be oversampled by a factor 10." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "330ee851-fcc3-47ad-8b1a-e5bd06d78869", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "lc_path = Path(\"$GAMMAPY_DATA/estimators/\")\n", + "lc_filename = \"pks2155_hess_lc/pks2155_hess_lc.fits\"\n", + "\n", + "lc = FluxPoints.read(lc_path/lc_filename, format=\"lightcurve\")\n", + "odata = lc.norm.data.flatten()\n", + "omean = odata.mean()\n", + "ostd = odata.std()\n", + "npoints = len(lc.norm.data)*10\n", + "times = lc.geom.axes[\"time\"].edges\n", + "tref = lc.geom.axes[\"time\"].reference_time\n", + "smax = np.diff(times).max()/10\n", + "lc.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "530fa958-3965-4753-a119-21af155999df", + "metadata": {}, + "source": [ + "## Function definition ##\n", + "\n", + "Some simple function definitions for PSD and PDF models, with their default parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d68f9022-debe-4a0f-b484-f23c7fa04de4", + "metadata": {}, + "outputs": [], + "source": [ + "def emm_gammalognorm(x, wgamma, a, s, loc, scale):\n", + " return wgamma*gamma.pdf(x, a) + (1-wgamma)*lognorm.pdf(x, s, loc, scale)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "9b95c838-5a0e-4739-90aa-53b91bd712e1", + "metadata": {}, + "outputs": [], + "source": [ + "def bpl(x, norm, aup, adn, x0):\n", + " return norm*(x**(-adn))/(1+((x/x0)**(aup-adn)))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "cadd0727-4527-40eb-99ca-b802a9306b71", + "metadata": {}, + "outputs": [], + "source": [ + "def pl(x, index):\n", + " return x**index" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "8b70ce94-ba71-43ef-80be-70b15e1a1d6f", + "metadata": {}, + "outputs": [], + "source": [ + "bpl_params = {\"norm\":1, \"aup\":2.4, \"adn\":3, \"x0\":0.1}\n", + "gl_params = {\"wgamma\":0.82,\"a\":5.67, \"s\":0.31, \"loc\":2.14, \"scale\":1}\n", + "ln_params = {'s': 0.5, 'loc': 1.5, 'scale': 1}\n", + "pl_params = {\"index\": -1.4}" + ] + }, + { + "cell_type": "markdown", + "id": "25dd6825-abbb-436e-9c12-b4886daf5c05", + "metadata": {}, + "source": [ + "## The Emmanoulopoulos algorithm ##\n", + "\n", + "The algorithm requires a PDF and PSD shape, the number of points to simulate and spacing between the points (as an astropy Quantity). Optionally can be passed: parameters for the PSD and PDF, random state for reproducibility, maximum number of iterations for the internal loop, number of chunk factor by which the length is multiplicated to avoid red noise leakage, target mean and standard deviation of the time series, whether to add poissonian noise internally to simulate observational effects." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "6570bb6c", + "metadata": {}, + "outputs": [], + "source": [ + "def TimmerKonig_lightcurve_simulator(\n", + " power_spectrum,\n", + " npoints,\n", + " spacing,\n", + " nchunks=10,\n", + " random_state=\"random-seed\",\n", + " power_spectrum_params=None,\n", + " mean=0.0,\n", + " std=1.0,\n", + " poisson=False,\n", + "):\n", + "\n", + " if not callable(power_spectrum):\n", + " raise ValueError(\n", + " \"The power spectrum has to be provided as a callable function.\"\n", + " )\n", + "\n", + " if not isinstance(npoints * nchunks, int):\n", + " raise TypeError(\"npoints and nchunks must be integers\")\n", + "\n", + " if poisson:\n", + " if isinstance(mean, u.Quantity):\n", + " wmean = mean.value * spacing.value\n", + " else:\n", + " wmean = mean * spacing.value\n", + " if wmean < 1.0:\n", + " raise Warning(\n", + " \"Poisson noise was requested but the target mean is too low - resulting counts will likely be 0.\"\n", + " )\n", + "\n", + " random_state = get_random_state(random_state)\n", + "\n", + " npoints_ext = npoints * nchunks\n", + "\n", + " frequencies = np.fft.fftfreq(npoints_ext, spacing.value)\n", + "\n", + " # To obtain real data only the positive or negative part of the frequency is necessary.\n", + " real_frequencies = np.sort(np.abs(frequencies[frequencies < 0]))\n", + "\n", + " if power_spectrum_params:\n", + " periodogram = power_spectrum(real_frequencies, **power_spectrum_params)\n", + " else:\n", + " periodogram = power_spectrum(real_frequencies)\n", + "\n", + " real_part = random_state.normal(0, 1, len(periodogram) - 1)\n", + " imaginary_part = random_state.normal(0, 1, len(periodogram) - 1)\n", + "\n", + " # Nyquist frequency component handling\n", + " if npoints_ext % 2 == 0:\n", + " idx0 = -2\n", + " random_factor = random_state.normal(0, 1)\n", + " else:\n", + " idx0 = -1\n", + " random_factor = random_state.normal(0, 1) + 1j * random_state.normal(0, 1)\n", + "\n", + " fourier_coeffs = np.concatenate(\n", + " [\n", + " np.sqrt(0.5 * periodogram[:-1]) * (real_part + 1j * imaginary_part),\n", + " np.sqrt(0.5 * periodogram[-1:]) * random_factor,\n", + " ]\n", + " )\n", + " fourier_coeffs = np.concatenate(\n", + " [fourier_coeffs, np.conjugate(fourier_coeffs[idx0::-1])]\n", + " )\n", + "\n", + " fourier_coeffs = np.insert(fourier_coeffs, 0, 0)\n", + " time_series = np.fft.ifft(fourier_coeffs).real\n", + "\n", + " ndiv = npoints_ext // (2 * nchunks)\n", + " setstart = npoints_ext // 2 - ndiv\n", + " setend = npoints_ext // 2 + ndiv\n", + " if npoints % 2 != 0:\n", + " setend = setend + 1\n", + " time_series = time_series[setstart:setend]\n", + "\n", + " time_series = (time_series - time_series.mean()) / time_series.std()\n", + " time_series = time_series * std + mean\n", + "\n", + " if poisson:\n", + " time_series = (\n", + " random_state.poisson(\n", + " np.where(time_series >= 0, time_series, 0) * spacing.value\n", + " )\n", + " / spacing.value\n", + " )\n", + "\n", + " time_axis = np.linspace(0, npoints * spacing.value, npoints) * spacing.unit\n", + "\n", + " return time_series, time_axis\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "58c4545b-8713-4c40-9f80-e495c3299633", + "metadata": {}, + "outputs": [], + "source": [ + "def Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints, spacing, pdf_params=None, psd_params=None, random_state=\"random-seed\", imax = 1000, nchunks=10, mean=0.0, std=1.0, poisson=False):\n", + " \n", + " target_cps = 0.2\n", + " lc_norm, taxis = TimmerKonig_lightcurve_simulator(psd, npoints, spacing, nchunks = nchunks, power_spectrum_params=psd_params, random_state=random_state)\n", + "\n", + " random_state = get_random_state(random_state)\n", + " \n", + " fft_norm = np.fft.rfft(lc_norm)\n", + "\n", + " a_norm = np.abs(fft_norm)/npoints\n", + " phi_norm = np.angle(fft_norm)\n", + "\n", + " if \"scale\" in pdf_params: scale = pdf_params.get(\"scale\")\n", + " else: scale = 1\n", + " \n", + " xx = np.linspace(0, scale*10, 1000)\n", + " lc_sim = np.interp(random_state.rand(npoints), np.cumsum(pdf(xx, **pdf_params))/np.sum(pdf(xx, **pdf_params)), xx)\n", + " lc_sim = (lc_sim - lc_sim.mean())/lc_sim.std()\n", + "\n", + " nconv = True\n", + " i=0\n", + " while nconv and i= 0, lc_sim, 0) * spacing.decompose().value*target_cps\n", + " )\n", + " / (spacing.decompose().value*target_cps)\n", + " )\n", + " \n", + " return lc_sim, taxis" + ] + }, + { + "cell_type": "markdown", + "id": "6bbdf21a-5463-4730-b1bd-4f72fbd4b029", + "metadata": {}, + "source": [ + "## Envelope and fitting ##\n", + "\n", + "The envelope function returns a set of periodogram extracted from a number of simulations nsims that use the same parameters.\n", + "\n", + "These envelopes can then be used via the x2_fit function to fit the requested PSD to an observed periodogram." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "4d6c825e-1d05-46fc-beeb-4cfd3f2a0d42", + "metadata": {}, + "outputs": [], + "source": [ + "def lightcurve_psd_envelope(psd, npoints, spacing, pdf=None, nsims=10000, pdf_params=None, psd_params=None, simulator=\"TK\", mean=0., std=1., oversample=10, poisson=False):\n", + " npoints_ext = npoints*oversample\n", + " spacing_ext = spacing/oversample\n", + " if simulator== \"TK\" : tseries, taxis = TimmerKonig_lightcurve_simulator(psd, npoints_ext, spacing_ext, power_spectrum_params=psd_params, mean=mean, std=std, poisson=poisson)\n", + " elif simulator== \"EMM\": tseries, taxis = Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints_ext, spacing_ext, pdf_params=pdf_params, psd_params=psd_params, mean=mean, std=std, poisson=poisson)\n", + " freqs, pg = periodogram(tseries, 1/spacing_ext.value)\n", + " envelopes_psd = np.empty((nsims, npoints//2))\n", + " envelopes_psd[0] = pg[1:npoints//2+1]\n", + " \n", + " for _ in range(1, nsims):\n", + " if simulator== \"TK\" : tseries, taxis = TimmerKonig_lightcurve_simulator(psd, npoints_ext, spacing_ext, power_spectrum_params=psd_params, mean=mean, std=std, poisson=poisson)\n", + " else: tseries, taxis = Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints_ext, spacing_ext, pdf_params=pdf_params, psd_params=psd_params, mean=mean, std=std, poisson=poisson)\n", + "\n", + " freqs, pg = periodogram(tseries, 1/spacing_ext.value)\n", + " envelopes_psd[_] = pg[1:npoints//2+1]\n", + "\n", + " return envelopes_psd, freqs[1:npoints//2+1]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "068ae572-491e-44f4-9835-24c9db07ec2f", + "metadata": {}, + "outputs": [], + "source": [ + "def x2_fit(psd_params_list, pgram, npoints, spacing, psd, pdf=None, pdf_params=None, simulator=\"TK\", nsims=10000, mean=None, std=None, poisson=False):\n", + "\n", + " psd_params_keys = list(inspect.signature(psd).parameters.keys())\n", + "\n", + " if len(psd_params_keys[1:]) != len(psd_params_list): raise ValueError(\"parameter values do not correspond to the request from the psd function\")\n", + " \n", + " psd_params = dict(zip(psd_params_keys[1:], psd_params_list))\n", + " \n", + " envelopes, freqs = lightcurve_psd_envelope(psd, npoints, spacing, pdf=pdf, pdf_params=pdf_params, psd_params=psd_params, simulator=simulator, nsims=nsims, mean=mean, std=std, poisson=poisson)\n", + " \n", + " if len(envelopes[0])!= len(pgram): raise ValueError(\"required length is different than data length!\")\n", + " \n", + " obs = (pgram - envelopes.mean(axis=0))**2/envelopes.std(axis=0)**2\n", + " sim = (envelopes - envelopes.mean(axis=0))**2/envelopes.std(axis=0)**2\n", + " sumobs = np.sum(obs)\n", + " sumsim = np.sum(sim, axis=-1)\n", + " sign = len(np.where(sumobs>=sumsim)[0])/nsims\n", + " \n", + " return sign" + ] + }, + { + "cell_type": "markdown", + "id": "78dd6fa2-c725-42b8-a854-5eefaaec5be2", + "metadata": {}, + "source": [ + "## Simulation ##\n", + "\n", + "The simulation call for the algorithm. Both the TK and EMM algorithms are called with the same power-law PSD. The EMM algorithm uses a lognormal PDF. The difference between TK and EMM algorithms is shown in the leftmost and rightmost plot, where the gaussian vs lognormal shape is evident. The middle plot shows the perfect compatibility in the periodogram. Seed is fixed for reproducibility. " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "9fa4aa20-d5e4-4352-8a7c-6348d5c882cc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1.47301407 -7.35992191] [-1.41604412 -6.92936994]\n", + "CPU times: user 45 ms, sys: 7.22 ms, total: 52.2 ms\n", + "Wall time: 57.5 ms\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%time\n", + "seed = 532019\n", + "#seed = \"random-seed\"\n", + "lctk2, taxis2 = Emmanoulopoulos_lightcurve_simulator(lognorm.pdf, pl, npoints, smax, pdf_params=ln_params, psd_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", + "lctk, taxis = TimmerKonig_lightcurve_simulator(pl, npoints, smax, power_spectrum_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", + "freqstk, pgramtk = periodogram(lctk, 1/smax.value)\n", + "freqstk2, pgramtk2 = periodogram(lctk2, 1/smax.value)\n", + "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15,3))\n", + "ax1.plot(taxis, lctk)\n", + "ax2.loglog(freqstk[1:], pgramtk[1:])\n", + "ax3.hist(lctk)\n", + "ax1.plot(taxis2, lctk2)\n", + "ax2.loglog(freqstk2[1:], pgramtk2[1:])\n", + "ax3.hist(lctk2)\n", + "coeff = np.polyfit(np.log(freqstk[1:]), np.log(pgramtk[1:]), 1)\n", + "coeff2 = np.polyfit(np.log(freqstk2[1:]), np.log(pgramtk2[1:]), 1)\n", + "\n", + "print(coeff, coeff2)" + ] + }, + { + "cell_type": "markdown", + "id": "592cd9e0-55d1-4bbf-93f4-e873b011d43d", + "metadata": {}, + "source": [ + "## Gammapy setup and simulation ##\n", + "\n", + "Setup of geometry for the Gammapy simulation. Generic setup for pointing, energy binning, and IRFs. For realistic simulations, choose IRFs that are consistent with the instrument and observational conditions." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "79fc7316-39ef-490d-9cf9-d714afe9249e", + "metadata": {}, + "outputs": [], + "source": [ + "TimeMapAxis.time_format = \"iso\"\n", + "\n", + "path = Path(\"$GAMMAPY_DATA/cta-caldb\")\n", + "irf_filename = \"Prod5-South-20deg-AverageAz-14MSTs37SSTs.180000s-v0.1.fits.gz\"\n", + "\n", + "irfs = load_irf_dict_from_file(path / irf_filename)\n", + "\n", + "energy_axis = MapAxis.from_energy_bounds(\n", + " energy_min=0.1 * u.TeV, energy_max=100 * u.TeV, nbin=1\n", + ")\n", + "\n", + "energy_axis_true = MapAxis.from_edges(\n", + " np.logspace(-1.2, 2.0, 31), unit=\"TeV\", name=\"energy_true\", interp=\"log\"\n", + ")\n", + "\n", + "time_axis = MapAxis.from_nodes(taxis, name=\"time\", interp=\"lin\")\n", + "\n", + "geom = RegionGeom.create(\"galactic;circle(107.65, -40.17, 5)\", axes=[energy_axis])\n", + "\n", + "pointing_position = SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\")\n", + "pointing = FixedPointingInfo(\n", + " fixed_icrs=SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\").icrs,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8d9aec9b-9f38-4f9b-903e-e5189c7edf6c", + "metadata": {}, + "source": [ + "The time series generated via EMM is taken as a LightCurveTemplateTemporalModel" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "c900eb8e-87ce-4771-8ccc-db627c7a541f", + "metadata": {}, + "outputs": [], + "source": [ + "gti_t0 = tref\n", + "\n", + "spectral_model = PowerLawSpectralModel(amplitude = 1e-10 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", + "\n", + "m = RegionNDMap.create(\n", + " region=PointSkyRegion(center=pointing_position),\n", + " axes=[time_axis],\n", + " unit=\"cm-2s-1TeV-1\",\n", + ")\n", + "\n", + "m.quantity = lctk2\n", + "\n", + "temporal_model = LightCurveTemplateTemporalModel(m, t_ref=gti_t0)\n", + "\n", + "model_simu = SkyModel(\n", + " spectral_model=spectral_model,\n", + " temporal_model=temporal_model,\n", + " name=\"model-simu\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "7ccc6acb-5054-4879-bba9-ae0bd14e6b02", + "metadata": {}, + "source": [ + "Observation timing setup and simulation fo the datasets. The \"observational\" sampling is taken to be much sparser than the synthetic lightcurve, to avoid aliasing." + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "bd889da2-54be-461f-b9a4-a34959e994a7", + "metadata": {}, + "outputs": [], + "source": [ + "lvtm = 10 * u.min\n", + "tstart = gti_t0 + np.arange(npoints/10)*lvtm\n", + "altaz = pointing_position.transform_to(AltAz(obstime = tstart, location = observatory_locations[\"cta_south\"]))" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "f142057c-852f-4605-88d3-b27d63417803", + "metadata": {}, + "outputs": [], + "source": [ + "datasets = Datasets()\n", + "\n", + "empty = SpectrumDataset.create(\n", + "geom=geom, energy_axis_true=energy_axis_true, name=\"empty\"\n", + ")\n", + "\n", + "maker = SpectrumDatasetMaker(selection=[\"exposure\", \"background\", \"edisp\"])\n", + "\n", + "for idx in range(len(tstart)):\n", + " obs = Observation.create(\n", + " pointing=pointing,\n", + " livetime=lvtm,\n", + " tstart=tstart[idx],\n", + " irfs=irfs,\n", + " reference_time=gti_t0,\n", + " obs_id=idx,\n", + " location=observatory_locations[\"cta_south\"],\n", + " )\n", + " empty_i = empty.copy(name=f\"dataset-{idx}\")\n", + " dataset = maker.run(empty_i, obs)\n", + " dataset.models = model_simu\n", + " dataset.fake()\n", + " datasets.append(dataset)\n", + "\n", + "\n", + "spectral_model = PowerLawSpectralModel(amplitude = 7e-11 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", + "model_fit = SkyModel(spectral_model=spectral_model, name=\"model-fit\")\n", + "datasets.models = model_fit" + ] + }, + { + "cell_type": "markdown", + "id": "725f0466-21c4-4da2-a5da-21486ef0a43d", + "metadata": {}, + "source": [ + "Lightcurve estimator setup and run." + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "6150efce-4ced-4237-bf53-12fbd5fe9a30", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "lc_maker_1d = LightCurveEstimator(\n", + " energy_edges=[0.1, 100] * u.TeV,\n", + " source=\"model-fit\",\n", + " selection_optional=[\"ul\"],\n", + ")\n", + "\n", + "lc_1d = lc_maker_1d.run(datasets)\n", + "lc_1d.plot();" + ] + }, + { + "cell_type": "markdown", + "id": "b27cd811-a990-48c1-93af-baee1198432c", + "metadata": {}, + "source": [ + "Assessment of the properties of the \"observed\" lightcurve in the time and frequency domain." + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "e2ee2f7b-c8ee-4251-b276-75d4cd247b66", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1.4034358347577256\n" + ] + }, + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data = lc_1d.norm.data.flatten()\n", + "dmean = data.mean()\n", + "dstd = data.std()\n", + "dnpoints = len(data)\n", + "dtimes = lc_1d.geom.axes[\"time\"].edges\n", + "dsmax = np.diff(dtimes).max()\n", + "ffreqs, pgram = periodogram(data, 1/dsmax.value)\n", + "coeff = np.polyfit(np.log(ffreqs[1:]), np.log(pgram[1:]), 1)\n", + "print(coeff[0])\n", + "plt.loglog(ffreqs[1:], pgram[1:])" + ] + }, + { + "cell_type": "markdown", + "id": "759e1ddd-98dc-4854-8ba7-c1e58facbb87", + "metadata": {}, + "source": [ + "### Fitting ###\n", + "\n", + "The x2_fit function is used as a cost function with the scipy minimizer, providing a fit of the spectral index for the \"observed\" lightcurve assuming a power-law PSD. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b08789fe-2a0a-4056-8b38-1aaea9946059", + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'pgram' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m:2\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'pgram' is not defined" + ] + } + ], + "source": [ + "%%time\n", + "initial_pars = [-2]\n", + "results = minimize(x2_fit, initial_pars, args=(pgram[1:], dnpoints, dsmax, pl, lognorm.pdf, ln_params, \"EMM\", 10000, dmean, dstd, False), method=\"Powell\", options={\"disp\": True})\n", + "print(results)\n", + "envelopes, freqs = lightcurve_psd_envelope(pl, dnpoints, dsmax, psd_params={\"index\": results.x}, simulator=\"EMM\", pdf = lognorm.pdf, pdf_params = ln_params , nsims=10000, mean=dmean, std=dstd, poisson=False)\n", + "plt.violinplot(envelopes, freqs, widths=np.diff(freqs).min(), showmedians=True);\n", + "plt.plot(freqs, pgram[1:], linewidth=0.7, marker=\"d\")\n", + "plt.yscale(\"log\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "939d6039", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From bfdfb6cd03921a85797d194f991224f9ef5d1667 Mon Sep 17 00:00:00 2001 From: Claudio Galelli Date: Fri, 23 Aug 2024 12:42:30 +0200 Subject: [PATCH 06/13] Delete recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb --- .../fit-psd-lightcurve.ipynb | 744 ------------------ 1 file changed, 744 deletions(-) delete mode 100644 recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb diff --git a/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb b/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb deleted file mode 100644 index 5632c59..0000000 --- a/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb +++ /dev/null @@ -1,744 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "b4ca33d6-129c-4a59-89d7-f57e39cacfc0", - "metadata": {}, - "source": [ - "# Generating synthetic lightcurves and fitting the power spectral density of a lightcurve #\n", - "\n", - "This notebook presents the advanced Emmanoulopoulos algorithm for the simulation of synthetic lightcurves. The original paper describing the algorithm is linked [here](https://arxiv.org/pdf/1305.0304.pdf). The version implemented here is compatible with the Gammapy implementation of the Timmer-Koenig algorithm.\n", - "The Timmer-Koenig algorithm generates synthetic lightcurve from a chosen power spectral density (PSD) shape. However, it can only generate time series with a gaussian probability density function (PDF). This is adequate for high-statistics astrophysical domains such as the optical or X-rays, but can be in issue when trying to reproduce curves in the gamma-ray domain, where photon counts are lower and statistics are generally Poissonian. The Emmanoulopoulos algorithm tries to solve this issue, combining a requested PSD and PDF in the simulation. It provides accurate synthetic lightcurves in a range of spectral indexes between -1 and -2 for power-law or similar PSDs.\n", - "\n", - "Together with the simulation algorithm the notebook adds a function to compute the PSD envelope for a lightcurve using either the Timmer-Koenig or the Emmanoulopoulos algorithm. This envelope is then used to fit the PSD fot he observed lightcurve, by passing through a tailored chi-squared-like cost function. This complex fitting is necessary to account for the fact that the periodogram of the observed lightcurve is only a possible realization of the PSD model, moreover convoluted with Poissonian noise and instrumental responses. This can lead to biases or deformation due to random fluctuation of the realization if extracted with a simple curve fit of the periodogram.\n", - "\n", - "The results are satisfactory for power-law or broken-power-law PSDs in a physical interval of spectral indexes, between -1 and -2. Using the Emmanoulopoulos algorithm shows consistently better PSD reconstruction over the Timmer-Koenig - this is due to the injected non-gaussian PDF." - ] - }, - { - "cell_type": "markdown", - "id": "b693b292-fa5c-4afa-b013-464389e4092a", - "metadata": {}, - "source": [ - "## Imports ##\n", - "\n", - "The first step is importing some usual packages, needed Astropy utilities, scipy tools for PDFs and minimization, and Gammapy functions and classes for the observational part." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "4678c090-734e-430d-a81e-ff77cf5ef8a0", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from pathlib import Path\n", - "import matplotlib.pyplot as plt\n", - "import inspect\n", - "\n", - "import astropy.units as u\n", - "from astropy.coordinates import SkyCoord, AltAz\n", - "\n", - "from regions import PointSkyRegion\n", - "\n", - "from gammapy.estimators import LightCurveEstimator, FluxPoints\n", - "from gammapy.makers import SpectrumDatasetMaker\n", - "from gammapy.data import Observation, observatory_locations, FixedPointingInfo\n", - "from gammapy.datasets import Datasets, SpectrumDataset\n", - "from gammapy.irf import load_irf_dict_from_file\n", - "from gammapy.maps import MapAxis, RegionGeom, TimeMapAxis, RegionNDMap\n", - "from gammapy.modeling.models import SkyModel, PowerLawSpectralModel, LightCurveTemplateTemporalModel\n", - "from gammapy.estimators.utils import compute_lightcurve_fvar\n", - "from gammapy.utils.random import get_random_state\n", - "\n", - "from scipy.optimize import minimize\n", - "from scipy.signal import periodogram\n", - "from scipy.stats import lognorm" - ] - }, - { - "cell_type": "markdown", - "id": "6ff44b6c-f786-4f7d-bf7c-c27cac5a78dc", - "metadata": {}, - "source": [ - "## Reference Lightcurve ##\n", - "\n", - "As a reference, the notebook uses the H.E.S.S. dataset for the PKS2155 AGN flare of 2006. Data properties such as mean and standard deviation fo the norm, number of points, sampling frequency, are taken from this flare. The synthetic lightcurve will be oversampled by a factor 10." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "330ee851-fcc3-47ad-8b1a-e5bd06d78869", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "lc_path = Path(\"$GAMMAPY_DATA/estimators/\")\n", - "lc_filename = \"pks2155_hess_lc/pks2155_hess_lc.fits\"\n", - "\n", - "lc = FluxPoints.read(lc_path/lc_filename, format=\"lightcurve\")\n", - "odata = lc.norm.data.flatten()\n", - "omean = odata.mean()\n", - "ostd = odata.std()\n", - "npoints = len(lc.norm.data)*10\n", - "times = lc.geom.axes[\"time\"].edges\n", - "tref = lc.geom.axes[\"time\"].reference_time\n", - "smax = np.diff(times).max()/10\n", - "lc.plot()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "530fa958-3965-4753-a119-21af155999df", - "metadata": {}, - "source": [ - "## Function definition ##\n", - "\n", - "Some simple function definitions for PSD and PDF models, with their default parameters." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "d68f9022-debe-4a0f-b484-f23c7fa04de4", - "metadata": {}, - "outputs": [], - "source": [ - "def emm_gammalognorm(x, wgamma, a, s, loc, scale):\n", - " return wgamma*gamma.pdf(x, a) + (1-wgamma)*lognorm.pdf(x, s, loc, scale)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "9b95c838-5a0e-4739-90aa-53b91bd712e1", - "metadata": {}, - "outputs": [], - "source": [ - "def bpl(x, norm, aup, adn, x0):\n", - " return norm*(x**(-adn))/(1+((x/x0)**(aup-adn)))" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "cadd0727-4527-40eb-99ca-b802a9306b71", - "metadata": {}, - "outputs": [], - "source": [ - "def pl(x, index):\n", - " return x**index" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "8b70ce94-ba71-43ef-80be-70b15e1a1d6f", - "metadata": {}, - "outputs": [], - "source": [ - "bpl_params = {\"norm\":1, \"aup\":2.4, \"adn\":3, \"x0\":0.1}\n", - "gl_params = {\"wgamma\":0.82,\"a\":5.67, \"s\":0.31, \"loc\":2.14, \"scale\":1}\n", - "ln_params = {'s': 0.5, 'loc': 1.5, 'scale': 1}\n", - "pl_params = {\"index\": -1.4}" - ] - }, - { - "cell_type": "markdown", - "id": "25dd6825-abbb-436e-9c12-b4886daf5c05", - "metadata": {}, - "source": [ - "## The Emmanoulopoulos algorithm ##\n", - "\n", - "The algorithm requires a PDF and PSD shape, the number of points to simulate and spacing between the points (as an astropy Quantity). Optionally can be passed: parameters for the PSD and PDF, random state for reproducibility, maximum number of iterations for the internal loop, number of chunk factor by which the length is multiplicated to avoid red noise leakage, target mean and standard deviation of the time series, whether to add poissonian noise internally to simulate observational effects." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "6570bb6c", - "metadata": {}, - "outputs": [], - "source": [ - "def TimmerKonig_lightcurve_simulator(\n", - " power_spectrum,\n", - " npoints,\n", - " spacing,\n", - " nchunks=10,\n", - " random_state=\"random-seed\",\n", - " power_spectrum_params=None,\n", - " mean=0.0,\n", - " std=1.0,\n", - " poisson=False,\n", - "):\n", - "\n", - " if not callable(power_spectrum):\n", - " raise ValueError(\n", - " \"The power spectrum has to be provided as a callable function.\"\n", - " )\n", - "\n", - " if not isinstance(npoints * nchunks, int):\n", - " raise TypeError(\"npoints and nchunks must be integers\")\n", - "\n", - " if poisson:\n", - " if isinstance(mean, u.Quantity):\n", - " wmean = mean.value * spacing.value\n", - " else:\n", - " wmean = mean * spacing.value\n", - " if wmean < 1.0:\n", - " raise Warning(\n", - " \"Poisson noise was requested but the target mean is too low - resulting counts will likely be 0.\"\n", - " )\n", - "\n", - " random_state = get_random_state(random_state)\n", - "\n", - " npoints_ext = npoints * nchunks\n", - "\n", - " frequencies = np.fft.fftfreq(npoints_ext, spacing.value)\n", - "\n", - " # To obtain real data only the positive or negative part of the frequency is necessary.\n", - " real_frequencies = np.sort(np.abs(frequencies[frequencies < 0]))\n", - "\n", - " if power_spectrum_params:\n", - " periodogram = power_spectrum(real_frequencies, **power_spectrum_params)\n", - " else:\n", - " periodogram = power_spectrum(real_frequencies)\n", - "\n", - " real_part = random_state.normal(0, 1, len(periodogram) - 1)\n", - " imaginary_part = random_state.normal(0, 1, len(periodogram) - 1)\n", - "\n", - " # Nyquist frequency component handling\n", - " if npoints_ext % 2 == 0:\n", - " idx0 = -2\n", - " random_factor = random_state.normal(0, 1)\n", - " else:\n", - " idx0 = -1\n", - " random_factor = random_state.normal(0, 1) + 1j * random_state.normal(0, 1)\n", - "\n", - " fourier_coeffs = np.concatenate(\n", - " [\n", - " np.sqrt(0.5 * periodogram[:-1]) * (real_part + 1j * imaginary_part),\n", - " np.sqrt(0.5 * periodogram[-1:]) * random_factor,\n", - " ]\n", - " )\n", - " fourier_coeffs = np.concatenate(\n", - " [fourier_coeffs, np.conjugate(fourier_coeffs[idx0::-1])]\n", - " )\n", - "\n", - " fourier_coeffs = np.insert(fourier_coeffs, 0, 0)\n", - " time_series = np.fft.ifft(fourier_coeffs).real\n", - "\n", - " ndiv = npoints_ext // (2 * nchunks)\n", - " setstart = npoints_ext // 2 - ndiv\n", - " setend = npoints_ext // 2 + ndiv\n", - " if npoints % 2 != 0:\n", - " setend = setend + 1\n", - " time_series = time_series[setstart:setend]\n", - "\n", - " time_series = (time_series - time_series.mean()) / time_series.std()\n", - " time_series = time_series * std + mean\n", - "\n", - " if poisson:\n", - " time_series = (\n", - " random_state.poisson(\n", - " np.where(time_series >= 0, time_series, 0) * spacing.value\n", - " )\n", - " / spacing.value\n", - " )\n", - "\n", - " time_axis = np.linspace(0, npoints * spacing.value, npoints) * spacing.unit\n", - "\n", - " return time_series, time_axis\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "58c4545b-8713-4c40-9f80-e495c3299633", - "metadata": {}, - "outputs": [], - "source": [ - "def Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints, spacing, pdf_params=None, psd_params=None, random_state=\"random-seed\", imax = 1000, nchunks=10, mean=0.0, std=1.0, poisson=False):\n", - " \n", - " target_cps = 0.2\n", - " lc_norm, taxis = TimmerKonig_lightcurve_simulator(psd, npoints, spacing, nchunks = nchunks, power_spectrum_params=psd_params, random_state=random_state)\n", - "\n", - " random_state = get_random_state(random_state)\n", - " \n", - " fft_norm = np.fft.rfft(lc_norm)\n", - "\n", - " a_norm = np.abs(fft_norm)/npoints\n", - " phi_norm = np.angle(fft_norm)\n", - "\n", - " if \"scale\" in pdf_params: scale = pdf_params.get(\"scale\")\n", - " else: scale = 1\n", - " \n", - " xx = np.linspace(0, scale*10, 1000)\n", - " lc_sim = np.interp(random_state.rand(npoints), np.cumsum(pdf(xx, **pdf_params))/np.sum(pdf(xx, **pdf_params)), xx)\n", - " lc_sim = (lc_sim - lc_sim.mean())/lc_sim.std()\n", - "\n", - " nconv = True\n", - " i=0\n", - " while nconv and i= 0, lc_sim, 0) * spacing.decompose().value*target_cps\n", - " )\n", - " / (spacing.decompose().value*target_cps)\n", - " )\n", - " \n", - " return lc_sim, taxis" - ] - }, - { - "cell_type": "markdown", - "id": "6bbdf21a-5463-4730-b1bd-4f72fbd4b029", - "metadata": {}, - "source": [ - "## Envelope and fitting ##\n", - "\n", - "The envelope function returns a set of periodogram extracted from a number of simulations nsims that use the same parameters.\n", - "\n", - "These envelopes can then be used via the x2_fit function to fit the requested PSD to an observed periodogram." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "4d6c825e-1d05-46fc-beeb-4cfd3f2a0d42", - "metadata": {}, - "outputs": [], - "source": [ - "def lightcurve_psd_envelope(psd, npoints, spacing, pdf=None, nsims=10000, pdf_params=None, psd_params=None, simulator=\"TK\", mean=0., std=1., oversample=10, poisson=False):\n", - " npoints_ext = npoints*oversample\n", - " spacing_ext = spacing/oversample\n", - " if simulator== \"TK\" : tseries, taxis = TimmerKonig_lightcurve_simulator(psd, npoints_ext, spacing_ext, power_spectrum_params=psd_params, mean=mean, std=std, poisson=poisson)\n", - " elif simulator== \"EMM\": tseries, taxis = Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints_ext, spacing_ext, pdf_params=pdf_params, psd_params=psd_params, mean=mean, std=std, poisson=poisson)\n", - " freqs, pg = periodogram(tseries, 1/spacing_ext.value)\n", - " envelopes_psd = np.empty((nsims, npoints//2))\n", - " envelopes_psd[0] = pg[1:npoints//2+1]\n", - " \n", - " for _ in range(1, nsims):\n", - " if simulator== \"TK\" : tseries, taxis = TimmerKonig_lightcurve_simulator(psd, npoints_ext, spacing_ext, power_spectrum_params=psd_params, mean=mean, std=std, poisson=poisson)\n", - " else: tseries, taxis = Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints_ext, spacing_ext, pdf_params=pdf_params, psd_params=psd_params, mean=mean, std=std, poisson=poisson)\n", - "\n", - " freqs, pg = periodogram(tseries, 1/spacing_ext.value)\n", - " envelopes_psd[_] = pg[1:npoints//2+1]\n", - "\n", - " return envelopes_psd, freqs[1:npoints//2+1]" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "068ae572-491e-44f4-9835-24c9db07ec2f", - "metadata": {}, - "outputs": [], - "source": [ - "def x2_fit(psd_params_list, pgram, npoints, spacing, psd, pdf=None, pdf_params=None, simulator=\"TK\", nsims=10000, mean=None, std=None, poisson=False):\n", - "\n", - " psd_params_keys = list(inspect.signature(psd).parameters.keys())\n", - "\n", - " if len(psd_params_keys[1:]) != len(psd_params_list): raise ValueError(\"parameter values do not correspond to the request from the psd function\")\n", - " \n", - " psd_params = dict(zip(psd_params_keys[1:], psd_params_list))\n", - " \n", - " envelopes, freqs = lightcurve_psd_envelope(psd, npoints, spacing, pdf=pdf, pdf_params=pdf_params, psd_params=psd_params, simulator=simulator, nsims=nsims, mean=mean, std=std, poisson=poisson)\n", - " \n", - " if len(envelopes[0])!= len(pgram): raise ValueError(\"required length is different than data length!\")\n", - " \n", - " obs = (pgram - envelopes.mean(axis=0))**2/envelopes.std(axis=0)**2\n", - " sim = (envelopes - envelopes.mean(axis=0))**2/envelopes.std(axis=0)**2\n", - " sumobs = np.sum(obs)\n", - " sumsim = np.sum(sim, axis=-1)\n", - " sign = len(np.where(sumobs>=sumsim)[0])/nsims\n", - " \n", - " return sign" - ] - }, - { - "cell_type": "markdown", - "id": "78dd6fa2-c725-42b8-a854-5eefaaec5be2", - "metadata": {}, - "source": [ - "## Simulation ##\n", - "\n", - "The simulation call for the algorithm. Both the TK and EMM algorithms are called with the same power-law PSD. The EMM algorithm uses a lognormal PDF. The difference between TK and EMM algorithms is shown in the leftmost and rightmost plot, where the gaussian vs lognormal shape is evident. The middle plot shows the perfect compatibility in the periodogram. Seed is fixed for reproducibility. " - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "9fa4aa20-d5e4-4352-8a7c-6348d5c882cc", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[-1.47301407 -7.35992191] [-1.41604412 -6.92936994]\n", - "CPU times: user 45 ms, sys: 7.22 ms, total: 52.2 ms\n", - "Wall time: 57.5 ms\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "%%time\n", - "seed = 532019\n", - "#seed = \"random-seed\"\n", - "lctk2, taxis2 = Emmanoulopoulos_lightcurve_simulator(lognorm.pdf, pl, npoints, smax, pdf_params=ln_params, psd_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", - "lctk, taxis = TimmerKonig_lightcurve_simulator(pl, npoints, smax, power_spectrum_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", - "freqstk, pgramtk = periodogram(lctk, 1/smax.value)\n", - "freqstk2, pgramtk2 = periodogram(lctk2, 1/smax.value)\n", - "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15,3))\n", - "ax1.plot(taxis, lctk)\n", - "ax2.loglog(freqstk[1:], pgramtk[1:])\n", - "ax3.hist(lctk)\n", - "ax1.plot(taxis2, lctk2)\n", - "ax2.loglog(freqstk2[1:], pgramtk2[1:])\n", - "ax3.hist(lctk2)\n", - "coeff = np.polyfit(np.log(freqstk[1:]), np.log(pgramtk[1:]), 1)\n", - "coeff2 = np.polyfit(np.log(freqstk2[1:]), np.log(pgramtk2[1:]), 1)\n", - "\n", - "print(coeff, coeff2)" - ] - }, - { - "cell_type": "markdown", - "id": "592cd9e0-55d1-4bbf-93f4-e873b011d43d", - "metadata": {}, - "source": [ - "## Gammapy setup and simulation ##\n", - "\n", - "Setup of geometry for the Gammapy simulation. Generic setup for pointing, energy binning, and IRFs. For realistic simulations, choose IRFs that are consistent with the instrument and observational conditions." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "79fc7316-39ef-490d-9cf9-d714afe9249e", - "metadata": {}, - "outputs": [], - "source": [ - "TimeMapAxis.time_format = \"iso\"\n", - "\n", - "path = Path(\"$GAMMAPY_DATA/cta-caldb\")\n", - "irf_filename = \"Prod5-South-20deg-AverageAz-14MSTs37SSTs.180000s-v0.1.fits.gz\"\n", - "\n", - "irfs = load_irf_dict_from_file(path / irf_filename)\n", - "\n", - "energy_axis = MapAxis.from_energy_bounds(\n", - " energy_min=0.1 * u.TeV, energy_max=100 * u.TeV, nbin=1\n", - ")\n", - "\n", - "energy_axis_true = MapAxis.from_edges(\n", - " np.logspace(-1.2, 2.0, 31), unit=\"TeV\", name=\"energy_true\", interp=\"log\"\n", - ")\n", - "\n", - "time_axis = MapAxis.from_nodes(taxis, name=\"time\", interp=\"lin\")\n", - "\n", - "geom = RegionGeom.create(\"galactic;circle(107.65, -40.17, 5)\", axes=[energy_axis])\n", - "\n", - "pointing_position = SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\")\n", - "pointing = FixedPointingInfo(\n", - " fixed_icrs=SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\").icrs,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "8d9aec9b-9f38-4f9b-903e-e5189c7edf6c", - "metadata": {}, - "source": [ - "The time series generated via EMM is taken as a LightCurveTemplateTemporalModel" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "c900eb8e-87ce-4771-8ccc-db627c7a541f", - "metadata": {}, - "outputs": [], - "source": [ - "gti_t0 = tref\n", - "\n", - "spectral_model = PowerLawSpectralModel(amplitude = 1e-10 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", - "\n", - "m = RegionNDMap.create(\n", - " region=PointSkyRegion(center=pointing_position),\n", - " axes=[time_axis],\n", - " unit=\"cm-2s-1TeV-1\",\n", - ")\n", - "\n", - "m.quantity = lctk2\n", - "\n", - "temporal_model = LightCurveTemplateTemporalModel(m, t_ref=gti_t0)\n", - "\n", - "model_simu = SkyModel(\n", - " spectral_model=spectral_model,\n", - " temporal_model=temporal_model,\n", - " name=\"model-simu\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "7ccc6acb-5054-4879-bba9-ae0bd14e6b02", - "metadata": {}, - "source": [ - "Observation timing setup and simulation fo the datasets. The \"observational\" sampling is taken to be much sparser than the synthetic lightcurve, to avoid aliasing." - ] - }, - { - "cell_type": "code", - "execution_count": 100, - "id": "bd889da2-54be-461f-b9a4-a34959e994a7", - "metadata": {}, - "outputs": [], - "source": [ - "lvtm = 10 * u.min\n", - "tstart = gti_t0 + np.arange(npoints/10)*lvtm\n", - "altaz = pointing_position.transform_to(AltAz(obstime = tstart, location = observatory_locations[\"cta_south\"]))" - ] - }, - { - "cell_type": "code", - "execution_count": 101, - "id": "f142057c-852f-4605-88d3-b27d63417803", - "metadata": {}, - "outputs": [], - "source": [ - "datasets = Datasets()\n", - "\n", - "empty = SpectrumDataset.create(\n", - "geom=geom, energy_axis_true=energy_axis_true, name=\"empty\"\n", - ")\n", - "\n", - "maker = SpectrumDatasetMaker(selection=[\"exposure\", \"background\", \"edisp\"])\n", - "\n", - "for idx in range(len(tstart)):\n", - " obs = Observation.create(\n", - " pointing=pointing,\n", - " livetime=lvtm,\n", - " tstart=tstart[idx],\n", - " irfs=irfs,\n", - " reference_time=gti_t0,\n", - " obs_id=idx,\n", - " location=observatory_locations[\"cta_south\"],\n", - " )\n", - " empty_i = empty.copy(name=f\"dataset-{idx}\")\n", - " dataset = maker.run(empty_i, obs)\n", - " dataset.models = model_simu\n", - " dataset.fake()\n", - " datasets.append(dataset)\n", - "\n", - "\n", - "spectral_model = PowerLawSpectralModel(amplitude = 7e-11 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", - "model_fit = SkyModel(spectral_model=spectral_model, name=\"model-fit\")\n", - "datasets.models = model_fit" - ] - }, - { - "cell_type": "markdown", - "id": "725f0466-21c4-4da2-a5da-21486ef0a43d", - "metadata": {}, - "source": [ - "Lightcurve estimator setup and run." - ] - }, - { - "cell_type": "code", - "execution_count": 102, - "id": "6150efce-4ced-4237-bf53-12fbd5fe9a30", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "lc_maker_1d = LightCurveEstimator(\n", - " energy_edges=[0.1, 100] * u.TeV,\n", - " source=\"model-fit\",\n", - " selection_optional=[\"ul\"],\n", - ")\n", - "\n", - "lc_1d = lc_maker_1d.run(datasets)\n", - "lc_1d.plot();" - ] - }, - { - "cell_type": "markdown", - "id": "b27cd811-a990-48c1-93af-baee1198432c", - "metadata": {}, - "source": [ - "Assessment of the properties of the \"observed\" lightcurve in the time and frequency domain." - ] - }, - { - "cell_type": "code", - "execution_count": 103, - "id": "e2ee2f7b-c8ee-4251-b276-75d4cd247b66", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-1.4034358347577256\n" - ] - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 103, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "data = lc_1d.norm.data.flatten()\n", - "dmean = data.mean()\n", - "dstd = data.std()\n", - "dnpoints = len(data)\n", - "dtimes = lc_1d.geom.axes[\"time\"].edges\n", - "dsmax = np.diff(dtimes).max()\n", - "ffreqs, pgram = periodogram(data, 1/dsmax.value)\n", - "coeff = np.polyfit(np.log(ffreqs[1:]), np.log(pgram[1:]), 1)\n", - "print(coeff[0])\n", - "plt.loglog(ffreqs[1:], pgram[1:])" - ] - }, - { - "cell_type": "markdown", - "id": "759e1ddd-98dc-4854-8ba7-c1e58facbb87", - "metadata": {}, - "source": [ - "### Fitting ###\n", - "\n", - "The x2_fit function is used as a cost function with the scipy minimizer, providing a fit of the spectral index for the \"observed\" lightcurve assuming a power-law PSD. " - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "b08789fe-2a0a-4056-8b38-1aaea9946059", - "metadata": { - "tags": [ - "nbsphinx-thumbnail" - ] - }, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'pgram' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m:2\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'pgram' is not defined" - ] - } - ], - "source": [ - "%%time\n", - "initial_pars = [-2]\n", - "results = minimize(x2_fit, initial_pars, args=(pgram[1:], dnpoints, dsmax, pl, lognorm.pdf, ln_params, \"EMM\", 10000, dmean, dstd, False), method=\"Powell\", options={\"disp\": True})\n", - "print(results)\n", - "envelopes, freqs = lightcurve_psd_envelope(pl, dnpoints, dsmax, psd_params={\"index\": results.x}, simulator=\"EMM\", pdf = lognorm.pdf, pdf_params = ln_params , nsims=10000, mean=dmean, std=dstd, poisson=False)\n", - "plt.violinplot(envelopes, freqs, widths=np.diff(freqs).min(), showmedians=True);\n", - "plt.plot(freqs, pgram[1:], linewidth=0.7, marker=\"d\")\n", - "plt.yscale(\"log\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "939d6039", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From bc985676b90a1a33956df7eada84dbc456635b4e Mon Sep 17 00:00:00 2001 From: Claudio Galelli Date: Fri, 23 Aug 2024 12:42:50 +0200 Subject: [PATCH 07/13] Add files via upload --- .../fit-psd-lightcurve.ipynb | 662 ++++++++++++++++++ 1 file changed, 662 insertions(+) create mode 100644 recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb diff --git a/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb b/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb new file mode 100644 index 0000000..1647878 --- /dev/null +++ b/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb @@ -0,0 +1,662 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b4ca33d6-129c-4a59-89d7-f57e39cacfc0", + "metadata": {}, + "source": [ + "# Generating synthetic lightcurves and fitting the power spectral density of a lightcurve #\n", + "\n", + "This notebook presents the advanced Emmanoulopoulos algorithm for the simulation of synthetic lightcurves. The original paper describing the algorithm is linked [here](https://arxiv.org/pdf/1305.0304.pdf). The version implemented here is compatible with the Gammapy implementation of the Timmer-Koenig algorithm.\n", + "The Timmer-Koenig algorithm generates synthetic lightcurve from a chosen power spectral density (PSD) shape. However, it can only generate time series with a gaussian probability density function (PDF). This is adequate for high-statistics astrophysical domains such as the optical or X-rays, but can be in issue when trying to reproduce curves in the gamma-ray domain, where photon counts are lower and statistics are generally Poissonian. The Emmanoulopoulos algorithm tries to solve this issue, combining a requested PSD and PDF in the simulation. It provides accurate synthetic lightcurves in a range of spectral indexes between -1 and -2 for power-law or similar PSDs.\n", + "\n", + "Together with the simulation algorithm the notebook adds a function to compute the PSD envelope for a lightcurve using either the Timmer-Koenig or the Emmanoulopoulos algorithm. This envelope is then used to fit the PSD fot he observed lightcurve, by passing through a tailored chi-squared-like cost function. This complex fitting is necessary to account for the fact that the periodogram of the observed lightcurve is only a possible realization of the PSD model, moreover convoluted with Poissonian noise and instrumental responses. This can lead to biases or deformation due to random fluctuation of the realization if extracted with a simple curve fit of the periodogram.\n", + "\n", + "The results are satisfactory for power-law or broken-power-law PSDs in a physical interval of spectral indexes, between -1 and -2. Using the Emmanoulopoulos algorithm shows consistently better PSD reconstruction over the Timmer-Koenig - this is due to the injected non-gaussian PDF." + ] + }, + { + "cell_type": "markdown", + "id": "b693b292-fa5c-4afa-b013-464389e4092a", + "metadata": {}, + "source": [ + "## Imports ##\n", + "\n", + "The first step is importing some usual packages, needed Astropy utilities, scipy tools for PDFs and minimization, and Gammapy functions and classes for the observational part." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4678c090-734e-430d-a81e-ff77cf5ef8a0", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "import inspect\n", + "\n", + "import astropy.units as u\n", + "from astropy.coordinates import SkyCoord, AltAz\n", + "\n", + "from regions import PointSkyRegion\n", + "\n", + "from gammapy.estimators import LightCurveEstimator, FluxPoints\n", + "from gammapy.makers import SpectrumDatasetMaker\n", + "from gammapy.data import Observation, observatory_locations, FixedPointingInfo\n", + "from gammapy.datasets import Datasets, SpectrumDataset\n", + "from gammapy.irf import load_irf_dict_from_file\n", + "from gammapy.maps import MapAxis, RegionGeom, TimeMapAxis, RegionNDMap\n", + "from gammapy.modeling.models import SkyModel, PowerLawSpectralModel, LightCurveTemplateTemporalModel\n", + "from gammapy.estimators.utils import compute_lightcurve_fvar\n", + "from gammapy.utils.random import get_random_state\n", + "\n", + "from scipy.optimize import minimize\n", + "from scipy.signal import periodogram\n", + "from scipy.stats import lognorm" + ] + }, + { + "cell_type": "markdown", + "id": "6ff44b6c-f786-4f7d-bf7c-c27cac5a78dc", + "metadata": {}, + "source": [ + "## Reference Lightcurve ##\n", + "\n", + "As a reference, the notebook uses the H.E.S.S. dataset for the PKS2155 AGN flare of 2006. Data properties such as mean and standard deviation fo the norm, number of points, sampling frequency, are taken from this flare. The synthetic lightcurve will be oversampled by a factor 10." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "330ee851-fcc3-47ad-8b1a-e5bd06d78869", + "metadata": {}, + "outputs": [], + "source": [ + "lc_path = Path(\"$GAMMAPY_DATA/estimators/\")\n", + "lc_filename = \"pks2155_hess_lc/pks2155_hess_lc.fits\"\n", + "\n", + "lc = FluxPoints.read(lc_path/lc_filename, format=\"lightcurve\")\n", + "odata = lc.norm.data.flatten()\n", + "omean = odata.mean()\n", + "ostd = odata.std()\n", + "npoints = len(lc.norm.data)*10\n", + "times = lc.geom.axes[\"time\"].edges\n", + "tref = lc.geom.axes[\"time\"].reference_time\n", + "smax = np.diff(times).max()/10\n", + "lc.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "530fa958-3965-4753-a119-21af155999df", + "metadata": {}, + "source": [ + "## Function definition ##\n", + "\n", + "Some simple function definitions for PSD and PDF models, with their default parameters." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d68f9022-debe-4a0f-b484-f23c7fa04de4", + "metadata": {}, + "outputs": [], + "source": [ + "def emm_gammalognorm(x, wgamma, a, s, loc, scale):\n", + " return wgamma*gamma.pdf(x, a) + (1-wgamma)*lognorm.pdf(x, s, loc, scale)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b95c838-5a0e-4739-90aa-53b91bd712e1", + "metadata": {}, + "outputs": [], + "source": [ + "def bpl(x, norm, aup, adn, x0):\n", + " return norm*(x**(-adn))/(1+((x/x0)**(aup-adn)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cadd0727-4527-40eb-99ca-b802a9306b71", + "metadata": {}, + "outputs": [], + "source": [ + "def pl(x, index):\n", + " return x**index" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b70ce94-ba71-43ef-80be-70b15e1a1d6f", + "metadata": {}, + "outputs": [], + "source": [ + "bpl_params = {\"norm\":1, \"aup\":2.4, \"adn\":3, \"x0\":0.1}\n", + "gl_params = {\"wgamma\":0.82,\"a\":5.67, \"s\":0.31, \"loc\":2.14, \"scale\":1}\n", + "ln_params = {'s': 0.5, 'loc': 1.5, 'scale': 1}\n", + "pl_params = {\"index\": -1.4}" + ] + }, + { + "cell_type": "markdown", + "id": "25dd6825-abbb-436e-9c12-b4886daf5c05", + "metadata": {}, + "source": [ + "## The Emmanoulopoulos algorithm ##\n", + "\n", + "The algorithm requires a PDF and PSD shape, the number of points to simulate and spacing between the points (as an astropy Quantity). Optionally can be passed: parameters for the PSD and PDF, random state for reproducibility, maximum number of iterations for the internal loop, number of chunk factor by which the length is multiplicated to avoid red noise leakage, target mean and standard deviation of the time series, whether to add poissonian noise internally to simulate observational effects." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6570bb6c", + "metadata": {}, + "outputs": [], + "source": [ + "def TimmerKonig_lightcurve_simulator(\n", + " power_spectrum,\n", + " npoints,\n", + " spacing,\n", + " nchunks=10,\n", + " random_state=\"random-seed\",\n", + " power_spectrum_params=None,\n", + " mean=0.0,\n", + " std=1.0,\n", + " poisson=False,\n", + "):\n", + "\n", + " if not callable(power_spectrum):\n", + " raise ValueError(\n", + " \"The power spectrum has to be provided as a callable function.\"\n", + " )\n", + "\n", + " if not isinstance(npoints * nchunks, int):\n", + " raise TypeError(\"npoints and nchunks must be integers\")\n", + "\n", + " if poisson:\n", + " if isinstance(mean, u.Quantity):\n", + " wmean = mean.value * spacing.value\n", + " else:\n", + " wmean = mean * spacing.value\n", + " if wmean < 1.0:\n", + " raise Warning(\n", + " \"Poisson noise was requested but the target mean is too low - resulting counts will likely be 0.\"\n", + " )\n", + "\n", + " random_state = get_random_state(random_state)\n", + "\n", + " npoints_ext = npoints * nchunks\n", + "\n", + " frequencies = np.fft.fftfreq(npoints_ext, spacing.value)\n", + "\n", + " # To obtain real data only the positive or negative part of the frequency is necessary.\n", + " real_frequencies = np.sort(np.abs(frequencies[frequencies < 0]))\n", + "\n", + " if power_spectrum_params:\n", + " periodogram = power_spectrum(real_frequencies, **power_spectrum_params)\n", + " else:\n", + " periodogram = power_spectrum(real_frequencies)\n", + "\n", + " real_part = random_state.normal(0, 1, len(periodogram) - 1)\n", + " imaginary_part = random_state.normal(0, 1, len(periodogram) - 1)\n", + "\n", + " # Nyquist frequency component handling\n", + " if npoints_ext % 2 == 0:\n", + " idx0 = -2\n", + " random_factor = random_state.normal(0, 1)\n", + " else:\n", + " idx0 = -1\n", + " random_factor = random_state.normal(0, 1) + 1j * random_state.normal(0, 1)\n", + "\n", + " fourier_coeffs = np.concatenate(\n", + " [\n", + " np.sqrt(0.5 * periodogram[:-1]) * (real_part + 1j * imaginary_part),\n", + " np.sqrt(0.5 * periodogram[-1:]) * random_factor,\n", + " ]\n", + " )\n", + " fourier_coeffs = np.concatenate(\n", + " [fourier_coeffs, np.conjugate(fourier_coeffs[idx0::-1])]\n", + " )\n", + "\n", + " fourier_coeffs = np.insert(fourier_coeffs, 0, 0)\n", + " time_series = np.fft.ifft(fourier_coeffs).real\n", + "\n", + " ndiv = npoints_ext // (2 * nchunks)\n", + " setstart = npoints_ext // 2 - ndiv\n", + " setend = npoints_ext // 2 + ndiv\n", + " if npoints % 2 != 0:\n", + " setend = setend + 1\n", + " time_series = time_series[setstart:setend]\n", + "\n", + " time_series = (time_series - time_series.mean()) / time_series.std()\n", + " time_series = time_series * std + mean\n", + "\n", + " if poisson:\n", + " time_series = (\n", + " random_state.poisson(\n", + " np.where(time_series >= 0, time_series, 0) * spacing.value\n", + " )\n", + " / spacing.value\n", + " )\n", + "\n", + " time_axis = np.linspace(0, npoints * spacing.value, npoints) * spacing.unit\n", + "\n", + " return time_series, time_axis\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "58c4545b-8713-4c40-9f80-e495c3299633", + "metadata": {}, + "outputs": [], + "source": [ + "def Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints, spacing, pdf_params=None, psd_params=None, random_state=\"random-seed\", imax = 1000, nchunks=10, mean=0.0, std=1.0, poisson=False):\n", + " \n", + " target_cps = 0.2\n", + " lc_norm, taxis = TimmerKonig_lightcurve_simulator(psd, npoints, spacing, nchunks = nchunks, power_spectrum_params=psd_params, random_state=random_state)\n", + "\n", + " random_state = get_random_state(random_state)\n", + " \n", + " fft_norm = np.fft.rfft(lc_norm)\n", + "\n", + " a_norm = np.abs(fft_norm)/npoints\n", + " phi_norm = np.angle(fft_norm)\n", + "\n", + " if \"scale\" in pdf_params: scale = pdf_params.get(\"scale\")\n", + " else: scale = 1\n", + " \n", + " xx = np.linspace(0, scale*10, 1000)\n", + " lc_sim = np.interp(random_state.rand(npoints), np.cumsum(pdf(xx, **pdf_params))/np.sum(pdf(xx, **pdf_params)), xx)\n", + " lc_sim = (lc_sim - lc_sim.mean())/lc_sim.std()\n", + "\n", + " nconv = True\n", + " i=0\n", + " while nconv and i= 0, lc_sim, 0) * spacing.decompose().value*target_cps\n", + " )\n", + " / (spacing.decompose().value*target_cps)\n", + " )\n", + " \n", + " return lc_sim, taxis" + ] + }, + { + "cell_type": "markdown", + "id": "6bbdf21a-5463-4730-b1bd-4f72fbd4b029", + "metadata": {}, + "source": [ + "## Envelope and fitting ##\n", + "\n", + "The envelope function returns a set of periodogram extracted from a number of simulations nsims that use the same parameters.\n", + "\n", + "These envelopes can then be used via the x2_fit function to fit the requested PSD to an observed periodogram." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d6c825e-1d05-46fc-beeb-4cfd3f2a0d42", + "metadata": {}, + "outputs": [], + "source": [ + "def lightcurve_psd_envelope(psd, npoints, spacing, pdf=None, nsims=10000, pdf_params=None, psd_params=None, simulator=\"TK\", mean=0., std=1., oversample=10, poisson=False):\n", + " npoints_ext = npoints*oversample\n", + " spacing_ext = spacing/oversample\n", + " if simulator== \"TK\" : tseries, taxis = TimmerKonig_lightcurve_simulator(psd, npoints_ext, spacing_ext, power_spectrum_params=psd_params, mean=mean, std=std, poisson=poisson)\n", + " elif simulator== \"EMM\": tseries, taxis = Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints_ext, spacing_ext, pdf_params=pdf_params, psd_params=psd_params, mean=mean, std=std, poisson=poisson)\n", + " freqs, pg = periodogram(tseries, 1/spacing_ext.value)\n", + " envelopes_psd = np.empty((nsims, npoints//2))\n", + " envelopes_psd[0] = pg[1:npoints//2+1]\n", + " \n", + " for _ in range(1, nsims):\n", + " if simulator== \"TK\" : tseries, taxis = TimmerKonig_lightcurve_simulator(psd, npoints_ext, spacing_ext, power_spectrum_params=psd_params, mean=mean, std=std, poisson=poisson)\n", + " else: tseries, taxis = Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints_ext, spacing_ext, pdf_params=pdf_params, psd_params=psd_params, mean=mean, std=std, poisson=poisson)\n", + "\n", + " freqs, pg = periodogram(tseries, 1/spacing_ext.value)\n", + " envelopes_psd[_] = pg[1:npoints//2+1]\n", + "\n", + " return envelopes_psd, freqs[1:npoints//2+1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "068ae572-491e-44f4-9835-24c9db07ec2f", + "metadata": {}, + "outputs": [], + "source": [ + "def x2_fit(psd_params_list, pgram, npoints, spacing, psd, pdf=None, pdf_params=None, simulator=\"TK\", nsims=10000, mean=None, std=None, poisson=False):\n", + "\n", + " psd_params_keys = list(inspect.signature(psd).parameters.keys())\n", + "\n", + " if len(psd_params_keys[1:]) != len(psd_params_list): raise ValueError(\"parameter values do not correspond to the request from the psd function\")\n", + " \n", + " psd_params = dict(zip(psd_params_keys[1:], psd_params_list))\n", + " \n", + " envelopes, freqs = lightcurve_psd_envelope(psd, npoints, spacing, pdf=pdf, pdf_params=pdf_params, psd_params=psd_params, simulator=simulator, nsims=nsims, mean=mean, std=std, poisson=poisson)\n", + " \n", + " if len(envelopes[0])!= len(pgram): raise ValueError(\"required length is different than data length!\")\n", + " \n", + " obs = (pgram - envelopes.mean(axis=0))**2/envelopes.std(axis=0)**2\n", + " sim = (envelopes - envelopes.mean(axis=0))**2/envelopes.std(axis=0)**2\n", + " sumobs = np.sum(obs)\n", + " sumsim = np.sum(sim, axis=-1)\n", + " sign = len(np.where(sumobs>=sumsim)[0])/nsims\n", + " \n", + " return sign" + ] + }, + { + "cell_type": "markdown", + "id": "78dd6fa2-c725-42b8-a854-5eefaaec5be2", + "metadata": {}, + "source": [ + "## Simulation ##\n", + "\n", + "The simulation call for the algorithm. Both the TK and EMM algorithms are called with the same power-law PSD. The EMM algorithm uses a lognormal PDF. The difference between TK and EMM algorithms is shown in the leftmost and rightmost plot, where the gaussian vs lognormal shape is evident. The middle plot shows the perfect compatibility in the periodogram. Seed is fixed for reproducibility. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9fa4aa20-d5e4-4352-8a7c-6348d5c882cc", + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "seed = 532019\n", + "#seed = \"random-seed\"\n", + "lctk2, taxis2 = Emmanoulopoulos_lightcurve_simulator(lognorm.pdf, pl, npoints, smax, pdf_params=ln_params, psd_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", + "lctk, taxis = TimmerKonig_lightcurve_simulator(pl, npoints, smax, power_spectrum_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", + "freqstk, pgramtk = periodogram(lctk, 1/smax.value)\n", + "freqstk2, pgramtk2 = periodogram(lctk2, 1/smax.value)\n", + "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15,3))\n", + "ax1.plot(taxis, lctk)\n", + "ax2.loglog(freqstk[1:], pgramtk[1:])\n", + "ax3.hist(lctk)\n", + "ax1.plot(taxis2, lctk2)\n", + "ax2.loglog(freqstk2[1:], pgramtk2[1:])\n", + "ax3.hist(lctk2)\n", + "coeff = np.polyfit(np.log(freqstk[1:]), np.log(pgramtk[1:]), 1)\n", + "coeff2 = np.polyfit(np.log(freqstk2[1:]), np.log(pgramtk2[1:]), 1)\n", + "\n", + "print(coeff, coeff2)" + ] + }, + { + "cell_type": "markdown", + "id": "592cd9e0-55d1-4bbf-93f4-e873b011d43d", + "metadata": {}, + "source": [ + "## Gammapy setup and simulation ##\n", + "\n", + "Setup of geometry for the Gammapy simulation. Generic setup for pointing, energy binning, and IRFs. For realistic simulations, choose IRFs that are consistent with the instrument and observational conditions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79fc7316-39ef-490d-9cf9-d714afe9249e", + "metadata": {}, + "outputs": [], + "source": [ + "TimeMapAxis.time_format = \"iso\"\n", + "\n", + "path = Path(\"$GAMMAPY_DATA/cta-caldb\")\n", + "irf_filename = \"Prod5-South-20deg-AverageAz-14MSTs37SSTs.180000s-v0.1.fits.gz\"\n", + "\n", + "irfs = load_irf_dict_from_file(path / irf_filename)\n", + "\n", + "energy_axis = MapAxis.from_energy_bounds(\n", + " energy_min=0.1 * u.TeV, energy_max=100 * u.TeV, nbin=1\n", + ")\n", + "\n", + "energy_axis_true = MapAxis.from_edges(\n", + " np.logspace(-1.2, 2.0, 31), unit=\"TeV\", name=\"energy_true\", interp=\"log\"\n", + ")\n", + "\n", + "time_axis = MapAxis.from_nodes(taxis, name=\"time\", interp=\"lin\")\n", + "\n", + "geom = RegionGeom.create(\"galactic;circle(107.65, -40.17, 5)\", axes=[energy_axis])\n", + "\n", + "pointing_position = SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\")\n", + "pointing = FixedPointingInfo(\n", + " fixed_icrs=SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\").icrs,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8d9aec9b-9f38-4f9b-903e-e5189c7edf6c", + "metadata": {}, + "source": [ + "The time series generated via EMM is taken as a LightCurveTemplateTemporalModel" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c900eb8e-87ce-4771-8ccc-db627c7a541f", + "metadata": {}, + "outputs": [], + "source": [ + "gti_t0 = tref\n", + "\n", + "spectral_model = PowerLawSpectralModel(amplitude = 1e-10 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", + "\n", + "m = RegionNDMap.create(\n", + " region=PointSkyRegion(center=pointing_position),\n", + " axes=[time_axis],\n", + " unit=\"cm-2s-1TeV-1\",\n", + ")\n", + "\n", + "m.quantity = lctk2\n", + "\n", + "temporal_model = LightCurveTemplateTemporalModel(m, t_ref=gti_t0)\n", + "\n", + "model_simu = SkyModel(\n", + " spectral_model=spectral_model,\n", + " temporal_model=temporal_model,\n", + " name=\"model-simu\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "7ccc6acb-5054-4879-bba9-ae0bd14e6b02", + "metadata": {}, + "source": [ + "Observation timing setup and simulation fo the datasets. The \"observational\" sampling is taken to be much sparser than the synthetic lightcurve, to avoid aliasing." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bd889da2-54be-461f-b9a4-a34959e994a7", + "metadata": {}, + "outputs": [], + "source": [ + "lvtm = 10 * u.min\n", + "tstart = gti_t0 + np.arange(npoints/10)*lvtm\n", + "altaz = pointing_position.transform_to(AltAz(obstime = tstart, location = observatory_locations[\"cta_south\"]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f142057c-852f-4605-88d3-b27d63417803", + "metadata": {}, + "outputs": [], + "source": [ + "datasets = Datasets()\n", + "\n", + "empty = SpectrumDataset.create(\n", + "geom=geom, energy_axis_true=energy_axis_true, name=\"empty\"\n", + ")\n", + "\n", + "maker = SpectrumDatasetMaker(selection=[\"exposure\", \"background\", \"edisp\"])\n", + "\n", + "for idx in range(len(tstart)):\n", + " obs = Observation.create(\n", + " pointing=pointing,\n", + " livetime=lvtm,\n", + " tstart=tstart[idx],\n", + " irfs=irfs,\n", + " reference_time=gti_t0,\n", + " obs_id=idx,\n", + " location=observatory_locations[\"cta_south\"],\n", + " )\n", + " empty_i = empty.copy(name=f\"dataset-{idx}\")\n", + " dataset = maker.run(empty_i, obs)\n", + " dataset.models = model_simu\n", + " dataset.fake()\n", + " datasets.append(dataset)\n", + "\n", + "\n", + "spectral_model = PowerLawSpectralModel(amplitude = 7e-11 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", + "model_fit = SkyModel(spectral_model=spectral_model, name=\"model-fit\")\n", + "datasets.models = model_fit" + ] + }, + { + "cell_type": "markdown", + "id": "725f0466-21c4-4da2-a5da-21486ef0a43d", + "metadata": {}, + "source": [ + "Lightcurve estimator setup and run." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6150efce-4ced-4237-bf53-12fbd5fe9a30", + "metadata": {}, + "outputs": [], + "source": [ + "lc_maker_1d = LightCurveEstimator(\n", + " energy_edges=[0.1, 100] * u.TeV,\n", + " source=\"model-fit\",\n", + " selection_optional=[\"ul\"],\n", + ")\n", + "\n", + "lc_1d = lc_maker_1d.run(datasets)\n", + "lc_1d.plot();" + ] + }, + { + "cell_type": "markdown", + "id": "b27cd811-a990-48c1-93af-baee1198432c", + "metadata": {}, + "source": [ + "Assessment of the properties of the \"observed\" lightcurve in the time and frequency domain." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2ee2f7b-c8ee-4251-b276-75d4cd247b66", + "metadata": {}, + "outputs": [], + "source": [ + "data = lc_1d.norm.data.flatten()\n", + "dmean = data.mean()\n", + "dstd = data.std()\n", + "dnpoints = len(data)\n", + "dtimes = lc_1d.geom.axes[\"time\"].edges\n", + "dsmax = np.diff(dtimes).max()\n", + "ffreqs, pgram = periodogram(data, 1/dsmax.value)\n", + "coeff = np.polyfit(np.log(ffreqs[1:]), np.log(pgram[1:]), 1)\n", + "print(coeff[0])\n", + "plt.loglog(ffreqs[1:], pgram[1:])" + ] + }, + { + "cell_type": "markdown", + "id": "759e1ddd-98dc-4854-8ba7-c1e58facbb87", + "metadata": {}, + "source": [ + "### Fitting ###\n", + "\n", + "The x2_fit function is used as a cost function with the scipy minimizer, providing a fit of the spectral index for the \"observed\" lightcurve assuming a power-law PSD. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b08789fe-2a0a-4056-8b38-1aaea9946059", + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [], + "source": [ + "%%time\n", + "initial_pars = [-2]\n", + "results = minimize(x2_fit, initial_pars, args=(pgram[1:], dnpoints, dsmax, pl, lognorm.pdf, ln_params, \"EMM\", 10000, dmean, dstd, False), method=\"Powell\", options={\"disp\": True})\n", + "print(results)\n", + "envelopes, freqs = lightcurve_psd_envelope(pl, dnpoints, dsmax, psd_params={\"index\": results.x}, simulator=\"EMM\", pdf = lognorm.pdf, pdf_params = ln_params , nsims=10000, mean=dmean, std=dstd, poisson=False)\n", + "plt.violinplot(envelopes, freqs, widths=np.diff(freqs).min(), showmedians=True);\n", + "plt.plot(freqs, pgram[1:], linewidth=0.7, marker=\"d\")\n", + "plt.yscale(\"log\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "939d6039", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From c66ddbc2491698a3c6971898af673f9dca880f36 Mon Sep 17 00:00:00 2001 From: Claudio Galelli Date: Fri, 30 Aug 2024 15:21:03 +0200 Subject: [PATCH 08/13] Delete recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb --- .../fit-psd-lightcurve.ipynb | 662 ------------------ 1 file changed, 662 deletions(-) delete mode 100644 recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb diff --git a/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb b/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb deleted file mode 100644 index 1647878..0000000 --- a/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb +++ /dev/null @@ -1,662 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "b4ca33d6-129c-4a59-89d7-f57e39cacfc0", - "metadata": {}, - "source": [ - "# Generating synthetic lightcurves and fitting the power spectral density of a lightcurve #\n", - "\n", - "This notebook presents the advanced Emmanoulopoulos algorithm for the simulation of synthetic lightcurves. The original paper describing the algorithm is linked [here](https://arxiv.org/pdf/1305.0304.pdf). The version implemented here is compatible with the Gammapy implementation of the Timmer-Koenig algorithm.\n", - "The Timmer-Koenig algorithm generates synthetic lightcurve from a chosen power spectral density (PSD) shape. However, it can only generate time series with a gaussian probability density function (PDF). This is adequate for high-statistics astrophysical domains such as the optical or X-rays, but can be in issue when trying to reproduce curves in the gamma-ray domain, where photon counts are lower and statistics are generally Poissonian. The Emmanoulopoulos algorithm tries to solve this issue, combining a requested PSD and PDF in the simulation. It provides accurate synthetic lightcurves in a range of spectral indexes between -1 and -2 for power-law or similar PSDs.\n", - "\n", - "Together with the simulation algorithm the notebook adds a function to compute the PSD envelope for a lightcurve using either the Timmer-Koenig or the Emmanoulopoulos algorithm. This envelope is then used to fit the PSD fot he observed lightcurve, by passing through a tailored chi-squared-like cost function. This complex fitting is necessary to account for the fact that the periodogram of the observed lightcurve is only a possible realization of the PSD model, moreover convoluted with Poissonian noise and instrumental responses. This can lead to biases or deformation due to random fluctuation of the realization if extracted with a simple curve fit of the periodogram.\n", - "\n", - "The results are satisfactory for power-law or broken-power-law PSDs in a physical interval of spectral indexes, between -1 and -2. Using the Emmanoulopoulos algorithm shows consistently better PSD reconstruction over the Timmer-Koenig - this is due to the injected non-gaussian PDF." - ] - }, - { - "cell_type": "markdown", - "id": "b693b292-fa5c-4afa-b013-464389e4092a", - "metadata": {}, - "source": [ - "## Imports ##\n", - "\n", - "The first step is importing some usual packages, needed Astropy utilities, scipy tools for PDFs and minimization, and Gammapy functions and classes for the observational part." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4678c090-734e-430d-a81e-ff77cf5ef8a0", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from pathlib import Path\n", - "import matplotlib.pyplot as plt\n", - "import inspect\n", - "\n", - "import astropy.units as u\n", - "from astropy.coordinates import SkyCoord, AltAz\n", - "\n", - "from regions import PointSkyRegion\n", - "\n", - "from gammapy.estimators import LightCurveEstimator, FluxPoints\n", - "from gammapy.makers import SpectrumDatasetMaker\n", - "from gammapy.data import Observation, observatory_locations, FixedPointingInfo\n", - "from gammapy.datasets import Datasets, SpectrumDataset\n", - "from gammapy.irf import load_irf_dict_from_file\n", - "from gammapy.maps import MapAxis, RegionGeom, TimeMapAxis, RegionNDMap\n", - "from gammapy.modeling.models import SkyModel, PowerLawSpectralModel, LightCurveTemplateTemporalModel\n", - "from gammapy.estimators.utils import compute_lightcurve_fvar\n", - "from gammapy.utils.random import get_random_state\n", - "\n", - "from scipy.optimize import minimize\n", - "from scipy.signal import periodogram\n", - "from scipy.stats import lognorm" - ] - }, - { - "cell_type": "markdown", - "id": "6ff44b6c-f786-4f7d-bf7c-c27cac5a78dc", - "metadata": {}, - "source": [ - "## Reference Lightcurve ##\n", - "\n", - "As a reference, the notebook uses the H.E.S.S. dataset for the PKS2155 AGN flare of 2006. Data properties such as mean and standard deviation fo the norm, number of points, sampling frequency, are taken from this flare. The synthetic lightcurve will be oversampled by a factor 10." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "330ee851-fcc3-47ad-8b1a-e5bd06d78869", - "metadata": {}, - "outputs": [], - "source": [ - "lc_path = Path(\"$GAMMAPY_DATA/estimators/\")\n", - "lc_filename = \"pks2155_hess_lc/pks2155_hess_lc.fits\"\n", - "\n", - "lc = FluxPoints.read(lc_path/lc_filename, format=\"lightcurve\")\n", - "odata = lc.norm.data.flatten()\n", - "omean = odata.mean()\n", - "ostd = odata.std()\n", - "npoints = len(lc.norm.data)*10\n", - "times = lc.geom.axes[\"time\"].edges\n", - "tref = lc.geom.axes[\"time\"].reference_time\n", - "smax = np.diff(times).max()/10\n", - "lc.plot()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "530fa958-3965-4753-a119-21af155999df", - "metadata": {}, - "source": [ - "## Function definition ##\n", - "\n", - "Some simple function definitions for PSD and PDF models, with their default parameters." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d68f9022-debe-4a0f-b484-f23c7fa04de4", - "metadata": {}, - "outputs": [], - "source": [ - "def emm_gammalognorm(x, wgamma, a, s, loc, scale):\n", - " return wgamma*gamma.pdf(x, a) + (1-wgamma)*lognorm.pdf(x, s, loc, scale)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9b95c838-5a0e-4739-90aa-53b91bd712e1", - "metadata": {}, - "outputs": [], - "source": [ - "def bpl(x, norm, aup, adn, x0):\n", - " return norm*(x**(-adn))/(1+((x/x0)**(aup-adn)))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cadd0727-4527-40eb-99ca-b802a9306b71", - "metadata": {}, - "outputs": [], - "source": [ - "def pl(x, index):\n", - " return x**index" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8b70ce94-ba71-43ef-80be-70b15e1a1d6f", - "metadata": {}, - "outputs": [], - "source": [ - "bpl_params = {\"norm\":1, \"aup\":2.4, \"adn\":3, \"x0\":0.1}\n", - "gl_params = {\"wgamma\":0.82,\"a\":5.67, \"s\":0.31, \"loc\":2.14, \"scale\":1}\n", - "ln_params = {'s': 0.5, 'loc': 1.5, 'scale': 1}\n", - "pl_params = {\"index\": -1.4}" - ] - }, - { - "cell_type": "markdown", - "id": "25dd6825-abbb-436e-9c12-b4886daf5c05", - "metadata": {}, - "source": [ - "## The Emmanoulopoulos algorithm ##\n", - "\n", - "The algorithm requires a PDF and PSD shape, the number of points to simulate and spacing between the points (as an astropy Quantity). Optionally can be passed: parameters for the PSD and PDF, random state for reproducibility, maximum number of iterations for the internal loop, number of chunk factor by which the length is multiplicated to avoid red noise leakage, target mean and standard deviation of the time series, whether to add poissonian noise internally to simulate observational effects." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6570bb6c", - "metadata": {}, - "outputs": [], - "source": [ - "def TimmerKonig_lightcurve_simulator(\n", - " power_spectrum,\n", - " npoints,\n", - " spacing,\n", - " nchunks=10,\n", - " random_state=\"random-seed\",\n", - " power_spectrum_params=None,\n", - " mean=0.0,\n", - " std=1.0,\n", - " poisson=False,\n", - "):\n", - "\n", - " if not callable(power_spectrum):\n", - " raise ValueError(\n", - " \"The power spectrum has to be provided as a callable function.\"\n", - " )\n", - "\n", - " if not isinstance(npoints * nchunks, int):\n", - " raise TypeError(\"npoints and nchunks must be integers\")\n", - "\n", - " if poisson:\n", - " if isinstance(mean, u.Quantity):\n", - " wmean = mean.value * spacing.value\n", - " else:\n", - " wmean = mean * spacing.value\n", - " if wmean < 1.0:\n", - " raise Warning(\n", - " \"Poisson noise was requested but the target mean is too low - resulting counts will likely be 0.\"\n", - " )\n", - "\n", - " random_state = get_random_state(random_state)\n", - "\n", - " npoints_ext = npoints * nchunks\n", - "\n", - " frequencies = np.fft.fftfreq(npoints_ext, spacing.value)\n", - "\n", - " # To obtain real data only the positive or negative part of the frequency is necessary.\n", - " real_frequencies = np.sort(np.abs(frequencies[frequencies < 0]))\n", - "\n", - " if power_spectrum_params:\n", - " periodogram = power_spectrum(real_frequencies, **power_spectrum_params)\n", - " else:\n", - " periodogram = power_spectrum(real_frequencies)\n", - "\n", - " real_part = random_state.normal(0, 1, len(periodogram) - 1)\n", - " imaginary_part = random_state.normal(0, 1, len(periodogram) - 1)\n", - "\n", - " # Nyquist frequency component handling\n", - " if npoints_ext % 2 == 0:\n", - " idx0 = -2\n", - " random_factor = random_state.normal(0, 1)\n", - " else:\n", - " idx0 = -1\n", - " random_factor = random_state.normal(0, 1) + 1j * random_state.normal(0, 1)\n", - "\n", - " fourier_coeffs = np.concatenate(\n", - " [\n", - " np.sqrt(0.5 * periodogram[:-1]) * (real_part + 1j * imaginary_part),\n", - " np.sqrt(0.5 * periodogram[-1:]) * random_factor,\n", - " ]\n", - " )\n", - " fourier_coeffs = np.concatenate(\n", - " [fourier_coeffs, np.conjugate(fourier_coeffs[idx0::-1])]\n", - " )\n", - "\n", - " fourier_coeffs = np.insert(fourier_coeffs, 0, 0)\n", - " time_series = np.fft.ifft(fourier_coeffs).real\n", - "\n", - " ndiv = npoints_ext // (2 * nchunks)\n", - " setstart = npoints_ext // 2 - ndiv\n", - " setend = npoints_ext // 2 + ndiv\n", - " if npoints % 2 != 0:\n", - " setend = setend + 1\n", - " time_series = time_series[setstart:setend]\n", - "\n", - " time_series = (time_series - time_series.mean()) / time_series.std()\n", - " time_series = time_series * std + mean\n", - "\n", - " if poisson:\n", - " time_series = (\n", - " random_state.poisson(\n", - " np.where(time_series >= 0, time_series, 0) * spacing.value\n", - " )\n", - " / spacing.value\n", - " )\n", - "\n", - " time_axis = np.linspace(0, npoints * spacing.value, npoints) * spacing.unit\n", - "\n", - " return time_series, time_axis\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "58c4545b-8713-4c40-9f80-e495c3299633", - "metadata": {}, - "outputs": [], - "source": [ - "def Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints, spacing, pdf_params=None, psd_params=None, random_state=\"random-seed\", imax = 1000, nchunks=10, mean=0.0, std=1.0, poisson=False):\n", - " \n", - " target_cps = 0.2\n", - " lc_norm, taxis = TimmerKonig_lightcurve_simulator(psd, npoints, spacing, nchunks = nchunks, power_spectrum_params=psd_params, random_state=random_state)\n", - "\n", - " random_state = get_random_state(random_state)\n", - " \n", - " fft_norm = np.fft.rfft(lc_norm)\n", - "\n", - " a_norm = np.abs(fft_norm)/npoints\n", - " phi_norm = np.angle(fft_norm)\n", - "\n", - " if \"scale\" in pdf_params: scale = pdf_params.get(\"scale\")\n", - " else: scale = 1\n", - " \n", - " xx = np.linspace(0, scale*10, 1000)\n", - " lc_sim = np.interp(random_state.rand(npoints), np.cumsum(pdf(xx, **pdf_params))/np.sum(pdf(xx, **pdf_params)), xx)\n", - " lc_sim = (lc_sim - lc_sim.mean())/lc_sim.std()\n", - "\n", - " nconv = True\n", - " i=0\n", - " while nconv and i= 0, lc_sim, 0) * spacing.decompose().value*target_cps\n", - " )\n", - " / (spacing.decompose().value*target_cps)\n", - " )\n", - " \n", - " return lc_sim, taxis" - ] - }, - { - "cell_type": "markdown", - "id": "6bbdf21a-5463-4730-b1bd-4f72fbd4b029", - "metadata": {}, - "source": [ - "## Envelope and fitting ##\n", - "\n", - "The envelope function returns a set of periodogram extracted from a number of simulations nsims that use the same parameters.\n", - "\n", - "These envelopes can then be used via the x2_fit function to fit the requested PSD to an observed periodogram." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4d6c825e-1d05-46fc-beeb-4cfd3f2a0d42", - "metadata": {}, - "outputs": [], - "source": [ - "def lightcurve_psd_envelope(psd, npoints, spacing, pdf=None, nsims=10000, pdf_params=None, psd_params=None, simulator=\"TK\", mean=0., std=1., oversample=10, poisson=False):\n", - " npoints_ext = npoints*oversample\n", - " spacing_ext = spacing/oversample\n", - " if simulator== \"TK\" : tseries, taxis = TimmerKonig_lightcurve_simulator(psd, npoints_ext, spacing_ext, power_spectrum_params=psd_params, mean=mean, std=std, poisson=poisson)\n", - " elif simulator== \"EMM\": tseries, taxis = Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints_ext, spacing_ext, pdf_params=pdf_params, psd_params=psd_params, mean=mean, std=std, poisson=poisson)\n", - " freqs, pg = periodogram(tseries, 1/spacing_ext.value)\n", - " envelopes_psd = np.empty((nsims, npoints//2))\n", - " envelopes_psd[0] = pg[1:npoints//2+1]\n", - " \n", - " for _ in range(1, nsims):\n", - " if simulator== \"TK\" : tseries, taxis = TimmerKonig_lightcurve_simulator(psd, npoints_ext, spacing_ext, power_spectrum_params=psd_params, mean=mean, std=std, poisson=poisson)\n", - " else: tseries, taxis = Emmanoulopoulos_lightcurve_simulator(pdf, psd, npoints_ext, spacing_ext, pdf_params=pdf_params, psd_params=psd_params, mean=mean, std=std, poisson=poisson)\n", - "\n", - " freqs, pg = periodogram(tseries, 1/spacing_ext.value)\n", - " envelopes_psd[_] = pg[1:npoints//2+1]\n", - "\n", - " return envelopes_psd, freqs[1:npoints//2+1]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "068ae572-491e-44f4-9835-24c9db07ec2f", - "metadata": {}, - "outputs": [], - "source": [ - "def x2_fit(psd_params_list, pgram, npoints, spacing, psd, pdf=None, pdf_params=None, simulator=\"TK\", nsims=10000, mean=None, std=None, poisson=False):\n", - "\n", - " psd_params_keys = list(inspect.signature(psd).parameters.keys())\n", - "\n", - " if len(psd_params_keys[1:]) != len(psd_params_list): raise ValueError(\"parameter values do not correspond to the request from the psd function\")\n", - " \n", - " psd_params = dict(zip(psd_params_keys[1:], psd_params_list))\n", - " \n", - " envelopes, freqs = lightcurve_psd_envelope(psd, npoints, spacing, pdf=pdf, pdf_params=pdf_params, psd_params=psd_params, simulator=simulator, nsims=nsims, mean=mean, std=std, poisson=poisson)\n", - " \n", - " if len(envelopes[0])!= len(pgram): raise ValueError(\"required length is different than data length!\")\n", - " \n", - " obs = (pgram - envelopes.mean(axis=0))**2/envelopes.std(axis=0)**2\n", - " sim = (envelopes - envelopes.mean(axis=0))**2/envelopes.std(axis=0)**2\n", - " sumobs = np.sum(obs)\n", - " sumsim = np.sum(sim, axis=-1)\n", - " sign = len(np.where(sumobs>=sumsim)[0])/nsims\n", - " \n", - " return sign" - ] - }, - { - "cell_type": "markdown", - "id": "78dd6fa2-c725-42b8-a854-5eefaaec5be2", - "metadata": {}, - "source": [ - "## Simulation ##\n", - "\n", - "The simulation call for the algorithm. Both the TK and EMM algorithms are called with the same power-law PSD. The EMM algorithm uses a lognormal PDF. The difference between TK and EMM algorithms is shown in the leftmost and rightmost plot, where the gaussian vs lognormal shape is evident. The middle plot shows the perfect compatibility in the periodogram. Seed is fixed for reproducibility. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9fa4aa20-d5e4-4352-8a7c-6348d5c882cc", - "metadata": {}, - "outputs": [], - "source": [ - "%%time\n", - "seed = 532019\n", - "#seed = \"random-seed\"\n", - "lctk2, taxis2 = Emmanoulopoulos_lightcurve_simulator(lognorm.pdf, pl, npoints, smax, pdf_params=ln_params, psd_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", - "lctk, taxis = TimmerKonig_lightcurve_simulator(pl, npoints, smax, power_spectrum_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", - "freqstk, pgramtk = periodogram(lctk, 1/smax.value)\n", - "freqstk2, pgramtk2 = periodogram(lctk2, 1/smax.value)\n", - "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15,3))\n", - "ax1.plot(taxis, lctk)\n", - "ax2.loglog(freqstk[1:], pgramtk[1:])\n", - "ax3.hist(lctk)\n", - "ax1.plot(taxis2, lctk2)\n", - "ax2.loglog(freqstk2[1:], pgramtk2[1:])\n", - "ax3.hist(lctk2)\n", - "coeff = np.polyfit(np.log(freqstk[1:]), np.log(pgramtk[1:]), 1)\n", - "coeff2 = np.polyfit(np.log(freqstk2[1:]), np.log(pgramtk2[1:]), 1)\n", - "\n", - "print(coeff, coeff2)" - ] - }, - { - "cell_type": "markdown", - "id": "592cd9e0-55d1-4bbf-93f4-e873b011d43d", - "metadata": {}, - "source": [ - "## Gammapy setup and simulation ##\n", - "\n", - "Setup of geometry for the Gammapy simulation. Generic setup for pointing, energy binning, and IRFs. For realistic simulations, choose IRFs that are consistent with the instrument and observational conditions." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "79fc7316-39ef-490d-9cf9-d714afe9249e", - "metadata": {}, - "outputs": [], - "source": [ - "TimeMapAxis.time_format = \"iso\"\n", - "\n", - "path = Path(\"$GAMMAPY_DATA/cta-caldb\")\n", - "irf_filename = \"Prod5-South-20deg-AverageAz-14MSTs37SSTs.180000s-v0.1.fits.gz\"\n", - "\n", - "irfs = load_irf_dict_from_file(path / irf_filename)\n", - "\n", - "energy_axis = MapAxis.from_energy_bounds(\n", - " energy_min=0.1 * u.TeV, energy_max=100 * u.TeV, nbin=1\n", - ")\n", - "\n", - "energy_axis_true = MapAxis.from_edges(\n", - " np.logspace(-1.2, 2.0, 31), unit=\"TeV\", name=\"energy_true\", interp=\"log\"\n", - ")\n", - "\n", - "time_axis = MapAxis.from_nodes(taxis, name=\"time\", interp=\"lin\")\n", - "\n", - "geom = RegionGeom.create(\"galactic;circle(107.65, -40.17, 5)\", axes=[energy_axis])\n", - "\n", - "pointing_position = SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\")\n", - "pointing = FixedPointingInfo(\n", - " fixed_icrs=SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\").icrs,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "8d9aec9b-9f38-4f9b-903e-e5189c7edf6c", - "metadata": {}, - "source": [ - "The time series generated via EMM is taken as a LightCurveTemplateTemporalModel" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c900eb8e-87ce-4771-8ccc-db627c7a541f", - "metadata": {}, - "outputs": [], - "source": [ - "gti_t0 = tref\n", - "\n", - "spectral_model = PowerLawSpectralModel(amplitude = 1e-10 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", - "\n", - "m = RegionNDMap.create(\n", - " region=PointSkyRegion(center=pointing_position),\n", - " axes=[time_axis],\n", - " unit=\"cm-2s-1TeV-1\",\n", - ")\n", - "\n", - "m.quantity = lctk2\n", - "\n", - "temporal_model = LightCurveTemplateTemporalModel(m, t_ref=gti_t0)\n", - "\n", - "model_simu = SkyModel(\n", - " spectral_model=spectral_model,\n", - " temporal_model=temporal_model,\n", - " name=\"model-simu\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "7ccc6acb-5054-4879-bba9-ae0bd14e6b02", - "metadata": {}, - "source": [ - "Observation timing setup and simulation fo the datasets. The \"observational\" sampling is taken to be much sparser than the synthetic lightcurve, to avoid aliasing." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bd889da2-54be-461f-b9a4-a34959e994a7", - "metadata": {}, - "outputs": [], - "source": [ - "lvtm = 10 * u.min\n", - "tstart = gti_t0 + np.arange(npoints/10)*lvtm\n", - "altaz = pointing_position.transform_to(AltAz(obstime = tstart, location = observatory_locations[\"cta_south\"]))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f142057c-852f-4605-88d3-b27d63417803", - "metadata": {}, - "outputs": [], - "source": [ - "datasets = Datasets()\n", - "\n", - "empty = SpectrumDataset.create(\n", - "geom=geom, energy_axis_true=energy_axis_true, name=\"empty\"\n", - ")\n", - "\n", - "maker = SpectrumDatasetMaker(selection=[\"exposure\", \"background\", \"edisp\"])\n", - "\n", - "for idx in range(len(tstart)):\n", - " obs = Observation.create(\n", - " pointing=pointing,\n", - " livetime=lvtm,\n", - " tstart=tstart[idx],\n", - " irfs=irfs,\n", - " reference_time=gti_t0,\n", - " obs_id=idx,\n", - " location=observatory_locations[\"cta_south\"],\n", - " )\n", - " empty_i = empty.copy(name=f\"dataset-{idx}\")\n", - " dataset = maker.run(empty_i, obs)\n", - " dataset.models = model_simu\n", - " dataset.fake()\n", - " datasets.append(dataset)\n", - "\n", - "\n", - "spectral_model = PowerLawSpectralModel(amplitude = 7e-11 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", - "model_fit = SkyModel(spectral_model=spectral_model, name=\"model-fit\")\n", - "datasets.models = model_fit" - ] - }, - { - "cell_type": "markdown", - "id": "725f0466-21c4-4da2-a5da-21486ef0a43d", - "metadata": {}, - "source": [ - "Lightcurve estimator setup and run." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6150efce-4ced-4237-bf53-12fbd5fe9a30", - "metadata": {}, - "outputs": [], - "source": [ - "lc_maker_1d = LightCurveEstimator(\n", - " energy_edges=[0.1, 100] * u.TeV,\n", - " source=\"model-fit\",\n", - " selection_optional=[\"ul\"],\n", - ")\n", - "\n", - "lc_1d = lc_maker_1d.run(datasets)\n", - "lc_1d.plot();" - ] - }, - { - "cell_type": "markdown", - "id": "b27cd811-a990-48c1-93af-baee1198432c", - "metadata": {}, - "source": [ - "Assessment of the properties of the \"observed\" lightcurve in the time and frequency domain." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e2ee2f7b-c8ee-4251-b276-75d4cd247b66", - "metadata": {}, - "outputs": [], - "source": [ - "data = lc_1d.norm.data.flatten()\n", - "dmean = data.mean()\n", - "dstd = data.std()\n", - "dnpoints = len(data)\n", - "dtimes = lc_1d.geom.axes[\"time\"].edges\n", - "dsmax = np.diff(dtimes).max()\n", - "ffreqs, pgram = periodogram(data, 1/dsmax.value)\n", - "coeff = np.polyfit(np.log(ffreqs[1:]), np.log(pgram[1:]), 1)\n", - "print(coeff[0])\n", - "plt.loglog(ffreqs[1:], pgram[1:])" - ] - }, - { - "cell_type": "markdown", - "id": "759e1ddd-98dc-4854-8ba7-c1e58facbb87", - "metadata": {}, - "source": [ - "### Fitting ###\n", - "\n", - "The x2_fit function is used as a cost function with the scipy minimizer, providing a fit of the spectral index for the \"observed\" lightcurve assuming a power-law PSD. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b08789fe-2a0a-4056-8b38-1aaea9946059", - "metadata": { - "tags": [ - "nbsphinx-thumbnail" - ] - }, - "outputs": [], - "source": [ - "%%time\n", - "initial_pars = [-2]\n", - "results = minimize(x2_fit, initial_pars, args=(pgram[1:], dnpoints, dsmax, pl, lognorm.pdf, ln_params, \"EMM\", 10000, dmean, dstd, False), method=\"Powell\", options={\"disp\": True})\n", - "print(results)\n", - "envelopes, freqs = lightcurve_psd_envelope(pl, dnpoints, dsmax, psd_params={\"index\": results.x}, simulator=\"EMM\", pdf = lognorm.pdf, pdf_params = ln_params , nsims=10000, mean=dmean, std=dstd, poisson=False)\n", - "plt.violinplot(envelopes, freqs, widths=np.diff(freqs).min(), showmedians=True);\n", - "plt.plot(freqs, pgram[1:], linewidth=0.7, marker=\"d\")\n", - "plt.yscale(\"log\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "939d6039", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 4a93107e39f9251dab907d31ec16f13e5bdc8cd0 Mon Sep 17 00:00:00 2001 From: Claudio Galelli Date: Fri, 30 Aug 2024 15:21:27 +0200 Subject: [PATCH 09/13] Add files via upload --- ...wer spectral density of a lightcurve.ipynb | 427 ++++++++++++++++++ 1 file changed, 427 insertions(+) create mode 100644 recipes/fit-psd-lightcurve/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb diff --git a/recipes/fit-psd-lightcurve/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb b/recipes/fit-psd-lightcurve/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb new file mode 100644 index 0000000..84fc4e2 --- /dev/null +++ b/recipes/fit-psd-lightcurve/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb @@ -0,0 +1,427 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b4ca33d6-129c-4a59-89d7-f57e39cacfc0", + "metadata": {}, + "source": [ + "# Generating synthetic lightcurves and fitting the power spectral density of a lightcurve #\n", + "\n", + "This notebook presents the advanced Emmanoulopoulos algorithm for the simulation of synthetic lightcurves. The original paper describing the algorithm is linked [here](https://arxiv.org/pdf/1305.0304.pdf). The version implemented here is compatible with the Gammapy implementation of the Timmer-Koenig algorithm.\n", + "The Timmer-Koenig algorithm generates synthetic lightcurve from a chosen power spectral density (PSD) shape. However, it can only generate time series with a gaussian probability density function (PDF). This is adequate for high-statistics astrophysical domains such as the optical or X-rays, but can be in issue when trying to reproduce curves in the gamma-ray domain, where photon counts are lower and statistics are generally Poissonian. The Emmanoulopoulos algorithm tries to solve this issue, combining a requested PSD and PDF in the simulation. It provides accurate synthetic lightcurves in a range of spectral indexes between -1 and -2 for power-law or similar PSDs.\n", + "\n", + "Together with the simulation algorithm the notebook shows a function to compute the PSD envelope for a lightcurve using either the Timmer-Koenig or the Emmanoulopoulos algorithm. This envelope is then used to fit the PSD fot he observed lightcurve, by passing through a tailored chi-squared-like cost function. This complex fitting is necessary to account for the fact that the periodogram of the observed lightcurve is only a possible realization of the PSD model, moreover convoluted with Poissonian noise and instrumental responses. This can lead to biases or deformation due to random fluctuation of the realization if extracted with a simple curve fit of the periodogram.\n", + "\n", + "The results are satisfactory for power-law or broken-power-law PSDs in a physical interval of spectral indexes, between -1 and -2. Using the Emmanoulopoulos algorithm shows consistently better PSD reconstruction over the Timmer-Koenig - this is due to the injected non-gaussian PDF.\n", + "\n", + "The functions for the Timmer-Koenig and Emmanoulopoulos algorithms, the envelope, x2-like cost function for fitting, and some helper analytical functions are implemented in the helper package `gammapy_SyLC`." + ] + }, + { + "cell_type": "markdown", + "id": "b693b292-fa5c-4afa-b013-464389e4092a", + "metadata": {}, + "source": [ + "## Imports ##\n", + "\n", + "The first step is importing some usual packages, needed Astropy utilities, scipy tools for PDFs and minimization, and Gammapy functions and classes for the observational part." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4678c090-734e-430d-a81e-ff77cf5ef8a0", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "import inspect\n", + "\n", + "import astropy.units as u\n", + "from astropy.coordinates import SkyCoord, AltAz\n", + "\n", + "from regions import PointSkyRegion\n", + "\n", + "from gammapy.estimators import LightCurveEstimator, FluxPoints\n", + "from gammapy.makers import SpectrumDatasetMaker\n", + "from gammapy.data import Observation, observatory_locations, FixedPointingInfo\n", + "from gammapy.datasets import Datasets, SpectrumDataset\n", + "from gammapy.irf import load_irf_dict_from_file\n", + "from gammapy.maps import MapAxis, RegionGeom, TimeMapAxis, RegionNDMap\n", + "from gammapy.modeling.models import SkyModel, PowerLawSpectralModel, LightCurveTemplateTemporalModel\n", + "from gammapy.estimators.utils import compute_lightcurve_fvar\n", + "from gammapy.utils.random import get_random_state\n", + "\n", + "from scipy.optimize import minimize\n", + "from scipy.signal import periodogram\n", + "from scipy.stats import lognorm" + ] + }, + { + "cell_type": "markdown", + "id": "3a7b5a24", + "metadata": {}, + "source": [ + "Additionally, we import the necessary functions for lightcurve simulation and fitting from the helper package [gammapy_SyLC](https://github.com/cgalelli/gammapy_SyLC). The package can be obtained from github and installed by running:\n", + "\n", + "`git clone https://github.com/cgalelli/gammapy_SyLC.git` \n", + "`cd gammapy_SyLC` \n", + "`python -m pip install -e .` " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3d340431", + "metadata": {}, + "outputs": [], + "source": [ + "from gammapy_SyLC import (TimmerKonig_lightcurve_simulator,\n", + " Emmanoulopoulos_lightcurve_simulator,\n", + " lightcurve_psd_envelope, \n", + " x2_fit, \n", + " pl)" + ] + }, + { + "cell_type": "markdown", + "id": "6ff44b6c-f786-4f7d-bf7c-c27cac5a78dc", + "metadata": {}, + "source": [ + "## Reference Lightcurve ##\n", + "\n", + "As a reference, the notebook uses the H.E.S.S. dataset for the PKS2155 AGN flare of 2006. Data properties such as mean and standard deviation fo the norm, number of points, sampling frequency, are taken from this flare. The synthetic lightcurve will be oversampled by a factor 10." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "330ee851-fcc3-47ad-8b1a-e5bd06d78869", + "metadata": {}, + "outputs": [], + "source": [ + "lc_path = Path(\"$GAMMAPY_DATA/estimators/\")\n", + "lc_filename = \"pks2155_hess_lc/pks2155_hess_lc.fits\"\n", + "\n", + "lc = FluxPoints.read(lc_path/lc_filename, format=\"lightcurve\")\n", + "odata = lc.norm.data.flatten()\n", + "omean = odata.mean()\n", + "ostd = odata.std()\n", + "npoints = len(lc.norm.data)*10\n", + "times = lc.geom.axes[\"time\"].edges\n", + "tref = lc.geom.axes[\"time\"].reference_time\n", + "smax = np.diff(times).max()/10\n", + "lc.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "69638a7d", + "metadata": {}, + "source": [ + "## Simulation ##\n", + "\n", + "\n", + "As a first step, the parameters for the functions used as models in the simulations are setup here:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b70ce94-ba71-43ef-80be-70b15e1a1d6f", + "metadata": {}, + "outputs": [], + "source": [ + "ln_params = {'s': 0.5, 'loc': 1.5, 'scale': 1}\n", + "pl_params = {\"index\": -1.4}" + ] + }, + { + "cell_type": "markdown", + "id": "78dd6fa2-c725-42b8-a854-5eefaaec5be2", + "metadata": {}, + "source": [ + "\n", + "Both the TK and EMM algorithms are called with the same power-law PSD. The EMM algorithm uses a lognormal PDF. The difference between TK and EMM algorithms is shown in the leftmost and rightmost plot, where the gaussian vs lognormal shape is evident. The middle plot shows the perfect compatibility in the periodogram. Seed is fixed for reproducibility. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9fa4aa20-d5e4-4352-8a7c-6348d5c882cc", + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "seed = 532019\n", + "#seed = \"random-seed\"\n", + "lctk2, taxis2 = Emmanoulopoulos_lightcurve_simulator(lognorm.pdf, pl, npoints, smax, pdf_params=ln_params, psd_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", + "lctk, taxis = TimmerKonig_lightcurve_simulator(pl, npoints, smax, power_spectrum_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", + "freqstk, pgramtk = periodogram(lctk, 1/smax.value)\n", + "freqstk2, pgramtk2 = periodogram(lctk2, 1/smax.value)\n", + "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15,3))\n", + "ax1.plot(taxis, lctk)\n", + "ax2.loglog(freqstk[1:], pgramtk[1:])\n", + "ax3.hist(lctk)\n", + "ax1.plot(taxis2, lctk2)\n", + "ax2.loglog(freqstk2[1:], pgramtk2[1:])\n", + "ax3.hist(lctk2)\n", + "coeff = np.polyfit(np.log(freqstk[1:]), np.log(pgramtk[1:]), 1)\n", + "coeff2 = np.polyfit(np.log(freqstk2[1:]), np.log(pgramtk2[1:]), 1)\n", + "\n", + "print(coeff, coeff2)" + ] + }, + { + "cell_type": "markdown", + "id": "592cd9e0-55d1-4bbf-93f4-e873b011d43d", + "metadata": {}, + "source": [ + "## Gammapy setup and simulation ##\n", + "\n", + "Setup of geometry for the Gammapy simulation. Generic setup for pointing, energy binning, and IRFs. For realistic simulations, choose IRFs that are consistent with the instrument and observational conditions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79fc7316-39ef-490d-9cf9-d714afe9249e", + "metadata": {}, + "outputs": [], + "source": [ + "TimeMapAxis.time_format = \"iso\"\n", + "\n", + "path = Path(\"$GAMMAPY_DATA/cta-caldb\")\n", + "irf_filename = \"Prod5-South-20deg-AverageAz-14MSTs37SSTs.180000s-v0.1.fits.gz\"\n", + "\n", + "irfs = load_irf_dict_from_file(path / irf_filename)\n", + "\n", + "energy_axis = MapAxis.from_energy_bounds(\n", + " energy_min=0.1 * u.TeV, energy_max=100 * u.TeV, nbin=1\n", + ")\n", + "\n", + "energy_axis_true = MapAxis.from_edges(\n", + " np.logspace(-1.2, 2.0, 31), unit=\"TeV\", name=\"energy_true\", interp=\"log\"\n", + ")\n", + "\n", + "time_axis = MapAxis.from_nodes(taxis, name=\"time\", interp=\"lin\")\n", + "\n", + "geom = RegionGeom.create(\"galactic;circle(107.65, -40.17, 5)\", axes=[energy_axis])\n", + "\n", + "pointing_position = SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\")\n", + "pointing = FixedPointingInfo(\n", + " fixed_icrs=SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\").icrs,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8d9aec9b-9f38-4f9b-903e-e5189c7edf6c", + "metadata": {}, + "source": [ + "The time series generated via EMM is taken as a LightCurveTemplateTemporalModel" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c900eb8e-87ce-4771-8ccc-db627c7a541f", + "metadata": {}, + "outputs": [], + "source": [ + "gti_t0 = tref\n", + "\n", + "spectral_model = PowerLawSpectralModel(amplitude = 1e-10 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", + "\n", + "m = RegionNDMap.create(\n", + " region=PointSkyRegion(center=pointing_position),\n", + " axes=[time_axis],\n", + " unit=\"cm-2s-1TeV-1\",\n", + ")\n", + "\n", + "m.quantity = lctk2\n", + "\n", + "temporal_model = LightCurveTemplateTemporalModel(m, t_ref=gti_t0)\n", + "\n", + "model_simu = SkyModel(\n", + " spectral_model=spectral_model,\n", + " temporal_model=temporal_model,\n", + " name=\"model-simu\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "7ccc6acb-5054-4879-bba9-ae0bd14e6b02", + "metadata": {}, + "source": [ + "Observation timing setup and simulation fo the datasets. The \"observational\" sampling is taken to be much sparser than the synthetic lightcurve, to avoid aliasing." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bd889da2-54be-461f-b9a4-a34959e994a7", + "metadata": {}, + "outputs": [], + "source": [ + "lvtm = 10 * u.min\n", + "tstart = gti_t0 + np.arange(npoints/10)*lvtm\n", + "altaz = pointing_position.transform_to(AltAz(obstime = tstart, location = observatory_locations[\"cta_south\"]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f142057c-852f-4605-88d3-b27d63417803", + "metadata": {}, + "outputs": [], + "source": [ + "datasets = Datasets()\n", + "\n", + "empty = SpectrumDataset.create(\n", + "geom=geom, energy_axis_true=energy_axis_true, name=\"empty\"\n", + ")\n", + "\n", + "maker = SpectrumDatasetMaker(selection=[\"exposure\", \"background\", \"edisp\"])\n", + "\n", + "for idx in range(len(tstart)):\n", + " obs = Observation.create(\n", + " pointing=pointing,\n", + " livetime=lvtm,\n", + " tstart=tstart[idx],\n", + " irfs=irfs,\n", + " reference_time=gti_t0,\n", + " obs_id=idx,\n", + " location=observatory_locations[\"cta_south\"],\n", + " )\n", + " empty_i = empty.copy(name=f\"dataset-{idx}\")\n", + " dataset = maker.run(empty_i, obs)\n", + " dataset.models = model_simu\n", + " dataset.fake()\n", + " datasets.append(dataset)\n", + "\n", + "\n", + "spectral_model = PowerLawSpectralModel(amplitude = 7e-11 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", + "model_fit = SkyModel(spectral_model=spectral_model, name=\"model-fit\")\n", + "datasets.models = model_fit" + ] + }, + { + "cell_type": "markdown", + "id": "725f0466-21c4-4da2-a5da-21486ef0a43d", + "metadata": {}, + "source": [ + "Lightcurve estimator setup and run." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6150efce-4ced-4237-bf53-12fbd5fe9a30", + "metadata": {}, + "outputs": [], + "source": [ + "lc_maker_1d = LightCurveEstimator(\n", + " energy_edges=[0.1, 100] * u.TeV,\n", + " source=\"model-fit\",\n", + " selection_optional=[\"ul\"],\n", + ")\n", + "\n", + "lc_1d = lc_maker_1d.run(datasets)\n", + "lc_1d.plot();" + ] + }, + { + "cell_type": "markdown", + "id": "b27cd811-a990-48c1-93af-baee1198432c", + "metadata": {}, + "source": [ + "Assessment of the properties of the \"observed\" lightcurve in the time and frequency domain." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2ee2f7b-c8ee-4251-b276-75d4cd247b66", + "metadata": {}, + "outputs": [], + "source": [ + "data = lc_1d.norm.data.flatten()\n", + "dmean = data.mean()\n", + "dstd = data.std()\n", + "dnpoints = len(data)\n", + "dtimes = lc_1d.geom.axes[\"time\"].edges\n", + "dsmax = np.diff(dtimes).max()\n", + "ffreqs, pgram = periodogram(data, 1/dsmax.value)\n", + "coeff = np.polyfit(np.log(ffreqs[1:]), np.log(pgram[1:]), 1)\n", + "print(coeff[0])\n", + "plt.loglog(ffreqs[1:], pgram[1:])" + ] + }, + { + "cell_type": "markdown", + "id": "759e1ddd-98dc-4854-8ba7-c1e58facbb87", + "metadata": {}, + "source": [ + "### Fitting ###\n", + "\n", + "The x2_fit function is used as a cost function with the scipy minimizer, providing a fit of the spectral index for the \"observed\" lightcurve assuming a power-law PSD. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b08789fe-2a0a-4056-8b38-1aaea9946059", + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [], + "source": [ + "%%time\n", + "initial_pars = [-2]\n", + "results = minimize(x2_fit, initial_pars, args=(pgram[1:], dnpoints, dsmax, pl, lognorm.pdf, ln_params, \"EMM\", 10000, dmean, dstd, False), method=\"Powell\", options={\"disp\": True})\n", + "print(results)\n", + "envelopes, freqs = lightcurve_psd_envelope(pl, dnpoints, dsmax, psd_params={\"index\": results.x}, simulator=\"EMM\", pdf = lognorm.pdf, pdf_params = ln_params , nsims=10000, mean=dmean, std=dstd, poisson=False)\n", + "plt.violinplot(envelopes, freqs, widths=np.diff(freqs).min(), showmedians=True);\n", + "plt.plot(freqs, pgram[1:], linewidth=0.7, marker=\"d\")\n", + "plt.yscale(\"log\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "67eae614", + "metadata": {}, + "source": [ + "Recipe by [Claudio Galelli](https://github.com/cgalelli/)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From fb102ad2faf3874db1bfbe29b99f144a5f4fa8ce Mon Sep 17 00:00:00 2001 From: Claudio Galelli Date: Fri, 30 Aug 2024 15:27:43 +0200 Subject: [PATCH 10/13] add gammapy version check --- ... the power spectral density of a lightcurve.ipynb | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/recipes/fit-psd-lightcurve/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb b/recipes/fit-psd-lightcurve/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb index 84fc4e2..da6b6a8 100644 --- a/recipes/fit-psd-lightcurve/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb +++ b/recipes/fit-psd-lightcurve/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb @@ -27,6 +27,18 @@ "The first step is importing some usual packages, needed Astropy utilities, scipy tools for PDFs and minimization, and Gammapy functions and classes for the observational part." ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "b68d2444", + "metadata": {}, + "outputs": [], + "source": [ + "import gammapy\n", + "\n", + "print(f\"Gammapy version : {gammapy.__version__}\")\n", + ] + }, { "cell_type": "code", "execution_count": null, From 44990285ca481f709d3c0bfd628b9e7323530bfa Mon Sep 17 00:00:00 2001 From: Claudio Galelli Date: Fri, 30 Aug 2024 15:36:14 +0200 Subject: [PATCH 11/13] Delete recipes/fit-psd-lightcurve/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb --- ...wer spectral density of a lightcurve.ipynb | 439 ------------------ 1 file changed, 439 deletions(-) delete mode 100644 recipes/fit-psd-lightcurve/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb diff --git a/recipes/fit-psd-lightcurve/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb b/recipes/fit-psd-lightcurve/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb deleted file mode 100644 index da6b6a8..0000000 --- a/recipes/fit-psd-lightcurve/Generating synthetic lightcurves and fitting the power spectral density of a lightcurve.ipynb +++ /dev/null @@ -1,439 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "b4ca33d6-129c-4a59-89d7-f57e39cacfc0", - "metadata": {}, - "source": [ - "# Generating synthetic lightcurves and fitting the power spectral density of a lightcurve #\n", - "\n", - "This notebook presents the advanced Emmanoulopoulos algorithm for the simulation of synthetic lightcurves. The original paper describing the algorithm is linked [here](https://arxiv.org/pdf/1305.0304.pdf). The version implemented here is compatible with the Gammapy implementation of the Timmer-Koenig algorithm.\n", - "The Timmer-Koenig algorithm generates synthetic lightcurve from a chosen power spectral density (PSD) shape. However, it can only generate time series with a gaussian probability density function (PDF). This is adequate for high-statistics astrophysical domains such as the optical or X-rays, but can be in issue when trying to reproduce curves in the gamma-ray domain, where photon counts are lower and statistics are generally Poissonian. The Emmanoulopoulos algorithm tries to solve this issue, combining a requested PSD and PDF in the simulation. It provides accurate synthetic lightcurves in a range of spectral indexes between -1 and -2 for power-law or similar PSDs.\n", - "\n", - "Together with the simulation algorithm the notebook shows a function to compute the PSD envelope for a lightcurve using either the Timmer-Koenig or the Emmanoulopoulos algorithm. This envelope is then used to fit the PSD fot he observed lightcurve, by passing through a tailored chi-squared-like cost function. This complex fitting is necessary to account for the fact that the periodogram of the observed lightcurve is only a possible realization of the PSD model, moreover convoluted with Poissonian noise and instrumental responses. This can lead to biases or deformation due to random fluctuation of the realization if extracted with a simple curve fit of the periodogram.\n", - "\n", - "The results are satisfactory for power-law or broken-power-law PSDs in a physical interval of spectral indexes, between -1 and -2. Using the Emmanoulopoulos algorithm shows consistently better PSD reconstruction over the Timmer-Koenig - this is due to the injected non-gaussian PDF.\n", - "\n", - "The functions for the Timmer-Koenig and Emmanoulopoulos algorithms, the envelope, x2-like cost function for fitting, and some helper analytical functions are implemented in the helper package `gammapy_SyLC`." - ] - }, - { - "cell_type": "markdown", - "id": "b693b292-fa5c-4afa-b013-464389e4092a", - "metadata": {}, - "source": [ - "## Imports ##\n", - "\n", - "The first step is importing some usual packages, needed Astropy utilities, scipy tools for PDFs and minimization, and Gammapy functions and classes for the observational part." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b68d2444", - "metadata": {}, - "outputs": [], - "source": [ - "import gammapy\n", - "\n", - "print(f\"Gammapy version : {gammapy.__version__}\")\n", - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4678c090-734e-430d-a81e-ff77cf5ef8a0", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from pathlib import Path\n", - "import matplotlib.pyplot as plt\n", - "import inspect\n", - "\n", - "import astropy.units as u\n", - "from astropy.coordinates import SkyCoord, AltAz\n", - "\n", - "from regions import PointSkyRegion\n", - "\n", - "from gammapy.estimators import LightCurveEstimator, FluxPoints\n", - "from gammapy.makers import SpectrumDatasetMaker\n", - "from gammapy.data import Observation, observatory_locations, FixedPointingInfo\n", - "from gammapy.datasets import Datasets, SpectrumDataset\n", - "from gammapy.irf import load_irf_dict_from_file\n", - "from gammapy.maps import MapAxis, RegionGeom, TimeMapAxis, RegionNDMap\n", - "from gammapy.modeling.models import SkyModel, PowerLawSpectralModel, LightCurveTemplateTemporalModel\n", - "from gammapy.estimators.utils import compute_lightcurve_fvar\n", - "from gammapy.utils.random import get_random_state\n", - "\n", - "from scipy.optimize import minimize\n", - "from scipy.signal import periodogram\n", - "from scipy.stats import lognorm" - ] - }, - { - "cell_type": "markdown", - "id": "3a7b5a24", - "metadata": {}, - "source": [ - "Additionally, we import the necessary functions for lightcurve simulation and fitting from the helper package [gammapy_SyLC](https://github.com/cgalelli/gammapy_SyLC). The package can be obtained from github and installed by running:\n", - "\n", - "`git clone https://github.com/cgalelli/gammapy_SyLC.git` \n", - "`cd gammapy_SyLC` \n", - "`python -m pip install -e .` " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3d340431", - "metadata": {}, - "outputs": [], - "source": [ - "from gammapy_SyLC import (TimmerKonig_lightcurve_simulator,\n", - " Emmanoulopoulos_lightcurve_simulator,\n", - " lightcurve_psd_envelope, \n", - " x2_fit, \n", - " pl)" - ] - }, - { - "cell_type": "markdown", - "id": "6ff44b6c-f786-4f7d-bf7c-c27cac5a78dc", - "metadata": {}, - "source": [ - "## Reference Lightcurve ##\n", - "\n", - "As a reference, the notebook uses the H.E.S.S. dataset for the PKS2155 AGN flare of 2006. Data properties such as mean and standard deviation fo the norm, number of points, sampling frequency, are taken from this flare. The synthetic lightcurve will be oversampled by a factor 10." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "330ee851-fcc3-47ad-8b1a-e5bd06d78869", - "metadata": {}, - "outputs": [], - "source": [ - "lc_path = Path(\"$GAMMAPY_DATA/estimators/\")\n", - "lc_filename = \"pks2155_hess_lc/pks2155_hess_lc.fits\"\n", - "\n", - "lc = FluxPoints.read(lc_path/lc_filename, format=\"lightcurve\")\n", - "odata = lc.norm.data.flatten()\n", - "omean = odata.mean()\n", - "ostd = odata.std()\n", - "npoints = len(lc.norm.data)*10\n", - "times = lc.geom.axes[\"time\"].edges\n", - "tref = lc.geom.axes[\"time\"].reference_time\n", - "smax = np.diff(times).max()/10\n", - "lc.plot()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "69638a7d", - "metadata": {}, - "source": [ - "## Simulation ##\n", - "\n", - "\n", - "As a first step, the parameters for the functions used as models in the simulations are setup here:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8b70ce94-ba71-43ef-80be-70b15e1a1d6f", - "metadata": {}, - "outputs": [], - "source": [ - "ln_params = {'s': 0.5, 'loc': 1.5, 'scale': 1}\n", - "pl_params = {\"index\": -1.4}" - ] - }, - { - "cell_type": "markdown", - "id": "78dd6fa2-c725-42b8-a854-5eefaaec5be2", - "metadata": {}, - "source": [ - "\n", - "Both the TK and EMM algorithms are called with the same power-law PSD. The EMM algorithm uses a lognormal PDF. The difference between TK and EMM algorithms is shown in the leftmost and rightmost plot, where the gaussian vs lognormal shape is evident. The middle plot shows the perfect compatibility in the periodogram. Seed is fixed for reproducibility. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9fa4aa20-d5e4-4352-8a7c-6348d5c882cc", - "metadata": {}, - "outputs": [], - "source": [ - "%%time\n", - "seed = 532019\n", - "#seed = \"random-seed\"\n", - "lctk2, taxis2 = Emmanoulopoulos_lightcurve_simulator(lognorm.pdf, pl, npoints, smax, pdf_params=ln_params, psd_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", - "lctk, taxis = TimmerKonig_lightcurve_simulator(pl, npoints, smax, power_spectrum_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", - "freqstk, pgramtk = periodogram(lctk, 1/smax.value)\n", - "freqstk2, pgramtk2 = periodogram(lctk2, 1/smax.value)\n", - "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15,3))\n", - "ax1.plot(taxis, lctk)\n", - "ax2.loglog(freqstk[1:], pgramtk[1:])\n", - "ax3.hist(lctk)\n", - "ax1.plot(taxis2, lctk2)\n", - "ax2.loglog(freqstk2[1:], pgramtk2[1:])\n", - "ax3.hist(lctk2)\n", - "coeff = np.polyfit(np.log(freqstk[1:]), np.log(pgramtk[1:]), 1)\n", - "coeff2 = np.polyfit(np.log(freqstk2[1:]), np.log(pgramtk2[1:]), 1)\n", - "\n", - "print(coeff, coeff2)" - ] - }, - { - "cell_type": "markdown", - "id": "592cd9e0-55d1-4bbf-93f4-e873b011d43d", - "metadata": {}, - "source": [ - "## Gammapy setup and simulation ##\n", - "\n", - "Setup of geometry for the Gammapy simulation. Generic setup for pointing, energy binning, and IRFs. For realistic simulations, choose IRFs that are consistent with the instrument and observational conditions." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "79fc7316-39ef-490d-9cf9-d714afe9249e", - "metadata": {}, - "outputs": [], - "source": [ - "TimeMapAxis.time_format = \"iso\"\n", - "\n", - "path = Path(\"$GAMMAPY_DATA/cta-caldb\")\n", - "irf_filename = \"Prod5-South-20deg-AverageAz-14MSTs37SSTs.180000s-v0.1.fits.gz\"\n", - "\n", - "irfs = load_irf_dict_from_file(path / irf_filename)\n", - "\n", - "energy_axis = MapAxis.from_energy_bounds(\n", - " energy_min=0.1 * u.TeV, energy_max=100 * u.TeV, nbin=1\n", - ")\n", - "\n", - "energy_axis_true = MapAxis.from_edges(\n", - " np.logspace(-1.2, 2.0, 31), unit=\"TeV\", name=\"energy_true\", interp=\"log\"\n", - ")\n", - "\n", - "time_axis = MapAxis.from_nodes(taxis, name=\"time\", interp=\"lin\")\n", - "\n", - "geom = RegionGeom.create(\"galactic;circle(107.65, -40.17, 5)\", axes=[energy_axis])\n", - "\n", - "pointing_position = SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\")\n", - "pointing = FixedPointingInfo(\n", - " fixed_icrs=SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\").icrs,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "8d9aec9b-9f38-4f9b-903e-e5189c7edf6c", - "metadata": {}, - "source": [ - "The time series generated via EMM is taken as a LightCurveTemplateTemporalModel" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c900eb8e-87ce-4771-8ccc-db627c7a541f", - "metadata": {}, - "outputs": [], - "source": [ - "gti_t0 = tref\n", - "\n", - "spectral_model = PowerLawSpectralModel(amplitude = 1e-10 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", - "\n", - "m = RegionNDMap.create(\n", - " region=PointSkyRegion(center=pointing_position),\n", - " axes=[time_axis],\n", - " unit=\"cm-2s-1TeV-1\",\n", - ")\n", - "\n", - "m.quantity = lctk2\n", - "\n", - "temporal_model = LightCurveTemplateTemporalModel(m, t_ref=gti_t0)\n", - "\n", - "model_simu = SkyModel(\n", - " spectral_model=spectral_model,\n", - " temporal_model=temporal_model,\n", - " name=\"model-simu\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "7ccc6acb-5054-4879-bba9-ae0bd14e6b02", - "metadata": {}, - "source": [ - "Observation timing setup and simulation fo the datasets. The \"observational\" sampling is taken to be much sparser than the synthetic lightcurve, to avoid aliasing." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bd889da2-54be-461f-b9a4-a34959e994a7", - "metadata": {}, - "outputs": [], - "source": [ - "lvtm = 10 * u.min\n", - "tstart = gti_t0 + np.arange(npoints/10)*lvtm\n", - "altaz = pointing_position.transform_to(AltAz(obstime = tstart, location = observatory_locations[\"cta_south\"]))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f142057c-852f-4605-88d3-b27d63417803", - "metadata": {}, - "outputs": [], - "source": [ - "datasets = Datasets()\n", - "\n", - "empty = SpectrumDataset.create(\n", - "geom=geom, energy_axis_true=energy_axis_true, name=\"empty\"\n", - ")\n", - "\n", - "maker = SpectrumDatasetMaker(selection=[\"exposure\", \"background\", \"edisp\"])\n", - "\n", - "for idx in range(len(tstart)):\n", - " obs = Observation.create(\n", - " pointing=pointing,\n", - " livetime=lvtm,\n", - " tstart=tstart[idx],\n", - " irfs=irfs,\n", - " reference_time=gti_t0,\n", - " obs_id=idx,\n", - " location=observatory_locations[\"cta_south\"],\n", - " )\n", - " empty_i = empty.copy(name=f\"dataset-{idx}\")\n", - " dataset = maker.run(empty_i, obs)\n", - " dataset.models = model_simu\n", - " dataset.fake()\n", - " datasets.append(dataset)\n", - "\n", - "\n", - "spectral_model = PowerLawSpectralModel(amplitude = 7e-11 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", - "model_fit = SkyModel(spectral_model=spectral_model, name=\"model-fit\")\n", - "datasets.models = model_fit" - ] - }, - { - "cell_type": "markdown", - "id": "725f0466-21c4-4da2-a5da-21486ef0a43d", - "metadata": {}, - "source": [ - "Lightcurve estimator setup and run." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6150efce-4ced-4237-bf53-12fbd5fe9a30", - "metadata": {}, - "outputs": [], - "source": [ - "lc_maker_1d = LightCurveEstimator(\n", - " energy_edges=[0.1, 100] * u.TeV,\n", - " source=\"model-fit\",\n", - " selection_optional=[\"ul\"],\n", - ")\n", - "\n", - "lc_1d = lc_maker_1d.run(datasets)\n", - "lc_1d.plot();" - ] - }, - { - "cell_type": "markdown", - "id": "b27cd811-a990-48c1-93af-baee1198432c", - "metadata": {}, - "source": [ - "Assessment of the properties of the \"observed\" lightcurve in the time and frequency domain." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e2ee2f7b-c8ee-4251-b276-75d4cd247b66", - "metadata": {}, - "outputs": [], - "source": [ - "data = lc_1d.norm.data.flatten()\n", - "dmean = data.mean()\n", - "dstd = data.std()\n", - "dnpoints = len(data)\n", - "dtimes = lc_1d.geom.axes[\"time\"].edges\n", - "dsmax = np.diff(dtimes).max()\n", - "ffreqs, pgram = periodogram(data, 1/dsmax.value)\n", - "coeff = np.polyfit(np.log(ffreqs[1:]), np.log(pgram[1:]), 1)\n", - "print(coeff[0])\n", - "plt.loglog(ffreqs[1:], pgram[1:])" - ] - }, - { - "cell_type": "markdown", - "id": "759e1ddd-98dc-4854-8ba7-c1e58facbb87", - "metadata": {}, - "source": [ - "### Fitting ###\n", - "\n", - "The x2_fit function is used as a cost function with the scipy minimizer, providing a fit of the spectral index for the \"observed\" lightcurve assuming a power-law PSD. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b08789fe-2a0a-4056-8b38-1aaea9946059", - "metadata": { - "tags": [ - "nbsphinx-thumbnail" - ] - }, - "outputs": [], - "source": [ - "%%time\n", - "initial_pars = [-2]\n", - "results = minimize(x2_fit, initial_pars, args=(pgram[1:], dnpoints, dsmax, pl, lognorm.pdf, ln_params, \"EMM\", 10000, dmean, dstd, False), method=\"Powell\", options={\"disp\": True})\n", - "print(results)\n", - "envelopes, freqs = lightcurve_psd_envelope(pl, dnpoints, dsmax, psd_params={\"index\": results.x}, simulator=\"EMM\", pdf = lognorm.pdf, pdf_params = ln_params , nsims=10000, mean=dmean, std=dstd, poisson=False)\n", - "plt.violinplot(envelopes, freqs, widths=np.diff(freqs).min(), showmedians=True);\n", - "plt.plot(freqs, pgram[1:], linewidth=0.7, marker=\"d\")\n", - "plt.yscale(\"log\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "67eae614", - "metadata": {}, - "source": [ - "Recipe by [Claudio Galelli](https://github.com/cgalelli/)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 0248f1cf76276955ff87a9a391e35c3116b98254 Mon Sep 17 00:00:00 2001 From: Claudio Galelli Date: Fri, 30 Aug 2024 15:36:30 +0200 Subject: [PATCH 12/13] Add files via upload --- .../fit-psd-lightcurve.ipynb | 439 ++++++++++++++++++ 1 file changed, 439 insertions(+) create mode 100644 recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb diff --git a/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb b/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb new file mode 100644 index 0000000..c5fe9d5 --- /dev/null +++ b/recipes/fit-psd-lightcurve/fit-psd-lightcurve.ipynb @@ -0,0 +1,439 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b4ca33d6-129c-4a59-89d7-f57e39cacfc0", + "metadata": {}, + "source": [ + "# Generating synthetic lightcurves and fitting the power spectral density of a lightcurve #\n", + "\n", + "This notebook presents the advanced Emmanoulopoulos algorithm for the simulation of synthetic lightcurves. The original paper describing the algorithm is linked [here](https://arxiv.org/pdf/1305.0304.pdf). The version implemented here is compatible with the Gammapy implementation of the Timmer-Koenig algorithm.\n", + "The Timmer-Koenig algorithm generates synthetic lightcurve from a chosen power spectral density (PSD) shape. However, it can only generate time series with a gaussian probability density function (PDF). This is adequate for high-statistics astrophysical domains such as the optical or X-rays, but can be in issue when trying to reproduce curves in the gamma-ray domain, where photon counts are lower and statistics are generally Poissonian. The Emmanoulopoulos algorithm tries to solve this issue, combining a requested PSD and PDF in the simulation. It provides accurate synthetic lightcurves in a range of spectral indexes between -1 and -2 for power-law or similar PSDs.\n", + "\n", + "Together with the simulation algorithm the notebook shows a function to compute the PSD envelope for a lightcurve using either the Timmer-Koenig or the Emmanoulopoulos algorithm. This envelope is then used to fit the PSD fot he observed lightcurve, by passing through a tailored chi-squared-like cost function. This complex fitting is necessary to account for the fact that the periodogram of the observed lightcurve is only a possible realization of the PSD model, moreover convoluted with Poissonian noise and instrumental responses. This can lead to biases or deformation due to random fluctuation of the realization if extracted with a simple curve fit of the periodogram.\n", + "\n", + "The results are satisfactory for power-law or broken-power-law PSDs in a physical interval of spectral indexes, between -1 and -2. Using the Emmanoulopoulos algorithm shows consistently better PSD reconstruction over the Timmer-Koenig - this is due to the injected non-gaussian PDF.\n", + "\n", + "The functions for the Timmer-Koenig and Emmanoulopoulos algorithms, the envelope, x2-like cost function for fitting, and some helper analytical functions are implemented in the helper package `gammapy_SyLC`." + ] + }, + { + "cell_type": "markdown", + "id": "b693b292-fa5c-4afa-b013-464389e4092a", + "metadata": {}, + "source": [ + "## Imports ##\n", + "\n", + "The first step is importing some usual packages, needed Astropy utilities, scipy tools for PDFs and minimization, and Gammapy functions and classes for the observational part." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a0819ee7", + "metadata": {}, + "outputs": [], + "source": [ + "import gammapy\n", + "\n", + "print(f\"Gammapy version : {gammapy.__version__}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4678c090-734e-430d-a81e-ff77cf5ef8a0", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "import inspect\n", + "\n", + "import astropy.units as u\n", + "from astropy.coordinates import SkyCoord, AltAz\n", + "\n", + "from regions import PointSkyRegion\n", + "\n", + "from gammapy.estimators import LightCurveEstimator, FluxPoints\n", + "from gammapy.makers import SpectrumDatasetMaker\n", + "from gammapy.data import Observation, observatory_locations, FixedPointingInfo\n", + "from gammapy.datasets import Datasets, SpectrumDataset\n", + "from gammapy.irf import load_irf_dict_from_file\n", + "from gammapy.maps import MapAxis, RegionGeom, TimeMapAxis, RegionNDMap\n", + "from gammapy.modeling.models import SkyModel, PowerLawSpectralModel, LightCurveTemplateTemporalModel\n", + "from gammapy.estimators.utils import compute_lightcurve_fvar\n", + "from gammapy.utils.random import get_random_state\n", + "\n", + "from scipy.optimize import minimize\n", + "from scipy.signal import periodogram\n", + "from scipy.stats import lognorm" + ] + }, + { + "cell_type": "markdown", + "id": "3a7b5a24", + "metadata": {}, + "source": [ + "Additionally, we import the necessary functions for lightcurve simulation and fitting from the helper package [gammapy_SyLC](https://github.com/cgalelli/gammapy_SyLC). The package can be obtained from github and installed by running:\n", + "\n", + "`git clone https://github.com/cgalelli/gammapy_SyLC.git` \n", + "`cd gammapy_SyLC` \n", + "`python -m pip install -e .` " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3d340431", + "metadata": {}, + "outputs": [], + "source": [ + "from gammapy_SyLC import (TimmerKonig_lightcurve_simulator,\n", + " Emmanoulopoulos_lightcurve_simulator,\n", + " lightcurve_psd_envelope, \n", + " x2_fit, \n", + " pl)" + ] + }, + { + "cell_type": "markdown", + "id": "6ff44b6c-f786-4f7d-bf7c-c27cac5a78dc", + "metadata": {}, + "source": [ + "## Reference Lightcurve ##\n", + "\n", + "As a reference, the notebook uses the H.E.S.S. dataset for the PKS2155 AGN flare of 2006. Data properties such as mean and standard deviation fo the norm, number of points, sampling frequency, are taken from this flare. The synthetic lightcurve will be oversampled by a factor 10." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "330ee851-fcc3-47ad-8b1a-e5bd06d78869", + "metadata": {}, + "outputs": [], + "source": [ + "lc_path = Path(\"$GAMMAPY_DATA/estimators/\")\n", + "lc_filename = \"pks2155_hess_lc/pks2155_hess_lc.fits\"\n", + "\n", + "lc = FluxPoints.read(lc_path/lc_filename, format=\"lightcurve\")\n", + "odata = lc.norm.data.flatten()\n", + "omean = odata.mean()\n", + "ostd = odata.std()\n", + "npoints = len(lc.norm.data)*10\n", + "times = lc.geom.axes[\"time\"].edges\n", + "tref = lc.geom.axes[\"time\"].reference_time\n", + "smax = np.diff(times).max()/10\n", + "lc.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "69638a7d", + "metadata": {}, + "source": [ + "## Simulation ##\n", + "\n", + "\n", + "As a first step, the parameters for the functions used as models in the simulations are setup here:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b70ce94-ba71-43ef-80be-70b15e1a1d6f", + "metadata": {}, + "outputs": [], + "source": [ + "ln_params = {'s': 0.5, 'loc': 1.5, 'scale': 1}\n", + "pl_params = {\"index\": -1.4}" + ] + }, + { + "cell_type": "markdown", + "id": "78dd6fa2-c725-42b8-a854-5eefaaec5be2", + "metadata": {}, + "source": [ + "\n", + "Both the TK and EMM algorithms are called with the same power-law PSD. The EMM algorithm uses a lognormal PDF. The difference between TK and EMM algorithms is shown in the leftmost and rightmost plot, where the gaussian vs lognormal shape is evident. The middle plot shows the perfect compatibility in the periodogram. Seed is fixed for reproducibility. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9fa4aa20-d5e4-4352-8a7c-6348d5c882cc", + "metadata": {}, + "outputs": [], + "source": [ + "%%time\n", + "seed = 532019\n", + "#seed = \"random-seed\"\n", + "lctk2, taxis2 = Emmanoulopoulos_lightcurve_simulator(lognorm.pdf, pl, npoints, smax, pdf_params=ln_params, psd_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", + "lctk, taxis = TimmerKonig_lightcurve_simulator(pl, npoints, smax, power_spectrum_params=pl_params,mean =omean, std=ostd,random_state=seed)\n", + "freqstk, pgramtk = periodogram(lctk, 1/smax.value)\n", + "freqstk2, pgramtk2 = periodogram(lctk2, 1/smax.value)\n", + "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15,3))\n", + "ax1.plot(taxis, lctk)\n", + "ax2.loglog(freqstk[1:], pgramtk[1:])\n", + "ax3.hist(lctk)\n", + "ax1.plot(taxis2, lctk2)\n", + "ax2.loglog(freqstk2[1:], pgramtk2[1:])\n", + "ax3.hist(lctk2)\n", + "coeff = np.polyfit(np.log(freqstk[1:]), np.log(pgramtk[1:]), 1)\n", + "coeff2 = np.polyfit(np.log(freqstk2[1:]), np.log(pgramtk2[1:]), 1)\n", + "\n", + "print(coeff, coeff2)" + ] + }, + { + "cell_type": "markdown", + "id": "592cd9e0-55d1-4bbf-93f4-e873b011d43d", + "metadata": {}, + "source": [ + "## Gammapy setup and simulation ##\n", + "\n", + "Setup of geometry for the Gammapy simulation. Generic setup for pointing, energy binning, and IRFs. For realistic simulations, choose IRFs that are consistent with the instrument and observational conditions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79fc7316-39ef-490d-9cf9-d714afe9249e", + "metadata": {}, + "outputs": [], + "source": [ + "TimeMapAxis.time_format = \"iso\"\n", + "\n", + "path = Path(\"$GAMMAPY_DATA/cta-caldb\")\n", + "irf_filename = \"Prod5-South-20deg-AverageAz-14MSTs37SSTs.180000s-v0.1.fits.gz\"\n", + "\n", + "irfs = load_irf_dict_from_file(path / irf_filename)\n", + "\n", + "energy_axis = MapAxis.from_energy_bounds(\n", + " energy_min=0.1 * u.TeV, energy_max=100 * u.TeV, nbin=1\n", + ")\n", + "\n", + "energy_axis_true = MapAxis.from_edges(\n", + " np.logspace(-1.2, 2.0, 31), unit=\"TeV\", name=\"energy_true\", interp=\"log\"\n", + ")\n", + "\n", + "time_axis = MapAxis.from_nodes(taxis, name=\"time\", interp=\"lin\")\n", + "\n", + "geom = RegionGeom.create(\"galactic;circle(107.65, -40.17, 5)\", axes=[energy_axis])\n", + "\n", + "pointing_position = SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\")\n", + "pointing = FixedPointingInfo(\n", + " fixed_icrs=SkyCoord(107.65, -40.17, unit=\"deg\", frame=\"galactic\").icrs,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8d9aec9b-9f38-4f9b-903e-e5189c7edf6c", + "metadata": {}, + "source": [ + "The time series generated via EMM is taken as a LightCurveTemplateTemporalModel" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c900eb8e-87ce-4771-8ccc-db627c7a541f", + "metadata": {}, + "outputs": [], + "source": [ + "gti_t0 = tref\n", + "\n", + "spectral_model = PowerLawSpectralModel(amplitude = 1e-10 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", + "\n", + "m = RegionNDMap.create(\n", + " region=PointSkyRegion(center=pointing_position),\n", + " axes=[time_axis],\n", + " unit=\"cm-2s-1TeV-1\",\n", + ")\n", + "\n", + "m.quantity = lctk2\n", + "\n", + "temporal_model = LightCurveTemplateTemporalModel(m, t_ref=gti_t0)\n", + "\n", + "model_simu = SkyModel(\n", + " spectral_model=spectral_model,\n", + " temporal_model=temporal_model,\n", + " name=\"model-simu\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "7ccc6acb-5054-4879-bba9-ae0bd14e6b02", + "metadata": {}, + "source": [ + "Observation timing setup and simulation fo the datasets. The \"observational\" sampling is taken to be much sparser than the synthetic lightcurve, to avoid aliasing." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bd889da2-54be-461f-b9a4-a34959e994a7", + "metadata": {}, + "outputs": [], + "source": [ + "lvtm = 10 * u.min\n", + "tstart = gti_t0 + np.arange(npoints/10)*lvtm\n", + "altaz = pointing_position.transform_to(AltAz(obstime = tstart, location = observatory_locations[\"cta_south\"]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f142057c-852f-4605-88d3-b27d63417803", + "metadata": {}, + "outputs": [], + "source": [ + "datasets = Datasets()\n", + "\n", + "empty = SpectrumDataset.create(\n", + "geom=geom, energy_axis_true=energy_axis_true, name=\"empty\"\n", + ")\n", + "\n", + "maker = SpectrumDatasetMaker(selection=[\"exposure\", \"background\", \"edisp\"])\n", + "\n", + "for idx in range(len(tstart)):\n", + " obs = Observation.create(\n", + " pointing=pointing,\n", + " livetime=lvtm,\n", + " tstart=tstart[idx],\n", + " irfs=irfs,\n", + " reference_time=gti_t0,\n", + " obs_id=idx,\n", + " location=observatory_locations[\"cta_south\"],\n", + " )\n", + " empty_i = empty.copy(name=f\"dataset-{idx}\")\n", + " dataset = maker.run(empty_i, obs)\n", + " dataset.models = model_simu\n", + " dataset.fake()\n", + " datasets.append(dataset)\n", + "\n", + "\n", + "spectral_model = PowerLawSpectralModel(amplitude = 7e-11 * u.TeV**-1 * u.cm**-2 * u.s**-1)\n", + "model_fit = SkyModel(spectral_model=spectral_model, name=\"model-fit\")\n", + "datasets.models = model_fit" + ] + }, + { + "cell_type": "markdown", + "id": "725f0466-21c4-4da2-a5da-21486ef0a43d", + "metadata": {}, + "source": [ + "Lightcurve estimator setup and run." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6150efce-4ced-4237-bf53-12fbd5fe9a30", + "metadata": {}, + "outputs": [], + "source": [ + "lc_maker_1d = LightCurveEstimator(\n", + " energy_edges=[0.1, 100] * u.TeV,\n", + " source=\"model-fit\",\n", + " selection_optional=[\"ul\"],\n", + ")\n", + "\n", + "lc_1d = lc_maker_1d.run(datasets)\n", + "lc_1d.plot();" + ] + }, + { + "cell_type": "markdown", + "id": "b27cd811-a990-48c1-93af-baee1198432c", + "metadata": {}, + "source": [ + "Assessment of the properties of the \"observed\" lightcurve in the time and frequency domain." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2ee2f7b-c8ee-4251-b276-75d4cd247b66", + "metadata": {}, + "outputs": [], + "source": [ + "data = lc_1d.norm.data.flatten()\n", + "dmean = data.mean()\n", + "dstd = data.std()\n", + "dnpoints = len(data)\n", + "dtimes = lc_1d.geom.axes[\"time\"].edges\n", + "dsmax = np.diff(dtimes).max()\n", + "ffreqs, pgram = periodogram(data, 1/dsmax.value)\n", + "coeff = np.polyfit(np.log(ffreqs[1:]), np.log(pgram[1:]), 1)\n", + "print(coeff[0])\n", + "plt.loglog(ffreqs[1:], pgram[1:])" + ] + }, + { + "cell_type": "markdown", + "id": "759e1ddd-98dc-4854-8ba7-c1e58facbb87", + "metadata": {}, + "source": [ + "### Fitting ###\n", + "\n", + "The x2_fit function is used as a cost function with the scipy minimizer, providing a fit of the spectral index for the \"observed\" lightcurve assuming a power-law PSD. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b08789fe-2a0a-4056-8b38-1aaea9946059", + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [], + "source": [ + "%%time\n", + "initial_pars = [-2]\n", + "results = minimize(x2_fit, initial_pars, args=(pgram[1:], dnpoints, dsmax, pl, lognorm.pdf, ln_params, \"EMM\", 10000, dmean, dstd, False), method=\"Powell\", options={\"disp\": True})\n", + "print(results)\n", + "envelopes, freqs = lightcurve_psd_envelope(pl, dnpoints, dsmax, psd_params={\"index\": results.x}, simulator=\"EMM\", pdf = lognorm.pdf, pdf_params = ln_params , nsims=10000, mean=dmean, std=dstd, poisson=False)\n", + "plt.violinplot(envelopes, freqs, widths=np.diff(freqs).min(), showmedians=True);\n", + "plt.plot(freqs, pgram[1:], linewidth=0.7, marker=\"d\")\n", + "plt.yscale(\"log\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "67eae614", + "metadata": {}, + "source": [ + "Recipe by [Claudio Galelli](https://github.com/cgalelli/)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 30dc581c952c281a079c4a39fb8f510082a47341 Mon Sep 17 00:00:00 2001 From: Claudio Galelli Date: Fri, 30 Aug 2024 15:49:58 +0200 Subject: [PATCH 13/13] Update recipes/fit-psd-lightcurve/env.yml MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Régis Terrier --- recipes/fit-psd-lightcurve/env.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/recipes/fit-psd-lightcurve/env.yml b/recipes/fit-psd-lightcurve/env.yml index dc7d48b..c993ba7 100644 --- a/recipes/fit-psd-lightcurve/env.yml +++ b/recipes/fit-psd-lightcurve/env.yml @@ -11,3 +11,5 @@ dependencies: - scipy - jupyter - matplotlib + - pip: + - git+https://github.com/cgalelli/gammapy_SyLC.git