FITSPipeline

The raw data (e.g., *_raw.fits files) is hosted in the Mikulski Archive for Space Telescopes (MAST), operated by STScI. No account is needed for public data like this.

• Go to the MAST HST search interface: https://mast.stsci.edu/search/ui/#/hst
• In the search form:
  • Enter “17830” in the “Proposal ID” field.
  • Optionally, filter by “Target Name” as “3I/ATLAS” or “C/2025 N1” to narrow it down.
  • Click “Search”.
• The results will show datasets from the proposal, including:
  • July 21, 2025 observations: Two orbits with short exposures (25-40 seconds) in WFC3/UVIS filters (likely F606W or similar broadbands for comet imaging).
  • November 30, 2025 observations: Similar WFC3 setup, tracking the comet (background stars appear streaked due to motion).
  • Dataset IDs typically start with “J” or “I” (e.g., jfxx01010_asn.fits for associations, or individual *_raw.fits files).
• Select the datasets you want (check boxes), then click “Download” or “Add to Basket”.
• Choose file types: Select “Uncalibrated” or “Raw” to get the original FITS files (avoid “Calibrated” if you want to process from scratch).
• Download the ZIP or individual files. Each observation might include multiple exposures and an association table (*_asn.fits) for grouping them.

Alternatively, for programmatic download (since you have Python): - Install astroquery if not already: pip install astroquery - Use this example script:

from astroquery.mast import Observations

​# Query by proposal and target obs_table =
Observations.query_criteria(proposal_id=“17830”,
target_name=[“3I/ATLAS”, “C/2025 N1”])

​# List available products data_products =
Observations.get_product_list(obs_table)

​# Filter for raw FITS (adjust filters as needed) raw_products =
Observations.filter_products(data_products, productType=“SCIENCE”,
extension=“fits”, mrp_only=False, calib_level=1) # calib_level=1 for raw

​# Download to current directory
Observations.download_products(raw_products, download_dir=“.”)

This will fetch the files directly.

Once downloaded, start with simple viewing/analysis using astropy (assuming it's installed; if not, pip install astropy).

• Open and inspect a file:

  from astropy.io import fits
  import matplotlib.pyplot as plt
  
  # Open the FITS file
  with fits.open('example_raw.fits') as hdul:  # Replace with your file name
      hdul.info()  # Shows structure (primary header, science data, etc.)
      header = hdul[0].header  # Or hdul[1].header for science extension
      print(header)  # View keywords like EXPTIME, FILTER, DATE-OBS
  
      # Plot the raw science data (usually in extension 1 'SCI')
      data = hdul[1].data  # Adjust extension if needed
      plt.imshow(data, cmap='gray', origin='lower')
      plt.colorbar()
      plt.show()
  

• This gives you the uncalibrated image. For comets, you'll see the raw counts; background stars may streak in tracking mode.

Hubble raw data needs calibration (bias subtraction, flat-fielding, CTE correction, etc.) for accurate analysis. Use the official calwf3 pipeline, part of HSTCAL.

• If dithered (multiple positions), use DrizzlePac (install: conda install -c conda-forge drizzlepac) to align and combine:

  from drizzlepac import astrodrizzle
  astrodrizzle.AstroDrizzle('*_flt.fits', output='combined_drz')
  

• For comet-specific analysis (e.g., coma measurement, photometry): Use astropy's photutils or custom scripts.
• Documentation: Check the WFC3 Data Handbook (https://hst-docs.stsci.edu/wfc3dhb) for details on keywords and steps. If you run into issues, the STScI Help Desk (help@stsci.edu) is responsive.

Once you've calibrated your Hubble WFC3 FITS files (e.g., producing ​*_flt.fits or a drizzled *_drz.fits file), exporting to a viewable format like JPG, PNG, or TIFF is straightforward using Python with astropy and matplotlib. Astronomical images have high dynamic range, so proper scaling/stretching is key to revealing details (e.g., the comet's coma and tail) without the image appearing blank or washed out.

This is ideal for Hubble data, as it automatically computes good min/max cuts based on the image statistics (similar to what DS9 or professional tools use).

from astropy.io import fits
from astropy.visualization import ZScaleInterval, ImageNormalize
import matplotlib.pyplot as plt

# Load your processed FITS file (e.g., a single flt or combined drz)
filename = 'your_drizzled_drz.fits'  # Or 'example_flt.fits'
with fits.open(filename) as hdul:
    data = hdul[0].data  # Primary science data is usually in extension 0 for drz, or [1].data for flt
    header = hdul[0].header

# Create a normalized image with ZScale (handles outliers well)
norm = ImageNormalize(data, interval=ZScaleInterval())

# Plot and save
plt.figure(figsize=(10, 10))
plt.imshow(data, cmap='gray', norm=norm, origin='lower')  # 'gray' is common for single-filter comet images
plt.title(f'Hubble WFC3 Image of 3I/ATLAS\n{header.get("FILTER", "Unknown Filter")}')
plt.axis('off')  # Hide axes for a cleaner look
plt.savefig('3I_ATLAS_hubble.jpg', dpi=300, bbox_inches='tight')  # JPG for small file size
plt.savefig('3I_ATLAS_hubble.png', dpi=300, bbox_inches='tight')  # PNG for lossless
plt.savefig('3I_ATLAS_hubble.tiff', dpi=300, bbox_inches='tight')  # TIFF for high quality/printing
plt.show()  # Optional: display interactively

• Why ZScale? It ignores extreme outliers (e.g., cosmic rays or hot pixels) and stretches the display to highlight faint features like the comet's extended structure.
• Cmap options: Try ‘viridis’, ‘plasma’, or ‘inferno’ for pseudo-color if you prefer (though grayscale is standard for broadband filters).
• For multi-filter data: If you have images in multiple filters (unlikely for this proposal, but possible), stack them as RGB later with tools like astropy's make_luptonrgb.

If ZScale doesn't suit your taste:

from astropy.visualization import LogStretch

norm = ImageNormalize(data, interval=ZScaleInterval(), stretch=LogStretch())
# Then same plt.imshow(...) as above

• Use the drizzled (*_drz.fits or *_drc.fits) file if available—it's combined, distortion-corrected, and higher resolution.
• For comets like 3I/ATLAS (non-sidereal tracking), stars will streak, but the comet should be sharp. Zoom in on the central region if needed: plt.xlim(xmin, xmax); plt.ylim(ymin, ymax)
• Higher DPI (e.g., 300+) gives sharper exports for sharing/printing.
• If the image looks too dark/bright, tweak with vmin=/=vmax manually: plt.imshow(data, cmap'gray', vmin=0.1, vmax=99.9)= (percentiles work well).

This will produce professional-looking outputs similar to official Hubble releases. Here's what processed Hubble images of comets typically look like (for reference; your raw processing should yield comparable results with the right stretch):

Run the script on your files and adjust as needed—share your exported image if you want feedback on the stretch!