Rubin First Look Solar System object discoveries#
Rubin First Look Solar System object discoveries: orbits and magnitude variations¶
For the Solar System object discoveries released as part of Rubin First Look.
Last verified to run: 2026-02-12
Repository: github.com/lsst/tutorial-notebooks
Learning objective: Use the Minor Planet Center (MPC) to access Solar System object discoveries released as part of Rubin First Look.
LSST data products: Small body observations that were made by Rubin and submitted to the Minor Planet Center (MPC) were used by the MPC to compute orbits; the MPC-computed orbits and Rubin observations submitted to the MPC are retrieved from the MPC in this notebook.
Packages: get_orb and get_obs APIs from the Minor Planet Center.
Credit: Originally developed by Sarah Greenstreet and Mario Juric from the Rubin Community Science team, Solar System Processing (SSP) team and Solar System Commissioning science unit. Please consider acknowledging them if this notebook is used for the preparation of journal articles, software releases, or other notebooks.
Get Support: Everyone is encouraged to ask questions or raise issues in the Support Category of the Rubin Community Forum. Rubin staff will respond to all questions posted there.
1. Introduction¶
This notebook examines Solar System objects discovered and released as part of Rubin First Look, including examining their orbital classifications and magnitude variations. The Rubin First Look Solar System object discoveries are available in the Minor Planet Center (MPC)'s database and are not available on the Rubin Science Platform.
The Rubin First Look Solar System object discoveries were observed in the M49 region on 21 April, 24 April, 27 April, 29 April, 1 May, 2 May, 3 May, 2025 (parts of 7 nights in total). The discoveries consist of 2,098 Solar System objects, including 7 near-Earth objects (NEOs), 2,015 main-belt asteroids (MBAs), 11 Jupiter Trojans, 5 transneptunian objects (TNOs), and 60 additional objects.
This notebook provides examples of using the MPC get_orb API to retrieve the orbit information for all of the 2,098 Rubin First Look Solar System object discoveries and determine their orbital classifications. In addition, each of these 2,098 discoveries had dense enough coverage over the 7 nights of LSSTComCam observations to see magnitude variations in many of them. This notebook uses the MPC get_obs API to retrieve all the Rubin observations (observatory code X05) from the MPC for a subset of the 2,098 discoveries and examines an example object's magnitude variation.
1.1. Import packages¶
Import numpy, a fundamental package for scientific computing with arrays in Python
(numpy.org), and
matplotlib, a comprehensive library for data visualization
(matplotlib.org;
matplotlib gallery).
import requests
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from astropy.time import Time
from lsst.utils.plotting import (get_multiband_plot_colors,
get_multiband_plot_symbols)
1.2. Define parameters and functions¶
Define a targets list. Read in the provisional designations of the 2,098 Rubin First Look Solar System object discoveries from the Rubin_First_Look_Solar_System_Discovery_Designations.csv file.
targets = []
path = '/rubin/cst_repos/tutorial-notebooks-data/data/'
input_file = path + 'Rubin_First_Look_Solar_System_Discovery_Designations.csv'
with open(input_file, 'r') as f:
for line in f.readlines():
desig = line.strip().split(',')
if desig[0][0:1] != 'u':
targets.append(desig[0])
assert len(targets) == 2098
print('Number of targets: ', len(targets))
print('Example target names: ', targets[0], targets[1], targets[2])
Number of targets: 2098 Example target names: 2025 MO4 2025 MP4 2025 MQ4
Option to print the list of targets.
# print(targets[1:])
Define parameters to use colorblind-friendly colors with matplotlib.
plt.style.use('seaborn-v0_8-colorblind')
prop_cycle = plt.rcParams['axes.prop_cycle']
colors = prop_cycle.by_key()['color']
Define the colors and symbols to use in plots to represent the six LSST filters, $ugrizy$.
filter_names = ['u', 'g', 'r', 'i', 'z', 'y']
filter_colors = get_multiband_plot_colors()
filter_symbols = get_multiband_plot_symbols()
2. Orbits¶
The Rubin First Look Solar System object discoveries include 2,098 Solar System objects. Broken down by orbital classification, these discoveries include 7 near-Earth objects (NEOs), 2,015 main-belt asteroids (MBAs), 11 Jupiter Trojans, 5 transneptunian objects (TNOs), and 60 additional objects.
Below, retrieve orbit information for each discovery from the Minor Planet Center (MPC), calculate orbit classifications, and plot orbital parameters.
2.1. Query the Minor Planet Center¶
Use the Minor Planet Center's get_orb API to retrieve the orbit information for all 2,098 objects in the Rubin First Look Solar System discoveries and store the list of retrieved dictionaries in a DataFrame called discovery_orbits. Return fields for the object's provisional designation, absolute magnitude, semimajor axis, eccentricity, inclination, argument of perihelion, longitude of ascending node, time of perihelion passage, the total number of observations used in the orbit fit, and the orbit classification information. The request may take roughly 10 minutes or more to complete.
Warning: the following code cell produces a FutureWarning that is ok to ignore.
column_names = ['designation', 'absolute_magnitude',
'semimajor_axis', 'eccentricity',
'inclination', 'argument_of_perihelion',
'ascending_node', 'peri_time',
'nobs_total']
discovery_orbits = pd.DataFrame(columns=column_names)
for obj in targets[1:]:
response = requests.get("https://data.minorplanetcenter.net/api/get-orb", json={"desig": obj})
if response.ok:
mpc_orb = response.json()[0]['mpc_orb']
next_orb_df = pd.DataFrame(columns=column_names)
next_orb_df['designation'] = [mpc_orb[0]['designation_data']['unpacked_primary_provisional_designation']]
next_orb_df['absolute_magnitude'] = mpc_orb[0]['magnitude_data']['H']
next_orb_df['semimajor_axis'] = mpc_orb[0]['COM']['coefficient_values'][0]/(1.0 - mpc_orb[0]['COM']['coefficient_values'][1])
next_orb_df['eccentricity'] = mpc_orb[0]['COM']['coefficient_values'][1]
next_orb_df['inclination'] = mpc_orb[0]['COM']['coefficient_values'][2]
next_orb_df['ascending_node'] = mpc_orb[0]['COM']['coefficient_values'][3]
next_orb_df['argument_of_perihelion'] = mpc_orb[0]['COM']['coefficient_values'][4]
next_orb_df['peri_time'] = mpc_orb[0]['COM']['coefficient_values'][5]
next_orb_df['nobs_total'] = mpc_orb[0]['orbit_fit_statistics']['nobs_total']
next_orb_df['orbit_type_str'] = mpc_orb[0]['categorization']['orbit_type_str']
next_orb_df['orbit_type_int'] = mpc_orb[0]['categorization']['orbit_type_int']
else:
print("Error: ", response.status_code, response.content)
discovery_orbits = pd.concat([discovery_orbits, next_orb_df], ignore_index=True)
discovery_orbits['orbit_type_int'] = discovery_orbits['orbit_type_int'].apply(np.int64)
discovery_orbits
/tmp/ipykernel_563/1882236218.py:27: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation. discovery_orbits = pd.concat([discovery_orbits, next_orb_df], ignore_index=True)
| designation | absolute_magnitude | semimajor_axis | eccentricity | inclination | argument_of_perihelion | ascending_node | peri_time | nobs_total | orbit_type_str | orbit_type_int | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 2025 MP4 | 19.096 | 2.897743 | 0.054089 | 10.181741 | 309.134421 | 43.344292 | 61583.567732 | 32 | Main Belt | 11 |
| 1 | 2025 MQ4 | 20.047 | 3.066082 | 0.181365 | 16.304089 | 126.988053 | 42.091056 | 60691.915183 | 117 | Main Belt | 11 |
| 2 | 2025 MR4 | 19.619 | 3.023744 | 0.123046 | 7.357088 | 61.624559 | 137.839524 | 58884.629957 | 274 | Main Belt | 11 |
| 3 | 2025 MS4 | 17.902 | 3.230348 | 0.133779 | 6.850902 | 285.872675 | 86.071192 | 61843.346122 | 188 | Main Belt | 11 |
| 4 | 2025 MT4 | 19.286 | 2.624496 | 0.146611 | 13.845450 | 19.110632 | 36.147468 | 60248.920184 | 185 | Main Belt | 11 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| 2092 | 2025 MH88 | 19.065 | 2.775692 | 0.119218 | 5.653174 | 279.872207 | 68.732357 | 61489.326808 | 64 | Main Belt | 11 |
| 2093 | 2025 MJ88 | 20.425 | 2.337802 | 0.190616 | 6.484180 | 14.113660 | 89.929460 | 60529.157619 | 166 | Main Belt | 11 |
| 2094 | 2022 SZ331 | 18.388 | 2.983731 | 0.072460 | 6.494899 | 290.689425 | 97.358218 | 59944.018209 | 234 | Main Belt | 11 |
| 2095 | 2025 ML88 | 18.960 | 2.682665 | 0.039947 | 8.469304 | 328.758842 | 83.195029 | 60164.221632 | 230 | Main Belt | 11 |
| 2096 | 2025 MM88 | 18.941 | 2.548880 | 0.075732 | 9.845715 | 316.163968 | 45.407072 | 61473.786286 | 337 | Main Belt | 11 |
2097 rows × 11 columns
Option to write the discovery_orbits DataFrame to a csv file in order to avoid the need to repeat the time-consuming request at a future date.
# discovery_orbits.to_csv('Rubin_discovery_orbits.csv', index=False)
2.2. Plot orbit classifications¶
Plot the semimajor axes, eccentricities, and inclinations of the 2,098 Rubin First Look Solar System object discoveries. Use the orbit types defined by the MPC (https://minorplanetcenter.net/mpcops/documentation/orbit-types/) to distinguish each orbital classification in the plot.
a = discovery_orbits["semimajor_axis"]
e = discovery_orbits["eccentricity"]
inc = discovery_orbits["inclination"]
inner_orbits = discovery_orbits[a < 7]
outer_orbits = discovery_orbits[a >= 7]
orbit_type_map = {
0: "Atira",
1: "Aten",
2: "Apollo",
3: "Amor",
9: "Other",
10: "Mars Crosser",
11: "Main Belt",
12: "Jupiter Trojan",
19: "Other",
20: "Jupiter Coupled",
21: "Neptune Trojan",
22: "Centaur",
23: "TNO",
30: "Hyperbolic",
31: "Parabolic",
99: "Other"
}
fig, axes = plt.subplots(1, 2, figsize=(8, 4))
plt.subplots_adjust(wspace=0.25)
for ax, oo in zip(axes, (inner_orbits, outer_orbits)):
markers = "s^*+xDh"*2
for otype, orb in oo.groupby('orbit_type_int'):
if len(orb) > 500:
s, marker = 0.1, 'o'
else:
s = 10
marker, markers = markers[0], markers[1:]
label = orbit_type_map[otype]
ax.scatter(orb["semimajor_axis"],
orb["eccentricity"],
s=s, marker=marker,
label=f"{label} ({len(orb)})")
for handle in ax.legend().legend_handles:
handle.set_sizes([10])
ax.legend(loc='upper right', bbox_to_anchor=(0.92, 1), fontsize=6)
ax.set_xlabel("semimajor axis (au)")
ax.set_ylabel("eccentricity")
fig.suptitle(f"Rubin First Look Solar System Object Discoveries ({len(discovery_orbits)} objects)")
fig, axes = plt.subplots(1, 2, figsize=(8, 4))
plt.subplots_adjust(wspace=0.25)
for ax, oo in zip(axes, (inner_orbits, outer_orbits)):
markers = "s^*+xDh"*2
for otype, orb in oo.groupby('orbit_type_int'):
if len(orb) > 500:
s, marker = 0.1, 'o'
else:
s = 10
marker, markers = markers[0], markers[1:]
label = orbit_type_map[otype]
ax.scatter(orb["semimajor_axis"],
orb["inclination"], s=s,
marker=marker,
label=f"{label} ({len(orb)})")
for handle in ax.legend().legend_handles:
handle.set_sizes([10])
ax.legend(loc='upper right', fontsize=6)
ax.set_xlabel("semimajor axis (au)")
ax.set_ylabel("inclination (deg)")
Figure 1: Semimajor axis, eccentricity, and inclination for the 2,098 Rubin First Look Solar System object discoveries, with colors and symbols indicating orbital class. The left two plots show the inner orbits (semimajor axis < 7 au) while the right two plots show the outer orbits (semimajor axis >=7).
3. Magnitudes¶
Each of the 2,098 Rubin First Look Solar System object discoveries had dense enough coverage (over the nights of 21 April, 24 April, 27 April, 29 April, 1 May, 2 May, 3 May, 2025 (parts of 7 nights in total)) to see variations in their magnitudes. Below, retrieve all Rubin observations (observatory code X05) from the Minor Planet Center (MPC) for a subset of 10 example discoveries and examine the magnitude variation for one example object.
3.1. Query the Minor Planet Center¶
Create a subset target list of 10 Rubin discoveries. This example includes the objects with some of the smallest and largest semimajor axes, smallest and largest eccentricities, smallest and largest inclinations, brightest and faintest absolute magnitudes, and the smallest and largest number of observations.
target_subset = ['2025 ME74',
'2025 ML58',
'2025 MN73',
'2025 MJ25',
'2022 MO19',
'2025 MG88',
'2025 MP35',
'2025 MR32',
'2025 MO72',
'2025 MX21']
Use the Minor Planet Center's get_obs API to retrieve all observations for the target_subset objects in the Rubin First Look Solar System discoveries and store them in a pandas DataFrame called discovery_observations, reducing the number of columns to those needed and converting selected strings to floats using numpy's to_numeric module.
To retrieve the observations for all 2,098 Rubin First Look Solar System discoveries can take up to 40 minutes or more to complete, and is not recommended. It is recommended to select a subset of targets to include in the MPC's get_obs API query, resulting in faster retrieval. A collection of all Rubin observations submitted to the MPC to date is maintained by the Asteroid Institute (a program of the B612 Foundation) at ls.st/ast.
column_names_full = ['Obstype', 'artsat', 'astcat', 'band', 'com', 'ctr', 'dec', 'decstar',
'delay', 'deltadec', 'deltara', 'deprecated', 'disc', 'dist', 'doppler',
'exp', 'frq', 'localuse', 'logsnr', 'mag', 'mode', 'notes', 'nstars',
'nucmag', 'obscenter', 'obsid', 'obstime', 'pa', 'permid', 'photap',
'photcat', 'pos1', 'pos2', 'pos3', 'poscov11', 'poscov12', 'poscov13',
'poscov22', 'poscov23', 'poscov33', 'precdec', 'precra', 'prectime',
'prog', 'provid', 'ra', 'rastar', 'rcv', 'ref', 'remarks', 'rmscorr',
'rmsdec', 'rmsdelay', 'rmsdist', 'rmsdoppler', 'rmsfit', 'rmsmag',
'rmspa', 'rmsra', 'rmstime', 'seeing', 'stn', 'subfmt', 'subfrm', 'sys',
'trkid', 'trksub', 'trx', 'unctime']
column_names_trunc = ['Obstype', 'astcat', 'band', 'dec',
'mag', 'obstime', 'provid', 'ra',
'rmsdec', 'rmsmag', 'rmsra', 'stn',
'trksub']
discovery_observations = pd.DataFrame(columns=column_names_trunc)
for obj in target_subset[1:]:
response = requests.get("https://data.minorplanetcenter.net/api/get-obs",
json={"desigs": [obj], "output_format": ["ADES_DF"]})
if response.ok:
ades_df = pd.DataFrame(response.json()[0]['ADES_DF'])
else:
print("Error: ", response.status_code, response.content)
ingest_observations = ades_df.drop(['artsat', 'com', 'ctr', 'decstar',
'delay', 'deltadec', 'deltara',
'deprecated', 'disc', 'dist',
'doppler', 'exp', 'frq', 'localuse',
'logsnr', 'mode', 'notes', 'nstars',
'nucmag', 'obscenter', 'obsid', 'pa',
'permid', 'photap', 'photcat', 'pos1',
'pos2', 'pos3', 'poscov11', 'poscov12',
'poscov13', 'poscov22', 'poscov23',
'poscov33', 'precdec', 'precra',
'prectime', 'prog', 'rastar', 'rcv',
'ref', 'remarks', 'rmscorr', 'rmsdelay',
'rmsdist', 'rmsdoppler', 'rmsfit',
'rmspa', 'rmstime', 'seeing', 'subfmt',
'subfrm', 'sys', 'trkid', 'trx', 'unctime'], axis=1)
discovery_observations = pd.concat([discovery_observations, ingest_observations],
ignore_index=True)
discovery_observations['dec'] = pd.to_numeric(discovery_observations['dec'])
discovery_observations['ra'] = pd.to_numeric(discovery_observations['ra'])
discovery_observations['rmsdec'] = pd.to_numeric(discovery_observations['rmsdec'])
discovery_observations['rmsra'] = pd.to_numeric(discovery_observations['rmsra'])
discovery_observations['mag'] = pd.to_numeric(discovery_observations['mag'])
discovery_observations['rmsmag'] = pd.to_numeric(discovery_observations['rmsmag'])
len(discovery_observations)
Error: 500 b'{\n "error": "general_error",\n "message": "get-obs failed with Bad Label from designation identifier: DesignationResult(found=0, object_type=None, orbfit_name=None, name=None, citation=None, iau_designation=None, permid=None, packed_permid=None, packed_primary_provisional_designation=None, packed_secondary_provisional_designations=None, new_style_packed_permid=None, new_style_packed_primary_provisional_designation=None, new_style_packed_secondary_provisional_designations=None, unpacked_primary_provisional_designation=None, unpacked_secondary_provisional_designations=None, dual_status_info=None, disambiguation_list=None). Should have been caught by the designation identifier."\n}\n'
1524
Convert the obstime from isot to mjd. Add the MJD to a new column called epoch.
strings = []
for obs in discovery_observations['obstime']:
trunc_string = obs[:-1]
strings.append(trunc_string)
discovery_observations['epoch'] = Time(strings, format='isot', scale='utc').mjd
discovery_observations.head()
| Obstype | astcat | band | dec | mag | obstime | provid | ra | rmsdec | rmsmag | ... | stn | trksub | fltr | obssubid | shapeocc | trkmpc | vel1 | vel2 | vel3 | epoch | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | optical | Gaia2 | i | 5.495148 | 23.194 | 2025-04-22T02:39:32.840Z | 2025 ML58 | 187.076187 | 0.136 | 0.157 | ... | X05 | tnoa006 | None | 24580699629551649 | None | tnoa006 | None | None | None | 60787.110797 |
| 1 | optical | Gaia2 | i | 5.495205 | 23.307 | 2025-04-22T02:41:01.262Z | 2025 ML58 | 187.076196 | 0.104 | 0.164 | ... | X05 | tnoa006 | None | 24580699896414258 | None | tnoa006 | None | None | None | 60787.111820 |
| 2 | optical | Gaia2 | i | 5.495246 | 23.195 | 2025-04-22T02:43:22.655Z | 2025 ML58 | 187.076119 | 0.117 | 0.146 | ... | X05 | tnoa006 | None | 24580700296445973 | None | tnoa006 | None | None | None | 60787.113457 |
| 3 | optical | Gaia2 | i | 5.495203 | 23.204 | 2025-04-22T02:44:50.066Z | 2025 ML58 | 187.076139 | 0.080 | 0.152 | ... | X05 | tnoa006 | None | 24580700566454293 | None | tnoa006 | None | None | None | 60787.114468 |
| 4 | optical | Gaia2 | i | 5.495216 | 23.001 | 2025-04-22T02:47:02.172Z | 2025 ML58 | 187.076072 | 0.201 | 0.125 | ... | X05 | tnoa006 | None | 24580700968058883 | None | tnoa006 | None | None | None | 60787.115997 |
5 rows × 21 columns
Restrict the observations for all discoveries to those made by Rubin (observatory code X05).
select = np.isin(discovery_observations['stn'], 'X05', invert=False)
Rubin_discovery_observations = discovery_observations[select].copy()
len(Rubin_discovery_observations)
1443
Option to write the Rubin_discovery_observations DataFrame to a csv file.
# Rubin_discovery_observations.to_csv('Rubin_discovery_observations.csv', index=False)
3.2. Examine the magnitude variation for an example discovery¶
Isolate the Rubin observations for a single object. For example, choose the object with the largest number of observations.
object_name = '2025 MX21'
select = np.isin(Rubin_discovery_observations['provid'], object_name, invert=False)
selected_Rubin_discovery_observations = Rubin_discovery_observations[select].copy()
len(selected_Rubin_discovery_observations)
445
Plot the magnitude over time for the selected Rubin First Look Solar System object discovery both for the full observation period and on a single night to see the variation in magnitude.
MJDmin, MJDmax = 60797, 60797.2
MJD = selected_Rubin_discovery_observations['epoch']
mag = selected_Rubin_discovery_observations['mag']
full_obs = selected_Rubin_discovery_observations
single_night_obs = selected_Rubin_discovery_observations[(MJDmin < MJD) & (MJD < MJDmax)]
fig, axes = plt.subplots(1, 2, figsize=(14, 4))
axes[0].axvline(MJDmin + 0.1, lw=10, alpha=0.2, color='grey')
a = 0
for ax, mags in zip(axes, (full_obs, single_night_obs)):
for filt in ['g', 'r', 'i']:
select_filt = np.isin(mags['band'], filt, invert=False)
tx = np.where(select_filt == 1)[0]
ax.scatter(mags['epoch'][select_filt], mags['mag'][select_filt],
s=10, marker=filter_symbols[filt],
color=filter_colors[filt],
label=f"{filt} ({len(tx)})")
if a == 1:
ax.errorbar(mags['epoch'][select_filt], mags['mag'][select_filt],
yerr=mags['rmsmag'][select_filt], fmt='None',
ecolor=filter_colors[filt])
del select_filt, tx
a += 1
for handle in ax.legend().legend_handles:
handle.set_sizes([10])
ax.invert_yaxis()
ax.set_xlabel('MJD')
ax.set_ylabel('Magnitude')
ax.minorticks_on()
fig.suptitle(f"Rubin First Look Solar System Object Discovery {object_name} Magnitude Variation")
plt.show()
Figure 2: Magnitude over time for the selected Rubin First Look Solar System object discovery both for the full observation period (left) and on a single night (right) to see the magnitude variation. Observations were taken in $g$-, $r$-, and $i$-band.
3.3. Evaluate photometric quality¶
In a full Rubin data release, the photometry for moving objects in the DiaSource catalog comes with flag parameters to indicate potential issues with the photometric measurement or calibration (e.g., contamination from cosmic ray flux, sources at the edge of a detector), and the difference- and direct-images are available for visual checks on the source being measured.
Observational metadata such as seeing, sky background, and limiting metadata are also available.
These aspects of a full Rubin data release enable users to identify and reject potential poor-quality measurements from an analysis.
However, for the RFL photometry released to the MPC, the only indicator of photometric quality available is the rmsmag column.
Show the distribution of all rmsmag values in this target_subset of 10 Rubin discoveries in order to approximate the boundary between the distribution of "acceptable" or "normal" measurements, and the tail of any "outlier" measurements.
fig = plt.figure(figsize=(8, 3))
plt.axvline(0.23, ls='dashed', alpha=0.7, color='black')
for filt in ['g', 'r', 'i']:
select_filt = np.isin(Rubin_discovery_observations['band'],
filt, invert=False)
plt.hist(Rubin_discovery_observations['rmsmag'][select_filt], 80,
histtype='step', log=True, color=filter_colors[filt], label=filt)
plt.xlabel('rms mag')
plt.ylabel('log(N)')
plt.legend(loc='upper right')
plt.show()
Figure 3: The log of the number of photometric measurements with a given
rmsmagvalue for thistarget_subsetof 10 Rubin discoveries. The dashed grey line is drawn at $0.23$ mag, the approximate (by-eye) edge of the distribution ofrmsmagvalues for this 10 objecttarget_subset.
Show scatter plots of the rmsmag values as a function of mag values, per filter.
fig, axes = plt.subplots(1, 3, figsize=(10, 5))
for f, filt in enumerate(['g', 'r', 'i']):
select = np.isin(Rubin_discovery_observations['band'], filt, invert=False)
axes[f].axhline(0.23, alpha=0.5, color='grey')
axes[f].plot(Rubin_discovery_observations['mag'][select],
Rubin_discovery_observations['rmsmag'][select],
'o', ms=2, mew=0, alpha=0.7, color=filter_colors[filt])
axes[f].set_xlabel('mag')
axes[f].set_title(filt)
axes[0].set_ylabel('rms mag')
plt.show()
Figure 4: The
rmsmagas a function ofmagfor the $g$-, $r$-, and $i$-band photometric measurements for thistarget_subsetof 10 Rubin discoveries. The main locus of points in each plot represents "normal" photometric measurements, with no outliers clearly visible. The horizontal lines drawn atrmsmag$=0.23$ mag represent about the upper bound on the distribution for thistarget_subsetof 10 Rubin discoveries.
The above demonstrates a simple, by-eye evaluation that rmsmag $= 0.23$ mag indicates the edge of the photometric meaurement for this target_subset of 10 Rubin discoveries in the RFL data sent to the MPC.
Inclusion of any data points that were to have rmsmag values larger than this limit in any analysis should be done with caution.
Clean up.
del discovery_orbits, discovery_observations, Rubin_discovery_observations