diff --git a/.gitignore b/.gitignore index b56c81e..17d4b90 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,7 @@ +*.png +*random*.fits +*random*.lis +*.DS_Store *.pyc .ipynb_checkpoints/ diff --git a/docs/flystar/examples/motion_model_example.ipynb b/docs/flystar/examples/motion_model_example.ipynb new file mode 100644 index 0000000..b3de4b9 --- /dev/null +++ b/docs/flystar/examples/motion_model_example.ipynb @@ -0,0 +1,1363 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "333cd262", + "metadata": {}, + "source": [ + "# Motion Model Examples" + ] + }, + { + "cell_type": "markdown", + "id": "9251851e", + "metadata": {}, + "source": [ + "# Table of Contents" + ] + }, + { + "cell_type": "markdown", + "id": "1e4364ed", + "metadata": {}, + "source": [ + "# Table of Contents\n", + "- [1. Motion Model](#1-motion-model)\n", + " - [1.1. Example: Linear Model Fit](#11-example-linear-model-fit)\n", + " - [1.2. Example: Acceleration Model Fit](#12-example-acceleration-model-fit)\n", + " - [1.3. Example: Parallax Model Fit](#13-example-parallax-model-fit)\n", + "- [2. Fit Motion Model in StarTable](#2-fit-motion-model-in-startable)\n", + " - [2.1. Example: Default Fitting](#21-example-default-fitting)\n", + " - [2.2 Example: Specify Motion Models](#22-example-specify-motion-models)\n", + " - [2.3. Example: Specify the `motion_model_input` Column](#23-example-specify-the-motion_model_input-column)\n", + " - [2.4. Example: Infer Positions](#24-example-infer-positions)\n", + " - [2.5. Speed Test](#25-speed-test)\n" + ] + }, + { + "cell_type": "markdown", + "id": "4bd92a9d", + "metadata": {}, + "source": [ + "# 1. Motion Model" + ] + }, + { + "cell_type": "markdown", + "id": "0d084c38", + "metadata": {}, + "source": [ + "Summary of currently implemented motion models" + ] + }, + { + "cell_type": "markdown", + "id": "faddd6d8", + "metadata": {}, + "source": [ + "| Motion Model | required params | fit_params | fixed_params | model | Description |\n", + "|--------------|----------|--------------------------------------------|-------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n", + "| Empty | 0 | NA | NA | $x(t) = $ NaN / fill_value
$x_e(t) = $ Inf | |\n", + "| Fixed | 1 | $x_0$
$y_0$ | NA | $x(t) = $ np.average($x$, weights=$x_{wt}$) | $x_{wt} = 1/xe^2$ if weighting='var'
$x_{wt} = 1/\\|xe\\|$ if weighting = 'std' |\n", + "| Linear | 2 | $x_0, v_x$
$y_0, v_y$ | optional: $t_0 =$ np.average($t, 1/\\sqrt{x_e^2 + y_e^2}$) | $x(t) = x_0 + v_x * (t - t_0)$ | |\n", + "| Acceleration | 3 | $x_0, v_{x0}, a_x$
$y_0, v_{y0}, a_y$ | optional: $t_0 =$ np.average($t, 1/\\sqrt{x_e^2 + y_e^2}$) | $x(t) = x_0 + v_{x0} * (t - t_0) + 1/2 * a_x * (t - t_0)^2$ | |\n", + "| Parallax | 3 | $x_0, v_x, pi$
$y_0, v_y$ | required: ra, dec
optional: $t_0 =$ np.average($t, 1/\\sqrt{x_e^2 + y_e^2}$); $pa=0$; obsLocation='earth' | $x(t) = x_0 + v_x * (t - t_0) + pvec * (t - t_0)$ | pvec is the parallax vector calculated based on ra, dec, pa, and obsLocation.
Only supports the same obsLocation for all stars in StarTable.fit_motion_model right now. |" + ] + }, + { + "cell_type": "markdown", + "id": "6fdc98af", + "metadata": {}, + "source": [ + "Examples on using `flystar.MotionModel`:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "51c963a1", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "id": "473b0674", + "metadata": {}, + "source": [ + "Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ce4edb88", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from flystar import motion_model\n", + "from flystar.startables import StarTable\n", + "from flystar.motion_model import Empty, Fixed, Linear, Acceleration, Parallax" + ] + }, + { + "cell_type": "markdown", + "id": "8c0e8559", + "metadata": {}, + "source": [ + "Prepare data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "86b6319d", + "metadata": {}, + "outputs": [], + "source": [ + "t = np.array([0, 1., 2.2, 3.5, 5.]) + 2025.0\n", + "x = np.array([0., 0.5, 2.1, 3.2, 8.0])\n", + "y = np.array([10.2, 8.5, 9.1, 10.5, 13.0])\n", + "xe = np.array([0.2, 0.5, 0.3, 0.4, 0.6])\n", + "ye = np.array([0.3, 0.2, 0.5, 0.2, 0.4])\n", + "t_test = np.linspace(2025.0, 2030.0, 100) # Test times for model evaluation" + ] + }, + { + "cell_type": "markdown", + "id": "b1a87102", + "metadata": {}, + "source": [ + "## 1.1. Example: Linear Model Fit" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0926c0a8", + "metadata": {}, + "outputs": [], + "source": [ + "mm = Linear()\n", + "params, param_errs = mm.fit(t, x, y, xe, ye)" + ] + }, + { + "cell_type": "markdown", + "id": "1fad1962", + "metadata": {}, + "source": [ + "Evaluate model at time t:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "840693ae", + "metadata": {}, + "outputs": [], + "source": [ + "x_model, y_model = mm.model(t, params)" + ] + }, + { + "cell_type": "markdown", + "id": "42fbd575", + "metadata": {}, + "source": [ + "Or if uncertainties of parameters is provided at the same time, the model will return the model uncertainties as well:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8fcbdc5d", + "metadata": {}, + "outputs": [], + "source": [ + "x_model, y_model, xe_model, ye_model = mm.model(t, params, param_errs)" + ] + }, + { + "cell_type": "markdown", + "id": "6f9954ef", + "metadata": {}, + "source": [ + "Note that we did not provide the `fixed_params_dict` parameter in the `model` function, so the MotionModel will use the saved self.fixed_params_dict. One can also specify the fixed_params_dict as:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6752e477", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'t0': np.float64(2027.0454838983064)}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mm.fixed_params_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "eba675c8", + "metadata": {}, + "outputs": [], + "source": [ + "x_model, y_model, xe_model, ye_model = mm.model(t_test, params, param_errs, mm.fixed_params_dict)" + ] + }, + { + "cell_type": "markdown", + "id": "a2acbe90", + "metadata": {}, + "source": [ + "Define a helper function to visualize result" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7dba325f", + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_fit(t, x, y, xe, ye, x_model, y_model, xe_model, ye_model, mm_name, t_test=None):\n", + " if t_test is None:\n", + " t_test = t\n", + " x = np.atleast_2d(x)\n", + " y = np.atleast_2d(y)\n", + " xe = np.atleast_2d(xe)\n", + " ye = np.atleast_2d(ye)\n", + " x_model = np.atleast_2d(x_model)\n", + " y_model = np.atleast_2d(y_model)\n", + " xe_model = np.atleast_2d(xe_model)\n", + " ye_model = np.atleast_2d(ye_model)\n", + " \n", + " N_cases = x.shape[0]\n", + " fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))\n", + " for i in range(N_cases):\n", + " l0 = ax1.errorbar(t, x[i], yerr=xe[i], fmt='o', color=f'C{i%10}', label='Data')\n", + " l1, = ax1.plot(t_test, x_model[i], label=f'{mm_name} Fit')\n", + " l2 = ax1.fill_between(t_test, x_model[i] - xe_model[i], x_model[i] + xe_model[i], color=f'C{i%10}', alpha=0.3, label='Model Uncertainty')\n", + "\n", + " r0 = ax2.errorbar(t, y[i], yerr=ye[i], fmt='o', color=f'C{i%10}', label='Data')\n", + " r1, = ax2.plot(t_test, y_model[i], label=f'{mm_name} Fit')\n", + " r2 = ax2.fill_between(t_test, y_model[i] - ye_model[i], y_model[i] + ye_model[i], color=f'C{i%10}', alpha=0.3, label='Model Uncertainty')\n", + " ax1.set_xlabel('Time')\n", + " ax1.set_ylabel('X Position')\n", + " ax1.set_title(f'{mm_name} Motion Model Fit')\n", + " ax1.legend(\n", + " [l0, (l1, l2)], \n", + " ['Data', 'Model Fit'],\n", + " )\n", + " \n", + " ax2.set_xlabel('Time')\n", + " ax2.set_ylabel('Y Position')\n", + " ax2.set_title(f'{mm_name} Motion Model Fit')\n", + " ax2.legend(\n", + " [r0, (r1, r2)], \n", + " ['Data', 'Model Fit'],\n", + " )\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ad03fc67", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_fit(t, x, y, xe, ye, x_model, y_model, xe_model, ye_model, mm.name, t_test)" + ] + }, + { + "cell_type": "markdown", + "id": "98d3e2c4", + "metadata": {}, + "source": [ + "## 1.2. Example: Acceleration Model Fit" + ] + }, + { + "cell_type": "markdown", + "id": "ede486e5", + "metadata": {}, + "source": [ + "Upon further inspection, acceleration model seems to be a better representation of the data" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0a0d9d1f", + "metadata": {}, + "outputs": [], + "source": [ + "mm = Acceleration()\n", + "params, param_errs = mm.fit(t, x, y, xe, ye)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b3d63417", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_model, y_model, xe_model, ye_model = mm.model(t_test, params, param_errs)\n", + "visualize_fit(t, x, y, xe, ye, x_model, y_model, xe_model, ye_model, mm.name, t_test)" + ] + }, + { + "cell_type": "markdown", + "id": "9d1f63b4", + "metadata": {}, + "source": [ + "Moreover, `MotionModel.model` is fully vectorized, and can infer positions of multiple stars at multiple times, and the resulting inferred positions has shape (N_stars, N_times). See the example below:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "d1e406c5", + "metadata": {}, + "outputs": [], + "source": [ + "t = np.array([0, 1., 2.2, 3.5, 5.]) + 2025.0\n", + "\n", + "xs = np.array([\n", + " [0., 0.5, 2.1, 3.2, 8.0],\n", + " [10.0, 8.9, 9.2, 7.4, 7.0],\n", + " [2.5, 6.2, 5.2, 3.2, 5.0]\n", + "])\n", + "\n", + "ys = np.array([\n", + " [10.2, 8.5, 9.1, 10.5, 13.0],\n", + " [8.0, 9.9, 8.2, 7.4, 7.0],\n", + " [5.2, 6.2, 4.7, 3.2, 6.0]\n", + "])\n", + "\n", + "xes = np.array([\n", + " [0.2, 0.5, 0.3, 0.4, 0.6],\n", + " [0.5, 0.2, 0.7, 0.3, 0.2],\n", + " [0.5, 0.7, 0.6, 0.4, 0.3]\n", + "])\n", + "\n", + "yes = np.array([\n", + " [0.3, 0.2, 0.5, 0.2, 0.4],\n", + " [0.2, 0.5, 0.6, 0.4, 0.2],\n", + " [0.4, 0.2, 0.3, 0.4, 0.5]\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "4adebbe8", + "metadata": {}, + "outputs": [], + "source": [ + "params = []\n", + "param_errs = []\n", + "for xi, yi, xei, yei in zip(xs, ys, xes, yes):\n", + " p, pe = mm.fit(t, xi, yi, xei, yei)\n", + " params.append(p)\n", + " param_errs.append(pe)" + ] + }, + { + "cell_type": "markdown", + "id": "4e0424df", + "metadata": {}, + "source": [ + "Once we have the params and param errors, we can infer the model positions at any given time." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "95745baa", + "metadata": {}, + "outputs": [], + "source": [ + "x_model, y_model, xe_model, ye_model = mm.model(t_test, params, param_errs)" + ] + }, + { + "cell_type": "markdown", + "id": "06fdca50", + "metadata": {}, + "source": [ + "The inferred positions should have shape (N_stars, N_times):" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "54206834", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3, 100)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_model.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e6a4e42e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_fit(t, xs, ys, xes, yes, x_model, y_model, xe_model, ye_model, mm.name, t_test)" + ] + }, + { + "cell_type": "markdown", + "id": "f7ae3e7f", + "metadata": {}, + "source": [ + "## 1.3. Example: Parallax Model Fit" + ] + }, + { + "cell_type": "markdown", + "id": "08eceab5", + "metadata": {}, + "source": [ + "Parallax model requires some fixed parameters: `ra`, `dec`, `pa`, `obsLocation`, and `t0`.\n", + "- `ra` and `dec` are required parameters. \n", + "- `pa = 0` by default\n", + "- `obsLocation = 'earth'` by default\n", + "- `t0 = np.average(t, 1./np.hypot(xe, ye))` by default\n", + "\n", + "We need to provide the fixed parameters in the `fixed_params_dict`:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "018fc13a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"dtf2d\" yielded 1 of \"dubious year (Note 6)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"dtf2d\" yielded 2 of \"dubious year (Note 6)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"utctai\" yielded 2 of \"dubious year (Note 3)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"utctai\" yielded 1 of \"dubious year (Note 3)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"taiutc\" yielded 1 of \"dubious year (Note 4)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n" + ] + } + ], + "source": [ + "mm = Parallax()\n", + "fixed_params_dict = {'ra': 0., 'dec': 10., 'pa': 0., 'obsLocation': 'earth'}\n", + "params, param_errs = mm.fit(t, x, y, xe, ye, fixed_params_dict)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "73dafb1f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"dtf2d\" yielded 20 of \"dubious year (Note 6)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"dtf2d\" yielded 40 of \"dubious year (Note 6)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"utctai\" yielded 40 of \"dubious year (Note 3)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"utctai\" yielded 20 of \"dubious year (Note 3)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/home/weilingfeng/Software/miniconda3/envs/main/lib/python3.12/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"taiutc\" yielded 20 of \"dubious year (Note 4)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_model, y_model, xe_model, ye_model = mm.model(t_test, params, param_errs)\n", + "visualize_fit(t, x, y, xe, ye, x_model, y_model, xe_model, ye_model, mm.name, t_test)" + ] + }, + { + "cell_type": "markdown", + "id": "5be8fb7e", + "metadata": {}, + "source": [ + "# 2. Fit Motion Model in StarTable" + ] + }, + { + "cell_type": "markdown", + "id": "3bd8dec7", + "metadata": {}, + "source": [ + "Examples on `flystar.StarTable.fit_motion_model`. Prepare the data with invalid values:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "aa698e86", + "metadata": {}, + "outputs": [], + "source": [ + "t = np.array([0, 1., 2.2, 3.5, 5.]) + 2025.0\n", + "\n", + "x = np.array([\n", + " [0., 0.5, 2.1, 3.2, 8.0], # Increasing 5 Epochs\n", + " [10.0, 8.9, 9.2, 7.4, 7.0], # Decreasing 5 Epochs\n", + " [2.5, np.nan, 5.2, np.nan, 5.0], # 3 Epochs\n", + " [np.nan, 6.2, np.nan, np.nan, 9.2], # 2 Epochs\n", + " [np.nan, 2.0, np.nan, np.nan, np.nan], # 1 Epoch\n", + " [np.nan, np.nan, np.nan, np.nan, np.nan] # All NaNs\n", + "])\n", + "\n", + "y = np.array([\n", + " [10.2, 8.5, 9.1, 10.5, 13.0], # Increasing 5 Epochs\n", + " [8.0, 9.9, 8.2, 7.4, 7.0], # Decreasing 5 Epochs\n", + " [5.2, np.nan, 4.7, np.nan, 6.0], # 3 Epochs\n", + " [np.nan, 1.2, np.nan, np.nan, 3.2], # 2 Epochs\n", + " [np.nan, 2.0, np.nan, np.nan, np.nan], # 1 Epoch\n", + " [np.nan, np.nan, np.nan, np.nan, np.nan] # All NaNs\n", + "])\n", + "\n", + "xe = np.array([\n", + " [0.2, 0.5, 0.3, 0.4, 0.6],\n", + " [0.5, 0.2, 0.7, 0.3, 0.2],\n", + " [0.5, np.nan, 0.6, np.nan, 0.3],\n", + " [np.nan, 0.6, np.nan, np.nan, 0.3],\n", + " [np.nan, 0.4, np.nan, np.nan, np.nan],\n", + " [np.nan, np.nan, np.nan, np.nan, np.nan]\n", + "])\n", + "\n", + "ye = np.array([\n", + " [0.3, 0.2, 0.5, 0.2, 0.4],\n", + " [0.2, 0.5, 0.6, 0.4, 0.2],\n", + " [0.7, np.nan, 0.5, np.nan, 0.2],\n", + " [np.nan, 0.4, np.nan, np.nan, 0.5],\n", + " [np.nan, 0.5, np.nan, np.nan, np.nan],\n", + " [np.nan, np.nan, np.nan, np.nan, np.nan]\n", + "])\n", + "\n", + "x = np.ma.masked_invalid(x)\n", + "y = np.ma.masked_invalid(y)\n", + "xe = np.ma.masked_invalid(xe)\n", + "ye = np.ma.masked_invalid(ye)\n", + "mask = np.ma.getmaskarray(x) | np.ma.getmaskarray(y) | np.ma.getmaskarray(xe) | np.ma.getmaskarray(ye)\n", + "\n", + "tab = StarTable({\n", + " 'x': x,\n", + " 'y': y,\n", + " 'xe': xe,\n", + " 'ye': ye\n", + "})\n", + "tab.meta['list_times'] = t" + ] + }, + { + "cell_type": "markdown", + "id": "9201897f", + "metadata": {}, + "source": [ + "There are a 2 ways to specify the desired motion models:\n", + "1. Let MotionModel automatically determine which motion model to use among the given `motion_models` list based on the number of valid observations. MotionModel will choose the motion model that has enough observations, i.e. $n_\\text{fit} \\geq n_\\text{params}$. \n", + "2. Specify a motion model for each star in the `motion_model_input` column. In case there is not enough observations, MotionModel will \"downgrade\" to a model with less parameters until $n_\\text{fit} \\geq n_\\text{params}$ among all the unique motion models specified in the column.\n", + "\n", + "Note that when `absolute_sigma=False` and `n_fit == n_params`, we don't have enough degree of freedom to rescale the uncertainties, so the uncertainties will be set to infinity -- the same behavior as `scipy.optimize.curve_fit`.
By default `motion_models = [Empty, Fixed, Linear]`. `Empty` and `Fixed` will always be added in the list to handle 0 and 1 point cases. See examples below for details. Let's start with the most basic usage." + ] + }, + { + "cell_type": "markdown", + "id": "e58f429d", + "metadata": {}, + "source": [ + "## 2.1. Example: Default Fitting" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "02642d3b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Empty: 0%| | 0/1 [00:00StarTable length=6\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
n_fitn_requiredmotion_model_used
int64int64str20
52Linear
52Linear
32Linear
22Linear
12Fixed
02Empty
" + ], + "text/plain": [ + "\n", + "n_fit n_required motion_model_used\n", + "int64 int64 str20 \n", + "----- ---------- -----------------\n", + " 5 2 Linear\n", + " 5 2 Linear\n", + " 3 2 Linear\n", + " 2 2 Linear\n", + " 1 2 Fixed\n", + " 0 2 Empty" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tab['n_required'] = 2\n", + "tab[['n_fit', 'n_required', 'motion_model_used']]" + ] + }, + { + "cell_type": "markdown", + "id": "20470c6e", + "metadata": {}, + "source": [ + "Next, let's try `absolute_sigma=False`. As mentioned above, we don't have enough degree of freedom to rescale the uncertainties for the forth star. In this case, the parameter uncertainties will be set to infinity, which is the same behavior as `scipy.optimize.curve_fit`. The same `OptmizieWarning` as in `scipy` will be raised." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "26b11593", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Empty: 0%| | 0/1 [00:00\n", + "0.2398025689409276\n", + "0.07197698078673948\n", + "0.26723109004421475\n", + "inf\n", + "inf\n", + "inf\n", + "" + ], + "text/plain": [ + "\n", + " 0.2398025689409276\n", + "0.07197698078673948\n", + "0.26723109004421475\n", + " inf\n", + " inf\n", + " inf" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tab['vx_err']" + ] + }, + { + "cell_type": "markdown", + "id": "241ab6d6", + "metadata": {}, + "source": [ + "## 2.2. Example: Specify Motion Models" + ] + }, + { + "cell_type": "markdown", + "id": "220922c5", + "metadata": {}, + "source": [ + "Alternatively, one can specify a list of motion models to use, and the function will also automatically determine which model to use for each star depending on the valid observed epochs. In the following example, we specify `Acceleration` model, but **the function will always implicitly add `Empty` and `Fixed`** to handle the 0 or 1 epoch stars." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "a596c8e8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Acceleration: 0%| | 0/3 [00:00StarTable length=6\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
n_fitmotion_model_used
int64str20
5Acceleration
5Acceleration
3Acceleration
2Fixed
1Fixed
0Empty
" + ], + "text/plain": [ + "\n", + "n_fit motion_model_used\n", + "int64 str20 \n", + "----- -----------------\n", + " 5 Acceleration\n", + " 5 Acceleration\n", + " 3 Acceleration\n", + " 2 Fixed\n", + " 1 Fixed\n", + " 0 Empty" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tab[['n_fit', 'motion_model_used']]" + ] + }, + { + "cell_type": "markdown", + "id": "188290a9", + "metadata": {}, + "source": [ + "## 2.3. Example: Specify the `motion_model_input` Column" + ] + }, + { + "cell_type": "markdown", + "id": "99624463", + "metadata": {}, + "source": [ + "One can also specify a motion model for each star as a column in the star table. However, the function will \"downgrade\" the model to one with fewer parameters until $n_\\text{fit} \\geq n_\\text{params}$:" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "04db5f9e", + "metadata": {}, + "outputs": [], + "source": [ + "ra = np.zeros(len(x))\n", + "dec = np.zeros(len(x))\n", + "pa = np.zeros(len(x))\n", + "\n", + "motion_model_input = [\n", + " 'Acceleration', # Will use Acceleration\n", + " 'Parallax', # Will use Parallax\n", + " 'Linear', # Will use Linear\n", + " 'Acceleration', # Will use Linear, as n_fit = 2 < 3\n", + " 'Linear', # Will use Fixed, as n_fit = 1 < 2\n", + " 'Fixed' # Will use Empty, as n_fit = 0 < 1\n", + "]\n", + "tab = StarTable({\n", + " 'x': x,\n", + " 'y': y,\n", + " 'xe': xe,\n", + " 'ye': ye,\n", + " 'ra': ra,\n", + " 'dec': dec,\n", + " 'pa': pa,\n", + " 'motion_model_input': motion_model_input\n", + "})\n", + "tab.meta['list_times'] = t" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "2b61fbcf", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Acceleration: 0%| | 0/1 [00:00StarTable length=6\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
n_fitn_requiredmotion_model_inputmotion_model_used
int64int64str12str12
53AccelerationAcceleration
53ParallaxParallax
32LinearLinear
23AccelerationLinear
12LinearFixed
01FixedEmpty
" + ], + "text/plain": [ + "\n", + "n_fit n_required motion_model_input motion_model_used\n", + "int64 int64 str12 str12 \n", + "----- ---------- ------------------ -----------------\n", + " 5 3 Acceleration Acceleration\n", + " 5 3 Parallax Parallax\n", + " 3 2 Linear Linear\n", + " 2 3 Acceleration Linear\n", + " 1 2 Linear Fixed\n", + " 0 1 Fixed Empty" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_mm_map = motion_model.motion_model_map()\n", + "tab['n_required'] = np.array([all_mm_map[mm].n_params for mm in tab['motion_model_input']], dtype=int)\n", + "tab[['n_fit', 'n_required', 'motion_model_input', 'motion_model_used']]" + ] + }, + { + "cell_type": "markdown", + "id": "d4f96fcb", + "metadata": {}, + "source": [ + "## 2.4. Example: Infer Positions" + ] + }, + { + "cell_type": "markdown", + "id": "c660ec98", + "metadata": {}, + "source": [ + "Continuing from the previous example: Once we fit the motion models and the parameters are added into the table, we can infer the positions at arbitrary times with `StarTable.infer_positions`" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "095be28f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/weilingfeng/Software/miniconda3/envs/main/lib/python3.13/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"dtf2d\" yielded 20 of \"dubious year (Note 6)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/Users/weilingfeng/Software/miniconda3/envs/main/lib/python3.13/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"dtf2d\" yielded 40 of \"dubious year (Note 6)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/Users/weilingfeng/Software/miniconda3/envs/main/lib/python3.13/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"utctai\" yielded 40 of \"dubious year (Note 3)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/Users/weilingfeng/Software/miniconda3/envs/main/lib/python3.13/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"utctai\" yielded 20 of \"dubious year (Note 3)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n", + "/Users/weilingfeng/Software/miniconda3/envs/main/lib/python3.13/site-packages/erfa/core.py:133: ErfaWarning: ERFA function \"taiutc\" yielded 20 of \"dubious year (Note 4)\"\n", + " warn(f'ERFA function \"{func_name}\" yielded {wmsg}', ErfaWarning)\n" + ] + } + ], + "source": [ + "x_model, y_model, xe_model, ye_model = tab.infer_positions(t_test)" + ] + }, + { + "cell_type": "markdown", + "id": "a4df5458", + "metadata": {}, + "source": [ + "As in `MotionModel.model`, `StarTable.infer_positions` is also vectorized and returns positions and uncertainties in shapes of $(N_\\text{stars}, N_\\text{times})$" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "2f7e8b7a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(6, 100)" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_model.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "7aab0868", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "visualize_fit(t, x, y, xe, ye, x_model, y_model, xe_model, ye_model, mm.name, t_test)" + ] + }, + { + "cell_type": "markdown", + "id": "12bb0136", + "metadata": {}, + "source": [ + "## 2.5. Speed Test" + ] + }, + { + "cell_type": "markdown", + "id": "43fd87c5", + "metadata": {}, + "source": [ + "Speed test for the most commonly used Linear model. As the `use_scipy=False` option for the Linear model uses the [matrix multiplication solution](https://en.wikipedia.org/wiki/Weighted_least_squares#Solution), it is extremely fast at fewer epochs: " + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "de576a47", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 10 epochs...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:01<00:00, 6350.75it/s]\n", + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:00<00:00, 25802.05it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 31 epochs...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:01<00:00, 6184.77it/s]\n", + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:00<00:00, 23908.79it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 100 epochs...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:01<00:00, 6347.19it/s]\n", + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:00<00:00, 14309.49it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 316 epochs...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:01<00:00, 5023.37it/s]\n", + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:03<00:00, 3288.47it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 1000 epochs...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fitting motion model Linear: 100%|██████████| 10000/10000 [00:02<00:00, 4314.91it/s]\n", + "Fitting motion model Linear: 100%|██████████| 10000/10000 [01:19<00:00, 125.47it/s]\n" + ] + } + ], + "source": [ + "import time\n", + "N = 10000\n", + "dims = np.logspace(1, 3, 5, dtype=int)\n", + "rng = np.random.default_rng(42)\n", + "\n", + "scipy_times = []\n", + "analytic_times = []\n", + "\n", + "for dim in dims:\n", + " print(f'Fitting {dim} epochs...')\n", + " t = np.linspace(2025.0, 2030.0, dim)\n", + " x = rng.random((N, dim))\n", + " y = rng.random((N, dim))\n", + " xe = rng.uniform(0, 0.2, size=(N, dim))\n", + " ye = rng.uniform(0, 0.2, size=(N, dim))\n", + " tab = StarTable({\n", + " 'x': x,\n", + " 'y': y,\n", + " 'xe': xe,\n", + " 'ye': ye\n", + " })\n", + " tab.meta['list_times'] = t\n", + " \n", + " start = time.time()\n", + " tab.fit_motion_model(use_scipy=True)\n", + " end = time.time()\n", + " scipy_times.append(end - start)\n", + " \n", + " start = time.time()\n", + " tab.fit_motion_model(use_scipy=False)\n", + " end = time.time()\n", + " analytic_times.append(end - start)\n", + "\n", + "scipy_times = np.array(scipy_times)\n", + "analytic_times = np.array(analytic_times)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "3d2a8457", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "280" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Collect memory garbage data\n", + "import gc\n", + "gc.collect()" + ] + }, + { + "cell_type": "markdown", + "id": "06442faf", + "metadata": {}, + "source": [ + "Let's visualize the performance:" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "03d53769", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.plot(dims, N / scipy_times, marker='o', label='Scipy Curve Fit')\n", + "ax.plot(dims, N / analytic_times, marker='o', color='C3', label='Motion Model Analytic')\n", + "ax.set_xscale('log')\n", + "ax.set_xlabel('Number of Epochs')\n", + "ax.set_ylabel('Stars Fit per Second')\n", + "ax.set_title(f'Motion Model Fitting Performance of {N} Stars')\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ea672ab4", + "metadata": {}, + "source": [ + "It can be seen that for epochs < 200, the analytic solution is faster than scipy, and vice versa for > 300 epochs." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "main", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/flystar/align.py b/flystar/align.py index 35156a2..2101663 100755 --- a/flystar/align.py +++ b/flystar/align.py @@ -1,41 +1,64 @@ -import numpy as np -from flystar import match -from flystar import transforms -from flystar import plots -from flystar.starlists import StarList -from flystar.startables import StarTable -from astropy.table import Table, Column, vstack -import datetime -import copy import os +import gc import pdb +import copy import time +import pickle import warnings +import datetime +import numpy as np +import matplotlib.pyplot as plt +from tqdm import tqdm +from multiprocessing import Pool +from . import match, transforms, plots, motion_model +from .starlists import StarList +from .startables import StarTable +from .motion_model import Empty, Fixed +from astropy.table import Table, Column, vstack from astropy.utils.exceptions import AstropyUserWarning -# Keep a list of columns that are "aggregated" motion model terms. -motion_model_col_names = ['x0', 'x0e', 'y0', 'y0e', - 'vx', 'vxe', 'vy', 'vye', - 'ax', 'axe', 'ay', 'aye', - 't0', 'm0', 'm0e', 'use_in_trans'] class MosaicSelfRef(object): - def __init__(self, list_of_starlists, ref_index=0, iters=2, - dr_tol=[1, 1], dm_tol=[2, 1], - outlier_tol=[None, None], - trans_args=[{'order': 2}, {'order': 2}], - init_order=1, - mag_trans=True, mag_lim=None, weights=None, - trans_input=None, trans_class=transforms.PolyTransform, - use_vel=False, calc_trans_inverse=False, - init_guess_mode='miracle', iter_callback=None, - verbose=True): - + def __init__( + self, + list_of_starlists, + starlist_vertices=None, + # Alignment parameters + ref_index=0, + iters=2, + dr_tol=[1, 1], + dm_tol=[2, 1], + outlier_tol=None, + # Transformation parameters + trans_class=transforms.PolyTransform, + trans_args=[{'order': 2}, {'order': 2}], + trans_input=None, + trans_weights=None, + init_order=1, + init_guess_mode='miracle', + briteN=None, + calc_trans_inverse=False, + # Magnitude parameters + mag_trans=True, + mag_lim=None, + # Motion model parameters + motion_models=['Empty', 'Fixed'], + fixed_params_dict=None, + vel_weights='var', + use_scipy=True, + absolute_sigma=True, + scipy_method=None, + # Advanced options + iter_callback=None, + save_path=None, + prefix_name='msr', + verbose=True + ): """ - Make a mosaic object by passing in a list of starlists and then running fit(). + Make a mosaic object by passing in a list of starlists and then running fit(). Required Parameters - ---------- + ------------------- list_of_starlists : array of StarList objects An array or list of flystar.starlists.StarList objects (which are Astropy Tables). There should be one for each starlist and they must contain 'x', 'y', and 'm' columns. @@ -43,25 +66,28 @@ def __init__(self, list_of_starlists, ref_index=0, iters=2, Note that there is an optional weights column called 'w'. If this column exists in any of the lists, it will be queried to determine if an individual star can be used to derive the transformations between starlists. This is the most flexible way - to allow you to determine, as a function of time and star, which ones are good enough - in the transformation. Note that just because it can be used (i.e. w_in=1), - doesn't meant that it will be used. The mag limits and outliers still take precedence. - Note also that the weights that go into the transformation are + to allow you to determine, as a function of time and star, which ones are good enough + in the transformation. Note that just because it can be used (i.e. w_in=1), + doesn't meant that it will be used. The mag limits and outliers still take precedence. + Note also that the weights that go into the transformation are star_list['w'] * ref_list['w'] * weight_from_keyword (see the weights parameter) - for those stars not trimmed out by the other criteria. - + for those stars not trimmed out by the other criteria. Optional Parameters - ---------- + ------------------- + starlist_vertices : list or array + A list or array of polygon vertices coordinates for each starlist. Initial guess will only use stars in overlapping regions defined by these polygons. + Shape of (N_lists, N_vertices, 2) in the format of [[x1, y1], [x2, y2], ..., [xN, yN]] for each starlist, by default None + ref_index : int The index of the reference epoch. (default = 0). Note that this is the reference - list only for the first iteration. Subsequent iterations will utilize the sigma-clipped - mean of the positions from all the starlists. + list only for the first iteration. Subsequent iterations will utilize the sigma-clipped + mean of the positions from all the starlists. iters : int - The number of iterations used in the matching and transformation. TO DO: INNER/OUTER? + The number of iterations used in the matching and transformation. TO DO: INNER/OUTER? dr_tol : list or array The delta-radius (dr) tolerance for matching in units of the reference coordinate system. @@ -69,130 +95,212 @@ def __init__(self, list_of_starlists, ref_index=0, iters=2, dm_tol : list or array The delta-magnitude (dm) tolerance for matching in units of the reference coordinate system. - This is a list of dm values, one for each iteration of matching/transformation. + This is a list of dm values, one for each iteration of matching/transformation. outlier_tol : list or array - The outlier tolerance (in units of sigma) for rejecting outlier stars. + The outlier tolerance (in units of sigma) for rejecting outlier stars. This is a list of tol values, one for each iteration of matching/transformation. + If not provided, will be None for each iteration. - mag_trans : boolean - If true, this will also calculate and (temporarily) apply a zeropoint offset to - magnitudes in each list to bring them into a common magnitude system. This is - essential for matching (with finite dm_tol) starlists of different filters or - starlists that are not photometrically calibrated. Note that the final_table columns - of 'm', 'm0', and 'm0e' will contain the transformed magnitudes while the - final_table column 'm_orig' will contain the original un-transformed magnitudes. - If mag_trans = False, then no such zeropoint offset it applied at any point. + trans_class : transforms.Transform2D object (or subclass) + The transform class that will be used to when deriving the optimal + transformation parameters between each list and the reference list. - mag_lim : array - If different from None, it indicates the minimum and maximum magnitude - on the catalogs for finding the transformations. Note, if you want specify the mag_lim - separately for each list and each iteration, you need to pass in a 2D array that - has shape (N_lists, 2). + trans_args : dictionary + A dictionary (or a list of dictionaries) containing any extra keywords that are needed + in the transformation object. For instance, "order". Note that if a list is passed in, + then the transformation argument (i.e. order) will be changed for every iteration in + iters. + + trans_input : array or list of transform objects + def = None. If not None, then this should contain an array or list of transform + objects that will be used as the initial guess in the alignment and matching. - weights : str + trans_weights : str Either None (def), 'both,var', 'list,var', or 'ref,var' depending on whether you want to weight by the positional uncertainties (variances) in the individual starlists, or also with the uncertainties in the reference frame itself. Note weighting only works when there are positional uncertainties availabe. Other options include 'both,std', 'list,std', 'list,var'. - trans_input : array or list of transform objects - def = None. If not None, then this should contain an array or list of transform - objects that will be used as the initial guess in the alignment and matching. - - trans_class : transforms.Transform2D object (or subclass) - The transform class that will be used to when deriving the optimal - transformation parameters between each list and the reference list. + init_order : int + The order of the initial transformation used for the first iteration. - trans_args : dictionary - A dictionary (or a list of dictionaries) containing any extra keywords that are needed - in the transformation object. For instance, "order". Note that if a list is passed in, - then the transformation argument (i.e. order) will be changed for every iteration in - iters. + init_guess_mode : string + If no initial transformations are passed in via the trans_input keyword, then we have + to make the initial transformation and matching blindly. We can do this in a couple of + different ways. Options are 'miracle' or 'name' (see trans_initial_guess() for more details). - use_vel : boolean - If velocities are present in the reference list and use_vel == True, then during - each iteration of the alignment, the reference list will be propogated in time - using the velocity information. So all transformations will be derived w.r.t. - the propogated positions. See also update_vel. + briteN : int + If init_guess_mode is 'miracle', this is the number of brightest stars to use in the miracle match. + Default is min(50, len(star_list)). - calc_trans_inverse: boolean + calc_trans_inverse: boolean If true, then calculate the inverse transformation (from reference to starlist) in addition to the normal transformation (from starlist to reference). The inverse calculation is calculated by switching the order to the positions in match_and_transform. The inverse transformations are saved in self.trans_list_inverse. - self.trans_list_inverse doesn't exist if calc_trans_inverse == False - init_guess_mode : string - If no initial transformations are passed in via the trans_input keyword, then we have - to make the initial transformation and matching blindly. We can do this in a couple of - different ways. Options are 'miracle' or 'name' (see trans_initial_guess() for more details). + mag_trans : boolean + If true, this will also calculate and (temporarily) apply a zeropoint offset to + magnitudes in each list to bring them into a common magnitude system. This is + essential for matching (with finite dm_tol) starlists of different filters or + starlists that are not photometrically calibrated. Note that the final_table columns + of 'm', 'm0', and 'm0_err' will contain the transformed magnitudes while the + final_table column 'm_orig' will contain the original un-transformed magnitudes. + If mag_trans = False, then no such zeropoint offset it applied at any point. + + mag_lim : array + If different from None, it indicates the minimum and maximum magnitude + on the starlists for finding the transformations BEFORE mag trans. + Note, if you want specify the mag_lim separately for each list, + you need to pass in a 2D array that has shape (N_lists, 2). + + motion_models : list of MotionModel or str, optional + Motion models or their names to use for new or unassigned stars + + motion_model_for_new_star : str or MotionModel, optional + Motion model or its name for newly added stars in the ref table. Used in add_rows_for_new_stars(). + If None, the most complex motion model in motion_models will be used, by default None. + + fixed_params_dict : None or dict + Dictionary of motion model fixed parameters, e.g., ra, dec, pa, obsLocation, t0, etc. See motion_model classes for details. + + vel_weights : str + Either 'var' (def) or 'std', depending on whether you want to weight the motion model + fits by the variance or standard deviation of the position data + + use_scipy : bool, optional + If True, use scipy.optimize.curve_fit for velocity fitting. If False, use linear + algebra fitting of posible, by default True. + + absolute_sigma : bool, optional + If True, the velocity fit will use absolute errors in the data. If False, relative + errors will be used, by default False. + + scipy_method : str, optional + Method of scipy.curve_fit, {'lm', 'trf', 'dogbox'}, by default None iter_callback : None or function A function to call (that accepts a StarTable object and an iteration number) - at the end of every iteration. This can be used for plotting or printing state. + at the end of every iteration. This can be used for plotting or printing state. + + save_path : str, optional + Path to save the MosaicSelfRef object as a pickle file. - verbose : int (0 to 9, inclusive) + prefix_name : str, optional + Prefix for the file names, including PREFIX_input.log, PREFIX.pkl, PREFIX_ref_table.fits. + + verbose : bool or int (0 to 9, inclusive) Controls the verbosity of print statements. (0 least, 9 most verbose). For backwards compatibility, 0 = False, 9 = True. (Note: technically right now no checks on whether the number is an integer or not...) Example - ---------- - msc = align.MosaicToRef(list_of_starlists, iters=1, + ------- + mtr = align.MosaicToRef(list_of_starlists, iters=1, dr_tol=[0.1], dm_tol=[5], outlier_tol=[None], mag_lim=[13, 21], trans_class=transforms.PolyTransform, trans_args=[{'order': 1}], weights='both,std', init_guess_mode='miracle', verbose=False) - msc.fit() + mtr.fit() # Access a list of all the transformation parameters: - trans_list = msc.trans_list + trans_list = mtr.trans_list # Access the fully-combined reference table. - stars_table = msc.ref_table + stars_table = mtr.ref_table # Plot the magnitude of the first star vs. time: - # Overplot the mean magnitude. + # Overplot the mean magnitude. plt.plot(stars_table['t'][0, :], stars_table['m'][0, :], 'k.') - plt.axhline(stars_table['m0'][0]) + plt.axhline(stars_table['m0'][0]) # Plot the X position of the first star vs. time: # Overplot the best-fit proper motion. times = stars_table['t'][0, :] plt.errorbar(times, stars_table['x'][0, :], yerr=stars_table['xe'][0, :]) - plt.axhline(stars_table['x0'][0] + stars_table['vx'][0]*(times - stars_table['t0'][0])) - + plt.axhline(stars_table['x0'][0] + stars_table['vx'][0]*(times - stars_table['t0'][0])) """ + dr_tol = np.atleast_1d(dr_tol) + dm_tol = np.atleast_1d(dm_tol) + self.iters = len(dr_tol) + if dm_tol is not None: + assert self.iters == len(dm_tol), f'dr_tol (len={self.iters}) and dm_tol (len={len(dm_tol)}) must all have the same length!' + if outlier_tol is not None: + assert self.iters == len(outlier_tol), f'dr_tol (len={self.iters}) and outlier_tol (len={len(outlier_tol)}) must all have the same length!' self.star_lists = list_of_starlists + self.starlist_vertices = starlist_vertices self.ref_index = ref_index - self.iters = iters self.dr_tol = dr_tol self.dm_tol = dm_tol - self.outlier_tol = outlier_tol self.trans_args = trans_args self.init_order = init_order self.mag_trans = mag_trans self.mag_lim = mag_lim - self.weights = weights + self.trans_weighting = trans_weights + self.vel_weighting = vel_weights self.trans_input = trans_input self.trans_class = trans_class - self.calc_trans_inverse = calc_trans_inverse - self.use_vel = use_vel + self.calc_trans_inverse = calc_trans_inverse + self.use_scipy = use_scipy + self.absolute_sigma = absolute_sigma + self.scipy_method = scipy_method + self.fixed_params_dict = fixed_params_dict self.init_guess_mode = init_guess_mode + self.briteN = briteN self.iter_callback = iter_callback + self.save_path = save_path + self.prefix_name = prefix_name self.verbose = verbose + if self.starlist_vertices is not None: + import shapely + self.reflist_polygon = shapely.make_valid(shapely.Polygon(self.starlist_vertices[self.ref_index])) + else: + self.reflist_polygon = None + + # Check x and y are 1d + for ii in range(len(self.star_lists)): + if self.star_lists[ii]['x'].ndim != 1 or self.star_lists[ii]['y'].ndim != 1: + raise ValueError(f"StarList at index {ii} has x and y that are not 1D. x.ndim={self.star_lists[ii]['x'].ndim}, y.ndim={self.star_lists[ii]['y'].ndim}. Please flatten these columns to be 1D.") + + if outlier_tol is None: + self.outlier_tol = [None] * self.iters + else: + self.outlier_tol = outlier_tol + + all_mm_map = motion_model.motion_model_map() + if all(isinstance(mm, str) for mm in motion_models): + assert all(mm in all_mm_map.keys() for mm in motion_models), f"All motion model names must be in {list(all_mm_map.keys())}" + mm_names = motion_models + motion_models = [all_mm_map[mm] for mm in motion_models] + else: + mm_names = [mm.name for mm in motion_models] + if 'Empty' not in mm_names: + motion_models.append(all_mm_map['Empty']) + if 'Fixed' not in mm_names: + motion_models.append(all_mm_map['Fixed']) + + # Sort by increasing n_params + motion_models = sorted(motion_models, key=lambda mm: mm.n_params) + self.motion_models = motion_models + + # if motion_model_for_new_star is None: + # self.motion_model_for_new_star = self.motion_models[-1] + # elif isinstance(motion_model_for_new_star, str): + # assert motion_model_for_new_star in all_mm_map.keys(), f"motion_model_for_new_star must be in {list(all_mm_map.keys())}" + # self.motion_model_for_new_star = all_mm_map[motion_model_for_new_star] + # For backwards compatibility. - if self.verbose is True: - self.verbose = 9 - if self.verbose is False: - self.verbose = 0 - + # if self.verbose is True: + # self.verbose = 9 + # if self.verbose is False: + # self.verbose = 0 + self.N_lists = len(self.star_lists) # Hard-coded values: @@ -203,7 +311,6 @@ def = None. If not None, then this should contain an array or list of transform # Error checking for parameters. ########## self.fix_iterable_conditions() # fix dr_tol, dm_tol, outlier_tol, mag_lim to be iterable. - check_iter_tolerances(self.iters, self.dr_tol, self.dm_tol, self.outlier_tol) check_trans_input(self.star_lists, self.trans_input, self.mag_trans) ########## @@ -214,41 +321,40 @@ def = None. If not None, then this should contain an array or list of transform # is passed in, replicate for all star lists, all loop iterations. ########## self.setup_trans_info() - return def fix_iterable_conditions(self): if not np.iterable(self.dr_tol): self.dr_tol = np.repeat(self.dr_tol, self.iters) - assert len(self.dr_tol) == self.iters + assert len(self.dr_tol) == self.iters, f'len(dr_tol)={len(self.dr_tol)} != iters={self.iters}' if not np.iterable(self.dm_tol): self.dm_tol = np.repeat(self.dm_tol, self.iters) - assert len(self.dm_tol) == self.iters + assert len(self.dm_tol) == self.iters, f'len(dm_tol)={len(self.dm_tol)} != iters={self.iters}' if not np.iterable(self.outlier_tol): self.outlier_tol = np.repeat(self.outlier_tol, self.iters) - assert len(self.outlier_tol) == self.iters + assert len(self.outlier_tol) == self.iters, f'len(outlier_tol)={len(self.outlier_tol)} != iters={self.iters}' if self.mag_lim is None: - self.mag_lim = np.repeat([[None, None]], len(self.star_lists), axis=0) - elif (len(self.mag_lim) == 2): + self.mag_lim = np.repeat([None], len(self.star_lists), axis=0) + elif (len(self.mag_lim) == 2) and (np.ndim(self.mag_lim) == 1): self.mag_lim = np.repeat([self.mag_lim], len(self.star_lists), axis=0) assert len(self.mag_lim) == len(self.star_lists) return - - - def fit(self): + + + def fit(self, processes=1, chunksize=None): """ Using the current parameter settings, match and transform all the lists to a reference position. Note in the first pass, the reference position is just the specified input reference starlist. In subsequent iterations, - this is updated. + this is updated. The ultimate outcome is the creation of self.ref_table. This reference table will contain "averaged" quantites as well as a big 2D array of all - the matched original and transformed quantities. + the matched original and transformed quantities. Averaged columns on ref_table: x0 @@ -257,12 +363,54 @@ def fit(self): x0e y0e m0e - vx (only if use_vel=True) - vy (only if use_vel=True) - vxe (only if use_vel=True) - vye (only if use_vel=True) + additional motion_model columns + Parameters + ---------- + processes : int, optional + Number of processes to use for parallel processing, maximum os.cpu_count(), by default 1 (no multiprocessing) + chunksize : int, optional + Chunk size for multiprocessing, by default None (auto) """ + # Setup save_path: + if self.save_path: + if not os.path.exists(os.path.dirname(self.save_path)): + os.makedirs(os.path.dirname(self.save_path)) + + # Save input params + input_filename = f'{self.prefix_name}_input.txt' + input_dict = { + 'ref_index': self.ref_index, + 'iters': self.iters, + 'dr_tol': self.dr_tol, + 'dm_tol': self.dm_tol, + 'outlier_tol': self.outlier_tol, + 'trans_class': self.trans_class, + 'trans_args': self.trans_args, + 'trans_input': self.trans_input, + 'trans_weights': self.trans_weighting, + 'init_order': self.init_order, + 'init_guess_mode': self.init_guess_mode, + 'calc_trans_inverse': self.calc_trans_inverse, + 'mag_trans': self.mag_trans, + 'mag_lim': self.mag_lim, + 'motion_models': self.motion_models, + 'fixed_params_dict': self.fixed_params_dict, + 'vel_weights': self.vel_weighting, + 'use_scipy': self.use_scipy, + 'absolute_sigma': self.absolute_sigma, + 'iter_callback': self.iter_callback, + 'save_path': self.save_path, + 'prefix_name': self.prefix_name, + 'verbose': self.verbose + } + if self.save_path is not None: + if not os.path.exists(self.save_path): + os.makedirs(self.save_path) + with open(os.path.join(self.save_path, input_filename), 'w') as file: + for key, value in input_dict.items(): + file.write(f'{key}:\t{value}\n') + ########## # Setup a reference table to store data. It will contain: # x0, y0, m0 -- the running average of positions: 1D @@ -270,8 +418,9 @@ def fit(self): # x_orig, y_orig, m_orig, (opt. errors) -- the transformed errors for the lists: 2D # w, w_orig (optiona) -- the input and output weights of stars in transform: 2D ########## + if 't0' in self.star_lists[self.ref_index].colnames: self.t0_provided = True + else: self.t0_provided = False self.ref_table = self.setup_ref_table_from_starlist(self.star_lists[self.ref_index]) - # Save the reference index to the meta data on the reference list. self.ref_table.meta['ref_list'] = self.ref_index @@ -281,8 +430,8 @@ def fit(self): # ########## for nn in range(self.iters): - - # If we are on subsequent iterations, remove matching results from the + + # If we are on subsequent iterations, remove matching results from the # prior iteration. This leaves aggregated (1D) columns alone. if nn > 0: self.reset_ref_values() @@ -296,29 +445,37 @@ def fit(self): print("**********") # ALL the action is in here. Match and transform the stack of starlists. - # This updates trans objects and the ref_table. - self.match_and_transform(self.mag_lim[self.ref_index], - self.dr_tol[nn], self.dm_tol[nn], self.outlier_tol[nn], - self.trans_args[nn]) + # This updates trans objects and the ref_table. + self.match_and_transform( + self.mag_lim[self.ref_index], + self.dr_tol[nn], + self.dm_tol[nn], + self.outlier_tol[nn], + self.trans_args[nn], + nn, + processes=processes, + chunksize=chunksize + ) # Clean up the reference table # Find where stars are detected. self.ref_table.detections() ### Drop all stars that have 0 detections. - idx = np.where(self.ref_table['n_detect'] == 0)[0] - print(' *** Getting rid of {0:d} out of {1:d} junk sources'.format(len(idx), len(self.ref_table))) + idx = np.where((self.ref_table['n_detect'] == 0))[0] + if self.verbose: + print(' *** Getting rid of {0:d} out of {1:d} junk sources'.format(len(idx), len(self.ref_table))) self.ref_table.remove_rows(idx) - if self.iter_callback != None: + if self.iter_callback is not None: self.iter_callback(self.ref_table, nn) - + ########## # # Re-do all matching given final transformations. # No trimming this time. - # First rest the reference table 2D values. + # First rest the reference table 2D values. ########## self.reset_ref_values(exclude=['used_in_trans']) @@ -328,49 +485,152 @@ def fit(self): print("**********") self.match_lists(self.dr_tol[-1], self.dm_tol[-1]) - self.update_ref_table_aggregates() + # Hard-coded not to keep ref values for MosaicSelfRef + self.update_ref_table_aggregates(processes=processes, chunksize=chunksize) ########## # Clean up output table. - # + # ########## # Find where stars are detected. if self.verbose > 0: print('') print(' Preparing the reference table...') - + self.ref_table.detections() ### Drop all stars that have 0 detections. - idx = np.where(self.ref_table['n_detect'] == 0)[0] - print(' *** Getting rid of {0:d} out of {1:d} junk sources'.format(len(idx), len(self.ref_table))) + idx = np.where((self.ref_table['n_detect'] == 0))[0] + if self.verbose: + print(f' *** Getting rid of {len(idx):d} out of {len(self.ref_table):d} junk sources') self.ref_table.remove_rows(idx) - if self.iter_callback != None: + if self.iter_callback is not None: self.iter_callback(self.ref_table, nn) - + + # Add times into ref_table meta data + # complete_times = np.array([np.unique(col[~np.isnan(col)])[0] for col in self.ref_table['t'].T]) + all_epochs = get_all_epochs(self.ref_table) + self.ref_table.meta['list_times'] = list(all_epochs) + + # Update chi2 values in ref table, as motion_model_used may have changed + x_inferred, y_inferred, _, _ = self.ref_table.infer_positions(all_epochs) + # Ensure x_inferred and y_inferred is 2D for chi2 calculation + if x_inferred.ndim == 1: + x_inferred = x_inferred[:, np.newaxis] + if y_inferred.ndim == 1: + y_inferred = y_inferred[:, np.newaxis] + weighted_xy = ('xe' in self.ref_table.colnames) and ('ye' in self.ref_table.colnames) + if weighted_xy: + chi2_x_2d = ((self.ref_table['x'] - x_inferred) / self.ref_table['xe'])**2 + chi2_y_2d = ((self.ref_table['y'] - y_inferred) / self.ref_table['ye'])**2 + else: + chi2_x_2d = (self.ref_table['x'] - x_inferred)**2 + chi2_y_2d = (self.ref_table['y'] - y_inferred)**2 + chi2_x = np.nansum(chi2_x_2d, axis=1) + chi2_y = np.nansum(chi2_y_2d, axis=1) + chi2_x[~np.isfinite(chi2_x_2d).any(axis=1)] = np.nan + chi2_y[~np.isfinite(chi2_y_2d).any(axis=1)] = np.nan + self.ref_table['chi2_x'] = chi2_x + self.ref_table['chi2_y'] = chi2_y + + # Update t0 and n_fit when no fitting is run because all motion_model_input==Fixed + if ('t0' not in self.ref_table.colnames) or ('n_fit' not in self.ref_table.colnames): + x_data = np.ma.masked_invalid(self.ref_table['x'].data, copy=True) + y_data = np.ma.masked_invalid(self.ref_table['y'].data, copy=True) + if weighted_xy: + xe = self.ref_table['xe'] + ye = self.ref_table['ye'] + xe_data = np.ma.masked_invalid(xe.data, copy=True) + ye_data = np.ma.masked_invalid(ye.data, copy=True) + else: + xe_data = None + ye_data = None + + if (xe_data is not None) and (ye_data is not None): + xe_data.mask[np.isclose(xe_data, 0.)] = True + ye_data.mask[np.isclose(ye_data, 0.)] = True + fill_with_one = np.all(xe_data.mask, axis=1) & np.all(ye_data.mask, axis=1) + xe_data[fill_with_one] = 1. + ye_data[fill_with_one] = 1. + + if np.ndim(x_data) == 1: + x_data = x_data[:, np.newaxis] + if np.ndim(y_data) == 1: + y_data = y_data[:, np.newaxis] + if weighted_xy: + if np.ndim(xe_data) == 1: + xe_data = xe_data[:, np.newaxis] + if np.ndim(ye_data) == 1: + ye_data = ye_data[:, np.newaxis] + + if 't' in self.ref_table.colnames: + t_data = copy.deepcopy(self.ref_table['t'].data) + else: + t_data = copy.deepcopy(np.array(self.ref_table.meta['list_times'])) + t_data = np.broadcast_to(t_data, xe_data.shape) + + # Update t0, adapted from startables.fit_motion_models + if 't0' not in self.ref_table.colnames: + weights = 1. / np.hypot(xe_data, ye_data) if weighted_xy else None + self.ref_table['t0'] = np.average(t_data, axis=1, weights=weights) + + # Update n_fit: unique epochs with valid data + if 'n_fit' not in self.ref_table.colnames: + xy_mask = ~ (x_data.mask | y_data.mask) + if weighted_xy: + xy_mask &= ~ (xe_data.mask | ye_data.mask) + + self.ref_table['n_fit'] = np.array([ + len(set(t_data[i][xy_mask[i]])) + for i in range(len(self.ref_table)) + ]) + + if self.save_path is not None: + filename = f'{self.prefix_name}.pkl' + with open(os.path.join(self.save_path, filename), 'wb') as file: + pickle.dump(self, file) + # Using pickle here because nan in a fits file is auto-converted to a masked value in astropy.io.fits.open() + filename = f'{self.prefix_name}_ref_table.pkl' + with open(os.path.join(self.save_path, filename), 'wb') as file: + pickle.dump(self.ref_table, file) + + if self.verbose > 0: + print('===================================') + print('========== Done with fit ==========') + print('===================================') return - def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_args): + def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_args, nn=None, processes=1, chunksize=None): """ Given some reference list of positions, loop through all the starlists transform and match them. """ + if self.starlist_vertices is not None: + import shapely for ii in range(len(self.star_lists)): if self.verbose > 0: - msg = ' Matching catalog {0} / {1} with {2:d} stars' - msg2 = ' {0:8s} < {1:0.3f}' - print(" ") - print(" **********") - print(msg.format((ii + 1), len(self.star_lists), len(self.star_lists[ii]))) - print(msg2.format('dr', dr_tol)) - print(msg2.format('|dm|', dm_tol)) - print(' outlier tol: ', outlier_tol) - print(' mag_lim: ', self.mag_lim[ii]) - print(" **********") + print() + print(" **********") + if nn is not None: + print(f" Iteration {nn+1} / {self.iters}") + print(f' Matching catalog {ii + 1} / {len(self.star_lists)} with {len(self.star_lists[ii]):d} stars') + print(f' dr < {dr_tol}') + print(f' |dm| < {dm_tol}') + print(f' outlier tol: {outlier_tol}') + print(f' mag_lim: {self.mag_lim[ii]}') + print(" **********") star_list = self.star_lists[ii] - ref_list = self.get_ref_list_from_table(star_list['t'][0]) + + if 't' in star_list.meta: + ref_list = self.get_ref_list_from_table(star_list.meta['t'], processes=processes, chunksize=chunksize) + elif 't' in star_list.colnames: + assert np.unique(star_list['t']).size == 1, f"StarList at index {ii} has multiple unique times in the 't' column. Cannot determine reference list for matching." + ref_list = self.get_ref_list_from_table(star_list['t'][0], processes=processes, chunksize=chunksize) + else: + raise KeyError(f"StarList at index {ii} does not have a 't' column or meta['t'] entry. Cannot determine reference list for matching.") + trans = self.trans_list[ii] # Trim a COPY of the reference and star lists based on magnitude. @@ -379,63 +639,143 @@ def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_ar # star_list_T is trimmed and transformed self.apply_mag_lim_via_use_in_trans(ref_list, ref_mag_lim) star_list_orig_trim = apply_mag_lim(star_list, self.mag_lim[ii]) # trimmed, untransformed copy - star_list_T = apply_mag_lim(star_list, self.mag_lim[ii]) # trimmed, will be transformed copy + star_list_T = copy.deepcopy(star_list_orig_trim) # trimmed, will be transformed copy + + assert len(star_list_orig_trim) > 0, f"No stars remain after applying mag_lim={self.mag_lim[ii]} to star_list at index {ii}. Please check your mag_lim." ### Initial match and transform: 1st order (if we haven't already). if trans is None: # Only use "use_in_trans" reference stars, even for initial guessing. - keepers = np.where(ref_list['use_in_trans'] == True)[0] - - trans = trans_initial_guess(ref_list[keepers], star_list_orig_trim, self.trans_args[0], - mode=self.init_guess_mode, - order=self.init_order, - verbose=self.verbose, - mag_trans=self.mag_trans) + keepers = ref_list['use_in_trans'] + trans = trans_initial_guess( + ref_list=ref_list[keepers], + star_list=star_list_orig_trim, + trans_args=self.trans_args[0], + mode=self.init_guess_mode, + order=self.init_order, + briteN=self.briteN, + polygon_reflist=self.reflist_polygon, + polygon_starlist=shapely.Polygon(self.starlist_vertices[ii]) if self.starlist_vertices is not None else None, + buffer=dr_tol, + motion_models=self.motion_models, + fixed_params_dict=self.fixed_params_dict, + mag_trans=self.mag_trans, + verbose=self.verbose + ) + if np.isnan(trans.px.parameters).any() or np.isnan(trans.py.parameters).any(): + raise ValueError(f"Initial transformation contains NaN parameters. trans.px={trans.px.parameters}, trans.py={trans.py.parameters}.") if self.mag_trans: star_list_T.transform_xym(trans) # trimmed, transformed else: - star_list_T.transform_xy(trans) - + star_list_T.transform_xy(trans) + # Match stars between the transformed, trimmed lists. - idx1, idx2, dr, dm = match.match(star_list_T['x'], star_list_T['y'], star_list_T['m'], - ref_list['x'], ref_list['y'], ref_list['m'], - dr_tol=dr_tol, dm_tol=dm_tol, verbose=self.verbose) + if 'use_in_trans' in ref_list.colnames: + # Only use stars specified by "use_in_trans" column. + use_in_trans = ref_list['use_in_trans'] + idx1, idx2, dr, dm = match.match( + star_list_T['x'], star_list_T['y'], star_list_T['m'], + ref_list['x'][use_in_trans], ref_list['y'][use_in_trans], ref_list['m'][use_in_trans], + dr_tol=dr_tol, dm_tol=dm_tol, verbose=self.verbose + ) + # Restore idx2 to the full reference list indices + idx2 = np.where(use_in_trans)[0][idx2] + + else: + idx1, idx2, dr, dm = match.match( + star_list_T['x'], star_list_T['y'], star_list_T['m'], + ref_list['x'], ref_list['y'], ref_list['m'], + dr_tol=dr_tol, dm_tol=dm_tol, verbose=self.verbose + ) + if self.verbose > 1: print( ' Match 1: Found ', len(idx1), ' matches out of ', len(star_list_T), '. If match count is low, check dr_tol, dm_tol.' ) + # # Plot matched stars + # unmatched_starlist = np.array([True if i not in idx1 else False for i in range(len(star_list_T))]) + # unmatched_ref = np.array([True if i not in idx2 else False for i in range(len(ref_list))]) + # use_in_trans = ref_list[idx2]['use_in_trans'] + + # fig = go.Figure() + # plotly_stars( + # x=star_list_T['x'][unmatched_starlist], + # y=star_list_T['y'][unmatched_starlist], + # m=star_list_T['m'][unmatched_starlist], + # star_name=star_list_T['name'][unmatched_starlist], + # label='Unmatched Star List', + # color='C9', + # fig=fig + # ) + # plotly_stars( + # x=star_list_T['x'][idx1], + # y=star_list_T['y'][idx1], + # m=star_list_T['m'][idx1], + # label='Matched Star List', + # color='C0', + # fig=fig + # ) + # plotly_stars( + # x=ref_list['x'][idx2][~use_in_trans], + # y=ref_list['y'][idx2][~use_in_trans], + # m=ref_list['m'][idx2][~use_in_trans], + # label='Matched ref (use_in_trans=False)', + # color='C4', + # fig=fig + # ) + # plotly_stars( + # x=ref_list['x'][unmatched_ref & ref_list['use_in_trans']], + # y=ref_list['y'][unmatched_ref & ref_list['use_in_trans']], + # m=ref_list['m'][unmatched_ref & ref_list['use_in_trans']], + # star_name=ref_list['name'][unmatched_ref & ref_list['use_in_trans']], + # label='Unmatched ref (use_in_trans=True)', + # symbol='star-open', + # marker_size=5, + # color='C3', + # fig=fig + # ) + # plotly_stars( + # x=ref_list['x'][idx2][use_in_trans], + # y=ref_list['y'][idx2][use_in_trans], + # m=ref_list['m'][idx2][use_in_trans], + # label='Matched ref (use_in_trans=True)', + # symbol='star', + # marker_size=5, + # color='C3', + # fig=fig + # ) + # fig.update_layout( + # title=f'Matched Stars - Catalog {ii + 1}', + # xaxis_title='X', + # yaxis_title='Y' + # ) + # fig.write_html(os.path.join(self.save_path, f'matched_stars_{ii + 1}.html')) + # fig.show() + + # Outlier rejection - if outlier_tol != None: - keepers = self.outlier_rejection_indices(star_list_T[idx1], ref_list[idx2], - outlier_tol) + if outlier_tol is not None: + keepers = self.outlier_rejection_indices(star_list_T[idx1], ref_list[idx2], outlier_tol, verbose=self.verbose) if self.verbose > 1: - print( ' Rejected ', len(idx1) - len(keepers), ' outliers.' ) - - idx1 = idx1[keepers] - idx2 = idx2[keepers] + print( ' Rejected ', len(idx1) - sum(keepers), ' outliers.' ) - # Only use stars specified by "use_in_trans" column. - if 'use_in_trans' in ref_list.colnames: - keepers = np.where(ref_list[idx2]['use_in_trans'] == True)[0] - - if self.verbose > 1: - print( ' Rejected ', len(idx1) - len(keepers), ' with use_in_trans=False.' ) - idx1 = idx1[keepers] idx2 = idx2[keepers] # Determine weights in the fit. weight = self.get_weights_for_lists(ref_list[idx2], star_list_T[idx1]) - # Derive the best-fit transformation parameters. + # Derive the best-fit transformation parameters. if self.verbose > 1: print( ' Using ', len(idx1), ' stars in transformation.' ) - trans = self.trans_class.derive_transform(star_list_orig_trim['x'][idx1], star_list_orig_trim['y'][idx1], - ref_list['x'][idx2], ref_list['y'][idx2], - **trans_args, - m=star_list_orig_trim['m'][idx1], mref=ref_list['m'][idx2], - weights=weight, mag_trans=self.mag_trans) + trans = self.trans_class.derive_transform( + star_list_orig_trim['x'][idx1], star_list_orig_trim['y'][idx1], + ref_list['x'][idx2], ref_list['y'][idx2], + **trans_args, + m=star_list_orig_trim['m'][idx1], mref=ref_list['m'][idx2], + weights=weight, mag_trans=self.mag_trans + ) # Save the final transformation. self.trans_list[ii] = trans @@ -444,12 +784,15 @@ def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_ar # NOTE: We will not recalculate weights here if self.calc_trans_inverse: if self.verbose > 1: - print('Doing inverse') - trans_inv = self.trans_class.derive_transform(ref_list['x'][idx2], ref_list['y'][idx2], - star_list_orig_trim['x'][idx1], star_list_orig_trim['y'][idx1], - trans_args['order'], m=ref_list['m'][idx2], - mref=star_list_orig_trim['m'][idx1], weights=weight, - mag_trans=self.mag_trans) + print('Calculating inverse transformation...') + + trans_inv = self.trans_class.derive_transform( + ref_list['x'][idx2], ref_list['y'][idx2], + star_list_orig_trim['x'][idx1], star_list_orig_trim['y'][idx1], + trans_args['order'], m=ref_list['m'][idx2], + mref=star_list_orig_trim['m'][idx1], weights=weight, + mag_trans=self.mag_trans + ) self.trans_list_inverse[ii] = trans_inv # Apply the XY transformation to a new copy of the starlist and @@ -469,7 +812,7 @@ def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_ar ml='m_lis_T', mr='m_ref', dx='dx_mpix', dy='dy_mpix', dm='dm', xo='x_orig', yo='y_orig', mo='m_orig')) - + fmt = '{nr:20s} {n:20s} {xl:9.5f} {xr:9.5f} {yl:9.5f} {yr:9.5f} {ml:6.2f} {mr:6.2f} ' fmt += '{dx:7.2f} {dy:7.2f} {dm:6.2f} {xo:9.5f} {yo:9.5f} {mo:6.2f}' for foo in range(len(idx1)): @@ -479,51 +822,73 @@ def match_and_transform(self, ref_mag_lim, dr_tol, dm_tol, outlier_tol, trans_ar print(fmt.format(nr=star_r['name'], n=star_s['name'], xl=star_t['x'], xr=star_r['x'], yl=star_t['y'], yr=star_r['y'], ml=star_t['m'], mr=star_r['m'], - dx=(star_t['x'] - star_r['x']) * 1e3, + dx=(star_t['x'] - star_r['x']) * 1e3, dy=(star_t['y'] - star_r['y']) * 1e3, dm=(star_t['m'] - star_r['m']), xo=star_s['x'], yo=star_s['y'], mo=star_s['m'])) - - idx_lis, idx_ref, dr, dm = match.match(star_list_T['x'], star_list_T['y'], star_list_T['m'], - ref_list['x'], ref_list['y'], ref_list['m'], - dr_tol=dr_tol, dm_tol=dm_tol, verbose=self.verbose) - + + idx_lis, idx_ref, dr, dm = match.match( + star_list_T['x'], star_list_T['y'], star_list_T['m'], + ref_list['x'], ref_list['y'], ref_list['m'], + dr_tol=dr_tol, dm_tol=dm_tol, verbose=self.verbose + ) + if self.verbose > 1: print( ' Match 2: After trans, found ', len(idx_lis), ' matches out of ', len(star_list_T), '. If match count is low, check dr_tol, dm_tol.' ) ## Make plot, if desired - plots.trans_positions(ref_list, ref_list[idx_ref], star_list_T, star_list_T[idx_lis], - fileName='{0}'.format(star_list_T['t'][0])) - + if self.save_path: + plots.trans_positions(ref_list, ref_list[idx_ref], star_list_T, star_list_T[idx_lis], + save_path=os.path.join(self.save_path, 'plots', f'iter{nn}', f"Transformed_Positions_Starlist_{ii}_t_{star_list_T['t'][0]}.png"), + show_plot=False) ### Update the observed (but transformed) values in the reference table. self.update_ref_table_from_list(star_list, star_list_T, ii, idx_ref, idx_lis, idx2) - + ### Update the "average" values to be used as the reference frame for the next list. - if self.update_ref_orig != 'periter': - self.update_ref_table_aggregates() + keep_ref_orig = (self.update_ref_orig==False) or (self.update_ref_orig=='atend') or (self.update_ref_orig=='periter' and ii<(len(self.star_lists) - 1)) + if keep_ref_orig and ii < (len(self.star_lists) - 1): + keep_orig = self.ref_table['ref_orig'] | (~np.isfinite(self.ref_table['x'][:,ii])) + elif keep_ref_orig: + keep_orig = self.ref_table['ref_orig'] + elif ii < (len(self.star_lists) - 1): + keep_orig = ~np.isfinite(self.ref_table['x'][:,ii]) + else: + keep_orig=None + self.update_ref_table_aggregates(keep_orig=keep_orig, processes=processes, chunksize=chunksize) + + # Update ref list polygon + if self.starlist_vertices is not None: + self.reflist_polygon = shapely.make_valid(self.reflist_polygon.union(shapely.Polygon(self.starlist_vertices[ii]))) # Print out some metrics if self.verbose > 0: msg1 = ' {0:2s} (mean and std) for {1:10s}: {2:8.5f} +/- {3:8.5f}' - print(' Residuals: ') + print(' Residuals: ') print(msg1.format('dr', 'all stars', dr.mean(), dr.std())) - print(msg1.format('dm', 'all stars', dm.mean(), dm.std())) + print(msg1.format('dm', 'all stars', dm.mean(), dm.std())) # ref_list - ref_table # Calculate the residuals just for those used in the transformation used = np.where(self.ref_table['used_in_trans'][:, ii] == True)[0] used_good = used[ np.where(np.isin(used, idx_ref) == True)[0] ] - - dr_u = np.hypot(self.ref_table['x'][used_good, ii] - ref_list['x'][used_good], - self.ref_table['y'][used_good, ii] - ref_list['y'][used_good]) - dm_u = np.abs(self.ref_table['m'][used_good, ii] - ref_list['m'][used_good]) + + dr_u = np.hypot(ref_list['x'][used_good] - self.ref_table['x'][used_good, ii], + ref_list['y'][used_good] - self.ref_table['y'][used_good, ii]) + dm_u = ref_list['m'][used_good] - self.ref_table['m'][used_good, ii] print(msg1.format('dr', 'trans stars', dr_u.mean(), dr_u.std())) print(msg1.format('dm', 'trans stars', dm_u.mean(), dm_u.std())) print(' Used {0:d} trans ref stars.'.format(len(used))) print(' Dropped {0:d} matches after transform.'.format(len(used) - len(used_good))) + gc.collect() # clean up memory after each iteration + # Save ref_table after each iteration + # print(f"Saving self after iteration {ii=}") + # if self.save_path: + # with open(os.path.join(self.save_path, f"{self.prefix_name}_iter.pkl"), 'wb') as file: + # pickle.dump(self, file) + return - + def setup_trans_info(self): """ Setup transformation info into a usable format. @@ -536,9 +901,9 @@ def setup_trans_info(self): trans_args = self.trans_args N_lists = len(self.star_lists) iters = self.iters - + trans_list = [None for ii in range(N_lists)] - if trans_input != None: + if trans_input is not None: trans_list = [trans_input[ii] for ii in range(N_lists)] # Keep a list of trans_args, one for each starlist. If only @@ -552,19 +917,21 @@ def setup_trans_info(self): # Add inverse trans list, if desired if self.calc_trans_inverse: - trans_list_inverse = [None for ii in range(N_lists)] + trans_list_inverse = [None] * N_lists self.trans_list_inverse = trans_list_inverse return def setup_ref_table_from_starlist(self, star_list): - """ + """ Start with the reference list.... this will change and grow over time, so make a copy that we will keep updating. - The reference table will contain one columne for every named + The reference table will contain one column for every named array in the original reference star list. """ col_arrays = {} + + motion_model_col_names = motion_model.all_motion_model_param_names(with_errors=True, with_fixed=True) + ['m0','m0_err','use_in_trans', 'motion_model_input', 'motion_model_used'] for col_name in star_list.colnames: if col_name == 'name': # The "name" column will be 1D; but we will also add a "name_in_list" column. @@ -573,24 +940,22 @@ def setup_ref_table_from_starlist(self, star_list): else: new_col_name = col_name - # Make every column's 2D arrays except "name" and those + # Make every column's 2D arrays per star except "name" and those # columns used for the motion model. if col_name in motion_model_col_names: col_arrays[new_col_name] = star_list[col_name].data else: - new_col_data = np.array([star_list[col_name].data]).T + new_col_data = star_list[col_name].data[:, None] col_arrays[new_col_name] = new_col_data # Use the columns from the ref list to make the ref_table. ref_table = StarTable(**col_arrays) - + # Make new columns to hold original values. These will be copies # of the old columns and will only include x, y, m, xe, ye, me. - # The columns we have already created will hold transformed values. + # The columns we have already created will hold transformed values. trans_col_names = ['x', 'y', 'm', 'xe', 'ye', 'me', 'w'] - for tt in range(len(trans_col_names)): - old_name = trans_col_names[tt] - + for old_name in trans_col_names: if old_name in ref_table.colnames: new_col = ref_table[old_name].copy() new_col.name = old_name + '_orig' @@ -598,104 +963,107 @@ def setup_ref_table_from_starlist(self, star_list): # Make sure ref_table has the necessary x0, y0, m0 and associated # error columns. If they don't exist, then add them as a copy of - # the original x,y,m etc columns. + # the original x,y,m etc columns. new_cols_arr = ['x0', 'y0', 'm0'] orig_cols_arr = ['x', 'y', 'm'] ref_cols = ref_table.keys() - for ii in range(len(new_cols_arr)): - if not new_cols_arr[ii] in ref_cols: + for new_col, orig_col in zip(new_cols_arr, orig_cols_arr): + if new_col not in ref_cols: # Some munging to convert data shape from (N,1) to (N,), # since these are all 1D cols - vals = np.transpose(np.array(ref_table[orig_cols_arr[ii]]))[0] + vals = np.array(ref_table[orig_col]).flatten() # Now add to ref_table - new_col = Column(vals, name=new_cols_arr[ii]) - ref_table.add_column(new_col) + ref_table.add_column(vals, name=new_col) # Do the same thing for the x0e, y0e, m0e columns, but # ONLY IF THEY ALREADY EXIST IN REF_TABLE! Otherwise, # just fill these tables with zeros. We need something # in these columns in order for the error propagation to # work later on. - new_err_cols = ['x0e', 'y0e', 'm0e'] + new_err_cols = ['x0_err', 'y0_err', 'm0_err'] orig_err_cols = ['xe', 'ye', 'me'] - for ii in range(len(new_err_cols)): + for new_err_col, orig_err_col in zip(new_err_cols, orig_err_cols): # If the orig col name (e.g. xe) is in the ref_table, but the new col name # (e.g. x0e) doesn't exist, then add the x0e column as a duplicate of xe. - if (orig_err_cols[ii] in ref_cols) & (not new_err_cols[ii] in ref_cols): + if (orig_err_col in ref_cols) and (new_err_col not in ref_cols): # Some munging to convert data shape from (N,1) to (N,), # since these are all 1D cols - vals = np.transpose(np.array(ref_table[orig_err_cols[ii]]))[0] - + vals = np.transpose(np.array(ref_table[orig_err_col]))[0] # Now add to ref_table - new_col = Column(vals, name=new_err_cols[ii]) - ref_table.add_column(new_col) - elif (not orig_err_cols[ii] in ref_cols) & (not new_err_cols[ii] in ref_cols): + ref_table.add_column(vals, name=new_err_col) + elif (orig_err_col not in ref_cols) and (new_err_col not in ref_cols): # If neither the orig_err_col or new_err_col is in the ref_table, put in the # new_err_cols as an array of zeros vals = np.zeros(len(ref_table)) - new_col = Column(vals, name=new_err_cols[ii]) - ref_table.add_column(new_col) + ref_table.add_column(vals, name=new_err_col) # Final check: ref_table should now have x0, y0, m0, x0e, y0e, and m0e columns # This is necessary for later steps, even if the columns are just zeros. final_new_cols = np.concatenate((new_cols_arr, new_err_cols)) for ii in final_new_cols: - assert ii in ref_table.keys() - + assert ii in ref_table.keys(), f"ref_table is missing necessary column {ii}." + # Make sure we have a column to indicate whether each star # CAN BE USED in the transformation. This will be 1D if 'use_in_trans' not in ref_table.colnames: - new_col = Column(np.ones(len(ref_table), dtype=bool), name='use_in_trans') - ref_table.add_column(new_col) + ref_table.add_column(np.ones(len(ref_table), dtype=bool), name='use_in_trans') # Make sure we have a column to indicate whether each star # IS USED in the transformation. This will be 2D if 'used_in_trans' not in ref_table.colnames: - new_col = Column(np.zeros([len(ref_table),1], dtype=bool), name='used_in_trans') - ref_table.add_column(new_col) - - # Keep track of whether this is an original reference star. - col_ref_orig = Column(np.ones(len(ref_table), dtype=bool), name='ref_orig') - ref_table.add_column(col_ref_orig) + ref_table.add_column(np.zeros([len(ref_table), 1], dtype=bool), name='used_in_trans') + # Keep track of whether this is an original reference star. + ref_table.add_column(np.ones(len(ref_table), dtype=bool), name='ref_orig') # Now reset the original values to invalids... they will be filled in # at later times. Preserve content only in the columns: name, x0, y0, m0 (and 0e). # Note that these are all the 1D columsn. for col_name in ref_table.colnames: if len(ref_table[col_name].data.shape) == 2: # Find the 2D columns - ref_table._set_invalid_list_values(col_name, -1) + ref_table._set_invalid_list_values(col_name, -1) + + if 'motion_model_input' not in ref_table.colnames: + ref_table.add_column(np.repeat(self.motion_models[-1].name, len(ref_table)), name='motion_model_input') + # FIXME: Why do we need to set motion_model_used here before fitting? + # if 'motion_model_used' not in ref_table.colnames: + # # Order self.motion_models by decreasing n_params + # sorted_mms = sorted(self.motion_models, key=lambda mm: mm.n_params, reverse=True) + # # Save the most complex motion model that can infer the positions with the existing columns. + # for mm in sorted_mms: + # if all([_ in ref_table.colnames for _ in mm.fit_param_names]) and all([_ in ref_table.colnames for _ in mm.fixed_param_names]): + # ref_table.add_column(np.repeat(mm.name, len(ref_table)), name='motion_model_used') + # break return ref_table def apply_mag_lim_via_use_in_trans(self, ref_list, ref_mag_lim): - """Set the use_in_trans flag to False for any star in the - star list that falls beyond the magnitude limits. + """Set the use_in_trans flag to False for any star in the + star list that falls beyond the magnitude limits. This should really only be applied to reference star lists. """ - if ((ref_mag_lim is not None) and (ref_mag_lim[0] is not None)): + if ref_mag_lim is not None: # Support 'm0' (primary) or 'm' column name. if 'm0' in ref_list.colnames: mcol = 'm0' else: mcol = 'm' - no_use = np.where((ref_list[mcol] < ref_mag_lim[0]) | - (ref_list[mcol] >= ref_mag_lim[1])) + no_use = (ref_list[mcol] < ref_mag_lim[0]) | (ref_list[mcol] >= ref_mag_lim[1]) ref_list['use_in_trans'][no_use] = False - + return def outlier_rejection_indices(self, star_list, ref_list, outlier_tol, verbose=True): """ Determine the outliers based on the residual positions between two different - starlists and some threshold (in sigma). Return the indices of the stars - to keep (that shouldn't be rejected as outliers). + starlists and some threshold (in sigma). Return the indices of the stars + to keep (that shouldn't be rejected as outliers). Note that we assume that the star_list and ref_list are already transformed and - matched. + matched. Parameters ---------- @@ -706,8 +1074,8 @@ def outlier_rejection_indices(self, star_list, ref_list, outlier_tol, verbose=Tr starlist with 'x0', 'y0' outlier_tol : float - Number of sigma inside which we keep stars and outside of which we - reject stars as outliers. + Number of sigma inside which we keep stars and outside of which we + reject stars as outliers. Optional Parameters -------------------- @@ -715,8 +1083,8 @@ def outlier_rejection_indices(self, star_list, ref_list, outlier_tol, verbose=Tr Returns ---------- - keepers : nd.array - The indicies of the stars to keep. + keepers : boolean array + The boolean array of the stars to keep. """ # Optionally propogate the reference positions forward in time. xref = ref_list['x'] @@ -728,11 +1096,11 @@ def outlier_rejection_indices(self, star_list, ref_list, outlier_tol, verbose=Tr resid_on_old_trans = np.hypot(x_resid_on_old_trans, y_resid_on_old_trans) threshold = outlier_tol * resid_on_old_trans.std() - keepers = np.where(resid_on_old_trans < threshold)[0] + keepers = resid_on_old_trans < threshold if verbose: msg = ' Outlier Rejection: Keeping {0:d} of {1:d}' - print(msg.format(len(keepers), len(resid_on_old_trans))) + print(msg.format(sum(keepers), len(resid_on_old_trans))) return keepers @@ -741,7 +1109,7 @@ def update_ref_table_from_list(self, star_list, star_list_T, ii, idx_ref, idx_li Inputs ---------- star_list : StarList - The original star list. + The original star list. star_list_T : StarList The original star list now transformed into the reference coordinate system. @@ -756,7 +1124,7 @@ def update_ref_table_from_list(self, star_list, star_list_T, ii, idx_ref, idx_li The indices of the matched targets in the origin starlist (epoch). idx_ref_in_trans : np.array dtype=int - The indices in the reference table (self.ref_table). + The indices in the reference table (self.ref_table). """ ### Update the reference table for matched stars. # Add the matched stars to the reference table. @@ -764,97 +1132,136 @@ def update_ref_table_from_list(self, star_list, star_list_T, ii, idx_ref, idx_li if ((self.ref_table['x'].shape[1] != len(self.star_lists)) and (ii != self.ref_index) and (ii >= self.ref_table['x'].shape[1])): - + self.ref_table.add_starlist() - + copy_over_values(self.ref_table, star_list, star_list_T, ii, idx_ref, idx_lis) self.ref_table['used_in_trans'][idx_ref_in_trans, ii] = True ### Add the unmatched stars and grow the size of the reference table. - self.ref_table, idx_lis_new, idx_ref_new = add_rows_for_new_stars(self.ref_table, star_list, idx_lis) + self.ref_table, idx_lis_new, idx_ref_new = add_rows_for_new_stars( + self.ref_table, + star_list, + idx_lis, + # motion_model_name=self.motion_model_for_new_star.name + motion_model_name=self.motion_models[-1].name, + fixed_params_dict=self.fixed_params_dict + ) + if len(idx_ref_new) > 0: if self.verbose > 0: print(' Adding {0:d} new stars to the reference table.'.format(len(idx_ref_new))) - + copy_over_values(self.ref_table, star_list, star_list_T, ii, idx_ref_new, idx_lis_new) # Copy the single-epoch values to the aggregate (only for new stars). self.ref_table['x0'][idx_ref_new] = star_list_T['x'][idx_lis_new] self.ref_table['y0'][idx_ref_new] = star_list_T['y'][idx_lis_new] self.ref_table['m0'][idx_ref_new] = star_list_T['m'][idx_lis_new] - + self.ref_table['name'] = update_old_and_new_names(self.ref_table, ii, idx_ref_new) if self.use_ref_new == True: self.ref_table['use_in_trans'][idx_ref_new] = True else: self.ref_table['use_in_trans'][idx_ref_new] = False - + return - - def update_ref_table_aggregates(self, n_boot=0, weighting='var', use_scipy=True, absolute_sigma=False, show_progress=True): - """ - Average positions or fit velocities. + + def update_ref_table_aggregates(self, keep_orig=None, n_boot=0, seed=None, processes=1, chunksize=None): + """ Average positions or fit velocities. Average magnitudes. Calculate bootstrap errors if desired. - Update the use_in_trans values as needed. + Update the use_in_trans values as needed. TODO: ????. Updates aggregate columns in self.ref_table in place. + + + Parameters + ---------- + keep_orig : array-like of bool, optional + Boolean array indicating which stars to keep original values for, by default None + n_boot : int, optional + Number of bootstrap iterations, by default 0 + seed : int, optional + Random seed for reproducible bootstrap results, by default None + """ # Keep track of the original reference values. # In certain cases, we will NOT update these. - if not self.update_ref_orig: - ref_orig_idx = np.where(self.ref_table['ref_orig'] == True)[0] - x0_orig = self.ref_table['x0'][ref_orig_idx] - y0_orig = self.ref_table['y0'][ref_orig_idx] - m0_orig = self.ref_table['m0'][ref_orig_idx] - x0e_orig = self.ref_table['x0e'][ref_orig_idx] - y0e_orig = self.ref_table['y0e'][ref_orig_idx] - m0e_orig = self.ref_table['m0e'][ref_orig_idx] - - if self.use_vel: - vx_orig = self.ref_table['vx'][ref_orig_idx] - vy_orig = self.ref_table['vy'][ref_orig_idx] - vxe_orig = self.ref_table['vxe'][ref_orig_idx] - vye_orig = self.ref_table['vye'][ref_orig_idx] - t0_orig = self.ref_table['t0'][ref_orig_idx] - - if self.use_vel: - # Combine positions with a velocity fit. - self.ref_table.fit_velocities(weighting=weighting, use_scipy=use_scipy, absolute_sigma=absolute_sigma, bootstrap=n_boot, verbose=self.verbose, show_progress=show_progress) - + if (keep_orig is not None) and (sum(keep_orig) > 0): + vals_orig = {} + vals_orig['m0'] = self.ref_table['m0'][keep_orig] + vals_orig['m0_err'] = self.ref_table['m0_err'][keep_orig] + # Collect all motion model parameter names + motion_model_class_names = [] + if 'motion_model_input' in self.ref_table.keys(): + motion_model_class_names += self.ref_table['motion_model_input'].tolist() + if 'motion_model_used' in self.ref_table.keys(): + motion_model_class_names += self.ref_table['motion_model_used'][keep_orig].tolist() + vals_orig['motion_model_used'] = self.ref_table['motion_model_used'][keep_orig] + vals_orig['n_params'] = self.ref_table['n_params'][keep_orig] + motion_model_col_names = motion_model.motion_model_param_names(motion_model_class_names, with_errors=True, with_fixed=True) + for mm in motion_model_col_names: + if f'{mm}_mm' in self.ref_table.keys(): + vals_orig[mm] = self.ref_table[mm][keep_orig] + elif mm in self.ref_table.keys(): + vals_orig[mm] = self.ref_table[mm][keep_orig] + fit_star_idxs = ~keep_orig + else: + fit_star_idxs = None + + if np.all(self.ref_table['motion_model_input']=='Fixed'): + # self.ref_table.fit_motion_models( + # motion_models=['Fixed'], + # weighting=self.vel_weighting, + # use_scipy=self.use_scipy, + # absolute_sigma=self.absolute_sigma, + # verbose=self.verbose + # ) + weighted_xy = ('xe' in self.ref_table.colnames) and ('ye' in self.ref_table.colnames) + weighted_m = ('me' in self.ref_table.colnames) + self.ref_table.combine_lists_xym(weighted_xy=weighted_xy, weighted_m=weighted_m) + + else: + self.ref_table.fit_motion_models( + motion_models=self.motion_models, + fixed_params_dict=self.fixed_params_dict, + weighting=self.vel_weighting, + use_scipy=self.use_scipy, + absolute_sigma=self.absolute_sigma, + method=self.scipy_method, + select_stars=fit_star_idxs, + bootstrap=n_boot, + seed=seed, + processes=processes, + chunksize=chunksize, + verbose=self.verbose + ) # Combine (transformed) magnitudes if 'me' in self.ref_table.colnames: weights_col = None else: weights_col = 'me' - self.ref_table.combine_lists('m', weights_col=weights_col, ismag=True) - else: - weighted_xy = ('xe' in self.ref_table.colnames) and ('ye' in self.ref_table.colnames) - weighted_m = ('me' in self.ref_table.colnames) - - self.ref_table.combine_lists_xym(weighted_xy=weighted_xy, weighted_m=weighted_m) + + # if (keep_orig is not None) and (sum(keep_orig) > 0): + # Determine motion_model_used for keep_orig stars + # Filter possible motion models based on available columns + motion_model_used, n_params = determine_motion_models(self.ref_table, self.motion_models, self.fixed_params_dict, processes, chunksize, self.verbose > 0) + + # Assign the determined motion models + self.ref_table['motion_model_used'] = Column(motion_model_used, name='motion_model_used', dtype='U20') + self.ref_table['n_params'] = Column(n_params, name='n_params', dtype=int) # Replace the originals if we are supposed to keep them fixed. - if not self.update_ref_orig: - self.ref_table['x0'][ref_orig_idx] = x0_orig - self.ref_table['y0'][ref_orig_idx] = y0_orig - self.ref_table['m0'][ref_orig_idx] = m0_orig - self.ref_table['x0e'][ref_orig_idx] = x0e_orig - self.ref_table['y0e'][ref_orig_idx] = y0e_orig - self.ref_table['m0e'][ref_orig_idx] = m0e_orig - - if self.use_vel: - self.ref_table['vx'][ref_orig_idx] = vx_orig - self.ref_table['vy'][ref_orig_idx] = vy_orig - self.ref_table['vxe'][ref_orig_idx] = vxe_orig - self.ref_table['vye'][ref_orig_idx] = vye_orig - self.ref_table['t0'][ref_orig_idx] = t0_orig + if (keep_orig is not None) and (sum(keep_orig) > 0): + for val in vals_orig.keys(): + self.ref_table[val][keep_orig] = vals_orig[val] return - + def get_weights_for_lists(self, ref_list, star_list): if 'xe' in ref_list.colnames: var_xref = ref_list['xe']**2 @@ -862,7 +1269,7 @@ def get_weights_for_lists(self, ref_list, star_list): else: var_xref = 0.0 var_yref = 0.0 - + if 'xe' in star_list.colnames: var_xlis = star_list['xe']**2 var_ylis = star_list['ye']**2 @@ -870,19 +1277,19 @@ def get_weights_for_lists(self, ref_list, star_list): var_xlis = 0.0 var_ylis = 0.0 - if self.weights != None: - if self.weights == 'both,var': + if self.trans_weighting is not None: + if self.trans_weighting == 'both,var': weight = 1.0 / (var_xref + var_xlis + var_yref + var_ylis) - if self.weights == 'both,std': + if self.trans_weighting == 'both,std': weight = 1.0 / np.sqrt(var_xref + var_xlis + var_yref + var_ylis) - if self.weights == 'ref,var': + if self.trans_weighting == 'ref,var': weight = 1.0 / (var_xref + var_yref) - if self.weights == 'ref,std': + if self.trans_weighting == 'ref,std': weight = 1.0 / np.sqrt(var_xref + var_yref) - if self.weights == 'list,var': + if self.trans_weighting == 'list,var': weight = 1.0 / (var_xlis + var_ylis) - if self.weights == 'list,std': - weight = 1.0 / np.sqrt(var_xlis, var_ylis) + if self.trans_weighting == 'list,std': + weight = 1.0 / np.sqrt(var_xlis + var_ylis) else: weight = None @@ -901,16 +1308,20 @@ def get_weights_for_lists(self, ref_list, star_list): # Fix bad weights: weight[bad] = 0.0 + if weight is not None and np.all(weight == 0.0): + # Catch the case where all weights were bad. + weight = None + return weight - + def match_lists(self, dr_tol, dm_tol): """ Using the existing trans objects, match all the starlists to the - reference starlist (self.ref_table), propogated to the appropriate epoch. + reference starlist (self.ref_table), propogated to the appropriate epoch. No trimming of stars. - No new transformations derived. + No new transformations derived. The resulting matched values will be used to update self.ref_table """ @@ -922,25 +1333,26 @@ def match_lists(self, dr_tol, dm_tol): star_list_T.transform_xym(self.trans_list[ii]) else: star_list_T.transform_xy(self.trans_list[ii]) - - xref, yref = get_pos_at_time(star_list_T['t'][0], self.ref_table, use_vel=self.use_vel) # optional velocity propogation. + + xref, yref = infer_positions(star_list_T['t'][0], self.ref_table, self.motion_models, self.fixed_params_dict) mref = self.ref_table['m0'] idx_lis, idx_ref, dr, dm = match.match(star_list_T['x'], star_list_T['y'], star_list_T['m'], xref, yref, mref, dr_tol=dr_tol, dm_tol=dm_tol, verbose=self.verbose) + if self.verbose > 0: - fmt = 'Matched {0:5d} out of {1:5d} stars in list {2:2d} [dr = {3:7.4f} +/- {4:6.4f}, dm = {5:5.2f} +/- {6:4.2f}' + fmt = 'Matched {0:5d} out of {1:5d} stars in list {2:2d} [dr = {3:7.4f} ± {4:6.4f}, dm = {5:5.2f} ± {6:4.2f}]' print(fmt.format(len(idx_lis), len(star_list_T), ii, dr.mean(), dr.std(), dm.mean(), dm.std())) copy_over_values(self.ref_table, self.star_lists[ii], star_list_T, ii, idx_ref, idx_lis) return - def get_ref_list_from_table(self, epoch): + def get_ref_list_from_table(self, epoch, processes=1, chunksize=None): """ Convert the averaged quantites in self.ref_table into a StarList object - appropriate for the specified epoch. + appropriate for the specified epoch. Columns in resulting reference list will include: name @@ -952,39 +1364,21 @@ def get_ref_list_from_table(self, epoch): me (optional) use_in_trans (optional) """ - # Reference stars will be named. + # Reference stars will be named. name = self.ref_table['name'] + # Calculate x, y, xe, ye - if self.use_vel and ('vx' in self.ref_table.colnames): - # First check if we should use velocities and if they exist. - dt = epoch - self.ref_table['t0'] - x = self.ref_table['x0'] + (self.ref_table['vx'] * dt) - y = self.ref_table['y0'] + (self.ref_table['vy'] * dt) - - xe = np.hypot(self.ref_table['x0e'], self.ref_table['vxe']*dt) - ye = np.hypot(self.ref_table['y0e'], self.ref_table['vye']*dt) - - idx = np.where(np.isfinite(self.ref_table['vx']) == False)[0] - x[idx] = self.ref_table['x0'][idx] - y[idx] = self.ref_table['y0'][idx] - xe[idx] = self.ref_table['x0e'][idx] - ye[idx] = self.ref_table['y0e'][idx] - else: - # No velocities... just used average positions. - x = self.ref_table['x0'] - y = self.ref_table['y0'] - - if 'x0e' in self.ref_table.colnames: - xe = self.ref_table['x0e'] - ye = self.ref_table['y0e'] - else: - xe = None - ye = None + if 'motion_model_used' not in self.ref_table.colnames: + motion_model_used, n_params = determine_motion_models(self.ref_table, self.motion_models, self.fixed_params_dict, processes, chunksize, self.verbose > 0) + self.ref_table['motion_model_used'] = Column(motion_model_used, name='motion_model_used', dtype='U20') + self.ref_table['n_params'] = Column(n_params, name='n_params', dtype=int) + + x, y, xe, ye = self.ref_table.infer_positions(epoch, fixed_params_dict=self.fixed_params_dict) m = self.ref_table['m0'] - - if 'm0e' in self.ref_table.colnames: - me = self.ref_table['m0e'] + + if 'm0_err' in self.ref_table.colnames: + me = self.ref_table['m0_err'] else: me = None @@ -1012,32 +1406,32 @@ def reset_ref_values(self, exclude=None): """ Reset all the 2D arrays in the reference table. This is the action we take at the beginning of each new iteration. We don't preserve matching - results from the prior iterations. + results from the prior iterations. """ # All 2D columns should be reset. for col_name in self.ref_table.colnames: - if (exclude != None) and (col_name in exclude): + if (exclude is not None) and (col_name in exclude): continue - + if len(self.ref_table[col_name].data.shape) == 2: # Find the 2D columns # Loop through epochs for this array. for cc in range(self.ref_table[col_name].shape[1]): self.ref_table._set_invalid_list_values(col_name, cc) return - - def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_bootstrap=True, weighting='var', use_scipy=True, absolute_sigma=False, show_progress=True): + + def calc_bootstrap_errors(self, n_boot=100, seed=None, boot_epochs_min=-1, calc_vel_in_bootstrap=True, update_errors=False, processes=1, chunksize=None, verbose=True): """ Function to calculate bootstrap errors for the transformations as well as the proper motions. For each iteration, this will: - 1) Draw full-size bootstrap w/replacement sample from reference stars in + 1) Draw full-size bootstrap w/replacement sample from reference stars in ref_table and re-calculate the transformations for each epoch 2) Apply transformation to all stars in each epoch - If calc_vel_in_bootstraps: + If calc_vel_in_bootstrap: 3) For each star, draw full-size boostrap sample w/replacement from epochs 4) Calculate proper motion for each star using resampled epochs - + The saved outputs will be: x_trans, y_trans, m_trans (transformed postions/mags), as well as the proper motion fit parameters. @@ -1047,54 +1441,55 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot Parameters: ---------- - mosaic_object: MosaicToRef object + mosaic_object : MosaicToRef object MosaicToRef object after the complete match_and_transform process - n_boot: int, must be greater than 0 - Number of bootstrap iterations when calculating transformations and the proper motion. - PM bootstrap is only done for final proper motion - calculation (e.g., not for each iteration of the starlist for matching) + n_boot : int, optional + Number of bootstrap iterations when calculating transformations and the proper motion. + PM bootstrap is only done for final proper motion calculation + (e.g., not for each iteration of the starlist for matching), by default 100 - boot_epochs_min: int or -1 - In order to be included in bootstrap analysis, non-reference stars must be detected in - at least boot_epochs_min epochs. If boot_epochs_min = -1, then all stars will + seed : int, optional + Random seed for reproducible bootstrap results. + + boot_epochs_min : int, optional + In order to be included in bootstrap analysis, non-reference stars must be detected in + at least boot_epochs_min epochs. If boot_epochs_min = -1, then all stars will be included in the analysis, regardless of the number of epochs detected. - For stars that fail boot_epochs_min criteria, np.nan is used + For stars that fail boot_epochs_min criteria, np.nan is used, by default -1 - calc_vel_in_bootstrap: boolean - If true, do bootstrap sample w/ replacement over the epochs and calculate + calc_vel_in_bootstrap : boolean, optional + If true, do bootstrap sample w/ replacement over the epochs and calculate stellar proper motions, as well as the bootstrap over reference stars - to calculate positional alignment errors. If false, only - calculate position alignment errors. - - weighting: str - 'var' or 'std' weighting for velocity fitting, by default 'var'. If 'var', use the variance of the residuals to weight the fit. - If 'std', use the standard deviation of the residuals to weight the fit. - - use_scipy: boolean - If True, use scipy.optimize.curve_fit to fit the velocity. If False, use flystar.fit_velocity.linear_fit, by default True. - - absolute_sigma: boolean - If True, use the absolute sigma in the velocity fitting. If False, use the relative sigma, by default False. - - + to calculate positional alignment errors. If false, only + calculate position alignment errors, by default True + + update_errors : boolean + If True, save the starlist errors as xe_list, bootstrap errors as xe_boot, and their quad sum as xe (and likewise for ye and me). If False (default), leave the starlist errors in place as xe and bootstrap errors as xe_boot. + + processes : int, optional + Number of processes to use for parallel processing, maximum os.cpu_count(), by default 1 (no multiprocessing) + + chunksize : int, optional + Chunk size for multiprocessing, by default None (auto) + + verbose : boolean, optional + Print verbose information or not, by default True + Output: ------ - Seven new columns will be added to self.ref_table: + New columns will be added to self.ref_table: 'xe_boot', 2D column: bootstrap x pos uncertainties due to transformation for each epoch 'ye_boot', 2D column: bootstrap y pos uncertainties due to transformation for each epoch 'me_boot', 2D column: bootstrap mag uncertainties due to transformation for each epoch - + If calc_vel_in_bootstrap: - 'x0e_boot', 1D column: bootstrap uncertainties in x0 for PM fit - 'y0e_boot', 1D column: bootstrap uncertainties in y0 for PM fit - 'vxe_boot', 1D column: bootstrap uncertainties in vx for PM fit - 'vye_boot', 1D column: bootstrap uncertainties in vy for PM fit + '_err_boot', 1D column: bootstrap uncertainties in for motion model fit For stars that fail boot_epochs_min criteria, np.nan is used """ # First, assert than n_boot > 0 - assert n_boot > 0 + assert n_boot > 0, f'{n_boot=} is not possive!' ref_table = copy.deepcopy(self.ref_table) n_epochs = len(ref_table['x'][0]) @@ -1110,69 +1505,102 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot t0_arr = t0_arr[idx_good] else: idx_good = np.arange(0, len(ref_table), 1) - idx_ref = np.where(ref_table['use_in_trans'] == True) - - # Initialize output arrays - x_trans_arr = np.ones((len(ref_table['x']), n_boot, n_epochs)) * -999 - y_trans_arr = np.ones((len(ref_table['x']), n_boot, n_epochs)) * -999 - m_trans_arr = np.ones((len(ref_table['x']), n_boot, n_epochs)) * -999 - xe_trans_arr = np.ones((len(ref_table['x']), n_boot, n_epochs)) * -999 - ye_trans_arr = np.ones((len(ref_table['x']), n_boot, n_epochs)) * -999 - me_trans_arr = np.ones((len(ref_table['x']), n_boot, n_epochs)) * -999 + + #idx_ref = np.where(ref_table['use_in_trans'] == True) + + # Initialize sums for output + x_boot_sum = np.zeros((len(ref_table['x']), n_epochs)) + x2_boot_sum = np.zeros((len(ref_table['x']), n_epochs)) + y_boot_sum = np.zeros((len(ref_table['x']), n_epochs)) + y2_boot_sum = np.zeros((len(ref_table['x']), n_epochs)) + m_boot_sum = np.zeros((len(ref_table['x']), n_epochs)) + m2_boot_sum = np.zeros((len(ref_table['x']), n_epochs)) + + # Set up motion model parameters + if 'motion_model_used' in ref_table.keys(): + motion_model_list = np.unique(ref_table['motion_model_used']).tolist() + elif 'motion_model_input' in ref_table.keys(): + motion_model_list = np.unique(ref_table['motion_model_input']).tolist() + + if 'Empty' not in motion_model_list: + motion_model_list.append('Empty') + if 'Fixed' not in motion_model_list: + motion_model_list.append('Fixed') + + motion_col_list = motion_model.motion_model_param_names(motion_model_list, with_errors=False, with_fixed=False) if calc_vel_in_bootstrap: - x0_arr = np.ones((len(ref_table['x']), n_boot)) * -999 - y0_arr = np.ones((len(ref_table['x']), n_boot)) * -999 - vx_arr = np.ones((len(ref_table['x']), n_boot)) * -999 - vy_arr = np.ones((len(ref_table['x']), n_boot)) * -999 + motion_boot_sum = {} + motion2_boot_sum = {} + for col in motion_col_list: + motion_boot_sum[col] = np.zeros((len(ref_table['x']))) + motion2_boot_sum[col] = np.zeros((len(ref_table['x']))) + + all_mm_map = motion_model.motion_model_map() + motion_model_list = [all_mm_map[mm_name] for mm_name in motion_model_list] + motion_boot_min_epochs = np.max([mm.n_params for mm in motion_model_list]) ### IF MEMORY PROBLEMS HERE: ### DEFINE MEAN, STD VARIABLES AND BUILD THEM RATHER THAN SAVING FULL ARRAY ### DECREASE PRECISION ON ARRAYS (32 bit instead of 64: dtype=np.float32) ### AT SOME POINT, NEED TO CONVERT BACK (LOOK UP HOW TO DO THIS CAREFULLY) - t1 = time.time() - for ii in range(n_boot): + rng = np.random.default_rng(seed) + for ii in tqdm(range(n_boot), desc='Bootstrap iterations', disable=not verbose): # Recalculate transformations using bootstrap sample of # reference stars. Use a loop for each epoch here, so we # can handle case where different reference stars are used # in different epochs + + # Initialize data arrays + x_trans_arr = np.ones((len(ref_table['x']), n_epochs)) * -999 + y_trans_arr = np.ones((len(ref_table['x']), n_epochs)) * -999 + m_trans_arr = np.ones((len(ref_table['x']), n_epochs)) * -999 + xe_trans_arr = np.ones((len(ref_table['x']), n_epochs)) * -999 + ye_trans_arr = np.ones((len(ref_table['x']), n_epochs)) * -999 + me_trans_arr = np.ones((len(ref_table['x']), n_epochs)) * -999 + for jj in range(n_epochs): - # Extract bootstrap sample of matched reference stars - good = np.where(~np.isnan(ref_table['x_orig'][idx_ref][:,jj])) - samp_idx = np.random.choice(good[0], len(good[0]), replace=True) - + # Extract bootstrap sample of matched reference stars for this epoch + #good = np.where(~np.isnan(ref_table['x_orig'][idx_ref][:,jj])) + good = np.where( (ref_table['used_in_trans'][:,jj] == True) & (~np.isnan(ref_table['x_orig'][:,jj])) ) + samp_idx = rng.choice(good[0], len(good[0]), replace=True) + # Get reference star positions in particular epoch from ref_list. t_epoch = t_arr[jj] - ref_orig = self.get_ref_list_from_table(t_epoch) - - # Get idx of reference stars in bootstrap sample in the ref_orig. - # Then, use these to build reference starlist for the alignment - idx_tmp = [] - for ff in range(len(samp_idx)): - name_tmp = ref_table['name'][samp_idx[ff]] - foo = np.where(ref_orig['name'] == name_tmp)[0][0] - idx_tmp.append(foo) - - ref_boot = StarList(name=ref_orig['name'][idx_tmp], - x=ref_orig['x'][idx_tmp], - y=ref_orig['y'][idx_tmp], - m=ref_orig['m'][idx_tmp], - xe=ref_orig['xe'][idx_tmp], - ye=ref_orig['ye'][idx_tmp], - me=ref_orig['me'][idx_tmp]) + ref_orig = self.get_ref_list_from_table(t_epoch, processes=processes, chunksize=chunksize)[idx_good] + + ## Get idx of reference stars in bootstrap sample in the ref_orig. + ## Then, use these to build reference starlist for the alignment + #idx_tmp = [] + #for ff in range(len(samp_idx)): + # name_tmp = ref_table['name'][idx_ref][samp_idx[ff]] + # foo = np.where(ref_orig['name'] == name_tmp)[0][0] + # idx_tmp.append(foo) + + ref_boot = StarList(name=ref_orig['name'][samp_idx], + x=ref_orig['x'][samp_idx], + y=ref_orig['y'][samp_idx], + m=ref_orig['m'][samp_idx], + xe=ref_orig['xe'][samp_idx], + ye=ref_orig['ye'][samp_idx], + me=ref_orig['me'][samp_idx]) # Now build star list with original positions of the reference stars # in the bootstrap sample - starlist_boot = StarList(name=ref_table['name'][idx_ref][samp_idx], - x=ref_table['x_orig'][:,jj][idx_ref][samp_idx], - y=ref_table['y_orig'][:,jj][idx_ref][samp_idx], - m=ref_table['m_orig'][:,jj][idx_ref][samp_idx], - xe=ref_table['xe_orig'][:,jj][idx_ref][samp_idx], - ye=ref_table['ye_orig'][:,jj][idx_ref][samp_idx], - me=ref_table['me_orig'][:,jj][idx_ref][samp_idx]) - + starlist_boot = StarList(name=ref_table['name'][samp_idx], + x=ref_table['x_orig'][:,jj][samp_idx], + y=ref_table['y_orig'][:,jj][samp_idx], + m=ref_table['m_orig'][:,jj][samp_idx], + xe=ref_table['xe_orig'][:,jj][samp_idx], + ye=ref_table['ye_orig'][:,jj][samp_idx], + me=ref_table['me_orig'][:,jj][samp_idx]) + + # Sanity check: makes sure names match between ref_boot and starlist_boot, + # since they need to line up + assert np.all(ref_boot['name'] == starlist_boot['name']) + # Calculate weights based on weights keyword. If weights desired, will need to # make starlist objects for this - if self.weights != None: + if self.trans_weighting is not None: # In order for weights calculation to work, we need to apply a transformation # to the star_list_T so it is in the same units as ref_boot. So, we'll apply # the final transformation for the epoch to get close enough for the @@ -1182,17 +1610,18 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot starlist_boot_T.transform_xym(self.trans_list[jj]) else: starlist_boot_T.transform_xy(self.trans_list[jj]) - + weight = self.get_weights_for_lists(ref_boot, starlist_boot_T) else: weight = None - + # Recalculate transformation trans = self.trans_class.derive_transform(starlist_boot['x'], starlist_boot['y'], ref_boot['x'], ref_boot['y'], self.trans_args[0]['order'], m=starlist_boot['m'], mref=ref_boot['m'], weights=weight, mag_trans=self.mag_trans) + #print(jj) # Apply transformation to *all* orig positions in this epoch. Need to make a new # FLYSTAR starlist object with the original positions for this. We don't @@ -1209,49 +1638,76 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot starlist_T.transform_xym(trans) else: starlist_T.transform_xy(trans) - + # Add output to pos arrays - x_trans_arr[:,ii,jj] = starlist_T['x'] - y_trans_arr[:,ii,jj] = starlist_T['y'] - m_trans_arr[:,ii,jj] = starlist_T['m'] - xe_trans_arr[:,ii,jj] = starlist_T['xe'] - ye_trans_arr[:,ii,jj] = starlist_T['ye'] - me_trans_arr[:,ii,jj] = starlist_T['me'] - - t2 = time.time() + x_trans_arr[:,jj] = starlist_T['x'] + y_trans_arr[:,jj] = starlist_T['y'] + m_trans_arr[:,jj] = starlist_T['m'] + xe_trans_arr[:,jj] = starlist_T['xe'] + ye_trans_arr[:,jj] = starlist_T['ye'] + me_trans_arr[:,jj] = starlist_T['me'] + + x_boot_sum += x_trans_arr + x2_boot_sum += x_trans_arr**2 + y_boot_sum += y_trans_arr + y2_boot_sum += y_trans_arr**2 + if self.mag_trans: + m_boot_sum += m_trans_arr + m2_boot_sum += m_trans_arr**2 + + # t2 = time.time() #print('=================================================') #print('Time to do {0} epochs: {1}s'.format(n_epochs, t2-t1)) #print('=================================================') - + # Finally, calculate proper motions for this bootstrap iteration # for each star, if desired. Draw a full-sample bootstrap over the epochs # for each star, and then run it through the startable fit_velocities machinery if calc_vel_in_bootstrap: - boot_idx = np.random.choice(np.arange(0, n_epochs, 1), size=n_epochs) + boot_idx = rng.choice(np.arange(0, n_epochs, 1), size=n_epochs) + while len(np.unique(boot_idx)) < motion_boot_min_epochs: + boot_idx = rng.choice(np.arange(0, n_epochs, 1), size=n_epochs) t_boot = t_arr[boot_idx] - + star_table = StarTable(name=ref_table['name'], - x=x_trans_arr[:,ii,boot_idx], - y=y_trans_arr[:,ii,boot_idx], - m=m_trans_arr[:,ii,boot_idx], - xe=xe_trans_arr[:,ii,boot_idx], - ye=ye_trans_arr[:,ii,boot_idx], - me=me_trans_arr[:,ii,boot_idx], - t=np.tile(t_boot, (len(ref_table),1)) ) + x=x_trans_arr[:,boot_idx], + y=y_trans_arr[:,boot_idx], + m=m_trans_arr[:,boot_idx], + xe=xe_trans_arr[:,boot_idx], + ye=ye_trans_arr[:,boot_idx], + me=me_trans_arr[:,boot_idx], + t=np.tile(t_boot, (len(ref_table),1))) + if 'motion_model_used' in ref_table.columns: + star_table['motion_model_input'] = ref_table['motion_model_used'] # Now, do proper motion calculation, making sure to fix t0 to the # orig value (so we can get a reasonable error on x0, y0) - star_table.fit_velocities(weighting=weighting, use_scipy=use_scipy, absolute_sigma=absolute_sigma, fixed_t0=t0_arr, show_progress=show_progress) + if self.fixed_params_dict is None: + fixed_params_dict = {'t0': t0_arr} + elif 't0' not in self.fixed_params_dict.keys(): + fixed_params_dict = self.fixed_params_dict.copy() + fixed_params_dict['t0'] = t0_arr + + star_table.fit_motion_models( + motion_models=self.motion_models, + fixed_params_dict=fixed_params_dict, + weighting=self.vel_weighting, + use_scipy=self.use_scipy, + absolute_sigma=self.absolute_sigma, + method=self.scipy_method, + processes=processes, + chunksize=chunksize, + verbose=False + ) # Save proper motion fit results to output arrays - x0_arr[:,ii] = star_table['x0'] - y0_arr[:,ii] = star_table['y0'] - vx_arr[:,ii] = star_table['vx'] - vy_arr[:,ii] = star_table['vy'] + for col in motion_col_list: + motion_boot_sum[col] += star_table[col] + motion2_boot_sum[col] += star_table[col]**2 # Quick check to make sure bootstrap calc was valid: output t0 should be # same as input t0_arr, since we used fixed_t0 option - assert np.sum(abs(star_table['t0'] - t0_arr) == 0) + np.testing.assert_array_equal(star_table['t0'], t0_arr) #t3 = time.time() #print('=================================================') @@ -1259,75 +1715,151 @@ def calc_bootstrap_errors(self, n_boot=100, boot_epochs_min=-1, calc_vel_in_boot #print('=================================================') # Calculate the bootstrap error values. - x_err_b = np.std(x_trans_arr, ddof=1, axis=1) - y_err_b = np.std(y_trans_arr, ddof=1, axis=1) - m_err_b = np.std(m_trans_arr, ddof=1, axis=1) - + x_boot_mean = x_boot_sum/n_boot + x_err_b = np.sqrt((x2_boot_sum - 2*x_boot_mean*x_boot_sum + n_boot*x_boot_mean**2)/n_boot) + y_boot_mean = y_boot_sum/n_boot + y_err_b = np.sqrt((y2_boot_sum - 2*y_boot_mean*y_boot_sum + n_boot*y_boot_mean**2)/n_boot) + m_boot_mean = m_boot_sum/n_boot + m_err_b = np.sqrt((m2_boot_sum - 2*m_boot_mean*m_boot_sum + n_boot*m_boot_mean**2)/n_boot) + + motion_data_err = {} if calc_vel_in_bootstrap: - x0_err_b = np.std(x0_arr, ddof=1, axis=1) - y0_err_b = np.std(y0_arr, ddof=1, axis=1) - vx_err_b = np.std(vx_arr, ddof=1, axis=1) - vy_err_b = np.std(vy_arr, ddof=1, axis=1) + for col in motion_col_list: + mot_boot_mean = motion_boot_sum[col]/n_boot + motion_data_err[col] = np.sqrt((motion2_boot_sum[col] - + 2*mot_boot_mean*motion_boot_sum[col] + n_boot*mot_boot_mean**2)/n_boot) else: - x0_err_b = np.nan - y0_err_b = np.nan - vx_err_b = np.nan - vy_err_b = np.nan + for col in motion_col_list: + motion_data_err[col] = np.nan # Add summary statistics to *original* ref_table, i.e. ref_table # hanging off of mosaic object. col_heads_2D = ['xe_boot', 'ye_boot', 'me_boot'] - data_dict = {'xe_boot': x_err_b, 'ye_boot': y_err_b, 'me_boot': m_err_b, - 'x0e_boot': x0_err_b, 'y0e_boot': y0_err_b, - 'vxe_boot': vx_err_b, 'vye_boot': vy_err_b} - + data_dict = {'xe_boot': x_err_b, 'ye_boot': y_err_b, 'me_boot': m_err_b} + for col in motion_col_list: + data_dict[col+'_err_boot'] = motion_data_err[col] + for ff in col_heads_2D: col = Column(np.ones((len(self.ref_table), n_epochs)), name=ff) col.fill(np.nan) - + col[idx_good] = data_dict[ff] self.ref_table.add_column(col) + # # Calculate chi^2 with bootstrap positional errors + # # Determine which motion model to use: + # motion_model_list = sorted(motion_model_list, key=lambda mm: mm.n_params) + # mm_n_params = np.sort([mm.n_params for mm in motion_model_list]) + + # required_params = [all_mm_map[mm_name].n_params for mm_name in self.ref_table['motion_model_input']] + # mm_digitized = np.digitize( + # x=np.minimum(np.array(self.ref_table['n_detect']), required_params), + # bins=mm_n_params + # ) - 1 + # self.ref_table['motion_model_used'] = np.array([motion_model_list[d].name for d in mm_digitized], dtype='U20') + + + x_pred, y_pred, _, _ = self.ref_table.infer_positions(t_arr, fixed_params_dict=self.fixed_params_dict) + if np.ndim(x_pred) == 1: + x_pred = x_pred[:, np.newaxis] + if np.ndim(y_pred) == 1: + y_pred = y_pred[:, np.newaxis] + xe_comb = np.hypot(self.ref_table['xe'], self.ref_table['xe_boot']) + ye_comb = np.hypot(self.ref_table['ye'], self.ref_table['ye_boot']) + data_dict['chi2_x_boot'] = np.nansum((self.ref_table['x'] - x_pred)**2 / xe_comb**2, axis=1) + data_dict['chi2_y_boot'] = np.nansum((self.ref_table['y'] - y_pred)**2 / ye_comb**2, axis=1) + for ff in ['chi2_x_boot', 'chi2_y_boot']: + col = Column(np.ones(len(self.ref_table)), name=ff) + col.fill(np.nan) + + col[idx_good] = data_dict[ff][idx_good] + self.ref_table.add_column(col) + # Now handle the velocities, if they were calculated if calc_vel_in_bootstrap: - col_heads_1D = [ 'x0e_boot', 'y0e_boot', 'vxe_boot', 'vye_boot'] - + col_heads_1D = [col+'_err_boot' for col in motion_col_list] + for ff in col_heads_1D: col = Column(np.ones(len(self.ref_table)), name=ff) col.fill(np.nan) - + col[idx_good] = data_dict[ff] self.ref_table.add_column(col) - print('===============================') - print('Done with bootstrap') - print('===============================') - + if verbose: + print('===================================') + print('======= Done with bootstrap =======') + print('===================================') + + if update_errors: + self.ref_table['xe_list'] = self.ref_table['xe'] + self.ref_table['ye_list'] = self.ref_table['ye'] + self.ref_table['me_list'] = self.ref_table['me'] + self.ref_table['xe'] = np.hypot(self.ref_table['xe_list'], self.ref_table['xe_boot']) + self.ref_table['ye'] = np.hypot(self.ref_table['ye_list'], self.ref_table['ye_boot']) + self.ref_table['me'] = np.hypot(self.ref_table['me_list'], self.ref_table['me_boot']) + print("Saved starlist errors to xe_list and added xe_boot to xe in quadrature.") + print("The same was done for ye and me.") + + if self.save_path is not None: + with open(os.path.join(self.save_path, self.prefix_name+'_bootstrap.pkl'), 'wb') as file: + pickle.dump(self, file) + with open(os.path.join(self.save_path, self.prefix_name+'_ref_table_bootstrap.pkl'), 'wb') as file: + pickle.dump(self.ref_table, file) + return - + class MosaicToRef(MosaicSelfRef): - def __init__(self, ref_list, list_of_starlists, iters=2, - dr_tol=[1, 1], dm_tol=[2, 1], - outlier_tol=[None, None], - trans_args=[{'order': 2}, {'order': 2}], - init_order=1, - mag_trans=True, mag_lim=None, ref_mag_lim=None, - weights=None, - trans_input=None, - trans_class=transforms.PolyTransform, - calc_trans_inverse=False, - use_ref_new=False, - use_vel=False, update_ref_orig=False, - init_guess_mode='miracle', - iter_callback=None, - verbose=True): + def __init__( + self, + ref_list, + list_of_starlists, + reflist_vertex=None, + starlist_vertices=None, + # Alignment parameters + iters=2, + dr_tol=[1, 1], + dm_tol=[2, 1], + outlier_tol=None, + # Reference behavior (MosiacToRef specific) + use_ref_new=False, + update_ref_orig=False, + # Transformation parameters + trans_class=transforms.PolyTransform, + trans_args=[{'order': 2}, {'order': 2}], + trans_input=None, + trans_weights=None, + init_order=1, + init_guess_mode='miracle', + briteN=None, + calc_trans_inverse=False, + # Magnitude parameters + mag_trans=True, + mag_lim=None, + ref_mag_lim=None, + # Motion model parameters + motion_models=['Empty', 'Fixed'], + fixed_params_dict=None, + vel_weights='var', + use_scipy=True, + absolute_sigma=True, + scipy_method=None, + # Advanced options + iter_callback=None, + save_path=None, + prefix_name='mtr', + verbose=True + ): """ Required Parameters - ---------- + ------------------- ref_list : StarList object - Can optionally have velocities. All starlists will be aligned to this one. + All starlists will be aligned to this one. + Must have columns (x, y, m, xe, ye, me) or (x0, y0, m0, x0_err, y0_err, m0_err). + May have t or t0 columns. + May have motion model parameters list_of_starlists : array of StarList objects An array or list of flystar.starlists.StarList objects (which are Astropy Tables). @@ -1336,20 +1868,28 @@ def __init__(self, ref_list, list_of_starlists, iters=2, Note that there is an optional weights column called 'w'. If this column exists in any of the lists, it will be queried to determine if an individual star can be used to derive the transformations between starlists. This is the most flexible way - to allow you to determine, as a function of time and star, which ones are good enough - in the transformation. Note that just because it can be used (i.e. w_in=1), - doesn't meant that it will be used. The mag limits and outliers still take precedence. - Note also that the weights that go into the transformation are + to allow you to determine, as a function of time and star, which ones are good enough + in the transformation. Note that just because it can be used (i.e. w_in=1), + doesn't meant that it will be used. The mag limits and outliers still take precedence. + Note also that the weights that go into the transformation are star_list['w'] * ref_list['w'] * weight_from_keyword (see the weights parameter) - for those stars not trimmed out by the other criteria. + for those stars not trimmed out by the other criteria. Optional Parameters ---------- + reflist_vertex : array + An array of polygon vertices coordinates for the reference starlist. Initial guess will only use stars in overlapping regions defined by these polygons. + Shape of (N_vertices, 2) in the format of [[x1, y1], [x2, y2], ..., [xN, yN]] for the reference starlist, by default None + + starlist_vertices : list or array + A list or array of polygon vertices coordinates for each starlist. Initial guess will only use stars in overlapping regions defined by these polygons. + Shape of (N_lists, N_vertices, 2) in the format of [[x1, y1], [x2, y2], ..., [xN, yN]] for each starlist, by default None + iters : int - The number of iterations used in the matching and transformation. TO DO: INNER/OUTER? + The number of iterations used in the matching and transformation. TO DO: INNER/OUTER? dr_tol : list or array The delta-radius (dr) tolerance for matching in units of the reference coordinate system. @@ -1357,172 +1897,241 @@ def __init__(self, ref_list, list_of_starlists, iters=2, dm_tol : list or array The delta-magnitude (dm) tolerance for matching in units of the reference coordinate system. - This is a list of dm values, one for each iteration of matching/transformation. + This is a list of dm values, one for each iteration of matching/transformation. outlier_tol : list or array - The outlier tolerance (in units of sigma) for rejecting outlier stars. + The outlier tolerance (in units of sigma) for rejecting outlier stars. This is a list of tol values, one for each iteration of matching/transformation. - mag_trans : boolean - If true, this will also calculate and (temporarily) apply a zeropoint offset to - magnitudes in each list to bring them into a common magnitude system. This is - essential for matching (with finite dm_tol) starlists of different filters or - starlists that are not photometrically calibrated. Note that the final_table columns - of 'm', 'm0', and 'm0e' will contain the transformed magnitudes while the - final_table column 'm_orig' will contain the original un-transformed magnitudes. - If mag_trans = False, then no such zeropoint offset it applied at any point. - - mag_lim : array - If different from None, it indicates the minimum and maximum magnitude - on the catalogs for finding the transformations. Note, if you want specify the mag_lim - separately for each list and each iteration, you need to pass in a 2D array that - has shape (N_lists, 2). + use_ref_new : boolean + Each pass, new stars are matched and added to the ref_table. However, we don't + necessarily want to use these in the reference frame in subsequent passes. + If True, then the new stars will be used in later passes/iterations. + If False, then the new stars will be carried, but not used in the transformation. + We determine which stars to use through setting a boolean use_in_trans flag. - ref_mag_lim : array - If different from None, it indicates the minimum and maximum magnitude - on the reference catalog for finding the transformations. + update_ref_orig : boolean or str + Should we update the reference values (position, velocity, t0) after each starlist + is transformed in each iteration? - weights : str - Either None (def), 'both,var', 'list,var', or 'ref,var' depending on whether you want - to weight by the positional uncertainties (variances) in the individual starlists, or also with - the uncertainties in the reference frame itself. Note weighting only works when there - are positional uncertainties availabe. Other options include 'both,std', 'list,std', 'list,var'. + False if you want to get into an absolute reference frame and are using Gaia data. + True if you want to use the reference list as more of an initial guess. + 'periter' if you want to align all the starlists, then calculate the velocity. - trans_input : array or list of transform objects - def = None. If not None, then this should contain an array or list of transform - objects that will be used as the initial guess in the alignment and matching. + Note that this only impacts the stars that are in the original reference list... the + newly identified stars that end up in ref_table will always be updated; but not always + used for transformation fitting. trans_class : transforms.Transform2D object (or subclass) The transform class that will be used to when deriving the optimal - transformation parameters between each list and the reference list. + transformation parameters between each list and the reference list. trans_args : dictionary - A dictionary (or a list of dictionaries) containing any extra keywords that are needed - in the transformation object. For instance, "order". Note that if a list is passed in, + A dictionary (or a list of dictionaries) containing any extra keywords that are needed + in the transformation object. For instance, "order". Note that if a list is passed in, then the transformation argument (i.e. order) will be changed for every iteration in iters. + trans_input : array or list of transform objects + def = None. If not None, then this should contain an array or list of transform + objects that will be used as the initial guess in the alignment and matching. + + trans_weights : str + Either None (def), 'both,var', 'list,var', or 'ref,var' depending on whether you want + to weight by the positional uncertainties (variances) in the individual starlists, or also with + the uncertainties in the reference frame itself. Note weighting only works when there + are positional uncertainties availabe. Other options include 'both,std', 'list,std', 'list,var'. + init_order: int Polynomial transformation order to use for initial guess transformation. Order=1 should be used in most cases, but sometimes higher order is needed + init_guess_mode : string + If no initial transformations are passed in via the trans_input keyword, then we have + to make the initial transformation and matching blindly. We can do this in a couple of + different ways. Options are 'miracle' or 'name' (see trans_initial_guess() for more details). + + briteN : int + If init_guess_mode is 'miracle', this is the number of brightest stars to use in the miracle match. + Default is min(50, len(star_list)). + calc_trans_inverse: boolean If true, then calculate the inverse transformation (from reference to starlist) in addition to the normal transformation (from starlist to reference). The inverse calculation is calculated by switching the order to the positions in match_and_transform. The inverse transformations are saved in self.trans_list_inverse. - self.trans_list_inverse doesn't exist if calc_trans_inverse == False - update_ref_orig : boolean or str - Should we update the reference values (position, velocity, t0) after each starlist - is transformed in each iteration? + mag_trans : boolean + If true, this will also calculate and (temporarily) apply a zeropoint offset to + magnitudes in each list to bring them into a common magnitude system. This is + essential for matching (with finite dm_tol) starlists of different filters or + starlists that are not photometrically calibrated. Note that the final_table columns + of 'm', 'm0', and 'm0_err' will contain the transformed magnitudes while the + final_table column 'm_orig' will contain the original un-transformed magnitudes. + If mag_trans = False, then no such zeropoint offset it applied at any point. - False if you want to get into an absolute reference frame and are using Gaia data. - True if you want to use the reference list as more of an initial guess. - 'periter' if you want to align all the starlists, then calculate the velocity. + mag_lim : array + If different from None, it indicates the minimum and maximum magnitude + on the starlists for finding the transformations BEFORE mag trans. + Note, if you want specify the mag_lim separately for each list, + you need to pass in a 2D array that has shape (N_lists, 2). - Note that this only impacts the stars that are in the original reference list... the - newly identified stars that end up in ref_table will always be updated; but not always - used for transformation fitting. + ref_mag_lim : array + If different from None, it indicates the minimum and maximum magnitude + on the reference catalog for finding the transformations. - use_ref_new : boolean - Each pass, new stars are matched and added to the ref_table. However, we don't - necessarily want to use these in the reference frame in subsequent passes. - If True, then the new stars will be used in later passes/iterations. - If False, then the new stars will be carried, but not used in the transformation. - We determine which stars to use through setting a boolean use_in_trans flag. + motion_models : list of str or MotionModel objects + List of motion model names (strings) or MotionModel objects to use - use_vel : boolean - If velocities are present in the reference list and use_vel == True, then during - each iteration of the alignment, the reference list will be propogated in time - using the velocity information. So all transformations will be derived w.r.t. - the propogated positions. See also update_vel. + motion_model_for_new_star : str or MotionModel, optional + Motion model or its name for newly added stars in the ref table. Used in add_rows_for_new_stars(). + If None, the most complex motion model in motion_models will be used, by default None. - init_guess_mode : string - If no initial transformations are passed in via the trans_input keyword, then we have - to make the initial transformation and matching blindly. We can do this in a couple of - different ways. Options are 'miracle' or 'name' (see trans_initial_guess() for more details). + fixed_params_dict : None or dict + Dictionary of fixed parameters for motion models + + vel_weights : str + Either 'var' (def) or 'std', depending on whether you want to weight the motion model + fits by the variance or standard deviation of the position data + + use_scipy : bool, optional + If True, use scipy.optimize.curve_fit for velocity fitting. If False, use linear algebra fitting, by default True. + + absolute_sigma : bool, optional + If True, the velocity fit will use absolute errors in the data. If False, relative errors will be used, by default False. + + scipy_method : str, optional + Method of scipy.curve_fit, {'lm', 'trf', 'dogbox'}, by default None iter_callback : None or function A function to call (that accepts a StarTable object and an iteration number) - at the end of every iteration. This can be used for plotting or printing state. + at the end of every iteration. This can be used for plotting or printing state. + + save_path : str, optional + Path to save the MosaicToRef object as a pickle file. + + verbose : bool or int (0 to 9, inclusive) + Controls the verbosity of print statements. (0 least, 9 most verbose). + For backwards compatibility, 0 = False, 9 = True. + (Note: technically right now no checks on whether the number is an integer or not...) Example - ---------- - msc = align.MosaicToRef(my_gaia, list_of_starlists, iters=1, + ------- + mtr = align.MosaicToRef(my_gaia, list_of_starlists, iters=1, dr_tol=[0.1], dm_tol=[5], outlier_tol=[None], mag_lim=[13, 21], trans_class=transforms.PolyTransform, trans_args=[{'order': 1}], - use_vel=True, use_ref_new=False, update_ref_orig=False, mag_trans=False, weights='both,std', init_guess_mode='miracle', verbose=False) - msc.fit() + mtr.fit() # Access a list of all the transformation parameters: - trans_list = msc.trans_list + trans_list = mtr.trans_list # Access the fully-combined reference table. - stars_table = msc.ref_table + stars_table = mtr.ref_table # Plot the magnitude of the first star vs. time: - # Overplot the mean magnitude. + # Overplot the mean magnitude. plt.plot(stars_table['t'][0, :], stars_table['m'][0, :], 'k.') - plt.axhline(stars_table['m0'][0]) + plt.axhline(stars_table['m0'][0]) # Plot the X position of the first star vs. time: # Overplot the best-fit proper motion. times = stars_table['t'][0, :] plt.errorbar(times, stars_table['x'][0, :], yerr=stars_table['xe'][0, :]) - plt.axhline(stars_table['x0'][0] + stars_table['vx'][0]*(times - stars_table['t0'][0])) + plt.axhline(stars_table['x0'][0] + stars_table['vx'][0]*(times - stars_table['t0'][0])) """ - super().__init__(list_of_starlists, ref_index=-1, iters=iters, - dr_tol=dr_tol, dm_tol=dm_tol, - outlier_tol=outlier_tol, trans_args=trans_args, - init_order=init_order, - mag_trans=mag_trans, mag_lim=mag_lim, weights=weights, - trans_input=trans_input, trans_class=trans_class, - calc_trans_inverse=calc_trans_inverse, use_vel=use_vel, - init_guess_mode=init_guess_mode, - iter_callback=iter_callback, - verbose=verbose) - + super().__init__( + list_of_starlists, + # Alignment parameters + ref_index=-1, + dr_tol=dr_tol, + dm_tol=dm_tol, + outlier_tol=outlier_tol, + # Transformation parameters + trans_class=trans_class, + trans_args=trans_args, + trans_input=trans_input, + trans_weights=trans_weights, + init_order=init_order, + init_guess_mode=init_guess_mode, + briteN=briteN, + calc_trans_inverse=calc_trans_inverse, + # Magnitude parameters + mag_trans=mag_trans, + mag_lim=mag_lim, + # Motion model parameters + motion_models=motion_models, + # motion_model_for_new_star=motion_model_for_new_star, + fixed_params_dict=fixed_params_dict, + vel_weights=vel_weights, + use_scipy=use_scipy, + absolute_sigma=absolute_sigma, + # Advanced options + iter_callback=iter_callback, + save_path=save_path, + prefix_name=prefix_name, + verbose=verbose + ) + + self.starlist_vertices = starlist_vertices self.ref_list = copy.deepcopy(ref_list) self.ref_mag_lim = ref_mag_lim self.update_ref_orig = update_ref_orig self.use_ref_new = use_ref_new + if reflist_vertex is not None: + import shapely + self.reflist_polygon = shapely.make_valid(shapely.Polygon(reflist_vertex)) + else: + self.reflist_polygon = None + + # If motion_model_used in columns but params columns are missing, raise a warning and remove motion_model_used column to avoid confusion. + # if 'motion_model_used' in self.ref_list.colnames: + # motion_model_params = motion_model.motion_model_param_names(np.unique(self.ref_list['motion_model_used']), with_errors=False, with_fixed=True) + # missing_params = [param for param in motion_model_params if (param not in self.ref_list.colnames) and (f'{param}_err' not in self.ref_list.colnames) and (param not in self.fixed_params_dict.keys())] + # if len(missing_params) > 0: + # warnings.warn("Warning: 'motion_model_used' column found in ref_list, but the following motion model parameter columns are missing: " + ", ".join(missing_params) + ". Removing 'motion_model_used' column to avoid confusion.") + # self.ref_list.remove_column('motion_model_used') + + # If motion_model_used in columns, remove it and raise a warning, since it will only be determined after the fit. + if 'motion_model_used' in self.ref_list.colnames: + warnings.warn("Warning: 'motion_model_used' column found in ref_list. This column will be determined after the fit, so it is being removed from the input ref_list to avoid confusion.") + self.ref_list.remove_column('motion_model_used') + # Do some temporary clean up of the reference list. if ('x' not in self.ref_list.colnames) and ('x0' in self.ref_list.colnames): self.ref_list['x'] = self.ref_list['x0'] self.ref_list['y'] = self.ref_list['y0'] - if ('xe' not in self.ref_list.colnames) and ('x0e' in self.ref_list.colnames): - self.ref_list['xe'] = self.ref_list['x0e'] - self.ref_list['ye'] = self.ref_list['y0e'] + if ('xe' not in self.ref_list.colnames) and ('x0_err' in self.ref_list.colnames): + self.ref_list['xe'] = self.ref_list['x0_err'] + self.ref_list['ye'] = self.ref_list['y0_err'] if ('m' not in self.ref_list.colnames) and ('m0' in self.ref_list.colnames): self.ref_list['m'] = self.ref_list['m0'] - if ('me' not in self.ref_list.colnames) and ('m0e' in self.ref_list.colnames): - self.ref_list['me'] = self.ref_list['m0e'] + if ('me' not in self.ref_list.colnames) and ('m0_err' in self.ref_list.colnames): + self.ref_list['me'] = self.ref_list['m0_err'] if ('t' not in self.ref_list.colnames) and ('t0' in self.ref_list.colnames): self.ref_list['t'] = self.ref_list['t0'] return - - def fit(self): + + def fit(self, processes=1, chunksize=None): """ Using the current parameter settings, match and transform all the lists to a reference position. Note in the first pass, the reference position is just the specified input reference starlist. In subsequent iterations, - this is (optionally) updated. + this is (optionally) updated. The ultimate outcome is the creation of self.ref_table. This reference table will contain "averaged" quantites as well as a big 2D array of all - the matched original and transformed quantities. + the matched original and transformed quantities. Averaged columns on ref_table: x0 @@ -1531,33 +2140,83 @@ def fit(self): x0e y0e m0e - vx (only if use_vel=True) - vy (only if use_vel=True) - vxe (only if use_vel=True) - vye (only if use_vel=True) + addl. motion_model parameters + Parameters + ---------- + processes : int, optional + Number of processes to use for parallel processing, maximum os.cpu_count(), by default 1 (no multiprocessing) + chunksize : int, optional + Chunk size for multiprocessing, by default None (auto) """ # Create a log file of the parameters used in the fit. - with open('MosaicToRef_input_params.log', 'w',) as _log: - logger(_log, 'Parameters used for fit: ', self.verbose) - logger(_log, '------------------------- ', self.verbose) - logger(_log, ' dr_tol = ' + str(self.dr_tol), self.verbose) - logger(_log, ' dm_tol = ' + str(self.dm_tol), self.verbose) - logger(_log, ' outlier_tol = ' + str(self.outlier_tol), self.verbose) - logger(_log, ' trans_args = ' + str(self.trans_args), self.verbose) - logger(_log, ' mag_trans = ' + str(self.mag_trans), self.verbose) - logger(_log, ' mag_lim = ' + str(self.mag_lim), self.verbose) - logger(_log, ' ref_mag_lim = ' + str(self.ref_mag_lim), self.verbose) - logger(_log, ' weights = ' + str(self.weights), self.verbose) - logger(_log, ' trans_input = ' + str(self.trans_input), self.verbose) - logger(_log, ' trans_class = ' + str(self.trans_class), self.verbose) - logger(_log, ' calc_trans_inverse = ' + str(self.calc_trans_inverse), self.verbose) - logger(_log, ' use_ref_new = ' + str(self.use_ref_new), self.verbose) - logger(_log, ' use_vel = ' + str(self.use_vel), self.verbose) - logger(_log, ' update_ref_orig = ' + str(self.update_ref_orig), self.verbose) - logger(_log, ' init_guess_mode = ' + str(self.init_guess_mode), self.verbose) - logger(_log, ' iter_callback = ' + str(self.iter_callback), self.verbose) - logger(_log, '-------------------------\n', self.verbose) + # Setup save_path: + if self.save_path: + if not os.path.exists(os.path.dirname(self.save_path)): + os.makedirs(os.path.dirname(self.save_path)) + + # Save input params + input_filename = f'{self.prefix_name}_input.txt' + input_dict = { + 'iters': self.iters, + 'dr_tol': self.dr_tol, + 'dm_tol': self.dm_tol, + 'outlier_tol': self.outlier_tol, + 'use_ref_new': self.use_ref_new, + 'update_ref_orig': self.update_ref_orig, + 'trans_class': self.trans_class, + 'trans_args': self.trans_args, + 'trans_input': self.trans_input, + 'trans_weights': self.trans_weighting, + 'init_order': self.init_order, + 'init_guess_mode': self.init_guess_mode, + 'calc_trans_inverse': self.calc_trans_inverse, + 'mag_trans': self.mag_trans, + 'mag_lim': self.mag_lim, + 'ref_mag_lim': self.ref_mag_lim, + 'motion_models': self.motion_models, + 'fixed_params_dict': self.fixed_params_dict, + 'vel_weights': self.vel_weighting, + 'use_scipy': self.use_scipy, + 'absolute_sigma': self.absolute_sigma, + 'iter_callback': self.iter_callback, + 'save_path': self.save_path, + 'prefix_name': self.prefix_name, + 'verbose': self.verbose + } + if self.save_path is not None: + if not os.path.exists(self.save_path): + os.makedirs(self.save_path) + with open(os.path.join(self.save_path, input_filename), 'w') as file: + for key, value in input_dict.items(): + file.write(f'{key}:\t{value}\n') + + if self.ref_mag_lim is not None: + self.ref_mag_lim[0] = self.ref_mag_lim[0] if self.ref_mag_lim[0] is not None else -np.inf + self.ref_mag_lim[1] = self.ref_mag_lim[1] if self.ref_mag_lim[1] is not None else np.inf + + # if self.save_path is not None: + # with open(f'{os.path.dirname(self.save_path)}/MosaicToRef_input_params.log', 'w',) as _log: + # logger(_log, 'Parameters used for fit: ', self.verbose) + # logger(_log, '------------------------- ', self.verbose) + # logger(_log, ' dr_tol = ' + str(self.dr_tol), self.verbose) + # logger(_log, ' dm_tol = ' + str(self.dm_tol), self.verbose) + # logger(_log, ' outlier_tol = ' + str(self.outlier_tol), self.verbose) + # logger(_log, ' trans_args = ' + str(self.trans_args), self.verbose) + # logger(_log, ' mag_trans = ' + str(self.mag_trans), self.verbose) + # logger(_log, ' mag_lim = ' + str(self.mag_lim), self.verbose) + # logger(_log, ' ref_mag_lim = ' + str(self.ref_mag_lim), self.verbose) + # logger(_log, ' trans_weights = ' + str(self.trans_weighting), self.verbose) + # logger(_log, ' vel_weights = ' + str(self.vel_weighting), self.verbose) + # logger(_log, ' trans_input = ' + str(self.trans_input), self.verbose) + # logger(_log, ' trans_class = ' + str(self.trans_class), self.verbose) + # logger(_log, ' calc_trans_inverse = ' + str(self.calc_trans_inverse), self.verbose) + # logger(_log, ' use_ref_new = ' + str(self.use_ref_new), self.verbose) + # logger(_log, ' motion_models = ' + str([mm.name for mm in self.motion_models]), self.verbose) + # logger(_log, ' update_ref_orig = ' + str(self.update_ref_orig), self.verbose) + # logger(_log, ' init_guess_mode = ' + str(self.init_guess_mode), self.verbose) + # logger(_log, ' iter_callback = ' + str(self.iter_callback), self.verbose) + # logger(_log, '-------------------------\n', self.verbose) ########## @@ -1567,17 +2226,9 @@ def fit(self): # x_orig, y_orig, m_orig, (opt. errors) -- the transformed errors for the lists: 2D # w, w_orig (optiona) -- the input and output weights of stars in transform: 2D ########## + if 't0' in self.ref_list.colnames: self.t0_provided = True + else: self.t0_provided = False self.ref_table = self.setup_ref_table_from_starlist(self.ref_list) - - # copy over velocities if they exist in the reference list - if 'vx' in self.ref_list.colnames: - self.ref_table['vx'] = self.ref_list['vx'] - self.ref_table['vy'] = self.ref_list['vy'] - self.ref_table['t0'] = self.ref_list['t0'] - if 'vxe' in self.ref_list.colnames: - self.ref_table['vxe'] = self.ref_list['vxe'] - self.ref_table['vye'] = self.ref_list['vye'] - ########## # @@ -1585,8 +2236,7 @@ def fit(self): # ########## for nn in range(self.iters): - - # If we are on subsequent iterations, remove matching results from the + # If we are on subsequent iterations, remove matching results from the # prior iteration. This leaves aggregated (1D) columns alone. if nn > 0: self.reset_ref_values() @@ -1598,31 +2248,38 @@ def fit(self): print('Starting iter {0:d} with ref_table shape:'.format(nn), self.ref_table['x'].shape) print("**********") print("**********") - + # ALL the action is in here. Match and transform the stack of starlists. - # This updates trans objects and the ref_table. - self.match_and_transform(self.ref_mag_lim, - self.dr_tol[nn], self.dm_tol[nn], self.outlier_tol[nn], - self.trans_args[nn]) + # This updates trans objects and the ref_table. + self.match_and_transform( + self.ref_mag_lim, + self.dr_tol[nn], + self.dm_tol[nn], + self.outlier_tol[nn], + self.trans_args[nn], + nn, + processes=processes, + chunksize=chunksize + ) # Clean up the reference table # Find where stars are detected. self.ref_table.detections() ### Drop all stars that have 0 detections. - idx = np.where((self.ref_table['n_detect'] == 0) & (self.ref_table['ref_orig'] == False))[0] + idx = np.where((self.ref_table['n_detect'] == 0))[0] # & (self.ref_table['ref_orig'] == False))[0] if self.verbose > 0: - print(' *** Getting rid of {0:d} out of {1:d} junk sources'.format(len(idx), len(self.ref_table))) + print(' *** Getting rid of {0:d} out of {1:d} junk sources'.format(len(idx), len(self.ref_table))) self.ref_table.remove_rows(idx) - if self.iter_callback != None: + if self.iter_callback is not None: self.iter_callback(self.ref_table, nn) ########## # # Re-do all matching given final transformations. # No trimming this time. - # First rest the reference table 2D values. + # First reset the reference table 2D values. ########## self.reset_ref_values(exclude=['used_in_trans']) @@ -1632,34 +2289,295 @@ def fit(self): print("**********") self.match_lists(self.dr_tol[-1], self.dm_tol[-1]) - self.update_ref_table_aggregates() + if self.update_ref_orig: + keep_orig=None + else: + keep_orig = self.ref_table['ref_orig'] + self.update_ref_table_aggregates(keep_orig=keep_orig, processes=processes, chunksize=chunksize) ########## # Clean up output table. - # + # ########## # Find where stars are detected. if self.verbose > 0: - print('') - print(' Preparing the reference table...') - + print(' Preparing the reference table...') + self.ref_table.detections() ### Drop all stars that have 0 detections. - idx = np.where(self.ref_table['n_detect'] == 0)[0] - print(' *** Getting rid of {0:d} out of {1:d} junk sources'.format(len(idx), len(self.ref_table))) + idx = np.where((self.ref_table['n_detect'] == 0))[0] # & (self.ref_table['ref_orig'] == False))[0] + if self.verbose: + print(' *** Getting rid of {0:d} out of {1:d} junk sources'.format(len(idx), len(self.ref_table))) self.ref_table.remove_rows(idx) - if self.iter_callback != None: + if self.iter_callback is not None: self.iter_callback(self.ref_table, nn) + + # Add times into ref_table meta data + all_epochs = get_all_epochs(self.ref_table) + self.ref_table.meta['list_times'] = all_epochs + + # Update chi2 values in ref table, as motion_model_used may have changed + x_inferred, y_inferred, _, _ = self.ref_table.infer_positions(all_epochs, fixed_params_dict=self.fixed_params_dict) + # Convert x_inferred and y_inferred to 2D arrays if they are 1D (i.e. if only one epoch), so that the chi2 calculation works correctly. + if x_inferred.ndim == 1: + x_inferred = x_inferred[:, np.newaxis] + if y_inferred.ndim == 1: + y_inferred = y_inferred[:, np.newaxis] + chi2_x_2d = ((self.ref_table['x'] - x_inferred) / self.ref_table['xe'])**2 + chi2_y_2d = ((self.ref_table['y'] - y_inferred) / self.ref_table['ye'])**2 + chi2_x = np.nansum(chi2_x_2d, axis=1) + chi2_y = np.nansum(chi2_y_2d, axis=1) + chi2_x[~np.isfinite(chi2_x_2d).any(axis=1)] = np.nan + chi2_y[~np.isfinite(chi2_y_2d).any(axis=1)] = np.nan + self.ref_table['chi2_x'] = chi2_x + self.ref_table['chi2_y'] = chi2_y + + # Update t0 and n_fit when no fitting is run because all motion_model_input==Fixed + if ('t0' not in self.ref_table.colnames) or ('n_fit' not in self.ref_table.colnames): + x_data = np.ma.masked_invalid(self.ref_table['x'].data, copy=True) + y_data = np.ma.masked_invalid(self.ref_table['y'].data, copy=True) + xe = self.ref_table['xe'] if 'xe' in self.ref_table.colnames else None + ye = self.ref_table['ye'] if 'ye' in self.ref_table.colnames else None + weighted_xy = (xe is not None) and (ye is not None) + xe_data = np.ma.masked_invalid(self.ref_table['xe'].data, copy=True) if weighted_xy else None + ye_data = np.ma.masked_invalid(self.ref_table['ye'].data, copy=True) if weighted_xy else None + if (xe_data is not None) and (ye_data is not None): + xe_data.mask[np.isclose(xe_data, 0.)] = True + ye_data.mask[np.isclose(ye_data, 0.)] = True + fill_with_one = np.all(xe_data.mask, axis=1) & np.all(ye_data.mask, axis=1) + xe_data[fill_with_one] = 1. + ye_data[fill_with_one] = 1. + + if np.ndim(x_data) == 1: + x_data = x_data[:, np.newaxis] + if np.ndim(y_data) == 1: + y_data = y_data[:, np.newaxis] + if weighted_xy: + if np.ndim(xe_data) == 1: + xe_data = xe_data[:, np.newaxis] + if np.ndim(ye_data) == 1: + ye_data = ye_data[:, np.newaxis] + + if 't' in self.ref_table.colnames: + t_data = copy.deepcopy(self.ref_table['t'].data) + else: + t_data = copy.deepcopy(np.array(self.ref_table.meta['list_times'])) + t_data = np.broadcast_to(t_data, xe_data.shape) + + # Update t0, adapted from startables.fit_motion_models + if 't0' not in self.ref_table.colnames: + weights = 1. / np.hypot(xe_data, ye_data) if weighted_xy else None + self.ref_table['t0'] = np.average(t_data, axis=1, weights=weights) + + # Update n_fit: unique epochs with valid data + if 'n_fit' not in self.ref_table.colnames: + xy_mask = ~ (x_data.mask | y_data.mask) + if weighted_xy: + xy_mask &= ~ (xe_data.mask | ye_data.mask) + + self.ref_table['n_fit'] = np.array([ + len(set(t_data[i][xy_mask[i]])) + for i in range(len(self.ref_table)) + ]) + + if self.save_path is not None: + filename = f'{self.prefix_name}.pkl' + with open(os.path.join(self.save_path, filename), 'wb') as file: + pickle.dump(self, file) + # Using pickle here because nan in a fits file is auto-converted to a masked value in astropy.io.fits.open() + filename = f'{self.prefix_name}_ref_table.pkl' + with open(os.path.join(self.save_path, filename), 'wb') as file: + pickle.dump(self.ref_table, file) + + if self.verbose > 0: + print('===================================') + print('========== Done with fit ==========') + print('===================================') return +# TODO: This is sometimes run on a startable, not a starlist, at least as currently used +def infer_positions(t, startable, motion_models=None, fixed_params_dict=None, return_errors=False): + """ + Take a startable, check to see if it has motion/velocity columns. + If it does, then propagate the positions forward in time + to the desired epoch. If no motion/velocities exist, then just + use ['x0', 'y0'] or ['x', 'y'] + + Parameters + ---------- + t : float + The time to propagate to. Usually in decimal years; + but it should be in the same units + as the 't0' column in starlist. + startable : StarTable + Startable that needs to be inferred. + motion_models : list of MotionModel classes or strings + The motion models to check for in the startable + return_errors : boolean + Whether to return the inferred position errors. If True, then the function returns x, y, xe, ye. If False, then it just returns x, y, by default False. + + Returns + ------- + x, y, (xe, ye) : tuple + Inferred position (and errors) at time t + """ + if ('motion_model_used' in startable.colnames): + x, y, xe, ye = startable.infer_positions(t, fixed_params_dict=fixed_params_dict) + if return_errors: + return x, y, xe, ye + else: + return x, y + + # Convert motion_models from strings to MotionModel classes if needed. + if motion_models is None: + # Setting the default to None to avoid mutable default argument issue + # See https://stackoverflow.com/questions/15189245/assigning-class-variable-as-default-value-to-class-method-argument + motion_models = [Empty, Fixed] + all_mm_map = motion_model.motion_model_map() + if all(isinstance(mm, str) for mm in motion_models): + mm_names = motion_models + motion_models = [all_mm_map[mm] for mm in motion_models] + else: + mm_names = [mm.name for mm in motion_models] + + # Always add Empty and Fixed in motion models + if 'Fixed' not in mm_names: + motion_models.insert(0, Fixed) + if 'Empty' not in mm_names: + motion_models.insert(0, Empty) + + # Otherwise, infer positions using the most complex motion model with the existing columns, until it reaches Fixed or Empty + # Sort motion models inversely by mm.n_params + motion_models = sorted(motion_models, key=lambda mm: mm.n_params, reverse=True) + for mm in motion_models: + if mm.name == 'Empty': + x = startable['x'] + y = startable['y'] + return x, y + + required_columns = mm.fit_param_names + mm.fixed_param_names + if all([param in startable.colnames for param in required_columns]): + # Check if the values are finite for non-string columns in the required columns for this motion model. If not, skip to the next motion model. + if not all([np.isfinite(startable[param]).all() for param in required_columns if startable[param].dtype.kind in 'if']): + continue + + # If we have error columns for all fit parameters, then use them in the model inference. Otherwise, just use the fit parameters without errors. + x, y = mm().model( + t=t, + fit_params=np.array([startable[param] for param in mm.fit_param_names]).T, + fixed_params_dict={param: startable[param] for param in mm.fixed_param_names} + ) + break + + return x, y + + # # If no motion model, check for velocities + # elif ('vx' in startable.colnames) and ('vy' in startable.colnames) and (np.isfinite(startable['vx']).all()) and (np.isfinite(startable['vy']).all()): + # x = startable['x0'] + startable['vx'] * (t - startable['t0']) + # y = startable['y0'] + startable['vy'] * (t - startable['t0']) + + # # If no velocities, try fitted positon + # elif ('x0' in startable.colnames) and ('y0' in startable.colnames) and (np.isfinite(startable['x0']).all()) and (np.isfinite(startable['y0']).all()): + # x = startable['x0'] + # y = startable['y0'] + # # Otherwise, use measured position + # else: + # x = startable['x'] + # y = startable['y'] + # return x, y + +def determine_motion_model(motion_models_possible, k, fixed_params_dict): + """Helper function for multiprocessing determine_motion_models for each star + """ + for mm, req_col_in_table, req_cols, req_col_in_dict in motion_models_possible[::-1]: + # If required column in table/fixed_params dict is numeric, check if all values are finite. + # If so, use mm as motion model and stop further searching + if all(np.isfinite(req_cols[col][k]) for col in req_col_in_table if np.issubdtype(req_cols[col].dtype, np.number)) \ + and all(np.isfinite(fixed_params_dict[col]) for col in req_col_in_dict if np.issubdtype(np.array(fixed_params_dict[col]).dtype, np.number)): + return mm.name, mm.n_params + +def determine_motion_models(startable, motion_models=None, fixed_params_dict=None, processes=1, chunksize=None, verbose=True): + """Determine motion model used in star table based on the finite model parameter columns + + Parameters + ---------- + startable : startable + Startable with motion model parameter columns + motion_models : list of MotionModel or str, optional + List of motion model classes or their names to select from. + If None, all available motion models will be considered, by default None + fixed_params_dict : dict, optional + Dictionary of fixed parameters, by default None + verbose : bool, optional + Show progress bar or not + + Returns + ------- + motion_model_used : list + List of motion model used for each star + n_params : list + List of n parameters per direction for each star + """ + + if motion_models is None: + motion_models = motion_model.MotionModel.__subclasses__() + elif all(isinstance(mm, str) for mm in motion_models): + all_mm_map = motion_model.motion_model_map() + motion_models = [all_mm_map[mm] for mm in motion_models] + + if fixed_params_dict is None: + fixed_params_dict = {} + + motion_models_possible = [] + for mm in motion_models: + required_columns = mm.fit_param_names + mm.fixed_param_names + req_col_in_table = [col for col in required_columns if (col in startable.colnames)] + req_col_in_dict = [col for col in required_columns if (col in fixed_params_dict.keys())] + req_cols = startable[req_col_in_table] + if all((col in startable.colnames) or (col in fixed_params_dict.keys()) for col in required_columns): + motion_models_possible.append((mm, req_col_in_table, req_cols, req_col_in_dict)) + + if processes == 1: + motion_model_used = [] + n_params = [] + for k in tqdm(range(len(startable)), desc='Determining motion models', disable=not verbose): + for mm, req_col_in_table, req_cols, req_col_in_dict in motion_models_possible[::-1]: + # If required column in table/fixed_params dict is numeric, check if all values are finite. + # If so, use mm as motion model and stop further searching + if all(np.isfinite(req_cols[col][k]) for col in req_col_in_table if np.issubdtype(req_cols[col].dtype, np.number)) \ + and all(np.isfinite(fixed_params_dict[col]) for col in req_col_in_dict if np.issubdtype(np.array(fixed_params_dict[col]).dtype, np.number)): + motion_model_used.append(mm.name) + n_params.append(mm.n_params) + break + else: + arguments = [( + motion_models_possible, k, fixed_params_dict + ) for k in range(len(startable))] + + with Pool(processes) as pool: + results = list(pool.starmap( + determine_motion_model, + tqdm( + arguments, + desc=f'Determining motion models with {processes} processes', + disable=not verbose + ), + chunksize=chunksize + )) + motion_model_used = [result[0] for result in results] + n_params = [result[1] for result in results] + + return motion_model_used, n_params + + def get_all_epochs(t): """ Helper function to get times of all epochs from a ref table. - This is required because our previous approach - of simply taking the time array of the star with the most detections - fails for mosaicked catalogs, because it is then possible that + This is required because our previous approach + of simply taking the time array of the star with the most detections + fails for mosaicked catalogs, because it is then possible that no star is detected in all fields. """ nepochs = len(t['t'][0]) @@ -1676,16 +2594,17 @@ def get_all_epochs(t): all_epochs = np.array(all_epochs) return all_epochs - -def setup_ref_table_from_starlist(star_list): - """ + +def setup_ref_table_from_starlist(star_list, motion_models): + """ Start with the reference list.... this will change and grow over time, so make a copy that we will keep updating. The reference table will contain one columne for every named array in the original reference star list. """ col_arrays = {} + motion_model_col_names = motion_model.motion_model_param_names(motion_models, with_errors=True) for col_name in star_list.colnames: if col_name == 'name': # The "name" column will be 1D; but we will also add a "name_in_list" column. @@ -1693,7 +2612,7 @@ def setup_ref_table_from_starlist(star_list): new_col_name = "name_in_list" else: new_col_name = col_name - + # Make every column's 2D arrays except "name" and those # columns used for the motion model. if col_name in motion_model_col_names: @@ -1707,7 +2626,7 @@ def setup_ref_table_from_starlist(star_list): # Make new columns to hold original values. These will be copies # of the old columns and will only include x, y, m, xe, ye, me. - # The columns we have already created will hold transformed values. + # The columns we have already created will hold transformed values. trans_col_names = ['x', 'y', 'm', 'xe', 'ye', 'me', 'w'] for tt in range(len(trans_col_names)): old_name = trans_col_names[tt] @@ -1719,32 +2638,30 @@ def setup_ref_table_from_starlist(star_list): # Make sure ref_table has the necessary x0, y0, m0 and associated # error columns. If they don't exist, then add them as a copy of - # the original x,y,m etc columns. - new_cols_arr = ['x0', 'x0e', 'y0', 'y0e', 'm0', 'm0e'] + # the original x,y,m etc columns. + new_cols_arr = ['x0', 'x0_err', 'y0', 'y0_err', 'm0', 'm0_err'] orig_cols_arr = ['x', 'xe', 'y', 'ye', 'm', 'me'] assert len(new_cols_arr) == len(orig_cols_arr) ref_cols = ref_table.keys() - for ii in range(len(new_cols_arr)): - if not new_cols_arr[ii] in ref_cols: + for new_col, orig_col in zip(new_cols_arr, orig_cols_arr): + if new_col not in ref_cols: # Some munging to convert data shape from (N,1) to (N,), # since these are all 1D cols - vals = np.transpose(np.array(ref_table[orig_cols_arr[ii]]))[0] + vals = np.array(ref_table[orig_col]).flatten() # Now add to ref_table - new_col = Column(vals, name=new_cols_arr[ii]) - ref_table.add_column(new_col) - + ref_table.add_column(vals, name=new_col) + if 'use_in_trans' not in ref_table.colnames: - new_col = Column(np.ones(len(ref_table), dtype=bool), name='use_in_trans') - ref_table.add_column(new_col) + ref_table.add_column(np.ones(len(ref_table), dtype=bool), name='use_in_trans') # Now reset the original values to invalids... they will be filled in # at later times. Preserve content only in the columns: name, x0, y0, m0 (and 0e). - # Note that these are all the 1D columsn. + # Note that these are all the 1D columns. for col_name in ref_table.colnames: if len(ref_table[col_name].data.shape) == 2: # Find the 2D columns - ref_table._set_invalid_list_values(col_name, -1) + ref_table._set_invalid_list_values(col_name, -1) return ref_table @@ -1754,14 +2671,14 @@ def copy_over_values(ref_table, star_list, star_list_T, idx_epoch, idx_ref, idx_ into the reference table we carry around and that is the final output product. Copy only those values for stars that match. - Copy all columns that are in both ref_table and star_list_T. + Copy all columns that are in both ref_table and star_list_T. Copy all columns that are also in star_list but copy them into _orig. Parameters ---------- ref_table : StarTable The table we will be copying values into. Note the columns with the appropriate - names and dimensions must already exist. + names and dimensions must already exist. star_list : StarList The astropy table to copy values from. These should be untransformed (orig) values. star_list_T : StarList @@ -1769,7 +2686,7 @@ def copy_over_values(ref_table, star_list, star_list_T, idx_epoch, idx_ref, idx_ idx_ref : list or array The indices into the ref_table where values are copied to. idx_lis : list or array - The indices into the star_list or star_lsit_T where values are copied from. + The indices into the star_list or star_list_T where values are copied from. """ for col_name in ref_table.colnames: if col_name in star_list_T.colnames: @@ -1788,7 +2705,7 @@ def reset_ref_values(ref_table): """ Reset all the 2D arrays in the reference table. This is the action we take at the beginning of each new iteration. We don't preserve matching - results from the prior iterations. + results from the prior iterations. """ # All 2D columns should be reset. for col_name in ref_table.colnames: @@ -1796,445 +2713,106 @@ def reset_ref_values(ref_table): # Loop through epochs for this array. for cc in range(ref_table[col_name].shape[1]): ref_table._set_invalid_list_values(col_name, cc) - + return -def add_rows_for_new_stars(ref_table, star_list, idx_lis): +def add_rows_for_new_stars(ref_table, star_list, idx_list, motion_model_name='Fixed', fixed_params_dict=None): """ - For each star that is in star_list and NOT in idx_list, make a - new row in the reference table. The values will be empty (None, NAN, etc.). + For each star that is in star_list and NOT in idx_list, make a + new row in the reference table. The values will be empty (None, NAN, etc.). Parameters ---------- ref_table : StarTable The reference table that the rows will be added to. - star_list : StarList The starlist that will be used to estimate how many new stars there are. - - idx_lis : array or list + idx_list : array or list The indices of the non-new stars (those that matched already). The complement of this array will be used as the new stars. + motion_model_name : str + The motion model name to assign to the new stars. + fixed_params_dict : dict + The default fixed parameters to assign to the new stars. - Returns - ---------- - ref_table : StarTable - The reference table with rows added into. - idx_lis_new : list - The list of indices into the star_list object for the "new" stars. - idx_ref_new : list - The list of indices into the ref_table object for the "new" stars. - - """ - last_star_idx = len(ref_table) - - idx_lis_orig = np.arange(len(star_list)) - idx_lis_new = np.array(list(set(idx_lis_orig) - set(idx_lis))) - - if len(idx_lis_new) > 0: - col_arrays = {} - - for col_name in ref_table.colnames: - new_col_name = col_name - - if ref_table[col_name].dtype == np.dtype('float'): - new_col_empty = np.nan - elif ref_table[col_name].dtype == np.dtype('int'): - new_col_empty = -1 - elif ref_table[col_name].dtype == np.dtype('bool'): - new_col_empty = False - else: - new_col_empty = np.nan - - if len(ref_table[col_name].shape) == 1: - new_col_shape = len(idx_lis_new) - else: - new_col_shape = [len(idx_lis_new), ref_table[col_name].shape[1]] - - new_col_data = Column(data=np.tile(new_col_empty, new_col_shape), - name=col_name, dtype=ref_table[col_name].dtype) - col_arrays[new_col_name] = new_col_data - - ref_table_new = StarTable(**col_arrays) - ref_table_nstars = ref_table.meta['n_stars'] + ref_table_new.meta['n_stars'] - ref_table.meta['n_stars'] = ref_table_nstars - ref_table_new.meta['n_stars'] = ref_table_nstars - ref_table_new.meta['ref_list'] = ref_table.meta['ref_list'] - ref_table = vstack([ref_table, ref_table_new]) - - idx_ref_new = np.arange(last_star_idx, len(ref_table)) - - return ref_table, idx_lis_new, idx_ref_new - - -def run_align_iter(catalog, trans_order=1, poly_deg=1, ref_mag_lim=19, ref_radius_lim=300): - # Load up data with matched stars. - d = Table.read(catalog) - - # Determine how many epochs there are. - N_epochs = len([n for n, c in enumerate(d.colnames) if c.startswith('name')]) - - # Determine how many stars there are. - N_stars = len(d) - - # Determine the reference epoch - ref = d.meta['L_REF'] - - # Figure out the number of free parameters for the specified - # poly2d order. - poly2d = models.Polynomial2D(trans_order) - N_par_trans_per_epoch = 2.0 * poly2d.get_num_coeff(2) # one poly2d for each dimension (X, Y) - N_par_trans = N_par_trans_per_epoch * N_epochs - - ########## - # First iteration -- align everything to REF epoch with zero velocities. - ########## - print('ALIGN_EPOCHS: run_align_iter() -- PASS 1') - ee_ref = d.meta['L_REF'] - - target_name = 'OB120169' - - trans1, used1 = calc_transform_ref_epoch(d, target_name, ee_ref, ref_mag_lim, ref_radius_lim) - - ########## - # Derive the velocity of each stars using the round 1 transforms. - ########## - calc_polyfit_all_stars(d, poly_deg, init_fig_idx=0) - - calc_mag_avg_all_stars(d) - - tdx = np.where((d['name_0'] == 'OB120169') | (d['name_0'] == 'OB120169_L'))[0] - print(d[tdx]['name_0', 't0', 'mag', 'x0', 'vx', 'x0e', 'vxe', 'chi2x', 'y0', 'vy', 'y0e', 'vye', 'chi2y', 'dof']) - - ########## - # Second iteration -- align everything to reference positions derived from iteration 1 - ########## - print('ALIGN_EPOCHS: run_align_iter() -- PASS 2') - target_name = 'OB120169' - - trans2, used2 = calc_transform_ref_poly(d, target_name, poly_deg, ref_mag_lim, ref_radius_lim) - - ########## - # Derive the velocity of each stars using the round 1 transforms. - ########## - calc_polyfit_all_stars(d, poly_deg, init_fig_idx=4) - - ########## - # Save output - ########## - d.write(catalog.replace('.fits', '_aln.fits'), overwrite=True) - - return - -def calc_transform_ref_epoch(d, target_name, ee_ref, ref_mag_lim, ref_radius_lim): - # Determine how many epochs there are. - N_epochs = len([n for n, c in enumerate(d.colnames) if c.startswith('name')]) - - # output array - trans = [] - used = [] - - # Find the target - tdx = np.where(d['name_0'] == 'OB120169')[0][0] - - # Reference values - t_ref = d['t_{0:d}'.format(ee_ref)] - m_ref = d['m_{0:d}'.format(ee_ref)] - x_ref = d['x_{0:d}'.format(ee_ref)] - y_ref = d['y_{0:d}'.format(ee_ref)] - xe_ref = d['xe_{0:d}'.format(ee_ref)] - ye_ref = d['ye_{0:d}'.format(ee_ref)] - - # Calculate some quanitites we use for selecting reference stars. - r_ref = np.hypot(x_ref - x_ref[tdx], y_ref - y_ref[tdx]) - - # Loop through and align each epoch to the reference epoch. - for ee in range(N_epochs): - # Pull out the X, Y positions (and errors) for the two - # starlists we are going to align. - x_epo = d['x_{0:d}'.format(ee)] - y_epo = d['y_{0:d}'.format(ee)] - t_epo = d['t_{0:d}'.format(ee)] - xe_epo = d['xe_{0:d}'.format(ee)] - ye_epo = d['ye_{0:d}'.format(ee)] - - # Figure out the set of stars detected in both epochs. - idx = np.where((t_ref != 0) & (t_epo != 0) & (xe_ref != 0) & (xe_epo != 0))[0] - - # Find those in both epochs AND reference stars. This is [idx][rdx] - rdx = np.where((r_ref[idx] < ref_radius_lim) & (m_ref[idx] < ref_mag_lim))[0] - - # Average the positional errors together to get one weight per star. - xye_ref = (xe_ref + ye_ref) / 2.0 - xye_epo = (xe_epo + ye_epo) / 2.0 - xye_wgt = (xye_ref**2 + xye_epo**2)**0.5 - - # Calculate transform based on the matched stars - trans_tmp = transforms.PolyTransform(x_epo[idx][rdx], y_epo[idx][rdx], x_ref[idx][rdx], y_ref[idx][rdx], - weights=xye_wgt[idx][rdx], order=2) - - trans.append(trans_tmp) - - - # Apply thte transformation to the stars positions and errors: - xt_epo = np.zeros(len(d), dtype=float) - yt_epo = np.zeros(len(d), dtype=float) - xet_epo = np.zeros(len(d), dtype=float) - yet_epo = np.zeros(len(d), dtype=float) - - xt_epo[idx], xet_epo[idx], yt_epo[idx], yet_epo[idx] = trans_tmp.evaluate_errors(x_epo[idx], xe_epo[idx], - y_epo[idx], ye_epo[idx], - nsim=100) - - d['xt_{0:d}'.format(ee)] = xt_epo - d['yt_{0:d}'.format(ee)] = yt_epo - d['xet_{0:d}'.format(ee)] = xet_epo - d['yet_{0:d}'.format(ee)] = yet_epo - - # Record which stars we used in the transform. - used_tmp = np.zeros(len(d), dtype=bool) - used_tmp[idx[rdx]] = True - - used.append(used_tmp) - - if True: - plot_quiver_residuals(xt_epo, yt_epo, x_ref, y_ref, idx, rdx, 'Epoch: ' + str(ee)) - - used = np.array(used) - - return trans, used - - -def calc_transform_ref_poly(d, target_name, poly_deg, ref_mag_lim, ref_radius_lim): - # Determine how many epochs there are. - N_epochs = len([n for n, c in enumerate(d.colnames) if c.startswith('name')]) + Returns + ---------- + ref_table : StarTable + The reference table with rows added into. + idx_lis_new : list + The list of indices into the star_list object for the "new" stars. + idx_ref_new : list + The list of indices into the ref_table object for the "new" stars. - # output array - trans = [] - used = [] + """ + last_star_idx = len(ref_table) - # Find the target - tdx = np.where(d['name_0'] == 'OB120169')[0][0] + idx_lis_orig = np.arange(len(star_list)) + idx_lis_new = np.array(list(set(idx_lis_orig) - set(idx_list))) + N_newstars = len(idx_lis_new) - # Temporary Reference values - t_ref = d['t0'] - m_ref = d['mag'] - x_ref = d['x0'] - y_ref = d['y0'] - xe_ref = d['x0e'] - ye_ref = d['y0e'] - - # Calculate some quanitites we use for selecting reference stars. - r_ref = np.hypot(x_ref - x_ref[tdx], y_ref - y_ref[tdx]) + mm_map = motion_model.motion_model_map() + mm = mm_map[motion_model_name] - for ee in range(N_epochs): - # Pull out the X, Y positions (and errors) for the two - # starlists we are going to align. - x_epo = d['x_{0:d}'.format(ee)] - y_epo = d['y_{0:d}'.format(ee)] - t_epo = d['t_{0:d}'.format(ee)] - xe_epo = d['xe_{0:d}'.format(ee)] - ye_epo = d['ye_{0:d}'.format(ee)] - - # Shift the reference position by the polyfit for each star. - dt = t_epo - t_ref - if poly_deg >= 0: - x_ref_ee = x_ref - y_ref_ee = y_ref - xe_ref_ee = x_ref - ye_ref_ee = y_ref - - if poly_deg >= 1: - x_ref_ee += d['vx'] * dt - y_ref_ee += d['vy'] * dt - xe_ref_ee = np.hypot(xe_ref_ee, d['vxe'] * dt) - ye_ref_ee = np.hypot(ye_ref_ee, d['vye'] * dt) - - if poly_deg >= 2: - x_ref_ee += d['ax'] * dt - y_ref_ee += d['ay'] * dt - xe_ref_ee = np.hypot(xe_ref_ee, d['axe'] * dt) - ye_ref_ee = np.hypot(ye_ref_ee, d['aye'] * dt) - - # Figure out the set of stars detected in both. - idx = np.where((t_ref != 0) & (t_epo != 0) & (xe_ref != 0) & (xe_epo != 0))[0] + # Add optional fixed params default values into fixed params dict, prioritizing values in fixed_params_dict + if fixed_params_dict is not None: + fixed_params_dict.update({k: v for k, v in mm.optional_fixed_params.items() if k not in fixed_params_dict}) + else: + fixed_params_dict = mm.optional_fixed_params.copy() - # Find those in both AND reference stars. This is [idx][rdx] - rdx = np.where((r_ref[idx] < ref_radius_lim) & (m_ref[idx] < ref_mag_lim))[0] - - # Average the positional errors together to get one weight per star. - xye_ref = (xe_ref_ee + ye_ref_ee) / 2.0 - xye_epo = (xe_epo + ye_epo) / 2.0 - xye_wgt = (xye_ref**2 + xye_epo**2)**0.5 - - # Calculate transform based on the matched stars - trans_tmp = transforms.PolyTransform(x_epo[idx][rdx], y_epo[idx][rdx], x_ref_ee[idx][rdx], y_ref_ee[idx][rdx], - weights=xye_wgt[idx][rdx], order=2) - trans.append(trans_tmp) - - # Apply thte transformation to the stars positions and errors: - xt_epo = np.zeros(len(d), dtype=float) - yt_epo = np.zeros(len(d), dtype=float) - xet_epo = np.zeros(len(d), dtype=float) - yet_epo = np.zeros(len(d), dtype=float) - - xt_epo[idx], xet_epo[idx], yt_epo[idx], yet_epo[idx] = trans_tmp.evaluate_errors(x_epo[idx], xe_epo[idx], - y_epo[idx], ye_epo[idx], - nsim=100) - d['xt_{0:d}'.format(ee)] = xt_epo - d['yt_{0:d}'.format(ee)] = yt_epo - d['xet_{0:d}'.format(ee)] = xet_epo - d['yet_{0:d}'.format(ee)] = yet_epo + if N_newstars > 0: + col_arrays = {} - # Record which stars we used in the transform. - used_tmp = np.zeros(len(d), dtype=bool) - used_tmp[idx[rdx]] = True + for col_name in ref_table.colnames: + new_col_name = col_name + + if col_name in fixed_params_dict.keys(): + new_col_empty = fixed_params_dict[col_name] + elif col_name=='n_params': + new_col_empty = mm.n_params + elif col_name=='motion_model_input': + new_col_empty = motion_model_name + elif col_name=='motion_model_used': + new_col_empty = 'Empty' + elif ref_table[col_name].dtype == np.dtype('float'): + new_col_empty = np.nan + elif ref_table[col_name].dtype == np.dtype('int'): + new_col_empty = -1 + elif ref_table[col_name].dtype == np.dtype('bool'): + new_col_empty = False + else: + new_col_empty = np.nan - used.append(used_tmp) + if len(ref_table[col_name].shape) == 1: + new_col_shape = N_newstars + else: + new_col_shape = [N_newstars, ref_table[col_name].shape[1]] - if True: - plot_quiver_residuals(xt_epo, yt_epo, x_ref_ee, y_ref_ee, idx, rdx, 'Epoch: ' + str(ee)) + new_col_data = Column( + data=np.tile(new_col_empty, new_col_shape), + name=col_name, + dtype=ref_table[col_name].dtype + ) - used = np.array(used) - - return trans, used + col_arrays[new_col_name] = new_col_data -def calc_polyfit_all_stars(d, poly_deg, init_fig_idx=0): - # Determine how many stars there are. - N_stars = len(d) + ref_table_new = StarTable(**col_arrays) + ref_table_nstars = ref_table.meta['n_stars'] + ref_table_new.meta['n_stars'] + ref_table.meta['n_stars'] = ref_table_nstars + ref_table_new.meta['n_stars'] = ref_table_nstars + ref_table_new.meta['ref_list'] = ref_table.meta['ref_list'] + ref_table = vstack([ref_table, ref_table_new]) - # Determine how many epochs there are. - N_epochs = len([n for n, c in enumerate(d.colnames) if c.startswith('name')]) - - # Setup some variables to save the results - t0_all = [] - px_all = [] - py_all = [] - pxe_all = [] - pye_all = [] - chi2x_all = [] - chi2y_all = [] - dof_all = [] - - # Get the time array, which is the same for all stars. - # Also, sort the time indices. - t = np.array([d['t_{0:d}'.format(ee)][0] for ee in range(N_epochs)]) - tdx = t.argsort() - t_sorted = t[tdx] - - # Run polyfit on each star. - for ss in range(N_stars): - # Get the x, y, xe, ye, and t arrays for this star. - xt = np.array([d['xt_{0:d}'.format(ee)][ss] for ee in range(N_epochs)]) - yt = np.array([d['yt_{0:d}'.format(ee)][ss] for ee in range(N_epochs)]) - xet = np.array([d['xet_{0:d}'.format(ee)][ss] for ee in range(N_epochs)]) - yet = np.array([d['yet_{0:d}'.format(ee)][ss] for ee in range(N_epochs)]) - t_tmp = np.array([d['t_{0:d}'.format(ee)][ss] for ee in range(N_epochs)]) - - # Sort these arrays. - xt_sorted = xt[tdx] - yt_sorted = yt[tdx] - xet_sorted = xet[tdx] - yet_sorted = yet[tdx] - t_tmp_sorted = t_tmp[tdx] - - # Get only the detected epochs. - edx = np.where(t_tmp_sorted != 0)[0] - - # Calculate the weighted t0 (using the transformed errors). - weight_for_t0 = 1.0 / np.hypot(xet_sorted, yet_sorted) - t0 = np.average(t_sorted[edx], weights=weight_for_t0[edx]) - - # for ee in edx: - # print('{0:8.3f} {1:10.5f} {2:10.5f} {3:8.5f} {4:8.5f}'.format(t[ee], xt[ee], yt[ee], xet[ee], yet[ee])) - # pdb.set_trace() - - # Run polyfit - dt = t_sorted - t0 - px, covx = np.polyfit(dt[edx], xt_sorted[edx], poly_deg, w=1./xet_sorted[edx], cov=True) - py, covy = np.polyfit(dt[edx], yt_sorted[edx], poly_deg, w=1./yet_sorted[edx], cov=True) - - pxe = np.sqrt(np.diag(covx)) - pye = np.sqrt(np.diag(covy)) - - - x_mod = np.polyval(px, dt[edx]) - y_mod = np.polyval(py, dt[edx]) - chi2x = np.sum( ((x_mod - xt_sorted[edx]) / xet_sorted[edx])**2 ) - chi2y = np.sum( ((y_mod - yt_sorted[edx]) / yet_sorted[edx])**2 ) - dof = len(edx) - (poly_deg + 1) - - # Save results: - t0_all.append(t0) - px_all.append(px) - py_all.append(py) - pxe_all.append(pxe) - pye_all.append(pye) - chi2x_all.append(chi2x) - chi2y_all.append(chi2y) - dof_all.append(dof) - - if d[ss]['name_0'] in ['OB120169', 'OB120169_L']: - gs = GridSpec(3, 2) # 3 rows, 1 column - fig = plt.figure(ss + 1 + init_fig_idx, figsize=(12, 8)) - a0 = fig.add_subplot(gs[0:2, 0]) - a1 = fig.add_subplot(gs[2, 0]) - a2 = fig.add_subplot(gs[0:2, 1]) - a3 = fig.add_subplot(gs[2, 1]) - - a0.errorbar(t_sorted[edx], xt_sorted[edx], yerr=xet_sorted[edx], fmt='ro') - a0.plot(t_sorted[edx], x_mod, 'k-') - a0.set_title(d[ss]['name_0'] + ' X') - a1.errorbar(t_sorted[edx], xt_sorted[edx] - x_mod, yerr=xet_sorted[edx], fmt='ro') - a1.axhline(0, linestyle='--') - a1.set_xlabel('Time (yrs)') - a2.errorbar(t_sorted[edx], yt_sorted[edx], yerr=yet_sorted[edx], fmt='ro') - a2.plot(t_sorted[edx], y_mod, 'k-') - a2.set_title(d[ss]['name_0'] + ' Y') - a3.errorbar(t_sorted[edx], yt_sorted[edx] - y_mod, yerr=yet_sorted[edx], fmt='ro') - a3.axhline(0, linestyle='--') - a3.set_xlabel('Time (yrs)') + idx_ref_new = np.arange(last_star_idx, len(ref_table)) - + return ref_table, idx_lis_new, idx_ref_new - t0_all = np.array(t0_all) - px_all = np.array(px_all) - py_all = np.array(py_all) - pxe_all = np.array(pxe_all) - pye_all = np.array(pye_all) - chi2x_all = np.array(chi2x_all) - chi2y_all = np.array(chi2y_all) - dof_all = np.array(dof_all) - - # Done with all the stars... recast as numpy arrays and save to output table. - d['t0'] = t0_all - d['chi2x'] = chi2x_all - d['chi2y'] = chi2y_all - d['dof'] = dof_all - if poly_deg >= 0: - d['x0'] = px_all[:, -1] - d['y0'] = py_all[:, -1] - d['x0e'] = pxe_all[:, -1] - d['y0e'] = pye_all[:, -1] - - if poly_deg >= 1: - d['vx'] = px_all[:, -2] - d['vy'] = py_all[:, -2] - d['vxe'] = pxe_all[:, -2] - d['vye'] = pye_all[:, -2] - - if poly_deg >= 2: - d['ax'] = px_all[:, -3] - d['ay'] = py_all[:, -3] - d['axe'] = pxe_all[:, -3] - d['aye'] = pye_all[:, -3] - - pdb.set_trace() - - return +""" +Functions specific to OB120169 moved to align_old_functions,py +""" def calc_mag_avg_all_stars(d): - # Determine how many stars there are. + # Determine how many stars there are. N_stars = len(d) # Determine how many epochs there are. @@ -2258,8 +2836,7 @@ def calc_mag_avg_all_stars(d): -def initial_align(table1, table2, briteN=100, - transformModel=transforms.PolyTransform, order=1, req_match=5): +def initial_align(table1, table2, briteN=100, transformModel=transforms.PolyTransform, order=1): """ Calculates an initial (unweighted) transformation from table1 starlist into table2 starlist (i.e., table2 is the reference starlist). Matching is done using @@ -2276,7 +2853,7 @@ def initial_align(table1, table2, briteN=100, y: y position xe: error in x position ye: error in y position - + vx: proper motion in x direction vy proper motion in y direction vxe: error in x proper motion @@ -2284,11 +2861,11 @@ def initial_align(table1, table2, briteN=100, m: magnitude me: magnitude error - + t0: linear motion time zero point use: specify use in transformation - + Parameters: ---------- @@ -2310,13 +2887,10 @@ def initial_align(table1, table2, briteN=100, -order: int Order of the transformation. Not relevant for 4 parameter or spline fit - -req_match: int - Number of required matches of the input catalog to the total reference - Output: ------ Transformation object - + """ # Extract necessary information from tables (x, y, m) x1 = table1['x'] @@ -2364,7 +2938,7 @@ def transform_and_match(table1, table2, transform, dr_tol=1.0, dm_tol=None, verb starlist file positions. -transform: transformation object - + -verbose: bool, optional Prints on screen information on the matching @@ -2383,7 +2957,6 @@ def transform_and_match(table1, table2, transform, dr_tol=1.0, dm_tol=None, verb y2 = table2['y'] m2 = table2['m'] - # Transform x, y coordinates from starlist 1 into starlist 2 x1t, y1t = transform.evaluate(x1, y1) @@ -2436,7 +3009,7 @@ def find_transform(table1, table1_trans, table2, transModel=transforms.PolyTrans if weights=='starlist', we only use postion error in transformed starlist. if weights=='reference', we only use position error in reference starlist. if weights==None, we don't use weights. - + verbose: bool (default=True) Prints on screen information on the matching @@ -2452,7 +3025,7 @@ def find_transform(table1, table1_trans, table2, transModel=transforms.PolyTrans (transModel != transforms.LegTransform) ): print(( '{0} not supported yet!'.format(transModel))) return - + # Extract *untransformed* coordinates from starlist 1 # and the matching coordinates from starlist 2 x1 = table1['x'] @@ -2464,7 +3037,7 @@ def find_transform(table1, table1_trans, table2, transModel=transforms.PolyTrans # calculate weights from *transformed* coords. This is where we use the # transformation object - if (table1_trans != None) and ('xe' in table1_trans.colnames): + if (table1_trans is not None) and ('xe' in table1_trans.colnames): x1e = table1_trans['xe'] y1e = table1_trans['ye'] @@ -2530,7 +3103,7 @@ def find_transform_new(table1_mat, table2_mat, if weights = 'both' or 'starlist' then the positions in table 1 are first transformed using the transInit object. This is necessary if the plate scales are very different between the table 1 and the reference list. - + verbose: bool (default=True) Prints on screen information on the matching @@ -2543,7 +3116,7 @@ def find_transform_new(table1_mat, table2_mat, if ( (transModel != transforms.four_paramNW) & (transModel != transforms.PolyTransform) ): print(( '{0} not supported yet!'.format(transModel))) return - + # Extract *untransformed* coordinates from starlist 1 # and the matching coordinates from starlist 2 x1 = table1_mat['x'] @@ -2552,18 +3125,18 @@ def find_transform_new(table1_mat, table2_mat, y2 = table2_mat['y'] # Get the uncertainties (if needed) and calculate the weights. - if weights != None: + if weights is not None: x1e = table1_mat['xe'] y1e = table1_mat['ye'] x2e = table2_mat['xe'] y2e = table2_mat['ye'] - if transInit != None: + if transInit is not None: table1T_mat = table1_mat.copy() - table1T_mat = transform_by_object(table1T_mat, transInit) + table1T_mat = transform_from_object(table1T_mat, transInit) - x1e = table1T_mag['xe'] - y1e = table1T_mag['ye'] + x1e = table1T_mat['xe'] + y1e = table1T_mat['ye'] # Calculate weights as to user specification if weights == 'both': @@ -2631,7 +3204,7 @@ def write_transform(transform, starlist, reference, N_trans, deltaMag=0, restric outFile: string (default: 'outTrans.txt') Name of output text file - + Output: ------ txt file with the file name outFile @@ -2639,7 +3212,7 @@ def write_transform(transform, starlist, reference, N_trans, deltaMag=0, restric # Extract info about transformation trans_name = transform.__class__.__name__ trans_order = transform.order - + # Extract X, Y coefficients from transform if trans_name == 'four_paramNW': Xcoeff = transform.px @@ -2648,12 +3221,11 @@ def write_transform(transform, starlist, reference, N_trans, deltaMag=0, restric Xcoeff = transform.px.parameters Ycoeff = transform.py.parameters else: - print(( '{0} not yet supported!'.format(transType))) - return - + raise Exception(f'{trans_name} not yet supported!') + # Write output _out = open(outFile, 'w') - + # Write the header. DO NOT CHANGE, HARDCODED IN JAVA ALIGN _out.write('## Date: {0}\n'.format(datetime.date.today()) ) _out.write('## File: {0}, Reference: {1}\n'.format(starlist, reference) ) @@ -2666,7 +3238,7 @@ def write_transform(transform, starlist, reference, N_trans, deltaMag=0, restric _out.write('## N_trans: {0}\n'.format(N_trans)) _out.write('## Delta Mag: {0}\n'.format(deltaMag)) _out.write('{0:16s} {1:16s}\n'.format('# Xcoeff', 'Ycoeff')) - + # Write the coefficients such that the orders are together as defined in # documentation. This is a pain because PolyTransform output is weird. # (see astropy Polynomial2D documentation) @@ -2677,12 +3249,12 @@ def write_transform(transform, starlist, reference, N_trans, deltaMag=0, restric # CODE TO GET INDICIES N = trans_order - 1 idx_list = list() - + # when trans_order=1, N=0 idx_list.append(0) idx_list.append(1) idx_list.append(N+2) - + if trans_order >= 2: for k in range(2, N+2): idx_list.append(k) @@ -2703,10 +3275,12 @@ def write_transform(transform, starlist, reference, N_trans, deltaMag=0, restric _out.close() - + return +# Transform_from_file original version moved to align_old_functions.py +# This version makes the transFile an object and uses transform_from_object def transform_from_file(starlist, transFile): """ Apply transformation from transFile to starlist. Returns astropy table with @@ -2714,9 +3288,8 @@ def transform_from_file(starlist, transFile): positions/position errors, plus velocities and velocity errors if they are present in starlist. - WARNING: THIS CODE WILL NOT WORK FOR LEGENDRE POLYNOMIAL - TRANSFORMS - + WARNING: THIS CODE WORKS FOR POLYTRANSFORM + Parameters: ---------- starlist: astropy table @@ -2731,154 +3304,32 @@ def transform_from_file(starlist, transFile): ------ Copy of starlist astropy table with transformed coordinates. """ - # Make a copy of starlist. This is what we will eventually modify with - # the transformed coordinates - starlist_f = copy.deepcopy(starlist) - - # Check to see if velocities are present in starlist. If so, we will - # need to transform these as well as positions - vel = False - keys = list(starlist.keys()) - if 'vx' in keys: - vel = True - - # Extract needed information from starlist - x_orig = starlist['x'] - y_orig = starlist['y'] - xe_orig = starlist['xe'] - ye_orig = starlist['ye'] - - if vel: - x0_orig = starlist['x0'] - y0_orig = starlist['y0'] - x0e_orig = starlist['x0e'] - y0e_orig = starlist['y0e'] - - vx_orig = starlist['vx'] - vy_orig = starlist['vy'] - vxe_orig = starlist['vxe'] - vye_orig = starlist['vye'] - - # Read transFile - trans = Table.read(transFile, format='ascii.commented_header', header_start=-1) - Xcoeff = trans['Xcoeff'] - Ycoeff = trans['Ycoeff'] - - #-----------------------------------------------# - # General equation for applying the transform - #-----------------------------------------------# - #""" + # Make transform object + trans_table = Table.read(transFile, format='ascii.commented_header', header_start=-1) + Xcoeff = trans_table['Xcoeff'] + Ycoeff = trans_table['Ycoeff'] # First determine the order based on the number of terms # Comes from Nterms = (N+1)*(N+2) / 2. order = (np.sqrt(1 + 8*len(Xcoeff)) - 3) / 2. - if order%1 != 0: print( 'Incorrect number of coefficients for polynomial') print( 'Stopping') return order = int(order) + # Do transform + transform = transforms.PolyTransform(order, Xcoeff, Ycoeff) + return transform_from_object(starlist, transform) - # Position transformation - x_new, y_new = transform_pos_from_file(Xcoeff, Ycoeff, order, x_orig, - y_orig) - - if vel: - x0_new, y0_new = transform_pos_from_file(Xcoeff, Ycoeff, order, x0_orig, - y0_orig) - - # Position error transformation - xe_new, ye_new = transform_poserr_from_file(Xcoeff, Ycoeff, order, xe_orig, - ye_orig, x_orig, y_orig) - - if vel: - x0e_new, y0e_new = transform_poserr_from_file(Xcoeff, Ycoeff, order, x0e_orig, - y0e_orig, x0_orig, y0_orig) - - if vel: - # Velocity transformation - vx_new, vy_new = transform_vel_from_file(Xcoeff, Ycoeff, order, vx_orig, - vy_orig, x_orig, y_orig) - - # Velocity error transformation - vxe_new, vye_new = transform_velerr_from_file(Xcoeff, Ycoeff, order, - vxe_orig, vye_orig, - vx_orig, vy_orig, - xe_orig, ye_orig, - x_orig, y_orig) - - #----------------------------------------# - # Hard coded example: old but functional - #----------------------------------------# - """ - # How the transformation is applied depends on the type of transform. - # This can be determined by the length of Xcoeff, Ycoeff - if len(Xcoeff) == 3: - x_new = Xcoeff[0] + Xcoeff[1] * x_orig + Xcoeff[2] * y_orig - y_new = Ycoeff[0] + Ycoeff[1] * x_orig + Ycoeff[2] * y_orig - xe_new = np.sqrt( (Xcoeff[1] * xe_orig)**2 + (Xcoeff[2] * ye_orig)**2 ) - ye_new = np.sqrt( (Ycoeff[1] * xe_orig)**2 + (Ycoeff[2] * ye_orig)**2 ) - - if vel: - vx_new = Xcoeff[1] * vx_orig + Xcoeff[2] * vy_orig - vy_new = Ycoeff[1] * vx_orig + Ycoeff[2] * vy_orig - vxe_new = np.sqrt( (Xcoeff[1] * vxe_orig)**2 + (Xcoeff[2] * vye_orig)**2 ) - vye_new = np.sqrt( (Ycoeff[1] * vxe_orig)**2 + (Ycoeff[2] * vye_orig)**2 ) - - elif len(Xcoeff) == 6: - x_new = Xcoeff[0] + Xcoeff[1]*x_orig + Xcoeff[3]*x_orig**2 + Xcoeff[2]*y_orig + \ - Xcoeff[5]*y_orig**2. + Xcoeff[4]*x_orig*y_orig - - y_new = Ycoeff[0] + Ycoeff[1]*x_orig + Ycoeff[3]*x_orig**2 + Ycoeff[2]*y_orig + \ - Ycoeff[5]*y_orig**2. + Ycoeff[4]*x_orig*y_orig - - xe_new = np.sqrt( (Xcoeff[1] + 2*Xcoeff[3]*x_orig + Xcoeff[4]*y_orig)**2 * xe_orig**2 + \ - (Xcoeff[2] + 2*Xcoeff[5]*y_orig + Xcoeff[4]*x_orig)**2 * ye_orig**2 ) - - ye_new = np.sqrt( (Ycoeff[1] + 2*Ycoeff[3]*x_orig + Ycoeff[4]*y_orig)**2 * xe_orig**2 + \ - (Ycoeff[2] + 2*Ycoeff[5]*y_orig + Ycoeff[4]*x_orig)**2 * ye_orig**2 ) - - if vel: - vx_new = Xcoeff[1]*vx_orig + 2*Xcoeff[3]*x_orig*vx_orig + Xcoeff[2]*vy_orig + \ - 2.*Xcoeff[5]*y_orig*vy_orig + Xcoeff[4]*(x_orig*vy_orig + vx_orig*y_orig) - - vy_new = Ycoeff[1]*vx_orig + 2*Ycoeff[3]*x_orig*vx_orig + Ycoeff[2]*vy_orig + \ - 2.*Ycoeff[5]*y_orig*vy_orig + Ycoeff[4]*(x_orig*vy_orig + vx_orig*y_orig) - - vxe_new = np.sqrt( (Xcoeff[1] + 2*Xcoeff[3]*x_orig + Xcoeff[4]*y_orig)**2 * vxe_orig**2 + \ - (Xcoeff[2] + 2*Xcoeff[5]*y_orig + Xcoeff[4]*x_orig)**2 * vye_orig**2 + \ - (2*Xcoeff[3]*vx_orig + Xcoeff[4]*vy_orig)**2 * xe_orig**2 + \ - (2*Xcoeff[5]*vy_orig + Xcoeff[4]*vx_orig)**2 * ye_orig**2 ) - - vye_new = np.sqrt( (Ycoeff[1] + 2*Ycoeff[3]*x_orig + Ycoeff[4]*y_orig)**2 * vxe_orig**2 + \ - (Ycoeff[2] + 2*Ycoeff[5]*y_orig + Ycoeff[4]*x_orig)**2 * vye_orig**2 + \ - (2*Ycoeff[3]*vx_orig + Ycoeff[4]*vy_orig)**2 * xe_orig**2 + \ - (2*Ycoeff[5]*vy_orig + Ycoeff[4]*vx_orig)**2 * ye_orig**2 ) - """ - #Update transformed coords to copy of astropy table - starlist_f['x'] = x_new - starlist_f['y'] = y_new - starlist_f['xe'] = xe_new - starlist_f['ye'] = ye_new - - if vel: - starlist_f['x0'] = x0_new - starlist_f['y0'] = y0_new - starlist_f['x0e'] = x0e_new - starlist_f['y0e'] = y0e_new - starlist_f['vx'] = vx_new - starlist_f['vy'] = vy_new - starlist_f['vxe'] = vxe_new - starlist_f['vye'] = vye_new - - return starlist_f def transform_from_object(starlist, transform): """ Apply transformation to starlist. Returns astropy table with transformed positions/position errors, velocities and velocity errors - if they are present in starlits - + if they are present in starlits. If a more complex motion_model is + implemented, the motion parameters are set to nan, as we need the full time + series to refit. + Parameters: ---------- starlist: astropy table @@ -2899,11 +3350,24 @@ def transform_from_object(starlist, transform): starlist_f = copy.deepcopy(starlist) keys = list(starlist.keys()) - # Check to see if velocities are present in starlist. If so, we will - # need to transform these as well as positions - vel = 'vx' in keys + # Check to see if velocities or motion_model are present in starlist. + vel = ('vx' in keys) and ("motion_model_input" not in keys) + mot = ("motion_model_input" in keys) + # If the only motion models used are Fixed and Linear, we can still transform velocities. + if mot: + motion_models_unique = list(np.unique(starlist_f['motion_model_input'])) + if 'Linear' in motion_models_unique: + motion_models_unique.remove('Linear') + if 'Fixed' in motion_models_unique: + motion_models_unique.remove('Fixed') + if len(motion_models_unique)==0: + vel=True + mot=False + + # Prior code before motion_model implementation + # Can still be used as shortcut for Linear+Fixed motion_model only err = 'xe' in keys - + # Extract needed information from starlist x = starlist_f['x'] y = starlist_f['y'] @@ -2911,49 +3375,50 @@ def transform_from_object(starlist, transform): if err: xe = starlist_f['xe'] ye = starlist_f['ye'] + else: + xe = np.zeros(len(starlist_f)) + ye = np.zeros(len(starlist_f)) if vel: x0 = starlist_f['x0'] y0 = starlist_f['y0'] - x0e = starlist_f['x0e'] - y0e = starlist_f['y0e'] + x0e = starlist_f['x0_err'] + y0e = starlist_f['y0_err'] vx = starlist_f['vx'] vy = starlist_f['vy'] - vxe = starlist_f['vxe'] - vye = starlist_f['vye'] - + vxe = starlist_f['vx_err'] + vye = starlist_f['vy_err'] + # calculate the transformed position and velocity - - # (x_new, y_new, xe_new, ye_new) in (x,y) x_new, y_new, xe_new, ye_new = position_transform_from_object(x, y, xe, ye, transform) - - if vel: - # (x0_new, y0_new, x0e_new, y0e_new) in (x0, y0, x0e, y0e) - x0_new, y0_new, x0e_new, y0e_new = position_transform_from_object(x0, y0, x0e, y0e, transform) - # (vx_new, vy_new, vxe_new, vye_new) in (x0, y0, x0e, y0e, vx, vy, vxe, vye) - vx_new, vy_new, vxe_new, vye_new = velocity_transform_from_object(x0, y0, x0e, y0e, vx, vy, vxe, vye, transform) - # update transformed coords to copy of astropy table starlist_f['x'] = x_new starlist_f['y'] = y_new starlist_f['xe'] = xe_new starlist_f['ye'] = ye_new - + if vel: + x0_new, y0_new, x0e_new, y0e_new = position_transform_from_object(x0, y0, x0e, y0e, transform) + vx_new, vy_new, vxe_new, vye_new = velocity_transform_from_object(x0, y0, x0e, y0e, vx, vy, vxe, vye, transform) starlist_f['x0'] = x0_new starlist_f['y0'] = y0_new - starlist_f['x0e'] = x0e_new - starlist_f['y0e'] = y0e_new + starlist_f['x0_err'] = x0e_new + starlist_f['y0_err'] = y0e_new starlist_f['vx'] = vx_new starlist_f['vy'] = vy_new - starlist_f['vxe'] = vxe_new - starlist_f['vye'] = vye_new - - return starlist_f - + starlist_f['vx_err'] = vxe_new + starlist_f['vy_err'] = vye_new + # For more complicated motion_models, + # we can't easily transform them, set the values to nans and refit later. + if mot: + motion_model_params = motion_model.motion_model_param_names() + for param in motion_model_params: + if param in keys: + starlist_f[param] = np.nan + return starlist_f def position_transform_from_object(x, y, xe, ye, transform): @@ -2965,7 +3430,7 @@ def position_transform_from_object(x, y, xe, ye, transform): - x, y: original position - xe, ye: original position error - transform: transformation object from astropy.modeling.models.polynomial2D - + Outpus: - x_new, y_new: transformed position - xe_new, ye_new: transformed position error @@ -2982,8 +3447,8 @@ def position_transform_from_object(x, y, xe, ye, transform): order = transform.order else: txt = 'Transform not yet supported by position_transform_from_object' - raise StandardError(txt) - + raise Exception(txt) + # How the transformation is applied depends on the type of transform. # This can be determined by the length of Xcoeff, Ycoeff N = order - 1 @@ -3008,9 +3473,8 @@ def position_transform_from_object(x, y, xe, ye, transform): sub = int(2*N + 2 + j + (2*N+2-i) * (i-1)/2.) y_new += Ycoeff[sub] * (x**i) * (y**j) - """ - THIS IS WRONG BELOW! + THIS IS WRONG BELOW! - NOTE: I don't think this is wrong any more Currently doing: ((A + B + C) * xe)**2 @@ -3018,7 +3482,7 @@ def position_transform_from_object(x, y, xe, ye, transform): Should be doing: ((A**2 + B**2 + C**2) * xe**2) """ - + # xe_new & ye_new in (x,y,xe,ye) xe_new = 0 temp1 = 0 @@ -3066,11 +3530,11 @@ def velocity_transform_from_object(x0, y0, x0e, y0e, vx, vy, vxe, vye, transform - x0, y0, x0e, y0e: original position and position error - vx, vy, vxe, vye: original velocity and velocity error - transform: transformation object from astropy.modeling.models.polynomial2D - + Outpus: - vx_new, vy_new, vxe_new, vye_new: transformed velocity and velocity error """ - + # Read transformation: Extract X, Y coefficients from transform if transform.__class__.__name__ == 'four_paramNW': Xcoeff = transform.px @@ -3082,8 +3546,8 @@ def velocity_transform_from_object(x0, y0, x0e, y0e, vx, vy, vxe, vye, transform order = transform.order else: txt = 'Transform not yet supported by velocity_transform_from_object' - raise StandardError(txt) - + raise Exception(txt) + # How the transformation is applied depends on the type of transform. # This can be determined by the length of Xcoeff, Ycoeff N = order - 1 @@ -3144,7 +3608,7 @@ def velocity_transform_from_object(x0, y0, x0e, y0e, vx, vy, vxe, vye, transform for i in range(1, N+1): for j in range(1, N+2-i): sub = 2*N + 2 + j + (2*N+2-i) * (i-1)/2. - temp3 += i * Xcoeff[int(sub)] * (x0**(i-1)) * (y0**j) + temp3 += i * Xcoeff[int(sub)] * (x0**(i-1)) * (y0**j) for j in range(1, N+2): temp4 += j * Xcoeff[N+1+j] * (y0**(j-1)) @@ -3155,7 +3619,6 @@ def velocity_transform_from_object(x0, y0, x0e, y0e, vx, vy, vxe, vye, transform vxe_new = np.sqrt((temp1*x0e)**2 + (temp2*y0e)**2 + (temp3*vxe)**2 + (temp4*vye)**2) - vye_new = 0 temp1 = 0 temp2 = 0 @@ -3188,7 +3651,7 @@ def velocity_transform_from_object(x0, y0, x0e, y0e, vx, vy, vxe, vye, transform for i in range(1, N+1): for j in range(1, N+2-i): sub = 2*N + 2 + j + (2*N+2-i) * (i-1)/2. - temp3 += i * Ycoeff[int(sub)] * (x0**(i-1)) * (y0**j) + temp3 += i * Ycoeff[int(sub)] * (x0**(i-1)) * (y0**j) for j in range(1, N+2): temp4 += j * Ycoeff[N+1+j] * (y0**(j-1)) @@ -3202,344 +3665,66 @@ def velocity_transform_from_object(x0, y0, x0e, y0e, vx, vy, vxe, vye, transform return vx_new, vy_new, vxe_new, vye_new -def transform_pos_from_file(Xcoeff, Ycoeff, order, x_orig, y_orig): - """ - Given the read-in coefficients from transform_from_file, apply the - transformation to the observed positions. This is generalized to - work with any order polynomial transform. - - WARNING: THIS CODE WILL NOT WORK FOR LEGENDRE POLYNOMIAL - TRANSFORMS - - Parameters: - ---------- - Xcoeff: Array - Array with the coefficients of the X pos transformation - - Ycoeff: Array - Array with the coefficients of the Y pos transformation - - order: int - Order of transformation - - x_orig: array - Array with the original X positions - - y_orig: array - Array with the original Y positions - - Output: - ------ - x_new: array - Transformed X positions - - y_new: array - Transformed Y positions - - """ - idx = 0 # coeff index - x_new = 0.0 - y_new = 0.0 - for i in range(order+1): - for j in range(i+1): - x_new += Xcoeff[idx] * x_orig**(i-j) * y_orig**j - y_new += Ycoeff[idx] * x_orig**(i-j) * y_orig**j - - idx += 1 - - return x_new, y_new - -def transform_poserr_from_file(Xcoeff, Ycoeff, order, xe_orig, ye_orig, x_orig, y_orig): - """ - Given the read-in coefficients from transform_from_file, apply the - transformation to the observed position errors. This is generalized to - work with any order transform. - - WARNING: THIS CODE WILL NOT WORK FOR LEGENDRE POLYNOMIAL - TRANSFORMS - - Parameters: - ---------- - Xcoeff: Array - Array with the coefficients of the X pos transformation - - Ycoeff: Array - Array with the coefficients of the Y pos transformation - - order: int - Order of transformation - - xe_orig: array - Array with the original X position errs - - ye_orig: array - Array with the original Y position errs - - x_orig: array - Array with the original X positions - - y_orig: array - Array with the original Y positions - - Output: - ------ - xe_new: array - Transformed X position errs - - ye_new: array - Transformed Y position errs - """ - idx = 0 # coeff index - xe_new_tmp1 = 0.0 - ye_new_tmp1 = 0.0 - xe_new_tmp2 = 0.0 - ye_new_tmp2 = 0.0 - - # First loop: dx'/dx - for i in range(order+1): - for j in range(i+1): - xe_new_tmp1 += Xcoeff[idx] * (i - j) * x_orig**(i-j-1) * y_orig**j - ye_new_tmp1 += Ycoeff[idx] * (i - j) * x_orig**(i-j-1) * y_orig**j - - idx += 1 - - # Second loop: dy'/dy - idx = 0 # coeff index - for i in range(order+1): - for j in range(i+1): - xe_new_tmp2 += Xcoeff[idx] * (j) * x_orig**(i-j) * y_orig**(j-1) - ye_new_tmp2 += Ycoeff[idx] * (j) * x_orig**(i-j) * y_orig**(j-1) - - idx += 1 - # Take square root for xe/ye_new - xe_new = np.sqrt((xe_new_tmp1 * xe_orig)**2 + (xe_new_tmp2 * ye_orig)**2) - ye_new = np.sqrt((ye_new_tmp1 * ye_orig)**2 + (ye_new_tmp2 * ye_orig)**2) - - return xe_new, ye_new - -def transform_vel_from_file(Xcoeff, Ycoeff, order, vx_orig, vy_orig, x_orig, y_orig): - """ - Given the read-in coefficients from transform_from_file, apply the - transformation to the observed proper motions. This is generalized to - work with any order transform. - - WARNING: THIS CODE WILL NOT WORK FOR LEGENDRE POLYNOMIAL - TRANSFORMS - - Parameters: - ---------- - Xcoeff: Array - Array with the coefficients of the X pos transformation - - Ycoeff: Array - Array with the coefficients of the Y pos transformation - - order: int - Order of transformation - - vx_orig: array - Array with the original X proper motions - - vy_orig: array - Array with the original Y proper motions - - x_orig: array - Array with the original X positions - - y_orig: array - Array with the original Y positions - - Output: - ------ - vx_new: array - Transformed X proper motions - - vy_new: array - Transformed Y proper motions - """ - idx = 0 # coeff index - vx_new = 0.0 - vy_new = 0.0 - # First loop: dx'/dx - for i in range(order+1): - for j in range(i+1): - vx_new += Xcoeff[idx] * (i - j) * x_orig**(i-j-1) * y_orig**j * vx_orig - vy_new += Ycoeff[idx] * (i - j) * x_orig**(i-j-1) * y_orig**j * vx_orig - - idx += 1 - # Second loop: dy'/dy - idx = 0 # coeff index - for i in range(order+1): - for j in range(i+1): - vx_new += Xcoeff[idx] * (j) * x_orig**(i-j) * y_orig**(j-1) * vy_orig - vy_new += Ycoeff[idx] * (j) * x_orig**(i-j) * y_orig**(j-1) * vy_orig - - idx += 1 - - return vx_new, vy_new - -def transform_velerr_from_file(Xcoeff, Ycoeff, order, vxe_orig, vye_orig, vx_orig, - vy_orig, xe_orig, ye_orig, x_orig, y_orig): - """ - Given the read-in coefficients from transform_from_file, apply the - transformation to the observed proper motion errors. This is generalized to - work with any order transform. - - WARNING: THIS CODE WILL NOT WORK FOR LEGENDRE POLYNOMIAL - TRANSFORMS - - Parameters: - ---------- - Xcoeff: Array - Array with the coefficients of the X pos transformation - - Ycoeff: Array - Array with the coefficients of the Y pos transformation - - order: int - Order of transformation - - vxe_orig: array - Array with the original X proper motion errs - - vye_orig: array - Array with the original Y proper motion errs - - vx_orig: array - Array with the original X proper motions - - vy_orig: array - Array with the original Y proper motions - - xe_orig: array - Array with the original X position errs - - ye_orig: array - Array with the original Y position errs - - x_orig: array - Array with the original X positions - - y_orig: array - Array with the original Y positions - - Output: - ------ - vxe_new: array - Transformed X proper motion errs - - vye_new: array - Transformed Y proper motion errs - """ - idx = 0 - vxe_new_tmp1 = 0.0 - vye_new_tmp1 = 0.0 - vxe_new_tmp2 = 0.0 - vye_new_tmp2 = 0.0 - vxe_new_tmp3 = 0.0 - vye_new_tmp3 = 0.0 - vxe_new_tmp4 = 0.0 - vye_new_tmp4 = 0.0 - - - # First loop: dvx' / dx - for i in range(order+1): - for j in range(i+1): - vxe_new_tmp1 += Xcoeff[idx] * (i-j) * (i-j-1) * x_orig**(i-j-2) * y_orig**j * vx_orig - vxe_new_tmp1 += Xcoeff[idx] * (j) * (i-j) * x_orig**(i-j-1) * y_orig**(j-1) * vy_orig - vye_new_tmp1 += Ycoeff[idx] * (i-j) * (i-j-1) * x_orig**(i-j-2) * y_orig**j * vx_orig - vye_new_tmp1 += Ycoeff[idx] * (j) * (i-j) * x_orig**(i-j-1) * y_orig**(j-1) * vy_orig - - idx += 1 - - # Second loop: dvx' / dy - idx = 0 - for i in range(order+1): - for j in range(i+1): - vxe_new_tmp2 += Xcoeff[idx] * (i-j) * (j) * x_orig**(i-j-1) * y_orig**(j-1) * vx_orig - vxe_new_tmp2 += Xcoeff[idx] * (j) * (j-1) * x_orig**(i-j-1) * y_orig**(j-2) * vy_orig - vye_new_tmp2 += Ycoeff[idx] * (i-j) * (j) * x_orig**(i-j-1) * y_orig**(j-1) * vx_orig - vye_new_tmp2 += Ycoeff[idx] * (j) * (j-1) * x_orig**(i-j-1) * y_orig**(j-2) * vy_orig - - idx += 1 - - # Third loop: dvx' / dvx - idx = 0 - for i in range(order+1): - for j in range(i+1): - vxe_new_tmp3 += Xcoeff[idx] * (i-j) * x_orig**(i-j-1) * y_orig**j - vye_new_tmp3 += Ycoeff[idx] * (i-j) * x_orig**(i-j-1) * y_orig**j - - idx += 1 - - # Fourth loop: dvx' / dvy - idx = 0 - for i in range(order+1): - for j in range(i+1): - vxe_new_tmp4 += Xcoeff[idx] * (j) * x_orig**(i-j) * y_orig**(j-1) - vye_new_tmp4 += Ycoeff[idx] * (j) * x_orig**(i-j) * y_orig**(j-1) - - idx += 1 - - vxe_new = np.sqrt((vxe_new_tmp1 * xe_orig)**2 + (vxe_new_tmp2 * ye_orig)**2 + \ - (vxe_new_tmp3 * vxe_orig)**2 + (vxe_new_tmp4 * vye_orig)**2) - vye_new = np.sqrt((vye_new_tmp1 * xe_orig)**2 + (vye_new_tmp2 * ye_orig)**2 + \ - (vye_new_tmp3 * vxe_orig)**2 + (vye_new_tmp4 * vye_orig)**2) - - return vxe_new, vye_new - - -def check_iter_tolerances(iters, dr_tol, dm_tol, outlier_tol): - # iteration tolerances must match the number of iterations requested. - assert iters == len(dr_tol) - assert iters == len(dm_tol) - assert iters == len(outlier_tol) - - return - def check_trans_input(list_of_starlists, trans_input, mag_trans): # Check trans_input # If we are transforming magnitudes and their are input transformations, # then they need to have a mag_offset on them. - if trans_input != None: - assert len(trans_input) == len(list_of_starlists) + if trans_input is not None: + assert len(trans_input) == len(list_of_starlists), f'trans_input (len={len(trans_input)}) must have the same length as list_of_starlists (len={len(list_of_starlists)})!' - if mag_trans: + if mag_trans: for ii in range(len(trans_input)): - if trans_input[ii] != None: + if trans_input[ii] is not None: try: trans_input[ii].mag_offset except NameError: print('Missing trans.mag_offset on trans_input[{0:d}].'.format(ii)) print('Setting mag_offset = 0 and dm_tol[0] = 100 and hoping for the best!!') trans_input[ii].mag_offset = 0.0 - + return -def trans_initial_guess(ref_list, star_list, trans_args, mode='miracle', - ignore_contains='star', verbose=True, n_req_match=3, - mag_trans=True, order=1): +def trans_initial_guess( + ref_list, + star_list, + trans_args, + mode='miracle', + order=1, + briteN=None, + n_req_match=3, + polygon_reflist=None, + polygon_starlist=None, + buffer=0, + motion_models=None, + fixed_params_dict=None, + ignore_contains='star', + mag_trans=True, + verbose=True +): """ Take two starlists and perform an initial matching and transformation. This function will grow with time to handle difference types of initial guess transformations (triangle matching, match by name, etc.). For now it - is just blind triangle matching on the brightest 50 stars. + is just blind triangle matching on the brightest 50 stars. """ warnings.filterwarnings('ignore', category=AstropyUserWarning) - + if motion_models is None: + motion_models = [] + + # Match by name if mode == 'name': # First trim the two lists down to only those that don't contain # the "ignore_contains" string. - idx_r = np.flatnonzero(np.char.find(ref_list['name'], ignore_contains) == -1) - idx_s = np.flatnonzero(np.char.find(star_list['name'], ignore_contains) == -1) + idx_r = np.flatnonzero(np.char.find(ref_list['name'].astype(str), ignore_contains) == -1) + idx_s = np.flatnonzero(np.char.find(star_list['name'].astype(str), ignore_contains) == -1) # Match the star names name_matches, ndx_r, ndx_s = np.intersect1d(ref_list['name'][idx_r], star_list['name'][idx_s], assume_unique=True, return_indices=True) - + x1m = star_list['x'][idx_s][ndx_s] y1m = star_list['y'][idx_s][ndx_s] m1m = star_list['m'][idx_s][ndx_s] @@ -3548,31 +3733,47 @@ def trans_initial_guess(ref_list, star_list, trans_args, mode='miracle', m2m = ref_list['m'][idx_r][ndx_r] N = len(x1m) - else: - # Default is miracle match. - briteN = min(50, len(star_list)) + # Default is miracle match. + elif mode == 'miracle': + if briteN is None: + briteN = min(50, len(star_list)) + else: + assert (type(briteN) == int) and (briteN > 0), f'briteN must be a positive integer, but got {briteN}.' # If there are velocities in the reference list, use them. # We assume velocities are in the same units as the positions. - xref, yref = get_pos_at_time(star_list['t'][0], ref_list) + xref, yref = infer_positions(star_list['t'][0], ref_list, motion_models, fixed_params_dict=fixed_params_dict) if 'm' in ref_list.colnames: mref = ref_list['m'] else: mref = ref_list['m0'] - - N, x1m, y1m, m1m, x2m, y2m, m2m = match.miracle_match_briteN(star_list['x'], - star_list['y'], - star_list['m'], - xref, - yref, - mref, - briteN) - - err_msg = 'Failed to find more than '+str(n_req_match) - err_msg += ' (only ' + str(len(x1m)) + ') matches, giving up.' - assert len(x1m) >= n_req_match, err_msg + + N, x1m, y1m, m1m, x2m, y2m, m2m = match.miracle_match_briteN( + star_list['x'], + star_list['y'], + star_list['m'], + xref, + yref, + mref, + briteN, + polygon_reflist, + polygon_starlist, + buffer=buffer + ) + else: + raise ValueError(f'flystar.align.trans_initial_guess: Unknown mode: {mode}. Must be one of ["name", "miracle"].') + + if len(x1m) < n_req_match: + fig, ax = plt.subplots() + ax.scatter(star_list['x'], star_list['y'], s=1, label='star_list') + ax.scatter(xref, yref, s=1, label='ref_list') + ax.legend() + ax.set_aspect('equal') + plt.show() + raise AssertionError(f'Failed to find more than {n_req_match} (only {len(x1m)}) matches, giving up.') + if verbose > 1: - print('initial_guess: {0:d} stars matched between starlist and reference list'.format(N)) + print('Initial_guess: {0:d} stars matched between starlist and reference list'.format(N)) # Calculate position transformation based on matches if ('order' in trans_args) and (trans_args['order'] == 0): @@ -3589,24 +3790,24 @@ def trans_initial_guess(ref_list, star_list, trans_args, mode='miracle', trans.mag_offset = np.mean(m2m - m1m) else: trans.mag_offset = 0 - + if verbose > 1: - print('init guess: ', trans.px.parameters, trans.py.parameters) + print('Initial guess:') + print(f'{trans.px.parameters=}') + print(f'{trans.py.parameters=}') + print(f'{trans.mag_offset=}') warnings.filterwarnings('default', category=AstropyUserWarning) - + return trans def update_old_and_new_names(ref_table, list_index, idx_ref_new): # Make new ref_list names for the new stars. new_names = [] - new_name_len_max = 0 - for ss in idx_ref_new: - new_name = '{0:3d}_{1:s}'.format(list_index, ref_table['name_in_list'][ss, list_index]) - new_names.append(new_name) - new_name_len_max = max(new_name_len_max, len(new_name)) + new_names = [f"{list_index:3d}_{name}" for name in ref_table['name_in_list'][idx_ref_new, list_index]] + new_name_len_max = np.max([len(new_name) for new_name in new_names]) old_names = ref_table['name'] old_name_len = [len(old_name) for old_name in old_names] @@ -3616,15 +3817,15 @@ def update_old_and_new_names(ref_table, list_index, idx_ref_new): all_names = old_names.astype('U{0:d}'.format(new_name_len_max)) else: all_names = old_names - + all_names[idx_ref_new] = new_names - + return all_names def copy_and_rename_for_ref(star_list): """ Make a deep copy of the starlist and rename the columns to include - "0". This only applies to x, y, m and xe, ye, me (if they exist) + "0". This only applies to x, y, m and xe, ye, me (if they exist) columns. Input @@ -3637,17 +3838,17 @@ def copy_and_rename_for_ref(star_list): if 'xe' in star_list.colnames: old_cols += ['xe'] - new_cols += ['x0e'] + new_cols += ['x0_err'] if 'ye' in star_list.colnames: old_cols += ['ye'] - new_cols += ['y0e'] + new_cols += ['y0_err'] if 'me' in star_list.colnames: old_cols += ['me'] - new_cols += ['m0e'] + new_cols += ['m0_err'] if 'w' in star_list.colnames: old_cols += ['w'] new_cols += ['w'] - + ref_list = copy.deepcopy(star_list) for ii in range(len(old_cols)): @@ -3655,51 +3856,51 @@ def copy_and_rename_for_ref(star_list): return ref_list -def outlier_rejection_indices(star_list, ref_list, outlier_tol, verbose=True): +def outlier_rejection_indices(star_list, ref_list, outlier_tol, motion_models, fixed_params_dict=None, verbose=True): """ Determine the outliers based on the residual positions between two different - starlists and some threshold (in sigma). Return the indices of the stars - to keep (that shouldn't be rejected as outliers). + starlists and some threshold (in sigma). Return the indices of the stars + to keep (that shouldn't be rejected as outliers). Note that we assume that the star_list and ref_list are already transformed and - matched. + matched. Parameters ---------- star_list : StarList starlist with 'x', 'y' - ref_list : StarList starlist with 'x0', 'y0' - outlier_tol : float - Number of sigma inside which we keep stars and outside of which we - reject stars as outliers. - - Optional Parameters - -------------------- - verbose : boolean + Number of sigma inside which we keep stars and outside of which we + reject stars as outliers. + motion_models : list of motion_model objects + The motion models to use in the star_list + fixed_params_dict : dict or None, optional + Dictionary of fixed parameters for motion models, by default None + verbose : bool, optional + If True, print information about the outlier rejection process, by default True Returns ---------- - keepers : nd.array - The indicies of the stars to keep. + keepers : bool array + The boolean array of the stars to keep. """ # Optionally propogate the reference positions forward in time. - xref, yref = get_pos_in_time(star_list['t'][0], ref_list) - + xref, yref = infer_positions(star_list['t'][0], ref_list, motion_models, fixed_params_dict=fixed_params_dict) + # Residuals x_resid_on_old_trans = star_list['x'] - xref y_resid_on_old_trans = star_list['y'] - yref resid_on_old_trans = np.hypot(x_resid_on_old_trans, y_resid_on_old_trans) threshold = outlier_tol * resid_on_old_trans.std() - keepers = np.where(resid_on_old_trans < threshold)[0] + keepers = resid_on_old_trans < threshold if verbose > 0: msg = ' Outlier Rejection: Keeping {0:d} of {1:d}' - print(msg.format(len(keepers), len(resid_on_old_trans))) - + print(msg.format(sum(keepers), len(resid_on_old_trans))) + return keepers def setup_trans_info(trans_input, trans_args, N_lists, iters): @@ -3711,7 +3912,7 @@ def setup_trans_info(trans_input, trans_args, N_lists, iters): iters : int """ trans_list = [None for ii in range(N_lists)] - if trans_input != None: + if trans_input is not None: trans_list = [trans_input[ii] for ii in range(N_lists)] # Keep a list of trans_args, one for each starlist. If only @@ -3719,12 +3920,12 @@ def setup_trans_info(trans_input, trans_args, N_lists, iters): if type(trans_args) == dict: tmp = trans_args trans_args = [tmp for ii in range(iters)] - + return trans_list, trans_args def apply_mag_lim(star_list, mag_lim): - """ Apply a magnitude limit to the list. If no magnitude limit is - specified, then return a copy of the list. This works on a + """ Apply a magnitude limit to the list. If no magnitude limit is + specified, then return a copy of the list. This works on a reference list (with 'm0') or a star_list ('m') with 'm0' taking priority. @@ -3743,7 +3944,7 @@ def apply_mag_lim(star_list, mag_lim): mcol = 'm' conditions = {} - + cond_key = '{0:s}_min'.format(mcol) conditions[cond_key] = mag_lim[0] @@ -3761,7 +3962,7 @@ def get_weighting_scheme(weights, ref_list, star_list): else: var_xref = 0.0 var_yref = 0.0 - + if 'xe' in star_list.colnames: var_xlis = star_list['xe']**2 var_ylis = star_list['ye']**2 @@ -3769,7 +3970,7 @@ def get_weighting_scheme(weights, ref_list, star_list): var_xlis = 0.0 var_ylis = 0.0 - if weights != None: + if weights is not None: if weights == 'both,var': weight = 1.0 / (var_xref + var_xlis + var_yref + var_ylis) if weights == 'both,std': @@ -3792,36 +3993,9 @@ def get_weighting_scheme(weights, ref_list, star_list): return weight -def get_pos_at_time(t, starlist, use_vel=True): - """ - Take a starlist, check to see if it has velocity columns. - If it does, then propogate the positions forward in time - to the desired epoch. If no velocities exist, then just - use ['x0', 'y0'] or ['x', 'y'] - - Inputs - ---------- - t_array : float - The time to propogate to. Usually in decimal years; - but it should be in the same units - as the 't0' column in starlist. - """ - if use_vel and ('vx' in starlist.colnames) and ('vy' in starlist.colnames): - dt = t - starlist['t0'] - x = starlist['x0'] + (starlist['vx'] * dt) - y = starlist['y0'] + (starlist['vy'] * dt) - else: - if ('x0' in starlist.colnames) and ('y0' in starlist.colnames): - x = starlist['x0'] - y = starlist['y0'] - else: - x = starlist['x'] - y = starlist['y'] - - return (x, y) def logger(logfile, message, verbose = 9): if verbose > 4: print(message) logfile.write(message + '\n') - return + return \ No newline at end of file diff --git a/flystar/align_old_functions.py b/flystar/align_old_functions.py new file mode 100755 index 0000000..9bae670 --- /dev/null +++ b/flystar/align_old_functions.py @@ -0,0 +1,828 @@ +""" +Old functions that are only referenced in examples and template +""" +def transform_from_file(starlist, transFile): + """ + Apply transformation from transFile to starlist. Returns astropy table with + added columns with the transformed coordinates. NOTE: Transforms + positions/position errors, plus velocities and velocity errors if they + are present in starlist. + + WARNING: THIS CODE WILL NOT WORK FOR LEGENDRE POLYNOMIAL + TRANSFORMS + + Parameters: + ---------- + starlist: astropy table + Starlist we want to apply the transformation too. Must already + have standard column headers + + transFile: ascii file + File with the transformation coefficients. Assumed to be output of + write_transform, with coefficients specified as code documents + + Output: + ------ + Copy of starlist astropy table with transformed coordinates. + """ + # Make a copy of starlist. This is what we will eventually modify with + # the transformed coordinates + starlist_f = copy.deepcopy(starlist) + + # Check to see if velocities are present in starlist. If so, we will + # need to transform these as well as positions + vel = False + keys = list(starlist.keys()) + if 'vx' in keys: + vel = True + + # Extract needed information from starlist + x_orig = starlist['x'] + y_orig = starlist['y'] + xe_orig = starlist['xe'] + ye_orig = starlist['ye'] + + if vel: + x0_orig = starlist['x0'] + y0_orig = starlist['y0'] + x0e_orig = starlist['x0_err'] + y0e_orig = starlist['y0_err'] + + vx_orig = starlist['vx'] + vy_orig = starlist['vy'] + vxe_orig = starlist['vx_err'] + vye_orig = starlist['vy_err'] + + # Read transFile + trans = Table.read(transFile, format='ascii.commented_header', header_start=-1) + Xcoeff = trans['Xcoeff'] + Ycoeff = trans['Ycoeff'] + + #-----------------------------------------------# + # General equation for applying the transform + #-----------------------------------------------# + #""" + # First determine the order based on the number of terms + # Comes from Nterms = (N+1)*(N+2) / 2. + order = (np.sqrt(1 + 8*len(Xcoeff)) - 3) / 2. + + if order%1 != 0: + print( 'Incorrect number of coefficients for polynomial') + print( 'Stopping') + return + order = int(order) + + # Position transformation + x_new, y_new = transform_pos_from_file(Xcoeff, Ycoeff, order, x_orig, + y_orig) + + if vel: + x0_new, y0_new = transform_pos_from_file(Xcoeff, Ycoeff, order, x0_orig, + y0_orig) + + # Position error transformation + xe_new, ye_new = transform_poserr_from_file(Xcoeff, Ycoeff, order, xe_orig, + ye_orig, x_orig, y_orig) + + if vel: + x0e_new, y0e_new = transform_poserr_from_file(Xcoeff, Ycoeff, order, x0e_orig, + y0e_orig, x0_orig, y0_orig) + + if vel: + # Velocity transformation + vx_new, vy_new = transform_vel_from_file(Xcoeff, Ycoeff, order, vx_orig, + vy_orig, x_orig, y_orig) + + # Velocity error transformation + vxe_new, vye_new = transform_velerr_from_file(Xcoeff, Ycoeff, order, + vxe_orig, vye_orig, + vx_orig, vy_orig, + xe_orig, ye_orig, + x_orig, y_orig) + + #----------------------------------------# + # Hard coded example: old but functional + #----------------------------------------# + """ + # How the transformation is applied depends on the type of transform. + # This can be determined by the length of Xcoeff, Ycoeff + if len(Xcoeff) == 3: + x_new = Xcoeff[0] + Xcoeff[1] * x_orig + Xcoeff[2] * y_orig + y_new = Ycoeff[0] + Ycoeff[1] * x_orig + Ycoeff[2] * y_orig + xe_new = np.sqrt( (Xcoeff[1] * xe_orig)**2 + (Xcoeff[2] * ye_orig)**2 ) + ye_new = np.sqrt( (Ycoeff[1] * xe_orig)**2 + (Ycoeff[2] * ye_orig)**2 ) + + if vel: + vx_new = Xcoeff[1] * vx_orig + Xcoeff[2] * vy_orig + vy_new = Ycoeff[1] * vx_orig + Ycoeff[2] * vy_orig + vxe_new = np.sqrt( (Xcoeff[1] * vxe_orig)**2 + (Xcoeff[2] * vye_orig)**2 ) + vye_new = np.sqrt( (Ycoeff[1] * vxe_orig)**2 + (Ycoeff[2] * vye_orig)**2 ) + + elif len(Xcoeff) == 6: + x_new = Xcoeff[0] + Xcoeff[1]*x_orig + Xcoeff[3]*x_orig**2 + Xcoeff[2]*y_orig + \ + Xcoeff[5]*y_orig**2. + Xcoeff[4]*x_orig*y_orig + + y_new = Ycoeff[0] + Ycoeff[1]*x_orig + Ycoeff[3]*x_orig**2 + Ycoeff[2]*y_orig + \ + Ycoeff[5]*y_orig**2. + Ycoeff[4]*x_orig*y_orig + + xe_new = np.sqrt( (Xcoeff[1] + 2*Xcoeff[3]*x_orig + Xcoeff[4]*y_orig)**2 * xe_orig**2 + \ + (Xcoeff[2] + 2*Xcoeff[5]*y_orig + Xcoeff[4]*x_orig)**2 * ye_orig**2 ) + + ye_new = np.sqrt( (Ycoeff[1] + 2*Ycoeff[3]*x_orig + Ycoeff[4]*y_orig)**2 * xe_orig**2 + \ + (Ycoeff[2] + 2*Ycoeff[5]*y_orig + Ycoeff[4]*x_orig)**2 * ye_orig**2 ) + + if vel: + vx_new = Xcoeff[1]*vx_orig + 2*Xcoeff[3]*x_orig*vx_orig + Xcoeff[2]*vy_orig + \ + 2.*Xcoeff[5]*y_orig*vy_orig + Xcoeff[4]*(x_orig*vy_orig + vx_orig*y_orig) + + vy_new = Ycoeff[1]*vx_orig + 2*Ycoeff[3]*x_orig*vx_orig + Ycoeff[2]*vy_orig + \ + 2.*Ycoeff[5]*y_orig*vy_orig + Ycoeff[4]*(x_orig*vy_orig + vx_orig*y_orig) + + vxe_new = np.sqrt( (Xcoeff[1] + 2*Xcoeff[3]*x_orig + Xcoeff[4]*y_orig)**2 * vxe_orig**2 + \ + (Xcoeff[2] + 2*Xcoeff[5]*y_orig + Xcoeff[4]*x_orig)**2 * vye_orig**2 + \ + (2*Xcoeff[3]*vx_orig + Xcoeff[4]*vy_orig)**2 * xe_orig**2 + \ + (2*Xcoeff[5]*vy_orig + Xcoeff[4]*vx_orig)**2 * ye_orig**2 ) + + vye_new = np.sqrt( (Ycoeff[1] + 2*Ycoeff[3]*x_orig + Ycoeff[4]*y_orig)**2 * vxe_orig**2 + \ + (Ycoeff[2] + 2*Ycoeff[5]*y_orig + Ycoeff[4]*x_orig)**2 * vye_orig**2 + \ + (2*Ycoeff[3]*vx_orig + Ycoeff[4]*vy_orig)**2 * xe_orig**2 + \ + (2*Ycoeff[5]*vy_orig + Ycoeff[4]*vx_orig)**2 * ye_orig**2 ) + """ + #Update transformed coords to copy of astropy table + starlist_f['x'] = x_new + starlist_f['y'] = y_new + starlist_f['xe'] = xe_new + starlist_f['ye'] = ye_new + + if vel: + starlist_f['x0'] = x0_new + starlist_f['y0'] = y0_new + starlist_f['x0_err'] = x0e_new + starlist_f['y0_err'] = y0e_new + starlist_f['vx'] = vx_new + starlist_f['vy'] = vy_new + starlist_f['vx_err'] = vxe_new + starlist_f['vy_err'] = vye_new + + return starlist_f + +def transform_pos_from_file(Xcoeff, Ycoeff, order, x_orig, y_orig): + """ + Given the read-in coefficients from transform_from_file, apply the + transformation to the observed positions. This is generalized to + work with any order polynomial transform. + + WARNING: THIS CODE WILL NOT WORK FOR LEGENDRE POLYNOMIAL + TRANSFORMS + + Parameters: + ---------- + Xcoeff: Array + Array with the coefficients of the X pos transformation + + Ycoeff: Array + Array with the coefficients of the Y pos transformation + + order: int + Order of transformation + + x_orig: array + Array with the original X positions + + y_orig: array + Array with the original Y positions + + Output: + ------ + x_new: array + Transformed X positions + + y_new: array + Transformed Y positions + + """ + idx = 0 # coeff index + x_new = 0.0 + y_new = 0.0 + for i in range(order+1): + for j in range(i+1): + x_new += Xcoeff[idx] * x_orig**(i-j) * y_orig**j + y_new += Ycoeff[idx] * x_orig**(i-j) * y_orig**j + + idx += 1 + + return x_new, y_new + +def transform_poserr_from_file(Xcoeff, Ycoeff, order, xe_orig, ye_orig, x_orig, y_orig): + """ + Given the read-in coefficients from transform_from_file, apply the + transformation to the observed position errors. This is generalized to + work with any order transform. + + WARNING: THIS CODE WILL NOT WORK FOR LEGENDRE POLYNOMIAL + TRANSFORMS + + Parameters: + ---------- + Xcoeff: Array + Array with the coefficients of the X pos transformation + + Ycoeff: Array + Array with the coefficients of the Y pos transformation + + order: int + Order of transformation + + xe_orig: array + Array with the original X position errs + + ye_orig: array + Array with the original Y position errs + + x_orig: array + Array with the original X positions + + y_orig: array + Array with the original Y positions + + Output: + ------ + xe_new: array + Transformed X position errs + + ye_new: array + Transformed Y position errs + """ + idx = 0 # coeff index + xe_new_tmp1 = 0.0 + ye_new_tmp1 = 0.0 + xe_new_tmp2 = 0.0 + ye_new_tmp2 = 0.0 + + # First loop: dx'/dx + for i in range(order+1): + for j in range(i+1): + xe_new_tmp1 += Xcoeff[idx] * (i - j) * x_orig**(i-j-1) * y_orig**j + ye_new_tmp1 += Ycoeff[idx] * (i - j) * x_orig**(i-j-1) * y_orig**j + + idx += 1 + + # Second loop: dy'/dy + idx = 0 # coeff index + for i in range(order+1): + for j in range(i+1): + xe_new_tmp2 += Xcoeff[idx] * (j) * x_orig**(i-j) * y_orig**(j-1) + ye_new_tmp2 += Ycoeff[idx] * (j) * x_orig**(i-j) * y_orig**(j-1) + + idx += 1 + # Take square root for xe/ye_new + xe_new = np.sqrt((xe_new_tmp1 * xe_orig)**2 + (xe_new_tmp2 * ye_orig)**2) + ye_new = np.sqrt((ye_new_tmp1 * ye_orig)**2 + (ye_new_tmp2 * ye_orig)**2) + + return xe_new, ye_new + +def transform_vel_from_file(Xcoeff, Ycoeff, order, vx_orig, vy_orig, x_orig, y_orig): + """ + Given the read-in coefficients from transform_from_file, apply the + transformation to the observed proper motions. This is generalized to + work with any order transform. + + WARNING: THIS CODE WILL NOT WORK FOR LEGENDRE POLYNOMIAL + TRANSFORMS + + Parameters: + ---------- + Xcoeff: Array + Array with the coefficients of the X pos transformation + + Ycoeff: Array + Array with the coefficients of the Y pos transformation + + order: int + Order of transformation + + vx_orig: array + Array with the original X proper motions + + vy_orig: array + Array with the original Y proper motions + + x_orig: array + Array with the original X positions + + y_orig: array + Array with the original Y positions + + Output: + ------ + vx_new: array + Transformed X proper motions + + vy_new: array + Transformed Y proper motions + """ + idx = 0 # coeff index + vx_new = 0.0 + vy_new = 0.0 + # First loop: dx'/dx + for i in range(order+1): + for j in range(i+1): + vx_new += Xcoeff[idx] * (i - j) * x_orig**(i-j-1) * y_orig**j * vx_orig + vy_new += Ycoeff[idx] * (i - j) * x_orig**(i-j-1) * y_orig**j * vx_orig + + idx += 1 + # Second loop: dy'/dy + idx = 0 # coeff index + for i in range(order+1): + for j in range(i+1): + vx_new += Xcoeff[idx] * (j) * x_orig**(i-j) * y_orig**(j-1) * vy_orig + vy_new += Ycoeff[idx] * (j) * x_orig**(i-j) * y_orig**(j-1) * vy_orig + + idx += 1 + + return vx_new, vy_new + +def transform_velerr_from_file(Xcoeff, Ycoeff, order, vxe_orig, vye_orig, vx_orig, + vy_orig, xe_orig, ye_orig, x_orig, y_orig): + """ + Given the read-in coefficients from transform_from_file, apply the + transformation to the observed proper motion errors. This is generalized to + work with any order transform. + + WARNING: THIS CODE WILL NOT WORK FOR LEGENDRE POLYNOMIAL + TRANSFORMS + + Parameters: + ---------- + Xcoeff: Array + Array with the coefficients of the X pos transformation + + Ycoeff: Array + Array with the coefficients of the Y pos transformation + + order: int + Order of transformation + + vxe_orig: array + Array with the original X proper motion errs + + vye_orig: array + Array with the original Y proper motion errs + + vx_orig: array + Array with the original X proper motions + + vy_orig: array + Array with the original Y proper motions + + xe_orig: array + Array with the original X position errs + + ye_orig: array + Array with the original Y position errs + + x_orig: array + Array with the original X positions + + y_orig: array + Array with the original Y positions + + Output: + ------ + vxe_new: array + Transformed X proper motion errs + + vye_new: array + Transformed Y proper motion errs + """ + idx = 0 + vxe_new_tmp1 = 0.0 + vye_new_tmp1 = 0.0 + vxe_new_tmp2 = 0.0 + vye_new_tmp2 = 0.0 + vxe_new_tmp3 = 0.0 + vye_new_tmp3 = 0.0 + vxe_new_tmp4 = 0.0 + vye_new_tmp4 = 0.0 + + + # First loop: dvx' / dx + for i in range(order+1): + for j in range(i+1): + vxe_new_tmp1 += Xcoeff[idx] * (i-j) * (i-j-1) * x_orig**(i-j-2) * y_orig**j * vx_orig + vxe_new_tmp1 += Xcoeff[idx] * (j) * (i-j) * x_orig**(i-j-1) * y_orig**(j-1) * vy_orig + vye_new_tmp1 += Ycoeff[idx] * (i-j) * (i-j-1) * x_orig**(i-j-2) * y_orig**j * vx_orig + vye_new_tmp1 += Ycoeff[idx] * (j) * (i-j) * x_orig**(i-j-1) * y_orig**(j-1) * vy_orig + + idx += 1 + + # Second loop: dvx' / dy + idx = 0 + for i in range(order+1): + for j in range(i+1): + vxe_new_tmp2 += Xcoeff[idx] * (i-j) * (j) * x_orig**(i-j-1) * y_orig**(j-1) * vx_orig + vxe_new_tmp2 += Xcoeff[idx] * (j) * (j-1) * x_orig**(i-j-1) * y_orig**(j-2) * vy_orig + vye_new_tmp2 += Ycoeff[idx] * (i-j) * (j) * x_orig**(i-j-1) * y_orig**(j-1) * vx_orig + vye_new_tmp2 += Ycoeff[idx] * (j) * (j-1) * x_orig**(i-j-1) * y_orig**(j-2) * vy_orig + + idx += 1 + + # Third loop: dvx' / dvx + idx = 0 + for i in range(order+1): + for j in range(i+1): + vxe_new_tmp3 += Xcoeff[idx] * (i-j) * x_orig**(i-j-1) * y_orig**j + vye_new_tmp3 += Ycoeff[idx] * (i-j) * x_orig**(i-j-1) * y_orig**j + + idx += 1 + + # Fourth loop: dvx' / dvy + idx = 0 + for i in range(order+1): + for j in range(i+1): + vxe_new_tmp4 += Xcoeff[idx] * (j) * x_orig**(i-j) * y_orig**(j-1) + vye_new_tmp4 += Ycoeff[idx] * (j) * x_orig**(i-j) * y_orig**(j-1) + + idx += 1 + + vxe_new = np.sqrt((vxe_new_tmp1 * xe_orig)**2 + (vxe_new_tmp2 * ye_orig)**2 + \ + (vxe_new_tmp3 * vxe_orig)**2 + (vxe_new_tmp4 * vye_orig)**2) + vye_new = np.sqrt((vye_new_tmp1 * xe_orig)**2 + (vye_new_tmp2 * ye_orig)**2 + \ + (vye_new_tmp3 * vxe_orig)**2 + (vye_new_tmp4 * vye_orig)**2) + + return vxe_new, vye_new + + + + + + +""" +Old functions with things hard-coded for OB120169 +""" + +def run_align_iter(catalog, trans_order=1, poly_deg=1, ref_mag_lim=19, ref_radius_lim=300): + # Load up data with matched stars. + d = Table.read(catalog) + + # Determine how many epochs there are. + N_epochs = len([n for n, c in enumerate(d.colnames) if c.startswith('name')]) + + # Determine how many stars there are. + N_stars = len(d) + + # Determine the reference epoch + ref = d.meta['L_REF'] + + # Figure out the number of free parameters for the specified + # poly2d order. + poly2d = models.Polynomial2D(trans_order) + N_par_trans_per_epoch = 2.0 * poly2d.get_num_coeff(2) # one poly2d for each dimension (X, Y) + N_par_trans = N_par_trans_per_epoch * N_epochs + + ########## + # First iteration -- align everything to REF epoch with zero velocities. + ########## + print('ALIGN_EPOCHS: run_align_iter() -- PASS 1') + ee_ref = d.meta['L_REF'] + + target_name = 'OB120169' + + trans1, used1 = calc_transform_ref_epoch(d, target_name, ee_ref, ref_mag_lim, ref_radius_lim) + + ########## + # Derive the velocity of each stars using the round 1 transforms. + ########## + calc_polyfit_all_stars(d, poly_deg, init_fig_idx=0) + + calc_mag_avg_all_stars(d) + + tdx = np.where((d['name_0'] == 'OB120169') | (d['name_0'] == 'OB120169_L'))[0] + print(d[tdx]['name_0', 't0', 'mag', 'x0', 'vx', 'x0_err', 'vx_err', 'chi2x', 'y0', 'vy', 'y0_err', 'vy_err', 'chi2y', 'dof']) + + ########## + # Second iteration -- align everything to reference positions derived from iteration 1 + ########## + print('ALIGN_EPOCHS: run_align_iter() -- PASS 2') + target_name = 'OB120169' + + trans2, used2 = calc_transform_ref_poly(d, target_name, poly_deg, ref_mag_lim, ref_radius_lim) + + ########## + # Derive the velocity of each stars using the round 1 transforms. + ########## + calc_polyfit_all_stars(d, poly_deg, init_fig_idx=4) + + ########## + # Save output + ########## + d.write(catalog.replace('.fits', '_aln.fits'), overwrite=True) + + return + +def calc_transform_ref_epoch(d, target_name, ee_ref, ref_mag_lim, ref_radius_lim): + # Determine how many epochs there are. + N_epochs = len([n for n, c in enumerate(d.colnames) if c.startswith('name')]) + + # output array + trans = [] + used = [] + + # Find the target + tdx = np.where(d['name_0'] == 'OB120169')[0][0] + + # Reference values + t_ref = d['t_{0:d}'.format(ee_ref)] + m_ref = d['m_{0:d}'.format(ee_ref)] + x_ref = d['x_{0:d}'.format(ee_ref)] + y_ref = d['y_{0:d}'.format(ee_ref)] + xe_ref = d['xe_{0:d}'.format(ee_ref)] + ye_ref = d['ye_{0:d}'.format(ee_ref)] + + # Calculate some quanitites we use for selecting reference stars. + r_ref = np.hypot(x_ref - x_ref[tdx], y_ref - y_ref[tdx]) + + # Loop through and align each epoch to the reference epoch. + for ee in range(N_epochs): + # Pull out the X, Y positions (and errors) for the two + # starlists we are going to align. + x_epo = d['x_{0:d}'.format(ee)] + y_epo = d['y_{0:d}'.format(ee)] + t_epo = d['t_{0:d}'.format(ee)] + xe_epo = d['xe_{0:d}'.format(ee)] + ye_epo = d['ye_{0:d}'.format(ee)] + + # Figure out the set of stars detected in both epochs. + idx = np.where((t_ref != 0) & (t_epo != 0) & (xe_ref != 0) & (xe_epo != 0))[0] + + # Find those in both epochs AND reference stars. This is [idx][rdx] + rdx = np.where((r_ref[idx] < ref_radius_lim) & (m_ref[idx] < ref_mag_lim))[0] + + # Average the positional errors together to get one weight per star. + xye_ref = (xe_ref + ye_ref) / 2.0 + xye_epo = (xe_epo + ye_epo) / 2.0 + xye_wgt = (xye_ref**2 + xye_epo**2)**0.5 + + # Calculate transform based on the matched stars + trans_tmp = transforms.PolyTransform(x_epo[idx][rdx], y_epo[idx][rdx], x_ref[idx][rdx], y_ref[idx][rdx], + weights=xye_wgt[idx][rdx], order=2) + + trans.append(trans_tmp) + + + # Apply thte transformation to the stars positions and errors: + xt_epo = np.zeros(len(d), dtype=float) + yt_epo = np.zeros(len(d), dtype=float) + xet_epo = np.zeros(len(d), dtype=float) + yet_epo = np.zeros(len(d), dtype=float) + + xt_epo[idx], xet_epo[idx], yt_epo[idx], yet_epo[idx] = trans_tmp.evaluate_errors(x_epo[idx], xe_epo[idx], + y_epo[idx], ye_epo[idx], + nsim=100) + + d['xt_{0:d}'.format(ee)] = xt_epo + d['yt_{0:d}'.format(ee)] = yt_epo + d['xet_{0:d}'.format(ee)] = xet_epo + d['yet_{0:d}'.format(ee)] = yet_epo + + # Record which stars we used in the transform. + used_tmp = np.zeros(len(d), dtype=bool) + used_tmp[idx[rdx]] = True + + used.append(used_tmp) + + if True: + plot_quiver_residuals(xt_epo, yt_epo, x_ref, y_ref, idx, rdx, 'Epoch: ' + str(ee)) + + used = np.array(used) + + return trans, used + +def calc_transform_ref_poly(d, target_name, poly_deg, ref_mag_lim, ref_radius_lim): + # Determine how many epochs there are. + N_epochs = len([n for n, c in enumerate(d.colnames) if c.startswith('name')]) + + # output array + trans = [] + used = [] + + # Find the target + tdx = np.where(d['name_0'] == 'OB120169')[0][0] + + # Temporary Reference values + t_ref = d['t0'] + m_ref = d['mag'] + x_ref = d['x0'] + y_ref = d['y0'] + xe_ref = d['x0_err'] + ye_ref = d['y0_err'] + + # Calculate some quanitites we use for selecting reference stars. + r_ref = np.hypot(x_ref - x_ref[tdx], y_ref - y_ref[tdx]) + + for ee in range(N_epochs): + # Pull out the X, Y positions (and errors) for the two + # starlists we are going to align. + x_epo = d['x_{0:d}'.format(ee)] + y_epo = d['y_{0:d}'.format(ee)] + t_epo = d['t_{0:d}'.format(ee)] + xe_epo = d['xe_{0:d}'.format(ee)] + ye_epo = d['ye_{0:d}'.format(ee)] + + # Shift the reference position by the polyfit for each star. + dt = t_epo - t_ref + if poly_deg >= 0: + x_ref_ee = x_ref + y_ref_ee = y_ref + xe_ref_ee = x_ref + ye_ref_ee = y_ref + + if poly_deg >= 1: + x_ref_ee += d['vx'] * dt + y_ref_ee += d['vy'] * dt + xe_ref_ee = np.hypot(xe_ref_ee, d['vx_err'] * dt) + ye_ref_ee = np.hypot(ye_ref_ee, d['vy_err'] * dt) + + if poly_deg >= 2: + x_ref_ee += d['ax'] * dt + y_ref_ee += d['ay'] * dt + xe_ref_ee = np.hypot(xe_ref_ee, d['axe'] * dt) + ye_ref_ee = np.hypot(ye_ref_ee, d['aye'] * dt) + + # Figure out the set of stars detected in both. + idx = np.where((t_ref != 0) & (t_epo != 0) & (xe_ref != 0) & (xe_epo != 0))[0] + + # Find those in both AND reference stars. This is [idx][rdx] + rdx = np.where((r_ref[idx] < ref_radius_lim) & (m_ref[idx] < ref_mag_lim))[0] + + # Average the positional errors together to get one weight per star. + xye_ref = (xe_ref_ee + ye_ref_ee) / 2.0 + xye_epo = (xe_epo + ye_epo) / 2.0 + xye_wgt = (xye_ref**2 + xye_epo**2)**0.5 + + # Calculate transform based on the matched stars + trans_tmp = transforms.PolyTransform(x_epo[idx][rdx], y_epo[idx][rdx], x_ref_ee[idx][rdx], y_ref_ee[idx][rdx], + weights=xye_wgt[idx][rdx], order=2) + trans.append(trans_tmp) + + # Apply thte transformation to the stars positions and errors: + xt_epo = np.zeros(len(d), dtype=float) + yt_epo = np.zeros(len(d), dtype=float) + xet_epo = np.zeros(len(d), dtype=float) + yet_epo = np.zeros(len(d), dtype=float) + + xt_epo[idx], xet_epo[idx], yt_epo[idx], yet_epo[idx] = trans_tmp.evaluate_errors(x_epo[idx], xe_epo[idx], + y_epo[idx], ye_epo[idx], + nsim=100) + d['xt_{0:d}'.format(ee)] = xt_epo + d['yt_{0:d}'.format(ee)] = yt_epo + d['xet_{0:d}'.format(ee)] = xet_epo + d['yet_{0:d}'.format(ee)] = yet_epo + + # Record which stars we used in the transform. + used_tmp = np.zeros(len(d), dtype=bool) + used_tmp[idx[rdx]] = True + + used.append(used_tmp) + + if True: + plot_quiver_residuals(xt_epo, yt_epo, x_ref_ee, y_ref_ee, idx, rdx, 'Epoch: ' + str(ee)) + + used = np.array(used) + + return trans, used + +def calc_polyfit_all_stars(d, poly_deg, init_fig_idx=0): + # Determine how many stars there are. + N_stars = len(d) + + # Determine how many epochs there are. + N_epochs = len([n for n, c in enumerate(d.colnames) if c.startswith('name')]) + + # Setup some variables to save the results + t0_all = [] + px_all = [] + py_all = [] + pxe_all = [] + pye_all = [] + chi2x_all = [] + chi2y_all = [] + dof_all = [] + + # Get the time array, which is the same for all stars. + # Also, sort the time indices. + t = np.array([d['t_{0:d}'.format(ee)][0] for ee in range(N_epochs)]) + tdx = t.argsort() + t_sorted = t[tdx] + + # Run polyfit on each star. + for ss in range(N_stars): + # Get the x, y, xe, ye, and t arrays for this star. + xt = np.array([d['xt_{0:d}'.format(ee)][ss] for ee in range(N_epochs)]) + yt = np.array([d['yt_{0:d}'.format(ee)][ss] for ee in range(N_epochs)]) + xet = np.array([d['xet_{0:d}'.format(ee)][ss] for ee in range(N_epochs)]) + yet = np.array([d['yet_{0:d}'.format(ee)][ss] for ee in range(N_epochs)]) + t_tmp = np.array([d['t_{0:d}'.format(ee)][ss] for ee in range(N_epochs)]) + + # Sort these arrays. + xt_sorted = xt[tdx] + yt_sorted = yt[tdx] + xet_sorted = xet[tdx] + yet_sorted = yet[tdx] + t_tmp_sorted = t_tmp[tdx] + + # Get only the detected epochs. + edx = np.where(t_tmp_sorted != 0)[0] + + # Calculate the weighted t0 (using the transformed errors). + weight_for_t0 = 1.0 / np.hypot(xet_sorted, yet_sorted) + t0 = np.average(t_sorted[edx], weights=weight_for_t0[edx]) + + # for ee in edx: + # print('{0:8.3f} {1:10.5f} {2:10.5f} {3:8.5f} {4:8.5f}'.format(t[ee], xt[ee], yt[ee], xet[ee], yet[ee])) + # pdb.set_trace() + + # Run polyfit + dt = t_sorted - t0 + px, covx = np.polyfit(dt[edx], xt_sorted[edx], poly_deg, w=1./xet_sorted[edx], cov=True) + py, covy = np.polyfit(dt[edx], yt_sorted[edx], poly_deg, w=1./yet_sorted[edx], cov=True) + + pxe = np.sqrt(np.diag(covx)) + pye = np.sqrt(np.diag(covy)) + + + x_mod = np.polyval(px, dt[edx]) + y_mod = np.polyval(py, dt[edx]) + chi2x = np.sum( ((x_mod - xt_sorted[edx]) / xet_sorted[edx])**2 ) + chi2y = np.sum( ((y_mod - yt_sorted[edx]) / yet_sorted[edx])**2 ) + dof = len(edx) - (poly_deg + 1) + + # Save results: + t0_all.append(t0) + px_all.append(px) + py_all.append(py) + pxe_all.append(pxe) + pye_all.append(pye) + chi2x_all.append(chi2x) + chi2y_all.append(chi2y) + dof_all.append(dof) + + if d[ss]['name_0'] in ['OB120169', 'OB120169_L']: + gs = GridSpec(3, 2) # 3 rows, 1 column + fig = plt.figure(ss + 1 + init_fig_idx, figsize=(12, 8)) + a0 = fig.add_subplot(gs[0:2, 0]) + a1 = fig.add_subplot(gs[2, 0]) + a2 = fig.add_subplot(gs[0:2, 1]) + a3 = fig.add_subplot(gs[2, 1]) + + a0.errorbar(t_sorted[edx], xt_sorted[edx], yerr=xet_sorted[edx], fmt='ro') + a0.plot(t_sorted[edx], x_mod, 'k-') + a0.set_title(d[ss]['name_0'] + ' X') + a1.errorbar(t_sorted[edx], xt_sorted[edx] - x_mod, yerr=xet_sorted[edx], fmt='ro') + a1.axhline(0, linestyle='--') + a1.set_xlabel('Time (yrs)') + a2.errorbar(t_sorted[edx], yt_sorted[edx], yerr=yet_sorted[edx], fmt='ro') + a2.plot(t_sorted[edx], y_mod, 'k-') + a2.set_title(d[ss]['name_0'] + ' Y') + a3.errorbar(t_sorted[edx], yt_sorted[edx] - y_mod, yerr=yet_sorted[edx], fmt='ro') + a3.axhline(0, linestyle='--') + a3.set_xlabel('Time (yrs)') + + + + t0_all = np.array(t0_all) + px_all = np.array(px_all) + py_all = np.array(py_all) + pxe_all = np.array(pxe_all) + pye_all = np.array(pye_all) + chi2x_all = np.array(chi2x_all) + chi2y_all = np.array(chi2y_all) + dof_all = np.array(dof_all) + + # Done with all the stars... recast as numpy arrays and save to output table. + d['t0'] = t0_all + d['chi2x'] = chi2x_all + d['chi2y'] = chi2y_all + d['dof'] = dof_all + if poly_deg >= 0: + d['x0'] = px_all[:, -1] + d['y0'] = py_all[:, -1] + d['x0_err'] = pxe_all[:, -1] + d['y0_err'] = pye_all[:, -1] + + if poly_deg >= 1: + d['vx'] = px_all[:, -2] + d['vy'] = py_all[:, -2] + d['vx_err'] = pxe_all[:, -2] + d['vy_err'] = pye_all[:, -2] + + if poly_deg >= 2: + d['ax'] = px_all[:, -3] + d['ay'] = py_all[:, -3] + d['axe'] = pxe_all[:, -3] + d['aye'] = pye_all[:, -3] + + pdb.set_trace() + + return + diff --git a/flystar/analysis.py b/flystar/analysis.py index 953461b..7deaa36 100644 --- a/flystar/analysis.py +++ b/flystar/analysis.py @@ -1,27 +1,21 @@ import numpy as np import pylab as plt -from flystar import starlists -from flystar import startables -from flystar import align -from flystar import match -from flystar import transforms +from . import starlists, match from astropy import table from astropy.table import Table, Column from astropy.coordinates import SkyCoord from astropy import units as u from astropy.wcs import WCS -from astroquery.gaia import Gaia -from astroquery.mast import Observations, Catalogs import pdb, copy import math from scipy.stats import f ################################################## # New codes for velocity support in FlyStar and using -# the new StarTable and StarList format. +# the new StarTable and StarList format. ################################################## -def query_gaia(ra, dec, search_radius=30.0, table_name='gaiadr2'): +def query_gaia(ra, dec, search_radius=30.0, table_name='gaiadr3'): """ Query the Gaia database at the specified location and with the specified search radius @@ -35,13 +29,14 @@ def query_gaia(ra, dec, search_radius=30.0, table_name='gaiadr2'): Dec. in degrees in the format such as '-29:00:28.0' search_radius : float - The search radius in arcseconds. + The search radius in arcseconds. Optional Input -------------- table_name : string Options are 'gaiadr2' or 'gaiaedr3' """ + from astroquery.gaia import Gaia target_coords = SkyCoord(ra, dec, unit=(u.hourangle, u.deg), frame='icrs') ra = target_coords.ra.degree dec = target_coords.dec.degree @@ -49,20 +44,72 @@ def query_gaia(ra, dec, search_radius=30.0, table_name='gaiadr2'): search_radius *= u.arcsec Gaia.ROW_LIMIT = 50000 - gaia_job = Gaia.cone_search_async(target_coords, search_radius, table_name = table_name + '.gaia_source') + gaia_job = Gaia.cone_search_async(target_coords, radius=search_radius, table_name=table_name + '.gaia_source') gaia = gaia_job.get_results() #Change new 'SOURCE_ID' column header back to lowercase 'source_id' so all subsequent functions still work: - gaia['SOURCE_ID'].name = 'source_id' + if 'SOURCE_ID' in gaia.colnames: + gaia.rename_column('SOURCE_ID', 'source_id') return gaia +def check_gaia_parallaxes(ra,dec,search_radius=10.0,table_name='gaiadr3',target='(unnamed)', + file_ext=''): + """ + Query the Gaia database at the specified location + and with the specified search radius, and plot + parallaxes. + + Input + ---------- + ra : string + R.A. in hours in the format such as '17:45:40.3' + + dec : string + Dec. in degrees in the format such as '-29:00:28.0' + + search_radius : float + The search radius in arcseconds. -def prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=None, match_dr_max=0.2): + Optional Input + -------------- + table_name : string + Options are 'gaiadr2' or 'gaiadr3' + """ + # Query Gaia + gaia = query_gaia(ra,dec,search_radius=search_radius,table_name=table_name) + # Set up reasonable histogram bins + plim0,plim1 = np.min(gaia['parallax']),np.max(gaia['parallax']) + pplim0,pplim1 = np.min(gaia['parallax']/gaia['parallax_error']),np.max(gaia['parallax']/gaia['parallax_error']) + binwidth = 1 + pbins = np.arange(np.floor(plim0),np.ceil(plim1)+binwidth,binwidth) + ppbins = np.arange(np.floor(pplim0),np.ceil(pplim1)+binwidth,binwidth) + # Find number where plx/plx_err>3 + p_perr = (gaia['parallax']/gaia['parallax_error']).compressed() + nppe3 = sum((p_perr>3).astype(int)) + nppen3 = sum((p_perr<-3).astype(int)) + print(table_name,'stars within',search_radius,'\" with plx/plx_err>3: ', nppe3, ' of ', len(gaia['parallax'])) + print(table_name,'stars within',search_radius,'\" with plx/plx_err<-3: ', nppen3, ' of ', len(gaia['parallax'])) + # Plot + plt.subplots(nrows=1,ncols=2,figsize=(12,6)) + plt.subplot(121) + plt.xlabel('parallax (mas)'); plt.ylabel('N stars') + plt.hist(gaia['parallax'],bins=pbins) + plt.yscale('log') + plt.title(table_name+' parallax histograms, '+str(search_radius)+'\" radius around '+target, loc='left') + plt.subplot(122) + plt.xlabel('parallax/parallax_error') + plt.hist(gaia['parallax']/gaia['parallax_error'],bins=ppbins) + plt.yscale('log') + plt.tight_layout() + plt.savefig('gaiaplx'+file_ext+'.png') + + +def prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=None, match_dr_max=0.2, pi_err_limit=0.4, default_motion_model='Linear'): """ Take a Gaia table (from astroquery) and produce a new table with a tangential projection - and shift such that the origin is centered on the target of interest. - Convert everything into arcseconds and name columns such that they are + and shift such that the origin is centered on the target of interest. + Convert everything into arcseconds and name columns such that they are ready for FlyStar input. Inputs @@ -79,7 +126,7 @@ def prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=None, match_dr_max=0.2) target_coords = SkyCoord(ra, dec, unit=(u.hourangle, u.deg), frame='icrs') ra = target_coords.ra.degree # in decimal degrees dec = target_coords.dec.degree # in decimal degrees - + cos_dec = np.cos(np.radians(dec)) x = (gaia['ra'] - ra) * cos_dec * 3600.0 # arcsec y = (gaia['dec'] - dec) * 3600.0 # arcsec @@ -90,15 +137,15 @@ def prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=None, match_dr_max=0.2) gaia_new['x0'] = x * -1.0 gaia_new['y0'] = y - gaia_new['x0e'] = xe - gaia_new['y0e'] = ye + gaia_new['x0_err'] = xe + gaia_new['y0_err'] = ye # Also convert the velocities. Note that Gaia PM are already * cos(dec) gaia_new['vx'] = gaia['pmra'].data * -1.0 / 1e3 # asec/yr gaia_new['vy'] = gaia['pmdec'].data / 1e3 - gaia_new['vxe'] = gaia['pmra_error'].data / 1e3 - gaia_new['vye'] = gaia['pmdec_error'].data / 1e3 - + gaia_new['vx_err'] = gaia['pmra_error'].data / 1e3 + gaia_new['vy_err'] = gaia['pmdec_error'].data / 1e3 + gaia_new['t0'] = gaia['ref_epoch'].data gaia_new['source_id'] = gaia['source_id'].data.astype('S19') @@ -106,40 +153,84 @@ def prepare_gaia_for_flystar(gaia, ra, dec, targets_dict=None, match_dr_max=0.2) idx = np.where(gaia['pmdec'].mask == True)[0] gaia_new['vx'][idx] = 0.0 gaia_new['vy'][idx] = 0.0 - gaia_new['vxe'][idx] = 0.0 - gaia_new['vye'][idx] = 0.0 - + gaia_new['vx_err'][idx] = 0.0 + gaia_new['vy_err'][idx] = 0.0 + gaia_new['m'] = gaia['phot_g_mean_mag'] gaia_new['me'] = 1.09/gaia['phot_g_mean_flux_over_error'] - gaia_new['parallax'] = gaia['parallax'] - gaia_new['parallax_error'] = gaia['parallax_error'] + gaia_new['pi'] = gaia['parallax'].data*1e-3 + gaia_new['pi_err'] = gaia['parallax_error'].data*1e-3 # Set the velocities (and uncertainties) to zero if they aren't measured. idx = np.where(np.isnan(gaia_new['vx']) == True)[0] gaia_new['vx'][idx] = 0.0 - gaia_new['vxe'][idx] = 0.0 + gaia_new['vx_err'][idx] = 0.0 gaia_new['vy'][idx] = 0.0 - gaia_new['vye'][idx] = 0.0 + gaia_new['vy_err'][idx] = 0.0 + + # Cut out stars with high plx error and set motion models + idx = np.where((gaia_new['pi_err']>(pi_err_limit/1e3)) | (gaia['parallax'].mask == True))[0] + gaia_new['pi'][idx] = 0.0 + gaia_new['pi_err'][idx] = 0.0 + if default_motion_model=='Parallax': + gaia_new['motion_model_input'] = 'Parallax' + gaia_new['motion_model_used'] = 'Parallax' + gaia_new['motion_model_used'][idx] = 'Linear' + gaia_new['n_params'] = 3 + gaia_new['n_params'][idx] = 2 + elif default_motion_model=='Linear': + gaia_new['motion_model_input'] = 'Linear' + gaia_new['motion_model_used'] = 'Linear' + gaia_new['n_params'] = 2 + elif default_motion_model=='Fixed': + gaia_new['motion_model_input'] = 'Fixed' + gaia_new['motion_model_used'] = 'Fixed' + gaia_new['n_params'] = 1 + elif default_motion_model=='Empty': + gaia_new['motion_model_input'] = 'Empty' + gaia_new['motion_model_used'] = 'Empty' + gaia_new['n_params'] = 0 + else: + print("Invalid motion model",default_motion_model,"- none assigned") + + #macy additions to try to fix wild magnitude values + #gaia_new['ruwe'] = gaia['ruwe'] + #try: + # gaia_new = gaia_new[~gaia_new['m'].mask] + #except: + # print('no invalig mags') gaia_new = gaia_new.filled() #convert masked colunms to regular columns if targets_dict != None: - for targ_name, targ_coo in targets_dict.items(): - dx = gaia_new['x0'] - (targ_coo[0] * -1.0) - dy = gaia_new['y0'] - targ_coo[1] +# for targ_name, targ_coo in targets_dict.items(): +# dx = gaia_new['x0'] - (targ_coo[0] * -1.0) +# dy = gaia_new['y0'] - targ_coo[1] +# dr = np.hypot(dx, dy) +# +# idx = dr.argmin() +# +# if dr[idx] < match_dr_max: +# gaia_new['name'][idx] = targ_name +# print('Found match for: ', targ_name, ' - ',gaia_new['source_id'][idx]) + targ_names = [x for x in targets_dict] + targ_xs = np.array([targets_dict[x][0] for x in targets_dict]) + targ_ys = np.array([targets_dict[x][1] for x in targets_dict]) + for i_gaia in range(len(gaia_new)): + dx = gaia_new['x0'][i_gaia] - (targ_xs * -1.0) + dy = gaia_new['y0'][i_gaia] - targ_ys dr = np.hypot(dx, dy) idx = dr.argmin() if dr[idx] < match_dr_max: - gaia_new['name'][idx] = targ_name - print('Found match for: ', targ_name) + gaia_new['name'][i_gaia] = targ_names[idx] + print('Found match for: ', targ_names[idx], ' - ',gaia_new['source_id'][i_gaia]) return gaia_new - def run_flystar(): - + test_file = '/u/jlu/work/microlens/OB150211/a_2018_10_19/a_ob150211_2018_10_19/lis/stars_matched2.fits' t = Table.read(test_file) @@ -171,39 +262,39 @@ def run_flystar(): ym_t = y0 + vy * (t - t0) # Model distorted positions - - + + return def project_gaia(gaia, epoch, ra, dec): """ Take the Gaia measurements, forward them in time, and then convert them into a tangential projection. - + Inputs ---------- epoch : float (year) The decimal year to project the measurement to. Note that we use 365.25 days per year. - + ra : float (deg) The right ascension (J2000) in decimal degrees of the center of the field. - + dec : float (deg) The declination (J2000) in decimal degrees of the center of the field. - + """ t0 = gaia['ref_epoch'] x0 = (gaia['ra'] - ra) * np.cos(np.radians(dec)) * 3600.0 # Arcsec y0 = (gaia['dec'] - dec) * 3600.0 x0e = gaia['ra_error'] / 1.0e3 # arcsec, already in alpha* (multiplied by cos(delta)) y0e = gaia['dec_error'] / 1.0e3 # arcsec - - + + vx = gaia['pmra'] / 1.0e3 # arcsec / yr - vy = gaia['pmdec'] / 1.0e3 + vy = gaia['pmdec'] / 1.0e3 vxe = gaia['pmra_error'] / 1.0e3 # arcsec / yr vye = gaia['pmdec_error'] / 1.0e3 - + # Modify any vx/vy, etc. that are zero and make a regular (unmasked) numpy array. vx[vx.mask] = 0.0 vy[vy.mask] = 0.0 @@ -213,29 +304,29 @@ def project_gaia(gaia, epoch, ra, dec): vy = np.array(vy) vxe = np.array(vxe) vye = np.array(vye) - + dt = epoch - t0 x_now = (x0 + (vx * dt)) * -1.0 # Switch to a left-handed coordinate system, like detector pixels. y_now = (y0 + (vy * dt)) xe_now = np.hypot(x0e, vxe*dt) ye_now = np.hypot(y0e, vye*dt) - + # Format as a starlist - gaia_lis = starlists.StarList(name=gaia['source_id'], + gaia_lis = starlists.StarList(name=gaia['source_id'], x=x_now, y=y_now, m=gaia['phot_g_mean_mag'], xe=xe_now, ye=ye_now, me=1.0/gaia['phot_g_mean_flux_over_error']) - + # Duplicate columns to 'x_avg', etc. Needed for initial guessing. gaia_lis['x_avg'] = gaia_lis['x'] gaia_lis['y_avg'] = gaia_lis['y'] - gaia_lis['m_avg'] = gaia_lis['m'] - + gaia_lis['m_avg'] = gaia_lis['m'] + return gaia_lis def rename_after_flystar(star_tab, label_dat_file, new_copy=True, dr_tol=0.05, dm_tol=0.3, verbose=False): """ - Take a StarTable output from FlyStar MosaicToRef that has been + Take a StarTable output from FlyStar MosaicToRef that has been aligned into R.A. and Dec. (usually by way of Gaia). Align the output to a label.dat file for this source and rename everything. @@ -263,25 +354,28 @@ def rename_after_flystar(star_tab, label_dat_file, new_copy=True, dr_tol=0.05, d x_lab[ndx_lab[ii]], star_tab['x0'][ndx_star[ii]], y_lab[ndx_lab[ii]], star_tab['y0'][ndx_star[ii]], m_lab[ndx_lab[ii]], star_tab['m0'][ndx_star[ii]])) - + print('Temporary shift transformations: ') print(' dm = {0:8.4f} +/- {1:8.4f}'.format(dm.mean(), dm.std())) print(' dx = {0:8.4f} +/- {1:8.4f}'.format(dx.mean(), dx.std())) print(' dy = {0:8.4f} +/- {1:8.4f}'.format(dy.mean(), dy.std())) - + m_lab = label_tab['m'] + dm.mean() x_lab += dx.mean() y_lab += dy.mean() - + # Now that we are in a common coordinate and magnitude # system, lets match the whole lists by coordinates. - idx_lab, idx_star, dr, dm = match.match(x_lab, y_lab, m_lab, + idx_lab, idx_star, dr, dm = match.match(x_lab, y_lab, m_lab, star_tab['x0'], star_tab['y0'], star_tab['m0'], dr_tol=dr_tol, dm_tol=dm_tol, verbose=verbose) + #print('idx_lab:') + #for iii in range(len(idx_lab)): + # print(label_tab["name"][idx_lab[iii]], star_tab["name"][idx_star[iii]]) print('Renaming {0:d} out of {1:d} stars'.format(len(idx_lab), len(star_tab))) - + # Make a copy of the table, UNLESS, the user specifies. if new_copy: new_tab = copy.deepcopy(star_tab) @@ -291,9 +385,9 @@ def rename_after_flystar(star_tab, label_dat_file, new_copy=True, dr_tol=0.05, d # copy over the original names... don't overwrite (this could mean data loss) if 'name_orig' not in new_tab.colnames: new_tab.add_column(Column(star_tab['name'].data, name='name_orig')) - + new_tab['name'][idx_star] = label_tab[idx_lab]['name'] - + return new_tab def pick_good_ref_stars(star_tab, r_cut=None, m_cut=None, p_err_cut=None, pm_err_cut=None, name_cut=None, reset=True): @@ -317,12 +411,12 @@ def pick_good_ref_stars(star_tab, r_cut=None, m_cut=None, p_err_cut=None, pm_err print('pick_good_ref_stars: Use {0:d} stars after m<{1:.2f}.'.format(use.sum(), m_cut)) if p_err_cut is not None: - p_err = np.mean((star_tab['x0e'], star_tab['y0e']), axis=0) + p_err = np.mean((star_tab['x0_err'], star_tab['y0_err']), axis=0) use = use & (p_err < p_err_cut) print('pick_good_ref_stars: Use {0:d} stars after p_err<{1:.5f}.'.format(use.sum(), p_err_cut)) if pm_err_cut is not None: - pm_err = np.mean((star_tab['vxe'], star_tab['vye']), axis=0) + pm_err = np.mean((star_tab['vx_err'], star_tab['vy_err']), axis=0) use = use & (pm_err < pm_err_cut) print('pick_good_ref_stars: Use {0:d} stars after pm_err<{1:.5f}.'.format(use.sum(), pm_err_cut)) @@ -338,44 +432,24 @@ def pick_good_ref_stars(star_tab, r_cut=None, m_cut=None, p_err_cut=None, pm_err def startable_subset(tab, idx, mag_trans=True, mag_trans_orig=False): """ - Input is MosaicToRef table from alignment of multiple filters, + Input is MosaicToRef table from alignment of multiple filters, such that the astrometry is combined but the photometry is not. - This function is used to separate out a selected filter from the + This function is used to separate out a selected filter from the combined astrometry + uncombined photometry table. """ # Multiples: ['x', 'y', 'm', 'name_in_list', 'xe', 'ye', 'me', 't', - # 'x_orig', 'y_orig', 'm_orig', 'xe_orig', 'ye_orig', 'me_orig', 'used_in_trans'] - # Single: ['name', 'm0', 'm0e', 'use_in_trans', 'ref_orig', 'n_detect', - # 'x0', 'vx', 'y0', 'vy', 'x0e', 'vxe', 'y0e', 'vye', 't0'] + # 'x_orig', 'y_orig', 'm_orig', 'xe_orig', 'ye_orig', 'me_orig', 'used_in_trans', + # 'xe_boot','ye_boot','me_boot'] + # Single: ['name', 'm0', 'm0_err', 'use_in_trans', 'ref_orig', 'n_detect', + # 'x0', 'vx', 'y0', 'vy', 'x0_err', 'vx_err', 'y0_err', 'vy_err', 't0'] # Don't include n_vfit - new_tab = startables.StarTable(name=tab['name'].data, - x=tab['x'][:,idx].data, - y=tab['y'][:,idx].data, - m=tab['m'][:,idx].data, - xe=tab['xe'][:,idx].data, - ye=tab['ye'][:,idx].data, - me=tab['me'][:,idx].data, - t=tab['t'][:,idx].data, - x_orig=tab['x_orig'][:,idx].data, - y_orig=tab['y_orig'][:,idx].data, - m_orig=tab['m_orig'][:,idx].data, - xe_orig=tab['xe_orig'][:,idx].data, - ye_orig=tab['ye_orig'][:,idx].data, - me_orig=tab['me_orig'][:,idx].data, - used_in_trans=tab['used_in_trans'][:,idx].data, - m0=tab['m0'].data, - m0e=tab['m0e'].data, - use_in_trans=tab['use_in_trans'].data, - x0=tab['x0'].data, - vx=tab['vx'].data, - y0=tab['y0'].data, - vy=tab['vy'].data, - x0e=tab['x0e'].data, - vxe=tab['vxe'].data, - y0e=tab['y0e'].data, - vye=tab['vye'].data, - t0=tab['t0'].data) + new_tab = copy.deepcopy(tab) + #new_tab.remove_column('n_fit') + new_tab.remove_column('n_detect') + for col in ['x','y','m','name_in_list','xe','ye','me','t','x_orig','y_orig','m_orig', + 'xe_orig','ye_orig','me_orig','used_in_trans','xe_boot','ye_boot','me_boot']: + new_tab[col] = tab[col][:,idx] new_tab.combine_lists('m', weights_col='me', sigma=3, ismag=True) @@ -392,7 +466,7 @@ def startable_subset(tab, idx, mag_trans=True, mag_trans_orig=False): # Update the original table. if mag_trans_orig: tab['m'][:,idx[ii]] += mag_offset - + return new_tab @@ -402,13 +476,13 @@ def startable_subset(tab, idx, mag_trans=True, mag_trans_orig=False): def calc_chi2(ref_mat, starlist_mat, transform, errs='both'): """ - calculate the chi2 and reduced chi2 of the position + calculate the chi2 and reduced chi2 of the position between two matched starlists. Input: ref_mat: astropy table Reference starlist only containing matched stars that were used in the transformation. Standard column headers are assumed. - + starlist_mat: astropy table Transformed starlist only containing the matched stars used in the transformation. Standard column headers are assumed. @@ -448,7 +522,7 @@ def calc_chi2(ref_mat, starlist_mat, transform, errs='both'): elif errs == 'starlist': xerr = starlist_mat['xe'] yerr = starlist_mat['ye'] - + # For both X and Y, calculate chi-square. Combine arrays to get combined # chi-square @@ -456,11 +530,11 @@ def calc_chi2(ref_mat, starlist_mat, transform, errs='both'): chi_sq_y = diff_y**2. / yerr**2. chi_sq = np.append(chi_sq_x, chi_sq_y) - + # Calculate degrees of freedom in transformation num_mod_params = calc_nparam(transform) deg_freedom = len(chi_sq) - num_mod_params - + # Calculate reduced chi-square chi_sq = np.sum(chi_sq) chi_sq_red = chi_sq / deg_freedom @@ -477,7 +551,7 @@ def calc_nparam(transformation): nparam = 4 elif transformation.__class__.__name__ == 'PolyTransform': order = transformation.order - nparam = (order+1) * (order+2) + nparam = (order+1) * (order+2) return nparam def calc_F(red_chi2_1, red_chi2_2, v1, v2): @@ -498,24 +572,24 @@ def calc_F(red_chi2_1, red_chi2_2, v1, v2): for 1st order polynomial fitting: x' = a0 + a1*x + a2*y y' = b0 + b1*x + b2*y - v1 = 2*N1 - 2*3 (2*: because x and y direction) + v1 = 2*N1 - 2*3 (2*: because x and y direction) red_chi2_1 = chi2/v1 for 2nd order polynomial fitting: x' = a0 + a1*x + a2*y + a3*x**2 + a4*y**2 + a5*x*y y' = b0 + b1*x + b2*y + b3*x**2 + b4*y**2 + b5*x*y - v1 = 2*N1 - 2*6 + v1 = 2*N1 - 2*6 red_chi2_2 = chi2/v2 calc_F(red_chi2_1, red_chi2_2, v1, v2) - + ***Note*** - * make sure the first model is the simple model + * make sure the first model is the simple model and the second model is the more complicated model - * the return value represents the probability that + * the return value represents the probability that the first model is better than the second model, in other words, the small P means the more colicated model is needed. the large P means the simple model is good enough. - * normally, the P value will increase from model1->model2, to - model2->model3, to model3->model4. The user can decide a + * normally, the P value will increase from model1->model2, to + model2->model3, to model3->model4. The user can decide a critical value (eg, 0.7) to find the proper model. """ diff --git a/flystar/archive_io.py b/flystar/archive_io.py index 88de5cb..2177e40 100755 --- a/flystar/archive_io.py +++ b/flystar/archive_io.py @@ -1,9 +1,9 @@ import pickle -# Need to add these functions to a utility .py file rather than storing them in general structure. +# Need to add these functions to a utility .py file rather than storing them in general structure. def open_archive(file_name): """ - Helper function to open archived files. + Helper function to open archived files. """ with open(file_name, 'rb') as file_archive: file_dict = pickle.load(file_archive) @@ -11,7 +11,7 @@ def open_archive(file_name): def save_archive(file_name, save_data): """ - Helper function to archive a file. + Helper function to archive a file. """ with open(file_name, 'wb') as outfile: pickle.dump(save_data, outfile, protocol=pickle.HIGHEST_PROTOCOL) diff --git a/flystar/conftest.py b/flystar/conftest.py index 672b273..da164b5 100644 --- a/flystar/conftest.py +++ b/flystar/conftest.py @@ -31,9 +31,9 @@ def pytest_configure(config): PYTEST_HEADER_MODULES.pop('Pandas', None) PYTEST_HEADER_MODULES['scikit-image'] = 'skimage' - from . import __version__ + #from . import __version__ packagename = os.path.basename(os.path.dirname(__file__)) - TESTED_VERSIONS[packagename] = __version__ + #TESTED_VERSIONS[packagename] = __version__ # Uncomment the last two lines in this block to treat all DeprecationWarnings as # exceptions. For Astropy v2.0 or later, there are 2 additional keywords, diff --git a/flystar/examples.py b/flystar/examples.py index 8059562..0165cb3 100644 --- a/flystar/examples.py +++ b/flystar/examples.py @@ -1,11 +1,5 @@ -from flystar import transforms -from flystar import match -from flystar import align -from flystar import starlists -from flystar import plots import numpy as np -import copy -import pdb +from . import transforms, match, align, starlists, plots def align_example(labelFile, reference, transModel=transforms.four_paramNW, order=1, N_loop=2, @@ -38,7 +32,7 @@ def align_example(labelFile, reference, transModel=transforms.four_paramNW, orde dr_tol: float (default = 1.0) The search radius for the matching algorithm, in the same units as the starlist file positions. - + dm_tol: float or None If float, sets the maximum magnitude difference allowed in matching between label.dat and starlist. Note that this should be set to @@ -54,10 +48,10 @@ def align_example(labelFile, reference, transModel=transforms.four_paramNW, orde outFile: string (default = 'outTrans.txt') Name of output ascii file which contains the transform parameters. - + Output: ------ - + """ # Read in label.dat file and reference starlist, changing columns to their # standard column headers/epochs/orientations @@ -72,7 +66,7 @@ def align_example(labelFile, reference, transModel=transforms.four_paramNW, orde # Apply intial transformation to label.dat (for error weighting purposes below) label_trans = align.transform_from_object(label, trans) - + # Use transformation to match starlists, then recalculate transformation. # Iterate on this as many times as desired for i in range(N_loop): @@ -80,10 +74,10 @@ def align_example(labelFile, reference, transModel=transforms.four_paramNW, orde trans, dr_tol=dr_tol, dm_tol=dm_tol) - + trans, N_trans = align.find_transform(label[idx_label], label_trans[idx_label], - starlist_mat[idx_starlist], + starlist[idx_starlist], transModel=transModel, order=order, weights=weights) @@ -91,14 +85,14 @@ def align_example(labelFile, reference, transModel=transforms.four_paramNW, orde # Write final transform in java align format print('Write transform to {0}'.format(outFile)) align.write_transform(trans, labelFile, reference, N_trans, outFile=outFile) - + # Test transform: apply final transformation to label.dat label_trans2 = align.transform(label, outFile) # Make diagnostic plots - + return - + def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order=1, N_loop=2, dr_tol=1.0, dm_tol=None, briteN=100, weights=None, restrict=False, @@ -131,7 +125,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order dr_tol: float (default = 1.0) The search radius for the matching algorithm, in the same units as the starlist file positions. - + dm_tol: float or None (default = None) If float, sets the maximum magnitude difference allowed in matching between label.dat and starlist. Note that this should be set to @@ -143,7 +137,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order weights: string (default=None) if weights=='both', we use both position error and velocity error in transformed - starlist and reference starlist as uncertanties. And weights is the reciprocal + starlist and reference starlist as uncertanties. And weights is the reciprocal of this uncertanty. if weights=='starlist', we only use postion error and velocity error in transformed starlist as uncertainty. @@ -156,7 +150,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order outFile: string (default = 'outTrans.txt') Name of output ascii file which contains the transform parameters. - + Output: ------ outFile is written containing the tranformation coefficients @@ -170,11 +164,11 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order positions and the label.dat positions after transformation. -Positions_quiver.png: Quiver plot showing the difference between reference - positions and transformed label.dat positions as a function of location. - + positions and transformed label.dat positions as a function of location. + -Magnitude_hist.png: Histogram of the difference between the reference list magnitude and label.dat magnitude for matched stars. - + """ # Read in label.dat file and reference starlist, changing columns to their # standard column headers/epochs/orientations @@ -192,10 +186,10 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order # Perform blind matching of 100 brightest stars and calculate initial transform trans = align.initial_align(label_r, starlist, briteN, transformModel=transModel, order=order) - + # Apply transformation to label.dat file, for weighting purposes. label_trans = align.transform_from_object(label, trans) - + # Use transformation to match starlists, then recalculate transformation. # Iterate on this as many times as desired for i in range(N_loop): @@ -223,7 +217,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order print('Write transform to {0}'.format(outFile)) align.write_transform(trans, labelFile, reference, N_trans, deltaMag=delta_m, restrict=restrict, weights=weights, outFile=outFile) - + # Test transform: apply to label.dat, make diagnostic plots label_trans2 = align.transform_from_file(label, outFile) @@ -241,7 +235,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order label_trans2[idx_label], xlim=xlim, ylim=ylim) # Histogram of difference in transformed and reference positions for - # matched stars + # matched stars plots.pos_diff_hist(starlist[idx_starlist], label_trans2[idx_label]) # Histogram of difference in transformed and reference positions for @@ -250,7 +244,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order plots.pos_diff_err_hist(starlist[idx_starlist], label_trans2[idx_label], trans, errs='both', bin_width=0.5, xlim=[-6,6]) - # Histogram of difference in the magnitudes for the matched stars + # Histogram of difference in the magnitudes for the matched stars plots.mag_diff_hist(starlist[idx_starlist], label_trans2[idx_label]) # Quiver plot showing difference between transformed and reference @@ -260,7 +254,7 @@ def align_Arches(labelFile, reference, transModel=transforms.four_paramNW, order ylim=ylim, outlier_reject=None) print('Done with plots') - print('Done with plots') + print('Done with plots') return @@ -274,7 +268,7 @@ def align_gc(starFile, refFile, transModel=transforms.PolyTransform, order=1, N_ Parameters: ----------- starFile: string - Starlist we would like to transform into the reference frame, eg:label.dat + Starlist we would like to transform into the reference frame, eg:label.dat refFile: string Starlist that defines the reference frame. @@ -312,7 +306,7 @@ def align_gc(starFile, refFile, transModel=transforms.PolyTransform, order=1, N_ """ #---------------------------------------------- - # Read in starlist and reference + # Read in starlist and reference #---------------------------------------------- # starlist has postion & postion err ref = starlists.read_starlist(refFile, error=True) @@ -400,7 +394,7 @@ def align_starlists(starlist, ref, transModel=transforms.PolyTransform, order=2, Parameters: ----------- starlist: Table - Starlist we would like to transform into the reference frame, eg:label.dat + Starlist we would like to transform into the reference frame, eg:label.dat ref: Table Starlist that defines the reference frame. @@ -433,7 +427,7 @@ def align_starlists(starlist, ref, transModel=transforms.PolyTransform, order=2, outFile: string('outTrans.txt') the name of the output transformation file """ - + #-------------------------------------------------- # Initial transformation with brightest briteN stars #-------------------------------------------------- diff --git a/flystar/fit_velocity.py b/flystar/fit_velocity.py deleted file mode 100755 index 0317322..0000000 --- a/flystar/fit_velocity.py +++ /dev/null @@ -1,205 +0,0 @@ -from tqdm import tqdm -import numpy as np -import pandas as pd - -def linear(x, k, b): - return k*x + b - -def linear_fit(x, y, sigma=None, absolute_sigma=True): - """Weighted linear regression (See https://en.wikipedia.org/wiki/Weighted_least_squares#Solution). Recommended for low-dimension, non-degenerate data. Otherwise, please use scipy.curve_fit. - - Parameters - ---------- - x : array-like - x data - y : array-like - y data - sigma : array-like, optional - Weighted by 1/sigma**2. If not provided, weight = 1, by default None - absolute_sigma : bool, optional - If True (default), sigma is used in an absolute sense and the estimated parameter uncertainty reflects these absolute values. If False, only the relative magnitudes of the sigma values matter, by default True - - Returns - ------- - result : dictionary - Dictionary with keys 'slope', 'e_slope', 'intercept', 'e_intercept', and 'chi2' if return_chi2=True. - """ - x = np.array(x) - y = np.array(y) - if sigma is None: - sigma = np.ones_like(x) - else: - sigma = np.array(sigma) - - X = np.vander(x, 2) - W = np.diag(1/sigma**2) - XTWX = X.T @ W @ X - pcov = np.linalg.inv(XTWX) # Covariance Matrix - popt = pcov @ X.T @ W @ y # Linear Solution - perr = np.sqrt(np.diag(pcov)) # Uncertainty of Linear Solution - - residual = y - X @ popt - chi2 = residual.T @ W @ residual - - if not absolute_sigma: - reduced_chi2 = chi2/(len(x) - 2) - perr *= reduced_chi2**0.5 - - result = { - 'slope': popt[0], - 'intercept': popt[1], - 'e_slope': perr[0], - 'e_intercept': perr[1], - 'chi2': chi2 - } - - return result - - -def calc_chi2(x, y, sigma, slope, intercept): - popt = np.array([slope, intercept]) - X = np.vander(x, 2) - W = np.diag(1/sigma**2) - residual = y - X @ popt - return residual.T @ W @ residual - - -def fit_velocity(startable, weighting='var', use_scipy=False, absolute_sigma=True, epoch_cols='all', art_star=False): - """Fit proper motion with weighted linear regression equations (see https://en.wikipedia.org/wiki/Weighted_least_squares#Solution). - Assumes that all data are valid. - - Parameters - ---------- - startable : StarTable - StarTable object - weighting : str, optional - Weighting by variance (1/ye**2) or standard deviation (1/ye), by default 'var' - use_scipy : bool, optional - Use scipy.curve_fit or flystar.fit_velocity.linear_fit, by default False - absolute_sigma : bool, optional - If True (default), sigma is used in an absolute sense and the estimated parameter uncertainty reflects these absolute values. If False, only the relative magnitudes of the sigma values matter, by default True - epoch_cols : str or list of intergers, optional - List of indicies of columns to use. If 'all', use all columns, by default 'all' - art_star : bool, optional - Artificial star catalog or not. If True, use startable['x'][:, epoch_ols, 1] as the location, by default False. - - Returns - ------- - result : pd.DataFrame - Proper motion dataframe with keys vx, vxe, vy, vye, x0, x0e, y0, y0e - - Raises - ------ - ValueError - If weighting is neither 'std' nor 'var' - """ - if weighting not in ['std', 'var']: - raise ValueError(f"Weighting must be either 'std' or 'var', not '{weighting}'.") - if epoch_cols is None: - epoch_cols = np.arange(len(startable.meta['YEARS'])) # use all cols if not specified - - N = len(startable) - vx = np.zeros(N) - vy = np.zeros(N) - vxe = np.zeros(N) - vye = np.zeros(N) - x0 = np.zeros(N) - y0 = np.zeros(N) - x0e = np.zeros(N) - y0e = np.zeros(N) - chi2_vx = np.zeros(N) - chi2_vy = np.zeros(N) - t0 = np.zeros(N) - - time = np.array(startable.meta['YEARS'])[epoch_cols] - - if not art_star: - x_arr = startable['x'][:, epoch_cols] - y_arr = startable['y'][:, epoch_cols] - else: - x_arr = startable['x'][:, epoch_cols, 1] - y_arr = startable['y'][:, epoch_cols, 1] - - xe_arr = startable['xe'][:, epoch_cols] - ye_arr = startable['ye'][:, epoch_cols] - - if weighting=='std': - sigma_x_arr = np.abs(xe_arr)**0.5 - sigma_y_arr = np.abs(ye_arr)**0.5 - elif weighting=='var': - sigma_x_arr = xe_arr - sigma_y_arr = ye_arr - - # For each star - for i in tqdm(range(len(startable))): - x = x_arr[i] - y = y_arr[i] - xe = xe_arr[i] - ye = ye_arr[i] - sigma_x = sigma_x_arr[i] - sigma_y = sigma_y_arr[i] - - t_weight = 1. / np.hypot(xe, ye) - t0[i] = np.average(time, weights=t_weight) - dt = time - t0[i] - - if use_scipy: - p0x = np.array([0., x.mean()]) - p0y = np.array([0., y.mean()]) - - # Use scipy.curve_fit to fit for velocity - vx_opt, vx_cov = curve_fit(linear, dt, x, p0=p0x, sigma=sigma_x, absolute_sigma=absolute_sigma) - vy_opt, vy_cov = curve_fit(linear, dt, y, p0=p0y, sigma=sigma_y, absolute_sigma=absolute_sigma) - - vx[i] = vx_opt[0] - vy[i] = vy_opt[0] - x0[i] = vx_opt[1] - y0[i] = vy_opt[1] - vxe[i], x0e[i] = np.sqrt(vx_cov.diagonal()) - vye[i], y0e[i] = np.sqrt(vy_cov.diagonal()) - chi2_vx[i] = calc_chi2(dt, x, sigma_x, *vx_opt) - chi2_vy[i] = calc_chi2(dt, y, sigma_y, *vy_opt) - - else: - vx_result = linear_fit(dt, x, sigma=sigma_x, absolute_sigma=absolute_sigma) - vy_result = linear_fit(dt, y, sigma=sigma_y, absolute_sigma=absolute_sigma) - - vx[i] = vx_result['slope'] - vxe[i] = vx_result['e_slope'] - x0[i] = vx_result['intercept'] - x0e[i] = vx_result['e_intercept'] - chi2_vx[i] = vx_result['chi2'] - - vy[i] = vy_result['slope'] - vye[i] = vy_result['e_slope'] - y0[i] = vy_result['intercept'] - y0e[i] = vy_result['e_intercept'] - chi2_vy[i] = vy_result['chi2'] - - result = pd.DataFrame({ - 'vx': vx, 'vy': vy, - 'vxe': vxe, 'vye': vye, - 'x0': x0, 'y0': y0, - 'x0e': x0e, 'y0e': y0e, - 'chi2_vx': chi2_vx, - 'chi2_vy': chi2_vy, - 't0': t0 - }) - return result - - -# Test -if __name__=='__main__': - from scipy.optimize import curve_fit - - x = np.array([1,2,3,4]) - y = np.array([1,2,5,6]) - sigma = np.array([.4,.2,.1,.3]) - - for absolute_sigma in [True, False]: - result = linear_fit(x, y, sigma=sigma, absolute_sigma=absolute_sigma) - popt, pcov = curve_fit(linear, x, y, sigma=sigma, absolute_sigma=absolute_sigma) - perr = np.sqrt(np.diag(pcov)) - print(f'Absolute Sigma = {absolute_sigma}') - print(f"linear_fit: slope = {result['slope']:.3f} ± {result['e_slope']:.3f}, intercept = {result['intercept']:.3f} ± {result['e_intercept']:.3f}, chi2={result['chi2']:.3f}") - print(f'curve_fit: slope = {popt[0]:.3f} ± {perr[0]:.3f}, intercept = {popt[1]:.3f} ± {perr[1]:.3f}, chi2={calc_chi2(x, y, sigma, *popt):.3f}\n') \ No newline at end of file diff --git a/flystar/match.py b/flystar/match.py index d40ccdb..66363ac 100644 --- a/flystar/match.py +++ b/flystar/match.py @@ -1,23 +1,20 @@ +import copy +import itertools import numpy as np -from flystar import starlists, transforms, startables, align +import matplotlib.pyplot as plt +from . import starlists, transforms, startables from collections import Counter -from scipy.spatial import cKDTree as KDT -from astropy.table import Column, Table -import itertools -import copy -import scipy.signal -from scipy.spatial import distance -import math -import pdb +from astropy.table import Column +from scipy.spatial import KDTree as KDT -def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, - Nbins_vmax=200, Nbins_angle=360,verbose=False): +def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, + polygon1=None, polygon2=None, buffer=0, Nbins_vmax=200, Nbins_angle=360,verbose=False): """ Take two input starlists and select the brightest stars from - each. Then performa a triangle matching algorithm along the lines of + each. Then perform a triangle matching algorithm along the lines of Groth 1986. - + For every possible triangle (combination of 3 stars) in a starlist, compute the ratio of two sides and the angle between those sides. These quantities are invariant under scale and rotation transformations. @@ -30,23 +27,115 @@ def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, and brightness uncertainties, the more bigger the bin sizes should really be. But this isn't well tested. """ - + if verbose: print( '') print( ' miracle_match_briteN: use brightest {0}'.format(Nbrite)) print( ' miracle_match_briteN: ') print( ' miracle_match_briteN: ') + xin1 = np.array(xin1) + yin1 = np.array(yin1) + min1 = np.array(min1) + xin2 = np.array(xin2) + yin2 = np.array(yin2) + min2 = np.array(min2) + + if (polygon1 is not None) and (polygon2 is not None): + import shapely + points1 = shapely.points(xin1, yin1) + points2 = shapely.points(xin2, yin2) + overlap = polygon1.intersection(polygon2).buffer(buffer) + in_poly1 = shapely.contains(overlap, points1) + in_poly2 = shapely.contains(overlap, points2) + xin1 = xin1[in_poly1] + yin1 = yin1[in_poly1] + min1 = min1[in_poly1] + xin2 = xin2[in_poly2] + yin2 = yin2[in_poly2] + min2 = min2[in_poly2] + # else: + # # Only look for matches within overlapping minimum-bounding-boxes of the 2 lists + # valid1 = (np.isfinite(xin1)) & (np.isfinite(yin1)) & (np.isfinite(min1)) + # valid2 = (np.isfinite(xin2)) & (np.isfinite(yin2)) & (np.isfinite(min2)) + # if (sum(valid1) < Nbrite) or (sum(valid2) < Nbrite): + # raise ValueError( + # f'Not enough valid stars to find matches! Need at least {Nbrite} valid stars.\n' + + # f'Valid stars in list 1: {sum(valid1)}\n' + + # f'Valid stars in list 2: {sum(valid2)}\n' + # ) + + # xin1 = xin1[valid1] + # yin1 = yin1[valid1] + # min1 = min1[valid1] + # xin2 = xin2[valid2] + # yin2 = yin2[valid2] + # min2 = min2[valid2] + + # xmin1, xmax1 = np.min(xin1), np.max(xin1) + # ymin1, ymax1 = np.min(yin1), np.max(yin1) + # xmin2, xmax2 = np.min(xin2), np.max(xin2) + # ymin2, ymax2 = np.min(yin2), np.max(yin2) + + # # Find the overlapping minimum bounding box + # x_overlap = (max(xmin1, xmin2), min(xmax1, xmax2)) + # y_overlap = (max(ymin1, ymin2), min(ymax1, ymax2)) + # if x_overlap[0] >= x_overlap[1] or y_overlap[0] >= y_overlap[1]: + # fig, ax = plt.subplots() + # ax.scatter(xin1, yin1, s=1, label='List 1') + # ax.scatter(xin2, yin2, s=1, label='List 2') + # ax.set_aspect('equal') + # ax.legend() + # plt.show() + # raise ValueError('The two star lists do not have an overlapping region!') + + # # Select overlapping regions + # in_overlap1 = (xin1 >= x_overlap[0]) & (xin1 <= x_overlap[1]) & (yin1 >= y_overlap[0]) & (yin1 <= y_overlap[1]) + # in_overlap2 = (xin2 >= x_overlap[0]) & (xin2 <= x_overlap[1]) & (yin2 >= y_overlap[0]) & (yin2 <= y_overlap[1]) + # if sum(in_overlap1) < Nbrite or sum(in_overlap2) < Nbrite: + # raise ValueError( + # 'Not enough stars in the overlapping region to find matches!\n' + + # f'Stars in overlap for list 1: {sum(in_overlap1)}\n' + + # f'Stars in overlap for list 2: {sum(in_overlap2)}\n' + # ) + + # from matplotlib.patches import Rectangle + # fig, ax = plt.subplots() + # polygon1 = Rectangle((xmin1, ymin1), xmax1-xmin1, ymax1-ymin1, fill=True, edgecolor='C0', facecolor='C0', alpha=0.5, label='MBB List 1') + # polygon2 = Rectangle((xmin2, ymin2), xmax2-xmin2, ymax2-ymin2, fill=True, edgecolor='C2', facecolor='C2', alpha=0.5, label='MBB List 2') + # polygon_overlap = Rectangle((x_overlap[0], y_overlap[0]), x_overlap[1]-x_overlap[0], y_overlap[1]-y_overlap[0], fill=True, edgecolor='red', facecolor='C3', alpha=0.5, label='Overlap Region') + # ax.scatter(xin1, yin1, s=1, label='List 1') + # ax.scatter(xin2, yin2, s=1, label='List 2') + # ax.add_patch(polygon1) + # ax.add_patch(polygon2) + # ax.add_patch(polygon_overlap) + # ax.set_aspect('equal') + # ax.legend() + # plt.show() + + # xin1 = xin1[in_overlap1] + # yin1 = yin1[in_overlap1] + # min1 = min1[in_overlap1] + # xin2 = xin2[in_overlap2] + # yin2 = yin2[in_overlap2] + # min2 = min2[in_overlap2] + # Get/check the lengths of the two starlists nin1 = len(xin1) nin2 = len(xin2) if (nin1 < Nbrite) or (nin2 < Nbrite): - print(( 'You need at least {0} to '.format(Nbrite))) - print( 'find the matches...') - print(( 'NIN1: ', nin1)) - print(( 'NIN2: ', nin2)) - return (0, None, None, None, None, None, None) + raise ValueError( + f'Not enough stars in the overlapping region to find matches! Need at least {Nbrite} valid stars.\n' + + f'Stars in overlap for list 1: {nin1}\n' + + f'Stars in overlap for list 2: {nin2}\n' + ) + # print(f'WARNING: You need at least {Nbrite} to find the matches...') + # print(f'NIN1: {nin1}') + # print(f'NIN2: {nin2}') + # # Nbrite = min(nin1, nin2) + # # print(f'Updating Nbrite to {Nbrite}...') + # return (0, None, None, None, None, None, None) # Take the Nbrite brightest stars from each list and order by brightness. if verbose: @@ -55,7 +144,7 @@ def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, print( ' miracle_match_briteN: ') x1, y1, m1 = order_by_brite(xin1, yin1, min1, Nbrite, verbose=verbose) x2, y2, m2 = order_by_brite(xin2, yin2, min2, Nbrite, verbose=verbose) - + #################### # # Triangle Matching @@ -111,7 +200,6 @@ def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, idx2_vmax_hist = idx2_vmax_hist[good_idx2] idx2_angl_hist = idx2_angl_hist[good_idx2] - ########## # Possible Matches ########## @@ -125,7 +213,7 @@ def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, # Now vote for all stars in the triangles that have possible matches (same vmax, angle) # between the first and second lists. votes = np.zeros((Nbrite, Nbrite)) - + matches = np.where(stars_in1_matches2[:,0] >= 0)[0] match_stars1 = stars_in1_matches2[matches,:] match_stars2 = stars_in_tri2[matches,:] @@ -138,7 +226,7 @@ def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, add_votes(votes, match_stars1[:,0], match_stars2[:,0]) add_votes(votes, match_stars1[:,1], match_stars2[:,1]) add_votes(votes, match_stars1[:,2], match_stars2[:,2]) - + ########## # Find matching triangles with most votes (and that pass threshold) ########## @@ -166,7 +254,6 @@ def miracle_match_briteN(xin1, yin1, min1, xin2, yin2, min2, Nbrite, x1_mat = x1[votes_sdx[0, good]] y1_mat = y1[votes_sdx[0, good]] m1_mat = m1[votes_sdx[0, good]] - return len(x1_mat), x1_mat, y1_mat, m1_mat, x2_mat, y2_mat, m2_mat @@ -205,11 +292,12 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): For two stars to be matched, they must be within a specified radius (dr_tol) and delta-magnitude (dm_tol). For stars with more than 1 neighbor (within the tolerances), if one is found that is the best match in both brightness and positional offsets - (closest in both), then the match is made. Otherwise, - their is a conflict and no match is returned for the star. - - + (closest in both), then the match is made. + Otherwise, their is a conflict and no match is returned for the star. + + Parameters + ---------- x1 : array-like X coordinate in the first catalog y1 : array-like @@ -230,9 +318,9 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): How close in delta-magnitude a match has to be to count as a match. If None, then any delta-magnitude is allowed. verbose : bool or int, optional - Prints on screen information on the matching. Higher verbose values + Prints on screen information on the matching. Higher verbose values (up to 9) provide more detail. - + Returns ------- idx1 : int array @@ -245,27 +333,37 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): Distance between the matches. dm : float array Delta-mag between the matches. (m1 - m2) - + + Raises + ------ + ValueError + If the input arrays do not have the same shape or if they do not contain any finite values. + Or when no match is found between the two catalogs. """ - + x1 = np.array(x1, copy=False) y1 = np.array(y1, copy=False) m1 = np.array(m1, copy=False) x2 = np.array(x2, copy=False) y2 = np.array(y2, copy=False) m2 = np.array(m2, copy=False) - - if x1.shape != y1.shape: - raise ValueError('x1 and y1 do not match!') - if x2.shape != y2.shape: - raise ValueError('x2 and y2 do not match!') - + + if not np.isfinite(x1).any(): raise ValueError('x1 does not contain any finite values!') + if not np.isfinite(y1).any(): raise ValueError('y1 does not contain any finite values!') + if not np.isfinite(m1).any(): raise ValueError('m1 does not contain any finite values!') + if not np.isfinite(x2).any(): raise ValueError('x2 does not contain any finite values!') + if not np.isfinite(y2).any(): raise ValueError('y2 does not contain any finite values!') + if not np.isfinite(m2).any(): raise ValueError('m2 does not contain any finite values!') + + assert x1.shape == y1.shape, 'x1 and y1 do not match!' + assert x2.shape == y2.shape, 'x2 and y2 do not match!' + # Setup coords1 pairs and coords 2 pairs # this is equivalent to, but faster than just doing np.array([x1, y1]) coords1 = np.empty((x1.size, 2)) coords1[:, 0] = x1 coords1[:, 1] = y1 - + # this is equivalent to, but faster than just doing np.array([x1, y1]) coords2 = np.empty((x2.size, 2)) coords2[:, 0] = x2 @@ -279,7 +377,10 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): idxs2 = np.ones(x1.size, dtype=int) * -1 # The matching will be done using a KDTree. - kdt = KDT(coords2, balanced_tree=False) + #kdt = KDT(coords2, balanced_tree=False) + #KDTree handling of NaNs throws error in scipy v1.10.1 and newer. + #Replace NaNs in coords2 with zero (0). -SKT + kdt = KDT(np.where(np.isfinite(coords2), coords2, 0), balanced_tree=False) # This returns the number of neighbors within the specified # radius. We will use this to find those stars that have no or one @@ -290,7 +391,6 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): # What is the largest number of matches we have for a given star? Nmatch_max = Nmatch.max() - # Loop through and handle all the different numbers of matches. # This turns out to be the most efficient so we can use numpy # array operations. Remember, skip the Nmatch=0 objects... they @@ -303,7 +403,7 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): if nn == 1: i2_nn = np.array([i2_match[mm][0] for mm in i1_nn]) - if dm_tol != None: + if dm_tol is not None: dm = np.abs(m1[i1_nn] - m2[i2_nn]) keep = dm < dm_tol idxs1[i1_nn[keep]] = i1_nn[keep] @@ -314,20 +414,18 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): else: i2_tmp = np.array([i2_match[mm] for mm in i1_nn]) - # Repeat star list 1 positions and magnitudes - # for nn times (tile then transpose) - x1_nn = np.tile(x1[i1_nn], (nn, 1)).T - y1_nn = np.tile(y1[i1_nn], (nn, 1)).T - m1_nn = np.tile(m1[i1_nn], (nn, 1)).T + x1_nn = x1[i1_nn] + y1_nn = y1[i1_nn] + m1_nn = m1[i1_nn] # Get out star list 2 positions and magnitudes x2_nn = x2[i2_tmp] y2_nn = y2[i2_tmp] m2_nn = m2[i2_tmp] - dr = np.abs(x1_nn - x2_nn, y1_nn - y2_nn) - dm = np.abs(m1_nn - m2_nn) + dr = np.hypot(x2_nn - x1_nn[:, np.newaxis], y2_nn - y1_nn[:, np.newaxis]) + dm = np.abs(m2_nn - m1_nn[:, np.newaxis]) - if dm_tol != None: + if dm_tol is not None: # Don't even consider stars that exceed our # delta-mag threshold. dr_msk = np.ma.masked_where(dm > dm_tol, dr) @@ -342,7 +440,7 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): # Double check that "min" choice is still within our # detla-mag tolerence. - dm_tmp = np.array([dm.T[dm_min[I]][I] for I in np.lib.index_tricks.ndindex(dm_min.shape)]) + dm_tmp = np.array([dm.T[dm_min[I]][I] for I in np.ndindex(dm_min.shape)]) keep = (dm_min == dr_min) & (dm_tmp < dm_tol) else: @@ -361,8 +459,8 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): idxs1 = idxs1[idxs1 >= 0] idxs2 = idxs2[idxs2 >= 0] - dr = np.hypot(x1[idxs1] - x2[idxs2], y1[idxs1] - y2[idxs2]) - dm = m1[idxs1] - m2[idxs2] + dr = np.hypot(x2[idxs2] - x1[idxs1], y2[idxs2] - y1[idxs1]) + dm = m2[idxs2] - m1[idxs1] # Deal with duplicates duplicates = [item for item, count in list(Counter(idxs2).items()) if count > 1] @@ -373,36 +471,29 @@ def match(x1, y1, m1, x2, y2, m2, dr_tol, dm_tol=None, verbose=True): # Index into the idxs1, idxs2 array of this duplicate. dups = np.where(idxs2 == duplicates[dd])[0] - # Assume the duplicates are confused first... see if we - # can resolve the confusion below. + # Assume the duplicates are confused first... see if we can resolve the confusion below. keep[dups] = False - - dm_dups = m1[idxs1[dups]] - m2[idxs2[dups]] - dr_dups = np.hypot(x1[idxs1[dups]] - x2[idxs2[dups]], y1[idxs1[dups]] - y2[idxs2[dups]]) - - dm_min = np.abs(dm_dups).argmin() - dr_min = np.abs(dr_dups).argmin() + best_dm = np.abs(m2[idxs2[dups]] - m1[idxs1[dups]]).argmin() + best_dr = np.hypot(x2[idxs2[dups]] - x1[idxs1[dups]], y2[idxs2[dups]] - y1[idxs1[dups]]).argmin() # If there is a clearly preferred match (closest in distance and brightness), then - # keep it and dump the other duplicates. - if dm_min == dr_min: - keep[dups[dm_min]] = True - else: - if verbose: - print(' confused, dropping') - + # keep it and dump the other duplicates. Otherwise, drop the match as confused. + if best_dm == best_dr: + keep[dups[best_dm]] = True + elif verbose > 3: + print(' confused, dropping star at',x2[idxs2[dups]][0],y2[idxs2[dups]][0]) # Clean up the duplicates idxs1 = idxs1[keep] idxs2 = idxs2[keep] dr = dr[keep] dm = dm[keep] - + return idxs1, idxs2, dr, dm def calc_triangles_vmax_angle(x, y): idx = np.arange(len(x), dtype=np.int16) - + # Option 1 -- this takes 0.217 seconds for 50 objects # t1 = time.time() # combo_iter1 = itertools.combinations(idx1, 3) @@ -411,53 +502,53 @@ def calc_triangles_vmax_angle(x, y): # print( 'Finished Option 1: ', t2 - t1) # print( combo_idx1_1.shape) # print( combo_idx1_1) - + # Option 2 -- this takes 0.016 seconds for 50 objects combo_iter = itertools.combinations(idx, 3) combo_dt = np.dtype('i2,i2,i2') combo_idx_tmp = np.fromiter(combo_iter, dtype=combo_dt) combo_idx = combo_idx_tmp.view(np.int16).reshape(-1, 3) - + ii0 = combo_idx[:,0] ii1 = combo_idx[:,1] ii2 = combo_idx[:,2] - + dxab = x[ii1] - x[ii0] dyab = y[ii1] - y[ii0] dxac = x[ii2] - x[ii0] dyac = y[ii2] - y[ii0] - + dab = np.hypot(dxab, dyab) dac = np.hypot(dxac, dyac) - + dmax = np.max([dab, dac], axis=0) dmin = np.min([dab, dac], axis=0) - + vmax = dmin ** 2 / dmax ** 2 vmax[dab < dac] *= -1 - + vdprod = dxab * dxac + dyab * dyac vcprod = dxab * dyac - dyab * dxac - + angle = np.degrees( np.arctan2( vdprod, vcprod) ) angle[angle < 0] += 360.0 angle[angle > 360] -= 360.0 - + return combo_idx, vmax, angle def add_votes(votes, match1, match2): # Construct a histogram of how often a bin is matched... then add the delta flat_idx = np.ravel_multi_index((match1, match2), dims=votes.shape) - + # extract the unique indices and their position unique_idx, idx_idx = np.unique(flat_idx, return_inverse=True) - + # aggregate the repeated indices deltas = np.bincount(idx_idx) - + # Sum them to the array votes.flat[unique_idx] += deltas - + return @@ -514,7 +605,7 @@ def generic_match(sl1, sl2, init_mode='triangle', init_mode verbose : bool, optional Prints on screen information on the matching - + Returns ------- transf : Transform2D @@ -523,16 +614,17 @@ def generic_match(sl1, sl2, init_mode='triangle', Startable of the two matched catalogs """ - + from . import align + # Check the input StarLists and transform them into astropy Tables if not isinstance(sl1, starlists.StarList): raise TypeError("The first catalog has to be a StarList") if not isinstance(sl2, starlists.StarList): raise TypeError("The second catalog has to be a StarList") - + # Find the initial transformation if init_mode == 'triangle': # Blind triangles method - + # Prepare the reduced starlists for matching sl1_cut = copy.deepcopy(sl1) sl2_cut = copy.deepcopy(sl2) @@ -542,21 +634,21 @@ def generic_match(sl1, sl2, init_mode='triangle', y_min=xy_match[6], y_max=xy_match[7]) sl1_cut.restrict_by_value(m_min=m_match[0], m_max=m_match[1]) sl2_cut.restrict_by_value(m_min=m_match[2], m_max=m_match[3]) - + # Find the transformation # TODO: test 'initial_align' with StarList input transf = align.initial_align(sl1_cut, sl2_cut, briteN=n_bright, transformModel=model, order=order_dr[0]) #order_dr[i_loop][0] ? - + elif init_mode == 'match_name': # Name match sl1_idx_init, sl2_idx_init, _ = starlists.restrict_by_name(sl1, sl2) transf = model(sl2['x'][sl2_idx_init], sl2['y'][sl2_idx_init], sl1['x'][sl1_idx_init], sl1['y'][sl1_idx_init], order=int(order_dr[0][0])) - + elif init_mode == 'load': # Load a transformation file transf = transforms.Transform2D.from_file(kwargs['transf_file']) - + else: # None of the above raise TypeError("Unrecognized initial matching method") @@ -565,28 +657,24 @@ def generic_match(sl1, sl2, init_mode='triangle', sl2_match = copy.deepcopy(sl2) sl1_match.restrict_by_value(m_min=m_match[0], m_max=m_match[1]) sl2_match.restrict_by_value(m_min=m_match[2], m_max=m_match[3]) - + # Refine the transformation if sigma_match: order_dr_len = len(order_dr) - + for i_loop in range(sigma_match[1]): order_dr = np.vstack((np.array(order_dr), np.array(order_dr[-1]))) - + for i_loop in range(len(order_dr)): - - # Transform and match the catalog to the reference frame -# sl2_idx, sl1_idx = align.transform_and_match(sl2_match, sl1_match, transf, -# dr_tol=order_dr[i_loop][1], -# verbose=verbose) + # Transform and match the catalog to the reference frame sl2_idx, sl1_idx = align.transform_and_match(sl2_match, sl1_match, transf, dr_tol=order_dr[1], verbose=verbose) # Transform the catalog to the reference frame sl2_transf_match = align.transform_from_object(sl2_match, transf) - + # Sigma-rejection if sigma_match and (i_loop >= order_dr_len): resid = np.sqrt((sl1_match['x'][sl1_idx] - @@ -595,29 +683,29 @@ def generic_match(sl1, sl2, init_mode='triangle', sl2_transf_match['y'][sl2_idx])**2) sl1_idx = sl1_idx[resid <= (sigma_match[0] * np.std(resid))] sl2_idx = sl2_idx[resid <= (sigma_match[0] * np.std(resid))] - + # Test section to observe the matching catalogs before refining the transformation """ from matplotlib import pyplot - + _, axarr = pyplot.subplots(nrows=1, ncols=1, figsize=(10,10)) axarr.scatter(sl1_match['x'][sl1_idx], sl1_match['y'][sl1_idx]) xlim = axarr.get_xlim() ylim = axarr.get_ylim() - + _, axarr = pyplot.subplots(nrows=1, ncols=1, figsize=(10, 10)) axarr.scatter(sl2_transf_match['x'][sl2_idx], sl2_transf_match['y'][sl2_idx]) axarr.set_xlim(xlim) axarr.set_ylim(ylim) """ - + # Find a better transformation transf, _ = align.find_transform(sl2_match[sl2_idx], sl2_transf_match[sl2_idx], sl1_match[sl1_idx], transModel=model, order=order_dr[0], verbose=verbose) # order=int(order_dr[i_loop][0]), verbose=verbose) - + # This section was used for testing transformations with normalized # coordinates. Only several catalogs had reduced residuals when using # high order polynomials (>3), some of them became unstable @@ -636,15 +724,15 @@ def generic_match(sl1, sl2, init_mode='triangle', sl1_match_norm, transModel=model, order=poly_order, verbose=verbose) c_exp = np.zeros(len(transf.px._parameters)) - + for i_c in range(len(transf.px._parameters)): c_exp[i_c] = int(transf.px._param_names[i_c][1:].split('_')[0]) +\ int(transf.px._param_names[i_c][1:].split('_')[1]) - + c_corr = mm ** (1 - c_exp) transf.px._parameters = transf.px._parameters * c_corr transf.py._parameters = transf.py._parameters * c_corr""" - + # Do the final transformation and matching using sl2_idx, sl1_idx = align.transform_and_match(sl2, sl1, transf, dr_tol=dr_final, verbose=verbose) @@ -659,10 +747,10 @@ def generic_match(sl1, sl2, init_mode='triangle', # ep_name=np.column_stack((np.array(sl1['name'][sl1_idx]), np.array(sl2_transf['name'][sl2_idx]))), # list_times=[sl1.meta['list_time'], sl2.meta['list_time']], # list_names=[sl1.meta['list_name'], sl2.meta['list_name']]) - + for col in sl1.colnames: if col in sl2.colnames: if col not in ['name', 'x', 'y', 'm']: st.add_column(Column(np.column_stack((np.array(sl1[col][sl1_idx]),np.array(sl2_transf[col][sl2_idx]))), name=col)) - + return transf, st diff --git a/flystar/motion_model.py b/flystar/motion_model.py new file mode 100644 index 0000000..efc574d --- /dev/null +++ b/flystar/motion_model.py @@ -0,0 +1,1310 @@ +import numpy as np +from abc import ABC +from flystar import parallax +from astropy.time import Time +from scipy.optimize import curve_fit, OptimizeWarning +import warnings + +class MotionModel(ABC): + name = "MotionModel" + + # Fit paramters: Shared fit parameters + fit_param_names = [] + n_fit_params = len(fit_param_names) + # Number of fit parameters/required observations in each direction + n_params = int((n_fit_params + 1) / 2) + + # Fixed parameters: These are parameters that are required for the model, but are not + # fit quantities. For example, RA and Dec in a parallax model. + fixed_param_names = [] + required_fixed_param_names = [] + optional_fixed_params = {} + + fixed_meta_data = [] + + # Non-fit paramters: Custom paramters that will not be fit. + # These parameters should be derived from the fit parameters and + # they must exist as a variable on the model object + + def __init__(self, *args, **kwargs): + """ + Make a motion model object. This object defines the fit and fixed parameters, + and contains functions to fit the model to data and infer positions at given times. + Each instance corresponds to a given motion model, not an individual star, + and thus the fit values are only input/returned in functions, not stored in the object. + """ + return + + def _check_param_dimensions(self, fit_params, fit_params_errs, fixed_params_dict): + """Check that parameters is either a scalar or length of N_stars + + Parameters + ---------- + fit_params: array-like + Fit parameters, shape (N_fit_params,) or (n_stars, N_fit_params) + fit_params_errs: array-like + Errors of fit parameters, shape (N_fit_params,) or (n_stars, N_fit_params) + fixed_params_dict : dict + Dictionary of fixed parameters + """ + N_stars = fit_params.shape[0] if fit_params.ndim > 1 else 1 + if fit_params_errs is not None: + assert fit_params_errs.shape == fit_params.shape, "fit_params and fit_params_errs must have the same shape!" + + if fixed_params_dict is not None: + for key, value in fixed_params_dict.items(): + # assert key in fixed_params_dict, f"Missing fixed parameter {key} in fixed_params_dict!" + value = fixed_params_dict[key] + if np.isscalar(value): + continue + else: + assert len(value) == N_stars, f"Length of fixed parameter {key} must be either 1 or N_stars={N_stars}!" + + def model_fit(self, dt): + return np.full_like(dt, np.nan) + + def model(self, t, fit_params, fit_param_errs=None, fixed_params_dict=None): + self._check_param_dimensions(fit_params, fit_param_errs, fixed_params_dict) + if fit_param_errs is None: + return np.full_like(t, np.nan), np.full_like(t, np.nan) + return np.full_like(t, np.nan), np.full_like(t, np.nan), np.full_like(t, np.inf), np.full_like(t, np.inf) + + def run_fit( + self, t, x, y, xe, ye, + fixed_params_dict=None, + weighting='var', + use_scipy=True, + absolute_sigma=True, + params_guess=None, + fill_value=np.nan, + return_chi2=False, + method=None, + verbose=True + ): + # Run a single fit (used both for overall fit + bootstrap iterations) + if return_chi2: + return np.full(self.n_fit_params, fill_value), np.full(self.n_fit_params, np.inf), np.nan, np.nan + return np.full(self.n_fit_params, fill_value), np.full(self.n_fit_params, np.inf) + + def calc_sigma(self, xe, ye, weighting='var'): + if weighting=='std': + return np.sqrt(np.abs(xe)), np.sqrt(np.abs(ye)) + elif weighting=='var': + return np.abs(xe), np.abs(ye) + else: + warnings.warn("Invalid weighting, using default weighting scheme var.", UserWarning) + return np.abs(xe), np.abs(ye) + + def fit( + self, t, x, y, xe, ye, + fixed_params_dict=None, + weighting='var', + use_scipy=True, + absolute_sigma=True, + fill_value=np.nan, + params_guess=None, + return_chi2=False, + bootstrap=0, + seed=None, + method=None, + verbose=True + ): + """Fit stellar motion parameters + + Parameters + ---------- + t : array-like + Times of measurements + x : array-like + x-coordinates + y : array-like + y-coordinates + xe : array-like + Uncertainty of x + ye : array-like + Uncertainty of y + fixed_params_dict : dict, optional + Dictionary of fixed parameters, see each motion model's fixed_param_names for details, by default None + weighting : str, optional + Use standard error weighting ('std': w=1/xe, 1/ye) or variance weighting ('var': w=1/xe**2, 1/ye**2), by default 'var' + use_scipy : bool, optional + Use scipy for optimization. Otherwise, use linear algebraic solution (Linear model only), which is faster for < 300 epochs, by default True + absolute_sigma : bool, optional + Absolute sigma. See scipy.optimize.curve_fit for details, by default True + fill_value : float, optional + Fill value for parameters when not enough data points to fit model, by default np.nan + params_guess : array-like, optional + Initial guess for the fit parameters used in scipy curve_fit, by default None + return_chi2 : bool, optional + Return chi^2 values along with parameters and uncertainties in params, param_errs, chi2_x, chi2_y, by default False + bootstrap : int, optional + Bootstrapping uncertainties, by default 0 + seed : int, optional + Seed for the random number generator, by default None + method : str, optional + Method of scipy.curve_fit, {'lm', 'trf', 'dogbox'}, by default None + verbose : bool, optional + Print warning messages, by default True + + Returns + ------- + params, param_errs(, chi2_x, chi2_y) + Parameters, uncertainties, and chi squares if return_chi2 is True. The corresponding parameter names are in self.fit_param_names. + """ + for variable, name in zip([t, x, y, xe, ye], ['t', 'x', 'y', 'xe', 'ye']): + assert np.ndim(variable) == 1, f"Input {name} array must be 1D! Got shape {np.shape(variable)}" + if name != 't': + assert len(t) == len(variable), f'Input {name} must have the same length as t! Got len(t)={len(t)}, len({name})={len(variable)}' + + if not verbose: + warnings.filterwarnings("ignore", category=OptimizeWarning) + + fit_result = self.run_fit( + t, x, y, xe, ye, + fixed_params_dict=fixed_params_dict, + weighting=weighting, + use_scipy=use_scipy, + absolute_sigma=absolute_sigma, + fill_value=fill_value, + params_guess=params_guess, + return_chi2=return_chi2, + verbose=verbose + ) + + if return_chi2: + params, param_errs, chi2_x, chi2_y = fit_result + else: + params, param_errs = fit_result + + + # Bootstrap errors + n_obs = len(t) + + if (bootstrap > 0) and (n_obs > self.n_params): + rng = np.random.default_rng(seed) + edx = np.arange(n_obs, dtype=int) + # Precompute All Bootstrap Draws at Once + # Ensure there are enough unique points in each bootstrap sample + bdx_unique = np.stack([ + rng.choice(edx, size=self.n_params, replace=False) + for _ in range(bootstrap) + ]) + # Draw with replacement for the rest + bdx_extra = np.stack([ + rng.choice(edx, size=n_obs - self.n_params, replace=True) + for _ in range(bootstrap) + ]) + bdx_all = np.hstack((bdx_unique, bdx_extra)) + + bb_params = [] + bb_params_errs = [] + for bdx in bdx_all: + params_bdx, param_errs_bdx = self.run_fit( + t[bdx], x[bdx], y[bdx], xe[bdx], ye[bdx], + fixed_params_dict=fixed_params_dict, + weighting=weighting, + use_scipy=use_scipy, + absolute_sigma=absolute_sigma, + params_guess=params, + fill_value=fill_value, + return_chi2=False, + method=method, + verbose=verbose + ) + bb_params.append(params_bdx) + bb_params_errs.append(param_errs_bdx) + + # Save the errors from the bootstrap + param_errs = np.std(bb_params, axis=0) + + # Account for odd case + inf_errs = [np.all(arr==np.inf) for arr in np.transpose(np.array(bb_params_errs))] + param_errs[inf_errs] = 0.0 + + if not verbose: + warnings.resetwarnings() + + if return_chi2: + return params, param_errs, chi2_x, chi2_y + else: + return params, param_errs + + + # def calc_chi2(self, dt, x, y, x_wt, y_wt, popt_x, popt_y, reduced=False, parallax=False): + # X_mat_t = np.vander(dt, 2) + # residual_x = x - X_mat_t @ popt_x + # residual_y = y - X_mat_t @ popt_y + + # W_mat_x = np.diag(x_wt) + # W_mat_y = np.diag(y_wt) + + # chi2_x = residual_x.T @ W_mat_x @ residual_x + # chi2_y = residual_y.T @ W_mat_y @ residual_y + + # if reduced: + # if len(dt) == self.n_params: + # return np.inf, np.inf + # if not parallax: + # degree_of_freedom = len(x) - self.n_params + # else: + # degree_of_freedom = 2*len(x) - len(self.fit_param_names) + # chi2_x, chi2_y = chi2_x / degree_of_freedom, chi2_y / degree_of_freedom + # return chi2_x, chi2_y + + def calc_chi2(self, t, x, y, xe, ye, fit_params, fixed_params_dict=None, reduced=False, parallax=False): + """ + Get the chi^2 value for the input motion model parameters and data. + """ + x_pred, y_pred = self.model(t, fit_params, fixed_params_dict=fixed_params_dict) + chi2x = np.sum((x - x_pred)**2 / xe**2) + chi2y = np.sum((y - y_pred)**2 / ye**2) + if reduced: + if len(t) == self.n_params: + return np.inf, np.inf + if parallax: + degree_of_freedom = 2*len(x) - len(self.fit_param_names) + else: + degree_of_freedom = len(x) - self.n_params + chi2x, chi2y = chi2x / degree_of_freedom, chi2y / degree_of_freedom + return chi2x, chi2y + +class Empty(MotionModel): + name = "Empty" + fit_param_names = [] + fixed_param_names = [] + required_fixed_param_names = [] + optional_fixed_params = {} + + n_fit_params = len(fit_param_names) + # Number of fit parameters/required observations in each direction + n_params = int((n_fit_params + 1) / 2) + + def __init__(self, **kwargs): + """Empty motion model, returns nan for values and inf for uncertainties. + """ + super().__init__() + return + + def model_fit(self, dt): + return np.full_like(dt, np.nan) + + def model(self, t, fit_params, fit_param_errs=None, fixed_params_dict=None): + """Predicted positions (and uncertainties, if fit_param_errs is provided) at time t of Empty model. + + Parameters + ---------- + t : float or array-like + Time array, shape (N_times,) + fit_params : array-like + Fit parameters, shape (N_fit_params,) or (N_stars, N_fit_params) + fit_param_errs : array-like, optional + Uncertainties for fit parameters, not applicable for Empty model, by default None + fixed_params_dict : dict, optional + Not applicable for Empty model, by default None + + Returns + ------- + x, y (, xe, ye) + Predicted position (and uncertainties) of Empty model, shape (N_times,) + """ + self._check_param_dimensions(fit_params, fit_param_errs, fixed_params_dict) + + t = np.atleast_1d(t) + fit_params = np.atleast_2d(fit_params) # (N_stars, N_fit_params) + + N_stars = fit_params.shape[0] + N_times = len(t) + + if N_times == N_stars or N_times == 1 or N_stars == 1: + # Assume each time corresponds to each star, so N_times = 1 + x = np.full(N_stars, np.nan) + y = np.full(N_stars, np.nan) + else: + x = np.full((N_stars, N_times), np.nan) + y = np.full((N_stars, N_times), np.nan) + + if fit_param_errs is None: + return x, y + return x, y, np.full_like(x, np.inf), np.full_like(y, np.inf) + + def run_fit( + self, t, x, y, xe, ye, + fixed_params_dict=None, + weighting='var', + use_scipy=True, + absolute_sigma=True, + params_guess=None, + fill_value=np.nan, + return_chi2=False, + method=None, + verbose=True + ): + """Fit stellar motion parameters + + Parameters + ---------- + t : float or array-like + Time array, shape (N_times,) + x : array-like + Observed x positions, shape (N_times,) + y : array-like + Observed y positions, shape (N_times,) + xe : array-like + Observed uncertainties in x positions, shape (N_times,) + ye : array-like + Observed uncertainties in y positions, shape (N_times,) + fixed_params_dict : dict, optional + Dictionary of fixed parameters, not applicable for Empty model, by default None + weighting : str, optional + Weighting scheme to use, 'var' or 'std', by default 'var' + use_scipy : bool, optional + Whether to use scipy.optimize for fitting, by default True + absolute_sigma : bool, optional + Whether to treat sigma as absolute, by default True + fill_value : float, optional + Value to fill parameters with when fitting is not possible, by default np.nan + params_guess : array-like, optional + Initial guess for parameters, by default None + return_chi2 : bool, optional + Whether to return chi-squared value, by default False + method : str, optional + Method of scipy.curve_fit, {'lm', 'trf', 'dogbox'}, by default None + verbose : bool, optional + Whether to print verbose output, by default True + + Returns + ------- + params, param_errors (, chi2_x, chi2_y) + Fitted parameters, their uncertainties, and optionally chi-squared values + """ + self.fixed_params_dict = fixed_params_dict + if verbose: + warnings.warn(f"Empty data cannot be fit. Setting parameters to {fill_value} and uncertainties to np.inf.", OptimizeWarning, stacklevel=2) + params = np.full(self.n_fit_params, fill_value) + param_errors = np.full(self.n_fit_params, np.inf) + if return_chi2: + return params, param_errors, np.nan, np.nan + else: + return params, param_errors + + +class Fixed(MotionModel): + """ + A non-moving motion model for a star on the sky. + """ + name = "Fixed" + fit_param_names = ['x0','y0'] + fixed_param_names = [] + required_fixed_param_names = [] + optional_fixed_params = {} + + n_fit_params = len(fit_param_names) + # Number of fit parameters/required observations in each direction + n_params = int((n_fit_params + 1) / 2) + + def __init__(self, **kwargs): + # Must call after setting parameters. + # This checks for proper parameter formatting. + super().__init__() + return + + def model_fit(self, dt, x0): + """Fit function for Fixed motion model + + Parameters + ---------- + dt : array-like + Time offset, shape (N_times,) + x0 : float or array-like + Average positions, scalar or shape (N_stars,) + + Returns + ------- + x : array-like + Predicted positions, shape (N_times,) if scalar x0, else (N_stars, N_times) + """ + return x0 + np.zeros_like(x0) * dt + + def model(self, t, fit_params, fit_param_errs=None, fixed_params_dict=None): + """Predicted positions (and uncertainties, if fit_param_errs is provided) at time t of Fixed model. + + Parameters + ---------- + t : float or array-like + Time array, shape (N_times,) + fit_params : array-like + x0, y0 in shape (N_fit_params,) or (N_stars, N_fit_params) + fit_param_errs : array-like, optional + Uncertainties for x0, y0 in shape (N_fit_params,) or (N_stars, N_fit_params), by default None + fixed_params_dict : dict, optional + Not applicable for Fixed, by default None + + + Returns + ------- + x, y (, xe, ye) + Predicted position (and uncertainties) of Fixed model, shape (N_stars, N_times), or (N_times,) if N_stars=1, or (N_stars,) if N_times=1 + """ + self.fixed_params_dict = fixed_params_dict + t = np.atleast_1d(t) + fit_params = np.atleast_2d(fit_params) # (N_stars, N_fit_params) + self._check_param_dimensions(fit_params, fit_param_errs, fixed_params_dict) + + N_stars = fit_params.shape[0] + N_times = len(t) + x0, y0 = fit_params.T # Each shape (N_stars,) + + # FIXME: Do we want this assumption? + if N_times == N_stars: + # Assume each time corresponds to each star, so N_times = 1 + dt = t[:, np.newaxis] # Shape (N_stars, 1) + N_times = 1 + else: + # Else, calculate each time for each star + dt = t[np.newaxis, :] - np.zeros(N_stars)[:, np.newaxis] # Shape (N_stars, N_times) + + # Return results in (N_stars, N_times) shape + x = self.model_fit(t, x0[:, np.newaxis]) # Shape (N_stars, N_times) + y = self.model_fit(t, y0[:, np.newaxis]) # Shape (N_stars, N_times) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x = x.flatten() + y = y.flatten() + + if fit_param_errs is None: + return x, y + + fit_param_errs = np.atleast_2d(fit_param_errs) # (N_stars, N_fit_params) + x0_err, y0_err = fit_param_errs.T + + # Return results in (N_stars, N_times) shape + x_err = np.broadcast_to(x0_err[:, np.newaxis], (N_stars, N_times)) + y_err = np.broadcast_to(y0_err[:, np.newaxis], (N_stars, N_times)) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x_err = x_err.flatten() + y_err = y_err.flatten() + + return x, y, x_err, y_err + + def run_fit( + self, t, x, y, xe, ye, + fixed_params_dict=None, + weighting='var', + use_scipy=True, + absolute_sigma=True, + params_guess=None, + fill_value=np.nan, + return_chi2=False, + method=None, + verbose=True + ): + if verbose and (not use_scipy): + warnings.warn("Fixed model has no non-scipy fitter option. Running with scipy.") + + n_obs = len(t) + degree_of_freedom = n_obs - self.n_params + # Not enough data points to fit model + if degree_of_freedom < 0: + warnings.warn( + f'Not enough data points to fit model. Setting parameters to {fill_value} and uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + params = np.full(self.n_fit_params, fill_value) + param_errors = np.full(self.n_fit_params, np.inf) + return params, param_errors, np.nan, np.nan + + # degree_of_freedom >= 0 + # Calculate weighted average position + sigma_x, sigma_y = self.calc_sigma(xe, ye, weighting=weighting) + x_wt, y_wt = 1. / sigma_x**2, 1. / sigma_y**2 + x0 = np.average(x, weights=x_wt) + # x0e = (np.sum(x_wt_norm**2 * xe**2))**0.5 # Error propagation + x0e = 1. / np.sum(x_wt)**0.5 # Error propagation + y0 = np.average(y, weights=y_wt) + # y0e = (np.sum(y_wt_norm**2 * ye**2))**0.5 # Error propagation + y0e = 1. / np.sum(y_wt)**0.5 # Error propagation + + params = np.array([x0, y0]) + param_errors = np.array([x0e, y0e]) + + if (not absolute_sigma) or return_chi2: + chi2x, chi2y = self.calc_chi2(t, x, y, xe, ye, params) + + if not absolute_sigma: + if degree_of_freedom > 0: + reduced_chi2x = chi2x / degree_of_freedom + reduced_chi2y = chi2y / degree_of_freedom + + param_errors[0] *= reduced_chi2x**0.5 + param_errors[1] *= reduced_chi2y**0.5 + else: + # degree_of_freedom == 0, as < 0 case already handled above + warnings.warn( + f'Degree of freedom < 0. Covariance of the parameters could not be estimated. Setting parameter uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + # Set parameter uncertainties to np.inf, same behavior as scipy.optimize.curve_fit + param_errors = np.full_like(param_errors, np.inf) + + if return_chi2: + return params, param_errors, chi2x, chi2y + else: + return params, param_errors + +class Linear(MotionModel): + """ + A 2D linear motion model for a star on the sky. + """ + name = "Linear" + fit_param_names = ['x0', 'vx', 'y0', 'vy'] + required_fixed_param_names = ['t0'] + optional_fixed_params = {} + fixed_param_names = required_fixed_param_names + list(optional_fixed_params.keys()) + + n_fit_params = len(fit_param_names) + # Number of fit parameters/required observations in each direction + n_params = int((n_fit_params + 1) / 2) + + def __init__(self, **kwargs): + # Must call after setting parameters. + # This checks for proper parameter formatting. + super().__init__() + return + + def model_fit(self, dt, x0, v): + """Linear motion model fit function + + Parameters + ---------- + dt : array-like + Time offset, shape (N_times,) + x0 : float or array-like + Initial position, shape (N_stars,) or scalar + v : float or array-like + Velocity, shape (N_stars,) or scalar + + Returns + ------- + x : array-like + Predicted position(s) + """ + return x0 + v * dt + + def model(self, t, fit_params, fit_param_errs=None, fixed_params_dict=None): + """Model positions (and uncertainties, if fit_param_errs is provided) at time t of Linear model. + + Parameters + ---------- + t : float or array-like + Time(s) at which to evaluate the model + fit_params : array-like + x0, vx, y0, vy in shape (N_fit_params,) or (N_stars, N_fit_params) + fit_param_errs : array-like, optional + Uncertainties of fit parameters in shape (N_fit_params,) or (N_stars, N_fit_params), by default None + fixed_params_dict : dict + t0, shape (1,) or (N_stars,) + + Returns + ------- + x, y (, xe, ye) + Predicted positions (and uncertainties, if fit_param_errs is provided) with shape (N_stars, N_times), or (N_times,) if N_stars=1, or (N_stars,) if N_times=1 + """ + if fixed_params_dict is None: + fixed_params_dict = self.fixed_params_dict + assert 't0' in fixed_params_dict, "Fixed parameter t0 is required for Linear model." + self._check_param_dimensions(fit_params, fit_param_errs, fixed_params_dict) + + t = np.atleast_1d(t) + fit_params = np.atleast_2d(fit_params) # (N_stars, N_fit_params) + + N_stars = fit_params.shape[0] + N_times = len(t) + + x0, vx, y0, vy = fit_params.T # Each shape (N_stars,) + t0 = np.atleast_1d(fixed_params_dict['t0']) # Shape (N_stars,) or (1,) + + if N_times == N_stars: + # Assume each time corresponds to each star, so N_times = 1 + dt = t - t0 # Shape (N_stars,) + dt = dt[:, np.newaxis] # Shape (N_stars, 1) + N_times = 1 + else: + dt = t[np.newaxis, :] - t0[:, np.newaxis] # Shape (N_stars, N_times) + + x = self.model_fit(dt, x0[:, np.newaxis], vx[:, np.newaxis]) # Shape (N_stars, N_times) + y = self.model_fit(dt, y0[:, np.newaxis], vy[:, np.newaxis]) # Shape (N_stars, N_times) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x = x.flatten() + y = y.flatten() + + if fit_param_errs is None: + return x, y + + fit_param_errs = np.atleast_2d(fit_param_errs) # (N_stars, N_fit_params) + x0_err, vx_err, y0_err, vy_err = fit_param_errs.T # Each shape (N_stars,) + x_err = np.hypot(x0_err[:, np.newaxis], vx_err[:, np.newaxis] * dt) # Shape (N_stars, N_times) + y_err = np.hypot(y0_err[:, np.newaxis], vy_err[:, np.newaxis] * dt) # Shape (N_stars, N_times) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x_err = x_err.flatten() + y_err = y_err.flatten() + return x, y, x_err, y_err + + def run_fit( + self, t, x, y, xe, ye, + fixed_params_dict=None, + weighting='var', + use_scipy=True, + absolute_sigma=True, + params_guess=None, + fill_value=np.nan, + return_chi2=False, + method=None, + verbose=True + ): + if fixed_params_dict is None: + fixed_params_dict = {} + if 't0' not in fixed_params_dict: + # Default t0 to weighted average time + fixed_params_dict['t0'] = np.average(t, weights=1./np.hypot(xe, ye)) + self.fixed_params_dict = fixed_params_dict + t0 = np.atleast_1d(fixed_params_dict['t0']) + t = np.atleast_1d(t) + x = np.atleast_1d(x) + y = np.atleast_1d(y) + xe = np.atleast_1d(xe) + ye = np.atleast_1d(ye) + + n_obs = len(t) + degree_of_freedom = n_obs - self.n_params + # Not enough data points to fit model + if degree_of_freedom < 0: + warnings.warn( + f'Not enough data points to fit model. Setting parameters to {fill_value} and uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + params = np.full(self.n_fit_params, fill_value) + param_errors = np.full(self.n_fit_params, np.inf) + if return_chi2: + return params, param_errors, np.nan, np.nan + else: + return params, param_errors + + # degree_of_freedom >= 0 + dt = t - t0 + sigma_x, sigma_y = self.calc_sigma(xe, ye, weighting=weighting) + x_wt, y_wt = 1. / sigma_x**2, 1. / sigma_y**2 + + if params_guess is None: + params_guess = [x.mean(), 0., y.mean(), 0.] + + if use_scipy: + x_opt, x_cov, x_info, x_msg, x_ier = curve_fit(self.model_fit, dt, x, p0=np.array(params_guess[:2]), sigma=sigma_x, absolute_sigma=absolute_sigma, full_output=True, method=method) + y_opt, y_cov, y_info, y_msg, y_ier = curve_fit(self.model_fit, dt, y, p0=np.array(params_guess[2:]), sigma=sigma_y, absolute_sigma=absolute_sigma, full_output=True, method=method) + x0, vx = x_opt + y0, vy = y_opt + x0e, vxe = np.sqrt(x_cov.diagonal()) + y0e, vye = np.sqrt(y_cov.diagonal()) + params = np.array([x0, vx, y0, vy]) + param_errors = np.array([x0e, vxe, y0e, vye]) + if return_chi2: + # chi2_x, chi2_y = self.calc_chi2(t, x, y, xe, ye, params, fixed_params_dict) + chi2_x = np.sum(x_info['fvec']**2) + chi2_y = np.sum(y_info['fvec']**2) + return params, param_errors, chi2_x, chi2_y + else: + return params, param_errors + + # Linear algebraic solution + # Use https://en.wikipedia.org/wiki/Weighted_least_squares#Solution_scheme + X_mat_t = np.vander(dt, 2) + + # x calculation + W_mat_x = np.diag(x_wt) + XTWX_mat_x = X_mat_t.T @ W_mat_x @ X_mat_t # Shape (2, 2) + pcov_x = np.linalg.pinv(XTWX_mat_x) # Covariance Matrix + popt_x = pcov_x @ X_mat_t.T @ W_mat_x @ x # Linear Solution + + # Singular matrix (not enough unique times): Fill uncertainty with Inf. + if np.linalg.matrix_rank(XTWX_mat_x) < 2: + warnings.warn( + f'Singular matrix. Covariance of the parameters could not be estimated. Setting parameter uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + perr_x = np.full_like(popt_x, np.inf) + else: + perr_x = np.sqrt(np.diag(pcov_x)) # Uncertainty of Linear Solution + + # y calculation + W_mat_y = np.diag(y_wt) + XTWX_mat_y = X_mat_t.T @ W_mat_y @ X_mat_t # Shape (2, 2) + pcov_y = np.linalg.pinv(XTWX_mat_y) # Covariance Matrix + popt_y = pcov_y @ X_mat_t.T @ W_mat_y @ y # Linear Solution + + # Singular matrix (not enough unique times): Fill uncertainty with Inf. + if np.linalg.matrix_rank(XTWX_mat_y) < 2: + warnings.warn( + f'Singular matrix. Covariance of the parameters could not be estimated. Setting parameter uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + perr_y = np.full_like(popt_y, np.inf) + else: + perr_y = np.sqrt(np.diag(pcov_y)) # Uncertainty of Linear Solution + + # prepare values to return + vx, x0 = popt_x + vy, y0 = popt_y + vxe, x0e = perr_x + vye, y0e = perr_y + + params = np.array([x0, vx, y0, vy]) + param_errors = np.array([x0e, vxe, y0e, vye]) + + # Does not use get_chi2 to accelerate calculation + if return_chi2 or (not absolute_sigma): + residual_x = x - X_mat_t @ popt_x + residual_y = y - X_mat_t @ popt_y + + chi2_x = residual_x.T @ W_mat_x @ residual_x + chi2_y = residual_y.T @ W_mat_y @ residual_y + + if not absolute_sigma: + if degree_of_freedom > 0: + reduced_chi2_x = chi2_x / degree_of_freedom + reduced_chi2_y = chi2_y / degree_of_freedom + + param_errors[0:2] *= reduced_chi2_x**0.5 + param_errors[2:4] *= reduced_chi2_y**0.5 + + else: + # degree_of_freedom == 0, as < 0 case already handled above + warnings.warn( + f'Degree of freedom < 0. Covariance of the parameters could not be estimated. Setting parameter uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + # Set parameter uncertainties to np.inf, same behavior as scipy.optimize.curve_fit + param_errors = np.full_like(param_errors, np.inf) + + if return_chi2: + return params, param_errors, chi2_x, chi2_y + else: + return params, param_errors + +class Acceleration(MotionModel): + """ + A 2D accelerating motion model for a star on the sky. + """ + name = "Acceleration" + fit_param_names = ['x0', 'vx0', 'ax', 'y0', 'vy0', 'ay'] + required_fixed_param_names = ['t0'] + optional_fixed_params = {} + fixed_param_names = required_fixed_param_names + list(optional_fixed_params.keys()) + + n_fit_params = len(fit_param_names) + # Number of required observations in each direction + n_params = int((n_fit_params + 1) / 2) + + def __init__(self): + # Must call after setting parameters. + # This checks for proper parameter formatting. + super().__init__() + return + + def model_fit(self, t, x0, v0, a): + """Model positions at time t of Acceleration model. + + Parameters + ---------- + t : float or array-like + Time(s) at which to evaluate the model + x0 : float or array-like + Initial position(s) + v0 : float or array-like + Initial velocity(ies) + a : float or array-like + Acceleration(s) + + Returns + ------- + float or array-like + Model positions at time t of Acceleration model + """ + return x0 + v0*t + 0.5*a*t**2 + + def model(self, t, fit_params, fit_param_errs=None, fixed_params_dict=None): + """Model positions (and uncertainties, if fit_param_errs is provided) at time t of Acceleration model. + + Parameters + ---------- + t : float or array-like + Time(s) at which to evaluate the model + fit_params : array-like + x0, vx, ax, y0, vy, ay in shape (N_fit_params,) or (N_stars, N_fit_params) + fit_param_errs : array-like, optional + Fit parameter uncertainties with shape (N_stars, N_fit_params) or (N_fit_params,), by default None + fixed_params_dict : dict + t0, shape (1,) or (N_stars,) + + Returns + ------- + x, y (, xe, ye) + Predicted positions (and uncertainties, if fit_param_errs is provided) with shape (N_stars, N_times), or (N_times,) if N_stars=1, or (N_stars,) if N_times=1 + """ + if fixed_params_dict is None: + fixed_params_dict = self.fixed_params_dict + assert 't0' in fixed_params_dict, "Fixed parameter t0 is required for Acceleration model." + self._check_param_dimensions(fit_params, fit_param_errs, fixed_params_dict) + + t = np.atleast_1d(t) + fit_params = np.atleast_2d(fit_params) # (N_stars, N_fit_params) + + N_stars = fit_params.shape[0] + N_times = len(t) + + x0, vx0, ax, y0, vy0, ay = fit_params.T # Each shape (N_stars,) + t0 = np.atleast_1d(fixed_params_dict['t0']) # Shape (N_stars,) or (1,) + + if N_times == N_stars: + # Assume each time corresponds to each star, so N_times = 1 + dt = t - t0 # Shape (N_stars,) + dt = dt[:, np.newaxis] # Shape (N_stars, 1) + N_times = 1 + else: + dt = t[np.newaxis, :] - t0[:, np.newaxis] # Shape (N_stars, N_times) + + x = self.model_fit(dt, x0[:, np.newaxis], vx0[:, np.newaxis], ax[:, np.newaxis]) # Shape (N_stars, N_times) + y = self.model_fit(dt, y0[:, np.newaxis], vy0[:, np.newaxis], ay[:, np.newaxis]) # Shape (N_stars, N_times) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x = x.flatten() + y = y.flatten() + + if fit_param_errs is None: + return x, y + + fit_param_errs = np.atleast_2d(fit_param_errs) # (N_stars, N_fit_params) + x0_err, vx0_err, ax_err, y0_err, vy0_err, ay_err = fit_param_errs.T + x_err = np.sqrt(x0_err[:, np.newaxis]**2 + (vx0_err[:, np.newaxis] * dt)**2 + (0.5 * ax_err[:, np.newaxis] * dt**2)**2) # Shape (N_stars, N_times) + y_err = np.sqrt(y0_err[:, np.newaxis]**2 + (vy0_err[:, np.newaxis] * dt)**2 + (0.5 * ay_err[:, np.newaxis] * dt**2)**2) # Shape (N_stars, N_times) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x_err = x_err.flatten() + y_err = y_err.flatten() + + return x, y, x_err, y_err + + + def run_fit( + self, t, x, y, xe, ye, + fixed_params_dict=None, + weighting='var', + use_scipy=True, + absolute_sigma=True, + params_guess=None, + fill_value=np.nan, + return_chi2=False, + method=None, + verbose=True + ): + if fixed_params_dict is None: + fixed_params_dict = {} + if 't0' not in fixed_params_dict: + # Default t0 to weighted average time + fixed_params_dict['t0'] = np.average(t, weights=1./np.hypot(xe, ye)) + self.fixed_params_dict = fixed_params_dict + t0 = np.atleast_1d(fixed_params_dict['t0']) + t = np.atleast_1d(t) + x = np.atleast_1d(x) + y = np.atleast_1d(y) + xe = np.atleast_1d(xe) + ye = np.atleast_1d(ye) + + if not use_scipy: + if verbose: + warnings.warn("Acceleration model has no non-scipy fitter option. Running with scipy.") + + n_obs = len(t) + degree_of_freedom = n_obs - self.n_params + # Not enough data points to fit model + if degree_of_freedom < 0: + warnings.warn( + f'Not enough data points to fit model. Setting parameters to {fill_value} and uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + params = np.full(self.n_fit_params, fill_value) + param_errors = np.full(self.n_fit_params, np.inf) + if return_chi2: + return params, param_errors, np.nan, np.nan + else: + return params, param_errors + + # degree_of_freedom >= 0 + dt = t - t0 + sigma_x, sigma_y = self.calc_sigma(xe, ye, weighting=weighting) + if params_guess is None: + # Initial guess for velocity: + idx_first, idx_last = np.argmin(t), np.argmax(t) + t_span = t[idx_last] - t[idx_first] + params_guess = [x.mean(), (x[idx_last] - x[idx_first]) / t_span, 0., y.mean(), (y[idx_last] - y[idx_first]) / t_span, 0.] + + x_opt, x_cov, x_info, x_msg, x_ier = curve_fit(self.model_fit, dt, x, p0=np.array(params_guess[:3]), sigma=sigma_x, absolute_sigma=absolute_sigma, full_output=True, method=method) + y_opt, y_cov, y_info, y_msg, y_ier = curve_fit(self.model_fit, dt, y, p0=np.array(params_guess[3:]), sigma=sigma_y, absolute_sigma=absolute_sigma, full_output=True, method=method) + x0, vx0, ax = x_opt + y0, vy0, ay = y_opt + x0e, vx0e, axe = np.sqrt(x_cov.diagonal()) + y0e, vy0e, aye = np.sqrt(y_cov.diagonal()) + + params = np.array([x0, vx0, ax, y0, vy0, ay]) + param_errors = np.array([x0e, vx0e, axe, y0e, vy0e, aye]) + if return_chi2: + # chi2_x, chi2_y = self.calc_chi2(t, x, y, xe, ye, params, fixed_params_dict) + chi2_x = np.sum(x_info['fvec']**2) + chi2_y = np.sum(y_info['fvec']**2) + return params, param_errors, chi2_x, chi2_y + else: + return params, param_errors + +class Parallax(MotionModel): + """ + Motion model for linear proper motion + parallax + + Requires RA and Dec J2000 (degrees) for parallax calculation. + Optional PA is counterclockwise offset of the image y-axis from North. + Optional obs parameter describes observer location, default is 'earth'. + """ + name = "Parallax" + fit_param_names = ['x0', 'vx', 'y0', 'vy', 'pi'] + required_fixed_param_names = ['t0', 'ra', 'dec'] + optional_fixed_params = {'pa': 0., 'obsLocation': 'earth'} + fixed_param_names = required_fixed_param_names + list(optional_fixed_params.keys()) + + + n_fit_params = len(fit_param_names) + # Number of required observations in each direction + n_params = int((n_fit_params + 1) / 2) + + def __init__(self): + super().__init__() + self.pvec_cached = None # Cache for parallax vector + self.t_mjd_cached = None # Cache for times corresponding to cached parallax vector + return + + def calc_parallax_vector(self, t_mjd, ra, dec, pa=0., obsLocation='earth'): + """Calculate parallax vector of shape (N_stars, 2, N_times) + + Parameters + ---------- + t_mjd : array-like + Time array in mjd + ra : float or array-like + Right ascension(s) in degrees + dec : float or array-like + Declination(s) in degrees + pa : float or array-like, optional + Position angle(s) of image y-axis from North in degrees, by default 0. + obsLocation : str, optional + Observer location, by default 'earth' + + Returns + ------- + pvec + Parallax vector of shape (N_stars, 2, N_times), where 2 corresponds to (x, y) components. + """ + if self.pvec_cached is not None: + t_mjd = np.atleast_1d(t_mjd) + t_mjd_cached = self.t_mjd_cached + if np.array_equal(t_mjd, t_mjd_cached): + # If cached values match input times, return cached values + return self.pvec_cached + + elif all(np.isin(t_mjd, t_mjd_cached)): + # If all input times are in cached values, return those + # Calculate pvec_idxs such that t_mjd_cached[ pvec_idxs ] == t_mjd + pvec_idxs = np.array([np.where(t_mjd_cached == t_mjd_i)[0][0] for t_mjd_i in t_mjd]) + pvec = self.pvec_cached[:, :, pvec_idxs] + return pvec + + pvec = parallax.parallax_in_direction(ra, dec, t_mjd, obsLocation=obsLocation, pa=pa) # Shape (N_stars, 2, N_times) + # self.plx_vector_cached = [t_mjd, pvec] + self.t_mjd_cached = t_mjd + self.pvec_cached = pvec + return pvec + + def model_fit(self, dt, x0, vx, y0, vy, pi): + """Model positions at time t of Parallax model. + + Parameters + ---------- + dt : float or array-like + Time(s) at which to evaluate the model + x0 : float or array-like + Initial position(s) + vx : float or array-like + Velocity(ies) + y0 : float or array-like + Initial position(s) + vy : float or array-like + Velocity(ies) + pi : float or array-like + Parallax factor(s) + + Returns + ------- + x_result, y_result : array-like + Model positions at time t of Parallax model, shape (N_stars, N_times) + """ + # x0, vx, y0, vy, pi are all shape (N_stars, N_times) + x_result = x0 + vx * dt + pi * self.pvec[:, 0, :] # Parallax contribution in x direction + y_result = y0 + vy * dt + pi * self.pvec[:, 1, :] # Parallax contribution in y direction + return x_result, y_result + + def _model_fit(self, dt, x0, vx, y0, vy, pi): + """Wrapper for model_fit to return concatenated results for scipy fitting.""" + x_result, y_result = self.model_fit(dt, x0, vx, y0, vy, pi) + # scipy.optimize.curve_fit expects a 1D output array with the same length + # as the input ydata. For single-star fits, intermediate broadcasting can + # yield arrays with shape (1, N_times); flatten to avoid M=1 interpretation. + return np.hstack([np.ravel(x_result), np.ravel(y_result)]) # Shape (2*N_times,) + + def model(self, t, fit_params, fit_param_errs=None, fixed_params_dict=None): + """Model positions (and uncertainties, if fit_param_errs is provided) at time t of Parallax model. + + Parameters + ---------- + t : float or array-like + Times at which to evaluate the model + fit_params : array-like + x0, vx, y0, vy, pi in shape (N_fit_params,) or (N_stars, N_fit_params) + fit_param_errs : array-like, optional + Uncertainties in fit parameters, by default None + fixed_params : dict + - t0, shape (N_stars,) or (1,). + - ra, shape (N_stars,) or (1,). + - dec, shape (N_stars,) or (1,). + - pa, optional, shape (N_stars,) or (1,), by default 0. + - obsLocation, optional, string, by default 'earth' + + Returns + ------- + x, y (, xe, ye) + Predicted positions (and uncertainties, if fit_param_errs is provided) with shape (N_stars, N_times), or (N_times,) if N_stars=1, or (N_stars,) if N_times=1 + """ + if fixed_params_dict is None: + fixed_params_dict = self.fixed_params_dict + assert all([_ in fixed_params_dict for _ in ['t0', 'ra', 'dec']]), "Fixed parameters t0, ra, and dec are required for Parallax model." + self._check_param_dimensions(fit_params, fit_param_errs, fixed_params_dict) + + t = np.atleast_1d(t) + fit_params = np.atleast_2d(fit_params) # (N_stars, N_fit_params) + + N_stars = fit_params.shape[0] + N_times = len(t) + + x0, vx, y0, vy, pi = fit_params.T # Each shape (N_stars,) + t0 = np.atleast_1d(fixed_params_dict['t0']) # Shape (N_stars,) or (1,) + ra = np.atleast_1d(fixed_params_dict['ra']) + dec = np.atleast_1d(fixed_params_dict['dec']) + pa = np.atleast_1d(fixed_params_dict.get('pa', 0.0)) + obsLocation = fixed_params_dict.get('obsLocation', 'earth') + + # TODO: vectorize parallax.parallax_in_direction to handle multiple obsLocation? + assert isinstance(obsLocation, str) or (np.unique(obsLocation).size == 1), "obsLocation must be a single string for all stars at this time." + if not isinstance(obsLocation, str): + obsLocation = np.unique(obsLocation)[0] + + + if N_times == N_stars: + # Assume each time corresponds to each star, so N_times = 1 + dt = t - t0 # Shape (N_stars,) + dt = dt[:, np.newaxis] # Shape (N_stars, 1) + N_times = 1 + else: + dt = t[np.newaxis, :] - t0[:, np.newaxis] # Shape (N_stars, N_times) + + t_mjd = Time(t, format='decimalyear', scale='utc').mjd # Shape (N_times,) + self.pvec = self.calc_parallax_vector(t_mjd, ra, dec, pa=pa, obsLocation=obsLocation) # Shape (N_stars, 2, N_times) + x, y = self.model_fit(dt, x0[:, np.newaxis], vx[:, np.newaxis], y0[:, np.newaxis], vy[:, np.newaxis], pi[:, np.newaxis]) # Shape (N_stars, N_times) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x = x.flatten() + y = y.flatten() + + if fit_param_errs is None: + return x, y + + fit_param_errs = np.atleast_2d(fit_param_errs) # (N_stars, N_fit_params) + x0_err, vx_err, y0_err, vy_err, pi_err = fit_param_errs.T + x_err = np.sqrt(x0_err[:, np.newaxis]**2 + (vx_err[:, np.newaxis] * dt)**2 + (pi_err[:, np.newaxis] * self.pvec[:, 0, :])**2) # Shape (N_stars, N_times) + y_err = np.sqrt(y0_err[:, np.newaxis]**2 + (vy_err[:, np.newaxis] * dt)**2 + (pi_err[:, np.newaxis] * self.pvec[:, 1, :])**2) # Shape (N_stars, N_times) + + if N_stars == 1 or N_times == 1: + # If only one star, return flattened arrays + x_err = x_err.flatten() + y_err = y_err.flatten() + return x, y, x_err, y_err + + + def run_fit( + self, t, x, y, xe, ye, + fixed_params_dict, + weighting='var', + use_scipy=True, + absolute_sigma=True, + params_guess=None, + fill_value=np.nan, + return_chi2=False, + method=None, + verbose=True + ): + if not use_scipy: + if verbose: + warnings.warn("Parallax model has no non-scipy fitter option. Running with scipy.", UserWarning) + + assert all([k in fixed_params_dict for k in ['ra', 'dec']]), "Parallax model requires 'ra' and 'dec' in fixed_params." + t = np.atleast_1d(t) + + if 't0' not in fixed_params_dict: + # Default t0 to weighted average time + fixed_params_dict['t0'] = np.average(t, weights=1./np.hypot(xe, ye)) + if 'obsLocation' not in fixed_params_dict: + fixed_params_dict['obsLocation'] = 'earth' + self.fixed_params_dict = fixed_params_dict + t0 = np.atleast_1d(fixed_params_dict['t0']) + ra = np.atleast_1d(fixed_params_dict['ra']) + dec = np.atleast_1d(fixed_params_dict['dec']) + pa = np.atleast_1d(fixed_params_dict.get('pa', 0.0)) + obsLocation = fixed_params_dict['obsLocation'] + + n_fit = len(t) + degree_of_freedom = n_fit - self.n_params + # Not enough data points to fit model + if degree_of_freedom < 0: + warnings.warn( + f'Not enough data points to fit model. Setting parameters to {fill_value} and uncertainties to np.inf.', + OptimizeWarning, stacklevel=2 + ) + params = np.full(self.n_fit_params, fill_value) + param_errors = np.full(self.n_fit_params, np.inf) + if return_chi2: + return params, param_errors, np.nan, np.nan + else: + return params, param_errors + + # degree_of_freedom >= 0 + t_mjd = Time(t, format='decimalyear', scale='utc').mjd + self.pvec = self.calc_parallax_vector(t_mjd, ra, dec, pa=pa, obsLocation=obsLocation) # Shape (2, N_times) + + # Initial guesses, x0,y0 as x,y averages; + # vx,vy as average velocity if first and last points are perfectly measured; + # pi for 10 pc distance + if params_guess is None: + idx_first, idx_last = np.argmin(t), np.argmax(t) + t_span = t[idx_last] - t[idx_first] + params_guess = np.array([ + x.mean(), (x[idx_last] - x[idx_first]) / t_span, + y.mean(), (y[idx_last] - y[idx_first]) / t_span, + 0.1 + ]) + + sigma_x, sigma_y = self.calc_sigma(xe, ye, weighting=weighting) + popt, pcov, infodict, mesg, ier = curve_fit( + self._model_fit, t - t0, np.hstack([x, y]), + p0=params_guess, sigma=np.hstack([sigma_x, sigma_y]), + absolute_sigma=absolute_sigma, full_output=True, method=method + ) + x0, vx, y0, vy, pi = popt + x0_err, vx_err, y0_err, vy_err, pi_err = np.sqrt(pcov.diagonal()) + + params = np.array([x0, vx, y0, vy, pi]) + param_errors = np.array([x0_err, vx_err, y0_err, vy_err, pi_err]) + + if return_chi2: + # chi2_x, chi2_y = self.calc_chi2(t, x, y, xe, ye, params, fixed_params_dict) + chi2_x = np.sum(infodict['fvec'][:len(t)]**2) + chi2_y = np.sum(infodict['fvec'][len(t):]**2) + return params, param_errors, chi2_x, chi2_y + else: + return params, param_errors + + +def motion_model_param_names(motion_models, with_errors=True, with_fixed=True): + """Get the motion model parameter names from a list of MotionModels. + + Parameters + ---------- + motion_models : MotionModel, str, or list of MotionModels/strings. + Motion model to query parameter names from. If str, should be the name of a MotionModel class. + with_errors : bool, optional + Add uncertainty names with '_err' suffix or not, by default True + with_fixed : bool, optional + Add fixed param names with '_fixed' suffix or not, by default True + + Returns + ------- + list + List of all unique parameter names across all motion models + """ + list_of_parameters = [] + + def list_add(name): + if name not in list_of_parameters: + list_of_parameters.append(name) + + motion_models = np.atleast_1d(motion_models) + mm_map = motion_model_map() + for mm in motion_models: + if isinstance(mm, str): + mm = mm_map[mm] + for param in mm.fit_param_names: + # Fitter params + list_add(param) + # Error params + if with_errors: + list_add(param + '_err') + # Fixed params + if with_fixed: + for param in mm.fixed_param_names: + list_add(param) + return list_of_parameters + + +def all_motion_model_param_names(with_errors=True, with_fixed=True): + """Get all motion model parameter names from all available MotionModels. + + Parameters + ---------- + with_errors : bool, optional + Add uncertainty names with '_err' suffix or not, by default True + with_fixed : bool, optional + Add fixed param names with '_fixed' suffix or not, by default True + + Returns + ------- + list + List of all unique parameter names across all motion models + """ + return motion_model_param_names(MotionModel.__subclasses__(), with_errors=with_errors, with_fixed=with_fixed) + +def motion_model_map(): + """Get a dictionary mapping motion model names to MotionModel classes. + + Returns + ------- + mm_map : dict + Dictionary mapping motion model names to MotionModel classes. + """ + mm_map = dict( + [(mm.__name__, mm) for mm in MotionModel.__subclasses__()] + ) + # Sort by required epochs + mm_map = dict(sorted(mm_map.items(), key=lambda item: item[1].n_params)) + return mm_map \ No newline at end of file diff --git a/flystar/parallax.py b/flystar/parallax.py new file mode 100755 index 0000000..1605060 --- /dev/null +++ b/flystar/parallax.py @@ -0,0 +1,167 @@ +# Parallax calculation module for motion models involving parallax +# Adapted from BAGLE's parallax.py + +import math + +import numpy as np +from joblib import Memory +import os +from astropy import units, units as u +from astropy.coordinates import SkyCoord, get_body_barycentric, get_body_barycentric_posvel, solar_system_ephemeris, \ + CartesianRepresentation +from astropy.time import Time + +# Use the JPL ephemerides. +solar_system_ephemeris.set('jpl') + +# Setup a parallax cache +try: + cache_dir = os.environ['PARALLAX_CACHE_DIR'] +except: + cache_dir = os.path.dirname(__file__) + '/parallax_cache/' +cache_memory = Memory(cache_dir, verbose=0) +# Default cache size is 1 GB +cache_memory.reduce_size() + +# @cache_memory.cache() +def parallax_in_direction(ra, dec, mjd, obsLocation='earth', pa=0.): + """ + Calculate the parallax vector in a given direction following MulensModel. + + Parameters + ---------- + RA : float or array-like + Right Ascension in degrees. (J2000) + Dec : float or array-like + Declination in degrees. (J2000) + mjd : float or array-like + Modified Julian Date. + obsLocation : str, optional + Observer location, by default 'earth'. + PA : float, optional + Position angle in degrees (counterclockwise offset of the image y-axis from North), by default 0. + + Returns + ------- + pvec : ndarray + Parallax vector components, shape of (N_stars, 2, N_times), where the second dimension corresponds to the x or y components. + """ + # Munge inputs into astropy format. + # times = Time(mjd + 2400000.5, format='jd', scale='tdb') + ra = np.atleast_1d(ra) + dec = np.atleast_1d(dec) + mjd = np.atleast_1d(mjd) + pa = np.atleast_1d(pa) + times = Time(mjd, format='mjd', scale='tdb') # convert to TDB + coord = SkyCoord(ra, dec, unit=(units.deg, units.deg)) # Shape (N_stars,) + + directions = coord.cartesian.xyz.value.T # Shape (N_stars, 3) + north = np.array([0., 0., 1.]) + # Cross product of each star with north vector + _east_projected = np.cross(north, directions) + _east_projected /= np.linalg.norm(_east_projected, axis=1)[:, np.newaxis] # Shape (N_stars, 3) + _north_projected = np.cross(directions, _east_projected) + _north_projected /= np.linalg.norm(_north_projected, axis=1)[:, np.newaxis] # Shape (N_stars, 3) + + obs_pos = get_observer_barycentric(obsLocation, times) # Shape (N_times,) + sun_pos = get_body_barycentric(body='sun', time=times) # Shape (N_times,) + + sun_obs_pos = sun_pos - obs_pos + + pos = sun_obs_pos.xyz.T.to(units.au).value # Shape (N_times, 3) + # Broadcast pos to (N_stars, 3, N_times) and take dot product with east and north unit vectors to get components in those directions. + pos = np.broadcast_to(pos.T, (directions.shape[0], 3, pos.shape[0])) # Shape (N_stars, 3, N_times) + + e = np.einsum('sdt,sd->st', pos, _east_projected) # Shape (N_stars, N_times) + n = np.einsum('sdt,sd->st', pos, _north_projected) # Shape (N_stars, N_times) + + # Rotate frame e,n->x,y accounting for PA + pa = np.deg2rad(pa) # shape (N_stars,) + x = -e * np.cos(pa[:, np.newaxis]) + n * np.sin(pa[:, np.newaxis]) # Shape (N_stars, N_times) + y = e * np.sin(pa[:, np.newaxis]) + n * np.cos(pa[:, np.newaxis]) # Shape (N_stars, N_times) + # pvec Shape (N_stars, 2, N_times) + pvec = np.stack((x, y), axis=1) + return pvec + + +def get_observer_barycentric(body, times, min_ephem_step=1, velocity=False): + """ + Get the barycentric position of a satellite or other Solar System body + using JPL emphemerides through the Horizon app. + + The ephemeris is queried at a decimated time step set by min_ephem_step + (def=1 day) that must be 1 day or larger. The positions + (and optionally velocities) are then interpolated onto the desired + time array. + + Inputs + ------ + body : str + The name of the Solar System body. Must use the JPL Horizon + naming scheme. + + times : astropy.time.Time array + Array of times (astropy.time.core.Time) objects at which to + fetch the position of the specified Solar System body. + + Optional Inputs + --------------- + min_ephem_step : int + Minimum time step to query JPL in days. Must not be <1 and must + be in integer days. + + veloctiy : bool + If true, return both position and velocity vectors over time. + + Return + ------ + coord : astropy.coordinates.CartesianRepresentation + The xyz coordinates in the plane of the Solar System at the + input times. + """ + + if body in solar_system_ephemeris.bodies: + if velocity: + obs_pos, obs_vel = get_body_barycentric_posvel(body=body, time=times) + else: + obs_pos = get_body_barycentric(body=body, time=times) + else: + # Figure out a cadence for the ephemerides, not smaller than 1 day. + dt = np.median(np.diff(times)).jd + if dt < min_ephem_step: + dt = min_ephem_step + + # Get the date range, add some padding on each side. + t_min = times.min() + t_max = times.max() + t_min.format = 'iso' + t_max.format = 'iso' + t_min = str(t_min - dt*u.day).split()[0] + t_max = str(t_max + dt*u.day).split()[0] + step = f'{dt:.0f}d' + + # Fetch the Horizons ephemeris. + from astroquery.jplhorizons import Horizons + obj = Horizons(id=body, epochs={'start':t_min, 'stop':t_max, 'step':step}) + obj_data = obj.vectors() + + ephem_jd = obj_data['datetime_jd'] + + # Interpolate to the actual time array. + obj_x_at_t = np.interp(times.jd, ephem_jd, obj_data['x'].to('km')) * u.km + obj_y_at_t = np.interp(times.jd, ephem_jd, obj_data['y'].to('km')) * u.km + obj_z_at_t = np.interp(times.jd, ephem_jd, obj_data['z'].to('km')) * u.km + + if velocity: + obj_vx_at_t = np.interp(times.jd, ephem_jd, obj_data['vx'].to('km/s')) * u.km / u.s + obj_vy_at_t = np.interp(times.jd, ephem_jd, obj_data['vy'].to('km/s')) * u.km / u.s + obj_vz_at_t = np.interp(times.jd, ephem_jd, obj_data['vz'].to('km/s')) * u.km / u.s + + obs_vel = CartesianRepresentation(obj_vx_at_t, obj_vy_at_t, obj_vz_at_t) + + obs_pos = CartesianRepresentation(obj_x_at_t, obj_y_at_t, obj_z_at_t) + + if velocity: + return (obs_pos, obs_vel) + else: + return obs_pos \ No newline at end of file diff --git a/flystar/plots.py b/flystar/plots.py index c675170..277e472 100755 --- a/flystar/plots.py +++ b/flystar/plots.py @@ -1,19 +1,18 @@ -from flystar import analysis -import pylab as py -import pylab as plt -import numpy as np -import matplotlib.mlab as mlab +import os +import math +import astropy import matplotlib -from matplotlib import colors -import matplotlib.cm as cm +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.colors as mcolors +from matplotlib import cm +from matplotlib.ticker import FormatStrFormatter from scipy.stats import chi2 -from scipy.optimize import curve_fit from scipy.stats import norm -import pdb -import math -import astropy +from scipy.optimize import curve_fit +from astropy import units as u from astropy.table import Table -from astropy.io import ascii +from astropy.coordinates import SkyCoord #################################################### # Code for making diagnostic plots for astrometry @@ -21,8 +20,8 @@ #################################################### -def trans_positions(ref, ref_mat, starlist, starlist_mat, xlim=None, ylim=None, fileName=None, - equal_axis=True, root='./'): +def trans_positions(ref, ref_mat, starlist, starlist_mat, xlim=None, ylim=None, + equal_axis=True, save_path=None, show_plot=True): """ Plot positions of stars in reference list and the transformed starlist, in reference list coordinates. Stars used in the transformation are @@ -38,7 +37,7 @@ def trans_positions(ref, ref_mat, starlist, starlist_mat, xlim=None, ylim=None, transformation. Standard column headers are assumed. starlist: astropy table - Transformed starist with the reference starlist coordinates. + Transformed starlist with the reference starlist coordinates. Standard column headers are assumed starlist_mat: astropy table @@ -49,35 +48,44 @@ def trans_positions(ref, ref_mat, starlist, starlist_mat, xlim=None, ylim=None, If not None, sets the xmin and xmax limit of the plot ylim: None or list/array [ymin, ymax] - If not None, sets the ymin and ymax limit of the plot + If not None, sets the ymin and ymax limit of the plot equal_axis: boolean If true, make axes equal. True by default - + + save_path: string + Path to save the figure to. Default is None + + show_plot: boolean + If true, show the plot. Default is True + """ - py.figure(figsize=(10,10)) - py.clf() - py.plot(ref['x'], ref['y'], 'g+', ms=5, label='Reference') - py.plot(starlist['x'], starlist['y'], 'rx', ms=5, label='starlist') - py.plot(ref_mat['x'], ref_mat['y'], color='skyblue', marker='s', ms=10, alpha=0.3, + plt.figure(figsize=(6, 6)) + plt.clf() + plt.plot(ref['x'], ref['y'], 'g+', ms=5, label='Reference') + plt.plot(starlist['x'], starlist['y'], 'rx', ms=5, label='starlist') + plt.plot(ref_mat['x'], ref_mat['y'], color='skyblue', marker='s', ms=10, alpha=0.3, linestyle='None', label='Matched Reference') - py.plot(starlist_mat['x'], starlist_mat['y'], color='darkblue', marker='s', ms=5, alpha=0.3, + plt.plot(starlist_mat['x'], starlist_mat['y'], color='darkblue', marker='s', ms=5, alpha=0.3, linestyle='None', label='Matched starlist') - py.xlabel('X position (Reference Coords)') - py.ylabel('Y position (Reference Coords)') - py.legend(numpoints=1) - py.title('Label.dat Positions After Transformation') + plt.xlabel('X position (Reference Coords)') + plt.ylabel('Y position (Reference Coords)') + plt.legend(numpoints=1, loc='lower right') + plt.title('Label.dat Positions After Transformation') if xlim != None: - py.axis([xlim[0], xlim[1], ylim[0], ylim[1]]) + plt.axis([xlim[0], xlim[1], ylim[0], ylim[1]]) if equal_axis: - py.axis('equal') - if fileName!=None: - #py.savefig(root + fileName[3:8] + 'Transformed_positions_' + '.png') - py.savefig(root + 'Transformed_positions_{0}'.format(fileName) + '.png') - else: - py.savefig(root + 'Transformed_positions.png') + plt.axis('equal') - py.close() + if save_path: + if not os.path.exists(os.path.dirname(save_path)): + os.makedirs(os.path.dirname(save_path)) + plt.tight_layout() + plt.savefig(save_path, dpi=300) + if show_plot: + plt.show() + else: + plt.close() return @@ -91,10 +99,10 @@ def pos_diff_hist(ref_mat, starlist_mat, nbins=25, bin_width=None, xlim=None, fi ref_mat: astropy table Reference starlist only containing matched stars that were used in the transformation. Standard column headers are assumed. - + starlist_mat: astropy table Transformed starlist only containing the matched stars used in - the transformation. Standard column headers are assumed. + the transformation. Standard column headers are assumed. nbins: int Number of bins used in histogram, regardless of data range. This is @@ -106,7 +114,7 @@ def pos_diff_hist(ref_mat, starlist_mat, nbins=25, bin_width=None, xlim=None, fi xlim: None or [xmin, xmax] If not none, set the X range of the plot - + """ diff_x = ref_mat['x'] - starlist_mat['x'] diff_y = ref_mat['y'] - starlist_mat['y'] @@ -118,23 +126,24 @@ def pos_diff_hist(ref_mat, starlist_mat, nbins=25, bin_width=None, xlim=None, fi max_range = max([max(diff_x), max(diff_y)]) bins = np.arange(min_range, max_range+bin_width, bin_width) - - py.figure(figsize=(10,10)) - py.clf() - py.hist(diff_x, histtype='step', bins=bins, color='blue', label='X') - py.hist(diff_y, histtype='step', bins=bins, color='red', label='Y') - py.xlabel('Reference Position - starlist Position') - py.ylabel('N stars') - py.title('Position Differences for matched stars') + + plt.figure(figsize=(6, 6)) + plt.clf() + plt.hist(diff_x, histtype='step', bins=bins, color='blue', label='X') + plt.hist(diff_y, histtype='step', bins=bins, color='red', label='Y') + plt.xlabel('Reference Position - starlist Position') + plt.ylabel('N stars') + plt.title('Position Differences for matched stars') if xlim != None: - py.xlim([xlim[0], xlim[1]]) - py.legend() + plt.xlim([xlim[0], xlim[1]]) + plt.legend() + plt.tight_layout() if fileName != None: - py.savefig(root + fileName[3:8] + 'Positions_hist_' + '.png') + plt.savefig(root + fileName[3:8] + 'Positions_hist_' + '.png', dpi=300) else: - py.savefig(root + 'Positions_hist.png') + plt.savefig(root + 'Positions_hist.png', dpi=300) - py.close() + plt.close() return def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None, errs='both', xlim=None, @@ -152,7 +161,7 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None ref_mat: astropy table Reference starlist only containing matched stars that were used in the transformation. Standard column headers are assumed. - + starlist_mat: astropy table Transformed starlist only containing the matched stars used in the transformation. Standard column headers are assumed. @@ -183,9 +192,10 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None outlier: float (default = 10) Defines how many sigma away from 0 a star must be in order to be considered - an outlier. - + an outlier. + """ + from . import analysis diff_x = ref_mat['x'] - starlist_mat['x'] diff_y = ref_mat['y'] - starlist_mat['y'] @@ -199,7 +209,7 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None elif errs == 'starlist': xerr = starlist_mat['xe'] yerr = starlist_mat['ye'] - + # Calculate ratio between differences and the combined error. This is # what we will plot ratio_x = diff_x / xerr @@ -207,7 +217,7 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None # Identify non-outliers, within +/- sigma away from 0 good = np.where( (np.abs(ratio_x) < outlier) & (np.abs(ratio_y) < outlier) ) - + """ # For both X and Y, calculate chi-square. Combine arrays to get combined # chi-square @@ -215,11 +225,11 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None chi_sq_y = diff_y**2. / yerr**2. chi_sq = np.append(chi_sq_x, chi_sq_y) - + # Calculate degrees of freedom in transformation num_mod_params = calc_nparam(transform) deg_freedom = len(chi_sq) - num_mod_params - + # Calculate reduced chi-square chi_sq_red = np.sum(chi_sq) / deg_freedom """ @@ -231,13 +241,13 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None starlist_mat[good], transform, errs=errs) - + num_mod_params = analysis.calc_nparam(transform) #-------------------------------------------# # Plotting #-------------------------------------------# - + # Set the binning as per user input bins = nbins if bin_width != None: @@ -245,52 +255,53 @@ def pos_diff_err_hist(ref_mat, starlist_mat, transform, nbins=25, bin_width=None max_range = max([max(ratio_x), max(ratio_y)]) bins = np.arange(min_range, max_range+bin_width, bin_width) - - py.figure(figsize=(10,10)) - py.clf() - n_x, bins_x, p = py.hist(ratio_x, histtype='step', bins=bins, color='blue', + + plt.figure(figsize=(6, 6)) + plt.clf() + n_x, bins_x, p = plt.hist(ratio_x, histtype='step', bins=bins, color='blue', label='X', density=True, linewidth=2) - n_y, bins_y, p = py.hist(ratio_y, histtype='step', bins=bins, color='red', + n_y, bins_y, p = plt.hist(ratio_y, histtype='step', bins=bins, color='red', label='Y', density=True, linewidth=2) # Overplot a Gaussian, as well mean = 0 sigma = 1 x = np.arange(-6, 6, 0.1) - py.plot(x, norm.pdf(x,mean,sigma), 'g-', linewidth=2) - + plt.plot(x, norm.pdf(x,mean,sigma), 'g-', linewidth=2) + # Annotate reduced chi-sqared values in plot: with outliers - xstr = '$\chi^2_r$ = {0}'.format(np.round(chi_sq_red, decimals=3)) - py.annotate(xstr, xy=(0.3, 0.77), xycoords='figure fraction', color='black') + xstr = r'$\chi^2_r$ = {0}'.format(np.round(chi_sq_red, decimals=3)) + plt.annotate(xstr, xy=(0.3, 0.77), xycoords='figure fraction', color='black') txt = r'$\nu$ = 2*{0} - {1} = {2}'.format(len(diff_x), num_mod_params, deg_freedom) - py.annotate(txt, xy=(0.25,0.74), xycoords='figure fraction', color='black') + plt.annotate(txt, xy=(0.25,0.74), xycoords='figure fraction', color='black') xstr2 = 'With Outliers' - xstr3 = '{0} with +/- {1}+ sigma'.format(len(ratio_x) - len(good[0]), outlier) - py.annotate(xstr2, xy=(0.29, 0.83), xycoords='figure fraction', color='black') - py.annotate(xstr3, xy=(0.25, 0.80), xycoords='figure fraction', color='black') - + xstr3 = '{0} with ± {1}+ sigma'.format(len(ratio_x) - len(good[0]), outlier) + plt.annotate(xstr2, xy=(0.29, 0.83), xycoords='figure fraction', color='black') + plt.annotate(xstr3, xy=(0.25, 0.80), xycoords='figure fraction', color='black') + # Annotate reduced chi-sqared values in plot: without outliers - xstr = '$\chi^2_r$ = {0}'.format(np.round(chi_sq_red_good, decimals=3)) - py.annotate(xstr, xy=(0.7, 0.8), xycoords='figure fraction', color='black') + xstr = r'$\chi^2_r$ = {0}'.format(np.round(chi_sq_red_good, decimals=3)) + plt.annotate(xstr, xy=(0.7, 0.8), xycoords='figure fraction', color='black') txt = r'$\nu$ = 2*{0} - {1} = {2}'.format(len(good[0]), num_mod_params, deg_freedom_good) - py.annotate(txt, xy=(0.65,0.77), xycoords='figure fraction', color='black') + plt.annotate(txt, xy=(0.65,0.77), xycoords='figure fraction', color='black') xstr2 = 'Without Outliers' - py.annotate(xstr2, xy=(0.67, 0.83), xycoords='figure fraction', color='black') - - py.xlabel('(Ref Pos - TransStarlist Pos) / Ast. Error') - py.ylabel('N stars (normalized)') - py.title('Position Residuals for Matched Stars') + plt.annotate(xstr2, xy=(0.67, 0.83), xycoords='figure fraction', color='black') + + plt.xlabel('(Ref Pos - TransStarlist Pos) / Ast. Error') + plt.ylabel('N stars (normalized)') + plt.title('Position Residuals for Matched Stars') if xlim != None: - py.xlim([xlim[0], xlim[1]]) - py.legend() + plt.xlim([xlim[0], xlim[1]]) + plt.legend() + plt.tight_layout() if fileName != None: - py.savefig(root + fileName[3:8] + 'Positions_err_ratio_hist_' + '.png') + plt.savefig(root + fileName[3:8] + 'Positions_err_ratio_hist_' + '.png', dpi=300) else: - py.savefig(root + 'Positions_err_ratio_hist.png') + plt.savefig(root + 'Positions_err_ratio_hist.png', dpi=300) - py.close() + plt.close() return @@ -304,10 +315,10 @@ def mag_diff_hist(ref_mat, starlist_mat, bins=25, fileName=None, root='./'): ref_mat: astropy table Reference starlist only containing matched stars that were used in the transformation. Standard column headers are assumed. - + starlist_mat: astropy table Transformed starlist only containing the matched stars used in - the transformation. Standard column headers are assumed. + the transformation. Standard column headers are assumed. """ diff_m = ref_mat['m'] - starlist_mat['m'] @@ -316,19 +327,20 @@ def mag_diff_hist(ref_mat, starlist_mat, bins=25, fileName=None, root='./'): bad = np.isnan(diff_m) bad2 = np.where(bad == True) diff_m = np.delete(diff_m, bad2) - - py.figure(figsize=(10,10)) - py.clf() - py.hist(diff_m, bins=bins) - py.xlabel('Reference Mag - TransStarlist Mag') - py.ylabel('N stars') - py.title('Magnitude Difference for matched stars') + + plt.figure(figsize=(6, 6)) + plt.clf() + plt.hist(diff_m, bins=bins) + plt.xlabel('Reference Mag - TransStarlist Mag') + plt.ylabel('N stars') + plt.title('Magnitude Difference for matched stars') + plt.tight_layout() if fileName != None: - py.savefig(root + fileName[3:8] + 'Magnitude_hist_' + '.png') + plt.savefig(root + fileName[3:8] + 'Magnitude_hist_' + '.png', dpi=300) else: - py.savefig(root + 'Magnitude_hist.png') + plt.savefig(root + 'Magnitude_hist.png', dpi=300) - py.close() + plt.close() return def pos_diff_quiver(ref_mat, starlist_mat, qscale=10, keyLength=0.2, xlim=None, ylim=None, @@ -342,7 +354,7 @@ def pos_diff_quiver(ref_mat, starlist_mat, qscale=10, keyLength=0.2, xlim=None, ref_mat: astropy table Reference starlist only containing matched stars that were used in the transformation. Standard column headers are assumed. - + starlist_mat: astropy table Transformed starlist only containing the matched stars used in the transformation. Standard column headers are assumed. @@ -387,7 +399,7 @@ def pos_diff_quiver(ref_mat, starlist_mat, qscale=10, keyLength=0.2, xlim=None, diff_y = diff_y[good] xpos = xpos[good] ypos = ypos[good] - + # Divide differences by reference error, if desired if sigma: @@ -408,36 +420,39 @@ def pos_diff_quiver(ref_mat, starlist_mat, qscale=10, keyLength=0.2, xlim=None, diff_y = np.append(diff_y, 0) s = len(xpos) - - py.figure(figsize=(10,10)) - py.clf() - q = py.quiver(xpos, ypos, diff_x, diff_y, scale=qscale) + + plt.figure(figsize=(6, 6)) + plt.clf() + q = plt.quiver(xpos, ypos, diff_x, diff_y, scale=qscale) fmt = '{0} ref units'.format(keyLength) - #py.quiverkey(q, 0.2, 0.92, keyLength, fmt, coordinates='figure', color='black') + #plt.quiverkey(q, 0.2, 0.92, keyLength, fmt, coordinates='figure', color='black') # Make our reference arrow a different color - q2 = py.quiver(xpos[s-2:s], ypos[s-2:s], diff_x[s-2:s], diff_y[s-2:s], scale=qscale, color='red') + q2 = plt.quiver(xpos[s-2:s], ypos[s-2:s], diff_x[s-2:s], diff_y[s-2:s], scale=qscale, color='red') # Annotate our reference quiver arrow - py.annotate(fmt, xy=(xpos[-1]-2, ypos[-1]+0.5), color='red') - py.xlabel('X Position (Reference coords)') - py.ylabel('Y Position (Reference coords)') + plt.annotate(fmt, xy=(xpos[-1]-2, ypos[-1]+0.5), color='red') + plt.xlabel('X Position (Reference coords)') + plt.ylabel('Y Position (Reference coords)') if xlim != None: - py.axis([xlim[0], ylim[1], ylim[0], ylim[1]]) + plt.axis([xlim[0], ylim[1], ylim[0], ylim[1]]) if sigma: if fileName != None: - py.title('(Reference - Transformed Starlist positions) / sigma') - py.savefig(root + fileName[3:8] + 'Positions_quiver_sigma_' + '.png') + title = '(Reference - Transformed Starlist positions) / sigma' + save_path = root + fileName[3:8] + 'Positions_quiver_sigma.png' else: - py.title('(Reference - Transformed Starlist positions) / sigma') - py.savefig(root + 'Positions_quiver_sigma.png') + title = '(Reference - Transformed Starlist positions) / sigma' + save_path = root + 'Positions_quiver_sigma.png' else: if fileName != None: - py.title('Reference - Transformed Starlist positions') - py.savefig(root + fileName[3:8] + 'Positions_quiver_' + '.png') + title = 'Reference - Transformed Starlist positions' + save_path = root + fileName[3:8] + 'Positions_quiver.png' else: - py.title('Reference - Transformed Starlist positions') - py.savefig(root + 'Positions_quiver.png') + title = 'Reference - Transformed Starlist positions' + save_path = root + 'Positions_quiver.png' - py.close() + plt.title(title) + plt.tight_layout() + plt.savefig(save_path, dpi=300) + plt.close() return def vpd(ref, starlist_trans, vxlim, vylim): @@ -462,7 +477,7 @@ def vpd(ref, starlist_trans, vxlim, vylim): If not None, sets the vxmin and vxmax limit of the plot vylim: None or list/array [vymin, vymax] - If not None, sets the vymin and vymax limit of the plot + If not None, sets the vymin and vymax limit of the plot """ # Extract velocities ref_vx = ref['vx'] @@ -470,17 +485,19 @@ def vpd(ref, starlist_trans, vxlim, vylim): trans_vx = starlist_trans['vx'] trans_vy = starlist_trans['vy'] - py.figure(figsize=(10,10)) - py.clf() - py.plot(trans_vx, trans_vy, 'k.', ms=8, label='Transformed', alpha=0.4) - py.plot(ref_vx, ref_vy, 'r.', ms=8, label='Reference', alpha=0.4) - py.xlabel('Vx (Reference units)') - py.ylabel('Vy (Reference units)') + plt.figure(figsize=(6, 6)) + plt.clf() + plt.plot(trans_vx, trans_vy, 'k.', ms=8, label='Transformed', alpha=0.4) + plt.plot(ref_vx, ref_vy, 'r.', ms=8, label='Reference', alpha=0.4) + plt.xlabel('Vx (Reference units)') + plt.ylabel('Vy (Reference units)') if vxlim != None: - py.axis([vxlim[0], vylim[1], vylim[0], vylim[1]]) - py.title('Reference and Transformed Proper Motions') - py.legend() - py.savefig('Transformed_velocities.png') + plt.axis([vxlim[0], vylim[1], vylim[0], vylim[1]]) + plt.title('Reference and Transformed Proper Motions') + plt.legend() + plt.tight_layout() + plt.savefig('Transformed_velocities.png', dpi=300) + plt.close() return @@ -505,7 +522,7 @@ def vel_diff_err_hist(ref_mat, starlist_mat, nbins=25, bin_width=None, vxlim=Non bin_width: None or float If float, sets the width of the bins used in the histograms. Will override nbins - + vxlim: None or [vx_min, vx_max] If not none, set the X axis of the Vx plot by defining the minimum and maximum values @@ -517,9 +534,9 @@ def vel_diff_err_hist(ref_mat, starlist_mat, nbins=25, bin_width=None, vxlim=Non # Will produce 2-panel plot: Vx resid and Vy resid diff_vx = ref_mat['vx'] - starlist_mat['vx'] diff_vy = ref_mat['vy'] - starlist_mat['vy'] - - vx_err = np.hypot(ref_mat['vxe'], starlist_mat['vxe']) - vy_err = np.hypot(ref_mat['vye'], starlist_mat['vye']) + + vx_err = np.hypot(ref_mat['vx_err'], starlist_mat['vx_err']) + vy_err = np.hypot(ref_mat['vy_err'], starlist_mat['vy_err']) ratio_vx = diff_vx / vx_err ratio_vy = diff_vy / vy_err @@ -535,28 +552,28 @@ def vel_diff_err_hist(ref_mat, starlist_mat, nbins=25, bin_width=None, vxlim=Non mean = 0 sigma = 1 x = np.arange(-6, 6, 0.1) - - py.figure(figsize=(20,10)) - py.subplot(121) - py.subplots_adjust(left=0.1) - py.hist(ratio_vx, bins=xbins, histtype='step', color='black', density=True, + + plt.figure(figsize=(12, 6)) + plt.subplot(121) + plt.subplots_adjust(left=0.1) + plt.hist(ratio_vx, bins=xbins, histtype='step', color='black', density=True, linewidth=2) - py.plot(x, norm.pdf(x,mean,sigma), 'r-', linewidth=2) - py.xlabel('(Ref Vx - Trans Vx) / Vxe') - py.ylabel('N_stars') - py.title('Vx Residuals, Matched') + plt.plot(x, norm.pdf(x,mean,sigma), 'r-', linewidth=2) + plt.xlabel('(Ref Vx - Trans Vx) / Vxe') + plt.ylabel('N_stars') + plt.title('Vx Residuals, Matched') if vxlim != None: - py.xlim([vxlim[0], vxlim[1]]) - py.subplot(122) - py.hist(ratio_vy, bins=ybins, histtype='step', color='black', density=True, + plt.xlim([vxlim[0], vxlim[1]]) + plt.subplot(122) + plt.hist(ratio_vy, bins=ybins, histtype='step', color='black', density=True, linewidth=2) - py.plot(x, norm.pdf(x,mean,sigma), 'r-', linewidth=2) - py.xlabel('(Ref Vy - Trans Vy) / Vye') - py.ylabel('N_stars') - py.title('Vy Residuals, Matched') + plt.plot(x, norm.pdf(x,mean,sigma), 'r-', linewidth=2) + plt.xlabel('(Ref Vy - Trans Vy) / Vye') + plt.ylabel('N_stars') + plt.title('Vy Residuals, Matched') if vylim != None: - py.xlim([vylim[0], vylim[1]]) - py.savefig('Vel_err_ratio_dist.png') + plt.xlim([vylim[0], vylim[1]]) + plt.savefig('Vel_err_ratio_dist.png', dpi=300) return @@ -589,10 +606,10 @@ def residual_vpd(ref_mat, starlist_trans_mat, pscale=None): # Error calculation depends on if we are converting to mas/yr if pscale != None: - xerr_frac = np.hypot((ref_mat['vxe'] / ref_mat['vx']), - (starlist_trans_mat['vxe'] / starlist_trans_mat['vx'])) - yerr_frac = np.hypot((ref_mat['vye'] / ref_mat['vy']), - (starlist_trans_mat['vye'] / starlist_trans_mat['vy'])) + xerr_frac = np.hypot((ref_mat['vx_err'] / ref_mat['vx']), + (starlist_trans_mat['vx_err'] / starlist_trans_mat['vx'])) + yerr_frac = np.hypot((ref_mat['vy_err'] / ref_mat['vy']), + (starlist_trans_mat['vy_err'] / starlist_trans_mat['vy'])) # Now apply the plate scale to convert to mas/yr diff_x *= pscale @@ -600,31 +617,33 @@ def residual_vpd(ref_mat, starlist_trans_mat, pscale=None): xerr = diff_x * xerr_frac yerr = diff_y * yerr_frac else: - xerr = np.hypot(ref_mat['vxe'], starlist_trans_mat['vxe']) - yerr = np.hypot(ref_mat['vye'], starlist_trans_mat['vye']) + xerr = np.hypot(ref_mat['vx_err'], starlist_trans_mat['vx_err']) + yerr = np.hypot(ref_mat['vy_err'], starlist_trans_mat['vy_err']) # Plotting - py.figure(figsize=(10,10)) - py.clf() - py.errorbar(diff_x, diff_y, xerr=xerr, yerr=yerr, fmt='k.', ms=8, alpha=0.5) + plt.figure(figsize=(6, 6)) + plt.clf() + plt.errorbar(diff_x, diff_y, xerr=xerr, yerr=yerr, fmt='k.', ms=8, alpha=0.5) if pscale != None: - py.xlabel('Reference_vx - Transformed_vx (mas/yr)') - py.ylabel('Reference_vy - Transformed_vy (mas/yr)') + plt.xlabel('Reference_vx - Transformed_vx (mas/yr)') + plt.ylabel('Reference_vy - Transformed_vy (mas/yr)') else: - py.xlabel('Reference_vx - Transformed_vx (reference coords)') - py.ylabel('Reference_vy - Transformed_vy (reference coords)') - py.title('Proper Motion Residuals') - py.savefig('resid_vpd.png') + plt.xlabel('Reference_vx - Transformed_vx (reference coords)') + plt.ylabel('Reference_vy - Transformed_vy (reference coords)') + plt.title('Proper Motion Residuals') + plt.tight_layout() + plt.savefig('resid_vpd.png', dpi=300) + plt.close() return def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', - poly='polyfit_d/fit', points='points_d/', radial=False, NcolMax=3, figsize=(15,15)): + poly='polyfit_d/fit', points='points_d/', radial=False, NcolMax=3, figsize=(6, 6)): print( 'Creating residuals plots for star(s):' ) print( starNames ) - + s = starset.StarSet(rootDir + align) s.loadPolyfit(rootDir + poly, accel=0, arcsec=0) Nstars = len(starNames) @@ -634,18 +653,18 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', else: Nrows = math.ceil(Nstars / (Ncols / 2)) * 3 - py.close('all') - py.figure(2, figsize=figsize) + plt.close('all') + plt.figure(2, figsize=figsize) names = s.getArray('name') mag = s.getArray('mag') x = s.getArray('x') y = s.getArray('y') r = np.hypot(x,y) - + for i in range(Nstars): - + starName = starNames[i] - + ii = names.index(starName) star = s.stars[ii] @@ -726,9 +745,9 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', idx = np.where(abs(sig) > 4) print( 'Star: ', starName ) - print( '\tX Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tX Chi^2 = %5.2f (%6.2f for %2d dof)' % (fitx.chi2red, fitx.chi2, fitx.dof)) - print( '\tY Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tY Chi^2 = %5.2f (%6.2f for %2d dof)' % (fity.chi2red, fity.chi2, fity.dof)) # print( 'X Outliers: ', time[idxX] ) # print( 'Y Outliers: ', time[idxY] ) @@ -743,8 +762,8 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', t0 = int(np.floor(np.min(time))) tO = int(np.ceil(np.max(time))) - - dateTicLoc = py.MultipleLocator(3) + + dateTicLoc = plt.MultipleLocator(3) dateTicRng = [t0-1, tO+1] dateTics = np.arange(t0, tO+1) DateTicsLabel = dateTics-2000 @@ -752,7 +771,7 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', # See if we are using MJD instead. if time[0] > 50000: print('MJD') - dateTicLoc = py.MultipleLocator(1000) + dateTicLoc = plt.MultipleLocator(1000) t0 = int(np.round(np.min(time), 50)) tO = int(np.round(np.max(time), 50)) dateTicRng = [t0-200, tO+200] @@ -763,7 +782,6 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', maxErr = np.array([xerr, yerr]).max() resTicRng = [-1.1*maxErr, 1.1*maxErr] - from matplotlib.ticker import FormatStrFormatter fmtX = FormatStrFormatter('%5i') fmtY = FormatStrFormatter('%6.2f') fontsize1 = 10 @@ -773,125 +791,125 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', row = 1 else: col = 1 + 2*(i % (Ncols/2)) - row = 1 + 3*(i//(Ncols/2)) - + row = 1 + 3*(i//(Ncols/2)) + ind = (row-1)*Ncols + col - paxes = py.subplot(Nrows, Ncols, ind) - py.plot(time, fitLineX, 'b-') - py.plot(time, fitLineX + fitSigX, 'b--') - py.plot(time, fitLineX - fitSigX, 'b--') - py.errorbar(time, x, yerr=xerr, fmt='k.') - rng = py.axis() - py.ylim(np.min(x-xerr-0.1),np.max(x+xerr+0.1)) - py.xlabel('Date - 2000 (yrs)', fontsize=fontsize1) + paxes = plt.subplot(Nrows, Ncols, ind) + plt.plot(time, fitLineX, 'b-') + plt.plot(time, fitLineX + fitSigX, 'b--') + plt.plot(time, fitLineX - fitSigX, 'b--') + plt.errorbar(time, x, yerr=xerr, fmt='k.') + rng = plt.axis() + plt.ylim(np.min(x-xerr-0.1),np.max(x+xerr+0.1)) + plt.xlabel('Date - 2000 (yrs)', fontsize=fontsize1) if time[0] > 50000: - py.xlabel('Date (MJD)', fontsize=fontsize1) - py.ylabel('X (pix)', fontsize=fontsize1) + plt.xlabel('Date (MJD)', fontsize=fontsize1) + plt.ylabel('X (pix)', fontsize=fontsize1) paxes.xaxis.set_major_formatter(fmtX) paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.yaxis.set_major_formatter(fmtY) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - py.yticks(np.arange(np.min(x-xerr-0.1), np.max(x+xerr+0.1), 0.2)) - py.xticks(dateTics, DateTicsLabel) - py.xlim(np.min(dateTics), np.max(dateTics)) - py.annotate(starName,xy=(1.0,1.1), xycoords='axes fraction', fontsize=12, color='red') + plt.yticks(np.arange(np.min(x-xerr-0.1), np.max(x+xerr+0.1), 0.2)) + plt.xticks(dateTics, DateTicsLabel) + plt.xlim(np.min(dateTics), np.max(dateTics)) + plt.annotate(starName,xy=(1.0,1.1), xycoords='axes fraction', fontsize=12, color='red') col = col + 1 ind = (row-1)*Ncols + col - paxes = py.subplot(Nrows, Ncols, ind) - py.plot(time, fitLineY, 'b-') - py.plot(time, fitLineY + fitSigY, 'b--') - py.plot(time, fitLineY - fitSigY, 'b--') - py.errorbar(time, y, yerr=yerr, fmt='k.') - rng = py.axis() - py.axis(dateTicRng + [rng[2], rng[3]], fontsize=fontsize1) - py.xlabel('Date - 2000 (yrs)', fontsize=fontsize1) + paxes = plt.subplot(Nrows, Ncols, ind) + plt.plot(time, fitLineY, 'b-') + plt.plot(time, fitLineY + fitSigY, 'b--') + plt.plot(time, fitLineY - fitSigY, 'b--') + plt.errorbar(time, y, yerr=yerr, fmt='k.') + rng = plt.axis() + plt.axis(dateTicRng + [rng[2], rng[3]], fontsize=fontsize1) + plt.xlabel('Date - 2000 (yrs)', fontsize=fontsize1) if time[0] > 50000: - py.xlabel('Date (MJD)', fontsize=fontsize1) - py.ylabel('Y (pix)', fontsize=fontsize1) + plt.xlabel('Date (MJD)', fontsize=fontsize1) + plt.ylabel('Y (pix)', fontsize=fontsize1) #paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.xaxis.set_major_formatter(fmtX) paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.yaxis.set_major_formatter(fmtY) paxes.tick_params(axis='both', which='major', labelsize=12) - py.ylim(np.min(y-yerr-0.1),np.max(y+yerr+0.1)) - py.yticks(np.arange(np.min(y-yerr-0.1), np.max(y+yerr+0.1), 0.2)) - py.xticks(dateTics, DateTicsLabel) - py.xlim(np.min(dateTics), np.max(dateTics)) + plt.ylim(np.min(y-yerr-0.1),np.max(y+yerr+0.1)) + plt.yticks(np.arange(np.min(y-yerr-0.1), np.max(y+yerr+0.1), 0.2)) + plt.xticks(dateTics, DateTicsLabel) + plt.xlim(np.min(dateTics), np.max(dateTics)) row = row + 1 col = col - 1 ind = (row-1)*Ncols + col - paxes = py.subplot(Nrows, Ncols, ind) - py.plot(time, np.zeros(len(time)), 'b-') - py.plot(time, fitSigX, 'b--') - py.plot(time, -fitSigX, 'b--') - py.errorbar(time, x - fitLineX, yerr=xerr, fmt='k.') - py.axis(dateTicRng + resTicRng, fontsize=fontsize1) - py.xlabel('Date - 2000 (yrs)', fontsize=fontsize1) + paxes = plt.subplot(Nrows, Ncols, ind) + plt.plot(time, np.zeros(len(time)), 'b-') + plt.plot(time, fitSigX, 'b--') + plt.plot(time, -fitSigX, 'b--') + plt.errorbar(time, x - fitLineX, yerr=xerr, fmt='k.') + plt.axis(dateTicRng + resTicRng, fontsize=fontsize1) + plt.xlabel('Date - 2000 (yrs)', fontsize=fontsize1) if time[0] > 50000: - py.xlabel('Date (MJD)', fontsize=fontsize1) - py.ylabel('X Residuals (pix)', fontsize=fontsize1) + plt.xlabel('Date (MJD)', fontsize=fontsize1) + plt.ylabel('X Residuals (pix)', fontsize=fontsize1) paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.xaxis.set_major_formatter(fmtX) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - py.xticks(dateTics, DateTicsLabel) - py.xlim(np.min(dateTics), np.max(dateTics)) + plt.xticks(dateTics, DateTicsLabel) + plt.xlim(np.min(dateTics), np.max(dateTics)) col = col + 1 ind = (row-1)*Ncols + col - paxes = py.subplot(Nrows, Ncols, ind) - py.plot(time, np.zeros(len(time)), 'b-') - py.plot(time, fitSigY, 'b--') - py.plot(time, -fitSigY, 'b--') - py.errorbar(time, y - fitLineY, yerr=yerr, fmt='k.') - py.axis(dateTicRng + resTicRng, fontsize=fontsize1) - py.xlabel('Date -2000 (yrs)', fontsize=fontsize1) + paxes = plt.subplot(Nrows, Ncols, ind) + plt.plot(time, np.zeros(len(time)), 'b-') + plt.plot(time, fitSigY, 'b--') + plt.plot(time, -fitSigY, 'b--') + plt.errorbar(time, y - fitLineY, yerr=yerr, fmt='k.') + plt.axis(dateTicRng + resTicRng, fontsize=fontsize1) + plt.xlabel('Date -2000 (yrs)', fontsize=fontsize1) if time[0] > 50000: - py.xlabel('Date (MJD)', fontsize=fontsize1) - py.ylabel('Y Residuals (pix)', fontsize=fontsize1) + plt.xlabel('Date (MJD)', fontsize=fontsize1) + plt.ylabel('Y Residuals (pix)', fontsize=fontsize1) paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.xaxis.set_major_formatter(fmtX) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - py.xticks(dateTics, DateTicsLabel) - py.xlim(np.min(dateTics), np.max(dateTics)) + plt.xticks(dateTics, DateTicsLabel) + plt.xlim(np.min(dateTics), np.max(dateTics)) row = row + 1 col = col - 1 ind = (row-1)*Ncols + col - paxes = py.subplot(Nrows, Ncols, ind) - py.errorbar(x,y, xerr=xerr, yerr=yerr, fmt='k.') - py.yticks(np.arange(np.min(y-yerr-0.1), np.max(y+yerr+0.1), 0.2)) - py.xticks(np.arange(np.min(x-xerr-0.1), np.max(x+xerr+0.1), 0.2), rotation = 270) - py.axis('equal') + paxes = plt.subplot(Nrows, Ncols, ind) + plt.errorbar(x,y, xerr=xerr, yerr=yerr, fmt='k.') + plt.yticks(np.arange(np.min(y-yerr-0.1), np.max(y+yerr+0.1), 0.2)) + plt.xticks(np.arange(np.min(x-xerr-0.1), np.max(x+xerr+0.1), 0.2), rotation = 270) + plt.axis('equal') paxes.tick_params(axis='both', which='major', labelsize=fontsize1) paxes.yaxis.set_major_formatter(FormatStrFormatter('%.2f')) paxes.xaxis.set_major_formatter(FormatStrFormatter('%.2f')) - py.xlabel('X (pix)', fontsize=fontsize1) - py.ylabel('Y (pix)', fontsize=fontsize1) - py.plot(fitLineX, fitLineY, 'b-') + plt.xlabel('X (pix)', fontsize=fontsize1) + plt.ylabel('Y (pix)', fontsize=fontsize1) + plt.plot(fitLineX, fitLineY, 'b-') col = col + 1 ind = (row-1)*Ncols + col bins = np.arange(-7.5, 7.5, 1) - paxes = py.subplot(Nrows, Ncols, ind) + paxes = plt.subplot(Nrows, Ncols, ind) id = np.where(diffY < 0)[0] - sig[id] = -1.*sig[id] - (n, b, p) = py.hist(sigX, bins, histtype='stepfilled', color='b', label='X') - py.setp(p, 'facecolor', 'b') - (n, b, p) = py.hist(sigY, bins, histtype='step', color='r', label='Y') - py.axis([-7, 7, 0, 8], fontsize=10) - py.legend() - py.xlabel('Residuals (sigma)', fontsize=fontsize1) - py.ylabel('Number of Epochs', fontsize=fontsize1) + sig[id] = -1.*sig[id] + (n, b, p) = plt.hist(sigX, bins, histtype='stepfilled', color='b', label='X') + plt.setp(p, 'facecolor', 'b') + (n, b, p) = plt.hist(sigY, bins, histtype='step', color='r', label='Y') + plt.axis([-7, 7, 0, 8], fontsize=10) + plt.legend() + plt.xlabel('Residuals (sigma)', fontsize=fontsize1) + plt.ylabel('Number of Epochs', fontsize=fontsize1) ########## # @@ -899,111 +917,110 @@ def plotStar(starNames, rootDir='./', align='align/align_d_rms_1000_abs_t', # ########## if (radial == True): - py.clf() + plt.clf() - dateTicLoc = py.MultipleLocator(3) + dateTicLoc = plt.MultipleLocator(3) maxErr = np.array([rerr, terr]).max() resTicRng = [-3*maxErr, 3*maxErr] - from matplotlib.ticker import FormatStrFormatter fmtX = FormatStrFormatter('%5i') fmtY = FormatStrFormatter('%6.2f') - paxes = py.subplot(3,2,1) - py.plot(time, fitLineR, 'b-') - py.plot(time, fitLineR + fitSigR, 'b--') - py.plot(time, fitLineR - fitSigR, 'b--') - py.errorbar(time, r, yerr=rerr, fmt='k.') - rng = py.axis() - py.axis(dateTicRng + [rng[2], rng[3]]) - py.xlabel('Date (yrs)') - py.ylabel('R (pix)') + paxes = plt.subplot(3,2,1) + plt.plot(time, fitLineR, 'b-') + plt.plot(time, fitLineR + fitSigR, 'b--') + plt.plot(time, fitLineR - fitSigR, 'b--') + plt.errorbar(time, r, yerr=rerr, fmt='k.') + rng = plt.axis() + plt.axis(dateTicRng + [rng[2], rng[3]]) + plt.xlabel('Date (yrs)') + plt.ylabel('R (pix)') paxes.xaxis.set_major_formatter(fmtX) paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.yaxis.set_major_formatter(fmtY) - paxes = py.subplot(3, 2, 2) - py.plot(time, fitLineT, 'b-') - py.plot(time, fitLineT + fitSigT, 'b--') - py.plot(time, fitLineT - fitSigT, 'b--') - py.errorbar(time, t, yerr=terr, fmt='k.') - rng = py.axis() - py.axis(dateTicRng + [rng[2], rng[3]]) - py.xlabel('Date (yrs)') - py.ylabel('T (pix)') + paxes = plt.subplot(3, 2, 2) + plt.plot(time, fitLineT, 'b-') + plt.plot(time, fitLineT + fitSigT, 'b--') + plt.plot(time, fitLineT - fitSigT, 'b--') + plt.errorbar(time, t, yerr=terr, fmt='k.') + rng = plt.axis() + plt.axis(dateTicRng + [rng[2], rng[3]]) + plt.xlabel('Date (yrs)') + plt.ylabel('T (pix)') paxes.xaxis.set_major_formatter(fmtX) paxes.get_xaxis().set_major_locator(dateTicLoc) paxes.yaxis.set_major_formatter(fmtY) - paxes = py.subplot(3, 2, 3) - py.plot(time, np.zeros(len(time)), 'b-') - py.plot(time, fitSigR, 'b--') - py.plot(time, -fitSigR, 'b--') - py.errorbar(time, r - fitLineR, yerr=rerr, fmt='k.') - py.axis(dateTicRng + resTicRng) - py.xlabel('Date (yrs)') - py.ylabel('R Residuals (pix)') + paxes = plt.subplot(3, 2, 3) + plt.plot(time, np.zeros(len(time)), 'b-') + plt.plot(time, fitSigR, 'b--') + plt.plot(time, -fitSigR, 'b--') + plt.errorbar(time, r - fitLineR, yerr=rerr, fmt='k.') + plt.axis(dateTicRng + resTicRng) + plt.xlabel('Date (yrs)') + plt.ylabel('R Residuals (pix)') paxes.get_xaxis().set_major_locator(dateTicLoc) - paxes = py.subplot(3, 2, 4) - py.plot(time, np.zeros(len(time)), 'b-') - py.plot(time, fitSigT, 'b--') - py.plot(time, -fitSigT, 'b--') - py.errorbar(time, t - fitLineT, yerr=terr, fmt='k.') - py.axis(dateTicRng + resTicRng) - py.xlabel('Date (yrs)') - py.ylabel('T Residuals (pix)') + paxes = plt.subplot(3, 2, 4) + plt.plot(time, np.zeros(len(time)), 'b-') + plt.plot(time, fitSigT, 'b--') + plt.plot(time, -fitSigT, 'b--') + plt.errorbar(time, t - fitLineT, yerr=terr, fmt='k.') + plt.axis(dateTicRng + resTicRng) + plt.xlabel('Date (yrs)') + plt.ylabel('T Residuals (pix)') paxes.get_xaxis().set_major_locator(dateTicLoc) bins = np.arange(-7, 7, 1) - py.subplot(3, 2, 5) - (n, b, p) = py.hist(sigR, bins) - py.setp(p, 'facecolor', 'k') - py.axis([-5, 5, 0, 20]) - py.xlabel('T Residuals (sigma)') - py.ylabel('Number of Epochs') - - py.subplot(3, 2, 6) - (n, b, p) = py.hist(sigT, bins) - py.axis([-5, 5, 0, 20]) - py.setp(p, 'facecolor', 'k') - py.xlabel('Y Residuals (sigma)') - py.ylabel('Number of Epochs') - - py.subplots_adjust(wspace=0.4, hspace=0.4, right=0.95, top=0.95) - py.savefig(rootDir+'plots/plotStarRadial_' + starName + '.png') - py.show() + plt.subplot(3, 2, 5) + (n, b, p) = plt.hist(sigR, bins) + plt.setp(p, 'facecolor', 'k') + plt.axis([-5, 5, 0, 20]) + plt.xlabel('T Residuals (sigma)') + plt.ylabel('Number of Epochs') + + plt.subplot(3, 2, 6) + (n, b, p) = plt.hist(sigT, bins) + plt.axis([-5, 5, 0, 20]) + plt.setp(p, 'facecolor', 'k') + plt.xlabel('Y Residuals (sigma)') + plt.ylabel('Number of Epochs') + + plt.subplots_adjust(wspace=0.4, hspace=0.4, right=0.95, top=0.95) + plt.savefig(rootDir+'plots/plotStarRadial_' + starName + '.png', dpi=300) + plt.show() title = rootDir.split('/')[-2] - py.suptitle(title, x=0.5, y=0.97) + plt.suptitle(title, x=0.5, y=0.97) if Nstars == 1: - py.subplots_adjust(wspace=0.4, hspace=0.4, left = 0.15, bottom = 0.1, right=0.9, top=0.9) - py.savefig(rootDir+'plots/plotStar_' + starName + '.png') + plt.subplots_adjust(wspace=0.4, hspace=0.4, left = 0.15, bottom = 0.1, right=0.9, top=0.9) + plt.savefig(rootDir+'plots/plotStar_' + starName + '.png', dpi=300) else: - py.subplots_adjust(wspace=0.6, hspace=0.6, left = 0.08, bottom = 0.05, right=0.95, top=0.90) - py.savefig(rootDir+'plots/plotStar_all.png') - py.show() + plt.subplots_adjust(wspace=0.6, hspace=0.6, left = 0.08, bottom = 0.05, right=0.95, top=0.90) + plt.savefig(rootDir+'plots/plotStar_all.png', dpi=300) + plt.show() - py.show() + plt.show() print('Fubar') - + ################################################## # New codes for velocity support in FlyStar and using -# the new StarTable and StarList format. +# the new StarTable and StarList format. ################################################## def plot_pm(tab): - plt.figure(figsize=(6,6)) + plt.figure(figsize=(6, 6)) plt.clf() plt.subplots_adjust(top=0.85) q = plt.quiver(tab['x0'].data, tab['y0'].data, tab['vx'].data*1e3, tab['vy'].data*1e3, scale=1e2, angles='xy') - plt.quiverkey(q, 0.5, 0.8, 10, '10 mas/yr', color='red', + plt.quiverkey(q, 0.5, 0.8, 10, '10 mas/yr', color='red', coordinates='figure', labelpos='E') plt.xlabel(r'$\Delta \alpha$ (")') plt.ylabel(r'$\Delta \delta$ (")') @@ -1020,16 +1037,16 @@ def plot_gaia(gaia): d_ra_tan = (ra_tan - ra_tan_mean) * cos_dec * 3600.0 d_de_tan = (de_tan - de_tan_mean) * 3600.0 - + pmra = gaia['pmra'] pmdec = gaia['pmdec'] - plt.figure(figsize=(6,6)) + plt.figure(figsize=(6, 6)) plt.clf() plt.subplots_adjust(top=0.85) q = plt.quiver(d_ra_tan.data, d_de_tan.data, pmra.data, pmdec.data, scale=1e2, angles='xy') - plt.quiverkey(q, 0.5, 0.8, 10, '10 mas/yr', color='red', + plt.quiverkey(q, 0.5, 0.8, 10, '10 mas/yr', color='red', coordinates='figure', labelpos='E') plt.xlabel(r'$\Delta \alpha \cos \delta$ ('')') plt.ylabel(r'$\Delta \delta$ ('')') @@ -1037,29 +1054,31 @@ def plot_gaia(gaia): fmt = r'[$\alpha$, $\delta$] = [{0:8.3f}$^\circ$, {1:8.3f}$^\circ$]' plt.title(fmt.format(ra_tan_mean, de_tan_mean)) plt.gca().invert_xaxis() - - return -def plot_pm_error(tab): - plt.figure(figsize=(6,6)) - plt.clf() - plt.semilogy(tab['m0'], tab['vxe']*1e3, 'r.', label=r'$\sigma_{\mu_{\alpha *}}$', alpha=0.4) - plt.semilogy(tab['m0'], tab['vye']*1e3, 'b.', label=r'$\sigma_{\mu_{\delta}}$', alpha=0.4) - plt.legend() - plt.xlabel('Mag') - plt.ylabel('PM Error (mas/yr)') - +def plot_pm_error(tab, save_path=None): + fig, ax = plt.subplots(1, 1, figsize=(6, 6)) + ax.semilogy(tab['m0'], tab['vx_err']*1e3, color='C0', marker='.', ls='none', ms=3, label=r'$\sigma_{\mu_{\alpha *}}$', alpha=0.3) + ax.semilogy(tab['m0'], tab['vy_err']*1e3, color='C3', marker='.', ls='none', ms=3, label=r'$\sigma_{\mu_{\delta}}$', alpha=0.3) + ax.legend() + ax.set_xlabel('Mag') + ax.set_ylabel('PM Error (mas/yr)') + plt.tight_layout() + if save_path is not None: + plt.savefig(save_path, dpi=300) + plt.show() return -def plot_mag_error(tab): - plt.figure(figsize=(6,6)) - plt.clf() - plt.semilogy(tab['m0'], tab['m0e'], 'r.', alpha=0.4) - plt.legend() - plt.xlabel('Mag') - plt.ylabel('Mag Error (mag)') - +def plot_mag_error(tab, save_path=None): + fig, ax = plt.subplots(1, 1, figsize=(6, 6)) + ax.semilogy(tab['m0'], tab['m0_err'], color='C0', marker='.', ls='none', alpha=0.4) + ax.legend() + ax.set_xlabel('Mag') + ax.set_ylabel('Mag Error (mag)') + plt.tight_layout() + if save_path is not None: + plt.savefig(save_path, dpi=300) + plt.show() return def plot_mean_residuals_by_epoch(tab): @@ -1069,9 +1088,8 @@ def plot_mean_residuals_by_epoch(tab): the size of the mean residual. """ # Predicted model positions at each epoch - dt = tab['t'] - tab['t0'][:, np.newaxis] - xt_mod = tab['x0'][:, np.newaxis] + tab['vx'][:, np.newaxis] * dt - yt_mod = tab['y0'][:, np.newaxis] + tab['vy'][:, np.newaxis] * dt + i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] + xt_mod, yt_mod, xt_mod_err, yt_mod_err = tab.predict_positions(tab['t'][i_all_detected]) # Residuals dx = tab['x'] - xt_mod @@ -1117,10 +1135,10 @@ def plot_mean_residuals_by_epoch(tab): plt.axhline(0, ls='--', color='black') plt.xlabel('Time (yr)') plt.ylabel('Mag Residuals') - + return -def plot_quiver_residuals_all_epochs(tab, unit='arcsec', scale=None, plotlim=None): +def plot_quiver_residuals_all_epochs(tab, unit='arcsec', scale=None, plotlim=None, save_path=None, show_plot=True): # Keep track of the residuals for averaging. dr_good = np.zeros(len(tab), dtype=float) @@ -1128,19 +1146,32 @@ def plot_quiver_residuals_all_epochs(tab, unit='arcsec', scale=None, plotlim=Non dr_ref = np.zeros(len(tab), dtype=float) n_ref = np.zeros(len(tab), dtype=int) + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + complete_times = np.array([np.unique(col[~np.isnan(col)])[0] for col in tab['t'].T]) + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(complete_times, motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(complete_times) + for ee in range(tab['x'].shape[1]): - dt = tab['t'][:, ee] - tab['t0'] - xt_mod = tab['x0'] + tab['vx'] * dt - yt_mod = tab['y0'] + tab['vy'] * dt - + xt_mod = xt_mod_all[:,ee] + yt_mod = yt_mod_all[:,ee] + good_idx = np.where(np.isfinite(tab['x'][:, ee]) == True)[0] ref_idx = np.where(tab[good_idx]['used_in_trans'][:, ee] == True)[0] - dx, dy = plot_quiver_residuals(tab['x'][:, ee], tab['y'][:, ee], - xt_mod, yt_mod, - good_idx, ref_idx, - 'Epoch {0:d}'.format(ee), - unit=unit, scale=scale, plotlim=plotlim) + dx, dy = plot_quiver_residuals( + tab['x'][:, ee], + tab['y'][:, ee], + xt_mod, + yt_mod, + good_idx, + ref_idx, + 'Epoch {0:d}'.format(ee), + unit=unit, + scale=scale, + plotlim=plotlim, + show_plot=show_plot, + save_path=f'{save_path}/Quiver_Residual_{ee}.png' if save_path else None + ) # Building up average dr for a set of stars. dr = np.hypot(dx, dy) @@ -1154,13 +1185,13 @@ def plot_quiver_residuals_all_epochs(tab, unit='arcsec', scale=None, plotlim=Non dr_good_avg = np.zeros(len(tab), dtype=float) idx = np.where(n_good > 0)[0] dr_good_avg[idx] = dr_good[idx] / n_good[idx] - + dr_ref_avg = np.zeros(len(tab), dtype=float) idx = np.where(n_ref > 0)[0] dr_ref_avg[idx] = dr_ref[idx] / n_ref[idx] - hdr = '{name:>16s} {mag:>5s} {dr:>6s} {x:>6s} {y:>6s} {r:>6s}' - fmt = '{name:16s} {mag:5.2f} {dr:6.4f} {x:6.3f} {y:6.3f} {r:6.3f}' + # hdr = '{name:>16s} {mag:>5s} {dr:>6s} {x:>6s} {y:>6s} {r:>6s}' + # fmt = '{name:16s} {mag:5.2f} {dr:6.4f} {x:6.3f} {y:6.3f} {r:6.3f}' # print() # print('##########') @@ -1180,11 +1211,11 @@ def plot_quiver_residuals_all_epochs(tab, unit='arcsec', scale=None, plotlim=Non # if (dr_ref_avg[rr] > 0): # print(fmt.format(name=tab['name'][rr], mag=tab['m0'][rr], dr=dr_ref_avg[rr], # x=tab['x0'][rr], y=tab['y0'][rr], r=np.hypot(tab['x0'][rr], tab['y0'][rr]))) - + return -def plot_quiver_residuals_with_orig_all_epochs(tab, trans_list, unit='arcsec', scale=None, plotlim=None, scale_orig=None, cte_fit=None, mlim=15): +def plot_quiver_residuals_with_orig_all_epochs(tab, trans_list, unit='arcsec', scale=None, plotlim=None, scale_orig=None, cte_fit=None, mlim=15, show_plot=True, save_path=None): # Keep track of the residuals for averaging. dr_good = np.zeros(len(tab), dtype=float) @@ -1192,59 +1223,64 @@ def plot_quiver_residuals_with_orig_all_epochs(tab, trans_list, unit='arcsec', s dr_ref = np.zeros(len(tab), dtype=float) n_ref = np.zeros(len(tab), dtype=int) + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + for ee in range(tab['x'].shape[1]): dt = tab['t'][:, ee] - tab['t0'] - xt_mod = tab['x0'] + tab['vx'] * dt - yt_mod = tab['y0'] + tab['vy'] * dt - + xt_mod = xt_mod_all[ee] + yt_mod = yt_mod_all[ee] + good_idx = np.where(np.isfinite(tab['x'][:, ee]) == True)[0] ref_idx = np.where(tab[good_idx]['used_in_trans'][:, ee] == True)[0] da = calc_da(trans_list[ee]) - dx, dy = plot_quiver_residuals(tab['x'][:, ee], tab['y'][:, ee], - xt_mod, yt_mod, + dx, dy = plot_quiver_residuals(tab['x'][:, ee], tab['y'][:, ee], + xt_mod, yt_mod, good_idx, ref_idx, - 'Epoch {0:d}'.format(ee), - unit=unit, scale=scale, plotlim=plotlim) + 'Epoch {0:d}'.format(ee), + unit=unit, scale=scale, plotlim=plotlim, show_plot=show_plot, save_path=f'{save_path}/Quiver_Residual_{ee}.png' if save_path else None) - plot_quiver_residuals_orig(tab['x'][:, ee], tab['y'][:, ee], - xt_mod, yt_mod, + plot_quiver_residuals_orig(tab['x'][:, ee], tab['y'][:, ee], + xt_mod, yt_mod, good_idx, ref_idx, tab['x_orig'][:, ee], tab['y_orig'][:, ee], da, - 'Epoch {0:d}'.format(ee), - scale=scale_orig, plotlim=plotlim) + 'Epoch {0:d}'.format(ee), + scale=scale_orig, plotlim=plotlim, show_plot=show_plot, save_path=f'{save_path}/Quiver_Residual_Orig_{ee}.png' if save_path else None) - plot_mag_scatter(tab['m'][:, ee], - tab['m0'], tab['m0e'], - tab['x'][:, ee], tab['y'][:, ee], + plot_mag_scatter(tab['m'][:, ee], + tab['m0'], tab['m0_err'], + tab['x'][:, ee], tab['y'][:, ee], tab['xe'][:, ee], tab['ye'][:, ee], - xt_mod, yt_mod, + xt_mod, yt_mod, good_idx, ref_idx, 'Epoch {0:d}'.format(ee), da=da, xorig=tab['x_orig'][:, ee], yorig=tab['y_orig'][:, ee], - cte_fit=cte_fit, mlim=mlim) + cte_fit=cte_fit, mlim=mlim, show_plot=show_plot, save_path=f'{save_path}/Mag_Scatter_{ee}.png' if save_path else None) - plot_y_scatter(tab['m'][:, ee], - tab['m0'], tab['m0e'], - tab['x'][:, ee], tab['y'][:, ee], + plot_y_scatter(tab['m'][:, ee], + tab['m0'], tab['m0_err'], + tab['x'][:, ee], tab['y'][:, ee], tab['xe'][:, ee], tab['ye'][:, ee], - xt_mod, yt_mod, + xt_mod, yt_mod, good_idx, ref_idx, 'Epoch {0:d}'.format(ee), da=da, xorig=tab['x_orig'][:, ee], yorig=tab['y_orig'][:, ee], - cte_fit=cte_fit, mlim=mlim) + cte_fit=cte_fit, mlim=mlim, show_plot=show_plot, save_path=f'{save_path}/Y_Scatter_{ee}.png' if save_path else None) # plot_quiver_residuals_orig_angle_xy(tab['x'][:, ee], tab['y'][:, ee], -# xt_mod, yt_mod, +# xt_mod, yt_mod, # good_idx, ref_idx, # tab['x_orig'][:, ee], tab['y_orig'][:, ee], da, # 'Epoch {0:d}'.format(ee)) # # plot_quiver_residuals_vs_pos_err(dx, dy, good_idx, ref_idx, -# 1e3 * tab['xe'][:, ee], 1e3 * tab['ye'][:, ee], +# 1e3 * tab['xe'][:, ee], 1e3 * tab['ye'][:, ee], # 'positional err (mas)', 'Epoch {0:d}'.format(ee), da=da) - + # Building up average dr for a set of stars. dr = np.hypot(dx, dy) @@ -1257,13 +1293,13 @@ def plot_quiver_residuals_with_orig_all_epochs(tab, trans_list, unit='arcsec', s dr_good_avg = np.zeros(len(tab), dtype=float) idx = np.where(n_good > 0)[0] dr_good_avg[idx] = dr_good[idx] / n_good[idx] - + dr_ref_avg = np.zeros(len(tab), dtype=float) idx = np.where(n_ref > 0)[0] dr_ref_avg[idx] = dr_ref[idx] / n_ref[idx] - hdr = '{name:>16s} {mag:>5s} {dr:>6s} {x:>6s} {y:>6s} {r:>6s}' - fmt = '{name:16s} {mag:5.2f} {dr:6.4f} {x:6.3f} {y:6.3f} {r:6.3f}' + # hdr = '{name:>16s} {mag:>5s} {dr:>6s} {x:>6s} {y:>6s} {r:>6s}' + # fmt = '{name:16s} {mag:5.2f} {dr:6.4f} {x:6.3f} {y:6.3f} {r:6.3f}' # print() # print('##########') @@ -1283,7 +1319,7 @@ def plot_quiver_residuals_with_orig_all_epochs(tab, trans_list, unit='arcsec', s # if (dr_ref_avg[rr] > 0): # print(fmt.format(name=tab['name'][rr], mag=tab['m0'][rr], dr=dr_ref_avg[rr], # x=tab['x0'][rr], y=tab['y0'][rr], r=np.hypot(tab['x0'][rr], tab['y0'][rr]))) - + return @@ -1291,24 +1327,28 @@ def plot_mag_scatter_multi_trans_all_epochs(tab_list, trans_list_list, unit='arc m_t_list = [] x_t_list = [] y_t_list = [] - xe_t_list = [] + xe_t_list = [] ye_t_list = [] x_ref_list = [] - y_ref_list = [] - good_idx_list = [] - ref_idx_list =[] + y_ref_list = [] + good_idx_list = [] + ref_idx_list =[] da_list = [] ntrans = len(tab_list) + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) for mm in range(ntrans): tab = tab_list[mm] trans_list = trans_list_list[mm] for ee in range(tab['x'].shape[1]): dt = tab['t'][:, ee] - tab['t0'] - xt_mod = tab['x0'] + tab['vx'] * dt - yt_mod = tab['y0'] + tab['vy'] * dt - + xt_mod = xt_mod_all[ee] + yt_mod = yt_mod_all[ee] + good_idx = np.where(np.isfinite(tab['x'][:, ee]) == True)[0] ref_idx = np.where(tab[good_idx]['used_in_trans'][:, ee] == True)[0] @@ -1317,19 +1357,19 @@ def plot_mag_scatter_multi_trans_all_epochs(tab_list, trans_list_list, unit='arc m_t_list.append(tab['m'][:, ee]) x_t_list.append(tab['x'][:, ee]) y_t_list.append(tab['y'][:, ee]) - xe_t_list.append(tab['xe'][:, ee]) + xe_t_list.append(tab['xe'][:, ee]) ye_t_list.append(tab['ye'][:, ee]) x_ref_list.append(xt_mod) y_ref_list.append(yt_mod) - good_idx_list.append(good_idx) - ref_idx_list.append(ref_idx) + good_idx_list.append(good_idx) + ref_idx_list.append(ref_idx) da_list.append(da) for ee in range(tab_list[0]['x'].shape[1]): - plot_mag_scatter_multi_trans(m_t_list[ee::ntrans], x_t_list[ee::ntrans], y_t_list[ee::ntrans], - xe_t_list[ee::ntrans], ye_t_list[ee::ntrans], x_ref_list[ee::ntrans], y_ref_list[ee::ntrans], + plot_mag_scatter_multi_trans(m_t_list[ee::ntrans], x_t_list[ee::ntrans], y_t_list[ee::ntrans], + xe_t_list[ee::ntrans], ye_t_list[ee::ntrans], x_ref_list[ee::ntrans], y_ref_list[ee::ntrans], good_idx_list[ee::ntrans], ref_idx_list[ee::ntrans], 'Epoch {0:d}'.format(ee), da_list[ee::ntrans]) - + return @@ -1351,7 +1391,7 @@ def calc_da(trans_list): c01 = trans_list.px.parameters[c01_idx] c10 = trans_list.px.parameters[c10_idx] da = np.degrees(np.arctan2(-c01, c10)) - + return da @@ -1359,7 +1399,7 @@ def plot_mag_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, # Residual dx = (x_t - x_ref) dy = (y_t - y_ref) - + # Magnitude mgood = m_t[good_idx] mref = m_t[good_idx][ref_idx] @@ -1397,8 +1437,7 @@ def plot_mag_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, xgood = np.cos(np.radians(agood)) * rgood xref = np.cos(np.radians(aref)) * rref - fig, ax = plt.subplots(7, 1, figsize=(6,18), sharex=True, num=103) -# plt.clf() + fig, ax = plt.subplots(7, 1, figsize=(6, 18), sharex=True, num=103) plt.subplots_adjust(hspace=0.01) ax[0].scatter(mgood, agood, color='black', alpha=0.3, s=2) ax[0].scatter(mref, aref, color='red', alpha=0.3, s=2) @@ -1448,15 +1487,17 @@ def plot_mag_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, ax[6].axhline(y=0) ax[0].set_title(title) + plt.tight_layout() plt.show() plt.pause(1) + return def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, ref_idx, title, da=0, xorig=None, yorig=None, cte_fit=None, mlim=15): # Residual dx = (x_t - x_ref) dy = (y_t - y_ref) - + # Magnitude mgood = m_t[good_idx] mref = m_t[good_idx][ref_idx] @@ -1494,7 +1535,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r xgood = np.cos(np.radians(agood)) * rgood xref = np.cos(np.radians(aref)) * rref - fig, ax = plt.subplots(7, 1, figsize=(6,18), sharex=True, num=103) + fig, ax = plt.subplots(7, 1, figsize=(6, 18), sharex=True, num=103) # plt.clf() plt.subplots_adjust(hspace=0.01) ax[0].scatter(yorig[good_idx], agood, color='black', alpha=0.3, s=2) @@ -1547,6 +1588,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[6].axhline(y=0) ax[0].set_title(title) + plt.tight_layout() plt.show() plt.pause(1) @@ -1567,24 +1609,24 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r if cte_fit=='power': idx = np.where(mgood > mlim)[0] gpopt, gpcov = curve_fit(T_cte_y, mgood[idx], ygood[idx], maxfev=100000) - + marr = np.linspace(13, 24, 1000) - + # Corrected values ygood_new = ygood - T_cte_y(mgood, *gpopt) yref_new = yref - T_cte_y(mref, *gpopt) - + agood = angle_from_xy(xgood, ygood) % 360 rgood = np.hypot(xgood, ygood) aref = angle_from_xy(xref, yref) % 360 rref = np.hypot(xref, yref) - + agood_new = angle_from_xy(xgood, ygood_new) % 360 rgood_new = np.hypot(xgood, ygood_new) aref_new = angle_from_xy(xref, yref_new) % 360 rref_new = np.hypot(xref, yref_new) - - fig, ax = plt.subplots(4, 2, figsize=(12,12), sharex=True, sharey='row', num=105) + + fig, ax = plt.subplots(4, 2, figsize=(12, 12), sharex=True, sharey='row', num=105) plt.subplots_adjust(hspace=0.01, wspace=0.01) ax[0,0].scatter(mgood, ygood, color='black', alpha=0.3, s=2) ax[0,0].scatter(mref, yref, color='red', alpha=0.3, s=2) @@ -1593,24 +1635,24 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[0,0].axhline(y=0) ax[0,0].plot(marr, T_cte_y(marr, *gpopt), 'k-') ax[0,0].set_title('No correction') - + ax[0,1].scatter(mgood, ygood_new, color='black', alpha=0.3, s=2) ax[0,1].scatter(mref, yref_new, color='red', alpha=0.3, s=2) ax[0,1].set_ylim(-0.01, 0.01) ax[0,1].axhline(y=0) ax[0,1].set_title('Corrected') - + ax[1,0].scatter(mgood, ygood/yegood, color='black', alpha=0.3, s=2) ax[1,0].scatter(mref, yref/yeref, color='red', alpha=0.3, s=2) ax[1,0].set_ylabel('Res/Pos Err, y') ax[1,0].set_ylim(-10, 10) ax[1,0].axhline(y=0) - + ax[1,1].scatter(mgood, ygood_new/yegood, color='black', alpha=0.3, s=2) ax[1,1].scatter(mref, yref_new/yeref, color='red', alpha=0.3, s=2) ax[1,1].set_ylim(-10, 10) ax[1,1].axhline(y=0) - + ax[2,0].scatter(mgood, rgood, color='black', alpha=0.3, s=2) ax[2,0].scatter(mref, rref, color='red', alpha=0.3, s=2) ax[2,0].set_ylabel('Modulus (arcsec)') @@ -1619,7 +1661,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[2,0].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood.data, rref.data]))) else: ax[2,0].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood, rref]))) - + ax[2,1].scatter(mgood, rgood_new, color='black', alpha=0.3, s=2) ax[2,1].scatter(mref, rref_new, color='red', alpha=0.3, s=2) ax[2,1].set_yscale('log') @@ -1627,16 +1669,19 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[2,1].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood_new.data, rref_new.data]))) else: ax[2,1].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood_new, rref_new]))) - + ax[3,0].scatter(mgood, agood, color='black', alpha=0.3, s=2) ax[3,0].scatter(mref, aref, color='red', alpha=0.3, s=2) ax[3,0].set_ylabel('Angle (deg)') ax[3,0].set_xlabel('mag') - + ax[3,1].scatter(mgood, agood_new, color='black', alpha=0.3, s=2) ax[3,1].scatter(mref, aref_new, color='red', alpha=0.3, s=2) ax[3,1].set_xlabel('mag') + plt.tight_layout() + plt.show() + if cte_fit=='power_line': idx1 = np.where((mgood > 15) & (mgood < 18.5))[0] idx2 = np.where(mgood > 18.5)[0] @@ -1646,7 +1691,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r gpopt1, gpcov1 = curve_fit(T_line, mgood[idx1], ygood[idx1], maxfev=100000) gpopt2, gpcov2 = curve_fit(T_cte_y, mgood[idx2], ygood[idx2], maxfev=100000) - + marr1 = np.linspace(13, 18.5, 1000) marr2 = np.linspace(18.5, 24, 1000) @@ -1674,7 +1719,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r xeref2 = xeref[idx2r] yeref1 = yeref[idx1r] yeref2 = yeref[idx2r] - + # Corrected values ygood_new1 = ygood1 - T_line(mgood1, *gpopt1) yref_new1 = yref1 - T_line(mref1, *gpopt1) @@ -1700,8 +1745,8 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r rgood_new2 = np.hypot(xgood2, ygood_new2) aref_new2 = angle_from_xy(xref2, yref_new2) % 360 rref_new2 = np.hypot(xref2, yref_new2) - - fig, ax = plt.subplots(4, 2, figsize=(12,12), sharex=True, sharey='row', num=105) + + fig, ax = plt.subplots(4, 2, figsize=(12, 12), sharex=True, sharey='row', num=105) plt.subplots_adjust(hspace=0.01, wspace=0.01) ax[0,0].scatter(mgood, ygood, color='black', alpha=0.3, s=2) ax[0,0].scatter(mref, yref, color='red', alpha=0.3, s=2) @@ -1711,7 +1756,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[0,0].plot(marr1, T_line(marr1, *gpopt1), 'b-') ax[0,0].plot(marr2, T_cte_y(marr2, *gpopt2), 'b-') ax[0,0].set_title('No correction') - + ax[0,1].scatter(mgood1, ygood_new1, color='black', alpha=0.3, s=2) ax[0,1].scatter(mref1, yref_new1, color='red', alpha=0.3, s=2) ax[0,1].scatter(mgood2, ygood_new2, color='black', alpha=0.3, s=2) @@ -1719,20 +1764,20 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[0,1].set_ylim(-0.01, 0.01) ax[0,1].axhline(y=0) ax[0,1].set_title('Corrected') - + ax[1,0].scatter(mgood, ygood/yegood, color='black', alpha=0.3, s=2) ax[1,0].scatter(mref, yref/yeref, color='red', alpha=0.3, s=2) ax[1,0].set_ylabel('Res/Pos Err, y') ax[1,0].set_ylim(-10, 10) ax[1,0].axhline(y=0) - + ax[1,1].scatter(mgood1, ygood_new1/yegood1, color='black', alpha=0.3, s=2) ax[1,1].scatter(mref1, yref_new1/yeref1, color='red', alpha=0.3, s=2) ax[1,1].scatter(mgood2, ygood_new2/yegood2, color='black', alpha=0.3, s=2) ax[1,1].scatter(mref2, yref_new2/yeref2, color='red', alpha=0.3, s=2) ax[1,1].set_ylim(-10, 10) ax[1,1].axhline(y=0) - + ax[2,0].scatter(mgood, rgood, color='black', alpha=0.3, s=2) ax[2,0].scatter(mref, rref, color='red', alpha=0.3, s=2) ax[2,0].set_ylabel('Modulus (arcsec)') @@ -1741,7 +1786,7 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[2,0].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood.data, rref.data]))) else: ax[2,0].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood, rref]))) - + ax[2,1].scatter(mgood1, rgood_new1, color='black', alpha=0.3, s=2) ax[2,1].scatter(mref1, rref_new1, color='red', alpha=0.3, s=2) ax[2,1].scatter(mgood2, rgood_new2, color='black', alpha=0.3, s=2) @@ -1751,18 +1796,18 @@ def plot_y_scatter(m_t, m0, m0e, x_t, y_t, xe_t, ye_t, x_ref, y_ref, good_idx, r ax[2,1].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood_new.data2, rref_new.data2]))) else: ax[2,1].set_ylim(1e-6, 1.1 * np.max(np.concatenate([rgood_new2, rref_new2]))) - + ax[3,0].scatter(mgood, agood, color='black', alpha=0.3, s=2) ax[3,0].scatter(mref, aref, color='red', alpha=0.3, s=2) ax[3,0].set_ylabel('Angle (deg)') ax[3,0].set_xlabel('mag') - + ax[3,1].scatter(mgood1, agood_new1, color='black', alpha=0.3, s=2) ax[3,1].scatter(mref1, aref_new1, color='red', alpha=0.3, s=2) ax[3,1].scatter(mgood2, agood_new2, color='black', alpha=0.3, s=2) ax[3,1].scatter(mref2, aref_new2, color='red', alpha=0.3, s=2) ax[3,1].set_xlabel('mag') - + def T_cte_y(m, A, m0, alpha, m1): base = m/m0 @@ -1772,16 +1817,16 @@ def T_line(m, a, b): return a + m*b -def plot_quiver_residuals(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, title, - unit='pixel', scale=None, plotlim=None): +def plot_quiver_residuals(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, title, + unit='pixel', scale=None, plotlim=None, save_path=None, show_plot=True): """ unit : str 'pixel' or 'arcsec' The pixel units of the input values. Note, if arcsec, then the values will be - converted to milli-arcsec for plotting when appropriate. + converted to milli-arcsec for plotting when appropriate. scale : float - The quiver scale. If none, then default units will be used appropriate to the unit. + The quiver scale. If none, then default units will be used appropriate to the unit. plotlim : float (positive) Sets the size of the plotted figure. If None, then default is used. @@ -1810,33 +1855,37 @@ def plot_quiver_residuals(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, title, unit2 = 'mas' - plt.figure(101, figsize=(6,6)) - plt.clf() - q = plt.quiver(x_ref[good_idx], y_ref[good_idx], dx[good_idx], dy[good_idx], + fig, ax = plt.subplots(1, 1, figsize=(6, 6)) + q = ax.quiver(x_ref[good_idx], y_ref[good_idx], dx[good_idx], dy[good_idx], color='black', scale=quiv_scale, angles='xy', alpha=0.5) - plt.quiver(x_ref[good_idx][ref_idx], y_ref[good_idx][ref_idx], dx[good_idx][ref_idx], dy[good_idx][ref_idx], + ax.quiver(x_ref[good_idx][ref_idx], y_ref[good_idx][ref_idx], dx[good_idx][ref_idx], dy[good_idx][ref_idx], color='red', scale=quiv_scale, angles='xy') - plt.quiverkey(q, 0.5, 0.85, quiv_label_val, quiv_label, + ax.quiverkey(q, 0.5, 0.85, quiv_label_val, quiv_label, coordinates='figure', labelpos='E', color='green') - plt.xlabel('X (ref ' + unit + ')') - plt.ylabel('Y (ref ' + unit + ')') - plt.title(title) - plt.axis('equal') + ax.set_xlabel('X (ref ' + unit + ')') + ax.set_ylabel('Y (ref ' + unit + ')') + ax.set_title(title) + ax.axis('equal') if plotlim is not None: - plt.xlim(-1 * plotlim, plotlim) - plt.ylim(-1 * plotlim, plotlim) - plt.show() - plt.pause(1) + ax.set_xlim(-1 * plotlim, plotlim) + ax.set_ylim(-1 * plotlim, plotlim) + plt.tight_layout() + if save_path: + plt.savefig(save_path, dpi=300) + if show_plot: + plt.show() + else: + plt.close() - str_fmt = 'Residuals (mean, std): dx = {0:7.3f} +/- {1:7.3f} {5:s} dy = {2:7.3f} +/- {3:7.3f} {5:s} for {4:s} stars' + str_fmt = '{0:s}: Residuals (mean, std): dx = {1:7.3f} ± {2:7.3f} {6:s} dy = {3:7.3f} ± {4:7.3f} {6:s} for {5:s} stars' if len(ref_idx) > 1: - print(str_fmt.format(dx[good_idx][ref_idx].mean(), dx[good_idx][ref_idx].std(), + print(str_fmt.format(title, dx[good_idx][ref_idx].mean(), dx[good_idx][ref_idx].std(), dy[good_idx][ref_idx].mean(), dy[good_idx][ref_idx].std(), 'REF', unit2)) else: - print(str_fmt.format(dx[good_idx][ref_idx].mean(), 0.0, + print(str_fmt.format(title, dx[good_idx][ref_idx].mean(), 0.0, dy[good_idx][ref_idx].mean(), 0.0, 'REF', unit2)) - - print(str_fmt.format(dx[good_idx].mean(), dx[good_idx].std(), + + print(str_fmt.format(title, dx[good_idx].mean(), dx[good_idx].std(), dy[good_idx].mean(), dy[good_idx].std(), 'GOOD', unit2)) @@ -1849,23 +1898,27 @@ def plot_quiver_residuals_magcolor_all_epochs(tab, unit='arcsec', scale=None, pl dr_ref = np.zeros(len(tab), dtype=float) n_ref = np.zeros(len(tab), dtype=int) - idx = np.where((tab['m0'] < lower_mag) & + idx = np.where((tab['m0'] < lower_mag) & (tab['m0'] > upper_mag))[0] tab = tab[idx] + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) for ee in range(tab['x'].shape[1]): dt = tab['t'][:, ee] - tab['t0'] - xt_mod = tab['x0'] + tab['vx'] * dt - yt_mod = tab['y0'] + tab['vy'] * dt + xt_mod = xt_mod_all[ee] + yt_mod = yt_mod_all[ee] mag = tab['m0'] good_idx = np.where(np.isfinite(tab['x'][:, ee]) == True)[0] ref_idx = np.where(tab[good_idx]['used_in_trans'][:, ee] == True)[0] - dx, dy = plot_quiver_residuals_magcolor(tab['x'][:, ee], tab['y'][:, ee], + dx, dy = plot_quiver_residuals_magcolor(tab['x'][:, ee], tab['y'][:, ee], xt_mod, yt_mod, mag, good_idx, ref_idx, - 'Epoch {0:d}'.format(ee), + 'Epoch {0:d}'.format(ee), unit=unit, scale=scale, plotlim=plotlim) # Building up average dr for a set of stars. @@ -1880,7 +1933,7 @@ def plot_quiver_residuals_magcolor_all_epochs(tab, unit='arcsec', scale=None, pl dr_good_avg = np.zeros(len(tab), dtype=float) idx = np.where(n_good > 0)[0] dr_good_avg[idx] = dr_good[idx] / n_good[idx] - + dr_ref_avg = np.zeros(len(tab), dtype=float) idx = np.where(n_ref > 0)[0] dr_ref_avg[idx] = dr_ref[idx] / n_ref[idx] @@ -1890,16 +1943,16 @@ def plot_quiver_residuals_magcolor_all_epochs(tab, unit='arcsec', scale=None, pl -def plot_quiver_residuals_magcolor(x_t, y_t, x_ref, y_ref, mag, good_idx, ref_idx, title, +def plot_quiver_residuals_magcolor(x_t, y_t, x_ref, y_ref, mag, good_idx, ref_idx, title, unit='pixel', scale=None, plotlim=None): """ unit : str 'pixel' or 'arcsec' The pixel units of the input values. Note, if arcsec, then the values will be - converted to milli-arcsec for plotting when appropriate. + converted to milli-arcsec for plotting when appropriate. scale : float - The quiver scale. If none, then default units will be used appropriate to the unit. + The quiver scale. If none, then default units will be used appropriate to the unit. plotlim : float (positive) Sets the size of the plotted figure. If None, then default is used. @@ -1927,51 +1980,48 @@ def plot_quiver_residuals_magcolor(x_t, y_t, x_ref, y_ref, mag, good_idx, ref_id quiv_label_val = 1.0 unit2 = 'mas' - norm = matplotlib.colors.Normalize() + norm = mcolors.Normalize() norm.autoscale(mag) - cm = matplotlib.cm.viridis - sm = matplotlib.cm.ScalarMappable(cmap=cm, norm=norm) + cmap = matplotlib.colormaps['viridis'] + sm = matplotlib.cm.ScalarMappable(cmap=cmap, norm=norm) # cmap = mpl.cm.cool -# norm = mpl.colors.Normalize(vmin=np.min(mag), vmax=np.max(mag)) -# +# norm = mpl.mcolors.Normalize(vmin=np.min(mag), vmax=np.max(mag)) +# # cb1 = mpl.colorbar.ColorbarBase(ax, cmap=cmap, # norm=norm, # orientation='horizontal') - plt.figure(101, figsize=(6,6)) - plt.clf() - q = plt.quiver(x_ref[good_idx], y_ref[good_idx], dx[good_idx], dy[good_idx], + fig, ax=plt.subplots(1, 1, figsize=(6, 6)) + q = ax.quiver(x_ref[good_idx], y_ref[good_idx], dx[good_idx], dy[good_idx], color=cm(norm(mag[good_idx])), scale=quiv_scale, angles='xy', alpha=0.8) - plt.quiverkey(q, 0.5, 0.85, quiv_label_val, quiv_label, + ax.quiverkey(q, 0.5, 0.85, quiv_label_val, quiv_label, coordinates='figure', labelpos='E', color='green') - plt.colorbar(sm) - plt.xlabel('X (ref ' + unit + ')') - plt.ylabel('Y (ref ' + unit + ')') - plt.title(title + ', Good') - plt.axis('equal') + fig.colorbar(sm, ax=ax) + ax.set_xlabel('X (ref ' + unit + ')') + ax.set_ylabel('Y (ref ' + unit + ')') + ax.set_title(title + ', Good') + ax.axis('equal') if plotlim is not None: - plt.xlim(-1 * plotlim, plotlim) - plt.ylim(-1 * plotlim, plotlim) + ax.set_xlim(-1 * plotlim, plotlim) + ax.set_ylim(-1 * plotlim, plotlim) + plt.tight_layout() plt.show() - plt.pause(1) - plt.figure(102, figsize=(6,6)) - plt.clf() - q = plt.quiver(x_ref[good_idx][ref_idx], y_ref[good_idx][ref_idx], dx[good_idx][ref_idx], dy[good_idx][ref_idx], + fig, ax = plt.subplots(1, 1, figsize=(6, 6)) + q = ax.quiver(x_ref[good_idx][ref_idx], y_ref[good_idx][ref_idx], dx[good_idx][ref_idx], dy[good_idx][ref_idx], color=cm(norm(mag[good_idx][ref_idx])), scale=quiv_scale, angles='xy', alpha=0.8) - plt.quiverkey(q, 0.5, 0.85, quiv_label_val, quiv_label, + ax.quiverkey(q, 0.5, 0.85, quiv_label_val, quiv_label, coordinates='figure', labelpos='E', color='green') - plt.colorbar(sm) - plt.xlabel('X (ref ' + unit + ')') - plt.ylabel('Y (ref ' + unit + ')') - plt.title(title + ', Ref') - plt.axis('equal') + fig.colorbar(sm, ax=ax) + ax.set_xlabel('X (ref ' + unit + ')') + ax.set_ylabel('Y (ref ' + unit + ')') + ax.set_title(title + ', Ref') + ax.axis('equal') if plotlim is not None: - plt.xlim(-1 * plotlim, plotlim) - plt.ylim(-1 * plotlim, plotlim) + ax.set_xlim(-1 * plotlim, plotlim) + ax.set_ylim(-1 * plotlim, plotlim) plt.show() - plt.pause(1) str_fmt = 'Residuals (mean, std): dx = {0:7.3f} +/- {1:7.3f} {5:s} dy = {2:7.3f} +/- {3:7.3f} {5:s} for {4:s} stars' if len(ref_idx) > 1: @@ -1980,7 +2030,7 @@ def plot_quiver_residuals_magcolor(x_t, y_t, x_ref, y_ref, mag, good_idx, ref_id else: print(str_fmt.format(dx[good_idx][ref_idx].mean(), 0.0, dy[good_idx][ref_idx].mean(), 0.0, 'REF', unit2)) - + print(str_fmt.format(dx[good_idx].mean(), dx[good_idx].std(), dy[good_idx].mean(), dy[good_idx].std(), 'GOOD', unit2)) @@ -1988,17 +2038,17 @@ def plot_quiver_residuals_magcolor(x_t, y_t, x_ref, y_ref, mag, good_idx, ref_id return (dx, dy) -def plot_quiver_residuals_orig(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, - x_orig, y_orig, da, title, - scale=None, plotlim=None): +def plot_quiver_residuals_orig(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, + x_orig, y_orig, da, title, + scale=None, plotlim=None, save_path=None): """ unit : str 'pixel' or 'arcsec' The pixel units of the input values. Note, if arcsec, then the values will be - converted to milli-arcsec for plotting when appropriate. + converted to milli-arcsec for plotting when appropriate. scale : float - The quiver scale. If none, then default units will be used appropriate to the unit. + The quiver scale. If none, then default units will be used appropriate to the unit. plotlim : float (positive) Sets the size of the plotted figure. If None, then default is used. @@ -2013,8 +2063,8 @@ def plot_quiver_residuals_orig(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, dy /= 0.04 # Residual modulus - r_good = np.hypot(dx[good_idx], dy[good_idx]) - r_ref = np.hypot(dx[good_idx][ref_idx], dy[good_idx][ref_idx]) + # r_good = np.hypot(dx[good_idx], dy[good_idx]) + # r_ref = np.hypot(dx[good_idx][ref_idx], dy[good_idx][ref_idx]) # Residual angle agood = angle_from_xy(dx[good_idx], dy[good_idx]) @@ -2030,21 +2080,23 @@ def plot_quiver_residuals_orig(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, dx_ref_new, dy_ref_new = rotate(dx[good_idx][ref_idx], dy[good_idx][ref_idx], -da) print('Rotation angle between HST and Gaia (deg): ', da) - plt.figure(102, figsize=(6,6)) - plt.clf() - q = plt.quiver(x_orig[good_idx], y_orig[good_idx], dx_good_new, dy_good_new, + fig, ax = plt.subplots(1, 1, figsize=(6, 6)) + q = ax.quiver(x_orig[good_idx], y_orig[good_idx], dx_good_new, dy_good_new, color='black', scale=scale, angles='xy', alpha=0.5) - plt.quiver(x_orig[good_idx][ref_idx], y_orig[good_idx][ref_idx], dx_ref_new, dy_ref_new, + ax.quiver(x_orig[good_idx][ref_idx], y_orig[good_idx][ref_idx], dx_ref_new, dy_ref_new, color='red', scale=scale, angles='xy') - plt.quiverkey(q, 0.5, 0.85, 0.3, '0.3 pix', + ax.quiverkey(q, 0.5, 0.85, 0.3, '0.3 pix', coordinates='figure', labelpos='E', color='green') - plt.xlabel('X (ref pix)') - plt.ylabel('Y (ref pix)') - plt.title(title) - plt.axis('equal') + ax.set_xlabel('X (ref pix)') + ax.set_ylabel('Y (ref pix)') + ax.set_title(title) + ax.axis('equal') if plotlim is not None: - plt.xlim(-1 * plotlim, plotlim) - plt.ylim(-1 * plotlim, plotlim) + ax.set_xlim(-1 * plotlim, plotlim) + ax.set_ylim(-1 * plotlim, plotlim) + plt.tight_layout() + if save_path: + plt.savefig(save_path, dpi=300) plt.show() plt.pause(1) @@ -2058,11 +2110,11 @@ def plot_quiver_residuals_orig(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, # ax1.hist(aref ,color='red', histtype = 'step', # alpha=0.8, bins = 36, density=True) # ax1.set_xlabel('Quiver angle (degrees), HST camera') -# -# ax2.scatter(x_orig[good_idx], y_orig[good_idx], +# +# ax2.scatter(x_orig[good_idx], y_orig[good_idx], # s=5e3 * r_good**2, alpha=0.3, color='black') -# ax2.scatter(x_orig[good_idx][ref_idx], y_orig[good_idx][ref_idx], -# s=5e3 * r_ref**2, alpha=0.5, color='red') +# ax2.scatter(x_orig[good_idx][ref_idx], y_orig[good_idx][ref_idx], +# s=5e3 * r_ref**2, alpha=0.5, color='red') # ax2.set_xlabel('X (orig pix)') # ax2.set_ylabel('Y (orig pix)') # plt.title(title) @@ -2088,16 +2140,16 @@ def rotate(x, y, theta): return xnew, ynew -def plot_quiver_residuals_orig_angle_xy(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, +def plot_quiver_residuals_orig_angle_xy(x_t, y_t, x_ref, y_ref, good_idx, ref_idx, x_orig, y_orig, da, title, scale=None, plotlim=None): """ unit : str 'pixel' or 'arcsec' The pixel units of the input values. Note, if arcsec, then the values will be - converted to milli-arcsec for plotting when appropriate. + converted to milli-arcsec for plotting when appropriate. scale : float - The quiver scale. If none, then default units will be used appropriate to the unit. + The quiver scale. If none, then default units will be used appropriate to the unit. plotlim : float (positive) Sets the size of the plotted figure. If None, then default is used. @@ -2105,7 +2157,7 @@ def plot_quiver_residuals_orig_angle_xy(x_t, y_t, x_ref, y_ref, good_idx, ref_id """ dx = (x_t - x_ref) dy = (y_t - y_ref) - + # Residual modulus r_good = np.hypot(dx[good_idx], dy[good_idx]) r_ref = np.hypot(dx[good_idx][ref_idx], dy[good_idx][ref_idx]) @@ -2120,13 +2172,13 @@ def plot_quiver_residuals_orig_angle_xy(x_t, y_t, x_ref, y_ref, good_idx, ref_id agood = agood % 360 aref = aref % 360 - plt.figure(figsize=(14,6)) - plt.clf() - ax1 = plt.subplot(1, 2, 1) - ax2 = plt.subplot(1, 2, 2) - plt.subplots_adjust(wspace=0.3) + # plt.figure(figsize=(12,6)) + # plt.clf() + # ax1 = plt.subplot(1, 2, 1) + # ax2 = plt.subplot(1, 2, 2) + # plt.subplots_adjust(wspace=0.3) - plt.clf() + # plt.clf() fig, ax = plt.subplots(1, 2, figsize=(12,6), sharey=True) # plt.clf() plt.subplots_adjust(wspace=0.01) @@ -2143,13 +2195,14 @@ def plot_quiver_residuals_orig_angle_xy(x_t, y_t, x_ref, y_ref, good_idx, ref_id if plotlim is not None: plt.xlim(-1 * plotlim, plotlim) plt.ylim(-1 * plotlim, plotlim) + plt.tight_layout() plt.show() plt.pause(1) return -def plot_chi2_dist(tab, Ndetect, xlim=40, n_bins=50): +def plot_chi2_dist(tab, Ndetect, xlim=40, n_bins=50, boot_err=False): """ tab = flystar table Ndetect = Number of epochs star detected in @@ -2158,26 +2211,33 @@ def plot_chi2_dist(tab, Ndetect, xlim=40, n_bins=50): chi2_y_list = [] fnd_list = [] # Number of non-NaN error measurements + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + for ii in range(len(tab)): - # Ignore the NaNs + # Ignore the NaNs fnd = np.argwhere(~np.isnan(tab['xe'][ii,:])) -# fnd = np.where(tab['xe'][ii, :] > 0)[0] fnd_list.append(len(fnd)) - + x = tab['x'][ii, fnd] y = tab['y'][ii, fnd] - xerr = tab['xe'][ii, fnd] - yerr = tab['ye'][ii, fnd] + if boot_err: + xerr = np.hypot(tab['xe_boot'][ii, fnd], tab['xe'][ii, fnd]) + yerr = np.hypot(tab['ye_boot'][ii, fnd], tab['ye'][ii, fnd]) + else: + xerr = tab['xe'][ii, fnd] + yerr = tab['ye'][ii, fnd] - dt = tab['t'][ii, fnd] - tab['t0'][ii] - fitLineX = tab['x0'][ii] + (tab['vx'][ii] * dt) - fitLineY = tab['y0'][ii] + (tab['vy'][ii] * dt) + fitLineX = xt_mod_all[ii, fnd] + fitLineY = yt_mod_all[ii,fnd] diffX = x - fitLineX diffY = y - fitLineY sigX = diffX / xerr sigY = diffY / yerr - + chi2_x = np.sum(sigX**2) chi2_y = np.sum(sigY**2) chi2_x_list.append(chi2_x) @@ -2186,27 +2246,36 @@ def plot_chi2_dist(tab, Ndetect, xlim=40, n_bins=50): x = np.array(chi2_x_list) y = np.array(chi2_y_list) fnd = np.array(fnd_list) - + idx = np.where(fnd == Ndetect)[0] # Fitting position and velocity... so subtract 2 to get Ndof - Ndof = Ndetect - 2 + n_params = np.nanmean(tab['n_params'][idx]) + Ndof = Ndetect - n_params + if len(np.unique(tab['n_params'][idx]))>1: + print("** Warning: using average Ndof for multiple motion models. **") + print("** Consider using plot_chi2_reduced_dist. **") + print(f"Ndof={Ndof:.2f}, Ndetect={Ndetect}, Nparams={n_params:.2f}") + else: + print(f"Ndof={Ndof}, Ndetect={Ndetect}, Nparams={n_params}") chi2_xaxis = np.linspace(0, xlim, xlim*3) chi2_bins = np.linspace(0, xlim, n_bins) - plt.figure(figsize=(6,4)) + plt.figure(figsize=(6, 4)) plt.clf() plt.hist(x[idx], bins=chi2_bins, histtype='step', label='X', density=True) plt.hist(y[idx], bins=chi2_bins, histtype='step', label='Y', density=True) - plt.plot(chi2_xaxis, chi2.pdf(chi2_xaxis, Ndof), 'r-', alpha=0.6, - label='$\chi^2$ ' + str(Ndof) + ' dof') - plt.title('$N_{epoch} = $' + str(Ndetect) + ', $N_{dof} = $' + str(Ndof)) + plt.plot(chi2_xaxis, chi2.pdf(chi2_xaxis, Ndof), 'r-', alpha=0.6, + label=r'$\chi^2$ ' + str(round(Ndof,2)) + ' dof') + plt.title('$N_{epoch} = $' + str(Ndetect) + ', $N_{dof} = $' + str(round(Ndof,2))) plt.xlim(0, xlim) plt.legend() + plt.tight_layout() + plt.show() + + chi2red_x = x / Ndof + chi2red_y = y / Ndof + chi2red_t = (x + y) / (2.0 * Ndof) - chi2red_x = x / (fnd - 2) - chi2red_y = y / (fnd - 2) - chi2red_t = (x + y) / (2.0 * (fnd - 2)) - print('Mean reduced chi^2: (Ndetect = {0:d} of {1:d})'.format(len(idx), len(tab))) fmt = ' {0:s} = {1:.1f} for N_detect and {2:.1f} for all' med_chi2red_x_f = np.median(chi2red_x[idx]) @@ -2221,36 +2290,218 @@ def plot_chi2_dist(tab, Ndetect, xlim=40, n_bins=50): return +def plot_chi2_reduced_dist(tab, Ndetect, xlim=8, n_bins=50, boot_err=False): + """ + tab = flystar table + Ndetect = Number of epochs star detected in + """ + chi2_x_list = [] + chi2_y_list = [] + fnd_list = [] # Number of non-NaN error measurements + + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + + for ii in range(len(tab)): + # Ignore the NaNs + fnd = np.argwhere(~np.isnan(tab['xe'][ii,:])) + fnd_list.append(len(fnd)) + + x = tab['x'][ii, fnd] + y = tab['y'][ii, fnd] + if boot_err: + xerr = np.hypot(tab['xe_boot'][ii, fnd], tab['xe'][ii, fnd]) + yerr = np.hypot(tab['ye_boot'][ii, fnd], tab['ye'][ii, fnd]) + else: + xerr = tab['xe'][ii, fnd] + yerr = tab['ye'][ii, fnd] + + fitLineX = xt_mod_all[ii, fnd] + fitLineY = yt_mod_all[ii,fnd] -def plot_chi2_dist_per_epoch(tab, Ndetect, xlim, ylim = [-1, 1], target_idx = 0): + diffX = x - fitLineX + diffY = y - fitLineY + sigX = diffX / xerr + sigY = diffY / yerr + + chi2_x = np.sum(sigX**2) + chi2_y = np.sum(sigY**2) + chi2_x_list.append(chi2_x) + chi2_y_list.append(chi2_y) + + x = np.array(chi2_x_list) + y = np.array(chi2_y_list) + fnd = np.array(fnd_list) + + idx = np.where(fnd == Ndetect)[0] + n_params = tab['n_params'] + Ndof = Ndetect - n_params + print("Reduced chi2 for Ndetect="+str(Ndetect)) + chi2_bins = np.linspace(0, xlim, n_bins) + + plt.figure(figsize=(6, 4)) + plt.clf() + plt.hist(x[idx]/Ndof[idx], bins=chi2_bins, histtype='step', label='X', density=True) + plt.hist(y[idx]/Ndof[idx], bins=chi2_bins, histtype='step', label='Y', density=True) + plt.axvline(np.median(x[idx]/Ndof[idx]), color='C0', linestyle='--', label='X median') + plt.axvline(np.median(y[idx]/Ndof[idx]), color='C1', linestyle='--', label='Y median') + plt.title('Reduced chi2, $N_{epoch} = $' + str(Ndetect)) + plt.xlim(0, xlim) + plt.legend() + plt.tight_layout() + plt.show() + + chi2red_x = x / Ndof + chi2red_y = y / Ndof + chi2red_t = (x + y) / (2.0 * Ndof + 1*(tab['motion_model_used']=='Parallax')) + + print('Mean reduced chi^2: (Ndetect = {0:d} of {1:d})'.format(len(idx), len(tab))) + fmt = ' {0:s} = {1:.1f} for N_detect and {2:.1f} for all' + med_chi2red_x_f = np.median(chi2red_x[idx]) + med_chi2red_x_a = np.median(chi2red_x) + med_chi2red_y_f = np.median(chi2red_y[idx]) + med_chi2red_y_a = np.median(chi2red_y) + med_chi2red_t_f = np.median(chi2red_t[idx]) + med_chi2red_t_a = np.median(chi2red_t) + print(fmt.format(' X', med_chi2red_x_f, med_chi2red_x_a)) + print(fmt.format(' Y', med_chi2red_y_f, med_chi2red_y_a)) + print(fmt.format('Tot', med_chi2red_t_f, med_chi2red_t_a)) + + return + + +def plot_chi2_dist_per_filter(tab, Ndetect, xlim=40, n_bins=50, filter=None, boot_err=False): """ tab = flystar table Ndetect = Number of epochs star detected in """ - diffX_arr = -99 * np.ones((len(tab['xe']), Ndetect)) - diffY_arr = -99 * np.ones((len(tab['xe']), Ndetect)) - errX_arr = -99 * np.ones((len(tab['xe']), Ndetect)) - errY_arr = -99 * np.ones((len(tab['xe']), Ndetect)) - sigX_arr = -99 * np.ones((len(tab['xe']), Ndetect)) - sigY_arr = -99 * np.ones((len(tab['xe']), Ndetect)) - m_arr = -99 * np.ones((len(tab['xe']), Ndetect)) + chi2_x_list = [] + chi2_y_list = [] + fnd_list = [] # Number of non-NaN error measurements + + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + + for ii in range(len(tab)): + # Ignore the NaNs + fnd = np.argwhere(~np.isnan(tab['xe'][ii,:])) + fnd_list.append(len(fnd)) + + x = tab['x'][ii, fnd] + y = tab['y'][ii, fnd] + if boot_err: + xerr = np.hypot(tab['xe_boot'][ii, fnd], tab['xe'][ii, fnd]) + yerr = np.hypot(tab['ye_boot'][ii, fnd], tab['ye'][ii, fnd]) + else: + xerr = tab['xe'][ii, fnd] + yerr = tab['ye'][ii, fnd] + + fitLineX = xt_mod_all[ii, fnd] + fitLineY = yt_mod_all[ii,fnd] + + diffX = x - fitLineX + diffY = y - fitLineY + sigX = diffX / xerr + sigY = diffY / yerr + + chi2_x = np.sum(sigX**2) + chi2_y = np.sum(sigY**2) + chi2_x_list.append(chi2_x) + chi2_y_list.append(chi2_y) + #print(fitLineX, x, xerr) + #pdb.set_trace() + + x = np.array(chi2_x_list) + y = np.array(chi2_y_list) + fnd = np.array(fnd_list) + + + idx = np.where(fnd == Ndetect)[0] + # Fitting position and velocity... so subtract n_params to get Ndof + n_params = np.nanmean(tab['n_params'][idx]) + Ndof = Ndetect - n_params + print(f"Ndof={Ndof}, Ndetect={Ndetect}, Nparams={n_params}") + chi2_xaxis = np.linspace(0, xlim, xlim*3) + chi2_bins = np.linspace(0, xlim, n_bins) + print(x[idx]) + #pdb.set_trace() + + plt.figure(figsize=(6, 4)) + plt.clf() + plt.hist(x[idx], bins=chi2_bins, histtype='stepfilled', label='RA', density=True, color='skyblue', alpha=0.8, edgecolor='k') + plt.hist(y[idx], bins=chi2_bins, histtype='stepfilled', label='DEC', density=True, color='orange', alpha=0.8, edgecolor='k') + plt.plot(chi2_xaxis, chi2.pdf(chi2_xaxis, Ndof), 'r-', alpha=0.6, + label=r'$\chi^2$ ' + str(Ndof) + ' dof') + #plt.title('$N_{epoch} = $' + str(Ndetect) + ', $N_{dof} = $' + str(Ndof)) + plt.title(str(filter)+' (N = '+str(len(chi2_x_list))+')', fontsize=22) + plt.xlim(0, xlim) + plt.ylabel(r'PDF', fontsize=28) + plt.legend(fontsize=20) + plt.tick_params(labelsize=20, direction='in', right=True, top=True) + plt.tight_layout() + plt.savefig(str(filter)+'_chi2_dist.png', dpi=300) + plt.close() + + chi2red_x = x / Ndof + chi2red_y = y / Ndof + chi2red_t = (x + y) / (2.0 * Ndof) + + print('Mean reduced chi^2: (Ndetect = {0:d} of {1:d})'.format(len(idx), len(tab))) + fmt = ' {0:s} = {1:.1f} for N_detect and {2:.1f} for all' + med_chi2red_x_f = np.median(chi2red_x[idx]) + med_chi2red_x_a = np.median(chi2red_x) + med_chi2red_y_f = np.median(chi2red_y[idx]) + med_chi2red_y_a = np.median(chi2red_y) + med_chi2red_t_f = np.median(chi2red_t[idx]) + med_chi2red_t_a = np.median(chi2red_t) + print(fmt.format(' X', med_chi2red_x_f, med_chi2red_x_a)) + print(fmt.format(' Y', med_chi2red_y_f, med_chi2red_y_a)) + print(fmt.format('Tot', med_chi2red_t_f, med_chi2red_t_a)) + + return + + +def plot_chi2_dist_per_epoch(tab, Ndetect, mlim=[14, 21], ylim=[-1, 1], target_idx=0, boot_err=False): + """ + tab = flystar table + Ndetect = Number of epochs star detected in + """ + diffX_arr = np.nan * np.ones((len(tab['xe']), Ndetect)) + diffY_arr = np.nan * np.ones((len(tab['xe']), Ndetect)) + errX_arr = np.nan * np.ones((len(tab['xe']), Ndetect)) + errY_arr = np.nan * np.ones((len(tab['xe']), Ndetect)) + sigX_arr = np.nan * np.ones((len(tab['xe']), Ndetect)) + sigY_arr = np.nan * np.ones((len(tab['xe']), Ndetect)) + m_arr = np.nan * np.ones((len(tab['xe']), Ndetect)) + + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) for ii in range(len(tab['xe'])): - # Ignore the NaNs + # Ignore the NaNs fnd = np.argwhere(~np.isnan(tab['xe'][ii,:])) - if len(fnd) == Ndetect: + if len(fnd) == Ndetect and tab['use_in_trans'][ii]: time = tab['t'][ii, fnd] x = tab['x'][ii, fnd] y = tab['y'][ii, fnd] m = tab['m'][ii, fnd] - xerr = tab['xe'][ii, fnd] - yerr = tab['ye'][ii, fnd] + if boot_err: + xerr = np.hypot(tab['xe_boot'][ii, fnd], tab['xe'][ii, fnd]) + yerr = np.hypot(tab['ye_boot'][ii, fnd], tab['ye'][ii, fnd]) + else: + xerr = tab['xe'][ii, fnd] + yerr = tab['ye'][ii, fnd] + + fitLineX = xt_mod_all[ii, fnd] + fitLineY = yt_mod_all[ii, fnd] - dt = tab['t'][ii, fnd] - tab['t0'][ii] - fitLineX = tab['x0'][ii] + (tab['vx'][ii] * dt) - fitLineY = tab['y0'][ii] + (tab['vy'][ii] * dt) - diffX = x - fitLineX diffY = y - fitLineY sigX = diffX / xerr @@ -2259,7 +2510,7 @@ def plot_chi2_dist_per_epoch(tab, Ndetect, xlim, ylim = [-1, 1], target_idx = 0) diffX_arr[ii] = diffX.reshape(Ndetect,) diffY_arr[ii] = diffY.reshape(Ndetect,) errX_arr[ii] = xerr.reshape(Ndetect,) - errY_arr[ii] = yerr.reshape(Ndetect,) + errY_arr[ii] = yerr.reshape(Ndetect,) sigX_arr[ii] = sigX.reshape(Ndetect,) sigY_arr[ii] = sigY.reshape(Ndetect,) m_arr[ii] = m.reshape(Ndetect,) @@ -2281,32 +2532,157 @@ def plot_chi2_dist_per_epoch(tab, Ndetect, xlim, ylim = [-1, 1], target_idx = 0) if target_idx is not None: ax2.plot(m_arr[target_idx, ii], sigX_arr[target_idx, ii], 's', color='black', ms=5) ax2.plot(m_arr[target_idx, ii], sigY_arr[target_idx, ii], 'o', color='black', ms=5) - ax2.set_xlim(xlim[0], xlim[1]) + ax2.set_xlim(mlim[0], mlim[1]) ax2.set_ylim(-5, 5) ax2.axhline(y=0, color='black', alpha=0.9, zorder=1000) + ax2.axhline(y=np.nanmean(sigX_arr[:, ii]), color='tab:blue', alpha=0.9,linestyle='dotted', zorder=1001) + ax2.axhline(y=np.nanmean(sigY_arr[:, ii]), color='tab:orange', alpha=0.9,linestyle='dotted', zorder=1002) ax2.set_xlabel('mag') ax2.set_ylabel('sigma') ax2.set_title('Epoch {0}'.format(ii)) ax2.legend() - ax3.errorbar(m_arr[:, ii], diffX_arr[:, ii]*1E3, yerr=errX_arr[:, ii]*1E3, + #print(errX_arr[:, ii]) + ax3.errorbar(m_arr[:, ii], diffX_arr[:, ii]*1E3, yerr=errX_arr[:, ii]*1E3, marker='s', label = 'X', ls='none', color='tab:blue', alpha=0.4, ms=5) - ax3.errorbar(m_arr[:, ii], diffY_arr[:, ii]*1E3, yerr=errY_arr[:, ii]*1E3, + ax3.errorbar(m_arr[:, ii], diffY_arr[:, ii]*1E3, yerr=errY_arr[:, ii]*1E3, marker='o', label = 'Y', ls='none', color='tab:orange', alpha=0.4, ms=5) if target_idx is not None: - ax3.errorbar(m_arr[target_idx, ii], diffX_arr[target_idx, ii]*1E3, yerr=errX_arr[target_idx, ii]*1E3, + ax3.errorbar(m_arr[target_idx, ii], diffX_arr[target_idx, ii]*1E3, yerr=errX_arr[target_idx, ii]*1E3, marker='s', ls='none', color='black', ms=5) - ax3.errorbar(m_arr[target_idx, ii], diffY_arr[target_idx, ii]*1E3, yerr=errY_arr[target_idx, ii]*1E3, + ax3.errorbar(m_arr[target_idx, ii], diffY_arr[target_idx, ii]*1E3, yerr=errY_arr[target_idx, ii]*1E3, marker='o', ls='none', color='black', ms=5) - ax3.set_xlim(xlim[0], xlim[1]) + ax3.set_xlim(mlim[0], mlim[1]) ax3.set_ylim(ylim[0], ylim[1]) ax3.axhline(y=0, color='black', alpha=0.9, zorder=1000) + ax3.axhline(y=np.nanmean(diffX_arr[:, ii]*1E3), color='tab:blue', alpha=0.9,linestyle='dotted', zorder=1001) + ax3.axhline(y=np.nanmean(diffY_arr[:, ii]*1E3), color='tab:orange', alpha=0.9,linestyle='dotted', zorder=1002) ax3.set_xlabel('mag') ax3.set_ylabel('residual (mas)') return -def plot_chi2_dist_mag(tab, Ndetect, mlim=40, n_bins=30): +# TODO: update for motion model +def plot_chi2_ecliptic_per_epoch(tab, Ndetect,ra,dec, mlim=[14,21], ylim = [-1, 1], target_idx = 0): + """ + tab = flystar table + Ndetect = Number of epochs star detected in + """ + diffX_arr = -99 * np.ones((len(tab['xe']), Ndetect)) + diffY_arr = -99 * np.ones((len(tab['xe']), Ndetect)) + errX_arr = 99 * np.ones((len(tab['xe']), Ndetect)) + errY_arr = 99 * np.ones((len(tab['xe']), Ndetect)) + sigX_arr = -99 * np.ones((len(tab['xe']), Ndetect)) + sigY_arr = -99 * np.ones((len(tab['xe']), Ndetect)) + m_arr = -99 * np.ones((len(tab['xe']), Ndetect)) + + rad_to_as = 180/np.pi * 60 * 60 + deg_to_as = 60 * 60 + def eq_to_ec(ra,dec): + e = 23.446 * np.pi/180 + sinb = np.sin(dec)*np.cos(e) - np.cos(dec)*np.sin(e)*np.sin(ra) + cosb = np.cos(np.arcsin(sinb)) + cosg = np.cos(ra)*np.cos(dec)/cosb + sing = (np.sin(dec)*np.sin(e) + np.cos(dec)*np.cos(e)*np.sin(ra))/cosb + g,b = np.arctan2(sing,cosg)*180/np.pi,np.arcsin(sinb)*180/np.pi + g = 360+g + return g*deg_to_as,b*deg_to_as + coord0 = SkyCoord(ra=ra,dec=dec,unit=(u.hourangle, u.deg),frame='icrs') + + for ii in range(len(tab['xe'])): + # Ignore the NaNs + fnd = np.argwhere(~np.isnan(tab['xe'][ii,:])) + if len(fnd) == Ndetect and tab['use_in_trans'][ii]: + time = tab['t'][ii, fnd] + x = tab['x'][ii, fnd] + y = tab['y'][ii, fnd] + m = tab['m'][ii, fnd] + vx = tab['vx'][ii] + vy = tab['vy'][ii] + lambda_0,beta_0 = eq_to_ec((coord0.ra - tab['x0'][ii]*u.arcsec).radian, + (coord0.dec + tab['y0'][ii]*u.arcsec).radian) + x1 = coord0.ra - u.arcsec*x + y1 = coord0.dec + u.arcsec*y + ra_rad,dec_rad = x1.radian, y1.radian + lambda_obs,beta_obs = eq_to_ec(ra_rad,dec_rad) + x2 = coord0.ra - tab['x0'][ii]*u.arcsec - (time-tab['t0'][ii])*vx*u.arcsec + y2 = coord0.dec + tab['y0'][ii]*u.arcsec + (time-tab['t0'][ii])*vy*u.arcsec + ra_rad,dec_rad = x2.radian, y2.radian + lambda_pm,beta_pm = eq_to_ec(ra_rad,dec_rad) + + xerr = tab['xe'][ii, fnd] + yerr = tab['ye'][ii, fnd] + + dt = tab['t'][ii, fnd] - tab['t0'][ii] + fitLineX = lambda_pm + fitLineY = beta_pm + + diffX = lambda_obs - fitLineX + diffY = beta_obs - fitLineY + sigX = diffX / xerr + sigY = diffY / yerr + + diffX_arr[ii] = diffX.reshape(Ndetect,) + diffY_arr[ii] = diffY.reshape(Ndetect,) + errX_arr[ii] = xerr.reshape(Ndetect,) + errY_arr[ii] = yerr.reshape(Ndetect,) + sigX_arr[ii] = sigX.reshape(Ndetect,) + sigY_arr[ii] = sigY.reshape(Ndetect,) + m_arr[ii] = m.reshape(Ndetect,) + + ts_folded = tab['t'][0]%1 + i_sort = np.argsort(ts_folded) + print(ts_folded,i_sort) + for ii in i_sort: +# fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 4), +# gridspec_kw={'width_ratios': [1, 2, 2]}) +# plt.subplots_adjust(wspace=0.5) +# ax1.hist(sigX_arr[:, ii], label = 'X', histtype='step', bins=np.linspace(-10, 10)) +# ax1.hist(sigY_arr[:, ii], label = 'Y', histtype='step', bins=np.linspace(-10, 10)) +# ax1.set_xlabel('sigma') +# ax1.legend() + + fig, (ax2, ax3) = plt.subplots(1, 2, figsize=(14, 4)) + plt.subplots_adjust(wspace=0.25) + + '''ax2.plot(m_arr[:, ii], sigX_arr[:, ii], 's', label = 'lambda', color='tab:blue', alpha=0.4, ms=5) + ax2.plot(m_arr[:, ii], sigY_arr[:, ii], 'o', label = 'beta', color='tab:orange', alpha=0.4, ms=5) + if target_idx is not None: + ax2.plot(m_arr[target_idx, ii], sigX_arr[target_idx, ii], 's', color='black', ms=5) + ax2.plot(m_arr[target_idx, ii], sigY_arr[target_idx, ii], 'o', color='black', ms=5) + ax2.set_xlim(mlim[0], mlim[1]) + ax2.set_ylim(-5, 5) + ax2.axhline(y=0, color='black', alpha=0.9, zorder=1000) + ax2.set_xlabel('mag') + ax2.set_ylabel('sigma')''' + ax2.set_title('Epoch {0}'.format(ii)+', phase='+str(tab['t'][0][ii]%1)[:5]) + + #print(errX_arr[:, ii]) + ax2.errorbar(m_arr[:, ii], diffX_arr[:, ii]*1E3, yerr=errX_arr[:, ii]*1E3, + marker='s', label = 'lambda', ls='none', color='tab:blue', alpha=0.4, ms=5) + ax3.errorbar(m_arr[:, ii], diffY_arr[:, ii]*1E3, yerr=errY_arr[:, ii]*1E3, + marker='o', label = 'beta', ls='none', color='tab:orange', alpha=0.4, ms=5) + if target_idx is not None: + #print('target',m_arr[target_idx, ii],diffX_arr[target_idx, ii]*1E3,diffY_arr[target_idx, ii]*1E3) + ax2.errorbar(m_arr[target_idx, ii], diffX_arr[target_idx, ii]*1E3, yerr=errX_arr[target_idx, ii]*1E3, + marker='s', ls='none', color='black', ms=5) + ax3.errorbar(m_arr[target_idx, ii], diffY_arr[target_idx, ii]*1E3, yerr=errY_arr[target_idx, ii]*1E3, + marker='o', ls='none', color='black', ms=5) + ax2.legend() + ax3.legend() + ax2.set_xlim(mlim[0], mlim[1]) + ax3.set_xlim(mlim[0], mlim[1]) + ax2.set_ylim(ylim[0], ylim[1]) + ax3.set_ylim(ylim[0], ylim[1]) + ax2.axhline(y=0, color='black', alpha=0.9, zorder=1000) + ax3.axhline(y=0, color='black', alpha=0.9, zorder=1000) + ax2.set_xlabel('mag') + ax2.set_ylabel('residual (mas)') + ax3.set_xlabel('mag') + ax3.set_ylabel('residual (mas)') + return + +def plot_chi2_dist_mag(tab, Ndetect, xlim=40, n_bins=30, boot_err=False): """ tab = flystar table Ndetect = Number of epochs star detected in @@ -2315,18 +2691,21 @@ def plot_chi2_dist_mag(tab, Ndetect, mlim=40, n_bins=30): fnd_list = [] # Number of non-NaN error measurements for ii in range(len(tab['me'])): - # Ignore the NaNs + # Ignore the NaNs fnd = np.argwhere(~np.isnan(tab['me'][ii,:])) fnd_list.append(len(fnd)) - + m = tab['m'][ii, fnd] - merr = tab['me'][ii, fnd] + if boot_err: + merr = np.hypot(tab['me_boot'][ii, fnd], tab['me'][ii, fnd]) + else: + merr = tab['me'][ii, fnd] m0 = tab['m0'][ii] - m0err = tab['m0e'][ii] + m0err = tab['m0_err'][ii] diff_m = m0 - m sig_m = diff_m/merr - + chi2_m = np.sum(sig_m**2) chi2_m_list.append(chi2_m) @@ -2337,34 +2716,95 @@ def plot_chi2_dist_mag(tab, Ndetect, mlim=40, n_bins=30): # Fitting mean magnitude... so subtract 1 to get Ndof Ndof = Ndetect - 1 - chi2_maxis = np.linspace(0, mlim, mlim*3) - chi2_bins = np.linspace(0, mlim, n_bins) + chi2_maxis = np.linspace(0, xlim, xlim*3) + chi2_bins = np.linspace(0, xlim, n_bins) - plt.figure(figsize=(6,4)) + plt.figure(figsize=(6, 4)) plt.clf() - plt.hist(chi2_m[idx], bins=np.arange(mlim*10), histtype='step', density=True) - plt.plot(chi2_maxis, chi2.pdf(chi2_maxis, Ndof), 'r-', alpha=0.6, - label='$\chi^2$ ' + str(Ndof) + ' dof') + plt.hist(chi2_m[idx], bins=np.arange(xlim*10), histtype='step', density=True) + plt.plot(chi2_maxis, chi2.pdf(chi2_maxis, Ndof), 'r-', alpha=0.6, + label=r'$\chi^2$ ' + str(Ndof) + ' dof') plt.title('$N_{epoch} = $' + str(Ndetect) + ', $N_{dof} = $' + str(Ndof)) - plt.xlim(0, mlim) + plt.xlim(0, xlim) plt.legend() + plt.tight_layout() + plt.show() print('Mean reduced chi^2: (Ndetect = {0:d} of {1:d})'.format(len(idx), len(tab))) fmt = ' {0:s} = {1:.1f} for N_detect and {2:.1f} for all' print(fmt.format('M', np.median(chi2_m[idx] / (fnd[idx] - 2)), np.median(chi2_m / (fnd - 2)))) - + return -def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), color_time=False): +def plot_chi2_dist_mag_per_filter(tab, Ndetect, mlim=40, n_bins=30, xlim=40, file_name=None, filter=None): + """ + tab = flystar table + Ndetect = Number of epochs star detected in """ - Plot a set of stars positions, flux and residuals over time. + chi2_m_list = [] + fnd_list = [] # Number of non-NaN error measurements + + for ii in range(len(tab['me'])): + # Ignore the NaNs + fnd = np.argwhere(~np.isnan(tab['me'][ii,:])) + fnd_list.append(len(fnd)) + + m = tab['m'][ii, fnd] + merr = tab['me'][ii, fnd] + m0 = tab['m0'][ii] + m0err = tab['m0_err'][ii] + + diff_m = m0 - m + sig_m = diff_m/merr + + chi2_m = np.sum(sig_m**2) + chi2_m_list.append(chi2_m) + + chi2_m = np.array(chi2_m_list) + fnd = np.array(fnd_list) + + idx = np.where(fnd == Ndetect)[0] + + # Fitting mean magnitude... so subtract 1 to get Ndof + Ndof = Ndetect - 1 + chi2_maxis = np.linspace(0, xlim, xlim*3) + chi2_bins = np.linspace(0, xlim, n_bins) + + plt.figure(figsize=(6, 4)) + plt.clf() + plt.hist(chi2_m[idx], bins=np.arange(xlim*10), label='mag', histtype='stepfilled', density=True, color='green', alpha=0.7, edgecolor='k') + plt.plot(chi2_maxis, chi2.pdf(chi2_maxis, Ndof), 'r-', alpha=0.6, + label=r'$\chi^2$ ' + str(Ndof) + ' dof') + #plt.title('$N_{epoch} = $' + str(Ndetect) + ', $N_{dof} = $' + str(Ndof)) + plt.xlim(0, xlim) + plt.xlabel(r'$\chi^{2}$', fontsize=28) + plt.ylabel(r'PDF', fontsize=28) + plt.legend(fontsize=20) + plt.tick_params(labelsize=20, direction='in', right=True, top=True) + plt.tight_layout() + plt.savefig(str(filter)+'_chi2_dist_mag.png', dpi=300) + plt.close() + + print('Mean reduced chi^2: (Ndetect = {0:d} of {1:d})'.format(len(idx), len(tab))) + fmt = ' {0:s} = {1:.1f} for N_detect and {2:.1f} for all' + print(fmt.format('M', np.median(chi2_m[idx] / (fnd[idx] - 2)), np.median(chi2_m / (fnd - 2)))) + + return + +def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), color_time=False, boot_err=False): + """ + Plot a set of stars positions, flux and residuals over time. epoch_array : None, array Array of the epoch indicies to plot. If None, plots all epochs. """ + + def rs(x): + return x.reshape(len(x)) + print( 'Creating residuals plots for star(s):' ) print( star_names ) - + Nstars = len(star_names) Ncols = 3 * np.min([Nstars, NcolMax]) if Nstars <= Ncols/3: @@ -2379,10 +2819,17 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), x = tab['x0'] y = tab['y0'] r = np.hypot(x, y) - + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] + cont_times = np.arange(np.min(tab['t'][i_all_detected]), np.max(tab['t'][i_all_detected]), 0.01) + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + # xt_cont_all, yt_cont_all, xt_cont_err, yt_cont_err = tab.get_star_positions_at_time(cont_times, motion_model_dict, allow_alt_models=True) + xt_cont_all, yt_cont_all, xt_cont_err, yt_cont_err = tab.infer_positions(cont_times) + for i in range(Nstars): starName = star_names[i] - + try: ii = np.where(tab['name'] == starName)[0][0] except IndexError: @@ -2397,24 +2844,30 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), fnd = fnd.reshape(len(fnd),1) time = tab['t'][ii, fnd] - dtime = time.data % 1 + dtime = time.data % 1 x = tab['x'][ii, fnd] y = tab['y'][ii, fnd] m = tab['m'][ii, fnd] - xerr = tab['xe'][ii, fnd] - yerr = tab['ye'][ii, fnd] - merr = tab['me'][ii, fnd] + if boot_err: + xerr = np.hypot(tab['xe'][ii, fnd], tab['xe_boot'][ii, fnd]) + yerr = np.hypot(tab['ye'][ii, fnd], tab['ye_boot'][ii, fnd]) + merr = np.hypot(tab['me'][ii, fnd], tab['me_boot'][ii, fnd]) + else: + xerr = tab['xe'][ii, fnd] + yerr = tab['ye'][ii, fnd] + merr = tab['me'][ii, fnd] dt = tab['t'][ii, fnd] - tab['t0'][ii] - fitLineX = tab['x0'][ii] + (tab['vx'][ii] * dt) - fitLineY = tab['y0'][ii] + (tab['vy'][ii] * dt) - fitSigX = np.hypot(tab['x0e'][ii], tab['vxe'][ii]*dt) - fitSigY = np.hypot(tab['y0e'][ii], tab['vye'][ii]*dt) + fitLineX = xt_mod_all[ii, fnd] + fitLineY = yt_mod_all[ii, fnd] + + fitSigX = xt_mod_err[ii, fnd] + fitSigY = yt_mod_err[ii, fnd] fitLineM = np.repeat(tab['m0'][ii], len(dt)).reshape(len(dt),1) - fitSigM = np.repeat(tab['m0e'][ii], len(dt)).reshape(len(dt),1) + fitSigM = np.repeat(tab['m0_err'][ii], len(dt)).reshape(len(dt),1) diffX = x - fitLineX diffY = y - fitLineY @@ -2437,21 +2890,23 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), chi2_y = np.sum(sigY**2) chi2_m = np.sum(sigM**2) - dof = len(x) - 2 + dof = (len(tab['x'][ii])-tab['n_params'][ii]).astype(int) dofM = len(m) - 1 chi2_red_x = chi2_x / dof chi2_red_y = chi2_y / dof chi2_red_m = chi2_m / dofM - + print( 'Star: ', starName ) - print( '\tX Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tX Chi^2 = %5.2f (%6.2f for %2d dof)' % (chi2_red_x, chi2_x, dof)) - print( '\tY Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tY Chi^2 = %5.2f (%6.2f for %2d dof)' % (chi2_red_y, chi2_y, dof)) - print( '\tM Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tM Chi^2 = %5.2f (%6.2f for %2d dof)' % (chi2_red_m, chi2_m, dofM)) + if 'motion_model_used' in tab.keys(): + print('\tMotion model:', tab['motion_model_used'][ii]) tmin = time.min() tmax = time.max() @@ -2483,7 +2938,6 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), resTicRng = [-1.1*maxErr, 1.1*maxErr] resTicRngM = [-1.1*maxErrM, 1.1*maxErrM] - from matplotlib.ticker import FormatStrFormatter fmtX = FormatStrFormatter('%5i') fmtY = FormatStrFormatter('%6.3f') fmtM = FormatStrFormatter('%5.2f') @@ -2497,18 +2951,23 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), row = 1 else: col = 1 + 3*(i % (Ncols/3)) - row = 1 + 3*(i//(Ncols/3)) + row = 1 + 3*(i//(Ncols/3)) ind = int((row-1)*Ncols + col) paxes = plt.subplot(Nrows, Ncols, ind) - plt.plot(time, fitLineX, 'b-') - plt.plot(time, fitLineX + fitSigX, 'b--') - plt.plot(time, fitLineX - fitSigX, 'b--') + plt.plot(cont_times, xt_cont_all[ii], 'b-') + plt.plot(cont_times, xt_cont_all[ii] + xt_cont_err[ii], 'b--') + plt.plot(cont_times, xt_cont_all[ii] - xt_cont_err[ii], 'b--') if not color_time: - plt.errorbar(time, x, yerr=xerr.reshape(len(xerr),), fmt='k.') + #print('x:',x) + #print('xerr:',xerr) + #print('xerr_reshaped:', xerr.reshape(len(xerr),)) + #plt.errorbar(time, x, yerr=xerr.reshape(len(xerr)), fmt='k.') + plt.errorbar(rs(time), rs(x), yerr=rs(xerr), fmt='k.') + #plt.errorbar(time, x, yerr=xerr, fmt='k.') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, x, xerr, time_color): @@ -2534,13 +2993,13 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), ind = int((row-1)*Ncols + col) paxes = plt.subplot(Nrows, Ncols, ind) - plt.plot(time, fitLineY, 'b-') - plt.plot(time, fitLineY + fitSigY, 'b--') - plt.plot(time, fitLineY - fitSigY, 'b--') + plt.plot(cont_times, yt_cont_all[ii], 'b-') + plt.plot(cont_times, yt_cont_all[ii] + yt_cont_err[ii], 'b--') + plt.plot(cont_times, yt_cont_all[ii] - yt_cont_err[ii], 'b--') if not color_time: - plt.errorbar(time, y, yerr=yerr.reshape(len(yerr),), fmt='k.') + plt.errorbar(rs(time), rs(y), yerr=rs(yerr), fmt='k.') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, y, yerr, time_color): @@ -2568,9 +3027,9 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), plt.plot(time, fitLineM + fitSigM, 'g--') plt.plot(time, fitLineM - fitSigM, 'g--') if not color_time: - plt.errorbar(time, m, yerr=merr.reshape(len(merr),), fmt='k.') + plt.errorbar(rs(time), rs(m), yerr=rs(merr), fmt='k.') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, m, merr, time_color): @@ -2586,7 +3045,7 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), paxes.xaxis.set_major_formatter(fmtX) paxes.yaxis.set_major_formatter(fmtM) paxes.tick_params(axis='both', which='major', labelsize=12) - + ########## # X residuals vs time @@ -2597,12 +3056,12 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), paxes = plt.subplot(Nrows, Ncols, ind) plt.plot(time, np.zeros(len(time)), 'b-') - plt.plot(time, fitSigX*1e3, 'b--') - plt.plot(time, -fitSigX*1e3, 'b--') + plt.plot(cont_times, xt_cont_err[ii]*1e3, 'b--') + plt.plot(cont_times, -xt_cont_err[ii]*1e3, 'b--') if not color_time: - plt.errorbar(time, (x - fitLineX)*1e3, yerr=xerr.reshape(len(xerr),)*1e3, fmt='k.') + plt.errorbar(rs(time), rs(x - fitLineX)*1e3, yerr=rs(xerr)*1e3, fmt='k.') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, (x - fitLineX)*1e3, xerr*1e3, time_color): @@ -2625,12 +3084,12 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), paxes = plt.subplot(Nrows, Ncols, ind) plt.plot(time, np.zeros(len(time)), 'b-') - plt.plot(time, fitSigY*1e3, 'b--') - plt.plot(time, -fitSigY*1e3, 'b--') + plt.plot(cont_times, yt_cont_err[ii]*1e3, 'b--') + plt.plot(cont_times, -yt_cont_err[ii]*1e3, 'b--') if not color_time: - plt.errorbar(time, (y - fitLineY)*1e3, yerr=yerr.reshape(len(yerr),)*1e3, fmt='k.') + plt.errorbar(rs(time), rs(y - fitLineY)*1e3, yerr=rs(yerr)*1e3, fmt='k.') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, (y - fitLineY)*1e3, yerr*1e3, time_color): @@ -2656,9 +3115,9 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), plt.plot(time, fitSigM*1e3, 'g--') plt.plot(time, -fitSigM*1e3, 'g--') if not color_time: - plt.errorbar(time, (m - fitLineM), yerr=merr.reshape(len(merr),), fmt='k.') + plt.errorbar(rs(time), rs(m - fitLineM), yerr=rs(merr), fmt='k.') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, (m - fitLineM), merr, time_color): @@ -2683,13 +3142,13 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), paxes = plt.subplot(Nrows, Ncols, ind) if not color_time: - plt.errorbar(x,y, xerr=xerr.reshape(len(xerr),), - yerr=yerr.reshape(len(yerr),), fmt='k.') + plt.errorbar(rs(x),rs(y), xerr=rs(xerr), + yerr=rs(yerr), fmt='k.') else: sc = plt.scatter(x, y, s=0, c=dtime, vmin=0, vmax=1, cmap='hsv') clb = plt.colorbar(sc) clb.ax.tick_params(labelsize=fontsize1) - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, eexx, eeyy, color in zip(x, y, xerr, yerr, time_color): @@ -2701,7 +3160,7 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), paxes.xaxis.set_major_formatter(FormatStrFormatter('%.3f')) plt.xlabel('X (asec)', fontsize=fontsize1) plt.ylabel('Y (asec)', fontsize=fontsize1) - plt.plot(fitLineX, fitLineY, 'b-') + plt.plot(xt_cont_all[ii], yt_cont_all[ii], 'b-') ########## # X, Y Histogram of Residuals @@ -2712,7 +3171,7 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), bins = np.arange(-7.5, 7.5, 1) paxes = plt.subplot(Nrows, Ncols, ind) id = np.where(diffY < 0)[0] - sig[id] = -1.*sig[id] + sig[id] = -1.*sig[id] (n, b, p) = plt.hist(sigX, bins, histtype='stepfilled', color='b', label='X') plt.setp(p, 'facecolor', 'b') (n, b, p) = plt.hist(sigY, bins, histtype='step', color='r', label='Y') @@ -2738,26 +3197,24 @@ def plot_stars(tab, star_names, NcolMax=2, epoch_array = None, figsize=(15,25), plt.xlabel('Residuals (sigma)', fontsize=fontsize1) plt.ylabel('Number of Epochs', fontsize=fontsize1) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - + if Nstars == 1: - plt.subplots_adjust(wspace=0.4, hspace=0.4, left = 0.15, bottom = 0.1, right=0.9, top=0.9) - # plt.savefig(rootDir+'plots/plotStar_' + starName + '.png') + plt.subplots_adjust(wspace=0.4, hspace=0.4, left = 0.15, bottom = 0.1, right=0.9, top=0.9) + # plt.savefig(rootDir+'plots/plotStar_' + starName + '.png', dpi=300) else: plt.subplots_adjust(wspace=0.6, hspace=0.6, left = 0.08, bottom = 0.05, right=0.95, top=0.90) - # plt.savefig(rootDir+'plots/plotStar_all.png') + # plt.savefig(rootDir+'plots/plotStar_all.png', dpi=300) plt.show() plt.show() return - - def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_list = None, - figsize=(15,25), color_time=False, resTicRng=None): + figsize=(15,25), color_time=False, resTicRng=None, save_name=None, boot_err=False): """ - Plot a set of stars positions, flux and residuals over time. + Plot a set of stars positions, flux and residuals over time. epoch_array : None, array Array of the epoch indicies to plot. If None, plots all epochs. @@ -2767,7 +3224,14 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ """ print( 'Creating residuals plots for star(s):' ) print( star_names ) - + def rs(x): + return x.reshape(len(x)) + + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + Nstars = len(star_names) Ncols = 3 * np.min([Nstars, NcolMax]) if Nstars <= Ncols/3: @@ -2782,45 +3246,56 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ x = tab['x0'] y = tab['y0'] r = np.hypot(x, y) - + # motion_model_dict = motion_model.validate_motion_model_dict(motion_model_dict, tab, None) + i_all_detected = np.where(~np.any(np.isnan(tab['t']),axis=1))[0][0] + cont_times = np.arange(np.min(tab['t'][i_all_detected]), np.max(tab['t'][i_all_detected]), 0.01) + # xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.get_star_positions_at_time(tab['t'][i_all_detected], motion_model_dict, allow_alt_models=True) + xt_mod_all, yt_mod_all, xt_mod_err, yt_mod_err = tab.infer_positions(tab['t'][i_all_detected]) + # xt_cont_all, yt_cont_all, xt_cont_err, yt_cont_err = tab.get_star_positions_at_time(cont_times, motion_model_dict, allow_alt_models=True) + xt_cont_all, yt_cont_all, xt_cont_err, yt_cont_err = tab.infer_positions(cont_times) + for i in range(Nstars): for ea, epoch_array in enumerate(epoch_array_list): color=color_list[ea] starName = star_names[i] - + try: ii = np.where(tab['name'] == starName)[0][0] except IndexError: print("!! %s is not in this list"%starName) continue - + # Ignore the NaNs fnd = np.argwhere(~np.isnan(tab['xe'][ii,:])) - + if epoch_array is not None: fnd = np.intersect1d(fnd, epoch_array) fnd = fnd.reshape(len(fnd),1) - + time = tab['t'][ii, fnd] - dtime = time.data % 1 + dtime = time.data % 1 x = tab['x'][ii, fnd] y = tab['y'][ii, fnd] m = tab['m'][ii, fnd] - - xerr = tab['xe'][ii, fnd] - yerr = tab['ye'][ii, fnd] - merr = tab['me'][ii, fnd] - - dt = tab['t'][ii, fnd] - tab['t0'][ii] - fitLineX = tab['x0'][ii] + (tab['vx'][ii] * dt) - fitLineY = tab['y0'][ii] + (tab['vy'][ii] * dt) - - fitSigX = np.hypot(tab['x0e'][ii], tab['vxe'][ii]*dt) - fitSigY = np.hypot(tab['y0e'][ii], tab['vye'][ii]*dt) - - fitLineM = np.repeat(tab['m0'][ii], len(dt)).reshape(len(dt),1) - fitSigM = np.repeat(tab['m0e'][ii], len(dt)).reshape(len(dt),1) - + + if boot_err: + xerr = np.hypot(tab['xe'][ii, fnd], tab['xe_boot'][ii, fnd]) + yerr = np.hypot(tab['ye'][ii, fnd], tab['ye_boot'][ii, fnd]) + merr = np.hypot(tab['me'][ii, fnd], tab['me_boot'][ii, fnd]) + else: + xerr = tab['xe'][ii, fnd] + yerr = tab['ye'][ii, fnd] + merr = tab['me'][ii, fnd] + + fitLineX = xt_mod_all[ii, fnd] + fitLineY = yt_mod_all[ii, fnd] + + fitSigX = xt_mod_err[ii, fnd] + fitSigY = yt_mod_err[ii, fnd] + + fitLineM = np.repeat(tab['m0'][ii], len(time)).reshape(len(time),1) + fitSigM = np.repeat(tab['m0_err'][ii], len(time)).reshape(len(time),1) + diffX = x - fitLineX diffY = y - fitLineY diffM = m - fitLineM @@ -2830,42 +3305,42 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ sigY = diffY / yerr sigM = diffM / merr sig = diff / rerr - + # Determine if there are points that are more than 4 sigma off idxX = np.where(abs(sigX) > 4) idxY = np.where(abs(sigY) > 4) idxM = np.where(abs(sigM) > 4) idx = np.where(abs(sig) > 4) - + # Calculate chi^2 metrics chi2_x = np.sum(sigX**2) chi2_y = np.sum(sigY**2) chi2_m = np.sum(sigM**2) - + dof = len(x) - 2 dofM = len(m) - 1 - + chi2_red_x = chi2_x / dof chi2_red_y = chi2_y / dof chi2_red_m = chi2_m / dofM - - + + print( 'Star: ', starName ) - print( '\tX Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tX Chi^2 = %5.2f (%6.2f for %2d dof)' % (chi2_red_x, chi2_x, dof)) - print( '\tY Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tY Chi^2 = %5.2f (%6.2f for %2d dof)' % (chi2_red_y, chi2_y, dof)) - print( '\tM Chi^2 = %5.2f (%6.2f for %2d dof)' % + print( '\tM Chi^2 = %5.2f (%6.2f for %2d dof)' % (chi2_red_m, chi2_m, dofM)) - + tmin = time.min() tmax = time.max() - + dateTicLoc = plt.MultipleLocator(3) dateTicRng = [np.floor(tmin), np.ceil(tmax)] dateTics = np.arange(np.floor(tmin), np.ceil(tmax)+0.1) DateTicsLabel = dateTics - + # See if we are using MJD instead. if time[0] > 50000: print('MJD') @@ -2875,12 +3350,12 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ dateTicRng = [tmin-200, tmax+200] dateTics = np.arange(dateTicRng[0], dateTicRng[-1]+500, 1000) DateTicsLabel = dateTics - - + + maxErr = np.array([(diffX-xerr)*1e3, (diffX+xerr)*1e3, (diffY-yerr)*1e3, (diffY+yerr)*1e3]).max() maxErrM = np.array([(diffM - merr), (diffM + merr)]).max() - + if maxErr > 2: maxErr = 2.0 if maxErrM > 1.0: @@ -2888,13 +3363,12 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ if resTicRng == None: resTicRng = [-1.1*maxErr, 1.1*maxErr] resTicRngM = [-1.1*maxErrM, 1.1*maxErrM] - - from matplotlib.ticker import FormatStrFormatter + fmtX = FormatStrFormatter('%5i') fmtY = FormatStrFormatter('%6.3f') fmtM = FormatStrFormatter('%5.2f') fontsize1 = 10 - + ########## # X vs time ########## @@ -2903,18 +3377,19 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ row = 1 else: col = 1 + 3*(i % (Ncols/3)) - row = 1 + 3*(i//(Ncols/3)) - + row = 1 + 3*(i//(Ncols/3)) + ind = int((row-1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) - plt.plot(time, fitLineX, 'b-') - plt.plot(time, fitLineX + fitSigX, 'b--') - plt.plot(time, fitLineX - fitSigX, 'b--') + plt.plot(cont_times, xt_cont_all[ii], 'b-') + plt.plot(cont_times, xt_cont_all[ii] + xt_cont_err[ii], 'b--') + plt.plot(cont_times, xt_cont_all[ii] - xt_cont_err[ii], 'b--') + print(np.shape(xerr.reshape(len(xerr),))) if not color_time: - plt.errorbar(time, x, yerr=xerr.reshape(len(xerr),), marker='.', color=color, ls='none') + plt.errorbar(rs(time), rs(x), yerr=rs(xerr), marker='.', color=color, ls='none') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, x, xerr, time_color): @@ -2931,22 +3406,22 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ paxes.yaxis.set_major_formatter(fmtY) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) plt.annotate(starName, xy=(1.0,1.1), xycoords='axes fraction', fontsize=12, color='red') - - + + ########## # Y vs time ########## col = col + 1 ind = int((row-1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) - plt.plot(time, fitLineY, 'b-') - plt.plot(time, fitLineY + fitSigY, 'b--') - plt.plot(time, fitLineY - fitSigY, 'b--') + plt.plot(cont_times, yt_cont_all[ii], 'b-') + plt.plot(cont_times, yt_cont_all[ii] + yt_cont_err[ii], 'b--') + plt.plot(cont_times, yt_cont_all[ii] - yt_cont_err[ii], 'b--') if not color_time: - plt.errorbar(time, y, yerr=yerr.reshape(len(yerr),), marker='.', color=color, ls='none') + plt.errorbar(rs(time), rs(y), yerr=rs(yerr), marker='.', color=color, ls='none') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, y, yerr, time_color): @@ -2962,21 +3437,21 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ paxes.xaxis.set_major_formatter(fmtX) paxes.yaxis.set_major_formatter(fmtY) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - + ########## # M vs time ########## col = col + 1 ind = int((row - 1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) plt.plot(time, fitLineM, 'g-') plt.plot(time, fitLineM + fitSigM, 'g--') plt.plot(time, fitLineM - fitSigM, 'g--') if not color_time: - plt.errorbar(time, m, yerr=merr.reshape(len(merr),), marker='.', color=color, ls='none') + plt.errorbar(rs(time), rs(m), yerr=rs(merr), marker='.', color=color, ls='none') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, m, merr, time_color): @@ -2992,23 +3467,23 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ paxes.xaxis.set_major_formatter(fmtX) paxes.yaxis.set_major_formatter(fmtM) paxes.tick_params(axis='both', which='major', labelsize=12) - - + + ########## # X residuals vs time ########## row = row + 1 col = col - 2 ind = int((row-1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) plt.plot(time, np.zeros(len(time)), 'b-') - plt.plot(time, fitSigX*1e3, 'b--') - plt.plot(time, -fitSigX*1e3, 'b--') + plt.plot(cont_times, xt_cont_err[ii]*1e3, 'b--') + plt.plot(cont_times, -xt_cont_err[ii]*1e3, 'b--') if not color_time: - plt.errorbar(time, (x - fitLineX)*1e3, yerr=xerr.reshape(len(xerr),)*1e3, marker='.', color=color, ls='none') + plt.errorbar(rs(time), rs(x - fitLineX)*1e3, yerr=rs(xerr)*1e3, marker='.', color=color, ls='none') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, (x - fitLineX)*1e3, xerr*1e3, time_color): @@ -3022,21 +3497,21 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ plt.ylabel('X Residuals (mas)', fontsize=fontsize1) paxes.xaxis.set_major_formatter(fmtX) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - + ########## # Y residuals vs time ########## col = col + 1 ind = int((row-1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) plt.plot(time, np.zeros(len(time)), 'b-') - plt.plot(time, fitSigY*1e3, 'b--') - plt.plot(time, -fitSigY*1e3, 'b--') + plt.plot(cont_times, yt_cont_err[ii]*1e3, 'b--') + plt.plot(cont_times, -yt_cont_err[ii]*1e3, 'b--') if not color_time: - plt.errorbar(time, (y - fitLineY)*1e3, yerr=yerr.reshape(len(yerr),)*1e3, marker='.', color=color, ls='none') + plt.errorbar(rs(time), rs(y - fitLineY)*1e3, yerr=rs(yerr)*1e3, marker='.', color=color, ls='none') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, (y - fitLineY)*1e3, yerr*1e3, time_color): @@ -3050,21 +3525,21 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ plt.ylabel('Y Residuals (mas)', fontsize=fontsize1) paxes.xaxis.set_major_formatter(fmtX) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - + ########## # M residuals vs time ########## col = col + 1 ind = int((row-1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) plt.plot(time, np.zeros(len(time)), 'g-') plt.plot(time, fitSigM*1e3, 'g--') plt.plot(time, -fitSigM*1e3, 'g--') if not color_time: - plt.errorbar(time, (m - fitLineM), yerr=merr.reshape(len(merr),), marker='.', color=color, ls='none') + plt.errorbar(rs(time), rs(m - fitLineM), yerr=rs(merr), marker='.', color=color, ls='none') else: - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, ee, color in zip(time, (m - fitLineM), merr, time_color): @@ -3078,24 +3553,24 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ plt.ylabel('m Residuals (mag)', fontsize=fontsize1) paxes.xaxis.set_major_formatter(fmtX) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - - + + ########## # X vs. Y ########## row = row + 1 col = col - 2 ind = int((row-1)*Ncols + col) - + paxes = plt.subplot(Nrows, Ncols, ind) if not color_time: - plt.errorbar(x,y, xerr=xerr.reshape(len(xerr),), - yerr=yerr.reshape(len(yerr),), marker='.', color=color, ls='none') + plt.errorbar(rs(x),rs(y), xerr=rs(xerr), + yerr=rs(yerr), marker='.', color=color, ls='none') else: sc = plt.scatter(x, y, s=0, c=dtime, vmin=0, vmax=1, cmap='hsv') clb = plt.colorbar(sc) clb.ax.tick_params(labelsize=fontsize1) - norm = colors.Normalize(vmin=0, vmax=1, clip=True) + norm = mcolors.Normalize(vmin=0, vmax=1, clip=True) mapper = cm.ScalarMappable(norm=norm, cmap='hsv') time_color = np.array([(mapper.to_rgba(v)) for v in dtime]) for xx, yy, eexx, eeyy, color in zip(x, y, xerr, yerr, time_color): @@ -3107,18 +3582,18 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ paxes.xaxis.set_major_formatter(FormatStrFormatter('%.3f')) plt.xlabel('X (asec)', fontsize=fontsize1) plt.ylabel('Y (asec)', fontsize=fontsize1) - plt.plot(fitLineX, fitLineY, 'b-') - + plt.plot(fitLineX, fitLineY, 'b-') + ########## # X, Y Histogram of Residuals ########## col = col + 1 ind = int((row-1)*Ncols + col) - + bins = np.arange(-7.5, 7.5, 1) paxes = plt.subplot(Nrows, Ncols, ind) id = np.where(diffY < 0)[0] - sig[id] = -1.*sig[id] + sig[id] = -1.*sig[id] (n, b, p) = plt.hist(sigX, bins, histtype='stepfilled', color='b', label='X') plt.setp(p, 'facecolor', 'b') (n, b, p) = plt.hist(sigY, bins, histtype='step', color='r', label='Y') @@ -3128,13 +3603,13 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ plt.xlabel('Residuals (sigma)', fontsize=fontsize1) plt.ylabel('Number of Epochs', fontsize=fontsize1) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - + ########## # M Histogram of Residuals ########## col = col + 1 ind = int((row-1)*Ncols + col) - + bins = np.arange(-7.5, 7.5, 1) paxes = plt.subplot(Nrows, Ncols, ind) (n, b, p) = plt.hist(sigM, bins, histtype='stepfilled', color='g', label='m') @@ -3144,16 +3619,17 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ plt.xlabel('Residuals (sigma)', fontsize=fontsize1) plt.ylabel('Number of Epochs', fontsize=fontsize1) paxes.tick_params(axis='both', which='major', labelsize=fontsize1) - + if Nstars == 1: - plt.subplots_adjust(wspace=0.4, hspace=0.4, left = 0.15, bottom = 0.1, right=0.9, top=0.9) - # plt.savefig(rootDir+'plots/plotStar_' + starName + '.png') + plt.subplots_adjust(wspace=0.4, hspace=0.4, left = 0.15, bottom = 0.1, right=0.9, top=0.9) + # plt.savefig(rootDir+'plots/plotStar_' + starName + '.png', dpi=300) else: plt.subplots_adjust(wspace=0.6, hspace=0.6, left = 0.08, bottom = 0.05, right=0.95, top=0.90) - # plt.savefig(rootDir+'plots/plotStar_all.png') + # plt.savefig(rootDir+'plots/plotStar_all.png', dpi=300) plt.show() - + if save_name is not None: + plt.savefig(save_name + '.png', dpi=300) plt.show() return @@ -3161,33 +3637,48 @@ def plot_stars_nfilt(tab, star_names, NcolMax=2, epoch_array_list = None, color_ def plot_errors_vs_r_m(star_tab, vmax_perr=0.75, vmax_pmerr=0.75): """ - Plot the positional errors and the proper motion errors as a function of radius - and magnitude. The positional an proper motion errors will be the mean in the - two axis (as is used in pick_good_ref_stars()). + Plot the positional errors and the proper motion errors as a function of radius + and magnitude. The positional an proper motion errors will be the mean in the + two axis (as is used in pick_good_ref_stars()). """ r = np.hypot(star_tab['x0'], star_tab['y0']) - p_err = np.mean((star_tab['x0e'], star_tab['y0e']), axis=0) * 1e3 - pm_err = np.mean((star_tab['vxe'], star_tab['vye']), axis=0) * 1e3 + p_err = np.mean((star_tab['x0_err'], star_tab['y0_err']), axis=0) * 1e3 + pm_err = np.mean((star_tab['vx_err'], star_tab['vy_err']), axis=0) * 1e3 plt.figure(figsize=(12, 6)) plt.clf() plt.subplots_adjust(wspace=0.4) - + plt.subplot(1, 2, 1) plt.scatter(star_tab['m0'], r, c=p_err, s=8, vmin=0, vmax=vmax_perr) plt.colorbar(label='Pos Err (mas)') plt.xlabel('Mag') - plt.ylabel('Radius (")') + plt.ylabel('Radius (")') plt.subplot(1, 2, 2) plt.scatter(star_tab['m0'], r, c=pm_err, s=8, vmin=0, vmax=vmax_pmerr) plt.colorbar(label='PM Err (mas/yr)') plt.xlabel('Mag') plt.ylabel('Radius (")') + plt.tight_layout() + plt.show() return - - + +def plot_plxs(star_tab, target_idx=0): + fig,ax = plt.subplots(nrows=1,ncols=2,figsize=(10,5)) + ax[0].errorbar(star_tab['m0'],star_tab['pi']*1e3, yerr=star_tab['pi_err']*1e3,marker='.',linestyle='none') + if target_idx is not None: + ax[0].errorbar(star_tab['m0'][target_idx],star_tab['pi'][target_idx]*1e3, yerr=star_tab['pi_err'][target_idx]*1e3,marker='*',linestyle='none', color='orange', markersize=10) + ax[0].axhline(0, c='gray') + ax[0].set_ylabel('Plx (mas)') + ax[0].set_xlabel('Mag') + ax[1].hist(star_tab['pi']/star_tab['pi_err'], bins=range(-10,10)) + ax[1].set_ylabel('N stars') + ax[1].set_xlabel('Plx/Plx_err') + plt.tight_layout() + ax[0].set_ylim(-5,5) + def plot_sky(stars_tab, plot_errors=False, center_star=None, range=0.4, xcenter=0, ycenter=0, show_names=False, saveplot=False, @@ -3201,8 +3692,8 @@ def plot_sky(stars_tab, Parameters ---------- stars_tab : flystar.startables.StarTable - The StarTable containining 'x', 'y', 't', 'xe', 'ye', columns etc. - for plotting, where each of these columns is a 2D array of + The StarTable containining 'x', 'y', 't', 'xe', 'ye', columns etc. + for plotting, where each of these columns is a 2D array of [star_index, epoch_index]. @@ -3247,11 +3738,11 @@ def plot_sky(stars_tab, good_t = np.isfinite(stars_tab['t']) epochs = np.unique(stars_tab['t'][good_t]) assert len(epochs) == stars_tab['t'].shape[1] - + yearsInt = np.floor(epochs).astype('int') # Set up a color scheme - cnorm = colors.Normalize(stars_tab['t'][0, :].min(), stars_tab['t'][0, :].max() + 1) + cnorm = mcolors.Normalize(stars_tab['t'][0, :].min(), stars_tab['t'][0, :].max() + 1) cmap = plt.cm.gist_ncar colorList = [] @@ -3259,8 +3750,8 @@ def plot_sky(stars_tab, foo = cnorm(yearsInt[ee]) colorList.append( cmap(cnorm(yearsInt[ee])) ) - py.close(2) - fig = py.figure(2, figsize=(13,10)) + plt.close(2) + fig = plt.figure(2, figsize=(13,10)) previousYear = 0.0 @@ -3298,13 +3789,13 @@ def plot_sky(stars_tab, label = '_nolegend_' if plot_errors: - (line, foo1, foo2) = py.errorbar(x, y, xerr=xe, yerr=ye, + (line, foo1, foo2) = plt.errorbar(x, y, xerr=xe, yerr=ye, color=colorList[ee], fmt='^', markeredgecolor=colorList[ee], markerfacecolor=colorList[ee], label=label, picker=4) else: - (line, foo1, foo2) = py.errorbar(x, y, xerr=None, yerr=None, + (line, foo1, foo2) = plt.errorbar(x, y, xerr=None, yerr=None, color=colorList[ee], fmt='^', markeredgecolor=colorList[ee], markerfacecolor=colorList[ee], @@ -3322,19 +3813,19 @@ def plot_sky(stars_tab, point_labels[line] = points_info foo = PrintSelected(point_labels, fig, stars_tab, mag_range, manual_print=manual_print) - py.connect('pick_event', foo) + plt.connect('pick_event', foo) xlo = xcenter + (range) xhi = xcenter - (range) ylo = ycenter - (range) yhi = ycenter + (range) - py.axis('equal') - py.axis([xlo, xhi, ylo, yhi]) - py.xlabel('R.A. Offset from Sgr A* (arcsec)') - py.ylabel('Dec. Offset from Sgr A* (arcsec)') + plt.axis('equal') + plt.axis([xlo, xhi, ylo, yhi]) + plt.xlabel('R.A. Offset from Sgr A* (arcsec)') + plt.ylabel('Dec. Offset from Sgr A* (arcsec)') - py.legend(handles=epochs_legend, numpoints=1, loc='lower left', fontsize=12) + plt.legend(handles=epochs_legend, numpoints=1, loc='lower left', fontsize=12) if show_names: xpos = stars_tab['x0'] @@ -3342,20 +3833,20 @@ def plot_sky(stars_tab, goodind = np.where((xpos <= xlo) & (xpos >= xhi) & (ypos >= ylo) & (ypos <= yhi))[0] for ind in goodind: - py.text(xpos[ind], ypos[ind], stars_tab['name'][ind], size=10) + plt.text(xpos[ind], ypos[ind], stars_tab['name'][ind], size=10) if saveplot: - py.show(block=0) + plt.show(block=0) if (center_star != None): - py.savefig('plot_sky_' + center_star + '.png') + plt.savefig('plot_sky_' + center_star + '.png', dpi=300) else: - py.savefig('plot_sky.png') + plt.savefig('plot_sky.png', dpi=300) else: - py.show() + plt.show() return - - + + class PrintSelected(object): def __init__(self, points_info, fig, tab, mag_range, manual_print=False): self.points_info = points_info @@ -3423,3 +3914,103 @@ def __call__(self, event): self.fig.canvas.draw() return + + +def plotly_stars(x, y, m=None, star_name=None, marker_size=3, color=None, alpha=0.7, symbol='circle', label=None, xlabel='x', ylabel='y', fig=None, figsize=(700, 700), show=None): + """Plot stars with plotly in interactive html format + + Parameters + ---------- + x : array-like + x positions + y : array-like + y positions + m : array-like, optional + magnitude to be added in hover label, by default None + star_name : array-like, optional + Star names to be added in hover label, by default None + marker_size : int, optional + Size of marker, by default 10 + color : array or str, optional + Color of marker, either a string (e.g., 'red') or rgba array, by default None + alpha : float, optional + Opacity of marker color, by default 0.7 + symbol : str, optional + Marker symbol, by default 'circle' + label : str, optional + Label for the star list, by default None + xlabel : str, optional + Label for the x-axis, by default 'x' + ylabel : str, optional + Label for the y-axis, by default 'y' + fig : plotly.graph_objects.Figure object, optional + Figure if the stars are to be added to an exisiting plot, by default None + figsize : tuple, optional + Figure size, by default (700, 700) + show : bool, optional + Show figure or not. By default: True if fig is None, False if fig is not None, by default None + + Returns + ------- + fig : plotly.graph_objects.Figure + Figure object + """ + import plotly.graph_objects as go + x = np.asarray(x) + y = np.asarray(y) + hover_template = 'x: %{x:.3f}
y: %{y:.3f}' + + if isinstance(color, str) and color.startswith('C') and color[1:].isdigit(): + color = mcolors.to_rgba(color, alpha=alpha) + color = f'rgba({color[0]*255}, {color[1]*255}, {color[2]*255}, {color[3]:.2f})' + + customdata = [] + + if star_name is not None: + hover_template = 'name: %{customdata[0]}
' + hover_template + customdata.append(star_name) + + if label is not None: + hover_template = f'{label}
' + hover_template + + if m is not None: + m = np.asarray(m) + m_idx = len(customdata) + hover_template += f'
m: %{{customdata[{m_idx}]:.2f}}' + customdata.append(m) + + if customdata: + customdata = np.column_stack(customdata) + hover_template += '' + + fig_data = go.Scattergl( + x=x, + y=y, + mode='markers', + marker=dict( + size=marker_size, + color=color, + symbol=symbol + ), + customdata=customdata, + hovertemplate=hover_template, + name=label + ) + + if fig is None: + fig = go.Figure(data=[fig_data]) + show = True if show is None else show + else: + fig.add_trace(fig_data) + show = False if show is None else show + + fig.update_layout( + xaxis_title=xlabel, + yaxis_title=ylabel, + xaxis=dict(scaleanchor='y', scaleratio=1), # Ensure equal aspect ratio + width=figsize[0], + height=figsize[1] + ) + if show: + fig.show() + return fig \ No newline at end of file diff --git a/flystar/starlists.py b/flystar/starlists.py index be49458..c6e92d0 100644 --- a/flystar/starlists.py +++ b/flystar/starlists.py @@ -31,7 +31,7 @@ def restrict_by_name(table1, table2): name1 = table1['name'] name2 = table2['name'] - + Name = np.intersect1d(name1, name2) # trim out stars begin with 'star' idx = [] @@ -67,7 +67,7 @@ def restrict_by_area(table1, area, exclude=False): exclude: boolean (default=False) If true, *exclude* the stars that fall within the given area. If false, then only return stars that fall within the given area - + Output: ------ array of indicies corresponding to stars which are within the designated @@ -76,7 +76,7 @@ def restrict_by_area(table1, area, exclude=False): # Extract star coordinates xpos = table1['x'] ypos = table1['y'] - + # Extract desired coordinate ranges x_range = area[0] y_range = area[1] @@ -89,7 +89,7 @@ def restrict_by_area(table1, area, exclude=False): else: good = np.where( ( (xpos < x_range[0]) | (xpos > x_range[1]) ) & ( (ypos < y_range[0]) | (ypos > y_range[1]) ) ) - + return good[0] def restrict_by_use(label_mat, starlist_mat, idx_label, idx_starlist): @@ -114,7 +114,7 @@ def restrict_by_use(label_mat, starlist_mat, idx_label, idx_starlist): idx_starlist: array of indicies Indicies of the matched stars in the starlist. - + Output: ------- idx_label_f: array of indicies in the label catalog that fulfill the restrict @@ -122,15 +122,15 @@ def restrict_by_use(label_mat, starlist_mat, idx_label, idx_starlist): idx_starlist_f: array of indicies in the starlist that fulfill the restrict condition - - + + label_trim: astropy table label table with only use > 2 stars starlist_trim: astropy table reference table with only stars that correspond to use > 2 stars in the label_mat table. - + """ print( 'Restrict option activated') @@ -151,7 +151,7 @@ def restrict_by_use(label_mat, starlist_mat, idx_label, idx_starlist): print( 'Restrict option activated') print(( 'Keeping {0} of {1} stars'.format(len(idx_restrict), len(label_mat)))) - + return idx_label_f, idx_starlist_f @@ -188,7 +188,7 @@ def read_label(labelFile, prop_to_time=None, flipX=True): If true, multiply the x positions and velocities by -1.0. This is useful when label.dat has +x to the east, while reference starlist has +x to the west. - + #OLD# tref: reference epoch that label.dat is converted to. Output: @@ -196,11 +196,11 @@ def read_label(labelFile, prop_to_time=None, flipX=True): labelFile: astropy.table. containing name, m, x0, y0, x0e, y0e, vx, vy, vxe, vye, t0, use, r0, (if prop_to_time: x, y, xe, ye, t) - + x and y is in arcsec, converted to tref epoch, *(-1) so it increases to west - + vx, vy, vxe, vye is converted to arcsec/yr """ @@ -209,12 +209,12 @@ def read_label(labelFile, prop_to_time=None, flipX=True): t_label.rename_column('col2', 'm') t_label.rename_column('col3', 'x0') t_label.rename_column('col4', 'y0') - t_label.rename_column('col5', 'x0e') - t_label.rename_column('col6', 'y0e') + t_label.rename_column('col5', 'x0_err') + t_label.rename_column('col6', 'y0_err') t_label.rename_column('col7', 'vx') t_label.rename_column('col8', 'vy') - t_label.rename_column('col9', 'vxe') - t_label.rename_column('col10','vye') + t_label.rename_column('col9', 'vx_err') + t_label.rename_column('col10','vy_err') t_label.rename_column('col11','t0') t_label.rename_column('col12','use') t_label.rename_column('col13','r0') @@ -222,23 +222,23 @@ def read_label(labelFile, prop_to_time=None, flipX=True): # Convert velocities from mas/yr to arcsec/year # t_label['vx'] *= 0.001 # t_label['vy'] *= 0.001 -# t_label['vxe'] *= 0.001 -# t_label['vye'] *= 0.001 +# t_label['vx_err'] *= 0.001 +# t_label['vy_err'] *= 0.001 t_label['vx'] = t_label['vx'] * 0.001 t_label['vy'] = t_label['vy'] * 0.001 - t_label['vxe'] = t_label['vxe'] * 0.001 - t_label['vye'] = t_label['vye'] * 0.001 + t_label['vx_err'] = t_label['vx_err'] * 0.001 + t_label['vy_err'] = t_label['vy_err'] * 0.001 # propogate to prop_to_time if prop_to_time is given if prop_to_time != None: x0 = t_label['x0'] - x0e = t_label['x0e'] + x0e = t_label['x0_err'] vx = t_label['vx'] - vxe = t_label['vxe'] + vxe = t_label['vx_err'] y0 = t_label['y0'] - y0e = t_label['y0e'] + y0e = t_label['y0_err'] vy = t_label['vy'] - vye = t_label['vye'] + vye = t_label['vy_err'] t0 = t_label['t0'] t_label['x'] = x0 + vx*(prop_to_time - t0) t_label['y'] = y0 + vy*(prop_to_time - t0) @@ -248,7 +248,7 @@ def read_label(labelFile, prop_to_time=None, flipX=True): t_label['y'].format = '.5f' t_label['xe'].format = '.5f' t_label['ye'].format = '.5f' - + # flip the x axis if flipX is True if flipX == True: t_label['x0'] = t_label['x0'] * (-1.0) @@ -295,7 +295,7 @@ def read_label_accel(labelFile, prop_to_time=None, flipX=True): If true, multiply the x positions and velocities by -1.0. This is useful when label.dat has +x to the east, while reference starlist has +x to the west. - + #OLD# tref: reference epoch that label.dat is converted to. Output: @@ -303,11 +303,11 @@ def read_label_accel(labelFile, prop_to_time=None, flipX=True): labelFile: astropy.table. containing name, m, x0, y0, x0e, y0e, vx, vy, vxe, vye, t0, use, r0, (if prop_to_time: x, y, xe, ye, t) - + x and y is in arcsec, converted to tref epoch, *(-1) so it increases to west - + vx, vy, vxe, vye is converted to arcsec/yr """ @@ -316,12 +316,12 @@ def read_label_accel(labelFile, prop_to_time=None, flipX=True): t_label.rename_column('col2', 'm') t_label.rename_column('col3', 'x0') t_label.rename_column('col4', 'y0') - t_label.rename_column('col5', 'x0e') - t_label.rename_column('col6', 'y0e') + t_label.rename_column('col5', 'x0_err') + t_label.rename_column('col6', 'y0_err') t_label.rename_column('col7', 'vx') t_label.rename_column('col8', 'vy') - t_label.rename_column('col9', 'vxe') - t_label.rename_column('col10','vye') + t_label.rename_column('col9', 'vx_err') + t_label.rename_column('col10','vy_err') t_label.rename_column('col11', 'ax') t_label.rename_column('col12', 'ay') t_label.rename_column('col13', 'axe') @@ -333,12 +333,12 @@ def read_label_accel(labelFile, prop_to_time=None, flipX=True): # Convert velocities from mas/yr to arcsec/year # t_label['vx'] *= 0.001 # t_label['vy'] *= 0.001 -# t_label['vxe'] *= 0.001 -# t_label['vye'] *= 0.001 +# t_label['vx_err'] *= 0.001 +# t_label['vy_err'] *= 0.001 t_label['vx'] = t_label['vx'] * 0.001 t_label['vy'] = t_label['vy'] * 0.001 - t_label['vxe'] = t_label['vxe'] * 0.001 - t_label['vye'] = t_label['vye'] * 0.001 + t_label['vx_err'] = t_label['vx_err'] * 0.001 + t_label['vy_err'] = t_label['vy_err'] * 0.001 t_label['ax'] = t_label['ax'] * 0.001 t_label['ay'] = t_label['ay'] * 0.001 @@ -348,15 +348,15 @@ def read_label_accel(labelFile, prop_to_time=None, flipX=True): # propogate to prop_to_time if prop_to_time is given if prop_to_time != None: x0 = t_label['x0'] - x0e = t_label['x0e'] + x0e = t_label['x0_err'] vx = t_label['vx'] - vxe = t_label['vxe'] + vxe = t_label['vx_err'] ax = t_label['ax'] axe = t_label['axe'] y0 = t_label['y0'] - y0e = t_label['y0e'] + y0e = t_label['y0_err'] vy = t_label['vy'] - vye = t_label['vye'] + vye = t_label['vy_err'] ay = t_label['ay'] aye = t_label['aye'] t0 = t_label['t0'] @@ -411,21 +411,21 @@ def read_starlist(starlistFile, error=True): col7: corr col8: N_frames col9: ? (left as default) - + error: boolean (default=True) If true, assumes starlist has error columns. This significantly changes the order of the columns. - + Output: ------ starlist astropy table. containing: name, m, x, y, xe, ye, t """ - t_ref = Table.read(starlistFile, format='ascii', delimiter='\s') + t_ref = Table.read(starlistFile, format='ascii', delimiter=r'\s') # Check if this already has column names: cols = t_ref.colnames - + if cols[0] != 'col1': t_ref['name'] = t_ref['name'].astype(str) return t_ref @@ -436,7 +436,7 @@ def read_starlist(starlistFile, error=True): t_ref.rename_column(cols[2], 't') t_ref.rename_column(cols[3], 'x') t_ref.rename_column(cols[4], 'y') - + if error==True: t_ref.rename_column(cols[5], 'xe') t_ref.rename_column(cols[6], 'ye') @@ -449,61 +449,56 @@ def read_starlist(starlistFile, error=True): t_ref.rename_column(cols[6], 'corr') t_ref.rename_column(cols[7], 'N_frames') t_ref.rename_column(cols[8], 'flux') - + return t_ref class StarList(Table): - """ - A StarList is an astropy.Table with star catalog from a single image. - - Required table columns (input as keywords): - ------------------------- - name : 1D numpy.array with shape = N_stars - List of names of the stars in the table. + def __init__(self, *args, **kwargs): + """ + A StarList is an astropy.Table with star catalog from a single image. - x : 1D numpy.array with shape = N_stars - Positions of N_stars in the x dimension. + Required table columns (input as keywords): + ------------------------- + name : 1D numpy.array with shape = N_stars + List of names of the stars in the table. - y : 1D numpy.array with shape = N_stars - Positions of N_stars in the y dimension. + x : 1D numpy.array with shape = N_stars + Positions of N_stars in the x dimension. - m : 1D numpy.array with shape = N_stars - Magnitudes of N_stars. + y : 1D numpy.array with shape = N_stars + Positions of N_stars in the y dimension. - Optional table columns (input as keywords): - ------------------------- - xe : 1D numpy.array with shape = N_stars - Position uncertainties of N_stars in the x dimension. + m : 1D numpy.array with shape = N_stars + Magnitudes of N_stars. - ye : 1D numpy.array with shape = N_stars - Position uncertainties of N_stars in the y dimension. + Optional table columns (input as keywords): + ------------------------- + xe : 1D numpy.array with shape = N_stars + Position uncertainties of N_stars in the x dimension. - me : 1D numpy.array with shape = N_stars - Magnitude uncertainties of N_stars. - - corr : 1D numpy.array with shape = N_stars - Fitting correlation of N_stars. + ye : 1D numpy.array with shape = N_stars + Position uncertainties of N_stars in the y dimension. - Optional table meta data - ------------------------- - list_name : str - Name of the starlist. + me : 1D numpy.array with shape = N_stars + Magnitude uncertainties of N_stars. - list_time : int or float - Time/date of the starlist. + corr : 1D numpy.array with shape = N_stars + Fitting correlation of N_stars. + Optional table meta data + ------------------------- + list_name : str + Name of the starlist. - """ - - def __init__(self, *args, **kwargs): - """ + list_time : int or float + Time/date of the starlist. """ # Check if the required arguments are present arg_req = ('name', 'x', 'y', 'm') found_all_required = True - + for arg_test in arg_req: if arg_test not in kwargs: found_all_required = False @@ -526,6 +521,7 @@ def __init__(self, *args, **kwargs): # Check if the type and size of the arguments are correct. # Name checking: type and shape + kwargs['name'] = np.asarray(kwargs['name']) if (not isinstance(kwargs['name'], np.ndarray)) or ( len(kwargs['name']) != n_stars): err_msg = "The '{0:s}' argument has to be a numpy array " @@ -535,6 +531,8 @@ def __init__(self, *args, **kwargs): # Check all the arrays. arg_tab = ('x', 'y', 'm', 'xe', 'ye', 'me', 'corr') + #print(kwargs) + for arg_test in arg_tab: if arg_test in kwargs: if not isinstance(kwargs[arg_test], np.ndarray): @@ -542,8 +540,8 @@ def __init__(self, *args, **kwargs): raise TypeError(err_msg.format(arg_test)) if kwargs[arg_test].shape != (n_stars,): - err_msg = "The '{0:s}' argument has to have shape = ({1:d},)" - raise TypeError(err_msg.format(arg_test, n_stars)) + err_msg = "The '{0:s}' argument has to have shape = ({1:d},), but has shape = {2}" + raise TypeError(err_msg.format(arg_test, n_stars, kwargs[arg_test].shape)) # We have to have special handling of meta-data meta_tab = ('list_time', 'list_name') @@ -581,7 +579,7 @@ def __init__(self, *args, **kwargs): self.add_column(MaskedColumn(data=kwargs[arg], name=arg)) else: self.add_column(Column(data=kwargs[arg], name=arg)) - + return @classmethod @@ -622,7 +620,7 @@ def from_lis_file(cls, filename, error=True, fvu_file=None): ------ starlists.StarList() object (subclass of Astropy Table). """ - t_ref = Table.read(filename, format='ascii', delimiter='\s') + t_ref = Table.read(filename, format='ascii', delimiter=r'\s') # Check if this already has column names: cols = t_ref.colnames @@ -639,7 +637,7 @@ def from_lis_file(cls, filename, error=True, fvu_file=None): t_ref.rename_column(cols[2], 't') t_ref.rename_column(cols[3], 'x') t_ref.rename_column(cols[4], 'y') - + if error==True: t_ref.rename_column(cols[5], 'xe') t_ref.rename_column(cols[6], 'ye') @@ -652,7 +650,7 @@ def from_lis_file(cls, filename, error=True, fvu_file=None): t_ref.rename_column(cols[6], 'corr') t_ref.rename_column(cols[7], 'N_frames') t_ref.rename_column(cols[8], 'flux') - + if ('me' not in cols) and ('snr' in cols) and (error == True): t_ref['me'] = 1.0 / t_ref['snr'] @@ -665,16 +663,16 @@ def from_lis_file(cls, filename, error=True, fvu_file=None): msg = 'Star list and metric list have different lengths.\n' msg += '\t len(stars) = {0:d}\n' msg += '\t len(fvu) = {1:d}\n' - + raise RuntimeError(msg.format(len(t_ref), len(t_fvu))) - - t_ref = astropy.table.hstack([t_ref, t_fvu]) + + t_ref = astropy.table.hstack([t_ref, t_fvu]) return cls.from_table(t_ref) def to_lis_file(self, filename): _out = open(filename, 'w') - + hdr = '{name:13s} {mag:>6s} {year:>8s} ' hdr += '{x:>9s} {y:>9s} {xe:>9s} {ye:>9s} ' hdr += '{snr:>20s} {corr:>6s} {nimg:>8s} {flux:>20s}\n' @@ -682,7 +680,7 @@ def to_lis_file(self, filename): _out.write(hdr.format(name='# name', mag='m', year='t', x='x', y='y', xe='xe', ye='ye', snr='snr', corr='corr', nimg='N_frames', flux='flux')) - + fmt = '{name:13s} {mag:6.3f} {year:8.3f} ' fmt += '{x:9.3f} {y:9.3f} {xe:9.3f} {ye:9.3f} ' @@ -695,10 +693,10 @@ def to_lis_file(self, filename): flux=self['flux'][ss])) _out.close() - + return - - + + @classmethod def from_table(cls, table): """ @@ -707,7 +705,7 @@ def from_table(cls, table): will be added to the new StarList object that is returned. """ starlist = cls(name=table['name'], x=table['x'], y=table['y'], m=table['m'], meta=table.meta) - + for col in table.colnames: if col in ['name', 'x', 'y', 'm']: continue @@ -719,10 +717,10 @@ def from_table(cls, table): def fubar(self): print('This is in StarList') return - + def restrict_by_value(self, **kwargs): """ - Restrict a table to any min/max range of column values. For instance, + Restrict a table to any min/max range of column values. For instance, to restrict to only stars between 10 <= m <= 15, use: starlist.restrict_by_value(m_min=10, m_max=15) @@ -730,31 +728,31 @@ def restrict_by_value(self, **kwargs): where 'm' was the column name. This function acts on self, so the rows are removed - forever. + forever. """ # Loop through all conditions and build up - # an array of indicies of rows to remove. + # an array of indicies of rows to remove. remove_flag = np.zeros(len(self), dtype=bool) - - for kwarg in kwargs: - if kwargs[kwarg] is not None: + + for key, value in kwargs.items(): + if value is not None: # Get the name of the column to act on and # whether the condition is min or max. - kwarg_split = kwarg.split('_') + key_split = key.split('_') + + # Support column names such as x_0. + col = '_'.join(key_split[:-1]) - # Support column names such as x_0. - col = '_'.join(kwarg_split[:-1]) + if key_split[-1] == 'min': + remove_flag = np.logical_or(remove_flag, self[col] <= value) - if kwarg_split[-1] == 'min': - remove_flag = np.logical_or(remove_flag, self[col] <= kwargs[kwarg]) - - if kwarg_split[-1] == 'max': - remove_flag = np.logical_or(remove_flag, self[col] >= kwargs[kwarg]) + if key_split[-1] == 'max': + remove_flag = np.logical_or(remove_flag, self[col] >= value) rem_idx = np.where(remove_flag == True)[0] - + self.remove_rows(rem_idx) - + return def transform_xym(self, trans): @@ -767,7 +765,7 @@ def transform_xym(self, trans): self.transform_xy(trans) self.transform_m(trans) - + return def transform_xy(self, trans): @@ -779,7 +777,7 @@ def transform_xy(self, trans): """ if trans == None: return - + x_T, y_T = trans.evaluate(self['x'], self['y']) self['x'] = x_T self['y'] = y_T @@ -790,7 +788,7 @@ def transform_xy(self, trans): self['ye'] = ye_T return - + def transform_m(self, trans): """ Apply a transformation (instance of flystar.transforms.Transform2D) @@ -800,14 +798,14 @@ def transform_m(self, trans): """ if trans == None: return - + m_T = trans.evaluate_mag(self['m']) self['m'] = m_T if 'me' in self.colnames: me_T = trans.evaluate_magerror(self['m'], self['me']) self['me'] = me_T - + return diff --git a/flystar/startables.py b/flystar/startables.py index 84953a9..9c8ac13 100644 --- a/flystar/startables.py +++ b/flystar/startables.py @@ -1,85 +1,88 @@ -from astropy.table import Table, Column, hstack -from astropy.stats import sigma_clipping -from scipy.optimize import curve_fit -from flystar.fit_velocity import linear_fit, calc_chi2, linear, fit_velocity -from tqdm import tqdm -import numpy as np -import warnings -import collections import pdb import time import copy +import warnings +import collections +import numpy as np +import pandas as pd +from tqdm import tqdm +from multiprocessing import Pool +from astropy.time import Time +from astropy.stats import sigma_clip +from astropy.table import Table, Column, MaskedColumn, hstack +from scipy.optimize import curve_fit +from pandas.api.types import is_string_dtype +from collections.abc import Iterable +from . import motion_model +from .motion_model import Empty, Fixed, Linear class StarTable(Table): - """ - A StarTable is an astropy.Table with stars matched from multiple starlists. + def __init__(self, *args, ref_list=0, **kwargs): + """ + A StarTable is an astropy.Table with stars matched from multiple starlists. - Required table columns (input as keywords): - ------------------------- - name : 1D numpy.array with shape = N_stars - List of unique names for each of the stars in the table. + Required table columns (input as keywords): + ------------------------- + name : 1D numpy.array with shape = N_stars + List of unique names for each of the stars in the table. - x : 2D numpy.array with shape = (N_stars, N_lists) - Positions of N_stars in each of N_lists in the x dimension. + x : 2D numpy.array with shape = (N_stars, N_lists) + Positions of N_stars in each of N_lists in the x dimension. - y : 2D numpy.array with shape = (N_stars, N_lists) - Positions of N_stars in each of N_lists in the y dimension. + y : 2D numpy.array with shape = (N_stars, N_lists) + Positions of N_stars in each of N_lists in the y dimension. - m : 2D numpy.array with shape = (N_stars, N_lists) - Magnitudes of N_stars in each of N_lists. + m : 2D numpy.array with shape = (N_stars, N_lists) + Magnitudes of N_stars in each of N_lists. - Optional table columns (input as keywords): - ------------------------- - xe : 2D numpy.array with shape = (N_stars, N_lists) - Position uncertainties of N_stars in each of N_lists in the x dimension. + Optional table columns (input as keywords): + ------------------------- + motion_model : 1D numpy.array with shape = N_stars + string indicating motion model type for each star - ye : 2D numpy.array with shape = (N_stars, N_lists) - Position uncertainties of N_stars in each of N_lists in the y dimension. + xe : 2D numpy.array with shape = (N_stars, N_lists) + Position uncertainties of N_stars in each of N_lists in the x dimension. - me : 2D numpy.array with shape = (N_stars, N_lists) - Magnitude uncertainties of N_stars in each of N_lists. + ye : 2D numpy.array with shape = (N_stars, N_lists) + Position uncertainties of N_stars in each of N_lists in the y dimension. - ep_name : 2D numpy.array with shape = (N_stars, N_lists) - Names in each epoch for each of N_stars in each of N_lists. This is - useful for tracking purposes. - - corr : 2D numpy.array with shape = (N_stars, N_lists) - Fitting correlation for each of N_stars in each of N_lists. + me : 2D numpy.array with shape = (N_stars, N_lists) + Magnitude uncertainties of N_stars in each of N_lists. - Optional table meta data - ------------------------- - list_names : list of strings - List of names, one for each of the starlists. + ep_name : 2D numpy.array with shape = (N_stars, N_lists) + Names in each epoch for each of N_stars in each of N_lists. This is + useful for tracking purposes. - list_times : list of integers or floats - List of times/dates for each starlist. + corr : 2D numpy.array with shape = (N_stars, N_lists) + Fitting correlation for each of N_stars in each of N_lists. - ref_list : int - Specify which list is the reference list (if any). + Optional table meta data + ------------------------- + list_names : list of strings + List of names, one for each of the starlists. + list_times : list of integers or floats + List of times/dates for each starlist. - Examples - -------------------------- + ref_list : int + Specify which list is the reference list (if any). - t = startables.StarTable(name=name, x=x, y=y, m=m) + Examples + -------------------------- - # Access the data: - print(t) - print(t['name'][0:10]) # print the first 10 star names - print(t['x'][0:10, 0]) # print x from the first epoch/list/column for the first 10 stars - """ - def __init__(self, *args, ref_list=0, **kwargs): - """ + t = startables.StarTable(name=name, x=x, y=y, m=m) + + # Access the data: + print(t) + print(t['name'][0:10]) # print the first 10 star names + print(t['x'][0:10, 0]) # print x from the first epoch/list/column for the first 10 stars """ - + # Check if the required arguments are present arg_req = ('name', 'x', 'y', 'm') - - found_all_required = True - for arg_test in arg_req: - if arg_test not in kwargs: - found_all_required = False + + found_all_required = all(arg in kwargs for arg in arg_req) if not found_all_required: if len(args) > 1: # If there are no arguments, it's because the @@ -102,9 +105,9 @@ def __init__(self, *args, ref_list=0, **kwargs): # Check if the type and size of the arguments are correct. # Name checking: type and shape if (not isinstance(kwargs['name'], np.ndarray)) or (len(kwargs['name']) != n_stars): - err_msg = "The '{0:s}' argument has to be a numpy array " - err_msg += "with length = {1:d}" - raise TypeError(err_msg.format('name', n_stars)) + err_msg = f"The 'name' argument has to be a numpy array, not {type(kwargs['name'])};" + err_msg += f"Its length should be {n_stars}, not {len(kwargs['name'])}." + raise TypeError(err_msg) # Check all the 2D arrays. arg_tab = ('x', 'y', 'm', 'xe', 'ye', 'me', 'name_in_list') @@ -112,21 +115,22 @@ def __init__(self, *args, ref_list=0, **kwargs): for arg_test in arg_tab: if arg_test in kwargs: if not isinstance(kwargs[arg_test], np.ndarray): - err_msg = "The '{0:s}' argument has to be a numpy array" - raise TypeError(err_msg.format(arg_test)) + err_msg = f"The '{arg_test}' argument has to be a numpy array, not {type(kwargs[arg_test])}" + raise TypeError(err_msg) if kwargs[arg_test].shape != (n_stars, n_lists): - err_msg = "The '{0:s}' argument has to have shape = ({1:d}, {2:d})" - raise TypeError(err_msg.format(arg_test, n_stars, n_lists)) + err_msg = f"The '{arg_test}' argument has to have shape = ({n_stars}, {n_lists})" + raise TypeError(err_msg) # Check that the reference list is specified. if ref_list not in range(n_lists): - err_msg = "The 'ref_list' argument has to be an integer between 0 and {0:d}" - raise IndexError(err_msg.format(n_lists-1)) + err_msg = f"The 'ref_list' argument has to be an integer between 0 and {n_lists-1}" + raise IndexError(err_msg) # We have to have special handling of meta-data (i.e. info that has # dimensions of n_lists). - meta_tab = ('LIST_TIMES', 'LIST_NAMES') + meta_tab = ('list_times', 'list_names') + meta_tab = ('list_times', 'list_names') meta_type = ((float, int), str) for mm in range(len(meta_tab)): meta_test = meta_tab[mm] @@ -134,13 +138,12 @@ def __init__(self, *args, ref_list=0, **kwargs): if meta_test in kwargs: if len(kwargs[meta_test]) != n_lists: - err_msg = "The '{0:s}' argument has to have length = {1:d}" - raise ValueError(err_msg.format(meta_test, n_lists)) + err_msg = f"The '{meta_test}' argument has to have length = {n_lists}" + raise ValueError(err_msg) if not all(isinstance(tt, meta_type_test) for tt in kwargs[meta_test]): - err_msg = "The '{0:s}' argument has to be a list of {1:s}." - raise TypeError(err_msg.format(meta_test, str(meta_type_test))) - + err_msg = f"The '{meta_test}' argument has to be a list of {str(meta_type_test)}." + raise TypeError(err_msg) ##### # Create the startable ##### @@ -153,22 +156,31 @@ def __init__(self, *args, ref_list=0, **kwargs): if meta_arg in kwargs: self.meta[meta_arg] = kwargs[meta_arg] del kwargs[meta_arg] + elif meta_arg.upper() in kwargs: + self.meta[meta_arg] = kwargs[meta_arg.upper()] + del kwargs[meta_arg] for arg in kwargs: - if arg in ['name', 'x', 'y', 'm']: + if arg in ['name', 'x', 'y', 'm', 'list_times', 'list_names']: continue else: self.add_column(Column(data=kwargs[arg], name=arg)) if arg == 'name_in_list': self['name_in_list'] = self['name_in_list'].astype('U20') + if arg == 'motion_model_input': + self['motion_model_input'] = self['motion_model_input'].astype('U20') + if arg == 'motion_model_used': + self['motion_model_used'] = self['motion_model_used'].astype('U20') + #if 'motion_model_input' not in kwargs: + # self['motion_model_input'] = np.repeat(self.default_motion_model, len(self['name'])) return - + def add_starlist(self, **kwargs): """ - Add data from a new list to an existing StarTable. + Add data from a new list to an existing StarTable. Note, you can pass in the data via a StarList object or - via a series of keywords with a 1D array on each. + via a series of keywords with a 1D array on each. In either case, the number of stars must already match the existing number of stars in the StarTable. @@ -204,16 +216,16 @@ def _add_list_data_from_starlist(self, starlist): old_type = self[col_name].info.dtype new_data = np.empty((old_data.shape[0], old_data.shape[1] + 1), dtype=old_type) new_data[:, :-1] = old_data - + # Save the new data array (with both old and new data in it) to the table. - self[col_name] = new_data - + self[col_name] = new_data + if (col_name in starlist.colnames): # Add data if it was input self[col_name][:, -1] = starlist[col_name] else: # Add junk data it if wasn't input self._set_invalid_list_values(col_name, -1) - - + + ########## # Update the table meta-data. Remember that entries are lists not numpy arrays. ########## @@ -222,38 +234,38 @@ def _add_list_data_from_starlist(self, starlist): lis_meta_keys = list(starlist.meta.keys()) # append 's' to the end to pluralize the input starlist. lis_meta_keys_plural = [lis_meta_key + 's' for lis_meta_key in lis_meta_keys] - + for kk in range(len(tab_meta_keys)): tab_key = tab_meta_keys[kk] # Meta table entries with a size that matches the n_lists size are the ones # that need a new value. We have to add something... whatever was passed in or None - if isinstance(self.meta[tab_key], collections.abc.Iterable) and (len(self.meta[tab_key]) == self.meta['n_lists']): + if isinstance(self.meta[tab_key], Iterable) and (len(self.meta[tab_key]) == self.meta['n_lists']) and (not isinstance(self.meta[tab_key], str)): # If we find the key in the starlists' meta argument, then add the new values. # Otherwise, add "None". - idx = np.where(lis_meta_keys_plural == tab_key)[0] - if len(idx) > 0: - lis_key = lis_meta_keys[idx[0]] + idx = lis_meta_keys_plural.index(tab_key) if tab_key in lis_meta_keys_plural else None + if idx is not None: + lis_key = lis_meta_keys[idx] self.meta[tab_key] = np.append(self.meta[tab_key], [starlist.meta[lis_key]]) else: self._append_invalid_meta_values(tab_key) # Update the n_lists meta keyword. self.meta['n_lists'] += 1 - + return - - + + def _add_list_data_from_keywords(self, **kwargs): # # Check if the required arguments are present # arg_req = ('x', 'y', 'm') - + # for arg_test in arg_req: # if arg_test not in kwargs: # err_msg = "Added lists require a '{0:s}' argument" # raise TypeError(err_msg.format(arg_test)) - + # # If we have errors, we need them in both dimensions. # if ('xe' in kwargs) ^ ('ye' in kwargs): # raise TypeError("Added lists with errors require both 'xe' and" + @@ -271,21 +283,21 @@ def _add_list_data_from_keywords(self, **kwargs): old_type = self[col_name].info.dtype new_data = np.empty((old_data.shape[0], old_data.shape[1] + 1), dtype=old_type) new_data[:, :-1] = old_data - + # Save the new data array (with both old and new data in it) to the table. self[col_name] = new_data - + if (col_name in kwargs): # Add data if it was input self[col_name][:, -1] = kwargs[col_name] else: # Add junk data it if wasn't input self._set_invalid_list_values(col_name, -1) - + # Update the table meta-data. Remember that entries are lists not numpy arrays. for key in self.meta.keys(): # Meta table entries with a size that matches the n_lists size are the ones # that need a new value. We have to add something... whatever was passed in or None - if isinstance(self.meta[key], collections.abc.Iterable) and (len(self.meta[key]) == self.meta['n_lists']): + if isinstance(self.meta[key], Iterable) and (len(self.meta[key]) == self.meta['n_lists']) and (not isinstance(self.meta[key], str)): # If we find the key is the passed in meta argument, then add the new values. # Otherwise, add "None". if 'meta' in kwargs: @@ -299,7 +311,7 @@ def _add_list_data_from_keywords(self, **kwargs): # Update the n_lists meta keyword. self.meta['n_lists'] += 1 - + return def _set_invalid_list_values(self, col_name, col_idx): @@ -313,7 +325,7 @@ def _set_invalid_list_values(self, col_name, col_idx): self[col_name][:, col_idx] = np.nan else: self[col_name][:, col_idx] = None - + return def _set_invalid_star_values(self, col_name, row_idx): @@ -327,13 +339,13 @@ def _set_invalid_star_values(self, col_name, row_idx): self[col_name][row_idx] = np.nan else: self[col_name][row_idx] = None - + return - + def _append_invalid_meta_values(self, key): """ - For an existing meta keyword that is a list (already known), - add an invalid value depending on the type. + For an existing meta keyword that is a list (already known), + add an invalid value depending on the type. """ if issubclass(type(self.meta[key][0]), np.integer): self.meta[key] = np.append(self.meta[key], [-1]) @@ -349,11 +361,11 @@ def _append_invalid_meta_values(self, key): warnings.warn(err_msg, UserWarning) return - - + + def get_starlist(self, list_index): """ - Return a StarList object for the specified list_index or epoch. + Return a StarList object for the specified list_index or epoch. Parameters ---------- @@ -373,26 +385,26 @@ def get_starlist(self, list_index): col_req_dict[col_name] = self[col_name] starlist = StarList(**col_req_dict) - + for col_name in self.colnames: if col_name in col_req_names: pass - + if len(self[col_name].data.shape) == 2: # Find the 2D columns starlist[col_name] = self[col_name][:, list_index] else: starlist[col_name] = self[col_name] - + return starlist - def combine_lists_xym(self, weighted_xy=True, weighted_m=True, mask_lists=False, sigma=3): + def combine_lists_xym(self, weighted_xy=True, weighted_m=True, mask_lists=None, sigma=3): """ For x, y and m columns in the table, collapse along the lists direction. For 'x', 'y' this means calculating the average position with outlier rejection. Optionally, weight by the 'xe' and 'ye' individual uncertainties. Optionally, use sigma clipping. - "mask_lists" is a list with the indices of starlists that are + "mask_lists" is a list with the indices of starlists that are excluded from the combination. Also, count the number of times a star is found in starlists. """ @@ -409,15 +421,15 @@ def combine_lists_xym(self, weighted_xy=True, weighted_m=True, mask_lists=False, weights_colm = 'me' else: weights_colm = None - + self.combine_lists('x', weights_col=weights_colx, mask_lists=mask_lists, sigma=sigma) self.combine_lists('y', weights_col=weights_coly, mask_lists=mask_lists, sigma=sigma) self.combine_lists('m', weights_col=weights_colm, mask_lists=mask_lists, sigma=sigma, ismag=True) - + return def combine_lists(self, col_name_in, weights_col=None, mask_val=None, - mask_lists=False, meta_add=True, ismag=False, sigma=3): + mask_lists=None, meta_add=True, ismag=False, sigma=3): """ For the specified column (col_name_in), collapse along the starlists direction and calculated the average value, with outlier rejection. @@ -427,604 +439,921 @@ def combine_lists(self, col_name_in, weights_col=None, mask_val=None, 0e -- the std (with outlier rejection) Masking of NaN values is also performed. - - "mask_lists" is a list with the indices of starlists that are + + "mask_lists" is a list with the indices of starlists that are excluded from the combination. - + A flag can be stored in the metadata to record if the average was weighted or not. """ - # Get the array we are going to combine. Make a copy so we don't mod it. - val_2d = copy.deepcopy( self[col_name_in].data ) + if mask_lists is not None: + # Extract list of indices that we want to keep (i.e. not mask) + mask_lists = np.atleast_1d(mask_lists) + assert mask_lists.dtype == int, "mask_lists needs to be a list of integers." + list_indices = np.array([i for i in np.arange(self[col_name_in].data.shape[1]) if i not in mask_lists]) + else: + # Use all indices + list_indices = np.arange(self[col_name_in].data.shape[1]) + + val_2d = np.ma.masked_invalid(self[col_name_in].data[:, list_indices]) if ismag: # Convert to flux. - val_2d = 10**(-val_2d / 2.5) + val_2d = 10**(-0.4 * val_2d) # Make a mask of invalid (NaN) values and a user-specified invalid value. - val_2d = np.ma.masked_invalid(val_2d) + if mask_val: val_2d = np.ma.masked_values(val_2d, mask_val) - - if mask_lists is not False: - # Remove a list - if isinstance(mask_lists, list): - if all(isinstance(item, int) for item in mask_lists): - val_2d.mask[:, mask_lists] = True - - # Throw a warning if mask_lists is not a list - if not isinstance(mask_lists, list): - raise RuntimeError('mask_lists needs to be a list.') + + # Figure out which ones are outliers. Returns a masked array. + if sigma: + # with warnings.catch_warnings(): + # warnings.filterwarnings('ignore', category=RuntimeWarning) + val_2d_clip = sigma_clip(val_2d, sigma=sigma, maxiters=5, axis=1) + else: + val_2d_clip = val_2d # Decide if we are going to have weights (before we # do the expensive sigma clipping routine). Note that - # if we have only 1 column to average, then we can't do weighting. + # if we have only 1 column to average, then we can't do weighting. if (weights_col and weights_col in self.colnames) and (val_2d.shape[1] > 1): - err_2d = self[weights_col].data - + err_2d = np.ma.masked_invalid(self[weights_col].data[:, list_indices]) + if ismag: # Convert to flux error - err_2d = err_2d * val_2d * np.log(10) / 2.5 - - np.seterr(divide='ignore') - wgt_2d = np.ma.masked_invalid(1.0 / err_2d**2) - np.seterr(divide='warn') - + err_2d = 0.4 * np.log(10) * val_2d * err_2d + + # Unify masks + unified_mask = val_2d_clip.mask | err_2d.mask + val_2d_clip.mask = unified_mask + err_2d.mask = unified_mask + + # Inverse variance weights minimize the propagated uncertainty + wgt_2d = np.ma.masked_invalid(1. / err_2d**2) + + # Calculate the weighted mean and uncertainty + avg = np.ma.average(val_2d_clip, weights=wgt_2d, axis=1) + std = np.ma.sqrt(1. / np.ma.sum(wgt_2d, axis=1)) # Error propagation for weighted mean + + # Use standard deviation of the weighted residuals as the uncertainty + # std = np.ma.sqrt(np.ma.average((val_2d_clip.T - avg).T**2, weights=wgt_2d, axis=1)) + if meta_add: self.meta[col_name_in + '0'] = 'weighted' else: wgt_2d = None + # Calculate the weighted mean and uncertainty + avg = np.ma.mean(val_2d_clip, axis=1) + std = np.ma.std(val_2d_clip, axis=1) / np.sqrt(len(list_indices)) # Standard error of the mean + # Use standard deviation of the residuals as the uncertainty + # std = np.ma.std(val_2d_clip, axis=1) + if meta_add: self.meta[col_name_in + '0'] = 'not_weighted' - # Figure out which ones are outliers. Returns a masked array. - if sigma: - warnings.filterwarnings('ignore', category=RuntimeWarning) - val_2d_clip = sigma_clipping.sigma_clip(val_2d, sigma=sigma, maxiters=5, axis=1) - warnings.filterwarnings('default', category=RuntimeWarning) - else: - val_2d_clip = val_2d - - # Calculate the (weighted) mean and standard deviation along - # the N_lists direction (axis=1). - if wgt_2d is not None: - avg = np.ma.average(val_2d_clip, weights=wgt_2d, axis=1) - std = np.sqrt(np.ma.average((val_2d_clip.T - avg).T**2, weights=wgt_2d, axis=1)) - else: - avg = np.ma.mean(val_2d_clip, axis=1) - std = np.ma.std(val_2d_clip, axis=1) - # To Do: bring the previous uncertainties of stars that are detected - # in only one input frame. - if (weights_col and weights_col in self.colnames) and (val_2d.shape[1] > 1): - mask_for_singles = ((~np.isnan(val_2d_clip)).sum(axis=1)==1) - std[mask_for_singles]=np.nanmean(err_2d[mask_for_singles], axis=1) + std = np.ma.masked_values(std, 0.) # Mask out any zero uncertainties (i.e., 1 or less valid points) # Save off our new AVG and STD into new columns with shape (N_stars). col_name_avg = col_name_in + '0' - col_name_std = col_name_in + '0e' + col_name_std = col_name_in + '0_err' if ismag: - std = (2.5 / np.log(10)) * std / avg + std = 2.5 / np.log(10) * std / avg # Error propagation avg = -2.5 * np.ma.log10(avg) + + # FIXME: why change? + # Fill mask with nan or inf + avg = avg.filled(np.nan) + std = std.filled(np.inf) + if col_name_avg in self.colnames: - self[col_name_avg] = avg.data - self[col_name_std] = std.data + self[col_name_avg] = avg + self[col_name_std] = std else: - self.add_column(Column(data=avg.data, name=col_name_avg)) - self.add_column(Column(data=std.data, name=col_name_std)) - + self.add_column(Column(data=avg, name=col_name_avg)) + self.add_column(Column(data=std, name=col_name_std)) + return def detections(self): """ Find where stars are detected. # """ - n_detect = np.sum(~np.isnan(self['x']), axis=1) - + n_detect = np.sum(np.isfinite(self['x']) & np.isfinite(self['y']), axis=1) + if 'n_detect' in self.colnames: self['n_detect'] = n_detect else: - self.add_column(Column(n_detect), name='n_detect') - + self.add_column(Column(data=n_detect, name='n_detect')) + return - - def fit_velocities(self, weighting='var', use_scipy=True, absolute_sigma=True, bootstrap=0, fixed_t0=False, verbose=False, - mask_val=None, mask_lists=False, show_progress=True): - """Fit velocities for all stars in the table and add to the columns 'vx', 'vxe', 'vy', 'vye', 'x0', 'x0e', 'y0', 'y0e'. + def fit_motion_models( + self, + motion_models=None, + fixed_params_dict=None, + weighting='var', + use_scipy=True, + absolute_sigma=True, + method=None, + select_stars=None, + bootstrap=0, + seed=None, + mask_value=None, + mask_lists=None, + fill_value=np.nan, + art_star=False, + processes=1, + chunksize=None, + verbose=True + ): + """Fit velocity for star table Parameters ---------- + motion_models : list of MotionModel or str, optional + Motion models to use, by default Empty, Fixed and Linear. + Empty and Fixed models are always added automatically for stars with n_fit = 0 or 1. + The behavior is as follows: + 1. If 'motion_model_input' column is NOT in table: + - Use the most complex model that has enough parameters to fit the data (n_fit >= n_params). + - If multiple models are supplied, prioritize the model with the most parameters to fit. + - If multiple models have the same number of parameters, raise AssertionError: not sure which to use. + 2. If 'motion_model_input' column IS in table: + - Use the model specified in the 'motion_model_input' column. + - If not enough data points to fit the specified model, use the most complex model in any 'motion_model_input' column that has enough parameters to fit the data (n_fit >= n_params) among the provided motion_models and 'motion_model_input'. + The actual used motion model is stored in the 'motion_model_used' column. The default motion_models are [Empty, Fixed, Linear]. + fixed_params_dict : dict, optional + Dictionary of fixed parameters for motion models, e.g., {'t0': 0., 'ra': np.array([...]), 'dec': np.array([...])}. + - Scalar values are used for all stars, array values should have length = N_stars. + - t0 is automatically calculated as np.average(t, weights=1/np.hypot(xe, ye)) if not provided. + - The keys should match the fixed parameter names in the motion models. See MotionModel class for details, by default None weighting : str, optional - Weight by variance 'var' or standard deviation 'std', by default 'var' + Uncertainty weighting, 'std' for weight=1/xe(ye) or 'var' for weight=1/xe(ye)**2, by default 'var' use_scipy : bool, optional - Use scipy.curve_fit (recommended for large number of epochs, but may return inf or nan) or analytic fitting from flystar.fit_velocity.linear_fit (recommended for a few epochs), by default True + Use scipy.optimize.curve_fit or algebraic solution (for Linear model only), by default False absolute_sigma : bool, optional - Absolute sigma or not. See https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html for details, by default True + Use absolute sigma or not, see scipy curve_fit for details, by default True + method : str, optional + Method of scipy.curve_fit, {'lm', 'trf', 'dogbox'}, by default None + select_stars : list of int, optional + Indices of stars to fit, by default None (fit all stars) bootstrap : int, optional - Calculate uncertain using bootstraping or not, by default 0 - fixed_t0 : bool or array-like, optional - Fix the t0 in dt = time - t0 if user provides an array with the same length of the table, or automatically calculate t0 = np.average(time, weights=1/np.hypot(xe, ye)) if False, by default False + Number of bootstrap samples for uncertainty resampling, by default 0 + seed : int, optional + Random seed for bootstrap resampling, by default None + mask_value : float, optional + Values to mask in data, by default None + mask_lists : list of int, optional + Indices of lists to mask/exclude from fitting, by default None + fill_value : float, optional + Fill value when there is not enough data points to fit, by default np.nan + art_star : bool, optional + Artifical star table or observed star table. If artificial stars, Use the output coordinates for fitting motion models (x[..., 1], y[..., 1]) + processes : int, optional + Number of processes to use for parallel processing, maximum os.cpu_count(), by default 1 (no multiprocessing) + chunksize : int, optional + Chunk size for multiprocessing, by default None (auto) verbose : bool, optional - Output verbose information or not, by default False - mask_val : float, optional - Value that needs to be masked in the data, e.g. -100000, by default None - mask_lists : list, optional - Columns that needs to be masked, by default False - show_progress : bool, optional - Show progress bar or not, by default True + Print verbose messages or not, by default True + Raises ------ ValueError - If weighting is neither 'var' or 'std' + If weighting is not 'var' or 'std'. KeyError - If there's not time information in the table + If time values are not found in the table or meta. + KeyError + If required columns 'x' and 'y' are missing in the table. """ + ########################### + ####### Check Params ###### + ########################### if weighting not in ['var', 'std']: - raise ValueError(f"fit_velocities: Weighting must either be 'var' or 'std', not {weighting}!") - - if ('t' not in self.colnames) and ('LIST_TIMES' not in self.meta): - raise KeyError("fit_velocities: Failed to access time values. No 't' column in table, no 'LIST_TIMES' in meta.") - + raise ValueError(f"fit_motion_models: Weighting must either be 'var' or 'std', not {weighting}!") + + if ('t' not in self.colnames) and ('list_times' not in self.meta): + raise KeyError("fit_motion_models: Failed to access time values. No 't' column in table, no 'list_times' in meta.") + # Check if we have the required columns if not all([_ in self.colnames for _ in ['x', 'y']]): - raise KeyError(f"fit_velocities: Missing required columns in the table: {', '.join(['x', 'y'])}!") - + raise KeyError(f"fit_motion_models: Missing required columns in the table: {', '.join(['x', 'y'])}!") + + # Make a copy of fixed_params_dict to avoid modifying the original one outside the function + fixed_params_dict = copy.deepcopy(fixed_params_dict) + + # Check fixed_params_dict is a dict + if fixed_params_dict is not None: + if not isinstance(fixed_params_dict, dict): + raise ValueError("fit_motion_models: fixed_params_dict must be a dictionary!") + + # Convert motion_models to MotionModel objects if they are strings: + if motion_models is None: + # Setting the default to None to avoid mutable default argument issue + # See https://stackoverflow.com/questions/15189245/assigning-class-variable-as-default-value-to-class-method-argument + motion_models = [Empty, Fixed, Linear] + all_mm_map = motion_model.motion_model_map() + if all(isinstance(mm, str) for mm in motion_models): + mm_names = motion_models + motion_models = [all_mm_map[mm] for mm in motion_models] + else: + mm_names = [mm.name for mm in motion_models] + + # Always add Empty and Fixed in motion models + if 'Fixed' not in mm_names: + motion_models.insert(0, Fixed) + if 'Empty' not in mm_names: + motion_models.insert(0, Empty) + mm_names = [mm.name for mm in motion_models] + + # Construct motion models if motion_model_input column exists + if 'motion_model_input' in self.colnames: + input_mm_names = np.unique(self['motion_model_input']) + assert all([name in all_mm_map.keys() for name in input_mm_names]), \ + f"fit_motion_models: Unknown motion model name(s) in 'motion_model_input' column. Available motion models are: {', '.join(all_mm_map.keys())}." + for mm_name in input_mm_names: + if mm_name not in mm_names: + motion_models.append(all_mm_map[mm_name]) + + # Sort motion models by required epochs + motion_models = sorted(motion_models, key=lambda mm: mm.n_params) + + input_mm_map = {mm.name: mm for mm in motion_models} + + mm_n_params = np.sort([mm.n_params for mm in motion_models]) + if 'motion_model_input' not in self.colnames: + # If motion_model_input column is not provided, assert that motion model n_params are unique and sorted + # Otherwise the fitter does not know which motion model to use based on n_obs + assert len(mm_n_params) == len(set(mm_n_params)), \ + f"fit_motion_models: Provided motion model n_params are not unique! Motion Models are: {[_.name for _ in motion_models]}" + '\n' + "Cannot decide which motion model to use based on n_obs. Please provide unique motion_models or a 'motion_model_input' column." + + + ########################### + ####### Prepare Data ###### + ########################### + # Prepare data for fitting N_stars = len(self) - - if verbose: - start_time = time.time() - msg = 'Starting startable.fit_velocities for {0:d} stars with n={1:d} bootstrap' - print(msg.format(N_stars, bootstrap)) - - # Clean/remove up old arrays. - if 'x0' in self.colnames: self.remove_column('x0') - if 'vx' in self.colnames: self.remove_column('vx') - if 'y0' in self.colnames: self.remove_column('y0') - if 'vy' in self.colnames: self.remove_column('vy') - if 'x0e' in self.colnames: self.remove_column('x0e') - if 'vxe' in self.colnames: self.remove_column('vxe') - if 'y0e' in self.colnames: self.remove_column('y0e') - if 'vye' in self.colnames: self.remove_column('vye') - if 'chi2_vx' in self.colnames: self.remove_column('chi2_vx') - if 'chi2_vy' in self.colnames: self.remove_column('chi2_vy') - if 't0' in self.colnames: self.remove_column('t0') - if 'n_vfit' in self.colnames: self.remove_column('n_vfit') - - # Define output arrays for the best-fit parameters. - self.add_column(Column(data = np.zeros(N_stars, dtype=float), name = 'x0')) - self.add_column(Column(data = np.zeros(N_stars, dtype=float), name = 'vx')) - self.add_column(Column(data = np.zeros(N_stars, dtype=float), name = 'y0')) - self.add_column(Column(data = np.zeros(N_stars, dtype=float), name = 'vy')) - - self.add_column(Column(data = np.zeros(N_stars, dtype=float), name = 'x0e')) - self.add_column(Column(data = np.zeros(N_stars, dtype=float), name = 'vxe')) - self.add_column(Column(data = np.zeros(N_stars, dtype=float), name = 'y0e')) - self.add_column(Column(data = np.zeros(N_stars, dtype=float), name = 'vye')) - - self.add_column(Column(data = np.zeros(N_stars, dtype=float), name = 'chi2_vx')) - self.add_column(Column(data = np.zeros(N_stars, dtype=float), name = 'chi2_vy')) - - self.add_column(Column(data = np.zeros(N_stars, dtype=float), name = 't0')) - self.add_column(Column(data = np.zeros(N_stars, dtype=int), name = 'n_vfit')) - - self.meta['N_VFIT_BOOTSTRAP'] = bootstrap - - # (FIXME: Do we need to catch the case where there's a single *unmasked* epoch?) - # Catch the case when there is only a single epoch. Just return 0 velocity - # and the same input position for the x0/y0. - if len(self['x'].shape) == 1: - self['x0'] = self['x'] - self['y0'] = self['y'] - if 't' in self.colnames: - self['t0'] = self['t'] - else: - self['t0'] = self.meta['LIST_TIMES'][0] - if 'xe' in self.colnames: - self['x0e'] = self['xe'] - self['y0e'] = self['ye'] - self['n_vfit'] = 1 - - return - - if self['x'].shape[1] == 1: - self['x0'] = self['x'][:,0] - self['y0'] = self['y'][:,0] - - if 't' in self.colnames: - self['t0'] = self['t'][:, 0] - else: - self['t0'] = self.meta['LIST_TIMES'][0] - - if 'xe' in self.colnames: - self['x0e'] = self['xe'][:,0] - self['y0e'] = self['ye'][:,0] - - self['n_vfit'] = 1 - - return - - # STARS LOOP through the stars and work on them 1 at a time. - # This is slow; but robust. - if show_progress: - for ss in tqdm(range(N_stars)): - self.fit_velocity_for_star(ss, weighting=weighting, use_scipy=use_scipy, absolute_sigma=absolute_sigma, bootstrap=bootstrap, fixed_t0=fixed_t0, - mask_val=mask_val, mask_lists=mask_lists) + if art_star: + x = self['x'].data[..., 1] + y = self['y'].data[..., 1] else: - for ss in range(N_stars): - self.fit_velocity_for_star(ss, weighting=weighting, use_scipy=use_scipy, absolute_sigma=absolute_sigma, bootstrap=bootstrap, fixed_t0=fixed_t0, - mask_val=mask_val, mask_lists=mask_lists, ) - if verbose: - stop_time = time.time() - print('startable.fit_velocities runtime = {0:.0f} s for {1:d} stars'.format(stop_time - start_time, N_stars)) - - return + x = self['x'].data + y = self['y'].data - def fit_velocity_for_star(self, ss, weighting='var', use_scipy=True, absolute_sigma=True, bootstrap=False, fixed_t0=False, - mask_val=None, mask_lists=False): + xe = self['xe'].data if 'xe' in self.colnames else None + ye = self['ye'].data if 'ye' in self.colnames else None + with_xe_ye = (xe is not None) and (ye is not None) - # Make a mask of invalid (NaN) values and a user-specified invalid value. - x = np.ma.masked_invalid(self['x'][ss, :].data) - y = np.ma.masked_invalid(self['y'][ss, :].data) - if mask_val: - x = np.ma.masked_values(x, mask_val) - y = np.ma.masked_values(y, mask_val) - # If no mask, convert x.mask to list - if not np.ma.is_masked(x): - x.mask = np.zeros_like(x.data, dtype=bool) - if not np.ma.is_masked(y): - y.mask = np.zeros_like(y.data, dtype=bool) - - - if mask_lists is not False: - # Remove a list - if isinstance(mask_lists, list): - if all(isinstance(item, int) for item in mask_lists): - x.mask[mask_lists] = True - y.mask[mask_lists] = True - - # Throw a warning if mask_lists is not a list - if not isinstance(mask_lists, list): - raise RuntimeError('mask_lists needs to be a list.') - - if 'xe' in self.colnames: - # Make a mask of invalid (NaN) values and a user-specified invalid value. - xe = np.ma.masked_invalid(self['xe'][ss, :].data) - ye = np.ma.masked_invalid(self['ye'][ss, :].data) - - # Catch the case where we have positions but no errors for - # some of the entries... we need to "fill in" reasonable - # weights for these... just use the average weights over - # all the other epochs. - pos_no_err = np.where((np.isfinite(x) & np.isfinite(y)) & - (np.isfinite(xe) == False) & (np.isfinite(ye) == False))[0] - pos_with_err = np.where((np.isfinite(x) & np.isfinite(y)) & - (np.isfinite(xe) & np.isfinite(ye)))[0] - - if len(pos_with_err) > 0: - xe[pos_no_err] = xe[pos_with_err].mean() - ye[pos_no_err] = ye[pos_with_err].mean() - else: - xe[pos_no_err] = 1.0 - ye[pos_no_err] = 1.0 + N_times = x.shape[1] + if mask_lists is not None: + list_indices = np.array([i for i in range(N_times) if i not in mask_lists]) else: - N_epochs = len(x) - xe = np.ones(N_epochs, dtype=float) - ye = np.ones(N_epochs, dtype=float) - xe = np.ma.masked_invalid(xe) - ye = np.ma.masked_invalid(xe) - - if mask_val: - xe = np.ma.masked_values(xe, mask_val) - ye = np.ma.masked_values(ye, mask_val) - # If no mask, convert xe.mask to list - if not np.ma.is_masked(xe): - xe.mask = np.zeros_like(xe.data, dtype=bool) - if not np.ma.is_masked(ye): - ye.mask = np.zeros_like(ye.data, dtype=bool) - - if mask_lists is not False: - # Remove a list - if isinstance(mask_lists, list): - if all(isinstance(item, int) for item in mask_lists): - xe.mask[mask_lists] = True - ye.mask[mask_lists] = True - - # Throw a warning if mask_lists is not a list - if not isinstance(mask_lists, list): - raise RuntimeError('mask_lists needs to be a list.') - - # Make a mask of invalid (NaN) values and a user-specified invalid value. + list_indices = np.arange(N_times) + + x_data = np.ma.masked_invalid(x[:, list_indices], copy=True) + y_data = np.ma.masked_invalid(y[:, list_indices], copy=True) + xe_data = np.ma.masked_invalid(xe[:, list_indices], copy=True) if with_xe_ye else None + ye_data = np.ma.masked_invalid(ye[:, list_indices], copy=True) if with_xe_ye else None + + # Mask out close to 0 values to avoid infinite weights + if with_xe_ye: + xe_data.mask[np.isclose(xe_data, 0)] = True + ye_data.mask[np.isclose(ye_data, 0)] = True + + # If all of xe and ye is masked for a star, effectively no uncertainties provided, fill with 1. + # Note that this automatically turn the mask to False for these stars + if with_xe_ye: + fill_with_one = np.all(xe_data.mask, axis=1) & np.all(ye_data.mask, axis=1) + xe_data[fill_with_one] = 1. + ye_data[fill_with_one] = 1. + + # Ensure data is 2D for consistent indexing, even if we have only one list/epoch (shape (N_stars, 1) instead of (N_stars,)) + if np.ndim(x_data) == 1: + x_data = x_data[:, np.newaxis] + if np.ndim(y_data) == 1: + y_data = y_data[:, np.newaxis] + if with_xe_ye: + if np.ndim(xe_data) == 1: + xe_data = xe_data[:, np.newaxis] + if np.ndim(ye_data) == 1: + ye_data = ye_data[:, np.newaxis] + + # t_data: 2d array with shape (N_stars, N_epochs) + # t0: 1d array with shape (N_stars,) if 't' in self.colnames: - t = np.ma.masked_invalid(self['t'][ss, :].data) + t_data = copy.deepcopy(self['t'].data[:, list_indices]) else: - t = np.ma.masked_invalid(self.meta['LIST_TIMES']) - - if mask_val: - t = np.ma.masked_values(t, mask_val) - if not np.ma.is_masked(t): - t.mask = np.zeros_like(t.data, dtype=bool) - - if mask_lists is not False: - # Remove a list - if isinstance(mask_lists, list): - if all(isinstance(item, int) for item in mask_lists): - t.mask[mask_lists] = True - - # Throw a warning if mask_lists is not a list - if not isinstance(mask_lists, list): - raise RuntimeError('mask_lists needs to be a list.') - - # For inconsistent masks, mask the star if any of the values are masked. - new_mask = np.logical_or.reduce((t.mask, x.mask, y.mask, xe.mask, ye.mask)) - # Figure out where we have detections (as indicated by error columns) - good = np.where((xe != 0) & (ye != 0) & - np.isfinite(xe) & np.isfinite(ye) & - np.isfinite(x) & np.isfinite(y) & ~new_mask)[0] - - N_good = len(good) - - # Catch the case where there is NO good data. - if N_good == 0: - return - - # Everything below has N_good >= 1 - x = x[good] - y = y[good] - t = t[good] - xe = xe[good] - ye = ye[good] - - # slope, intercept - p0x = np.array([0., x.mean()]) - p0y = np.array([0., y.mean()]) - - # Unless t0 is fixed, calculate the t0 for the stars. - if fixed_t0 is False: - t_weight = 1.0 / np.hypot(xe, ye) - t0 = np.average(t, weights=t_weight) + t_data = copy.deepcopy(np.array(self.meta['list_times']))[list_indices] + t_data = np.broadcast_to(t_data, x_data.shape) + + fixed_params_dict = {} if fixed_params_dict is None else fixed_params_dict + # Add default t0 if not provided in fixed_params_dict + if 't0' not in fixed_params_dict: + weights = 1. / np.hypot(xe_data, ye_data) if with_xe_ye else None + fixed_params_dict['t0'] = np.average(t_data, axis=1, weights=weights) else: - t0 = fixed_t0[ss] - dt = t - t0 - - self['t0'][ss] = t0 - self['n_vfit'][ss] = N_good - - # Catch the case where all the times are identical - if (dt == dt[0]).all(): - if weighting == 'var': - wgt_x = (1.0/xe)**2 - wgt_y = (1.0/ye)**2 - elif weighting == 'std': - wgt_x = 1./np.abs(xe) - wgt_y = 1./np.abs(ye) - - self['x0'][ss] = np.average(x, weights=wgt_x) - self['y0'][ss] = np.average(y, weights=wgt_y) - self['x0e'][ss] = np.sqrt(np.average((x - self['x0'][ss])**2, weights=wgt_x)) - self['y0e'][ss] = np.sqrt(np.average((y - self['y0'][ss])**2, weights=wgt_x)) - - self['vx'][ss] = 0.0 - self['vy'][ss] = 0.0 - self['vxe'][ss] = 0.0 - self['vye'][ss] = 0.0 + if np.ndim(fixed_params_dict['t0']) == 0: + fixed_params_dict['t0'] = np.full(N_stars, fixed_params_dict['t0']) + + t0 = fixed_params_dict['t0'] + + # Apply mask_value if provided + if mask_value: + x_data = np.ma.masked_values(x_data, mask_value) + y_data = np.ma.masked_values(y_data, mask_value) + if with_xe_ye: + xe_data = np.ma.masked_values(xe_data, mask_value) + ye_data = np.ma.masked_values(ye_data, mask_value) + + + # Calculate mask array + valid_xy = ~ (x_data.mask | y_data.mask) + if with_xe_ye: + valid_xy &= ~ (xe_data.mask | ye_data.mask) + + # Calculate n_fit: unmasked x y values + # This will be used to determine which motion model to use for each star. + # Note that we don't require unique times here + # as scipy.curve_fit and Linear algebra can fit non-unique times. + # self['n_fit'] = np.sum(valid_xy, axis=1) + + # Calculate n_fit: unique times & unmasked x y values + self['n_fit'] = np.array([ + len(set(t_data[i][valid_xy[i]])) + for i in range(N_stars) + ]) + + + ########################### + ####### Determine MM ###### + ########################### + n_fit = np.array(self['n_fit']) + if 'motion_model_input' in self.colnames: + # Determine which motion model to use based on motion_model_input column + # If n_fit < n_params for the input motion model, use the most complicated motion model with n_fit >= n_params + required_params = np.array([all_mm_map[mm_name].n_params for mm_name in self['motion_model_input']]) + reassign_mm = n_fit < required_params + + mm_digitized = np.digitize( + x=n_fit[reassign_mm], + bins=mm_n_params + ) - 1 # Convert to 0-based index + + # Assign motion models to stars + self['motion_model_used'] = self['motion_model_input'] + self['motion_model_used'][reassign_mm] = np.array([motion_models[d].name for d in mm_digitized], dtype='U20') - return + else: + # If motion_model_input column is not provided, use the most complicated model in motion_models with n_fit >= n_params. + mm_digitized = np.digitize( + x=n_fit, + bins=mm_n_params + ) - 1 # Convert to 0-based index + + # Assign motion models to stars + self['motion_model_used'] = np.array([motion_models[d].name for d in mm_digitized], dtype='U20') + + ############################ + # Prepare Fixed Parameters # + ############################ + # If required fixed params in self.meta or columns, but not provided in fixed_params_dict, add them to fixed_params_dict + motion_model_used = [all_mm_map[name] for name in np.unique(self['motion_model_used'])] + raise_key_error = False + missing_params = [] + for mm in motion_model_used: + # Check required fixed parameters + for param in mm.required_fixed_param_names: + # Check in the order of fixed_params_dict -> self.meta -> self columns + if param not in fixed_params_dict: + # If not provided in fixed_params_dict, it must be in table columns + if param in self.colnames: + fixed_params_dict[param] = self[param].data + elif param in self.meta: + # Check if the parameter is in self.meta + fixed_params_dict[param] = self.meta[param] + else: + raise_key_error = True + missing_params.append(f"'{param}'") + + # Check optional fixed parameters + # Set to default value if not provided in fixed_params_dict or in self + for param, value in mm.optional_fixed_params.items(): + if param not in fixed_params_dict: + # If param is not provided in fixed_params_dict + if param in self.colnames: + # Set to column value if column exists + fixed_params_dict[param] = self[param].data + elif param in self.meta: + # Check if the parameter is in self.meta + fixed_params_dict[param] = self.meta[param] + else: + # Set to default value if neither in columns nor provided in fixed_params_dict + fixed_params_dict[param] = value + self.meta[param] = value + + if raise_key_error: + raise KeyError(f"fit_motion_models: Missing required fixed parameter(s) for the motion models used: {', '.join(missing_params)}! Please provide them in fixed_params_dict, or as columns in the table, or as table metadata.") + + + # Prepare fixed_params_dict for each star + # This avoids checking types and slicing inside the fitting loop + fixed_params_stars = [{} for _ in range(N_stars)] + # Identify array parameters (length N_stars) and scalar parameters + array_params = {k: v for k, v in fixed_params_dict.items() if np.ndim(v) > 0 and len(v) == N_stars} + scalar_params = {k: v for k, v in fixed_params_dict.items() if k not in array_params} + + # Construct list of dicts for each star + # Using list comprehension for speed + fixed_params_stars = [ + {**scalar_params, **{k: v[i] for k, v in array_params.items()}} + for i in range(N_stars) + ] + + + ############################ + ####### Prepare Table ###### + ############################ + # Fill table with all possible motion model parameter names as new columns. + new_col_list = motion_model.motion_model_param_names(motion_model_used, with_errors=True, with_fixed=False) + new_col_list += ['chi2_x', 'chi2_y', 'n_params'] + + if 't0' not in new_col_list: + new_col_list.append('t0') + + # Add new columns if they do not exist + for col in new_col_list: + if col in self.colnames: + # Keep old data if the column already exists + continue + if col.endswith('_err'): + self.add_column( + Column(data=np.full(N_stars, np.inf, dtype=float), name=col), + rename_duplicate=True + ) + else: + self.add_column( + Column(data=np.full(N_stars, fill_value, dtype=float), name=col), + rename_duplicate=True + ) + + # Add fixed parameter meta if scalar, column if array. + fixed_param_names = [] + for mm in motion_model_used: + for param in mm.fixed_param_names: + if param not in fixed_param_names: + fixed_param_names.append(param) + # Remove t0 from fixed_param_names as it will be saved during fitting + if 't0' in fixed_param_names: + fixed_param_names.remove('t0') + + + for param in fixed_param_names: + coldata = np.array([fps[param] for fps in fixed_params_stars]) + + if param in self.colnames: + existing = self[param] + + # Skip if identical + same = ( + np.array_equal(existing, coldata) + if is_string_dtype(existing) + else np.allclose(existing, coldata, equal_nan=True) + ) + + if same: + continue - # Catch the case where we have enough measurements to actually - # fit a velocity! - if N_good > 2: - if weighting == 'var': - sigma_x = xe - sigma_y = ye - elif weighting == 'std': - sigma_x = np.abs(xe)**0.5 - sigma_y = np.abs(ye)**0.5 - - if use_scipy: - vx_opt, vx_cov = curve_fit(linear, dt, x, p0=p0x, sigma=sigma_x, absolute_sigma=absolute_sigma) - vy_opt, vy_cov = curve_fit(linear, dt, y, p0=p0y, sigma=sigma_y, absolute_sigma=absolute_sigma) - vx = vx_opt[0] - x0 = vx_opt[1] - vy = vy_opt[0] - y0 = vy_opt[1] - chi2_vx = calc_chi2(dt, x, sigma_x, *vx_opt) - chi2_vy = calc_chi2(dt, y, sigma_y, *vy_opt) - + # Different (or column does not yet exist) + if len(np.unique(coldata)) == 1: + # If param is the same for all stars, save it as meta + self.meta[param] = coldata[0] else: - result_vx = linear_fit(dt, x, sigma_x, absolute_sigma=absolute_sigma) - result_vy = linear_fit(dt, y, sigma_y, absolute_sigma=absolute_sigma) - vx = result_vx['slope'] - x0 = result_vx['intercept'] - vy = result_vy['slope'] - y0 = result_vy['intercept'] - chi2_vx = result_vx['chi2'] - chi2_vy = result_vy['chi2'] - - self['vx'][ss] = vx - self['x0'][ss] = x0 - self['vy'][ss] = vy - self['y0'][ss] = y0 - self['chi2_vx'][ss] = chi2_vx - self['chi2_vy'][ss] = chi2_vy - - # Run the bootstrap - if bootstrap > 0: - edx = np.arange(N_good, dtype=int) - - vx_b = np.zeros(bootstrap, dtype=float) - x0_b = np.zeros(bootstrap, dtype=float) - vy_b = np.zeros(bootstrap, dtype=float) - y0_b = np.zeros(bootstrap, dtype=float) - - for bb in range(bootstrap): - bdx = np.random.choice(edx, N_good) - if weighting == 'var': - sigma_x_b = xe[bdx] - sigma_y_b = ye[bdx] - elif weighting == 'std': - sigma_x_b = xe[bdx]**0.5 - sigma_y_b = ye[bdx]**0.5 - - if use_scipy: - vx_opt_b, vx_cov_b = curve_fit(linear, dt[bdx], x[bdx], p0=vx_opt, sigma=sigma_x_b, - absolute_sigma=absolute_sigma) - vy_opt_b, vy_cov_b = curve_fit(linear, dt[bdx], y[bdx], p0=vy_opt, sigma=sigma_y_b, - absolute_sigma=absolute_sigma) - vx_b[bb] = vx_opt_b[0] - x0_b[bb] = vx_opt_b[1] - vy_b[bb] = vy_opt_b[0] - y0_b[bb] = vy_opt_b[1] - - else: - result_vx_b = linear_fit(dt[bdx], x[bdx], sigma=sigma_x_b, absolute_sigma=absolute_sigma) - result_vy_b = linear_fit(dt[bdx], y[bdx], sigma=sigma_y_b, absolute_sigma=absolute_sigma) - vx_b[bb] = result_vx_b['slope'] - x0_b[bb] = result_vx_b['intercept'] - vy_b[bb] = result_vy_b['slope'] - y0_b[bb] = result_vy_b['intercept'] - - # Save the errors from the bootstrap - self['vxe'][ss] = vx_b.std() - self['x0e'][ss] = x0_b.std() - self['vye'][ss] = vy_b.std() - self['y0e'][ss] = y0_b.std() - + self.add_column( + Column(data=coldata, name=f"{param}_mm"), + rename_duplicate=True, + ) + + # Add a column to keep track of the number of points used in a fit and number of bootstrap used. + self.meta['n_bootstrap'] = bootstrap + + + ########################### + ######### FITTING ######### + ########################### + unique_motion_models, unique_inv_indices = np.unique(self['motion_model_used'], return_inverse=True) + if select_stars is not None: + select_stars = np.asarray(select_stars) + if select_stars.dtype == bool: + select_stars = np.flatnonzero(select_stars) else: - if use_scipy: - vxe, x0e = np.sqrt(vx_cov.diagonal()) - vye, y0e = np.sqrt(vy_cov.diagonal()) - else: - vxe = result_vx['e_slope'] - x0e = result_vx['e_intercept'] - vye = result_vy['e_slope'] - y0e = result_vy['e_intercept'] - - self['vxe'][ss] = vxe - self['x0e'][ss] = x0e - self['vye'][ss] = vye - self['y0e'][ss] = y0e - - elif N_good == 2: - # Not enough epochs to fit a velocity. - dx = np.diff(x)[0] - dy = np.diff(y)[0] - dt_diff = np.diff(dt)[0] - - if weighting == 'var': - sigma_x = 1./xe**2 - sigma_y = 1./ye**2 - elif weighting == 'std': - sigma_x = 1./np.abs(xe) - sigma_y = 1./np.abs(ye) - - self['x0'][ss] = np.average(x, weights=sigma_x) - self['y0'][ss] = np.average(y, weights=sigma_y) - self['x0e'][ss] = np.abs(dx) / 2**0.5 - self['y0e'][ss] = np.abs(dy) / 2**0.5 - self['vx'][ss] = dx / dt_diff - self['vy'][ss] = dy / dt_diff - self['vxe'][ss] = 0.0 - self['vye'][ss] = 0.0 - self['chi2_vx'][ss] = calc_chi2(dt, x, sigma_x, self['vx'][ss], self['x0'][ss]) - self['chi2_vy'][ss] = calc_chi2(dt, y, sigma_y, self['vy'][ss], self['y0'][ss]) - + select_stars = np.asarray(select_stars, dtype=int) + indices_by_motion_model = {key: np.intersect1d(select_stars, np.flatnonzero(unique_inv_indices == k)) for k, key in enumerate(unique_motion_models)} else: - # N_good == 1 case - self['n_vfit'][ss] = 1 - self['x0'][ss] = x - self['y0'][ss] = y - - if 'xe' in self.colnames: - self['x0e'] = xe - self['y0e'] = ye + indices_by_motion_model = {key: np.flatnonzero(unique_inv_indices == k) for k, key in enumerate(unique_motion_models)} + + # Unmasked indices for each star: + unmasked_idx = [np.flatnonzero(valid_xy[i]) for i in range(N_stars)] + + # For each motion model + for unique_motion_model, unique_index in indices_by_motion_model.items(): + # Create motion model instance + motion_model_instance = input_mm_map[unique_motion_model]() + param_names = motion_model_instance.fit_param_names + # Initialize arrays to store results + n_stars_this_model = len(unique_index) + n_params = len(param_names) + + params_array = np.full((n_stars_this_model, n_params), fill_value, dtype=float) + param_errs_array = np.full((n_stars_this_model, n_params), np.inf, dtype=float) + chi2_x_array = np.full(n_stars_this_model, np.nan, dtype=float) + chi2_y_array = np.full(n_stars_this_model, np.nan, dtype=float) + + # Prepare data as lists of arrays for faster access during fitting + t_stars = [np.array(t_data[i][unmasked_idx[i]]) for i in unique_index] + x_stars = [np.array(x_data[i][unmasked_idx[i]]) for i in unique_index] + y_stars = [np.array(y_data[i][unmasked_idx[i]]) for i in unique_index] + xe_stars = [np.array(xe_data[i][unmasked_idx[i]]) for i in unique_index] if with_xe_ye else [np.ones_like(x_star) for x_star in x_stars] + ye_stars = [np.array(ye_data[i][unmasked_idx[i]]) for i in unique_index] if with_xe_ye else [np.ones_like(y_star) for y_star in y_stars] + + # For each star + if len(unique_index) > 0: + if processes > 1: + # Use multiprocessing to fit stars in parallel + arguments = [( + motion_model_instance, + t_stars[idx], + x_stars[idx], + y_stars[idx], + xe_stars[idx], + ye_stars[idx], + fixed_params_stars[i_star], + weighting, + use_scipy, + absolute_sigma, + fill_value, + True, + bootstrap, + seed, + verbose + ) for idx, i_star in enumerate(unique_index)] + + with Pool(processes) as pool: + results = list(pool.starmap( + fit_motion_model, + tqdm( + arguments, + desc=f"Fitting motion model {unique_motion_model} with {processes} processes", + disable=not verbose + ), + chunksize=chunksize + )) + + for idx, (params, param_errs, chi2_x, chi2_y) in enumerate(results): + params_array[idx] = params + param_errs_array[idx] = param_errs + chi2_x_array[idx] = chi2_x + chi2_y_array[idx] = chi2_y + else: + # Expensive for loop! Prepare everything beforehand to speed up. + for idx, i_star in enumerate(tqdm(unique_index, disable=not verbose, desc=f"Fitting motion model {unique_motion_model}")): + # Fit the star + params, param_errs, chi2_x, chi2_y = motion_model_instance.fit( + t=t_stars[idx], + x=x_stars[idx], + y=y_stars[idx], + xe=xe_stars[idx], + ye=ye_stars[idx], + fixed_params_dict=fixed_params_stars[i_star], + weighting=weighting, + use_scipy=use_scipy, + absolute_sigma=absolute_sigma, + method=method, + fill_value=fill_value, + return_chi2=True, + bootstrap=bootstrap, + seed=seed, + verbose=verbose + ) + params_array[idx] = params + param_errs_array[idx] = param_errs + chi2_x_array[idx] = chi2_x + chi2_y_array[idx] = chi2_y + + # Store results back to the table + for j, param_name in enumerate(param_names): + self[param_name][unique_index] = params_array[:, j] + self[param_name + '_err'][unique_index] = param_errs_array[:, j] + self['chi2_x'][unique_index] = chi2_x_array + self['chi2_y'][unique_index] = chi2_y_array + self['t0'][unique_index] = t0[unique_index] + + # Update n_params regardless of selections + for mm in motion_model_used: + self['n_params'][self['motion_model_used'] == mm.name] = mm.n_params return - - - def fit_velocities_all_detected(self, weighting='var', use_scipy=False, absolute_sigma=False, epoch_cols='all', mask_val=None, art_star=False, return_result=False): - """Fit velocities for stars detected in all epochs specified by epoch_cols. - Criterion: xe/ye error > 0 and finite, x/y not masked. + + def infer_positions(self, times, fixed_params_dict=None, fill_value=np.nan): + """Infer star positions at given times using fitted motion models. Parameters ---------- - weighting : str, optional - Variance weighting('var') or standard deviation weighting ('std'), by default 'var' - use_scipy : bool, optional - Use scipy.curve_fit or flystar.fit_velocity.fit_velocity, by default False - absolute_sigma : bool, optional - Absolute sigma or rescaled sigma, by default False - epoch_cols : str or list of intergers, optional - List of epoch column indices used for fitting velocity, by default 'all' - mask_val : float, optional - Values in x, y to be masked - art_star : bool, optional - Artificial star or observation star catalog. If artificial star, use 'det' column to select stars detected in all epochs, by default False - return_result : bool, optional - Return the velocity results or not, by default False - + times : array_like + Times at which to predict positions. Scalar, or (N_times,) array, or (N_stars, N_times) array. + fixed_params_dict : None or dict, optional + Dictionary of fixed parameters to use for prediction. + If not provided, will try to look for fixed parameters in the meta data then in table columns. + If fixed params are found in both the table and the fixed_params_dict, the values in the table will be used and the fixed_params_dict values will be ignored, + by default None + fill_value : float, optional + Value to use for missing data, by default np.nan + Returns ------- - vel_result : astropy Table - Astropy Table with velocity results + x, y, xe, ye : ndarray + Arrays of predicted x, y positions and their uncertainties xe, ye, with shape (N_stars, N_times) or (N_stars,) if N_times=1, or (N_times,) if N_stars=1, or scalar. """ - + assert 'motion_model_used' in self.colnames, \ + "infer_positions: 'motion_model_used' column not found in the table. Please run fit_motion_models first." + N_stars = len(self) - - if epoch_cols == 'all': - epoch_cols = np.arange(np.shape(self['x'])[1]) - - # Artificial Star - if art_star: - detected_in_all_epochs = np.all(self['det'][:, epoch_cols], axis=1) - - # Observation Star + times = np.atleast_1d(times) + N_times = len(times) + + x_pred = np.full((N_stars, N_times), fill_value, dtype=float) + y_pred = np.full((N_stars, N_times), fill_value, dtype=float) + + # Only calculate xe ye if columns exist in table, otherwise fill with np.inf + if 'x0_err' in self.colnames and 'y0_err' in self.colnames: + # 'x0_err' and 'y0_err' are the common uncertainty params for all motion models + with_xe_ye = True + xe_pred = np.full((N_stars, N_times), np.inf, dtype=float) + ye_pred = np.full((N_stars, N_times), np.inf, dtype=float) else: - valid_xe = np.all(self['xe'][:, epoch_cols]!=0, axis=1) & np.all(np.isfinite(self['xe'][:, epoch_cols]), axis=1) - valid_ye = np.all(self['ye'][:, epoch_cols]!=0, axis=1) & np.all(np.isfinite(self['ye'][:, epoch_cols]), axis=1) - - if mask_val: - x = np.ma.masked_values(self['x'][:, epoch_cols], mask_val) - y = np.ma.masked_values(self['y'][:, epoch_cols], mask_val) - - # If no mask, convert x.mask to list - if not np.ma.is_masked(x): - x.mask = np.zeros_like(self['x'][:, epoch_cols].data, dtype=bool) - if not np.ma.is_masked(y): - y.mask = np.zeros_like(self['y'][:, epoch_cols].data, dtype=bool) - - valid_x = ~np.any(x.mask, axis=1) - valid_y = ~np.any(y.mask, axis=1) - detected_in_all_epochs = np.logical_and.reduce(( - valid_x, valid_y, valid_xe, valid_ye - )) - else: - detected_in_all_epochs = np.logical_and(valid_xe, valid_ye) - - - # Fit velocities - vel_result = fit_velocity(self[detected_in_all_epochs], weighting=weighting, use_scipy=use_scipy, absolute_sigma=absolute_sigma, epoch_cols=epoch_cols, art_star=art_star) - vel_result = Table.from_pandas(vel_result) - - - # Add n_vfit - n_vfit = len(epoch_cols) - vel_result['n_vfit'] = n_vfit - - # Clean/remove up old arrays. - columns = [*vel_result.keys(), 'n_vfit'] - for column in columns: - if column in self.colnames: self.remove_column(column) - - # Update self - for column in columns: - column_array = np.ma.zeros(N_stars) - column_array[detected_in_all_epochs] = vel_result[column] - column_array[~detected_in_all_epochs] = np.nan - column_array.mask = ~detected_in_all_epochs - self[column] = column_array + with_xe_ye = False + xe_pred = np.full((N_stars, N_times), np.inf, dtype=float) + ye_pred = np.full((N_stars, N_times), np.inf, dtype=float) + + # Calculate the dictionary of {motion_model: indices of stars with this motion model} for faster access during prediction + unique_motion_models, unique_inv_indices = np.unique(self['motion_model_used'], return_inverse=True) + indices_by_motion_model = {key: np.flatnonzero(unique_inv_indices == k) for k, key in enumerate(unique_motion_models)} - if return_result: - return vel_result + mm_map = motion_model.motion_model_map() + # Prepare fit_params, fixed_params, fit_param_errs for each star + for unique_motion_model, unique_index in indices_by_motion_model.items(): + # Create motion model instance + motion_model_instance = mm_map[unique_motion_model]() + # Prepare parameters for prediction + fit_params = np.array([ + self[param_name][unique_index] for param_name in motion_model_instance.fit_param_names + ]).T # shape (N_stars_this_model, N_params) + + fit_param_errs = np.array([ + self[param_name + '_err'][unique_index] for param_name in motion_model_instance.fit_param_names + ]).T if with_xe_ye else None # shape (N_stars_this_model, N_params) + + # Construct fixed_params: Look for fixed_params_dict -> table columns -> meta data -> default value + fixed_params = fixed_params_dict.copy() if fixed_params_dict is not None else {} + for param in motion_model_instance.required_fixed_param_names: + if param not in fixed_params: + # If required fixed param not provided, find it in the table columns or meta data + if param in self.colnames: + fixed_params[param] = self[param][unique_index] + elif param in self.meta: + fixed_params[param] = self.meta[param] + else: + raise KeyError(f"infer_positions: Required fixed parameter '{param}' not found for motion model '{unique_motion_model}'. Please provide it in fixed_params_dict, or add it as a column in the table, or add it to the meta data.") + else: + fixed_params[param] = fixed_params_dict[param] + + for param, default_value in motion_model_instance.optional_fixed_params.items(): + if param not in fixed_params: + # If optional fixed param not provided, find it in the table columns or meta data, otherwise use default value + if param in self.colnames: + if param == 'obsLocation': + # Special case for obsLocation: no vectorization implemented yet, use the value from the first star + assert np.unique(self[param][unique_index]).size == 1, \ + f"infer_positions: obsLocation fixed parameter has different values ({np.unique(self[param][unique_index])}) for different stars. Vectorized handling not implemented yet." + fixed_params[param] = self[param][unique_index] + elif param in self.meta: + fixed_params[param] = self.meta[param] + else: + fixed_params[param] = default_value + else: + fixed_params[param] = fixed_params_dict[param] + + + # Predict positions + # shape = (N_stars_this_model, N_times) or (N_stars_this_model,) if N_times=1 or (N_times,) if N_stars_this_model=1 or scalar + if with_xe_ye: + x, y, xe, ye = motion_model_instance.model( + times, fit_params, fit_param_errs, fixed_params + ) + else: + x, y = motion_model_instance.model( + times, fit_params, fixed_params=fixed_params + ) + + if N_stars==1 and N_times > 1: + # Reshape (N_times,) to (1, N_times) + x = x[np.newaxis, :] + y = y[np.newaxis, :] + if with_xe_ye: + xe = xe[np.newaxis, :] + ye = ye[np.newaxis, :] + elif N_times==1 and N_stars > 1: + # Reshape (N_stars,) to (N_stars, 1) + x = x[:, np.newaxis] + y = y[:, np.newaxis] + if with_xe_ye: + xe = xe[:, np.newaxis] + ye = ye[:, np.newaxis] + + x_pred[unique_index] = x + y_pred[unique_index] = y + if with_xe_ye: + xe_pred[unique_index] = xe + ye_pred[unique_index] = ye + + if N_stars==1 or N_times==1: + # Reshape back to 1D array or scalar + x_pred = x_pred.flatten() + y_pred = y_pred.flatten() + if with_xe_ye: + xe_pred = xe_pred.flatten() + ye_pred = ye_pred.flatten() + + xe_pred = xe_pred if with_xe_ye else np.full_like(x_pred, np.inf) + ye_pred = ye_pred if with_xe_ye else np.full_like(y_pred, np.inf) + return x_pred, y_pred, xe_pred, ye_pred + + + # New function, to use in align + def get_star_positions_at_time(self, t, motion_model_dict, allow_alt_models=True): + """ Get current x,y positions of each star according to its motion_model + """ + # Start with empty arrays so we can fill them in batches + N_stars = len(self) + if hasattr(t, "__len__"): + x = np.full((N_stars,len(t)), np.nan, dtype=float) + y = np.full((N_stars,len(t)), np.nan, dtype=float) + xe = np.full((N_stars,len(t)), np.nan, dtype=float) + ye = np.full((N_stars,len(t)), np.nan, dtype=float) else: - return \ No newline at end of file + x = np.full(N_stars, np.nan, dtype=float) + y = np.full(N_stars, np.nan, dtype=float) + xe = np.full(N_stars, np.nan, dtype=float) + ye = np.full(N_stars, np.nan, dtype=float) + + # TODO: probably worth some additional testing here + # Check which motion models we need + # use complex_mms to collect models besides Fixed and Linear + unique_mms = np.unique(self['motion_model_input']).tolist() + # Calculate current position in batches by motion model + for mm in unique_mms: + try: + # Identify stars with this model & get class + idx = np.where(self['motion_model_input']==mm)[0] + mod = motion_model_dict[mm] + # Set up parameters + param_dict = {} + for par in mod.fit_param_names + mod.fixed_param_names + [pm+'_err' for pm in mod.fit_param_names]: + param_dict[par] = self[par][idx] + x[idx],y[idx],xe[idx],ye[idx] = mod.get_batch_pos_at_time(t,**param_dict) + except: + pass + if np.isnan(x).any() and allow_alt_models: + re_calc = np.where(np.isnan(x))[0] + unique_mms = np.unique(self['motion_model_used'][re_calc]).tolist() + # Calculate current position in batches by motion model + for mm in unique_mms: + # Identify stars with this model & get class + idx_0 = np.where(self['motion_model_used']==mm)[0] + idx = np.intersect1d(re_calc, idx_0) + mod = motion_model_dict[mm] + # Set up parameters + param_dict = {} + for par in motion_model.get_one_motion_model_param_names(mm,with_errors=True,with_fixed=True): + param_dict[par] = self[par][idx] + x[idx],y[idx],xe[idx],ye[idx] = mod.get_batch_pos_at_time(t,**param_dict) + + return x, y, xe, ye + + + + def shift_reference_frame(self, delta_vx=0.0, delta_vy=0.0, delta_pi=0.0, fixed_params_dict=None): + """ + After completing an alignment, shift from your relative reference frame to + the absolute frame using either Gaia or a Galactic model. This modified the + motion model fit parameters as well as the time series astrometry, assuming + zero error on the shift values. + + Parameters + ---------- + delta_vx : float, optional + velocity shift in x-direction (as/yr) + delta_vy : float, optional + velocity shift in y-direction (as/yr) + delta_pi : float, optional + parallax shift (as) + fixed_params_dict : None or dict, optional + Dictionary of fixed parameters to use for prediction: ra, dec, obsLocation, specifically in this case + """ + if delta_vx==0.0 and delta_vy==0.0 and delta_pi==0.0: + print("No shifts input, reference frame unchanged.") + print("Specify delta_vx, delta_vy, and/or delta_pi to perform a reference frame shift.") + return + self['vx'] += delta_vx + self['x'] += delta_vx*(self['t']-self['t0'][:, np.newaxis]) + self['vy'] += delta_vy + self['y'] += delta_vy*(self['t']-self['t0'][:, np.newaxis]) + if delta_pi!=0.0: + fixed_params_dict = {} if fixed_params_dict is None else fixed_params_dict + if 'ra' not in fixed_params_dict or 'dec' not in fixed_params_dict: + raise KeyError("shift_reference_frame: 'ra' and 'dec' must be provided in fixed_params_dict for parallax shift.") + from .motion_model import Parallax + ra = fixed_params_dict['ra'] + dec = fixed_params_dict['dec'] + pa = fixed_params_dict.get('pa', 0.0) + obsLocation = fixed_params_dict.get('obsLocation', 'earth') + t_all = self['t'][np.where(~np.any(np.isnan(self['t']), axis=1))[0][0]] + t_mjd = Time(t_all, format='decimalyear', scale='utc').mjd + pvec = Parallax().calc_parallax_vector(t_mjd, ra=ra, dec=dec, pa=pa, obsLocation=obsLocation) + self['pi'] += delta_pi + self['x'] += delta_pi*pvec[:, 0, :] # Shape (N_stars, N_times) + self['y'] += delta_pi*pvec[:, 1, :] # Shape (N_stars, N_times) + return + +def shift_reference_frame(table, delta_vx=0.0, delta_vy=0.0, delta_pi=0.0, fixed_params_dict=None): + """ + After completing an alignment, shift from your relative reference frame to + the absolute frame using either Gaia or a Galactic model. This modified the + motion model fit parameters as well as the time series astrometry, assuming + zero error on the shift values. + + Parameters + ---------- + delta_vx : float, optional + velocity shift in x-direction (as/yr) + delta_vy : float, optional + velocity shift in y-direction (as/yr) + delta_pi : float, optional + parallax shift (as) + """ + if delta_vx==0.0 and delta_vy==0.0 and delta_pi==0.0: + print("No shifts input, reference frame unchanged.") + print("Specify delta_vx, delta_vy, and/or delta_pi to perform a reference frame shift.") + return + table['vx'] += delta_vx + table['x'] += delta_vx*(table['t']-table['t0'][:, np.newaxis]) + table['vy'] += delta_vy + table['y'] += delta_vy*(table['t']-table['t0'][:, np.newaxis]) + if delta_pi!=0.0: + from .motion_model import Parallax + fixed_params_dict = {} if fixed_params_dict is None else fixed_params_dict + if 'ra' not in fixed_params_dict or 'dec' not in fixed_params_dict: + raise KeyError("shift_reference_frame: 'ra' and 'dec' must be provided in fixed_params_dict for parallax shift.") + ra = fixed_params_dict['ra'] + dec = fixed_params_dict['dec'] + pa = fixed_params_dict.get('pa', 0.0) + obsLocation = fixed_params_dict.get('obsLocation', 'earth') + t_all = table['t'][np.where(~np.any(np.isnan(table['t']), axis=1))[0][0]] + t_mjd = Time(t_all, format='decimalyear', scale='utc').mjd + pvec = Parallax().calc_parallax_vector(t_mjd, ra=ra, dec=dec, pa=pa, obsLocation=obsLocation) + table['pi'] += delta_pi + table['x'] += delta_pi*pvec[:, 0, :] # Shape (N_stars, N_times) + table['y'] += delta_pi*pvec[:, 1, :] # Shape (N_stars, N_times) + return table + + +# Helper function to fit motion model for each star for multiprocessing +def fit_motion_model( + motion_model_instance, + t, x, y, xe, ye, + fixed_params_dict, + weighting, + use_scipy, + absolute_sigma, + fill_value, + return_chi2, + bootstrap, + seed, + verbose +): + return motion_model_instance.fit( + t=t, + x=x, + y=y, + xe=xe, + ye=ye, + fixed_params_dict=fixed_params_dict, + weighting=weighting, + use_scipy=use_scipy, + absolute_sigma=absolute_sigma, + fill_value=fill_value, + return_chi2=return_chi2, + bootstrap=bootstrap, + seed=seed, + verbose=verbose + ) \ No newline at end of file diff --git a/flystar/stitch_method2.py b/flystar/stitch_method2.py index 8cab361..f9aa4e0 100644 --- a/flystar/stitch_method2.py +++ b/flystar/stitch_method2.py @@ -42,7 +42,7 @@ def align_starlists(starlist, ref, transModel=transforms.PolyTransform, order=2, if weights==None, we don't use weights. """ - + #-------------------------------------------------- # Initial transformation with brightest briteN stars #-------------------------------------------------- @@ -98,7 +98,7 @@ def weighted_mean(df,x,xe,frames_in_use): # error = xe or ye # all_frames = e.g. ['A', 'B', 'C', ...] - + cols_x=["{0}_{1}".format(x,f) for f in frames_in_use] # columns for x_* e.g. ['x_A', 'x_B', 'x_C', ....] cols_xe=["{0}_{1}".format(xe,f) for f in frames_in_use] # columns for xe_* e.g. ['xe_A', 'xe_B', 'xe_C', ....] @@ -120,11 +120,11 @@ def weighted_mean(df,x,xe,frames_in_use): xe_master.append(array_xe[i][mask][0]) else: rows_to_drop.append(i) - + df=df.drop(rows_to_drop) df[x]=np.array(x_master) df[xe]=np.array(xe_master) - + return df @@ -132,12 +132,12 @@ def normal_mean(df,x,frames_in_use): cols_x=["{0}_{1}".format(x,f) for f in frames_in_use] df[x]=df[cols_x].mean(axis=1) - + return df def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaster='./master.lis'): - + # all_starslist: the list of the names of all starlists e.g. ['A', 'B', 'C', ... ] # name_initial_ref: the name of the reference that you use in the very first match. # corr_thresh : threshold for correlation values. @@ -149,11 +149,11 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste input_starslists.remove(name_initial_ref) for name_starlist in input_starslists: - + starlist=starlists.read_starlist('{0}.lis'.format(name_starlist)) if 'ref' not in locals(): ref=starlists.read_starlist('{0}.lis'.format(name_initial_ref)) - + #------------ Choose good stars to use for a trans object -------------------- @@ -162,14 +162,14 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste # Select the very first 11 columns (i.e. the master reference) consistent with those of the starlist. # Table -> dataframe -> Table, which lets us avoid the following error: 'MaskedColumn' object has no attribute '_mask' - + ref_for_align=ref_for_align.to_pandas() - + ref_for_align=Table.from_pandas(ref_for_align[starlist_for_align.colnames]) _,_,_,trans=align_starlists(starlist_for_align,ref_for_align,order=2,dr_tol=1,N_loop=15) - + #------------ Transform the whole starlist using the trans object and match with the reference ------------- starlist_transformed=align.transform_from_object(starlist,trans) @@ -183,7 +183,7 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste #-------------Convert the astropy talbes into dataframes --------------------- df_ref=ref.to_pandas() df_starlist_transformed=starlist_transformed.to_pandas() - + #-------------Columns 11-21 contain the measurments for the initial reference-------------- colnames=starlist.colnames @@ -199,11 +199,11 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste for col in colnames: df_ref['{0}_{1}'.format(col,name_starlist)]=np.nan df_ref.loc[idx_ref_matched,'{0}_{1}'.format(col,name_starlist)]= np.array(df_starlist_transformed.loc[idx_starlist_transformed_matched,col]) - + else: for col in colnames: - + df_ref.insert(len(df_ref.columns),'{0}_{1}'.format(col,name_starlist),np.nan) df_ref.loc[idx_ref_matched,'{0}_{1}'.format(col,name_starlist)]= np.array(df_starlist_transformed.loc[idx_starlist_transformed_matched,col]) @@ -218,7 +218,7 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste #-------------- Figure out which frames are currently included in the master frame ----------- frames_in_use=sorted(set([column[-1] for column in columns if (column[-1] in all_starlists)])) - + #-------------- Average the measurements ------------- for col in colnames: if (col!='name') and (col!='x') and (col!='y') and (col!='xe') and (col!='ye') and (col!='N_frames'): @@ -226,7 +226,7 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste df_comb=weighted_mean(df_comb,'x','xe',frames_in_use) df_comb=weighted_mean(df_comb,'y','ye',frames_in_use) - + #-------------Recalculate 'N_frames' for the master frame -> N_frames = the number of input starlists containing the star----------- # N_frames = the number of notnull columns at each row in the master frame divided by the number of columns in an input starlist, then minus one. # The "minus one" at the end accounts for the very first columns, i.e. master columns, that contain the averaged values of all the input starlists. @@ -244,7 +244,7 @@ def stitch(all_starlists, name_initial_ref, N_iter=5, corr_thresh=0.8, outMaste #-------------- Convert the final dataframe back into an astropy table ------ ref=Table.from_pandas(df_comb) - + ref.write(outMaster,format='ascii.commented_header', header_start=-1, overwrite=True) return diff --git a/flystar/template.py b/flystar/template.py index c714f9d..1373799 100644 --- a/flystar/template.py +++ b/flystar/template.py @@ -8,28 +8,28 @@ import pdb -def align_template(labelFile, reference, transModel=transforms.PolyTransform, order=1, N_loop=2, +def align_template(labelFile, reference, transModel=transforms.PolyTransform, order=1, N_loop=2, dr_tol=1.0, dm_tol=None, briteN=100, weights='both', restrict=False, outFile='outTrans.txt'): """ Base example of how to use the flystar code. Assumes we are transforming a label.dat into a reference starlist. - + Parameters: ----------- labelFile: ascii file Starlist we would like to transform into the reference frame. For this code, we expect a label.dat file - + reference: ascii file Starlist that defines the reference frame - + transModel: transformation class (default: transforms.polyTransform) Defines which transformation model to use. Both the four-parameter and polynomial transformations are supported - + order: int (default=1) Order of the polynomial transformation. Only used for polynomial transform - + N_loop: int (default=2) How many times to iterate on the transformation calculation. Ideally, each iteration adds more stars and thus a better transform, to some @@ -39,11 +39,11 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or the distance tolerance for matching two stars in align.transform_and_match dm_tol: float (defalut=None) - the magnitude tolerance for matching two stars in align.trnasform_and_match + the magnitude tolerance for matching two stars in align.trnasform_and_match briteN: int (default=100) the number of stars used in blind matching - + weights: string (default='both') if weights=='both', we use both position error in transformed starlist and reference starlist as uncertanty. And weights is the reciprocal of this uncertanty. @@ -66,7 +66,7 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or tref = starlist['t'][0] # label.dat has position & position err and velocity & velocity error label = starlists.read_label(labelFile, prop_to_time=tref, flipX=True) - + #-------------------------------------------------- # Initial transformation with brightest briteN stars @@ -79,21 +79,21 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or # and calculate initial transform label_ini = label[idx_ini_label] starlist_ini = starlist[idx_ini_starlist] - + trans = align.initial_align(label_ini, starlist_ini, briteN=briteN, transformModel=transModel, order=order) - + # apply the initial transform to label.dat # this is used for future weights calculation label_trans_ini = align.transform_from_object(label, trans) - + #------------------------------------------------------------------------ # Use transformation to match starlists, then recalculate transformation. #------------------------------------------------------------------------ # Iterate on this as many times as desired for i in range(N_loop): - # apply the transformation to label.dat and + # apply the transformation to label.dat and # matched the transformed label with starlist. idx_label, idx_starlist = align.transform_and_match(label, starlist, trans, dr_tol=dr_tol, dm_tol=dm_tol) @@ -101,17 +101,17 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or if restrict: label_match = label[idx_label] starlist_match = starlist[idx_starlist] - idx_label, idx_starlist = stalists.restrict_by_use(label_match, starlist_match, + idx_label, idx_starlist = stalists.restrict_by_use(label_match, starlist_match, idx_label, idx_starlist) - + # use the matched stars to calculate new transformation label_match = label[idx_label] starlist_match = starlist[idx_starlist] label_ini_match = label_trans_ini[idx_label] - trans, N_trans = align.find_transform(label_match, label_ini_match, starlist_match, + trans, N_trans = align.find_transform(label_match, label_ini_match, starlist_match, transModel=transModel, order=order, weights = weights) - + #--------------------------------------------- # Write final transform in java align format @@ -121,7 +121,7 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or # write the transformation coefficients to 'outTrans.txt' align.write_transform(trans, labelFile, reference, N_trans, deltaMag=delta_m, restrict=restrict, weights=weights, outFile=outFile) - + #----------------------------------------------------------- # Test transform: apply to label.dat, make diagnostic plots @@ -129,11 +129,11 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or # apply the final transformation to label.dat label_trans = align.transform_from_object(label, trans) label_trans_match = label_trans[idx_label] - + # postion map with every star in starlist and transformed label. # both matched and unmatched stars. plots.trans_positions( starlist, starlist_match, label_trans, label_trans_match) - + # position difference histogram for matched stars. plots.pos_diff_hist( starlist_match, label_trans_match) @@ -146,6 +146,6 @@ def align_template(labelFile, reference, transModel=transforms.PolyTransform, or # quiver plot of postion residules plots.pos_diff_quiver( starlist_match, label_trans_match) - + return - + diff --git a/flystar/tests/compare_branches.py b/flystar/tests/compare_branches.py new file mode 100644 index 0000000..6dd71b8 --- /dev/null +++ b/flystar/tests/compare_branches.py @@ -0,0 +1,45 @@ +import pickle +import flystar +import matplotlib.pyplot as plt +from flystar import align, transforms, motion_model +from flystar.plots import plot_stars + +branch = 'mm_rework_lingfeng' # 'mm_rework_lingfeng' or 'mm_rework' + +test_data_path = f'{flystar.__path__[0]}/tests/test_data' + +with open(f'{test_data_path}/my_gaia.pkl', 'rb') as f: + my_gaia = pickle.load(f) +with open(f'{test_data_path}/list_of_starlists.pkl', 'rb') as f: + list_of_starlists = pickle.load(f) +ra_deg, dec_deg = 18.0, -30.0 +my_gaia.remove_column('motion_model_used') +# my_gaia['motion_model_input'] = 'Fixed' +if branch == 'mm_rework_lingfeng': + msc = align.MosaicToRef(my_gaia, list_of_starlists, iters=1, + dr_tol=[0.2], dm_tol=[5], + outlier_tol=[None], mag_lim=[6, 20], + trans_class=transforms.PolyTransform, + trans_args=[{'order': 1}], + motion_models=['Fixed', 'Parallax'], + fixed_params_dict = {'ra':ra_deg, 'dec':dec_deg, 'pa':0.0, 'obsLocation':'earth'}, + use_ref_new=True, + update_ref_orig=False, + mag_trans=True, + trans_weights='both,std', + init_guess_mode='name', verbose=3) +elif branch == 'mm_rework': + msc = align.MosaicToRef(my_gaia, list_of_starlists, iters=1, + dr_tol=[0.2], dm_tol=[5], + outlier_tol=[None], mag_lim=[6, 20], + trans_class=transforms.PolyTransform, + trans_args=[{'order': 1}], + default_motion_model='Parallax', + motion_model_dict = {'Parallax': motion_model.Parallax(RA=ra_deg, Dec=dec_deg, PA=0.0, obsLocation='earth')}, + use_ref_new=True, + update_ref_orig=False, + mag_trans=True, + trans_weights='both,std', + init_guess_mode='name', verbose=3) + +msc.fit() \ No newline at end of file diff --git a/flystar/tests/test_align.ipynb b/flystar/tests/test_align.ipynb deleted file mode 100644 index 02442b9..0000000 --- a/flystar/tests/test_align.ipynb +++ /dev/null @@ -1,366 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Notebook for Running Align Tests" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from flystar.tests import test_align\n", - "from flystar import starlists\n", - "from astropy.table import Table" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Test: make_fake_starlists_poly1_vel\n", - "\n", - "Just make sure the tables look sensible and are in the right units." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " name m0 m0e ... vye t0 \n", - "-------- ----------------- -------------------- ... ------------------- ------\n", - "star_155 9.106905292995506 0.054167528156861204 ... 0.1564397531527286 2019.5\n", - "star_113 9.153031462110043 0.0421090989942197 ... 0.08128628950126615 2019.5\n", - "star_077 9.16547870263162 0.02021147759307802 ... 0.05907352582911862 2019.5\n", - "star_069 9.169817788300977 0.027788213230369625 ... 0.04965351499764548 2019.5\n", - "star_037 9.173200786855755 0.007665400875860144 ... 0.22723357600795704 2019.5\n", - " name m me ... ye t \n", - "-------- ----------------- -------------------- ... -------------------- ------\n", - "star_155 9.198437965086988 0.054167528156861204 ... 0.02649499466969545 2018.5\n", - "star_113 9.257333243243941 0.0421090989942197 ... 0.02606700846524875 2018.5\n", - "star_077 9.252158908537464 0.02021147759307802 ... 0.04250920654497108 2018.5\n", - "star_069 9.267901667333167 0.027788213230369625 ... 0.042689240225924296 2018.5\n", - "star_037 9.276780126418494 0.007665400875860144 ... 0.03592203011554212 2018.5\n", - " name m me ... ye t \n", - "-------- ----------------- -------------------- ... -------------------- ------\n", - "star_155 9.478887659623185 0.054167528156861204 ... 0.02649499466969545 2019.5\n", - "star_113 9.569878576042546 0.0421090989942197 ... 0.02606700846524875 2019.5\n", - "star_077 9.575998150724095 0.02021147759307802 ... 0.04250920654497108 2019.5\n", - "star_069 9.593581807234129 0.027788213230369625 ... 0.042689240225924296 2019.5\n", - "star_037 9.553127108740597 0.007665400875860144 ... 0.03592203011554212 2019.5\n", - "['name', 'm0', 'm0e', 'x0', 'x0e', 'y0', 'y0e', 'vx', 'vxe', 'vy', 'vye', 't0']\n", - "['name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't']\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jlu/code/python/flystar/flystar/starlists.py:386: UserWarning: The StarList class requires a arguments('name', 'x', 'y', 'm')\n", - " warnings.warn(err_msg, UserWarning)\n" - ] - } - ], - "source": [ - "test_align.make_fake_starlists_poly1_vel()\n", - "\n", - "ref = Table.read('random_vel_ref.fits')\n", - "lis0 = Table.read('random_vel_0.fits')\n", - "lis1 = Table.read('random_vel_1.fits')\n", - "\n", - "print(ref[0:5])\n", - "print(lis0[0:5])\n", - "print(lis1[0:5])\n", - "\n", - "print(ref.colnames)\n", - "print(lis0.colnames)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## test_align_vel\n", - "\n", - "Make sure it runs, make some plots along the way, etc." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jlu/code/python/flystar/flystar/starlists.py:386: UserWarning: The StarList class requires a arguments('name', 'x', 'y', 'm')\n", - " warnings.warn(err_msg, UserWarning)\n", - "/Users/jlu/code/python/flystar/flystar/starlists.py:386: UserWarning: The StarList class requires a arguments('name', 'x', 'y', 'm')\n", - " warnings.warn(err_msg, UserWarning)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "**********\n", - "**********\n", - "Starting iter 0 with ref_table shape: (200, 1)\n", - "**********\n", - "**********\n", - " \n", - " **********\n", - " Matching catalog 1 / 4 in iteration 0 with 200 stars\n", - " **********\n", - "initial_guess: 50 stars matched between starlist and reference list\n", - "initial_guess: [-6.05144456e+00 1.01098279e+00 -2.50608887e-04] [-1.07161761e+01 4.89226304e-05 1.01096529e+00]\n", - " Found 0 duplicates out of 196 matches\n", - "In Loop 0 found 196 matches\n", - " Found 0 duplicates out of 196 matches\n", - " \n", - " **********\n", - " Matching catalog 2 / 4 in iteration 0 with 200 stars\n", - " **********\n", - "initial_guess: 49 stars matched between starlist and reference list\n", - "initial_guess: [-1.02158015e+02 1.02080743e+00 -1.45081519e-04] [-5.07779471e+01 -2.60729494e-05 9.99423500e-01]\n", - " Found 0 duplicates out of 200 matches\n", - "In Loop 0 found 200 matches\n", - " Found 0 duplicates out of 200 matches\n", - " \n", - " **********\n", - " Matching catalog 3 / 4 in iteration 0 with 200 stars\n", - " **********\n", - "initial_guess: 50 stars matched between starlist and reference list\n", - "initial_guess: [-2.14220566e-10 1.00000000e+00 -2.24089697e-16] [2.50622339e-10 0.00000000e+00 1.00000000e+00]\n", - " Found 0 duplicates out of 200 matches\n", - "In Loop 0 found 200 matches\n", - " Found 0 duplicates out of 200 matches\n", - " \n", - " **********\n", - " Matching catalog 4 / 4 in iteration 0 with 200 stars\n", - " **********\n", - "initial_guess: 50 stars matched between starlist and reference list\n", - "initial_guess: [-2.57803428e+02 1.03052409e+00 -5.28390832e-05] [ 2.49886631e+02 -6.00884405e-05 9.98642952e-01]\n", - " Found 0 duplicates out of 200 matches\n", - "In Loop 0 found 200 matches\n", - " Found 0 duplicates out of 200 matches\n", - " \n", - "**********\n", - "**********\n", - "Starting iter 1 with ref_table shape: (204, 4)\n", - "**********\n", - "**********\n", - " \n", - " **********\n", - " Matching catalog 1 / 4 in iteration 1 with 200 stars\n", - " **********\n", - " Found 0 duplicates out of 199 matches\n", - "In Loop 1 found 199 matches\n", - " Found 0 duplicates out of 199 matches\n", - " \n", - " **********\n", - " Matching catalog 2 / 4 in iteration 1 with 200 stars\n", - " **********\n", - " Found 0 duplicates out of 198 matches\n", - "In Loop 1 found 198 matches\n", - " Found 0 duplicates out of 199 matches\n", - " \n", - " **********\n", - " Matching catalog 3 / 4 in iteration 1 with 200 stars\n", - " **********\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jlu/code/python/flystar/flystar/starlists.py:386: UserWarning: The StarList class requires a arguments('name', 'x', 'y', 'm')\n", - " warnings.warn(err_msg, UserWarning)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Found 0 duplicates out of 200 matches\n", - "In Loop 1 found 200 matches\n", - " Found 0 duplicates out of 200 matches\n", - " \n", - " **********\n", - " Matching catalog 4 / 4 in iteration 1 with 200 stars\n", - " **********\n", - " Found 0 duplicates out of 200 matches\n", - "In Loop 1 found 200 matches\n", - " Found 0 duplicates out of 200 matches\n", - "**********\n", - "Final Matching\n", - "**********\n", - " Found 0 duplicates out of 199 matches\n", - "Matched 199 out of 200 stars in list 0\n", - " Found 0 duplicates out of 199 matches\n", - "Matched 199 out of 200 stars in list 1\n", - " Found 0 duplicates out of 200 matches\n", - "Matched 200 out of 200 stars in list 2\n", - " Found 0 duplicates out of 199 matches\n", - "Matched 199 out of 200 stars in list 3\n", - "\n", - " Preparing the reference table...\n" - ] - } - ], - "source": [ - "test_align.test_mosaic_lists_vel()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> /Users/jlu/code/python/flystar/flystar/align.py(3244)apply_mag_lim()\n", - "-> star_list_T.restrict_by_value(**conditions)\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) conditions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'m0_min': None, 'm0_max': None}\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) type(star_list_T)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) type(ref_list)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "*** NameError: name 'ref_list' is not defined\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) ref_list\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "*** NameError: name 'ref_list' is not defined\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) u\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> /Users/jlu/code/python/flystar/flystar/align.py(991)mosaic_lists()\n", - "-> ref_list_T = apply_mag_lim(ref_list, mag_lim[ref_index])\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) type(ref_list)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdin", - "output_type": "stream", - "text": [ - "(Pdb) q\n" - ] - } - ], - "source": [ - "import pdb\n", - "pdb.pm()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "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.6.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/flystar/tests/test_align.py b/flystar/tests/test_align.py index 026a8b1..4717d76 100644 --- a/flystar/tests/test_align.py +++ b/flystar/tests/test_align.py @@ -1,20 +1,18 @@ -from flystar import align -from flystar import starlists -from flystar import startables -from flystar import transforms -from flystar import analysis -from astropy.table import Table -import numpy as np -import pylab as plt import pdb -import datetime +import flystar +import numpy as np +import matplotlib.pyplot as plt +from astropy.table import Table +from flystar.plots import plot_stars +from flystar import align, starlists, transforms, analysis, motion_model +test_data_path = f'{flystar.__path__[0]}/tests/test_data' def test_MosaicSelfRef(): """ Cross-match and align 4 starlists using the OO version of mosaic lists. """ - list_files = ['A.lis', 'B.lis', 'C.lis', 'D.lis'] + list_files = [f'{test_data_path}/{f}' for f in ['A.lis', 'B.lis', 'C.lis', 'D.lis']] lists = [starlists.StarList.from_lis_file(lf) for lf in list_files] ########## @@ -27,70 +25,67 @@ def test_MosaicSelfRef(): trans_args={'order': 2}) msc.fit() - + # Check some of the output quantities on the final table. assert 'x0' in msc.ref_table.colnames - assert 'x0e' in msc.ref_table.colnames + assert 'x0_err' in msc.ref_table.colnames assert 'y0' in msc.ref_table.colnames - assert 'y0e' in msc.ref_table.colnames + assert 'y0_err' in msc.ref_table.colnames assert 'm0' in msc.ref_table.colnames - assert 'm0e' in msc.ref_table.colnames + assert 'm0_err' in msc.ref_table.colnames assert 'use_in_trans' in msc.ref_table.colnames assert 'used_in_trans' in msc.ref_table.colnames assert 'ref_orig' in msc.ref_table.colnames assert msc.ref_table['use_in_trans'].shape == msc.ref_table['x0'].shape assert msc.ref_table['used_in_trans'].shape == msc.ref_table['x'].shape - # Check that we have some matched stars... should be at least 35 stars # that are detected in all 4 starlists. idx = np.where(msc.ref_table['n_detect'] == 4)[0] - assert len(idx) > 35 + assert len(idx) > 35 # Check that the transformation error isn't too big - assert (msc.ref_table['x0e'] < 3.0).all() # less than 1 pix - assert (msc.ref_table['y0e'] < 3.0).all() - #assert (msc.ref_table['m0e'] < 1.0).all() # less than 0.5 mag - assert (msc.ref_table['m0e'] < 1.5).all() # less than 0.5 mag - + valid_err = np.isfinite(msc.ref_table['x0_err']) & np.isfinite(msc.ref_table['y0_err']) & np.isfinite(msc.ref_table['m0_err']) + assert (msc.ref_table['x0_err'][valid_err] < 3.0).all() # less than 1 pix + assert (msc.ref_table['y0_err'][valid_err] < 3.0).all() + #assert (msc.ref_table['m0_err'][valid_err] < 1.0).all() # less than 0.5 mag + assert (msc.ref_table['m0_err'][valid_err] < 1.5).all() # less than 0.5 mag # Check that the transformation lists aren't too wacky for ii in range(4): - np.testing.assert_almost_equal(msc.trans_list[ii].px.c1_0, 1.0, 2) - np.testing.assert_almost_equal(msc.trans_list[ii].py.c0_1, 1.0, 2) - + np.testing.assert_allclose(msc.trans_list[ii].px.c1_0, 1.0, rtol=1e-2) + np.testing.assert_allclose(msc.trans_list[ii].py.c0_1, 1.0, rtol=1e-2) # We didn't do any velocity fitting, so make sure nothing got created. assert 'vx' not in msc.ref_table.colnames assert 'vy' not in msc.ref_table.colnames - assert 'vxe' not in msc.ref_table.colnames - assert 'vye' not in msc.ref_table.colnames + assert 'vx_err' not in msc.ref_table.colnames + assert 'vy_err' not in msc.ref_table.colnames plt.clf() plt.plot(msc.ref_table['x'][:, 0], msc.ref_table['y'][:, 0], - 'k+', color='red', mec='red', mfc='none') + '+', color='red', mec='red', mfc='none') plt.plot(msc.ref_table['x'][:, 1], msc.ref_table['y'][:, 1], - 'kx', color='blue', mec='blue', mfc='none') + 'x', color='blue', mec='blue', mfc='none') plt.plot(msc.ref_table['x'][:, 2], msc.ref_table['y'][:, 2], - 'ko', color='cyan', mec='cyan', mfc='none') + 'o', color='cyan', mec='cyan', mfc='none') plt.plot(msc.ref_table['x'][:, 3], msc.ref_table['y'][:, 3], - 'k^', color='green', mec='green', mfc='none') + '^', color='green', mec='green', mfc='none') plt.plot(msc.ref_table['x0'], msc.ref_table['y0'], - 'k.', color='black', alpha=0.2) - + '.', color='black', alpha=0.2) return def test_MosaicSelfRef_vel_tconst(): """ Cross-match and align 4 starlists using the OO version of mosaic lists. The 4 lists are all taken at the same time (so 0 velocities should result). - + """ - list_files = ['A.lis', 'B.lis', 'C.lis', 'D.lis'] + list_files = [f'{test_data_path}/{f}' for f in ['A.lis', 'B.lis', 'C.lis', 'D.lis']] lists = [starlists.StarList.from_lis_file(lf) for lf in list_files] ########## @@ -100,70 +95,61 @@ def test_MosaicSelfRef_vel_tconst(): msc = align.MosaicSelfRef(lists, ref_index=0, iters=2, dr_tol=[3, 3], dm_tol=[1, 1], trans_class=transforms.PolyTransform, - trans_args={'order': 2}, use_vel=True, + trans_args={'order': 2}, + motion_models=['Empty', 'Fixed', 'Linear'], verbose=False) msc.fit() - + # Check some of the output quantities on the final table. assert 'x0' in msc.ref_table.colnames - assert 'x0e' in msc.ref_table.colnames + assert 'x0_err' in msc.ref_table.colnames assert 'y0' in msc.ref_table.colnames - assert 'y0e' in msc.ref_table.colnames + assert 'y0_err' in msc.ref_table.colnames assert 'm0' in msc.ref_table.colnames - assert 'm0e' in msc.ref_table.colnames - assert 'vx' in msc.ref_table.colnames - assert 'vxe' in msc.ref_table.colnames - assert 'vy' in msc.ref_table.colnames - assert 'vye' in msc.ref_table.colnames + assert 'm0_err' in msc.ref_table.colnames + # Since they are in the same epoch, no velocity information can be inferred + # assert 'vx' in msc.ref_table.colnames + # assert 'vx_err' in msc.ref_table.colnames + # assert 'vy' in msc.ref_table.colnames + # assert 'vy_err' in msc.ref_table.colnames assert 't0' in msc.ref_table.colnames # Check that we have some matched stars... should be at least 35 stars # that are detected in all 4 starlists. idx = np.where(msc.ref_table['n_detect'] == 4)[0] - assert len(idx) > 35 + assert len(idx) > 35 # Check that the transformation error isn't too big - assert (msc.ref_table['x0e'] < 3.0).all() # less than 1 pix - assert (msc.ref_table['y0e'] < 3.0).all() - assert (msc.ref_table['m0e'] < 1.0).all() # less than 0.5 mag - + valid_err = np.isfinite(msc.ref_table['x0_err']) & np.isfinite(msc.ref_table['y0_err']) & np.isfinite(msc.ref_table['m0_err']) + assert (msc.ref_table['x0_err'][valid_err] < 3.0).all() # less than 1 pix + assert (msc.ref_table['y0_err'][valid_err] < 3.0).all() + assert (msc.ref_table['m0_err'][valid_err] < 1.0).all() # less than 0.5 mag + # Check that the transformation lists aren't too wacky for ii in range(4): - np.testing.assert_almost_equal(msc.trans_list[ii].px.c1_0, 1.0, 2) - np.testing.assert_almost_equal(msc.trans_list[ii].py.c0_1, 1.0, 2) - - # Check that the velocities aren't crazy... - # they should be zero (since there is no time difference) - np.testing.assert_almost_equal(msc.ref_table['vx'], 0, 1) - np.testing.assert_almost_equal(msc.ref_table['vy'], 0, 1) - - assert (msc.ref_table['vx'] == 0).all() - assert (msc.ref_table['vy'] == 0).all() - assert (msc.ref_table['vxe'] == 0).all() - assert (msc.ref_table['vye'] == 0).all() - + np.testing.assert_allclose(msc.trans_list[ii].px.c1_0, 1.0, rtol=1e-2) + np.testing.assert_allclose(msc.trans_list[ii].py.c0_1, 1.0, rtol=1e-2) return def test_MosaicSelfRef_vel(): """ Cross-match and align 4 starlists using the OO version of mosaic lists. - """ - list_files = ['A.lis', 'B.lis', 'C.lis', 'D.lis'] + list_files = [f'{test_data_path}/{f}' for f in ['A.lis', 'B.lis', 'C.lis', 'D.lis']] lists = [starlists.StarList.from_lis_file(lf) for lf in list_files] # Modify the times so that we get velocities out. - lists[0].meta['list_time'] = 2001.4 + lists[0].meta['list_times'] = 2001.4 lists[0]['t'] = 2001.4 - - lists[1].meta['list_time'] = 2002.4 + + lists[1].meta['list_times'] = 2002.4 lists[1]['t'] = 2002.4 - - lists[2].meta['list_time'] = 2003.4 + + lists[2].meta['list_times'] = 2003.4 lists[2]['t'] = 2003.4 - - lists[3].meta['list_time'] = 2004.4 + + lists[3].meta['list_times'] = 2004.4 lists[3]['t'] = 2004.4 @@ -171,76 +157,67 @@ def test_MosaicSelfRef_vel(): # Test instantiation and basic fitting. ########## msc = align.MosaicSelfRef(lists, ref_index=0, iters=3, - dr_tol=[5, 3, 3], dm_tol=[1, 1, 0.5], outlier_tol=None, + dr_tol=[5, 3, 3], dm_tol=[1, 1, 0.5], outlier_tol=None, briteN=30, trans_class=transforms.PolyTransform, - trans_args={'order': 2}, use_vel=True, + trans_args={'order': 2}, motion_models=['Empty', 'Fixed', 'Linear'], verbose=False) msc.fit() - + # Check some of the output quantities on the final table. assert 'x0' in msc.ref_table.colnames - assert 'x0e' in msc.ref_table.colnames + assert 'x0_err' in msc.ref_table.colnames assert 'y0' in msc.ref_table.colnames - assert 'y0e' in msc.ref_table.colnames + assert 'y0_err' in msc.ref_table.colnames assert 'm0' in msc.ref_table.colnames - assert 'm0e' in msc.ref_table.colnames + assert 'm0_err' in msc.ref_table.colnames assert 'vx' in msc.ref_table.colnames - assert 'vxe' in msc.ref_table.colnames + assert 'vx_err' in msc.ref_table.colnames assert 'vy' in msc.ref_table.colnames - assert 'vye' in msc.ref_table.colnames + assert 'vy_err' in msc.ref_table.colnames assert 't0' in msc.ref_table.colnames # Check that we have some matched stars... should be at least 35 stars # that are detected in all 4 starlists. idx = np.where(msc.ref_table['n_detect'] == 4)[0] - assert len(idx) > 35 + assert len(idx) >= 35, f"Expected at least 35 stars detected in all 4 starlists, but only found {len(idx)}" # Check that the transformation error isn't too big - assert (msc.ref_table['x0e'] < 3.0).all() # less than 1 pix - assert (msc.ref_table['y0e'] < 3.0).all() - assert (msc.ref_table['m0e'] < 1.0).all() # less than 0.5 mag - + valid_err = np.isfinite(msc.ref_table['x0_err']) & np.isfinite(msc.ref_table['y0_err']) & np.isfinite(msc.ref_table['m0_err']) + assert (msc.ref_table['x0_err'][valid_err] < 3.0).all() # less than 1 pix + assert (msc.ref_table['y0_err'][valid_err] < 3.0).all() + assert (msc.ref_table['m0_err'][valid_err] < 1.0).all() # less than 0.5 mag + # Check that the transformation lists aren't too wacky for ii in range(4): - np.testing.assert_almost_equal(msc.trans_list[ii].px.c1_0, 1.0, 2) - np.testing.assert_almost_equal(msc.trans_list[ii].py.c0_1, 1.0, 2) + np.testing.assert_allclose(msc.trans_list[ii].px.c1_0, 1.0, rtol=2e-2) + np.testing.assert_allclose(msc.trans_list[ii].py.c0_1, 1.0, rtol=2e-2) - plt.clf() plt.plot(msc.ref_table['vx'], msc.ref_table['vy'], 'k.', color='black', alpha=0.2) + return def test_MosaicToRef(): - make_fake_starlists_poly1_vel(seed=42) - - ref_file = 'random_vel_ref.fits' - list_files = ['random_vel_0.fits', - 'random_vel_1.fits', - 'random_vel_2.fits', - 'random_vel_3.fits'] + make_fake_starlists_poly1(seed=42) - ref_list = Table.read(ref_file) + ref_file = f'{test_data_path}/random_ref.fits' + list_files = [f'{test_data_path}/random_{i}.fits' for i in range(8)] - # Convert velocities to arcsec/yr - ref_list['vx'] *= 1e-3 - ref_list['vy'] *= 1e-3 - ref_list['vxe'] *= 1e-3 - ref_list['vye'] *= 1e-3 + ref_list = Table.read(ref_file) # Switch our list to a "increasing to the West" list. ref_list['x0'] *= -1.0 - ref_list['vx'] *= -1.0 - + lists = [starlists.StarList.read(lf) for lf in list_files] msc = align.MosaicToRef(ref_list, lists, iters=2, dr_tol=[0.2, 0.1], dm_tol=[1, 0.5], trans_class=transforms.PolyTransform, - trans_args={'order': 2}, use_vel=True, + trans_args={'order': 2}, motion_models=['Empty', 'Fixed'], update_ref_orig=False, verbose=False) msc.fit() @@ -252,250 +229,283 @@ def test_MosaicToRef(): assert msc.ref_table['use_in_trans'].shape == msc.ref_table['x0'].shape assert msc.ref_table['used_in_trans'].shape == msc.ref_table['x'].shape - # The velocities should be almost the same as the input + # The velocities should be almost the same as the input # velocities since update_ref_orig == False. - np.testing.assert_almost_equal(msc.ref_table['vx'], ref_list['vx'], 5) - np.testing.assert_almost_equal(msc.ref_table['vy'], ref_list['vy'], 5) - + np.testing.assert_allclose(msc.ref_table['x0'], ref_list['x0'], rtol=1e-5) + np.testing.assert_allclose(msc.ref_table['y0'], ref_list['y0'], rtol=1e-5) ########## - # Align and let velocities be free. + # Align and let velocities be free. ########## - msc.update_ref_orig = True + msc.update_ref_orig = 'periter' msc.fit() # The velocities should be almost the same (but not as close as before) # as the input velocities since update_ref == False. - np.testing.assert_almost_equal(msc.ref_table['vx'], ref_list['vx'], 1) - np.testing.assert_almost_equal(msc.ref_table['vy'], ref_list['vy'], 1) + np.testing.assert_allclose(msc.ref_table['x0'], ref_list['x0'], rtol=1e-1) + np.testing.assert_allclose(msc.ref_table['y0'], ref_list['y0'], rtol=1e-1) # Also double check that they aren't exactly the same for the reference stars. - assert np.any(np.not_equal(msc.ref_table['vx'], ref_list['vx'])) - - return msc - + assert np.not_equal(msc.ref_table['x0'], ref_list['x0']).all() + assert np.not_equal(msc.ref_table['y0'], ref_list['y0']).all() -def make_fake_starlists_shifts(): - N_stars = 200 - x = np.random.rand(N_stars) * 1000 - y = np.random.rand(N_stars) * 1000 - m = (np.random.rand(N_stars) * 8) + 9 - - sdx = np.argsort(m) - x = x[sdx] - y = y[sdx] - m = m[sdx] - - name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] + return - # Save original positions as reference (1st) list. - fmt = '{0:10s} {1:5.2f} 2015.0 {2:9.4f} {3:9.4f} 0 0 0 0\n' - _out = open('random_0.lis', 'w') - for ii in range(N_stars): - _out.write(fmt.format(name[ii], m[ii], x[ii], y[ii])) - _out.close() +def test_MosaicToRef_p0_vel(): + make_fake_starlists_poly0_vel(seed=42) + + ref_file = f'{test_data_path}/random_vel_ref.fits' + list_files = [f'{test_data_path}/random_vel_p0_{i}.fits' for i in range(4)] + + ref_list = Table.read(ref_file) + + # Convert velocities to arcsec/yr + ref_list['vx'] *= 1e-3 + ref_list['vy'] *= 1e-3 + ref_list['vx_err'] *= 1e-3 + ref_list['vy_err'] *= 1e-3 + + # Switch our list to a "increasing to the West" list. + ref_list['x0'] *= -1.0 + ref_list['vx'] *= -1.0 + + lists = [starlists.StarList.read(lf) for lf in list_files] + + msc = align.MosaicToRef(ref_list, lists, iters=2, + dr_tol=[0.2, 0.1], dm_tol=[1, 0.5], + outlier_tol=[None, None], + trans_class=transforms.PolyTransform, + trans_args={'order': 1}, motion_models=['Empty', 'Fixed', 'Linear'], + update_ref_orig=False, verbose=False) + msc.fit() + + # Check our status columns + assert 'use_in_trans' in msc.ref_table.colnames + assert 'used_in_trans' in msc.ref_table.colnames + assert 'ref_orig' in msc.ref_table.colnames + assert msc.ref_table['use_in_trans'].shape == msc.ref_table['x0'].shape + assert msc.ref_table['used_in_trans'].shape == msc.ref_table['x'].shape + # The velocities should be almost the same as the input + # velocities since update_ref_orig == False. + assert (msc.ref_table['name']==ref_list['name']).all() + np.testing.assert_allclose(msc.ref_table['vx'], ref_list['vx'], rtol=1e-5) + np.testing.assert_allclose(msc.ref_table['vy'], ref_list['vy'], rtol=1e-5) ########## - # Shifts + # Align and let velocities be free. ########## - # Make 4 new starlists with different shifts. - shifts = [[ 6.5, 10.1], - [100.3, 50.5], - [-30.0,-100.7], - [250.0,-250.0]] + msc.update_ref_orig = 'periter' + msc.fit() - for ss in range(len(shifts)): - xnew = x - shifts[ss][0] - ynew = y - shifts[ss][1] + # The velocities should be almost the same (but not as close as before) + # as the input velocities since update_ref == True. + assert (msc.ref_table['name']==ref_list['name']).all() + np.testing.assert_allclose(msc.ref_table['vx'], ref_list['vx'], rtol=1e-1, atol=3e-4) + np.testing.assert_allclose(msc.ref_table['vy'], ref_list['vy'], rtol=1e-1, atol=3e-4) - # Perturb with small errors (0.1 pix) - xnew += np.random.randn(N_stars) * 0.1 - ynew += np.random.randn(N_stars) * 0.1 + # Also double check that they aren't exactly the same for the reference stars. + #assert np.any(np.not_equal(msc.ref_table['vx'], ref_list['vx'])) + assert np.not_equal(msc.ref_table['vx'], ref_list['vx']).any() - mnew = m + np.random.randn(N_stars) * 0.05 + return - _out = open('random_shift_{0:d}.lis'.format(ss+1), 'w') - for ii in range(N_stars): - _out.write(fmt.format(name[ii], mnew[ii], xnew[ii], ynew[ii])) - _out.close() +def test_MosaicToRef_vel(): + make_fake_starlists_poly1_vel(seed=42) - return shifts + ref_file = f'{test_data_path}/random_vel_ref.fits' + list_files = [f'{test_data_path}/random_vel_{i}.fits' for i in range(4)] -def make_fake_starlists_poly1(seed=-1): - # If seed >=0, then set random seed to that value - if seed >= 0: - np.random.seed(seed=seed) - - N_stars = 200 - x = np.random.rand(N_stars) * 1000 - y = np.random.rand(N_stars) * 1000 - m = (np.random.rand(N_stars) * 8) + 9 - - sdx = np.argsort(m) - x = x[sdx] - y = y[sdx] - m = m[sdx] - - name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] + ref_list = Table.read(ref_file) - # Save original positions as reference (1st) list. - fmt = '{0:10s} {1:5.2f} 2015.0 {2:9.4f} {3:9.4f} 0 0 0 0\n' - _out = open('random_0.lis', 'w') - for ii in range(N_stars): - _out.write(fmt.format(name[ii], m[ii], x[ii], y[ii])) - _out.close() + # Convert velocities to arcsec/yr + ref_list['vx'] *= 1e-3 + ref_list['vy'] *= 1e-3 + ref_list['vx_err'] *= 1e-3 + ref_list['vy_err'] *= 1e-3 + + # Switch our list to a "increasing to the West" list. + ref_list['x0'] *= -1.0 + ref_list['vx'] *= -1.0 + + lists = [starlists.StarList.read(lf) for lf in list_files] + + msc = align.MosaicToRef(ref_list, lists, iters=2, + dr_tol=[0.2, 0.1], dm_tol=[1, 0.5], + outlier_tol=[None, None], + trans_class=transforms.PolyTransform, + trans_args={'order': 1}, motion_models=['Empty', 'Fixed', 'Linear'], + update_ref_orig=False, verbose=False) + msc.fit() + + # Check our status columns + assert 'use_in_trans' in msc.ref_table.colnames + assert 'used_in_trans' in msc.ref_table.colnames + assert 'ref_orig' in msc.ref_table.colnames + assert msc.ref_table['use_in_trans'].shape == msc.ref_table['x0'].shape + assert msc.ref_table['used_in_trans'].shape == msc.ref_table['x'].shape + # The velocities should be almost the same as the input + # velocities since update_ref_orig == False. + assert (msc.ref_table['name']==ref_list['name']).all() + np.testing.assert_allclose(msc.ref_table['vx'], ref_list['vx'], rtol=1e-5) + np.testing.assert_allclose(msc.ref_table['vy'], ref_list['vy'], rtol=1e-5) ########## - # Shifts + # Align and let velocities be free. ########## - # Make 4 new starlists with different shifts. - transforms = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], - [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], - [[-30.0, 1.00, 1e-5], [-100.7, 2e-5, 0.999]], - [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]]] + msc.update_ref_orig = 'periter' + msc.fit() - for ss in range(len(shifts)): - #transforms.PolyTransform2D(1, transforms[ss]) - xnew = x - shifts[ss][0] - ynew = y - shifts[ss][1] + # The velocities should be almost the same (but not as close as before) + # as the input velocities since update_ref == True. + assert (msc.ref_table['name']==ref_list['name']).all() + np.testing.assert_allclose(msc.ref_table['vx'], ref_list['vx'], rtol=1e-1, atol=3e-4) + np.testing.assert_allclose(msc.ref_table['vy'], ref_list['vy'], rtol=1e-1, atol=3e-4) - # Perturb with small errors (0.1 pix) - xnew += np.random.randn(N_stars) * 0.1 - ynew += np.random.randn(N_stars) * 0.1 + # Also double check that they aren't exactly the same for the reference stars. + #assert np.any(np.not_equal(msc.ref_table['vx'], ref_list['vx'])) + assert np.not_equal(msc.ref_table['vx'], ref_list['vx']).any() - mnew = m + np.random.randn(N_stars) * 0.05 + return - _out = open('random_shift_{0:d}.lis'.format(ss+1), 'w') - for ii in range(N_stars): - _out.write(fmt.format(name[ii], mnew[ii], xnew[ii], ynew[ii])) - _out.close() +def test_MosaicToRef_acc(): + make_fake_starlists_poly1_acc(seed=42) - return shifts + ref_file = f'{test_data_path}/random_acc_ref.fits' + list_files = [f'{test_data_path}/random_acc_{i}.fits' for i in range(8)] + ref_list = Table.read(ref_file) -def make_fake_starlists_poly1_vel(seed=-1): - # If seed >=0, then set random seed to that value - if seed >= 0: - np.random.seed(seed=seed) - - N_stars = 200 + # Convert velocities to arcsec/yr + ref_list['vx0'] *= 1e-3 + ref_list['vy0'] *= 1e-3 + ref_list['vx0_err'] *= 1e-3 + ref_list['vy0_err'] *= 1e-3 - x0 = np.random.rand(N_stars) * 10.0 # arcsec (increasing to East) - y0 = np.random.rand(N_stars) * 10.0 # arcsec - x0e = np.random.randn(N_stars) * 5.0e-4 # arcsec - y0e = np.random.randn(N_stars) * 5.0e-4 # arcsec - vx = np.random.randn(N_stars) * 5.0 # mas / yr - vy = np.random.randn(N_stars) * 5.0 # mas / yr - vxe = np.random.randn(N_stars) * 0.1 # mas / yr - vye = np.random.randn(N_stars) * 0.1 # mas / yr - m0 = (np.random.rand(N_stars) * 8) + 9 # mag - m0e = np.random.randn(N_stars) * 0.05 # mag - t0 = np.ones(N_stars) * 2019.5 + # Convert accelerations to arcsec/yr**2 + ref_list['ax'] *= 1e-3 + ref_list['ay'] *= 1e-3 + ref_list['ax_err'] *= 1e-3 + ref_list['ay_err'] *= 1e-3 - # Make all the errors positive - x0e = np.abs(x0e) - y0e = np.abs(y0e) - m0e = np.abs(m0e) - vxe = np.abs(vxe) - vye = np.abs(vye) - - name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] + # Switch our list to a "increasing to the West" list. + ref_list['x0'] *= -1.0 + ref_list['vx0'] *= -1.0 + ref_list['ax'] *= -1.0 - # Make an StarList - lis = starlists.StarList([name, m0, m0e, x0, x0e, y0, y0e, vx, vxe, vy, vye, t0], - names = ('name', 'm0', 'm0e', 'x0', 'x0e', 'y0', 'y0e', - 'vx', 'vxe', 'vy', 'vye', 't0')) - - sdx = np.argsort(m0) - lis = lis[sdx] + lists = [starlists.StarList.read(lf) for lf in list_files] - # Save original positions as reference (1st) list - # in a StarList format (with velocities). - lis.write('random_vel_ref.fits', overwrite=True) - - ########## - # Propogate to new times and distort. - ########## - # Make 4 new starlists with different epochs and transformations. - times = [2018.5, 2019.5, 2020.5, 2021.5] - xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], - [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], - [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.0]], - [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]]] - mag_trans = [0.1, 0.4, 0.0, -0.3] + msc = align.MosaicToRef(ref_list, lists, iters=2, + dr_tol=[0.4, 0.2], dm_tol=[1, 0.5], + trans_class=transforms.PolyTransform, + trans_args={'order': 2}, + motion_models=['Acceleration'], + update_ref_orig=False, verbose=False) - # Convert into pixels (undistorted) with the following info. - scale = 0.01 # arcsec / pix - shift = [1.0, 1.0] # pix - - for ss in range(len(times)): - dt = times[ss] - lis['t0'] - - x = lis['x0'] + (lis['vx']/1e3) * dt - y = lis['y0'] + (lis['vy']/1e3) * dt - t = np.ones(N_stars) * times[ss] + msc.fit() - # Convert into pixels - xp = (x / -scale) + shift[0] # -1 from switching to increasing to West (right) - yp = (y / scale) + shift[1] - xpe = lis['x0e'] / scale - ype = lis['y0e'] / scale + # Check our status columns + assert 'use_in_trans' in msc.ref_table.colnames + assert 'used_in_trans' in msc.ref_table.colnames + assert 'ref_orig' in msc.ref_table.colnames + assert msc.ref_table['use_in_trans'].shape == msc.ref_table['x0'].shape + assert msc.ref_table['used_in_trans'].shape == msc.ref_table['x'].shape - # Distort the positions - trans = transforms.PolyTransform(1, xy_trans[ss][0], xy_trans[ss][1], mag_offset=mag_trans[ss]) - xd, yd = trans.evaluate(xp, yp) - md = trans.evaluate_mag(lis['m0']) + # The velocities should be almost the same as the input + # velocities since update_ref_orig == False. + i_orig, i_fit = [],[] + for i,star in enumerate(ref_list["name"]): + if star in msc.ref_table["name"]: + i_fit.append(np.where(msc.ref_table["name"]==star)[0][0]) + i_orig.append(i) + np.testing.assert_allclose(msc.ref_table['ax'][i_fit], ref_list['ax'][i_orig], rtol=1e-5) + np.testing.assert_allclose(msc.ref_table['ay'][i_fit], ref_list['ay'][i_orig], rtol=1e-5) - # Perturb with small errors (0.1 pix) - xd += np.random.randn(N_stars) * 0.1 - yd += np.random.randn(N_stars) * 0.1 - md += np.random.randn(N_stars) * 0.02 - xde = xpe - yde = ype - mde = lis['m0e'] + ########## + # Align and let velocities be free. + ########## + msc.update_ref_orig = 'periter' + msc.fit() - # Save the new list as a starlist. - new_lis = starlists.StarList([lis['name'], md, mde, xd, xde, yd, yde, t], - names=('name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't')) + # The velocities should be almost the same (but not as close as before) + # as the input velocities since update_ref == False. + i_orig, i_fit = [],[] + for i,star in enumerate(ref_list["name"]): + if star in msc.ref_table["name"]: + ix_fit = np.where(msc.ref_table["name"]==star)[0][0] + if ~np.isnan(msc.ref_table['ax'][ix_fit]): + i_orig.append(i) + i_fit.append(ix_fit) + # Accelerations all too small, rtol doesn't work well here. + atol = 3e-4 + np.testing.assert_allclose(msc.ref_table['ax'][i_fit], ref_list['ax'][i_orig], atol=atol) + np.testing.assert_allclose(msc.ref_table['ay'][i_fit], ref_list['ay'][i_orig], atol=atol) + + ax_min = np.min(ref_list['ax'][i_orig]) + ax_max = np.max(ref_list['ax'][i_orig]) + ay_min = np.min(ref_list['ay'][i_orig]) + ay_max = np.max(ref_list['ay'][i_orig]) - new_lis.write('random_vel_{0:d}.fits'.format(ss), overwrite=True) + plt.clf() + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5)) + ax1.plot(ref_list['ax'][i_orig], msc.ref_table['ax'][i_fit], '.') + ax1.plot([ax_min, ax_max], [ax_min, ax_max], color='C3') + ax1.plot([ax_min, ax_max], [ax_min - atol, ax_max - atol], ls='--', color='C3') + ax1.plot([ax_min, ax_max], [ax_min + atol, ax_max + atol], ls='--', color='C3') + ax1.set_xlabel('Input ax') + ax1.set_ylabel('Ref Table ax') + ax1.set_title('Acceleration in X') + + ax2.plot(ref_list['ay'][i_orig], msc.ref_table['ay'][i_fit], '.') + ax2.plot([ay_min, ay_max], [ay_min, ay_max], color='C3') + ax2.plot([ay_min, ay_max], [ay_min - atol, ay_max - atol], ls='--', color='C3') + ax2.plot([ay_min, ay_max], [ay_min + atol, ay_max + atol], ls='--', color='C3') + ax2.set_xlabel('Input ay') + ax2.set_ylabel('Ref Table ay') + ax2.set_title('Acceleration in Y') + plt.tight_layout() + + # Also double check that they aren't exactly the same for the reference stars. + assert np.any(np.not_equal(msc.ref_table['ax'][i_fit], ref_list['ax'][i_orig])) + return - return (xy_trans, mag_trans) - def test_MosaicToRef_hst_me(): """ - Test Casey's issue with 'me' not getting propogated + Test Casey's issue with 'me' not getting propogated from the input starlists to the output table. - Use data from MB10-364 microlensing target for the test. + Use data from MB10-364 microlensing target for the test. """ # Target RA and Dec (MOA data download) - ra = '17:57:05.401' - dec = '-34:27:05.01' - + # ra = '17:57:05.401' + # dec = '-34:27:05.01' + # Load up a Gaia catalog (queried around the RA/Dec above) - my_gaia = Table.read('mb10364_data/my_gaia.fits') + my_gaia = Table.read(f'{test_data_path}/mb10364_data/my_gaia.fits') my_gaia['me'] = 0.01 - + + my_gaia.rename_columns( + ['x0e', 'y0e', 'vxe', 'vye'], + ['x0_err', 'y0_err', 'vx_err', 'vy_err'] + ) # Gather the list of starlists. For first pass, don't modify the starlists. # Loop through the observations and read them in, in prep for alignment with Gaia epochs = [2011.83, 2012.73, 2013.81] - starlist_names = ['mb10364_data/2011_10_31_F606W_MATCHUP_XYMEEE_final.calib', - 'mb10364_data/2012_09_25_F606W_MATCHUP_XYMEEE_final.calib', - 'mb10364_data/2013_10_24_F606W_MATCHUP_XYMEEE_final.calib'] - + starlist_names = [f'{test_data_path}/mb10364_data/2011_10_31_F606W_MATCHUP_XYMEEE_final.calib', + f'{test_data_path}/mb10364_data/2012_09_25_F606W_MATCHUP_XYMEEE_final.calib', + f'{test_data_path}/mb10364_data/2013_10_24_F606W_MATCHUP_XYMEEE_final.calib'] + list_of_starlists = [] - + # Just using the F606W filters first. for ee in range(len(starlist_names)): lis = starlists.StarList.from_lis_file(starlist_names[ee]) - + # # Add additive error term. MAYBE YOU DON'T NEED THIS # lis['xe'] = np.hypot(lis['xe'], 0.01) # Adding 0.01 pix (0.1 mas) in quadrature. # lis['ye'] = np.hypot(lis['ye'], 0.01) - + lis['t'] = epochs[ee] # Lets dump the faint stars. @@ -503,40 +513,42 @@ def test_MosaicToRef_hst_me(): lis = lis[idx] list_of_starlists.append(lis) - - msc = align.MosaicToRef(my_gaia, list_of_starlists, iters=1, - dr_tol=[0.1], dm_tol=[5], - outlier_tol=[None], mag_lim=[13, 21], - trans_class=transforms.PolyTransform, - trans_args=[{'order': 1}], - use_vel=False, - use_ref_new=False, - update_ref_orig=False, - mag_trans=False, - weights='both,std', - init_guess_mode='miracle', verbose=False) - msc.fit() - tab = msc.ref_table - assert 'me' in tab.colnames + msc = align.MosaicToRef( + my_gaia, list_of_starlists, iters=1, + dr_tol=[0.1], dm_tol=[5], + outlier_tol=[None], mag_lim=[13, 21], + trans_class=transforms.PolyTransform, + trans_args=[{'order': 1}], + motion_models=['Empty', 'Fixed'], + use_ref_new=False, + update_ref_orig=False, + mag_trans=False, + trans_weights='both,std', + init_guess_mode='miracle', + # save_path=f'{test_data_path}/mb10364_data/test_MosaicToRef_hst_me.pkl', + verbose=False + ) + msc.fit() + assert 'me' in msc.ref_table.colnames return def test_bootstrap(): """ - Test to make sure calc_bootstrap_error() call is working + Test to make sure calc_bootstrap_error() call is working properly (e.g., only called when user calls calc_bootstrap_error, n_boot param for calc_bootstrap_error only, boot_epochs_min working, etc.) """ # Read in starlists for MosaicToRef - ref = Table.read('ref_vel.lis', format='ascii') - list1 = Table.read('E.lis', format='ascii') - list2 = Table.read('F.lis', format='ascii') + ref = Table.read(f'{test_data_path}/ref_vel.lis', format='ascii') + list1 = Table.read(f'{test_data_path}/E.lis', format='ascii') + list2 = Table.read(f'{test_data_path}/F.lis', format='ascii') list1 = starlists.StarList.from_table(list1) list2 = starlists.StarList.from_table(list2) - + # Set parameters for alignment transModel = transforms.PolyTransform trans_args = {'order':2} @@ -546,7 +558,7 @@ def test_bootstrap(): outlier_tol = None mag_lim = None ref_mag_lim = None - weights = 'both,var' + trans_weights = 'both,var' mag_trans = False n_boot = 15 @@ -560,8 +572,8 @@ def test_bootstrap(): mag_trans=mag_trans, mag_lim=mag_lim, ref_mag_lim=ref_mag_lim, - weights=weights, - use_vel=True, + trans_weights=trans_weights, + motion_models=['Linear'], use_ref_new=False, update_ref_orig=False, init_guess_mode='name', @@ -575,13 +587,12 @@ def test_bootstrap(): assert 'vye_boot' not in match1.ref_table.keys() # Run bootstrap: no boot_epochs_min - match1.calc_bootstrap_errors(n_boot=n_boot, boot_epochs_min=boot_epochs_min) - + match1.calc_bootstrap_errors(n_boot=n_boot, boot_epochs_min=boot_epochs_min, seed=42) # Make sure columns exist, and none of them are nan values assert np.sum(np.isnan(match1.ref_table['xe_boot'])) == 0 assert np.sum(np.isnan(match1.ref_table['ye_boot'])) == 0 - assert np.sum(np.isnan(match1.ref_table['vxe_boot'])) == 0 - assert np.sum(np.isnan(match1.ref_table['vye_boot'])) == 0 + assert np.sum(np.isnan(match1.ref_table['vx_err_boot'])) == 0 + assert np.sum(np.isnan(match1.ref_table['vy_err_boot'])) == 0 # Test 2: make sure boot_epochs_min is working # Eliminate some rows to list2, so some stars are only in 1 epoch. @@ -595,8 +606,8 @@ def test_bootstrap(): mag_trans=mag_trans, mag_lim=mag_lim, ref_mag_lim=ref_mag_lim, - weights=weights, - use_vel=True, + trans_weights=trans_weights, + motion_models=['Linear'], use_ref_new=False, update_ref_orig=False, init_guess_mode='name', @@ -605,7 +616,7 @@ def test_bootstrap(): # Now run_calc_bootstrap_error, with boot_epochs_min engaged boot_epochs_min2 = 2 - match2.calc_bootstrap_errors(n_boot=n_boot, boot_epochs_min=boot_epochs_min2) + match2.calc_bootstrap_errors(n_boot=n_boot, boot_epochs_min=boot_epochs_min2, seed=42) # Make sure boot_epochs_min cut worked as intended out = match2.ref_table @@ -618,38 +629,37 @@ def test_bootstrap(): assert len(good[0]) > 0 # For "good" stars: all bootstrap vals should be present - assert np.sum(np.isnan(out['xe_boot'][good])) == 0 - assert np.sum(np.isnan(out['ye_boot'][good])) == 0 - assert np.sum(np.isnan(out['vxe_boot'][good])) == 0 - assert np.sum(np.isnan(out['vye_boot'][good])) == 0 + assert np.sum(~np.isfinite(out['xe_boot'][good])) == 0 + assert np.sum(~np.isfinite(out['ye_boot'][good])) == 0 + assert np.sum(~np.isfinite(out['vx_err_boot'][good])) == 0 + assert np.sum(~np.isfinite(out['vy_err_boot'][good])) == 0 # For "bad" stars, all bootstrap vals should be nans assert np.sum(np.isfinite(out['xe_boot'][bad])) == 0 assert np.sum(np.isfinite(out['ye_boot'][bad])) == 0 - assert np.sum(np.isfinite(out['vxe_boot'][bad])) == 0 - assert np.sum(np.isfinite(out['vye_boot'][bad])) == 0 + assert np.sum(np.isfinite(out['vx_err_boot'][bad])) == 0 + assert np.sum(np.isfinite(out['vy_err_boot'][bad])) == 0 return def test_calc_vel_in_bootstrap(): """ Check calc_vel_in_bootstrap performance in calc_bootstrap_errors() - - Only calculate velocity bootstrap (e.g., bootstrap over epochs and + + Only calculate velocity bootstrap (e.g., bootstrap over epochs and calculating proper motions) if calc_vel_in_bootstrap=True. """ import copy - - # Define match parameters - ref = Table.read('ref_vel.lis', format='ascii') - list1 = Table.read('E.lis', format='ascii') - list2 = Table.read('F.lis', format='ascii') + # Define match parameters + ref = Table.read(f'{test_data_path}/ref_vel.lis', format='ascii') + list1 = Table.read(f'{test_data_path}/E.lis', format='ascii') + list2 = Table.read(f'{test_data_path}/F.lis', format='ascii') list1 = starlists.StarList.from_table(list1) list2 = starlists.StarList.from_table(list2) - + # Set parameters for alignment transModel = transforms.PolyTransform trans_args = {'order':2} @@ -659,7 +669,7 @@ def test_calc_vel_in_bootstrap(): outlier_tol = None mag_lim = None ref_mag_lim = None - weights = 'both,var' + trans_weights = 'both,var' mag_trans = False n_boot = 15 @@ -673,8 +683,8 @@ def test_calc_vel_in_bootstrap(): mag_trans=mag_trans, mag_lim=mag_lim, ref_mag_lim=ref_mag_lim, - weights=weights, - use_vel=True, + trans_weights=trans_weights, + motion_models=['Linear'], use_ref_new=False, update_ref_orig=False, init_guess_mode='name', @@ -688,36 +698,36 @@ def test_calc_vel_in_bootstrap(): # Run calc_bootstrap_error function with calc_vel_in_bootstrap=True. # Make sure bootstrap velocity errors are calculated and valid n_boot = 50 - match_vel.calc_bootstrap_errors(n_boot=n_boot, calc_vel_in_bootstrap=True) + match_vel.calc_bootstrap_errors(n_boot=n_boot, calc_vel_in_bootstrap=True, seed=42) assert 'xe_boot' in match_vel.ref_table.keys() assert np.sum(np.isnan(match_vel.ref_table['xe_boot'])) == 0 - assert 'vxe_boot' in match_vel.ref_table.keys() - assert np.sum(np.isnan(match_vel.ref_table['vxe_boot'])) == 0 + assert 'vx_err_boot' in match_vel.ref_table.keys() + assert np.sum(np.isnan(match_vel.ref_table['vx_err_boot'])) == 0 # Run without calc_vel_in_bootstrap, make sure velocities are NOT calculated - match.calc_bootstrap_errors(n_boot=n_boot, calc_vel_in_bootstrap=False) + match.calc_bootstrap_errors(n_boot=n_boot, calc_vel_in_bootstrap=False, seed=42) assert 'xe_boot' in match.ref_table.keys() assert np.sum(np.isnan(match.ref_table['xe_boot'])) == 0 - assert 'vxe_boot' not in match.ref_table.keys() - + assert 'vx_err_boot' not in match.ref_table.keys() + return def test_transform_xym(): """ Test to make sure transforms are being done to mags only - if mag_trans = True. This can cause subtle bugs + if mag_trans = True. This can cause subtle bugs otherwise """ #---Align 1: self.mag_Trans = False---# - ref = Table.read('ref_vel.lis', format='ascii') - list1 = Table.read('E.lis', format='ascii') - list2 = Table.read('F.lis', format='ascii') + ref = Table.read(f'{test_data_path}/ref_vel.lis', format='ascii') + list1 = Table.read(f'{test_data_path}/E.lis', format='ascii') + list2 = Table.read(f'{test_data_path}/F.lis', format='ascii') list1 = starlists.StarList.from_table(list1) list2 = starlists.StarList.from_table(list2) - + # Set parameters for alignment transModel = transforms.PolyTransform trans_args = {'order':2} @@ -727,7 +737,7 @@ def test_transform_xym(): outlier_tol = None mag_lim = None ref_mag_lim = None - weights = 'both,var' + trans_weights = 'both,var' n_boot = 15 mag_trans = False @@ -740,17 +750,17 @@ def test_transform_xym(): mag_trans=mag_trans, mag_lim=mag_lim, ref_mag_lim=ref_mag_lim, - weights=weights, - use_vel=False, + trans_weights=trans_weights, + motion_models=['Fixed'], use_ref_new=False, update_ref_orig=False, init_guess_mode='name', verbose=False) match1.fit() - match1.calc_bootstrap_errors(n_boot=n_boot) + match1.calc_bootstrap_errors(n_boot=n_boot, seed=42) - # Make sure all transformations have mag_offset = 0 + # Make sure all transformations have mag_offset = 0 trans_list = match1.trans_list for ii in trans_list: @@ -759,7 +769,7 @@ def test_transform_xym(): # Check that no mag transformation has been applied to m col in ref_table tab1 = match1.ref_table assert np.all(tab1['m'] == tab1['m_orig']) - + # Check me_boost == 0 or really small (should be the case # since we don't transform mags) assert np.isclose(np.max(tab1['me_boot']), 0, rtol=10**-5) @@ -775,15 +785,15 @@ def test_transform_xym(): mag_trans=mag_trans, mag_lim=mag_lim, ref_mag_lim=ref_mag_lim, - weights=weights, - use_vel=False, + trans_weights=trans_weights, + motion_models=['Fixed'], use_ref_new=False, update_ref_orig=False, init_guess_mode='name', verbose=False) match2.fit() - match2.calc_bootstrap_errors(n_boot=n_boot) + match2.calc_bootstrap_errors(n_boot=n_boot, seed=42) # Make sure all transformations have correct mag offset @@ -792,34 +802,34 @@ def test_transform_xym(): for ii in trans_list2: assert ii.mag_offset > 20 - # Make sure final table mags have transform applied (i.e, + # Make sure final table mags have transform applied (i.e, tab2 = match2.ref_table assert np.all(tab2['m'] != tab2['m_orig']) - + # Check me_boost > 0 assert np.min(tab2['me_boot']) > 10**-3 print('Done mag_trans = True case') - + return def test_MosaicToRef_mag_bug(): """ Bug found by Tuan Do on 2020-04-12. """ - make_fake_starlists_poly1_vel() + make_fake_starlists_poly1_vel(seed=42) - ref_list = starlists.StarList.from_lis_file('random_0.lis', error=False) + ref_list = starlists.StarList.read(f'{test_data_path}/random_vel_0.fits') lists = [ref_list] - msc = align.MosaicToRef(ref_list, lists, + msc = align.MosaicToRef(ref_list, lists, mag_trans=True, - iters=1, + iters=1, dr_tol=[0.2], dm_tol=[1], outlier_tol=None, trans_class=transforms.PolyTransform, trans_args=[{'order': 1}], - use_vel=False, + motion_models=['Fixed'], use_ref_new=False, update_ref_orig=False, verbose=True) @@ -839,7 +849,7 @@ def test_MosaicToRef_mag_bug(): def test_masked_cols(): """ Test to make sure analysis.prepare_gaia_for_flystar - produces an astropy.table.Table, NOT a masked column + produces an astropy.table.Table, NOT a masked column table. MosaicToRef cannot handle masked column tables. Also make sure this example works, since we use it for the examples @@ -847,15 +857,16 @@ def test_masked_cols(): """ # Get gaia reference stars using analysis.py # around a test location. - target = 'ob150029' + # target = 'ob150029' ra = '17:59:46.60' dec = '-28:38:41.8' # Coordinates are arcsecs offset +x to the East. - targets_dict = {'ob150029': [0.0, 0.0], - 'S11_15_3.9': [ 1.13982, 3.73524], - 'S13_13_4.5': [-4.42878, 0.03100] - } + targets_dict = { + 'ob150029': [0.0, 0.0], + 'S005': [1.1416, 3.7405], + 'S002': [-4.421, 0.027] + } # Get gaia catalog stars. Note that this produces a masked column table search_rad = 10.0 # arcsec @@ -865,7 +876,7 @@ def test_masked_cols(): assert isinstance(my_gaia, Table) # Let's make sure the entire align runs, just to be safe - + # Get starlists to align to gaia epochs = ['15jun07','16jul14', '17may21'] @@ -873,21 +884,591 @@ def test_masked_cols(): for ee in range(len(epochs)): lis_file = 'mag' + epochs[ee] + '_ob150029_kp_rms_named.lis' - lis = starlists.StarList.from_lis_file(lis_file) - + lis = starlists.StarList.from_lis_file(f'{test_data_path}/{lis_file}') list_of_starlists.append(lis) # Run the align msc = align.MosaicToRef(my_gaia, list_of_starlists, iters=2, dr_tol=[0.2, 0.1], dm_tol=[1, 1], trans_class=transforms.PolyTransform, - trans_args=[{'order': 1}, {'order': 1}], - use_vel=True, + trans_args=[{'order': 1}, {'order': 1}], + motion_models=['Linear'], use_ref_new=False, - update_ref_orig=False, + update_ref_orig=False, mag_trans=True, init_guess_mode='name', verbose=True) msc.fit() - return + +def make_fake_starlists_shifts(): + N_stars = 200 + x = np.random.rand(N_stars) * 1000 + y = np.random.rand(N_stars) * 1000 + m = (np.random.rand(N_stars) * 8) + 9 + + sdx = np.argsort(m) + x = x[sdx] + y = y[sdx] + m = m[sdx] + + name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] + + # Save original positions as reference (1st) list. + fmt = '{0:10s} {1:5.2f} 2015.0 {2:9.4f} {3:9.4f} 0 0 0 0\n' + _out = open(f'{test_data_path}/random_0.lis', 'w') + for ii in range(N_stars): + _out.write(fmt.format(name[ii], m[ii], x[ii], y[ii])) + _out.close() + + + ########## + # Shifts + ########## + # Make 4 new starlists with different shifts. + shifts = [[ 6.5, 10.1], + [100.3, 50.5], + [-30.0,-100.7], + [250.0,-250.0]] + + for ss in range(len(shifts)): + xnew = x - shifts[ss][0] + ynew = y - shifts[ss][1] + + # Perturb with small errors (0.1 pix) + xnew += np.random.randn(N_stars) * 0.1 + ynew += np.random.randn(N_stars) * 0.1 + + mnew = m + np.random.randn(N_stars) * 0.05 + + _out = open(f'{test_data_path}/random_shift_{ss+1}.lis', 'w') + for ii in range(N_stars): + _out.write(fmt.format(name[ii], mnew[ii], xnew[ii], ynew[ii])) + _out.close() + + return shifts + +def make_fake_starlists_poly1(seed=-1): + # If seed >=0, then set random seed to that value + if seed >= 0: + np.random.seed(seed=seed) + + N_stars = 200 + + x0 = np.random.rand(N_stars) * 10.0 # arcsec (increasing to East) + y0 = np.random.rand(N_stars) * 10.0 # arcsec + x0e = np.random.randn(N_stars) * 5.0e-4 # arcsec + y0e = np.random.randn(N_stars) * 5.0e-4 # arcsec + m0 = (np.random.rand(N_stars) * 8) + 9 # mag + m0e = np.random.randn(N_stars) * 0.05 # mag + t0 = np.ones(N_stars) * 2019.5 + + # Make all the errors positive + x0e = np.abs(x0e) + y0e = np.abs(y0e) + m0e = np.abs(m0e) + + name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] + + # Make an StarList + lis = starlists.StarList([name, m0, m0e, x0, x0e, y0, y0e, t0], + names = ('name', 'm0', 'm0_err', 'x0', 'x0_err', 'y0', 'y0_err', 't0')) + + sdx = np.argsort(m0) + lis = lis[sdx] + + # Save original positions as reference (1st) list + # in a StarList format (with velocities). + lis.write(f'{test_data_path}/random_ref.fits', overwrite=True) + + ########## + # Shifts + ########## + # Make 4 new starlists with different shifts. + times = [2018.5, 2019.0, 2019.5, 2020.0, 2020.5, 2021.0, 2021.5, 2022.0] + xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], + [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], + [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.0]], + [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]], + [[ 50.0, 1.01, 1e-5], [ -31.0, 1e-5, 1.000]], + [[ 78.0, 0.98, 0.0 ], [ 45.0, 9e-6, 1.001]], + [[-13.0, 0.99, 1e-5], [ 150, 2e-5, 1.002]], + [[ 94.0, 1.00, 9e-6], [-182.0, 0.0, 0.99]]] + mag_trans = [0.1, 0.4, 0.0, -0.3, 0.2, 0.0, -0.1, -0.3] + + # Convert into pixels (undistorted) with the following info. + scale = 0.01 # arcsec / pix + shift = [1.0, 1.0] # pix + + for ss in range(len(times)): + dt = times[ss] - lis['t0'] + + x = lis['x0'] + y = lis['y0'] + t = np.ones(N_stars) * times[ss] + + # Convert into pixels + xp = (x / -scale) + shift[0] # -1 from switching to increasing to West (right) + yp = (y / scale) + shift[1] + xpe = lis['x0_err'] / scale + ype = lis['y0_err'] / scale + + # Distort the positions + trans = transforms.PolyTransform(1, xy_trans[ss][0], xy_trans[ss][1], mag_offset=mag_trans[ss]) + xd, yd = trans.evaluate(xp, yp) + md = trans.evaluate_mag(lis['m0']) + + # Perturb with small errors (0.1 pix) + xd += np.random.randn(N_stars) * 0.1 + yd += np.random.randn(N_stars) * 0.1 + md += np.random.randn(N_stars) * 0.02 + xde = xpe + yde = ype + mde = lis['m0_err'] + + # fig, ax = plt.subplots() + # ax.scatter(x0, y0, s=2, label='Reference') + # ax.scatter(xd, yd, s=2, label='Starlist') + # ax.set_xlabel('X (pix)') + # ax.set_ylabel('Y (pix)') + # ax.legend() + # plt.show() + + # Save the new list as a starlist. + new_lis = starlists.StarList([lis['name'], md, mde, xd, xde, yd, yde, t], + names=('name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't')) + + new_lis.write(f'{test_data_path}/random_{ss}.fits', overwrite=True) + + return (xy_trans,mag_trans) + +def make_fake_starlists_poly0_vel(seed=-1): + # If seed >=0, then set random seed to that value + if seed >= 0: + np.random.seed(seed=seed) + + N_stars = 200 + + x0 = np.random.rand(N_stars) * 10.0 # arcsec (increasing to East) + y0 = np.random.rand(N_stars) * 10.0 # arcsec + x0e = np.ones(N_stars) * 1.0e-4 # arcsec + y0e = np.ones(N_stars) * 1.0e-4 # arcsec + vx = np.random.randn(N_stars) * 5.0 # mas / yr + vy = np.random.randn(N_stars) * 5.0 # mas / yr + vxe = np.ones(N_stars) * 0.05 # mas / yr + vye = np.ones(N_stars) * 0.05 # mas / yr + m0 = (np.random.rand(N_stars) * 8) + 9 # mag + m0e = np.random.randn(N_stars) * 0.05 # mag + t0 = np.ones(N_stars) * 2019.5 + + # Make all the errors positive + x0e = np.abs(x0e) + y0e = np.abs(y0e) + m0e = np.abs(m0e) + vxe = np.abs(vxe) + vye = np.abs(vye) + + name = [f'star_{ii:03d}' for ii in range(N_stars)] + + # Make an StarList + lis = starlists.StarList([name, m0, m0e, x0, x0e, y0, y0e, vx, vxe, vy, vye, t0], + names = ('name', 'm0', 'm0_err', 'x0', 'x0_err', 'y0', 'y0_err', + 'vx', 'vx_err', 'vy', 'vy_err', 't0')) + + sdx = np.argsort(m0) + lis = lis[sdx] + + # Save original positions as reference (1st) list + # in a StarList format (with velocities). + lis.write(f'{test_data_path}/random_vel_ref.fits', overwrite=True) + + ########## + # Propogate to new times and distort. + ########## + # Make 4 new starlists with different epochs and transformations. + times = [2018.5, 2019.0, 2019.5, 2020.0, 2020.5, 2021.0, 2021.5, 2022.0] + xy_trans = [[[ 6.5], [ 10.1]], + [[100.3], [ 50.5]], + [[ 0.0], [ 0.0]], + [[250.0], [-250.0]], + [[ 50.0], [ -31.0]], + [[ 78.0], [ 45.0]], + [[-13.0], [ 150]], + [[ 94.0], [-182.0]]] + mag_trans = [0.1, 0.4, 0.0, -0.3, 0.2, 0.0, -0.1, -0.3] + + # Convert into pixels (undistorted) with the following info. + scale = 0.01 # arcsec / pix + shift = [1.0, 1.0] # pix + + for ss in range(len(times)): + dt = times[ss] - lis['t0'] + + x = lis['x0'] + (lis['vx']/1e3) * dt + y = lis['y0'] + (lis['vy']/1e3) * dt + t = np.ones(N_stars) * times[ss] + + # Convert into pixels + xp = (x / -scale) + shift[0] # -1 from switching to increasing to West (right) + yp = (y / scale) + shift[1] + xpe = lis['x0_err'] / scale + ype = lis['y0_err'] / scale + + # Distort the positions + trans = transforms.PolyTransform(0, xy_trans[ss][0], xy_trans[ss][1], mag_offset=mag_trans[ss]) + xd, yd = trans.evaluate(xp, yp) + md = trans.evaluate_mag(lis['m0']) + + # Perturb with small errors (0.1 pix) + xd += np.random.randn(N_stars) * xpe + yd += np.random.randn(N_stars) * ype + md += np.random.randn(N_stars) * 0.02 + xde = xpe + yde = ype + mde = lis['m0_err'] + + # Save the new list as a starlist. + new_lis = starlists.StarList([lis['name'], md, mde, xd, xde, yd, yde, t], + names=('name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't')) + + new_lis.write(f'{test_data_path}/random_vel_p0_{ss}.fits', overwrite=True) + + return (xy_trans, mag_trans) + + +def make_fake_starlists_poly1_vel(seed=-1): + # If seed >=0, then set random seed to that value + if seed >= 0: + np.random.seed(seed=seed) + + N_stars = 200 + + x0 = np.random.rand(N_stars) * 10.0 # arcsec (increasing to East) + y0 = np.random.rand(N_stars) * 10.0 # arcsec + x0e = np.ones(N_stars) * 1.0e-4 # arcsec + y0e = np.ones(N_stars) * 1.0e-4 # arcsec + vx = np.random.randn(N_stars) * 5.0 # mas / yr + vy = np.random.randn(N_stars) * 5.0 # mas / yr + vxe = np.ones(N_stars) * 0.05 # mas / yr + vye = np.ones(N_stars) * 0.05 # mas / yr + m0 = (np.random.rand(N_stars) * 8) + 9 # mag + m0e = np.random.randn(N_stars) * 0.05 # mag + t0 = np.ones(N_stars) * 2019.5 + + # Make all the errors positive + x0e = np.abs(x0e) + y0e = np.abs(y0e) + m0e = np.abs(m0e) + vxe = np.abs(vxe) + vye = np.abs(vye) + + name = [f'star_{ii:03d}' for ii in range(N_stars)] + + # Make an StarList + lis = starlists.StarList([name, m0, m0e, x0, x0e, y0, y0e, vx, vxe, vy, vye, t0], + names = ('name', 'm0', 'm0_err', 'x0', 'x0_err', 'y0', 'y0_err', + 'vx', 'vx_err', 'vy', 'vy_err', 't0')) + + sdx = np.argsort(m0) + lis = lis[sdx] + + # Save original positions as reference (1st) list + # in a StarList format (with velocities). + lis.write(f'{test_data_path}/random_vel_ref.fits', overwrite=True) + + ########## + # Propogate to new times and distort. + ########## + # Make 4 new starlists with different epochs and transformations. + times = [2018.5, 2019.0, 2019.5, 2020.0, 2020.5, 2021.0, 2021.5, 2022.0] + xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], + [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], + [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.000]], + [[250.0, 1.01, 2e-5], [-250.0, 1e-5, 0.98]], + [[ 50.0, 1.01, 1e-5], [ -31.0, 1e-5, 1.000]], + [[ 78.0, 0.98, 0.0 ], [ 45.0, 9e-6, 1.001]], + [[-13.0, 0.99, 1e-5], [ 150, 2e-5, 1.002]], + [[ 94.0, 1.00, 9e-6], [-182.0, 0.0, 0.99]]] + mag_trans = [0.1, 0.4, 0.0, -0.3, 0.2, 0.0, -0.1, -0.3] + + # Convert into pixels (undistorted) with the following info. + scale = 0.01 # arcsec / pix + shift = [1.0, 1.0] # pix + + for ss in range(len(times)): + dt = times[ss] - lis['t0'] + + x = lis['x0'] + (lis['vx']/1e3) * dt + y = lis['y0'] + (lis['vy']/1e3) * dt + t = np.ones(N_stars) * times[ss] + + # Convert into pixels + xp = (x / -scale) + shift[0] # -1 from switching to increasing to West (right) + yp = (y / scale) + shift[1] + xpe = lis['x0_err'] / scale + ype = lis['y0_err'] / scale + + # Distort the positions + trans = transforms.PolyTransform(1, xy_trans[ss][0], xy_trans[ss][1], mag_offset=mag_trans[ss]) + xd, yd = trans.evaluate(xp, yp) + md = trans.evaluate_mag(lis['m0']) + + # Perturb with small errors (0.1 mas) + xd += np.random.randn(N_stars) * xpe + yd += np.random.randn(N_stars) * ype + md += np.random.randn(N_stars) * 0.02 + xde = xpe + yde = ype + mde = lis['m0_err'] + + # Save the new list as a starlist. + new_lis = starlists.StarList([lis['name'], md, mde, xd, xde, yd, yde, t], + names=('name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't')) + + new_lis.write(f'{test_data_path}/random_vel_{ss}.fits', overwrite=True) + + return (xy_trans, mag_trans) + +def make_fake_starlists_poly1_acc(seed=-1): + # If seed >=0, then set random seed to that value + if seed >= 0: + np.random.seed(seed=seed) + + N_stars = 200 + + x0 = np.random.rand(N_stars) * 10.0 # arcsec (increasing to East) + y0 = np.random.rand(N_stars) * 10.0 # arcsec + x0e = np.ones(N_stars) * 1.0e-4 # arcsec + y0e = np.ones(N_stars) * 1.0e-4 # arcsec + vx = np.random.randn(N_stars) * 5.0 # mas / yr + vy = np.random.randn(N_stars) * 5.0 # mas / yr + vxe = np.ones(N_stars) * 0.1 # mas / yr + vye = np.ones(N_stars) * 0.1 # mas / yr + ax = np.random.randn(N_stars) * 0.5 # mas / yr^2 + ay = np.random.randn(N_stars) * 0.5 # mas / yr^2 + axe = np.ones(N_stars) * 0.01 # mas / yr^2 + aye = np.ones(N_stars) * 0.01 # mas / yr^2 + m0 = (np.random.rand(N_stars) * 8) + 9 # mag + m0e = np.random.randn(N_stars) * 0.05 # mag + t0 = np.ones(N_stars) * 2019.5 + + # Make all the errors positive + x0e = np.abs(x0e) + y0e = np.abs(y0e) + m0e = np.abs(m0e) + vxe = np.abs(vxe) + vye = np.abs(vye) + axe = np.abs(axe) + aye = np.abs(aye) + + name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] + + # Make an StarList + lis = starlists.StarList([name, m0, m0e, + x0, x0e, y0, y0e, + vx, vxe, vy, vye, + ax, axe, ay, aye, + t0], + names = ('name', 'm0', 'm0_err', + 'x0', 'x0_err', 'y0', 'y0_err', + 'vx0', 'vx0_err', 'vy0', 'vy0_err', + 'ax', 'ax_err', 'ay', 'ay_err', + 't0')) + + sdx = np.argsort(m0) + lis = lis[sdx] + + # Save original positions as reference (1st) list + # in a StarList format (with velocities). + lis.write(f'{test_data_path}/random_acc_ref.fits', overwrite=True) + + ########## + # Propogate to new times and distort. + ########## + # Make 4 new starlists with different epochs and transformations. + times = [2018.5, 2019.0, 2019.5, 2020.0, 2020.5, 2021.0, 2021.5, 2022.0] + xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], + [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], + [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.000]], + [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]], + [[ 50.0, 1.01, 1e-5], [ -31.0, 1e-5, 1.000]], + [[ 78.0, 0.98, 0.0 ], [ 45.0, 9e-6, 1.001]], + [[-13.0, 0.99, 1e-5], [ 150, 2e-5, 1.002]], + [[ 94.0, 1.00, 9e-6], [-182.0, 0.0, 0.99]]] + mag_trans = [0.1, 0.4, 0.0, -0.3, 0.2, 0.0, -0.1, -0.3] + + # Convert into pixels (undistorted) with the following info. + scale = 0.01 # arcsec / pix + shift = [1.0, 1.0] # pix + + for ss in range(len(times)): + dt = times[ss] - lis['t0'] + + x = lis['x0'] + (lis['vx0']/1e3) * dt + 0.5*(lis['ax']/1e3) * dt**2 + y = lis['y0'] + (lis['vy0']/1e3) * dt + 0.5*(lis['ay']/1e3) * dt**2 + t = np.ones(N_stars) * times[ss] + + # Convert into pixels + xp = (x / -scale) + shift[0] # -1 from switching to increasing to West (right) + yp = (y / scale) + shift[1] + xpe = lis['x0_err'] / scale + ype = lis['y0_err'] / scale + + # Distort the positions + trans = transforms.PolyTransform(1, xy_trans[ss][0], xy_trans[ss][1], mag_offset=mag_trans[ss]) + xd, yd = trans.evaluate(xp, yp) + md = trans.evaluate_mag(lis['m0']) + + # Perturb with small errors (0.1 pix) + xd += np.random.randn(N_stars) * xpe + yd += np.random.randn(N_stars) * ype + md += np.random.randn(N_stars) * 0.02 + xde = xpe + yde = ype + mde = lis['m0_err'] + + # Save the new list as a starlist. + new_lis = starlists.StarList([lis['name'], md, mde, xd, xde, yd, yde, t], + names=('name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't')) + + new_lis.write(f'{test_data_path}/random_acc_{ss}.fits', overwrite=True) + + return (xy_trans, mag_trans) + +def make_fake_starlists_poly1_par(seed=-1): + # If seed >=0, then set random seed to that value + if seed >= 0: + np.random.seed(seed=seed) + + N_stars = 200 + + x0 = np.random.rand(N_stars) * 10.0 # arcsec (increasing to East) + y0 = np.random.rand(N_stars) * 10.0 # arcsec + x0e = np.random.randn(N_stars) * 5.0e-4 # arcsec + y0e = np.random.randn(N_stars) * 5.0e-4 # arcsec + vx = np.random.randn(N_stars) * 5.0 # mas / yr + vy = np.random.randn(N_stars) * 5.0 # mas / yr + vxe = np.random.randn(N_stars) * 0.1 # mas / yr + vye = np.random.randn(N_stars) * 0.1 # mas / yr + pi = np.random.randn(N_stars) * 0.5 # mas + pie = np.random.randn(N_stars) * 0.01 # mas + m0 = (np.random.rand(N_stars) * 8) + 9 # mag + m0e = np.random.randn(N_stars) * 0.05 # mag + t0 = np.ones(N_stars) * 2019.5 + + # Make all the errors positive + x0e = np.abs(x0e) + y0e = np.abs(y0e) + m0e = np.abs(m0e) + vxe = np.abs(vxe) + vye = np.abs(vye) + pie = np.abs(pie) + + name = ['star_{0:03d}'.format(ii) for ii in range(N_stars)] + + # Make an StarList + lis = starlists.StarList([name, m0, m0e, + x0, x0e, y0, y0e, + vx, vxe, vy, vye, + pi, pie, + t0], + names = ('name', 'm0', 'm0_err', + 'x0', 'x0_err', 'y0', 'y0_err', + 'vx', 'vx_err', 'vy', 'vy_err', + 'pi', 'pi_err', + 't0')) + + sdx = np.argsort(m0) + lis = lis[sdx] + + # Save original positions as reference (1st) list + # in a StarList format (with velocities). + lis.write(f'{test_data_path}/random_par_ref.fits', overwrite=True) + + ########## + # Propogate to new times and distort. + ########## + # Make 4 new starlists with different epochs and transformations. + '''times = [2018.5, 2019.5, 2020.5, 2021.5] + xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], + [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], + [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.0]], + [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]]] + mag_trans = [0.1, 0.4, 0.0, -0.3]''' + + times = [2018.5, 2019.0, 2019.5, 2020.0, 2020.5, 2021.0, 2021.5, 2022.0] + xy_trans = [[[ 6.5, 0.99, 1e-5], [ 10.1, 1e-5, 0.99]], + [[100.3, 0.98, 1e-5], [ 50.5, 9e-6, 1.001]], + [[ 0.0, 1.00, 0.0], [ 0.0, 0.0, 1.0]], + [[250.0, 0.97, 2e-5], [-250.0, 1e-5, 1.001]], + [[ 50.0, 1.00, 0.0], [ -31.0, 0.0, 1.000]], + [[ 78.0, 1.00, 0.0 ], [ 45.0, 0.0, 1.00]], + [[-13.0, 1.00, 0.0], [ 150, 0.0, 1.00]], + [[ 94.0, 1.00, 0.0], [-182.0, 0.0, 1.00]]] + mag_trans = [0.1, 0.4, 0.0, -0.3, 0.0, 0.0, 0.0, 0.0] + + # Convert into pixels (undistorted) with the following info. + scale = 0.01 # arcsec / pix + shift = [1.0, 1.0] # pix + + for ss in range(len(times)): + dt = times[ss] - lis['t0'] + + par_mod = motion_model.Parallax(pa=0,ra=18.0, dec=-30.0) + par_mod_dat = par_mod.get_batch_pos_at_time(dt+lis['t0'], x0=lis['x0'],vx=lis['vx']/1e3, pi=lis['pi'], + y0=lis['y0'], vy=lis['vy']/1e3, t0=lis['t0']) + x,y = par_mod_dat[0], par_mod_dat[1] + t = np.ones(N_stars) * times[ss] + + # Convert into pixels + xp = (x / -scale) + shift[0] # -1 from switching to increasing to West (right) + yp = (y / scale) + shift[1] + xpe = lis['x0_err'] / scale + ype = lis['y0_err'] / scale + + # Distort the positions + trans = transforms.PolyTransform(1, xy_trans[ss][0], xy_trans[ss][1], mag_offset=mag_trans[ss]) + xd, yd = trans.evaluate(xp, yp) + md = trans.evaluate_mag(lis['m0']) + + # Perturb with small errors (0.1 pix) + xd += np.random.randn(N_stars) * 0.1 + yd += np.random.randn(N_stars) * 0.1 + md += np.random.randn(N_stars) * 0.02 + xde = xpe + yde = ype + mde = lis['m0_err'] + + # Save the new list as a starlist. + new_lis = starlists.StarList([lis['name'], md, mde, xd, xde, yd, yde, t], + names=('name', 'm', 'me', 'x', 'xe', 'y', 'ye', 't')) + + new_lis.write(f'{test_data_path}/random_par_{ss}.fits', overwrite=True) + + return (xy_trans, mag_trans) + +if __name__ == '__main__': + import pickle + with open(f'{test_data_path}/my_gaia.pkl', 'rb') as f: + my_gaia = pickle.load(f) + with open(f'{test_data_path}/list_of_starlists.pkl', 'rb') as f: + list_of_starlists = pickle.load(f) + ra_deg, dec_deg = 18.0, -30.0 + my_gaia.remove_column('motion_model_used') + msc = align.MosaicToRef(my_gaia, list_of_starlists, iters=3, + dr_tol=[0.2, 0.1, 0.08], dm_tol=[5,5,5], + outlier_tol=[None, None, 3], mag_lim=[6, 20], + trans_class=transforms.PolyTransform, + trans_args=[{'order': 1}, {'order': 1}, {'order': 1}], + motion_models=['Linear','Parallax'], + fixed_params_dict = {'ra':ra_deg, 'dec':dec_deg, 'pa':0.0, 'obsLocation':'earth'}, + use_ref_new=True, + update_ref_orig=False, + mag_trans=True, + trans_weights='both,std', + init_guess_mode='name', verbose=3) + msc.fit() + for i in range(msc.ref_table['x'].shape[1]): + plt.scatter(msc.ref_table['x'][:, i], msc.ref_table['y'][:, i]) + plt.show() + plot_stars(msc.ref_table, msc.ref_table['name'][:3]) \ No newline at end of file diff --git a/flystar/tests/A.lis b/flystar/tests/test_data/A.lis similarity index 100% rename from flystar/tests/A.lis rename to flystar/tests/test_data/A.lis diff --git a/flystar/tests/B.lis b/flystar/tests/test_data/B.lis similarity index 100% rename from flystar/tests/B.lis rename to flystar/tests/test_data/B.lis diff --git a/flystar/tests/C.lis b/flystar/tests/test_data/C.lis similarity index 100% rename from flystar/tests/C.lis rename to flystar/tests/test_data/C.lis diff --git a/flystar/tests/D.lis b/flystar/tests/test_data/D.lis similarity index 100% rename from flystar/tests/D.lis rename to flystar/tests/test_data/D.lis diff --git a/flystar/tests/E.lis b/flystar/tests/test_data/E.lis similarity index 100% rename from flystar/tests/E.lis rename to flystar/tests/test_data/E.lis diff --git a/flystar/tests/F.lis b/flystar/tests/test_data/F.lis similarity index 100% rename from flystar/tests/F.lis rename to flystar/tests/test_data/F.lis diff --git a/flystar/tests/coveragerc b/flystar/tests/test_data/coveragerc similarity index 100% rename from flystar/tests/coveragerc rename to flystar/tests/test_data/coveragerc diff --git a/flystar/tests/mb10364_data/2011_10_31_F606W_MATCHUP_XYMEEE_final.calib b/flystar/tests/test_data/mb10364_data/2011_10_31_F606W_MATCHUP_XYMEEE_final.calib similarity index 100% rename from flystar/tests/mb10364_data/2011_10_31_F606W_MATCHUP_XYMEEE_final.calib rename to flystar/tests/test_data/mb10364_data/2011_10_31_F606W_MATCHUP_XYMEEE_final.calib diff --git a/flystar/tests/mb10364_data/2012_09_25_F606W_MATCHUP_XYMEEE_final.calib b/flystar/tests/test_data/mb10364_data/2012_09_25_F606W_MATCHUP_XYMEEE_final.calib similarity index 100% rename from flystar/tests/mb10364_data/2012_09_25_F606W_MATCHUP_XYMEEE_final.calib rename to flystar/tests/test_data/mb10364_data/2012_09_25_F606W_MATCHUP_XYMEEE_final.calib diff --git a/flystar/tests/mb10364_data/2013_10_24_F606W_MATCHUP_XYMEEE_final.calib b/flystar/tests/test_data/mb10364_data/2013_10_24_F606W_MATCHUP_XYMEEE_final.calib similarity index 100% rename from flystar/tests/mb10364_data/2013_10_24_F606W_MATCHUP_XYMEEE_final.calib rename to flystar/tests/test_data/mb10364_data/2013_10_24_F606W_MATCHUP_XYMEEE_final.calib diff --git a/flystar/tests/mb10364_data/my_gaia.fits b/flystar/tests/test_data/mb10364_data/my_gaia.fits similarity index 100% rename from flystar/tests/mb10364_data/my_gaia.fits rename to flystar/tests/test_data/mb10364_data/my_gaia.fits diff --git a/flystar/tests/ref.lis b/flystar/tests/test_data/ref.lis similarity index 100% rename from flystar/tests/ref.lis rename to flystar/tests/test_data/ref.lis diff --git a/flystar/tests/ref_vel.lis b/flystar/tests/test_data/ref_vel.lis similarity index 99% rename from flystar/tests/ref_vel.lis rename to flystar/tests/test_data/ref_vel.lis index 4d223b0..fc191bb 100644 --- a/flystar/tests/ref_vel.lis +++ b/flystar/tests/test_data/ref_vel.lis @@ -1,4 +1,4 @@ -name x y m xe ye me t0 vx vy vxe vye +name x y m xe ye me t0 vx vy vx_err vy_err gaia_1150 -63.98457260029581 -30.67278228118061 13.628200000000001 0.00014609621924194742 0.00014585407086906515 0.0115 2010.5 0.0 0.0 0.1 0.1 gaia_1162 0.47637231898572985 -79.79611824529178 14.6439 0.00011419811781207949 0.00011415029792639667 0.0084 2010.5 0.0 0.0 0.1 0.1 gaia_1166 8.546170748636236 -47.35893234401765 14.696900000000001 0.00013283068515276605 0.00013260913293195234 0.0041 2010.5 0.0 0.0 0.1 0.1 diff --git a/flystar/tests/test_catalog.fits b/flystar/tests/test_data/test_catalog.fits similarity index 100% rename from flystar/tests/test_catalog.fits rename to flystar/tests/test_data/test_catalog.fits diff --git a/flystar/tests/test_match.py b/flystar/tests/test_match.py index 594f0b9..1022f6d 100644 --- a/flystar/tests/test_match.py +++ b/flystar/tests/test_match.py @@ -164,7 +164,7 @@ def test_generic_match(): n2 = np.array(['S11', 'S12', 'S13', 'S14', 'S15', 'S16', 'S17', 'S18', 'S19']) - + list1 = Table([n1, x1, y1, m1], names=('name', 'x', 'y', 'm')) list2 = Table([n2, x2, y2, m2], @@ -180,4 +180,7 @@ def test_generic_match(): m_match=(None, None, None, None), sigma_match=None, n_bright=8, verbose=True) - +if __name__ == '__main__': + # test_match_duplicates() + # test_miracle_match_briteN() + test_generic_match() \ No newline at end of file diff --git a/flystar/tests/test_motion_model.py b/flystar/tests/test_motion_model.py new file mode 100644 index 0000000..de67d65 --- /dev/null +++ b/flystar/tests/test_motion_model.py @@ -0,0 +1,398 @@ +from flystar import motion_model +import numpy as np +import matplotlib.pyplot as plt +from scipy.optimize import curve_fit + +def within_error(true_val, fit_val, fit_err, n_sigma=3): + return np.abs(true_val - fit_val) <= n_sigma*fit_err + +def test_Fixed(): + # Test handling of a single star + true_params = {'x0': 1.0, 'y0':0.5, 'x0_err':0.1, 'y0_err':0.1} + mod = motion_model.Fixed() + param_list = mod.fit_param_names + # Confirm return of proper values for single t and array t + x_t, y_t = mod.model( + 0.0, + fit_params=np.array([true_params['x0'], true_params['y0']]).T + ) + assert x_t==true_params['x0'] + assert y_t==true_params['y0'] + x_t, y_t = mod.model( + [0.0,2025.0,10000], + fit_params=np.array([true_params['x0'], true_params['y0']]).T + ) + assert (x_t==true_params['x0']).all() + assert (y_t==true_params['y0']).all() + + # Check behavior of model + x0_batch = np.random.uniform(-2.0,2.0, 50) + y0_batch = np.random.uniform(-2.0,2.0, 50) + x0_err_batch = np.repeat(0.1, 50) + y0_err_batch = np.repeat(0.1, 50) + # Single epoch + t_batch=2020.0 + x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.model( + t_batch, + fit_params=np.array([x0_batch, y0_batch]).T, + fit_param_errs=np.array([x0_err_batch, y0_err_batch]).T + ) + assert (x_t_batch==x0_batch).all() + assert (y_t_batch==y0_batch).all() + assert (x_err_t_batch==x0_err_batch).all() + assert (y_err_t_batch==y0_err_batch).all() + # Multiple times + t_batch = np.arange(2015.0,2025.0, 0.5) + x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.model( + t_batch, + fit_params=np.array([x0_batch, y0_batch]).T, + fit_param_errs=np.array([x0_err_batch, y0_err_batch]).T + ) + assert (x_t_batch==np.array([np.repeat(x0_batch_i, len(t_batch)) for x0_batch_i in x0_batch])).all() + assert (y_t_batch==np.array([np.repeat(y0_batch_i, len(t_batch)) for y0_batch_i in y0_batch])).all() + assert (x_err_t_batch==np.array([np.repeat(x0_err_batch_i, len(t_batch)) for x0_err_batch_i in x0_err_batch])).all() + assert (y_err_t_batch==np.array([np.repeat(y0_err_batch_i, len(t_batch)) for y0_err_batch_i in y0_err_batch])).all() + + # Test fitter + t = np.arange(2015.0,2025.0, 0.5) + # Get values from model and add scatter + x_true, y_true = mod.model( + t, + fit_params=np.array([true_params['x0'], true_params['y0']]) + ) + x_sim = np.random.normal(x_true, true_params['x0_err']) + y_sim = np.random.normal(y_true, true_params['y0_err']) + xe = np.ones_like(t)*true_params['x0_err'] + ye = np.ones_like(t)*true_params['y0_err'] + # Run fit + params, param_errs = mod.fit( + t, + x_sim,y_sim, + xe=xe, + ye=ye + ) + + x_wt = 1. / xe**2 + y_wt = 1. / ye**2 + x_wt_norm = x_wt / np.sum(x_wt) + y_wt_norm = y_wt / np.sum(y_wt) + x_mean = np.average(x_sim, weights=x_wt) + y_mean = np.average(y_sim, weights=y_wt) + x_std = (np.sum(x_wt_norm**2 * xe**2))**0.5 + y_std = (np.sum(y_wt_norm**2 * ye**2))**0.5 + + # Confirm true value is within error bar of fit value + assert np.all([within_error(true_params[param_list[i]], params[i], param_errs[i]) for i in range(len(params))]) + np.testing.assert_allclose(params[0], x_mean, atol=1e-5) + np.testing.assert_allclose(params[1], y_mean, atol=1e-5) + np.testing.assert_allclose(param_errs[0], x_std, atol=1e-5) + np.testing.assert_allclose(param_errs[1], y_std, atol=1e-5) + + +def test_Linear(): + # Test handling of a single star + true_params = {'x0': 1.0, 'y0':0.5, 'x0_err':0.1, 'y0_err':0.1, + 'vx':0.2, 'vy':0.5, 'vx_err':0.05, 'vy_err':0.05, + 't0':2025.0} + mod = motion_model.Linear() + param_list = mod.fit_param_names + # Confirm return of proper values for single t=t0 and array t + x_t, y_t = mod.model( + t=true_params['t0'], + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) + assert x_t==true_params['x0'] + assert y_t==true_params['y0'] + t_arr = np.array([2010.0,true_params['t0'],2030.0]) + x_t, y_t = mod.model( + t=t_arr, + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) + assert (x_t==(true_params['x0'] + (t_arr-true_params['t0'])*true_params['vx'])).all() + assert (y_t==(true_params['y0'] + (t_arr-true_params['t0'])*true_params['vy'])).all() + + # Check behavior of model + x0_batch = np.random.uniform(-2.0,2.0, 50) + y0_batch = np.random.uniform(-2.0,2.0, 50) + vx_batch = np.random.uniform(-2.0,2.0, 50) + vy_batch = np.random.uniform(-2.0,2.0, 50) + x0_err_batch = np.repeat(0.1, 50) + y0_err_batch = np.repeat(0.1, 50) + vx_err_batch = np.repeat(0.05, 50) + vy_err_batch = np.repeat(0.05, 50) + t0_batch = np.repeat(2025.0,50) + # Single epoch + t_batch=2020.0 + x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.model( + t=t_batch, + fit_params=np.array([x0_batch, vx_batch, y0_batch, vy_batch]).T, + fit_param_errs=np.array([x0_err_batch, vx_err_batch, y0_err_batch, vy_err_batch]).T, + fixed_params_dict={'t0': t0_batch} + ) + + np.testing.assert_allclose(x_t_batch, (x0_batch+(t_batch-t0_batch)*vx_batch), atol=1e-5) + np.testing.assert_allclose(y_t_batch, (y0_batch+(t_batch-t0_batch)*vy_batch), atol=1e-5) + np.testing.assert_allclose(x_err_t_batch, np.hypot(x0_err_batch, (t_batch-t0_batch)*vx_err_batch), atol=1e-5) + np.testing.assert_allclose(y_err_t_batch, np.hypot(y0_err_batch, (t_batch-t0_batch)*vy_err_batch), atol=1e-5) + + # Multiple times + t_batch = np.arange(2015.0,2025.0, 0.5) + x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.model( + t=t_batch, + fit_params=np.array([x0_batch, vx_batch, y0_batch, vy_batch]).T, + fit_param_errs=np.array([x0_err_batch, vx_err_batch, y0_err_batch, vy_err_batch]).T, + fixed_params_dict={'t0': t0_batch} + ) + np.testing.assert_allclose(x_t_batch, np.array([x0_batch[i] + (t_batch-t0_batch[i])*vx_batch[i] for i in range(len(x0_batch))]), atol=1e-5) + np.testing.assert_allclose(y_t_batch, np.array([y0_batch[i] + (t_batch-t0_batch[i])*vy_batch[i] for i in range(len(x0_batch))]), atol=1e-5) + np.testing.assert_allclose(x_err_t_batch, np.array([np.hypot(x0_err_batch[i], (t_batch-t0_batch[i])*vx_err_batch[i]) for i in range(len(x0_batch))]), atol=1e-5) + np.testing.assert_allclose(y_err_t_batch, np.array([np.hypot(y0_err_batch[i], (t_batch-t0_batch[i])*vy_err_batch[i]) for i in range(len(x0_batch))]), atol=1e-5) + + # Test fitter + t = np.arange(2015.0,2025.0, 0.5) + # Get values from model and add scatter + x_true, y_true = mod.model( + t=t, + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) + x_sim = np.random.normal(x_true, 0.05) + y_sim = np.random.normal(y_true, 0.05) + # Run fit + xe = np.ones_like(t)*0.05 + ye = np.ones_like(t)*0.05 + + def linear(t, x0, vx): + return x0 + vx * t + + for absolute_sigma in [True, False]: + for weighting in ['std', 'var']: + for use_scipy in [True, False]: + params, param_errs = mod.fit( + t=t, + x=x_sim, + y=y_sim, + xe=xe, + ye=ye, + fixed_params_dict={'t0': true_params['t0']}, + weighting=weighting, + use_scipy=use_scipy, + absolute_sigma=absolute_sigma + ) + + # Scipy + xe_scipy = xe**0.5 if weighting=='std' else xe + ye_scipy = ye**0.5 if weighting=='std' else ye + x_popt, x_pcov = curve_fit( + linear, + t - true_params['t0'], + x_sim, + sigma=xe_scipy, + absolute_sigma=absolute_sigma, + p0=[np.mean(x_sim), 0.0] + ) + y_popt, y_pcov = curve_fit( + linear, + t - true_params['t0'], + y_sim, + sigma=ye_scipy, + absolute_sigma=absolute_sigma, + p0=[np.mean(y_sim), 0.0] + ) + np.testing.assert_allclose(params[:2], x_popt, atol=1e-5) + np.testing.assert_allclose(param_errs[:2], np.sqrt(np.diag(x_pcov)), atol=1e-5) + np.testing.assert_allclose(params[2:], y_popt, atol=1e-5) + np.testing.assert_allclose(param_errs[2:], np.sqrt(np.diag(y_pcov)), atol=1e-5) + + # Test fitter with bootstrap + t = np.arange(2015.0, 2025.0, 0.5) + # Get values from model and add scatter + x_true, y_true = mod.model( + t=t, + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) + x_true_err, y_true_err = np.ones_like(t)*0.05, np.ones_like(t)*0.05 + x_sim = np.random.normal(x_true, x_true_err) + y_sim = np.random.normal(y_true, y_true_err) + # Run fit + params, param_errs = mod.fit(t, x_sim, y_sim, x_true_err, y_true_err, fixed_params_dict={'t0': true_params['t0']}, bootstrap=10, seed=42) + # Confirm true value is within error bar of fit value + assert np.all([within_error(true_params[param_list[i]], params[i], param_errs[i]) for i in range(len(params))]) + + +def test_Acceleration(): + # Test handling of a single star + true_params = {'x0': 1.0, 'y0':0.5, 'x0_err':0.1, 'y0_err':0.1, + 'vx0':0.2, 'vy0':0.5, 'vx0_err':0.05, 'vy0_err':0.05, + 'ax':0.1, 'ay':-0.1, 'ax_err':0.02, 'ay_err':0.02, + 't0':2025.0} + mod = motion_model.Acceleration() + param_list = mod.fit_param_names + # Confirm return of proper values for single t=t0 and array t + x_t, y_t = mod.model( + t=true_params['t0'], + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) + np.testing.assert_allclose(x_t, true_params['x0']) + np.testing.assert_allclose(y_t, true_params['y0']) + t_arr = np.array([2010.0, true_params['t0'], 2030.0]) + x_t, y_t = mod.model( + t=t_arr, + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) + np.testing.assert_allclose(x_t, true_params['x0'] + (t_arr-true_params['t0'])*true_params['vx0'] + 0.5*(t_arr-true_params['t0'])**2*true_params['ax']) + np.testing.assert_allclose(y_t, true_params['y0'] + (t_arr-true_params['t0'])*true_params['vy0'] + 0.5*(t_arr-true_params['t0'])**2*true_params['ay']) + + # Check behavior of model + x0_batch = np.random.uniform(-2.0,2.0, 50) + y0_batch = np.random.uniform(-2.0,2.0, 50) + vx0_batch = np.random.uniform(-2.0,2.0, 50) + vy0_batch = np.random.uniform(-2.0,2.0, 50) + ax_batch = np.random.uniform(-1.0,1.0, 50) + ay_batch = np.random.uniform(-1.0,1.0, 50) + x0_err_batch = np.repeat(0.1, 50) + y0_err_batch = np.repeat(0.1, 50) + vx0_err_batch = np.repeat(0.05, 50) + vy0_err_batch = np.repeat(0.05, 50) + ax_err_batch = np.repeat(0.02, 50) + ay_err_batch = np.repeat(0.02, 50) + t0_batch = np.repeat(2025.0,50) + # Single epoch + t_batch=2020.0 + x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.model( + t=t_batch, + fit_params=np.array([x0_batch, vx0_batch, ax_batch, y0_batch, vy0_batch, ay_batch]).T, + fit_param_errs=np.array([x0_err_batch, vx0_err_batch, ax_err_batch, y0_err_batch, vy0_err_batch, ay_err_batch]).T, + fixed_params_dict={'t0': t0_batch} + ) + np.testing.assert_allclose(x_t_batch, x0_batch + (t_batch-t0_batch)*vx0_batch + 0.5*(t_batch-t0_batch)**2*ax_batch) + np.testing.assert_allclose(y_t_batch, y0_batch + (t_batch-t0_batch)*vy0_batch + 0.5*(t_batch-t0_batch)**2*ay_batch) + np.testing.assert_allclose(x_err_t_batch, np.sqrt(x0_err_batch**2 + ((t_batch-t0_batch)*vx0_err_batch)**2 + + (0.5*(t_batch-t0_batch)**2*ax_err_batch)**2)) + np.testing.assert_allclose(y_err_t_batch, np.sqrt(y0_err_batch**2 + ((t_batch-t0_batch)*vy0_err_batch)**2 + + (0.5*(t_batch-t0_batch)**2*ay_err_batch)**2)) + + # Multiple times + t_batch = np.arange(2015.0,2025.0, 0.5) + x_t_batch, y_t_batch, x_err_t_batch, y_err_t_batch = mod.model( + t=t_batch, + fit_params=np.array([x0_batch, vx0_batch, ax_batch, y0_batch, vy0_batch, ay_batch]).T, + fit_param_errs=np.array([x0_err_batch, vx0_err_batch, ax_err_batch, y0_err_batch, vy0_err_batch, ay_err_batch]).T, + fixed_params_dict={'t0': t0_batch} + ) + np.testing.assert_allclose(x_t_batch, np.array([x0_batch[i] + (t_batch-t0_batch[i])*vx0_batch[i] + 0.5*(t_batch-t0_batch[i])**2*ax_batch[i] for i in range(len(x0_batch))])) + np.testing.assert_allclose(y_t_batch, np.array([y0_batch[i] + (t_batch-t0_batch[i])*vy0_batch[i] + 0.5*(t_batch-t0_batch[i])**2*ay_batch[i] for i in range(len(x0_batch))])) + np.testing.assert_allclose(x_err_t_batch, np.array([np.sqrt(x0_err_batch[i]**2 + ((t_batch-t0_batch[i])*vx0_err_batch[i])**2 + (0.5*(t_batch-t0_batch[i])**2*ax_err_batch[i])**2) for i in range(len(x0_batch))])) + np.testing.assert_allclose(y_err_t_batch, np.array([np.sqrt(y0_err_batch[i]**2 + ((t_batch-t0_batch[i])*vy0_err_batch[i])**2 + (0.5*(t_batch-t0_batch[i])**2*ay_err_batch[i])**2) for i in range(len(x0_batch))])) + + # Test fitter + t = np.arange(2015.0,2025.0, 0.5) + # Get values from model and add scatter + x_true, y_true = mod.model( + t=t, + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict={'t0': true_params['t0']} + ) + x_true_err = np.sqrt(true_params['x0_err']**2 + ((t - true_params['t0']) * true_params['vx0_err'])**2 + + (0.5*(t - true_params['t0'])**2 * true_params['ax_err'])**2) + y_true_err = np.sqrt(true_params['y0_err']**2 + ((t - true_params['t0']) * true_params['vy0_err'])**2 + + (0.5*(t - true_params['t0'])**2 * true_params['ay_err'])**2) + x_sim = np.random.normal(x_true, x_true_err) + y_sim = np.random.normal(y_true, y_true_err) + # Run fit + mod_fit = motion_model.Acceleration() + params, param_errs = mod_fit.fit( + t=t, + x=x_sim, + y=y_sim, + xe=x_true_err, + ye=y_true_err, + fixed_params_dict={'t0': true_params['t0']} + ) + # Confirm true value is within error bar of fit value + assert np.all([within_error(true_params[param_list[i]], params[i], param_errs[i]) for i in range(len(params))]) + +#@pytest.mark.skip(reason="not written") +def test_Parallax(): + # Test handling of a single star + true_params = {'x0': 1.0, 'y0':-0.5, 'x0_err':0.1, 'y0_err':0.1, + 'vx':-0.2, 'vy':0.5, 'vx_err':0.05, 'vy_err':0.05, + 'pi':0.5, 'ra':17.76, 'dec':-28.933, 'pa':0, + 't0':2020.0, 'obsLocation': 'earth'} + mod = motion_model.Parallax() + param_list = mod.fit_param_names + fixed_params_dict = { + 't0': true_params['t0'], + 'ra': true_params['ra'], + 'dec': true_params['dec'], + 'pa': true_params['pa'], + 'obsLocation': true_params['obsLocation'] + } + + # Test fitter + t = np.arange(2015.0,2025.0, 0.5) + # Get values from model and add scatter + x_true, y_true = mod.model( + t=t, + fit_params=np.array([true_params[p] for p in param_list]).T, + fixed_params_dict=fixed_params_dict + ) + x_true_err, y_true_err = np.ones_like(t)*true_params['x0_err'], np.ones_like(t)*true_params['y0_err'] + x_sim = np.random.normal(x_true, x_true_err) + y_sim = np.random.normal(y_true, y_true_err) + # Run fit + params, param_errs = mod.fit(t, x_sim,y_sim, x_true_err, y_true_err, fixed_params_dict=fixed_params_dict) + + x_model, y_model = mod.model( + t=t, + fit_params=params, + fixed_params_dict=fixed_params_dict + ) + plt.clf() + fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5)) + ax1.plot(t, x_model, color='C3', lw=2, label='Model x') + ax1.plot(t, x_true, color='C0', ls='--', label='True x') + ax1.errorbar(t, x_sim, yerr=x_true_err, fmt='o', color='C0', label='Sim x') + ax1.set_xlabel('t') + ax1.set_ylabel('x') + ax1.legend() + ax2.plot(t, y_model, color='C3', lw=2, label='Model y') + ax2.plot(t, y_true, color='C0', ls='--', label='True y') + ax2.errorbar(t, y_sim, yerr=y_true_err, fmt='o', color='C0', label='Sim y') + ax2.set_xlabel('t') + ax2.set_ylabel('y') + ax2.legend() + plt.tight_layout() + + # Confirm true value is within error bar of fit value + assert np.all([within_error(true_params[param_list[i]], params[i], param_errs[i]) for i in range(len(params))]) + +def test_Parallax_PA(): + # Set PA=0 model + x0, y0 = 2.0, -1.0 + vx, vy = 0.2, 0.5 + ra, dec = 17.76, -28.933 + pi = 0.5 + mod_pa0 = motion_model.Parallax() + # Set PA=90 model with equivalent parameters in that frame + mod_pa90 = motion_model.Parallax() + + t_set = np.arange(2018, 2024, 0.01) + t0 = 2020.0 + dat_pa0 = mod_pa0.model( + t = t_set, + fit_params = np.array([x0, vx, y0, vy, pi]).T, + fixed_params_dict = {'t0': t0, 'ra': ra, 'dec': dec, 'pa': 0} + ) + dat_pa90 = mod_pa90.model( + t = t_set, + fit_params = np.array([y0, vy, -x0, -vx, pi]).T, + fixed_params_dict = {'t0': t0, 'ra': ra, 'dec': dec, 'pa': 90} + ) + np.testing.assert_allclose(dat_pa0[0], -dat_pa90[1], atol=1e-10) + np.testing.assert_allclose(dat_pa0[1], dat_pa90[0], atol=1e-10) \ No newline at end of file diff --git a/flystar/tests/test_starlist.py b/flystar/tests/test_starlist.py index 5113c43..568c26d 100644 --- a/flystar/tests/test_starlist.py +++ b/flystar/tests/test_starlist.py @@ -1,16 +1,17 @@ from astropy.table import Table from flystar.starlists import StarList import os, pdb +import flystar -test_dir = os.path.dirname(__file__) +test_data_path = f'{flystar.__path__[0]}/tests/test_data' def make_star_list(): # User input - cat_file = test_dir + '/A.lis' + cat_file = f'{test_data_path}/A.lis' # Read and arrange the test input - cat_tab = Table.read(cat_file, format='ascii', delimiter='\s') + cat_tab = Table.read(cat_file, format='ascii', delimiter=r'\s') # Copy columns from the input file. # Note that all of these inputs will be numpy arrays. @@ -25,7 +26,7 @@ def make_star_list(): # Name is a unique name for each star and is a 1D array. starlist_time = 2011.1 - starlist_name = 'A.lis' + starlist_name = f'{test_data_path}/A.lis' # Generate the starlist starlist = StarList(name=name_in, x=x_in, y=y_in, m=m_in, xe=xe_in, diff --git a/flystar/tests/test_startable.py b/flystar/tests/test_startable.py index 9051fb8..6630a83 100644 --- a/flystar/tests/test_startable.py +++ b/flystar/tests/test_startable.py @@ -1,20 +1,22 @@ +import os +import pdb +import pytest +import flystar +import numpy as np from astropy.table import Table from astropy import table +from flystar import motion_model from flystar.startables import StarTable from flystar.starlists import StarList -import numpy as np -import pytest -import os -import pdb -test_dir = os.path.dirname(__file__) +test_data_path = f'{flystar.__path__[0]}/tests/test_data' def test_StarTable_init1(): """ Test creation of new StarTable. """ # User input - cat_file = test_dir + '/test_catalog.fits' + cat_file = f'{test_data_path}/test_catalog.fits' # Read and arrange the test input cat_tab = Table.read(cat_file) @@ -39,9 +41,14 @@ def test_StarTable_init1(): starlist_names = np.array(['file1', 'file2', 'file3', 'file4', 'file5', 'file6', 'file7', 'file8']) # Generate the startable - startable = StarTable(name=name_in, x=x_in, y=y_in, m=m_in, xe=xe_in, ye=ye_in, me=me_in, - ref_list=1, - list_times=starlist_times, list_names=starlist_names) + startable = StarTable( + name=name_in, + x=x_in, y=y_in, m=m_in, + xe=xe_in, ye=ye_in, me=me_in, + ref_list=1, + list_times=starlist_times, + list_names=starlist_names + ) # Now put in some assertions to make sure all our startable columns # have the right dimensions. @@ -55,7 +62,7 @@ def test_StarTable_init1(): assert len(startable['name']) == N_stars assert startable.meta['list_times'][0] == starlist_times[0] assert type(startable) == StarTable - + return def test_StarTable_init2(): @@ -65,8 +72,8 @@ def test_StarTable_init2(): Also double check that we can add a second list to it using add_starlist and we can get_starlist() as well. """ - list_file1 = 'A.lis' - list_file2 = 'B.lis' + list_file1 = 'test_data/A.lis' + list_file2 = 'test_data/B.lis' list1 = StarList.from_lis_file(list_file1) list2 = StarList.from_lis_file(list_file2) @@ -75,7 +82,6 @@ def test_StarTable_init2(): assert len(tab) == len(list1) - return def test_combine_lists(): @@ -100,7 +106,7 @@ def test_combine_lists(): t.combine_lists('x', mask_val=-100000) assert t['x0'][0] == x_avg_0 assert t['x0'][-1] == pytest.approx(2108.855, 0.001) - + # Test 4: weighted average of x. x_wgt_0 = 1.0 / t['xe'][0, :]**2 x_avg_0 = np.average(t['x'][0, :], weights=x_wgt_0) @@ -115,14 +121,14 @@ def test_combine_lists(): # Test 5: make sure mask_list is working. ########## # Test 5ai: Non-masked, weighted_m=False - tt.combine_lists_xym(weighted_xy=True, weighted_m=False, mask_lists=False) + tt.combine_lists_xym(weighted_xy=True, weighted_m=False, mask_lists=None) assert np.arange(1.8, 38, 4) == pytest.approx(tt['x0'].data) assert np.arange(1.8, 38, 4) == pytest.approx(tt['y0'].data) avg_m = -2.5 * np.log10((4 * 10**-0.4 + 1)/5) assert avg_m * np.ones(10) == pytest.approx(tt['m0'].data) # Test 5aii: Non-masked, weighted_m=True - tt.combine_lists_xym(weighted_xy=True, weighted_m=True, mask_lists=False) + tt.combine_lists_xym(weighted_xy=True, weighted_m=True, mask_lists=None) assert np.arange(1.8, 38, 4) == pytest.approx(tt['x0'].data) assert np.arange(1.8, 38, 4) == pytest.approx(tt['y0'].data) avg_m_weight = 0.9391744564422395 @@ -141,9 +147,10 @@ def test_combine_lists(): assert np.ones(10) == pytest.approx(tt['m0'].data) # Test 5c: Things that should break the code. - with pytest.raises(RuntimeError): - t.combine_lists_xym(weighted_xy=True, weighted_m=True, mask_lists=np.arange(2)) - with pytest.raises(RuntimeError): + # with pytest.raises(RuntimeError): + # This would not break the code anymore + # t.combine_lists_xym(weighted_xy=True, weighted_m=True, mask_lists=np.arange(2)) + with pytest.raises(AssertionError): t.combine_lists_xym(weighted_xy=True, weighted_m=True, mask_lists=True) return @@ -168,78 +175,79 @@ def test_add_starlist(): t.add_starlist(x=x_new, y=y_new, m=m_new, xe=xe_new, ye=ye_new, me=me_new, meta={'list_times': t_new}) - assert len(t) == len(t_orig) + np.testing.assert_equal(len(t), len(t_orig)) expected_shape = np.array(t_orig['x'].shape) expected_shape[1] += 1 - - assert len(t['x'].shape) == len(expected_shape) - assert t['x'].shape[0] == expected_shape[0] + + np.testing.assert_equal(len(t['x'].shape), len(expected_shape)) + np.testing.assert_equal(t['x'].shape[0], expected_shape[0]) assert t['x'].shape[1] == expected_shape[1] - assert len(t['y'].shape) == len(expected_shape) - assert t['y'].shape[0] == expected_shape[0] + np.testing.assert_equal(len(t['y'].shape), len(expected_shape)) + np.testing.assert_equal(t['y'].shape[0], expected_shape[0]) assert t['y'].shape[1] == expected_shape[1] - assert len(t['m'].shape) == len(expected_shape) - assert t['m'].shape[0] == expected_shape[0] + np.testing.assert_equal(len(t['m'].shape), len(expected_shape)) + np.testing.assert_equal(t['m'].shape[0], expected_shape[0]) assert t['m'].shape[1] == expected_shape[1] - assert len(t['xe'].shape) == len(expected_shape) - assert t['xe'].shape[0] == expected_shape[0] - assert t['xe'].shape[1] == expected_shape[1] - - assert len(t['ye'].shape) == len(expected_shape) - assert t['ye'].shape[0] == expected_shape[0] - assert t['ye'].shape[1] == expected_shape[1] + np.testing.assert_equal(len(t['xe'].shape), len(expected_shape)) + np.testing.assert_equal(t['xe'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['xe'].shape[1], expected_shape[1]) - assert len(t['me'].shape) == len(expected_shape) - assert t['me'].shape[0] == expected_shape[0] - assert t['me'].shape[1] == expected_shape[1] - - assert len(t['name']) == len(t_orig['name']) - assert len(t.meta['list_times']) == expected_shape[1] - assert t.meta['n_lists'] == 9 + np.testing.assert_equal(len(t['ye'].shape), len(expected_shape)) + np.testing.assert_equal(t['ye'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['ye'].shape[1], expected_shape[1]) + np.testing.assert_equal(len(t['me'].shape), len(expected_shape)) + np.testing.assert_equal(t['me'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['me'].shape[1], expected_shape[1]) + np.testing.assert_equal(len(t['name']), len(t_orig['name'])) + np.testing.assert_equal(len(t.meta['list_times']), expected_shape[1]) + np.testing.assert_equal(t.meta['n_lists'], 9) # Test 2: Add as starlist rather than with keywords. - starlist = StarList(name=t_orig['name'], x=x_new, y=y_new, m=m_new, - xe=xe_new, ye=ye_new, me=me_new, list_time=2001.0, list_name='A.lis') + starlist = StarList( + name=t_orig['name'], + x=x_new, y=y_new, m=m_new, + xe=xe_new, ye=ye_new, me=me_new, + list_time=2001.0, list_name='A.lis' + ) t = make_star_table() t.add_starlist(starlist=starlist) - assert len(t) == len(t_orig) + np.testing.assert_equal(len(t), len(t_orig)) expected_shape = np.array(t_orig['x'].shape) expected_shape[1] += 1 - - assert len(t['x'].shape) == len(expected_shape) - assert t['x'].shape[0] == expected_shape[0] - assert t['x'].shape[1] == expected_shape[1] - assert len(t['y'].shape) == len(expected_shape) - assert t['y'].shape[0] == expected_shape[0] - assert t['y'].shape[1] == expected_shape[1] + np.testing.assert_equal(len(t['x'].shape), len(expected_shape)) + np.testing.assert_equal(t['x'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['x'].shape[1], expected_shape[1]) - assert len(t['m'].shape) == len(expected_shape) - assert t['m'].shape[0] == expected_shape[0] - assert t['m'].shape[1] == expected_shape[1] + np.testing.assert_equal(len(t['y'].shape), len(expected_shape)) + np.testing.assert_equal(t['y'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['y'].shape[1], expected_shape[1]) - assert len(t['xe'].shape) == len(expected_shape) - assert t['xe'].shape[0] == expected_shape[0] - assert t['xe'].shape[1] == expected_shape[1] + np.testing.assert_equal(len(t['m'].shape), len(expected_shape)) + np.testing.assert_equal(t['m'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['m'].shape[1], expected_shape[1]) - assert len(t['ye'].shape) == len(expected_shape) - assert t['ye'].shape[0] == expected_shape[0] - assert t['ye'].shape[1] == expected_shape[1] + np.testing.assert_equal(len(t['xe'].shape), len(expected_shape)) + np.testing.assert_equal(t['xe'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['xe'].shape[1], expected_shape[1]) + np.testing.assert_equal(len(t['ye'].shape), len(expected_shape)) + np.testing.assert_equal(t['ye'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['ye'].shape[1], expected_shape[1]) - assert len(t['me'].shape) == len(expected_shape) - assert t['me'].shape[0] == expected_shape[0] - assert t['me'].shape[1] == expected_shape[1] + np.testing.assert_equal(len(t['me'].shape), len(expected_shape)) + np.testing.assert_equal(t['me'].shape[0], expected_shape[0]) + np.testing.assert_equal(t['me'].shape[1], expected_shape[1]) - assert len(t['name']) == len(t_orig['name']) - assert len(t.meta['list_times']) == expected_shape[1] - assert t.meta['n_lists'] == 9 + np.testing.assert_equal(len(t['name']), len(t_orig['name'])) + np.testing.assert_equal(len(t.meta['list_times']), expected_shape[1]) + np.testing.assert_equal(t.meta['n_lists'], 9) return @@ -255,13 +263,13 @@ def test_get_starlist(): assert t['x'][0,2] == t_list['x'][0] assert type(t_list) == StarList assert len(t_list['x'].shape) == 1 - + return def test_combine_1col(): # User input - cat_file = test_dir + '/test_catalog.fits' + cat_file = f'{test_data_path}/test_catalog.fits' # Read and arrange the test input cat_tab = Table.read(cat_file) @@ -287,11 +295,11 @@ def test_combine_1col(): t.combine_lists('x', weights_col='xe') - assert t['x0'][0] == t['x'][0] + np.testing.assert_equal(t['x0'][0], t['x'][0]) return -def test_fit_velocities(): +def test_fit_motion_models(): tab = make_star_table() tt = make_tiny_star_table() @@ -303,155 +311,99 @@ def test_fit_velocities(): tab = table.vstack((tab1, tab2, tab3)) tab.meta = tab1.meta - tab.fit_velocities(verbose=True) + tab.fit_motion_models(verbose=True, mask_value=-100000.) # Test creation of new variables - assert len(tab['vx']) == len(tab) - assert len(tab['vy']) == len(tab) - assert len(tab['vxe']) == len(tab) - assert len(tab['vye']) == len(tab) - assert len(tab['n_vfit']) == len(tab) - assert tab.meta['n_vfit_bootstrap'] == 0 + np.testing.assert_equal(len(tab['vx']), len(tab)) + np.testing.assert_equal(len(tab['vy']), len(tab)) + np.testing.assert_equal(len(tab['vx_err']), len(tab)) + np.testing.assert_equal(len(tab['vy_err']), len(tab)) + np.testing.assert_equal(len(tab['n_fit']), len(tab)) + np.testing.assert_equal(tab.meta['n_bootstrap'], 0) # Test no-fit for stars with N<2 epochs. n_epochs = (tab['x'] >= 0).sum(axis=1) idx = np.where(n_epochs < 2)[0] - assert (tab['vx'][idx] == 0).all() - assert (tab['vxe'][idx] == 0).all() - assert (tab['n_vfit'][idx] == 2).all() + np.testing.assert_equal((tab['vx'][idx] == 0).all(), True) + np.testing.assert_equal((tab['vx_err'][idx] == 0).all(), True) + np.testing.assert_equal((tab['n_fit'][idx] == 2).all(), True) # Test that the velocity errors were calculated. - assert (tab['vxe'][0:100] > 0).all() - assert (tab['x0e'][0:100] > 0).all() - assert (tab['vye'][0:100] > 0).all() - assert (tab['y0e'][0:100] > 0).all() - assert np.isfinite(tab['x0']).all() - assert np.isfinite(tab['vx']).all() - assert np.isfinite(tab['y0']).all() - assert np.isfinite(tab['vy']).all() - assert np.isfinite(tab['x0e']).all() - assert np.isfinite(tab['vxe']).all() - assert np.isfinite(tab['y0e']).all() - assert np.isfinite(tab['vye']).all() + np.testing.assert_equal((~(tab['vx_err'][0:100] < 0)).all(), True) + np.testing.assert_equal((~(tab['x0_err'][0:100] < 0)).all(), True) + np.testing.assert_equal((~(tab['vy_err'][0:100] < 0)).all(), True) + np.testing.assert_equal((~(tab['y0_err'][0:100] < 0)).all(), True) ########## # Test running a second time. We should get the same results. ########## vx_orig = tab['vx'] x0_orig = tab['x0'] - vxe_orig = tab['vxe'] - x0e_orig = tab['x0e'] - tab.fit_velocities(verbose=False) + vxe_orig = tab['vx_err'] + x0e_orig = tab['x0_err'] + tab.fit_motion_models(verbose=False, mask_value=-100000.) - assert (vx_orig == tab['vx']).all() - assert (x0_orig == tab['x0']).all() - assert (vxe_orig == tab['vxe']).all() - assert (x0e_orig == tab['x0e']).all() + np.testing.assert_allclose(tab['vx'], vx_orig) + np.testing.assert_allclose(tab['x0'], x0_orig) + np.testing.assert_allclose(tab['vx_err'], vxe_orig) + np.testing.assert_allclose(tab['x0_err'], x0e_orig) ########## # Test fixed_t0 functionality ########## fixed_t0 = tab['t0'] + np.random.normal(size=len(tab)) - tab.fit_velocities(fixed_t0=fixed_t0) - - assert(np.sum(abs(tab['t0'] - fixed_t0)) == 0) + tab.fit_motion_models(verbose=False, mask_value=-100000., fixed_params_dict={'t0': fixed_t0}) + np.testing.assert_allclose(tab['t0'], fixed_t0) ########## # Test bootstrap ########## tab_b = table.vstack((tab1, tab2, tab3)) tab_b.meta = tab1.meta - tab_b.fit_velocities(verbose=True, bootstrap=50) - - assert tab_b.meta['n_vfit_bootstrap'] == 50 - assert tab_b['x0e'][0] > tab['x0e'][0] - assert tab_b['vxe'][0] > tab['vxe'][0] - assert tab_b['y0e'][0] > tab['y0e'][0] - assert tab_b['vye'][0] > tab['vye'][0] + tab_b.fit_motion_models(verbose=True, bootstrap=50) + + np.testing.assert_equal(tab_b.meta['n_bootstrap'], 50) + np.testing.assert_array_less(tab['x0_err'][0], tab_b['x0_err'][0]) + np.testing.assert_array_less(tab['vx_err'][0], tab_b['vx_err'][0]) + np.testing.assert_array_less(tab['y0_err'][0], tab_b['y0_err'][0]) + np.testing.assert_array_less(tab['vy_err'][0], tab_b['vy_err'][0]) ########## # Test what happens with no velocity errors ########## - tab.remove_columns(['xe', 'ye', 'x0', 'y0', 'x0e', 'y0e', 'vx', 'vy', 'vxe', 'vye', 'n_vfit']) - tab.fit_velocities(verbose=False) - - assert len(tab['vx']) == len(tab) - assert len(tab['vy']) == len(tab) - assert len(tab['vxe']) == len(tab) - assert len(tab['vye']) == len(tab) - assert len(tab['n_vfit']) == len(tab) - assert (tab['vxe'][0:100] > 0).all() - assert (tab['x0e'][0:100] > 0).all() - assert (tab['vye'][0:100] > 0).all() - assert (tab['y0e'][0:100] > 0).all() + tab.remove_columns(['xe', 'ye', 'x0', 'y0', 'x0_err', 'y0_err', 'vx', 'vy', 'vx_err', 'vy_err', 'n_fit']) + tab.fit_motion_models(verbose=False) + + np.testing.assert_equal(len(tab['vx']), len(tab)) + np.testing.assert_equal(len(tab['vy']), len(tab)) + np.testing.assert_equal(len(tab['vx_err']), len(tab)) + np.testing.assert_equal(len(tab['vy_err']), len(tab)) + np.testing.assert_equal(len(tab['n_fit']), len(tab)) + np.testing.assert_equal((~(tab['vx_err'][0:100] < 0)).all(), True) + np.testing.assert_equal((~(tab['x0_err'][0:100] < 0)).all(), True) + np.testing.assert_equal((~(tab['vy_err'][0:100] < 0)).all(), True) + np.testing.assert_equal((~(tab['y0_err'][0:100] < 0)).all(), True) ######### # Test mask_list ######### # Test 5a: Masked - tt.fit_velocities(bootstrap=0, verbose=False, mask_lists=[1]) - assert np.arange(2.25, 48, 5) == pytest.approx(tt['x0'].data) - assert np.arange(2.25, 48, 5) == pytest.approx(tt['y0'].data) - assert np.zeros(10) == pytest.approx(tt['x0e'].data) - assert np.zeros(10) == pytest.approx(tt['y0e'].data) - assert np.ones(10) == pytest.approx(tt['vx'].data) - assert np.ones(10) == pytest.approx(tt['vy'].data) - assert np.zeros(10) == pytest.approx(tt['vxe'].data) - assert np.zeros(10) == pytest.approx(tt['vye'].data) - assert 2017.25 * np.ones(10) == pytest.approx(tt['t0'].data) - - # Test 5b: Things that should break the code. - with pytest.raises(RuntimeError): - tt.fit_velocities(bootstrap=0, verbose=False, mask_lists=np.arange(2)) - with pytest.raises(RuntimeError): - tt.fit_velocities(bootstrap=0, verbose=False, mask_lists=True) + print("Testing Masked List") + tt.fit_motion_models(verbose=False, mask_lists=[1]) + np.testing.assert_allclose(np.arange(2.25, 48, 5), tt['x0'].data) + np.testing.assert_allclose(np.arange(2.25, 48, 5), tt['y0'].data) + np.testing.assert_allclose(np.full(10, 0.05), tt['x0_err'].data) + np.testing.assert_allclose(np.full(10, 0.05), tt['y0_err'].data) + np.testing.assert_allclose(np.ones(10), tt['vx'].data) + np.testing.assert_allclose(np.ones(10), tt['vy'].data) + np.testing.assert_allclose(np.full(10, 0.03380617), tt['vx_err'].data) + np.testing.assert_allclose(np.full(10, 0.03380617), tt['vy_err'].data) + np.testing.assert_allclose(2017.25 * np.ones(10), tt['t0'].data) return -def test_fit_velocities_1epoch(): - ########## - # Test: only 1 epoch - ########## - tab = make_star_table_1epoch() - - # We don't need the entire table... lets just - # pull a small subset for faster testing. - tab1 = tab[0:100] - tab2 = tab[10000:10100] - tab3 = tab[-100:] - tab_1 = table.vstack((tab1, tab2, tab3)) - - tab_1.fit_velocities(verbose=False) - - assert 'n_vfit' in tab_1.colnames - assert 't0' in tab_1.colnames - assert 'x0' in tab_1.colnames - assert 'y0' in tab_1.colnames - assert 'vx' in tab_1.colnames - assert 'vy' in tab_1.colnames - assert 'x0e' in tab_1.colnames - assert 'y0e' in tab_1.colnames - assert 'vxe' in tab_1.colnames - assert 'vye' in tab_1.colnames - - - assert (tab_1['x0'] == tab_1['x'][:,0]).all() - assert (tab_1['y0'] == tab_1['y'][:,0]).all() - assert (tab_1['x0e'] == tab_1['xe'][:,0]).all() - assert (tab_1['y0e'] == tab_1['ye'][:,0]).all() - - assert(tab_1['vx'] == 0).all() - assert(tab_1['vy'] == 0).all() - assert(tab_1['vxe'] == 0).all() - assert(tab_1['vye'] == 0).all() - - assert(tab_1['t0'] == 2001.0).all() - assert(tab_1['n_vfit'] == 1).all() - - return -def test_fit_velocities_2epoch(): - +def test_fit_motion_model_2epoch(): ########## # Test: only 2 epoch2 ########## @@ -463,37 +415,91 @@ def test_fit_velocities_2epoch(): tab2 = tab[10000:10100] tab3 = tab[-100:] tab_2 = table.vstack((tab1, tab2, tab3)) + tab_2.meta=tab1.meta - tab_2.fit_velocities(verbose=False) + tab_2.fit_motion_models(verbose=False, mask_value=-100000.) - assert 'n_vfit' in tab_2.colnames - assert 't0' in tab_2.colnames - assert 'x0' in tab_2.colnames - assert 'y0' in tab_2.colnames - assert 'vx' in tab_2.colnames - assert 'vy' in tab_2.colnames - assert 'x0e' in tab_2.colnames - assert 'y0e' in tab_2.colnames - assert 'vxe' in tab_2.colnames - assert 'vye' in tab_2.colnames + assert all([_ in tab_2.colnames for _ in ['n_fit', 't0', 'x0', 'y0', 'vx', 'vy', 'x0_err', 'y0_err', 'vx_err', 'vy_err']]) # 2 detections + print(tab1.meta) np.testing.assert_almost_equal(tab_2['x0'][0], tab_2['x'][0,0], 1) - assert tab_2['n_vfit'][0] == 2 - + np.testing.assert_equal(tab_2['n_fit'][0], 2) + # 1 detection - assert tab_2['x0'][100] == tab_2['x'][100, 0] - assert tab_2['n_vfit'][100] == 1 - + np.testing.assert_equal(tab_2['x0'][100], tab_2['x'][100, 0]) + np.testing.assert_equal(tab_2['n_fit'][100], 1) + # 0 detections - assert tab_2['x0'][-1] == 0 - assert tab_2['n_vfit'][-1] == 0 - + np.testing.assert_equal(np.isnan(tab_2['x0'][-1]), True) + np.testing.assert_equal(tab_2['n_fit'][-1], 0) + return + +def test_multiprocessing(): + rng = np.random.default_rng(42) + N = 10000 + x = rng.random((N, 5)) + y = rng.random((N, 5)) + m = rng.random((N, 5)) + xe = rng.random((N, 5)) + ye = rng.random((N, 5)) + t = np.arange(5) + 2026 + fixed_params_dict = [None for _ in range(N)] + weighting = 'var' + fill_value = np.nan + verbose = True + + st1 = StarTable( + name=np.arange(N), + x=x, + y=y, + m=m, + xe=xe, + ye=ye + ) + st1.meta['list_times'] = t + + st2 = StarTable( + name=np.arange(N), + x=x, + y=y, + m=m, + xe=xe, + ye=ye + ) + st2.meta['list_times'] = t + + st1.fit_motion_models( + motion_models=['Linear'], + weighting=weighting, + use_scipy=True, + absolute_sigma=True, + bootstrap=0, + fill_value=fill_value, + verbose=verbose + ) + + st2.fit_motion_models( + motion_models=['Linear'], + weighting=weighting, + use_scipy=True, + absolute_sigma=True, + bootstrap=0, + fill_value=fill_value, + processes=10, + verbose=verbose + ) + + for key in ['x0', 'x0_err', 'y0', 'y0_err', 'vx', 'vx_err', 'vy', 'vy_err', 'chi2_x', 'chi2_y', 'n_params', 't0']: + np.testing.assert_array_equal(st1[key], st2[key], err_msg=f"Mismatch in {key} between single and multi-processing runs.") + return + + def make_star_table(): # User input - cat_file = test_dir + '/test_catalog.fits' + cat_file = f'{test_data_path}/test_catalog.fits' # Read and arrange the test input cat_tab = Table.read(cat_file) @@ -514,15 +520,21 @@ def make_star_table(): starlist_names = np.array(['file1', 'file2', 'file3', 'file4', 'file5', 'file6', 'file7', 'file8']) # Generate the startable - startable = StarTable(name=name_in, x=x_in, y=y_in, m=m_in, xe=xe_in, ye=ye_in, me=me_in, n=n_in, - ref_list=1, - list_times=starlist_times, list_names=starlist_names) + startable = StarTable( + name=name_in, + x=x_in, y=y_in, m=m_in, + xe=xe_in, ye=ye_in, me=me_in, + n=n_in, + ref_list=1 + ) + startable.meta['list_times'] = starlist_times + startable.meta['list_names'] = starlist_names return startable def make_star_table_1epoch(): # User input - cat_file = test_dir + '/test_catalog.fits' + cat_file = f'{test_data_path}/test_catalog.fits' # Read and arrange the test input cat_tab = Table.read(cat_file) @@ -550,8 +562,8 @@ def make_star_table_1epoch(): return startable def make_star_table_2epoch(): - # User inpup - cat_file = test_dir + '/test_catalog.fits' + # User input + cat_file = f'{test_data_path}/test_catalog.fits' # Read and arrange the test input cat_tab = Table.read(cat_file) diff --git a/flystar/tests/test_transforms.py b/flystar/tests/test_transforms.py index ea7c423..11338ad 100644 --- a/flystar/tests/test_transforms.py +++ b/flystar/tests/test_transforms.py @@ -22,9 +22,9 @@ def compare_evaluate_errors(): xe = np.abs(np.random.randn(100) * 0.1) ye = np.abs(np.random.randn(100) * 0.1) - xe_new1 = foo._evaluate_error2(x, y, xe, ye, foo.px.parameters) + # xe_new1 = foo._evaluate_error2(x, y, xe, ye, foo.px.parameters) - xe_new2, ye_new2 = foo._evaluate_error(x, y, xe, ye) + xe_new2, ye_new2 = foo.evaluate_error(x, y, xe, ye) # BROKEN diff --git a/flystar/transforms.py b/flystar/transforms.py index 0a1885a..968ccfa 100755 --- a/flystar/transforms.py +++ b/flystar/transforms.py @@ -5,7 +5,9 @@ from astropy.table import Table import collections import re -import pdb +import copy +import datetime +from . import motion_model class Transform2D(object): ''' @@ -112,21 +114,39 @@ def evaluate_starlist(self, star_list): new_list['xe'] = vals[0] new_list['ye'] = vals[1] - # Velocities (if they exist) - if 'vx' in new_list.colnames: + # Velocities (if they exist and no more complex motion model used) + complex_motion_model = ('motion_model_input' in new_list.colnames) + if complex_motion_model: + # If the only motion models used are Fixed and Linear, we can still transform velocities. + motion_models_unique = list(np.unique(starlist_f['motion_model_input'])) + if 'Linear' in motion_models_unique: + motion_models_unique.remove('Linear') + if 'Fixed' in motion_models_unique: + motion_models_unique.remove('Fixed') + if len(motion_models_unique)==0: + complex_motion_model=False + # Cannot transform more complex motion models - set values to nan + if complex_motion_model: + motion_params = motion_model.motion_model_param_names(new_list['motion_model_input'], with_errors=True, with_fixed=False) + for param in motion_params: + if param in new_list.colnames: + new_list[param] = np.nan + + if ('vx' in new_list.colnames) and (not complex_motion_model): + # For velocity only, no problem vals = self.evaluate_vel(star_list['x'], star_list['y'], star_list['vx'], star_list['vy']) new_list['vx'] = vals[0] new_list['vy'] = vals[1] # Velocity errors (if they exist) - if 'vxe' in new_list.colnames: + if 'vx_err' in new_list.colnames: vals = self.evaluate_vel_error(star_list['x'], star_list['y'], star_list['vx'], star_list['vy'], star_list['xe'], star_list['ye'], - star_list['vxe'], star_list['vye']) - new_list['vxe'] = vals[0] - new_list['vye'] = vals[1] + star_list['vx_err'], star_list['vy_err']) + new_list['vx_err'] = vals[0] + new_list['vy_err'] = vals[1] return new_list @@ -201,7 +221,7 @@ def evaluate(self, x, y): yn = self.py[0] + self.py[1]*x + self.py[2]*y return xn, yn - def evaluate_error(self, x, y): + def evaluate_error(self, x, y, xe, ye): """ Transform positional uncertainties. @@ -226,7 +246,7 @@ def evaluate_error(self, x, y): """ xe_new = np.hypot(self.px[1] * xe, self.px[2] * ye) - xe_new = np.hpyot(self.px[1] * xe, self.px[2] * ye) + ye_new = np.hpyot(self.px[1] * xe, self.px[2] * ye) return xe_new, ye_new @@ -254,14 +274,14 @@ def __init__(self, order, px, py, pxerr=None, pyerr=None, mag_offset=0.0): Parameters ---------- - px : list or array [a0, a1, a2, ...] + order : int + The order of the transformation. 0 = 2 free parameters, 1 = 6 free parameters. + + px : list or array [a0, a1, a2, ...] coefficients to transform input x coordinates into output x' coordinates. py : list or array [b0, b1, b2, ...] coefficients to transform input y coordinates into output y' coordinates. - - order : int - The order of the transformation. 0 = 2 free parameters, 1 = 6 free parameters. pxerr : array or list array or list of errors of the coefficients to transform input x coordinates @@ -288,7 +308,7 @@ def __init__(self, order, px, py, pxerr=None, pyerr=None, mag_offset=0.0): px_dict = PolyTransform.make_param_dict(px, self.poly_order, isY=False) py_dict = PolyTransform.make_param_dict(py, self.poly_order, isY=True) - fixed_params = {'c0_0': False, 'c1_0': True, 'c1_1': True} + fixed_params = {'c0_0': False, 'c1_0': True, 'c0_1': True} #, 'c1_1':True} self.px = models.Polynomial2D(self.poly_order, **px_dict, fixed=fixed_params) self.py = models.Polynomial2D(self.poly_order, **py_dict, fixed=fixed_params) else: @@ -312,7 +332,7 @@ def make_param_dict(initial_param, order, isY=False): a0 + a1*x + a2*y + a3*x^2 + a4*x*y + a5*y^2 + a6*x^3 + a7*x^2*y + a8*x*y^2 + a9*y^3 - and conver this into a dictionary where: + and convert this into a dictionary where: c0_0 = a0 c1_0 = a1 @@ -580,7 +600,7 @@ def derive_transform(cls, x, y, xref, yref, order, m=None, mref=None, init_gx = PolyTransform.make_param_dict(init_gx, poly_order, isY=False) init_gy = PolyTransform.make_param_dict(init_gy, poly_order, isY=True) - fixed_params = {'c0_0': False, 'c1_0': True, 'c1_1': True, 'c0_1': True} + fixed_params = {'c0_0': False, 'c1_0': True, 'c0_1': True} #, 'c1_1':True} p_init_x = models.Polynomial2D(poly_order, **init_gx, fixed=fixed_params) p_init_y = models.Polynomial2D(poly_order, **init_gy, fixed=fixed_params) else: @@ -592,6 +612,7 @@ def derive_transform(cls, x, y, xref, yref, order, m=None, mref=None, fit_p = fitting.LinearLSQFitter() + #pdb.set_trace() px = fit_p(p_init_x, x, y, xref, weights=weights) py = fit_p(p_init_y, x, y, yref, weights=weights) @@ -646,7 +667,7 @@ def from_file(cls, trans_file): return trans_obj - def to_file(self, trans_file): + def to_file(self, transform, outFile): """ Given a transformation object, write out the coefficients in a text file (readable by java align). Outfile name is specified by user. @@ -657,9 +678,9 @@ def to_file(self, trans_file): Parameters: ---------- - trans_file : str - The name of the output file to save the coefficients and meta data to. - This file can be read back in with + transform : PolyTransform + The transformation object containing the coefficients and meta data to save. + This object can be recreated with trans_obj = PolyTransfrom.from_file(trans_file). @@ -675,7 +696,7 @@ def to_file(self, trans_file): # Write output _out = open(outFile, 'w') - + # Write the header. DO NOT CHANGE, HARDCODED IN JAVA ALIGN _out.write('## Date: {0}\n'.format(datetime.date.today()) ) _out.write('## File: {0}, Reference: {1}\n'.format(starlist, reference) ) diff --git a/setup.cfg b/setup.cfg index 0bf235e..d851345 100644 --- a/setup.cfg +++ b/setup.cfg @@ -37,7 +37,7 @@ testpaths = "flystar" "docs" astropy_header = true doctest_plus = enabled text_file_format = rst -addopts = --doctest-rst +#addopts = --doctest-rst [coverage:run] omit =