torchsky.wcs¶

AffineFitResult(
    matrix: Tensor,
    offset: Tensor,
    residuals: Tensor,
    rms: Tensor,
    geometry: str,
    inlier_mask: Tensor,
    iterations: int,
)

SkyAffineFitResult(
    frame: TangentPlaneFrame, affine: AffineFitResult
)

TangentPlaneFrame(ra0: float, dec0: float)

ApproximateMatchResult(
    reference_indices: Tensor, separation_arcsec: Tensor
)

AstrometricMatchGraph(
    observations: Sequence[AstrometricObservation],
    *,
    reference_source_ids: Any | None = None,
    reference_positions: Any | None = None,
    reference_covariance: Any | None = None,
    reference_proper_motion_mas_per_year: Any | None = None,
    reference_proper_motion_covariance: Any | None = None,
    reference_parallax_mas: Any | None = None,
    reference_parallax_variance: Any | None = None,
    tangent_frame: TangentPlaneFrame | None = None,
)

AstrometricObservation(
    exposure_id: Hashable,
    detector_xy: Tensor,
    source_ids: Tensor | None,
    centroid_covariance: Tensor,
    approximate_wcs: Any | None = None,
    sky_position: Tensor | None = None,
    epoch: Epoch | Tensor | float | None = None,
    detector_id: Hashable = "detector",
    covariance_space: CovarianceSpace = "detector",
    world_jacobian: Tensor | None = None,
    color: Tensor | None = None,
    dcr_basis: Tensor | None = None,
    lateral_color_basis: Tensor | None = None,
    zenith_angle_deg: Tensor | float | None = None,
    parallactic_angle_deg: Tensor | float | None = None,
    parallax_factor: Tensor | None = None,
)

AstrometryConfig(
    pose_model: PoseModel = "rscale",
    max_iterations: int = 15,
    convergence_tolerance: float = 1e-08,
    huber_delta: float = 3.0,
    cg_max_iterations: int = 200,
    cg_rtol: float = 1e-10,
    cg_atol: float = 0.0,
    damping: float = 1e-12,
    fit_detector_grid: bool = False,
    detector_grid_shape: tuple[int, int] = (4, 4),
    detector_grid_regularization: float = 1e-08,
    fit_dcr: bool = False,
    fit_lateral_color: bool = False,
    color_pivot: float = 0.0,
    missing_color: MissingPolicy = "error",
    fit_proper_motion: bool = False,
    fit_parallax: bool = False,
    reference_epoch: float = 2000.0,
    epoch_format: Literal[
        "jd", "mjd", "jyear", "byear", "unix"
    ] = "jyear",
    epoch_scale: Literal[
        "utc", "tai", "tt", "gps", "ut1", "tcb", "tdb"
    ] = "tcb",
    missing_epoch: Literal["error", "reference"] = "error",
    rank_policy: RankPolicy = "error",
    rank_rtol: float = 1e-10,
    covariance_max_parameters: int = 256,
    covariance_jacobian_step: float = 0.001,
)

AstrometryDiagnostics(
    converged: bool,
    iterations: int,
    objective_history: tuple[float, ...],
    step_history: tuple[float, ...],
    cg_iterations: tuple[int, ...],
    reduced_rank: int | None,
    reduced_dimension: int,
    condition_number: float | None,
    connected_components: tuple[tuple[Hashable, ...], ...],
    gauge_exposures: tuple[Hashable, ...],
    kinematic_gauge_sources: tuple[int, ...],
    reference_anchored_components: tuple[bool, ...],
    dropped_source_blocks: tuple[int, ...],
    dropped_dcr_exposures: tuple[Hashable, ...],
    dropped_lateral_color_detectors: tuple[Hashable, ...],
    matrix_free_reduced: bool = True,
    assembled_observation_matrix: bool = False,
)

AstrometrySolution(
    exposure_ids: tuple[Hashable, ...],
    source_ids: Tensor,
    pose_model: str,
    pose_parameters: Tensor,
    source_positions: Tensor,
    source_tangent_positions: Tensor,
    proper_motion_mas_per_year: Tensor | None,
    parallax_mas: Tensor | None,
    dcr_coefficients: Tensor | None,
    lateral_color_coefficients: Tensor | None,
    detector_ids: tuple[Hashable, ...],
    detector_residual_control: Tensor | None,
    residuals_arcsec: Tensor,
    robust_weights: Tensor,
    exposure_covariance: dict[Hashable, Tensor],
    diagnostics: AstrometryDiagnostics,
    fit_mask: Tensor,
)

AstrometryNetBootstrapResult(
    hypothesis: AstrometryNetHypothesis,
    verification: AstrometryNetVerification,
    bundle_solution: AstrometrySolution,
    provenance: AstrometryNetProvenance,
)

AstrometryNetConfig(
    executable: str | Path,
    executable_sha256: str,
    executable_version: str,
    index_manifest: str | Path,
    index_manifest_sha256: str,
    timeout_seconds: float = 60.0,
    version_args: tuple[str, ...] = ("--version",),
)

AstrometryNetHypothesis(
    header: Mapping[str, Any],
    center_ra_deg: float,
    center_dec_deg: float,
    pixel_scale_arcsec: tuple[float, float],
    orientation_deg: float,
    determinant_deg2_per_pixel2: float,
    handedness: Literal["right", "left"],
    parity: Literal["normal", "flipped"],
    index_id: int,
    index_healpix: int,
    index_hpnside: int,
    log_odds: float,
    matched_sources: int,
)

AstrometryNetIndexIdentity(
    index_id: str,
    version: str,
    manifest_path: str,
    manifest_sha256: str,
    backend_config_path: str,
    backend_config_sha256: str,
    astrometry_index_ids: tuple[int, ...],
    files: tuple[tuple[str, str], ...],
)

AstrometryNetProvenance(
    executable_path: str,
    executable_sha256: str,
    executable_version: str,
    index: AstrometryNetIndexIdentity,
    bootstrap_arguments: tuple[str, ...],
    verification_arguments: tuple[str, ...],
    bootstrap_input_count: int,
    verification_input_count: int,
    runtime_downloads: bool = False,
)

AstrometryNetVerification(
    supplied_count: int,
    matched_count: int,
    residuals_pixels: Tensor,
    rms_pixels: float,
    max_pixels: float,
)

AstrometryNetVerificationConfig(
    min_matches: int,
    max_rms_pixels: float,
    max_residual_pixels: float,
    reference_sigma_arcsec: float = 0.01,
)

CoupledCalibrationConfig(
    astrometry: AstrometryConfig = AstrometryConfig(),
    max_iterations: int = 6,
    photometry_max_iterations: int = 20,
    convergence_tolerance: float = 1e-07,
    photometry_convergence_tolerance: float = 1e-08,
    huber_delta: float = 3.0,
    fit_extinction: bool = True,
    fit_cloud: bool = True,
    fit_star_flat: bool = True,
    fit_color_terms: bool = True,
    color_bands: tuple[Hashable, Hashable] | None = None,
    color_pivot: float = 0.0,
    color_scale: float = -2.5 / log(10.0),
    missing_color: MissingColorPolicy = "drop",
    fit_variability: bool = False,
    variable_source_ids: tuple[int, ...] = (),
    holdout_source_ids: tuple[int, ...] = (),
    holdout_exposure_ids: tuple[Hashable, ...] = (),
    damping: float = 1e-10,
    rank_rtol: float = 1e-10,
    cg_max_iterations: int = 500,
    cg_rtol: float = 1e-10,
    covariance_max_parameters: int = 256,
)

CoupledCalibrationDiagnostics(
    converged: bool,
    iterations: int,
    stage_history: tuple[str, ...],
    astrometric_step_history: tuple[float, ...],
    photometric_step_history: tuple[float, ...],
    color_step_history: tuple[float, ...],
    source_holdout_count: int,
    exposure_holdout_count: int,
)

CoupledCalibrationGraph(
    astrometry_graph: AstrometricMatchGraph,
    photometric_blocks: Sequence[
        PhotometricMeasurementBlock
    ],
    *,
    reference: PhotometricReference | None = None,
    sed_basis: Tensor | None = None,
)

CoupledCalibrationSolution(
    astrometry: AstrometrySolution,
    photometry: PhotometricCalibrationSolution,
    diagnostics: CoupledCalibrationDiagnostics,
    covariance: dict[str, object],
    provenance: dict[str, object],
)

PhotometricCalibrationDiagnostics(
    converged: bool,
    iterations: int,
    objective_history: tuple[float, ...],
    step_history: tuple[float, ...],
    cg_iterations: tuple[int, ...],
    connected_components: tuple[tuple[Hashable, ...], ...],
    gauge_exposures: tuple[Hashable, ...],
    reference_anchored_components: tuple[bool, ...],
    dropped_extinction_exposures: tuple[Hashable, ...],
    dropped_cloud_exposures: tuple[Hashable, ...],
    dropped_star_flat_parameters: tuple[
        tuple[Hashable, int], ...
    ],
    dropped_color_bands: tuple[Hashable, ...],
    information_rank: int | None,
    information_dimension: int,
    condition_number: float | None,
    matrix_free: bool = True,
    assembled_measurement_matrix: bool = False,
)

PhotometricCalibrationSolution(
    source_ids: Tensor,
    bands: tuple[Hashable, ...],
    source_band_flux: Tensor,
    source_band_log_flux: Tensor,
    source_coefficient_variance: Tensor,
    colors: Tensor,
    exposure_ids: tuple[Hashable, ...],
    exposure_log_zeropoint: Tensor,
    exposure_extinction: Tensor,
    exposure_cloud: Tensor,
    detector_ids: tuple[Hashable, ...],
    star_flat_coefficients: Tensor,
    band_color_terms: Tensor,
    predicted_log_flux: Tensor,
    residual_log_flux: Tensor,
    robust_weights: Tensor,
    variability_offsets: Tensor,
    fit_mask: Tensor,
    global_covariance: Tensor | None,
    diagnostics: PhotometricCalibrationDiagnostics,
    provenance: dict[str, object],
)