From 6255fc0736e3fa3df29dcbca6662f5ec93c4bb23 Mon Sep 17 00:00:00 2001 From: Stephanie Merritt Date: Tue, 19 Mar 2024 17:03:53 +0000 Subject: [PATCH 01/18] Adding functionality to read from local SQL database --- src/adler/dataclasses/AdlerPlanetoid.py | 117 +++++++++++++++---- src/adler/dataclasses/Observations.py | 29 +++-- src/adler/dataclasses/SSObject.py | 22 +--- src/adler/dataclasses/dataclass_utilities.py | 20 +++- 4 files changed, 133 insertions(+), 55 deletions(-) diff --git a/src/adler/dataclasses/AdlerPlanetoid.py b/src/adler/dataclasses/AdlerPlanetoid.py index fd6413a..0865cf1 100644 --- a/src/adler/dataclasses/AdlerPlanetoid.py +++ b/src/adler/dataclasses/AdlerPlanetoid.py @@ -49,9 +49,51 @@ def __init__( self.AdlerData = adler_data @classmethod - def construct_from_SQL(cls): - # to-do - pass + def construct_from_SQL( + cls, + ssObjectId, + sql_filename, + filter_list=["u", "g", "r", "i", "z", "y"], + date_range=[60000.0, 67300.0], + schema=None, + ): + """Custom constructor which builds the AdlerPlanetoid object and the associated Observations, MPCORB and SSObject objects from + a local SQL database. Mostly used for testing. + + Parameters + ----------- + ssObjectId : str + ssObjectId of the object of interest. + + sql_filename : str + Filepath to the local SQL database. + + filter_list : list of str + A comma-separated list of the filters of interest. + + date_range : list of int + The minimum and maximum dates of the desired observations. + + schema : str or None + Schema/database from which to select the data tables. Can be None. Default is currently "dp03_catalogs_10yr" for testing using DP0.3. + + """ + + if len(date_range) != 2: + raise Exception("date_range argument must be of length 2.") + + observations_by_filter = cls.populate_observations( + cls, ssObjectId, filter_list, date_range, sql_filename=sql_filename, schema=schema + ) + + mpcorb = cls.populate_MPCORB(cls, ssObjectId, sql_filename=sql_filename, schema=schema) + ssobject = cls.populate_SSObject( + cls, ssObjectId, filter_list, sql_filename=sql_filename, schema=schema + ) + + adler_data = AdlerData(filter_list) + + return cls(ssObjectId, filter_list, date_range, observations_by_filter, mpcorb, ssobject, adler_data) @classmethod def construct_from_RSP( @@ -87,7 +129,15 @@ def construct_from_RSP( return cls(ssObjectId, filter_list, date_range, observations_by_filter, mpcorb, ssobject, adler_data) - def populate_observations(self, ssObjectId, filter_list, date_range, service=None, sql_filename=None): + def populate_observations( + self, + ssObjectId, + filter_list, + date_range, + service=None, + sql_filename=None, + schema="dp03_catalogs_10yr", + ): """Populates the observations_by_filter class attribute. Can populate from either the RSP for a SQL database: this behaviour is controlled by the service and sql_filename parameters, one of which must be supplied. @@ -102,27 +152,35 @@ def populate_observations(self, ssObjectId, filter_list, date_range, service=Non date_range : list of int The minimum and maximum dates of the desired observations. - service : pyvo.dal.tap.TAPService object + service : pyvo.dal.tap.TAPService object or None TAPService object linked to the RSP. Default=None. - sql_filename : str + sql_filename : str or None Filepath to a SQL database. Default=None. + schema : str or None + Schema/database from which to select the data tables. Can be None. Default is currently "dp03_catalogs_10yr" for testing using DP0.3. + """ + if schema: + schema = schema + "." + else: + schema = "" + observations_by_filter = [] for filter_name in filter_list: observations_sql_query = f""" SELECT - ssObject.ssObjectId, mag, magErr, band, midpointMjdTai, ra, dec, phaseAngle, + ssObject.ssObjectId, mag, magErr, band, midPointMjdTai, ra, dec, phaseAngle, topocentricDist, heliocentricDist FROM - dp03_catalogs_10yr.ssObject - JOIN dp03_catalogs_10yr.diaSource ON dp03_catalogs_10yr.ssObject.ssObjectId = dp03_catalogs_10yr.diaSource.ssObjectId - JOIN dp03_catalogs_10yr.ssSource ON dp03_catalogs_10yr.diaSource.diaSourceId = dp03_catalogs_10yr.ssSource.diaSourceId + {schema}ssObject + JOIN {schema}diaSource ON {schema}ssObject.ssObjectId = {schema}diaSource.ssObjectId + JOIN {schema}ssSource ON {schema}diaSource.diaSourceId = {schema}ssSource.diaSourceId WHERE - ssObject.ssObjectId = {ssObjectId} AND band = '{filter_name}' AND midpointMjdTai BETWEEN {date_range[0]} AND {date_range[1]} + ssObject.ssObjectId = {ssObjectId} AND band = '{filter_name}' AND midPointMjdTai BETWEEN {date_range[0]} AND {date_range[1]} """ data_table = get_data_table(observations_sql_query, service=service, sql_filename=sql_filename) @@ -133,7 +191,7 @@ def populate_observations(self, ssObjectId, filter_list, date_range, service=Non return observations_by_filter - def populate_MPCORB(self, ssObjectId, service=None, sql_filename=None): + def populate_MPCORB(self, ssObjectId, service=None, sql_filename=None, schema="dp03_catalogs_10yr"): """Populates the MPCORB object class attribute. Can populate from either the RSP for a SQL database: this behaviour is controlled by the service and sql_filename parameters, one of which must be supplied. @@ -142,19 +200,28 @@ def populate_MPCORB(self, ssObjectId, service=None, sql_filename=None): ssObjectId : str ssObjectId of the object of interest. - service : pyvo.dal.tap.TAPService object + service : pyvo.dal.tap.TAPService object or None TAPService object linked to the RSP. Default=None. - sql_filename : str + sql_filename : str or None Filepath to a SQL database. Default=None. + schema : str or None + Schema/database from which to select the data tables. Can be None. Default is currently "dp03_catalogs_10yr" for testing using DP0.3. + """ + + if schema: + schema = schema + "." + else: + schema = "" + MPCORB_sql_query = f""" SELECT ssObjectId, mpcDesignation, mpcNumber, mpcH, mpcG, epoch, peri, node, incl, e, n, q, uncertaintyParameter, flags FROM - dp03_catalogs_10yr.MPCORB + {schema}MPCORB WHERE ssObjectId = {ssObjectId} """ @@ -163,7 +230,9 @@ def populate_MPCORB(self, ssObjectId, service=None, sql_filename=None): return MPCORB.construct_from_data_table(ssObjectId, data_table) - def populate_SSObject(self, ssObjectId, filter_list, service=None, sql_filename=None): + def populate_SSObject( + self, ssObjectId, filter_list, service=None, sql_filename=None, schema="dp03_catalogs_10yr" + ): """Populates the SSObject class attribute. Can populate from either the RSP for a SQL database: this behaviour is controlled by the service and sql_filename parameters, one of which must be supplied. @@ -175,18 +244,26 @@ def populate_SSObject(self, ssObjectId, filter_list, service=None, sql_filename= filter_list : list of str A comma-separated list of the filters of interest. - service : pyvo.dal.tap.TAPService object + service : pyvo.dal.tap.TAPService object or None TAPService object linked to the RSP. Default=None. - sql_filename : str + sql_filename : str or None Filepath to a SQL database. Default=None. + schema : str or None + Schema/database from which to select the data tables. Can be None. Default is currently "dp03_catalogs_10yr" for testing using DP0.3. + """ + if schema: + schema = schema + "." + else: + schema = "" + filter_dependent_columns = "" for filter_name in filter_list: - filter_string = "{}_H, {}_G12, {}_Herr, {}_G12err, {}_nData, ".format( + filter_string = "{}_H, {}_G12, {}_HErr, {}_G12Err, {}_Ndata, ".format( filter_name, filter_name, filter_name, filter_name, filter_name ) @@ -198,7 +275,7 @@ def populate_SSObject(self, ssObjectId, filter_list, service=None, sql_filename= {filter_dependent_columns} maxExtendedness, minExtendedness, medianExtendedness FROM - dp03_catalogs_10yr.SSObject + {schema}SSObject WHERE ssObjectId = {ssObjectId} """ diff --git a/src/adler/dataclasses/Observations.py b/src/adler/dataclasses/Observations.py index 2d5aa1e..b28356d 100644 --- a/src/adler/dataclasses/Observations.py +++ b/src/adler/dataclasses/Observations.py @@ -85,21 +85,28 @@ def construct_from_data_table(cls, ssObjectId, filter_name, data_table): """ - reduced_mag = cls.calculate_reduced_mag( - cls, data_table["mag"], data_table["topocentricDist"], data_table["heliocentricDist"] - ) + mag = get_from_table(data_table, "mag", "array") + magErr = get_from_table(data_table, "magErr", "array") + midpointMjdTai = get_from_table(data_table, "midPointMjdTai", "array") + ra = get_from_table(data_table, "ra", "array") + dec = get_from_table(data_table, "dec", "array") + phaseAngle = get_from_table(data_table, "phaseAngle", "array") + topocentricDist = get_from_table(data_table, "topocentricDist", "array") + heliocentricDist = get_from_table(data_table, "heliocentricDist", "array") + + reduced_mag = cls.calculate_reduced_mag(cls, mag, topocentricDist, heliocentricDist) return cls( ssObjectId, filter_name, - data_table["mag"], - data_table["magErr"], - data_table["midpointMjdTai"], - data_table["ra"], - data_table["dec"], - data_table["phaseAngle"], - data_table["topocentricDist"], - data_table["heliocentricDist"], + mag, + magErr, + midpointMjdTai, + ra, + dec, + phaseAngle, + topocentricDist, + heliocentricDist, reduced_mag, len(data_table), ) diff --git a/src/adler/dataclasses/SSObject.py b/src/adler/dataclasses/SSObject.py index 0b1e1fd..45d494e 100644 --- a/src/adler/dataclasses/SSObject.py +++ b/src/adler/dataclasses/SSObject.py @@ -86,9 +86,9 @@ def construct_from_data_table(cls, ssObjectId, filter_list, data_table): for i, filter in enumerate(filter_list): H[i] = get_from_table(data_table, filter + "_H", "float") G12[i] = get_from_table(data_table, filter + "_G12", "float") - Herr[i] = get_from_table(data_table, filter + "_Herr", "float") - G12err[i] = get_from_table(data_table, filter + "_G12err", "float") - nData[i] = get_from_table(data_table, filter + "_nData", "int") + Herr[i] = get_from_table(data_table, filter + "_HErr", "float") + G12err[i] = get_from_table(data_table, filter + "_G12Err", "float") + nData[i] = get_from_table(data_table, filter + "_Ndata", "int") maxExtendedness = get_from_table(data_table, "maxExtendedness", "float") minExtendedness = get_from_table(data_table, "minExtendedness", "float") @@ -110,19 +110,3 @@ def construct_from_data_table(cls, ssObjectId, filter_list, data_table): minExtendedness, medianExtendedness, ) - - def populate_from_table(self, data_table): - """Populates the SSObject object from the data_table class variable created on initialisation.""" - - self.discoverySubmissionDate = self.get_from_table(data_table, "discoverySubmissionDate", "float") - self.firstObservationDate = self.get_from_table(data_table, "firstObservationDate", "float") - self.arc = self.get_from_table(data_table, "arc", "float") - self.numObs = self.get_from_table(data_table, "numObs", "int") - self.r_H = self.get_from_table(data_table, "r_H", "float") - self.r_G12 = self.get_from_table(data_table, "r_G12", "float") - self.r_Herr = self.get_from_table(data_table, "r_Herr", "float") - self.r_G12Err = self.get_from_table(data_table, "r_G12err", "float") - self.r_nData = self.get_from_table(data_table, "r_nData", "int") - self.maxExtendedness = self.get_from_table(data_table, "maxExtendedness", "float") - self.minExtendedness = self.get_from_table(data_table, "minExtendedness", "float") - self.medianExtendedness = self.get_from_table(data_table, "medianExtendedness", "float") diff --git a/src/adler/dataclasses/dataclass_utilities.py b/src/adler/dataclasses/dataclass_utilities.py index 04372c3..e13d912 100644 --- a/src/adler/dataclasses/dataclass_utilities.py +++ b/src/adler/dataclasses/dataclass_utilities.py @@ -1,4 +1,6 @@ import numpy as np +import pandas as pd +import sqlite3 def get_data_table(sql_query, service=None, sql_filename=None): @@ -11,16 +13,16 @@ def get_data_table(sql_query, service=None, sql_filename=None): sql_query : str The SQL query made to the RSP or SQL database. - service : pyvo.dal.tap.TAPService object + service : pyvo.dal.tap.TAPService object or None TAPService object linked to the RSP. Default=None. - sql_filename : str + sql_filename : str or None Filepath to a SQL database. Default=None. Returns ----------- - data_table : DALResultsTable + data_table : DALResultsTable or Pandas dataframe Data table containing the results of the SQL query. """ @@ -28,8 +30,16 @@ def get_data_table(sql_query, service=None, sql_filename=None): if service: data_table = service.search(sql_query) elif sql_filename: - # to-do - pass + cnx = sqlite3.connect(sql_filename) + data_table = pd.read_sql_query( + sql_query, cnx + ) # would really like to move away from Pandas for this... + with pd.option_context( + "future.no_silent_downcasting", True + ): # suppresses a useless FutureWarning: the below line accounts for the warned behaviour already + data_table = data_table.fillna(value=np.nan).infer_objects( + copy=False + ) # changes Nones to NaNs because None forces dtype=object: bad. return data_table From cab25ecf9bdb188f4148a9067bb20e5f32dcd9cb Mon Sep 17 00:00:00 2001 From: Steph Merritt Date: Tue, 19 Mar 2024 17:10:43 +0000 Subject: [PATCH 02/18] Removing databases from gitignore --- .gitignore | 2 -- 1 file changed, 2 deletions(-) diff --git a/.gitignore b/.gitignore index a7b6b17..1558b2c 100644 --- a/.gitignore +++ b/.gitignore @@ -164,5 +164,3 @@ cython_debug/ # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ -# ignore large db files -*.db From ec583a8e3b3c2433ea6321a556d6071d0973d150 Mon Sep 17 00:00:00 2001 From: Stephanie Merritt Date: Tue, 19 Mar 2024 17:12:03 +0000 Subject: [PATCH 03/18] Adding testing database. --- tests/data/testing_database.db | Bin 0 -> 57344 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 tests/data/testing_database.db diff --git a/tests/data/testing_database.db b/tests/data/testing_database.db new file mode 100644 index 0000000000000000000000000000000000000000..7a220e3bcffdbc65f92490b11c691334da75d150 GIT binary patch literal 57344 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 literal 0 HcmV?d00001 From 06efcb9a9eec8d0bae8ae44a3628b595ab52d703 Mon Sep 17 00:00:00 2001 From: Steph Merritt Date: Tue, 26 Mar 2024 12:13:16 +0000 Subject: [PATCH 04/18] unit tests for AdlerPlanetoid --- src/adler/dataclasses/AdlerPlanetoid.py | 2 +- src/adler/utilities/tests_utilities.py | 17 +++ .../adler/dataclasses/test_AdlerPlanetoid.py | 107 ++++++++++++++++++ 3 files changed, 125 insertions(+), 1 deletion(-) create mode 100644 src/adler/utilities/tests_utilities.py create mode 100644 tests/adler/dataclasses/test_AdlerPlanetoid.py diff --git a/src/adler/dataclasses/AdlerPlanetoid.py b/src/adler/dataclasses/AdlerPlanetoid.py index 0865cf1..060b0de 100644 --- a/src/adler/dataclasses/AdlerPlanetoid.py +++ b/src/adler/dataclasses/AdlerPlanetoid.py @@ -98,7 +98,7 @@ def construct_from_SQL( @classmethod def construct_from_RSP( cls, ssObjectId, filter_list=["u", "g", "r", "i", "z", "y"], date_range=[60000.0, 67300.0] - ): + ): # pragma: no cover """Custom constructor which builds the AdlerPlanetoid object and the associated Observations, MPCORB and SSObject objects from the RSP. diff --git a/src/adler/utilities/tests_utilities.py b/src/adler/utilities/tests_utilities.py new file mode 100644 index 0000000..9d20388 --- /dev/null +++ b/src/adler/utilities/tests_utilities.py @@ -0,0 +1,17 @@ +import os +from pathlib import Path + + +def get_test_data_path(): + # This file's path: `/src/sorcha/utilities/test_data_utilities.py` + # THIS_DIR = `/` + THIS_DIR = Path(__file__).parent.parent.parent.parent + + # Returned path: `/tests/data/filename` + return os.path.join(THIS_DIR, "tests/data") + + +def get_test_data_filepath(filename): + filepath = get_test_data_path() + + return os.path.join(filepath, filename) diff --git a/tests/adler/dataclasses/test_AdlerPlanetoid.py b/tests/adler/dataclasses/test_AdlerPlanetoid.py new file mode 100644 index 0000000..a92b777 --- /dev/null +++ b/tests/adler/dataclasses/test_AdlerPlanetoid.py @@ -0,0 +1,107 @@ +import numpy as np +from numpy.testing import assert_almost_equal + +from adler.utilities.tests_utilities import get_test_data_filepath +from adler.dataclasses.AdlerPlanetoid import AdlerPlanetoid + + +ssoid = 8268570668335894776 +test_db_path = get_test_data_filepath("testing_database.db") + + +def test_construct_from_SQL(): + test_planetoid = AdlerPlanetoid.construct_from_SQL(ssoid, test_db_path) + + # testing just a few values here to ensure correct setup: these objects have their own unit tests + assert test_planetoid.MPCORB.mpcH == 19.8799991607666 + assert test_planetoid.SSObject.discoverySubmissionDate == 60218.0 + assert_almost_equal( + test_planetoid.observations_by_filter[1].mag, + [ + 21.33099937, + 22.67099953, + 23.5359993, + 22.85000038, + 22.97599983, + 22.94499969, + 23.13599968, + 23.19400024, + 23.1609993, + ], + ) + + # did we pick up all the filters? + assert len(test_planetoid.observations_by_filter) == 6 + assert len(test_planetoid.SSObject.H) == 6 + assert test_planetoid.filter_list == ["u", "g", "r", "i", "z", "y"] + + # checking the date range to ensure it's the default + assert test_planetoid.date_range == [60000.0, 67300.0] + + +def test_construct_with_single_filter(): + test_planetoid = AdlerPlanetoid.construct_from_SQL(ssoid, test_db_path, filter_list=["g"]) + + # should only be one filter in here now + assert len(test_planetoid.observations_by_filter) == 1 + assert len(test_planetoid.SSObject.H) == 1 + assert test_planetoid.filter_list == ["g"] + + assert_almost_equal( + test_planetoid.observations_by_filter[0].mag, + [ + 21.33099937, + 22.67099953, + 23.5359993, + 22.85000038, + 22.97599983, + 22.94499969, + 23.13599968, + 23.19400024, + 23.1609993, + ], + ) + + +def test_construct_with_date_range(): + test_planetoid = AdlerPlanetoid.construct_from_SQL( + ssoid, test_db_path, filter_list=["r"], date_range=[61000.0, 62000.0] + ) + + expected_dates = np.array( + [ + 61294.15865, + 61322.07319, + 61323.00925, + 61326.03134, + 61329.00043, + 61330.01524, + 61355.02232, + 61355.02277, + 61253.97055, + 61253.96744, + 61253.96433, + 61052.13729, + ] + ) + + assert_almost_equal(test_planetoid.observations_by_filter[0].midpointMjdTai, expected_dates) + + +def test_observations_in_filter(): + test_planetoid = AdlerPlanetoid.construct_from_SQL(ssoid, test_db_path) + + assert_almost_equal( + test_planetoid.observations_in_filter("g").mag, + [ + 21.33099937, + 22.67099953, + 23.5359993, + 22.85000038, + 22.97599983, + 22.94499969, + 23.13599968, + 23.19400024, + 23.1609993, + ], + ) From d33720126fcf37c23a8aff8760b56b1626db8f1c Mon Sep 17 00:00:00 2001 From: Steph Merritt Date: Tue, 26 Mar 2024 12:16:00 +0000 Subject: [PATCH 05/18] Creating .coveragerc file. --- .coveragerc | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 .coveragerc diff --git a/.coveragerc b/.coveragerc new file mode 100644 index 0000000..6f5f2ad --- /dev/null +++ b/.coveragerc @@ -0,0 +1,3 @@ +[report] +exclude_also = + # pragma: no cover \ No newline at end of file From 07eb82069576c3d3bcc07215824f78871e8a5eb4 Mon Sep 17 00:00:00 2001 From: Steph Merritt Date: Tue, 26 Mar 2024 12:24:50 +0000 Subject: [PATCH 06/18] pathing issues --- src/adler/utilities/tests_utilities.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/adler/utilities/tests_utilities.py b/src/adler/utilities/tests_utilities.py index 9d20388..92df937 100644 --- a/src/adler/utilities/tests_utilities.py +++ b/src/adler/utilities/tests_utilities.py @@ -3,12 +3,13 @@ def get_test_data_path(): - # This file's path: `/src/sorcha/utilities/test_data_utilities.py` - # THIS_DIR = `/` - THIS_DIR = Path(__file__).parent.parent.parent.parent + # where is this file? + path_to_file = os.path.abspath(__file__) - # Returned path: `/tests/data/filename` - return os.path.join(THIS_DIR, "tests/data") + # the test data folder is thus: + path_to_data = os.path.join(str(Path(path_to_file).parents[3]), "tests/data/") + + return path_to_data def get_test_data_filepath(filename): From d58b221c6ce759b0e394dfb27f89a2589d6ac257 Mon Sep 17 00:00:00 2001 From: Steph Merritt Date: Tue, 26 Mar 2024 12:39:11 +0000 Subject: [PATCH 07/18] modifying init --- src/adler/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/adler/__init__.py b/src/adler/__init__.py index 25b7585..443fa66 100644 --- a/src/adler/__init__.py +++ b/src/adler/__init__.py @@ -1,2 +1,3 @@ from . import dataclasses from . import science +from . import utilities From 894cfdfece240a065c57b7021d11a10ea59cb48b Mon Sep 17 00:00:00 2001 From: Steph Merritt Date: Tue, 26 Mar 2024 12:46:12 +0000 Subject: [PATCH 08/18] more inits --- src/adler/dataclasses/__init__.py | 6 ++++++ src/adler/science/__init__.py | 1 + src/adler/utilities/__init__.py | 1 + 3 files changed, 8 insertions(+) create mode 100644 src/adler/dataclasses/__init__.py create mode 100644 src/adler/science/__init__.py create mode 100644 src/adler/utilities/__init__.py diff --git a/src/adler/dataclasses/__init__.py b/src/adler/dataclasses/__init__.py new file mode 100644 index 0000000..9b7a7df --- /dev/null +++ b/src/adler/dataclasses/__init__.py @@ -0,0 +1,6 @@ +from . import AdlerData +from . import Observations +from . import dataclass_utilities +from . import MPCORB +from . import AdlerPlanetoid +from . import SSObject diff --git a/src/adler/science/__init__.py b/src/adler/science/__init__.py new file mode 100644 index 0000000..3a3d202 --- /dev/null +++ b/src/adler/science/__init__.py @@ -0,0 +1 @@ +from . import PhaseCurve diff --git a/src/adler/utilities/__init__.py b/src/adler/utilities/__init__.py new file mode 100644 index 0000000..13dbd9e --- /dev/null +++ b/src/adler/utilities/__init__.py @@ -0,0 +1 @@ +from . import tests_utilities From e356aee12f91e19542baa33a0417ef56a7256302 Mon Sep 17 00:00:00 2001 From: Steph Merritt Date: Tue, 26 Mar 2024 12:56:08 +0000 Subject: [PATCH 09/18] editing workflow --- .github/workflows/testing-and-coverage.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/testing-and-coverage.yml b/.github/workflows/testing-and-coverage.yml index 3e67786..97bb48b 100644 --- a/.github/workflows/testing-and-coverage.yml +++ b/.github/workflows/testing-and-coverage.yml @@ -27,8 +27,8 @@ jobs: run: | sudo apt-get update python -m pip install --upgrade pip - pip install . - pip install .[dev] + pip install -e . + pip install -e .[dev] if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - name: Run unit tests with pytest run: | From bf84d19dd465d2f5c27450950a0f753ff439bc77 Mon Sep 17 00:00:00 2001 From: Steph Merritt Date: Tue, 26 Mar 2024 13:19:46 +0000 Subject: [PATCH 10/18] Suppressing warning manually. --- src/adler/dataclasses/dataclass_utilities.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/adler/dataclasses/dataclass_utilities.py b/src/adler/dataclasses/dataclass_utilities.py index e13d912..8f4b377 100644 --- a/src/adler/dataclasses/dataclass_utilities.py +++ b/src/adler/dataclasses/dataclass_utilities.py @@ -1,6 +1,7 @@ import numpy as np import pandas as pd import sqlite3 +import warnings def get_data_table(sql_query, service=None, sql_filename=None): @@ -34,9 +35,12 @@ def get_data_table(sql_query, service=None, sql_filename=None): data_table = pd.read_sql_query( sql_query, cnx ) # would really like to move away from Pandas for this... - with pd.option_context( - "future.no_silent_downcasting", True - ): # suppresses a useless FutureWarning: the below line accounts for the warned behaviour already + + # Pandas is triggering a useless FutureWarning here which I am choosing to suppress. + # The code is already written to account for the FutureWarning, but it triggers anyway. Thanks, Pandas. + # Note that pd.option_context("future.no_silent_downcasting", True) would also work, but only for Pandas >2.0.3. + with warnings.catch_warnings(): + warnings.filterwarnings("ignore", category=FutureWarning) data_table = data_table.fillna(value=np.nan).infer_objects( copy=False ) # changes Nones to NaNs because None forces dtype=object: bad. From 4c31b4945814b3a3bb505cc5dfbe59c40ba67747 Mon Sep 17 00:00:00 2001 From: Steph Merritt Date: Tue, 26 Mar 2024 14:03:37 +0000 Subject: [PATCH 11/18] Adding test for Observations class. --- src/adler/dataclasses/Observations.py | 18 +- tests/adler/dataclasses/test_Observations.py | 184 +++++++++++++++++++ 2 files changed, 193 insertions(+), 9 deletions(-) create mode 100644 tests/adler/dataclasses/test_Observations.py diff --git a/src/adler/dataclasses/Observations.py b/src/adler/dataclasses/Observations.py index b28356d..77768f6 100644 --- a/src/adler/dataclasses/Observations.py +++ b/src/adler/dataclasses/Observations.py @@ -52,15 +52,15 @@ class Observations: ssObjectId: str = "" filter_name: str = "" - mag: np.ndarray = field(default_factory=np.zeros(0)) - magErr: np.ndarray = field(default_factory=np.zeros(0)) - midpointMjdTai: np.ndarray = field(default_factory=np.zeros(0)) - ra: np.ndarray = field(default_factory=np.zeros(0)) - dec: np.ndarray = field(default_factory=np.zeros(0)) - phaseAngle: np.ndarray = field(default_factory=np.zeros(0)) - topocentricDist: np.ndarray = field(default_factory=np.zeros(0)) - heliocentricDist: np.ndarray = field(default_factory=np.zeros(0)) - reduced_mag: np.ndarray = field(default_factory=np.zeros(0)) + mag: np.ndarray = field(default_factory=lambda: np.zeros(0)) + magErr: np.ndarray = field(default_factory=lambda: np.zeros(0)) + midpointMjdTai: np.ndarray = field(default_factory=lambda: np.zeros(0)) + ra: np.ndarray = field(default_factory=lambda: np.zeros(0)) + dec: np.ndarray = field(default_factory=lambda: np.zeros(0)) + phaseAngle: np.ndarray = field(default_factory=lambda: np.zeros(0)) + topocentricDist: np.ndarray = field(default_factory=lambda: np.zeros(0)) + heliocentricDist: np.ndarray = field(default_factory=lambda: np.zeros(0)) + reduced_mag: np.ndarray = field(default_factory=lambda: np.zeros(0)) num_obs: int = 0 @classmethod diff --git a/tests/adler/dataclasses/test_Observations.py b/tests/adler/dataclasses/test_Observations.py new file mode 100644 index 0000000..e90fe89 --- /dev/null +++ b/tests/adler/dataclasses/test_Observations.py @@ -0,0 +1,184 @@ +from numpy.testing import assert_almost_equal +import numpy as np + +from adler.dataclasses.Observations import Observations +from adler.dataclasses.dataclass_utilities import get_data_table +from adler.utilities.tests_utilities import get_test_data_filepath + + +def test_populate_from_data_table(): + ssoid = 8268570668335894776 + test_db_path = get_test_data_filepath("testing_database.db") + schema = "" + filter_name = "r" + date_range = [61000.0, 62000.0] + + test_query = f""" + SELECT + ssObject.ssObjectId, mag, magErr, band, midPointMjdTai, ra, dec, phaseAngle, + topocentricDist, heliocentricDist + FROM + ssObject + JOIN {schema}diaSource ON {schema}ssObject.ssObjectId = {schema}diaSource.ssObjectId + JOIN {schema}ssSource ON {schema}diaSource.diaSourceId = {schema}ssSource.diaSourceId + WHERE + ssObject.ssObjectId = {ssoid} AND band = '{filter_name}' AND midPointMjdTai BETWEEN {date_range[0]} AND {date_range[1]} + """ + + data_table = get_data_table(test_query, sql_filename=test_db_path) + test_observations = Observations.construct_from_data_table(ssoid, filter_name, data_table) + + expected_mag = np.array( + [ + 20.4470005, + 22.24799919, + 22.27599907, + 22.29100037, + 22.66200066, + 22.69799995, + 23.56800079, + 23.70199966, + 22.22900009, + 22.04899979, + 22.17700005, + 23.52199936, + ] + ) + expected_magerr = np.array( + [0.011, 0.046, 0.06, 0.082, 0.083, 0.063, 0.17200001, 0.199, 0.264, 0.28299999, 0.31600001, 0.163] + ) + expected_mjd = np.array( + [ + 61294.15865, + 61322.07319, + 61323.00925, + 61326.03134, + 61329.00043, + 61330.01524, + 61355.02232, + 61355.02277, + 61253.97055, + 61253.96744, + 61253.96433, + 61052.13729, + ] + ) + expected_ra = np.array( + [ + 301.5682143, + 315.2799036, + 315.6390597, + 316.7793075, + 317.8804823, + 318.2527231, + 327.0967385, + 327.0968451, + 170.4323598, + 170.4247983, + 170.4172297, + 62.6767601, + ] + ) + expected_dec = np.array( + [ + -17.709034, + -13.7156598, + -13.6098197, + -13.2712987, + -12.9420707, + -12.8300092, + -10.035292, + -10.0351984, + -3.6550378, + -3.6513877, + -3.6478445, + 27.0535373, + ] + ) + expected_phaseangle = np.array( + [ + 33.56268311, + 32.00559616, + 31.97466469, + 31.86707687, + 31.74268913, + 31.69605255, + 29.76596832, + 29.76592445, + 126.7827301, + 126.78705597, + 126.79136658, + 18.63666534, + ] + ) + expected_heliodist = np.array( + [ + 1.35723567, + 1.66025329, + 1.66984999, + 1.70058703, + 1.73042095, + 1.74053574, + 1.97701716, + 1.97702122, + 0.87671232, + 0.87667543, + 0.87663853, + 2.21820784, + ] + ) + expected_topodist = np.array( + [ + 0.45957258, + 0.93472457, + 0.95206416, + 1.00859618, + 1.06491303, + 1.08432984, + 1.58487654, + 1.58488584, + 0.20776999, + 0.20780498, + 0.20783997, + 1.4200809, + ] + ) + expected_reduced_mag = np.array( + [ + 21.47195362, + 21.29370916, + 21.2692807, + 21.11941945, + 21.33467112, + 21.31877818, + 21.08797141, + 21.22195309, + 25.92680044, + 25.74652589, + 25.87425196, + 21.03042275, + ] + ) + + assert_almost_equal(test_observations.mag, expected_mag) + assert_almost_equal(test_observations.magErr, expected_magerr) + assert_almost_equal(test_observations.midpointMjdTai, expected_mjd) + assert_almost_equal(test_observations.ra, expected_ra) + assert_almost_equal(test_observations.dec, expected_dec) + assert_almost_equal(test_observations.phaseAngle, expected_phaseangle) + assert_almost_equal(test_observations.heliocentricDist, expected_heliodist) + assert_almost_equal(test_observations.topocentricDist, expected_topodist) + assert_almost_equal(test_observations.reduced_mag, expected_reduced_mag) + + +def test_calculate_reduced_mag(): + test_object = Observations( + mag=np.array([20]), topocentricDist=np.array([0.5]), heliocentricDist=np.array([1.5]) + ) + reduced_mag = test_object.calculate_reduced_mag( + test_object.mag, test_object.topocentricDist, test_object.heliocentricDist + )[0] + + expected_reduced_mag = 20.0 - 5 * np.log10(0.5 * 1.5) + + assert_almost_equal(reduced_mag, expected_reduced_mag) From 14458d8d9a735fe71b37d2c9ede689b6364708fd Mon Sep 17 00:00:00 2001 From: Steph Merritt Date: Tue, 26 Mar 2024 14:21:41 +0000 Subject: [PATCH 12/18] Unit test for MPCORB object --- tests/adler/dataclasses/test_Observations.py | 2 +- tests/adler/test_MPCORB.py | 41 ++++++++++++++++++++ 2 files changed, 42 insertions(+), 1 deletion(-) create mode 100644 tests/adler/test_MPCORB.py diff --git a/tests/adler/dataclasses/test_Observations.py b/tests/adler/dataclasses/test_Observations.py index e90fe89..7ec9a02 100644 --- a/tests/adler/dataclasses/test_Observations.py +++ b/tests/adler/dataclasses/test_Observations.py @@ -6,7 +6,7 @@ from adler.utilities.tests_utilities import get_test_data_filepath -def test_populate_from_data_table(): +def test_construct_observations_from_data_table(): ssoid = 8268570668335894776 test_db_path = get_test_data_filepath("testing_database.db") schema = "" diff --git a/tests/adler/test_MPCORB.py b/tests/adler/test_MPCORB.py new file mode 100644 index 0000000..d79c117 --- /dev/null +++ b/tests/adler/test_MPCORB.py @@ -0,0 +1,41 @@ +from numpy.testing import assert_almost_equal +import numpy as np + +from adler.dataclasses.MPCORB import MPCORB +from adler.dataclasses.dataclass_utilities import get_data_table +from adler.utilities.tests_utilities import get_test_data_filepath + + +def test_construct_MPCORB_from_data_table(): + ssoid = 8268570668335894776 + test_db_path = get_test_data_filepath("testing_database.db") + schema = "" + + test_query = f""" + SELECT + ssObjectId, mpcDesignation, mpcNumber, mpcH, mpcG, epoch, peri, node, incl, e, n, q, + uncertaintyParameter, flags + FROM + {schema}MPCORB + WHERE + ssObjectId = {ssoid} + """ + + data_table = get_data_table(test_query, sql_filename=test_db_path) + test_MPCORB = MPCORB.construct_from_data_table(ssoid, data_table) + + assert test_MPCORB.ssObjectId == 8268570668335894776 + assert test_MPCORB.mpcDesignation == "2014 QL4" + assert test_MPCORB.mpcNumber == 0 + assert_almost_equal(test_MPCORB.mpcH, 19.8799991607666, decimal=6) + assert_almost_equal(test_MPCORB.mpcG, 0.15000000596046448, decimal=6) + assert_almost_equal(test_MPCORB.epoch, 60065.0, decimal=6) + assert_almost_equal(test_MPCORB.peri, 260.5468204162153, decimal=6) + assert_almost_equal(test_MPCORB.node, 322.8059, decimal=6) + assert_almost_equal(test_MPCORB.incl, 4.427569999999975, decimal=6) + assert_almost_equal(test_MPCORB.e, 0.7168805704972735, decimal=6) + assert_almost_equal(test_MPCORB.e, 0.7168805704972735, decimal=6) + assert np.isnan(test_MPCORB.n) + assert_almost_equal(test_MPCORB.q, 0.5898291078470536, decimal=6) + assert test_MPCORB.uncertaintyParameter == "" + assert test_MPCORB.flags == "0" From c0eeb0e48b7221dd70f33c5b03922de549d0d7d6 Mon Sep 17 00:00:00 2001 From: Steph Merritt Date: Tue, 26 Mar 2024 14:34:37 +0000 Subject: [PATCH 13/18] adding MPCORB unit test --- src/adler/dataclasses/SSObject.py | 10 ++-- tests/adler/dataclasses/test_Observations.py | 5 +- tests/adler/dataclasses/test_SSObject.py | 52 ++++++++++++++++++++ tests/adler/test_MPCORB.py | 3 +- 4 files changed, 60 insertions(+), 10 deletions(-) create mode 100644 tests/adler/dataclasses/test_SSObject.py diff --git a/src/adler/dataclasses/SSObject.py b/src/adler/dataclasses/SSObject.py index 45d494e..d86414c 100644 --- a/src/adler/dataclasses/SSObject.py +++ b/src/adler/dataclasses/SSObject.py @@ -61,11 +61,11 @@ class SSObject: firstObservationDate: float = 0.0 arc: float = 0.0 numObs: int = 0 - H: np.ndarray = field(default_factory=np.zeros(0)) - G12: np.ndarray = field(default_factory=np.zeros(0)) - Herr: np.ndarray = field(default_factory=np.zeros(0)) - G12err: np.ndarray = field(default_factory=np.zeros(0)) - nData: np.ndarray = field(default_factory=np.zeros(0)) + H: np.ndarray = field(default_factory=lambda: np.zeros(0)) + G12: np.ndarray = field(default_factory=lambda: np.zeros(0)) + Herr: np.ndarray = field(default_factory=lambda: np.zeros(0)) + G12err: np.ndarray = field(default_factory=lambda: np.zeros(0)) + nData: np.ndarray = field(default_factory=lambda: np.zeros(0)) maxExtendedness: float = 0.0 minExtendedness: float = 0.0 medianExtendedness: float = 0.0 diff --git a/tests/adler/dataclasses/test_Observations.py b/tests/adler/dataclasses/test_Observations.py index 7ec9a02..24c2b25 100644 --- a/tests/adler/dataclasses/test_Observations.py +++ b/tests/adler/dataclasses/test_Observations.py @@ -9,7 +9,6 @@ def test_construct_observations_from_data_table(): ssoid = 8268570668335894776 test_db_path = get_test_data_filepath("testing_database.db") - schema = "" filter_name = "r" date_range = [61000.0, 62000.0] @@ -19,8 +18,8 @@ def test_construct_observations_from_data_table(): topocentricDist, heliocentricDist FROM ssObject - JOIN {schema}diaSource ON {schema}ssObject.ssObjectId = {schema}diaSource.ssObjectId - JOIN {schema}ssSource ON {schema}diaSource.diaSourceId = {schema}ssSource.diaSourceId + JOIN diaSource ON ssObject.ssObjectId = diaSource.ssObjectId + JOIN ssSource ON diaSource.diaSourceId = ssSource.diaSourceId WHERE ssObject.ssObjectId = {ssoid} AND band = '{filter_name}' AND midPointMjdTai BETWEEN {date_range[0]} AND {date_range[1]} """ diff --git a/tests/adler/dataclasses/test_SSObject.py b/tests/adler/dataclasses/test_SSObject.py new file mode 100644 index 0000000..f4121e4 --- /dev/null +++ b/tests/adler/dataclasses/test_SSObject.py @@ -0,0 +1,52 @@ +from numpy.testing import assert_almost_equal +from numpy.testing import assert_equal +import numpy as np + +from adler.utilities.tests_utilities import get_test_data_filepath +from adler.dataclasses.dataclass_utilities import get_data_table +from adler.dataclasses.SSObject import SSObject + + +def test_construct_SSObject_from_data_table(): + ssoid = 8268570668335894776 + test_db_path = get_test_data_filepath("testing_database.db") + + filter_list = ["r", "g"] + + filter_dependent_columns = "" + + for filter_name in filter_list: + filter_string = "{}_H, {}_G12, {}_HErr, {}_G12Err, {}_Ndata, ".format( + filter_name, filter_name, filter_name, filter_name, filter_name + ) + + filter_dependent_columns += filter_string + + test_query = f""" + SELECT + discoverySubmissionDate, firstObservationDate, arc, numObs, + {filter_dependent_columns} + maxExtendedness, minExtendedness, medianExtendedness + FROM + SSObject + WHERE + ssObjectId = {ssoid} + """ + + data_table = get_data_table(test_query, sql_filename=test_db_path) + test_SSObject = SSObject.construct_from_data_table(ssoid, filter_list, data_table) + + assert test_SSObject.ssObjectId == 8268570668335894776 + assert test_SSObject.filter_list == filter_list + assert_almost_equal(test_SSObject.discoverySubmissionDate, 60218.0, decimal=6) + assert_almost_equal(test_SSObject.firstObservationDate, 60220.01958, decimal=6) + assert_almost_equal(test_SSObject.arc, 3342.05859375, decimal=6) + assert test_SSObject.numObs == 94 + assert_almost_equal(test_SSObject.H, [19.80589294, 20.29232597], decimal=6) + assert_almost_equal(test_SSObject.G12, [1.52932608, 1.72339332], decimal=6) + assert_almost_equal(test_SSObject.Herr, [0.01974303, 0.0302103], decimal=6) + assert_almost_equal(test_SSObject.G12err, [0.05071714, 0.04049731], decimal=6) + assert_equal(test_SSObject.nData, [38.0, 9.0]) + assert_equal(test_SSObject.maxExtendedness, 0.0) + assert_equal(test_SSObject.minExtendedness, 0.0) + assert_equal(test_SSObject.medianExtendedness, 0.0) diff --git a/tests/adler/test_MPCORB.py b/tests/adler/test_MPCORB.py index d79c117..f94db75 100644 --- a/tests/adler/test_MPCORB.py +++ b/tests/adler/test_MPCORB.py @@ -9,14 +9,13 @@ def test_construct_MPCORB_from_data_table(): ssoid = 8268570668335894776 test_db_path = get_test_data_filepath("testing_database.db") - schema = "" test_query = f""" SELECT ssObjectId, mpcDesignation, mpcNumber, mpcH, mpcG, epoch, peri, node, incl, e, n, q, uncertaintyParameter, flags FROM - {schema}MPCORB + MPCORB WHERE ssObjectId = {ssoid} """ From 5a0f280e5a22a511a55419727a9fbb5cff41ea6c Mon Sep 17 00:00:00 2001 From: Steph Merritt Date: Tue, 26 Mar 2024 14:38:03 +0000 Subject: [PATCH 14/18] docstrings for test utility functions --- src/adler/utilities/tests_utilities.py | 28 ++++++++++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/src/adler/utilities/tests_utilities.py b/src/adler/utilities/tests_utilities.py index 92df937..6f4d76c 100644 --- a/src/adler/utilities/tests_utilities.py +++ b/src/adler/utilities/tests_utilities.py @@ -2,7 +2,16 @@ from pathlib import Path -def get_test_data_path(): +def get_test_data_path(): # pragma: no cover + """Gets the absolute path of the tests/data directory. + + Returns + ----------- + path_to_data : str + The absolute path to the tests/data directory. + + """ + # where is this file? path_to_file = os.path.abspath(__file__) @@ -12,7 +21,22 @@ def get_test_data_path(): return path_to_data -def get_test_data_filepath(filename): +def get_test_data_filepath(filename): # pragma: no cover + """Gets the absolute path of a supplied file in the tests/data directory. + + + Parameters + ----------- + filename : str + The filename of the desired test file. + + Returns + ----------- + str + The absolute path to the specified file in the tests/data directory. + + """ + filepath = get_test_data_path() return os.path.join(filepath, filename) From d57910697330f730d3711cea1c60cb19c4950a88 Mon Sep 17 00:00:00 2001 From: Steph Merritt Date: Tue, 26 Mar 2024 15:52:16 +0000 Subject: [PATCH 15/18] Unit test for dataclass utils. --- src/adler/dataclasses/dataclass_utilities.py | 4 +- .../dataclasses/test_dataclass_utilities.py | 56 +++++++++++++++++++ tests/data/test_dataclass_utilities_table.csv | 13 +++++ 3 files changed, 72 insertions(+), 1 deletion(-) create mode 100644 tests/adler/dataclasses/test_dataclass_utilities.py create mode 100644 tests/data/test_dataclass_utilities_table.csv diff --git a/src/adler/dataclasses/dataclass_utilities.py b/src/adler/dataclasses/dataclass_utilities.py index 8f4b377..9cbf89b 100644 --- a/src/adler/dataclasses/dataclass_utilities.py +++ b/src/adler/dataclasses/dataclass_utilities.py @@ -74,6 +74,8 @@ def get_from_table(data_table, column_name, data_type): elif data_type == "array": return np.array(data_table[column_name]) else: - print("Type not recognised.") + raise TypeError( + "Type for argument data_type not recognised: must be one of 'str', 'float', 'int', 'array'." + ) except ValueError: raise ValueError("Could not cast column name to type.") diff --git a/tests/adler/dataclasses/test_dataclass_utilities.py b/tests/adler/dataclasses/test_dataclass_utilities.py new file mode 100644 index 0000000..dfae4b7 --- /dev/null +++ b/tests/adler/dataclasses/test_dataclass_utilities.py @@ -0,0 +1,56 @@ +import pytest +import pandas as pd +from pandas.testing import assert_frame_equal +from numpy.testing import assert_equal + +from adler.dataclasses.dataclass_utilities import get_data_table +from adler.dataclasses.dataclass_utilities import get_from_table +from adler.utilities.tests_utilities import get_test_data_filepath + + +def test_get_data_table(): + ssoid = 8268570668335894776 + test_db_path = get_test_data_filepath("testing_database.db") + filter_name = "r" + date_range = [61000.0, 62000.0] + + test_query = f""" + SELECT + ssObject.ssObjectId, mag, magErr, band, midPointMjdTai, ra, dec, phaseAngle, + topocentricDist, heliocentricDist + FROM + ssObject + JOIN diaSource ON ssObject.ssObjectId = diaSource.ssObjectId + JOIN ssSource ON diaSource.diaSourceId = ssSource.diaSourceId + WHERE + ssObject.ssObjectId = {ssoid} AND band = '{filter_name}' AND midPointMjdTai BETWEEN {date_range[0]} AND {date_range[1]} + """ + + data_table = get_data_table(test_query, sql_filename=test_db_path) + + expected_table = pd.read_csv(get_test_data_filepath("test_dataclass_utilities_table.csv")) + assert_frame_equal(data_table, expected_table) + + +def test_get_from_table(): + test_table = pd.DataFrame( + {"string_col": "a test string", "int_col": 4, "float_col": 4.5, "array_col": [5, 6]} + ) + + assert get_from_table(test_table, "string_col", "str") == "a test string" + assert get_from_table(test_table, "int_col", "int") == 4 + assert get_from_table(test_table, "float_col", "float") == 4.5 + assert_equal(get_from_table(test_table, "array_col", "array"), [5, 6]) + + with pytest.raises(ValueError) as error_info_1: + get_from_table(test_table, "string_col", "int") + + assert error_info_1.value.args[0] == "Could not cast column name to type." + + with pytest.raises(TypeError) as error_info_2: + get_from_table(test_table, "string_col", "fake") + + assert ( + error_info_2.value.args[0] + == "Type for argument data_type not recognised: must be one of 'str', 'float', 'int', 'array'." + ) diff --git a/tests/data/test_dataclass_utilities_table.csv b/tests/data/test_dataclass_utilities_table.csv new file mode 100644 index 0000000..11a4dfc --- /dev/null +++ b/tests/data/test_dataclass_utilities_table.csv @@ -0,0 +1,13 @@ +ssObjectId,mag,magErr,band,midPointMjdTai,ra,dec,phaseAngle,topocentricDist,heliocentricDist +8268570668335894776,20.44700050354004,0.010999999940395355,r,61294.15865,301.5682143,-17.709034,33.56268310546875,0.45957258343696594,1.3572356700897217 +8268570668335894776,22.24799919128418,0.04600000008940697,r,61322.07319,315.2799036,-13.7156598,32.00559616088867,0.9347245693206787,1.6602532863616943 +8268570668335894776,22.275999069213867,0.05999999865889549,r,61323.00925,315.6390597,-13.6098197,31.97466468811035,0.9520641565322876,1.6698499917984009 +8268570668335894776,22.291000366210938,0.0820000022649765,r,61326.03134,316.7793075,-13.2712987,31.867076873779297,1.0085961818695068,1.7005870342254639 +8268570668335894776,22.66200065612793,0.08299999684095383,r,61329.00043,317.8804823,-12.9420707,31.74268913269043,1.064913034439087,1.7304209470748901 +8268570668335894776,22.697999954223633,0.06300000101327896,r,61330.01524,318.2527231,-12.8300092,31.69605255126953,1.0843298435211182,1.7405357360839844 +8268570668335894776,23.56800079345703,0.1720000058412552,r,61355.02232,327.0967385,-10.035292,29.765968322753906,1.584876537322998,1.9770171642303467 +8268570668335894776,23.70199966430664,0.19900000095367432,r,61355.02277,327.0968451,-10.0351984,29.76592445373535,1.584885835647583,1.9770212173461914 +8268570668335894776,22.229000091552734,0.2639999985694885,r,61253.97055,170.4323598,-3.6550378,126.78273010253906,0.2077699899673462,0.8767123222351074 +8268570668335894776,22.048999786376953,0.28299999237060547,r,61253.96744,170.4247983,-3.6513877,126.78705596923828,0.20780497789382935,0.8766754269599915 +8268570668335894776,22.177000045776367,0.3160000145435333,r,61253.96433,170.4172297,-3.6478445,126.79136657714844,0.2078399658203125,0.8766385316848755 +8268570668335894776,23.52199935913086,0.16300000250339508,r,61052.13729,62.6767601,27.0535373,18.63666534423828,1.4200809001922607,2.218207836151123 From e817b3bdfe297bada42e761e6f2c3d7733251ea6 Mon Sep 17 00:00:00 2001 From: jrob93 Date: Wed, 27 Mar 2024 17:54:21 +0000 Subject: [PATCH 16/18] example nb --- notebooks/adler_examples_local_db.ipynb | 907 ++++++++++++++++++++++++ 1 file changed, 907 insertions(+) create mode 100644 notebooks/adler_examples_local_db.ipynb diff --git a/notebooks/adler_examples_local_db.ipynb b/notebooks/adler_examples_local_db.ipynb new file mode 100644 index 0000000..691d4d2 --- /dev/null +++ b/notebooks/adler_examples_local_db.ipynb @@ -0,0 +1,907 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "d591f5d8-9148-46ff-a62b-0f2a29eb806c", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:11.533501Z", + "iopub.status.busy": "2024-02-29T16:09:11.533247Z", + "iopub.status.idle": "2024-02-29T16:09:13.062886Z", + "shell.execute_reply": "2024-02-29T16:09:13.061510Z", + "shell.execute_reply.started": "2024-02-29T16:09:11.533477Z" + } + }, + "outputs": [], + "source": [ + "from adler.dataclasses.AdlerPlanetoid import AdlerPlanetoid\n", + "from adler.science.PhaseCurve import PhaseCurve\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.gridspec as gridspec\n", + "import astropy.units as u" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "645efb98-567d-481e-a79c-b1cfdc828726", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:13.065333Z", + "iopub.status.busy": "2024-02-29T16:09:13.064482Z", + "iopub.status.idle": "2024-02-29T16:09:13.070452Z", + "shell.execute_reply": "2024-02-29T16:09:13.069235Z", + "shell.execute_reply.started": "2024-02-29T16:09:13.065297Z" + } + }, + "outputs": [], + "source": [ + "# ssObjectId of object to analyse\n", + "ssoid = \"8268570668335894776\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "10b36aab-b322-49b8-8ff3-49bef68d7416", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:13.072314Z", + "iopub.status.busy": "2024-02-29T16:09:13.071967Z", + "iopub.status.idle": "2024-02-29T16:09:14.279820Z", + "shell.execute_reply": "2024-02-29T16:09:14.278772Z", + "shell.execute_reply.started": "2024-02-29T16:09:13.072275Z" + } + }, + "outputs": [], + "source": [ + "# retrieve the object data via adler\n", + "# here we use an offline SQL database which contains the observations of the sso\n", + "fname = \"../tests/data/testing_database.db\"\n", + "planetoid = AdlerPlanetoid.construct_from_SQL(ssoid,sql_filename = fname)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d9a0623d-0dc7-49c1-99dd-a76ef970a3ff", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:14.281553Z", + "iopub.status.busy": "2024-02-29T16:09:14.281143Z", + "iopub.status.idle": "2024-02-29T16:09:14.287399Z", + "shell.execute_reply": "2024-02-29T16:09:14.286612Z", + "shell.execute_reply.started": "2024-02-29T16:09:14.281511Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'ssObjectId': '8268570668335894776',\n", + " 'filter_list': ['u', 'g', 'r', 'i', 'z', 'y'],\n", + " 'date_range': [60000.0, 67300.0],\n", + " 'observations_by_filter': [Observations(ssObjectId='8268570668335894776', filter_name='u', mag=array([], dtype=object), magErr=array([], dtype=object), midpointMjdTai=array([], dtype=object), ra=array([], dtype=object), dec=array([], dtype=object), phaseAngle=array([], dtype=object), topocentricDist=array([], dtype=object), heliocentricDist=array([], dtype=object), reduced_mag=array([], dtype=object), num_obs=0),\n", + " Observations(ssObjectId='8268570668335894776', filter_name='g', mag=array([21.33099937, 22.67099953, 23.5359993 , 22.85000038, 22.97599983,\n", + " 22.94499969, 23.13599968, 23.19400024, 23.1609993 ]), magErr=array([0.033, 0.07 , 0.141, 0.075, 0.048, 0.046, 0.068, 0.065, 0.066]), midpointMjdTai=array([62379.03985, 62414.11171, 63534.06359, 61323.17176, 60228.05559,\n", + " 60228.05606, 60229.03603, 60231.05795, 60233.03832]), ra=array([255.2300797, 304.1658794, 311.2951848, 315.6989729, 323.5328231,\n", + " 323.5329139, 323.7251118, 324.132392 , 324.5463505]), dec=array([-23.3427625, -17.1779969, -15.6242814, -13.5912723, -10.6707848,\n", + " -10.6707602, -10.6150706, -10.4964008, -10.3753228]), phaseAngle=array([63.60055161, 38.03742981, 36.49517059, 31.97113991, 27.42666817,\n", + " 27.42672539, 27.53459549, 27.73578453, 27.90441322]), topocentricDist=array([0.33790752, 0.84168053, 1.27439773, 0.95509756, 0.99907744,\n", + " 0.99908602, 1.01725268, 1.05503416, 1.09241748]), heliocentricDist=array([1.11330199, 1.51804984, 1.66657984, 1.67151237, 1.77300227,\n", + " 1.7730068 , 1.78262854, 1.80235839, 1.82152498]), reduced_mag=array([23.45394514, 22.13883298, 21.90034373, 21.83421374, 21.73445762,\n", + " 21.70343328, 21.84355119, 21.79846187, 21.66688044]), num_obs=9),\n", + " Observations(ssObjectId='8268570668335894776', filter_name='r', mag=array([21.91399956, 21.98600006, 21.75900078, 22.09399986, 21.61499977,\n", + " 21.72800064, 21.72200012, 20.4470005 , 21.78899956, 21.95899963,\n", + " 22.17900085, 22.44499969, 22.38999939, 22.92399979, 22.24799919,\n", + " 22.27599907, 22.29100037, 22.66200066, 22.69799995, 23.93300056,\n", + " 23.74200058, 22.14299965, 22.16799927, 22.24900055, 22.28499985,\n", + " 22.26199913, 22.44000053, 23.56800079, 23.70199966, 24.19499969,\n", + " 22.22900009, 22.04899979, 22.17700005, 23.52199936, 23.70199966,\n", + " 22.88699913, 23.06800079, 24.24200058]), magErr=array([0.095 , 0.049 , 0.07 , 0.047 , 0.036 ,\n", + " 0.038 , 0.034 , 0.011 , 0.052 , 0.06 ,\n", + " 0.042 , 0.098 , 0.1 , 0.116 , 0.046 ,\n", + " 0.06 , 0.082 , 0.083 , 0.063 , 0.35100001,\n", + " 0.2 , 0.057 , 0.034 , 0.036 , 0.054 ,\n", + " 0.051 , 0.046 , 0.17200001, 0.199 , 0.17 ,\n", + " 0.264 , 0.28299999, 0.31600001, 0.163 , 0.248 ,\n", + " 0.182 , 0.211 , 0.38299999]), midpointMjdTai=array([63492.00291, 63500.06856, 63479.0044 , 63502.00311, 62406.09011,\n", + " 62407.07445, 62407.09369, 61294.15865, 62412.12365, 62414.13572,\n", + " 62415.05691, 62422.06327, 62422.06596, 63534.03975, 61322.07319,\n", + " 61323.00925, 61326.03134, 61329.00043, 61330.01524, 63554.05676,\n", + " 63562.05437, 60223.98877, 60224.07621, 60226.02382, 60228.0802 ,\n", + " 60228.08066, 60230.03315, 61355.02232, 61355.02277, 60264.01472,\n", + " 61253.97055, 61253.96744, 61253.96433, 61052.13729, 63217.23761,\n", + " 62125.2233 , 62113.17449, 62095.28873]), ra=array([268.4639755, 281.1782352, 239.848597 , 283.7424099, 298.1255196,\n", + " 298.9437966, 298.9592036, 301.5682143, 302.7875618, 304.1818652,\n", + " 304.7993288, 309.1175392, 309.1190487, 311.280946 , 315.2799036,\n", + " 315.6390597, 316.7793075, 317.8804823, 318.2527231, 322.0860789,\n", + " 325.868688 , 322.7789008, 322.7931457, 323.1475474, 323.5372789,\n", + " 323.5373434, 323.9242256, 327.0967385, 327.0968451, 332.3781914,\n", + " 170.4323598, 170.4247983, 170.4172297, 62.6767601, 68.4459325,\n", + " 69.233718 , 74.6917865, 81.7128501]), dec=array([-22.9543395, -21.8517282, -21.8243507, -21.5140075, -18.6306791,\n", + " -18.443366 , -18.4396764, -17.709034 , -17.5230447, -17.1737751,\n", + " -17.0169932, -15.874741 , -15.8743016, -15.6284188, -13.7156598,\n", + " -13.6098197, -13.2712987, -12.9420707, -12.8300092, -12.3090787,\n", + " -11.0256047, -10.889507 , -10.8850457, -10.7825671, -10.6694075,\n", + " -10.6693695, -10.5571517, -10.035292 , -10.0351984, -7.9025949,\n", + " -3.6550378, -3.6513877, -3.6478445, 27.0535373, 28.5344673,\n", + " 28.6462634, 29.3204275, 29.563878 ]), phaseAngle=array([ 56.70839691, 50.07988358, 72.76689148, 48.80239868,\n", + " 40.30448914, 39.98022079, 39.97434235, 33.56268311,\n", + " 38.53084564, 38.03194427, 37.81433105, 36.34851074,\n", + " 36.34802628, 36.50101089, 32.00559616, 31.97466469,\n", + " 31.86707687, 31.74268913, 31.69605255, 31.88496971,\n", + " 30.16068649, 26.89824295, 26.91216087, 27.17892265,\n", + " 27.42977715, 27.42983437, 27.63732719, 29.76596832,\n", + " 29.76592445, 27.73990822, 126.7827301 , 126.78705597,\n", + " 126.79136658, 18.63666534, 5.73195124, 7.0533433 ,\n", + " 2.55333257, 9.17568874]), topocentricDist=array([0.58142245, 0.68610221, 0.47289231, 0.71412551, 0.70371586,\n", + " 0.72016948, 0.72049457, 0.45957258, 0.806705 , 0.8421095 ,\n", + " 0.85847169, 0.98606402, 0.98611432, 1.27393341, 0.93472457,\n", + " 0.95206416, 1.00859618, 1.06491303, 1.08432984, 1.67350197,\n", + " 1.8374033 , 0.92473841, 0.92631632, 0.96172243, 0.99953324,\n", + " 0.99954176, 1.03583491, 1.58487654, 1.58488584, 1.71470714,\n", + " 0.20776999, 0.20780498, 0.20783997, 1.4200809 , 1.59280014,\n", + " 1.50733411, 1.56365716, 1.73338318]), heliocentricDist=array([1.19897687, 1.29408848, 1.0418874 , 1.31655276, 1.42970574,\n", + " 1.44069195, 1.44090629, 1.35723567, 1.49640727, 1.51831007,\n", + " 1.52828085, 1.60294342, 1.60297179, 1.66633558, 1.66025329,\n", + " 1.66984999, 1.70058703, 1.73042095, 1.74053574, 1.86338043,\n", + " 1.93771982, 1.73265779, 1.73353231, 1.75293028, 1.77324426,\n", + " 1.77324879, 1.79237878, 1.97701716, 1.97702122, 2.10192013,\n", + " 0.87671232, 0.87667543, 0.87663853, 2.21820784, 2.55602884,\n", + " 2.46223307, 2.54469585, 2.65981913]), reduced_mag=array([22.69748655, 22.2442361 , 23.29608557, 22.22793578, 21.60177977,\n", + " 21.64797142, 21.64066789, 21.47195362, 21.38017677, 21.42535443,\n", + " 21.5893551 , 21.45088317, 21.39573365, 21.28945381, 21.29370916,\n", + " 21.2692807 , 21.11941945, 21.33467112, 21.31877818, 21.46336177,\n", + " 20.98452321, 21.11934119, 21.13954299, 21.1149286 , 21.04217083,\n", + " 21.01914605, 21.09639885, 21.08797141, 21.22195309, 21.41096887,\n", + " 25.92680044, 25.74652589, 25.87425196, 21.03042275, 20.65336449,\n", + " 20.03930569, 20.06911369, 20.92326717]), num_obs=38),\n", + " Observations(ssObjectId='8268570668335894776', filter_name='i', mag=array([21.6439991 , 21.36300087, 21.87800026, 21.9109993 , 21.13100052,\n", + " 21.31299973, 21.52899933, 21.4489994 , 21.9659996 , 22.34600067,\n", + " 22.1060009 , 22.8239994 , 22.1420002 , 22.22699928, 22.55699921,\n", + " 22.9260006 , 22.86000061, 23.03899956, 23.01000023, 23.01499939,\n", + " 21.69099998, 21.62800026, 21.73800087, 21.7670002 , 24.12299919,\n", + " 23.5720005 , 23.12000084, 22.00600052, 22.13199997, 21.44499969,\n", + " 21.8920002 , 22.96100044]), magErr=array([0.09 , 0.09 , 0.097 , 0.061 , 0.056 ,\n", + " 0.06 , 0.043 , 0.055 , 0.052 , 0.123 ,\n", + " 0.138 , 0.149 , 0.056 , 0.108 , 0.072 ,\n", + " 0.15099999, 0.108 , 0.161 , 0.17200001, 0.24699999,\n", + " 0.033 , 0.034 , 0.036 , 0.034 , 0.287 ,\n", + " 0.20900001, 0.162 , 0.236 , 0.25099999, 0.273 ,\n", + " 0.32800001, 0.20200001]), midpointMjdTai=array([63491.01061, 63492.02797, 63479.02886, 63502.02736, 62399.06072,\n", + " 62406.11472, 62407.05015, 62407.11748, 62415.0812 , 62422.08767,\n", + " 62422.09036, 62436.04279, 61322.99785, 61329.01185, 61330.03932,\n", + " 61336.03529, 61340.01945, 61341.11766, 61341.11811, 61342.06216,\n", + " 60220.01958, 60220.02049, 60221.12372, 60221.12557, 63562.07814,\n", + " 61355.01017, 60247.08273, 62349.97398, 62349.97087, 62349.96776,\n", + " 62349.96465, 61036.13418]), ra=array([266.6413363, 268.5086178, 239.9100993, 283.7730287, 291.4097759,\n", + " 298.145886 , 298.9243467, 298.9782853, 304.8150582, 309.1312689,\n", + " 309.1328297, 316.4041661, 315.6348596, 317.8845061, 318.2612529,\n", + " 320.4304128, 321.848623 , 322.2360534, 322.2361831, 322.569595 ,\n", + " 322.1115349, 322.1116543, 322.2881508, 322.2884132, 325.8794637,\n", + " 327.0925894, 327.8278286, 172.616229 , 172.6111715, 172.6060941,\n", + " 172.6010555, 68.9454695]), dec=array([-23.0326404, -22.9520606, -21.8321338, -21.5096171, -20.0492988,\n", + " -18.625892 , -18.4479994, -18.4350998, -17.0128368, -15.8709103,\n", + " -15.8704781, -13.7834185, -13.6110905, -12.9407809, -12.8273414,\n", + " -12.1670727, -11.7275091, -11.6058333, -11.6058105, -11.5011345,\n", + " -11.0839115, -11.0838709, -11.0316938, -11.0315926, -11.0218241,\n", + " -10.0366378, -9.382581 , -1.8195237, -1.8173023, -1.8150431,\n", + " -1.8127825, 28.5483987]), phaseAngle=array([ 57.69313812, 56.68458939, 72.73178864, 48.7874794 ,\n", + " 43.18344498, 40.29655838, 39.98762894, 39.96704483,\n", + " 37.80903625, 36.34411621, 36.34362793, 33.94010925,\n", + " 31.97488785, 31.74231148, 31.69519234, 31.36940193,\n", + " 31.10543633, 31.02681541, 31.0267849 , 30.95575333,\n", + " 26.25296974, 26.25314522, 26.44772339, 26.4480629 ,\n", + " 30.1556778 , 29.76718521, 28.40824509, 111.80013275,\n", + " 111.80042267, 111.80072021, 111.80101013, 10.05950642]), topocentricDist=array([0.57015663, 0.58171409, 0.47300589, 0.71448445, 0.59068811,\n", + " 0.70412856, 0.71975976, 0.72089708, 0.85890698, 0.98651999,\n", + " 0.98657024, 1.25412667, 0.95185274, 1.06513095, 1.08479238,\n", + " 1.20115972, 1.2799077 , 1.30180955, 1.30181861, 1.32069123,\n", + " 0.85387373, 0.85388964, 0.87341589, 0.87344897, 1.83789635,\n", + " 1.58462429, 1.36697185, 0.4382202 , 0.43826094, 0.43830171,\n", + " 0.43834251, 1.41184878]), heliocentricDist=array([1.18712699, 1.19927573, 1.04218543, 1.31683338, 1.35009003,\n", + " 1.42998099, 1.44042122, 1.44117129, 1.52854323, 1.60319996,\n", + " 1.60322821, 1.74579298, 1.66973341, 1.73053503, 1.74077535,\n", + " 1.7996881 , 1.83804572, 1.84850955, 1.84851384, 1.85747135,\n", + " 1.69262958, 1.69263875, 1.70382977, 1.70384848, 1.93793714,\n", + " 1.97690809, 1.95307171, 0.76700246, 0.76696873, 0.76693499,\n", + " 0.76690125, 2.34223175]), reduced_mag=array([22.49154229, 22.14485771, 23.41394253, 22.04338125, 21.62239573,\n", + " 21.29808859, 21.45061395, 21.36605507, 21.3748803 , 21.35053275,\n", + " 21.11038412, 21.12232867, 21.1359157 , 20.89908229, 21.17655245,\n", + " 21.25201058, 21.0023258 , 21.1321538 , 21.10313432, 21.06638231,\n", + " 20.8912221 , 20.82817013, 20.87476443, 20.90365766, 21.36469569,\n", + " 21.09243657, 20.98761203, 24.37355475, 24.49944785, 23.8123411 ,\n", + " 24.259235 , 20.3639102 ]), num_obs=32),\n", + " Observations(ssObjectId='8268570668335894776', filter_name='z', mag=array([21.65099907, 20.8239994 , 21.2840004 , 21.27899933, 22.35499954,\n", + " 21.80500031, 21.54999924, 21.36400032, 22.88599968, 23.33099937,\n", + " 21.72400093, 21.83499908, 21.87899971, 22.81800079, 22.74699974]), magErr=array([0.14399999, 0.169 , 0.077 , 0.077 , 0.20900001,\n", + " 0.097 , 0.116 , 0.075 , 0.197 , 0.19400001,\n", + " 0.054 , 0.057 , 0.054 , 0.17299999, 0.245 ]), midpointMjdTai=array([63491.03495, 62370.9729 , 62399.08464, 62400.05034, 63520.05886,\n", + " 62411.05949, 62411.07292, 61309.15792, 62429.06267, 61340.00767,\n", + " 60220.04371, 60221.09951, 60221.10141, 60238.11179, 60247.05882]), ra=array([266.6862015, 228.9645547, 291.4352238, 292.4644191, 301.7031394,\n", + " 302.0220675, 302.0316622, 309.9445463, 312.9360241, 321.8445762,\n", + " 322.1149878, 322.2845177, 322.2848101, 325.6657983, 327.8220494]), dec=array([-23.0308381, -20.6945178, -20.0441634, -19.8413071, -18.1180487,\n", + " -17.7117757, -17.7093386, -15.2786908, -14.804212 , -11.7288161,\n", + " -11.0827998, -11.0328789, -11.0327917, -10.0432689, -9.3844064]), phaseAngle=array([57.66902161, 80.89524078, 43.17203903, 42.70541382, 40.52689362,\n", + " 38.80998611, 38.80657959, 32.35914612, 35.09179688, 31.10615921,\n", + " 26.25766945, 26.44327354, 26.44362259, 28.21966362, 28.40810394]), topocentricDist=array([0.57043034, 0.29524919, 0.59106016, 0.60608381, 1.01253808,\n", + " 0.78817856, 0.78841257, 0.70432466, 1.11828279, 1.27967286,\n", + " 0.85429835, 0.87298429, 0.87301797, 1.18980193, 1.36648977]), heliocentricDist=array([1.18741798, 1.01504409, 1.35036433, 1.36142015, 1.51896226,\n", + " 1.48475397, 1.48490143, 1.52411139, 1.6754756 , 1.83793306,\n", + " 1.69287491, 1.70358479, 1.70360386, 1.86992252, 1.95285416]), reduced_mag=array([22.49696788, 23.44063126, 21.77358717, 21.69637503, 21.4202078 ,\n", + " 21.46360474, 21.20774341, 21.2100523 , 21.52255093, 21.47385612,\n", + " 20.92282874, 20.97314817, 21.01704072, 21.08150939, 20.61561877]), num_obs=15),\n", + " Observations(ssObjectId='8268570668335894776', filter_name='y', mag=array([], dtype=object), magErr=array([], dtype=object), midpointMjdTai=array([], dtype=object), ra=array([], dtype=object), dec=array([], dtype=object), phaseAngle=array([], dtype=object), topocentricDist=array([], dtype=object), heliocentricDist=array([], dtype=object), reduced_mag=array([], dtype=object), num_obs=0)],\n", + " 'MPCORB': MPCORB(ssObjectId='8268570668335894776', mpcDesignation='2014 QL4', mpcNumber=0, mpcH=19.8799991607666, mpcG=0.15000000596046448, epoch=60065.0, peri=260.5468204162153, node=322.8059, incl=4.427569999999975, e=0.7168805704972735, n=nan, q=0.5898291078470536, uncertaintyParameter='', flags='0'),\n", + " 'SSObject': SSObject(ssObjectId='8268570668335894776', filter_list=['u', 'g', 'r', 'i', 'z', 'y'], discoverySubmissionDate=60218.0, firstObservationDate=60220.01958, arc=3342.05859375, numObs=94, H=array([ nan, 20.29232597, 19.80589294, 19.47262955, 19.59087944,\n", + " nan]), G12=array([ nan, 1.72339332, 1.52932608, 1.7948637 , 1.70006168,\n", + " nan]), Herr=array([ nan, 0.0302103 , 0.01974303, 0.02164448, 0.04272443,\n", + " nan]), G12err=array([ nan, 0.04049731, 0.05071714, 0.04562044, 0.09607928,\n", + " nan]), nData=array([ 0., 9., 38., 32., 15., 0.]), maxExtendedness=0.0, minExtendedness=0.0, medianExtendedness=0.0),\n", + " 'AdlerData': AdlerData(filter_list=['u', 'g', 'r', 'i', 'z', 'y'], model_lists=[[], [], [], [], [], []], phaseAngle_min_adler=array([nan, nan, nan, nan, nan, nan]), phaseAngle_range_adler=array([nan, nan, nan, nan, nan, nan]), nobs_adler=array([0, 0, 0, 0, 0, 0]), arc_adler=array([nan, nan, nan, nan, nan, nan]), H_adler=[[], [], [], [], [], []], H_err_adler=[[], [], [], [], [], []], phase_parameters=[[], [], [], [], [], []], phase_parameters_err=[[], [], [], [], [], []])}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# inspect the object\n", + "# planetoid.__dict__" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1d360360-025b-4a77-acf5-325b2f2d1873", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:14.290960Z", + "iopub.status.busy": "2024-02-29T16:09:14.290631Z", + "iopub.status.idle": "2024-02-29T16:09:14.307210Z", + "shell.execute_reply": "2024-02-29T16:09:14.306215Z", + "shell.execute_reply.started": "2024-02-29T16:09:14.290937Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'ssObjectId': '8268570668335894776',\n", + " 'filter_list': ['u', 'g', 'r', 'i', 'z', 'y'],\n", + " 'discoverySubmissionDate': 60218.0,\n", + " 'firstObservationDate': 60220.01958,\n", + " 'arc': 3342.05859375,\n", + " 'numObs': 94,\n", + " 'H': array([ nan, 20.29232597, 19.80589294, 19.47262955, 19.59087944,\n", + " nan]),\n", + " 'G12': array([ nan, 1.72339332, 1.52932608, 1.7948637 , 1.70006168,\n", + " nan]),\n", + " 'Herr': array([ nan, 0.0302103 , 0.01974303, 0.02164448, 0.04272443,\n", + " nan]),\n", + " 'G12err': array([ nan, 0.04049731, 0.05071714, 0.04562044, 0.09607928,\n", + " nan]),\n", + " 'nData': array([ 0., 9., 38., 32., 15., 0.]),\n", + " 'maxExtendedness': 0.0,\n", + " 'minExtendedness': 0.0,\n", + " 'medianExtendedness': 0.0}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "planetoid.SSObject.__dict__" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "be8f8d63", + "metadata": {}, + "outputs": [], + "source": [ + "obs_r = planetoid.observations_in_filter(\"r\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "da1e483d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'ssObjectId': '8268570668335894776',\n", + " 'filter_name': 'r',\n", + " 'mag': array([21.91399956, 21.98600006, 21.75900078, 22.09399986, 21.61499977,\n", + " 21.72800064, 21.72200012, 20.4470005 , 21.78899956, 21.95899963,\n", + " 22.17900085, 22.44499969, 22.38999939, 22.92399979, 22.24799919,\n", + " 22.27599907, 22.29100037, 22.66200066, 22.69799995, 23.93300056,\n", + " 23.74200058, 22.14299965, 22.16799927, 22.24900055, 22.28499985,\n", + " 22.26199913, 22.44000053, 23.56800079, 23.70199966, 24.19499969,\n", + " 22.22900009, 22.04899979, 22.17700005, 23.52199936, 23.70199966,\n", + " 22.88699913, 23.06800079, 24.24200058]),\n", + " 'magErr': array([0.095 , 0.049 , 0.07 , 0.047 , 0.036 ,\n", + " 0.038 , 0.034 , 0.011 , 0.052 , 0.06 ,\n", + " 0.042 , 0.098 , 0.1 , 0.116 , 0.046 ,\n", + " 0.06 , 0.082 , 0.083 , 0.063 , 0.35100001,\n", + " 0.2 , 0.057 , 0.034 , 0.036 , 0.054 ,\n", + " 0.051 , 0.046 , 0.17200001, 0.199 , 0.17 ,\n", + " 0.264 , 0.28299999, 0.31600001, 0.163 , 0.248 ,\n", + " 0.182 , 0.211 , 0.38299999]),\n", + " 'midpointMjdTai': array([63492.00291, 63500.06856, 63479.0044 , 63502.00311, 62406.09011,\n", + " 62407.07445, 62407.09369, 61294.15865, 62412.12365, 62414.13572,\n", + " 62415.05691, 62422.06327, 62422.06596, 63534.03975, 61322.07319,\n", + " 61323.00925, 61326.03134, 61329.00043, 61330.01524, 63554.05676,\n", + " 63562.05437, 60223.98877, 60224.07621, 60226.02382, 60228.0802 ,\n", + " 60228.08066, 60230.03315, 61355.02232, 61355.02277, 60264.01472,\n", + " 61253.97055, 61253.96744, 61253.96433, 61052.13729, 63217.23761,\n", + " 62125.2233 , 62113.17449, 62095.28873]),\n", + " 'ra': array([268.4639755, 281.1782352, 239.848597 , 283.7424099, 298.1255196,\n", + " 298.9437966, 298.9592036, 301.5682143, 302.7875618, 304.1818652,\n", + " 304.7993288, 309.1175392, 309.1190487, 311.280946 , 315.2799036,\n", + " 315.6390597, 316.7793075, 317.8804823, 318.2527231, 322.0860789,\n", + " 325.868688 , 322.7789008, 322.7931457, 323.1475474, 323.5372789,\n", + " 323.5373434, 323.9242256, 327.0967385, 327.0968451, 332.3781914,\n", + " 170.4323598, 170.4247983, 170.4172297, 62.6767601, 68.4459325,\n", + " 69.233718 , 74.6917865, 81.7128501]),\n", + " 'dec': array([-22.9543395, -21.8517282, -21.8243507, -21.5140075, -18.6306791,\n", + " -18.443366 , -18.4396764, -17.709034 , -17.5230447, -17.1737751,\n", + " -17.0169932, -15.874741 , -15.8743016, -15.6284188, -13.7156598,\n", + " -13.6098197, -13.2712987, -12.9420707, -12.8300092, -12.3090787,\n", + " -11.0256047, -10.889507 , -10.8850457, -10.7825671, -10.6694075,\n", + " -10.6693695, -10.5571517, -10.035292 , -10.0351984, -7.9025949,\n", + " -3.6550378, -3.6513877, -3.6478445, 27.0535373, 28.5344673,\n", + " 28.6462634, 29.3204275, 29.563878 ]),\n", + " 'phaseAngle': array([ 56.70839691, 50.07988358, 72.76689148, 48.80239868,\n", + " 40.30448914, 39.98022079, 39.97434235, 33.56268311,\n", + " 38.53084564, 38.03194427, 37.81433105, 36.34851074,\n", + " 36.34802628, 36.50101089, 32.00559616, 31.97466469,\n", + " 31.86707687, 31.74268913, 31.69605255, 31.88496971,\n", + " 30.16068649, 26.89824295, 26.91216087, 27.17892265,\n", + " 27.42977715, 27.42983437, 27.63732719, 29.76596832,\n", + " 29.76592445, 27.73990822, 126.7827301 , 126.78705597,\n", + " 126.79136658, 18.63666534, 5.73195124, 7.0533433 ,\n", + " 2.55333257, 9.17568874]),\n", + " 'topocentricDist': array([0.58142245, 0.68610221, 0.47289231, 0.71412551, 0.70371586,\n", + " 0.72016948, 0.72049457, 0.45957258, 0.806705 , 0.8421095 ,\n", + " 0.85847169, 0.98606402, 0.98611432, 1.27393341, 0.93472457,\n", + " 0.95206416, 1.00859618, 1.06491303, 1.08432984, 1.67350197,\n", + " 1.8374033 , 0.92473841, 0.92631632, 0.96172243, 0.99953324,\n", + " 0.99954176, 1.03583491, 1.58487654, 1.58488584, 1.71470714,\n", + " 0.20776999, 0.20780498, 0.20783997, 1.4200809 , 1.59280014,\n", + " 1.50733411, 1.56365716, 1.73338318]),\n", + " 'heliocentricDist': array([1.19897687, 1.29408848, 1.0418874 , 1.31655276, 1.42970574,\n", + " 1.44069195, 1.44090629, 1.35723567, 1.49640727, 1.51831007,\n", + " 1.52828085, 1.60294342, 1.60297179, 1.66633558, 1.66025329,\n", + " 1.66984999, 1.70058703, 1.73042095, 1.74053574, 1.86338043,\n", + " 1.93771982, 1.73265779, 1.73353231, 1.75293028, 1.77324426,\n", + " 1.77324879, 1.79237878, 1.97701716, 1.97702122, 2.10192013,\n", + " 0.87671232, 0.87667543, 0.87663853, 2.21820784, 2.55602884,\n", + " 2.46223307, 2.54469585, 2.65981913]),\n", + " 'reduced_mag': array([22.69748655, 22.2442361 , 23.29608557, 22.22793578, 21.60177977,\n", + " 21.64797142, 21.64066789, 21.47195362, 21.38017677, 21.42535443,\n", + " 21.5893551 , 21.45088317, 21.39573365, 21.28945381, 21.29370916,\n", + " 21.2692807 , 21.11941945, 21.33467112, 21.31877818, 21.46336177,\n", + " 20.98452321, 21.11934119, 21.13954299, 21.1149286 , 21.04217083,\n", + " 21.01914605, 21.09639885, 21.08797141, 21.22195309, 21.41096887,\n", + " 25.92680044, 25.74652589, 25.87425196, 21.03042275, 20.65336449,\n", + " 20.03930569, 20.06911369, 20.92326717]),\n", + " 'num_obs': 38}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "obs_r.__dict__" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9d7dc125-06c1-49ad-8854-17d8c8b6954f", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:14.353538Z", + "iopub.status.busy": "2024-02-29T16:09:14.352944Z", + "iopub.status.idle": "2024-02-29T16:09:14.544075Z", + "shell.execute_reply": "2024-02-29T16:09:14.543137Z", + "shell.execute_reply.started": "2024-02-29T16:09:14.353500Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the observations\n", + "x_plot = \"phaseAngle\"\n", + "y_plot = \"reduced_mag\"\n", + "\n", + "x = getattr(obs_r, x_plot)\n", + "y = getattr(obs_r, y_plot)\n", + "xerr = obs_r.magErr\n", + "\n", + "fig = plt.figure()\n", + "gs = gridspec.GridSpec(1, 1)\n", + "ax1 = plt.subplot(gs[0, 0])\n", + "\n", + "ax1.errorbar(x, y, xerr, fmt=\"o\")\n", + "\n", + "ax1.invert_yaxis()\n", + "ax1.set_xlabel(x_plot)\n", + "ax1.set_ylabel(y_plot)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6efe3b5a-09dd-4d5e-9f41-20ea6e1b43df", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:14.545627Z", + "iopub.status.busy": "2024-02-29T16:09:14.545342Z", + "iopub.status.idle": "2024-02-29T16:09:14.553323Z", + "shell.execute_reply": "2024-02-29T16:09:14.552540Z", + "shell.execute_reply.started": "2024-02-29T16:09:14.545603Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jrobinson/miniconda3/envs/adler-dev/lib/python3.10/site-packages/sbpy/photometry/iau.py:50: InvalidPhaseFunctionWarning: G12 parameter could result in an invalid phsae function\n", + " warnings.warn(msg, exception)\n" + ] + } + ], + "source": [ + "# define the phase curve\n", + "\n", + "r_H = planetoid.SSObject.H[2]\n", + "r_G12 = planetoid.SSObject.G12[2]\n", + "\n", + "pc = PhaseCurve(\n", + " abs_mag=r_H * u.mag, phase_param=r_G12, model_name=\"HG12_Pen16\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "80f552f1-8907-4cc9-b57c-2e667eab459c", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:14.554644Z", + "iopub.status.busy": "2024-02-29T16:09:14.554319Z", + "iopub.status.idle": "2024-02-29T16:09:14.571588Z", + "shell.execute_reply": "2024-02-29T16:09:14.570921Z", + "shell.execute_reply.started": "2024-02-29T16:09:14.554620Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pc.model_function" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "24c1955e-95cd-4d77-ad05-aa5b8d18620a", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:14.572987Z", + "iopub.status.busy": "2024-02-29T16:09:14.572491Z", + "iopub.status.idle": "2024-02-29T16:09:14.593610Z", + "shell.execute_reply": "2024-02-29T16:09:14.592732Z", + "shell.execute_reply.started": "2024-02-29T16:09:14.572960Z" + } + }, + "outputs": [ + { + "data": { + "text/latex": [ + "$[0,~2.5875789,~5.1751578,~7.7627367,~10.350316,~12.937895,~15.525473,~18.113052,~20.700631,~23.28821,~25.875789,~28.463368,~31.050947,~33.638526,~36.226105,~38.813684,~41.401263,~43.988841,~46.57642,~49.163999,~51.751578,~54.339157,~56.926736,~59.514315,~62.101894,~64.689473,~67.277052,~69.864631,~72.452209,~75.039788,~77.627367,~80.214946,~82.802525,~85.390104,~87.977683,~90.565262,~93.152841,~95.74042,~98.327999,~100.91558,~103.50316,~106.09074,~108.67831,~111.26589,~113.85347,~116.44105,~119.02863,~121.61621,~124.20379,~126.79137] \\; \\mathrm{{}^{\\circ}}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "alpha = np.linspace(0, np.amax(obs_r.phaseAngle)) * u.deg\n", + "alpha" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c3f30fe0-0d89-4ffa-8237-9c71181d44ee", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:14.594977Z", + "iopub.status.busy": "2024-02-29T16:09:14.594621Z", + "iopub.status.idle": "2024-02-29T16:09:14.614140Z", + "shell.execute_reply": "2024-02-29T16:09:14.613401Z", + "shell.execute_reply.started": "2024-02-29T16:09:14.594943Z" + } + }, + "outputs": [ + { + "data": { + "text/latex": [ + "$[19.805893,~19.920355,~20.052052,~20.202895,~20.360566,~20.513141,~20.658458,~20.794601,~20.920251,~21.035105,~21.140282,~21.238644,~21.334969,~21.432803,~21.532351,~21.633562,~21.736362,~21.840655,~21.946316,~22.053192,~22.161093,~22.2698,~22.379056,~22.488576,~22.598035,~22.706974,~22.814826,~22.920961,~23.024702,~23.12535,~23.222222,~23.314692,~23.402255,~23.484581,~23.561579,~23.633452,~23.700294,~23.761468,~23.816277,~23.864116,~23.904505,~23.937131,~23.961868,~23.978792,~23.988178,~23.990477,~23.986295,~23.97653,~23.964571,~23.955435] \\; \\mathrm{mag}$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "red_mag = pc.ReducedMag(alpha)\n", + "red_mag" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "04be98a1-e4dc-4216-bcd9-ef777f6053fb", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:14.615656Z", + "iopub.status.busy": "2024-02-29T16:09:14.615050Z", + "iopub.status.idle": "2024-02-29T16:09:14.783515Z", + "shell.execute_reply": "2024-02-29T16:09:14.782664Z", + "shell.execute_reply.started": "2024-02-29T16:09:14.615623Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %matplotlib widget\n", + "\n", + "# plot the observations with the LSST phase curve\n", + "x_plot = \"phaseAngle\"\n", + "y_plot = \"reduced_mag\"\n", + "\n", + "x = getattr(obs_r, x_plot)\n", + "y = getattr(obs_r, y_plot)\n", + "xerr = obs_r.magErr\n", + "\n", + "fig = plt.figure()\n", + "gs = gridspec.GridSpec(1, 1)\n", + "ax1 = plt.subplot(gs[0, 0])\n", + "\n", + "ax1.errorbar(x, y, xerr, fmt=\"o\")\n", + "\n", + "ax1.plot(alpha.value, red_mag.value)\n", + "\n", + "ax1.invert_yaxis()\n", + "ax1.set_xlabel(x_plot)\n", + "ax1.set_ylabel(y_plot)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "9815543d-6140-4bdb-8bad-8296994723f4", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:14.784754Z", + "iopub.status.busy": "2024-02-29T16:09:14.784498Z", + "iopub.status.idle": "2024-02-29T16:09:14.953022Z", + "shell.execute_reply": "2024-02-29T16:09:14.952237Z", + "shell.execute_reply.started": "2024-02-29T16:09:14.784731Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the observations\n", + "x_plot = \"midpointMjdTai\"\n", + "y_plot = \"reduced_mag\"\n", + "\n", + "x = getattr(obs_r, x_plot)\n", + "y = getattr(obs_r, y_plot)\n", + "xerr = obs_r.magErr\n", + "\n", + "fig = plt.figure()\n", + "gs = gridspec.GridSpec(1, 1)\n", + "ax1 = plt.subplot(gs[0, 0])\n", + "\n", + "ax1.errorbar(x, y, xerr, fmt=\"o\")\n", + "\n", + "ax1.invert_yaxis()\n", + "ax1.set_xlabel(x_plot)\n", + "ax1.set_ylabel(y_plot)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "de462b92-3914-4091-b0af-bddd9e9c1ef1", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:14.954181Z", + "iopub.status.busy": "2024-02-29T16:09:14.953935Z", + "iopub.status.idle": "2024-02-29T16:09:14.957556Z", + "shell.execute_reply": "2024-02-29T16:09:14.956913Z", + "shell.execute_reply.started": "2024-02-29T16:09:14.954159Z" + } + }, + "outputs": [], + "source": [ + "# do a different phase curve fit to the data\n", + "# adler should be able to fit different models, and perform more sophisticated fits" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f92891c9-6ccf-4dac-8887-9545f633ba90", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:14.963464Z", + "iopub.status.busy": "2024-02-29T16:09:14.958584Z", + "iopub.status.idle": "2024-02-29T16:09:14.975015Z", + "shell.execute_reply": "2024-02-29T16:09:14.974187Z", + "shell.execute_reply.started": "2024-02-29T16:09:14.963434Z" + } + }, + "outputs": [], + "source": [ + "pc_fit = PhaseCurve(abs_mag=pc.abs_mag, model_name=\"HG\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "db24432b-6d05-4ff2-9d98-e52d8c2e4342", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:14.976283Z", + "iopub.status.busy": "2024-02-29T16:09:14.975943Z", + "iopub.status.idle": "2024-02-29T16:09:14.992854Z", + "shell.execute_reply": "2024-02-29T16:09:14.992071Z", + "shell.execute_reply.started": "2024-02-29T16:09:14.976260Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pc_fit.model_function" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9039e2e2-27d9-4d21-b2f6-9504a5b85ce4", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:14.994511Z", + "iopub.status.busy": "2024-02-29T16:09:14.993863Z", + "iopub.status.idle": "2024-02-29T16:09:15.023285Z", + "shell.execute_reply": "2024-02-29T16:09:15.022583Z", + "shell.execute_reply.started": "2024-02-29T16:09:14.994486Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pc_fit.FitModel(\n", + " phase_angle=obs_r.phaseAngle * u.deg,\n", + " reduced_mag=obs_r.reduced_mag * u.mag,\n", + " mag_err=obs_r.magErr * u.mag,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "5d4b7144-ee72-45e0-9606-c40f83c443c6", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:15.024555Z", + "iopub.status.busy": "2024-02-29T16:09:15.024229Z", + "iopub.status.idle": "2024-02-29T16:09:15.217263Z", + "shell.execute_reply": "2024-02-29T16:09:15.216519Z", + "shell.execute_reply.started": "2024-02-29T16:09:15.024533Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %matplotlib widget\n", + "\n", + "# plot the observations with the LSST phase curve\n", + "x_plot = \"phaseAngle\"\n", + "y_plot = \"reduced_mag\"\n", + "\n", + "x = getattr(obs_r, x_plot)\n", + "y = getattr(obs_r, y_plot)\n", + "xerr = obs_r.magErr\n", + "\n", + "fig = plt.figure()\n", + "gs = gridspec.GridSpec(1, 1)\n", + "ax1 = plt.subplot(gs[0, 0])\n", + "\n", + "ax1.errorbar(x, y, xerr, fmt=\"o\")\n", + "\n", + "ax1.plot(alpha.value, pc.ReducedMag(alpha).value, label=pc.model_name)\n", + "ax1.plot(alpha.value, pc_fit.ReducedMag(alpha).value, label=pc_fit.model_name)\n", + "\n", + "ax1.invert_yaxis()\n", + "ax1.set_xlabel(x_plot)\n", + "ax1.set_ylabel(y_plot)\n", + "ax1.legend()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "b7f39ed4-8334-4e10-a97c-a9471105225b", + "metadata": { + "execution": { + "iopub.execute_input": "2024-02-29T16:09:15.221317Z", + "iopub.status.busy": "2024-02-29T16:09:15.220742Z", + "iopub.status.idle": "2024-02-29T16:09:15.224414Z", + "shell.execute_reply": "2024-02-29T16:09:15.223697Z", + "shell.execute_reply.started": "2024-02-29T16:09:15.221290Z" + } + }, + "outputs": [], + "source": [ + "# # now we would add our calculated values back into planetoid\n", + "# planetoid.AdlerSchema.r_H = pc_fit.abs_mag\n", + "# planetoid.AdlerSchema.r_G = pc_fit.phase_param" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "adler-dev", + "language": "python", + "name": "adler-dev" + }, + "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.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From cd1b10c30a889bdcdec19a3719015513f59ba866 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci-lite[bot]" <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com> Date: Wed, 27 Mar 2024 17:56:47 +0000 Subject: [PATCH 17/18] [pre-commit.ci lite] apply automatic fixes --- notebooks/adler_examples_local_db.ipynb | 495 ++---------------------- 1 file changed, 33 insertions(+), 462 deletions(-) diff --git a/notebooks/adler_examples_local_db.ipynb b/notebooks/adler_examples_local_db.ipynb index 691d4d2..d352cd2 100644 --- a/notebooks/adler_examples_local_db.ipynb +++ b/notebooks/adler_examples_local_db.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "d591f5d8-9148-46ff-a62b-0f2a29eb806c", "metadata": { "execution": { @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "645efb98-567d-481e-a79c-b1cfdc828726", "metadata": { "execution": { @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "10b36aab-b322-49b8-8ff3-49bef68d7416", "metadata": { "execution": { @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "d9a0623d-0dc7-49c1-99dd-a76ef970a3ff", "metadata": { "execution": { @@ -77,179 +77,7 @@ "shell.execute_reply.started": "2024-02-29T16:09:14.281511Z" } }, - "outputs": [ - { - "data": { - "text/plain": [ - "{'ssObjectId': '8268570668335894776',\n", - " 'filter_list': ['u', 'g', 'r', 'i', 'z', 'y'],\n", - " 'date_range': [60000.0, 67300.0],\n", - " 'observations_by_filter': [Observations(ssObjectId='8268570668335894776', filter_name='u', mag=array([], dtype=object), magErr=array([], dtype=object), midpointMjdTai=array([], dtype=object), ra=array([], dtype=object), dec=array([], dtype=object), phaseAngle=array([], dtype=object), topocentricDist=array([], dtype=object), heliocentricDist=array([], dtype=object), reduced_mag=array([], dtype=object), num_obs=0),\n", - " Observations(ssObjectId='8268570668335894776', filter_name='g', mag=array([21.33099937, 22.67099953, 23.5359993 , 22.85000038, 22.97599983,\n", - " 22.94499969, 23.13599968, 23.19400024, 23.1609993 ]), magErr=array([0.033, 0.07 , 0.141, 0.075, 0.048, 0.046, 0.068, 0.065, 0.066]), midpointMjdTai=array([62379.03985, 62414.11171, 63534.06359, 61323.17176, 60228.05559,\n", - " 60228.05606, 60229.03603, 60231.05795, 60233.03832]), ra=array([255.2300797, 304.1658794, 311.2951848, 315.6989729, 323.5328231,\n", - " 323.5329139, 323.7251118, 324.132392 , 324.5463505]), dec=array([-23.3427625, -17.1779969, -15.6242814, -13.5912723, -10.6707848,\n", - " -10.6707602, -10.6150706, -10.4964008, -10.3753228]), phaseAngle=array([63.60055161, 38.03742981, 36.49517059, 31.97113991, 27.42666817,\n", - " 27.42672539, 27.53459549, 27.73578453, 27.90441322]), topocentricDist=array([0.33790752, 0.84168053, 1.27439773, 0.95509756, 0.99907744,\n", - " 0.99908602, 1.01725268, 1.05503416, 1.09241748]), heliocentricDist=array([1.11330199, 1.51804984, 1.66657984, 1.67151237, 1.77300227,\n", - " 1.7730068 , 1.78262854, 1.80235839, 1.82152498]), reduced_mag=array([23.45394514, 22.13883298, 21.90034373, 21.83421374, 21.73445762,\n", - " 21.70343328, 21.84355119, 21.79846187, 21.66688044]), num_obs=9),\n", - " Observations(ssObjectId='8268570668335894776', filter_name='r', mag=array([21.91399956, 21.98600006, 21.75900078, 22.09399986, 21.61499977,\n", - " 21.72800064, 21.72200012, 20.4470005 , 21.78899956, 21.95899963,\n", - " 22.17900085, 22.44499969, 22.38999939, 22.92399979, 22.24799919,\n", - " 22.27599907, 22.29100037, 22.66200066, 22.69799995, 23.93300056,\n", - " 23.74200058, 22.14299965, 22.16799927, 22.24900055, 22.28499985,\n", - " 22.26199913, 22.44000053, 23.56800079, 23.70199966, 24.19499969,\n", - " 22.22900009, 22.04899979, 22.17700005, 23.52199936, 23.70199966,\n", - " 22.88699913, 23.06800079, 24.24200058]), magErr=array([0.095 , 0.049 , 0.07 , 0.047 , 0.036 ,\n", - " 0.038 , 0.034 , 0.011 , 0.052 , 0.06 ,\n", - " 0.042 , 0.098 , 0.1 , 0.116 , 0.046 ,\n", - " 0.06 , 0.082 , 0.083 , 0.063 , 0.35100001,\n", - " 0.2 , 0.057 , 0.034 , 0.036 , 0.054 ,\n", - " 0.051 , 0.046 , 0.17200001, 0.199 , 0.17 ,\n", - " 0.264 , 0.28299999, 0.31600001, 0.163 , 0.248 ,\n", - " 0.182 , 0.211 , 0.38299999]), midpointMjdTai=array([63492.00291, 63500.06856, 63479.0044 , 63502.00311, 62406.09011,\n", - " 62407.07445, 62407.09369, 61294.15865, 62412.12365, 62414.13572,\n", - " 62415.05691, 62422.06327, 62422.06596, 63534.03975, 61322.07319,\n", - " 61323.00925, 61326.03134, 61329.00043, 61330.01524, 63554.05676,\n", - " 63562.05437, 60223.98877, 60224.07621, 60226.02382, 60228.0802 ,\n", - " 60228.08066, 60230.03315, 61355.02232, 61355.02277, 60264.01472,\n", - " 61253.97055, 61253.96744, 61253.96433, 61052.13729, 63217.23761,\n", - " 62125.2233 , 62113.17449, 62095.28873]), ra=array([268.4639755, 281.1782352, 239.848597 , 283.7424099, 298.1255196,\n", - " 298.9437966, 298.9592036, 301.5682143, 302.7875618, 304.1818652,\n", - " 304.7993288, 309.1175392, 309.1190487, 311.280946 , 315.2799036,\n", - " 315.6390597, 316.7793075, 317.8804823, 318.2527231, 322.0860789,\n", - " 325.868688 , 322.7789008, 322.7931457, 323.1475474, 323.5372789,\n", - " 323.5373434, 323.9242256, 327.0967385, 327.0968451, 332.3781914,\n", - " 170.4323598, 170.4247983, 170.4172297, 62.6767601, 68.4459325,\n", - " 69.233718 , 74.6917865, 81.7128501]), dec=array([-22.9543395, -21.8517282, -21.8243507, -21.5140075, -18.6306791,\n", - " -18.443366 , -18.4396764, -17.709034 , -17.5230447, -17.1737751,\n", - " -17.0169932, -15.874741 , -15.8743016, -15.6284188, -13.7156598,\n", - " -13.6098197, -13.2712987, -12.9420707, -12.8300092, -12.3090787,\n", - " -11.0256047, -10.889507 , -10.8850457, -10.7825671, -10.6694075,\n", - " -10.6693695, -10.5571517, -10.035292 , -10.0351984, -7.9025949,\n", - " -3.6550378, -3.6513877, -3.6478445, 27.0535373, 28.5344673,\n", - " 28.6462634, 29.3204275, 29.563878 ]), phaseAngle=array([ 56.70839691, 50.07988358, 72.76689148, 48.80239868,\n", - " 40.30448914, 39.98022079, 39.97434235, 33.56268311,\n", - " 38.53084564, 38.03194427, 37.81433105, 36.34851074,\n", - " 36.34802628, 36.50101089, 32.00559616, 31.97466469,\n", - " 31.86707687, 31.74268913, 31.69605255, 31.88496971,\n", - " 30.16068649, 26.89824295, 26.91216087, 27.17892265,\n", - " 27.42977715, 27.42983437, 27.63732719, 29.76596832,\n", - " 29.76592445, 27.73990822, 126.7827301 , 126.78705597,\n", - " 126.79136658, 18.63666534, 5.73195124, 7.0533433 ,\n", - " 2.55333257, 9.17568874]), topocentricDist=array([0.58142245, 0.68610221, 0.47289231, 0.71412551, 0.70371586,\n", - " 0.72016948, 0.72049457, 0.45957258, 0.806705 , 0.8421095 ,\n", - " 0.85847169, 0.98606402, 0.98611432, 1.27393341, 0.93472457,\n", - " 0.95206416, 1.00859618, 1.06491303, 1.08432984, 1.67350197,\n", - " 1.8374033 , 0.92473841, 0.92631632, 0.96172243, 0.99953324,\n", - " 0.99954176, 1.03583491, 1.58487654, 1.58488584, 1.71470714,\n", - " 0.20776999, 0.20780498, 0.20783997, 1.4200809 , 1.59280014,\n", - " 1.50733411, 1.56365716, 1.73338318]), heliocentricDist=array([1.19897687, 1.29408848, 1.0418874 , 1.31655276, 1.42970574,\n", - " 1.44069195, 1.44090629, 1.35723567, 1.49640727, 1.51831007,\n", - " 1.52828085, 1.60294342, 1.60297179, 1.66633558, 1.66025329,\n", - " 1.66984999, 1.70058703, 1.73042095, 1.74053574, 1.86338043,\n", - " 1.93771982, 1.73265779, 1.73353231, 1.75293028, 1.77324426,\n", - " 1.77324879, 1.79237878, 1.97701716, 1.97702122, 2.10192013,\n", - " 0.87671232, 0.87667543, 0.87663853, 2.21820784, 2.55602884,\n", - " 2.46223307, 2.54469585, 2.65981913]), reduced_mag=array([22.69748655, 22.2442361 , 23.29608557, 22.22793578, 21.60177977,\n", - " 21.64797142, 21.64066789, 21.47195362, 21.38017677, 21.42535443,\n", - " 21.5893551 , 21.45088317, 21.39573365, 21.28945381, 21.29370916,\n", - " 21.2692807 , 21.11941945, 21.33467112, 21.31877818, 21.46336177,\n", - " 20.98452321, 21.11934119, 21.13954299, 21.1149286 , 21.04217083,\n", - " 21.01914605, 21.09639885, 21.08797141, 21.22195309, 21.41096887,\n", - " 25.92680044, 25.74652589, 25.87425196, 21.03042275, 20.65336449,\n", - " 20.03930569, 20.06911369, 20.92326717]), num_obs=38),\n", - " Observations(ssObjectId='8268570668335894776', filter_name='i', mag=array([21.6439991 , 21.36300087, 21.87800026, 21.9109993 , 21.13100052,\n", - " 21.31299973, 21.52899933, 21.4489994 , 21.9659996 , 22.34600067,\n", - " 22.1060009 , 22.8239994 , 22.1420002 , 22.22699928, 22.55699921,\n", - " 22.9260006 , 22.86000061, 23.03899956, 23.01000023, 23.01499939,\n", - " 21.69099998, 21.62800026, 21.73800087, 21.7670002 , 24.12299919,\n", - " 23.5720005 , 23.12000084, 22.00600052, 22.13199997, 21.44499969,\n", - " 21.8920002 , 22.96100044]), magErr=array([0.09 , 0.09 , 0.097 , 0.061 , 0.056 ,\n", - " 0.06 , 0.043 , 0.055 , 0.052 , 0.123 ,\n", - " 0.138 , 0.149 , 0.056 , 0.108 , 0.072 ,\n", - " 0.15099999, 0.108 , 0.161 , 0.17200001, 0.24699999,\n", - " 0.033 , 0.034 , 0.036 , 0.034 , 0.287 ,\n", - " 0.20900001, 0.162 , 0.236 , 0.25099999, 0.273 ,\n", - " 0.32800001, 0.20200001]), midpointMjdTai=array([63491.01061, 63492.02797, 63479.02886, 63502.02736, 62399.06072,\n", - " 62406.11472, 62407.05015, 62407.11748, 62415.0812 , 62422.08767,\n", - " 62422.09036, 62436.04279, 61322.99785, 61329.01185, 61330.03932,\n", - " 61336.03529, 61340.01945, 61341.11766, 61341.11811, 61342.06216,\n", - " 60220.01958, 60220.02049, 60221.12372, 60221.12557, 63562.07814,\n", - " 61355.01017, 60247.08273, 62349.97398, 62349.97087, 62349.96776,\n", - " 62349.96465, 61036.13418]), ra=array([266.6413363, 268.5086178, 239.9100993, 283.7730287, 291.4097759,\n", - " 298.145886 , 298.9243467, 298.9782853, 304.8150582, 309.1312689,\n", - " 309.1328297, 316.4041661, 315.6348596, 317.8845061, 318.2612529,\n", - " 320.4304128, 321.848623 , 322.2360534, 322.2361831, 322.569595 ,\n", - " 322.1115349, 322.1116543, 322.2881508, 322.2884132, 325.8794637,\n", - " 327.0925894, 327.8278286, 172.616229 , 172.6111715, 172.6060941,\n", - " 172.6010555, 68.9454695]), dec=array([-23.0326404, -22.9520606, -21.8321338, -21.5096171, -20.0492988,\n", - " -18.625892 , -18.4479994, -18.4350998, -17.0128368, -15.8709103,\n", - " -15.8704781, -13.7834185, -13.6110905, -12.9407809, -12.8273414,\n", - " -12.1670727, -11.7275091, -11.6058333, -11.6058105, -11.5011345,\n", - " -11.0839115, -11.0838709, -11.0316938, -11.0315926, -11.0218241,\n", - " -10.0366378, -9.382581 , -1.8195237, -1.8173023, -1.8150431,\n", - " -1.8127825, 28.5483987]), phaseAngle=array([ 57.69313812, 56.68458939, 72.73178864, 48.7874794 ,\n", - " 43.18344498, 40.29655838, 39.98762894, 39.96704483,\n", - " 37.80903625, 36.34411621, 36.34362793, 33.94010925,\n", - " 31.97488785, 31.74231148, 31.69519234, 31.36940193,\n", - " 31.10543633, 31.02681541, 31.0267849 , 30.95575333,\n", - " 26.25296974, 26.25314522, 26.44772339, 26.4480629 ,\n", - " 30.1556778 , 29.76718521, 28.40824509, 111.80013275,\n", - " 111.80042267, 111.80072021, 111.80101013, 10.05950642]), topocentricDist=array([0.57015663, 0.58171409, 0.47300589, 0.71448445, 0.59068811,\n", - " 0.70412856, 0.71975976, 0.72089708, 0.85890698, 0.98651999,\n", - " 0.98657024, 1.25412667, 0.95185274, 1.06513095, 1.08479238,\n", - " 1.20115972, 1.2799077 , 1.30180955, 1.30181861, 1.32069123,\n", - " 0.85387373, 0.85388964, 0.87341589, 0.87344897, 1.83789635,\n", - " 1.58462429, 1.36697185, 0.4382202 , 0.43826094, 0.43830171,\n", - " 0.43834251, 1.41184878]), heliocentricDist=array([1.18712699, 1.19927573, 1.04218543, 1.31683338, 1.35009003,\n", - " 1.42998099, 1.44042122, 1.44117129, 1.52854323, 1.60319996,\n", - " 1.60322821, 1.74579298, 1.66973341, 1.73053503, 1.74077535,\n", - " 1.7996881 , 1.83804572, 1.84850955, 1.84851384, 1.85747135,\n", - " 1.69262958, 1.69263875, 1.70382977, 1.70384848, 1.93793714,\n", - " 1.97690809, 1.95307171, 0.76700246, 0.76696873, 0.76693499,\n", - " 0.76690125, 2.34223175]), reduced_mag=array([22.49154229, 22.14485771, 23.41394253, 22.04338125, 21.62239573,\n", - " 21.29808859, 21.45061395, 21.36605507, 21.3748803 , 21.35053275,\n", - " 21.11038412, 21.12232867, 21.1359157 , 20.89908229, 21.17655245,\n", - " 21.25201058, 21.0023258 , 21.1321538 , 21.10313432, 21.06638231,\n", - " 20.8912221 , 20.82817013, 20.87476443, 20.90365766, 21.36469569,\n", - " 21.09243657, 20.98761203, 24.37355475, 24.49944785, 23.8123411 ,\n", - " 24.259235 , 20.3639102 ]), num_obs=32),\n", - " Observations(ssObjectId='8268570668335894776', filter_name='z', mag=array([21.65099907, 20.8239994 , 21.2840004 , 21.27899933, 22.35499954,\n", - " 21.80500031, 21.54999924, 21.36400032, 22.88599968, 23.33099937,\n", - " 21.72400093, 21.83499908, 21.87899971, 22.81800079, 22.74699974]), magErr=array([0.14399999, 0.169 , 0.077 , 0.077 , 0.20900001,\n", - " 0.097 , 0.116 , 0.075 , 0.197 , 0.19400001,\n", - " 0.054 , 0.057 , 0.054 , 0.17299999, 0.245 ]), midpointMjdTai=array([63491.03495, 62370.9729 , 62399.08464, 62400.05034, 63520.05886,\n", - " 62411.05949, 62411.07292, 61309.15792, 62429.06267, 61340.00767,\n", - " 60220.04371, 60221.09951, 60221.10141, 60238.11179, 60247.05882]), ra=array([266.6862015, 228.9645547, 291.4352238, 292.4644191, 301.7031394,\n", - " 302.0220675, 302.0316622, 309.9445463, 312.9360241, 321.8445762,\n", - " 322.1149878, 322.2845177, 322.2848101, 325.6657983, 327.8220494]), dec=array([-23.0308381, -20.6945178, -20.0441634, -19.8413071, -18.1180487,\n", - " -17.7117757, -17.7093386, -15.2786908, -14.804212 , -11.7288161,\n", - " -11.0827998, -11.0328789, -11.0327917, -10.0432689, -9.3844064]), phaseAngle=array([57.66902161, 80.89524078, 43.17203903, 42.70541382, 40.52689362,\n", - " 38.80998611, 38.80657959, 32.35914612, 35.09179688, 31.10615921,\n", - " 26.25766945, 26.44327354, 26.44362259, 28.21966362, 28.40810394]), topocentricDist=array([0.57043034, 0.29524919, 0.59106016, 0.60608381, 1.01253808,\n", - " 0.78817856, 0.78841257, 0.70432466, 1.11828279, 1.27967286,\n", - " 0.85429835, 0.87298429, 0.87301797, 1.18980193, 1.36648977]), heliocentricDist=array([1.18741798, 1.01504409, 1.35036433, 1.36142015, 1.51896226,\n", - " 1.48475397, 1.48490143, 1.52411139, 1.6754756 , 1.83793306,\n", - " 1.69287491, 1.70358479, 1.70360386, 1.86992252, 1.95285416]), reduced_mag=array([22.49696788, 23.44063126, 21.77358717, 21.69637503, 21.4202078 ,\n", - " 21.46360474, 21.20774341, 21.2100523 , 21.52255093, 21.47385612,\n", - " 20.92282874, 20.97314817, 21.01704072, 21.08150939, 20.61561877]), num_obs=15),\n", - " Observations(ssObjectId='8268570668335894776', filter_name='y', mag=array([], dtype=object), magErr=array([], dtype=object), midpointMjdTai=array([], dtype=object), ra=array([], dtype=object), dec=array([], dtype=object), phaseAngle=array([], dtype=object), topocentricDist=array([], dtype=object), heliocentricDist=array([], dtype=object), reduced_mag=array([], dtype=object), num_obs=0)],\n", - " 'MPCORB': MPCORB(ssObjectId='8268570668335894776', mpcDesignation='2014 QL4', mpcNumber=0, mpcH=19.8799991607666, mpcG=0.15000000596046448, epoch=60065.0, peri=260.5468204162153, node=322.8059, incl=4.427569999999975, e=0.7168805704972735, n=nan, q=0.5898291078470536, uncertaintyParameter='', flags='0'),\n", - " 'SSObject': SSObject(ssObjectId='8268570668335894776', filter_list=['u', 'g', 'r', 'i', 'z', 'y'], discoverySubmissionDate=60218.0, firstObservationDate=60220.01958, arc=3342.05859375, numObs=94, H=array([ nan, 20.29232597, 19.80589294, 19.47262955, 19.59087944,\n", - " nan]), G12=array([ nan, 1.72339332, 1.52932608, 1.7948637 , 1.70006168,\n", - " nan]), Herr=array([ nan, 0.0302103 , 0.01974303, 0.02164448, 0.04272443,\n", - " nan]), G12err=array([ nan, 0.04049731, 0.05071714, 0.04562044, 0.09607928,\n", - " nan]), nData=array([ 0., 9., 38., 32., 15., 0.]), maxExtendedness=0.0, minExtendedness=0.0, medianExtendedness=0.0),\n", - " 'AdlerData': AdlerData(filter_list=['u', 'g', 'r', 'i', 'z', 'y'], model_lists=[[], [], [], [], [], []], phaseAngle_min_adler=array([nan, nan, nan, nan, nan, nan]), phaseAngle_range_adler=array([nan, nan, nan, nan, nan, nan]), nobs_adler=array([0, 0, 0, 0, 0, 0]), arc_adler=array([nan, nan, nan, nan, nan, nan]), H_adler=[[], [], [], [], [], []], H_err_adler=[[], [], [], [], [], []], phase_parameters=[[], [], [], [], [], []], phase_parameters_err=[[], [], [], [], [], []])}" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# inspect the object\n", "# planetoid.__dict__" @@ -257,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "1d360360-025b-4a77-acf5-325b2f2d1873", "metadata": { "execution": { @@ -268,42 +96,14 @@ "shell.execute_reply.started": "2024-02-29T16:09:14.290937Z" } }, - "outputs": [ - { - "data": { - "text/plain": [ - "{'ssObjectId': '8268570668335894776',\n", - " 'filter_list': ['u', 'g', 'r', 'i', 'z', 'y'],\n", - " 'discoverySubmissionDate': 60218.0,\n", - " 'firstObservationDate': 60220.01958,\n", - " 'arc': 3342.05859375,\n", - " 'numObs': 94,\n", - " 'H': array([ nan, 20.29232597, 19.80589294, 19.47262955, 19.59087944,\n", - " nan]),\n", - " 'G12': array([ nan, 1.72339332, 1.52932608, 1.7948637 , 1.70006168,\n", - " nan]),\n", - " 'Herr': array([ nan, 0.0302103 , 0.01974303, 0.02164448, 0.04272443,\n", - " nan]),\n", - " 'G12err': array([ nan, 0.04049731, 0.05071714, 0.04562044, 0.09607928,\n", - " nan]),\n", - " 'nData': array([ 0., 9., 38., 32., 15., 0.]),\n", - " 'maxExtendedness': 0.0,\n", - " 'minExtendedness': 0.0,\n", - " 'medianExtendedness': 0.0}" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "planetoid.SSObject.__dict__" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "be8f8d63", "metadata": {}, "outputs": [], @@ -313,104 +113,17 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "da1e483d", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'ssObjectId': '8268570668335894776',\n", - " 'filter_name': 'r',\n", - " 'mag': array([21.91399956, 21.98600006, 21.75900078, 22.09399986, 21.61499977,\n", - " 21.72800064, 21.72200012, 20.4470005 , 21.78899956, 21.95899963,\n", - " 22.17900085, 22.44499969, 22.38999939, 22.92399979, 22.24799919,\n", - " 22.27599907, 22.29100037, 22.66200066, 22.69799995, 23.93300056,\n", - " 23.74200058, 22.14299965, 22.16799927, 22.24900055, 22.28499985,\n", - " 22.26199913, 22.44000053, 23.56800079, 23.70199966, 24.19499969,\n", - " 22.22900009, 22.04899979, 22.17700005, 23.52199936, 23.70199966,\n", - " 22.88699913, 23.06800079, 24.24200058]),\n", - " 'magErr': array([0.095 , 0.049 , 0.07 , 0.047 , 0.036 ,\n", - " 0.038 , 0.034 , 0.011 , 0.052 , 0.06 ,\n", - " 0.042 , 0.098 , 0.1 , 0.116 , 0.046 ,\n", - " 0.06 , 0.082 , 0.083 , 0.063 , 0.35100001,\n", - " 0.2 , 0.057 , 0.034 , 0.036 , 0.054 ,\n", - " 0.051 , 0.046 , 0.17200001, 0.199 , 0.17 ,\n", - " 0.264 , 0.28299999, 0.31600001, 0.163 , 0.248 ,\n", - " 0.182 , 0.211 , 0.38299999]),\n", - " 'midpointMjdTai': array([63492.00291, 63500.06856, 63479.0044 , 63502.00311, 62406.09011,\n", - " 62407.07445, 62407.09369, 61294.15865, 62412.12365, 62414.13572,\n", - " 62415.05691, 62422.06327, 62422.06596, 63534.03975, 61322.07319,\n", - " 61323.00925, 61326.03134, 61329.00043, 61330.01524, 63554.05676,\n", - " 63562.05437, 60223.98877, 60224.07621, 60226.02382, 60228.0802 ,\n", - " 60228.08066, 60230.03315, 61355.02232, 61355.02277, 60264.01472,\n", - " 61253.97055, 61253.96744, 61253.96433, 61052.13729, 63217.23761,\n", - " 62125.2233 , 62113.17449, 62095.28873]),\n", - " 'ra': array([268.4639755, 281.1782352, 239.848597 , 283.7424099, 298.1255196,\n", - " 298.9437966, 298.9592036, 301.5682143, 302.7875618, 304.1818652,\n", - " 304.7993288, 309.1175392, 309.1190487, 311.280946 , 315.2799036,\n", - " 315.6390597, 316.7793075, 317.8804823, 318.2527231, 322.0860789,\n", - " 325.868688 , 322.7789008, 322.7931457, 323.1475474, 323.5372789,\n", - " 323.5373434, 323.9242256, 327.0967385, 327.0968451, 332.3781914,\n", - " 170.4323598, 170.4247983, 170.4172297, 62.6767601, 68.4459325,\n", - " 69.233718 , 74.6917865, 81.7128501]),\n", - " 'dec': array([-22.9543395, -21.8517282, -21.8243507, -21.5140075, -18.6306791,\n", - " -18.443366 , -18.4396764, -17.709034 , -17.5230447, -17.1737751,\n", - " -17.0169932, -15.874741 , -15.8743016, -15.6284188, -13.7156598,\n", - " -13.6098197, -13.2712987, -12.9420707, -12.8300092, -12.3090787,\n", - " -11.0256047, -10.889507 , -10.8850457, -10.7825671, -10.6694075,\n", - " -10.6693695, -10.5571517, -10.035292 , -10.0351984, -7.9025949,\n", - " -3.6550378, -3.6513877, -3.6478445, 27.0535373, 28.5344673,\n", - " 28.6462634, 29.3204275, 29.563878 ]),\n", - " 'phaseAngle': array([ 56.70839691, 50.07988358, 72.76689148, 48.80239868,\n", - " 40.30448914, 39.98022079, 39.97434235, 33.56268311,\n", - " 38.53084564, 38.03194427, 37.81433105, 36.34851074,\n", - " 36.34802628, 36.50101089, 32.00559616, 31.97466469,\n", - " 31.86707687, 31.74268913, 31.69605255, 31.88496971,\n", - " 30.16068649, 26.89824295, 26.91216087, 27.17892265,\n", - " 27.42977715, 27.42983437, 27.63732719, 29.76596832,\n", - " 29.76592445, 27.73990822, 126.7827301 , 126.78705597,\n", - " 126.79136658, 18.63666534, 5.73195124, 7.0533433 ,\n", - " 2.55333257, 9.17568874]),\n", - " 'topocentricDist': array([0.58142245, 0.68610221, 0.47289231, 0.71412551, 0.70371586,\n", - " 0.72016948, 0.72049457, 0.45957258, 0.806705 , 0.8421095 ,\n", - " 0.85847169, 0.98606402, 0.98611432, 1.27393341, 0.93472457,\n", - " 0.95206416, 1.00859618, 1.06491303, 1.08432984, 1.67350197,\n", - " 1.8374033 , 0.92473841, 0.92631632, 0.96172243, 0.99953324,\n", - " 0.99954176, 1.03583491, 1.58487654, 1.58488584, 1.71470714,\n", - " 0.20776999, 0.20780498, 0.20783997, 1.4200809 , 1.59280014,\n", - " 1.50733411, 1.56365716, 1.73338318]),\n", - " 'heliocentricDist': array([1.19897687, 1.29408848, 1.0418874 , 1.31655276, 1.42970574,\n", - " 1.44069195, 1.44090629, 1.35723567, 1.49640727, 1.51831007,\n", - " 1.52828085, 1.60294342, 1.60297179, 1.66633558, 1.66025329,\n", - " 1.66984999, 1.70058703, 1.73042095, 1.74053574, 1.86338043,\n", - " 1.93771982, 1.73265779, 1.73353231, 1.75293028, 1.77324426,\n", - " 1.77324879, 1.79237878, 1.97701716, 1.97702122, 2.10192013,\n", - " 0.87671232, 0.87667543, 0.87663853, 2.21820784, 2.55602884,\n", - " 2.46223307, 2.54469585, 2.65981913]),\n", - " 'reduced_mag': array([22.69748655, 22.2442361 , 23.29608557, 22.22793578, 21.60177977,\n", - " 21.64797142, 21.64066789, 21.47195362, 21.38017677, 21.42535443,\n", - " 21.5893551 , 21.45088317, 21.39573365, 21.28945381, 21.29370916,\n", - " 21.2692807 , 21.11941945, 21.33467112, 21.31877818, 21.46336177,\n", - " 20.98452321, 21.11934119, 21.13954299, 21.1149286 , 21.04217083,\n", - " 21.01914605, 21.09639885, 21.08797141, 21.22195309, 21.41096887,\n", - " 25.92680044, 25.74652589, 25.87425196, 21.03042275, 20.65336449,\n", - " 20.03930569, 20.06911369, 20.92326717]),\n", - " 'num_obs': 38}" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "obs_r.__dict__" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "9d7dc125-06c1-49ad-8854-17d8c8b6954f", "metadata": { "execution": { @@ -421,18 +134,7 @@ "shell.execute_reply.started": "2024-02-29T16:09:14.353500Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# plot the observations\n", "x_plot = \"phaseAngle\"\n", @@ -457,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "6efe3b5a-09dd-4d5e-9f41-20ea6e1b43df", "metadata": { "execution": { @@ -468,16 +170,7 @@ "shell.execute_reply.started": "2024-02-29T16:09:14.545603Z" } }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jrobinson/miniconda3/envs/adler-dev/lib/python3.10/site-packages/sbpy/photometry/iau.py:50: InvalidPhaseFunctionWarning: G12 parameter could result in an invalid phsae function\n", - " warnings.warn(msg, exception)\n" - ] - } - ], + "outputs": [], "source": [ "# define the phase curve\n", "\n", @@ -491,7 +184,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "80f552f1-8907-4cc9-b57c-2e667eab459c", "metadata": { "execution": { @@ -502,25 +195,14 @@ "shell.execute_reply.started": "2024-02-29T16:09:14.554620Z" } }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "pc.model_function" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "24c1955e-95cd-4d77-ad05-aa5b8d18620a", "metadata": { "execution": { @@ -531,33 +213,7 @@ "shell.execute_reply.started": "2024-02-29T16:09:14.572960Z" } }, - "outputs": [ - { - "data": { - "text/latex": [ - "$[0,~2.5875789,~5.1751578,~7.7627367,~10.350316,~12.937895,~15.525473,~18.113052,~20.700631,~23.28821,~25.875789,~28.463368,~31.050947,~33.638526,~36.226105,~38.813684,~41.401263,~43.988841,~46.57642,~49.163999,~51.751578,~54.339157,~56.926736,~59.514315,~62.101894,~64.689473,~67.277052,~69.864631,~72.452209,~75.039788,~77.627367,~80.214946,~82.802525,~85.390104,~87.977683,~90.565262,~93.152841,~95.74042,~98.327999,~100.91558,~103.50316,~106.09074,~108.67831,~111.26589,~113.85347,~116.44105,~119.02863,~121.61621,~124.20379,~126.79137] \\; \\mathrm{{}^{\\circ}}$" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "alpha = np.linspace(0, np.amax(obs_r.phaseAngle)) * u.deg\n", "alpha" @@ -565,7 +221,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "c3f30fe0-0d89-4ffa-8237-9c71181d44ee", "metadata": { "execution": { @@ -576,30 +232,7 @@ "shell.execute_reply.started": "2024-02-29T16:09:14.594943Z" } }, - "outputs": [ - { - "data": { - "text/latex": [ - "$[19.805893,~19.920355,~20.052052,~20.202895,~20.360566,~20.513141,~20.658458,~20.794601,~20.920251,~21.035105,~21.140282,~21.238644,~21.334969,~21.432803,~21.532351,~21.633562,~21.736362,~21.840655,~21.946316,~22.053192,~22.161093,~22.2698,~22.379056,~22.488576,~22.598035,~22.706974,~22.814826,~22.920961,~23.024702,~23.12535,~23.222222,~23.314692,~23.402255,~23.484581,~23.561579,~23.633452,~23.700294,~23.761468,~23.816277,~23.864116,~23.904505,~23.937131,~23.961868,~23.978792,~23.988178,~23.990477,~23.986295,~23.97653,~23.964571,~23.955435] \\; \\mathrm{mag}$" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "red_mag = pc.ReducedMag(alpha)\n", "red_mag" @@ -607,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "04be98a1-e4dc-4216-bcd9-ef777f6053fb", "metadata": { "execution": { @@ -618,18 +251,7 @@ "shell.execute_reply.started": "2024-02-29T16:09:14.615623Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# %matplotlib widget\n", "\n", @@ -658,7 +280,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "9815543d-6140-4bdb-8bad-8296994723f4", "metadata": { "execution": { @@ -669,18 +291,7 @@ "shell.execute_reply.started": "2024-02-29T16:09:14.784731Z" } }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAGwCAYAAABcnuQpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA9r0lEQVR4nO3de3RU1f3+8WeSkBskAwFCggRIgQoYQEDEEIyoECj+VNRWq6Ki1AsNIGpRUSuolVDFS1dbsVgLWkSt/cpViUbBIJY7RIxoFAyCkHCLzEACITD794crI0Nuk2GSmRPer7Vmrcw5e858Zq/JzDP77HOOzRhjBAAAYFEhgS4AAADgTBBmAACApRFmAACApRFmAACApRFmAACApRFmAACApRFmAACApYUFuoCG5nK5tGfPHsXExMhmswW6HAAA4AVjjA4fPqz27dsrJKT2sZcmH2b27NmjpKSkQJcBAAB8sGvXLnXo0KHWNk0+zMTExEj6qTNiY2MDXA0AAPCG0+lUUlKS+3u8Nk0+zFTuWoqNjSXMAABgMd5MEWECMAAAsDTCDAAAsDTCDAAAsDTCDAAAsDTCDAAAsDTCDAAAsDTCDAAAsDTCDAAAsDTCDAAAsDTCDAAAsDTCDAAAsDTCDAAAsDTCDAAAsDTCDAAAsLSwQBcAAFZSdvyEej7+gfv+1ieHKzqcj1IgkBiZAQAAlkaYAQAAlkaYAQAAlhbQMJOVlaUBAwYoJiZG8fHxGjVqlAoKCjzaHDt2TJmZmWrdurVatGih6667Tnv37g1QxQAAINgENMzk5uYqMzNTa9asUU5OjioqKpSRkaHS0lJ3m/vuu09LlizRO++8o9zcXO3Zs0fXXnttAKsGgJ+tKyzRSZcJdBnAWc1mjAma/8L9+/crPj5eubm5Sk9Pl8PhUNu2bTV//nz9+te/liR9/fXX6tGjh1avXq2LLrqoyjbKy8tVXl7uvu90OpWUlCSHw6HY2NhGey0AmqYFm37Qff/53GNZoj1SU6/sqREpiQGqCmh6nE6n7Ha7V9/fQTVnxuFwSJLi4uIkSRs3blRFRYWGDh3qbtO9e3d17NhRq1evrnYbWVlZstvt7ltSUlLDFw7grJD1/tYqQUaSihzHNG7eJmXnFwWgKgBBE2ZcLpcmTZqktLQ0paSkSJKKi4sVHh6uli1berRt166diouLq93OlClT5HA43Lddu3Y1dOkAzgLvbynSP1YW1rjeSHpiyVZ2OQEBEDRnesrMzFR+fr5WrVp1RtuJiIhQRESEn6oCAOmky+ixRfl1tityHNO6whKldmndCFUBqBQUIzPjx4/X0qVLtWLFCnXo0MG9PCEhQcePH9ehQ4c82u/du1cJCQmNXCWAs9W6whKVlB73qu2+w8cauBoApwtomDHGaPz48VqwYIGWL1+u5ORkj/X9+/dXs2bN9PHHH7uXFRQUaOfOnUpNTW3scgGcpeoTUOJjIhuwEgDVCehupszMTM2fP1+LFi1STEyMex6M3W5XVFSU7Ha7xo4dq/vvv19xcXGKjY3VhAkTlJqaWu2RTADQELwNKHHNm+nC5LgGrgbA6QIaZmbNmiVJGjJkiMfyOXPmaMyYMZKkF154QSEhIbruuutUXl6u4cOH66WXXmrkSgGczS5MjlOiPVJFjtpHaP50dYpCQ2yNVBWASkF1npmGUJ/j1AGgJtn5RRo3b5Nq+sC8Oz1ZU0b2bNSagKbMsueZAYBgNSIlUbNG91O7WM+jJeOah+ulm/oRZIAACppDswEg2I1ISVRa1zbqNe1D97LcyUMUE9ksgFUBYGQGAOrh9DkxzJEBAo8wAwAALI0wAwA+2vrkcEWHs7ceCDTCDAAAsDTCDAAAsDTGRwGgHqLDw7RjxhWBLgPAKRiZAQAAlkaYAQAAlkaYAQAAlkaYAQAAlkaYAQAAlkaYAQAAlkaYAQAggMqOn1Dnh99T54ffU9nxE4Eux5IIMwAAwNIIMwAAwNIIMwAAwNIIMwAAwNIIMwAAwNIIMwAAwNIIMwBQBw6dBYIbYQYAgAA66TLuv9cVlnjch3cIMwAABEh2fpGGPp/rvj9mznoN/vNyZecXBbAq6yHMAAAQANn5RRo3b5P2Oss9lhc7jmncvE0EmnogzAAA0MhOuoyeWLJV1e1Qqlz2xJKt7HLyEmEGAIBGtq6wREWOYzWuN5KKHMe0rrCk8YqyMMIMAACNbN/hmoOML+3OdoQZAAAaWXxMpF/bne0IMwAANLILk+OUaI+UrYb1NkmJ9khdmBzXmGVZFmEGAIBGFhpi09Qre0pSlUBTeX/qlT0VGlJT3MGpCDMAAATAiJREzRrdT/GxER7LE+yRmjW6n0akJAaoMusJC3QBAACcrUakJCqtaxv1mvahJGnu7QN0cbe2jMjUEyMzAAAE0KnB5cLkOIKMDwgzAACg3oLpAqyEGQAAYGmEGQCoA1c1BoIbYQYAasFVjYHgR5gBgBpwVWPAGggzOOsE06Q1BC+uagxYB+eZAYBq1OeqxqldWjdeYWhyosPDtGPGFYEuo95On0sWyPPjMDIDBCFGjwKPqxoDNQu2uWQBDTNZWVkaMGCAYmJiFB8fr1GjRqmgoMCjzezZszVkyBDFxsbKZrPp0KFDgSn2NCddRqu3H9SivN1avf0gQ80WwpEp8AZXNQaqF4xzyQIaZnJzc5WZmak1a9YoJydHFRUVysjIUGlpqbtNWVmZRowYoUceeSSAlXrKzi9S2ozluvGVNbr3rTzd+Moapc3g6AYrCLZfEwheXNUYqCpY55IFNMxkZ2drzJgxOu+889SnTx/NnTtXO3fu1MaNG91tJk2apIcfflgXXXRRACv9WXZ+ke6Zt0nFTs+h5WLnMd3D0Q1BLRh/TSB4cVVjoKr6zCVrTEE1Z8bhcEiS4uJ8/6VTXl4up9PpcfOXky6jh9/9otY2U979gt0WQShYf03UhF1hwYGrGgOegnUuWdCEGZfLpUmTJiktLU0pKSk+bycrK0t2u919S0pK8luNa747qENlFbW2+bGsQmu+O+i354R/BOuvieqwKyy4jEhJ1Ef3X+K+P/f2AVr10GUEGZyVgnUuWdCEmczMTOXn5+utt946o+1MmTJFDofDfdu1a5efKpRWb/cupHjbDo0nWH9NVKqcUP7kki91D7vCgg5XNQZ+EqxzyYLiPDPjx4/X0qVLtXLlSnXo0OGMthUREaGIiIi6G/rE26F+dgkEm2D9NSH9NBIzdfGXVQLMqYx++pB4YslWDeuZwJcpgIConEs2bt4m2eT5bRfIuWQBHZkxxmj8+PFasGCBli9fruTk5ECWU6eBnb07MZa37dB4gvXXRE2TkqsTTLvCAJy9gnEuWUBHZjIzMzV//nwtWrRIMTExKi4uliTZ7XZFRUVJkoqLi1VcXKxt27ZJkr744gvFxMSoY8eOZzRR2BcuL0dcvG2HxhOMvyZqm5RcG07SBiDQRqQkKq1rG/Wa9qGkn+aSnbVnAJ41a5YcDoeGDBmixMRE9+3tt992t3n55ZfVt29f3XnnnZKk9PR09e3bV4sXL270ehds3u3XdmhcwfZroq5JyTXhJG0AgkEwzSUL6MiMMXX/Jp02bZqmTZvW8MV44Ycfy/zaDo0vmH5N1HeExaafghcnaQMQaGXHT6jn4x8Eugy3oDmayQrOaRnl13YIjGD5NVHfERYjTtIGANUhzNTDr/t7d84ab9vh7FbXpGQAgHcIM/UwqGsbRYeH1tqmeXioBnVt00gVwcpqO11+dSoPzeZswAACpez4CXV++D2PXUxbnxyu6PDAnumFMFMPoSE2PX99n1rbPHd9H3YDBLno8DDtmHGFdsy4IuD/gCNSEnVXerJsXrxlODQbQKAF648pwkw9jUhJ1Muj+6ldzGlHxMRG6GWu1YJ6ys4v0j9WFqo+nw8cmg0gEE6/1EqlnK17A1CNp6A4A7DVjEhJ1LCeCVpXWKJ9h48pPuanI0zKT5xU54ffkxQcw24Ibt5cuLQ6HJoNoLFVnuCzut9dk97KU0RYSEB/zPNt66PQEJtSu3CmX/jOmwuXnopDswEEgjcn+Az0pVbYzQQESH0uSBrIa54AOLvVdYLPYJjPx8gMEDDeT5Rp1Txc069JYU4W6nTSZbSusEQ//Fimyf/dIond3jgz3s7TC+R8Pt7dfnTqLO91hSUBvU4Fgl/qL9robyu2e9X2twOSCDIBVHkEXLDLzi/SE0u2VvkV/dKKbbpv2Ll8HsEn3s7TC+R8PnYz+cnps7zHzFmvwX9eruz8ogBWhWB2UZfWigjz7l+Q7yDUpXKCZnW7A/62Yrv6/ymHzyP4pK4TfNokJQZ4Ph9hxg8qP0T2Oss9lhc7jmncvE18gKBaoSE23XPJL7xqm/oLTsSImnkzQfNQWQWfR/CJNyf4DPR8PsLMGartQ6RyGWdtRU0mXv7LOs8q3TKqmS7iyDnUwtsrsBvxeQTfjEhJ1KzR/RQfG1FlXealXTSsZ0IAqvoZYeYMWWGWN4LPSZfR6u0HtXTLHt2d3qXWtk9cfR5zHVCrYsdRr9vyeQRfjUhJ1Ef3X1Jl+d9WbA/4tAomAJ8hK8zyRnCpbpJmy+hmMi4jx7ETVdoP69muMcuDBZWUHq9X+2Inn0fwzWfbDsimqsdiVk6rmBWgM+ETZs6QFWZ5I3jUdBZNR1mFjKT7hnZT5zbN3WeVZkQG3ohrUXXovzYlR8rrbgScpq5pFZUXww3EyfPYzXSGrDDLG8HBmw+Ct9bv0v/r3V6pXVoTZOC1hNj6/ViKax7eQJWgKQvmaRWEmTNU2yxvztqKUwXzBwGsrfJHlbcS7FENWA2aqmCeVkGY8YOaZnkn2CMDtv8QwSeYPwhgbaf+qKoLI8XwVTBPqyDM+Mnps7zn3j5Aqx66jCADt2D+IID1jUhJ1Es39VOLiJqnQtrESDF8F8zTKggzfnTqBwSTN3G6YP4ggPVl5xfpqfe26kh51SPiJKlVdDNGinFGgnlaBWEGaCTB/EEAa6vtUgaVfiyraMSK0FQF67QKwgzQiCo/CBJOm6wZ6A8CWJc3lzKQfj5slrP/4kwF47QKzjPjR1a5si4Ca0RKoob1TNC6whLtO3yMc8rgjNTnUgaVR8ulcnkMnKFgm1ZBmAECIDTExhcK/KK+R79xtByaInYzAYCFxUXV7wR4HC2HpogwAwAW9vXew1635Wg5NFWEGQCwsF0/lnndlqPl0FQRZgDAwjrFRXvV7tf9zuFoOTRZhBkAsLBbUjurrsEWm6Tp1/ZulHqAQCDMAICFhYeF6M6Lk2ttc1d6ssLD+LhH08Wh2QBgcVNG/nRm6Vc+LdSp58QLsUl3XpzsXg80VYQZAGgCpozsqQcyuuvfq3fo+5IydYqL1i2pnRmRwVmBMAMATUR4WIjGXvyLQJcBNDoiOwAAsDTCDAAAsDR2MwEAgHoJtgsrMzIDAAAsjTADAAAsjTADAAAsjTADAAAsjTADAAAsLaBhJisrSwMGDFBMTIzi4+M1atQoFRQUuNeXlJRowoQJOvfccxUVFaWOHTtq4sSJcjgcAawaAAAEk4CGmdzcXGVmZmrNmjXKyclRRUWFMjIyVFpaKknas2eP9uzZo5kzZyo/P19z585Vdna2xo4dG8iyAQBAELEZY0zdzRrH/v37FR8fr9zcXKWnp1fb5p133tHo0aNVWlqqsLC6T5PjdDplt9vlcDgUGxvr75IBAEADqM/3d1CdNK9y91FcXFytbWJjY2sMMuXl5SovL3ffdzqd/i0SAAAElaCZAOxyuTRp0iSlpaUpJSWl2jYHDhzQU089pbvuuqvG7WRlZclut7tvSUlJDVUyAAAIAkGzm2ncuHFatmyZVq1apQ4dOlRZ73Q6NWzYMMXFxWnx4sVq1qxZtdupbmQmKSmJ3UwAAFiI5XYzjR8/XkuXLtXKlSurDTKHDx/WiBEjFBMTowULFtQYZCQpIiJCERERDVkuAAAIIgHdzWSM0fjx47VgwQItX75cycnJVdo4nU5lZGQoPDxcixcvVmRkZAAqBQAAwSqgIzOZmZmaP3++Fi1apJiYGBUXF0uS7Ha7oqKi3EGmrKxM8+bNk9PpdE/obdu2rUJDQwNZPgAACAIBnTNjs9mqXT5nzhyNGTNGn3zyiS699NJq2xQWFqpz5851PgeHZgMAYD2WmTNTV44aMmRInW0AAMDZLSgmAAMAgOBy0mW0rrBE+w4fU3xMpC5MjlNoSPV7VAKNMAMAADxk5xdp2uKtKnYecy9LiI3UtKt6akRKYgArq17QnDQPAAAEXnZ+ke6Zt8kjyEhSsfOY7pm3Sdn5RQGqrGaEGQAAIOmnXUsPv/tFrW2mvPuFTrqCaz6rT7uZFi9eXO1ym82myMhIde3atdpzxgAAgOC15ruDOlRWUWubH8sqtOa7g0rr2qaRqqqbT2Fm1KhRstlsVY40qlxms9k0ePBgLVy4UK1atfJLoQAAoGGt3n7Q63bBFGZ82s2Uk5OjAQMGKCcnRw6HQw6HQzk5ORo4cKD7sgQHDx7UH/7wB3/XCwAAGoy3u4+awG6me++9V7Nnz9agQYPcyy6//HJFRkbqrrvu0pdffqkXX3xRd9xxh98KBQAADSv1F230txXbvWoXTHwamdm+fXu1Z+OLjY3Vd999J0nq1q2bDhw4cGbVAQCARnNRl9ZqGV3zxZwlqWV0M13UpXUjVeQdn8JM//79NXnyZO3fv9+9bP/+/XrwwQc1YMAASdK3336rpKQk/1QJAAAaXGiITTOu7VVrmxnX9gq6k+f5FGZeffVVFRYWqkOHDuratau6du2qDh06aMeOHfrnP/8pSTpy5Igee+wxvxYLAAAa1oiURL08up8SYiM8lifERujl0f2C8qR5Pl9o0uVy6cMPP9Q333wjSTr33HM1bNgwhYQE16lruNAkAAD1F+jLGdTn+zugV81uDIQZAACsp1Guml1aWqrc3Fzt3LlTx48f91g3ceJEXzcLAABQLz6Fmc2bN2vkyJEqKytTaWmp4uLidODAAUVHRys+Pp4wAwAAGo1PE1zuu+8+XXnllfrxxx8VFRWlNWvW6Pvvv1f//v01c+ZMf9cIAABQI5/CTF5enh544AGFhIQoNDRU5eXlSkpK0jPPPKNHHnnE3zUCAADUyKcw06xZM/dRS/Hx8dq5c6ckyW63a9euXf6rDgAAoA4+zZnp27ev1q9fr27duumSSy7R448/rgMHDujf//63UlJS/F0jAABAjXwamZk+fboSE386ac7TTz+tVq1aady4cdq/f79mz57t1wIBAABqw3lmAABA0KnP93dwna4XAACgnnyaM3Pw4EE9/vjjWrFihfbt2yeXy+WxvqSkxC/FAQAA1MWnMHPLLbdo27ZtGjt2rNq1ayebLbiungkAAM4ePoWZTz/9VKtWrVKfPn38XQ8AAEC9+DRnpnv37jp69Ki/awEAAEHg8LEKdX74PXV++D19UrBPJ13BfayQT2HmpZde0qOPPqrc3FwdPHhQTqfT4wYAAKwpO79IQ5/Pdd8fM2e9Bv95ubLziwJYVe182s3UsmVLOZ1OXXbZZR7LjTGy2Ww6efKkX4oDAACNJzu/SOPmbdLp4zDFjmMaN2+TZo3upxEpiQGprTY+hZmbb75ZzZo10/z585kADABAE3DSZfTEkq1VgowkGUk2SU8s2aphPRMUGhJc3/s+hZn8/Hxt3rxZ5557rr/rAQAAAbCusERFjmM1rjeSihzHtK6wRKldWjdeYV7wac7MBRdcwAUlAQBoQvYdrjnI+NKuMfk0MjNhwgTde++9mjx5snr16qVmzZp5rO/du7dfigMAAI0jPibSr+0ak09h5oYbbpAk3XHHHe5lNpuNCcAAAFjUhclxSrRHqthxrNp5MzZJCfZIXZgc19il1cmnMFNYWOjvOgAAQACFhtg09cqeGjdvk2ySR6CpnO479cqeQTf5V/IxzHTq1MmrdldccYX++c9/KjEx+A7jAgAAnkakJGrW6H6auvhL7XWWu5cn2CM19cqeQXlYtuRjmPHWypUrOVMwAAAWMiIlUcN6JmhdYYn2HT6m+Jifdi0F44hMpQYNMwAAwHpCQ2xBd/h1bXw6NBsAACBYEGYAAIClEWYAAIClEWYAAIClNWiYeeSRRxQXF3wn1wEAAE2HzRhT3Yn+qli8eLHXG73qqqu8apeVlaV3331XX3/9taKiojRo0CD9+c9/9riA5d13362PPvpIe/bsUYsWLdxtunfv7tVzOJ1O2e12ORwOxcbGev0aAABA4NTn+9vrMBMS4jmIU3n5glPvV/L2cgYjRozQb3/7Ww0YMEAnTpzQI488ovz8fG3dulXNmzeXJM2ePVvdu3dXx44dVVJSomnTpikvL0+FhYUKDQ2t8zkIMwAAWE+DhJlTffTRR3rooYc0ffp0paamSpJWr16txx57TNOnT9ewYcN8Knz//v2Kj49Xbm6u0tPTq22zZcsW9enTR9u2bVOXLl3q3CZhBgAA66nP97dPJ82bNGmSXn75ZQ0ePNi9bPjw4YqOjtZdd92lr776ypfNyuFwSFKN82xKS0s1Z84cJScnKykpqdo25eXlKi//+RTMTqfTp1oAAIA1+DQBePv27WrZsmWV5Xa7XTt27PCpEJfLpUmTJiktLU0pKSke61566SW1aNFCLVq00LJly5STk6Pw8PBqt5OVlSW73e6+1RR6AABA0+DTbqb09HRFRkbq3//+t9q1aydJ2rt3r2699VYdO3ZMubm59S5k3LhxWrZsmVatWqUOHTp4rHM4HNq3b5+Kioo0c+ZM7d69W5999pkiIyOrbKe6kZmkpCR2MwEAYCENPmdm27Ztuuaaa/TNN9+4Rz527dqlbt26aeHCheratWu9tjd+/HgtWrRIK1euVHJycq1tjx8/rlatWumf//ynbrzxxjq3zZwZAACsp8HnzHTt2lVbtmxRTk6Ovv76a0lSjx49NHToUI+jmupijNGECRO0YMECffLJJ3UGmcrHGGM8Rl8AAMDZy+erZttsNmVkZCg9PV0RERH1CjGVMjMzNX/+fC1atEgxMTEqLi6W9NPcm6ioKH333Xd6++23lZGRobZt2+qHH37QjBkzFBUVpZEjR/paOgAAaEJ8mgDscrn01FNP6ZxzzlGLFi1UWFgoSfrjH/+oV1991evtzJo1Sw6HQ0OGDFFiYqL79vbbb0uSIiMj9emnn2rkyJHq2rWrbrjhBsXExOh///uf4uPjfSkdAAA0MT6NzPzpT3/Sa6+9pmeeeUZ33nmne3lKSopefPFFjR071qvt1DVdp3379nr//fd9KREAAJwlfBqZef311zV79mzdfPPNHmfh7dOnj3sODQAAQGPwKczs3r272iOWXC6XKioqzrgoAAAAb/kUZnr27KlPP/20yvL//ve/6tu37xkXBQAA4C2f5sw8/vjjuu2227R79265XC69++67Kigo0Ouvv66lS5f6u0YAANAITrqM1hWWaN/hY4qPidSFyXEKDan/0cqNzaeT5knSp59+qieffFKff/65jhw5on79+unxxx9XRkaGv2s8I5w0DwCAumXnF+mJJVtV5DjmXpZoj9TUK3tqREpio9fT4GcAthLCDAAAtcvOL9K4eZt0eiCoHJOZNbpfowea+nx/+zRnZv369Vq7dm2V5WvXrtWGDRt82SQAAAiAky6jJ5ZsrRJkJLmXPbFkq066gnfsw6cwk5mZqV27dlVZvnv3bmVmZp5xUQAAoHGsKyzx2LV0OiOpyHFM6wpLGq+oevIpzGzdulX9+vWrsrxv377aunXrGRcFAAAax77DNQcZX9oFgk9hJiIiQnv37q2yvKioSGFhPl/uCQAANLL4mEi/tgsEn8JMRkaGpkyZIofD4V526NAhPfLIIxo2bJjfigMAAA3rwuQ4JdojVdMB2Db9dFTThclxjVlWvfgUZmbOnKldu3apU6dOuvTSS3XppZcqOTlZxcXFeu655/xdIwAAaCChITZNvbKnJFUJNJX3p17ZM6jPN+PzodmlpaV644039PnnnysqKkq9e/fWjTfeqGbNmvm7xjPCodkAANSN88wEMcIMAADeCaYzANfn+9un2bqvv/56retvvfVWXzYLAAACKDTEptQurQNdRr35NDLTqlUrj/sVFRUqKytTeHi4oqOjVVISPMeiMzIDAID1NPgZgH/88UeP25EjR1RQUKDBgwfrzTff9KloAAAAX/gUZqrTrVs3zZgxQ/fee6+/NgkAAFAnv4UZSQoLC9OePXv8uUkAAIBa+TQBePHixR73jTEqKirS3/72N6WlpfmlMAAAAG/4FGZGjRrlcd9ms6lt27a67LLLOGkeAABoVD6FGZfL5e86AAAAfOLXOTMAAACNzeuRmfvvv9/rjT7//PM+FQMAAFBfXoeZzZs3e9zftGmTTpw4oXPPPVeS9M033yg0NFT9+/f3b4UAAAC18DrMrFixwv33888/r5iYGL322mvuswH/+OOPuv3223XxxRf7v0oAAIAa+HQ5g3POOUcffvihzjvvPI/l+fn5ysjICKpzzXA5AwAArKfBL2fgdDq1f//+Ksv379+vw4cP+7JJAAAAn/gUZq655hrdfvvtevfdd/XDDz/ohx9+0P/93/9p7Nixuvbaa/1dIwAAQI18Os/Myy+/rD/84Q+66aabVFFR8dOGwsI0duxYPfvss34tEAAAoDY+zZmpVFpaqu3bt0uSunTpoubNm/utMH9hzgwAANbT4HNmKhUVFamoqEjdunVT8+bNdQa5CAAAwCc+hZmDBw/q8ssv1y9/+UuNHDlSRUVFkqSxY8fqgQce8GuBAAAAtfEpzNx3331q1qyZdu7cqejoaPfyG264QdnZ2X4rDgAAoC4+TQD+8MMP9cEHH6hDhw4ey7t166bvv//eL4UBAAB4w6eRmdLSUo8RmUolJSWKiIg446IAAAC85VOYufjii/X666+779tsNrlcLj3zzDO69NJL/VYcAABAXXzazfTss8/qsssu04YNG3T8+HE9+OCD+vLLL1VSUqLPPvvM3zUCAADUqN5hpqKiQhMnTtSSJUuUk5OjmJgYHTlyRNdee60yMzOVmJjYEHUCAABUq95hplmzZtqyZYtatWqlRx99tCFqAgAA8JpPc2ZGjx6tV1991d+1AAAA1JtPc2ZOnDihf/3rX/roo4/Uv3//KpcxeP755/1SHAAAQF18GpnJz89Xv379FBMTo2+++UabN2923/Ly8rzeTlZWlgYMGKCYmBjFx8dr1KhRKigoqLatMUa/+tWvZLPZtHDhQl/KBgAATZBPIzMrVqzwy5Pn5uYqMzNTAwYM0IkTJ/TII48oIyNDW7durTLa8+KLL8pms/nleQEAQNPhU5jxl9MvfTB37lzFx8dr48aNSk9Pdy/Py8vTc889pw0bNnC0FAAA8BDQMHM6h8MhSYqLi3MvKysr00033aS///3vSkhIqHMb5eXlKi8vd993Op3+LxQAAAQNn+bMNASXy6VJkyYpLS1NKSkp7uX33XefBg0apKuvvtqr7WRlZclut7tvSUlJDVUyAAAIAkEzMpOZman8/HytWrXKvWzx4sVavny5Nm/e7PV2pkyZovvvv9993+l0EmgAAGjCgmJkZvz48Vq6dKlWrFjhcSXu5cuXa/v27WrZsqXCwsIUFvZT9rruuus0ZMiQarcVERGh2NhYjxsAAGi6bMYYE6gnN8ZowoQJWrBggT755BN169bNY31xcbEOHDjgsaxXr176y1/+oiuvvFLJycl1PofT6ZTdbpfD4SDYAABgEfX5/g7obqbMzEzNnz9fixYtUkxMjIqLiyVJdrtdUVFRSkhIqHbSb8eOHb0KMgAAoOkL6G6mWbNmyeFwaMiQIUpMTHTf3n777UCWBQAALCSgIzO+7OEK4F4xAAAQhIJiAjAAAICvCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSCDMAAMDSAhpmsrKyNGDAAMXExCg+Pl6jRo1SQUGBR5shQ4bIZrN53O65554AVQwAAIJNQMNMbm6uMjMztWbNGuXk5KiiokIZGRkqLS31aHfnnXeqqKjIfXvmmWcCVDEAAAg2YYF88uzsbI/7c+fOVXx8vDZu3Kj09HT38ujoaCUkJDR2eQAAwAKCas6Mw+GQJMXFxXksf+ONN9SmTRulpKRoypQpKisrq3Eb5eXlcjqdHjcAANB0BXRk5lQul0uTJk1SWlqaUlJS3MtvuukmderUSe3bt9eWLVv00EMPqaCgQO+++26128nKytITTzzRWGUDAIAAsxljTKCLkKRx48Zp2bJlWrVqlTp06FBju+XLl+vyyy/Xtm3b1KVLlyrry8vLVV5e7r7vdDqVlJQkh8Oh2NjYBqkdAAD4l9PplN1u9+r7OyhGZsaPH6+lS5dq5cqVtQYZSRo4cKAk1RhmIiIiFBER0SB1AgCA4BPQMGOM0YQJE7RgwQJ98sknSk5OrvMxeXl5kqTExMQGrg4AAFhBQMNMZmam5s+fr0WLFikmJkbFxcWSJLvdrqioKG3fvl3z58/XyJEj1bp1a23ZskX33Xef0tPT1bt370CWDgAAgkRA58zYbLZql8+ZM0djxozRrl27NHr0aOXn56u0tFRJSUm65ppr9Nhjj3k9/6U++9wAAEBwsMycmbpyVFJSknJzcxupGgAAYEVBdZ4ZAACA+iLMAAAASyPMAAAASyPMAAAASyPMAAAASyPMAAAASyPMAAAASyPMAAAASyPMAAAASyPMAAAASyPMAAAASyPMAAAASyPMAAAASyPMAAAASyPMAAAASyPMAAAASyPMAAAASyPMAA2s7PgJdX74PXV++D2VHT8R6HIAoMkhzAAAAEsjzAAAAEsjzAAAAEsjzAAAAEsjzAAN7NRJv0wABgD/I8wAAABLI8wAAABLI8wAAABLI8wAAABLI8wADeyky7j/3rDjR4/7AIAzR5gBGlB2fpH+318/c9+/Z94mDf7zcmXnFwWwKgBoWggzQAPJzi/SuHmbtP9wucfyYscxjZu3iUADAH5CmAEawEmX0RNLtqq6HUqVy55YspVdTgDgB4QZoAGsKyxRkeNYjeuNpCLHMa0rLGm8ogCgiSLMAA1g3+Gag4wv7QAANSPMAA0gPibSr+0AADUjzAAN4MLkOCXaI2WrYb1NUqI9UhcmxzVmWQDQJBFmgAYQGmLT1Ct7VjsBWPppzszUK3sqNKSmuAMA8BZhBgAAWBphBmgAlYdm18QmDs0GAH8hzAANgEOzAaDxEGaABsCh2QDQeAgzQANo0yLCr+0AADUjzAANwdupMEyZAYAzFtAwk5WVpQEDBigmJkbx8fEaNWqUCgoKqrRbvXq1LrvsMjVv3lyxsbFKT0/X0aNHA1Ax4J0DpeV1N6pHOwBAzQIaZnJzc5WZmak1a9YoJydHFRUVysjIUGlpqbvN6tWrNWLECGVkZGjdunVav369xo8fr5AQBpUQvDgDMAA0HpsxJmgGuvfv36/4+Hjl5uYqPT1dknTRRRdp2LBheuqpp3zaptPplN1ul8PhUGxsrD/LBWp00mU0+M/LVew4Vu2eJJukBHukVj10GSfOA4Bq1Of7O6iGNxwOhyQpLu6nU7zv27dPa9euVXx8vAYNGqR27drpkksu0apVq2rcRnl5uZxOp8cNaGyVZwCuTmV04QzAAOAfQRNmXC6XJk2apLS0NKWkpEiSvvvuO0nStGnTdOeddyo7O1v9+vXT5Zdfrm+//bba7WRlZclut7tvSUlJjfYagFONSEnUrNH91DbG84ilBHukZo3upxEpiQGqDACalqDZzTRu3DgtW7ZMq1atUocOHSRJ//vf/5SWlqYpU6Zo+vTp7ra9e/fWFVdcoaysrCrbKS8vV3n5z5MqnU6nkpKS2M2EgNnrPKqB05dLkl4e3U/DeiYwIgMAdajPbqawRqqpVuPHj9fSpUu1cuVKd5CRpMTEn3659uzpOVzfo0cP7dy5s9ptRUREKCKCc3cgeJwaXC7o3IogAwB+FtDdTMYYjR8/XgsWLNDy5cuVnJzssb5z585q3759lcO1v/nmG3Xq1KkxSwUAAEEqoCMzmZmZmj9/vhYtWqSYmBgVFxdLkux2u6KiomSz2TR58mRNnTpVffr00fnnn6/XXntNX3/9tf773/8GsnQAABAkAhpmZs2aJUkaMmSIx/I5c+ZozJgxkqRJkybp2LFjuu+++1RSUqI+ffooJydHXbp0aeRqAQBAMApomPF27vHDDz+shx9+uIGrAQAAVhQ0h2YDAAD4gjADAAAsjTADAAAsLSjOMwM0ZW1aRGrHjCsCXQYANFmMzAAAAEsjzAAAAEsjzAAAAEsjzAAAAEsjzAAAAEsjzAAAAEsjzAAAAEsjzAAAAEsjzAAAAEsjzAAAAEsjzAAAAEsjzAAAAEsjzAAAAEsjzAAAAEsjzAAAAEsLC3QBDc0YI0lyOp0BrgQAAHir8nu78nu8Nk0+zBw+fFiSlJSUFOBKAABAfR0+fFh2u73WNjbjTeSxMJfLpT179igmJkY2my3Q5TQ4p9OppKQk7dq1S7GxsYEuJ6DoC0/0x8/oC0/0hyf642eB7AtjjA4fPqz27dsrJKT2WTFNfmQmJCREHTp0CHQZjS42Nvas/yesRF94oj9+Rl94oj880R8/C1Rf1DUiU4kJwAAAwNIIMwAAwNIIM01MRESEpk6dqoiIiECXEnD0hSf642f0hSf6wxP98TOr9EWTnwAMAACaNkZmAACApRFmAACApRFmAACApRFmAACApRFmgsDu3bs1evRotW7dWlFRUerVq5c2bNjgXm+M0eOPP67ExERFRUVp6NCh+vbbbz220blzZ9lsNo/bjBkzPNps2bJFF198sSIjI5WUlKRnnnmmSi3vvPOOunfvrsjISPXq1Uvvv/9+w7zoGtTVF++++64yMjLUunVr2Ww25eXlVdnGsWPHlJmZqdatW6tFixa67rrrtHfvXo82O3fu1BVXXKHo6GjFx8dr8uTJOnHihEebTz75RP369VNERIS6du2quXPnNsRLrpU/+mPIkCFV3hv33HOPR5um0B8VFRV66KGH1KtXLzVv3lzt27fXrbfeqj179nhso6SkRDfffLNiY2PVsmVLjR07VkeOHPFoY/X/FW/7oql8bkh1/69MmzZN3bt3V/PmzdWqVSsNHTpUa9eu9djG2fDekLzrC8u9NwwCqqSkxHTq1MmMGTPGrF271nz33Xfmgw8+MNu2bXO3mTFjhrHb7WbhwoXm888/N1dddZVJTk42R48edbfp1KmTefLJJ01RUZH7duTIEfd6h8Nh2rVrZ26++WaTn59v3nzzTRMVFWX+8Y9/uNt89tlnJjQ01DzzzDNm69at5rHHHjPNmjUzX3zxRdD0xeuvv26eeOIJ88orrxhJZvPmzVW2c88995ikpCTz8ccfmw0bNpiLLrrIDBo0yL3+xIkTJiUlxQwdOtRs3rzZvP/++6ZNmzZmypQp7jbfffediY6ONvfff7/ZunWr+etf/2pCQ0NNdnZ2g/bBqfzVH5dccom58847Pd4bDofDvb6p9MehQ4fM0KFDzdtvv22+/vprs3r1anPhhRea/v37e2xnxIgRpk+fPmbNmjXm008/NV27djU33nije31T+F/xti+awueGMd79r7zxxhsmJyfHbN++3eTn55uxY8ea2NhYs2/fPnebs+G94W1fWO29QZgJsIceesgMHjy4xvUul8skJCSYZ5991r3s0KFDJiIiwrz55pvuZZ06dTIvvPBCjdt56aWXTKtWrUx5ebnHc5977rnu+9dff7254oorPB43cOBAc/fdd9fnJfmsrr44VWFhYbVf3ocOHTLNmjUz77zzjnvZV199ZSSZ1atXG2OMef/9901ISIgpLi52t5k1a5aJjY1198+DDz5ozjvvPI9t33DDDWb48OG+vDSf+KM/jPkpzNx77701PrYp9keldevWGUnm+++/N8YYs3XrViPJrF+/3t1m2bJlxmazmd27dxtjmt7/SqXT+8KYpvG5UVlTffvD4XAYSeajjz4yxpzd743T+8IY67032M0UYIsXL9YFF1yg3/zmN4qPj1ffvn31yiuvuNcXFhaquLhYQ4cOdS+z2+0aOHCgVq9e7bGtGTNmqHXr1urbt6+effZZj90Eq1evVnp6usLDw93Lhg8froKCAv3444/uNqc+T2Wb05+nodTVF97YuHGjKioqPF5H9+7d1bFjR/frWL16tXr16qV27dq52wwfPlxOp1Nffvmlu00g+0LyT39UeuONN9SmTRulpKRoypQpKisrc69ryv3hcDhks9nUsmVLST+9jpYtW+qCCy5wtxk6dKhCQkLcw+xN9X/l9L6oZPXPDan+/XH8+HHNnj1bdrtdffr0kXT2vjeq64tKVnpvEGYC7LvvvtOsWbPUrVs3ffDBBxo3bpwmTpyo1157TZJUXFwsSR5fNJX3K9dJ0sSJE/XWW29pxYoVuvvuuzV9+nQ9+OCD7vXFxcXVbuPU56ipzanP05Dq6gtvFBcXKzw8vMoH9qmv40z6wul06ujRo/V9aT7xR39I0k033aR58+ZpxYoVmjJliv79739r9OjR7vVNtT+OHTumhx56SDfeeKP7AnnFxcWKj4/3aBcWFqa4uDi/vD+C9X+lur6QmsbnhuR9fyxdulQtWrRQZGSkXnjhBeXk5KhNmzbu13E2vTdq6wvJeu+NJn/V7GDncrl0wQUXaPr06ZKkvn37Kj8/Xy+//LJuu+02r7dz//33u//u3bu3wsPDdffddysrKyvoT0NdyV990VT4qz/uuusu99+9evVSYmKiLr/8cm3fvl1dunTxe90NpT79UVFRoeuvv17GGM2aNSsQ5TYof/VFU/jckLzvj0svvVR5eXk6cOCAXnnlFV1//fVau3ZtlRBjZf7qC6u9NxiZCbDExET17NnTY1mPHj20c+dOSVJCQoIkVTkaZ+/eve511Rk4cKBOnDihHTt2uLdT3TZOfY6a2tT2PP5UV194IyEhQcePH9ehQ4c8lp/6Os6kL2JjYxUVFeV1PWfCH/1RnYEDB0qStm3bJqnp9Ufll/f333+vnJwcj5GIhIQE7du3z6P9iRMnVFJS4pf3R7D9r9TWF9Wx4ueG5H1/NG/eXF27dtVFF12kV199VWFhYXr11VclnX3vjdr6ojrB/t4gzARYWlqaCgoKPJZ988036tSpkyQpOTlZCQkJ+vjjj93rnU6n1q5dq9TU1Bq3m5eXp5CQEHfKTk1N1cqVK1VRUeFuk5OTo3PPPVetWrVytzn1eSrb1PY8/lRXX3ijf//+atasmcfrKCgo0M6dO92vIzU1VV988YXHB1flB33lh0Cg+0LyT39Up/Lw7cTERElNqz8qv7y//fZbffTRR2rdurVH+9TUVB06dEgbN250L1u+fLlcLpc75DWV/5W6+qI6VvzckHz/X3G5XCovL5d0dr03qnNqX1Qn6N8bfp9SjHpZt26dCQsLM08//bT59ttvzRtvvGGio6PNvHnz3G1mzJhhWrZsaRYtWmS2bNlirr76ao9Ds//3v/+ZF154weTl5Znt27ebefPmmbZt25pbb73VvY1Dhw6Zdu3amVtuucXk5+ebt956y0RHR1c5jC4sLMzMnDnTfPXVV2bq1KmNekihN31x8OBBs3nzZvPee+8ZSeatt94ymzdvNkVFRe4299xzj+nYsaNZvny52bBhg0lNTTWpqanu9ZWHImdkZJi8vDyTnZ1t2rZtW+2hyJMnTzZfffWV+fvf/97ohyL7oz+2bdtmnnzySbNhwwZTWFhoFi1aZH7xi1+Y9PT0Jtcfx48fN1dddZXp0KGDycvL8zik9NQjLkaMGGH69u1r1q5da1atWmW6devmcfhtU/hf8aYvmsrnhjf9ceTIETNlyhSzevVqs2PHDrNhwwZz++23m4iICJOfn+/eztnw3vCmL6z43iDMBIElS5aYlJQUExERYbp3725mz57tsd7lcpk//vGPpl27diYiIsJcfvnlpqCgwL1+48aNZuDAgcZut5vIyEjTo0cPM336dHPs2DGP7Xz++edm8ODBJiIiwpxzzjlmxowZVWr5z3/+Y375y1+a8PBwc95555n33nuvYV50Derqizlz5hhJVW5Tp051tzl69Kj5/e9/b1q1amWio6PNNddc4xF2jDFmx44d5le/+pWJiooybdq0MQ888ICpqKjwaLNixQpz/vnnm/DwcPOLX/zCzJkzp6Fedo3OtD927txp0tPTTVxcnImIiDBdu3Y1kydP9jjPjDFNoz8qD0+v7rZixQp3u4MHD5obb7zRtGjRwsTGxprbb7/dHD582ON5rP6/4k1fNKXPDWNq74+jR4+aa665xrRv396Eh4ebxMREc9VVV5l169Z5bONseG940xdWfG/YjDHG/+M9AAAAjYM5MwAAwNIIMwAAwNIIMwAAwNIIMwAAwNIIMwAAwNIIMwAAwNIIMwAAwNIIMwAAwNIIMwDq9Mknn8hms1W5gOep5s6dq5YtW/r1eXfs2CGbzea+nlRj6ty5s1588cVa29hsNi1cuPCMn8ub/gVQM8IMgDoNGjRIRUVFstvtjfq8SUlJKioqUkpKitePmTZtms4///wqyzt37iybzaa33nqryrrzzjtPNptNc+fOdS9bv3697rrrLq+ec+7cubLZbLXeKq82XJ1A9S/QVBBmANQpPDxcCQkJstlsjfq8oaGhSkhIUFhYmF+2l5SUpDlz5ngsW7NmjYqLi9W8eXOP5W3btlV0dLRX273hhhtUVFTkvqWmpurOO+/0WJaUlFTj4wPVv0BTQZgBzkJDhgzRhAkTNGnSJLVq1Urt2rXTK6+8otLSUt1+++2KiYlR165dtWzZMknV7waZO3euOnbsqOjoaF1zzTU6ePCgx3NUjpD84x//UFJSkqKjo3X99dfL4XC427hcLj355JPq0KGDIiIidP755ys7O9u9/vTdTJV1fPzxx7rgggsUHR2tQYMGqaCgwF3TE088oc8//9w9InLqaMvNN9+s3Nxc7dq1y73sX//6l26++eYqgen03Uzffvut0tPTFRkZqZ49eyonJ8e9LioqSgkJCe5beHi4oqOj3fdzcnI0cOBAxcTEKCEhQTfddJP27dvnfjy7mYAzQ5gBzlKvvfaa2rRpo3Xr1mnChAkaN26cfvOb32jQoEHatGmTMjIydMstt6isrKzKY9euXauxY8dq/PjxysvL06WXXqo//elPVdpt27ZN//nPf7RkyRJlZ2dr8+bN+v3vf+9e/5e//EXPPfecZs6cqS1btmj48OG66qqr9O2339Za+6OPPqrnnntOGzZsUFhYmO644w5JP42QPPDAAzrvvPPcIyI33HCD+3Ht2rXT8OHD9dprr0mSysrK9Pbbb7sfXxOXy6Vrr71W4eHhWrt2rV5++WU99NBDtT7mVBUVFXrqqaf0+eefa+HChdqxY4fGjBnj9eMB1KFBrsUNIKhdcsklZvDgwe77J06cMM2bNze33HKLe1lRUZGRZFavXm1WrFhhJJkff/zRGGPMjTfeaEaOHOmxzRtuuMHY7Xb3/alTp5rQ0FDzww8/uJctW7bMhISEmKKiImOMMe3btzdPP/20x3YGDBhgfv/73xtjjCksLDSSzObNm40xxl3HRx995G7/3nvvGUnm6NGj7uft06dPldfcqVMn88ILL5iFCxeaLl26GJfLZV577TXTt29fY4wxdrvdzJkzp0p7Y4z54IMPTFhYmNm9e7fHa5FkFixYUOW5LrnkEnPvvfdWWV5p/fr1RpI5fPiwx+uq7F8A9cPIDHCW6t27t/vv0NBQtW7dWr169XIva9eunSR57A6p9NVXX2ngwIEey1JTU6u069ixo8455xyPNi6XSwUFBXI6ndqzZ4/S0tI8HpOWlqavvvrK69oTExNrrLM6V1xxhY4cOaKVK1fqX//6V52jMtJPrzcpKUnt27f3eC3e2rhxo6688kp17NhRMTExuuSSSyRJO3fu9HobAGpGmAHOUs2aNfO4b7PZPJZVTkZ1uVyNWpc3zqTOsLAw3XLLLZo6darWrl2rm2++uUFqrFRaWqrhw4crNjZWb7zxhtavX68FCxZIko4fP96gzw2cLQgzAOqtR48eWrt2rceyNWvWVGm3c+dO7dmzx6NNSEiIzj33XMXGxqp9+/b67LPPPB7z2WefqWfPnj7XFh4erpMnT9ba5o477lBubq6uvvpqtWrVqs5t9ujRQ7t27VJRUZF7WXWvtzpff/21Dh48qBkzZujiiy9W9+7dvR5FAuAd/xzvCOCsMnHiRKWlpWnmzJm6+uqr9cEHH3gchVQpMjJSt912m2bOnCmn06mJEyfq+uuvV0JCgiRp8uTJmjp1qrp06aLzzz9fc+bMUV5ent544w2fa+vcubMKCwuVl5enDh06KCYmRhERER5tevTooQMHDnh96PXQoUP1y1/+UrfddpueffZZOZ1OPfroo149tmPHjgoPD9df//pX3XPPPcrPz9dTTz1V79cFoGaMzACot4suukivvPKK/vKXv6hPnz768MMP9dhjj1Vp17VrV1177bUaOXKkMjIy1Lt3b7300kvu9RMnTtT999+vBx54QL169VJ2drYWL16sbt26+VzbddddpxEjRujSSy9V27Zt9eabb1bbrnXr1oqKivJqmyEhIVqwYIGOHj2qCy+8UL/73e/09NNPe/XYtm3bau7cuXrnnXfUs2dPzZgxQzNnzvT69QCom80YYwJdBICmZ9q0aVq4cGFALkXgD4mJiXrqqaf0u9/9LtClAKgDu5kA4BRlZWX67LPPtHfvXp133nmBLgeAF9jNBACnmD17tn77299q0qRJ9Tr8GkDgsJsJAABYGiMzAADA0ggzAADA0ggzAADA0ggzAADA0ggzAADA0ggzAADA0ggzAADA0ggzAADA0v4/xJyQUj3dfq4AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# plot the observations\n", "x_plot = \"midpointMjdTai\"\n", @@ -705,7 +316,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "de462b92-3914-4091-b0af-bddd9e9c1ef1", "metadata": { "execution": { @@ -724,7 +335,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "f92891c9-6ccf-4dac-8887-9545f633ba90", "metadata": { "execution": { @@ -742,7 +353,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "db24432b-6d05-4ff2-9d98-e52d8c2e4342", "metadata": { "execution": { @@ -753,25 +364,14 @@ "shell.execute_reply.started": "2024-02-29T16:09:14.976260Z" } }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "pc_fit.model_function" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "9039e2e2-27d9-4d21-b2f6-9504a5b85ce4", "metadata": { "execution": { @@ -782,25 +382,7 @@ "shell.execute_reply.started": "2024-02-29T16:09:14.994486Z" } }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "pc_fit.FitModel(\n", " phase_angle=obs_r.phaseAngle * u.deg,\n", @@ -811,7 +393,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "5d4b7144-ee72-45e0-9606-c40f83c443c6", "metadata": { "execution": { @@ -822,18 +404,7 @@ "shell.execute_reply.started": "2024-02-29T16:09:15.024533Z" } }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# %matplotlib widget\n", "\n", @@ -864,7 +435,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "b7f39ed4-8334-4e10-a97c-a9471105225b", "metadata": { "execution": { From 2f6a4ce4775e62bae2dbf833afa754f2c3ad825b Mon Sep 17 00:00:00 2001 From: jrob93 Date: Wed, 27 Mar 2024 18:05:58 +0000 Subject: [PATCH 18/18] example nb with foramtting --- notebooks/adler_examples_local_db.ipynb | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/notebooks/adler_examples_local_db.ipynb b/notebooks/adler_examples_local_db.ipynb index d352cd2..f959401 100644 --- a/notebooks/adler_examples_local_db.ipynb +++ b/notebooks/adler_examples_local_db.ipynb @@ -61,7 +61,7 @@ "# retrieve the object data via adler\n", "# here we use an offline SQL database which contains the observations of the sso\n", "fname = \"../tests/data/testing_database.db\"\n", - "planetoid = AdlerPlanetoid.construct_from_SQL(ssoid,sql_filename = fname)" + "planetoid = AdlerPlanetoid.construct_from_SQL(ssoid, sql_filename=fname)" ] }, { @@ -177,9 +177,7 @@ "r_H = planetoid.SSObject.H[2]\n", "r_G12 = planetoid.SSObject.G12[2]\n", "\n", - "pc = PhaseCurve(\n", - " abs_mag=r_H * u.mag, phase_param=r_G12, model_name=\"HG12_Pen16\"\n", - ")" + "pc = PhaseCurve(abs_mag=r_H * u.mag, phase_param=r_G12, model_name=\"HG12_Pen16\")" ] }, {