diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 0660e8055..726252669 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,11 +1,12 @@ repos: - repo: https://github.com/pre-commit/pre-commit-hooks - rev: v2.3.0 + rev: v3.2.0 hooks: - id: check-yaml - id: check-merge-conflict - id: check-symlinks - repo: https://github.com/psf/black - rev: 19.3b0 + rev: 19.10b0 hooks: - id: black + language_version: python3 diff --git a/CHANGELOG.md b/CHANGELOG.md index c222feaa0..e9712f303 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project, at least loosely, adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## Unreleased +### Added +- Now contains an implementation of FFTFIT in `pint.profile` (PR #777) + ## [0.8.1] - 2021-01-07 ## Fixed - Right click to delete TOAs in pintk now works diff --git a/docs/examples/Example of parameter usage.md b/docs/examples/Example of parameter usage.md new file mode 100644 index 000000000..8e76f9521 --- /dev/null +++ b/docs/examples/Example of parameter usage.md @@ -0,0 +1,344 @@ +--- +jupyter: + jupytext: + formats: ipynb,md + text_representation: + extension: .md + format_name: markdown + format_version: '1.2' + jupytext_version: 1.5.2 + kernelspec: + display_name: Python 3 + language: python + name: python3 +--- + +# Example of parameter usage + +```python jupyter={"outputs_hidden": false} +import pint.models.model_builder as mb +import pint.models.parameter as pp +import astropy.units as u +from astropy.coordinates.angles import Angle +import pytest +``` + +```python jupyter={"outputs_hidden": false} +model = mb.get_model("B1855+09_NANOGrav_dfg+12_TAI.par") +``` + +```python jupyter={"outputs_hidden": false} +print(model.params) +``` + +## Attributions in Parameters + +```python jupyter={"outputs_hidden": false} +printed = [] +for p in model.params: + par = getattr(model, p) + if type(par) in printed: + continue + print("Name ", par.name) + print("Type ", type(par)) + print("Quantity ", par.quantity, type(par.quantity)) + print("Value ", par.value) + print("units ", par.units) + print("Uncertainty ", par.uncertainty) + print("Uncertainty_value", par.uncertainty_value) + print("Summary ", par) + print("Parfile Style ", par.as_parfile_line()) + print() + printed.append(type(par)) +# Note JUMP and DMX is different. +``` + +## Making a parameter + +```python jupyter={"outputs_hidden": false} +t = pp.floatParameter(name="TEST", value=100, units="Hz", uncertainty=0.03) +print(t) +``` + +```python jupyter={"outputs_hidden": false} +t2 = pp.floatParameter(name="TEST", value="200", units="Hz", uncertainty=".04") +print(t2) +``` + +```python jupyter={"outputs_hidden": false} +t3 = pp.floatParameter( + name="TEST", value=0.3 * u.kHz, units="Hz", uncertainty=4e-5 * u.kHz +) +print(t3) +print(t3.quantity) +print(t3.value) +print(t3.uncertainty) +print(t3.uncertainty_value) +``` + +## Change Parameter quantity of value + +```python jupyter={"outputs_hidden": false} +par = model.F0 +print(par) +par.quantity = 200 +print("Quantity ", par.quantity, type(par.quantity)) +print("Value ", par.value) +print(par) +``` + +```python jupyter={"outputs_hidden": false} +# Test F0 +print(par) +par.value = 150 +print("Quantity ", par.quantity, type(par.quantity)) +print("Value ", par.value) +print(par) +``` + +```python jupyter={"outputs_hidden": false} +# Example for F0 +print(par) +par.value = "100" +print("Quantity ", par.quantity, type(par.quantity)) +print("Value ", par.value) +print(par) +``` + +```python jupyter={"outputs_hidden": false} +# Example for F0 +print(par) +par.quantity = "300" +print("Quantity ", par.quantity, type(par.quantity)) +print("Value ", par.value) +print(par) +``` + +```python jupyter={"outputs_hidden": false} +# Examle F0 +par.quantity = 0.3 * u.kHz +print("Quantity ", par.quantity, type(par.quantity)) +print("Value ", par.value) +print(par) +``` + +```python jupyter={"outputs_hidden": false} +try: + # Examle F0 + print(par) + par.value = 100 * u.second # SET F0 to seconds as time. + print("Quantity ", par.quantity, type(par.quantity)) + print("Value ", par.value) + print(par) +except u.UnitConversionError as e: + print("Exception raised:", e) +else: + raise ValueError("That was supposed to raise an exception!") +``` + +### For MJD parameters + +```python jupyter={"outputs_hidden": false} +par = model.TZRMJD +print(par) +par.quantity = 54000 +print("Quantity ", par.quantity, type(par.quantity)) +print("Value ", par.value) +print(par) +par.quantity +``` + +```python jupyter={"outputs_hidden": false} +# Example for TZRMJD +par.quantity = "54001" +print("Quantity ", par.quantity, type(par.quantity)) +print("Value ", par.value) +print(par) +par.quantity +``` + +```python jupyter={"outputs_hidden": false} +# Example for TZRMJD +par.value = 54002 +print("Quantity ", par.quantity, type(par.quantity)) +print("Value ", par.value) +print(par) +par.quantity +``` + +```python jupyter={"outputs_hidden": false} +# Example for TZRMJD +par.value = "54003" +print("Quantity ", par.quantity, type(par.quantity)) +print("Value ", par.value) +print(par) +par.quantity +``` + +### For AngleParameters + +```python jupyter={"outputs_hidden": false} +# Example for RAJ +par = model.RAJ +print(par) +par.quantity = 50 +print("Quantity ", par.quantity, type(par.quantity)) +print("Value ", par.value) +print(par) +par.quantity +``` + +```python jupyter={"outputs_hidden": false} +import astropy +``` + +```python jupyter={"outputs_hidden": false} +astropy.__version__ +``` + +```python jupyter={"outputs_hidden": false} +Angle(50.0 * u.hourangle) +``` + +```python jupyter={"outputs_hidden": false} +# Example for RAJ +print(par) +par.quantity = 30.5 +print("Quantity ", par.quantity, type(par.quantity)) +print("Value ", par.value) +print(par) +par.quantity +``` + +```python jupyter={"outputs_hidden": false} +# Example for RAJ +print(par) +par.quantity = "20:30:00" +print("Quantity ", par.quantity, type(par.quantity)) +print("Value ", par.value) +print(par) +par.quantity +``` + +```python jupyter={"outputs_hidden": false} +# Example for RAJ +print(par) +par.value = "20:05:0" +print("Quantity ", par.quantity, type(par.quantity)) +print("Value ", par.value) +print(par) +par.quantity +``` + +```python jupyter={"outputs_hidden": false} +# Example for RAJ +print(par) +par.quantity = 30 * u.deg +print("Quantity ", par.quantity, type(par.quantity)) +print("Quantity in deg", par.quantity.to(u.deg)) +print("Value ", par.value) +print(par) +par.quantity +``` + +```python jupyter={"outputs_hidden": false} +# Example for RAJ +print(par) +par.value = 40 * u.rad +print("Quantity ", par.quantity, type(par.quantity)) +print("Quantity in rad", par.quantity.to(u.rad)) +print("Value ", par.value) +print(par) +par.quantity +``` + +Test for wrong unit + +```python jupyter={"outputs_hidden": false} +# Example for RAJ +try: + print(par) + par.value = 40 * u.second # Here second is in the unit of time, not hourangle + print("Quantity ", par.quantity, type(par.quantity)) + print("Quantity in rad", par.quantity.to(u.rad)) + print("Value ", par.value) + print(par) + par.quantity +except u.UnitConversionError as e: + print("Exception raised:", e) +else: + raise ValueError("That was supposed to raise an exception!") +``` + +```python jupyter={"outputs_hidden": false} +try: + # Example for RAJ + print(par) + par.quantity = 30 * u.hour # Here hour is in the unit of time, not hourangle + print("Quantity ", par.quantity, type(par.quantity)) + print("Quantity in deg", par.quantity.to(u.deg)) + print("Value ", par.value) + print(par) + par.quantity +except u.UnitConversionError as e: + print("Exception raised:", e) +else: + raise ValueError("That was supposed to raise an exception!") +``` + +## Example for uncertainty + +```python jupyter={"outputs_hidden": false} +par = model.F0 +``` + + +```python jupyter={"outputs_hidden": false} +# Example for F0 +print(par.uncertainty) +print(par.uncertainty_value) +par.uncertainty = par.uncertainty_value / 1000.0 * u.kHz +print(par) +print(par.uncertainty) +``` + + +```python jupyter={"outputs_hidden": false} +# Example for F0 +par.uncertainty_value = 6e-13 +print(par) +print(par.uncertainty) +``` + +```python jupyter={"outputs_hidden": false} +# Example for F0 +par.uncertainty_value = 7e-16 * u.kHz +print(par) +print(par.uncertainty) +``` + + +## How do "prefix parameters" and "mask parameters" work? + + +```python +cat = pp.prefixParameter( + parameter_type="float", name="CAT0", units=u.ml, long_double=True +) +``` + +```python +dir(cat) +``` + +```python +cat.is_prefix +``` + +```python +cat.index +``` + +```python + +``` diff --git a/docs/examples/MCMC_walkthrough.ipynb.broken b/docs/examples/MCMC_walkthrough.ipynb.broken new file mode 100644 index 000000000..31392ca1f --- /dev/null +++ b/docs/examples/MCMC_walkthrough.ipynb.broken @@ -0,0 +1,472 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MCMC Walkthrough" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook contains examples of how to use the MCMC Fitter class and how to modify it for more specific uses.\n", + "\n", + "All of these examples will use the EmceeSampler class, which is currently the only Sampler implementation supported by PINT. Future work may include implementations of other sampling methods." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "import numpy as np\n", + "import pint.models\n", + "import pint.toa as toa\n", + "import pint.fermi_toas as fermi\n", + "from pint.residuals import Residuals\n", + "from pint.sampler import EmceeSampler\n", + "from pint.mcmc_fitter import MCMCFitter, MCMCFitterBinnedTemplate\n", + "from pint.scripts.event_optimize import read_gaussfitfile, marginalize_over_phase\n", + "from astropy import log\n", + "import matplotlib.pyplot as plt\n", + "import pickle" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "log.setLevel(\"WARNING\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(0)\n", + "state = np.random.mtrand.RandomState()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic Example\n", + "\n", + "This example will show a vanilla, unmodified MCMCFitter operating with a simple template and on a small dataset. The sampler is a wrapper around the *emcee* package, so it requires a number of walkers for the ensemble sampler. This number of walkers must be specified by the user.\n", + "\n", + "The first few lines are the basic methods used to load in models, TOAs, and templates. More detailed information on this can be found in *pint.scripts.event_optimize.py*." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "parfile = \"PSRJ0030+0451_psrcat.par\"\n", + "eventfile = \"J0030+0451_P8_15.0deg_239557517_458611204_ft1weights_GEO_wt.gt.0.4.fits\"\n", + "gaussianfile = \"templateJ0030.3gauss\"\n", + "weightcol = \"PSRJ0030+0451\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "minWeight = 0.9\n", + "nwalkers = 10\n", + "nsteps = 50\n", + "nbins = 256\n", + "phs = 0.0" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: EPHVER 2 does nothing in PINT [pint.models.timing_model]\n", + "WARNING: No ephemeris provided to TOAs object or compute_TDBs. Using DE421 [pint.toa]\n" + ] + } + ], + "source": [ + "model = pint.models.get_model(parfile)\n", + "tl = fermi.load_Fermi_TOAs(eventfile, weightcolumn=weightcol, minweight=minWeight)\n", + "ts = toa.TOAs(toalist=tl)\n", + "# Introduce a small error so that residuals can be calculated\n", + "ts.table[\"error\"] = 1.0\n", + "ts.filename = eventfile\n", + "ts.compute_TDBs()\n", + "ts.compute_posvels(ephem=\"DE421\", planets=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "weights = np.asarray([x[\"weight\"] for x in ts.table[\"flags\"]])\n", + "template = read_gaussfitfile(gaussianfile, nbins)\n", + "template /= template.mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sampler and Fitter creation\n", + "\n", + "The sampler must be initialized first, and then passed as an argument into the *MCMCFitter* constructor. The fitter will send its log-posterior probabilility function to the sampler for the MCMC run. The log-prior and log-likelihood functions of the *MCMCFitter* can be written by the user. The default behavior is to use the functions implemented in the *pint.mcmc_fitter* module.\n", + "\n", + "The *EmceeSampler* requires only an argument for the number of walkers in the ensemble.\n", + "\n", + "Here, we use *MCMCFitterBinnedTemplate* because the Gaussian template not a callable function. If the template is analytic and callable, then *MCMCFitterAnalyticTemplate* should be used, and template parameters can be used in the optimization." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "sampler = EmceeSampler(nwalkers)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "fitter = MCMCFitterBinnedTemplate(\n", + " ts, model, sampler, template=template, weights=weights, phs=phs\n", + ")\n", + "fitter.sampler.random_state = state" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next step determines the predicted starting phase of the pulse, which is used to set an accurate initial phase in the model. This will result in a more accurate fit. This step uses the *marginalize over phase* method implemented in *pint.scripts.event_optimize.py*." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting pulse likelihood: 539.546581\n", + "Starting pulse phase: 0.589355\n", + "Pre-MCMC Values:\n", + " F0:\t 205.53\n", + " F1:\t 0.58936\n" + ] + } + ], + "source": [ + "phases = fitter.get_event_phases()\n", + "maxbin, like_start = marginalize_over_phase(\n", + " phases, template, weights=fitter.weights, minimize=True, showplot=True\n", + ")\n", + "fitter.fitvals[-1] = 1.0 - maxbin[0] / float(len(template))\n", + "print(\"Starting pulse likelihood: %f\" % like_start)\n", + "print(\"Starting pulse phase: %f\" % fitter.fitvals[-1])\n", + "print(\"Pre-MCMC Values:\")\n", + "for name, val in zip(fitter.fitkeys, fitter.fitvals):\n", + " print(\"%8s:\\t%12.5g\" % (name, val))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The MCMCFitter class is a subclass of *pint.fitter.Fitter*. It is run in exactly the same way - with the *fit_toas()* method." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50/50 [01:10<00:00, 1.42s/it]\n" + ] + } + ], + "source": [ + "fitter.fit_toas(maxiter=nsteps, pos=None)\n", + "fitter.set_parameters(fitter.maxpost_fitvals)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To make this run relatively fast for demonstration purposes, nsteps was purposefully kept very small. However, this means that the results of this fit will not be very good. For an example of MCMC fitting that produces better results, look at pint/examples/fitNGC440E_MCMC.py" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Post-MCMC values (50th percentile +/- (16th/84th percentile):\n", + " F0: 205.530699272835 (+ 3.4382e-08 / - 1.166e-08)\n", + " F1: 0.589355241152989 (+ 0 / - 0)\n", + "Final ln-posterior: -1402.3\n" + ] + } + ], + "source": [ + "fitter.phaseogram()\n", + "samples = sampler.sampler.chain[:, 10:, :].reshape((-1, fitter.n_fit_params))\n", + "ranges = map(\n", + " lambda v: (v[1], v[2] - v[1], v[1] - v[0]),\n", + " zip(*np.percentile(samples, [16, 50, 84], axis=0)),\n", + ")\n", + "print(\"Post-MCMC values (50th percentile +/- (16th/84th percentile):\")\n", + "for name, vals in zip(fitter.fitkeys, ranges):\n", + " print(\"%8s:\" % name + \"%25.15g (+ %12.5g / - %12.5g)\" % vals)\n", + "print(\"Final ln-posterior: %12.5g\" % fitter.lnposterior(fitter.maxpost_fitvals))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Customizable Example\n", + "\n", + "This second example will demonstrate how the *MCMCFitter* can be customized for more involved use. Users can define their own prior and likelihood probability functions to allow for more unique configurations." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "timfile2 = \"NGC6440E.tim\"\n", + "parfile2 = \"NGC6440E.par.good\"\n", + "model2 = pint.models.get_model(parfile2)\n", + "toas2 = toa.get_TOAs(timfile2, planets=False, ephem=\"DE421\")\n", + "nwalkers2 = 12\n", + "nsteps2 = 10" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The new probability functions must be defined by the user and must have the following characteristics. They must take two arguments: an *MCMCFitter* object, and a vector of fitting parameters (called *theta* here). They must return a float (not an astropy Quantity).\n", + "\n", + "The new functions can be passed to the constructor of the *MCMCFitter* object using the keywords *lnprior* and *lnlike*, as shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def lnprior_basic(ftr, theta):\n", + " lnsum = 0.0\n", + " for val, key in zip(theta[:-1], ftr.fitkeys[:-1]):\n", + " lnsum += getattr(ftr.model, key).prior_pdf(val, logpdf=True)\n", + " # print('%s:\\t%f' % (key, val))\n", + " # print('PHASE:\\t%f' % theta[-1])\n", + " # Add phase term\n", + " if theta[-1] > 1.0 or theta[-1] < 0.0:\n", + " return np.inf\n", + " return lnsum\n", + "\n", + "\n", + "def lnlikelihood_chi2(ftr, theta):\n", + " ftr.set_parameters(theta)\n", + " # Uncomment to view progress\n", + " # print('Count is: %d' % ftr.numcalls)\n", + " return -Residuals(toas=ftr.toas, model=ftr.model).chi2.value\n", + "\n", + "\n", + "sampler2 = EmceeSampler(nwalkers=nwalkers2)\n", + "fitter2 = MCMCFitter(\n", + " toas2, model2, sampler2, lnprior=lnprior_basic, lnlike=lnlikelihood_chi2\n", + ")\n", + "fitter2.sampler.random_state = state" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'numpy.float128' object has no attribute 'value'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlike_start\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfitter2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlnlikelihood\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfitter2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfitter2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_parameters\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Starting pulse likelihood: %f\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mlike_start\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mlnlikelihood_chi2\u001b[0;34m(ftr, theta)\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;31m# Uncomment to view progress\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 16\u001b[0m \u001b[0;31m# print('Count is: %d' % ftr.numcalls)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0mResiduals\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtoas\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mftr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtoas\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mftr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mchi2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'numpy.float128' object has no attribute 'value'" + ] + } + ], + "source": [ + "like_start = fitter2.lnlikelihood(fitter2, fitter2.get_parameters())\n", + "print(\"Starting pulse likelihood: %f\" % like_start)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/10 [00:00" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# compute the total delay\n", + "total_delay = m.delay(t)\n", + "total_delay" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One can get the delay upto some component. For example, I want to the delay computation stop at jump delay." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$[392.26834,~299.04792,~129.09853,~\\dots,~-335.16783,~-395.83022,~-36.455001] \\; \\mathrm{s}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "to_jump_delay = m.delay(t, cutoff_component=\"SolarSystemShapiro\")\n", + "to_jump_delay" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "floatParameter( F1 -6.2049547277487420583e-16 (Hz / s) +/- 1.73809343735734e-20 Hz / s frozen=False)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m.F1" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'AbsPhase': pint.models.absolute_phase.AbsPhase,\n", + " 'AstrometryEquatorial': pint.models.astrometry.AstrometryEquatorial,\n", + " 'AstrometryEcliptic': pint.models.astrometry.AstrometryEcliptic,\n", + " 'BinaryBT': pint.models.binary_bt.BinaryBT,\n", + " 'BinaryDD': pint.models.binary_dd.BinaryDD,\n", + " 'BinaryDDK': pint.models.binary_ddk.BinaryDDK,\n", + " 'BinaryELL1': pint.models.binary_ell1.BinaryELL1,\n", + " 'BinaryELL1H': pint.models.binary_ell1.BinaryELL1H,\n", + " 'DispersionDM': pint.models.dispersion_model.DispersionDM,\n", + " 'DispersionDMX': pint.models.dispersion_model.DispersionDMX,\n", + " 'FD': pint.models.frequency_dependent.FD,\n", + " 'Glitch': pint.models.glitch.Glitch,\n", + " 'PhaseJump': pint.models.jump.PhaseJump,\n", + " 'ScaleToaError': pint.models.noise_model.ScaleToaError,\n", + " 'EcorrNoise': pint.models.noise_model.EcorrNoise,\n", + " 'PLRedNoise': pint.models.noise_model.PLRedNoise,\n", + " 'SolarSystemShapiro': pint.models.solar_system_shapiro.SolarSystemShapiro,\n", + " 'SolarWindDispersion': pint.models.solar_wind_dispersion.SolarWindDispersion,\n", + " 'Spindown': pint.models.spindown.Spindown,\n", + " 'Wave': pint.models.wave.Wave,\n", + " 'IFunc': pint.models.ifunc.IFunc}" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Component.component_types" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t, *_ = Component.component_types.values()\n", + "ti = t()\n", + "ti.component_special_params" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "defaultdict(list,\n", + " {'RAJ': ['AstrometryEquatorial'],\n", + " 'DECJ': ['AstrometryEquatorial'],\n", + " 'PMRA': ['AstrometryEquatorial'],\n", + " 'PMDEC': ['AstrometryEquatorial'],\n", + " 'RA': ['AstrometryEquatorial'],\n", + " 'DEC': ['AstrometryEquatorial'],\n", + " 'ELONG': ['AstrometryEcliptic'],\n", + " 'ELAT': ['AstrometryEcliptic'],\n", + " 'PMELONG': ['AstrometryEcliptic'],\n", + " 'PMELAT': ['AstrometryEcliptic'],\n", + " 'LAMBDA': ['AstrometryEcliptic'],\n", + " 'BETA': ['AstrometryEcliptic'],\n", + " 'PMLAMBDA': ['AstrometryEcliptic'],\n", + " 'PMBETA': ['AstrometryEcliptic'],\n", + " 'DMX_0001': ['DispersionDMX'],\n", + " 'DMXR1_0001': ['DispersionDMX'],\n", + " 'DMXR2_0001': ['DispersionDMX'],\n", + " 'NE_SW': ['SolarWindDispersion'],\n", + " 'SWM': ['SolarWindDispersion'],\n", + " 'NE1AU': ['SolarWindDispersion'],\n", + " 'SOLARN0': ['SolarWindDispersion']})" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from collections import defaultdict\n", + "\n", + "special = defaultdict(list)\n", + "for n, t in Component.component_types.items():\n", + " for p in t().component_special_params:\n", + " special[p].append(n)\n", + "\n", + "\n", + "special" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "G = Component.component_types[\"Glitch\"]\n", + "g = G()\n", + "g.component_special_params" + ] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,md" + }, + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/examples/Timing_model_update_example.md b/docs/examples/Timing_model_update_example.md new file mode 100644 index 000000000..b9bf64982 --- /dev/null +++ b/docs/examples/Timing_model_update_example.md @@ -0,0 +1,46 @@ +--- +jupyter: + jupytext: + formats: ipynb,md + text_representation: + extension: .md + format_name: markdown + format_version: '1.2' + jupytext_version: 1.5.2 + kernelspec: + display_name: Python 3 + language: python + name: python3 +--- + +```python jupyter={"outputs_hidden": false} +import pint.models.model_builder as mb +``` + +# To get all the model componets + +```python jupyter={"outputs_hidden": false} +# mb.get_components() +``` + +# Update on timing model + +```python jupyter={"outputs_hidden": false} +model = mb.get_model("NGC6440E.par") +``` + +```python jupyter={"outputs_hidden": false} +model.get_params_of_type("str") +``` + +```python jupyter={"outputs_hidden": false} +model.get_params_of_type("float") +``` + +```python jupyter={"outputs_hidden": false} +model.get_params_of_type("prefix") +``` + +```python jupyter={"outputs_hidden": false} + +``` diff --git a/docs/examples/fftfit.md b/docs/examples/fftfit.md new file mode 100644 index 000000000..0871744df --- /dev/null +++ b/docs/examples/fftfit.md @@ -0,0 +1,362 @@ +--- +jupyter: + jupytext: + formats: ipynb,md + text_representation: + extension: .md + format_name: markdown + format_version: '1.2' + jupytext_version: 1.5.2 + kernelspec: + display_name: Python 3 + language: python + name: python3 +--- + +```python +%load_ext autoreload +%autoreload 2 +``` + +```python +import numpy as np +import matplotlib.pyplot as plt +import scipy.stats +import pint.profile +``` + +```python +template = np.zeros(256) +template[:16] = 1 +plt.plot(np.linspace(0, 1, len(template), endpoint=False), template) +up_template = pint.profile.upsample(template, 16) +plt.plot(np.linspace(0, 1, len(up_template), endpoint=False), up_template) +plt.xlim(0, 1) +``` + +```python +template = np.diff(scipy.stats.vonmises(100).cdf(np.linspace(0, 2 * np.pi, 1024 + 1))) +plt.plot(np.linspace(0, 1, len(template), endpoint=False), template) +up_template = pint.profile.upsample(template, 16) +plt.plot(np.linspace(0, 1, len(up_template), endpoint=False), up_template) +plt.plot( + np.linspace(0, 1, len(template), endpoint=False), pint.profile.shift(template, 0.25), +) +plt.xlim(0, 1) +``` + +```python +if False: + template = np.diff(scipy.stats.vonmises(10).cdf(np.linspace(0, 2 * np.pi, 64 + 1))) + profile = pint.profile.shift(template, 0.25) +else: + template = np.random.randn(64) + profile = np.random.randn(len(template)) + +upsample = 8 +if len(template) != len(profile): + raise ValueError( + "Template is length %d but profile is length %d" % (len(template), len(profile)) + ) +t_c = np.fft.rfft(template) +p_c = np.fft.rfft(profile) +ccf_c = np.zeros((len(template) * upsample) // 2 + 1, dtype=complex) +ccf_c[: len(t_c)] = t_c +ccf_c[: len(p_c)] *= np.conj(p_c) +ccf = np.fft.irfft(ccf_c) +x = np.argmax(ccf) / len(ccf) +l, r = x - 1 / len(ccf), x + 1 / len(ccf) + +plt.figure() +xs = np.linspace(0, 1, len(ccf), endpoint=False) +plt.plot(xs, ccf) +plt.axvspan(r, l, alpha=0.2) +plt.axvline(x) + + +def gof(x): + return -(ccf_c * np.exp(2.0j * np.pi * np.arange(len(ccf_c)) * x)).sum().real + + +plt.plot(xs, [-2 * gof(x) / len(xs) for x in xs]) + +plt.figure() +xs = np.linspace(x - 4 / len(ccf), x + 4 / len(ccf), 100) +plt.plot(xs, [gof(x) for x in xs]) +plt.axvspan(l, r, alpha=0.2) +plt.axvline(x) +``` + +```python +template = pint.profile.upsample( + np.diff(scipy.stats.vonmises(10).cdf(np.linspace(0, 2 * np.pi, 16 + 1))), 2, +) +for s in np.linspace(0, 1 / len(template), 33): + profile = pint.profile.shift(template, s) + print((s - pint.profile.fftfit_basic(template, profile)) * len(template)) +``` + +```python +a = np.random.randn(256) +a_c = np.fft.rfft(a) +a_c[-1] = 0 +a_c[0] = 0 +xs = np.linspace(0, 1, len(a), endpoint=False) +a_m = ( + (a_c[:, None] * np.exp(2.0j * np.pi * xs[None, :] * np.arange(len(a_c))[:, None])) + .sum(axis=0) + .real + * 2 + / len(a) +) +a_i = np.fft.irfft(a_c) +plt.plot(xs, a_m) +plt.plot(xs, a_i) +np.sqrt(np.mean((a_m - a_i) ** 2)) +``` + +```python +c = np.zeros(6, dtype=complex) +c[-1] = 1 +np.fft.irfft(c) +``` + +```python +r = np.random.randn(256) +r_c = np.fft.rfft(r) +r_1 = np.fft.irfft(np.conj(r_c)) +plt.plot(r) +plt.plot(r_1[1::-1]) +``` + +```python +n = 16 +c = np.zeros(5, dtype=complex) +c[0] = 1 +print(pint.profile.irfft_value(c, 0, n)) +np.fft.irfft(c, n) +``` + +```python +n = 8 +c = np.zeros(5, dtype=complex) +c[-1] = 1 +print(pint.profile.irfft_value(c, 0, n)) +np.fft.irfft(c, n) +``` + +```python +n = 16 +c = np.zeros(5, dtype=complex) +c[-1] = 1 +print(pint.profile.irfft_value(c, 0, n)) +np.fft.irfft(c, n) +``` + +```python +a = np.ones(8) +a[::2] *= -1 +pint.profile.shift(pint.profile.shift(a, 1 / 16), -1 / 16) +``` + +```python +s = 1 / 3 +t = pint.profile.vonmises_profile(10, 16) +t_c = np.fft.rfft(t) +t_s_c = np.fft.rfft(pint.profile.shift(t, s)) +ccf_c = np.conj(t_c) * t_s_c +ccf_c[-1] = 0 +plt.plot(np.fft.irfft(ccf_c, 256)) +``` + +```python +s = 1 / 8 +kappa = 1.0 +n = 4096 +template = pint.profile.vonmises_profile(kappa, n) +profile = pint.profile.shift(template, s / n) +rs = pint.profile.fftfit_basic(template, profile) +print(s, rs * n) +upsample = 8 + +n_long = len(template) * upsample +t_c = np.fft.rfft(template) +p_c = np.fft.rfft(profile) +ccf_c = t_c.copy() +ccf_c *= np.conj(p_c) +ccf_c[0] = 0 +ccf_c[-1] = 0 +ccf = np.fft.irfft(ccf_c, n_long) +i = np.argmax(ccf) +assert ccf[i] >= ccf[(i - 1) % len(ccf)] +assert ccf[i] >= ccf[(i + 1) % len(ccf)] +x = i / len(ccf) +l, r = x - 1 / len(ccf), x + 1 / len(ccf) + + +def gof(x): + return -pint.profile.irfft_value(ccf_c, x, n_long) + + +print(l, gof(l)) +print(x, gof(x)) +print(r, gof(r)) +print(-s / n, gof(-s / n)) + +res = scipy.optimize.minimize_scalar(gof, bracket=(l, x, r), method="brent", tol=1e-10) +res +``` + +```python +t = pint.profile.vonmises_profile(10, 1024, 1 / 3) +plt.plot(np.linspace(0, 1, len(t), endpoint=False), t) +plt.xlim(0, 1) +``` + +```python +profile1 = pint.profile.vonmises_profile(1, 512, phase=0.3) +profile2 = pint.profile.vonmises_profile(10, 1024, phase=0.7) +s = pint.profile.fftfit_basic(profile1, profile2) +pint.profile.fftfit_basic(pint.profile.shift(profile1, s), profile2) +``` + +Okay, so let's try to work out the uncertainties on the outputs. + +Let's view the problem as this: we have a set of Fourier coefficients $t_j$ for the template and a set of Fourier coefficients $p_j$ for the profile. We are looking for $a$ and $\phi$ that minimize + +$$ \chi^2 = \sum_{j=1}^m \left|ae^{2\pi i j \phi} t_j - p_j\right|^2. $$ + +Put another way we have a vector-valued function $F(a,\phi)$ and we are trying to match the observed profile vector. We can estimate the uncertainties using the Jacobian of $F$. + +$$\frac{\partial F}{\partial a}_j = e^{2\pi i j \phi} t_j, $$ + +and + +$$\frac{\partial F}{\partial \phi}_j = a 2\pi i j e^{2\pi i j \phi} t_j. $$ + +If this forms a matrix $J$, and the uncertainties on the input data are of size $\sigma$, then the covariance matrix for the fit parameters will be $\sigma^2(J^TJ)^{-1}$. + + +```python +n = 8 + +r = [] +for i in range(10000): + t = np.random.randn(n) + t_c = np.fft.rfft(t) + + r.append(np.mean(np.abs(t_c[1:-1]) ** 2) / (n * np.mean(np.abs(t) ** 2))) +np.mean(r) +``` + +```python +template = pint.profile.vonmises_profile(1, 256) +plt.plot(template) +plt.xlim(0, len(template)) +std = 1 +shift = 0 +scale = 1 +r = pint.profile.fftfit_aarchiba.fftfit_full(template, scale * pint.profile.shift(template, shift), std=std) +r.shift, r.scale, r.offset, r.uncertainty, r.cov +``` + +```python +fftfit.fftfit_full? +``` + +```python +def gen_shift(): + return pint.profile.wrap( + pint.profile.fftfit_basic( + template, scale * template + std * np.random.randn(len(template)) + ) + ) + + +shifts = [] +``` + +```python +for i in range(1000): + shifts.append(gen_shift()) +np.std(shifts) +``` + +```python +r.uncertainty / np.std(shifts) +``` + +```python +snrs = {} + +scale = 1e-3 +template = pint.profile.vonmises_profile(100, 1024, 1 / 3) + 0.5*pint.profile.vonmises_profile(50, 1024, 1 / 2) +plt.plot(np.linspace(0, 1, len(template), endpoint=False), scale*template) + +def gen_prof(std): + shift = np.random.uniform(0, 1) + shift_template = pint.profile.shift(template, shift) + return scale*shift_template + scale*std * np.random.standard_normal(len(template)) / np.sqrt( + len(template) + ) + + +plt.plot(np.linspace(0, 1, len(template), endpoint=False), gen_prof(0.01)) +plt.xlim(0, 1) + + +def gen_shift(std): + shift = np.random.uniform(0, 1) + shift_template = pint.profile.shift(template, shift) + profile = scale*shift_template + scale*std * np.random.standard_normal(len(template)) / np.sqrt( + len(template) + ) + return pint.profile.wrap(pint.profile.fftfit_basic(template, profile) - shift) + + +gen_shift(0.01) +``` + +```python +def gen_uncert(std): + return pint.profile.fftfit_aarchiba.fftfit_full(template, gen_prof(std), std=scale*std/np.sqrt(len(template))).uncertainty + +def gen_uncert_estimate(std): + return pint.profile.fftfit_full(template, gen_prof(std)).uncertainty +``` + +```python +for s in np.geomspace(1, 1e-4, 9): + if s not in snrs: + snrs[s] = [] + for i in range(1000): + snrs[s].append(gen_shift(s)) +``` + +```python +snr_list = sorted(snrs.keys()) +plt.loglog(snr_list, [np.std(snrs[s]) for s in snr_list], "o", label="measured std.") +plt.loglog(snr_list, [gen_uncert(s) for s in snr_list], ".", label="computed uncert.") +plt.loglog(snr_list, [gen_uncert_estimate(s) for s in snr_list], "+", label="computed uncert. w/estimate") +plt.legend() +plt.xlabel("SNR (some strange units)") +plt.ylabel("Uncertainty or standard deviation (phase)") + +``` + +```python +p = 1-2*scipy.stats.norm.sf(1) +p +``` + +```python +scipy.stats.binom.isf(0.01, 100, p), scipy.stats.binom.isf(0.99, 100, p) +``` + +```python +scipy.stats.binom(16, p).ppf(0.99) +``` + +```python + +``` diff --git a/src/pint/profile/__init__.py b/src/pint/profile/__init__.py new file mode 100644 index 000000000..38091b1b9 --- /dev/null +++ b/src/pint/profile/__init__.py @@ -0,0 +1,283 @@ +"""Tools for working with pulse profiles. + +The key tool here is FFTFIT (:func:`pint.profile.fftfit_full`), which allows +one to find the phase shift that optimally aligns a template with a profile, +but there are also tools here for doing those shifts and generating useful +profiles. +""" + +import numpy as np +import scipy.stats +from numpy.fft import irfft, rfft + +import pint.profile.fftfit_aarchiba +import pint.profile.fftfit_nustar +import pint.profile.fftfit_presto + +__all__ = [ + "fftfit_full", + "fftfit_basic", + "FFTFITResult", + "fftfit_cprof", + "fftfit_classic", + "wrap", + "vonmises_profile", + "upsample", + "shift", +] + + +class FFTFITResult: + """Summary of the results of an FFTFit operation. + + Not all of these attributes may be present in every object; which are + returned depends on the algorithm used and the options it is passed. + + If these quantities are available, then + ``r.scale*shift(template, r.shift) + r.offset`` + should be as close as possible to the profile used in the fitting. + + Attributes + ---------- + shift : float + The shift required to make the template match the profile. Between 0 and 1. + scale : float + The amount the template must be scaled by to match the profile. + offset : float + The amount to add to the scaled template to match the profile. + uncertainty : float + The estimated one-sigma uncertainty in the shift attribute. + """ + + pass + + +def wrap(a): + """Wrap a floating-point number or array to the range -0.5 to 0.5.""" + return (a + 0.5) % 1 - 0.5 + + +def zap_nyquist(profile): + if len(profile) % 2: + return profile + else: + c = np.fft.rfft(profile) + c[-1] = 0 + return np.fft.irfft(c) + + +def vonmises_profile(kappa, n, phase=0): + """Generate a profile based on a von Mises distribution. + + The von Mises distribution is a cyclic analogue of a Gaussian distribution. The width is + specified by the parameter ``kappa``, which for large ``kappa`` is approximately + ``1/(2*pi*sigma**2)``. + """ + return np.diff( + scipy.stats.vonmises(kappa).cdf( + np.linspace(-2 * np.pi * phase, 2 * np.pi * (1 - phase), n + 1) + ) + ) + + +def upsample(profile, factor): + """Produce an up-sampled version of a pulse profile. + + This uses a Fourier algorithm, with zero in the new Fourier coefficients. + """ + output_len = len(profile) * factor + if output_len % 2: + raise ValueError("Cannot cope with odd output profile lengths") + c = np.fft.rfft(profile) + output_c = np.zeros(output_len // 2 + 1, dtype=complex) + output_c[: len(c)] = c * factor + output = np.fft.irfft(output_c) + assert len(output) == output_len + return output + + +def shift(profile, phase): + """Shift a profile in phase. + + This is a shift towards later phases - if your profile has a 1 in bin zero + and apply a phase shift of 1/4, the 1 will now be in bin n/4. If the + profile has even length, do not modify the Nyquist component. + """ + c = np.fft.rfft(profile) + if len(profile) % 2: + c *= np.exp(-2.0j * np.pi * phase * np.arange(len(c))) + else: + c[:-1] *= np.exp(-2.0j * np.pi * phase * np.arange(len(c) - 1)) + return np.fft.irfft(c, len(profile)) + + +def irfft_value(c, phase, n=None): + """Evaluate the inverse real FFT at a particular position. + + If the phase is one of the usual grid points the result will agree with + the results of :func:`numpy.fft.irfft` there. + + No promises if n is small enough to imply truncation. + """ + natural_n = (len(c) - 1) * 2 + if n is None: + n = natural_n + phase = np.asarray(phase) + s = phase.shape + phase = np.atleast_1d(phase) + c = np.array(c) + c[0] /= 2 + if n == natural_n: + c[-1] /= 2 + return ( + ( + c[:, None] + * np.exp(2.0j * np.pi * phase[None, :] * np.arange(len(c))[:, None]) + ) + .sum(axis=0) + .real + * 2 + / n + ).reshape(s) + + +def fftfit_full(template, profile, code="aarchiba"): + """Match template to profile and return match properties. + + The returned object, a :class:`pint.profile.FFTFITResult`, has a + ``.shift`` attribute indicating the optimal shift, + a ``.uncertainty`` attribute containting an estimate of the uncertainty, and + possibly certain other attributes depending on which version of the code is + run. + + The ``.shift`` attribute is computed so that ``shift(template, r.shift)`` is + as closely aligned with ``profile`` as possible. + + Parameters + ---------- + template : array + The template representing the ideal pulse profile. + profile : array + The observed profile the template should be aligned with. + code : "aarchiba", "nustar", "presto" + Which underlying algorithm and code should be used to carry out the + operation. Generally the "aarchiba" code base is the best tested + under idealized circumstances, and "presto" is the compiled FORTRAN + code FFTFIT that has been in use for a very long time (but is not + available unless PINT has access to the compiled code base of PRESTO). + """ + if code == "aarchiba": + return pint.profile.fftfit_aarchiba.fftfit_full(template, profile) + elif code == "nustar": + return pint.profile.fftfit_nustar.fftfit_full(template, profile) + elif code == "presto": + if pint.profile.fftfit_presto.presto is None: + raise ValueError("The PRESTO compiled code is not available") + return pint.profile.fftfit_presto.fftfit_full(template, profile) + else: + raise ValueError("Unrecognized FFTFIT implementation {}".format(code)) + + +def fftfit_basic(template, profile, code="aarchiba"): + """Return the optimal phase shift to match template to profile. + + This calls :func:`pint.profile.fftfit_full` and extracts the ``.shift`` attribute. + + Parameters + ---------- + template : array + The template representing the ideal pulse profile. + profile : array + The observed profile the template should be aligned with. + code : "aarchiba", "nustar", "presto" + Which code to use. See :func:`pint.profile.fftfit_full` for details. + """ + if code == "aarchiba": + return pint.profile.fftfit_aarchiba.fftfit_basic(template, profile) + else: + return fftfit_full(template, profile, code=code).shift + + +def fftfit_cprof(template): + """Transform a template for use with fftfit_classic. + + Emulate the version of fftfit.cprof in PRESTO. + Returns results suitable for :func:`pint.profile.fftfit_classic`. + + Parameter + --------- + template : array + + Returns + ------- + c : float + The constant term? This may not agree with PRESTO. + amp : array + Real values representing the Fourier amplitudes of the template, not + including the constant term. + pha : array + Real values indicating the angles of the Fourier coefficients of the + template, not including the constant term; the sign is the negative + of that returned by ``np.fft.rfft``. + """ + tc = rfft(template) + tc *= np.exp(-2.0j * np.pi * np.arange(len(tc)) / len(template)) + return 2 * tc, 2 * np.abs(tc)[1:], -np.angle(tc)[1:] + + +def fftfit_classic(profile, template_amplitudes, template_angles, code="aarchiba"): + """Emulate the version of fftfit in PRESTO. + + This has a different calling and return convention. + The template can be transformed appropriately with + :func:`pint.profile.fftfit_cprof`. + + Parameters + ---------- + profile : array + The observed profile. + template_amplitudes : array + Real values representing the Fourier amplitudes of the template, not + including the constant term. + template_angles : array + Real values indicating the angles of the Fourier coefficients of the + template, not including the constant term; the sign is the negative + of that returned by ``np.fft.rfft``. + + Returns + ------- + shift : float + The shift, in bins, plus one. + eshift : float + The uncertainty in the shift, in bins. + snr : float + Some kind of signal-to-noise ratio; not implemented. + esnr : float + Uncertainty in the above; not implemented. + b : float + Unknown; not implemented. + errb : float + Uncertainty in the above; not implemented. + ngood + Unknown, maybe the number of harmonics used? Not implemented. + """ + if code == "presto": + import presto.fftfit + + return presto.fftfit.fftfit(profile, template_amplitudes, template_angles) + if len(profile) % 2: + raise ValueError("fftfit_classic only works on even-length profiles") + template_f = np.zeros(len(template_amplitudes) + 1, dtype=complex) + template_f[1:] = template_amplitudes * np.exp(-1.0j * template_angles) + template = irfft(template_f) + r = fftfit_full(template, profile, code=code) + + shift = (r.shift % 1) * len(profile) + eshift = r.uncertainty * len(profile) + snr = np.nan + esnr = np.nan + b = np.nan + errb = np.nan + ngood = np.nan + + return shift, eshift, snr, esnr, b, errb, ngood diff --git a/src/pint/profile/fftfit_aarchiba.py b/src/pint/profile/fftfit_aarchiba.py new file mode 100644 index 000000000..d642e623a --- /dev/null +++ b/src/pint/profile/fftfit_aarchiba.py @@ -0,0 +1,110 @@ +"""Use FFT techniques to align a template with a pulse profile. + +This should be accompanied by test_fftfit.py, which uses hypothesis to check +its reliability. If not, don't edit this, you don't have the git version. + +""" +from __future__ import division + +import numpy as np +import scipy.optimize +import scipy.stats + +import pint.profile + + +def fftfit_full( + template, profile, compute_scale=True, compute_uncertainty=True, std=None +): + # We will upsample the cross-correlation function to ensure + # that the highest peak is not missed + upsample = 8 + + t_c = np.fft.rfft(template) + if len(template) % 2 == 0: + t_c[-1] = 0 + p_c = np.fft.rfft(profile) + if len(profile) % 2 == 0: + p_c[-1] = 0 + n_c = min(len(t_c), len(p_c)) + t_c = t_c[:n_c] + p_c = p_c[:n_c] + + ccf_c = np.conj(t_c).copy() + ccf_c *= p_c + ccf_c[0] = 0 + n_long = 2 ** int(np.ceil(np.log2(2 * (n_c - 1) * upsample))) + ccf = np.fft.irfft(ccf_c, n_long) + i = np.argmax(ccf) + assert ccf[i] >= ccf[(i - 1) % len(ccf)] + assert ccf[i] >= ccf[(i + 1) % len(ccf)] + x = i / len(ccf) + l, r = x - 1 / len(ccf), x + 1 / len(ccf) + + def gof(x): + return -pint.profile.irfft_value(ccf_c, x, n_long) + + res = scipy.optimize.minimize_scalar( + gof, bounds=(l, r), method="Bounded", options=dict(xatol=1e-5 / n_c) + ) + if not res.success: + raise ValueError("FFTFIT failed: %s" % res.message) + # assert gof(res.x) <= gof(x) + r = pint.profile.FFTFITResult() + r.shift = pint.profile.wrap(res.x) + + if compute_scale or compute_uncertainty: + # shifted template corefficients + s_c = t_c * np.exp(-2j * np.pi * np.arange(len(t_c)) * r.shift) + assert len(s_c) == len(p_c) + n_data = 2 * len(s_c) - 1 + a = np.zeros((n_data, 2)) + b = np.zeros(n_data) + a[0, 1] = len(template) + a[0, 0] = s_c[0].real + b[0] = p_c[0].real + b[1 : len(p_c)] = p_c[1:].real + b[len(p_c) :] = p_c[1:].imag + a[1 : len(s_c), 0] = s_c[1:].real + a[len(s_c) :, 0] = s_c[1:].imag + + lin_x, res, rk, s = scipy.linalg.lstsq(a, b) + assert lin_x.shape == (2,) + + r.scale = lin_x[0] + r.offset = lin_x[1] + + if compute_uncertainty: + if std is None: + resid = ( + r.scale * pint.profile.shift(template, r.shift) + r.offset - profile + ) + std = np.sqrt(np.mean(resid ** 2)) + r.std = std + + J = np.zeros((2 * len(s_c) - 2, 2)) + J[: len(s_c) - 1, 0] = ( + -r.scale * 2 * np.pi * s_c[1:].imag * np.arange(1, len(s_c)) + ) + J[len(s_c) - 1 :, 0] = ( + r.scale * 2 * np.pi * s_c[1:].real * np.arange(1, len(s_c)) + ) + J[: len(s_c) - 1, 1] = s_c[1:].real + J[len(s_c) - 1 :, 1] = s_c[1:].imag + cov = scipy.linalg.inv(np.dot(J.T, J)) + assert cov.shape == (2, 2) + # FIXME: std is per data point, not per real or imaginary + # entry in s_c; check conversion + r.uncertainty = std * np.sqrt(len(profile) * cov[0, 0] / 2) + r.cov = cov + + return r + + +def fftfit_basic(template, profile): + """Compute the phase shift between template and profile + + We should have fftfit_basic(template, shift(template, s)) == s + """ + r = fftfit_full(template, profile, compute_scale=False, compute_uncertainty=False) + return r.shift diff --git a/src/pint/profile/fftfit_nustar.py b/src/pint/profile/fftfit_nustar.py new file mode 100644 index 000000000..89c2136c8 --- /dev/null +++ b/src/pint/profile/fftfit_nustar.py @@ -0,0 +1,206 @@ +# by mateobachetti +# from https://github.com/NuSTAR/nustar-clock-utils/blob/master/nuclockutils/diagnostics/fftfit.py +from collections import namedtuple + +import numpy as np +from scipy.optimize import brentq, minimize + +import pint.profile + + +def find_delay_with_ccf(amp, pha): + nh = 32 + nprof = nh * 2 + CCF = np.zeros(64, dtype=np.complex) + CCF[:nh] = amp[:nh] * np.cos(pha[:nh]) + 1.0j * amp[:nh] * np.sin(pha[:nh]) + CCF[nprof : nprof - nh : -1] = np.conj(CCF[nprof : nprof - nh : -1]) + CCF[nh // 2 : nh] = 0 + CCF[nprof - nh // 2 : nprof - nh : -1] = 0 + ccf = np.fft.ifft(CCF) + + imax = np.argmax(ccf.real) + cmax = ccf[imax] + shift = normalize_phase_0d5(imax / nprof) + + # plt.figure() + # plt.plot(ccf.real) + # plt.show() + # fb=np.real(cmax) + # ia=imax-1 + # if(ia == -1): ia=nprof-1 + # fa=np.real(ccf[ia]) + # ic=imax+1 + # if(ic == nprof): ic=0 + # fc=np.real(ccf[ic]) + # if ((2*fb-fc-fa) != 0): + # shift=imax+0.5*(fa-fc)/(2*fb-fc-fa) + # shift = normalize_phase_0d5(shift / nprof) + return shift + + +def best_phase_func(tau, amp, pha, ngood=20): + # tau = params['tau'] + # good = slice(1, idx.size // 2 + 1) + good = slice(1, ngood + 1) + idx = np.arange(1, ngood + 1, dtype=int) + res = np.sum(idx * amp[good] * np.sin(-pha[good] + TWOPI * idx * tau)) + # print(tau, res) + return res + + +TWOPI = 2 * np.pi + + +def chi_sq(b, tau, P, S, theta, phi, ngood=20): + # tau = params['tau'] + # good = slice(1, idx.size // 2 + 1) + good = slice(1, ngood + 1) + idx = np.arange(1, ngood + 1, dtype=int) + angle_diff = phi[good] - theta[good] + TWOPI * idx * tau + exp_term = np.exp(1.0j * angle_diff) + + to_square = P[good] - b * S[good] * exp_term + res = np.sum((to_square * to_square.conj())) + + return res.real + + +def chi_sq_alt(b, tau, P, S, theta, phi, ngood=20): + # tau = params['tau'] + # good = slice(1, idx.size // 2 + 1) + good = slice(1, ngood + 1) + idx = np.arange(1, ngood + 1, dtype=int) + angle_diff = phi[good] - theta[good] + TWOPI * idx * tau + chisq_1 = P[good] ** 2 + b ** 2 * S[good] ** 2 + chisq_2 = -2 * b * P[good] * S[good] * np.cos(angle_diff) + res = np.sum(chisq_1 + chisq_2) + + return res + + +FFTFITResult = namedtuple( + "FFTFITResult", ["mean_amp", "std_amp", "mean_phase", "std_phase"] +) + + +def fftfit(prof, template): + """Align a template to a pulse profile. + Parameters + ---------- + prof : array + The pulse profile + template : array, default None + The template of the pulse used to perform the TOA calculation. If None, + a simple sinusoid is used + Returns + ------- + mean_amp, std_amp : floats + Mean and standard deviation of the amplitude + mean_phase, std_phase : floats + Mean and standard deviation of the phase + """ + prof = prof - np.mean(prof) + + nbin = len(prof) + + template = template - np.mean(template) + + temp_ft = np.fft.fft(template) + prof_ft = np.fft.fft(prof) + freq = np.fft.fftfreq(prof.size) + good = freq == freq + + P = np.abs(prof_ft[good]) + theta = np.angle(prof_ft[good]) + S = np.abs(temp_ft[good]) + phi = np.angle(temp_ft[good]) + + assert np.allclose(temp_ft[good], S * np.exp(1.0j * phi)) + assert np.allclose(prof_ft[good], P * np.exp(1.0j * theta)) + + amp = P * S + pha = theta - phi + + mean = np.mean(amp) + ngood = np.count_nonzero(amp >= mean) + + dph_ccf = find_delay_with_ccf(amp, pha) + + idx = np.arange(0, len(P), dtype=int) + sigma = np.std(prof_ft[good]) + + def func_to_minimize(tau): + return best_phase_func(-tau, amp, pha, ngood=ngood) + + start_val = dph_ccf + start_sign = np.sign(func_to_minimize(start_val)) + + count_down = 0 + count_up = 0 + trial_val_up = start_val + trial_val_down = start_val + while True: + if np.sign(func_to_minimize(trial_val_up)) != start_sign: + best_dph = trial_val_up + break + if np.sign(func_to_minimize(trial_val_down)) != start_sign: + best_dph = trial_val_down + break + trial_val_down -= 1 / nbin + count_down += 1 + trial_val_up += 1 / nbin + count_up += 1 + + a, b = best_dph - 2 / nbin, best_dph + 2 / nbin + + shift, res = brentq(func_to_minimize, a, b, full_output=True) + + nmax = ngood + good = slice(1, nmax) + + big_sum = np.sum( + idx[good] ** 2 * amp[good] * np.cos(-pha[good] + 2 * np.pi * idx[good] * -shift) + ) + + b = np.sum( + amp[good] * np.cos(-pha[good] + 2 * np.pi * idx[good] * -shift) + ) / np.sum(S[good] ** 2) + + eshift = sigma ** 2 / (2 * b * big_sum) + + eb = sigma ** 2 / (2 * np.sum(S[good] ** 2)) + + return FFTFITResult(b, np.sqrt(eb), normalize_phase_0d5(shift), np.sqrt(eshift)) + + +def normalize_phase_0d5(phase): + """Normalize phase between -0.5 and 0.5 + Examples + -------- + >>> normalize_phase_0d5(0.5) + 0.5 + >>> normalize_phase_0d5(-0.5) + 0.5 + >>> normalize_phase_0d5(4.25) + 0.25 + >>> normalize_phase_0d5(-3.25) + -0.25 + """ + while phase > 0.5: + phase -= 1 + while phase <= -0.5: + phase += 1 + return phase + + +def fftfit_basic(template, profile): + n, seb, shift, eshift = fftfit(profile, template) + return shift + + +def fftfit_full(template, profile): + r = fftfit(profile, template) + ro = pint.profile.FFTFITResult() + ro.shift = r.mean_phase + ro.uncertainty = r.std_phase + return ro diff --git a/src/pint/profile/fftfit_nustar.py~aside b/src/pint/profile/fftfit_nustar.py~aside new file mode 100644 index 000000000..af5c8ed93 --- /dev/null +++ b/src/pint/profile/fftfit_nustar.py~aside @@ -0,0 +1,189 @@ +# by mateobachetti +# from https://github.com/NuSTAR/nustar-clock-utils/blob/master/nuclockutils/diagnostics/fftfit.py +import numpy as np +from scipy.optimize import minimize, brentq + + +def find_delay_with_ccf(amp, pha): + nh = 32 + nprof = nh * 2 + CCF = np.zeros(64, dtype=np.complex) + CCF[:nh] = amp[:nh] * np.cos(pha[:nh]) + 1.0j * amp[:nh] * np.sin(pha[:nh]) + CCF[nprof : nprof - nh : -1] = np.conj(CCF[nprof : nprof - nh : -1]) + CCF[nh // 2 : nh] = 0 + CCF[nprof - nh // 2 : nprof - nh : -1] = 0 + ccf = np.fft.ifft(CCF) + + imax = np.argmax(ccf.real) + cmax = ccf[imax] + shift = normalize_phase_0d5(imax / nprof) + + # plt.figure() + # plt.plot(ccf.real) + # plt.show() + # fb=np.real(cmax) + # ia=imax-1 + # if(ia == -1): ia=nprof-1 + # fa=np.real(ccf[ia]) + # ic=imax+1 + # if(ic == nprof): ic=0 + # fc=np.real(ccf[ic]) + # if ((2*fb-fc-fa) != 0): + # shift=imax+0.5*(fa-fc)/(2*fb-fc-fa) + # shift = normalize_phase_0d5(shift / nprof) + return shift + + +def best_phase_func(tau, amp, pha, ngood=20): + # tau = params['tau'] + # good = slice(1, idx.size // 2 + 1) + good = slice(1, ngood + 1) + idx = np.arange(1, ngood + 1, dtype=int) + res = np.sum(idx * amp[good] * np.sin(-pha[good] + TWOPI * idx * tau)) + # print(tau, res) + return res + + +TWOPI = 2 * np.pi + + +def chi_sq(b, tau, P, S, theta, phi, ngood=20): + # tau = params['tau'] + # good = slice(1, idx.size // 2 + 1) + good = slice(1, ngood + 1) + idx = np.arange(1, ngood + 1, dtype=int) + angle_diff = phi[good] - theta[good] + TWOPI * idx * tau + exp_term = np.exp(1.0j * angle_diff) + + to_square = P[good] - b * S[good] * exp_term + res = np.sum((to_square * to_square.conj())) + + return res.real + + +def chi_sq_alt(b, tau, P, S, theta, phi, ngood=20): + # tau = params['tau'] + # good = slice(1, idx.size // 2 + 1) + good = slice(1, ngood + 1) + idx = np.arange(1, ngood + 1, dtype=int) + angle_diff = phi[good] - theta[good] + TWOPI * idx * tau + chisq_1 = P[good] ** 2 + b ** 2 * S[good] ** 2 + chisq_2 = -2 * b * P[good] * S[good] * np.cos(angle_diff) + res = np.sum(chisq_1 + chisq_2) + + return res + + +def fftfit(prof, template): + """Align a template to a pulse profile. + Parameters + ---------- + prof : array + The pulse profile + template : array, default None + The template of the pulse used to perform the TOA calculation. If None, + a simple sinusoid is used + Returns + ------- + mean_amp, std_amp : floats + Mean and standard deviation of the amplitude + mean_phase, std_phase : floats + Mean and standard deviation of the phase + """ + prof = prof - np.mean(prof) + + nbin = len(prof) + + template = template - np.mean(template) + + temp_ft = np.fft.fft(template) + prof_ft = np.fft.fft(prof) + freq = np.fft.fftfreq(prof.size) + good = freq == freq + + P = np.abs(prof_ft[good]) + theta = np.angle(prof_ft[good]) + S = np.abs(temp_ft[good]) + phi = np.angle(temp_ft[good]) + + assert np.allclose(temp_ft[good], S * np.exp(1.0j * phi)) + assert np.allclose(prof_ft[good], P * np.exp(1.0j * theta)) + + amp = P * S + pha = theta - phi + + mean = np.mean(amp) + ngood = np.count_nonzero(amp >= mean) + + dph_ccf = find_delay_with_ccf(amp, pha) + + idx = np.arange(0, len(P), dtype=int) + sigma = np.std(prof_ft[good]) + + def func_to_minimize(tau): + return best_phase_func(-tau, amp, pha, ngood=ngood) + + start_val = dph_ccf + start_sign = np.sign(func_to_minimize(start_val)) + + count_down = 0 + count_up = 0 + trial_val_up = start_val + trial_val_down = start_val + while True: + if np.sign(func_to_minimize(trial_val_up)) != start_sign: + best_dph = trial_val_up + break + if np.sign(func_to_minimize(trial_val_down)) != start_sign: + best_dph = trial_val_down + break + trial_val_down -= 1 / nbin + count_down += 1 + trial_val_up += 1 / nbin + count_up += 1 + + a, b = best_dph - 2 / nbin, best_dph + 2 / nbin + + shift, res = brentq(func_to_minimize, a, b, full_output=True) + + nmax = ngood + good = slice(1, nmax) + + big_sum = np.sum( + idx[good] ** 2 * amp[good] * np.cos(-pha[good] + 2 * np.pi * idx[good] * -shift) + ) + + b = np.sum( + amp[good] * np.cos(-pha[good] + 2 * np.pi * idx[good] * -shift) + ) / np.sum(S[good] ** 2) + + eshift = sigma ** 2 / (2 * b * big_sum) + + eb = sigma ** 2 / (2 * np.sum(S[good] ** 2)) + + return b, np.sqrt(eb), normalize_phase_0d5(shift), np.sqrt(eshift) + + +def normalize_phase_0d5(phase): + """Normalize phase between -0.5 and 0.5 + Examples + -------- + >>> normalize_phase_0d5(0.5) + 0.5 + >>> normalize_phase_0d5(-0.5) + 0.5 + >>> normalize_phase_0d5(4.25) + 0.25 + >>> normalize_phase_0d5(-3.25) + -0.25 + """ + while phase > 0.5: + phase -= 1 + while phase <= -0.5: + phase += 1 + return phase + + +def fftfit_basic(template, profile): + n, seb, shift, eshift = fftfit(profile, template) + return shift diff --git a/src/pint/profile/fftfit_presto.py b/src/pint/profile/fftfit_presto.py new file mode 100644 index 000000000..920ce87f1 --- /dev/null +++ b/src/pint/profile/fftfit_presto.py @@ -0,0 +1,34 @@ +import numpy as np +from numpy.fft import rfft + +import pint.profile + +try: + import presto.fftfit +except ImportError: + presto = None + + +def fftfit_full(template, profile): + if len(template) != len(profile): + raise ValueError( + "template has length {} but profile has length {}".format( + len(template), len(profile) + ) + ) + if len(template) > 2 ** 13: + raise ValueError( + "template has length {} which is too long".format(len(template)) + ) + # _, amp, pha = pint.profile.fftfit_cprof(template) + _, amp, pha = presto.fftfit.cprof(template) + shift, eshift, snr, esnr, b, errb, ngood = presto.fftfit.fftfit(profile, amp, pha) + r = pint.profile.FFTFITResult() + # Need to add 1 to the shift for some reason + r.shift = pint.profile.wrap(shift / len(template)) + r.uncertainty = eshift / len(template) + return r + + +def fftfit_basic(template, profile): + return fftfit_full(template, profile).shift diff --git a/src/pint/scripts/event_optimize.py b/src/pint/scripts/event_optimize.py index f825eb3c1..9d36deed6 100755 --- a/src/pint/scripts/event_optimize.py +++ b/src/pint/scripts/event_optimize.py @@ -27,6 +27,7 @@ UniformUnboundedRV, ) from pint.observatory.satellite_obs import get_satellite_observatory +from pint.profile import fftfit_cprof, fftfit_classic __all__ = ["read_gaussfitfile", "marginalize_over_phase", "main"] # log.setLevel('DEBUG') @@ -141,13 +142,11 @@ def measure_phase(profile, template, rotate_prof=True): (returned as a tuple). These are defined as in Taylor's talk at the Royal Society. """ - import fftfit - - c, amp, pha = fftfit.cprof(template) + c, amp, pha = fftfit_cprof(template) pha1 = pha[0] if rotate_prof: pha = np.fmod(pha - np.arange(1, len(pha) + 1) * pha1, 2.0 * np.pi) - shift, eshift, snr, esnr, b, errb, ngood = fftfit.fftfit(profile, amp, pha) + shift, eshift, snr, esnr, b, errb, ngood = fftfit_classic(profile, amp, pha) return shift, eshift, snr, esnr, b, errb, ngood @@ -238,8 +237,7 @@ def marginalize_over_phase( def get_fit_keyvals(model, phs=0.0, phserr=0.1): - """Read the model to determine fitted keys and their values and errors from the par file - """ + """Read the model to determine fitted keys and their values and errors from the par file""" fitkeys = [p for p in model.params if not getattr(model, p).frozen] fitvals = [] fiterrs = [] diff --git a/tests/test_event_optimize.py b/tests/test_event_optimize.py index 302c21d7c..a08177118 100644 --- a/tests/test_event_optimize.py +++ b/tests/test_event_optimize.py @@ -1,6 +1,4 @@ #!/usr/bin/env python -# This test is DISABLED because event_optimize requires PRESTO to be installed -# to get the fftfit module. It can be run manually by people who have PRESTO from __future__ import division, print_function import os diff --git a/tests/test_fftfit.py b/tests/test_fftfit.py new file mode 100644 index 000000000..1a19a8a0f --- /dev/null +++ b/tests/test_fftfit.py @@ -0,0 +1,844 @@ +from functools import wraps +from itertools import product + +import numpy as np +import pytest +import scipy.stats +from hypothesis import assume, given, target +from hypothesis.extra.numpy import arrays +from hypothesis.strategies import ( + complex_numbers, + composite, + floats, + integers, + just, + one_of, +) +from numpy.testing import assert_allclose + +import pint.profile +from pint.profile import ( + fftfit_aarchiba, + fftfit_basic, + fftfit_classic, + fftfit_cprof, + fftfit_full, + fftfit_nustar, + fftfit_presto, + irfft_value, + vonmises_profile, + wrap, +) + +NO_PRESTO = fftfit_presto.presto is None + + +def assert_rms_close(a, b, rtol=1e-8, atol=1e-8, name=None): + __tracebackhide__ = True + if name is not None: + target(np.mean((a - b) ** 2), label=f"{name} mean") + target((a - b).max(), label=f"{name} max") + target(-(a - b).min(), label=f"{name} min") + assert np.mean((a - b) ** 2) < rtol * (np.mean(a ** 2) + np.mean(b ** 2)) + atol + + +def assert_allclose_phase(a, b, atol=1e-8, name=None): + __tracebackhide__ = True + if name is not None: + target(np.abs(wrap(a - b)).max(), label="{} max".format(name)) + target(np.abs(wrap(a - b)).mean(), label="{} mean".format(name)) + assert np.all(np.abs(wrap(a - b)) <= atol) + + +ONE_SIGMA = 1 - 2 * scipy.stats.norm().sf(1) + + +def assert_happens_with_probability( + func, p=ONE_SIGMA, n=100, p_lower=None, p_upper=None, fpp=0.05, +): + __tracebackhide__ = True + if p_lower is None: + p_lower = p + if p_upper is None: + p_upper = p + if p_lower > p_upper: + raise ValueError( + "Lower limit on probability {} is higher than upper limit {}".format( + p_lower, p_upper + ) + ) + + k = 0 + for i in range(n): + if func(): + k += 1 + low_k = scipy.stats.binom(n, p_lower).ppf(fpp / 2) + high_k = scipy.stats.binom(n, p_upper).isf(fpp / 2) + assert low_k <= k + assert k <= high_k + + +@composite +def powers_of_two(draw): + return 2 ** draw(integers(4, 16)) + + +@composite +def vonmises_templates(draw, ns=powers_of_two(), phase=floats(0, 1)): + return vonmises_profile(draw(floats(1, 1000)), draw(ns), draw(phase)) + + +@composite +def vonmises_templates_noisy(draw, ns=powers_of_two(), phase=floats(0, 1)): + n = draw(ns) + return vonmises_profile(draw(floats(1, 1000)), n, draw(phase)) + ( + 1e-3 / n + ) * np.random.default_rng(0).standard_normal(n) + + +@composite +def random_templates(draw, ns=powers_of_two()): + return np.random.randn(draw(ns)) + + +@composite +def boxcar_templates(draw, ns=powers_of_two(), duty=floats(0, 1)): + n = draw(ns) + t = np.zeros(n) + m = int(draw(duty) * n) + t[:m] = 1 + t[0] = 1 + t[-1] = 0 + return t + + +@pytest.fixture +def state(): + return np.random.default_rng(0) + + +def randomized_test(tries=5, seed=0): + if tries < 1: + raise ValueError("Must carry out at least one try") + + def rt(f): + @wraps(f) + def wrapper(*args, **kwargs): + kwargs.pop("state", None) + bad_seeds = [] + bad_seed = None + bad_exc = None + for i in range(seed, seed + tries): + try: + return f(*args, state=np.random.default_rng(seed), **kwargs) + except AssertionError as e: + bad_seeds.append(i) + bad_seed = i + bad_exc = e + raise AssertionError( + "Test failed for all seeds (%s). Failure for seed %d shown above." + % (bad_seeds, bad_seed) + ) from bad_exc + + return wrapper + + return rt + + +@randomized_test(tries=3) +def test_normal_fpp(state): + assert state.standard_normal() < 2 + + +@given( + arrays(complex, integers(3, 9), elements=complex_numbers(max_magnitude=1e8)), + integers(4, 16), +) +def test_irfft_value(c, n): + assume(n >= 2 * (len(c) - 1)) + c = c.copy() + c[0] = c[0].real + c[-1] = 0 + xs = np.linspace(0, 1, n, endpoint=False) + assert_rms_close(np.fft.irfft(c, n), irfft_value(c, xs, n)) + + +@given( + arrays(complex, integers(3, 1025), elements=complex_numbers(max_magnitude=1e8)), + integers(4, 4096), + floats(0, 1), +) +def test_irfft_value_one(c, n, x): + assume(n >= 2 * (len(c) - 1)) + irfft_value(c, x, n) + + +@given(floats(0, 1), one_of(vonmises_templates_noisy(), random_templates())) +def test_shift_invertible(s, template): + assert_allclose( + template, pint.profile.shift(pint.profile.shift(template, s), -s), atol=1e-14 + ) + + +@given(integers(0, 2 ** 20), floats(1, 1000), integers(5, 16), floats(0, 1)) +@pytest.mark.parametrize( + "code", + [ + "aarchiba", + pytest.param( + "nustar", marks=[pytest.mark.xfail(reason="profile too symmetric"),], + ), + pytest.param( + "presto", + marks=[ + pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available"), + pytest.mark.xfail(reason="profile too symmetric"), + ], + ), + ], +) +def test_fftfit_basic_integer_vonmises(code, i, kappa, profile_length, phase): + if code == "presto": + assume(profile_length <= 13) + n = 2 ** profile_length + template = vonmises_profile(kappa, n, phase) + (1e-3 / n) * np.random.default_rng( + 0 + ).standard_normal(n) + assume(sum(template > 0.5 * template.max()) > 1) + s = i / len(template) + rs = fftfit_basic(template, pint.profile.shift(template, s), code=code) + assert_allclose_phase(s, rs, atol=1 / (32 * len(template)), name="shift") + + +@given(integers(0, 2 ** 20), vonmises_templates_noisy()) +@pytest.mark.parametrize( + "code", + [ + "aarchiba", + pytest.param( + "nustar", marks=[pytest.mark.xfail(reason="profile too symmetric"),], + ), + pytest.param( + "presto", + marks=[ + pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available"), + pytest.mark.xfail(reason="profile too symmetric"), + ], + ), + ], +) +def test_fftfit_basic_integer(code, i, template): + if code != "aarchiba": + assume(len(template) >= 32) + s = i / len(template) + rs = fftfit_basic(template, pint.profile.shift(template, s), code=code) + assert_allclose_phase(s, rs, name="shift") + + +@given(integers(0, 2 ** 5), vonmises_templates_noisy()) +@pytest.mark.parametrize( + "code", + [ + "aarchiba", + pytest.param( + "nustar", marks=[pytest.mark.xfail(reason="profile too symmetric"),], + ), + pytest.param( + "presto", + marks=[ + pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available"), + pytest.mark.xfail(reason="profile too symmetric"), + ], + ), + ], +) +def test_fftfit_basic_integer_fraction(code, i, template): + s = i / len(template) / 2 ** 5 + rs = fftfit_basic(template, pint.profile.shift(template, s), code=code) + assert_allclose_phase(rs, s, atol=1e-4 / len(template), name="shift") + + +@given(floats(0, 1), floats(1, 1000), powers_of_two()) +@pytest.mark.parametrize( + "code", + [ + "aarchiba", + pytest.param( + "nustar", marks=[pytest.mark.xfail(reason="profile too symmetric"),], + ), + pytest.param( + "presto", + marks=[ + pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available"), + pytest.mark.xfail(reason="profile too symmetric"), + ], + ), + ], +) +def test_fftfit_basic_subbin(code, s, kappa, n): + if code != "aarchiba": + assume(n >= 32) + template = vonmises_profile(kappa, n) + (1e-3 / n) * np.random.default_rng( + 0 + ).standard_normal(n) + rs = fftfit_basic(template, pint.profile.shift(template, s / n), code=code) + assert_allclose_phase(rs, s / n, atol=1e-4 / len(template), name="shift") + + +@given( + floats(0, 1), + one_of(vonmises_templates_noisy(), random_templates(), boxcar_templates()), +) +@pytest.mark.parametrize( + "code", + [ + "aarchiba", + pytest.param( + "nustar", marks=[pytest.mark.xfail(reason="profile too symmetric"),], + ), + pytest.param( + "presto", + marks=[ + pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available"), + pytest.mark.xfail(reason="profile too symmetric"), + ], + ), + ], +) +def test_fftfit_basic_template(code, s, template): + if code != "aarchiba": + assume(len(template) >= 32) + rs = fftfit_basic(template, pint.profile.shift(template, s), code=code) + assert_allclose_phase(rs, s, atol=1e-3 / len(template), name="shift") + + +@given( + one_of(vonmises_templates(), random_templates(), boxcar_templates()), + one_of(vonmises_templates(), random_templates(), boxcar_templates()), +) +@pytest.mark.parametrize( + "code", + [ + "aarchiba", + pytest.param( + "nustar", marks=[pytest.mark.xfail(reason="profiles different lengths"),], + ), + pytest.param( + "presto", + marks=[ + pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available"), + pytest.mark.xfail(reason="profiles different lengths"), + ], + ), + ], +) +def test_fftfit_basic_different_profiles(code, profile1, profile2): + if code != "aarchiba": + assume(len(profile1) >= 32) + fftfit_basic(profile1, profile2, code=code) + + +@given( + one_of(vonmises_templates(), random_templates()), + one_of(vonmises_templates(), random_templates()), +) +@pytest.mark.parametrize( + "code", + [ + "aarchiba", + pytest.param( + "nustar", marks=[pytest.mark.xfail(reason="profiles different lengths"),], + ), + pytest.param( + "presto", + marks=[ + pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available"), + pytest.mark.xfail(reason="profiles different lengths"), + ], + ), + ], +) +def test_fftfit_shift_equivalence(code, profile1, profile2): + if code != "aarchiba": + assume(len(profile1) >= 32) + s = fftfit_basic(profile1, profile2, code=code) + assert_allclose_phase( + fftfit_basic(pint.profile.shift(profile1, s), profile2, code=code), + 0, + atol=1e-3 / min(len(profile1), len(profile2)), + name="shift", + ) + + +@given( + one_of(vonmises_templates(), random_templates(), boxcar_templates()), + floats(0, 1), + one_of(just(1.0), floats(0.5, 2), floats(1e-5, 1e5)), + one_of(just(0.0), floats(-1, 1), floats(-1e5, 1e5)), +) +def test_fftfit_compute_scale(template, s, a, b): + profile = a * pint.profile.shift(template, s) + b + r = fftfit_full(template, profile) + assert_allclose_phase(s, r.shift, atol=1e-3 / len(template), name="shift") + assert_allclose(b, r.offset, atol=a * 1e-8) + assert_allclose(a, r.scale, atol=(1 + abs(b)) * 1e-8) + assert_rms_close( + profile, + r.scale * pint.profile.shift(template, r.shift) + r.offset, + atol=1e-7, + rtol=1e-8, + name="profile", + ) + + +@pytest.mark.parametrize("kappa,n,std", [(10, 64, 0.01), (100, 1024, 0.02)]) +@randomized_test() +def test_fftfit_uncertainty_template(kappa, n, std, state): + template = vonmises_profile(kappa, n) + r = fftfit_aarchiba.fftfit_full(template, template, std=std) + + def gen_shift(): + return wrap( + fftfit_basic( + template, template + std * state.standard_normal((len(template),)) + ) + ) + + values = [gen_shift() for i in range(100)] + ks, fpp = scipy.stats.kstest(values, scipy.stats.norm(0, r.uncertainty).cdf) + + +# could be hypothesized +@pytest.mark.parametrize( + "kappa,n,std,shift,scale,offset", + [ + (1, 256, 0.01, 0, 1, 0), + (10, 64, 0.01, 1 / 3, 2e-3, 0), + (100, 1024, 0.02, 0.2, 1e4, 0), + (100, 2048, 0.01, 0.2, 1e4, -100), + ], +) +def test_fftfit_uncertainty_scaling_invariance(kappa, n, std, shift, scale, offset): + state = np.random.default_rng(0) + template = vonmises_profile(kappa, n) + profile = pint.profile.shift(template, shift) + std * state.standard_normal( + len(template) + ) + + r_1 = fftfit_full(template, profile) + r_2 = fftfit_full(template, scale * profile + offset) + + assert_allclose_phase(r_2.shift, r_1.shift, 1.0 / (32 * n)) + assert_allclose(r_2.uncertainty, r_1.uncertainty, rtol=1e-3) + assert_allclose(r_2.scale, scale * r_1.scale, rtol=1e-3) + assert_allclose(r_2.offset, offset + scale * r_1.offset, rtol=1e-3, atol=1e-6) + + +@pytest.mark.parametrize( + "kappa,n,std,shift,scale,offset,estimate", + [ + a + (b,) + for a, b in product( + [ + (1, 256, 0.01, 0, 1, 0), + (10, 64, 0.01, 1 / 3, 1e-6, 0), + (100, 1024, 0.002, 0.2, 1e4, 0), + (100, 1024, 0.02, 0.2, 1e4, 0), + ], + [False, True], + ) + ], +) +@randomized_test(tries=8) +def test_fftfit_uncertainty_estimate( + kappa, n, std, shift, scale, offset, estimate, state +): + """Check the noise level estimation works.""" + template = vonmises_profile(kappa, n) + + def value_within_one_sigma(): + profile = ( + pint.profile.shift(template, shift) + + offset + + std * state.standard_normal(len(template)) + ) + if estimate: + r = fftfit_aarchiba.fftfit_full(template, scale * profile) + else: + r = fftfit_aarchiba.fftfit_full(template, scale * profile, std=scale * std) + return np.abs(wrap(r.shift - shift)) < r.uncertainty + + assert_happens_with_probability(value_within_one_sigma, ONE_SIGMA) + + +@pytest.mark.parametrize( + "kappa,n,std,shift,scale,offset,code", + [ + (1, 256, 0.01, 0, 1, 0, "aarchiba"), + (10, 64, 0.01, 1 / 3, 1e-6, 0, "aarchiba"), + (100, 1024, 0.002, 0.2, 1e4, 0, "aarchiba"), + (100, 1024, 0.02, 0.2, 1e4, 0, "aarchiba"), + (1000, 4096, 0.01, 0.7, 1e4, 0, "aarchiba"), + pytest.param(1, 256, 0.01, 0, 1, 0, "nustar",), + pytest.param(10, 64, 0.01, 1 / 3, 1e-6, 0, "nustar",), + pytest.param(100, 1024, 0.002, 0.2, 1e4, 0, "nustar",), + pytest.param(100, 1024, 0.02, 0.2, 1e4, 0, "nustar",), + pytest.param(1000, 4096, 0.01, 0.7, 1e4, 0, "nustar",), + pytest.param( + 1, + 256, + 0.01, + 0, + 1, + 0, + "presto", + marks=[pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available"),], + ), + pytest.param( + 10, + 64, + 0.01, + 1 / 3, + 1e-6, + 0, + "presto", + marks=[ + pytest.mark.xfail(reason="bug?"), + pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available"), + ], + ), + pytest.param( + 100, + 1024, + 0.002, + 0.2, + 1e4, + 0, + "presto", + marks=[ + pytest.mark.xfail(reason="bug?"), + pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available"), + ], + ), + pytest.param( + 100, + 1024, + 0.02, + 0.2, + 1e4, + 0, + "presto", + marks=[pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available")], + ), + pytest.param( + 1000, + 4096, + 0.01, + 0.7, + 1e4, + 0, + "presto", + marks=[pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available")], + ), + ], +) +@randomized_test(tries=8) +def test_fftfit_value(kappa, n, std, shift, scale, offset, code, state): + """Check if the returned values are okay with a noisy profile. + + Here we define "okay" as scattered about the right value and within + one sigma as defined by the uncertainty returned by the aarchiba version + of the code (this is presumably a trusted uncertainty). + """ + template = vonmises_profile(kappa, n) + profile = ( + pint.profile.shift(template, shift) + + offset + + std * state.standard_normal(len(template)) + ) + r_true = fftfit_aarchiba.fftfit_full(template, scale * profile, std=scale * std) + assert r_true.uncertainty < 0.1, "This uncertainty is too big for accuracy" + + def value_within_one_sigma(): + profile = ( + pint.profile.shift(template, shift) + + offset + + std * state.standard_normal(len(template)) + ) + r = fftfit_full(template, scale * profile, code=code) + return np.abs(wrap(r.shift - shift)) < r_true.uncertainty + + assert_happens_with_probability(value_within_one_sigma, ONE_SIGMA) + + +@pytest.mark.parametrize( + "kappa,n,std,shift,scale,offset,code", + [ + (1, 256, 0.01, 0, 1, 0, "aarchiba"), + (10, 64, 0.01, 1 / 3, 1e-6, 0, "aarchiba"), + (100, 1024, 0.002, 0.2, 1e4, 0, "aarchiba"), + (100, 1024, 0.02, 0.2, 1e4, 0, "aarchiba"), + (1000, 4096, 0.01, 0.7, 1e4, 0, "aarchiba"), + pytest.param( + 1, + 256, + 0.01, + 0, + 1, + 0, + "nustar", + marks=pytest.mark.xfail(reason="claimed uncertainty too big"), + ), + pytest.param( + 10, + 64, + 0.01, + 1 / 3, + 1e-6, + 0, + "nustar", + marks=pytest.mark.xfail(reason="bug?"), + ), + pytest.param( + 100, + 1024, + 0.002, + 0.2, + 1e4, + 0, + "nustar", + marks=pytest.mark.xfail(reason="bug?"), + ), + pytest.param( + 100, + 1024, + 0.02, + 0.2, + 1e4, + 0, + "nustar", + marks=pytest.mark.xfail(reason="bug?"), + ), + pytest.param( + 1000, + 4096, + 0.01, + 0.7, + 1e4, + 0, + "nustar", + marks=pytest.mark.xfail(reason="bug?"), + ), + pytest.param( + 1, + 256, + 0.01, + 0, + 1, + 0, + "presto", + marks=[ + pytest.mark.xfail(reason="bug?"), + pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available"), + ], + ), + pytest.param( + 10, + 64, + 0.01, + 1 / 3, + 1e-6, + 0, + "presto", + marks=[ + pytest.mark.xfail(reason="bug?"), + pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available"), + ], + ), + pytest.param( + 100, + 1024, + 0.002, + 0.2, + 1e4, + 0, + "presto", + marks=[ + pytest.mark.xfail(reason="bug?"), + pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available"), + ], + ), + pytest.param( + 100, + 1024, + 0.02, + 0.2, + 1e4, + 0, + "presto", + marks=[pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available")], + ), + pytest.param( + 1000, + 4096, + 0.01, + 0.7, + 1e4, + 0, + "presto", + marks=[pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available")], + ), + ], +) +@randomized_test(tries=8) +def test_fftfit_value_vs_uncertainty(kappa, n, std, shift, scale, offset, code, state): + """Check if the scatter matches the claimed uncertainty.""" + template = vonmises_profile(kappa, n) + + def value_within_one_sigma(): + profile = ( + pint.profile.shift(template, shift) + + offset + + std * state.standard_normal(len(template)) + ) + r = fftfit_full(template, scale * profile, code=code) + assert r.uncertainty < 0.1, "This uncertainty is too big for accuracy" + return np.abs(wrap(r.shift - shift)) < r.uncertainty + + assert_happens_with_probability(value_within_one_sigma, ONE_SIGMA) + + +@pytest.mark.parametrize( + "kappa1,kappa2,n,std,code", + [ + (1, 1.1, 256, 0.01, "aarchiba"), + (10, 11, 2048, 0.01, "aarchiba"), + (100, 110, 2048, 0.01, "aarchiba"), + (1.1, 1, 256, 0.01, "aarchiba"), + (11, 10, 2048, 0.01, "aarchiba"), + (110, 100, 2048, 0.01, "aarchiba"), + (1, 1.1, 256, 0.01, "nustar"), + (10, 11, 2048, 0.01, "nustar"), + (100, 110, 2048, 0.01, "nustar"), + (1.1, 1, 256, 0.01, "nustar"), + (11, 10, 2048, 0.01, "nustar"), + (110, 100, 2048, 0.01, "nustar"), + pytest.param( + 1, + 1.1, + 256, + 0.01, + "presto", + marks=[ + pytest.mark.xfail(reason="bug?"), + pytest.mark.skipif(NO_PRESTO, reason="PRESTO not available"), + ], + ), + pytest.param( + 10, + 11, + 2048, + 0.01, + "presto", + marks=[pytest.mark.skipif(NO_PRESTO, reason="PRESTO not available")], + ), + pytest.param( + 100, + 110, + 2048, + 0.01, + "presto", + marks=[pytest.mark.skipif(NO_PRESTO, reason="PRESTO not available")], + ), + pytest.param( + 1.1, + 1, + 256, + 0.01, + "presto", + marks=[ + pytest.mark.xfail(reason="bug?"), + pytest.mark.skipif(NO_PRESTO, reason="PRESTO not available"), + ], + ), + pytest.param( + 11, + 10, + 2048, + 0.01, + "presto", + marks=[pytest.mark.skipif(NO_PRESTO, reason="PRESTO not available")], + ), + pytest.param( + 110, + 100, + 2048, + 0.01, + "presto", + marks=[pytest.mark.skipif(NO_PRESTO, reason="PRESTO not available")], + ), + ], +) +@randomized_test(tries=8) +def test_fftfit_wrong_profile(kappa1, kappa2, n, std, code, state): + """Check that the uncertainty is okay or pessimistic if the template is wrong.""" + template = vonmises_profile(kappa1, n) + wrong_template = vonmises_profile(kappa2, n) + + def value_within_one_sigma(): + shift = state.uniform(0, 1) + profile = pint.profile.shift(template, shift) + std * state.standard_normal( + len(template) + ) + r = fftfit_full(wrong_template, profile, code=code) + return np.abs(wrap(r.shift - shift)) < r.uncertainty + + # Must be pessimistic + assert_happens_with_probability(value_within_one_sigma, ONE_SIGMA, p_upper=1) + + +@pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available") +@pytest.mark.parametrize("n", [32, 128, 1024]) +def test_fftfit_cprof_compare(n): + template = vonmises_profile(100, n) + import presto.fftfit + + c, amp, pha = fftfit_cprof(template) + cp, ampp, phap = presto.fftfit.cprof(template) + + assert_allclose(c, cp, atol=5e-6) + assert_allclose(amp, ampp, atol=5e-6) + assert_allclose(cp[1:], ampp * np.exp(1.0j * phap), atol=5e-6) + + +@pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available") +def test_fftfit_classic_runs(): + template = vonmises_profile(100, 1024) + _, amp, pha = fftfit_cprof(template) + shift, eshift, snr, esnr, b, errb, ngood = fftfit_classic( + template, amp, pha, code="presto" + ) + + +@pytest.mark.skipif(NO_PRESTO, reason="PRESTO is not available") +@pytest.mark.parametrize("n,s", [(32, 0.1), (128, 0.3), (1024, 0.05)]) +def test_fftfit_classic_compare(n, s): + template = vonmises_profile(100, n) + _, amp, pha = fftfit_cprof(template) + + profile = pint.profile.shift(template, s) + 1e-3 * np.random.randn(len(template)) + + shift, eshift, snr, esnr, b, errb, ngood = fftfit_classic( + profile, amp, pha, code="aarchiba" + ) + shift_p, eshift_p, snr_p, esnr_p, b_p, errb_p, ngood_p = fftfit_classic( + profile, amp, pha, code="presto" + ) + + assert_allclose_phase(shift, shift_p, atol=1e-2) + assert_allclose(eshift, eshift_p, rtol=1e-2, atol=1e-2) + # assert_allclose(snr, snr_p) + # assert_allclose(esnr, esnr_p) + # assert_allclose(b, b_p) + # assert_allclose(errb, errb_p) + # assert_allclose(ngood, ngood_p)