def make_diffuse_background(bkg_events, event_params, rmf, prng=None):
from soxs.instrument import perform_dither
n_e = bkg_events["energy"].size
bkg_events['time'] = prng.uniform(size=n_e,
low=0.0,
high=event_params["exposure_time"])
x_offset, y_offset = perform_dither(bkg_events["time"],
event_params["dither_params"])
rot_mat = get_rot_mat(event_params["roll_angle"])
det = np.array([
bkg_events["detx"] + x_offset - event_params["aimpt_coords"][0],
bkg_events["dety"] + y_offset - event_params["aimpt_coords"][1]
])
pix = np.dot(rot_mat.T, det)
bkg_events["xpix"] = pix[0, :] + event_params['pix_center'][0]
bkg_events["ypix"] = pix[1, :] + event_params['pix_center'][1]
mylog.info("Scattering energies with RMF %s." %
os.path.split(rmf.filename)[-1])
bkg_events = rmf.scatter_energies(bkg_events, prng=prng)
return bkg_events
def make_diffuse_background(bkg_events, event_params, rmf, prng=None):
from soxs.instrument import perform_dither
n_e = bkg_events["energy"].size
bkg_events['time'] = prng.uniform(size=n_e,
low=0.0,
high=event_params["exposure_time"])
x_offset, y_offset = perform_dither(bkg_events["time"],
event_params["dither_params"])
rot_mat = get_rot_mat(event_params["roll_angle"])
det = np.array([
bkg_events["detx"] + x_offset - event_params["aimpt_coords"][0] -
event_params["aimpt_shift"][0], bkg_events["dety"] + y_offset -
event_params["aimpt_coords"][1] - event_params["aimpt_shift"][1]
])
pix = np.dot(rot_mat.T, det)
bkg_events["xpix"] = pix[0, :] + event_params['pix_center'][0]
bkg_events["ypix"] = pix[1, :] + event_params['pix_center'][1]
return bkg_events
def add_background_from_file(events, event_params, bkg_file):
f = pyfits.open(bkg_file)
hdu = f["EVENTS"]
sexp = event_params["exposure_time"]
bexp = hdu.header["EXPOSURE"]
if event_params["exposure_time"] > hdu.header["EXPOSURE"]:
raise RuntimeError(
"The background file does not have sufficient exposure! Source "
"exposure time %g, background exposure time %g." % (sexp, bexp))
for k1, k2 in key_map.items():
if event_params[k1] != hdu.header[k2]:
raise RuntimeError("'%s' keyword does not match! %s vs. %s" %
(k1, event_params[k1], hdu.header[k2]))
rmf1 = os.path.split(event_params["rmf"])[-1]
rmf2 = hdu.header["RESPFILE"]
arf1 = os.path.split(event_params["arf"])[-1]
arf2 = hdu.header["ANCRFILE"]
if rmf1 != rmf2:
raise RuntimeError("RMFs do not match! %s vs. %s" % (rmf1, rmf2))
if arf1 != arf2:
raise RuntimeError("ARFs do not match! %s vs. %s" % (arf1, arf2))
idxs = hdu.data["TIME"] < sexp
mylog.info("Adding %d background events from %s." % (idxs.sum(), bkg_file))
if event_params["roll_angle"] == hdu.header["ROLL_PNT"]:
xpix = hdu.data["X"][idxs]
ypix = hdu.data["Y"][idxs]
else:
rot_mat = get_rot_mat(event_params["roll_angle"])
xpix, ypix = np.dot(
rot_mat.T,
np.array([hdu.data["DETX"][idxs], hdu.data["DETY"][idxs]]))
xpix += hdu.header["TCRPX2"]
ypix += hdu.header["TCRPX3"]
all_events = {}
for key in [
"detx", "dety", "time", "ccd_id", event_params["channel_type"]
]:
all_events[key] = np.concatenate(
[events[key], hdu.data[key.upper()][idxs]])
all_events["xpix"] = np.concatenate([events["xpix"], xpix])
all_events["ypix"] = np.concatenate([events["ypix"], ypix])
all_events["energy"] = np.concatenate(
[events["energy"], hdu.data["ENERGY"][idxs] / 1000.0])
f.close()
return all_events
def make_diffuse_background(bkg_events, event_params, rmf, prng=None):
from soxs.instrument import perform_dither
n_e = bkg_events["energy"].size
bkg_events['time'] = prng.uniform(size=n_e, low=0.0,
high=event_params["exposure_time"])
x_offset, y_offset = perform_dither(bkg_events["time"],
event_params["dither_params"])
rot_mat = get_rot_mat(event_params["roll_angle"])
det = np.array([bkg_events["detx"] + x_offset - event_params["aimpt_coords"][0],
bkg_events["dety"] + y_offset - event_params["aimpt_coords"][1]])
pix = np.dot(rot_mat.T, det)
bkg_events["xpix"] = pix[0, :] + event_params['pix_center'][0]
bkg_events["ypix"] = pix[1, :] + event_params['pix_center'][1]
mylog.info("Scattering energies with RMF %s." % os.path.split(rmf.filename)[-1])
bkg_events = rmf.scatter_energies(bkg_events, prng=prng)
return bkg_events
def rotate_xy(theta, x, y):
coords = np.dot(get_rot_mat(theta), np.array([x, y]))
return coords
def generate_events(source,
exp_time,
instrument,
sky_center,
no_dither=False,
dither_params=None,
roll_angle=0.0,
subpixel_res=False,
aimpt_shift=None,
prng=None):
"""
Take unconvolved events and convolve them with instrumental responses. This
function does the following:
1. Determines which events are observed using the ARF
2. Pixelizes the events, applying PSF effects and dithering
3. Determines energy channels using the RMF
This function is not meant to be called by the end-user but is used by
the :func:`~soxs.instrument.instrument_simulator` function.
Parameters
----------
input_events : string, dict, or None
The unconvolved events to be used as input. Can be one of the
following:
1. The name of a SIMPUT catalog file.
2. A Python dictionary containing the following items:
"ra": A NumPy array of right ascension values in degrees.
"dec": A NumPy array of declination values in degrees.
"energy": A NumPy array of energy values in keV.
"flux": The flux of the entire source, in units of erg/cm**2/s.
out_file : string
The name of the event file to be written.
exp_time : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`
The exposure time to use, in seconds.
instrument : string
The name of the instrument to use, which picks an instrument
specification from the instrument registry.
sky_center : array, tuple, or list
The center RA, Dec coordinates of the observation, in degrees.
no_dither : boolean, optional
If True, turn off dithering entirely. Default: False
dither_params : array-like of floats, optional
The parameters to use to control the size and period of the dither
pattern. The first two numbers are the dither amplitude in x and y
detector coordinates in arcseconds, and the second two numbers are
the dither period in x and y detector coordinates in seconds.
Default: [8.0, 8.0, 1000.0, 707.0].
roll_angle : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`, optional
The roll angle of the observation in degrees. Default: 0.0
subpixel_res : boolean, optional
If True, event positions are not randomized within the pixels
within which they are detected. Default: False
aimpt_shift : array-like, optional
A two-float array-like object which shifts the aimpoint on the
detector from the nominal position. Units are in arcseconds.
Default: None, which results in no shift from the nominal aimpoint.
prng : :class:`~numpy.random.RandomState` object, integer, or None
A pseudo-random number generator. Typically will only
be specified if you have a reason to generate the same
set of random numbers, such as for a test. Default is None,
which sets the seed based on the system time.
"""
exp_time = parse_value(exp_time, "s")
roll_angle = parse_value(roll_angle, "deg")
prng = parse_prng(prng)
if source is None:
source_list = []
elif isinstance(source, dict):
parameters = {}
for key in ["flux", "emin", "emax", "src_names"]:
parameters[key] = source[key]
source_list = []
for i in range(len(parameters["flux"])):
phlist = SimputPhotonList(source["ra"][i], source["dec"][i],
source["energy"][i],
parameters['flux'][i],
parameters['src_names'][i])
source_list.append(phlist)
elif isinstance(source, str):
# Assume this is a SIMPUT catalog
source_list, parameters = read_simput_catalog(source)
try:
instrument_spec = instrument_registry[instrument]
except KeyError:
raise KeyError(
f"Instrument {instrument} is not in the instrument registry!")
if not instrument_spec["imaging"]:
raise RuntimeError(f"Instrument '{instrument_spec['name']}' is not "
f"designed for imaging observations!")
arf_file = get_data_file(instrument_spec["arf"])
rmf_file = get_data_file(instrument_spec["rmf"])
arf = AuxiliaryResponseFile(arf_file)
rmf = RedistributionMatrixFile(rmf_file)
nx = instrument_spec["num_pixels"]
plate_scale = instrument_spec["fov"] / nx / 60. # arcmin to deg
plate_scale_arcsec = plate_scale * 3600.0
if aimpt_shift is None:
aimpt_shift = np.zeros(2)
aimpt_shift = ensure_numpy_array(aimpt_shift).astype('float64')
aimpt_shift /= plate_scale_arcsec
if not instrument_spec["dither"]:
dither_on = False
else:
dither_on = not no_dither
if dither_params is None:
dither_params = [8.0, 8.0, 1000.0, 707.0]
dither_dict = {
"x_amp": dither_params[0],
"y_amp": dither_params[1],
"x_period": dither_params[2],
"y_period": dither_params[3],
"dither_on": dither_on,
"plate_scale": plate_scale_arcsec
}
event_params = {
"exposure_time": exp_time,
"arf": arf.filename,
"sky_center": sky_center,
"pix_center": np.array([0.5 * (2 * nx + 1)] * 2),
"num_pixels": nx,
"plate_scale": plate_scale,
"rmf": rmf.filename,
"channel_type": rmf.chan_type,
"telescope": rmf.header["TELESCOP"],
"instrument": instrument_spec['name'],
"mission": rmf.header.get("MISSION", ""),
"nchan": rmf.n_ch,
"roll_angle": roll_angle,
"fov": instrument_spec["fov"],
"chan_lim": [rmf.cmin, rmf.cmax],
"chips": instrument_spec["chips"],
"dither_params": dither_dict,
"aimpt_coords": instrument_spec["aimpt_coords"],
"aimpt_shift": aimpt_shift
}
# Set up WCS
w = pywcs.WCS(naxis=2)
w.wcs.crval = event_params["sky_center"]
w.wcs.crpix = event_params["pix_center"]
w.wcs.cdelt = [-plate_scale, plate_scale]
w.wcs.ctype = ["RA---TAN", "DEC--TAN"]
w.wcs.cunit = ["deg"] * 2
# Determine rotation matrix
rot_mat = get_rot_mat(roll_angle)
# Set up PSF
psf_type = instrument_spec["psf"][0]
psf_class = psf_model_registry[psf_type]
psf = psf_class(instrument_spec, prng=prng)
all_events = defaultdict(list)
for i, src in enumerate(source_list):
mylog.info(
f"Detecting events from source {parameters['src_names'][i]}")
# Step 1: Use ARF to determine which photons are observed
mylog.info(f"Applying energy-dependent effective area from "
f"{os.path.split(arf.filename)[-1]}.")
refband = [parameters["emin"][i], parameters["emax"][i]]
if src.src_type == "phlist":
events = arf.detect_events_phlist(src.events.copy(),
exp_time,
parameters["flux"][i],
refband,
prng=prng)
elif src.src_type.endswith("spectrum"):
events = arf.detect_events_spec(src, exp_time, refband, prng=prng)
n_evt = events["energy"].size
if n_evt == 0:
mylog.warning("No events were observed for this source!!!")
else:
# Step 2: Assign pixel coordinates to events. Apply dithering and
# PSF. Clip events that don't fall within the detection region.
mylog.info("Pixeling events.")
# Convert RA, Dec to pixel coordinates
xpix, ypix = w.wcs_world2pix(events["ra"], events["dec"], 1)
xpix -= event_params["pix_center"][0]
ypix -= event_params["pix_center"][1]
events.pop("ra")
events.pop("dec")
n_evt = xpix.size
# Rotate physical coordinates to detector coordinates
det = np.dot(rot_mat, np.array([xpix, ypix]))
detx = det[0, :] + event_params["aimpt_coords"][0] + aimpt_shift[0]
dety = det[1, :] + event_params["aimpt_coords"][1] + aimpt_shift[1]
# Add times to events
events['time'] = prng.uniform(size=n_evt,
low=0.0,
high=event_params["exposure_time"])
# Apply dithering
x_offset, y_offset = perform_dither(events["time"], dither_dict)
detx -= x_offset
dety -= y_offset
# PSF scattering of detector coordinates
mylog.info(f"Scattering events with a {psf}-based PSF.")
detx, dety = psf.scatter(detx, dety, events["energy"])
# Convert detector coordinates to chip coordinates.
# Throw out events that don't fall on any chip.
cx = np.trunc(detx) + 0.5 * np.sign(detx)
cy = np.trunc(dety) + 0.5 * np.sign(dety)
events["chip_id"] = -np.ones(n_evt, dtype='int')
for i, chip in enumerate(event_params["chips"]):
rtype = chip[0]
args = chip[1:]
r, _ = create_region(rtype, args, 0.0, 0.0)
inside = r.contains(PixCoord(cx, cy))
events["chip_id"][inside] = i
keep = events["chip_id"] > -1
mylog.info(f"{n_evt-keep.sum()} events were rejected because "
f"they do not fall on any CCD.")
n_evt = keep.sum()
if n_evt == 0:
mylog.warning("No events are within the field "
"of view for this source!!!")
else:
# Keep only those events which fall on a chip
for key in events:
events[key] = events[key][keep]
# Convert chip coordinates back to detector coordinates,
# unless the user has specified that they want subpixel
# resolution
if subpixel_res:
events["detx"] = detx[keep]
events["dety"] = dety[keep]
else:
events["detx"] = cx[keep] + \
prng.uniform(low=-0.5, high=0.5, size=n_evt)
events["dety"] = cy[keep] + \
prng.uniform(low=-0.5, high=0.5, size=n_evt)
# Convert detector coordinates back to pixel coordinates by
# adding the dither offsets back in and applying the rotation
# matrix again
det = np.array([
events["detx"] + x_offset[keep] -
event_params["aimpt_coords"][0] - aimpt_shift[0],
events["dety"] + y_offset[keep] -
event_params["aimpt_coords"][1] - aimpt_shift[1]
])
pix = np.dot(rot_mat.T, det)
events["xpix"] = pix[0, :] + event_params['pix_center'][0]
events["ypix"] = pix[1, :] + event_params['pix_center'][1]
if n_evt > 0:
for key in events:
all_events[key] = np.concatenate(
[all_events[key], events[key]])
if len(all_events["energy"]) == 0:
mylog.warning("No events from any of the sources in "
"the catalog were detected!")
for key in [
"xpix", "ypix", "detx", "dety", "time", "chip_id",
event_params["channel_type"]
]:
all_events[key] = np.array([])
else:
# Step 4: Scatter energies with RMF
mylog.info(f"Scattering energies with "
f"RMF {os.path.split(rmf.filename)[-1]}.")
all_events = rmf.scatter_energies(all_events, prng=prng)
return all_events, event_params
def generate_events(input_events, exp_time, instrument, sky_center,
no_dither=False, dither_params=None,
roll_angle=0.0, subpixel_res=False, prng=None):
"""
Take unconvolved events and convolve them with instrumental responses. This
function does the following:
1. Determines which events are observed using the ARF
2. Pixelizes the events, applying PSF effects and dithering
3. Determines energy channels using the RMF
This function is not meant to be called by the end-user but is used by
the :func:`~soxs.instrument.instrument_simulator` function.
Parameters
----------
input_events : string, dict, or None
The unconvolved events to be used as input. Can be one of the
following:
1. The name of a SIMPUT catalog file.
2. A Python dictionary containing the following items:
"ra": A NumPy array of right ascension values in degrees.
"dec": A NumPy array of declination values in degrees.
"energy": A NumPy array of energy values in keV.
"flux": The flux of the entire source, in units of erg/cm**2/s.
out_file : string
The name of the event file to be written.
exp_time : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`
The exposure time to use, in seconds.
instrument : string
The name of the instrument to use, which picks an instrument
specification from the instrument registry.
sky_center : array, tuple, or list
The center RA, Dec coordinates of the observation, in degrees.
no_dither : boolean, optional
If True, turn off dithering entirely. Default: False
dither_params : array-like of floats, optional
The parameters to use to control the size and period of the dither
pattern. The first two numbers are the dither amplitude in x and y
detector coordinates in arcseconds, and the second two numbers are
the dither period in x and y detector coordinates in seconds.
Default: [8.0, 8.0, 1000.0, 707.0].
roll_angle : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`, optional
The roll angle of the observation in degrees. Default: 0.0
subpixel_res: boolean, optional
If True, event positions are not randomized within the pixels
within which they are detected. Default: False
prng : :class:`~numpy.random.RandomState` object, integer, or None
A pseudo-random number generator. Typically will only
be specified if you have a reason to generate the same
set of random numbers, such as for a test. Default is None,
which sets the seed based on the system time.
"""
import pyregion._region_filter as rfilter
exp_time = parse_value(exp_time, "s")
roll_angle = parse_value(roll_angle, "deg")
prng = parse_prng(prng)
if isinstance(input_events, dict):
parameters = {}
for key in ["flux", "emin", "emax", "sources"]:
parameters[key] = input_events[key]
event_list = []
for i in range(len(parameters["flux"])):
edict = {}
for key in ["ra", "dec", "energy"]:
edict[key] = input_events[key][i]
event_list.append(edict)
elif isinstance(input_events, string_types):
# Assume this is a SIMPUT catalog
event_list, parameters = read_simput_catalog(input_events)
try:
instrument_spec = instrument_registry[instrument]
except KeyError:
raise KeyError("Instrument %s is not in the instrument registry!" % instrument)
if not instrument_spec["imaging"]:
raise RuntimeError("Instrument '%s' is not " % instrument_spec["name"] +
"designed for imaging observations!")
arf_file = get_response_path(instrument_spec["arf"])
rmf_file = get_response_path(instrument_spec["rmf"])
arf = AuxiliaryResponseFile(arf_file)
rmf = RedistributionMatrixFile(rmf_file)
nx = instrument_spec["num_pixels"]
plate_scale = instrument_spec["fov"]/nx/60. # arcmin to deg
plate_scale_arcsec = plate_scale * 3600.0
if not instrument_spec["dither"]:
dither_on = False
else:
dither_on = not no_dither
if dither_params is None:
dither_params = [8.0, 8.0, 1000.0, 707.0]
dither_dict = {"x_amp": dither_params[0],
"y_amp": dither_params[1],
"x_period": dither_params[2],
"y_period": dither_params[3],
"dither_on": dither_on,
"plate_scale": plate_scale_arcsec}
event_params = {}
event_params["exposure_time"] = exp_time
event_params["arf"] = arf.filename
event_params["sky_center"] = sky_center
event_params["pix_center"] = np.array([0.5*(2*nx+1)]*2)
event_params["num_pixels"] = nx
event_params["plate_scale"] = plate_scale
event_params["rmf"] = rmf.filename
event_params["channel_type"] = rmf.header["CHANTYPE"]
event_params["telescope"] = rmf.header["TELESCOP"]
event_params["instrument"] = instrument_spec['name']
event_params["mission"] = rmf.header.get("MISSION", "")
event_params["nchan"] = rmf.n_ch
event_params["roll_angle"] = roll_angle
event_params["fov"] = instrument_spec["fov"]
event_params["chan_lim"] = [rmf.cmin, rmf.cmax]
event_params["chips"] = instrument_spec["chips"]
event_params["dither_params"] = dither_dict
event_params["aimpt_coords"] = instrument_spec["aimpt_coords"]
w = pywcs.WCS(naxis=2)
w.wcs.crval = event_params["sky_center"]
w.wcs.crpix = event_params["pix_center"]
w.wcs.cdelt = [-plate_scale, plate_scale]
w.wcs.ctype = ["RA---TAN","DEC--TAN"]
w.wcs.cunit = ["deg"]*2
rot_mat = get_rot_mat(roll_angle)
all_events = defaultdict(list)
for i, evts in enumerate(event_list):
mylog.info("Detecting events from source %s." % parameters["sources"][i])
# Step 1: Use ARF to determine which photons are observed
mylog.info("Applying energy-dependent effective area from %s." % os.path.split(arf.filename)[-1])
refband = [parameters["emin"][i], parameters["emax"][i]]
events = arf.detect_events(evts, exp_time, parameters["flux"][i], refband, prng=prng)
n_evt = events["energy"].size
if n_evt == 0:
mylog.warning("No events were observed for this source!!!")
else:
# Step 2: Assign pixel coordinates to events. Apply dithering and
# PSF. Clip events that don't fall within the detection region.
mylog.info("Pixeling events.")
# Convert RA, Dec to pixel coordinates
xpix, ypix = w.wcs_world2pix(events["ra"], events["dec"], 1)
xpix -= event_params["pix_center"][0]
ypix -= event_params["pix_center"][1]
events.pop("ra")
events.pop("dec")
n_evt = xpix.size
# Rotate physical coordinates to detector coordinates
det = np.dot(rot_mat, np.array([xpix, ypix]))
detx = det[0,:] + event_params["aimpt_coords"][0]
dety = det[1,:] + event_params["aimpt_coords"][1]
# Add times to events
events['time'] = prng.uniform(size=n_evt, low=0.0,
high=event_params["exposure_time"])
# Apply dithering
x_offset, y_offset = perform_dither(events["time"], dither_dict)
detx -= x_offset
dety -= y_offset
# PSF scattering of detector coordinates
if instrument_spec["psf"] is not None:
psf_type, psf_spec = instrument_spec["psf"]
if psf_type == "gaussian":
sigma = psf_spec/sigma_to_fwhm/plate_scale_arcsec
detx += prng.normal(loc=0.0, scale=sigma, size=n_evt)
dety += prng.normal(loc=0.0, scale=sigma, size=n_evt)
else:
raise NotImplementedError("PSF type %s not implemented!" % psf_type)
# Convert detector coordinates to chip coordinates.
# Throw out events that don't fall on any chip.
cx = np.trunc(detx)+0.5*np.sign(detx)
cy = np.trunc(dety)+0.5*np.sign(dety)
if event_params["chips"] is None:
events["chip_id"] = np.zeros(n_evt, dtype='int')
keepx = np.logical_and(cx >= -0.5*nx, cx <= 0.5*nx)
keepy = np.logical_and(cy >= -0.5*nx, cy <= 0.5*nx)
keep = np.logical_and(keepx, keepy)
else:
events["chip_id"] = -np.ones(n_evt, dtype='int')
for i, chip in enumerate(event_params["chips"]):
thisc = np.ones(n_evt, dtype='bool')
rtype = chip[0]
args = chip[1:]
r = getattr(rfilter, rtype)(*args)
inside = r.inside(cx, cy)
thisc = np.logical_and(thisc, inside)
events["chip_id"][thisc] = i
keep = events["chip_id"] > -1
mylog.info("%d events were rejected because " % (n_evt-keep.sum()) +
"they do not fall on any CCD.")
n_evt = keep.sum()
if n_evt == 0:
mylog.warning("No events are within the field of view for this source!!!")
else:
# Keep only those events which fall on a chip
for key in events:
events[key] = events[key][keep]
# Convert chip coordinates back to detector coordinates, unless the
# user has specified that they want subpixel resolution
if subpixel_res:
events["detx"] = detx[keep]
events["dety"] = dety[keep]
else:
events["detx"] = cx[keep] + prng.uniform(low=-0.5, high=0.5, size=n_evt)
events["dety"] = cy[keep] + prng.uniform(low=-0.5, high=0.5, size=n_evt)
# Convert detector coordinates back to pixel coordinates by
# adding the dither offsets back in and applying the rotation
# matrix again
det = np.array([events["detx"] + x_offset[keep] - event_params["aimpt_coords"][0],
events["dety"] + y_offset[keep] - event_params["aimpt_coords"][1]])
pix = np.dot(rot_mat.T, det)
events["xpix"] = pix[0,:] + event_params['pix_center'][0]
events["ypix"] = pix[1,:] + event_params['pix_center'][1]
if n_evt > 0:
for key in events:
all_events[key] = np.concatenate([all_events[key], events[key]])
if len(all_events["energy"]) == 0:
mylog.warning("No events from any of the sources in the catalog were detected!")
for key in ["xpix", "ypix", "detx", "dety", "time", "chip_id", event_params["channel_type"]]:
all_events[key] = np.array([])
else:
# Step 4: Scatter energies with RMF
mylog.info("Scattering energies with RMF %s." % os.path.split(rmf.filename)[-1])
all_events = rmf.scatter_energies(all_events, prng=prng)
return all_events, event_params
def add_background_from_file(events, event_params, bkg_file):
from soxs.instrument import perform_dither
f = pyfits.open(bkg_file)
hdu = f["EVENTS"]
dither_params = {}
if "DITHXAMP" in hdu.header:
dither_params["x_amp"] = hdu.header["DITHXAMP"]
dither_params["y_amp"] = hdu.header["DITHYAMP"]
dither_params["x_period"] = hdu.header["DITHXPER"]
dither_params["y_period"] = hdu.header["DITHYPER"]
dither_params["plate_scale"] = hdu.header["TCDLT3"] * 3600.0
dither_params["dither_on"] = True
else:
dither_params["dither_on"] = False
sexp = event_params["exposure_time"]
bexp = hdu.header["EXPOSURE"]
if event_params["exposure_time"] > hdu.header["EXPOSURE"]:
raise RuntimeError(
"The background file does not have sufficient exposure! Source "
"exposure time %g, background exposure time %g." % (sexp, bexp))
for k1, k2 in key_map.items():
if event_params[k1] != hdu.header[k2]:
raise RuntimeError("'%s' keyword does not match! %s vs. %s" %
(k1, event_params[k1], hdu.header[k2]))
rmf1 = os.path.split(event_params["rmf"])[-1]
rmf2 = hdu.header["RESPFILE"]
arf1 = os.path.split(event_params["arf"])[-1]
arf2 = hdu.header["ANCRFILE"]
if rmf1 != rmf2:
raise RuntimeError("RMFs do not match! %s vs. %s" % (rmf1, rmf2))
if arf1 != arf2:
raise RuntimeError("ARFs do not match! %s vs. %s" % (arf1, arf2))
idxs = hdu.data["TIME"] < sexp
mylog.info("Adding %d background events from %s." % (idxs.sum(), bkg_file))
if event_params["roll_angle"] == hdu.header["ROLL_PNT"]:
xpix = hdu.data["X"][idxs]
ypix = hdu.data["Y"][idxs]
else:
rot_mat = get_rot_mat(event_params["roll_angle"])
if dither_params["dither_on"]:
t = hdu.data["TIME"][idxs]
x_off, y_off = perform_dither(t, dither_params)
else:
x_off = 0.0
y_off = 0.0
det = np.array([
hdu.data["DETX"][idxs] + x_off - event_params["aimpt_coords"][0],
hdu.data["DETY"][idxs] + y_off - event_params["aimpt_coords"][1]
])
xpix, ypix = np.dot(rot_mat.T, det)
xpix += hdu.header["TCRPX2"]
ypix += hdu.header["TCRPX3"]
all_events = {}
for key in [
"detx", "dety", "time", "ccd_id", event_params["channel_type"]
]:
all_events[key] = np.concatenate(
[events[key], hdu.data[key.upper()][idxs]])
all_events["xpix"] = np.concatenate([events["xpix"], xpix])
all_events["ypix"] = np.concatenate([events["ypix"], ypix])
all_events["energy"] = np.concatenate(
[events["energy"], hdu.data["ENERGY"][idxs] / 1000.0])
f.close()
return all_events
def make_exposure_map(event_file,
expmap_file,
energy,
weights=None,
asol_file=None,
normalize=True,
overwrite=False,
nhistx=16,
nhisty=16):
"""
Make an exposure map for a SOXS event file, and optionally write
an aspect solution file. The exposure map will be created by
binning an aspect histogram over the range of the aspect solution.
Parameters
----------
event_file : string
The path to the event file to use for making the exposure map.
expmap_file : string
The path to write the exposure map file to.
energy : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`, or NumPy array
The energy in keV to use when computing the exposure map, or
a set of energies to be used with the *weights* parameter. If
providing a set, it must be in keV.
weights : array-like, optional
The weights to use with a set of energies given in the
*energy* parameter. Used to create a more accurate exposure
map weighted by a range of energies. Default: None
asol_file : string, optional
The path to write the aspect solution file to, if desired.
Default: None
normalize : boolean, optional
If True, the exposure map will be divided by the exposure time
so that the map's units are cm**2. Default: True
overwrite : boolean, optional
Whether or not to overwrite an existing file. Default: False
nhistx : integer, optional
The number of bins in the aspect histogram in the DETX
direction. Default: 16
nhisty : integer, optional
The number of bins in the aspect histogram in the DETY
direction. Default: 16
"""
import pyregion._region_filter as rfilter
from scipy.ndimage.interpolation import rotate, shift
from soxs.instrument import AuxiliaryResponseFile, perform_dither
if isinstance(energy, np.ndarray) and weights is None:
raise RuntimeError("Must supply a single value for the energy if "
"you do not supply weights!")
if not isinstance(energy, np.ndarray):
energy = parse_value(energy, "keV")
f_evt = pyfits.open(event_file)
hdu = f_evt["EVENTS"]
arf = AuxiliaryResponseFile(hdu.header["ANCRFILE"])
exp_time = hdu.header["EXPOSURE"]
nx = int(hdu.header["TLMAX2"] - 0.5) // 2
ny = int(hdu.header["TLMAX3"] - 0.5) // 2
ra0 = hdu.header["TCRVL2"]
dec0 = hdu.header["TCRVL3"]
xdel = hdu.header["TCDLT2"]
ydel = hdu.header["TCDLT3"]
x0 = hdu.header["TCRPX2"]
y0 = hdu.header["TCRPX3"]
xdet0 = 0.5 * (2 * nx + 1)
ydet0 = 0.5 * (2 * ny + 1)
xaim = hdu.header.get("AIMPT_X", 0.0)
yaim = hdu.header.get("AIMPT_Y", 0.0)
roll = hdu.header["ROLL_PNT"]
instr = instrument_registry[hdu.header["INSTRUME"].lower()]
dither_params = {}
if "DITHXAMP" in hdu.header:
dither_params["x_amp"] = hdu.header["DITHXAMP"]
dither_params["y_amp"] = hdu.header["DITHYAMP"]
dither_params["x_period"] = hdu.header["DITHXPER"]
dither_params["y_period"] = hdu.header["DITHYPER"]
dither_params["plate_scale"] = ydel * 3600.0
dither_params["dither_on"] = True
else:
dither_params["dither_on"] = False
f_evt.close()
# Create time array for aspect solution
dt = 1.0 # Seconds
t = np.arange(0.0, exp_time + dt, dt)
# Construct WCS
w = pywcs.WCS(naxis=2)
w.wcs.crval = [ra0, dec0]
w.wcs.crpix = [x0, y0]
w.wcs.cdelt = [xdel, ydel]
w.wcs.ctype = ["RA---TAN", "DEC--TAN"]
w.wcs.cunit = ["deg"] * 2
# Create aspect solution if we had dithering.
# otherwise just set the offsets to zero
if dither_params["dither_on"]:
x_off, y_off = perform_dither(t, dither_params)
# Make the aspect histogram
x_amp = dither_params["x_amp"] / dither_params["plate_scale"]
y_amp = dither_params["y_amp"] / dither_params["plate_scale"]
x_edges = np.linspace(-x_amp, x_amp, nhistx + 1, endpoint=True)
y_edges = np.linspace(-y_amp, y_amp, nhisty + 1, endpoint=True)
asphist = np.histogram2d(x_off, y_off, (x_edges, y_edges))[0]
asphist *= dt
x_mid = 0.5 * (x_edges[1:] + x_edges[:-1])
y_mid = 0.5 * (y_edges[1:] + y_edges[:-1])
# Determine the effective area
eff_area = arf.interpolate_area(energy).value
if weights is not None:
eff_area = np.average(eff_area, weights=weights)
if instr["chips"] is None:
rtypes = ["Box"]
args = [[0.0, 0.0, instr["num_pixels"], instr["num_pixels"]]]
else:
rtypes = []
args = []
for i, chip in enumerate(instr["chips"]):
rtypes.append(chip[0])
args.append(np.array(chip[1:]))
tmpmap = np.zeros((2 * nx, 2 * ny))
for rtype, arg in zip(rtypes, args):
rfunc = getattr(rfilter, rtype)
new_args = parse_region_args(rtype, arg, xdet0 - xaim - 1.0,
ydet0 - yaim - 1.0)
r = rfunc(*new_args)
tmpmap += r.mask(tmpmap).astype("float64")
if dither_params["dither_on"]:
expmap = np.zeros((2 * nx, 2 * ny))
niter = nhistx * nhisty
pbar = tqdm(leave=True, total=niter, desc="Creating exposure map ")
for i in range(nhistx):
for j in range(nhisty):
expmap += shift(tmpmap,
(x_mid[i], y_mid[j]), order=0) * asphist[i, j]
pbar.update(nhisty)
pbar.close()
else:
expmap = tmpmap * exp_time
expmap *= eff_area
if normalize:
expmap /= exp_time
if roll != 0.0:
rotate(expmap, roll, output=expmap, reshape=False)
map_header = {
"EXPOSURE": exp_time,
"MTYPE1": "EQPOS",
"MFORM1": "RA,DEC",
"CTYPE1": "RA---TAN",
"CTYPE2": "DEC--TAN",
"CRVAL1": ra0,
"CRVAL2": dec0,
"CUNIT1": "deg",
"CUNIT2": "deg",
"CDELT1": xdel,
"CDELT2": ydel,
"CRPIX1": x0,
"CRPIX2": y0
}
map_hdu = pyfits.ImageHDU(expmap, header=pyfits.Header(map_header))
map_hdu.name = "EXPMAP"
map_hdu.writeto(expmap_file, overwrite=overwrite)
if asol_file is not None:
if dither_params["dither_on"]:
det = np.array([x_off, y_off])
pix = np.dot(get_rot_mat(roll).T, det)
ra, dec = w.wcs_pix2world(pix[0, :] + x0, pix[1, :] + y0, 1)
col_t = pyfits.Column(name='time', format='D', unit='s', array=t)
col_ra = pyfits.Column(name='ra', format='D', unit='deg', array=ra)
col_dec = pyfits.Column(name='dec',
format='D',
unit='deg',
array=dec)
coldefs = pyfits.ColDefs([col_t, col_ra, col_dec])
tbhdu = pyfits.BinTableHDU.from_columns(coldefs)
tbhdu.name = "ASPSOL"
tbhdu.header["EXPOSURE"] = exp_time
hdulist = [pyfits.PrimaryHDU(), tbhdu]
pyfits.HDUList(hdulist).writeto(asol_file, overwrite=overwrite)
else:
mylog.warning("Refusing to write an aspect solution file because "
"there was no dithering.")
def add_background_from_file(events, event_params, bkg_file):
from soxs.instrument import perform_dither
f = pyfits.open(bkg_file)
hdu = f["EVENTS"]
dither_params = {}
if "DITHXAMP" in hdu.header:
dither_params["x_amp"] = hdu.header["DITHXAMP"]
dither_params["y_amp"] = hdu.header["DITHYAMP"]
dither_params["x_period"] = hdu.header["DITHXPER"]
dither_params["y_period"] = hdu.header["DITHYPER"]
dither_params["plate_scale"] = hdu.header["TCDLT3"]*3600.0
dither_params["dither_on"] = True
else:
dither_params["dither_on"] = False
sexp = event_params["exposure_time"]
bexp = hdu.header["EXPOSURE"]
if event_params["exposure_time"] > hdu.header["EXPOSURE"]:
raise RuntimeError("The background file does not have sufficient exposure! Source "
"exposure time %g, background exposure time %g." % (sexp, bexp))
for k1, k2 in key_map.items():
if event_params[k1] != hdu.header[k2]:
raise RuntimeError("'%s' keyword does not match! %s vs. %s" % (k1, event_params[k1],
hdu.header[k2]))
rmf1 = os.path.split(event_params["rmf"])[-1]
rmf2 = hdu.header["RESPFILE"]
arf1 = os.path.split(event_params["arf"])[-1]
arf2 = hdu.header["ANCRFILE"]
if rmf1 != rmf2:
raise RuntimeError("RMFs do not match! %s vs. %s" % (rmf1, rmf2))
if arf1 != arf2:
raise RuntimeError("ARFs do not match! %s vs. %s" % (arf1, arf2))
idxs = hdu.data["TIME"] < sexp
mylog.info("Adding %d background events from %s." % (idxs.sum(), bkg_file))
if event_params["roll_angle"] == hdu.header["ROLL_PNT"]:
xpix = hdu.data["X"][idxs]
ypix = hdu.data["Y"][idxs]
else:
rot_mat = get_rot_mat(event_params["roll_angle"])
if dither_params["dither_on"]:
t = hdu.data["TIME"][idxs]
x_off, y_off = perform_dither(t, dither_params)
else:
x_off = 0.0
y_off = 0.0
det = np.array([hdu.data["DETX"][idxs] + x_off - event_params["aimpt_coords"][0],
hdu.data["DETY"][idxs] + y_off - event_params["aimpt_coords"][1]])
xpix, ypix = np.dot(rot_mat.T, det)
xpix += hdu.header["TCRPX2"]
ypix += hdu.header["TCRPX3"]
all_events = {}
for key in ["detx", "dety", "time", "ccd_id", event_params["channel_type"]]:
all_events[key] = np.concatenate([events[key], hdu.data[key.upper()][idxs]])
all_events["xpix"] = np.concatenate([events["xpix"], xpix])
all_events["ypix"] = np.concatenate([events["ypix"], ypix])
all_events["energy"] = np.concatenate([events["energy"], hdu.data["ENERGY"][idxs]/1000.0])
f.close()
return all_events
def generate_events(input_events, exp_time, instrument, sky_center,
no_dither=False, dither_params=None,
roll_angle=0.0, subpixel_res=False, prng=None):
"""
Take unconvolved events and convolve them with instrumental responses. This
function does the following:
1. Determines which events are observed using the ARF
2. Pixelizes the events, applying PSF effects and dithering
3. Determines energy channels using the RMF
This function is not meant to be called by the end-user but is used by
the :func:`~soxs.instrument.instrument_simulator` function.
Parameters
----------
input_events : string, dict, or None
The unconvolved events to be used as input. Can be one of the
following:
1. The name of a SIMPUT catalog file.
2. A Python dictionary containing the following items:
"ra": A NumPy array of right ascension values in degrees.
"dec": A NumPy array of declination values in degrees.
"energy": A NumPy array of energy values in keV.
"flux": The flux of the entire source, in units of erg/cm**2/s.
out_file : string
The name of the event file to be written.
exp_time : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`
The exposure time to use, in seconds.
instrument : string
The name of the instrument to use, which picks an instrument
specification from the instrument registry.
sky_center : array, tuple, or list
The center RA, Dec coordinates of the observation, in degrees.
no_dither : boolean, optional
If True, turn off dithering entirely. Default: False
dither_params : array-like of floats, optional
The parameters to use to control the size and period of the dither
pattern. The first two numbers are the dither amplitude in x and y
detector coordinates in arcseconds, and the second two numbers are
the dither period in x and y detector coordinates in seconds.
Default: [8.0, 8.0, 1000.0, 707.0].
roll_angle : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`, optional
The roll angle of the observation in degrees. Default: 0.0
subpixel_res: boolean, optional
If True, event positions are not randomized within the pixels
within which they are detected. Default: False
prng : :class:`~numpy.random.RandomState` object, integer, or None
A pseudo-random number generator. Typically will only
be specified if you have a reason to generate the same
set of random numbers, such as for a test. Default is None,
which sets the seed based on the system time.
"""
import pyregion._region_filter as rfilter
exp_time = parse_value(exp_time, "s")
roll_angle = parse_value(roll_angle, "deg")
prng = parse_prng(prng)
if isinstance(input_events, dict):
parameters = {}
for key in ["flux", "emin", "emax", "sources"]:
parameters[key] = input_events[key]
event_list = []
for i in range(len(parameters["flux"])):
edict = {}
for key in ["ra", "dec", "energy"]:
edict[key] = input_events[key][i]
event_list.append(edict)
elif isinstance(input_events, string_types):
# Assume this is a SIMPUT catalog
event_list, parameters = read_simput_catalog(input_events)
try:
instrument_spec = instrument_registry[instrument]
except KeyError:
raise KeyError("Instrument %s is not in the instrument registry!" % instrument)
if not instrument_spec["imaging"]:
raise RuntimeError("Instrument '%s' is not " % instrument_spec["name"] +
"designed for imaging observations!")
arf_file = get_response_path(instrument_spec["arf"])
rmf_file = get_response_path(instrument_spec["rmf"])
arf = AuxiliaryResponseFile(arf_file)
rmf = RedistributionMatrixFile(rmf_file)
nx = instrument_spec["num_pixels"]
plate_scale = instrument_spec["fov"]/nx/60. # arcmin to deg
plate_scale_arcsec = plate_scale * 3600.0
if not instrument_spec["dither"]:
dither_on = False
else:
dither_on = not no_dither
if dither_params is None:
dither_params = [8.0, 8.0, 1000.0, 707.0]
dither_dict = {"x_amp": dither_params[0],
"y_amp": dither_params[1],
"x_period": dither_params[2],
"y_period": dither_params[3],
"dither_on": dither_on,
"plate_scale": plate_scale_arcsec}
event_params = {}
event_params["exposure_time"] = exp_time
event_params["arf"] = arf.filename
event_params["sky_center"] = sky_center
event_params["pix_center"] = np.array([0.5*(2*nx+1)]*2)
event_params["num_pixels"] = nx
event_params["plate_scale"] = plate_scale
event_params["rmf"] = rmf.filename
event_params["channel_type"] = rmf.header["CHANTYPE"]
event_params["telescope"] = rmf.header["TELESCOP"]
event_params["instrument"] = instrument_spec['name']
event_params["mission"] = rmf.header.get("MISSION", "")
event_params["nchan"] = rmf.n_ch
event_params["roll_angle"] = roll_angle
event_params["fov"] = instrument_spec["fov"]
event_params["chan_lim"] = [rmf.cmin, rmf.cmax]
event_params["chips"] = instrument_spec["chips"]
event_params["dither_params"] = dither_dict
event_params["aimpt_coords"] = instrument_spec["aimpt_coords"]
w = pywcs.WCS(naxis=2)
w.wcs.crval = event_params["sky_center"]
w.wcs.crpix = event_params["pix_center"]
w.wcs.cdelt = [-plate_scale, plate_scale]
w.wcs.ctype = ["RA---TAN","DEC--TAN"]
w.wcs.cunit = ["deg"]*2
rot_mat = get_rot_mat(roll_angle)
all_events = defaultdict(list)
for i, evts in enumerate(event_list):
mylog.info("Detecting events from source %s." % parameters["sources"][i])
# Step 1: Use ARF to determine which photons are observed
mylog.info("Applying energy-dependent effective area from %s." % os.path.split(arf.filename)[-1])
refband = [parameters["emin"][i], parameters["emax"][i]]
events = arf.detect_events(evts, exp_time, parameters["flux"][i], refband, prng=prng)
n_evt = events["energy"].size
if n_evt == 0:
mylog.warning("No events were observed for this source!!!")
else:
# Step 2: Assign pixel coordinates to events. Apply dithering and
# PSF. Clip events that don't fall within the detection region.
mylog.info("Pixeling events.")
# Convert RA, Dec to pixel coordinates
xpix, ypix = w.wcs_world2pix(events["ra"], events["dec"], 1)
xpix -= event_params["pix_center"][0]
ypix -= event_params["pix_center"][1]
events.pop("ra")
events.pop("dec")
n_evt = xpix.size
# Rotate physical coordinates to detector coordinates
det = np.dot(rot_mat, np.array([xpix, ypix]))
detx = det[0,:] + event_params["aimpt_coords"][0]
dety = det[1,:] + event_params["aimpt_coords"][1]
# Add times to events
events['time'] = prng.uniform(size=n_evt, low=0.0,
high=event_params["exposure_time"])
# Apply dithering
x_offset, y_offset = perform_dither(events["time"], dither_dict)
detx -= x_offset
dety -= y_offset
# PSF scattering of detector coordinates
if instrument_spec["psf"] is not None:
psf_type, psf_spec = instrument_spec["psf"]
if psf_type == "gaussian":
sigma = psf_spec/sigma_to_fwhm/plate_scale_arcsec
detx += prng.normal(loc=0.0, scale=sigma, size=n_evt)
dety += prng.normal(loc=0.0, scale=sigma, size=n_evt)
else:
raise NotImplementedError("PSF type %s not implemented!" % psf_type)
# Convert detector coordinates to chip coordinates.
# Throw out events that don't fall on any chip.
cx = np.trunc(detx)+0.5*np.sign(detx)
cy = np.trunc(dety)+0.5*np.sign(dety)
if event_params["chips"] is None:
events["chip_id"] = np.zeros(n_evt, dtype='int')
keepx = np.logical_and(cx >= -0.5*nx, cx <= 0.5*nx)
keepy = np.logical_and(cy >= -0.5*nx, cy <= 0.5*nx)
keep = np.logical_and(keepx, keepy)
else:
events["chip_id"] = -np.ones(n_evt, dtype='int')
for i, chip in enumerate(event_params["chips"]):
thisc = np.ones(n_evt, dtype='bool')
rtype = chip[0]
args = chip[1:]
r = getattr(rfilter, rtype)(*args)
inside = r.inside(cx, cy)
thisc = np.logical_and(thisc, inside)
events["chip_id"][thisc] = i
keep = events["chip_id"] > -1
mylog.info("%d events were rejected because " % (n_evt-keep.sum()) +
"they do not fall on any CCD.")
n_evt = keep.sum()
if n_evt == 0:
mylog.warning("No events are within the field of view for this source!!!")
else:
# Keep only those events which fall on a chip
for key in events:
events[key] = events[key][keep]
# Convert chip coordinates back to detector coordinates, unless the
# user has specified that they want subpixel resolution
if subpixel_res:
events["detx"] = detx[keep]
events["dety"] = dety[keep]
else:
events["detx"] = cx[keep] + prng.uniform(low=-0.5, high=0.5, size=n_evt)
events["dety"] = cy[keep] + prng.uniform(low=-0.5, high=0.5, size=n_evt)
# Convert detector coordinates back to pixel coordinates by
# adding the dither offsets back in and applying the rotation
# matrix again
det = np.array([events["detx"] + x_offset[keep] - event_params["aimpt_coords"][0],
events["dety"] + y_offset[keep] - event_params["aimpt_coords"][1]])
pix = np.dot(rot_mat.T, det)
events["xpix"] = pix[0,:] + event_params['pix_center'][0]
events["ypix"] = pix[1,:] + event_params['pix_center'][1]
if n_evt > 0:
for key in events:
all_events[key] = np.concatenate([all_events[key], events[key]])
if len(all_events["energy"]) == 0:
mylog.warning("No events from any of the sources in the catalog were detected!")
for key in ["xpix", "ypix", "detx", "dety", "time", "chip_id", event_params["channel_type"]]:
all_events[key] = np.array([])
else:
# Step 4: Scatter energies with RMF
mylog.info("Scattering energies with RMF %s." % os.path.split(rmf.filename)[-1])
all_events = rmf.scatter_energies(all_events, prng=prng)
return all_events, event_params
def rotate_xy(theta, x, y):
coords = np.dot(get_rot_mat(theta), np.array([x, y]))
return coords
def make_exposure_map(event_file, expmap_file, energy, weights=None,
asol_file=None, normalize=True, overwrite=False,
reblock=1, nhistx=16, nhisty=16, order=1):
"""
Make an exposure map for a SOXS event file, and optionally write
an aspect solution file. The exposure map will be created by
binning an aspect histogram over the range of the aspect solution.
Parameters
----------
event_file : string
The path to the event file to use for making the exposure map.
expmap_file : string
The path to write the exposure map file to.
energy : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`, or NumPy array
The energy in keV to use when computing the exposure map, or
a set of energies to be used with the *weights* parameter. If
providing a set, it must be in keV.
weights : array-like, optional
The weights to use with a set of energies given in the
*energy* parameter. Used to create a more accurate exposure
map weighted by a range of energies. Default: None
asol_file : string, optional
The path to write the aspect solution file to, if desired.
Default: None
normalize : boolean, optional
If True, the exposure map will be divided by the exposure time
so that the map's units are cm**2. Default: True
overwrite : boolean, optional
Whether or not to overwrite an existing file. Default: False
reblock : integer, optional
Supply an integer power of 2 here to make an exposure map
with a different binning. Default: 1
nhistx : integer, optional
The number of bins in the aspect histogram in the DETX
direction. Default: 16
nhisty : integer, optional
The number of bins in the aspect histogram in the DETY
direction. Default: 16
order : integer, optional
The interpolation order to use when making the exposure map.
Default: 1
"""
import pyregion._region_filter as rfilter
from scipy.ndimage.interpolation import rotate, shift
from soxs.instrument import AuxiliaryResponseFile, perform_dither
if isinstance(energy, np.ndarray) and weights is None:
raise RuntimeError("Must supply a single value for the energy if "
"you do not supply weights!")
if not isinstance(energy, np.ndarray):
energy = parse_value(energy, "keV")
f_evt = pyfits.open(event_file)
hdu = f_evt["EVENTS"]
arf = AuxiliaryResponseFile(hdu.header["ANCRFILE"])
exp_time = hdu.header["EXPOSURE"]
nx = int(hdu.header["TLMAX2"]-0.5)//2
ny = int(hdu.header["TLMAX3"]-0.5)//2
ra0 = hdu.header["TCRVL2"]
dec0 = hdu.header["TCRVL3"]
xdel = hdu.header["TCDLT2"]
ydel = hdu.header["TCDLT3"]
x0 = hdu.header["TCRPX2"]
y0 = hdu.header["TCRPX3"]
xdet0 = 0.5*(2*nx+1)
ydet0 = 0.5*(2*ny+1)
xaim = hdu.header.get("AIMPT_X", 0.0)
yaim = hdu.header.get("AIMPT_Y", 0.0)
roll = hdu.header["ROLL_PNT"]
instr = instrument_registry[hdu.header["INSTRUME"].lower()]
dither_params = {}
if "DITHXAMP" in hdu.header:
dither_params["x_amp"] = hdu.header["DITHXAMP"]
dither_params["y_amp"] = hdu.header["DITHYAMP"]
dither_params["x_period"] = hdu.header["DITHXPER"]
dither_params["y_period"] = hdu.header["DITHYPER"]
dither_params["plate_scale"] = ydel*3600.0
dither_params["dither_on"] = True
else:
dither_params["dither_on"] = False
f_evt.close()
# Create time array for aspect solution
dt = 1.0 # Seconds
t = np.arange(0.0, exp_time+dt, dt)
# Construct WCS
w = pywcs.WCS(naxis=2)
w.wcs.crval = [ra0, dec0]
w.wcs.crpix = [x0, y0]
w.wcs.cdelt = [xdel, ydel]
w.wcs.ctype = ["RA---TAN","DEC--TAN"]
w.wcs.cunit = ["deg"]*2
# Create aspect solution if we had dithering.
# otherwise just set the offsets to zero
if dither_params["dither_on"]:
x_off, y_off = perform_dither(t, dither_params)
# Make the aspect histogram
x_amp = dither_params["x_amp"]/dither_params["plate_scale"]
y_amp = dither_params["y_amp"]/dither_params["plate_scale"]
x_edges = np.linspace(-x_amp, x_amp, nhistx+1, endpoint=True)
y_edges = np.linspace(-y_amp, y_amp, nhisty+1, endpoint=True)
asphist = np.histogram2d(x_off, y_off, (x_edges, y_edges))[0]
asphist *= dt
x_mid = 0.5*(x_edges[1:]+x_edges[:-1])/reblock
y_mid = 0.5*(y_edges[1:]+y_edges[:-1])/reblock
# Determine the effective area
eff_area = arf.interpolate_area(energy).value
if weights is not None:
eff_area = np.average(eff_area, weights=weights)
if instr["chips"] is None:
rtypes = ["Box"]
args = [[0.0, 0.0, instr["num_pixels"], instr["num_pixels"]]]
else:
rtypes = []
args = []
for i, chip in enumerate(instr["chips"]):
rtypes.append(chip[0])
args.append(np.array(chip[1:]))
tmpmap = np.zeros((2*nx, 2*ny))
for rtype, arg in zip(rtypes, args):
rfunc = getattr(rfilter, rtype)
new_args = parse_region_args(rtype, arg, xdet0-xaim-1.0, ydet0-yaim-1.0)
r = rfunc(*new_args)
tmpmap += r.mask(tmpmap).astype("float64")
tmpmap = downsample(tmpmap, reblock)
if dither_params["dither_on"]:
expmap = np.zeros(tmpmap.shape)
niter = nhistx*nhisty
pbar = tqdm(leave=True, total=niter, desc="Creating exposure map ")
for i in range(nhistx):
for j in range(nhisty):
expmap += shift(tmpmap, (x_mid[i], y_mid[j]), order=order)*asphist[i, j]
pbar.update(nhisty)
pbar.close()
else:
expmap = tmpmap*exp_time
expmap *= eff_area
if normalize:
expmap /= exp_time
if roll != 0.0:
rotate(expmap, roll, output=expmap, reshape=False)
expmap[expmap < 0.0] = 0.0
map_header = {"EXPOSURE": exp_time,
"MTYPE1": "EQPOS",
"MFORM1": "RA,DEC",
"CTYPE1": "RA---TAN",
"CTYPE2": "DEC--TAN",
"CRVAL1": ra0,
"CRVAL2": dec0,
"CUNIT1": "deg",
"CUNIT2": "deg",
"CDELT1": xdel*reblock,
"CDELT2": ydel*reblock,
"CRPIX1": 0.5*(2.0*nx//reblock+1),
"CRPIX2": 0.5*(2.0*ny//reblock+1)}
map_hdu = pyfits.ImageHDU(expmap, header=pyfits.Header(map_header))
map_hdu.name = "EXPMAP"
map_hdu.writeto(expmap_file, overwrite=overwrite)
if asol_file is not None:
if dither_params["dither_on"]:
det = np.array([x_off, y_off])
pix = np.dot(get_rot_mat(roll).T, det)
ra, dec = w.wcs_pix2world(pix[0,:]+x0, pix[1,:]+y0, 1)
col_t = pyfits.Column(name='time', format='D', unit='s', array=t)
col_ra = pyfits.Column(name='ra', format='D', unit='deg', array=ra)
col_dec = pyfits.Column(name='dec', format='D', unit='deg', array=dec)
coldefs = pyfits.ColDefs([col_t, col_ra, col_dec])
tbhdu = pyfits.BinTableHDU.from_columns(coldefs)
tbhdu.name = "ASPSOL"
tbhdu.header["EXPOSURE"] = exp_time
hdulist = [pyfits.PrimaryHDU(), tbhdu]
pyfits.HDUList(hdulist).writeto(asol_file, overwrite=overwrite)
else:
mylog.warning("Refusing to write an aspect solution file because "
"there was no dithering.")
def make_uniform_background(energy, event_params, rmf, prng=None):
from soxs.instrument import perform_dither
import pyregion._region_filter as rfilter
prng = parse_prng(prng)
bkg_events = {}
n_events = energy.size
nx = event_params["num_pixels"]
bkg_events["detx"] = prng.uniform(low=-0.5 * nx,
high=0.5 * nx,
size=n_events)
bkg_events["dety"] = prng.uniform(low=-0.5 * nx,
high=0.5 * nx,
size=n_events)
bkg_events["energy"] = energy
if event_params["chips"] is None:
bkg_events["chip_id"] = np.zeros(n_events, dtype='int')
else:
bkg_events["chip_id"] = -np.ones(n_events, dtype='int')
for i, chip in enumerate(event_params["chips"]):
thisc = np.ones(n_events, dtype='bool')
rtype = chip[0]
args = chip[1:]
r = getattr(rfilter, rtype)(*args)
inside = r.inside(bkg_events["detx"], bkg_events["dety"])
thisc = np.logical_and(thisc, inside)
bkg_events["chip_id"][thisc] = i
keep = bkg_events["chip_id"] > -1
for key in bkg_events:
bkg_events[key] = bkg_events[key][keep]
n_e = bkg_events["energy"].size
bkg_events['time'] = prng.uniform(size=n_e,
low=0.0,
high=event_params["exposure_time"])
x_offset, y_offset = perform_dither(bkg_events["time"],
event_params["dither_params"])
rot_mat = get_rot_mat(event_params["roll_angle"])
det = np.array([
bkg_events["detx"] + x_offset - event_params["aimpt_coords"][0],
bkg_events["dety"] + y_offset - event_params["aimpt_coords"][1]
])
pix = np.dot(rot_mat.T, det)
bkg_events["xpix"] = pix[0, :] + event_params['pix_center'][0]
bkg_events["ypix"] = pix[1, :] + event_params['pix_center'][1]
mylog.info("Scattering energies with RMF %s." %
os.path.split(rmf.filename)[-1])
bkg_events = rmf.scatter_energies(bkg_events, prng=prng)
return bkg_events
def rotate_xy(theta, x, y, inverse=False):
rot_mat = get_rot_mat(theta)
if inverse:
rot_mat = np.linalg.inv(rot_mat)
coords = np.dot(rot_mat, np.array([x, y]))
return coords
