adam_core.photometry package¶

adam_core.photometry.calculate_apparent_magnitude_v(H_v: float | ndarray[tuple[Any, ...], dtype[float64]], object_coords: CartesianCoordinates, observer: Observers, G: float | ndarray[tuple[Any, ...], dtype[float64]] = 0.15) → ndarray[tuple[Any, ...], dtype[float64]][source]¶

Calculate apparent V-band magnitudes.

Notes

This function is JAX-backed (numpy-sandwich pattern) and returns a NumPy array.

adam_core.photometry.calculate_apparent_magnitude_v_and_phase_angle(H_v: float | ndarray[tuple[Any, ...], dtype[float64]], object_coords: CartesianCoordinates, observer: Observers, G: float | ndarray[tuple[Any, ...], dtype[float64]] = 0.15) → tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]][source]¶

Calculate apparent V-band magnitudes and phase angles (degrees) together.

Why: when both are needed, the H-G model already computes the phase geometry. This combined function avoids redoing the same law-of-cosines computation twice.

adam_core.photometry.calculate_phase_angle(object_coords: CartesianCoordinates, observers: Observers) → ndarray[tuple[Any, ...], dtype[float64]][source]¶

Calculate the solar phase angle (Sun–object–observer) in degrees.

“Phase angle” here is the angle at the object between the Sun direction and the observer direction. It is commonly used for simple photometry/visibility metrics.

Notes

This helper expects heliocentric coordinates (origin = OriginCodes.SUN) for both the object and the observer. If you have barycentric coordinates, transform first.

Parameters:

object_coords – Object Cartesian coordinates in AU (origin must be SUN).
observers – Observer states (origin must be SUN).

Returns:

Phase angle in degrees for each paired row.

Return type:

phase_angle_deg

Examples

Given an Ephemeris eph from a propagator and corresponding Observers obs:

Use eph.coordinates for on-sky (RA/Dec, rho) values.
Use eph.aberrated_coordinates for emission-time geometry, and transform to heliocentric:

```python from adam_core.coordinates.cartesian import CartesianCoordinates from adam_core.coordinates.origin import OriginCodes from adam_core.coordinates.transform import transform_coordinates from adam_core.photometry import calculate_phase_angle from adam_core.observers import Observers

observers_eph = Observers.from_codes(eph.coordinates.origin.code, eph.coordinates.time)

obj_helio = transform_coordinates(: eph.aberrated_coordinates, CartesianCoordinates, frame_out=”ecliptic”, origin_out=OriginCodes.SUN,

) obs_helio = observers_eph.set_column(

“coordinates”, transform_coordinates(

observers_eph.coordinates, CartesianCoordinates, frame_out=”ecliptic”, origin_out=OriginCodes.SUN,

),

) alpha_deg = calculate_phase_angle(obj_helio, obs_helio) ```

adam_core.photometry.convert_magnitude(magnitude: ndarray[tuple[Any, ...], dtype[float64]], source_filter_id: ndarray[tuple[Any, ...], dtype[object_]], target_filter_id: ndarray[tuple[Any, ...], dtype[object_]], *, composition: str | tuple[float, float]) → ndarray[tuple[Any, ...], dtype[float64]][source]¶

Convert magnitudes between canonical bandpass filter IDs using template integrals.

Parameters:

magnitude (ndarray) – 1D array of magnitudes in source_filter_id.
source_filter_id (ndarray) – 1D array of canonical source filter IDs (e.g., ‘V’, ‘DECam_g’, ‘LSST_r’).
target_filter_id (ndarray) – 1D array of canonical target filter IDs.
composition (str or (float, float)) – Required. Either a template ID (‘C’, ‘S’, ‘NEO’, ‘MBA’, or a registered custom template), or a (weight_C, weight_S) tuple for a linear C/S mix.

Returns:

Magnitudes in target_filter_id.

Return type:

ndarray

adam_core.photometry.predict_magnitudes(H: float | ndarray[tuple[Any, ...], dtype[float64]], object_coords: CartesianCoordinates, exposures: Exposures, G: float | ndarray[tuple[Any, ...], dtype[float64]] = 0.15, reference_filter: str = 'V', *, composition: str | tuple[float, float]) → ndarray[tuple[Any, ...], dtype[float64]][source]¶

Predict apparent magnitudes for objects observed during exposures using bandpass-based conversions.

This: - compute apparent V-band magnitudes using the H-G system + geometry, then - convert V -> exposure filter.

Notes

exposures.filter must contain canonical bandpass filter_id values (e.g. ‘LSST_i’, ‘DECam_g’).
The V -> target conversion is computed from precomputed template×filter integrals, and requires an explicit asteroid composition (template_id or C/S mix weights).

Parameters:

H (float or ndarray) – Absolute magnitude(s) of the object(s) in reference_filter (canonical bandpass filter ID).
object_coords (CartesianCoordinates) – Cartesian coordinates of the object(s) at the exposure times.
exposures (Exposures) – Exposure table. exposures.filter must be a canonical bandpass filter_id.
G (float or ndarray, optional) – Slope parameter for the H-G system, defaults to 0.15.
reference_filter (str, optional) – Canonical filter ID in which H is defined. Defaults to “V”.
composition (str or (float, float)) – Required. Either a template ID (‘C’, ‘S’, ‘NEO’, ‘MBA’, or a registered custom template), or a (weight_C, weight_S) tuple for a linear C/S mix.

Returns:

Predicted apparent magnitudes in the exposures’ filters.

Return type:

ndarray

adam_core.photometry.hg_phase_correction(alpha_deg: ndarray[tuple[Any, ...], dtype[float64]] | float, G: float) → ndarray[tuple[Any, ...], dtype[float64]][source]¶

H-G phase correction in magnitudes for solar phase angle alpha_deg and slope G.

Returns -2.5 * log10[(1 - G) * phi1 + G * phi2] – the term added to H + 5 * log10(r_au * delta_au) to get the reduced/apparent V magnitude, where phi_i = exp(-A_i * tan(alpha/2) ** B_i). Zero at opposition (alpha = 0) and positive (fainter) for larger phase angles. NumPy implementation for CPU callers.

adam_core.photometry.reduced_magnitude(mag: ndarray[tuple[Any, ...], dtype[float64]], r_au: ndarray[tuple[Any, ...], dtype[float64]], delta_au: ndarray[tuple[Any, ...], dtype[float64]]) → ndarray[tuple[Any, ...], dtype[float64]][source]¶

Distance-reduced magnitude mag - 5 * log10(r_au * delta_au).

Removes the heliocentric (r_au) and observer (delta_au) distance dependence so that the residual variation reflects the object’s intrinsic brightness (rotation, color), not its changing geometry. Phase-angle dependence is handled separately by the H-G phase correction.

adam_core.photometry.estimate_absolute_magnitude_v_from_detections(detections: PointSourceDetections, exposures: Exposures, object_coords: CartesianCoordinates, *, composition: str | tuple[float, float], G: float = 0.15, strict_band_mapping: bool = False, reference_filter: str = 'V') → PhysicalParameters[source]¶

Estimate V-band absolute magnitude H from observed apparent magnitudes.

Assumptions¶

Orbit has already been fit; object_coords are the heliocentric object coordinates at the observation times (aligned 1:1 with detections).
We estimate H only; G and composition are treated as fixed inputs.

param detections:: Point-source detections. Uses mag and (optionally) mag_sigma.
param exposures:: Exposures referenced by detections.exposure_id. Uses observatory_code and filter.
param object_coords:: Object coordinates aligned with detections (same length and ordering).
param composition:: Required. Bandpass template ID (e.g. ‘NEO’) or (weight_C, weight_S) mix.
param G:: Fixed H-G slope parameter.
param strict_band_mapping:: If True, disallow SDSS/PS1 fallback filters when mapping reported bands.
param reference_filter:: Must be ‘V’ for this function.

adam_core.photometry.estimate_absolute_magnitude_v_from_detections_grouped(detections: PointSourceDetections, exposures: Exposures, object_coords: CartesianCoordinates, object_ids: Array | ChunkedArray | Sequence[str | None], *, composition: str | tuple[float, float], G: float = 0.15, strict_band_mapping: bool = False, reference_filter: str = 'V') → GroupedPhysicalParameters[source]¶

Vectorized grouped H-fit for many objects in one pass.

Parameters:

detections – Point-source detections for all groups.
exposures – Exposure table referenced by detections.exposure_id.
object_coords – Object coordinates aligned 1:1 with detections.
object_ids – Group label for each detection row (same length as detections).

Returns:

One row per object_id with nested physical parameters and fit row counts.

Return type:

GroupedPhysicalParameters

class adam_core.photometry.GroupedPhysicalParameters(table: Table, **kwargs: int | float | str)[source]¶

Bases: Table

n_fit_detections¶: A column for storing 64-bit integers.

object_id¶: A column for storing large strings (over 2³¹ bytes long). Large string data is stored in variable-length chunks.

physical_parameters¶

A column which represents an embedded quivr table.

Parameters:

table_type – The type of the table to embed.
nullable – Whether the column can contain null values.
metadata – A dictionary of metadata to attach to the column.

schema: ClassVar[pa.Schema] = object_id: large_string not null physical_parameters: struct<H_v: double, H_v_sigma: double, G: double, G_sigma: double, sigma_eff: double, chi2_red: doub (... 3 chars omitted) child 0, H_v: double child 1, H_v_sigma: double child 2, G: double child 3, G_sigma: double child 4, sigma_eff: double child 5, chi2_red: double n_fit_detections: int64 not null¶

adam_core.photometry.build_rotation_period_observations_from_detections(detections: PointSourceDetections, exposures: Exposures, object_coords: CartesianCoordinates) → RotationPeriodObservations[source]¶

adam_core.photometry.estimate_rotation_period(observations: RotationPeriodObservations, *, profile: str = 'default', search_fidelity: str | None = None, fourier_orders: tuple[int, ...] | None = None, clip_sigma: float = 3.0, min_rotations_in_span: float = 2.0, max_frequency_cycles_per_day: float = 1000.0, frequency_grid_scale: float = 30.0, max_search_period_hours: float | None = None, early_exit_on_insufficient: bool = True, exact_evaluation_backend: str = 'numpy', session_mode: str = 'auto', auto_session_min_observations_per_group: int = 6, auto_session_bic_improvement: float = 10.0, claim_doubled_fold: bool = True) → RotationPeriodResult[source]¶

Estimate an asteroid rotation period with a measured confidence verdict.

Fits the distance-reduced, light-time-corrected photometry with a truncated-harmonic Fourier model, searches a frequency grid, clusters harmonic aliases, and classifies the outcome against the confidence contract rather than emitting a bare point estimate.

Parameters:

observations (RotationPeriodObservations) – One row per photometric measurement: time, magnitude, optional uncertainty, filter, optional session id, and observing geometry (r_au / delta_au / phase_angle_deg).
profile (str, default "default") – Solver configuration profile (Fourier orders, F-test/cluster confidences, reliability window). Only "default" is shipped.
search_fidelity ({"validated_staged", "exact_grid"}, optional) – Frequency-search strategy; defaults to "validated_staged" (coarse pass refined with exact evaluations). "exact_grid" evaluates every grid frequency.
session_mode ({"ignore", "use", "auto"}, default "auto") – Per-session magnitude-offset handling. "auto" adopts offsets only when a BIC test clears auto_session_bic_improvement.
claim_doubled_fold (bool, default True) – When the ONLY remaining ambiguity is the half/full octave of a single-peaked fold (the solver has already doubled the period on the two-peaks-per-rotation shape prior and no rival alias cluster survives), allow the verdict single_period and append the confidence flag doubled_fold_assumed disclosing the assumption. Measured on the LCDB/DAMIT standard-candle sets this raises confident claims (76 -> 83 pooled) with strict precision improving (0.895 -> 0.904) and no new wrong-family claim; on the Rubin survey regression it raises claims from 6 to 11 of 76, all strictly correct. A genuinely single-peaked (spheroidal) body would make such a claim a 2x alias, so set False to restore the strictly agnostic behavior (verdict period_family with reason single_max_alias). The long-period and sub-harmonic guardrails still apply to these claims.
exact_evaluation_backend ({"numpy", "jax"}, default "numpy") – Backend for exact frequency fits; "jax" is faster on large grids and gives identical results (imported lazily, so "numpy" needs no JAX).
early_exit_on_insufficient (bool, default True) – When True (default), screen obviously under-determined inputs before building the grid and return a structured insufficient_data result instead of raising. Set False (validation/calibration) to force every object through the full solve so a recovered period is always reported.
min_rotations_in_span (float) – Frequency-grid and fit knobs: lower frequency bound (rotations spanned), upper bound, grid oversampling, optional period ceiling, and the sigma-clipping threshold.
max_frequency_cycles_per_day (float) – Frequency-grid and fit knobs: lower frequency bound (rotations spanned), upper bound, grid oversampling, optional period ceiling, and the sigma-clipping threshold.
frequency_grid_scale (float) – Frequency-grid and fit knobs: lower frequency bound (rotations spanned), upper bound, grid oversampling, optional period ceiling, and the sigma-clipping threshold.
max_search_period_hours (float) – Frequency-grid and fit knobs: lower frequency bound (rotations spanned), upper bound, grid oversampling, optional period ceiling, and the sigma-clipping threshold.
clip_sigma (float) – Frequency-grid and fit knobs: lower frequency bound (rotations spanned), upper bound, grid oversampling, optional period ceiling, and the sigma-clipping threshold.

Returns:

A one-row table. Headline fields: period_verdict (single_period / period_family / insufficient_data), reliability_code ("3" / "2" / "1", mapping to the LCDB U code), confidence_flags and insufficiency_reasons – plus the recovered period_hours / period_days, the Fourier diagnostic block, and the verdict diagnostics.

Return type:

RotationPeriodResult

Raises:

ValueError – If session_mode / exact_evaluation_backend is invalid or a numeric knob is non-positive.

Notes

The confidence verdict is measured, not guaranteed. The solver is designed to downgrade harmonic and sampling aliases to period_family instead of asserting a confident single_period, but this is calibrated behaviour with a known, nonzero residual false-confidence risk: a single_period result can occasionally be a harmonic or sampling alias of the true period. Measured strict single_period precision on the LCDB/DAMIT standard-candle set is ~0.88, and one tracked case (1627 Ivar, a ~5/3 diurnal-sampling alias) is still reported confidently at the wrong period. When a period that is wrong by an integer factor would be costly, cross-check a single_period result against alternate_period_days and reliability_code rather than treating the verdict as infallible.

adam_core.photometry.estimate_rotation_period_best_apparition(observations: RotationPeriodObservations, *, apparition_gap_days: float = 120.0, **solver_kwargs: Any) → RotationPeriodResult[source]¶

Solve each apparition separately and keep the highest-confidence result.

Ground-based lightcurves of the same asteroid from different apparitions differ in viewing aspect (and therefore amplitude), photometric noise, and nightly cadence, so the diurnal-alias structure of each apparition differs too. An apparition that happens to sample the rotation cleanly can yield a confident, correct period where the densest apparition – or all apparitions pooled – locks onto a sampling alias or hedges. This helper partitions the observations into apparitions (separated by more than apparition_gap_days), runs estimate_rotation_period() on each independently, and returns the result of the most confident apparition.

The selection rule uses no knowledge of any reference answer: rank the verdicts single_period > period_family > insufficient_data, tie-break on higher amplitude_snr, then on more observations, then on the earlier apparition. Measured on the 118-object LCDB standard-candle calibration set, this policy raised confident (single_period) claims from 35 to 43 while the strict precision of those claims improved (0.800 -> 0.837) and the wrong-family count was unchanged – selection shopping did not introduce false confidence on that set, but the guarantee is empirical, not structural.

The chosen row is returned with a apparition_selected_<k>_of_<n> confidence flag appended (1-based, chronological). An apparition whose solve fails with an expected ValueError participates as an insufficient_data candidate flagged solve_error; an unexpected error is re-raised with the apparition attached. Apparitions solve serially; for large batches, parallelize per apparition yourself.

adam_core.photometry.estimate_rotation_period_from_detections(detections: PointSourceDetections, exposures: Exposures, object_coords: CartesianCoordinates, **search_kwargs: Any) → RotationPeriodResult[source]¶

adam_core.photometry.estimate_rotation_period_from_detections_grouped(detections: PointSourceDetections, exposures: Exposures, object_coords: CartesianCoordinates, object_ids: Array | ChunkedArray | Sequence[str | None], **search_kwargs: Any) → GroupedRotationPeriodResults[source]¶

class adam_core.photometry.RotationPeriodObservations(table: Table, **kwargs: int | float | str)[source]¶

Bases: Table

delta_au¶: A column for storing 64-bit floating point numbers.

filter¶: A column for storing large strings (over 2³¹ bytes long). Large string data is stored in variable-length chunks.

classmethod from_point_source_observations(detections: PointSourceDetections, exposures: Exposures, object_coords: CartesianCoordinates) → RotationPeriodObservations[source]¶

Build observations from adam_core point-source detections + exposures.

Links this table to the core adam_core observation primitives: one row per PointSourceDetections entry, with filter and the per-exposure observing geometry (heliocentric distance r_au, observer distance delta_au, and solar phase_angle_deg) derived from the aligned Exposures and the object’s heliocentric CartesianCoordinates.

object_coords must be heliocentric (origin=SUN) and the same length and order as detections; detections.exposure_id is used to align each detection to its exposure. mag / r_au / delta_au / phase_angle_deg must be finite (and the distances positive) or a ValueError is raised.

mag¶: A column for storing 64-bit floating point numbers.

mag_sigma¶: A column for storing 64-bit floating point numbers.

phase_angle_deg¶: A column for storing 64-bit floating point numbers.

r_au¶: A column for storing 64-bit floating point numbers.

schema: ClassVar[pa.Schema] = time: struct<days: int64, nanos: int64> child 0, days: int64 child 1, nanos: int64 mag: double not null mag_sigma: double filter: large_string session_id: large_string r_au: double not null delta_au: double not null phase_angle_deg: double not null¶

session_id¶: A column for storing large strings (over 2³¹ bytes long). Large string data is stored in variable-length chunks.

time¶

A column which represents an embedded quivr table.

Parameters:

table_type – The type of the table to embed.
nullable – Whether the column can contain null values.
metadata – A dictionary of metadata to attach to the column.

class adam_core.photometry.RotationPeriodResult(table: Table, **kwargs: int | float | str)[source]¶

Bases: Table

alternate_period_days¶

A column for storing large lists of values (over 2³¹ objects).

Unless you need to represent data with more than 2**31 elements, prefer ListColumn.

The values in the list can be of any type.

Note that all quivr Tables are storing lists of values, so this column type is only useful for storing lists of lists.

Parameters:

value_type – The type of the values in the list.
nullable – Whether the list can contain null values.
metadata – A dictionary of metadata to attach to the column.
validator – A validator to run against the column’s values.

amplitude_snr¶: A column for storing 64-bit floating point numbers.

confidence_flags¶

A column for storing large lists of values (over 2³¹ objects).

Unless you need to represent data with more than 2**31 elements, prefer ListColumn.

The values in the list can be of any type.

Note that all quivr Tables are storing lists of values, so this column type is only useful for storing lists of lists.

Parameters:

value_type – The type of the values in the list.
nullable – Whether the list can contain null values.
metadata – A dictionary of metadata to attach to the column.
validator – A validator to run against the column’s values.

fourier_alternate_period_days¶

A column for storing large lists of values (over 2³¹ objects).

Unless you need to represent data with more than 2**31 elements, prefer ListColumn.

The values in the list can be of any type.

Note that all quivr Tables are storing lists of values, so this column type is only useful for storing lists of lists.

Parameters:

value_type – The type of the values in the list.
nullable – Whether the list can contain null values.
metadata – A dictionary of metadata to attach to the column.
validator – A validator to run against the column’s values.

fourier_is_reliable¶: A column for storing booleans.

fourier_is_valid¶: A column for storing booleans.

fourier_order¶: A column for storing 64-bit integers.

fourier_period_days¶: A column for storing 64-bit floating point numbers.

fourier_phase_c1¶: A column for storing 64-bit floating point numbers.

fourier_phase_c2¶: A column for storing 64-bit floating point numbers.

fourier_sigma_threshold¶: A column for storing 64-bit floating point numbers.

frequency_cycles_per_day¶: A column for storing 64-bit floating point numbers.

insufficiency_reasons¶

A column for storing large lists of values (over 2³¹ objects).

Unless you need to represent data with more than 2**31 elements, prefer ListColumn.

The values in the list can be of any type.

Note that all quivr Tables are storing lists of values, so this column type is only useful for storing lists of lists.

Parameters:

value_type – The type of the values in the list.
nullable – Whether the list can contain null values.
metadata – A dictionary of metadata to attach to the column.
validator – A validator to run against the column’s values.

is_period_doubled¶: A column for storing booleans.

is_reliable¶: A column for storing booleans.

is_valid¶: A column for storing booleans.

n_clipped¶: A column for storing 64-bit integers.

n_filters¶: A column for storing 64-bit integers.

n_fit_observations¶: A column for storing 64-bit integers.

n_observations¶: A column for storing 64-bit integers.

n_rotations_spanned¶: A column for storing 64-bit floating point numbers.

n_sessions¶: A column for storing 64-bit integers.

n_significant_aliases¶: A column for storing 64-bit integers.

period_days¶: A column for storing 64-bit floating point numbers.

period_hours¶: A column for storing 64-bit floating point numbers.

period_lower_days¶: A column for storing 64-bit floating point numbers.

period_upper_days¶: A column for storing 64-bit floating point numbers.

period_verdict¶: A column for storing large strings (over 2³¹ bytes long). Large string data is stored in variable-length chunks.

phase_coverage_fraction¶: A column for storing 64-bit floating point numbers.

profile¶: A column for storing large strings (over 2³¹ bytes long). Large string data is stored in variable-length chunks.

relative_period_uncertainty¶: A column for storing 64-bit floating point numbers.

reliability_code¶: A column for storing large strings (over 2³¹ bytes long). Large string data is stored in variable-length chunks.

residual_sigma_mag¶: A column for storing 64-bit floating point numbers.

schema: ClassVar[pa.Schema] = period_days: double not null period_hours: double not null frequency_cycles_per_day: double not null profile: large_string not null period_verdict: large_string not null reliability_code: large_string not null confidence_flags: large_list<item: large_string> child 0, item: large_string insufficiency_reasons: large_list<item: large_string> child 0, item: large_string is_valid: bool not null is_reliable: bool not null period_lower_days: double period_upper_days: double relative_period_uncertainty: double alternate_period_days: large_list<item: double> child 0, item: double fourier_period_days: double fourier_order: int64 fourier_sigma_threshold: double fourier_phase_c1: double fourier_phase_c2: double residual_sigma_mag: double fourier_is_valid: bool fourier_is_reliable: bool fourier_alternate_period_days: large_list<item: double> child 0, item: double phase_coverage_fraction: double n_rotations_spanned: double amplitude_snr: double n_significant_aliases: int64 n_observations: int64 not null n_fit_observations: int64 not null n_clipped: int64 not null n_filters: int64 not null n_sessions: int64 not null used_session_offsets: bool not null is_period_doubled: bool not null¶

classmethod single_insufficient(*, reasons: list[str], confidence_flags: list[str] | None = None, n_observations: int = 0, n_filters: int = 0, n_sessions: int = 0, profile: str = 'default') → RotationPeriodResult[source]¶

One-row insufficient_data result: NaN period, every nullable diagnostic None.

The canonical builder for the insufficient verdict. Used both by the solver’s early-exit path and by the detection wrappers when an object cannot be solved, so a grouped solve returns one row per object id rather than silently dropping failures. period_verdict/reliability_code are the contract constants ("insufficient_data" / "1").

used_session_offsets¶: A column for storing booleans.

class adam_core.photometry.GroupedRotationPeriodResults(table: Table, **kwargs: int | float | str)[source]¶

Bases: Table

object_id¶: A column for storing large strings (over 2³¹ bytes long). Large string data is stored in variable-length chunks.

result¶

A column which represents an embedded quivr table.

Parameters:

table_type – The type of the table to embed.
nullable – Whether the column can contain null values.
metadata – A dictionary of metadata to attach to the column.

schema: ClassVar[pa.Schema] = object_id: large_string not null result: struct<period_days: double, period_hours: double, frequency_cycles_per_day: double, profile: large_s (... 893 chars omitted) child 0, period_days: double child 1, period_hours: double child 2, frequency_cycles_per_day: double child 3, profile: large_string child 4, period_verdict: large_string child 5, reliability_code: large_string child 6, confidence_flags: large_list<item: large_string> child 0, item: large_string child 7, insufficiency_reasons: large_list<item: large_string> child 0, item: large_string child 8, is_valid: bool child 9, is_reliable: bool child 10, period_lower_days: double child 11, period_upper_days: double child 12, relative_period_uncertainty: double child 13, alternate_period_days: large_list<item: double> child 0, item: double child 14, fourier_period_days: double child 15, fourier_order: int64 child 16, fourier_sigma_threshold: double child 17, fourier_phase_c1: double child 18, fourier_phase_c2: double child 19, residual_sigma_mag: double child 20, fourier_is_valid: bool child 21, fourier_is_reliable: bool child 22, fourier_alternate_period_days: large_list<item: double> child 0, item: double child 23, phase_coverage_fraction: double child 24, n_rotations_spanned: double child 25, amplitude_snr: double child 26, n_significant_aliases: int64 child 27, n_observations: int64 child 28, n_fit_observations: int64 child 29, n_clipped: int64 child 30, n_filters: int64 child 31, n_sessions: int64 child 32, used_session_offsets: bool child 33, is_period_doubled: bool¶

adam_core.photometry package¶

Assumptions¶

Subpackages¶

Submodules¶