0
# Solar System Services
1

2
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.
3

4
## Capabilities
5

6
### JPL Horizons - Ephemerides Service
7

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

10
```python { .api }
11
from astroquery.jplhorizons import Horizons
12

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

16
def ephemerides(self, **kwargs) -> Table:
17
    """
18
    Generate ephemerides for the target object.
19
    
20
    Parameters:
21
    - **kwargs: Ephemeris parameters (airmass_lessthan, solar_elongation, etc.)
22
    
23
    Returns:
24
    Table with ephemeris data (RA, Dec, distance, magnitude, etc.)
25
    """
26

27
def elements(self, **kwargs) -> Table:
28
    """
29
    Get orbital elements for the target object.
30
    
31
    Parameters:
32
    - **kwargs: Element parameters (ref_plane, tp_type, etc.)
33
    
34
    Returns:
35
    Table with orbital elements
36
    """
37

38
def vectors(self, **kwargs) -> Table:
39
    """
40
    Get state vectors (position and velocity) for the target.
41
    
42
    Parameters:
43
    - **kwargs: Vector parameters (ref_plane, aberrations, etc.)
44
    
45
    Returns:
46
    Table with position and velocity vectors
47
    """
48

49
# Configuration
50
from astroquery.jplhorizons import conf
51
conf.server: str              # JPL Horizons server URL
52
conf.timeout: int = 60        # Connection timeout
53
```
54

55
Usage examples:
56

57
```python
58
from astroquery.jplhorizons import Horizons
59
from astropy.time import Time
60

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

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

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

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

82
### JPL Small Body Database - SBDB
83

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

86
```python { .api }
87
from astroquery.jplsbdb import SBDB
88

89
def query(targetname: str, **kwargs) -> Dict:
90
    """
91
    Query JPL Small Body Database for object information.
92
    
93
    Parameters:  
94
    - targetname: Name or designation of small body
95
    - **kwargs: Additional query parameters
96
    
97
    Returns:
98
    Dictionary with comprehensive small body data
99
    """
100

101
def query_async(targetname: str, **kwargs) -> JobResults:
102
    """
103
    Submit asynchronous query for small body data.
104
    
105
    Parameters:
106
    - targetname: Small body name or designation
107
    - **kwargs: Additional parameters
108
    
109
    Returns:
110
    JobResults object for retrieving results
111
    """
112

113
# Configuration
114
from astroquery.jplsbdb import conf
115
conf.server: str              # SBDB server URL
116
conf.timeout: int = 60        # Connection timeout
117
```
118

119
Usage examples:
120

121
```python
122
from astroquery.jplsbdb import SBDB
123

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

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

134
# Query comet
135
halley = SBDB.query('1P')
136
print("Orbital period:", halley['orbit']['period'])
137
```
138

139
### Minor Planet Center - MPC
140

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

143
```python { .api }
144
from astroquery.mpc import MPC
145

146
def query_object(target: str, **kwargs) -> Table:
147
    """
148
    Query MPC for information about a specific minor planet.
149
    
150
    Parameters:
151
    - target: Minor planet name, number, or designation
152
    - **kwargs: Additional query parameters
153
    
154
    Returns:
155
    Table with MPC orbital data
156
    """
157

158
def query_objects(targets: List[str], **kwargs) -> Table:
159
    """
160
    Query multiple minor planets simultaneously.
161
    
162
    Parameters:
163
    - targets: List of minor planet identifiers
164
    - **kwargs: Additional parameters
165
    
166
    Returns:
167
    Table with data for all queried objects
168
    """
169

170
def get_ephemeris(target: str, location: str = '500', start: str = None,
171
                 step: str = '1d', number: int = 10, **kwargs) -> Table:
172
    """
173
    Get ephemeris for a minor planet.
174
    
175
    Parameters:
176
    - target: Minor planet identifier
177
    - location: Observer location code
178
    - start: Start date
179
    - step: Time step
180
    - number: Number of ephemeris points
181
    - **kwargs: Additional ephemeris parameters
182
    
183
    Returns:
184
    Table with ephemeris data
185
    """
186

187
def get_observations(target: str) -> Table:
188
    """
189
    Get observational data for a minor planet.
190
    
191
    Parameters:
192
    - target: Minor planet identifier
193
    
194
    Returns:
195
    Table with observational records
196
    """
197

198
# Configuration
199
from astroquery.mpc import conf
200
conf.server: str              # MPC server URL
201
conf.timeout: int = 60        # Connection timeout
202
```
203

204
Usage examples:
205

206
```python
207
from astroquery.mpc import MPC
208

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

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

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

222
# Get observational history
223
obs = MPC.get_observations('433')  # Eros observations
224
print(f"Found {len(obs)} observations of Eros")
225
```
226

227
### Solar System Utilities
228

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

231
```python { .api }
232
from astroquery.solarsystem.pds import PDS
233
from astroquery.solarsystem.jpl import JPL
234

235
def query_region(coordinates: Union[SkyCoord, str], radius: Union[Quantity, str] = None,
236
                epoch: str = None) -> Table:
237
    """
238
    Query for solar system objects in a sky region at a specific epoch.
239
    
240
    Parameters:
241
    - coordinates: Center coordinates
242
    - radius: Search radius
243
    - epoch: Observation epoch
244
    
245
    Returns:
246
    Table with solar system objects in the region
247
    """
248

249
def get_body_barycentric_posvel(body: str, time: Time) -> Tuple:
250
    """
251
    Get barycentric position and velocity for solar system body.
252
    
253
    Parameters:
254
    - body: Solar system body name
255
    - time: Observation time
256
    
257
    Returns:
258
    Tuple of (position, velocity) arrays
259
    """
260

261
# Configuration for solar system services
262
from astroquery.solarsystem import conf
263
conf.timeout: int = 60        # Connection timeout
264
```
265

266
Usage examples:
267

268
```python
269
from astroquery.solarsystem import MPC
270
from astropy.coordinates import SkyCoord
271
from astropy.time import Time
272
import astropy.units as u
273

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

280
# Get positions for observation planning
281
bright_asteroids = asteroids_in_field[asteroids_in_field['V'] < 18]
282
print(bright_asteroids['designation', 'RA', 'Dec', 'V', 'motion_rate'])
283
```
284

285
## Common Types
286

287
```python { .api }
288
from astropy.table import Table
289
from astropy.coordinates import SkyCoord
290
from astropy.units import Quantity
291
from astropy.time import Time
292
from typing import Union, List, Dict, Tuple, Optional
293

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

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

308
# Return types
309
Table                                       # Ephemeris/orbital data
310
Dict                                        # Comprehensive object data
311
JobResults                                  # Asynchronous results
312
Tuple                                       # Position/velocity vectors
313
```