tessl/pypi-astroquery

Functions and classes to access online astronomical data resources

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Solar System Services

Name: tessl/pypi-astroquery
Author: tessl

Services providing ephemerides, orbital elements, and physical data for solar system objects including planets, asteroids, comets, and spacecraft. These services are essential for mission planning, observational preparation, and solar system research.

Capabilities

JPL Horizons - Ephemerides Service

JPL Horizons provides precise ephemerides, orbital elements, and physical data for solar system objects, supporting both observational planning and spacecraft navigation.

from astroquery.jplhorizons import Horizons

# Initialize Horizons object
horizons = Horizons(id: Union[str, int], location: str = '500', epochs: Union[str, List, float] = None)

def ephemerides(self, **kwargs) -> Table:
    """
    Generate ephemerides for the target object.
    
    Parameters:
    - **kwargs: Ephemeris parameters (airmass_lessthan, solar_elongation, etc.)
    
    Returns:
    Table with ephemeris data (RA, Dec, distance, magnitude, etc.)
    """

def elements(self, **kwargs) -> Table:
    """
    Get orbital elements for the target object.
    
    Parameters:
    - **kwargs: Element parameters (ref_plane, tp_type, etc.)
    
    Returns:
    Table with orbital elements
    """

def vectors(self, **kwargs) -> Table:
    """
    Get state vectors (position and velocity) for the target.
    
    Parameters:
    - **kwargs: Vector parameters (ref_plane, aberrations, etc.)
    
    Returns:
    Table with position and velocity vectors
    """

# Configuration
from astroquery.jplhorizons import conf
conf.server: str              # JPL Horizons server URL
conf.timeout: int = 60        # Connection timeout

Usage examples:

from astroquery.jplhorizons import Horizons
from astropy.time import Time

# Ephemerides for Ceres from Earth
ceres = Horizons(id='Ceres', location='500', 
                epochs={'start': '2023-01-01', 'stop': '2023-01-31', 'step': '1d'})
eph = ceres.ephemerides()
print(eph['datetime_str', 'RA', 'DEC', 'V'])

# Orbital elements for asteroid
asteroid = Horizons(id='433', location='500', epochs='2023-01-01')  # Eros
elem = asteroid.elements()
print(elem['e', 'a', 'incl', 'Omega', 'w', 'M'])

# State vectors for Mars from Sun  
mars = Horizons(id='499', location='500@10', epochs='2023-01-01')
vectors = mars.vectors()
print(vectors['x', 'y', 'z', 'vx', 'vy', 'vz'])

# Comet ephemerides with constraints
comet = Horizons(id='1P', location='I11', epochs='2023-06-01')  # Halley from Palomar
eph = comet.ephemerides(airmass_lessthan=2.0, solar_elongation=(30, 180))

JPL Small Body Database - SBDB

SBDB provides comprehensive data for asteroids and comets including orbital elements, physical properties, discovery information, and close approach data.

from astroquery.jplsbdb import SBDB

def query(targetname: str, **kwargs) -> Dict:
    """
    Query JPL Small Body Database for object information.
    
    Parameters:  
    - targetname: Name or designation of small body
    - **kwargs: Additional query parameters
    
    Returns:
    Dictionary with comprehensive small body data
    """

def query_async(targetname: str, **kwargs) -> JobResults:
    """
    Submit asynchronous query for small body data.
    
    Parameters:
    - targetname: Small body name or designation
    - **kwargs: Additional parameters
    
    Returns:
    JobResults object for retrieving results
    """

# Configuration
from astroquery.jplsbdb import conf
conf.server: str              # SBDB server URL
conf.timeout: int = 60        # Connection timeout

Usage examples:

from astroquery.jplsbdb import SBDB

# Query asteroid Ceres
ceres_data = SBDB.query('Ceres')
print("Orbital data:", ceres_data['orbit'])
print("Physical data:", ceres_data['phys_par'])
print("Discovery:", ceres_data['discovery'])

# Query by number
apophis = SBDB.query('99942')  # Apophis
print("Close approaches:", apophis['close_approaches'])

# Query comet
halley = SBDB.query('1P')
print("Orbital period:", halley['orbit']['period'])

Minor Planet Center - MPC

MPC provides authoritative orbital data, ephemerides, and observational information for asteroids and comets, serving as the central clearinghouse for minor planet observations.

from astroquery.mpc import MPC

def query_object(target: str, **kwargs) -> Table:
    """
    Query MPC for information about a specific minor planet.
    
    Parameters:
    - target: Minor planet name, number, or designation
    - **kwargs: Additional query parameters
    
    Returns:
    Table with MPC orbital data
    """

def query_objects(targets: List[str], **kwargs) -> Table:
    """
    Query multiple minor planets simultaneously.
    
    Parameters:
    - targets: List of minor planet identifiers
    - **kwargs: Additional parameters
    
    Returns:
    Table with data for all queried objects
    """

def get_ephemeris(target: str, location: str = '500', start: str = None,
                 step: str = '1d', number: int = 10, **kwargs) -> Table:
    """
    Get ephemeris for a minor planet.
    
    Parameters:
    - target: Minor planet identifier
    - location: Observer location code
    - start: Start date
    - step: Time step
    - number: Number of ephemeris points
    - **kwargs: Additional ephemeris parameters
    
    Returns:
    Table with ephemeris data
    """

def get_observations(target: str) -> Table:
    """
    Get observational data for a minor planet.
    
    Parameters:
    - target: Minor planet identifier
    
    Returns:
    Table with observational records
    """

# Configuration
from astroquery.mpc import conf
conf.server: str              # MPC server URL
conf.timeout: int = 60        # Connection timeout

Usage examples:

from astroquery.mpc import MPC

# Query orbital elements
vesta = MPC.query_object('4')  # Vesta
print(vesta['designation', 'a', 'e', 'i', 'H'])

# Get ephemeris
eph = MPC.get_ephemeris('Ceres', location='500', start='2023-01-01', 
                       step='1d', number=30)
print(eph['Date', 'RA', 'Dec', 'V'])

# Query multiple objects
asteroids = MPC.query_objects(['1', '2', '4', '10'])  # First 4 asteroids
print(asteroids['designation', 'H', 'diameter'])

# Get observational history
obs = MPC.get_observations('433')  # Eros observations
print(f"Found {len(obs)} observations of Eros")

Solar System Utilities

Additional utilities for solar system calculations including coordinate transformations, phase functions, and physical property databases.

from astroquery.solarsystem.pds import PDS
from astroquery.solarsystem.jpl import JPL

def query_region(coordinates: Union[SkyCoord, str], radius: Union[Quantity, str] = None,
                epoch: str = None) -> Table:
    """
    Query for solar system objects in a sky region at a specific epoch.
    
    Parameters:
    - coordinates: Center coordinates
    - radius: Search radius
    - epoch: Observation epoch
    
    Returns:
    Table with solar system objects in the region
    """

def get_body_barycentric_posvel(body: str, time: Time) -> Tuple:
    """
    Get barycentric position and velocity for solar system body.
    
    Parameters:
    - body: Solar system body name
    - time: Observation time
    
    Returns:
    Tuple of (position, velocity) arrays
    """

# Configuration for solar system services
from astroquery.solarsystem import conf
conf.timeout: int = 60        # Connection timeout

Usage examples:

from astroquery.solarsystem import MPC
from astropy.coordinates import SkyCoord
from astropy.time import Time
import astropy.units as u

# Find asteroids in a field
coords = SkyCoord('12h30m43s', '+12d23m28s', frame='icrs')
epoch = Time('2023-06-01')
asteroids_in_field = MPC.query_region(coords, radius=1*u.deg, epoch=epoch)
print(f"Found {len(asteroids_in_field)} asteroids in field")

# Get positions for observation planning
bright_asteroids = asteroids_in_field[asteroids_in_field['V'] < 18]
print(bright_asteroids['designation', 'RA', 'Dec', 'V', 'motion_rate'])

Common Types

from astropy.table import Table
from astropy.coordinates import SkyCoord
from astropy.units import Quantity
from astropy.time import Time
from typing import Union, List, Dict, Tuple, Optional

# Input types
target: Union[str, int]                     # Object identifier
location: str = '500'                       # Observer location (Earth center)
epochs: Union[str, List, float, Time]       # Time specification
coordinates: Union[SkyCoord, str]           # Sky coordinates

# Query parameters  
targetname: str                             # Small body name/designation
airmass_lessthan: float                     # Airmass constraint
solar_elongation: Tuple[float, float]       # Solar elongation range
start: str                                  # Start date
step: str = '1d'                           # Time step
number: int = 10                           # Number of points

# Return types
Table                                       # Ephemeris/orbital data
Dict                                        # Comprehensive object data
JobResults                                  # Asynchronous results
Tuple                                       # Position/velocity vectors

Install with Tessl CLI