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).

In [1]:

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.

In [2]:

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.

In [3]:

# print(targets[1:])

Define parameters to use colorblind-friendly colors with matplotlib.

In [4]:

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$.

In [5]:

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.

In [6]:

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)

Out[6]:

	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.

In [7]:

# 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.

In [8]:

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.

In [9]:

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.

In [10]:

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'

Out[10]:

1524

Convert the obstime from isot to mjd. Add the MJD to a new column called epoch.

In [11]:

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()

Out[11]:

	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).

In [12]:

select = np.isin(discovery_observations['stn'], 'X05', invert=False)
Rubin_discovery_observations = discovery_observations[select].copy()
len(Rubin_discovery_observations)

Out[12]:

1443

Option to write the Rubin_discovery_observations DataFrame to a csv file.

In [13]:

# 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.

In [14]:

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)

Out[14]:

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.

In [15]:

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.

In [16]:

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 rmsmag value for this target_subset of 10 Rubin discoveries. The dashed grey line is drawn at $0.23$ mag, the approximate (by-eye) edge of the distribution of rmsmag values for this 10 object target_subset.

Show scatter plots of the rmsmag values as a function of mag values, per filter.

In [17]:

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 rmsmag as a function of mag for the $g$-, $r$-, and $i$-band photometric measurements for this target_subset of 10 Rubin discoveries. The main locus of points in each plot represents "normal" photometric measurements, with no outliers clearly visible. The horizontal lines drawn at rmsmag $=0.23$ mag represent about the upper bound on the distribution for this target_subset of 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.

In [18]:

del discovery_orbits, discovery_observations, Rubin_discovery_observations

In [ ]: