2024-09-25

To use a HEALPix model as the sky model input for PyUVSim, you need to follow these steps. PyUVSim supports HEALPix maps as an input format, allowing you to simulate visibilities based on this sky model.

Steps for Using a HEALPix Sky Model in PyUVSim:

1. Prepare the HEALPix Sky Model

Ensure your HEALPix sky model is in the correct format. Typically, it's stored in a file as a HEALPix map, often using the FITS format. If your sky model is in a different format (e.g., HDF5 or a plain text file), you may need to convert it into a format that healpy can read.

Example of loading a HEALPix map:

import healpy as hp

# Load the HEALPix map (e.g., from a FITS file)
nside = 64  # Resolution parameter of HEALPix
sky_map = hp.read_map("path_to_healpix_sky_model.fits", field=0)

2. Convert the HEALPix Map to a PyUVSim Source Catalog

PyUVSim requires the sky model to be in the form of a source catalog with positions (RA, Dec) and flux densities. You'll need to convert the HEALPix map into a list of source positions and flux values.

Here’s how you can convert the HEALPix map into a PyUVSim-compatible format:

import numpy as np
import pyuvsim

# Get the pixel positions and flux values from the HEALPix map
nside = hp.get_nside(sky_map)
npix = hp.nside2npix(nside)

# Get the positions of the sources (in RA, Dec) from HEALPix pixels
theta, phi = hp.pix2ang(nside, np.arange(npix))

# Convert HEALPix coordinates to RA and Dec
ra = np.rad2deg(phi)
dec = np.rad2deg(0.5 * np.pi - theta)

# Assume the sky_map contains flux densities (or modify accordingly)
flux = sky_map

# Create a list of source objects
sources = []
for i in range(npix):
    if flux[i] > 0:  # Only add sources with non-zero flux
        source = pyuvsim.AnalyticSource(ra[i], dec[i], flux[i], stokes=[flux[i], 0, 0, 0])
        sources.append(source)

• ra and dec are the right ascension and declination of each source.
• flux represents the intensity of each source in your sky model.
• The stokes parameter is used to specify the Stokes parameters of the sources (I, Q, U, V). If you have polarized sources, you can include the other Stokes parameters.

3. Create a Sky Model Catalog

Once you have the list of source objects from the HEALPix map, you can create a pyuvsim.SkyModel:

sky_model = pyuvsim.SkyModel(sources)

4. Pass the Sky Model to PyUVSim

You now have the sky model prepared. You can either pass it directly to the PyUVSim simulation function or save it to a file for later use.

To use it directly in a simulation:

import pyuvsim

# Prepare your UVData object as usual
from pyuvdata import UVData
uvdata = UVData()
uvdata.read("path_to_uvfits_file.uvfits")

# Run the simulation with the custom sky model
results = pyuvsim.uvsim.run_uvsim(uvdata, catalog=sky_model)

5. Optional: Save the Sky Model to a File

If you want to save the generated sky model (e.g., for use later or in another simulation), PyUVSim supports saving it to a file:

import pyuvsim
sky_model.write_skyh5("my_sky_model.h5")

Then, later, you can load it with:

sky_model = pyuvsim.SkyModel.from_file("my_sky_model.h5")

6. Running PyUVSim

Once your sky model is ready and included in the PyUVSim configuration, you can run the simulation:

from pyuvsim import run_uvsim

# Call the simulation
run_uvsim("path_to_config_file.yaml")

In the YAML configuration file, make sure you refer to the sky model that you created. Alternatively, you can use the run_uvsim function directly in your Python script, as shown earlier.

Additional Notes:

• Resolution (NSIDE): Ensure the resolution (NSIDE) of your HEALPix map is appropriate for your simulation. Higher NSIDE values give better resolution but may require more memory and computational resources.
• Custom Source Properties: You can extend the pyuvsim.AnalyticSource class to include more detailed source properties, such as different spectral indices, polarization, etc.
• Parallelization: If your sky model is large, you can use MPI parallelization to distribute the computation across multiple cores for faster performance.

This process converts your HEALPix model into a PyUVSim-compatible sky model and runs the simulation accordingly.