0
# IPAC Services
1

2
Services provided by the Infrared Processing and Analysis Center (IPAC) including infrared surveys, extragalactic databases, exoplanet archives, and specialized astronomical catalogs. IPAC services are essential for infrared astronomy and extragalactic research.
3

4
## Capabilities
5

6
### IRSA - Infrared Science Archive
7

8
IRSA provides access to infrared and submillimeter astronomical surveys and catalogs, including 2MASS, WISE, Spitzer, and other infrared missions.
9

10
```python { .api }
11
from astroquery.ipac.irsa import Irsa
12

13
def query_region(coordinates: Union[SkyCoord, str], catalog: str = None,
14
                spatial: str = "Cone", radius: Union[Quantity, str] = None,
15
                width: Union[Quantity, str] = None, height: Union[Quantity, str] = None) -> Table:
16
    """
17
    Query IRSA catalogs in a sky region.
18
    
19
    Parameters:
20
    - coordinates: Center coordinates as SkyCoord or string
21
    - catalog: Catalog name (e.g., '2mass_psc', 'wise_allsky')
22
    - spatial: Spatial constraint type ('Cone', 'Box', 'Polygon')
23
    - radius: Search radius for cone searches
24
    - width: Width for box searches
25
    - height: Height for box searches
26
    
27
    Returns:
28
    Table with catalog sources in the specified region
29
    """
30

31
def query_object(object_name: str, catalog: str = None, 
32
                radius: Union[Quantity, str] = None) -> Table:
33
    """
34
    Query IRSA catalogs around a named object.
35
    
36
    Parameters:
37
    - object_name: Name of the astronomical object
38
    - catalog: Specific catalog to search
39
    - radius: Search radius around object
40
    
41
    Returns:
42
    Table with catalog entries around the object
43
    """
44

45
def list_catalogs() -> Table:
46
    """
47
    List available IRSA catalogs.
48
    
49
    Returns:
50
    Table with catalog names and descriptions
51
    """
52

53
def get_images(coordinates: Union[SkyCoord, str], mission: str,
54
              size: Union[Quantity, str] = None) -> List:
55
    """
56
    Download infrared images from IRSA missions.
57
    
58
    Parameters:
59
    - coordinates: Target coordinates
60
    - mission: Mission name ('2mass', 'wise', 'spitzer')
61
    - size: Image size
62
    
63
    Returns:
64
    List of HDUList objects with image data
65
    """
66

67
# Configuration
68
from astroquery.ipac.irsa import conf
69
conf.server: str              # IRSA server URL
70
conf.timeout: int = 60        # Connection timeout
71
```
72

73
Usage examples:
74

75
```python
76
from astroquery.ipac.irsa import Irsa
77
import astropy.units as u
78
from astropy.coordinates import SkyCoord
79

80
# Query 2MASS point source catalog
81
coords = SkyCoord('12h30m43s', '+12d23m28s', frame='icrs')
82
result = Irsa.query_region(coords, catalog='2mass_psc', radius=2*u.arcmin)
83
print(f"Found {len(result)} 2MASS sources")
84
print(result['designation', 'j_m', 'h_m', 'k_m'])
85

86
# Query WISE all-sky catalog  
87
wise_sources = Irsa.query_object('NGC 1068', catalog='wise_allsky', 
88
                                radius=30*u.arcsec)
89
print(f"Found {len(wise_sources)} WISE sources")
90

91
# List available catalogs
92
catalogs = Irsa.list_catalogs()
93
infrared_cats = catalogs[catalogs['title'].str.contains('infrared', case=False)]
94

95
# Get 2MASS images
96
images = Irsa.get_images(coords, mission='2mass', size=5*u.arcmin)
97
for img in images:
98
    print(f"Image shape: {img[0].data.shape}")
99
```
100

101
### NED - NASA Extragalactic Database
102

103
NED provides comprehensive information about extragalactic objects including galaxies, quasars, and other extragalactic sources, with cross-identifications, photometry, and bibliographic references.
104

105
```python { .api }
106
from astroquery.ipac.ned import Ned
107

108
def query_object(object_name: str, get_query_payload: bool = False) -> Table:
109
    """
110
    Query NED for information about an extragalactic object.
111
    
112
    Parameters:
113
    - object_name: Name of the extragalactic object
114
    - get_query_payload: Return query parameters instead of executing
115
    
116
    Returns:
117
    Table with NED object information
118
    """
119

120
def query_region(coordinates: Union[SkyCoord, str], radius: Union[Quantity, str] = None,
121
                equinox: str = "J2000.0") -> Table:
122
    """
123
    Query NED for extragalactic objects in a sky region.
124
    
125
    Parameters:
126
    - coordinates: Center coordinates
127
    - radius: Search radius (default: 1 arcmin)
128
    - equinox: Coordinate equinox
129
    
130
    Returns:
131
    Table with extragalactic objects in the region
132
    """
133

134
def get_table(object_name: str, table: str = "photometry") -> Table:
135
    """
136
    Get specific data tables for an extragalactic object.
137
    
138
    Parameters:
139
    - object_name: Name of the object
140
    - table: Table type ('photometry', 'redshifts', 'classifications', etc.)
141
    
142
    Returns:
143
    Table with requested data
144
    """
145

146
def query_refcode(refcode: str) -> Table:
147
    """
148
    Query NED by bibliographic reference code.
149
    
150
    Parameters:
151
    - refcode: NED reference code
152
    
153
    Returns:
154
    Table with objects from the specified reference
155
    """
156

157
def get_image_list(object_name: str) -> Table:
158
    """
159
    Get list of available images for an object.
160
    
161
    Parameters:
162
    - object_name: Name of the object
163
    
164
    Returns:
165
    Table with available image information
166
    """
167

168
# Configuration
169
from astroquery.ipac.ned import conf
170
conf.server: str              # NED server URL  
171
conf.timeout: int = 60        # Connection timeout
172
```
173

174
Usage examples:
175

176
```python
177
from astroquery.ipac.ned import Ned
178
import astropy.units as u
179
from astropy.coordinates import SkyCoord
180

181
# Query basic object information
182
result = Ned.query_object('NGC 1068')
183
print(result['Object Name', 'RA', 'DEC', 'Type', 'Redshift'])
184

185
# Get photometric data
186
photometry = Ned.get_table('NGC 1068', table='photometry')
187
print(f"Found {len(photometry)} photometric measurements")
188

189
# Region query for nearby galaxies
190
coords = SkyCoord('02h42m40.7s', '-00d00m48s', frame='icrs')
191
nearby = Ned.query_region(coords, radius=10*u.arcmin)
192
print(f"Found {len(nearby)} extragalactic objects")
193

194
# Get redshift measurements
195
redshifts = Ned.get_table('M87', table='redshifts')
196
print(redshifts['Published Velocity', 'Uncertainty', 'Reference'])
197
```
198

199
### NASA Exoplanet Archive
200

201
The NASA Exoplanet Archive provides access to confirmed exoplanet data, planetary system parameters, and stellar host information from various detection methods and surveys.
202

203
```python { .api }
204
from astroquery.ipac.nexsci.nasa_exoplanet_archive import NasaExoplanetArchive
205

206
def query_object(object_name: str, table: str = "pscomppars",
207
                get_query_payload: bool = False) -> Table:
208
    """
209
    Query NASA Exoplanet Archive for information about a specific object.
210
    
211
    Parameters:
212
    - object_name: Name of the star or planetary system
213
    - table: Archive table to query ('pscomppars', 'ps', 'cumulative', etc.)
214
    - get_query_payload: Return query parameters instead of executing
215
    
216
    Returns:
217
    Table with exoplanet/stellar data
218
    """
219

220
def query_criteria(table: str = "pscomppars", **criteria) -> Table:
221
    """
222
    Query the archive with specific selection criteria.
223
    
224
    Parameters:
225
    - table: Archive table to query
226
    - **criteria: Selection criteria (pl_bmassj='<1', pl_orbper='>365', etc.)
227
    
228
    Returns:
229
    Table with objects matching the criteria
230
    """
231

232
def query_aliases(object_name: str) -> Table:
233
    """
234
    Get all known aliases for a stellar/planetary system.
235
    
236
    Parameters:
237
    - object_name: Name of the object
238
    
239
    Returns:
240
    Table with alternative names and identifiers
241
    """
242

243
def get_target_list(coordinates: Union[SkyCoord, str], radius: Union[Quantity, str] = None) -> Table:
244
    """
245
    Get exoplanet targets in a sky region.
246
    
247
    Parameters:
248
    - coordinates: Center coordinates
249
    - radius: Search radius
250
    
251
    Returns:
252
    Table with exoplanet systems in the region
253
    """
254

255
# Configuration
256
from astroquery.ipac.nexsci.nasa_exoplanet_archive import conf
257
conf.server: str              # Archive server URL
258
conf.timeout: int = 60        # Connection timeout
259
```
260

261
Usage examples:
262

263
```python
264
from astroquery.ipac.nexsci.nasa_exoplanet_archive import NasaExoplanetArchive
265
import astropy.units as u
266
from astropy.coordinates import SkyCoord
267

268
# Query confirmed planets around a star
269
kepler_planets = NasaExoplanetArchive.query_object('Kepler-452', 
270
                                                  table='pscomppars')
271
print(f"Found {len(kepler_planets)} confirmed planets")
272
print(kepler_planets['pl_name', 'pl_bmassj', 'pl_orbper'])
273

274
# Query for Jupiter-like planets
275
jupiter_analogs = NasaExoplanetArchive.query_criteria(
276
    table='pscomppars',
277
    where="pl_bmassj>0.5 and pl_bmassj<2.0 and pl_orbper>300"
278
)
279
print(f"Found {len(jupiter_analogs)} Jupiter analogs")
280

281
# Query for habitable zone planets  
282
hab_zone = NasaExoplanetArchive.query_criteria(
283
    table='pscomppars',
284
    where="pl_eqt>200 and pl_eqt<320"  # Equilibrium temperature
285
)
286
print(f"Found {len(hab_zone)} potentially habitable planets")
287

288
# Get aliases for a system
289
aliases = NasaExoplanetArchive.query_aliases('HD 209458')
290
print(aliases['pl_name'])
291
```
292

293
### IRSA Dust Extinction Service
294

295
Service for querying Galactic dust extinction values along lines of sight, essential for correcting astronomical observations for interstellar extinction.
296

297
```python { .api }
298
from astroquery.ipac.irsa_dust import IrsaDust
299

300
def get_extinction_table(coordinates: Union[SkyCoord, str, List], 
301
                        radius: Union[Quantity, str] = None) -> Table:
302
    """
303
    Get dust extinction values for sky positions.
304
    
305
    Parameters:
306
    - coordinates: Target coordinates (single position or list)
307
    - radius: Search radius for extended sources
308
    
309
    Returns:
310
    Table with extinction values and dust maps information
311
    """
312

313
def get_query_table(coordinates: Union[SkyCoord, str, List]) -> Table:
314
    """
315
    Get detailed dust extinction information.
316
    
317
    Parameters:
318
    - coordinates: Target coordinates
319
    
320
    Returns:
321
    Table with comprehensive dust extinction data
322
    """
323

324
# Configuration
325
from astroquery.ipac.irsa_dust import conf
326
conf.server: str              # IRSA dust service URL
327
conf.timeout: int = 60        # Connection timeout
328
```
329

330
Usage examples:
331

332
```python
333
from astroquery.ipac.irsa_dust import IrsaDust
334
from astropy.coordinates import SkyCoord
335

336
# Get extinction for a single position
337
coords = SkyCoord('12h30m43s', '+12d23m28s', frame='icrs')
338
extinction = IrsaDust.get_extinction_table(coords)
339
print(f"A_V = {extinction['A_V'][0]:.3f} mag")
340

341
# Get extinction for multiple positions
342
coord_list = [SkyCoord('12h30m43s', '+12d23m28s', frame='icrs'),
343
              SkyCoord('18h30m00s', '-29d00m00s', frame='icrs')]
344
extinctions = IrsaDust.get_extinction_table(coord_list)
345
print(extinctions['A_V', 'A_B', 'A_R'])
346
```
347

348
## Common Types
349

350
```python { .api }
351
from astropy.table import Table
352
from astropy.coordinates import SkyCoord
353
from astropy.units import Quantity
354
from astropy.io.fits import HDUList
355
from typing import Union, List, Optional
356

357
# Input types
358
coordinates: Union[SkyCoord, str]           # Sky coordinates
359
object_name: str                            # Astronomical object name
360
radius: Union[Quantity, str, None]          # Search radius
361
catalog: str                                # Catalog name/identifier
362

363
# Query parameters
364
spatial: str = "Cone"                       # Spatial constraint type
365
table: str                                  # Archive table name
366
mission: str                                # Mission/survey name
367
equinox: str = "J2000.0"                   # Coordinate equinox
368

369
# Search criteria
370
width: Union[Quantity, str, None]           # Box width
371
height: Union[Quantity, str, None]          # Box height
372
size: Union[Quantity, str, None]            # Image size
373

374
# Return types
375
Table                                       # Query results
376
List[HDUList]                              # Image data
377
```