0
# Space Mission Archives
1
2
Archives from space missions and satellites providing specialized astronomical data including gamma-ray, X-ray, infrared, ultraviolet, and optical observations. These archives offer unique datasets from space-based observatories with capabilities unavailable from ground-based telescopes.
3
4
## Capabilities
5
6
### ESA - European Space Agency Missions
7
8
ESA missions provide access to data from major space telescopes including James Webb Space Telescope, Hubble Space Telescope, XMM-Newton, and other ESA-operated missions.
9
10
```python { .api }
11
from astroquery.esa.jwst import Jwst
12
from astroquery.esa.hubble import Hubble
13
from astroquery.esa.xmm_newton import XmmNewton
14
15
# James Webb Space Telescope
16
def query_object(name: str, radius: Union[Quantity, str] = None, **kwargs) -> Table:
17
"""
18
Query JWST archive for observations of a specific object.
19
20
Parameters:
21
- name: Name of the astronomical object
22
- radius: Search radius around object
23
- **kwargs: Additional query parameters
24
25
Returns:
26
Table with JWST observation metadata
27
"""
28
29
def query_region(coordinates: Union[SkyCoord, str], radius: Union[Quantity, str] = None) -> Table:
30
"""
31
Query JWST archive for observations in a sky region.
32
33
Parameters:
34
- coordinates: Center coordinates
35
- radius: Search radius
36
37
Returns:
38
Table with JWST observations in the region
39
"""
40
41
# Hubble Space Telescope
42
def query_object(name: str, radius: Union[Quantity, str] = None) -> Table:
43
"""
44
Query Hubble archive via ESA for observations of an object.
45
46
Parameters:
47
- name: Object name
48
- radius: Search radius
49
50
Returns:
51
Table with Hubble observation records
52
"""
53
54
# XMM-Newton
55
def query_object(name: str, radius: Union[Quantity, str] = None) -> Table:
56
"""
57
Query XMM-Newton archive for X-ray observations.
58
59
Parameters:
60
- name: Object name
61
- radius: Search radius
62
63
Returns:
64
Table with XMM-Newton observation metadata
65
"""
66
67
# Configuration
68
from astroquery.esa import conf
69
conf.server: str # ESA archive server
70
conf.timeout: int = 60 # Connection timeout
71
```
72
73
Usage examples:
74
75
```python
76
from astroquery.esa.jwst import Jwst
77
from astroquery.esa.hubble import Hubble
78
import astropy.units as u
79
from astropy.coordinates import SkyCoord
80
81
# Query JWST observations
82
jwst_obs = Jwst.query_object('NGC 628', radius=2*u.arcmin)
83
print(f"Found {len(jwst_obs)} JWST observations")
84
85
# Query Hubble archive through ESA
86
hubble_obs = Hubble.query_object('M51', radius=5*u.arcmin)
87
print(f"Found {len(hubble_obs)} Hubble observations")
88
89
# Region query for multiple missions
90
coords = SkyCoord('12h30m43s', '+12d23m28s', frame='icrs')
91
jwst_region = Jwst.query_region(coords, radius=30*u.arcsec)
92
```
93
94
### Fermi - Fermi Gamma-ray Space Telescope
95
96
Fermi LAT (Large Area Telescope) provides access to gamma-ray observations of the sky, including both survey data and targeted observations of gamma-ray sources.
97
98
```python { .api }
99
from astroquery.fermi import Fermi
100
101
def query_object(object_name: str, energyrange_MeV: Tuple[float, float] = (100, 100000),
102
obsdates: str = None, timesys: str = 'MET') -> Table:
103
"""
104
Query Fermi LAT for gamma-ray observations of an object.
105
106
Parameters:
107
- object_name: Name of the astronomical object
108
- energyrange_MeV: Energy range in MeV as (min, max) tuple
109
- obsdates: Observation date range
110
- timesys: Time system ('MET', 'UTC')
111
112
Returns:
113
Table with Fermi LAT observation information
114
"""
115
116
def query_region(coordinates: Union[SkyCoord, str], radius: Union[Quantity, str] = None,
117
energyrange_MeV: Tuple[float, float] = (100, 100000)) -> Table:
118
"""
119
Query Fermi LAT for gamma-ray data in a sky region.
120
121
Parameters:
122
- coordinates: Center coordinates
123
- radius: Search radius
124
- energyrange_MeV: Energy range in MeV
125
126
Returns:
127
Table with Fermi LAT data in the specified region
128
"""
129
130
def get_lightcurve(ra: float, dec: float, energyrange_MeV: Tuple[float, float] = (100, 100000),
131
binsize_days: float = 7.0) -> Table:
132
"""
133
Get gamma-ray light curve for a position.
134
135
Parameters:
136
- ra: Right ascension in degrees
137
- dec: Declination in degrees
138
- energyrange_MeV: Energy range in MeV
139
- binsize_days: Time bin size in days
140
141
Returns:
142
Table with light curve data
143
"""
144
145
# Configuration
146
from astroquery.fermi import conf
147
conf.server: str # Fermi server URL
148
conf.timeout: int = 60 # Connection timeout
149
```
150
151
Usage examples:
152
153
```python
154
from astroquery.fermi import Fermi
155
import astropy.units as u
156
from astropy.coordinates import SkyCoord
157
158
# Query gamma-ray observations of a blazar
159
result = Fermi.query_object('3C 279', energyrange_MeV=(1000, 10000))
160
print(f"Found {len(result)} Fermi observations")
161
162
# Region query for gamma-ray sources
163
coords = SkyCoord('12h30m43s', '+12d23m28s', frame='icrs')
164
gamma_sources = Fermi.query_region(coords, radius=1*u.deg,
165
energyrange_MeV=(100, 100000))
166
167
# Get light curve for Crab pulsar
168
lightcurve = Fermi.get_lightcurve(83.6331, 22.0145,
169
energyrange_MeV=(100, 100000),
170
binsize_days=30.0)
171
print(f"Light curve has {len(lightcurve)} time bins")
172
```
173
174
### ESASky - ESA Sky Service
175
176
ESASky provides access to multi-mission data from ESA and partner missions with an integrated view of astronomical observations across multiple wavelengths.
177
178
```python { .api }
179
from astroquery.esasky import ESASky
180
181
def query_object_catalogs(object_name: str, catalogs: List[str] = None,
182
radius: Union[Quantity, str] = None) -> Dict[str, Table]:
183
"""
184
Query ESASky catalogs for sources around an object.
185
186
Parameters:
187
- object_name: Name of the astronomical object
188
- catalogs: List of catalog names to search
189
- radius: Search radius
190
191
Returns:
192
Dictionary with catalog names as keys and Tables as values
193
"""
194
195
def query_region_catalogs(coordinates: Union[SkyCoord, str],
196
radius: Union[Quantity, str] = None,
197
catalogs: List[str] = None) -> Dict[str, Table]:
198
"""
199
Query ESASky catalogs in a sky region.
200
201
Parameters:
202
- coordinates: Center coordinates
203
- radius: Search radius
204
- catalogs: Catalog names to search
205
206
Returns:
207
Dictionary with catalog results
208
"""
209
210
def get_images(position: Union[SkyCoord, str], radius: Union[Quantity, str] = None,
211
missions: List[str] = None) -> Dict[str, List]:
212
"""
213
Download images from ESA missions.
214
215
Parameters:
216
- position: Target position
217
- radius: Image size/radius
218
- missions: List of mission names
219
220
Returns:
221
Dictionary with mission names and corresponding image data
222
"""
223
224
# Configuration
225
from astroquery.esasky import conf
226
conf.server: str # ESASky server URL
227
conf.timeout: int = 60 # Connection timeout
228
```
229
230
Usage examples:
231
232
```python
233
from astroquery.esasky import ESASky
234
import astropy.units as u
235
from astropy.coordinates import SkyCoord
236
237
# Query multiple catalogs around an object
238
catalogs = ESASky.query_object_catalogs('M31',
239
radius=10*u.arcmin,
240
catalogs=['Gaia', '2MASS'])
241
for cat_name, table in catalogs.items():
242
print(f"{cat_name}: {len(table)} sources")
243
244
# Get images from multiple missions
245
coords = SkyCoord('00h42m44s', '+41d16m09s', frame='icrs')
246
images = ESASky.get_images(coords, radius=5*u.arcmin,
247
missions=['Hubble', 'Spitzer'])
248
for mission, img_list in images.items():
249
print(f"{mission}: {len(img_list)} images")
250
```
251
252
### HEASARC - High Energy Astrophysics Science Archive
253
254
HEASARC provides access to data from high-energy astrophysics missions including X-ray, gamma-ray, and extreme ultraviolet observations from missions like RXTE, Swift, NuSTAR, and others.
255
256
```python { .api }
257
from astroquery.heasarc import Heasarc
258
259
def query_object(object_name: str, mission: str,
260
time: str = None, radius: Union[Quantity, str] = None) -> Table:
261
"""
262
Query HEASARC for high-energy observations of an object.
263
264
Parameters:
265
- object_name: Name of the astronomical object
266
- mission: Mission name (e.g., 'swift', 'rxte', 'nustar')
267
- time: Time constraint
268
- radius: Search radius
269
270
Returns:
271
Table with high-energy observation records
272
"""
273
274
def query_region(coordinates: Union[SkyCoord, str], mission: str,
275
radius: Union[Quantity, str] = None, time: str = None) -> Table:
276
"""
277
Query HEASARC for observations in a sky region.
278
279
Parameters:
280
- coordinates: Center coordinates
281
- mission: Mission name
282
- radius: Search radius
283
- time: Time constraint
284
285
Returns:
286
Table with observations in the specified region
287
"""
288
289
def get_tables() -> List[str]:
290
"""
291
Get list of available HEASARC tables/missions.
292
293
Returns:
294
List of available table names
295
"""
296
297
# Configuration
298
from astroquery.heasarc import conf
299
conf.server: str # HEASARC server URL
300
conf.timeout: int = 60 # Connection timeout
301
```
302
303
Usage examples:
304
305
```python
306
from astroquery.heasarc import Heasarc
307
import astropy.units as u
308
from astropy.coordinates import SkyCoord
309
310
# Query Swift observations of a source
311
swift_obs = Heasarc.query_object('Cygnus X-1', mission='swift')
312
print(f"Found {len(swift_obs)} Swift observations")
313
314
# Region query for NuSTAR observations
315
coords = SkyCoord('19h58m21.68s', '+35d12m05.8s', frame='icrs')
316
nustar_obs = Heasarc.query_region(coords, mission='nustar',
317
radius=2*u.arcmin)
318
319
# Get available missions/tables
320
tables = Heasarc.get_tables()
321
print(f"Available tables: {len(tables)}")
322
x_ray_tables = [t for t in tables if 'xray' in t.lower()]
323
```
324
325
## Common Types
326
327
```python { .api }
328
from astropy.table import Table
329
from astropy.coordinates import SkyCoord
330
from astropy.units import Quantity
331
from typing import Union, List, Dict, Tuple, Optional
332
333
# Input types
334
coordinates: Union[SkyCoord, str] # Sky coordinates
335
object_name: str # Astronomical object name
336
radius: Union[Quantity, str, None] # Search radius
337
mission: str # Mission/instrument name
338
339
# Energy/wavelength parameters
340
energyrange_MeV: Tuple[float, float] # Energy range for gamma-ray
341
time: str # Time constraints
342
binsize_days: float # Time bin size
343
344
# Return types
345
Table # Single table result
346
Dict[str, Table] # Multiple catalog results
347
Dict[str, List] # Mission image data
348
List[str] # Available tables/missions
349
```