From 0c86b27513daa1289e62a6edb56a20275591cb6b Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Fri, 13 Oct 2023 11:08:10 -0400 Subject: [PATCH 01/38] Implement use of an initial fid drift correction --- proseco/fid.py | 25 +++++++++++++++++++++++-- proseco/tests/conftest.py | 5 +++++ proseco/tests/test_fid.py | 20 ++++++++++++++++++-- 3 files changed, 46 insertions(+), 4 deletions(-) diff --git a/proseco/fid.py b/proseco/fid.py index 67a85413..59230de9 100644 --- a/proseco/fid.py +++ b/proseco/fid.py @@ -5,10 +5,13 @@ Get a catalog of fid lights. """ +import os import weakref import numpy as np +from chandra_aca.fid_drift import get_drift from chandra_aca.transform import yagzag_to_pixels +from cxotime import CxoTime from . import characteristics as ACA from . import characteristics_acq as ACQ @@ -316,7 +319,7 @@ def get_fid_candidates(self): Result is updating self.cand_fids. """ yang, zang = get_fid_positions( - self.detector, self.focus_offset, self.sim_offset + self.detector, self.focus_offset, self.sim_offset, self.t_ccd_acq, self.date ) row, col = yagzag_to_pixels(yang, zang, allow_bad=True) ids = np.arange(len(yang), dtype=np.int64) + 1 # E.g. 1 to 6 for ACIS @@ -472,7 +475,7 @@ def set_spoilers_score(self, fid): ) -def get_fid_positions(detector, focus_offset, sim_offset): +def get_fid_positions(detector, focus_offset, sim_offset, t_ccd_acq=None, date=None): """Calculate the fid light positions for all fids for ``detector``. This is adapted from the Matlab @@ -518,4 +521,22 @@ def get_fid_positions(detector, focus_offset, sim_offset): yang, zang = np.degrees(yfid) * 3600, np.degrees(zfid) * 3600 + # Apply fid drift + enable_fid_drift_env = os.environ.get("PROSECO_ENABLE_FID_DRIFT", "True") + if enable_fid_drift_env not in ("True", "False"): + raise ValueError( + f'PROSECO_ENABLE_FID_DRIFT env var must be either "True" or "False" ' + f"got {enable_fid_drift}" + ) + + # The env var is still just a string so do a string equals on it + if enable_fid_drift_env == "True": + if t_ccd_acq is None or date is None: + raise ValueError( + "t_ccd_acq and date must be provided if fid drift is enabled" + ) + dy, dz = get_drift(date, t_ccd_acq) + yang += dy + zang += dz + return yang, zang diff --git a/proseco/tests/conftest.py b/proseco/tests/conftest.py index d8c737f9..3a56dcea 100644 --- a/proseco/tests/conftest.py +++ b/proseco/tests/conftest.py @@ -7,6 +7,11 @@ def use_fixed_chandra_models(monkeypatch): monkeypatch.setenv("CHANDRA_MODELS_DEFAULT_VERSION", "3.48") +@pytest.fixture(autouse=True) +def disable_fid_drift(monkeypatch): + monkeypatch.setenv("PROSECO_ENABLE_FID_DRIFT", "False") + + # By default test with the latest AGASC version available including release candidates @pytest.fixture(autouse=True) def proseco_agasc_rc(monkeypatch): diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index 28ec2aeb..a03c47e6 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -10,14 +10,16 @@ from ..fid import get_fid_catalog, get_fid_positions from .test_common import DARK40, OBS_INFO, STD_INFO, mod_std_info -# Reference fid positions for spoiling tests +# Reference fid positions for spoiling tests. Because this is done outside +# a test the fixture to generally disable fid drift is not in effect. +os.environ["PROSECO_ENABLE_FID_DRIFT"] = "False" FIDS = get_fid_catalog(stars=StarsTable.empty(), **STD_INFO) # Do not use the AGASC supplement in testing by default since mags can change os.environ[agasc.SUPPLEMENT_ENABLED_ENV] = "False" -def test_get_fid_position(): +def test_get_fid_position(monkeypatch): """ Compare computed fid positions to flight values from starcheck reports. """ @@ -48,6 +50,20 @@ def test_get_fid_position(): assert np.allclose(yang[fidset], [-1174, 1224, -1177], rtol=0, atol=1.1) assert np.allclose(zang[fidset], [-468, -460, 561], rtol=0, atol=1.1) + yang1, zang1 = get_fid_positions("ACIS-S", focus_offset=0.0, sim_offset=0.0) + monkeypatch.setenv("CHANDRA_MODELS_DEFAULT_VERSION", "fid-drift") + monkeypatch.setenv("PROSECO_ENABLE_FID_DRIFT", "True") + yang2, zang2 = get_fid_positions( + "ACIS-S", focus_offset=0.0, sim_offset=0.0, date="2023:235", t_ccd_acq=-13.65 + ) + yang3, zang3 = get_fid_positions( + "ACIS-S", focus_offset=0.0, sim_offset=0.0, date="2019:001", t_ccd_acq=-13.65 + ) + assert np.allclose(yang1, yang3, rtol=0, atol=0.1) + assert np.allclose(zang1, zang3, rtol=0, atol=0.1) + assert np.allclose(yang1 - yang2, -36.35, rtol=0, atol=0.1) + assert np.allclose(zang1 - zang2, -11.83, rtol=0, atol=0.1) + def test_get_initial_catalog(): """Test basic catalog with no stars in field using standard 2-4-5 config.""" From f39da1eb06bbd66a427f0ba25c95c45bad6adbf2 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Tue, 17 Oct 2023 17:48:46 -0400 Subject: [PATCH 02/38] Update to use new get_fid_offset function in chandra_aca --- proseco/fid.py | 18 +++++++++--------- proseco/tests/conftest.py | 2 +- proseco/tests/test_fid.py | 14 ++++---------- 3 files changed, 14 insertions(+), 20 deletions(-) diff --git a/proseco/fid.py b/proseco/fid.py index 59230de9..4ac6c0d4 100644 --- a/proseco/fid.py +++ b/proseco/fid.py @@ -9,7 +9,7 @@ import weakref import numpy as np -from chandra_aca.fid_drift import get_drift +from chandra_aca.drift import get_fid_offset from chandra_aca.transform import yagzag_to_pixels from cxotime import CxoTime @@ -521,21 +521,21 @@ def get_fid_positions(detector, focus_offset, sim_offset, t_ccd_acq=None, date=N yang, zang = np.degrees(yfid) * 3600, np.degrees(zfid) * 3600 - # Apply fid drift - enable_fid_drift_env = os.environ.get("PROSECO_ENABLE_FID_DRIFT", "True") - if enable_fid_drift_env not in ("True", "False"): + # Apply fid offset + enable_fid_offset_env = os.environ.get("PROSECO_ENABLE_FID_OFFSET", "True") + if enable_fid_offset_env not in ("True", "False"): raise ValueError( - f'PROSECO_ENABLE_FID_DRIFT env var must be either "True" or "False" ' - f"got {enable_fid_drift}" + f'PROSECO_ENABLE_FID_OFFSET env var must be either "True" or "False" ' + f"got {enable_fid_offset_env}" ) # The env var is still just a string so do a string equals on it - if enable_fid_drift_env == "True": + if enable_fid_offset_env == "True": if t_ccd_acq is None or date is None: raise ValueError( - "t_ccd_acq and date must be provided if fid drift is enabled" + "t_ccd_acq and date must be provided if fid offset is enabled" ) - dy, dz = get_drift(date, t_ccd_acq) + dy, dz = get_fid_offset(date, t_ccd_acq) yang += dy zang += dz diff --git a/proseco/tests/conftest.py b/proseco/tests/conftest.py index 3a56dcea..769fedbd 100644 --- a/proseco/tests/conftest.py +++ b/proseco/tests/conftest.py @@ -9,7 +9,7 @@ def use_fixed_chandra_models(monkeypatch): @pytest.fixture(autouse=True) def disable_fid_drift(monkeypatch): - monkeypatch.setenv("PROSECO_ENABLE_FID_DRIFT", "False") + monkeypatch.setenv("PROSECO_ENABLE_FID_OFFSET", "False") # By default test with the latest AGASC version available including release candidates diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index a03c47e6..4785a1f5 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -12,7 +12,7 @@ # Reference fid positions for spoiling tests. Because this is done outside # a test the fixture to generally disable fid drift is not in effect. -os.environ["PROSECO_ENABLE_FID_DRIFT"] = "False" +os.environ["PROSECO_ENABLE_FID_OFFSET"] = "False" FIDS = get_fid_catalog(stars=StarsTable.empty(), **STD_INFO) # Do not use the AGASC supplement in testing by default since mags can change @@ -51,18 +51,12 @@ def test_get_fid_position(monkeypatch): assert np.allclose(zang[fidset], [-468, -460, 561], rtol=0, atol=1.1) yang1, zang1 = get_fid_positions("ACIS-S", focus_offset=0.0, sim_offset=0.0) - monkeypatch.setenv("CHANDRA_MODELS_DEFAULT_VERSION", "fid-drift") - monkeypatch.setenv("PROSECO_ENABLE_FID_DRIFT", "True") + monkeypatch.setenv("PROSECO_ENABLE_FID_OFFSET", "True") yang2, zang2 = get_fid_positions( "ACIS-S", focus_offset=0.0, sim_offset=0.0, date="2023:235", t_ccd_acq=-13.65 ) - yang3, zang3 = get_fid_positions( - "ACIS-S", focus_offset=0.0, sim_offset=0.0, date="2019:001", t_ccd_acq=-13.65 - ) - assert np.allclose(yang1, yang3, rtol=0, atol=0.1) - assert np.allclose(zang1, zang3, rtol=0, atol=0.1) - assert np.allclose(yang1 - yang2, -36.35, rtol=0, atol=0.1) - assert np.allclose(zang1 - zang2, -11.83, rtol=0, atol=0.1) + assert np.allclose(yang1 - yang2, -33.16, rtol=0, atol=0.1) + assert np.allclose(zang1 - zang2, -9.83, rtol=0, atol=0.1) def test_get_initial_catalog(): From c29342b28b9dcbccc898f6d48c223d1c8c0486de Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Sun, 29 Oct 2023 11:43:47 -0400 Subject: [PATCH 03/38] Update PROSECO_ENABLE_FID_OFFSET to tri-state --- proseco/fid.py | 43 ++++++++++++++++++++++++----------- proseco/tests/test_fid.py | 48 ++++++++++++++++++++++++++++++++++++--- 2 files changed, 75 insertions(+), 16 deletions(-) diff --git a/proseco/fid.py b/proseco/fid.py index 4ac6c0d4..6920cdbe 100644 --- a/proseco/fid.py +++ b/proseco/fid.py @@ -11,7 +11,7 @@ import numpy as np from chandra_aca.drift import get_fid_offset from chandra_aca.transform import yagzag_to_pixels -from cxotime import CxoTime +from cxotime import CxoTime, CxoTimeLike from . import characteristics as ACA from . import characteristics_acq as ACQ @@ -319,7 +319,11 @@ def get_fid_candidates(self): Result is updating self.cand_fids. """ yang, zang = get_fid_positions( - self.detector, self.focus_offset, self.sim_offset, self.t_ccd_acq, self.date + self.detector, + self.focus_offset, + self.sim_offset, + t_ccd=self.t_ccd_acq, + date=self.date, ) row, col = yagzag_to_pixels(yang, zang, allow_bad=True) ids = np.arange(len(yang), dtype=np.int64) + 1 # E.g. 1 to 6 for ACIS @@ -475,7 +479,13 @@ def set_spoilers_score(self, fid): ) -def get_fid_positions(detector, focus_offset, sim_offset, t_ccd_acq=None, date=None): +def get_fid_positions( + detector: str, + focus_offset: float, + sim_offset: float, + t_ccd: float | None = None, + date: CxoTimeLike | None = None, +) -> tuple: """Calculate the fid light positions for all fids for ``detector``. This is adapted from the Matlab @@ -495,9 +505,14 @@ def get_fid_positions(detector, focus_offset, sim_offset, t_ccd_acq=None, date=N yfid=-SIfield.fidpos(:,1)/(SIfield.focallength-xshift); zfid=-zshift/(SIfield.focallength-xshift); + This function also applies a temperature-dependent fid offset if t_ccd and date + are supplied and the PROSECO_ENABLE_FID_OFFSET env var is 'True' or None. + :param detector: 'ACIS-S' | 'ACIS-I' | 'HRC-S' | 'HRC-I' :param focus_offset: SIM focus offset [steps] :param sim_offset: SIM translation offset from nominal [steps] + :param t_ccd: CCD temperature (C) + :param date: date (CxoTime compatible) :returns: yang, zang where each is a np.array of angles [arcsec] """ @@ -521,22 +536,24 @@ def get_fid_positions(detector, focus_offset, sim_offset, t_ccd_acq=None, date=N yang, zang = np.degrees(yfid) * 3600, np.degrees(zfid) * 3600 - # Apply fid offset - enable_fid_offset_env = os.environ.get("PROSECO_ENABLE_FID_OFFSET", "True") - if enable_fid_offset_env not in ("True", "False"): + enable_fid_offset_env = os.environ.get("PROSECO_ENABLE_FID_OFFSET") + if enable_fid_offset_env not in ("True", "False", None): raise ValueError( - f'PROSECO_ENABLE_FID_OFFSET env var must be either "True" or "False" ' + f'PROSECO_ENABLE_FID_OFFSET env var must be either "True", "False", or None, ' f"got {enable_fid_offset_env}" ) - # The env var is still just a string so do a string equals on it - if enable_fid_offset_env == "True": - if t_ccd_acq is None or date is None: + # If enable_fid_offset_env is None or True then try to apply an offset + if not enable_fid_offset_env or enable_fid_offset_env == "True": + # Require that t_ccd and date are provided if fid offset is enabled + if enable_fid_offset_env == "True" and (t_ccd is None or date is None): raise ValueError( "t_ccd_acq and date must be provided if fid offset is enabled" ) - dy, dz = get_fid_offset(date, t_ccd_acq) - yang += dy - zang += dz + + if t_ccd is not None and date is not None: + dy, dz = get_fid_offset(date, t_ccd) + yang += dy + zang += dz return yang, zang diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index 4785a1f5..20171313 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -50,13 +50,55 @@ def test_get_fid_position(monkeypatch): assert np.allclose(yang[fidset], [-1174, 1224, -1177], rtol=0, atol=1.1) assert np.allclose(zang[fidset], [-468, -460, 561], rtol=0, atol=1.1) + +def test_get_fid_pos_with_offsets(monkeypatch): + # Confirm that if env var is set to 'False' then no offset is applied. + # Env var is set to false in the fixture. yang1, zang1 = get_fid_positions("ACIS-S", focus_offset=0.0, sim_offset=0.0) + + # Confirm that if env var is set to 'True' and t_ccd and date are specified, then + # offset is applied. monkeypatch.setenv("PROSECO_ENABLE_FID_OFFSET", "True") yang2, zang2 = get_fid_positions( - "ACIS-S", focus_offset=0.0, sim_offset=0.0, date="2023:235", t_ccd_acq=-13.65 + "ACIS-S", focus_offset=0.0, sim_offset=0.0, date="2023:235", t_ccd=-13.65 + ) + assert np.allclose(yang1 - yang2, -32.47, rtol=0, atol=0.1) + assert np.allclose(zang1 - zang2, -9.63, rtol=0, atol=0.1) + + # Confirm that if env var is not set and t_ccd and date are specified, then + # offset is applied. + monkeypatch.delenv("PROSECO_ENABLE_FID_OFFSET", raising=False) + yang3, zang3 = get_fid_positions( + "ACIS-S", focus_offset=0.0, sim_offset=0.0, date="2023:235", t_ccd=-13.65 + ) + assert np.allclose(yang2, yang3, rtol=0, atol=0.1) + assert np.allclose(zang2, zang3, rtol=0, atol=0.1) + + # Confirm that if env var is not set and t_ccd and date not specified, then + # no offset is applied. + monkeypatch.delenv("PROSECO_ENABLE_FID_OFFSET", raising=False) + yang4, zang4 = get_fid_positions( + "ACIS-S", + focus_offset=0.0, + sim_offset=0.0, ) - assert np.allclose(yang1 - yang2, -33.16, rtol=0, atol=0.1) - assert np.allclose(zang1 - zang2, -9.83, rtol=0, atol=0.1) + assert np.allclose(yang1, yang4, rtol=0, atol=0.1) + assert np.allclose(zang1, zang4, rtol=0, atol=0.1) + + # Confirm if env var is set to 'True' and t_ccd and date not specified, then + # there's an error. + monkeypatch.setenv("PROSECO_ENABLE_FID_OFFSET", "True") + with pytest.raises(ValueError, match="t_ccd_acq and date must be provided"): + get_fid_positions("ACIS-S", focus_offset=0.0, sim_offset=0.0) + + # Confirm an error if env var set to not-allowed value + monkeypatch.setenv("PROSECO_ENABLE_FID_OFFSET", "foo") + with pytest.raises( + ValueError, match='env var must be either "True", "False", or None,' + ): + get_fid_positions( + "ACIS-S", focus_offset=0.0, sim_offset=0.0, t_ccd=-13.65, date="2023:235" + ) def test_get_initial_catalog(): From e52fe59ab6243018e7d3df53a94629c78c21e37d Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Sun, 29 Oct 2023 12:18:02 -0400 Subject: [PATCH 04/38] Update warning text --- proseco/fid.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proseco/fid.py b/proseco/fid.py index 6920cdbe..0e258de9 100644 --- a/proseco/fid.py +++ b/proseco/fid.py @@ -548,7 +548,7 @@ def get_fid_positions( # Require that t_ccd and date are provided if fid offset is enabled if enable_fid_offset_env == "True" and (t_ccd is None or date is None): raise ValueError( - "t_ccd_acq and date must be provided if fid offset is enabled" + "t_ccd_acq and date must be provided if PROSECO_ENABLE_FID_OFFSET is 'True'" ) if t_ccd is not None and date is not None: From 550e0efdfe341252a46382b784d55be3b7c7f0d5 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Sat, 11 Nov 2023 08:47:33 -0500 Subject: [PATCH 05/38] Remove unnecessary monkeypatch --- proseco/tests/test_fid.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index 20171313..76b190ed 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -19,7 +19,7 @@ os.environ[agasc.SUPPLEMENT_ENABLED_ENV] = "False" -def test_get_fid_position(monkeypatch): +def test_get_fid_position(): """ Compare computed fid positions to flight values from starcheck reports. """ From b4bfa31e98c5cdc8f7bf27291cff9aba5ddca718 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Sat, 11 Nov 2023 08:47:55 -0500 Subject: [PATCH 06/38] Update comment --- proseco/fid.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/proseco/fid.py b/proseco/fid.py index 0e258de9..0df855bc 100644 --- a/proseco/fid.py +++ b/proseco/fid.py @@ -551,6 +551,8 @@ def get_fid_positions( "t_ccd_acq and date must be provided if PROSECO_ENABLE_FID_OFFSET is 'True'" ) + # Apply fid offset if t_ccd and date are provided + # (this is an "if" the case when enable_fid_offset_env is None) if t_ccd is not None and date is not None: dy, dz = get_fid_offset(date, t_ccd) yang += dy From 56d76a111791867d36b1e7b6d7245206a4b5277c Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Sat, 11 Nov 2023 09:29:53 -0500 Subject: [PATCH 07/38] Update docs to include new env var --- docs/index.rst | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/docs/index.rst b/docs/index.rst index 45fec3de..ed5a3563 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -317,7 +317,13 @@ The following environment variables are used by proseco: "4", "6", or "8". - ``PROSECO_PRINT_OBC_CAT``: if set then create and print a debug catalog while doing catalog merging. -- ``SKA``: root directory for Ska3 runtime environment +- ``PROSECO_ENABLE_FID_OFFSET``: controls application of time and temperature dependent fid + light positions offsets. These are conditionally applied in `proseco.fid.get_fid_positions`. + If var set to ``"False"`` then do not apply the time and temperature to the catalog positions + (should not be used in production). If set to ``"True"`` `get_fid_positions` will apply offsets + and throw an error if the time and temperature are not available. If set to `None`, the default, + then `get_fid_positions` will apply offsets if the time and temperature are available. +- ``SKA``: root directory that contains 'data' directory API docs -------- From d62bc3586c7310b439f3b653fc3b4a08ad1f81e4 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Thu, 30 Nov 2023 12:52:02 -0500 Subject: [PATCH 08/38] Add fid offset functional testing and position check notebooks --- analysis/backstop_offsets.ipynb | 201 ++ analysis/reselect_fid_offset.ipynb | 3573 ++++++++++++++++++++++++++++ 2 files changed, 3774 insertions(+) create mode 100644 analysis/backstop_offsets.ipynb create mode 100644 analysis/reselect_fid_offset.ipynb diff --git a/analysis/backstop_offsets.ipynb b/analysis/backstop_offsets.ipynb new file mode 100644 index 00000000..bcd448f8 --- /dev/null +++ b/analysis/backstop_offsets.ipynb @@ -0,0 +1,201 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Backstop positions vs proseco positions\n", + "\n", + "Compare proseco star catalog positions with backstop (via kadi observation starcats) and review\n", + "magnitude of differences caused by truncating / rounding before backstop generation." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.9.1.dev6+g07db67a\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ['SKA'] = '/Users/jean/ska'\n", + "import proseco\n", + "print(proseco.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from functools import lru_cache\n", + "from pathlib import Path\n", + "import pickle\n", + "import gzip\n", + "import warnings\n", + "\n", + "warnings.filterwarnings('ignore', category=UserWarning, module='chandra_aca')\n", + "warnings.filterwarnings('ignore', category=UserWarning, module='proseco')\n", + "\n", + "import astropy.units as u\n", + "from astropy.table import Table, join, vstack\n", + "\n", + "from cxotime import CxoTime\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from kadi.commands.commands_v2 import APPROVED_LOADS_OCCWEB_DIR\n", + "from kadi.commands import observations\n", + "from kadi.occweb import get_occweb_page\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "@lru_cache()\n", + "def get_pickle_path(load_name: str) -> Path:\n", + " year = '20' + load_name[5:7]\n", + " month_name = load_name[:3]\n", + " pkl_path = (\n", + " APPROVED_LOADS_OCCWEB_DIR \n", + " / year \n", + " / month_name \n", + " / load_name \n", + " / 'output'\n", + " / f'{load_name}_proseco.pkl.gz'\n", + " )\n", + " return pkl_path" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "@lru_cache()\n", + "def get_acas(load_name):\n", + " path = get_pickle_path(load_name)\n", + " pkl_bytes = get_occweb_page(path, binary=True, cache=True)\n", + " acas = pickle.loads(gzip.decompress(pkl_bytes))\n", + " return acas" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def get_aca(obsid, load_name):\n", + " acas = get_acas(load_name)\n", + " return acas[obsid]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def get_residuals(obss):\n", + " dys = []\n", + " dzs = []\n", + " obsids = []\n", + " seen_obs = {}\n", + " for obs in obss:\n", + " # Skip if we've already seen this obsid.\n", + " # Since we're working from kadi.observations, this will also skip\n", + " # obsids after SCS107. That's fine.\n", + " if obs['obsid'] in seen_obs:\n", + " continue\n", + " if obs.get('starcat_date') is None:\n", + " continue\n", + " if obs['source'] == 'CMD_EVT':\n", + " continue\n", + " sc = observations.get_starcats(obsid=obs['obsid'], starcat_date=obs['starcat_date'])\n", + " obsid = obs['obsid']\n", + " aca = get_aca(obsid, obs['source'])\n", + " obsids.extend(obsid * np.ones(len(aca)))\n", + " dys.extend(list(aca['yang'] - sc[0]['yang']))\n", + " dzs.extend(list(aca['zang'] - sc[0]['zang']))\n", + " seen_obs[obsid] = 1\n", + " return Table([obsids, dys, dzs], names=['obsid', 'dy', 'dz'])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "recent_obs = observations.get_observations(start=CxoTime.now() - 180 * u.day)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "res = get_residuals(recent_obs)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGwCAYAAACD0J42AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABMQUlEQVR4nO3de1xUdf4/8NcAw3BHgWRkRcWE8oKXVUMxE1Mwy0sP+65btK5t1upaFqFZptXY17BsQ3pgl7WvK6ZLuF3cXxdzxVLTRQtRVrzk/RIFsSlyERxGeP/+sDnrcB+Yy4F5PR8PH3o+53PO+bzPOXPm7ed85hyNiAiIiIiIVMTN2Q0gIiIiqo8JChEREakOExQiIiJSHSYoREREpDpMUIiIiEh1mKAQERGR6jBBISIiItXxcHYD2qKurg4//vgj/P39odFonN0cIiIiagURQUVFBcLCwuDm1nwfSYdMUH788UeEh4c7uxlERETUBt9//z169OjRbJ0OmaD4+/sDuB5gQECAk1vzXyaTCdu2bUNCQgK0Wq2zm+Mwrhi3K8YMMG7G3fm5YsyA4+IuLy9HeHi48j3enA6ZoJhv6wQEBKguQfHx8UFAQIDLndiuFrcrxgwwbsbd+blizIDj427N8AwOkiUiIiLVYYJCREREqsMEhYiIiFSnQ45BISIiUqva2lqYTCZnN8MqJpMJHh4euHr1Kmpra9u1Lk9PzxZ/QtwaTFCIiIhsQERQXFyMy5cvO7spVhMR6PV6fP/99+1+vpibmxsiIiLg6enZrvUwQSEiIrIBc3LSrVs3+Pj4dKgHidbV1aGyshJ+fn7t6v0wP0i1qKgIPXv2bNc+YIJCRETUTrW1tUpyEhwc7OzmWK2urg41NTXw8vJq9+2Zm266CT/++COuXbvWrp8sc5AsERFRO5nHnPj4+Di5Jc5nvrXT3rEsTFCIiIhspCPd1rEXW+0DJihERESkOkxQiIiISHU4SJaIiMiOVmWfcOj2noqPavc64uLiMGTIEKSlpbW/QW3EHhQiIiJSHSYoREREpDpMUIiIiFzYlStXMGvWLPTo0QO/+tWv8PrrryvzXnrpJURHRzdYZtiwYXjhhRfs2i6OQSEi29mxouU64xbbvx1E1GpPP/00du7ciQ0bNqBPnz5YunQp8vLyMGTIEDz88MNYtmwZcnNzMWLECADAoUOHcPDgQXzwwQd2bRd7UIiIiFxUZWUl1q5di5UrV2LcuHGIjo7G+vXrlYes9ejRAxMnTsS6deuUZdatW4exY8eiT58+dm0bExQiIiIXdfr0adTU1GDUqFFKWVBQEG655RZl+tFHH8X777+Pq1evwmQy4W9/+xsefvhhu7eNt3iIiIhclIi0WGfKlCnQ6XTYvHkzdDodjEYj7rvvPru3jT0oRERELqpv377QarXYt2+fUlZaWooTJ/777BYPDw/MmjUL69atw7p163D//fc75J1D7EEhIiJyUX5+fpg9ezaeeeYZeHt7IyIiAs8//3yDNxo/8sgj6NevHwDgX//6l0PaxgSFiIjIjmzxZFd7eu2111BRUYHExET4+/tjwYIFKCsrs6gTGRmJ2NhYXLx4ETExMQ5pFxMUIiIiF+bn54f33nsP5eXlCAgIgJubG55++mmLOiKCn376CXPmzHFYu5igEBERUZNKSkqwYcMG/PDDD/jDH/7gsO0yQSEiIqImhYaGIiQkBGvWrEHXrl0dtl2rfsVz7do1LF26FBEREfD29kafPn3w0ksvoa6uTqkjIjAYDAgLC4O3tzfi4uJw5MgRi/UYjUbMnz8fISEh8PX1xdSpU1FYWGibiIiIiMhmRAT/+c9/kJiY6NDtWpWgvPrqq3jnnXewevVqHDt2DCtXrsRrr72G9PR0pc7KlSuRmpqK1atXIzc3F3q9HvHx8aioqFDqJCUlYfPmzcjKysKePXtQWVmJyZMnK0+uIyIiItdm1S2evXv3Ytq0abjnnnsAAL1798b777+P/fv3A7ieZaWlpWHJkiWYPn06AGD9+vUIDQ1FZmYm5syZg7KyMqxduxYbNmzAhAkTAAAbN25EeHg4tm/fjokTJ9oyPiIiIuqArEpQbr/9drzzzjs4ceIEoqKi8O9//xt79uxBWloaAODs2bMoLi5GQkKCsoxOp8PYsWORk5ODOXPmIC8vDyaTyaJOWFgYBg4ciJycnEYTFKPRCKPRqEyXl5cDAEwmE0wmk1UB25O5LWpqkyO4YtyuGDPQirilFZ2yHXCf8Xi7TtxtjdlkMkFEUFdXZzHsoaMwP1HWHEN71NXVQURgMpng7u5uMc+a/WpVgvLMM8+grKwMt956K9zd3VFbW4uXX34ZDzzwAACguLgYwPUBNTcKDQ3F+fPnlTqenp4NBtqEhoYqy9e3YsUKLFu2rEH5tm3bHPI0O2tlZ2c7uwlO4Ypxu2LMQHNx39rywlu22LQtjsTj7TqsjdnDwwN6vR6VlZWoqamxU6vs78bhGG1VU1OD6upqfP3117h27ZrFvKqqqlavx6oEZdOmTdi4cSMyMzMxYMAA5OfnIykpCWFhYZg1a5ZST6PRWCwnIg3K6muuzuLFi5GcnKxMl5eXIzw8HAkJCQgICLAmBLsymUzIzs5GfHw8tFqts5vjMK4YtyvGDLQi7t2pLa9kTHLLdVSGx9t14m5rzFevXsX3338PPz8/eHl52bGF9iEiqKiogL+/f4vf1y25evUqvL29cccddzTYF+Y7IK1hVYLy9NNP49lnn8X9998PAIiOjsb58+exYsUKzJo1C3q9HsD1XpLu3bsry5WUlCi9Knq9HjU1NSgtLbXoRSkpKUFsbGyj29XpdNDpdA3KtVqtKj80am2Xvbli3K4YM9BM3JpWdA134P3F4+06rI25trYWGo0Gbm5uDR4T3xGYb+uYY4iLi8OQIUOUIRzWcHNzg0ajaXQfWrNPrUpQqqqqGux4d3d3JbCIiAjo9XpkZ2dj6NChAK539ezatQuvvvoqAGDYsGHQarXIzs7GjBkzAABFRUU4fPgwVq5caU1ziIiI1G/HCsdub9xix27PTqxKUKZMmYKXX34ZPXv2xIABA3Dw4EGkpqbi4YcfBnA980pKSkJKSgoiIyMRGRmJlJQU+Pj4KL+fDgwMxOzZs7FgwQIEBwcjKCgICxcuRHR0tPKrHiIiInJtViUo6enpeP755zFv3jyUlJQgLCwMc+bMwQsvvKDUWbRoEaqrqzFv3jyUlpYiJiYG27Ztg7+/v1Jn1apV8PDwwIwZM1BdXY3x48cjIyOjwWhfIiIisq8rV65g7ty52Lx5M/z9/bFw4UJl3s6dOzFu3LgGy8yaNQsZGRl2bZdVCYq/vz/S0tKavSel0WhgMBhgMBiarOPl5YX09HSLB7wRERGR4z399NPYuXMnNmzYgD59+mDp0qXIy8vDkCFDEBsbi6KiIqXusWPHcPfdd+OOO+6we7v4Lh4iIiIXVVlZibVr1yIjIwPjxo1DQEAA1q9fjx49egAAPD09lR/AXLx4EY8++igefvhhZWiHPXW8ocZERERkE6dPn0ZNTQ1GjRqllAUFBeGWW26xqGcymXDfffehZ8+eeOONNxzSNvagEBERuSjzE2Rb8qc//QkXLlxAbm4uPDwckzqwB4WIiMhF9e3bF1qtFvv27VPKSktLceLECWU6NTUVmzZtwieffILg4GCHtY09KERERC7Kz88Ps2fPxjPPPANvb29ERETg+eefV555tn37dixatAhvvvkmQkJClFfSeHt7IzAw0K5tYw8KERGRC3vttdcwZswYJCYmIiEhAbfffjuGDRsGANizZw9qa2sxd+5cdO/eXfnz5JNP2r1d7EEhIiKyJ5U/2dXPzw/vvfceysvLERAQADc3Nzz99NPK/OYeG2JP7EEhIiIi1WGCQkRERKrDBIWIiIhUhwkKERERqQ4TFCIiIhtp7YPPOjNb7QMmKERERO2k1WoBAFVVVU5uifPV1NQAANzd3du1Hv7MmIiIqJ3c3d3RpUsXlJSUAAB8fHyg0Wic3KrWq6urQ01NDa5evao8pK2t6/nPf/4DHx+fdj8SnwkKERGRDZjf+mtOUjoSEUF1dTW8vb3bnVi5ubmhZ8+e7V4PExQiIiIb0Gg06N69O7p16waTyeTs5ljFZDLh66+/xh133KHcrmorT0/PdvXCmDFBISIisiF3d/d2j79wNHd3d1y7dg1eXl7tTlBshQkKERF1WquyT7RY56n4KAe0hKzFX/EQERGR6jBBISIiItVhgkJERESqwwSFiIiIVIcJChEREakOExQiIiJSHSYoREREpDpMUIiIiEh1mKAQERGR6jBBISIiItVhgkJERESqwwSFiIiIVIcJChEREamOVQlK7969odFoGvx57LHHAAAiAoPBgLCwMHh7eyMuLg5HjhyxWIfRaMT8+fMREhICX19fTJ06FYWFhbaLiIiIiDo8qxKU3NxcFBUVKX+ys7MBAL/5zW8AACtXrkRqaipWr16N3Nxc6PV6xMfHo6KiQllHUlISNm/ejKysLOzZsweVlZWYPHkyamtrbRgWERERdWRWJSg33XQT9Hq98uezzz7DzTffjLFjx0JEkJaWhiVLlmD69OkYOHAg1q9fj6qqKmRmZgIAysrKsHbtWrz++uuYMGEChg4dio0bN6KgoADbt2+3S4BERETU8Xi0dcGamhps3LgRycnJ0Gg0OHPmDIqLi5GQkKDU0el0GDt2LHJycjBnzhzk5eXBZDJZ1AkLC8PAgQORk5ODiRMnNroto9EIo9GoTJeXlwMATCYTTCZTW0OwOXNb1NQmR3DFuF0xZqAVcUsr/s/TAfcZj3fHjVsjLffO3xhfZ4i5LRwVtzXrb3OC8o9//AOXL1/GQw89BAAoLi4GAISGhlrUCw0Nxfnz55U6np6e6Nq1a4M65uUbs2LFCixbtqxB+bZt2+Dj49PWEOzGfOvL1bhi3K4YM9Bc3Le2vPCWLTZtiyPxeHc8Ea2os2XLiQZlHTnm9rB33FVVVa2u2+YEZe3atZg0aRLCwsIsyjUajcW0iDQoq6+lOosXL0ZycrIyXV5ejvDwcCQkJCAgIKANrbcPk8mE7OxsxMfHQ6vVOrs5DuOKcbtizEAr4t6d2vJKxiS3XEdleLw7btxv7jjVYp3HxvVV/t0ZYm4LR8VtvgPSGm1KUM6fP4/t27fj448/Vsr0ej2A670k3bt3V8pLSkqUXhW9Xo+amhqUlpZa9KKUlJQgNja2ye3pdDrodLoG5VqtVpUnkFrbZW+uGLcrxgw0E7emrjUL275BDsLj3fGIxr3FOo3F1pFjbg97x23Nutv0HJR169ahW7duuOeee5SyiIgI6PV6i+6hmpoa7Nq1S0k+hg0bBq1Wa1GnqKgIhw8fbjZBISIiItdidQ9KXV0d1q1bh1mzZsHD47+LazQaJCUlISUlBZGRkYiMjERKSgp8fHyQmJgIAAgMDMTs2bOxYMECBAcHIygoCAsXLkR0dDQmTJhgu6iIiIioQ7M6Qdm+fTsuXLiAhx9+uMG8RYsWobq6GvPmzUNpaSliYmKwbds2+Pv7K3VWrVoFDw8PzJgxA9XV1Rg/fjwyMjLg7t5yNxwRERG5BqsTlISEBIhIo/M0Gg0MBgMMBkOTy3t5eSE9PR3p6enWbpqIiIhcBN/FQ0RERKrDBIWIiIhUhwkKERERqQ4TFCIiIlIdJihERESkOkxQiIiISHWYoBAREZHqMEEhIiIi1WGCQkRERKrDBIWIiIhUhwkKERERqQ4TFCIiIlIdJihERESkOkxQiIiISHWYoBAREZHqMEEhIiIi1WGCQkRERKrDBIWIiIhUhwkKERERqQ4TFCIiIlIdJihERESkOkxQiIiISHWYoBAREZHqMEEhIiIi1WGCQkRERKrDBIWIiIhUhwkKERERqQ4TFCIiIlIdJihERESkOkxQiIiISHWYoBAREZHqMEEhIiIi1bE6Qfnhhx/wu9/9DsHBwfDx8cGQIUOQl5enzBcRGAwGhIWFwdvbG3FxcThy5IjFOoxGI+bPn4+QkBD4+vpi6tSpKCwsbH80RERE1ClYlaCUlpZi9OjR0Gq1+OKLL3D06FG8/vrr6NKli1Jn5cqVSE1NxerVq5Gbmwu9Xo/4+HhUVFQodZKSkrB582ZkZWVhz549qKysxOTJk1FbW2uzwIiIiKjj8rCm8quvvorw8HCsW7dOKevdu7fybxFBWloalixZgunTpwMA1q9fj9DQUGRmZmLOnDkoKyvD2rVrsWHDBkyYMAEAsHHjRoSHh2P79u2YOHFig+0ajUYYjUZlury8HABgMplgMpmsCcGuzG1RU5scwRXjdsWYgVbELa34P08H3Gc83h03bo20/B/fG+PrDDG3haPitmb9GhGR1lbu378/Jk6ciMLCQuzatQu/+tWvMG/ePDz66KMAgDNnzuDmm2/GgQMHMHToUGW5adOmoUuXLli/fj2++uorjB8/HpcuXULXrl2VOoMHD8a9996LZcuWNdiuwWBotDwzMxM+Pj6tDpaIiIicp6qqComJiSgrK0NAQECzda3qQTlz5gzefvttJCcn47nnnsO3336LJ554AjqdDr///e9RXFwMAAgNDbVYLjQ0FOfPnwcAFBcXw9PT0yI5MdcxL1/f4sWLkZycrEyXl5cjPDwcCQkJLQboSCaTCdnZ2YiPj4dWq3V2cxzGFeN2xZiBVsS9O7XllYxJbrmOyvB4d9y439xxqsU6j43rq/y7M8TcFo6K23wHpDWsSlDq6uowfPhwpKSkAACGDh2KI0eO4O2338bvf/97pZ5Go7FYTkQalNXXXB2dTgedTtegXKvVqvIEUmu77M0V43bFmIFm4tbUtWZh2zfIQXi8Ox7RuLdYp7HYOnLM7WHvuK1Zt1WDZLt3747+/ftblPXr1w8XLlwAAOj1egBo0BNSUlKi9Kro9XrU1NSgtLS0yTpERETk2qxKUEaPHo3jx49blJ04cQK9evUCAERERECv1yM7O1uZX1NTg127diE2NhYAMGzYMGi1Wos6RUVFOHz4sFKHiIiIXJtVt3ieeuopxMbGIiUlBTNmzMC3336LNWvWYM2aNQCu39pJSkpCSkoKIiMjERkZiZSUFPj4+CAxMREAEBgYiNmzZ2PBggUIDg5GUFAQFi5ciOjoaOVXPUREROTarEpQRowYgc2bN2Px4sV46aWXEBERgbS0NDz44INKnUWLFqG6uhrz5s1DaWkpYmJisG3bNvj7+yt1Vq1aBQ8PD8yYMQPV1dUYP348MjIy4O7e8r1CIiIi6vysSlAAYPLkyZg8eXKT8zUaDQwGAwwGQ5N1vLy8kJ6ejvT0dGs3T0RERC6A7+IhIiIi1WGCQkRERKrDBIWIiIhUhwkKERERqQ4TFCIiIlIdJihERESkOkxQiIiISHWYoBAREZHqMEEhIiIi1WGCQkRERKrDBIWIiIhUhwkKERERqQ4TFCIiIlIdJihERESkOkxQiIiISHWYoBAREZHqMEEhIiIi1WGCQkRERKrDBIWIiIhUhwkKERERqQ4TFCIiIlIdJihERESkOkxQiIiISHU8nN0AIiIiZxh5Yc31f+wI/m+huAG4FdidCmjqgHGLndI2Yg8KERERqRATFCIiIlIdJihERESkOkxQiIiISHWYoBAREZHq8Fc8ncCq7BMt1nkqPsoBLSEiIrIN9qAQERGR6liVoBgMBmg0Gos/er1emS8iMBgMCAsLg7e3N+Li4nDkyBGLdRiNRsyfPx8hISHw9fXF1KlTUVhYaJtoiIiIqFOwugdlwIABKCoqUv4UFBQo81auXInU1FSsXr0aubm50Ov1iI+PR0VFhVInKSkJmzdvRlZWFvbs2YPKykpMnjwZtbW1tomIiIiIOjyrx6B4eHhY9JqYiQjS0tKwZMkSTJ8+HQCwfv16hIaGIjMzE3PmzEFZWRnWrl2LDRs2YMKECQCAjRs3Ijw8HNu3b8fEiRMb3abRaITRaFSmy8vLAQAmkwkmk8naEOzG3BZHt0kjLSd39myTs+J2JleMGWhF3NKK//N0wH3G491x427u+lincQcAmG44b83/Vso6cOzWcNSxtmb9GhGR1lY2GAx47bXXEBgYCJ1Oh5iYGKSkpKBPnz44c+YMbr75Zhw4cABDhw5Vlpk2bRq6dOmC9evX46uvvsL48eNx6dIldO3aVakzePBg3HvvvVi2bFmT221sXmZmJnx8fFodLBERETlPVVUVEhMTUVZWhoCAgGbrWtWDEhMTg/feew9RUVH46aefsHz5csTGxuLIkSMoLi4GAISGhlosExoaivPnzwMAiouL4enpaZGcmOuYl2/M4sWLkZycrEyXl5cjPDwcCQkJLQboSCaTCdnZ2YiPj4dWq3XYdt/ccarFOo+N62u37TsrbmdyxZiBVsS9O7XllYxJbrmOyjjzeDvz890ZzvPm9t+IwgwAwG29g5Qyk7ghuzIK8X4noNXUdcjztS0cdazNd0Baw6oEZdKkScq/o6OjMWrUKNx8881Yv349Ro4cCQDQaDQWy4hIg7L6Wqqj0+mg0+kalGu1WlV+aBzdLvmlm7I5jmiPWo+HPblizEAzcWvqWrOw7RvkIM443mr4fHfk87y5/ef2y+0fbSPnrVZTd728g8bdVvY+1tasu10/M/b19UV0dDROnjypjEup3xNSUlKi9Kro9XrU1NSgtLS0yTpERERE7UpQjEYjjh07hu7duyMiIgJ6vR7Z2dnK/JqaGuzatQuxsbEAgGHDhkGr1VrUKSoqwuHDh5U6RERERFbd4lm4cCGmTJmCnj17oqSkBMuXL0d5eTlmzZoFjUaDpKQkpKSkIDIyEpGRkUhJSYGPjw8SExMBAIGBgZg9ezYWLFiA4OBgBAUFYeHChYiOjlZ+1UNERERkVYJSWFiIBx54AD///DNuuukmjBw5Evv27UOvXr0AAIsWLUJ1dTXmzZuH0tJSxMTEYNu2bfD391fWsWrVKnh4eGDGjBmorq7G+PHjkZGRAXf3lu+zEhERkWuwKkHJyspqdr5Go4HBYIDBYGiyjpeXF9LT05Genm7NpomIiMiF8F08REREpDpMUIiIiEh1mKAQERGR6jBBISIiItVhgkJERESqwwSFiIiIVIcJChEREakOExQiIiJSHSYoREREpDpMUIiIiEh1mKAQERGR6jBBISIiItVhgkJERESqwwSFiIiIVIcJChEREakOExQiIiJSHSYoREREpDpMUIiIiEh1mKAQERGR6ng4uwFE5Byrsk+0WOep+CgHtISIqCH2oBAREZHqMEEhIiIi1WGCQkRERKrDBIWIiIhUhwkKERERqQ5/xUPUCvV/8aKRWkQAeHPHKYjGHQB/8UJEZEvsQSEiIiLVYYJCREREqsMEhYiIiFSHCQoRERGpDgfJEpntWNHkrJEXLgIA9vX8o6NaQ0Tk0trVg7JixQpoNBokJSUpZSICg8GAsLAweHt7Iy4uDkeOHLFYzmg0Yv78+QgJCYGvry+mTp2KwsLC9jSFiIiIOpE296Dk5uZizZo1GDRokEX5ypUrkZqaioyMDERFRWH58uWIj4/H8ePH4e/vDwBISkrCp59+iqysLAQHB2PBggWYPHky8vLy4O7u3r6IyP7q9zSIG4Bbgd2pgKbuetm4xQ5vFhERdR5t6kGprKzEgw8+iHfffRddu3ZVykUEaWlpWLJkCaZPn46BAwdi/fr1qKqqQmZmJgCgrKwMa9euxeuvv44JEyZg6NCh2LhxIwoKCrB9+3bbREVEREQdWpt6UB577DHcc889mDBhApYvX66Unz17FsXFxUhISFDKdDodxo4di5ycHMyZMwd5eXkwmUwWdcLCwjBw4EDk5ORg4sSJDbZnNBphNBqV6fLycgCAyWSCyWRqSwh2YW6Lo9ukkdoW69i0TWKZ15p+mTbdWK6i49Jq0nS+XvfLw9jM+7r+34Djj3t7teW8afEcb2Yf3rCSluuojLM+24ATPt+NrLejnds3am7/mT/XN167GlzPOnDs1nDUsbZm/VYnKFlZWThw4AByc3MbzCsuLgYAhIaGWpSHhobi/PnzSh1PT0+LnhdzHfPy9a1YsQLLli1rUL5t2zb4+PhYG4LdZWdnO3R7Ea2os2XLiZYrtdqtjZZmV97wJNUtW2y4PUdpPC4AQPD1vyKqLfdj76unlX/bdh/bX3vOm6bP8Wb24X9X2ootq5OjP9uAMz7fDTkjbltpbv/9HBwLANhS0XCecj3rwOdrW9j7WFdVVbW6rlUJyvfff48nn3wS27Ztg5eXV5P1NBqNxbSINCirr7k6ixcvRnJysjJdXl6O8PBwJCQkICAgwIoI7MtkMiE7Oxvx8fHQarUO2+6bO061WOexcX1tt8HdqRaTJnFDdmUU4v1OQGsegzImuZEFVa5eXDf69twlAEBuj4cAXP9fWe+rp3HO62blUfc23ccO0JbzpsVzvJl9qOiA54azPtuAEz7fN3Bm3LbS3P4bUZgBALitd5BS1uB61gHP17Zw1LE23wFpDasSlLy8PJSUlGDYsGFKWW1tLb7++musXr0ax48fB3C9l6R79+5KnZKSEqVXRa/Xo6amBqWlpRa9KCUlJYiNjW10uzqdDjqdrkG5VqtV5YfG0e0yf0E2x6btMSch9behqftvgqLC49KiJuICALdfuonr72vRuCtlajwXm9Oe86bJc7yZfXjDwi3XUSlnXHMc/vluYv0d7fw2a27/mT/X2kbOW+V61kHjbit7H2tr1m3VINnx48ejoKAA+fn5yp/hw4fjwQcfRH5+Pvr06QO9Xm/RRVRTU4Ndu3YpycewYcOg1Wot6hQVFeHw4cNNJihERETkWqzqQfH398fAgQMtynx9fREcHKyUJyUlISUlBZGRkYiMjERKSgp8fHyQmJgIAAgMDMTs2bOxYMECBAcHIygoCAsXLkR0dDQmTJhgo7CIiIioI7P5k2QXLVqE6upqzJs3D6WlpYiJicG2bduUZ6AAwKpVq+Dh4YEZM2aguroa48ePR0ZGBp+BQkRERABskKDs3LnTYlqj0cBgMMBgMDS5jJeXF9LT05Gent7ezRMREVEnxHfxEBFR+zXzLisFnzBNVuDbjImIiEh1mKAQERGR6jBBISIiItXhGBQiIjWpN5Zj5IWLDars6/lHR7WGyGnYg0JERESqwwSFiIiIVIcJChEREakOExQiIiJSHSYoREREpDpMUIiIiEh1+DNjInK6VdknWqzzVHyUA1pCRGrBBIXI1vhOEiKiduMtHiIiIlIdJihERESkOkxQiIiISHWYoBAREZHqMEEhIiIi1WGCQkRERKrDBIWIiIhUhwkKERERqQ4f1EZERAAaPtFXI7WIAPDmjlMQjTsAPtGXHIc9KERERKQ67EEhssLIC2sAAHUad/wcHIsRhRlwk9rrM3cEO7FlRESdC3tQiIiISHWYoBAREZHqMEEhIiIi1eEYFKJOqP6vMYiIOhr2oBAREZHqMEEhIiIi1WGCQkRERKpjVYLy9ttvY9CgQQgICEBAQABGjRqFL774QpkvIjAYDAgLC4O3tzfi4uJw5MgRi3UYjUbMnz8fISEh8PX1xdSpU1FYWGibaIiIiKhTsCpB6dGjB1555RXs378f+/fvx5133olp06YpScjKlSuRmpqK1atXIzc3F3q9HvHx8aioqFDWkZSUhM2bNyMrKwt79uxBZWUlJk+ejNraWttGRkRERB2WVQnKlClTcPfddyMqKgpRUVF4+eWX4efnh3379kFEkJaWhiVLlmD69OkYOHAg1q9fj6qqKmRmZgIAysrKsHbtWrz++uuYMGEChg4dio0bN6KgoADbt2+3S4BERETU8bT5Z8a1tbX44IMPcOXKFYwaNQpnz55FcXExEhISlDo6nQ5jx45FTk4O5syZg7y8PJhMJos6YWFhGDhwIHJycjBx4sRGt2U0GmE0GpXp8vJyAIDJZILJZGprCDZnbouj26SRlnufbNomscxrTb9Mm24sV9FxaTVpOl+v++VFafWnbyw3NbN8A3beP605J1qj/nnT4jnemn3QyLIOP4et5NDPdr19WP/cAxruL1u1q/56zdM3ltv62Ntbc+eWed/e+NltcD3riNeyNnDUOW7N+jUiItasvKCgAKNGjcLVq1fh5+eHzMxM3H333cjJycHo0aPxww8/ICwsTKn/xz/+EefPn8c///lPZGZm4g9/+INFsgEACQkJiIiIwF/+8pdGt2kwGLBs2bIG5ZmZmfDx8bGm+UREROQkVVVVSExMRFlZGQICApqta3UPyi233IL8/HxcvnwZH330EWbNmoVdu3Yp8zUajUV9EWlQVl9LdRYvXozk5GRlury8HOHh4UhISGgxQEcymUzIzs5GfHw8tFqtw7b75o5TLdZ5bFxf221wd6rFpEnckF0ZhXi/E9Bq6q4XjkluZEGVqxfXjb49d8liuk7jjktBMQi69I3yssDbege1flt23j+tOSdao/550+I53sw+VDQSu8PPYSs59LNdbx/WP/cAILfHQxbTTe4bK49H/eOgkVr0vnoa57xuhvzS22CrbTlKc+fWiMIMAJaf3QbXs454LWsDR53j5jsgrWF1guLp6Ym+fa+foMOHD0dubi7eeOMNPPPMMwCA4uJidO/eXalfUlKC0NBQAIBer0dNTQ1KS0vRtWtXizqxsbFNblOn00Gn0zUo12q1Dk0EWsvR7ZJGuoDrs2l7zElI/W1o6v6boKjwuLSoibgA/PeNxY2Um+dpm1m+ATvvn9acE63R1HnT5Dnemn3QyHIOP4fbyCGf7Xr7sLFzr/7+arJNVh6Ppo6DaNyVebbalqM0d24199lVrmcqOO8cyd7nuDXrbvdzUEQERqMRERER0Ov1yM7OVubV1NRg165dSvIxbNgwaLVaizpFRUU4fPhwswkKERERuRarelCee+45TJo0CeHh4aioqEBWVhZ27tyJrVu3QqPRICkpCSkpKYiMjERkZCRSUlLg4+ODxMREAEBgYCBmz56NBQsWIDg4GEFBQVi4cCGio6MxYcIEuwRIREREHY9VCcpPP/2EmTNnoqioCIGBgRg0aBC2bt2K+Ph4AMCiRYtQXV2NefPmobS0FDExMdi2bRv8/f2VdaxatQoeHh6YMWMGqqurMX78eGRkZMDd3TZd0kRERNTxWZWgrF27ttn5Go0GBoMBBoOhyTpeXl5IT09Henq6NZsmIiIiF9Lm56AQEZE6rMo+0Wj5yAsXlX+P6hPsqOYQ2QRfFkhERESqwx4UIgfae+b6/2j3XWv8f7xPxUc5sjlERKrFHhQiIiJSHfagEHVkO1Y0Wnzj2IN9Pf/oqNYQEdkMExQiFWlqsOONeBuIiFwBExQiopbsTgVw6/W/m3qk+7jFDm0SdUJN9IhacKHzjAkKdWrskSAi6pg4SJaIiIhUhwkKERERqQ5v8RAR2UlLtxh5e5GoaUxQyD442IuIiNqBCQp1WK0ZAEvkMI0k5Tc+jwbgM2lcXUvXrJEXLvKdSTdggkJE5ALMr1mor6nXLhA5GxMUIiIHGXlhjcX03rVOaghRB8AEhUil6n+ZKXawC5icp6nbFObbWaq5RfHLLbf6t9mo42CCQkRE1BQO+HcaPgeFiIiIVIc9KETUafDVBkSdBxMUch52nbomJ/8ct34S0+RYnxvUadyBYODbc5fgJrUAVDTWgqiTYoLSSbR4kW3twEomBA7Rmi9FV9bo/ql/DvNc7bA6Y08Xn8tke0xQiIiI2mPHihZ/LcSH9FmPCQoRte4nzeyxICIHYoJCZCNNPanT2Trt7SQ+Wp4cqL2f7077ObQjJihERGQzzX2R87H6ZA0mKB0AB1+Rmt14fjZ1H56/eCEiazFBIdXae+YicGZhk/NH/vI3u/HJGdR6S0/NWnObg59nMmOCQpZa82ySFrTmws3/UbsWW3yZMyEggks9P4oJSgfQGQdX8cuGqOMYUZihPKCOyFGYoJDLM4+h4FtPiTqW5sbn8fPc8TFBcbLWDIAd2WINInIlnbFXlag+JijU4XHgHRG1x423nBt77xI5h5s1lVesWIERI0bA398f3bp1w7333ovjx49b1BERGAwGhIWFwdvbG3FxcThy5IhFHaPRiPnz5yMkJAS+vr6YOnUqCgsL2x8NERERdQpW9aDs2rULjz32GEaMGIFr165hyZIlSEhIwNGjR+Hr6wsAWLlyJVJTU5GRkYGoqCgsX74c8fHxOH78OPz9/QEASUlJ+PTTT5GVlYXg4GAsWLAAkydPRl5eHtzd3W0fJbn8L2s6U5c4BxgTkSuwKkHZunWrxfS6devQrVs35OXl4Y477oCIIC0tDUuWLMH06dMBAOvXr0doaCgyMzMxZ84clJWVYe3atdiwYQMmTJgAANi4cSPCw8Oxfft2TJw4scF2jUYjjEajMl1eXg4AMJlMMJlM1kVsR+a2WNMmTSu6EOs0jkna/nX2cot1busd1KDMJG4Wfzuqvc5kjrGzx2o+pgCAr179ZToKpq/TAE0dAOC27y8pVdS2P2z1+erMx7u5fWSe58i4zdtszXW0uba3tc3OPtYWn7k2r8T678W2fH+1hXXfjyLS1g2dOnUKkZGRKCgowMCBA3HmzBncfPPNOHDgAIYOHarUmzZtGrp06YL169fjq6++wvjx43Hp0iV07dpVqTN48GDce++9WLZsWYPtGAyGRsszMzPh4+PT1uYTERGRA1VVVSExMRFlZWUICAhotm6bB8mKCJKTk3H77bdj4MCBAIDi4mIAQGhoqEXd0NBQnD9/Xqnj6elpkZyY65iXr2/x4sVITk5WpsvLyxEeHo6EhIQWA3Qkk8mE7OxsxMfHQ6vVtmqZN3ecarHOiMKMdrbMdprqQcmujEK83wloNXX49tylRpbsXOo07rgUFIOgS9+41EA6xs247S23x0MAgMfG9W2xbnPXz7ZeN519rBu7xlptTHLLdeppy/dXW5jvgLRGmxOUxx9/HIcOHcKePXsazNNoNBbTItKgrL7m6uh0Ouh0ugblWq3Wrjuyraxpl7SiG1FNF8T9Z//ToOz6qPcoHDz/M9yk1rqR1x2cm9Sq6vg4CuN2LY6M23xNbM01tLnrZ3vb66xjrf3l1mn7VtL270V7f69as+42fZfMnz8fn3zyCXbs2IEePXoo5Xq9HgAa9ISUlJQovSp6vR41NTUoLS1tsg4RERG5Nqt6UEQE8+fPx+bNm7Fz505ERERYzI+IiIBer0d2drYyBqWmpga7du3Cq6++CgAYNmwYtFotsrOzMWPGDABAUVERDh8+jJUrV9oiJiIiog7J1X9xeSOrEpTHHnsMmZmZ+H//7//B399f6SkJDAyEt7c3NBoNkpKSkJKSgsjISERGRiIlJQU+Pj5ITExU6s6ePRsLFixAcHAwgoKCsHDhQkRHRyu/6iEiIiLXZlWC8vbbbwMA4uLiLMrXrVuHhx56CACwaNEiVFdXY968eSgtLUVMTAy2bdumPAMFAFatWgUPDw/MmDED1dXVGD9+PDIyMvgMFCIiatkvb/Tl+3Y6N6tv8bREo9HAYDDAYDA0WcfLywvp6elIT0+3ZvMdTmves0NEREQN8V08TtaZnnBKRERkK0xQ7IjJBxERUdswQSEiItVQ/mO3wzV+qUJNc6VnahEREVEHwR4UIiJSHb61m9iDQkRERKrDBIWIiIhUhwkKERERqQ7HoBAREXUgLY3P2XftBJ6Kj3JQa+yHPShERESkOkxQiIiISHWYoBAREZHqcAwKERFRJzLywpqWn8Q7brFjGtMO7EEhIiIi1WGCQkRERKrDBIWIiIhUhwkKERERqQ4TFCIiIlIdJihERESkOkxQiIiISHX4HJQ2WpV9okGZRmoRAeDNHacgGneMdHyziIiIOgX2oBAREZHqMEEhIiIi1WGCQkRERKrDMShtNPLCmgZldRp3/BwcixGFGXCTWie0ioiIqHNgDwoRERGpDhMUIiIiUh0mKERERKQ6TFCIiIhIdZigEBERkeowQSEiIiLVsTpB+frrrzFlyhSEhYVBo9HgH//4h8V8EYHBYEBYWBi8vb0RFxeHI0eOWNQxGo2YP38+QkJC4Ovri6lTp6KwsLBdgRAREVHnYXWCcuXKFQwePBirV69udP7KlSuRmpqK1atXIzc3F3q9HvHx8aioqFDqJCUlYfPmzcjKysKePXtQWVmJyZMno7aWzw4hIiKiNjyobdKkSZg0aVKj80QEaWlpWLJkCaZPnw4AWL9+PUJDQ5GZmYk5c+agrKwMa9euxYYNGzBhwgQAwMaNGxEeHo7t27dj4sSJDdZrNBphNBqV6fLycgCAyWSCyWSyNgSbqNO4N1nW2LzOzBXjdsWYAcbNuDu/zhKzSVrof6j33Wn+LrX3d6o167fpk2TPnj2L4uJiJCQkKGU6nQ5jx45FTk4O5syZg7y8PJhMJos6YWFhGDhwIHJychpNUFasWIFly5Y1KN+2bRt8fHxsGULrBcc2OetSUIwDG6Ierhi3K8YMMG5X44pxd/SYt1S0VGFLo8XZ2dm2b8wNqqqqWl3XpglKcXExACA0NNSiPDQ0FOfPn1fqeHp6omvXrg3qmJevb/HixUhOTlamy8vLER4ejoSEBAQEBNgyhFb7dsPSBmV1GndcCopB0KVvXOpR964YtyvGDDBuxt35dZaYb+sd1HyFMckWkyaTCdnZ2YiPj4dWq7Vbu8x3QFrDLu/i0Wg0FtMi0qCsvubq6HQ66HS6BuVardauO7I5zZ24blLboU/stnLFuF0xZoBxuxpXjLujx6zV1LVQofHvTnt/r1qzbpv+zFiv1wNAg56QkpISpVdFr9ejpqYGpaWlTdYhIiIi12bTBCUiIgJ6vd7iHlZNTQ127dqF2NjrYzaGDRsGrVZrUaeoqAiHDx9W6hAREZFrs/oWT2VlJU6dOqVMnz17Fvn5+QgKCkLPnj2RlJSElJQUREZGIjIyEikpKfDx8UFiYiIAIDAwELNnz8aCBQsQHByMoKAgLFy4ENHR0cqveoiIiMi1WZ2g7N+/H+PGjVOmzYNXZ82ahYyMDCxatAjV1dWYN28eSktLERMTg23btsHf319ZZtWqVfDw8MCMGTNQXV2N8ePHIyMjA+7uHftnXURERGQbVicocXFxEJEm52s0GhgMBhgMhibreHl5IT09Henp6dZunoiIiFwA38VDREREqsMEhYiIiFSHCQoRERGpDhMUIiIiUh0mKERERKQ6TFCIiIhIdZigEBERkeowQSEiIiLVYYJCREREqsMEhYiIiFSHCQoRERGpjtXv4iEiIqIObscKy2lxA3ArsDsV0NRdLxu32OHNuhETlEasyj7RYp2RDmgHERGRq+ItHiIiIlId9qAQERF1MnvPXGyxzqg+wQ5oSduxB4WIiIhUhz0ojRh5YY2zm0BEROTS2INCREREqsMEhYiIiFSHCQoRERGpDhMUIiIiUh0mKERERKQ6TFCIiIhIdZigEBERkeowQSEiIiLVYYJCREREqsMEhYiIiFSHCQoRERGpDhMUIiIiUh0mKERERKQ6TFCIiIhIdZyaoLz11luIiIiAl5cXhg0bht27dzuzOURERKQSTktQNm3ahKSkJCxZsgQHDx7EmDFjMGnSJFy4cMFZTSIiIiKVcFqCkpqaitmzZ+ORRx5Bv379kJaWhvDwcLz99tvOahIRERGphIczNlpTU4O8vDw8++yzFuUJCQnIyclpUN9oNMJoNCrTZWVlAIBLly7BZDLZvH0VV6+1abk6jaCqqgoVV6/BTWpt3Cr1csW4XTFmgHEz7s7PlWK+WFmj/NskbqiqqsJFTQ20mrpfKly0+TYrKioAACLSYl2nJCg///wzamtrERoaalEeGhqK4uLiBvVXrFiBZcuWNSiPiIiwWxuJiIhcm8Fua66oqEBgYGCzdZySoJhpNBqLaRFpUAYAixcvRnJysjJdV1eHS5cuITg4uNH6zlJeXo7w8HB8//33CAgIcHZzHMYV43bFmAHGzbg7P1eMGXBc3CKCiooKhIWFtVjXKQlKSEgI3N3dG/SWlJSUNOhVAQCdTgedTmdR1qVLF3s2sV0CAgJc6sQ2c8W4XTFmgHG7GleM2xVjBhwTd0s9J2ZOGSTr6emJYcOGITs726I8OzsbsbGxzmgSERERqYjTbvEkJydj5syZGD58OEaNGoU1a9bgwoULmDt3rrOaRERERCrhtATlt7/9LS5evIiXXnoJRUVFGDhwILZs2YJevXo5q0ntptPp8OKLLza4HdXZuWLcrhgzwLgZd+fnijED6oxbI635rQ8RERGRA/FdPERERKQ6TFCIiIhIdZigEBERkeowQSEiIiLVYYJihdLSUsycOROBgYEIDAzEzJkzcfny5WaX+fjjjzFx4kSEhIRAo9EgPz+/0Xp79+7FnXfeCV9fX3Tp0gVxcXGorq62fRBtYM+4getPFpw0aRI0Gg3+8Y9/2LTt7WGPuC9duoT58+fjlltugY+PD3r27IknnnhCeb+Us9nrWBuNRsyfPx8hISHw9fXF1KlTUVhYaJ8g2qAtcYsIDAYDwsLC4O3tjbi4OBw5csSiTnFxMWbOnAm9Xg9fX1/8+te/xocffmjHSKxjr7gB9V7T7BmzuW5nuZ61FLe9r2dMUKyQmJiI/Px8bN26FVu3bkV+fj5mzpzZ7DJXrlzB6NGj8corrzRZZ+/evbjrrruQkJCAb7/9Frm5uXj88cfh5qaOw2OvuM3S0tJU9coCM3vE/eOPP+LHH3/En//8ZxQUFCAjIwNbt27F7Nmz7RGC1ex1rJOSkrB582ZkZWVhz549qKysxOTJk1Fbq46XsbUl7pUrVyI1NRWrV69Gbm4u9Ho94uPjlZehAcDMmTNx/PhxfPLJJygoKMD06dPx29/+FgcPHrR3SK1ir7jVfE2zV8xmnel61lLcdr+eCbXK0aNHBYDs27dPKdu7d68AkO+++67F5c+ePSsA5ODBgw3mxcTEyNKlS23ZXJuxZ9wiIvn5+dKjRw8pKioSALJ582Ybtbx97B33jf7+97+Lp6enmEym9jS53ewV8+XLl0Wr1UpWVpZS9sMPP4ibm5ts3brVZu1vq7bEXVdXJ3q9Xl555RWl7OrVqxIYGCjvvPOOUubr6yvvvfeexbJBQUHyf//3fzaOwnr2jFut1zR7xizSua5n1sR9I1tez5yfznYQe/fuRWBgIGJiYpSykSNHIjAwEDk5OW1eb0lJCb755ht069YNsbGxCA0NxdixY7Fnzx5bNLvd7BU3AFRVVeGBBx7A6tWrodfr29tUm7Jn3PWVlZUhICAAHh5OfXen3WLOy8uDyWRCQkKCUhYWFoaBAwfafF+2RVviPnv2LIqLiy1i0ul0GDt2rMUyt99+OzZt2oRLly6hrq4OWVlZMBqNiIuLs1s8rWWvuNV8TbPnse5s17PWxl2fLa9nTFBaqbi4GN26dWtQ3q1btwYvPbTGmTNnAAAGgwGPPvootm7dil//+tcYP348Tp482eb12oq94gaAp556CrGxsZg2bVq71mMP9oz7RhcvXsT//u//Ys6cOTZbZ1vZK+bi4mJ4enqia9euFuWhoaE23Zdt1Za4zeX1X25aP6ZNmzbh2rVrCA4Ohk6nw5w5c7B582bcfPPNNoygbewVt5qvafY81p3tetbauG9k6+uZyycoBoMBGo2m2T/79+8HgEbvK4pIu+431tXVAQDmzJmDP/zhDxg6dChWrVqFW265BX/961/bvN6WODvuTz75BF999RXS0tLavI62cHbcNyovL8c999yD/v3748UXX7TJOhujppgdsV4zR8Rdf379ZZYuXYrS0lJs374d+/fvR3JyMn7zm9+goKDABhE2ztlxO+Oa5uyYO/P1rKVz3Mwe1zPn9imrwOOPP47777+/2Tq9e/fGoUOH8NNPPzWY95///KdBhmmN7t27AwD69+9vUd6vXz9cuHChzettibPj/uqrr3D69Gl06dLFovy+++7DmDFjsHPnzjavuznOjtusoqICd911F/z8/LB582Zotdp2r7Mpzo5Zr9ejpqYGpaWlFr0oJSUldn17uT3jNnfhFxcXK59h4HpM5mVOnz6N1atX4/DhwxgwYAAAYPDgwdi9ezfefPNNvPPOO22KqyXOjtsZ1zRnx9wZr2etidvMbtezdo9icRHmQUbffPONUrZv3752DyCsq6uTsLCwBgPKhgwZIosXL7ZJ29vDXnEXFRVJQUGBxR8A8sYbb8iZM2dsHYbV7BW3iEhZWZmMHDlSxo4dK1euXLFls9vFXjGbB8lu2rRJKfvxxx9VN0jWmrjNAwhfffVVpcxoNFoMIDx06JAAkKNHj1osm5CQII8++qgdIrGOveJW8zXNXjF3xutZa+IWse/1jAmKFe666y4ZNGiQ7N27V/bu3SvR0dEyefJkizq33HKLfPzxx8r0xYsX5eDBg/L5558LAMnKypKDBw9KUVGRUmfVqlUSEBAgH3zwgZw8eVKWLl0qXl5ecurUKYfF1hx7xV0fVDTqXcQ+cZeXl0tMTIxER0fLqVOnpKioSPlz7do1h8bXGHsd67lz50qPHj1k+/btcuDAAbnzzjtl8ODBqohZpG1xv/LKKxIYGCgff/yxFBQUyAMPPCDdu3eX8vJyERGpqamRvn37ypgxY+Sbb76RU6dOyZ///GfRaDTy+eefOzS+ptgjbhF1X9PsFXN9neF61lLc9r6eMUGxwsWLF+XBBx8Uf39/8ff3lwcffFBKS0st6gCQdevWKdPr1q0TAA3+vPjiixbLrVixQnr06CE+Pj4yatQo2b17t/0DaiV7xl1/HWr6QNsj7h07djQ6H4CcPXvWYbE1xV7Hurq6Wh5//HEJCgoSb29vmTx5sly4cMExQbVCW+Kuq6uTF198UfR6veh0OrnjjjukoKDAYpkTJ07I9OnTpVu3buLj4yODBg1q8LNjZ7JX3CLqvabZM+b66+jo17OW4rb39UzzS6OIiIiIVMPlf8VDRERE6sMEhYiIiFSHCQoRERGpDhMUIiIiUh0mKERERKQ6TFCIiIhIdZigEBERkeowQSEiIiLVYYJCRK320EMP4d5777XrNgwGA4YMGWLXbXR0a9euRUJCgrOb0S4LFy7EE0884exmkIoxQSGiTmPnzp3QaDS4fPmys5tiN0ajES+88AKef/55ZzelXRYtWoR169bh7Nmzzm4KqRQTFOrUampqnN0EIpv66KOP4OfnhzFjxrRrPSaTyUYtaptu3bohISEB77zzjlPbQerFBIU6jLi4ODz++ON4/PHH0aVLFwQHB2Pp0qW48XVSvXv3xvLly/HQQw8hMDAQjz76KIDrF/UBAwZAp9Ohd+/eeP311y3W/dZbbyEyMhJeXl4IDQ3F//zP/yjzRAQrV65Enz594O3tjcGDB+PDDz+0WP7IkSO45557EBAQAH9/f4wZMwanT58GANTV1eGll15Cjx49oNPpMGTIEGzdurXdsZaWluL3v/89unbtCh8fH0yaNAknT55U5p8/fx5TpkxB165d4evriwEDBmDLli1W7vXGLVu2DN26dUNAQADmzJljkQhu3boVt99+u9LuyZMnK/vCrLCwEPfffz+CgoLg6+uL4cOH45tvvml0W2fPnkXfvn3xpz/9CXV1dU3Gde7cOYwbNw4A0LVrV2g0Gjz00EMArvc6PPHEE+jWrRu8vLxw++23Izc3V9mGuefl888/x+DBg+Hl5YWYmBgUFBQ0ux80Gg3efvttTJo0Cd7e3oiIiMAHH3xgUaegoAB33nknvL29ERwcjD/+8Y+orKy02PZtt90GX19fdOnSBaNHj8b58+eb3GZWVhamTp1qUZabm4v4+HiEhIQgMDAQY8eOxYEDBxq09Z133sG0adPg6+uL5cuXAwA++eQTDB8+HF5eXggJCcH06dOVZez5uQCAqVOn4v333292H5MLa/frBokcZOzYseLn5ydPPvmkfPfdd7Jx40bx8fGRNWvWKHV69eolAQEB8tprr8nJkyfl5MmTsn//fnFzc5OXXnpJjh8/LuvWrRNvb2/lrZ25ubni7u4umZmZcu7cOTlw4IC88cYbyjqfe+45ufXWW2Xr1q1y+vRpWbduneh0Otm5c6eIiBQWFkpQUJBMnz5dcnNz5fjx4/LXv/5VvvvuOxERSU1NlYCAAHn//fflu+++k0WLFolWq5UTJ060K9apU6dKv3795Ouvv5b8/HyZOHGi9O3bV2pqakRE5J577pH4+Hg5dOiQnD59Wj799FPZtWtXu47BrFmzxM/PT37729/K4cOH5bPPPpObbrpJnnvuOaXOhx9+KB999JGcOHFCDh48KFOmTJHo6Gipra0VEZGKigrp06ePjBkzRnbv3i0nT56UTZs2SU5OjoiIvPjiizJ48GARESkoKJDu3bvLs88+q6y/qbiuXbsmH330kQCQ48ePS1FRkVy+fFlERJ544gkJCwuTLVu2yJEjR2TWrFnStWtXuXjxooj8962s/fr1k23btsmhQ4dk8uTJ0rt3b2V/NgaABAcHy7vvvivHjx+XpUuXiru7uxw9elRERK5cuSJhYWEyffp0KSgokC+//FIiIiJk1qxZIiJiMpkkMDBQFi5cKKdOnZKjR49KRkaGnD9/vsltdunSRbKysizKvvzyS9mwYYMcPXpUjh49KrNnz5bQ0FApLy+3aGu3bt1k7dq1cvr0aTl37px89tln4u7uLi+88IIcPXpU8vPz5eWXXxYR+38uRESOHj0qAOTcuXNNxkuuiwkKdRhjx46Vfv36SV1dnVL2zDPPSL9+/ZTpXr16yb333muxXGJiosTHx1uUPf3009K/f38REfnoo48kICDA4mJuVllZKV5eXsqXp9ns2bPlgQceEBGRxYsXS0RERJNfZGFhYcpF32zEiBEyb968Nsd64sQJASD/+te/lPk///yzeHt7y9///ncREYmOjhaDwdDkNtpi1qxZEhQUJFeuXFHK3n77bfHz81MSkPpKSkoEgPKa9r/85S/i7++vJAf1mROUnJwcCQoKktdee81ifnNxmRONG18jX1lZKVqtVv72t78pZTU1NRIWFiYrV660WO7GL/6LFy+Kt7e3bNq0qcn9AUDmzp1rURYTEyN/+tOfRERkzZo10rVrV6msrFTmf/755+Lm5ibFxcVy8eJFAaB8qbektLRUAMjXX3/dbL1r166Jv7+/fPrppxZtTUpKsqg3atQoefDBBxtdh70/FyIiZWVlVsVProW3eKhDGTlyJDQajTI9atQonDx5ErW1tUrZ8OHDLZY5duwYRo8ebVE2evRoZbn4+Hj06tULffr0wcyZM/G3v/0NVVVVAICjR4/i6tWriI+Ph5+fn/LnvffeU7qq8/PzMWbMGGi12gbtLS8vx48//tjo9o8dO9bmWI8dOwYPDw/ExMQo84ODg3HLLbco633iiSewfPlyjB49Gi+++CIOHTrU5LZSUlIs4rtw4UKTdQcPHgwfHx+LdlVWVuL7778HAJw+fRqJiYno06cPAgICEBERAQDKOvPz8zF06FAEBQU1uY0LFy5gwoQJWLp0KRYuXGgxz5q4zO0xmUwWx0Cr1eK2225rcAxGjRql/DsoKMhifzblxmXM0+Zljh07hsGDB8PX11eZP3r0aNTV1eH48eMICgrCQw89hIkTJ2LKlCl44403UFRU1OS2qqurAQBeXl4W5SUlJZg7dy6ioqIQGBiIwMBAVFZWNjiO9T8b+fn5GD9+fKPbsufnwszb2xsAlPUS3YgJCnU6N34ZANfvld/4RW8uM/P398eBAwfw/vvvo3v37njhhRcwePBgXL58GXV1dQCAzz//HPn5+cqfo0ePKvfbzRfZ5jS2/fpl1rix/U2t95FHHsGZM2cwc+ZMFBQUYPjw4UhPT290ublz51rEFxYWZnWbzNudMmUKLl68iHfffRfffPONMrbEPE6lNfvrpptuwm233YasrCyUl5dbzLMmLuC/+6qtx6Atx8m8THPbMJevW7cOe/fuRWxsLDZt2oSoqCjs27ev0WWCg4Oh0WhQWlpqUf7QQw8hLy8PaWlpyMnJQX5+PoKDgxsMEq//2WjuWDjic3Hp0iUA1483UX1MUKhDqX/h3rdvHyIjI+Hu7t7kMv3798eePXssynJychAVFaUs5+HhgQkTJmDlypU4dOgQzp07h6+++gr9+/eHTqfDhQsX0LdvX4s/4eHhAIBBgwZh9+7djf4qIiAgAGFhYY1uv1+/fm2OtX///rh27ZrFwNKLFy/ixIkTFusNDw/H3Llz8fHHH2PBggV49913G91WUFCQRWweHh5Ntuvf//638j95c7v8/PzQo0cPXLx4EceOHcPSpUsxfvx49OvXr8GX6aBBg5Cfn698OTXG29sbn332Gby8vDBx4kRUVFRYzG8qLk9PTwCw6FHr27cvPD09LY6ByWTC/v37GxyDG/d5aWkpTpw4gVtvvbXJdtZfxjxtXqZ///7Iz8/HlStXlPn/+te/4ObmhqioKKVs6NChWLx4MXJycjBw4EBkZmY2ui1PT0/0798fR48etSjfvXs3nnjiCdx9993KYPCff/652XYD14/Fl19+2eR8e30uzA4fPgytVosBAwa02FZyQc67u0RkHfPA0aeeekq+++47yczMFF9fX3nnnXeUOr169ZJVq1ZZLJeXl2cxSDYjI8NikOynn34qb7zxhhw8eFDOnTsnb731lri5ucnhw4dFRGTJkiUSHBwsGRkZcurUKTlw4ICsXr1aMjIyROT62I/g4GBlMOCJEyfkvffeUwYDrlq1SgICAiQrK0u+++47eeaZZ1o9SLa5WKdNmyb9+/eX3bt3S35+vtx1110Wg2SffPJJ2bp1q5w5c0by8vLktttukxkzZrTrGJgHyT7wwANy5MgR2bJli4SGhiqDWGtrayU4OFh+97vfycmTJ+XLL7+UESNGCADZvHmziIgYjUaJioqSMWPGyJ49e+T06dPy4YcfNjpItqKiQm6//XYZPXq0VFRUtBhXYWGhaDQaycjIkJKSEotlwsLC5IsvvrAYJHvp0iUR+e8YlAEDBsj27duloKBApk6dKj179hSj0djk/gAgISEhsnbtWjl+/Li88MIL4ubmJkeOHBGR64Nku3fvLvfdd58UFBTIV199JX369FEGyZ45c0aeffZZycnJkXPnzsk///lPCQoKkrfeeqvJbSYnJ8t9991nUTZkyBCJj4+Xo0ePyr59+2TMmDHi7e1t8Vm48RiY7dixQ9zc3JRBsocOHZJXX31VROz/uTAf6zvvvLPJWMm1MUGhDmPs2LEyb948mTt3rgQEBEjXrl3l2WeftRhI2liCInL9lyX9+/cXrVYrPXv2tBh4uXv3bhk7dqx07dpVvL29ZdCgQRYDI+vq6uSNN96QW265RbRardx0000yceJEi1/E/Pvf/5aEhATx8fERf39/GTNmjJw+fVpErn9pL1u2TH71q1+JVquVwYMHyxdffNHuWC9duiQzZ86UwMBA8fb2lokTJ1okPY8//rjcfPPNotPp5KabbpKZM2fKzz//3Pod3ohZs2bJtGnT5IUXXpDg4GDx8/OTRx55RK5evarUyc7Oln79+olOp5NBgwbJzp07G3w5njt3Tu677z4JCAgQHx8fGT58uHzzzTciYpmgiFxPUmJjY2XMmDFSWVnZYlwvvfSS6PV60Wg0SiJQXV0t8+fPl5CQENHpdDJ69Gj59ttvlWXMCcqnn34qAwYMEE9PTxkxYoTk5+c3uz8AyJtvvinx8fGi0+mkV69e8v7771vUOXTokIwbN068vLwkKChIHn30USVxKi4ulnvvvVe6d+8unp6e0qtXL3nhhReaHHAsInLs2DHx9vZWfqEkInLgwAEZPny46HQ6iYyMlA8++KDBZ6GxBEXk+mDYIUOGiKenp4SEhMj06dNFxP6fCxGRqKioBvuLyEwj0sTNbCKViYuLw5AhQ5CWlubsptidK8WqBjt37sS4ceNQWlqKLl26tHo5jUaDzZs32/3x//XNmDFDuS3UUX3++ed4+umncejQoWZvKZLr4hgUIqIO5rXXXoOfn5+zm9EuV65cwbp165icUJN4ZhARdTC9evXC/Pnznd2MdpkxY4azm0Aqx1s8REREpDq8xUNERESqwwSFiIiIVIcJChEREakOExQiIiJSHSYoREREpDpMUIiIiEh1mKAQERGR6jBBISIiItX5/53Qhu8q13CQAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(res['dy'], bins=50, alpha=0.5, label='dy');\n", + "plt.hist(res['dz'], bins=50, alpha=0.5, label='dz');\n", + "plt.grid()\n", + "plt.legend();\n", + "plt.xlabel('proseco pos - backstop pos (arcsec)');" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ska3-flight", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/analysis/reselect_fid_offset.ipynb b/analysis/reselect_fid_offset.ipynb new file mode 100644 index 00000000..e5145de8 --- /dev/null +++ b/analysis/reselect_fid_offset.ipynb @@ -0,0 +1,3573 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Apply fid offsets in proseco\n", + "\n", + "Reselect a set of catalogs in 2 aca drift model epochs (and in the interval since the last safe mode) to confirm new fid offset positions and verify proseco catalogs in general are reasonable with this change." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.42.1.dev13+gcf5cbc1\n", + "5.11.1.dev7+g56d76a1.d20231130\n" + ] + } + ], + "source": [ + "import os\n", + "os.environ['SKA'] = '/Users/jean/ska'\n", + "import sys\n", + "sys.path.insert(0, '/Users/jean/git/chandra_aca') # includes https://github.com/sot/chandra_aca/pull/157\n", + "sys.path.insert(0, '../') # Proseco with https://github.com/sot/proseco/pull/388\n", + "import chandra_aca\n", + "print(chandra_aca.__version__)\n", + "import proseco\n", + "print(proseco.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import display\n", + "\n", + "from proseco.diff import catalog_diff\n", + "\n", + "\n", + "from functools import lru_cache\n", + "from pathlib import Path\n", + "import pickle\n", + "import gzip\n", + "import warnings\n", + "\n", + "warnings.filterwarnings('ignore', category=UserWarning, module='chandra_aca')\n", + "warnings.filterwarnings('ignore', category=UserWarning, module='proseco')\n", + "\n", + "import astropy.units as u\n", + "from astropy.table import Table, join, vstack\n", + "from cheta import fetch_sci as fetch\n", + "\n", + "from cxotime import CxoTime\n", + "from ska_matplotlib import plot_cxctime\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from kadi.commands import observations\n", + "from kadi.commands.commands_v2 import APPROVED_LOADS_OCCWEB_DIR\n", + "from kadi.occweb import get_occweb_page\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Retrieve fid stats data file on the web\n", + "COMMANDS_TELEM = Table.read(\n", + " \"https://cxc.harvard.edu/mta/ASPECT/ipynb/chandra_aca_fid_offset/fid_commands_telem.dat\",\n", + " format='ascii')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "@lru_cache()\n", + "def get_pickle_path(load_name: str) -> Path:\n", + " year = '20' + load_name[5:7]\n", + " month_name = load_name[:3]\n", + " pkl_path = (\n", + " APPROVED_LOADS_OCCWEB_DIR \n", + " / year \n", + " / month_name \n", + " / load_name \n", + " / 'output'\n", + " / f'{load_name}_proseco.pkl.gz'\n", + " )\n", + " return pkl_path" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "@lru_cache(maxsize=5)\n", + "def get_acas(load_name):\n", + " path = get_pickle_path(load_name)\n", + " pkl_bytes = get_occweb_page(path, binary=True, cache=True)\n", + " acas = pickle.loads(gzip.decompress(pkl_bytes))\n", + " return acas" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def get_aca(obsid, load_name):\n", + " acas = get_acas(load_name)\n", + " return acas[obsid]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def reselect(aca, enable_fid=None):\n", + " if enable_fid is None:\n", + " if 'PROSECO_ENABLE_FID_OFFSET' in os.environ:\n", + " del os.environ['PROSECO_ENABLE_FID_OFFSET']\n", + " else:\n", + " os.environ['PROSECO_ENABLE_FID_OFFSET'] = str(enable_fid)\n", + "\n", + " call_args = aca.call_args.copy()\n", + " if 'dark_date' in aca.meta:\n", + " call_args['dark_date'] = aca.meta['dark_date']\n", + " new_aca = proseco.get_aca_catalog(**call_args)\n", + " #print(acas[obsid].meta['dark_date'], new_acas[obsid].meta['dark_date'])\n", + " return new_aca" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def get_data(obss):\n", + " seen_obs = {}\n", + " dat = []\n", + " for obs in obss:\n", + " if int(obs['obsid']) > 38000:\n", + " continue\n", + " # Skip if we've already seen this obsid.\n", + " # Since we're working from kadi.observations, this will also skip\n", + " # obsids after SCS107. That's fine.\n", + " if obs['obsid'] in seen_obs:\n", + " continue\n", + " seen_obs[obs['obsid']] = 1\n", + " if obs.get('starcat_date') is None:\n", + " continue\n", + " if obs['source'] == 'CMD_EVT':\n", + " continue\n", + " obsid = obs['obsid']\n", + " #sc = observations.get_starcats(obsid=obs['obsid'], starcat_date=obs['starcat_date'])\n", + " aca = get_aca(obsid, obs['source'])\n", + " aca_fid_false = reselect(aca, enable_fid='False')\n", + " aca_fid_true = reselect(aca, enable_fid='True')\n", + " aca_fid_none = reselect(aca, enable_fid=None)\n", + " fid_obs = COMMANDS_TELEM[COMMANDS_TELEM['obsid'] == obsid]\n", + " for slot in fid_obs['slot']:\n", + " row = {'aca_orig_yang': aca[aca['slot'] == slot]['yang'][0],\n", + " 'aca_orig_zang': aca[aca['slot'] == slot]['zang'][0],\n", + " 'aca_orig_id': aca[aca['slot'] == slot]['id'][0],\n", + " 'aca_fid_false_yang': aca_fid_false[aca_fid_false['slot'] == slot]['yang'][0],\n", + " 'aca_fid_false_zang': aca_fid_false[aca_fid_false['slot'] == slot]['zang'][0],\n", + " 'aca_fid_false_id': aca_fid_false[aca_fid_false['slot'] == slot]['id'][0],\n", + " 'aca_fid_true_yang': aca_fid_true[aca_fid_true['slot'] == slot]['yang'][0],\n", + " 'aca_fid_true_zang': aca_fid_true[aca_fid_true['slot'] == slot]['zang'][0],\n", + " 'aca_fid_true_id': aca_fid_true[aca_fid_true['slot'] == slot]['id'][0],\n", + " 'aca_fid_none_yang': aca_fid_none[aca_fid_none['slot'] == slot]['yang'][0],\n", + " 'aca_fid_none_zang': aca_fid_none[aca_fid_none['slot'] == slot]['zang'][0],\n", + " 'aca_fid_none_id': aca_fid_none[aca_fid_none['slot'] == slot]['id'][0],\n", + " 'aca_obs_yang': fid_obs[fid_obs['slot'] == slot]['aoacyan'][0],\n", + " 'aca_obs_zang': fid_obs[fid_obs['slot'] == slot]['aoaczan'][0],\n", + " 'backstop_yang': fid_obs[fid_obs['slot'] == slot]['yang'][0],\n", + " 'backstop_zang': fid_obs[fid_obs['slot'] == slot]['zang'][0],\n", + " 'detector': fid_obs[fid_obs['slot'] == slot]['detector'][0],\n", + " 'source': obs['source'],\n", + " 'slot': slot,\n", + " 'tstart': fid_obs[fid_obs['slot'] == slot]['tstart'][0],\n", + " 'obsid': obsid}\n", + " dat.append(row)\n", + " return Table(dat)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_hist_resid(dat): \n", + " fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 4))\n", + " ybins = np.arange(-8, 40, 1)\n", + " #ybins = None\n", + " ax[0].hist(dat['aca_obs_yang'] - dat['aca_orig_yang'], bins=ybins,\n", + " alpha=0.5, label='as run')\n", + " ax[0].hist(dat['aca_obs_yang'] - dat['aca_fid_true_yang'], bins=ybins, \n", + " alpha=0.5, label='this PR')\n", + " ax[0].set_xlabel('Y offset (arcsec)')\n", + " ax[0].legend()\n", + " ax[0].grid()\n", + " zbins = np.arange(-8, 13, 1)\n", + " ax[1].hist(dat['aca_obs_zang'] - dat['aca_orig_zang'], bins=zbins,\n", + " alpha=0.5, label='as run')\n", + " ax[1].hist(dat['aca_obs_zang'] - dat['aca_fid_true_zang'], bins=zbins,\n", + " alpha=0.5, label='this PR')\n", + " ax[1].set_xlabel('Z offset (arcsec)')\n", + " ax[1].legend()\n", + " ax[1].grid()\n", + " plt.suptitle(f\"fid position residuals\"); " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_time_resid(dat): \n", + " fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 4))\n", + " plot_cxctime(dat['tstart'], dat['aca_obs_yang'] - dat['aca_orig_yang'], '.', label='as run', ax=ax[0])\n", + " plot_cxctime(dat['tstart'], dat['aca_obs_yang'] - dat['aca_fid_true_yang'], '.', label='this PR', ax=ax[0])\n", + " ax[0].set_ylabel('Y offset (arcsec)')\n", + " ax[0].legend()\n", + " ax[0].grid()\n", + " plot_cxctime(dat['tstart'], dat['aca_obs_zang'] - dat['aca_orig_zang'], '.', label='as run', ax=ax[1])\n", + " plot_cxctime(dat['tstart'], dat['aca_obs_zang'] - dat['aca_fid_true_zang'], '.', label='this PR', ax=ax[1])\n", + " ax[1].set_ylabel('Z offset (arcsec)')\n", + " ax[1].legend()\n", + " ax[1].grid()\n", + " plt.suptitle(f\"fid position residuals\"); " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def get_det_per_fid_counts(dat):\n", + " det_per_fid = {}\n", + " for det in ['HRC-I', 'HRC-S', 'ACIS-I', 'ACIS-S']:\n", + " fid_counts = {}\n", + " rows = dat[dat['detector'] == det]\n", + " for id in [1, 2, 3, 4, 5, 6]:\n", + " if det in ['HRC-I', 'HRC-S']:\n", + " if id in [5, 6]:\n", + " continue\n", + " fid_counts[id] = np.count_nonzero(rows['aca_fid_true_id'] == id)\n", + " det_per_fid[det] = fid_counts\n", + " return det_per_fid" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "epochs = [{'epoch': 1,\n", + " 'start': '2019:180',\n", + " 'stop': '2019:270',\n", + " 'note': 'after 2018:285 step change'},\n", + " {'epoch': 2,\n", + " 'start': '2022:295',\n", + " 'stop': '2023:040',\n", + " 'note': 'after 2022:294 step change'},\n", + " {'epoch': 3,\n", + " 'start': '2023:200',\n", + " 'stop': '2023:290',\n", + " 'note': 'after 2023:047 safe modes (not recalibrated)'},\n", + " ]\n", + "\n", + "epoch_dat = {}\n", + "for epoch in epochs:\n", + " filename = f'fid_epoch{epoch[\"epoch\"]}.csv'\n", + " if Path(filename).exists():\n", + " epoch_dat[epoch['epoch']] = Table.read(f'fid_epoch{epoch[\"epoch\"]}.csv')\n", + " else:\n", + " obss = observations.get_observations(start=epoch['start'], stop=epoch['stop'])\n", + " epoch_dat[epoch['epoch']] = get_data(obss)\n", + " epoch_dat[epoch['epoch']].write(filename, format='ascii.csv')\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def report(dat):\n", + " changed = dat['aca_orig_id'] != dat['aca_fid_false_id']\n", + " print(\"Number of data rows: \", len(dat))\n", + " print(\"Number of fids changed with reselect: \", len(dat[changed]))\n", + " y_match = np.all(dat['aca_fid_false_yang'][~changed] == dat['aca_orig_yang'][~changed])\n", + " z_match = np.all(dat['aca_fid_false_zang'][~changed] == dat['aca_orig_zang'][~changed])\n", + " print(\"Positions match for reselect fids with var set to false: \", y_match and z_match)\n", + " y_match = np.all(dat['aca_fid_true_yang'][~changed] == dat['aca_fid_none_yang'][~changed])\n", + " z_match = np.all(dat['aca_fid_true_zang'][~changed] == dat['aca_fid_none_zang'][~changed])\n", + " print(\"Positions match for reselect fids with var set to none or true: \", y_match and z_match)\n", + " ok = dat['aca_orig_id'] == dat['aca_fid_true_id']\n", + " print(\"Number of fids changed with fid offset reselect: \", len(dat[~ok]))\n", + " plot_hist_resid(dat[ok])\n", + " plot_time_resid(dat[ok])\n", + " print(\"Fids used by detector (confirm coverage)\")\n", + " print(get_det_per_fid_counts(dat[ok]))\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first epoch in this notebook includes data in 2019 (after proseco came into use)\n", + "which is also after the 2018:265 jump. The Y and Z fid offsets with the PR are approximately\n", + "zero-centered." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of data rows: 756\n", + "Number of fids changed with reselect: 18\n", + "Positions match for reselect fids with var set to false: True\n", + "Positions match for reselect fids with var set to none or true: True\n", + "Number of fids changed with fid offset reselect: 38\n", + "Fids used by detector (confirm coverage)\n", + "{'HRC-I': {1: 24, 2: 17, 3: 20, 4: 13}, 'HRC-S': {1: 12, 2: 9, 3: 12, 4: 3}, 'ACIS-I': {1: 84, 2: 12, 3: 29, 4: 7, 5: 77, 6: 71}, 'ACIS-S': {1: 11, 2: 93, 3: 9, 4: 103, 5: 99, 6: 13}}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "report(epoch_dat[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The second epoch in this notebook includes data in 2022 after the 2022:294 jump. The new fid positions are approximately zero centered." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of data rows: 1205\n", + "Number of fids changed with reselect: 16\n", + "Positions match for reselect fids with var set to false: True\n", + "Positions match for reselect fids with var set to none or true: True\n", + "Number of fids changed with fid offset reselect: 68\n", + "Fids used by detector (confirm coverage)\n", + "{'HRC-I': {1: 0, 2: 0, 3: 0, 4: 0}, 'HRC-S': {1: 0, 2: 0, 3: 0, 4: 0}, 'ACIS-I': {1: 113, 2: 6, 3: 27, 4: 10, 5: 107, 6: 109}, 'ACIS-S': {1: 29, 2: 211, 3: 35, 4: 231, 5: 216, 6: 43}}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "report(epoch_dat[2])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The third epoch is not an epoch as defined by the drift mode, but includes data after the 2023:044 2023:047 safe modes (the drift model has not been re-calibrated since jumps from those event). The corrected fid positions show mean offsets but continue to show significantly reduce spread." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of data rows: 990\n", + "Number of fids changed with reselect: 1\n", + "Positions match for reselect fids with var set to false: True\n", + "Positions match for reselect fids with var set to none or true: True\n", + "Number of fids changed with fid offset reselect: 35\n", + "Fids used by detector (confirm coverage)\n", + "{'HRC-I': {1: 26, 2: 27, 3: 27, 4: 11}, 'HRC-S': {1: 21, 2: 18, 3: 21, 4: 8}, 'ACIS-I': {1: 88, 2: 6, 3: 36, 4: 8, 5: 96, 6: 98}, 'ACIS-S': {1: 26, 2: 124, 3: 16, 4: 130, 5: 126, 6: 42}}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "report(epoch_dat[3])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def get_diff_catalog(aca_new, aca_ref): \n", + " diff = catalog_diff(aca_ref, aca_new, \n", + " names='idx id slot type yang zang',\n", + " labels=[f\"Obsid {aca_new.obsid}\"])\n", + " return diff" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "from proseco.diff import CatalogDiff, HTML_FOOTER, HTML_HEADER\n", + "\n", + "HTML_HEADER = \"\"\"\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def get_criticals(aca):\n", + " lines = []\n", + " acar = aca.get_review_table()\n", + " acar.run_aca_review()\n", + " criticals = acar.messages >= \"critical\"\n", + " if criticals:\n", + " lines.append(\"-------------------------------\")\n", + " lines.append(f\"{obsid}\")\n", + " lines.append(\"-------------------------------\")\n", + " for msg in criticals:\n", + " lines.append(msg['category'].capitalize() + ': ' + msg['text'])\n", + " return lines" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "import difflib\n", + "def get_diff_criticals(criticals_new, criticals_legacy):\n", + "\n", + " differ = difflib.HtmlDiff()\n", + " text_diff = differ.make_table(criticals_legacy, criticals_new)\n", + "\n", + " return CatalogDiff(HTML_HEADER + \"

CRITICALS

\" + text_diff + \"
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22200.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   934.86  -839.01
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1813.19  1058.98
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   400.85  1703.02
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   145.33  1635.817  5 548932512    4  GU*   145.33  1635.81
8  4 548933960    3  GU*   977.82 -1527.828  4 548933960    3  GU*   977.82 -1527.82
9  7 548937184    6  GU*  -393.18  -599.469  7 548937184    6  GU*  -393.18  -599.46
10  6 549850840    5  GU* -2220.93  2113.5010  6 549850840    5  GU* -2220.93  2113.50
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   145.33  1635.8112  5 548932512    4  AC*   145.33  1635.81
13 10 548933288    2  ACQ  1087.69 -1711.3113 10 548933288    2  ACQ  1087.69 -1711.31
14  4 548933960    3  AC*   977.82 -1527.8214  4 548933960    3  AC*   977.82 -1527.82
15 11 548934440    7  ACQ   169.93 -2011.1315 11 548934440    7  ACQ   169.93 -2011.13
16  8 548935824    0  ACQ   577.14  2331.3016  8 548935824    0  ACQ   577.14  2331.30
17  7 548937184    6  AC*  -393.18  -599.4617  7 548937184    6  AC*  -393.18  -599.46
18  9 548938256    1  ACQ -1953.39 -1455.8418  9 548938256    1  ACQ -1953.39 -1455.84
19  6 549850840    5  AC* -2220.93  2113.5019  6 549850840    5  AC* -2220.93  2113.50
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22200.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   934.86  -839.01
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1813.19  1058.98
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   400.85  1703.02
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   145.33  1635.817  5 548932512    4  GU*   145.33  1635.81
8  4 548933960    3  GU*   977.82 -1527.828  4 548933960    3  GU*   977.82 -1527.82
9  7 548937184    6  GU*  -393.18  -599.469  7 548937184    6  GU*  -393.18  -599.46
10  6 549850840    5  GU* -2220.93  2113.5010  6 549850840    5  GU* -2220.93  2113.50
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   145.33  1635.8112  5 548932512    4  AC*   145.33  1635.81
13 10 548933288    2  ACQ  1087.69 -1711.3113 10 548933288    2  ACQ  1087.69 -1711.31
14  4 548933960    3  AC*   977.82 -1527.8214  4 548933960    3  AC*   977.82 -1527.82
15 11 548934440    7  ACQ   169.93 -2011.1315 11 548934440    7  ACQ   169.93 -2011.13
16  8 548935824    0  ACQ   577.14  2331.3016  8 548935824    0  ACQ   577.14  2331.30
17  7 548937184    6  AC*  -393.18  -599.4617  7 548937184    6  AC*  -393.18  -599.46
18  9 548938256    1  ACQ -1953.39 -1455.8418  9 548938256    1  ACQ -1953.39 -1455.84
19  6 549850840    5  AC* -2220.93  2113.5019  6 549850840    5  AC* -2220.93  2113.50
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222200222200
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.93 < 4.04Critical: OR count of guide stars 3.93 < 4.0
5Critical: guide_count 3.93 and dither > 4x4 arcsec5Critical: guide_count 3.93 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222200222200
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.93 < 4.04Critical: OR count of guide stars 3.93 < 4.0
5Critical: guide_count 3.93 and dither > 4x4 arcsec5Critical: guide_count 3.93 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22264.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   928.36  -842.04
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.70  1055.95
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   394.34  1699.99
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   126.21  1636.917  5 548932512    4  GU*   126.21  1636.91
8  4 548933960    3  GU*   996.12 -1516.648  4 548933960    3  GU*   996.12 -1516.64
9  7 548937184    6  GU*  -385.77  -604.589  7 548937184    6  GU*  -385.77  -604.58
10  6 549850840    5  GU* -2245.53  2086.5410  6 549850840    5  GU* -2245.53  2086.54
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   126.21  1636.9112  5 548932512    4  AC*   126.21  1636.91
13 10 548933720    2  ACQ  1590.55  1585.4913 10 548933720    2  ACQ  1590.55  1585.49
14  4 548933960    3  AC*   996.12 -1516.6414  4 548933960    3  AC*   996.12 -1516.64
15 11 548934440    7  ACQ   194.02 -2009.4915 11 548934440    7  ACQ   194.02 -2009.49
16  8 548935824    0  ACQ   549.75  2337.4716  8 548935824    0  ACQ   549.75  2337.47
17  7 548937184    6  AC*  -385.77  -604.5817  7 548937184    6  AC*  -385.77  -604.58
18  9 548938256    1  ACQ -1935.73 -1479.3818  9 548938256    1  ACQ -1935.73 -1479.38
19  6 549850840    5  AC* -2245.53  2086.5419  6 549850840    5  AC* -2245.53  2086.54
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22264.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   928.36  -842.04
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.70  1055.95
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   394.34  1699.99
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   126.21  1636.917  5 548932512    4  GU*   126.21  1636.91
8  4 548933960    3  GU*   996.12 -1516.648  4 548933960    3  GU*   996.12 -1516.64
9  7 548937184    6  GU*  -385.77  -604.589  7 548937184    6  GU*  -385.77  -604.58
10  6 549850840    5  GU* -2245.53  2086.5410  6 549850840    5  GU* -2245.53  2086.54
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   126.21  1636.9112  5 548932512    4  AC*   126.21  1636.91
13 10 548933720    2  ACQ  1590.55  1585.4913 10 548933720    2  ACQ  1590.55  1585.49
14  4 548933960    3  AC*   996.12 -1516.6414  4 548933960    3  AC*   996.12 -1516.64
15 11 548934440    7  ACQ   194.02 -2009.4915 11 548934440    7  ACQ   194.02 -2009.49
16  8 548935824    0  ACQ   549.75  2337.4716  8 548935824    0  ACQ   549.75  2337.47
17  7 548937184    6  AC*  -385.77  -604.5817  7 548937184    6  AC*  -385.77  -604.58
18  9 548938256    1  ACQ -1935.73 -1479.3818  9 548938256    1  ACQ -1935.73 -1479.38
19  6 549850840    5  AC* -2245.53  2086.5419  6 549850840    5  AC* -2245.53  2086.54
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222264222264
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.98 < 4.04Critical: OR count of guide stars 3.98 < 4.0
5Critical: guide_count 3.98 and dither > 4x4 arcsec5Critical: guide_count 3.98 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222264222264
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.98 < 4.04Critical: OR count of guide stars 3.98 < 4.0
5Critical: guide_count 3.98 and dither > 4x4 arcsec5Critical: guide_count 3.98 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22265.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   929.01  -841.73
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.04  1056.26
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   395.00  1700.29
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   125.33  1636.507  5 548932512    4  GU*   125.33  1636.50
8  4 548933960    3  GU*   995.24 -1517.058  4 548933960    3  GU*   995.24 -1517.05
9  7 548937184    6  GU*  -386.65  -604.999  7 548937184    6  GU*  -386.65  -604.99
10  6 549850840    5  GU* -2246.41  2086.1310  6 549850840    5  GU* -2246.41  2086.13
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   125.33  1636.5012  5 548932512    4  AC*   125.33  1636.50
13  9 548933288    1  ACQ  1107.28 -1699.2213  9 548933288    1  ACQ  1107.28 -1699.22
14 10 548933720    2  ACQ  1589.67  1585.0814 10 548933720    2  ACQ  1589.67  1585.08
15  4 548933960    3  AC*   995.24 -1517.0515  4 548933960    3  AC*   995.24 -1517.05
16 11 548934440    7  ACQ   193.14 -2009.9016 11 548934440    7  ACQ   193.14 -2009.90
17  7 548937184    6  AC*  -386.65  -604.9917  7 548937184    6  AC*  -386.65  -604.99
18  8 548938256    0  ACQ -1936.61 -1479.7918  8 548938256    0  ACQ -1936.61 -1479.79
19  6 549850840    5  AC* -2246.41  2086.1319  6 549850840    5  AC* -2246.41  2086.13
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22265.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   929.01  -841.73
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.04  1056.26
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   395.00  1700.29
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   125.33  1636.507  5 548932512    4  GU*   125.33  1636.50
8  4 548933960    3  GU*   995.24 -1517.058  4 548933960    3  GU*   995.24 -1517.05
9  7 548937184    6  GU*  -386.65  -604.999  7 548937184    6  GU*  -386.65  -604.99
10  6 549850840    5  GU* -2246.41  2086.1310  6 549850840    5  GU* -2246.41  2086.13
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   125.33  1636.5012  5 548932512    4  AC*   125.33  1636.50
13  9 548933288    1  ACQ  1107.28 -1699.2213  9 548933288    1  ACQ  1107.28 -1699.22
14 10 548933720    2  ACQ  1589.67  1585.0814 10 548933720    2  ACQ  1589.67  1585.08
15  4 548933960    3  AC*   995.24 -1517.0515  4 548933960    3  AC*   995.24 -1517.05
16 11 548934440    7  ACQ   193.14 -2009.9016 11 548934440    7  ACQ   193.14 -2009.90
17  7 548937184    6  AC*  -386.65  -604.9917  7 548937184    6  AC*  -386.65  -604.99
18  8 548938256    0  ACQ -1936.61 -1479.7918  8 548938256    0  ACQ -1936.61 -1479.79
19  6 549850840    5  AC* -2246.41  2086.1319  6 549850840    5  AC* -2246.41  2086.13
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222265222265
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.89 < 4.04Critical: OR count of guide stars 3.89 < 4.0
5Critical: guide_count 3.89 and dither > 4x4 arcsec5Critical: guide_count 3.89 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222265222265
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.89 < 4.04Critical: OR count of guide stars 3.89 < 4.0
5Critical: guide_count 3.89 and dither > 4x4 arcsec5Critical: guide_count 3.89 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22733.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   931.11  -840.80
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1816.94  1057.18
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   397.10  1701.22
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 548933960    3  GU*  -477.93 -1808.927  4 548933960    3  GU*  -477.93 -1808.92
8  7 548937184    6  GU*  -838.41  -192.928  7 548937184    6  GU*  -838.41  -192.92
9  5 549849072    4  GU* -1547.46  2204.339  5 549849072    4  GU* -1547.46  2204.33
10  6 549849656    5  GU*  2453.57  2352.7810  6 549849656    5  GU*  2453.57  2352.78
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  8 548932512    0  ACQ  1086.95  1063.8312  8 548932512    0  ACQ  1086.95  1063.83
13  4 548933960    3  AC*  -477.93 -1808.9213  4 548933960    3  AC*  -477.93 -1808.92
14 11 548935824    7  ACQ  1878.27  1273.5914 11 548935824    7  ACQ  1878.27  1273.59
15  9 548936840    1  ACQ  -475.37 -1685.3615  9 548936840    1  ACQ  -475.37 -1685.36
16  7 548937184    6  AC*  -838.41  -192.9216  7 548937184    6  AC*  -838.41  -192.92
17 10 548939872    2  ACQ -2301.13   188.7117 10 548939872    2  ACQ -2301.13   188.71
18  5 549849072    4  AC* -1547.46  2204.3318  5 549849072    4  AC* -1547.46  2204.33
19  6 549849656    5  AC*  2453.57  2352.7819  6 549849656    5  AC*  2453.57  2352.78
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22733.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   931.11  -840.80
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1816.94  1057.18
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   397.10  1701.22
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 548933960    3  GU*  -477.93 -1808.927  4 548933960    3  GU*  -477.93 -1808.92
8  7 548937184    6  GU*  -838.41  -192.928  7 548937184    6  GU*  -838.41  -192.92
9  5 549849072    4  GU* -1547.46  2204.339  5 549849072    4  GU* -1547.46  2204.33
10  6 549849656    5  GU*  2453.57  2352.7810  6 549849656    5  GU*  2453.57  2352.78
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  8 548932512    0  ACQ  1086.95  1063.8312  8 548932512    0  ACQ  1086.95  1063.83
13  4 548933960    3  AC*  -477.93 -1808.9213  4 548933960    3  AC*  -477.93 -1808.92
14 11 548935824    7  ACQ  1878.27  1273.5914 11 548935824    7  ACQ  1878.27  1273.59
15  9 548936840    1  ACQ  -475.37 -1685.3615  9 548936840    1  ACQ  -475.37 -1685.36
16  7 548937184    6  AC*  -838.41  -192.9216  7 548937184    6  AC*  -838.41  -192.92
17 10 548939872    2  ACQ -2301.13   188.7117 10 548939872    2  ACQ -2301.13   188.71
18  5 549849072    4  AC* -1547.46  2204.3318  5 549849072    4  AC* -1547.46  2204.33
19  6 549849656    5  AC*  2453.57  2352.7819  6 549849656    5  AC*  2453.57  2352.78
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222733222733
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.90 < 4.04Critical: OR count of guide stars 3.90 < 4.0
5Critical: guide_count 3.90 and dither > 4x4 arcsec5Critical: guide_count 3.90 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222733222733
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.90 < 4.04Critical: OR count of guide stars 3.90 < 4.0
5Critical: guide_count 3.90 and dither > 4x4 arcsec5Critical: guide_count 3.90 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22734.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   929.02  -841.78
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.03  1056.20
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   395.00  1700.24
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 548933960    3  GU*  -479.60 -1809.717  4 548933960    3  GU*  -479.60 -1809.71
8  7 548937184    6  GU*  -840.08  -193.718  7 548937184    6  GU*  -840.08  -193.71
9  5 549849072    4  GU* -1549.13  2203.549  5 549849072    4  GU* -1549.13  2203.54
10  6 549849656    5  GU*  2451.90  2351.9910  6 549849656    5  GU*  2451.90  2351.99
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  8 548932512    0  ACQ  1085.28  1063.0412  8 548932512    0  ACQ  1085.28  1063.04
13  4 548933960    3  AC*  -479.60 -1809.7113  4 548933960    3  AC*  -479.60 -1809.71
14 11 548935824    7  ACQ  1876.60  1272.8014 11 548935824    7  ACQ  1876.60  1272.80
15  9 548936840    1  ACQ  -477.04 -1686.1515  9 548936840    1  ACQ  -477.04 -1686.15
16  7 548937184    6  AC*  -840.08  -193.7116  7 548937184    6  AC*  -840.08  -193.71
17 10 548939872    2  ACQ -2302.80   187.9217 10 548939872    2  ACQ -2302.80   187.92
18  5 549849072    4  AC* -1549.13  2203.5418  5 549849072    4  AC* -1549.13  2203.54
19  6 549849656    5  AC*  2451.90  2351.9919  6 549849656    5  AC*  2451.90  2351.99
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22734.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   929.02  -841.78
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.03  1056.20
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   395.00  1700.24
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 548933960    3  GU*  -479.60 -1809.717  4 548933960    3  GU*  -479.60 -1809.71
8  7 548937184    6  GU*  -840.08  -193.718  7 548937184    6  GU*  -840.08  -193.71
9  5 549849072    4  GU* -1549.13  2203.549  5 549849072    4  GU* -1549.13  2203.54
10  6 549849656    5  GU*  2451.90  2351.9910  6 549849656    5  GU*  2451.90  2351.99
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  8 548932512    0  ACQ  1085.28  1063.0412  8 548932512    0  ACQ  1085.28  1063.04
13  4 548933960    3  AC*  -479.60 -1809.7113  4 548933960    3  AC*  -479.60 -1809.71
14 11 548935824    7  ACQ  1876.60  1272.8014 11 548935824    7  ACQ  1876.60  1272.80
15  9 548936840    1  ACQ  -477.04 -1686.1515  9 548936840    1  ACQ  -477.04 -1686.15
16  7 548937184    6  AC*  -840.08  -193.7116  7 548937184    6  AC*  -840.08  -193.71
17 10 548939872    2  ACQ -2302.80   187.9217 10 548939872    2  ACQ -2302.80   187.92
18  5 549849072    4  AC* -1549.13  2203.5418  5 549849072    4  AC* -1549.13  2203.54
19  6 549849656    5  AC*  2451.90  2351.9919  6 549849656    5  AC*  2451.90  2351.99
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222734222734
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.89 < 4.04Critical: OR count of guide stars 3.89 < 4.0
5Critical: guide_count 3.89 and dither > 4x4 arcsec5Critical: guide_count 3.89 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222734222734
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.89 < 4.04Critical: OR count of guide stars 3.89 < 4.0
5Critical: guide_count 3.89 and dither > 4x4 arcsec5Critical: guide_count 3.89 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22850.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         2    0  FID  -770.80 -1742.84
4  2         4    1  FID  2140.23   166.634  2         4    1  FID  2142.63   165.82
5  3         5    2  FID -1826.28   160.175  3         5    2  FID -1823.88   159.36
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 763889856    4  GU* -2034.26  1827.497  5 763889856    4  GU* -2034.26  1827.49
8  4 764808424    3  GU*  1641.26  2366.448  4 764808424    3  GU*  1641.26  2366.44
9  6 839255272    5  GU*  1254.94   302.869  6 839255272    5  GU*  1254.94   302.86
10  7 839262008    6  GU*  -677.51   381.3410  7 839262008    6  GU*  -677.51   381.34
11  8 839262176    7  GU*  -596.76   770.3111  8 839262176    7  GU*  -596.76   770.31
12--- --------- ---- ---- -------- --------12--- --------- ---- ---- -------- --------
13  5 763889856    4  AC* -2034.26  1827.4913  5 763889856    4  AC* -2034.26  1827.49
14  4 764808424    3  AC*  1641.26  2366.4414  4 764808424    3  AC*  1641.26  2366.44
15  9 764811080    0  ACQ  2340.89  2058.9015  9 764811080    0  ACQ  2340.89  2058.90
16 11 838346224    2  ACQ -1437.86 -1503.6816 11 838346224    2  ACQ -1437.86 -1503.68
17  6 839255272    5  AC*  1254.94   302.8617  6 839255272    5  AC*  1254.94   302.86
18 10 839258264    1  ACQ  1421.69  -628.0118 10 839258264    1  ACQ  1421.69  -628.01
19  7 839262008    6  AC*  -677.51   381.3419  7 839262008    6  AC*  -677.51   381.34
20  8 839262176    7  AC*  -596.76   770.3120  8 839262176    7  AC*  -596.76   770.31
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22850.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         2    0  FID  -770.80 -1742.84
4  2         4    1  FID  2140.23   166.634  2         4    1  FID  2142.63   165.82
5  3         5    2  FID -1826.28   160.175  3         5    2  FID -1823.88   159.36
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 763889856    4  GU* -2034.26  1827.497  5 763889856    4  GU* -2034.26  1827.49
8  4 764808424    3  GU*  1641.26  2366.448  4 764808424    3  GU*  1641.26  2366.44
9  6 839255272    5  GU*  1254.94   302.869  6 839255272    5  GU*  1254.94   302.86
10  7 839262008    6  GU*  -677.51   381.3410  7 839262008    6  GU*  -677.51   381.34
11  8 839262176    7  GU*  -596.76   770.3111  8 839262176    7  GU*  -596.76   770.31
12--- --------- ---- ---- -------- --------12--- --------- ---- ---- -------- --------
13  5 763889856    4  AC* -2034.26  1827.4913  5 763889856    4  AC* -2034.26  1827.49
14  4 764808424    3  AC*  1641.26  2366.4414  4 764808424    3  AC*  1641.26  2366.44
15  9 764811080    0  ACQ  2340.89  2058.9015  9 764811080    0  ACQ  2340.89  2058.90
16 11 838346224    2  ACQ -1437.86 -1503.6816 11 838346224    2  ACQ -1437.86 -1503.68
17  6 839255272    5  AC*  1254.94   302.8617  6 839255272    5  AC*  1254.94   302.86
18 10 839258264    1  ACQ  1421.69  -628.0118 10 839258264    1  ACQ  1421.69  -628.01
19  7 839262008    6  AC*  -677.51   381.3419  7 839262008    6  AC*  -677.51   381.34
20  8 839262176    7  AC*  -596.76   770.3120  8 839262176    7  AC*  -596.76   770.31
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222850222850
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.92 < 4.04Critical: OR count of guide stars 3.92 < 4.0
5Critical: guide_count 3.92 and dither > 4x4 arcsec5Critical: guide_count 3.92 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222850222850
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.92 < 4.04Critical: OR count of guide stars 3.92 < 4.0
5Critical: guide_count 3.92 and dither > 4x4 arcsec5Critical: guide_count 3.92 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22851.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         2    0  FID  -767.07 -1741.10
4  2         4    1  FID  2140.23   166.634  2         4    1  FID  2146.36   167.57
5  3         5    2  FID -1826.28   160.175  3         5    2  FID -1820.14   161.11
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 763889856    3  GU* -2285.16  1477.357  4 763889856    3  GU* -2285.16  1477.35
8  8 764811080    7  GU*  1999.93  2390.308  8 764811080    7  GU*  1999.93  2390.30
9  5 839255272    4  GU*  1202.02   486.039  5 839255272    4  GU*  1202.02   486.03
10  6 839262008    5  GU*  -718.91   261.2310  6 839262008    5  GU*  -718.91   261.23
11  7 839262176    6  GU*  -700.00   658.0511  7 839262176    6  GU*  -700.00   658.05
12--- --------- ---- ---- -------- --------12--- --------- ---- ---- -------- --------
13  4 763889856    3  AC* -2285.16  1477.3513  4 763889856    3  AC* -2285.16  1477.35
14  8 764811080    7  AC*  1999.93  2390.3014  8 764811080    7  AC*  1999.93  2390.30
15 11 838341568    2  ACQ -2002.65   214.0015 11 838341568    2  ACQ -2002.65   214.00
16 10 838346224    1  ACQ -1175.02 -1719.5216 10 838346224    1  ACQ -1175.02 -1719.52
17  5 839255272    4  AC*  1202.02   486.0317  5 839255272    4  AC*  1202.02   486.03
18  9 839258264    0  ACQ  1512.34  -407.2918  9 839258264    0  ACQ  1512.34  -407.29
19  6 839262008    5  AC*  -718.91   261.2319  6 839262008    5  AC*  -718.91   261.23
20  7 839262176    6  AC*  -700.00   658.0520  7 839262176    6  AC*  -700.00   658.05
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 22851.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         2    0  FID  -767.07 -1741.10
4  2         4    1  FID  2140.23   166.634  2         4    1  FID  2146.36   167.57
5  3         5    2  FID -1826.28   160.175  3         5    2  FID -1820.14   161.11
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 763889856    3  GU* -2285.16  1477.357  4 763889856    3  GU* -2285.16  1477.35
8  8 764811080    7  GU*  1999.93  2390.308  8 764811080    7  GU*  1999.93  2390.30
9  5 839255272    4  GU*  1202.02   486.039  5 839255272    4  GU*  1202.02   486.03
10  6 839262008    5  GU*  -718.91   261.2310  6 839262008    5  GU*  -718.91   261.23
11  7 839262176    6  GU*  -700.00   658.0511  7 839262176    6  GU*  -700.00   658.05
12--- --------- ---- ---- -------- --------12--- --------- ---- ---- -------- --------
13  4 763889856    3  AC* -2285.16  1477.3513  4 763889856    3  AC* -2285.16  1477.35
14  8 764811080    7  AC*  1999.93  2390.3014  8 764811080    7  AC*  1999.93  2390.30
15 11 838341568    2  ACQ -2002.65   214.0015 11 838341568    2  ACQ -2002.65   214.00
16 10 838346224    1  ACQ -1175.02 -1719.5216 10 838346224    1  ACQ -1175.02 -1719.52
17  5 839255272    4  AC*  1202.02   486.0317  5 839255272    4  AC*  1202.02   486.03
18  9 839258264    0  ACQ  1512.34  -407.2918  9 839258264    0  ACQ  1512.34  -407.29
19  6 839262008    5  AC*  -718.91   261.2319  6 839262008    5  AC*  -718.91   261.23
20  7 839262176    6  AC*  -700.00   658.0520  7 839262176    6  AC*  -700.00   658.05
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222851222851
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.48 < 4.04Critical: OR count of guide stars 3.48 < 4.0
5Critical: guide_count 3.48 and dither > 4x4 arcsec5Critical: guide_count 3.48 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
222851222851
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.48 < 4.04Critical: OR count of guide stars 3.48 < 4.0
5Critical: guide_count 3.48 and dither > 4x4 arcsec5Critical: guide_count 3.48 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 27394.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          1    0  FID   919.83  -844.17t3  1          1    0  FID   925.94  -846.90
4  2          3    1  FID    37.19  -977.244  2          3    1  FID    43.30  -979.96
5  3          5    2  FID -1828.23  1053.815  3          5    2  FID -1822.11  1051.09
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  6 1055263328    5  GU*  1588.90  1144.437  6 1055263328    5  GU*  1588.90  1144.43
8  8 1055266912    7  GU*  -496.02  1828.288  8 1055266912    7  GU*  -496.02  1828.28
9  5 1055267536    4  GU*   869.07   865.939  5 1055267536    4  GU*   869.07   865.93
10  4 1055268728    3  GU*   186.48  1560.2110  4 1055268728    3  GU*   186.48  1560.21
11  7 1056183096    6  GU*  -509.58 -1118.7211  7 1056183096    6  GU*  -509.58 -1118.72
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13  6 1055263328    5  AC*  1588.90  1144.4313  6 1055263328    5  AC*  1588.90  1144.43
14  9 1055264408    0  ACQ -1887.37   741.3614  9 1055264408    0  ACQ -1887.37   741.36
15  8 1055266912    7  AC*  -496.02  1828.2815  8 1055266912    7  AC*  -496.02  1828.28
16  5 1055267536    4  AC*   869.07   865.9316  5 1055267536    4  AC*   869.07   865.93
17  4 1055268728    3  AC*   186.48  1560.2117  4 1055268728    3  AC*   186.48  1560.21
18 10 1056179824    1  ACQ -2193.69 -1936.8118 10 1056179824    1  ACQ -2193.69 -1936.81
19 11 1056182896    2  ACQ   641.93 -2246.0719 11 1056182896    2  ACQ   641.93 -2246.07
20  7 1056183096    6  AC*  -509.58 -1118.7220  7 1056183096    6  AC*  -509.58 -1118.72
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 27394.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          1    0  FID   919.83  -844.17t3  1          1    0  FID   925.94  -846.90
4  2          3    1  FID    37.19  -977.244  2          3    1  FID    43.30  -979.96
5  3          5    2  FID -1828.23  1053.815  3          5    2  FID -1822.11  1051.09
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  6 1055263328    5  GU*  1588.90  1144.437  6 1055263328    5  GU*  1588.90  1144.43
8  8 1055266912    7  GU*  -496.02  1828.288  8 1055266912    7  GU*  -496.02  1828.28
9  5 1055267536    4  GU*   869.07   865.939  5 1055267536    4  GU*   869.07   865.93
10  4 1055268728    3  GU*   186.48  1560.2110  4 1055268728    3  GU*   186.48  1560.21
11  7 1056183096    6  GU*  -509.58 -1118.7211  7 1056183096    6  GU*  -509.58 -1118.72
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13  6 1055263328    5  AC*  1588.90  1144.4313  6 1055263328    5  AC*  1588.90  1144.43
14  9 1055264408    0  ACQ -1887.37   741.3614  9 1055264408    0  ACQ -1887.37   741.36
15  8 1055266912    7  AC*  -496.02  1828.2815  8 1055266912    7  AC*  -496.02  1828.28
16  5 1055267536    4  AC*   869.07   865.9316  5 1055267536    4  AC*   869.07   865.93
17  4 1055268728    3  AC*   186.48  1560.2117  4 1055268728    3  AC*   186.48  1560.21
18 10 1056179824    1  ACQ -2193.69 -1936.8118 10 1056179824    1  ACQ -2193.69 -1936.81
19 11 1056182896    2  ACQ   641.93 -2246.0719 11 1056182896    2  ACQ   641.93 -2246.07
20  7 1056183096    6  AC*  -509.58 -1118.7220  7 1056183096    6  AC*  -509.58 -1118.72
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
227394227394
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.18 < 4.04Critical: OR count of guide stars 3.18 < 4.0

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
227394227394
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.18 < 4.04Critical: OR count of guide stars 3.18 < 4.0

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 27477.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         1    0  FID   950.83 -1729.97
4  2         4    1  FID  2140.23   166.634  2         2    1  FID  -744.96 -1734.11
5  3         6    2  FID   388.59   803.755  3         6    2  FID   416.83   811.68
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  7 768606952    6  GU* -1332.39  -857.307  7 768606952    6  GU* -1332.39  -857.30
8  6 768607024    5  GU* -1509.06 -1022.638  6 768607024    5  GU* -1509.06 -1022.63
9  4 768613752    3  GU* -1984.37  1326.369  4 768613752    3  GU* -1984.37  1326.36
10  5 768737456    4  GU*   417.81 -2270.2910  5 768737456    4  GU*   417.81 -2270.29
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  7 768606952    6  AC* -1332.39  -857.3012  7 768606952    6  AC* -1332.39  -857.30
13  6 768607024    5  AC* -1509.06 -1022.6313  6 768607024    5  AC* -1509.06 -1022.63
14  8 768608592    0  ACQ   -99.78  -907.0214  8 768608592    0  ACQ   -99.78  -907.02
15 10 768611824    2  ACQ -1773.36   641.7115 10 768611824    2  ACQ -1773.36   641.71
16  4 768613752    3  AC* -1984.37  1326.3616  4 768613752    3  AC* -1984.37  1326.36
17 11 768614072    7  ACQ -1620.00   -31.2217 11 768614072    7  ACQ -1620.00   -31.22
18  5 768737456    4  AC*   417.81 -2270.2918  5 768737456    4  AC*   417.81 -2270.29
19  9 768744032    1  ACQ  2257.74   748.6819  9 768744032    1  ACQ  2257.74   748.68
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 27477.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         1    0  FID   950.83 -1729.97
4  2         4    1  FID  2140.23   166.634  2         2    1  FID  -744.96 -1734.11
5  3         6    2  FID   388.59   803.755  3         6    2  FID   416.83   811.68
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  7 768606952    6  GU* -1332.39  -857.307  7 768606952    6  GU* -1332.39  -857.30
8  6 768607024    5  GU* -1509.06 -1022.638  6 768607024    5  GU* -1509.06 -1022.63
9  4 768613752    3  GU* -1984.37  1326.369  4 768613752    3  GU* -1984.37  1326.36
10  5 768737456    4  GU*   417.81 -2270.2910  5 768737456    4  GU*   417.81 -2270.29
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  7 768606952    6  AC* -1332.39  -857.3012  7 768606952    6  AC* -1332.39  -857.30
13  6 768607024    5  AC* -1509.06 -1022.6313  6 768607024    5  AC* -1509.06 -1022.63
14  8 768608592    0  ACQ   -99.78  -907.0214  8 768608592    0  ACQ   -99.78  -907.02
15 10 768611824    2  ACQ -1773.36   641.7115 10 768611824    2  ACQ -1773.36   641.71
16  4 768613752    3  AC* -1984.37  1326.3616  4 768613752    3  AC* -1984.37  1326.36
17 11 768614072    7  ACQ -1620.00   -31.2217 11 768614072    7  ACQ -1620.00   -31.22
18  5 768737456    4  AC*   417.81 -2270.2918  5 768737456    4  AC*   417.81 -2270.29
19  9 768744032    1  ACQ  2257.74   748.6819  9 768744032    1  ACQ  2257.74   748.68
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
227477227477
3-------------------------------3-------------------------------
4Critical: Guide indexes [6, 7] clustered within 500\" radius (man_angle_next > 5.0)4Critical: Guide indexes [6, 7] clustered within 500\" radius (man_angle_next > 5.0)

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
227477227477
3-------------------------------3-------------------------------
4Critical: Guide indexes [6, 7] clustered within 500\" radius (man_angle_next > 5.0)4Critical: Guide indexes [6, 7] clustered within 500\" radius (man_angle_next > 5.0)

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 27537.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          2    0  FID  -773.20 -1742.03t3  1          2    0  FID  -764.82 -1743.38
4  2          4    1  FID  2140.23   166.634  2          4    1  FID  2148.61   165.28
5  3          5    2  FID -1826.28   160.175  3          5    2  FID -1817.89   158.82
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  4 1154352872    3  GU*  -649.78 -2113.277  4 1154352872    3  GU*  -649.78 -2113.27
8  5 1154483104    4  GU*  1103.76  -701.878  5 1154483104    4  GU*  1103.76  -701.87
9  7 1154483776    6  GU* -1221.11    11.109  7 1154483776    6  GU* -1221.11    11.10
10  6 1154486312    5  GU* -1466.68  2142.7710  6 1154486312    5  GU* -1466.68  2142.77
11  8 1154486424    7  GUI -1874.84   928.2611  8 1154486424    7  GUI -1874.84   928.26
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13 11 1154352456    2  ACQ  -178.86 -1104.2313 11 1154352456    2  ACQ  -178.86 -1104.23
14 12 1154352712    7  ACQ -1596.19  -466.9114 12 1154352712    7  ACQ -1596.19  -466.91
15  4 1154352872    3  AC*  -649.78 -2113.2715  4 1154352872    3  AC*  -649.78 -2113.27
16  5 1154483104    4  AC*  1103.76  -701.8716  5 1154483104    4  AC*  1103.76  -701.87
17  9 1154483480    0  ACQ -1035.92   346.7817  9 1154483480    0  ACQ -1035.92   346.78
18  7 1154483776    6  AC* -1221.11    11.1018  7 1154483776    6  AC* -1221.11    11.10
19  6 1154486312    5  AC* -1466.68  2142.7719  6 1154486312    5  AC* -1466.68  2142.77
20 10 1154875896    1  ACQ  1398.12 -1323.6020 10 1154875896    1  ACQ  1398.12 -1323.60
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 27537.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          2    0  FID  -773.20 -1742.03t3  1          2    0  FID  -764.82 -1743.38
4  2          4    1  FID  2140.23   166.634  2          4    1  FID  2148.61   165.28
5  3          5    2  FID -1826.28   160.175  3          5    2  FID -1817.89   158.82
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  4 1154352872    3  GU*  -649.78 -2113.277  4 1154352872    3  GU*  -649.78 -2113.27
8  5 1154483104    4  GU*  1103.76  -701.878  5 1154483104    4  GU*  1103.76  -701.87
9  7 1154483776    6  GU* -1221.11    11.109  7 1154483776    6  GU* -1221.11    11.10
10  6 1154486312    5  GU* -1466.68  2142.7710  6 1154486312    5  GU* -1466.68  2142.77
11  8 1154486424    7  GUI -1874.84   928.2611  8 1154486424    7  GUI -1874.84   928.26
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13 11 1154352456    2  ACQ  -178.86 -1104.2313 11 1154352456    2  ACQ  -178.86 -1104.23
14 12 1154352712    7  ACQ -1596.19  -466.9114 12 1154352712    7  ACQ -1596.19  -466.91
15  4 1154352872    3  AC*  -649.78 -2113.2715  4 1154352872    3  AC*  -649.78 -2113.27
16  5 1154483104    4  AC*  1103.76  -701.8716  5 1154483104    4  AC*  1103.76  -701.87
17  9 1154483480    0  ACQ -1035.92   346.7817  9 1154483480    0  ACQ -1035.92   346.78
18  7 1154483776    6  AC* -1221.11    11.1018  7 1154483776    6  AC* -1221.11    11.10
19  6 1154486312    5  AC* -1466.68  2142.7719  6 1154486312    5  AC* -1466.68  2142.77
20 10 1154875896    1  ACQ  1398.12 -1323.6020 10 1154875896    1  ACQ  1398.12 -1323.60
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
227537227537
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.69 < 4.04Critical: OR count of guide stars 3.69 < 4.0
5Critical: guide_count 3.69 and dither > 4x4 arcsec5Critical: guide_count 3.69 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
t1-------------------------------t1-------------------------------
227537227537
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.69 < 4.04Critical: OR count of guide stars 3.69 < 4.0
5Critical: guide_count 3.69 and dither > 4x4 arcsec5Critical: guide_count 3.69 and dither > 4x4 arcsec

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 28048.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          1    0  FID -1175.03  -468.23t3  1          1    0  FID -1156.85  -465.28
4  2          3    1  FID -1177.69   561.304  2          2    1  FID  1242.89  -457.98
5  3          4    2  FID  1223.32   563.705  3          3    2  FID -1159.51   564.25
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  8 1032066000    7  GU* -1400.85 -1938.607  8 1032066000    7  GU* -1400.85 -1938.60
8  4 1033781448    3  GU* -1722.02  -323.058  4 1033781448    3  GU* -1722.02  -323.05
9  5 1034300880    4  GU*   522.18  -208.249  5 1034300880    4  GU*   522.18  -208.24
10  7 1034314520    6  GU*  2095.28  -491.0510  7 1034314520    6  GU*  2095.28  -491.05
11  6 1034323016    5  GU*  1015.18 -1108.9811  6 1034323016    5  GU*  1015.18 -1108.98
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13  8 1032066000    7  AC* -1400.85 -1938.6013  8 1032066000    7  AC* -1400.85 -1938.60
14  9 1032591016    0  ACQ  1559.23 -1946.4214  9 1032591016    0  ACQ  1559.23 -1946.42
15 11 1033780008    2  ACQ -1498.72  1058.6515 11 1033780008    2  ACQ -1498.72  1058.65
16  4 1033781448    3  AC* -1722.02  -323.0516  4 1033781448    3  AC* -1722.02  -323.05
17 10 1034292264    1  ACQ  -354.14  1450.6017 10 1034292264    1  ACQ  -354.14  1450.60
18  5 1034300880    4  AC*   522.18  -208.2418  5 1034300880    4  AC*   522.18  -208.24
19  7 1034314520    6  AC*  2095.28  -491.0519  7 1034314520    6  AC*  2095.28  -491.05
20  6 1034323016    5  AC*  1015.18 -1108.9820  6 1034323016    5  AC*  1015.18 -1108.98
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

Obsid 28048.0

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          1    0  FID -1175.03  -468.23t3  1          1    0  FID -1156.85  -465.28
4  2          3    1  FID -1177.69   561.304  2          2    1  FID  1242.89  -457.98
5  3          4    2  FID  1223.32   563.705  3          3    2  FID -1159.51   564.25
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  8 1032066000    7  GU* -1400.85 -1938.607  8 1032066000    7  GU* -1400.85 -1938.60
8  4 1033781448    3  GU* -1722.02  -323.058  4 1033781448    3  GU* -1722.02  -323.05
9  5 1034300880    4  GU*   522.18  -208.249  5 1034300880    4  GU*   522.18  -208.24
10  7 1034314520    6  GU*  2095.28  -491.0510  7 1034314520    6  GU*  2095.28  -491.05
11  6 1034323016    5  GU*  1015.18 -1108.9811  6 1034323016    5  GU*  1015.18 -1108.98
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13  8 1032066000    7  AC* -1400.85 -1938.6013  8 1032066000    7  AC* -1400.85 -1938.60
14  9 1032591016    0  ACQ  1559.23 -1946.4214  9 1032591016    0  ACQ  1559.23 -1946.42
15 11 1033780008    2  ACQ -1498.72  1058.6515 11 1033780008    2  ACQ -1498.72  1058.65
16  4 1033781448    3  AC* -1722.02  -323.0516  4 1033781448    3  AC* -1722.02  -323.05
17 10 1034292264    1  ACQ  -354.14  1450.6017 10 1034292264    1  ACQ  -354.14  1450.60
18  5 1034300880    4  AC*   522.18  -208.2418  5 1034300880    4  AC*   522.18  -208.24
19  7 1034314520    6  AC*  2095.28  -491.0519  7 1034314520    6  AC*  2095.28  -491.05
20  6 1034323016    5  AC*  1015.18 -1108.9820  6 1034323016    5  AC*  1015.18 -1108.98
\n", + " \n", + " \n", + " \n", + " \n", + "
Legends
\n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tt1-------------------------------
228048
3-------------------------------
4Critical: Fid 2 has red spoiler: star 1034304216 with mag 10.56

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

CRITICALS

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tt1-------------------------------
228048
3-------------------------------
4Critical: Fid 2 has red spoiler: star 1034304216 with mag 10.56

\n", + " Legends \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Colors
 Added 
Changed
Deleted
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Links
(f)irst change
(n)ext change
(t)op
\n", + " \n", + "\n", + "\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "obs_criticals = []\n", + "obs_diff_ids = []\n", + "for obsid in obsids:\n", + " # get rows from dat to get source load name\n", + " rows = dat[dat['obsid'] == obsid]\n", + " diff_catalog, diff_criticals, has_criticals, has_diff_ids = process_obsid(obsid, rows['source'][0])\n", + " if has_criticals:\n", + " obs_criticals.append((obsid, rows['source'][0]))\n", + " display(diff_catalog)\n", + " display(diff_criticals)\n", + " if has_diff_ids:\n", + " obs_diff_ids.append((obsid, rows['source'][0]))\n", + " break\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The catalog review shows unrelated critical warnings that did not change in guide stars, and one new critical warning on a fid light spoiler. Acceptable." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ska3-flight", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 5595c4c002814b82ccee2f20f4f084bd14850770 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Thu, 30 Nov 2023 12:58:29 -0500 Subject: [PATCH 09/38] Add a couple of comments to the fid review notebook --- analysis/reselect_fid_offset.ipynb | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/analysis/reselect_fid_offset.ipynb b/analysis/reselect_fid_offset.ipynb index e5145de8..771ce633 100644 --- a/analysis/reselect_fid_offset.ipynb +++ b/analysis/reselect_fid_offset.ipynb @@ -329,6 +329,13 @@ " " ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Confirm new proseco positions with the fid offsets applied are closer to observed fid light positions over three \"epochs\" and ~900 observations." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -605,6 +612,13 @@ "print(len(obsids))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Confirm reselected catalogs with and without the fid position updates are still reasonable catalogs without critical errors." + ] + }, { "cell_type": "code", "execution_count": 27, From af53856dc4f5ae44e7d15dd5744436e08c80aa7c Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Tue, 5 Dec 2023 15:43:16 -0500 Subject: [PATCH 10/38] Update docs/index.rst Co-authored-by: Tom Aldcroft --- docs/index.rst | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/index.rst b/docs/index.rst index ed5a3563..295caad4 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -318,11 +318,11 @@ The following environment variables are used by proseco: - ``PROSECO_PRINT_OBC_CAT``: if set then create and print a debug catalog while doing catalog merging. - ``PROSECO_ENABLE_FID_OFFSET``: controls application of time and temperature dependent fid - light positions offsets. These are conditionally applied in `proseco.fid.get_fid_positions`. - If var set to ``"False"`` then do not apply the time and temperature to the catalog positions - (should not be used in production). If set to ``"True"`` `get_fid_positions` will apply offsets - and throw an error if the time and temperature are not available. If set to `None`, the default, - then `get_fid_positions` will apply offsets if the time and temperature are available. + light position offsets (from the ACA drift model) in :ref:`~proseco.fid.get_fid_positions`: + - Not set: apply offsets if time and temperature are provided (as is done in ``proseco`` fid + selection since version 5.12.0) + - ``"True"``: require that time and temperature be provided and apply offsets. + - ``"False"``: do not apply offsets (typically used in regression testing not production). - ``SKA``: root directory that contains 'data' directory API docs From e97c59359c8ee6d36e96e3c131d52736018f2173 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Tue, 5 Dec 2023 15:43:46 -0500 Subject: [PATCH 11/38] Update proseco/fid.py in fid position docs Co-authored-by: Tom Aldcroft --- proseco/fid.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proseco/fid.py b/proseco/fid.py index 0df855bc..0d61c865 100644 --- a/proseco/fid.py +++ b/proseco/fid.py @@ -505,7 +505,7 @@ def get_fid_positions( yfid=-SIfield.fidpos(:,1)/(SIfield.focallength-xshift); zfid=-zshift/(SIfield.focallength-xshift); - This function also applies a temperature-dependent fid offset if t_ccd and date + This function also applies a temperature-dependent fid offset if ``t_ccd`` and ``date`` are supplied and the PROSECO_ENABLE_FID_OFFSET env var is 'True' or None. :param detector: 'ACIS-S' | 'ACIS-I' | 'HRC-S' | 'HRC-I' From b37bd204606acadc6fdd5e5d9fd71cfd6f9d2777 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Tue, 5 Dec 2023 15:44:09 -0500 Subject: [PATCH 12/38] Update proseco/fid.py ValueError text Co-authored-by: Tom Aldcroft --- proseco/fid.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proseco/fid.py b/proseco/fid.py index 0d61c865..5c1390fc 100644 --- a/proseco/fid.py +++ b/proseco/fid.py @@ -539,7 +539,7 @@ def get_fid_positions( enable_fid_offset_env = os.environ.get("PROSECO_ENABLE_FID_OFFSET") if enable_fid_offset_env not in ("True", "False", None): raise ValueError( - f'PROSECO_ENABLE_FID_OFFSET env var must be either "True", "False", or None, ' + f'PROSECO_ENABLE_FID_OFFSET env var must be either "True", "False", or not set, ' f"got {enable_fid_offset_env}" ) From a7325d31cc876e23c3724b0ae7e0e2ee28c925b9 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Tue, 5 Dec 2023 15:44:39 -0500 Subject: [PATCH 13/38] Update proseco/fid.py get_fid_position docs Co-authored-by: Tom Aldcroft --- proseco/fid.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proseco/fid.py b/proseco/fid.py index 5c1390fc..94368243 100644 --- a/proseco/fid.py +++ b/proseco/fid.py @@ -506,7 +506,7 @@ def get_fid_positions( zfid=-zshift/(SIfield.focallength-xshift); This function also applies a temperature-dependent fid offset if ``t_ccd`` and ``date`` - are supplied and the PROSECO_ENABLE_FID_OFFSET env var is 'True' or None. + are supplied and the ``PROSECO_ENABLE_FID_OFFSET`` env var is ``"True"`` or not set. :param detector: 'ACIS-S' | 'ACIS-I' | 'HRC-S' | 'HRC-I' :param focus_offset: SIM focus offset [steps] From eed0380d7d50496ae2bf520cd14b08df2805bc0a Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Tue, 5 Dec 2023 16:16:48 -0500 Subject: [PATCH 14/38] Simplify PROSECO_ENABLE_FID_OFFSET handling Co-authored-by: Tom Aldcroft --- proseco/fid.py | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/proseco/fid.py b/proseco/fid.py index 94368243..b2fd04ad 100644 --- a/proseco/fid.py +++ b/proseco/fid.py @@ -543,19 +543,16 @@ def get_fid_positions( f"got {enable_fid_offset_env}" ) - # If enable_fid_offset_env is None or True then try to apply an offset - if not enable_fid_offset_env or enable_fid_offset_env == "True": - # Require that t_ccd and date are provided if fid offset is enabled - if enable_fid_offset_env == "True" and (t_ccd is None or date is None): - raise ValueError( - "t_ccd_acq and date must be provided if PROSECO_ENABLE_FID_OFFSET is 'True'" - ) + has_tccd_and_date = t_ccd is not None and date is not None + + if enable_fid_offset_env == "True" and not has_tccd_and_date: + raise ValueError( + "t_ccd_acq and date must be provided if PROSECO_ENABLE_FID_OFFSET is 'True'" + ) - # Apply fid offset if t_ccd and date are provided - # (this is an "if" the case when enable_fid_offset_env is None) - if t_ccd is not None and date is not None: - dy, dz = get_fid_offset(date, t_ccd) - yang += dy - zang += dz + if has_tccd_and_date and enable_fid_offset_env != "False": + dy, dz = get_fid_offset(date, t_ccd) + yang += dy + zang += dz return yang, zang From d27e70a4b246f2b17b6ba8494ad2808143d20def Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Thu, 7 Dec 2023 14:53:47 -0500 Subject: [PATCH 15/38] Move supplement disable to conftest.py --- proseco/tests/conftest.py | 5 +++++ proseco/tests/test_acq.py | 3 --- proseco/tests/test_catalog.py | 3 --- proseco/tests/test_fid.py | 3 --- proseco/tests/test_guide.py | 3 --- proseco/tests/test_mon_full_cat.py | 3 --- 6 files changed, 5 insertions(+), 15 deletions(-) diff --git a/proseco/tests/conftest.py b/proseco/tests/conftest.py index 769fedbd..390787f7 100644 --- a/proseco/tests/conftest.py +++ b/proseco/tests/conftest.py @@ -1,4 +1,5 @@ import pytest +import agasc from agasc import get_agasc_filename @@ -11,6 +12,10 @@ def use_fixed_chandra_models(monkeypatch): def disable_fid_drift(monkeypatch): monkeypatch.setenv("PROSECO_ENABLE_FID_OFFSET", "False") +@pytest.fixture(autouse=True) +def disable_agasc_supplement(monkeypatch): + monkeypatch.setenv(agasc.SUPPLEMENT_ENABLED_ENV, "False") + # By default test with the latest AGASC version available including release candidates @pytest.fixture(autouse=True) diff --git a/proseco/tests/test_acq.py b/proseco/tests/test_acq.py index 20301448..f388675b 100644 --- a/proseco/tests/test_acq.py +++ b/proseco/tests/test_acq.py @@ -34,9 +34,6 @@ CACHE = {} # Cache stuff for speed TEST_COLS = ("idx", "slot", "id", "yang", "zang", "halfw") -# Do not use the AGASC supplement in testing by default since mags can change -os.environ[agasc.SUPPLEMENT_ENABLED_ENV] = "False" - def calc_p_brightest(acq, box_size, stars, dark, man_err=0, dither=20, bgd=0): """ diff --git a/proseco/tests/test_catalog.py b/proseco/tests/test_catalog.py index ffeb5580..8af2f5d9 100644 --- a/proseco/tests/test_catalog.py +++ b/proseco/tests/test_catalog.py @@ -24,9 +24,6 @@ HAS_SC_ARCHIVE = Path(mica.starcheck.starcheck.FILES["data_root"]).exists() TEST_COLS = "slot idx id type sz yang zang dim res halfw".split() -# Do not use the AGASC supplement in testing by default since mags can change -os.environ[agasc.SUPPLEMENT_ENABLED_ENV] = "False" - HAS_MAG_SUPPLEMENT = len(agasc.get_supplement_table("mags")) > 0 diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index 76b190ed..2ef916b7 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -15,9 +15,6 @@ os.environ["PROSECO_ENABLE_FID_OFFSET"] = "False" FIDS = get_fid_catalog(stars=StarsTable.empty(), **STD_INFO) -# Do not use the AGASC supplement in testing by default since mags can change -os.environ[agasc.SUPPLEMENT_ENABLED_ENV] = "False" - def test_get_fid_position(): """ diff --git a/proseco/tests/test_guide.py b/proseco/tests/test_guide.py index e9beea13..f079a155 100644 --- a/proseco/tests/test_guide.py +++ b/proseco/tests/test_guide.py @@ -30,9 +30,6 @@ HAS_SC_ARCHIVE = Path(mica.starcheck.starcheck.FILES["data_root"]).exists() -# Do not use the AGASC supplement in testing by default since mags can change -os.environ[agasc.SUPPLEMENT_ENABLED_ENV] = "False" - def test_select(proseco_agasc_1p7): """ diff --git a/proseco/tests/test_mon_full_cat.py b/proseco/tests/test_mon_full_cat.py index 49b9787a..f8bed146 100644 --- a/proseco/tests/test_mon_full_cat.py +++ b/proseco/tests/test_mon_full_cat.py @@ -18,9 +18,6 @@ HAS_SC_ARCHIVE = Path(mica.starcheck.starcheck.FILES["data_root"]).exists() TEST_COLS = "slot idx id type sz yang zang dim res halfw".split() -# Do not use the AGASC supplement in testing by default since mags can change -os.environ[agasc.SUPPLEMENT_ENABLED_ENV] = "False" - @pytest.fixture def stars(): From a688570f8f52e3126146a00f14f8ee1ee69f4538 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Thu, 7 Dec 2023 15:15:00 -0500 Subject: [PATCH 16/38] Update warning test with newer text --- proseco/tests/test_fid.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index 2ef916b7..0d1ae499 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -91,7 +91,7 @@ def test_get_fid_pos_with_offsets(monkeypatch): # Confirm an error if env var set to not-allowed value monkeypatch.setenv("PROSECO_ENABLE_FID_OFFSET", "foo") with pytest.raises( - ValueError, match='env var must be either "True", "False", or None,' + ValueError, match='env var must be either "True", "False", or not set,' ): get_fid_positions( "ACIS-S", focus_offset=0.0, sim_offset=0.0, t_ccd=-13.65, date="2023:235" From ceb3c26642f194646143168edc166129ccf45cc6 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Thu, 7 Dec 2023 15:20:16 -0500 Subject: [PATCH 17/38] Don't rely on the fixture value for offset tests --- proseco/tests/test_fid.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index 0d1ae499..4003a66a 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -50,7 +50,7 @@ def test_get_fid_position(): def test_get_fid_pos_with_offsets(monkeypatch): # Confirm that if env var is set to 'False' then no offset is applied. - # Env var is set to false in the fixture. + monkeypatch.setenv("PROSECO_ENABLE_FID_OFFSET", "False") yang1, zang1 = get_fid_positions("ACIS-S", focus_offset=0.0, sim_offset=0.0) # Confirm that if env var is set to 'True' and t_ccd and date are specified, then From 6ed6d97af5d42011c2f1bf7aaf41a91c4114562e Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Thu, 7 Dec 2023 15:20:37 -0500 Subject: [PATCH 18/38] Split off the throw-error fid offset tests --- proseco/tests/test_fid.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index 4003a66a..ac7bd26f 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -82,6 +82,8 @@ def test_get_fid_pos_with_offsets(monkeypatch): assert np.allclose(yang1, yang4, rtol=0, atol=0.1) assert np.allclose(zang1, zang4, rtol=0, atol=0.1) + +def test_get_fid_pos_errors(monkeypatch): # Confirm if env var is set to 'True' and t_ccd and date not specified, then # there's an error. monkeypatch.setenv("PROSECO_ENABLE_FID_OFFSET", "True") From 6d560f85998df8f709e5b8d4e460b37aaeb040d2 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Thu, 7 Dec 2023 15:37:53 -0500 Subject: [PATCH 19/38] Update some equality tests to actually test that --- proseco/tests/test_fid.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index ac7bd26f..cd2b612a 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -68,8 +68,8 @@ def test_get_fid_pos_with_offsets(monkeypatch): yang3, zang3 = get_fid_positions( "ACIS-S", focus_offset=0.0, sim_offset=0.0, date="2023:235", t_ccd=-13.65 ) - assert np.allclose(yang2, yang3, rtol=0, atol=0.1) - assert np.allclose(zang2, zang3, rtol=0, atol=0.1) + assert np.all(yang2 == yang3) + assert np.all(zang2 == zang3) # Confirm that if env var is not set and t_ccd and date not specified, then # no offset is applied. @@ -79,8 +79,8 @@ def test_get_fid_pos_with_offsets(monkeypatch): focus_offset=0.0, sim_offset=0.0, ) - assert np.allclose(yang1, yang4, rtol=0, atol=0.1) - assert np.allclose(zang1, zang4, rtol=0, atol=0.1) + assert np.all(yang1 == yang4) + assert np.all(zang1 == zang4) def test_get_fid_pos_errors(monkeypatch): From 421b3c968f5be85b1a6f140bf850d1af56c4d11d Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Fri, 8 Dec 2023 14:27:19 -0500 Subject: [PATCH 20/38] Update get_fid_catalog call in add_fake_stars_from_fid --- proseco/core.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/proseco/core.py b/proseco/core.py index 167ffb72..869b9fdd 100644 --- a/proseco/core.py +++ b/proseco/core.py @@ -1487,7 +1487,8 @@ def add_fake_stars_from_fid( detector=detector, sim_offset=sim_offset, focus_offset=0, - t_ccd=-10.0, + t_ccd_guide=-10.0, + t_ccd_acq=-10.0, date="2018:001", dither=8.0, ) From 0be47e82f763477ea8dab0563877fc8b7f79e7f6 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Fri, 8 Dec 2023 14:27:40 -0500 Subject: [PATCH 21/38] Require acquisition temperature in FidTable --- proseco/fid.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/proseco/fid.py b/proseco/fid.py index b2fd04ad..f0eedf00 100644 --- a/proseco/fid.py +++ b/proseco/fid.py @@ -97,6 +97,7 @@ class FidTable(ACACatalogTable): "detector", "sim_offset", "focus_offset", + "t_ccd_acq", "t_ccd_guide", "date", "dither_acq", @@ -125,7 +126,7 @@ def acqs(self, val): @property def t_ccd(self): - # For fids use the guide CCD temperature + # For fids use the guide CCD temperature to scale the dark map return self.t_ccd_guide @t_ccd.setter From 27071d11b252efbf7ef8e7f3298b4724b250450b Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Fri, 8 Dec 2023 14:28:00 -0500 Subject: [PATCH 22/38] Remove fixture to disable fid offsets --- proseco/tests/conftest.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/proseco/tests/conftest.py b/proseco/tests/conftest.py index 390787f7..13bf0d9b 100644 --- a/proseco/tests/conftest.py +++ b/proseco/tests/conftest.py @@ -8,10 +8,6 @@ def use_fixed_chandra_models(monkeypatch): monkeypatch.setenv("CHANDRA_MODELS_DEFAULT_VERSION", "3.48") -@pytest.fixture(autouse=True) -def disable_fid_drift(monkeypatch): - monkeypatch.setenv("PROSECO_ENABLE_FID_OFFSET", "False") - @pytest.fixture(autouse=True) def disable_agasc_supplement(monkeypatch): monkeypatch.setenv(agasc.SUPPLEMENT_ENABLED_ENV, "False") From 8e25a0bba43733aa73e68dbd9d17f2b7d3c2b777 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Fri, 8 Dec 2023 14:28:34 -0500 Subject: [PATCH 23/38] Supply acq and guide temperature in test_common --- proseco/tests/test_common.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/proseco/tests/test_common.py b/proseco/tests/test_common.py index eb033735..8ca599c7 100644 --- a/proseco/tests/test_common.py +++ b/proseco/tests/test_common.py @@ -11,7 +11,8 @@ date="2018:001", n_guide=5, n_fid=3, - t_ccd=-11, + t_ccd_acq=-11, + t_ccd_guide=-11, man_angle=90, dither=8.0, ) From e9a3e162529c5699236693cfe48c65e42e85dd21 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Fri, 8 Dec 2023 14:30:07 -0500 Subject: [PATCH 24/38] Disable fid offsets in one acq test --- proseco/tests/test_acq.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/proseco/tests/test_acq.py b/proseco/tests/test_acq.py index f388675b..97504e30 100644 --- a/proseco/tests/test_acq.py +++ b/proseco/tests/test_acq.py @@ -843,11 +843,16 @@ def get_dark_stars_simple(box_size_thresh, dither): return dark, stars -def test_acq_fid_catalog_probs_low_level(): +def test_acq_fid_catalog_probs_low_level(monkeypatch): """ Low-level tests of machinery to handle different fid light sets within acquisition probabilities. """ + + # Disable fid offsets for this specific test which has been set up to spoil + # fids at not-offset-corrected positions + monkeypatch.setenv("PROSECO_ENABLE_FID_OFFSET", "False") + # Put an acq star at an offset from fid light id=2 such that for a search # box size larger than box_size_thresh, that star will be spoiled. This # uses the equation in FidTable.spoils(). From 2b0e3a1deb0384cf048ccff861d35cb0f7d786a5 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Fri, 8 Dec 2023 14:31:36 -0500 Subject: [PATCH 25/38] Update fid positions in exp/regress values to offset positions --- proseco/tests/test_catalog.py | 25 ++++++++++--------- proseco/tests/test_fid.py | 40 ++++++++++++++---------------- proseco/tests/test_mon_full_cat.py | 6 ++--- 3 files changed, 35 insertions(+), 36 deletions(-) diff --git a/proseco/tests/test_catalog.py b/proseco/tests/test_catalog.py index 8af2f5d9..4809b50c 100644 --- a/proseco/tests/test_catalog.py +++ b/proseco/tests/test_catalog.py @@ -97,12 +97,13 @@ def test_get_aca_catalog_20603(proseco_agasc_1p7): img_size_guide=6, raise_exc=True, ) + # Expected 2 fids, 4 guide, 7 acq exp = [ "slot idx id type sz yang zang dim res halfw", "---- --- --------- ---- --- -------- -------- --- --- -----", - " 0 1 4 FID 8x8 2140.23 166.63 1 1 25", - " 1 2 5 FID 8x8 -1826.28 160.17 1 1 25", + " 0 1 4 FID 8x8 2136.87 163.42 1 1 25", + " 1 2 5 FID 8x8 -1829.63 156.96 1 1 25", " 2 3 116791824 BOT 6x6 622.00 -953.60 28 1 160", " 3 4 40114416 BOT 6x6 394.22 1204.43 24 1 140", " 4 5 40112304 BOT 6x6 -1644.35 2032.47 12 1 80", @@ -142,9 +143,9 @@ def test_get_aca_catalog_20259(proseco_agasc_1p7): exp = [ "slot idx id type sz yang zang dim res halfw", "---- --- --------- ---- --- -------- -------- --- --- -----", - " 0 1 1 FID 8x8 -1175.03 -468.23 1 1 25", - " 1 2 2 FID 8x8 1224.70 -460.93 1 1 25", - " 2 3 3 FID 8x8 -1177.69 561.30 1 1 25", + " 0 1 1 FID 8x8 -1176.88 -470.85 1 1 25", + " 1 2 2 FID 8x8 1222.86 -463.55 1 1 25", + " 2 3 3 FID 8x8 -1179.54 558.68 1 1 25", " 3 4 896009152 BOT 6x6 1693.39 217.92 16 1 100", " 4 5 897712576 BOT 6x6 -1099.95 2140.23 12 1 80", " 5 6 897717296 BOT 6x6 932.58 1227.48 12 1 80", @@ -565,7 +566,8 @@ def test_call_args_attr(): "obsid": 0, "optimize": False, "sim_offset": 0, - "t_ccd": -11, + "t_ccd_acq": -11, + "t_ccd_guide": -11, } @@ -731,8 +733,8 @@ def offset(id, drow, dcol, dmag, rmult=1): def test_dark_property(): """ - Test that in the case of a common t_ccd, all the dark current maps are - actually the same object. + Test that appropriate temperatures are applied to acq, fid, guide + dark maps. :return: None """ @@ -741,7 +743,6 @@ def test_dark_property(): assert aca.dark is getattr(aca, attr).dark kwargs = STD_INFO.copy() - del kwargs["t_ccd"] kwargs["t_ccd_acq"] = -12.5 kwargs["t_ccd_guide"] = -11.5 aca = get_aca_catalog(**kwargs) @@ -763,9 +764,9 @@ def test_dense_star_field_regress(proseco_agasc_1p7): exp = [ "slot idx id type sz yang zang dim res halfw mag ", "---- --- ---------- ---- --- -------- -------- --- --- ----- -----", - " 0 1 3 FID 8x8 40.01 -1871.10 1 1 25 7.00", - " 1 2 4 FID 8x8 2140.23 166.63 1 1 25 7.00", - " 2 3 5 FID 8x8 -1826.28 160.17 1 1 25 7.00", + " 0 1 3 FID 8x8 35.52 -1874.72 1 1 25 7.00", + " 1 2 4 FID 8x8 2135.73 163.01 1 1 25 7.00", + " 2 3 5 FID 8x8 -1830.77 156.55 1 1 25 7.00", " 3 4 1130899056 BOT 8x8 2386.83 -1808.51 28 1 160 6.24", " 4 5 1130889232 BOT 8x8 -251.98 -1971.97 28 1 160 6.99", " 5 6 1130893664 BOT 8x8 1530.07 -2149.38 28 1 160 7.62", diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index cd2b612a..5e5ac23f 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -10,9 +10,7 @@ from ..fid import get_fid_catalog, get_fid_positions from .test_common import DARK40, OBS_INFO, STD_INFO, mod_std_info -# Reference fid positions for spoiling tests. Because this is done outside -# a test the fixture to generally disable fid drift is not in effect. -os.environ["PROSECO_ENABLE_FID_OFFSET"] = "False" +# Reference fid positions for spoiling tests. FIDS = get_fid_catalog(stars=StarsTable.empty(), **STD_INFO) @@ -107,12 +105,12 @@ def test_get_initial_catalog(): " id yang zang row col mag spoiler_score idx slot", "int64 float64 float64 float64 float64 float64 int64 int64 int64", "----- -------- -------- ------- ------- ------- ------------- ----- -----", - " 1 922.59 -1737.89 -180.05 -344.10 7.00 0 0 -99", - " 2 -773.20 -1742.03 160.79 -345.35 7.00 0 1 0", - " 3 40.01 -1871.10 -2.67 -371.00 7.00 0 2 -99", - " 4 2140.23 166.63 -424.51 39.13 7.00 0 3 1", - " 5 -1826.28 160.17 372.97 36.47 7.00 0 4 2", - " 6 388.59 803.75 -71.49 166.10 7.00 0 5 -99", + " 1 918.09 -1741.51 -179.15 -344.83 7.00 0 0 -99", + " 2 -777.70 -1745.65 161.69 -346.09 7.00 0 1 0", + " 3 35.52 -1874.72 -1.77 -371.73 7.00 0 2 -99", + " 4 2135.73 163.01 -423.60 38.40 7.00 0 3 1", + " 5 -1830.77 156.55 373.88 35.74 7.00 0 4 2", + " 6 384.10 800.13 -70.59 165.37 7.00 0 5 -99", ] assert repr(FIDS.cand_fids).splitlines() == exp assert np.all(FIDS["id"] == [2, 4, 5]) @@ -132,12 +130,12 @@ def test_get_initial_catalog(): " id yang zang row col mag spoiler_score idx slot", "int64 float64 float64 float64 float64 float64 int64 int64 int64", "----- -------- -------- ------- ------- ------- ------------- ----- -----", - " 1 922.59 -1737.89 -180.05 -344.10 7.00 4 0 -99", - " 2 -773.20 -1742.03 160.79 -345.35 7.00 4 1 -99", - " 3 40.01 -1871.10 -2.67 -371.00 7.00 0 2 0", - " 4 2140.23 166.63 -424.51 39.13 7.00 0 3 1", - " 5 -1826.28 160.17 372.97 36.47 7.00 0 4 2", - " 6 388.59 803.75 -71.49 166.10 7.00 0 5 -99", + " 1 918.09 -1741.51 -179.15 -344.83 7.00 4 0 -99", + " 2 -777.70 -1745.65 161.69 -346.09 7.00 4 1 -99", + " 3 35.52 -1874.72 -1.77 -371.73 7.00 0 2 0", + " 4 2135.73 163.01 -423.60 38.40 7.00 0 3 1", + " 5 -1830.77 156.55 373.88 35.74 7.00 0 4 2", + " 6 384.10 800.13 -70.59 165.37 7.00 0 5 -99", ] assert repr(fids2.cand_fids).splitlines() == exp assert np.all(fids2["id"] == [3, 4, 5]) @@ -199,12 +197,12 @@ def test_fid_spoiling_acq(dither_z): " id yang zang row col mag spoiler_score idx slot", "int64 float64 float64 float64 float64 float64 int64 int64 int64", "----- -------- -------- ------- ------- ------- ------------- ----- -----", - " 1 922.59 -1737.89 -180.05 -344.10 7.00 0 0 0", - " 2 -773.20 -1742.03 160.79 -345.35 7.00 0 1 -99", - " 3 40.01 -1871.10 -2.67 -371.00 7.00 0 2 -99", - " 4 2140.23 166.63 -424.51 39.13 7.00 0 3 -99", - " 5 -1826.28 160.17 372.97 36.47 7.00 0 4 1", - " 6 388.59 803.75 -71.49 166.10 7.00 0 5 2", + " 1 918.09 -1741.51 -179.15 -344.83 7.00 0 0 0", + " 2 -777.70 -1745.65 161.69 -346.09 7.00 0 1 -99", + " 3 35.52 -1874.72 -1.77 -371.73 7.00 0 2 -99", + " 4 2135.73 163.01 -423.60 38.40 7.00 0 3 -99", + " 5 -1830.77 156.55 373.88 35.74 7.00 0 4 1", + " 6 384.10 800.13 -70.59 165.37 7.00 0 5 2", ] assert repr(fids5.cand_fids).splitlines() == exp diff --git a/proseco/tests/test_mon_full_cat.py b/proseco/tests/test_mon_full_cat.py index f8bed146..1d89ac4f 100644 --- a/proseco/tests/test_mon_full_cat.py +++ b/proseco/tests/test_mon_full_cat.py @@ -75,8 +75,8 @@ def test_monitor_mon_fixed_auto(proseco_agasc_1p7): exp = [ "slot idx id type sz yang zang dim res halfw", "---- --- --------- ---- --- -------- -------- --- --- -----", - " 0 1 4 FID 8x8 2140.23 166.63 1 1 25", - " 1 2 5 FID 8x8 -1826.28 160.17 1 1 25", + " 0 1 4 FID 8x8 2135.73 163.01 1 1 25", + " 1 2 5 FID 8x8 -1830.77 156.55 1 1 25", " 2 3 611190016 BOT 8x8 175.44 -1297.92 28 1 160", " 3 4 139192 BOT 8x8 587.27 802.49 28 1 160", " 7 5 611192384 BOT 8x8 1053.38 -275.16 28 1 160", @@ -138,7 +138,7 @@ def test_full_catalog(): exp = [ "slot idx id type sz yang zang dim res halfw mag ", "---- --- ------ ---- --- -------- -------- --- --- ----- -----", - " 0 1 1 FID 8x8 922.59 -1737.89 1 1 25 7.00", + " 0 1 1 FID 8x8 918.09 -1741.51 1 1 25 7.00", " 1 2 100007 BOT 8x8 -750.00 -750.00 28 1 160 7.00", " 2 3 100006 BOT 8x8 -750.00 750.00 28 1 160 7.50", " 3 4 100005 BOT 8x8 750.00 -750.00 28 1 160 8.00", From 7a299d013e23accf029458b80fd4c8617b3a14d5 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Fri, 8 Dec 2023 14:36:00 -0500 Subject: [PATCH 26/38] Remove unused imports --- proseco/tests/test_catalog.py | 1 - proseco/tests/test_fid.py | 3 --- proseco/tests/test_mon_full_cat.py | 2 -- 3 files changed, 6 deletions(-) diff --git a/proseco/tests/test_catalog.py b/proseco/tests/test_catalog.py index 4809b50c..48322152 100644 --- a/proseco/tests/test_catalog.py +++ b/proseco/tests/test_catalog.py @@ -1,6 +1,5 @@ # Licensed under a 3-clause BSD style license - see LICENSE.rst import copy -import os import pickle from pathlib import Path diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index 5e5ac23f..fc10c8e3 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -1,6 +1,3 @@ -import os - -import agasc import numpy as np import pytest diff --git a/proseco/tests/test_mon_full_cat.py b/proseco/tests/test_mon_full_cat.py index 1d89ac4f..1b8909df 100644 --- a/proseco/tests/test_mon_full_cat.py +++ b/proseco/tests/test_mon_full_cat.py @@ -1,8 +1,6 @@ # Licensed under a 3-clause BSD style license - see LICENSE.rst -import os from pathlib import Path -import agasc import mica.starcheck import numpy as np import pytest From b5fcc0877bf8379c03306212faca7c2ab57c8db7 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Fri, 8 Dec 2023 14:55:15 -0500 Subject: [PATCH 27/38] Use a FIDS test fixture --- proseco/tests/test_fid.py | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index fc10c8e3..cd7c7222 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -7,8 +7,11 @@ from ..fid import get_fid_catalog, get_fid_positions from .test_common import DARK40, OBS_INFO, STD_INFO, mod_std_info -# Reference fid positions for spoiling tests. -FIDS = get_fid_catalog(stars=StarsTable.empty(), **STD_INFO) + +# Reference fid positions for tests. +@pytest.fixture(scope="module") +def FIDS(): + return get_fid_catalog(stars=StarsTable.empty(), **STD_INFO) def test_get_fid_position(): @@ -95,7 +98,7 @@ def test_get_fid_pos_errors(monkeypatch): ) -def test_get_initial_catalog(): +def test_get_initial_catalog(FIDS): """Test basic catalog with no stars in field using standard 2-4-5 config.""" exp = [ "", @@ -155,7 +158,7 @@ def test_n_fid(): @pytest.mark.parametrize("dither_z", [8, 64]) -def test_fid_spoiling_acq(dither_z): +def test_fid_spoiling_acq(dither_z, FIDS): """Test fid spoiling acq. Check fid spoiling acq: @@ -230,7 +233,7 @@ def test_dither_as_sequence(): assert fids.dither_guide == (8, 22) -def test_fid_spoiler_score(): +def test_fid_spoiler_score(FIDS): """Test computing the fid spoiler score.""" dither_y = 8 dither_z = 64 @@ -257,7 +260,7 @@ def test_big_sim_offset(): assert all(name in fids.colnames for name in names) -def test_fid_hot_pixel_reject(): +def test_fid_hot_pixel_reject(FIDS): """Test hot pixel rejecting a fid""" lim = FID.hot_pixel_spoiler_limit dark = DARK40.copy() From ef377fa313739751040270902c7e83433803dd1b Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Fri, 8 Dec 2023 14:59:48 -0500 Subject: [PATCH 28/38] Rename notebooks --- ...fsets.ipynb => pr388-backstop-vs-proseco-star-positions.ipynb} | 0 ...ffset.ipynb => pr388-validate-drift-model-fid-positions.ipynb} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename analysis/{backstop_offsets.ipynb => pr388-backstop-vs-proseco-star-positions.ipynb} (100%) rename analysis/{reselect_fid_offset.ipynb => pr388-validate-drift-model-fid-positions.ipynb} (100%) diff --git a/analysis/backstop_offsets.ipynb b/analysis/pr388-backstop-vs-proseco-star-positions.ipynb similarity index 100% rename from analysis/backstop_offsets.ipynb rename to analysis/pr388-backstop-vs-proseco-star-positions.ipynb diff --git a/analysis/reselect_fid_offset.ipynb b/analysis/pr388-validate-drift-model-fid-positions.ipynb similarity index 100% rename from analysis/reselect_fid_offset.ipynb rename to analysis/pr388-validate-drift-model-fid-positions.ipynb From 3761755562f6c742f7df0322e593e9de053c55eb Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Fri, 8 Dec 2023 16:17:33 -0500 Subject: [PATCH 29/38] Rerun validation notebook --- ...8-validate-drift-model-fid-positions.ipynb | 1160 ++++++++--------- 1 file changed, 580 insertions(+), 580 deletions(-) diff --git a/analysis/pr388-validate-drift-model-fid-positions.ipynb b/analysis/pr388-validate-drift-model-fid-positions.ipynb index 771ce633..b0e3bb5c 100644 --- a/analysis/pr388-validate-drift-model-fid-positions.ipynb +++ b/analysis/pr388-validate-drift-model-fid-positions.ipynb @@ -18,8 +18,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "4.42.1.dev13+gcf5cbc1\n", - "5.11.1.dev7+g56d76a1.d20231130\n" + "4.44.1.dev12+gb259754\n", + "5.11.1.dev28+gef377fa\n" ] } ], @@ -571,7 +571,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -621,7 +621,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -650,31 +650,31 @@ "\n", "

Obsid 22200.0

\n", "\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   934.86  -839.01
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1813.19  1058.98
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   400.85  1703.02
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   145.33  1635.817  5 548932512    4  GU*   145.33  1635.81
8  4 548933960    3  GU*   977.82 -1527.828  4 548933960    3  GU*   977.82 -1527.82
9  7 548937184    6  GU*  -393.18  -599.469  7 548937184    6  GU*  -393.18  -599.46
10  6 549850840    5  GU* -2220.93  2113.5010  6 549850840    5  GU* -2220.93  2113.50
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   145.33  1635.8112  5 548932512    4  AC*   145.33  1635.81
13 10 548933288    2  ACQ  1087.69 -1711.3113 10 548933288    2  ACQ  1087.69 -1711.31
14  4 548933960    3  AC*   977.82 -1527.8214  4 548933960    3  AC*   977.82 -1527.82
15 11 548934440    7  ACQ   169.93 -2011.1315 11 548934440    7  ACQ   169.93 -2011.13
16  8 548935824    0  ACQ   577.14  2331.3016  8 548935824    0  ACQ   577.14  2331.30
17  7 548937184    6  AC*  -393.18  -599.4617  7 548937184    6  AC*  -393.18  -599.46
18  9 548938256    1  ACQ -1953.39 -1455.8418  9 548938256    1  ACQ -1953.39 -1455.84
19  6 549850840    5  AC* -2220.93  2113.5019  6 549850840    5  AC* -2220.93  2113.50
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   934.86  -839.01
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1813.19  1058.98
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   400.85  1703.02
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   145.33  1635.817  5 548932512    4  GU*   145.33  1635.81
8  4 548933960    3  GU*   977.82 -1527.828  4 548933960    3  GU*   977.82 -1527.82
9  7 548937184    6  GU*  -393.18  -599.469  7 548937184    6  GU*  -393.18  -599.46
10  6 549850840    5  GU* -2220.93  2113.5010  6 549850840    5  GU* -2220.93  2113.50
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   145.33  1635.8112  5 548932512    4  AC*   145.33  1635.81
13 10 548933288    2  ACQ  1087.69 -1711.3113 10 548933288    2  ACQ  1087.69 -1711.31
14  4 548933960    3  AC*   977.82 -1527.8214  4 548933960    3  AC*   977.82 -1527.82
15 11 548934440    7  ACQ   169.93 -2011.1315 11 548934440    7  ACQ   169.93 -2011.13
16  8 548935824    0  ACQ   577.14  2331.3016  8 548935824    0  ACQ   577.14  2331.30
17  7 548937184    6  AC*  -393.18  -599.4617  7 548937184    6  AC*  -393.18  -599.46
18  9 548938256    1  ACQ -1953.39 -1455.8418  9 548938256    1  ACQ -1953.39 -1455.84
19  6 549850840    5  AC* -2220.93  2113.5019  6 549850840    5  AC* -2220.93  2113.50
\n", " \n", @@ -720,31 +720,31 @@ "\n", "

Obsid 22200.0

\n", "\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   934.86  -839.01
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1813.19  1058.98
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   400.85  1703.02
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   145.33  1635.817  5 548932512    4  GU*   145.33  1635.81
8  4 548933960    3  GU*   977.82 -1527.828  4 548933960    3  GU*   977.82 -1527.82
9  7 548937184    6  GU*  -393.18  -599.469  7 548937184    6  GU*  -393.18  -599.46
10  6 549850840    5  GU* -2220.93  2113.5010  6 549850840    5  GU* -2220.93  2113.50
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   145.33  1635.8112  5 548932512    4  AC*   145.33  1635.81
13 10 548933288    2  ACQ  1087.69 -1711.3113 10 548933288    2  ACQ  1087.69 -1711.31
14  4 548933960    3  AC*   977.82 -1527.8214  4 548933960    3  AC*   977.82 -1527.82
15 11 548934440    7  ACQ   169.93 -2011.1315 11 548934440    7  ACQ   169.93 -2011.13
16  8 548935824    0  ACQ   577.14  2331.3016  8 548935824    0  ACQ   577.14  2331.30
17  7 548937184    6  AC*  -393.18  -599.4617  7 548937184    6  AC*  -393.18  -599.46
18  9 548938256    1  ACQ -1953.39 -1455.8418  9 548938256    1  ACQ -1953.39 -1455.84
19  6 549850840    5  AC* -2220.93  2113.5019  6 549850840    5  AC* -2220.93  2113.50
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   934.86  -839.01
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1813.19  1058.98
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   400.85  1703.02
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   145.33  1635.817  5 548932512    4  GU*   145.33  1635.81
8  4 548933960    3  GU*   977.82 -1527.828  4 548933960    3  GU*   977.82 -1527.82
9  7 548937184    6  GU*  -393.18  -599.469  7 548937184    6  GU*  -393.18  -599.46
10  6 549850840    5  GU* -2220.93  2113.5010  6 549850840    5  GU* -2220.93  2113.50
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   145.33  1635.8112  5 548932512    4  AC*   145.33  1635.81
13 10 548933288    2  ACQ  1087.69 -1711.3113 10 548933288    2  ACQ  1087.69 -1711.31
14  4 548933960    3  AC*   977.82 -1527.8214  4 548933960    3  AC*   977.82 -1527.82
15 11 548934440    7  ACQ   169.93 -2011.1315 11 548934440    7  ACQ   169.93 -2011.13
16  8 548935824    0  ACQ   577.14  2331.3016  8 548935824    0  ACQ   577.14  2331.30
17  7 548937184    6  AC*  -393.18  -599.4617  7 548937184    6  AC*  -393.18  -599.46
18  9 548938256    1  ACQ -1953.39 -1455.8418  9 548938256    1  ACQ -1953.39 -1455.84
19  6 549850840    5  AC* -2220.93  2113.5019  6 549850840    5  AC* -2220.93  2113.50
\n", " \n", @@ -796,17 +796,17 @@ "\n", "\n", "

CRITICALS

\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222200222200
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.93 < 4.04Critical: OR count of guide stars 3.93 < 4.0
5Critical: guide_count 3.93 and dither > 4x4 arcsec5Critical: guide_count 3.93 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222200222200
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.93 < 4.04Critical: OR count of guide stars 3.93 < 4.0
5Critical: guide_count 3.93 and dither > 4x4 arcsec5Critical: guide_count 3.93 and dither > 4x4 arcsec

\n", @@ -852,17 +852,17 @@ "\n", "\n", "

CRITICALS

\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222200222200
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.93 < 4.04Critical: OR count of guide stars 3.93 < 4.0
5Critical: guide_count 3.93 and dither > 4x4 arcsec5Critical: guide_count 3.93 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222200222200
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.93 < 4.04Critical: OR count of guide stars 3.93 < 4.0
5Critical: guide_count 3.93 and dither > 4x4 arcsec5Critical: guide_count 3.93 and dither > 4x4 arcsec

\n", @@ -914,31 +914,31 @@ "\n", "

Obsid 22264.0

\n", "\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   928.36  -842.04
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.70  1055.95
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   394.34  1699.99
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   126.21  1636.917  5 548932512    4  GU*   126.21  1636.91
8  4 548933960    3  GU*   996.12 -1516.648  4 548933960    3  GU*   996.12 -1516.64
9  7 548937184    6  GU*  -385.77  -604.589  7 548937184    6  GU*  -385.77  -604.58
10  6 549850840    5  GU* -2245.53  2086.5410  6 549850840    5  GU* -2245.53  2086.54
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   126.21  1636.9112  5 548932512    4  AC*   126.21  1636.91
13 10 548933720    2  ACQ  1590.55  1585.4913 10 548933720    2  ACQ  1590.55  1585.49
14  4 548933960    3  AC*   996.12 -1516.6414  4 548933960    3  AC*   996.12 -1516.64
15 11 548934440    7  ACQ   194.02 -2009.4915 11 548934440    7  ACQ   194.02 -2009.49
16  8 548935824    0  ACQ   549.75  2337.4716  8 548935824    0  ACQ   549.75  2337.47
17  7 548937184    6  AC*  -385.77  -604.5817  7 548937184    6  AC*  -385.77  -604.58
18  9 548938256    1  ACQ -1935.73 -1479.3818  9 548938256    1  ACQ -1935.73 -1479.38
19  6 549850840    5  AC* -2245.53  2086.5419  6 549850840    5  AC* -2245.53  2086.54
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   928.36  -842.04
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.70  1055.95
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   394.34  1699.99
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   126.21  1636.917  5 548932512    4  GU*   126.21  1636.91
8  4 548933960    3  GU*   996.12 -1516.648  4 548933960    3  GU*   996.12 -1516.64
9  7 548937184    6  GU*  -385.77  -604.589  7 548937184    6  GU*  -385.77  -604.58
10  6 549850840    5  GU* -2245.53  2086.5410  6 549850840    5  GU* -2245.53  2086.54
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   126.21  1636.9112  5 548932512    4  AC*   126.21  1636.91
13 10 548933720    2  ACQ  1590.55  1585.4913 10 548933720    2  ACQ  1590.55  1585.49
14  4 548933960    3  AC*   996.12 -1516.6414  4 548933960    3  AC*   996.12 -1516.64
15 11 548934440    7  ACQ   194.02 -2009.4915 11 548934440    7  ACQ   194.02 -2009.49
16  8 548935824    0  ACQ   549.75  2337.4716  8 548935824    0  ACQ   549.75  2337.47
17  7 548937184    6  AC*  -385.77  -604.5817  7 548937184    6  AC*  -385.77  -604.58
18  9 548938256    1  ACQ -1935.73 -1479.3818  9 548938256    1  ACQ -1935.73 -1479.38
19  6 549850840    5  AC* -2245.53  2086.5419  6 549850840    5  AC* -2245.53  2086.54
\n", " \n", @@ -984,31 +984,31 @@ "\n", "

Obsid 22264.0

\n", "\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   928.36  -842.04
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.70  1055.95
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   394.34  1699.99
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   126.21  1636.917  5 548932512    4  GU*   126.21  1636.91
8  4 548933960    3  GU*   996.12 -1516.648  4 548933960    3  GU*   996.12 -1516.64
9  7 548937184    6  GU*  -385.77  -604.589  7 548937184    6  GU*  -385.77  -604.58
10  6 549850840    5  GU* -2245.53  2086.5410  6 549850840    5  GU* -2245.53  2086.54
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   126.21  1636.9112  5 548932512    4  AC*   126.21  1636.91
13 10 548933720    2  ACQ  1590.55  1585.4913 10 548933720    2  ACQ  1590.55  1585.49
14  4 548933960    3  AC*   996.12 -1516.6414  4 548933960    3  AC*   996.12 -1516.64
15 11 548934440    7  ACQ   194.02 -2009.4915 11 548934440    7  ACQ   194.02 -2009.49
16  8 548935824    0  ACQ   549.75  2337.4716  8 548935824    0  ACQ   549.75  2337.47
17  7 548937184    6  AC*  -385.77  -604.5817  7 548937184    6  AC*  -385.77  -604.58
18  9 548938256    1  ACQ -1935.73 -1479.3818  9 548938256    1  ACQ -1935.73 -1479.38
19  6 549850840    5  AC* -2245.53  2086.5419  6 549850840    5  AC* -2245.53  2086.54
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   928.36  -842.04
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.70  1055.95
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   394.34  1699.99
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   126.21  1636.917  5 548932512    4  GU*   126.21  1636.91
8  4 548933960    3  GU*   996.12 -1516.648  4 548933960    3  GU*   996.12 -1516.64
9  7 548937184    6  GU*  -385.77  -604.589  7 548937184    6  GU*  -385.77  -604.58
10  6 549850840    5  GU* -2245.53  2086.5410  6 549850840    5  GU* -2245.53  2086.54
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   126.21  1636.9112  5 548932512    4  AC*   126.21  1636.91
13 10 548933720    2  ACQ  1590.55  1585.4913 10 548933720    2  ACQ  1590.55  1585.49
14  4 548933960    3  AC*   996.12 -1516.6414  4 548933960    3  AC*   996.12 -1516.64
15 11 548934440    7  ACQ   194.02 -2009.4915 11 548934440    7  ACQ   194.02 -2009.49
16  8 548935824    0  ACQ   549.75  2337.4716  8 548935824    0  ACQ   549.75  2337.47
17  7 548937184    6  AC*  -385.77  -604.5817  7 548937184    6  AC*  -385.77  -604.58
18  9 548938256    1  ACQ -1935.73 -1479.3818  9 548938256    1  ACQ -1935.73 -1479.38
19  6 549850840    5  AC* -2245.53  2086.5419  6 549850840    5  AC* -2245.53  2086.54
\n", " \n", @@ -1060,17 +1060,17 @@ "\n", "\n", "

CRITICALS

\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222264222264
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.98 < 4.04Critical: OR count of guide stars 3.98 < 4.0
5Critical: guide_count 3.98 and dither > 4x4 arcsec5Critical: guide_count 3.98 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222264222264
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.98 < 4.04Critical: OR count of guide stars 3.98 < 4.0
5Critical: guide_count 3.98 and dither > 4x4 arcsec5Critical: guide_count 3.98 and dither > 4x4 arcsec

\n", @@ -1116,17 +1116,17 @@ "\n", "\n", "

CRITICALS

\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222264222264
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.98 < 4.04Critical: OR count of guide stars 3.98 < 4.0
5Critical: guide_count 3.98 and dither > 4x4 arcsec5Critical: guide_count 3.98 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222264222264
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.98 < 4.04Critical: OR count of guide stars 3.98 < 4.0
5Critical: guide_count 3.98 and dither > 4x4 arcsec5Critical: guide_count 3.98 and dither > 4x4 arcsec

\n", @@ -1178,31 +1178,31 @@ "\n", "

Obsid 22265.0

\n", "\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   929.01  -841.73
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.04  1056.26
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   395.00  1700.29
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   125.33  1636.507  5 548932512    4  GU*   125.33  1636.50
8  4 548933960    3  GU*   995.24 -1517.058  4 548933960    3  GU*   995.24 -1517.05
9  7 548937184    6  GU*  -386.65  -604.999  7 548937184    6  GU*  -386.65  -604.99
10  6 549850840    5  GU* -2246.41  2086.1310  6 549850840    5  GU* -2246.41  2086.13
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   125.33  1636.5012  5 548932512    4  AC*   125.33  1636.50
13  9 548933288    1  ACQ  1107.28 -1699.2213  9 548933288    1  ACQ  1107.28 -1699.22
14 10 548933720    2  ACQ  1589.67  1585.0814 10 548933720    2  ACQ  1589.67  1585.08
15  4 548933960    3  AC*   995.24 -1517.0515  4 548933960    3  AC*   995.24 -1517.05
16 11 548934440    7  ACQ   193.14 -2009.9016 11 548934440    7  ACQ   193.14 -2009.90
17  7 548937184    6  AC*  -386.65  -604.9917  7 548937184    6  AC*  -386.65  -604.99
18  8 548938256    0  ACQ -1936.61 -1479.7918  8 548938256    0  ACQ -1936.61 -1479.79
19  6 549850840    5  AC* -2246.41  2086.1319  6 549850840    5  AC* -2246.41  2086.13
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   929.01  -841.73
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.04  1056.26
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   395.00  1700.29
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   125.33  1636.507  5 548932512    4  GU*   125.33  1636.50
8  4 548933960    3  GU*   995.24 -1517.058  4 548933960    3  GU*   995.24 -1517.05
9  7 548937184    6  GU*  -386.65  -604.999  7 548937184    6  GU*  -386.65  -604.99
10  6 549850840    5  GU* -2246.41  2086.1310  6 549850840    5  GU* -2246.41  2086.13
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   125.33  1636.5012  5 548932512    4  AC*   125.33  1636.50
13  9 548933288    1  ACQ  1107.28 -1699.2213  9 548933288    1  ACQ  1107.28 -1699.22
14 10 548933720    2  ACQ  1589.67  1585.0814 10 548933720    2  ACQ  1589.67  1585.08
15  4 548933960    3  AC*   995.24 -1517.0515  4 548933960    3  AC*   995.24 -1517.05
16 11 548934440    7  ACQ   193.14 -2009.9016 11 548934440    7  ACQ   193.14 -2009.90
17  7 548937184    6  AC*  -386.65  -604.9917  7 548937184    6  AC*  -386.65  -604.99
18  8 548938256    0  ACQ -1936.61 -1479.7918  8 548938256    0  ACQ -1936.61 -1479.79
19  6 549850840    5  AC* -2246.41  2086.1319  6 549850840    5  AC* -2246.41  2086.13
\n", " \n", @@ -1248,31 +1248,31 @@ "\n", "

Obsid 22265.0

\n", "\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   929.01  -841.73
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.04  1056.26
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   395.00  1700.29
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   125.33  1636.507  5 548932512    4  GU*   125.33  1636.50
8  4 548933960    3  GU*   995.24 -1517.058  4 548933960    3  GU*   995.24 -1517.05
9  7 548937184    6  GU*  -386.65  -604.999  7 548937184    6  GU*  -386.65  -604.99
10  6 549850840    5  GU* -2246.41  2086.1310  6 549850840    5  GU* -2246.41  2086.13
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   125.33  1636.5012  5 548932512    4  AC*   125.33  1636.50
13  9 548933288    1  ACQ  1107.28 -1699.2213  9 548933288    1  ACQ  1107.28 -1699.22
14 10 548933720    2  ACQ  1589.67  1585.0814 10 548933720    2  ACQ  1589.67  1585.08
15  4 548933960    3  AC*   995.24 -1517.0515  4 548933960    3  AC*   995.24 -1517.05
16 11 548934440    7  ACQ   193.14 -2009.9016 11 548934440    7  ACQ   193.14 -2009.90
17  7 548937184    6  AC*  -386.65  -604.9917  7 548937184    6  AC*  -386.65  -604.99
18  8 548938256    0  ACQ -1936.61 -1479.7918  8 548938256    0  ACQ -1936.61 -1479.79
19  6 549850840    5  AC* -2246.41  2086.1319  6 549850840    5  AC* -2246.41  2086.13
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   929.01  -841.73
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.04  1056.26
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   395.00  1700.29
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 548932512    4  GU*   125.33  1636.507  5 548932512    4  GU*   125.33  1636.50
8  4 548933960    3  GU*   995.24 -1517.058  4 548933960    3  GU*   995.24 -1517.05
9  7 548937184    6  GU*  -386.65  -604.999  7 548937184    6  GU*  -386.65  -604.99
10  6 549850840    5  GU* -2246.41  2086.1310  6 549850840    5  GU* -2246.41  2086.13
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  5 548932512    4  AC*   125.33  1636.5012  5 548932512    4  AC*   125.33  1636.50
13  9 548933288    1  ACQ  1107.28 -1699.2213  9 548933288    1  ACQ  1107.28 -1699.22
14 10 548933720    2  ACQ  1589.67  1585.0814 10 548933720    2  ACQ  1589.67  1585.08
15  4 548933960    3  AC*   995.24 -1517.0515  4 548933960    3  AC*   995.24 -1517.05
16 11 548934440    7  ACQ   193.14 -2009.9016 11 548934440    7  ACQ   193.14 -2009.90
17  7 548937184    6  AC*  -386.65  -604.9917  7 548937184    6  AC*  -386.65  -604.99
18  8 548938256    0  ACQ -1936.61 -1479.7918  8 548938256    0  ACQ -1936.61 -1479.79
19  6 549850840    5  AC* -2246.41  2086.1319  6 549850840    5  AC* -2246.41  2086.13
\n", " \n", @@ -1324,17 +1324,17 @@ "\n", "\n", "

CRITICALS

\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222265222265
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.89 < 4.04Critical: OR count of guide stars 3.89 < 4.0
5Critical: guide_count 3.89 and dither > 4x4 arcsec5Critical: guide_count 3.89 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222265222265
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.89 < 4.04Critical: OR count of guide stars 3.89 < 4.0
5Critical: guide_count 3.89 and dither > 4x4 arcsec5Critical: guide_count 3.89 and dither > 4x4 arcsec

\n", @@ -1380,17 +1380,17 @@ "\n", "\n", "

CRITICALS

\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222265222265
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.89 < 4.04Critical: OR count of guide stars 3.89 < 4.0
5Critical: guide_count 3.89 and dither > 4x4 arcsec5Critical: guide_count 3.89 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222265222265
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.89 < 4.04Critical: OR count of guide stars 3.89 < 4.0
5Critical: guide_count 3.89 and dither > 4x4 arcsec5Critical: guide_count 3.89 and dither > 4x4 arcsec

\n", @@ -1442,31 +1442,31 @@ "\n", "

Obsid 22733.0

\n", "\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   931.11  -840.80
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1816.94  1057.18
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   397.10  1701.22
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 548933960    3  GU*  -477.93 -1808.927  4 548933960    3  GU*  -477.93 -1808.92
8  7 548937184    6  GU*  -838.41  -192.928  7 548937184    6  GU*  -838.41  -192.92
9  5 549849072    4  GU* -1547.46  2204.339  5 549849072    4  GU* -1547.46  2204.33
10  6 549849656    5  GU*  2453.57  2352.7810  6 549849656    5  GU*  2453.57  2352.78
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  8 548932512    0  ACQ  1086.95  1063.8312  8 548932512    0  ACQ  1086.95  1063.83
13  4 548933960    3  AC*  -477.93 -1808.9213  4 548933960    3  AC*  -477.93 -1808.92
14 11 548935824    7  ACQ  1878.27  1273.5914 11 548935824    7  ACQ  1878.27  1273.59
15  9 548936840    1  ACQ  -475.37 -1685.3615  9 548936840    1  ACQ  -475.37 -1685.36
16  7 548937184    6  AC*  -838.41  -192.9216  7 548937184    6  AC*  -838.41  -192.92
17 10 548939872    2  ACQ -2301.13   188.7117 10 548939872    2  ACQ -2301.13   188.71
18  5 549849072    4  AC* -1547.46  2204.3318  5 549849072    4  AC* -1547.46  2204.33
19  6 549849656    5  AC*  2453.57  2352.7819  6 549849656    5  AC*  2453.57  2352.78
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   931.11  -840.80
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1816.94  1057.18
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   397.10  1701.22
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 548933960    3  GU*  -477.93 -1808.927  4 548933960    3  GU*  -477.93 -1808.92
8  7 548937184    6  GU*  -838.41  -192.928  7 548937184    6  GU*  -838.41  -192.92
9  5 549849072    4  GU* -1547.46  2204.339  5 549849072    4  GU* -1547.46  2204.33
10  6 549849656    5  GU*  2453.57  2352.7810  6 549849656    5  GU*  2453.57  2352.78
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  8 548932512    0  ACQ  1086.95  1063.8312  8 548932512    0  ACQ  1086.95  1063.83
13  4 548933960    3  AC*  -477.93 -1808.9213  4 548933960    3  AC*  -477.93 -1808.92
14 11 548935824    7  ACQ  1878.27  1273.5914 11 548935824    7  ACQ  1878.27  1273.59
15  9 548936840    1  ACQ  -475.37 -1685.3615  9 548936840    1  ACQ  -475.37 -1685.36
16  7 548937184    6  AC*  -838.41  -192.9216  7 548937184    6  AC*  -838.41  -192.92
17 10 548939872    2  ACQ -2301.13   188.7117 10 548939872    2  ACQ -2301.13   188.71
18  5 549849072    4  AC* -1547.46  2204.3318  5 549849072    4  AC* -1547.46  2204.33
19  6 549849656    5  AC*  2453.57  2352.7819  6 549849656    5  AC*  2453.57  2352.78
\n", " \n", @@ -1512,31 +1512,31 @@ "\n", "

Obsid 22733.0

\n", "\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   931.11  -840.80
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1816.94  1057.18
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   397.10  1701.22
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 548933960    3  GU*  -477.93 -1808.927  4 548933960    3  GU*  -477.93 -1808.92
8  7 548937184    6  GU*  -838.41  -192.928  7 548937184    6  GU*  -838.41  -192.92
9  5 549849072    4  GU* -1547.46  2204.339  5 549849072    4  GU* -1547.46  2204.33
10  6 549849656    5  GU*  2453.57  2352.7810  6 549849656    5  GU*  2453.57  2352.78
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  8 548932512    0  ACQ  1086.95  1063.8312  8 548932512    0  ACQ  1086.95  1063.83
13  4 548933960    3  AC*  -477.93 -1808.9213  4 548933960    3  AC*  -477.93 -1808.92
14 11 548935824    7  ACQ  1878.27  1273.5914 11 548935824    7  ACQ  1878.27  1273.59
15  9 548936840    1  ACQ  -475.37 -1685.3615  9 548936840    1  ACQ  -475.37 -1685.36
16  7 548937184    6  AC*  -838.41  -192.9216  7 548937184    6  AC*  -838.41  -192.92
17 10 548939872    2  ACQ -2301.13   188.7117 10 548939872    2  ACQ -2301.13   188.71
18  5 549849072    4  AC* -1547.46  2204.3318  5 549849072    4  AC* -1547.46  2204.33
19  6 549849656    5  AC*  2453.57  2352.7819  6 549849656    5  AC*  2453.57  2352.78
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   931.11  -840.80
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1816.94  1057.18
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   397.10  1701.22
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 548933960    3  GU*  -477.93 -1808.927  4 548933960    3  GU*  -477.93 -1808.92
8  7 548937184    6  GU*  -838.41  -192.928  7 548937184    6  GU*  -838.41  -192.92
9  5 549849072    4  GU* -1547.46  2204.339  5 549849072    4  GU* -1547.46  2204.33
10  6 549849656    5  GU*  2453.57  2352.7810  6 549849656    5  GU*  2453.57  2352.78
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  8 548932512    0  ACQ  1086.95  1063.8312  8 548932512    0  ACQ  1086.95  1063.83
13  4 548933960    3  AC*  -477.93 -1808.9213  4 548933960    3  AC*  -477.93 -1808.92
14 11 548935824    7  ACQ  1878.27  1273.5914 11 548935824    7  ACQ  1878.27  1273.59
15  9 548936840    1  ACQ  -475.37 -1685.3615  9 548936840    1  ACQ  -475.37 -1685.36
16  7 548937184    6  AC*  -838.41  -192.9216  7 548937184    6  AC*  -838.41  -192.92
17 10 548939872    2  ACQ -2301.13   188.7117 10 548939872    2  ACQ -2301.13   188.71
18  5 549849072    4  AC* -1547.46  2204.3318  5 549849072    4  AC* -1547.46  2204.33
19  6 549849656    5  AC*  2453.57  2352.7819  6 549849656    5  AC*  2453.57  2352.78
\n", " \n", @@ -1588,17 +1588,17 @@ "\n", "\n", "

CRITICALS

\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222733222733
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.90 < 4.04Critical: OR count of guide stars 3.90 < 4.0
5Critical: guide_count 3.90 and dither > 4x4 arcsec5Critical: guide_count 3.90 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222733222733
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.90 < 4.04Critical: OR count of guide stars 3.90 < 4.0
5Critical: guide_count 3.90 and dither > 4x4 arcsec5Critical: guide_count 3.90 and dither > 4x4 arcsec

\n", @@ -1644,17 +1644,17 @@ "\n", "\n", "

CRITICALS

\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222733222733
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.90 < 4.04Critical: OR count of guide stars 3.90 < 4.0
5Critical: guide_count 3.90 and dither > 4x4 arcsec5Critical: guide_count 3.90 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222733222733
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.90 < 4.04Critical: OR count of guide stars 3.90 < 4.0
5Critical: guide_count 3.90 and dither > 4x4 arcsec5Critical: guide_count 3.90 and dither > 4x4 arcsec

\n", @@ -1706,31 +1706,31 @@ "\n", "

Obsid 22734.0

\n", "\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   929.02  -841.78
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.03  1056.20
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   395.00  1700.24
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 548933960    3  GU*  -479.60 -1809.717  4 548933960    3  GU*  -479.60 -1809.71
8  7 548937184    6  GU*  -840.08  -193.718  7 548937184    6  GU*  -840.08  -193.71
9  5 549849072    4  GU* -1549.13  2203.549  5 549849072    4  GU* -1549.13  2203.54
10  6 549849656    5  GU*  2451.90  2351.9910  6 549849656    5  GU*  2451.90  2351.99
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  8 548932512    0  ACQ  1085.28  1063.0412  8 548932512    0  ACQ  1085.28  1063.04
13  4 548933960    3  AC*  -479.60 -1809.7113  4 548933960    3  AC*  -479.60 -1809.71
14 11 548935824    7  ACQ  1876.60  1272.8014 11 548935824    7  ACQ  1876.60  1272.80
15  9 548936840    1  ACQ  -477.04 -1686.1515  9 548936840    1  ACQ  -477.04 -1686.15
16  7 548937184    6  AC*  -840.08  -193.7116  7 548937184    6  AC*  -840.08  -193.71
17 10 548939872    2  ACQ -2302.80   187.9217 10 548939872    2  ACQ -2302.80   187.92
18  5 549849072    4  AC* -1549.13  2203.5418  5 549849072    4  AC* -1549.13  2203.54
19  6 549849656    5  AC*  2451.90  2351.9919  6 549849656    5  AC*  2451.90  2351.99
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   929.02  -841.78
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.03  1056.20
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   395.00  1700.24
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 548933960    3  GU*  -479.60 -1809.717  4 548933960    3  GU*  -479.60 -1809.71
8  7 548937184    6  GU*  -840.08  -193.718  7 548937184    6  GU*  -840.08  -193.71
9  5 549849072    4  GU* -1549.13  2203.549  5 549849072    4  GU* -1549.13  2203.54
10  6 549849656    5  GU*  2451.90  2351.9910  6 549849656    5  GU*  2451.90  2351.99
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  8 548932512    0  ACQ  1085.28  1063.0412  8 548932512    0  ACQ  1085.28  1063.04
13  4 548933960    3  AC*  -479.60 -1809.7113  4 548933960    3  AC*  -479.60 -1809.71
14 11 548935824    7  ACQ  1876.60  1272.8014 11 548935824    7  ACQ  1876.60  1272.80
15  9 548936840    1  ACQ  -477.04 -1686.1515  9 548936840    1  ACQ  -477.04 -1686.15
16  7 548937184    6  AC*  -840.08  -193.7116  7 548937184    6  AC*  -840.08  -193.71
17 10 548939872    2  ACQ -2302.80   187.9217 10 548939872    2  ACQ -2302.80   187.92
18  5 549849072    4  AC* -1549.13  2203.5418  5 549849072    4  AC* -1549.13  2203.54
19  6 549849656    5  AC*  2451.90  2351.9919  6 549849656    5  AC*  2451.90  2351.99
\n", " \n", @@ -1776,31 +1776,31 @@ "\n", "

Obsid 22734.0

\n", "\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   929.02  -841.78
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.03  1056.20
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   395.00  1700.24
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 548933960    3  GU*  -479.60 -1809.717  4 548933960    3  GU*  -479.60 -1809.71
8  7 548937184    6  GU*  -840.08  -193.718  7 548937184    6  GU*  -840.08  -193.71
9  5 549849072    4  GU* -1549.13  2203.549  5 549849072    4  GU* -1549.13  2203.54
10  6 549849656    5  GU*  2451.90  2351.9910  6 549849656    5  GU*  2451.90  2351.99
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  8 548932512    0  ACQ  1085.28  1063.0412  8 548932512    0  ACQ  1085.28  1063.04
13  4 548933960    3  AC*  -479.60 -1809.7113  4 548933960    3  AC*  -479.60 -1809.71
14 11 548935824    7  ACQ  1876.60  1272.8014 11 548935824    7  ACQ  1876.60  1272.80
15  9 548936840    1  ACQ  -477.04 -1686.1515  9 548936840    1  ACQ  -477.04 -1686.15
16  7 548937184    6  AC*  -840.08  -193.7116  7 548937184    6  AC*  -840.08  -193.71
17 10 548939872    2  ACQ -2302.80   187.9217 10 548939872    2  ACQ -2302.80   187.92
18  5 549849072    4  AC* -1549.13  2203.5418  5 549849072    4  AC* -1549.13  2203.54
19  6 549849656    5  AC*  2451.90  2351.9919  6 549849656    5  AC*  2451.90  2351.99
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         1    0  FID   919.83  -844.17t3  1         1    0  FID   929.02  -841.78
4  2         5    1  FID -1828.23  1053.814  2         5    1  FID -1819.03  1056.20
5  3         6    2  FID   385.81  1697.855  3         6    2  FID   395.00  1700.24
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 548933960    3  GU*  -479.60 -1809.717  4 548933960    3  GU*  -479.60 -1809.71
8  7 548937184    6  GU*  -840.08  -193.718  7 548937184    6  GU*  -840.08  -193.71
9  5 549849072    4  GU* -1549.13  2203.549  5 549849072    4  GU* -1549.13  2203.54
10  6 549849656    5  GU*  2451.90  2351.9910  6 549849656    5  GU*  2451.90  2351.99
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  8 548932512    0  ACQ  1085.28  1063.0412  8 548932512    0  ACQ  1085.28  1063.04
13  4 548933960    3  AC*  -479.60 -1809.7113  4 548933960    3  AC*  -479.60 -1809.71
14 11 548935824    7  ACQ  1876.60  1272.8014 11 548935824    7  ACQ  1876.60  1272.80
15  9 548936840    1  ACQ  -477.04 -1686.1515  9 548936840    1  ACQ  -477.04 -1686.15
16  7 548937184    6  AC*  -840.08  -193.7116  7 548937184    6  AC*  -840.08  -193.71
17 10 548939872    2  ACQ -2302.80   187.9217 10 548939872    2  ACQ -2302.80   187.92
18  5 549849072    4  AC* -1549.13  2203.5418  5 549849072    4  AC* -1549.13  2203.54
19  6 549849656    5  AC*  2451.90  2351.9919  6 549849656    5  AC*  2451.90  2351.99
\n", " \n", @@ -1852,17 +1852,17 @@ "\n", "\n", "

CRITICALS

\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222734222734
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.89 < 4.04Critical: OR count of guide stars 3.89 < 4.0
5Critical: guide_count 3.89 and dither > 4x4 arcsec5Critical: guide_count 3.89 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222734222734
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.89 < 4.04Critical: OR count of guide stars 3.89 < 4.0
5Critical: guide_count 3.89 and dither > 4x4 arcsec5Critical: guide_count 3.89 and dither > 4x4 arcsec

\n", @@ -1908,17 +1908,17 @@ "\n", "\n", "

CRITICALS

\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222734222734
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.89 < 4.04Critical: OR count of guide stars 3.89 < 4.0
5Critical: guide_count 3.89 and dither > 4x4 arcsec5Critical: guide_count 3.89 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222734222734
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.89 < 4.04Critical: OR count of guide stars 3.89 < 4.0
5Critical: guide_count 3.89 and dither > 4x4 arcsec5Critical: guide_count 3.89 and dither > 4x4 arcsec

\n", @@ -1970,32 +1970,32 @@ "\n", "

Obsid 22850.0

\n", "\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         2    0  FID  -770.80 -1742.84
4  2         4    1  FID  2140.23   166.634  2         4    1  FID  2142.63   165.82
5  3         5    2  FID -1826.28   160.175  3         5    2  FID -1823.88   159.36
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 763889856    4  GU* -2034.26  1827.497  5 763889856    4  GU* -2034.26  1827.49
8  4 764808424    3  GU*  1641.26  2366.448  4 764808424    3  GU*  1641.26  2366.44
9  6 839255272    5  GU*  1254.94   302.869  6 839255272    5  GU*  1254.94   302.86
10  7 839262008    6  GU*  -677.51   381.3410  7 839262008    6  GU*  -677.51   381.34
11  8 839262176    7  GU*  -596.76   770.3111  8 839262176    7  GU*  -596.76   770.31
12--- --------- ---- ---- -------- --------12--- --------- ---- ---- -------- --------
13  5 763889856    4  AC* -2034.26  1827.4913  5 763889856    4  AC* -2034.26  1827.49
14  4 764808424    3  AC*  1641.26  2366.4414  4 764808424    3  AC*  1641.26  2366.44
15  9 764811080    0  ACQ  2340.89  2058.9015  9 764811080    0  ACQ  2340.89  2058.90
16 11 838346224    2  ACQ -1437.86 -1503.6816 11 838346224    2  ACQ -1437.86 -1503.68
17  6 839255272    5  AC*  1254.94   302.8617  6 839255272    5  AC*  1254.94   302.86
18 10 839258264    1  ACQ  1421.69  -628.0118 10 839258264    1  ACQ  1421.69  -628.01
19  7 839262008    6  AC*  -677.51   381.3419  7 839262008    6  AC*  -677.51   381.34
20  8 839262176    7  AC*  -596.76   770.3120  8 839262176    7  AC*  -596.76   770.31
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         2    0  FID  -770.80 -1742.84
4  2         4    1  FID  2140.23   166.634  2         4    1  FID  2142.63   165.82
5  3         5    2  FID -1826.28   160.175  3         5    2  FID -1823.88   159.36
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 763889856    4  GU* -2034.26  1827.497  5 763889856    4  GU* -2034.26  1827.49
8  4 764808424    3  GU*  1641.26  2366.448  4 764808424    3  GU*  1641.26  2366.44
9  6 839255272    5  GU*  1254.94   302.869  6 839255272    5  GU*  1254.94   302.86
10  7 839262008    6  GU*  -677.51   381.3410  7 839262008    6  GU*  -677.51   381.34
11  8 839262176    7  GU*  -596.76   770.3111  8 839262176    7  GU*  -596.76   770.31
12--- --------- ---- ---- -------- --------12--- --------- ---- ---- -------- --------
13  5 763889856    4  AC* -2034.26  1827.4913  5 763889856    4  AC* -2034.26  1827.49
14  4 764808424    3  AC*  1641.26  2366.4414  4 764808424    3  AC*  1641.26  2366.44
15  9 764811080    0  ACQ  2340.89  2058.9015  9 764811080    0  ACQ  2340.89  2058.90
16 11 838346224    2  ACQ -1437.86 -1503.6816 11 838346224    2  ACQ -1437.86 -1503.68
17  6 839255272    5  AC*  1254.94   302.8617  6 839255272    5  AC*  1254.94   302.86
18 10 839258264    1  ACQ  1421.69  -628.0118 10 839258264    1  ACQ  1421.69  -628.01
19  7 839262008    6  AC*  -677.51   381.3419  7 839262008    6  AC*  -677.51   381.34
20  8 839262176    7  AC*  -596.76   770.3120  8 839262176    7  AC*  -596.76   770.31
\n", " \n", @@ -2041,32 +2041,32 @@ "\n", "

Obsid 22850.0

\n", "\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         2    0  FID  -770.80 -1742.84
4  2         4    1  FID  2140.23   166.634  2         4    1  FID  2142.63   165.82
5  3         5    2  FID -1826.28   160.175  3         5    2  FID -1823.88   159.36
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 763889856    4  GU* -2034.26  1827.497  5 763889856    4  GU* -2034.26  1827.49
8  4 764808424    3  GU*  1641.26  2366.448  4 764808424    3  GU*  1641.26  2366.44
9  6 839255272    5  GU*  1254.94   302.869  6 839255272    5  GU*  1254.94   302.86
10  7 839262008    6  GU*  -677.51   381.3410  7 839262008    6  GU*  -677.51   381.34
11  8 839262176    7  GU*  -596.76   770.3111  8 839262176    7  GU*  -596.76   770.31
12--- --------- ---- ---- -------- --------12--- --------- ---- ---- -------- --------
13  5 763889856    4  AC* -2034.26  1827.4913  5 763889856    4  AC* -2034.26  1827.49
14  4 764808424    3  AC*  1641.26  2366.4414  4 764808424    3  AC*  1641.26  2366.44
15  9 764811080    0  ACQ  2340.89  2058.9015  9 764811080    0  ACQ  2340.89  2058.90
16 11 838346224    2  ACQ -1437.86 -1503.6816 11 838346224    2  ACQ -1437.86 -1503.68
17  6 839255272    5  AC*  1254.94   302.8617  6 839255272    5  AC*  1254.94   302.86
18 10 839258264    1  ACQ  1421.69  -628.0118 10 839258264    1  ACQ  1421.69  -628.01
19  7 839262008    6  AC*  -677.51   381.3419  7 839262008    6  AC*  -677.51   381.34
20  8 839262176    7  AC*  -596.76   770.3120  8 839262176    7  AC*  -596.76   770.31
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         2    0  FID  -770.80 -1742.84
4  2         4    1  FID  2140.23   166.634  2         4    1  FID  2142.63   165.82
5  3         5    2  FID -1826.28   160.175  3         5    2  FID -1823.88   159.36
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  5 763889856    4  GU* -2034.26  1827.497  5 763889856    4  GU* -2034.26  1827.49
8  4 764808424    3  GU*  1641.26  2366.448  4 764808424    3  GU*  1641.26  2366.44
9  6 839255272    5  GU*  1254.94   302.869  6 839255272    5  GU*  1254.94   302.86
10  7 839262008    6  GU*  -677.51   381.3410  7 839262008    6  GU*  -677.51   381.34
11  8 839262176    7  GU*  -596.76   770.3111  8 839262176    7  GU*  -596.76   770.31
12--- --------- ---- ---- -------- --------12--- --------- ---- ---- -------- --------
13  5 763889856    4  AC* -2034.26  1827.4913  5 763889856    4  AC* -2034.26  1827.49
14  4 764808424    3  AC*  1641.26  2366.4414  4 764808424    3  AC*  1641.26  2366.44
15  9 764811080    0  ACQ  2340.89  2058.9015  9 764811080    0  ACQ  2340.89  2058.90
16 11 838346224    2  ACQ -1437.86 -1503.6816 11 838346224    2  ACQ -1437.86 -1503.68
17  6 839255272    5  AC*  1254.94   302.8617  6 839255272    5  AC*  1254.94   302.86
18 10 839258264    1  ACQ  1421.69  -628.0118 10 839258264    1  ACQ  1421.69  -628.01
19  7 839262008    6  AC*  -677.51   381.3419  7 839262008    6  AC*  -677.51   381.34
20  8 839262176    7  AC*  -596.76   770.3120  8 839262176    7  AC*  -596.76   770.31
\n", " \n", @@ -2118,17 +2118,17 @@ "\n", "\n", "

CRITICALS

\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222850222850
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.92 < 4.04Critical: OR count of guide stars 3.92 < 4.0
5Critical: guide_count 3.92 and dither > 4x4 arcsec5Critical: guide_count 3.92 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222850222850
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.92 < 4.04Critical: OR count of guide stars 3.92 < 4.0
5Critical: guide_count 3.92 and dither > 4x4 arcsec5Critical: guide_count 3.92 and dither > 4x4 arcsec

\n", @@ -2174,17 +2174,17 @@ "\n", "\n", "

CRITICALS

\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222850222850
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.92 < 4.04Critical: OR count of guide stars 3.92 < 4.0
5Critical: guide_count 3.92 and dither > 4x4 arcsec5Critical: guide_count 3.92 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222850222850
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.92 < 4.04Critical: OR count of guide stars 3.92 < 4.0
5Critical: guide_count 3.92 and dither > 4x4 arcsec5Critical: guide_count 3.92 and dither > 4x4 arcsec

\n", @@ -2236,32 +2236,32 @@ "\n", "

Obsid 22851.0

\n", "\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         2    0  FID  -767.07 -1741.10
4  2         4    1  FID  2140.23   166.634  2         4    1  FID  2146.36   167.57
5  3         5    2  FID -1826.28   160.175  3         5    2  FID -1820.14   161.11
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 763889856    3  GU* -2285.16  1477.357  4 763889856    3  GU* -2285.16  1477.35
8  8 764811080    7  GU*  1999.93  2390.308  8 764811080    7  GU*  1999.93  2390.30
9  5 839255272    4  GU*  1202.02   486.039  5 839255272    4  GU*  1202.02   486.03
10  6 839262008    5  GU*  -718.91   261.2310  6 839262008    5  GU*  -718.91   261.23
11  7 839262176    6  GU*  -700.00   658.0511  7 839262176    6  GU*  -700.00   658.05
12--- --------- ---- ---- -------- --------12--- --------- ---- ---- -------- --------
13  4 763889856    3  AC* -2285.16  1477.3513  4 763889856    3  AC* -2285.16  1477.35
14  8 764811080    7  AC*  1999.93  2390.3014  8 764811080    7  AC*  1999.93  2390.30
15 11 838341568    2  ACQ -2002.65   214.0015 11 838341568    2  ACQ -2002.65   214.00
16 10 838346224    1  ACQ -1175.02 -1719.5216 10 838346224    1  ACQ -1175.02 -1719.52
17  5 839255272    4  AC*  1202.02   486.0317  5 839255272    4  AC*  1202.02   486.03
18  9 839258264    0  ACQ  1512.34  -407.2918  9 839258264    0  ACQ  1512.34  -407.29
19  6 839262008    5  AC*  -718.91   261.2319  6 839262008    5  AC*  -718.91   261.23
20  7 839262176    6  AC*  -700.00   658.0520  7 839262176    6  AC*  -700.00   658.05
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         2    0  FID  -767.07 -1741.10
4  2         4    1  FID  2140.23   166.634  2         4    1  FID  2146.36   167.57
5  3         5    2  FID -1826.28   160.175  3         5    2  FID -1820.14   161.11
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 763889856    3  GU* -2285.16  1477.357  4 763889856    3  GU* -2285.16  1477.35
8  8 764811080    7  GU*  1999.93  2390.308  8 764811080    7  GU*  1999.93  2390.30
9  5 839255272    4  GU*  1202.02   486.039  5 839255272    4  GU*  1202.02   486.03
10  6 839262008    5  GU*  -718.91   261.2310  6 839262008    5  GU*  -718.91   261.23
11  7 839262176    6  GU*  -700.00   658.0511  7 839262176    6  GU*  -700.00   658.05
12--- --------- ---- ---- -------- --------12--- --------- ---- ---- -------- --------
13  4 763889856    3  AC* -2285.16  1477.3513  4 763889856    3  AC* -2285.16  1477.35
14  8 764811080    7  AC*  1999.93  2390.3014  8 764811080    7  AC*  1999.93  2390.30
15 11 838341568    2  ACQ -2002.65   214.0015 11 838341568    2  ACQ -2002.65   214.00
16 10 838346224    1  ACQ -1175.02 -1719.5216 10 838346224    1  ACQ -1175.02 -1719.52
17  5 839255272    4  AC*  1202.02   486.0317  5 839255272    4  AC*  1202.02   486.03
18  9 839258264    0  ACQ  1512.34  -407.2918  9 839258264    0  ACQ  1512.34  -407.29
19  6 839262008    5  AC*  -718.91   261.2319  6 839262008    5  AC*  -718.91   261.23
20  7 839262176    6  AC*  -700.00   658.0520  7 839262176    6  AC*  -700.00   658.05
\n", " \n", @@ -2307,32 +2307,32 @@ "\n", "

Obsid 22851.0

\n", "\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         2    0  FID  -767.07 -1741.10
4  2         4    1  FID  2140.23   166.634  2         4    1  FID  2146.36   167.57
5  3         5    2  FID -1826.28   160.175  3         5    2  FID -1820.14   161.11
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 763889856    3  GU* -2285.16  1477.357  4 763889856    3  GU* -2285.16  1477.35
8  8 764811080    7  GU*  1999.93  2390.308  8 764811080    7  GU*  1999.93  2390.30
9  5 839255272    4  GU*  1202.02   486.039  5 839255272    4  GU*  1202.02   486.03
10  6 839262008    5  GU*  -718.91   261.2310  6 839262008    5  GU*  -718.91   261.23
11  7 839262176    6  GU*  -700.00   658.0511  7 839262176    6  GU*  -700.00   658.05
12--- --------- ---- ---- -------- --------12--- --------- ---- ---- -------- --------
13  4 763889856    3  AC* -2285.16  1477.3513  4 763889856    3  AC* -2285.16  1477.35
14  8 764811080    7  AC*  1999.93  2390.3014  8 764811080    7  AC*  1999.93  2390.30
15 11 838341568    2  ACQ -2002.65   214.0015 11 838341568    2  ACQ -2002.65   214.00
16 10 838346224    1  ACQ -1175.02 -1719.5216 10 838346224    1  ACQ -1175.02 -1719.52
17  5 839255272    4  AC*  1202.02   486.0317  5 839255272    4  AC*  1202.02   486.03
18  9 839258264    0  ACQ  1512.34  -407.2918  9 839258264    0  ACQ  1512.34  -407.29
19  6 839262008    5  AC*  -718.91   261.2319  6 839262008    5  AC*  -718.91   261.23
20  7 839262176    6  AC*  -700.00   658.0520  7 839262176    6  AC*  -700.00   658.05
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         2    0  FID  -767.07 -1741.10
4  2         4    1  FID  2140.23   166.634  2         4    1  FID  2146.36   167.57
5  3         5    2  FID -1826.28   160.175  3         5    2  FID -1820.14   161.11
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  4 763889856    3  GU* -2285.16  1477.357  4 763889856    3  GU* -2285.16  1477.35
8  8 764811080    7  GU*  1999.93  2390.308  8 764811080    7  GU*  1999.93  2390.30
9  5 839255272    4  GU*  1202.02   486.039  5 839255272    4  GU*  1202.02   486.03
10  6 839262008    5  GU*  -718.91   261.2310  6 839262008    5  GU*  -718.91   261.23
11  7 839262176    6  GU*  -700.00   658.0511  7 839262176    6  GU*  -700.00   658.05
12--- --------- ---- ---- -------- --------12--- --------- ---- ---- -------- --------
13  4 763889856    3  AC* -2285.16  1477.3513  4 763889856    3  AC* -2285.16  1477.35
14  8 764811080    7  AC*  1999.93  2390.3014  8 764811080    7  AC*  1999.93  2390.30
15 11 838341568    2  ACQ -2002.65   214.0015 11 838341568    2  ACQ -2002.65   214.00
16 10 838346224    1  ACQ -1175.02 -1719.5216 10 838346224    1  ACQ -1175.02 -1719.52
17  5 839255272    4  AC*  1202.02   486.0317  5 839255272    4  AC*  1202.02   486.03
18  9 839258264    0  ACQ  1512.34  -407.2918  9 839258264    0  ACQ  1512.34  -407.29
19  6 839262008    5  AC*  -718.91   261.2319  6 839262008    5  AC*  -718.91   261.23
20  7 839262176    6  AC*  -700.00   658.0520  7 839262176    6  AC*  -700.00   658.05
\n", " \n", @@ -2384,17 +2384,17 @@ "\n", "\n", "

CRITICALS

\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222851222851
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.48 < 4.04Critical: OR count of guide stars 3.48 < 4.0
5Critical: guide_count 3.48 and dither > 4x4 arcsec5Critical: guide_count 3.48 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222851222851
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.48 < 4.04Critical: OR count of guide stars 3.48 < 4.0
5Critical: guide_count 3.48 and dither > 4x4 arcsec5Critical: guide_count 3.48 and dither > 4x4 arcsec

\n", @@ -2440,17 +2440,17 @@ "\n", "\n", "

CRITICALS

\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
222851222851
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.48 < 4.04Critical: OR count of guide stars 3.48 < 4.0
5Critical: guide_count 3.48 and dither > 4x4 arcsec5Critical: guide_count 3.48 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
222851222851
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.48 < 4.04Critical: OR count of guide stars 3.48 < 4.0
5Critical: guide_count 3.48 and dither > 4x4 arcsec5Critical: guide_count 3.48 and dither > 4x4 arcsec

\n", @@ -2502,32 +2502,32 @@ "\n", "

Obsid 27394.0

\n", "\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          1    0  FID   919.83  -844.17t3  1          1    0  FID   925.94  -846.90
4  2          3    1  FID    37.19  -977.244  2          3    1  FID    43.30  -979.96
5  3          5    2  FID -1828.23  1053.815  3          5    2  FID -1822.11  1051.09
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  6 1055263328    5  GU*  1588.90  1144.437  6 1055263328    5  GU*  1588.90  1144.43
8  8 1055266912    7  GU*  -496.02  1828.288  8 1055266912    7  GU*  -496.02  1828.28
9  5 1055267536    4  GU*   869.07   865.939  5 1055267536    4  GU*   869.07   865.93
10  4 1055268728    3  GU*   186.48  1560.2110  4 1055268728    3  GU*   186.48  1560.21
11  7 1056183096    6  GU*  -509.58 -1118.7211  7 1056183096    6  GU*  -509.58 -1118.72
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13  6 1055263328    5  AC*  1588.90  1144.4313  6 1055263328    5  AC*  1588.90  1144.43
14  9 1055264408    0  ACQ -1887.37   741.3614  9 1055264408    0  ACQ -1887.37   741.36
15  8 1055266912    7  AC*  -496.02  1828.2815  8 1055266912    7  AC*  -496.02  1828.28
16  5 1055267536    4  AC*   869.07   865.9316  5 1055267536    4  AC*   869.07   865.93
17  4 1055268728    3  AC*   186.48  1560.2117  4 1055268728    3  AC*   186.48  1560.21
18 10 1056179824    1  ACQ -2193.69 -1936.8118 10 1056179824    1  ACQ -2193.69 -1936.81
19 11 1056182896    2  ACQ   641.93 -2246.0719 11 1056182896    2  ACQ   641.93 -2246.07
20  7 1056183096    6  AC*  -509.58 -1118.7220  7 1056183096    6  AC*  -509.58 -1118.72
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          1    0  FID   919.83  -844.17t3  1          1    0  FID   925.94  -846.90
4  2          3    1  FID    37.19  -977.244  2          3    1  FID    43.30  -979.96
5  3          5    2  FID -1828.23  1053.815  3          5    2  FID -1822.11  1051.09
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  6 1055263328    5  GU*  1588.90  1144.437  6 1055263328    5  GU*  1588.90  1144.43
8  8 1055266912    7  GU*  -496.02  1828.288  8 1055266912    7  GU*  -496.02  1828.28
9  5 1055267536    4  GU*   869.07   865.939  5 1055267536    4  GU*   869.07   865.93
10  4 1055268728    3  GU*   186.48  1560.2110  4 1055268728    3  GU*   186.48  1560.21
11  7 1056183096    6  GU*  -509.58 -1118.7211  7 1056183096    6  GU*  -509.58 -1118.72
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13  6 1055263328    5  AC*  1588.90  1144.4313  6 1055263328    5  AC*  1588.90  1144.43
14  9 1055264408    0  ACQ -1887.37   741.3614  9 1055264408    0  ACQ -1887.37   741.36
15  8 1055266912    7  AC*  -496.02  1828.2815  8 1055266912    7  AC*  -496.02  1828.28
16  5 1055267536    4  AC*   869.07   865.9316  5 1055267536    4  AC*   869.07   865.93
17  4 1055268728    3  AC*   186.48  1560.2117  4 1055268728    3  AC*   186.48  1560.21
18 10 1056179824    1  ACQ -2193.69 -1936.8118 10 1056179824    1  ACQ -2193.69 -1936.81
19 11 1056182896    2  ACQ   641.93 -2246.0719 11 1056182896    2  ACQ   641.93 -2246.07
20  7 1056183096    6  AC*  -509.58 -1118.7220  7 1056183096    6  AC*  -509.58 -1118.72
\n", " \n", @@ -2573,32 +2573,32 @@ "\n", "

Obsid 27394.0

\n", "\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          1    0  FID   919.83  -844.17t3  1          1    0  FID   925.94  -846.90
4  2          3    1  FID    37.19  -977.244  2          3    1  FID    43.30  -979.96
5  3          5    2  FID -1828.23  1053.815  3          5    2  FID -1822.11  1051.09
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  6 1055263328    5  GU*  1588.90  1144.437  6 1055263328    5  GU*  1588.90  1144.43
8  8 1055266912    7  GU*  -496.02  1828.288  8 1055266912    7  GU*  -496.02  1828.28
9  5 1055267536    4  GU*   869.07   865.939  5 1055267536    4  GU*   869.07   865.93
10  4 1055268728    3  GU*   186.48  1560.2110  4 1055268728    3  GU*   186.48  1560.21
11  7 1056183096    6  GU*  -509.58 -1118.7211  7 1056183096    6  GU*  -509.58 -1118.72
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13  6 1055263328    5  AC*  1588.90  1144.4313  6 1055263328    5  AC*  1588.90  1144.43
14  9 1055264408    0  ACQ -1887.37   741.3614  9 1055264408    0  ACQ -1887.37   741.36
15  8 1055266912    7  AC*  -496.02  1828.2815  8 1055266912    7  AC*  -496.02  1828.28
16  5 1055267536    4  AC*   869.07   865.9316  5 1055267536    4  AC*   869.07   865.93
17  4 1055268728    3  AC*   186.48  1560.2117  4 1055268728    3  AC*   186.48  1560.21
18 10 1056179824    1  ACQ -2193.69 -1936.8118 10 1056179824    1  ACQ -2193.69 -1936.81
19 11 1056182896    2  ACQ   641.93 -2246.0719 11 1056182896    2  ACQ   641.93 -2246.07
20  7 1056183096    6  AC*  -509.58 -1118.7220  7 1056183096    6  AC*  -509.58 -1118.72
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          1    0  FID   919.83  -844.17t3  1          1    0  FID   925.94  -846.90
4  2          3    1  FID    37.19  -977.244  2          3    1  FID    43.30  -979.96
5  3          5    2  FID -1828.23  1053.815  3          5    2  FID -1822.11  1051.09
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  6 1055263328    5  GU*  1588.90  1144.437  6 1055263328    5  GU*  1588.90  1144.43
8  8 1055266912    7  GU*  -496.02  1828.288  8 1055266912    7  GU*  -496.02  1828.28
9  5 1055267536    4  GU*   869.07   865.939  5 1055267536    4  GU*   869.07   865.93
10  4 1055268728    3  GU*   186.48  1560.2110  4 1055268728    3  GU*   186.48  1560.21
11  7 1056183096    6  GU*  -509.58 -1118.7211  7 1056183096    6  GU*  -509.58 -1118.72
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13  6 1055263328    5  AC*  1588.90  1144.4313  6 1055263328    5  AC*  1588.90  1144.43
14  9 1055264408    0  ACQ -1887.37   741.3614  9 1055264408    0  ACQ -1887.37   741.36
15  8 1055266912    7  AC*  -496.02  1828.2815  8 1055266912    7  AC*  -496.02  1828.28
16  5 1055267536    4  AC*   869.07   865.9316  5 1055267536    4  AC*   869.07   865.93
17  4 1055268728    3  AC*   186.48  1560.2117  4 1055268728    3  AC*   186.48  1560.21
18 10 1056179824    1  ACQ -2193.69 -1936.8118 10 1056179824    1  ACQ -2193.69 -1936.81
19 11 1056182896    2  ACQ   641.93 -2246.0719 11 1056182896    2  ACQ   641.93 -2246.07
20  7 1056183096    6  AC*  -509.58 -1118.7220  7 1056183096    6  AC*  -509.58 -1118.72
\n", " \n", @@ -2650,16 +2650,16 @@ "\n", "\n", "

CRITICALS

\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
227394227394
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.18 < 4.04Critical: OR count of guide stars 3.18 < 4.0
t1-------------------------------t1-------------------------------
227394227394
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.18 < 4.04Critical: OR count of guide stars 3.18 < 4.0

\n", @@ -2705,16 +2705,16 @@ "\n", "\n", "

CRITICALS

\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
227394227394
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.18 < 4.04Critical: OR count of guide stars 3.18 < 4.0
t1-------------------------------t1-------------------------------
227394227394
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.18 < 4.04Critical: OR count of guide stars 3.18 < 4.0

\n", @@ -2766,31 +2766,31 @@ "\n", "

Obsid 27477.0

\n", "\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         1    0  FID   950.83 -1729.97
4  2         4    1  FID  2140.23   166.634  2         2    1  FID  -744.96 -1734.11
5  3         6    2  FID   388.59   803.755  3         6    2  FID   416.83   811.68
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  7 768606952    6  GU* -1332.39  -857.307  7 768606952    6  GU* -1332.39  -857.30
8  6 768607024    5  GU* -1509.06 -1022.638  6 768607024    5  GU* -1509.06 -1022.63
9  4 768613752    3  GU* -1984.37  1326.369  4 768613752    3  GU* -1984.37  1326.36
10  5 768737456    4  GU*   417.81 -2270.2910  5 768737456    4  GU*   417.81 -2270.29
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  7 768606952    6  AC* -1332.39  -857.3012  7 768606952    6  AC* -1332.39  -857.30
13  6 768607024    5  AC* -1509.06 -1022.6313  6 768607024    5  AC* -1509.06 -1022.63
14  8 768608592    0  ACQ   -99.78  -907.0214  8 768608592    0  ACQ   -99.78  -907.02
15 10 768611824    2  ACQ -1773.36   641.7115 10 768611824    2  ACQ -1773.36   641.71
16  4 768613752    3  AC* -1984.37  1326.3616  4 768613752    3  AC* -1984.37  1326.36
17 11 768614072    7  ACQ -1620.00   -31.2217 11 768614072    7  ACQ -1620.00   -31.22
18  5 768737456    4  AC*   417.81 -2270.2918  5 768737456    4  AC*   417.81 -2270.29
19  9 768744032    1  ACQ  2257.74   748.6819  9 768744032    1  ACQ  2257.74   748.68
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         1    0  FID   950.83 -1729.97
4  2         4    1  FID  2140.23   166.634  2         2    1  FID  -744.96 -1734.11
5  3         6    2  FID   388.59   803.755  3         6    2  FID   416.83   811.68
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  7 768606952    6  GU* -1332.39  -857.307  7 768606952    6  GU* -1332.39  -857.30
8  6 768607024    5  GU* -1509.06 -1022.638  6 768607024    5  GU* -1509.06 -1022.63
9  4 768613752    3  GU* -1984.37  1326.369  4 768613752    3  GU* -1984.37  1326.36
10  5 768737456    4  GU*   417.81 -2270.2910  5 768737456    4  GU*   417.81 -2270.29
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  7 768606952    6  AC* -1332.39  -857.3012  7 768606952    6  AC* -1332.39  -857.30
13  6 768607024    5  AC* -1509.06 -1022.6313  6 768607024    5  AC* -1509.06 -1022.63
14  8 768608592    0  ACQ   -99.78  -907.0214  8 768608592    0  ACQ   -99.78  -907.02
15 10 768611824    2  ACQ -1773.36   641.7115 10 768611824    2  ACQ -1773.36   641.71
16  4 768613752    3  AC* -1984.37  1326.3616  4 768613752    3  AC* -1984.37  1326.36
17 11 768614072    7  ACQ -1620.00   -31.2217 11 768614072    7  ACQ -1620.00   -31.22
18  5 768737456    4  AC*   417.81 -2270.2918  5 768737456    4  AC*   417.81 -2270.29
19  9 768744032    1  ACQ  2257.74   748.6819  9 768744032    1  ACQ  2257.74   748.68
\n", " \n", @@ -2836,31 +2836,31 @@ "\n", "

Obsid 27477.0

\n", "\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         1    0  FID   950.83 -1729.97
4  2         4    1  FID  2140.23   166.634  2         2    1  FID  -744.96 -1734.11
5  3         6    2  FID   388.59   803.755  3         6    2  FID   416.83   811.68
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  7 768606952    6  GU* -1332.39  -857.307  7 768606952    6  GU* -1332.39  -857.30
8  6 768607024    5  GU* -1509.06 -1022.638  6 768607024    5  GU* -1509.06 -1022.63
9  4 768613752    3  GU* -1984.37  1326.369  4 768613752    3  GU* -1984.37  1326.36
10  5 768737456    4  GU*   417.81 -2270.2910  5 768737456    4  GU*   417.81 -2270.29
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  7 768606952    6  AC* -1332.39  -857.3012  7 768606952    6  AC* -1332.39  -857.30
13  6 768607024    5  AC* -1509.06 -1022.6313  6 768607024    5  AC* -1509.06 -1022.63
14  8 768608592    0  ACQ   -99.78  -907.0214  8 768608592    0  ACQ   -99.78  -907.02
15 10 768611824    2  ACQ -1773.36   641.7115 10 768611824    2  ACQ -1773.36   641.71
16  4 768613752    3  AC* -1984.37  1326.3616  4 768613752    3  AC* -1984.37  1326.36
17 11 768614072    7  ACQ -1620.00   -31.2217 11 768614072    7  ACQ -1620.00   -31.22
18  5 768737456    4  AC*   417.81 -2270.2918  5 768737456    4  AC*   417.81 -2270.29
19  9 768744032    1  ACQ  2257.74   748.6819  9 768744032    1  ACQ  2257.74   748.68
f1idx     id    slot type   yang     zang  f1idx     id    slot type   yang     zang  
2--- --------- ---- ---- -------- --------2--- --------- ---- ---- -------- --------
t3  1         2    0  FID  -773.20 -1742.03t3  1         1    0  FID   950.83 -1729.97
4  2         4    1  FID  2140.23   166.634  2         2    1  FID  -744.96 -1734.11
5  3         6    2  FID   388.59   803.755  3         6    2  FID   416.83   811.68
6--- --------- ---- ---- -------- --------6--- --------- ---- ---- -------- --------
7  7 768606952    6  GU* -1332.39  -857.307  7 768606952    6  GU* -1332.39  -857.30
8  6 768607024    5  GU* -1509.06 -1022.638  6 768607024    5  GU* -1509.06 -1022.63
9  4 768613752    3  GU* -1984.37  1326.369  4 768613752    3  GU* -1984.37  1326.36
10  5 768737456    4  GU*   417.81 -2270.2910  5 768737456    4  GU*   417.81 -2270.29
11--- --------- ---- ---- -------- --------11--- --------- ---- ---- -------- --------
12  7 768606952    6  AC* -1332.39  -857.3012  7 768606952    6  AC* -1332.39  -857.30
13  6 768607024    5  AC* -1509.06 -1022.6313  6 768607024    5  AC* -1509.06 -1022.63
14  8 768608592    0  ACQ   -99.78  -907.0214  8 768608592    0  ACQ   -99.78  -907.02
15 10 768611824    2  ACQ -1773.36   641.7115 10 768611824    2  ACQ -1773.36   641.71
16  4 768613752    3  AC* -1984.37  1326.3616  4 768613752    3  AC* -1984.37  1326.36
17 11 768614072    7  ACQ -1620.00   -31.2217 11 768614072    7  ACQ -1620.00   -31.22
18  5 768737456    4  AC*   417.81 -2270.2918  5 768737456    4  AC*   417.81 -2270.29
19  9 768744032    1  ACQ  2257.74   748.6819  9 768744032    1  ACQ  2257.74   748.68
\n", " \n", @@ -2912,16 +2912,16 @@ "\n", "\n", "

CRITICALS

\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
227477227477
3-------------------------------3-------------------------------
4Critical: Guide indexes [6, 7] clustered within 500\" radius (man_angle_next > 5.0)4Critical: Guide indexes [6, 7] clustered within 500\" radius (man_angle_next > 5.0)
t1-------------------------------t1-------------------------------
227477227477
3-------------------------------3-------------------------------
4Critical: Guide indexes [6, 7] clustered within 500\" radius (man_angle_next > 5.0)4Critical: Guide indexes [6, 7] clustered within 500\" radius (man_angle_next > 5.0)

\n", @@ -2967,16 +2967,16 @@ "\n", "\n", "

CRITICALS

\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
227477227477
3-------------------------------3-------------------------------
4Critical: Guide indexes [6, 7] clustered within 500\" radius (man_angle_next > 5.0)4Critical: Guide indexes [6, 7] clustered within 500\" radius (man_angle_next > 5.0)
t1-------------------------------t1-------------------------------
227477227477
3-------------------------------3-------------------------------
4Critical: Guide indexes [6, 7] clustered within 500\" radius (man_angle_next > 5.0)4Critical: Guide indexes [6, 7] clustered within 500\" radius (man_angle_next > 5.0)

\n", @@ -3028,32 +3028,32 @@ "\n", "

Obsid 27537.0

\n", "\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          2    0  FID  -773.20 -1742.03t3  1          2    0  FID  -764.82 -1743.38
4  2          4    1  FID  2140.23   166.634  2          4    1  FID  2148.61   165.28
5  3          5    2  FID -1826.28   160.175  3          5    2  FID -1817.89   158.82
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  4 1154352872    3  GU*  -649.78 -2113.277  4 1154352872    3  GU*  -649.78 -2113.27
8  5 1154483104    4  GU*  1103.76  -701.878  5 1154483104    4  GU*  1103.76  -701.87
9  7 1154483776    6  GU* -1221.11    11.109  7 1154483776    6  GU* -1221.11    11.10
10  6 1154486312    5  GU* -1466.68  2142.7710  6 1154486312    5  GU* -1466.68  2142.77
11  8 1154486424    7  GUI -1874.84   928.2611  8 1154486424    7  GUI -1874.84   928.26
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13 11 1154352456    2  ACQ  -178.86 -1104.2313 11 1154352456    2  ACQ  -178.86 -1104.23
14 12 1154352712    7  ACQ -1596.19  -466.9114 12 1154352712    7  ACQ -1596.19  -466.91
15  4 1154352872    3  AC*  -649.78 -2113.2715  4 1154352872    3  AC*  -649.78 -2113.27
16  5 1154483104    4  AC*  1103.76  -701.8716  5 1154483104    4  AC*  1103.76  -701.87
17  9 1154483480    0  ACQ -1035.92   346.7817  9 1154483480    0  ACQ -1035.92   346.78
18  7 1154483776    6  AC* -1221.11    11.1018  7 1154483776    6  AC* -1221.11    11.10
19  6 1154486312    5  AC* -1466.68  2142.7719  6 1154486312    5  AC* -1466.68  2142.77
20 10 1154875896    1  ACQ  1398.12 -1323.6020 10 1154875896    1  ACQ  1398.12 -1323.60
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          2    0  FID  -773.20 -1742.03t3  1          2    0  FID  -764.82 -1743.38
4  2          4    1  FID  2140.23   166.634  2          4    1  FID  2148.61   165.28
5  3          5    2  FID -1826.28   160.175  3          5    2  FID -1817.89   158.82
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  4 1154352872    3  GU*  -649.78 -2113.277  4 1154352872    3  GU*  -649.78 -2113.27
8  5 1154483104    4  GU*  1103.76  -701.878  5 1154483104    4  GU*  1103.76  -701.87
9  7 1154483776    6  GU* -1221.11    11.109  7 1154483776    6  GU* -1221.11    11.10
10  6 1154486312    5  GU* -1466.68  2142.7710  6 1154486312    5  GU* -1466.68  2142.77
11  8 1154486424    7  GUI -1874.84   928.2611  8 1154486424    7  GUI -1874.84   928.26
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13 11 1154352456    2  ACQ  -178.86 -1104.2313 11 1154352456    2  ACQ  -178.86 -1104.23
14 12 1154352712    7  ACQ -1596.19  -466.9114 12 1154352712    7  ACQ -1596.19  -466.91
15  4 1154352872    3  AC*  -649.78 -2113.2715  4 1154352872    3  AC*  -649.78 -2113.27
16  5 1154483104    4  AC*  1103.76  -701.8716  5 1154483104    4  AC*  1103.76  -701.87
17  9 1154483480    0  ACQ -1035.92   346.7817  9 1154483480    0  ACQ -1035.92   346.78
18  7 1154483776    6  AC* -1221.11    11.1018  7 1154483776    6  AC* -1221.11    11.10
19  6 1154486312    5  AC* -1466.68  2142.7719  6 1154486312    5  AC* -1466.68  2142.77
20 10 1154875896    1  ACQ  1398.12 -1323.6020 10 1154875896    1  ACQ  1398.12 -1323.60
\n", " \n", @@ -3099,32 +3099,32 @@ "\n", "

Obsid 27537.0

\n", "\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          2    0  FID  -773.20 -1742.03t3  1          2    0  FID  -764.82 -1743.38
4  2          4    1  FID  2140.23   166.634  2          4    1  FID  2148.61   165.28
5  3          5    2  FID -1826.28   160.175  3          5    2  FID -1817.89   158.82
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  4 1154352872    3  GU*  -649.78 -2113.277  4 1154352872    3  GU*  -649.78 -2113.27
8  5 1154483104    4  GU*  1103.76  -701.878  5 1154483104    4  GU*  1103.76  -701.87
9  7 1154483776    6  GU* -1221.11    11.109  7 1154483776    6  GU* -1221.11    11.10
10  6 1154486312    5  GU* -1466.68  2142.7710  6 1154486312    5  GU* -1466.68  2142.77
11  8 1154486424    7  GUI -1874.84   928.2611  8 1154486424    7  GUI -1874.84   928.26
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13 11 1154352456    2  ACQ  -178.86 -1104.2313 11 1154352456    2  ACQ  -178.86 -1104.23
14 12 1154352712    7  ACQ -1596.19  -466.9114 12 1154352712    7  ACQ -1596.19  -466.91
15  4 1154352872    3  AC*  -649.78 -2113.2715  4 1154352872    3  AC*  -649.78 -2113.27
16  5 1154483104    4  AC*  1103.76  -701.8716  5 1154483104    4  AC*  1103.76  -701.87
17  9 1154483480    0  ACQ -1035.92   346.7817  9 1154483480    0  ACQ -1035.92   346.78
18  7 1154483776    6  AC* -1221.11    11.1018  7 1154483776    6  AC* -1221.11    11.10
19  6 1154486312    5  AC* -1466.68  2142.7719  6 1154486312    5  AC* -1466.68  2142.77
20 10 1154875896    1  ACQ  1398.12 -1323.6020 10 1154875896    1  ACQ  1398.12 -1323.60
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          2    0  FID  -773.20 -1742.03t3  1          2    0  FID  -764.82 -1743.38
4  2          4    1  FID  2140.23   166.634  2          4    1  FID  2148.61   165.28
5  3          5    2  FID -1826.28   160.175  3          5    2  FID -1817.89   158.82
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  4 1154352872    3  GU*  -649.78 -2113.277  4 1154352872    3  GU*  -649.78 -2113.27
8  5 1154483104    4  GU*  1103.76  -701.878  5 1154483104    4  GU*  1103.76  -701.87
9  7 1154483776    6  GU* -1221.11    11.109  7 1154483776    6  GU* -1221.11    11.10
10  6 1154486312    5  GU* -1466.68  2142.7710  6 1154486312    5  GU* -1466.68  2142.77
11  8 1154486424    7  GUI -1874.84   928.2611  8 1154486424    7  GUI -1874.84   928.26
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13 11 1154352456    2  ACQ  -178.86 -1104.2313 11 1154352456    2  ACQ  -178.86 -1104.23
14 12 1154352712    7  ACQ -1596.19  -466.9114 12 1154352712    7  ACQ -1596.19  -466.91
15  4 1154352872    3  AC*  -649.78 -2113.2715  4 1154352872    3  AC*  -649.78 -2113.27
16  5 1154483104    4  AC*  1103.76  -701.8716  5 1154483104    4  AC*  1103.76  -701.87
17  9 1154483480    0  ACQ -1035.92   346.7817  9 1154483480    0  ACQ -1035.92   346.78
18  7 1154483776    6  AC* -1221.11    11.1018  7 1154483776    6  AC* -1221.11    11.10
19  6 1154486312    5  AC* -1466.68  2142.7719  6 1154486312    5  AC* -1466.68  2142.77
20 10 1154875896    1  ACQ  1398.12 -1323.6020 10 1154875896    1  ACQ  1398.12 -1323.60
\n", " \n", @@ -3176,17 +3176,17 @@ "\n", "\n", "

CRITICALS

\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
227537227537
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.69 < 4.04Critical: OR count of guide stars 3.69 < 4.0
5Critical: guide_count 3.69 and dither > 4x4 arcsec5Critical: guide_count 3.69 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
227537227537
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.69 < 4.04Critical: OR count of guide stars 3.69 < 4.0
5Critical: guide_count 3.69 and dither > 4x4 arcsec5Critical: guide_count 3.69 and dither > 4x4 arcsec

\n", @@ -3232,17 +3232,17 @@ "\n", "\n", "

CRITICALS

\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
t1-------------------------------t1-------------------------------
227537227537
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.69 < 4.04Critical: OR count of guide stars 3.69 < 4.0
5Critical: guide_count 3.69 and dither > 4x4 arcsec5Critical: guide_count 3.69 and dither > 4x4 arcsec
t1-------------------------------t1-------------------------------
227537227537
3-------------------------------3-------------------------------
4Critical: OR count of guide stars 3.69 < 4.04Critical: OR count of guide stars 3.69 < 4.0
5Critical: guide_count 3.69 and dither > 4x4 arcsec5Critical: guide_count 3.69 and dither > 4x4 arcsec

\n", @@ -3294,32 +3294,32 @@ "\n", "

Obsid 28048.0

\n", "\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          1    0  FID -1175.03  -468.23t3  1          1    0  FID -1156.85  -465.28
4  2          3    1  FID -1177.69   561.304  2          2    1  FID  1242.89  -457.98
5  3          4    2  FID  1223.32   563.705  3          3    2  FID -1159.51   564.25
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  8 1032066000    7  GU* -1400.85 -1938.607  8 1032066000    7  GU* -1400.85 -1938.60
8  4 1033781448    3  GU* -1722.02  -323.058  4 1033781448    3  GU* -1722.02  -323.05
9  5 1034300880    4  GU*   522.18  -208.249  5 1034300880    4  GU*   522.18  -208.24
10  7 1034314520    6  GU*  2095.28  -491.0510  7 1034314520    6  GU*  2095.28  -491.05
11  6 1034323016    5  GU*  1015.18 -1108.9811  6 1034323016    5  GU*  1015.18 -1108.98
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13  8 1032066000    7  AC* -1400.85 -1938.6013  8 1032066000    7  AC* -1400.85 -1938.60
14  9 1032591016    0  ACQ  1559.23 -1946.4214  9 1032591016    0  ACQ  1559.23 -1946.42
15 11 1033780008    2  ACQ -1498.72  1058.6515 11 1033780008    2  ACQ -1498.72  1058.65
16  4 1033781448    3  AC* -1722.02  -323.0516  4 1033781448    3  AC* -1722.02  -323.05
17 10 1034292264    1  ACQ  -354.14  1450.6017 10 1034292264    1  ACQ  -354.14  1450.60
18  5 1034300880    4  AC*   522.18  -208.2418  5 1034300880    4  AC*   522.18  -208.24
19  7 1034314520    6  AC*  2095.28  -491.0519  7 1034314520    6  AC*  2095.28  -491.05
20  6 1034323016    5  AC*  1015.18 -1108.9820  6 1034323016    5  AC*  1015.18 -1108.98
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          1    0  FID -1175.03  -468.23t3  1          1    0  FID -1156.85  -465.28
4  2          3    1  FID -1177.69   561.304  2          2    1  FID  1242.89  -457.98
5  3          4    2  FID  1223.32   563.705  3          3    2  FID -1159.51   564.25
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  8 1032066000    7  GU* -1400.85 -1938.607  8 1032066000    7  GU* -1400.85 -1938.60
8  4 1033781448    3  GU* -1722.02  -323.058  4 1033781448    3  GU* -1722.02  -323.05
9  5 1034300880    4  GU*   522.18  -208.249  5 1034300880    4  GU*   522.18  -208.24
10  7 1034314520    6  GU*  2095.28  -491.0510  7 1034314520    6  GU*  2095.28  -491.05
11  6 1034323016    5  GU*  1015.18 -1108.9811  6 1034323016    5  GU*  1015.18 -1108.98
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13  8 1032066000    7  AC* -1400.85 -1938.6013  8 1032066000    7  AC* -1400.85 -1938.60
14  9 1032591016    0  ACQ  1559.23 -1946.4214  9 1032591016    0  ACQ  1559.23 -1946.42
15 11 1033780008    2  ACQ -1498.72  1058.6515 11 1033780008    2  ACQ -1498.72  1058.65
16  4 1033781448    3  AC* -1722.02  -323.0516  4 1033781448    3  AC* -1722.02  -323.05
17 10 1034292264    1  ACQ  -354.14  1450.6017 10 1034292264    1  ACQ  -354.14  1450.60
18  5 1034300880    4  AC*   522.18  -208.2418  5 1034300880    4  AC*   522.18  -208.24
19  7 1034314520    6  AC*  2095.28  -491.0519  7 1034314520    6  AC*  2095.28  -491.05
20  6 1034323016    5  AC*  1015.18 -1108.9820  6 1034323016    5  AC*  1015.18 -1108.98
\n", " \n", @@ -3365,32 +3365,32 @@ "\n", "

Obsid 28048.0

\n", "\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          1    0  FID -1175.03  -468.23t3  1          1    0  FID -1156.85  -465.28
4  2          3    1  FID -1177.69   561.304  2          2    1  FID  1242.89  -457.98
5  3          4    2  FID  1223.32   563.705  3          3    2  FID -1159.51   564.25
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  8 1032066000    7  GU* -1400.85 -1938.607  8 1032066000    7  GU* -1400.85 -1938.60
8  4 1033781448    3  GU* -1722.02  -323.058  4 1033781448    3  GU* -1722.02  -323.05
9  5 1034300880    4  GU*   522.18  -208.249  5 1034300880    4  GU*   522.18  -208.24
10  7 1034314520    6  GU*  2095.28  -491.0510  7 1034314520    6  GU*  2095.28  -491.05
11  6 1034323016    5  GU*  1015.18 -1108.9811  6 1034323016    5  GU*  1015.18 -1108.98
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13  8 1032066000    7  AC* -1400.85 -1938.6013  8 1032066000    7  AC* -1400.85 -1938.60
14  9 1032591016    0  ACQ  1559.23 -1946.4214  9 1032591016    0  ACQ  1559.23 -1946.42
15 11 1033780008    2  ACQ -1498.72  1058.6515 11 1033780008    2  ACQ -1498.72  1058.65
16  4 1033781448    3  AC* -1722.02  -323.0516  4 1033781448    3  AC* -1722.02  -323.05
17 10 1034292264    1  ACQ  -354.14  1450.6017 10 1034292264    1  ACQ  -354.14  1450.60
18  5 1034300880    4  AC*   522.18  -208.2418  5 1034300880    4  AC*   522.18  -208.24
19  7 1034314520    6  AC*  2095.28  -491.0519  7 1034314520    6  AC*  2095.28  -491.05
20  6 1034323016    5  AC*  1015.18 -1108.9820  6 1034323016    5  AC*  1015.18 -1108.98
f1idx     id     slot type   yang     zang  f1idx     id     slot type   yang     zang  
2--- ---------- ---- ---- -------- --------2--- ---------- ---- ---- -------- --------
t3  1          1    0  FID -1175.03  -468.23t3  1          1    0  FID -1156.85  -465.28
4  2          3    1  FID -1177.69   561.304  2          2    1  FID  1242.89  -457.98
5  3          4    2  FID  1223.32   563.705  3          3    2  FID -1159.51   564.25
6--- ---------- ---- ---- -------- --------6--- ---------- ---- ---- -------- --------
7  8 1032066000    7  GU* -1400.85 -1938.607  8 1032066000    7  GU* -1400.85 -1938.60
8  4 1033781448    3  GU* -1722.02  -323.058  4 1033781448    3  GU* -1722.02  -323.05
9  5 1034300880    4  GU*   522.18  -208.249  5 1034300880    4  GU*   522.18  -208.24
10  7 1034314520    6  GU*  2095.28  -491.0510  7 1034314520    6  GU*  2095.28  -491.05
11  6 1034323016    5  GU*  1015.18 -1108.9811  6 1034323016    5  GU*  1015.18 -1108.98
12--- ---------- ---- ---- -------- --------12--- ---------- ---- ---- -------- --------
13  8 1032066000    7  AC* -1400.85 -1938.6013  8 1032066000    7  AC* -1400.85 -1938.60
14  9 1032591016    0  ACQ  1559.23 -1946.4214  9 1032591016    0  ACQ  1559.23 -1946.42
15 11 1033780008    2  ACQ -1498.72  1058.6515 11 1033780008    2  ACQ -1498.72  1058.65
16  4 1033781448    3  AC* -1722.02  -323.0516  4 1033781448    3  AC* -1722.02  -323.05
17 10 1034292264    1  ACQ  -354.14  1450.6017 10 1034292264    1  ACQ  -354.14  1450.60
18  5 1034300880    4  AC*   522.18  -208.2418  5 1034300880    4  AC*   522.18  -208.24
19  7 1034314520    6  AC*  2095.28  -491.0519  7 1034314520    6  AC*  2095.28  -491.05
20  6 1034323016    5  AC*  1015.18 -1108.9820  6 1034323016    5  AC*  1015.18 -1108.98
\n", " \n", @@ -3442,16 +3442,16 @@ "\n", "\n", "

CRITICALS

\n", - "
\n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
tt1-------------------------------
228048
3-------------------------------
4Critical: Fid 2 has red spoiler: star 1034304216 with mag 10.56
tt1-------------------------------
228048
3-------------------------------
4Critical: Fid 2 has red spoiler: star 1034304216 with mag 10.56

\n", @@ -3497,16 +3497,16 @@ "\n", "\n", "

CRITICALS

\n", - " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", "
tt1-------------------------------
228048
3-------------------------------
4Critical: Fid 2 has red spoiler: star 1034304216 with mag 10.56
tt1-------------------------------
228048
3-------------------------------
4Critical: Fid 2 has red spoiler: star 1034304216 with mag 10.56

\n", From 1535aef8648851c241c698a409a582152ad7e9d2 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Tue, 12 Dec 2023 12:39:20 -0500 Subject: [PATCH 30/38] Set t_ccd_acq from t_ccd kwarg --- proseco/fid.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proseco/fid.py b/proseco/fid.py index f0eedf00..4b443c25 100644 --- a/proseco/fid.py +++ b/proseco/fid.py @@ -59,7 +59,6 @@ def get_fid_catalog(obsid=0, **kwargs): return empty_fids fids.set_stars(acqs=fids.acqs) - fids.cand_fids = fids.get_fid_candidates() # Set list of available fid_set's, accounting for n_fid and cand_fids. @@ -132,6 +131,7 @@ def t_ccd(self): @t_ccd.setter def t_ccd(self, value): self.t_ccd_guide = value + self.t_ccd_acq = value def set_fid_set(self, fid_ids): if len(self) > 0: From 9036aa0de7fc0cf7977b0fe3ae8c13111b0dbecc Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Tue, 12 Dec 2023 12:39:40 -0500 Subject: [PATCH 31/38] Add a test fixture to disable fid offsets --- proseco/tests/conftest.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/proseco/tests/conftest.py b/proseco/tests/conftest.py index 13bf0d9b..70286d3f 100644 --- a/proseco/tests/conftest.py +++ b/proseco/tests/conftest.py @@ -3,6 +3,11 @@ from agasc import get_agasc_filename +@pytest.fixture() +def disable_fid_offsets(monkeypatch): + monkeypatch.setenv("PROSECO_ENABLE_FID_OFFSET", "False") + + @pytest.fixture(autouse=True) def use_fixed_chandra_models(monkeypatch): monkeypatch.setenv("CHANDRA_MODELS_DEFAULT_VERSION", "3.48") From be17b85f8c2d4dcdebfc2c7ad364baa56fdc1ffe Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Tue, 12 Dec 2023 12:40:54 -0500 Subject: [PATCH 32/38] Disable fid offsets in two tests --- proseco/tests/test_catalog.py | 2 +- proseco/tests/test_fid.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/proseco/tests/test_catalog.py b/proseco/tests/test_catalog.py index 48322152..f6b0912a 100644 --- a/proseco/tests/test_catalog.py +++ b/proseco/tests/test_catalog.py @@ -677,7 +677,7 @@ def test_monitors_and_target_offset_args(): assert aca.target_offset is target_offset -def test_reject_column_spoilers(): +def test_reject_column_spoilers(disable_fid_offsets): """ Test that column spoiler handling is correct for guide, acq and fid selection. Also tests not selecting stars that are too bright. diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index cd7c7222..7f6938b2 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -208,7 +208,7 @@ def test_fid_spoiling_acq(dither_z, FIDS): assert repr(fids5.cand_fids).splitlines() == exp -def test_fid_mult_spoilers(proseco_agasc_1p7): +def test_fid_mult_spoilers(disable_fid_offsets, proseco_agasc_1p7): """ Test of fix for bug #54. 19605 and 20144 were previous crashing. """ From 989143d43d5c090b55e5156b1ecdcf66bed38214 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Tue, 12 Dec 2023 12:55:11 -0500 Subject: [PATCH 33/38] Make some new t_ccd kwarg/attr tests --- proseco/tests/test_catalog.py | 73 +++++++++++++++++++++++++++++++++++ proseco/tests/test_fid.py | 26 +++++++++++++ 2 files changed, 99 insertions(+) diff --git a/proseco/tests/test_catalog.py b/proseco/tests/test_catalog.py index f6b0912a..c9d27e41 100644 --- a/proseco/tests/test_catalog.py +++ b/proseco/tests/test_catalog.py @@ -570,6 +570,79 @@ def test_call_args_attr(): } +def test_t_ccd_attr(): + """ + Test that a t_ccd kwarg is set to all of the ACACatalogTable attrs + """ + + aca_args = STD_INFO.copy() + for kw in ["t_ccd", "t_ccd_acq", "t_ccd_guide"]: + if kw in aca_args: + del aca_args[kw] + + t_ccd = -11 + aca_args["t_ccd"] = t_ccd + aca = get_aca_catalog(**aca_args) + assert aca.t_ccd_acq == t_ccd + assert aca.t_ccd_guide == t_ccd + assert aca.acqs.t_ccd == t_ccd + assert aca.guides.t_ccd == t_ccd + assert aca.fids.t_ccd == t_ccd + assert aca.fids.t_ccd_acq == t_ccd + assert aca.fids.t_ccd_guide == t_ccd + + +def test_t_ccd_acq_attr(): + """ + Test that a t_ccd and t_ccd_acq kwarg are set to all of the expected ACACatalogTable attrs + """ + + aca_args = STD_INFO.copy() + for kw in ["t_ccd", "t_ccd_acq", "t_ccd_guide"]: + if kw in aca_args: + del aca_args[kw] + + t_ccd = -11 + t_ccd_acq = -16 + aca_args["t_ccd"] = t_ccd + aca_args["t_ccd_acq"] = t_ccd_acq + aca = get_aca_catalog(**aca_args) + assert aca.t_ccd_acq == t_ccd_acq + assert aca.t_ccd_guide == t_ccd + assert aca.acqs.t_ccd == t_ccd_acq + assert aca.guides.t_ccd == t_ccd + assert aca.fids.t_ccd == t_ccd + assert aca.fids.t_ccd_acq == t_ccd_acq + assert aca.fids.t_ccd_guide == t_ccd + + +def test_t_ccd_multi_attr(): + """ + Test assignments if t_ccd, t_ccd_acq, and t_ccd_guide supplied as kwargs + """ + + aca_args = STD_INFO.copy() + for kw in ["t_ccd", "t_ccd_acq", "t_ccd_guide"]: + if kw in aca_args: + del aca_args[kw] + + t_ccd = -11 + t_ccd_acq = -16 + t_ccd_guide = -6 + aca_args["t_ccd"] = t_ccd + aca_args["t_ccd_acq"] = t_ccd_acq + aca_args["t_ccd_guide"] = t_ccd_guide + aca = get_aca_catalog(**aca_args) + assert aca.t_ccd == t_ccd_guide + assert aca.t_ccd_acq == t_ccd_acq + assert aca.t_ccd_guide == t_ccd_guide + assert aca.acqs.t_ccd == t_ccd_acq + assert aca.guides.t_ccd == t_ccd_guide + assert aca.fids.t_ccd == t_ccd_guide + assert aca.fids.t_ccd_acq == t_ccd_acq + assert aca.fids.t_ccd_guide == t_ccd_guide + + def test_bad_obsid(): # Expects this to be starcheck catalog aca = get_aca_catalog(obsid="blah blah", raise_exc=False) diff --git a/proseco/tests/test_fid.py b/proseco/tests/test_fid.py index 7f6938b2..bd5ff101 100644 --- a/proseco/tests/test_fid.py +++ b/proseco/tests/test_fid.py @@ -98,6 +98,32 @@ def test_get_fid_pos_errors(monkeypatch): ) +def test_fid_catalog_t_ccd(): + """ + Test that t_ccd vs t_ccd_acq/guide is applied to get_fid_catalog + """ + aca_args1 = STD_INFO.copy() + for key in ["t_ccd_acq", "t_ccd_guide", "t_ccd"]: + if key in aca_args1: + del aca_args1[key] + aca_args1["t_ccd"] = -14 + fids1 = get_fid_catalog(**aca_args1) + + aca_args2 = STD_INFO.copy() + for key in ["t_ccd_acq", "t_ccd_guide", "t_ccd"]: + if key in aca_args2: + del aca_args2[key] + aca_args2["t_ccd_acq"] = -14 + aca_args2["t_ccd_guide"] = 5 + fids2 = get_fid_catalog(**aca_args2) + + assert fids1.t_ccd_acq == fids2.t_ccd_acq + assert fids1.t_ccd_guide != fids2.t_ccd_guide + assert fids1.t_ccd != fids2.t_ccd + assert np.all(fids1["yang"] == fids2["yang"]) + assert np.all(fids1["zang"] == fids2["zang"]) + + def test_get_initial_catalog(FIDS): """Test basic catalog with no stars in field using standard 2-4-5 config.""" exp = [ From e8a5529e4159ae9b4a7f661bfe55a9deb62c7f01 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Tue, 12 Dec 2023 14:49:10 -0500 Subject: [PATCH 34/38] Rerun validate notebook --- .../pr388-validate-drift-model-fid-positions.ipynb | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/analysis/pr388-validate-drift-model-fid-positions.ipynb b/analysis/pr388-validate-drift-model-fid-positions.ipynb index b0e3bb5c..162f9d82 100644 --- a/analysis/pr388-validate-drift-model-fid-positions.ipynb +++ b/analysis/pr388-validate-drift-model-fid-positions.ipynb @@ -19,7 +19,7 @@ "output_type": "stream", "text": [ "4.44.1.dev12+gb259754\n", - "5.11.1.dev28+gef377fa\n" + "5.11.1.dev33+g989143d\n" ] } ], @@ -358,7 +358,13 @@ "Number of fids changed with reselect: 18\n", "Positions match for reselect fids with var set to false: True\n", "Positions match for reselect fids with var set to none or true: True\n", - "Number of fids changed with fid offset reselect: 38\n", + "Number of fids changed with fid offset reselect: 38\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Fids used by detector (confirm coverage)\n", "{'HRC-I': {1: 24, 2: 17, 3: 20, 4: 13}, 'HRC-S': {1: 12, 2: 9, 3: 12, 4: 3}, 'ACIS-I': {1: 84, 2: 12, 3: 29, 4: 7, 5: 77, 6: 71}, 'ACIS-S': {1: 11, 2: 93, 3: 9, 4: 103, 5: 99, 6: 13}}\n" ] From 440b2da497c4f38096d3e08488e1e80e9a95bef6 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Tue, 12 Dec 2023 14:50:42 -0500 Subject: [PATCH 35/38] Restore previous comment --- proseco/fid.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/proseco/fid.py b/proseco/fid.py index 4b443c25..673bda57 100644 --- a/proseco/fid.py +++ b/proseco/fid.py @@ -125,7 +125,7 @@ def acqs(self, val): @property def t_ccd(self): - # For fids use the guide CCD temperature to scale the dark map + # For fids use the guide CCD temperature return self.t_ccd_guide @t_ccd.setter From 0b63ec0b2cd06801bb0301f68b9bd0840b870209 Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Tue, 12 Dec 2023 14:57:30 -0500 Subject: [PATCH 36/38] Use disable_fid_offsets fixture in an acq test --- proseco/tests/test_acq.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/proseco/tests/test_acq.py b/proseco/tests/test_acq.py index 97504e30..5659ae6e 100644 --- a/proseco/tests/test_acq.py +++ b/proseco/tests/test_acq.py @@ -843,16 +843,12 @@ def get_dark_stars_simple(box_size_thresh, dither): return dark, stars -def test_acq_fid_catalog_probs_low_level(monkeypatch): +def test_acq_fid_catalog_probs_low_level(monkeypatch, disable_fid_offsets): """ Low-level tests of machinery to handle different fid light sets within acquisition probabilities. """ - # Disable fid offsets for this specific test which has been set up to spoil - # fids at not-offset-corrected positions - monkeypatch.setenv("PROSECO_ENABLE_FID_OFFSET", "False") - # Put an acq star at an offset from fid light id=2 such that for a search # box size larger than box_size_thresh, that star will be spoiled. This # uses the equation in FidTable.spoils(). From 5c2b26f5565fd20d4f8a85a42e7b92b7605a2a2c Mon Sep 17 00:00:00 2001 From: Jean Connelly Date: Wed, 13 Dec 2023 10:17:32 -0500 Subject: [PATCH 37/38] Revert change to add_fake_stars_from_fid --- proseco/core.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/proseco/core.py b/proseco/core.py index 869b9fdd..167ffb72 100644 --- a/proseco/core.py +++ b/proseco/core.py @@ -1487,8 +1487,7 @@ def add_fake_stars_from_fid( detector=detector, sim_offset=sim_offset, focus_offset=0, - t_ccd_guide=-10.0, - t_ccd_acq=-10.0, + t_ccd=-10.0, date="2018:001", dither=8.0, ) From d86e28152e8cb8e673446be06f2f0b2422fde575 Mon Sep 17 00:00:00 2001 From: Tom Aldcroft Date: Thu, 14 Dec 2023 09:17:10 -0500 Subject: [PATCH 38/38] Some tiny cleanup --- docs/index.rst | 12 ++++++------ proseco/fid.py | 2 +- proseco/tests/test_acq.py | 3 +-- proseco/tests/test_guide.py | 2 -- 4 files changed, 8 insertions(+), 11 deletions(-) diff --git a/docs/index.rst b/docs/index.rst index 295caad4..237b6761 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -311,18 +311,18 @@ The following environment variables are used by proseco: If this is a relative path then it is relative to ````. - ``AGASC_SUPPLEMENT_ENABLED``: set to ``"False"`` to disable using the AGASC supplement. This is for testing and should not be used in production. +- ``PROSECO_ENABLE_FID_OFFSET``: controls application of time and temperature dependent fid + light position offsets (from the ACA drift model) in :ref:`~proseco.fid.get_fid_positions`: + - Not set: apply offsets if time and temperature are provided (as is done in ``proseco`` fid + selection since version 5.12.0) + - ``"True"``: require that time and temperature be provided and apply offsets. + - ``"False"``: do not apply offsets (typically used in regression testing not production). - ``PROSECO_IGNORE_MAXAGS_CONSTRAINTS``: if set then do not update ``maxmag`` in the catalog to prevent search hits clipping. - ``PROSECO_OR_IMAGE_SIZE``: override the default OR image size of 8x8. Can be one of "4", "6", or "8". - ``PROSECO_PRINT_OBC_CAT``: if set then create and print a debug catalog while doing catalog merging. -- ``PROSECO_ENABLE_FID_OFFSET``: controls application of time and temperature dependent fid - light position offsets (from the ACA drift model) in :ref:`~proseco.fid.get_fid_positions`: - - Not set: apply offsets if time and temperature are provided (as is done in ``proseco`` fid - selection since version 5.12.0) - - ``"True"``: require that time and temperature be provided and apply offsets. - - ``"False"``: do not apply offsets (typically used in regression testing not production). - ``SKA``: root directory that contains 'data' directory API docs diff --git a/proseco/fid.py b/proseco/fid.py index 673bda57..65112d7f 100644 --- a/proseco/fid.py +++ b/proseco/fid.py @@ -11,7 +11,7 @@ import numpy as np from chandra_aca.drift import get_fid_offset from chandra_aca.transform import yagzag_to_pixels -from cxotime import CxoTime, CxoTimeLike +from cxotime import CxoTimeLike from . import characteristics as ACA from . import characteristics_acq as ACQ diff --git a/proseco/tests/test_acq.py b/proseco/tests/test_acq.py index 5659ae6e..2db33042 100644 --- a/proseco/tests/test_acq.py +++ b/proseco/tests/test_acq.py @@ -3,7 +3,6 @@ import os from pathlib import Path -import agasc import numpy as np import pytest from chandra_aca import star_probs @@ -843,7 +842,7 @@ def get_dark_stars_simple(box_size_thresh, dither): return dark, stars -def test_acq_fid_catalog_probs_low_level(monkeypatch, disable_fid_offsets): +def test_acq_fid_catalog_probs_low_level(disable_fid_offsets): """ Low-level tests of machinery to handle different fid light sets within acquisition probabilities. diff --git a/proseco/tests/test_guide.py b/proseco/tests/test_guide.py index f079a155..0c916be9 100644 --- a/proseco/tests/test_guide.py +++ b/proseco/tests/test_guide.py @@ -1,10 +1,8 @@ # Licensed under a 3-clause BSD style license - see LICENSE.rst import itertools -import os from pathlib import Path -import agasc import mica.starcheck import numpy as np import pytest