def test_convolved_spectra(): arf = AuxiliaryResponseFile("xrs_hdxi_3x10.arf") spec1 = Spectrum.from_powerlaw(2.0, 0.01, 1.0, 0.1, 10.0, 1000) cspec1 = ConvolvedSpectrum(spec1, arf) cspec2 = spec1*arf spec2 = cspec1.deconvolve() assert_array_equal(cspec1.ebins.value, cspec2.ebins.value) assert_array_equal(spec1.ebins.value, spec2.ebins.value) assert_array_equal(cspec1.flux.value, cspec2.flux.value) assert_allclose(spec1.flux.value, spec2.flux.value)
def __init__(self, spectrum, arf): """ Generate a convolved spectrum by convolving a spectrum with an ARF. Parameters ---------- spectrum : :class:`~soxs.spectra.Spectrum` object The input spectrum to convolve with. arf : string or :class:`~soxs.instrument.AuxiliaryResponseFile` The ARF to use in the convolution. """ if not isinstance(arf, AuxiliaryResponseFile): arf = AuxiliaryResponseFile(arf) self.arf = arf earea = arf.interpolate_area(spectrum.emid) rate = spectrum.flux * earea super(ConvolvedSpectrum, self).__init__(spectrum.ebins, rate)
def test_uniform_bkgnd_scale(): hdxi_arf = AuxiliaryResponseFile("xrs_hdxi_3x10.arf") events, event_params = make_background((50, "ks"), "hdxi", [30., 45.], foreground=True, instr_bkgnd=True, ptsrc_bkgnd=False, prng=prng) ncts = np.logical_and(events["energy"] >= 0.7, events["energy"] <= 2.0).sum() t_exp = event_params["exposure_time"] fov = (event_params["fov"] * 60.0)**2 S = ncts / t_exp / fov dS = np.sqrt(ncts) / t_exp / fov foreground = ConvolvedBackgroundSpectrum(hm_astro_bkgnd, hdxi_arf) f_sum = foreground.get_flux_in_band(0.7, 2.0)[0] i_sum = acisi_particle_bkgnd.get_flux_in_band(0.7, 2.0)[0] b_sum = (f_sum + i_sum).to("ph/(arcsec**2*s)").value assert np.abs(S - b_sum) < 1.645 * dS
def test_simulate_bkgnd_spectrum(): tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) prng = RandomState(29) hdxi_arf = AuxiliaryResponseFile("xrs_hdxi_3x10.arf") hdxi_rmf = RedistributionMatrixFile("xrs_hdxi.rmf") exp_time = 50000.0 fov = 3600.0 simulate_spectrum(None, "hdxi", exp_time, "test_bkgnd.pha", instr_bkgnd=True, foreground=True, prng=prng, overwrite=True, bkgnd_area=(fov, "arcsec**2")) ch_min = hdxi_rmf.e_to_ch(0.7) - hdxi_rmf.cmin ch_max = hdxi_rmf.e_to_ch(2.0) - hdxi_rmf.cmin f = pyfits.open("test_bkgnd.pha") ncts = f["SPECTRUM"].data["COUNTS"][ch_min:ch_max].sum() f.close() S = ncts / exp_time / fov dS = np.sqrt(ncts) / exp_time / fov foreground = ConvolvedBackgroundSpectrum(hm_astro_bkgnd, hdxi_arf) f_sum = foreground.get_flux_in_band(0.7, 2.0)[0] i_sum = acisi_particle_bkgnd.get_flux_in_band(0.7, 2.0)[0] b_sum = (f_sum + i_sum).to("ph/(arcsec**2*s)").value assert np.abs(S - b_sum) < 1.645 * dS os.chdir(curdir) shutil.rmtree(tmpdir)
def setup(): from yt.config import ytcfg ytcfg["yt", "__withintesting"] = "True" try: make_simple_instrument("acisi_cy19", "sq_acisi_cy19", 20.0, 2400) except KeyError: pass acis_spec = get_instrument_from_registry("sq_acisi_cy19") rmf = RedistributionMatrixFile(acis_spec["rmf"]) arf = AuxiliaryResponseFile(acis_spec['arf']) def mymodel(pars, x, xhi=None): dx = x[1] - x[0] xmid = x + 0.5 * dx wm = WabsModel(pars[0]) wabs = wm.get_absorb(xmid) plaw = pars[1] * dx * (xmid * (1.0 + pars[2]))**(-pars[3]) return wabs * plaw @requires_module("sherpa") def test_power_law(): plaw_fit(1.1, prng=29) plaw_fit(0.8)
from soxs.events import write_spectrum from soxs.instrument_registry import get_instrument_from_registry ckms = clight.in_units("km/s").v def setup(): from yt.config import ytcfg ytcfg["yt", "__withintesting"] = "True" try: mucal_spec = get_instrument_from_registry("mucal") except KeyError: pass rmf = RedistributionMatrixFile(mucal_spec["rmf"]) arf = AuxiliaryResponseFile(mucal_spec['arf']) fit_model = TableApecModel(rmf.elo[0], rmf.ehi[-1], rmf.n_e) agen_var = TableApecModel(rmf.elo[0], rmf.ehi[-1], rmf.n_e, var_elem=["O", "Ca"], thermal_broad=True) def mymodel(pars, x, xhi=None): dx = x[1]-x[0] tm = TBabsModel(pars[0]) tbabs = tm.get_absorb(x+0.5*dx) bapec = fit_model.return_spectrum(pars[1], pars[2], pars[3], pars[4], velocity=pars[5]) eidxs = np.logical_and(rmf.elo >= x[0]-0.5*dx, rmf.elo <= x[-1]+0.5*dx) return tbabs*bapec[eidxs] def mymodel_var(pars, x, xhi=None):
def plaw_fit(alpha_sim): tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) nH_sim = 0.02 norm_sim = 1.0e-4 redshift = 0.01 exp_time = 5.0e4 area = 40000.0 inst_name = "hdxi" spec = Spectrum.from_powerlaw(alpha_sim, redshift, norm_sim) spec.apply_foreground_absorption(nH_sim) e = spec.generate_energies(exp_time, area) pt_src = PointSourceModel(30.0, 45.0, e.size) write_photon_list("plaw_model", "plaw_model", e.flux, pt_src.ra, pt_src.dec, e, clobber=True) instrument_simulator("plaw_model_simput.fits", "plaw_model_evt.fits", exp_time, inst_name, [30.0, 45.0], astro_bkgnd=None, instr_bkgnd_scale=0.0) inst = get_instrument_from_registry(inst_name) arf = AuxiliaryResponseFile(inst["arf"]) rmf = RedistributionMatrixFile(inst["rmf"]) os.system("cp %s ." % arf.filename) os.system("cp %s ." % rmf.filename) write_spectrum("plaw_model_evt.fits", "plaw_model_evt.pha", clobber=True) load_user_model(mymodel, "wplaw") add_user_pars("wplaw", ["nH", "norm", "redshift", "alpha"], [0.01, norm_sim * 0.8, redshift, 0.9], parmins=[0.0, 0.0, 0.0, 0.1], parmaxs=[10.0, 1.0e9, 10.0, 10.0], parfrozen=[False, False, True, False]) load_pha("plaw_model_evt.pha") set_stat("cstat") set_method("simplex") ignore(":0.5, 9.0:") set_model("wplaw") fit() set_covar_opt("sigma", 1.645) covar() res = get_covar_results() assert np.abs(res.parvals[0] - nH_sim) < res.parmaxes[0] assert np.abs(res.parvals[1] - norm_sim) < res.parmaxes[1] assert np.abs(res.parvals[2] - alpha_sim) < res.parmaxes[2] os.chdir(curdir) shutil.rmtree(tmpdir)
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 simulate_spectrum(spec, instrument, exp_time, out_file, instr_bkgnd=False, foreground=False, ptsrc_bkgnd=False, bkgnd_area=None, absorb_model="wabs", nH=0.05, overwrite=False, prng=None): """ Generate a PI or PHA spectrum from a :class:`~soxs.spectra.Spectrum` by convolving it with responses. To be used if one wants to create a spectrum without worrying about spatial response. Similar to XSPEC's "fakeit". Parameters ---------- spec : :class:`~soxs.spectra.Spectrum` The spectrum to be convolved. If None is supplied, only backgrounds will be simulated (if they are turned on). instrument : string The name of the instrument to use, which picks an instrument specification from the instrument registry. exp_time : float, (value, unit) tuple, or :class:`~astropy.units.Quantity` The exposure time in seconds. out_file : string The file to write the spectrum to. instr_bkgnd : boolean, optional Whether or not to include the instrumental/particle background. Default: False foreground : boolean, optional Whether or not to include the local foreground. Default: False ptsrc_bkgnd : boolean, optional Whether or not to include the unresolved point-source background. Default: False bkgnd_area : float, (value, unit) tuple, or :class:`~astropy.units.Quantity` The area on the sky for the background components, in square arcminutes. Default: None, necessary to specify if any of the background components are turned on. absorb_model : string, optional The absorption model to use, "wabs" or "tbabs". Default: "wabs" nH : float, optional The hydrogen column in units of 10**22 atoms/cm**2. Default: 0.05 overwrite : boolean, optional Whether or not to overwrite an existing file. 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. Examples -------- >>> spec = soxs.Spectrum.from_file("my_spectrum.txt") >>> soxs.simulate_spectrum(spec, "lynx_lxm", 100000.0, ... "my_spec.pi", overwrite=True) """ from soxs.events import _write_spectrum from soxs.instrument import RedistributionMatrixFile, \ AuxiliaryResponseFile from soxs.spectra import ConvolvedSpectrum from soxs.background.foreground import hm_astro_bkgnd from soxs.background.instrument import instrument_backgrounds from soxs.background.spectra import BackgroundSpectrum prng = parse_prng(prng) exp_time = parse_value(exp_time, "s") try: instrument_spec = instrument_registry[instrument] except KeyError: raise KeyError("Instrument %s is not in the instrument registry!" % instrument) if foreground or instr_bkgnd or ptsrc_bkgnd: if instrument_spec["grating"]: raise NotImplementedError("Backgrounds cannot be included in simulations " "of gratings spectra at this time!") if bkgnd_area is None: raise RuntimeError("The 'bkgnd_area' argument must be set if one wants " "to simulate backgrounds! Specify a value in square " "arcminutes.") bkgnd_area = np.sqrt(parse_value(bkgnd_area, "arcmin**2")) elif spec is None: raise RuntimeError("You have specified no source spectrum and no backgrounds!") arf_file = get_response_path(instrument_spec["arf"]) rmf_file = get_response_path(instrument_spec["rmf"]) arf = AuxiliaryResponseFile(arf_file) rmf = RedistributionMatrixFile(rmf_file) event_params = {} event_params["RESPFILE"] = os.path.split(rmf.filename)[-1] event_params["ANCRFILE"] = os.path.split(arf.filename)[-1] event_params["TELESCOP"] = rmf.header["TELESCOP"] event_params["INSTRUME"] = rmf.header["INSTRUME"] event_params["MISSION"] = rmf.header.get("MISSION", "") out_spec = np.zeros(rmf.n_ch) if spec is not None: cspec = ConvolvedSpectrum(spec, arf) out_spec += rmf.convolve_spectrum(cspec, exp_time, prng=prng) fov = None if bkgnd_area is None else np.sqrt(bkgnd_area) if foreground: mylog.info("Adding in astrophysical foreground.") cspec_frgnd = ConvolvedSpectrum(hm_astro_bkgnd.to_spectrum(fov), arf) out_spec += rmf.convolve_spectrum(cspec_frgnd, exp_time, prng=prng) if instr_bkgnd and instrument_spec["bkgnd"] is not None: mylog.info("Adding in instrumental background.") instr_spec = instrument_backgrounds[instrument_spec["bkgnd"]] cspec_instr = instr_spec.to_scaled_spectrum(fov, instrument_spec["focal_length"]) out_spec += rmf.convolve_spectrum(cspec_instr, exp_time, prng=prng) if ptsrc_bkgnd: mylog.info("Adding in background from unresolved point-sources.") spec_plaw = BackgroundSpectrum.from_powerlaw(1.45, 0.0, 2.0e-7, emin=0.01, emax=10.0, nbins=300000) spec_plaw.apply_foreground_absorption(nH, model=absorb_model) cspec_plaw = ConvolvedSpectrum(spec_plaw.to_spectrum(fov), arf) out_spec += rmf.convolve_spectrum(cspec_plaw, exp_time, prng=prng) bins = (np.arange(rmf.n_ch)+rmf.cmin).astype("int32") _write_spectrum(bins, out_spec, exp_time, rmf.header["CHANTYPE"], event_params, out_file, overwrite=overwrite)
def make_background(exp_time, instrument, sky_center, foreground=True, ptsrc_bkgnd=True, instr_bkgnd=True, no_dither=False, dither_params=None, roll_angle=0.0, subpixel_res=False, input_sources=None, absorb_model="wabs", nH=0.05, prng=None): """ Make background events. Parameters ---------- 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. foreground : boolean, optional Whether or not to include the Galactic foreground. Default: True instr_bkgnd : boolean, optional Whether or not to include the instrumental background. Default: True 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]. ptsrc_bkgnd : boolean, optional Whether or not to include the point-source background. Default: True Default: 0.05 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 input_sources : string, optional If set to a filename, input the point source positions, fluxes, and spectral indices from an ASCII table instead of generating them. Default: None absorb_model : string, optional The absorption model to use, "wabs" or "tbabs". Default: "wabs" nH : float, optional The hydrogen column in units of 10**22 atoms/cm**2. Default: 0.05 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. """ from soxs.background import make_instrument_background, \ make_foreground, make_ptsrc_background prng = parse_prng(prng) exp_time = parse_value(exp_time, "s") roll_angle = parse_value(roll_angle, "deg") 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!") fov = instrument_spec["fov"] input_events = defaultdict(list) arf_file = get_response_path(instrument_spec["arf"]) arf = AuxiliaryResponseFile(arf_file) rmf_file = get_response_path(instrument_spec["rmf"]) rmf = RedistributionMatrixFile(rmf_file) if ptsrc_bkgnd: mylog.info("Adding in point-source background.") ptsrc_events = make_ptsrc_background(exp_time, fov, sky_center, area=1.2*arf.max_area, input_sources=input_sources, absorb_model=absorb_model, nH=nH, prng=prng) for key in ["ra", "dec", "energy"]: input_events[key].append(ptsrc_events[key]) input_events["flux"].append(ptsrc_events["flux"]) input_events["emin"].append(ptsrc_events["energy"].min()) input_events["emax"].append(ptsrc_events["energy"].max()) input_events["sources"].append("ptsrc_bkgnd") events, event_params = generate_events(input_events, exp_time, instrument, sky_center, no_dither=no_dither, dither_params=dither_params, roll_angle=roll_angle, subpixel_res=subpixel_res, prng=prng) mylog.info("Generated %d photons from the point-source background." % len(events["energy"])) else: nx = instrument_spec["num_pixels"] events = defaultdict(list) 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": instrument_spec["fov"]/nx*60.0} event_params = {"exposure_time": exp_time, "fov": instrument_spec["fov"], "num_pixels": nx, "pix_center": np.array([0.5*(2*nx+1)]*2), "channel_type": rmf.header["CHANTYPE"], "sky_center": sky_center, "dither_params": dither_dict, "plate_scale": instrument_spec["fov"]/nx/60.0, "chan_lim": [rmf.cmin, rmf.cmax], "rmf": rmf_file, "arf": arf_file, "telescope": rmf.header["TELESCOP"], "instrument": instrument_spec['name'], "mission": rmf.header.get("MISSION", ""), "nchan": rmf.n_ch, "roll_angle": roll_angle, "aimpt_coords": instrument_spec["aimpt_coords"]} if "chips" not in event_params: event_params["chips"] = instrument_spec["chips"] if foreground: mylog.info("Adding in astrophysical foreground.") bkg_events = make_foreground(event_params, arf, rmf, prng=prng) for key in bkg_events: events[key] = np.concatenate([events[key], bkg_events[key]]) if instr_bkgnd and instrument_spec["bkgnd"] is not None: mylog.info("Adding in instrumental background.") bkg_events = make_instrument_background(instrument_spec["bkgnd"], event_params, rmf, prng=prng) for key in bkg_events: events[key] = np.concatenate([events[key], bkg_events[key]]) return 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 test_annulus(): tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) r_in = 10.0 r_out = 30.0 e = spec.generate_energies(exp_time, area, prng=prng) ann_src = AnnulusModel(ra0, dec0, r_in, r_out, e.size, prng=prng) write_photon_list("ann", "ann", e.flux, ann_src.ra, ann_src.dec, e, overwrite=True) instrument_simulator("ann_simput.fits", "ann_evt.fits", exp_time, "hdxi", [ra0, dec0], ptsrc_bkgnd=False, instr_bkgnd=False, foreground=False, prng=prng) inst = get_instrument_from_registry("hdxi") arf = AuxiliaryResponseFile(inst["arf"]) cspec = ConvolvedSpectrum(spec, arf) ph_flux = cspec.get_flux_in_band(0.5, 7.0)[0].value S0 = ph_flux / (np.pi * (r_out**2 - r_in**2)) write_radial_profile("ann_evt.fits", "ann_evt_profile.fits", [ra0, dec0], 1.1 * r_in, 0.9 * r_out, 100, ctr_type="celestial", emin=0.5, emax=7.0, overwrite=True) load_data(1, "ann_evt_profile.fits", 3, ["RMID", "SUR_BRI", "SUR_BRI_ERR"]) set_stat("chi2") set_method("levmar") set_source("const1d.src") src.c0 = 0.8 * S0 fit() set_covar_opt("sigma", 1.645) covar() res = get_covar_results() assert np.abs(res.parvals[0] - S0) < res.parmaxes[0] os.chdir(curdir) shutil.rmtree(tmpdir)
def test_beta_model(): tmpdir = tempfile.mkdtemp() curdir = os.getcwd() os.chdir(tmpdir) r_c = 20.0 beta = 1.0 exp_time = Quantity(500.0, "ks") e = spec.generate_energies(exp_time, area, prng=prng) beta_src = BetaModel(ra0, dec0, r_c, beta, e.size, prng=prng) write_photon_list("beta", "beta", e.flux, beta_src.ra, beta_src.dec, e, overwrite=True) instrument_simulator("beta_simput.fits", "beta_evt.fits", exp_time, "hdxi", [ra0, dec0], ptsrc_bkgnd=False, instr_bkgnd=False, foreground=False, prng=prng) inst = get_instrument_from_registry("hdxi") arf = AuxiliaryResponseFile(inst["arf"]) cspec = ConvolvedSpectrum(spec, arf) ph_flux = cspec.get_flux_in_band(0.5, 7.0)[0].value S0 = 3.0 * ph_flux / (2.0 * np.pi * r_c * r_c) write_radial_profile("beta_evt.fits", "beta_evt_profile.fits", [ra0, dec0], 0.0, 100.0, 200, ctr_type="celestial", emin=0.5, emax=7.0, overwrite=True) load_data(1, "beta_evt_profile.fits", 3, ["RMID", "SUR_BRI", "SUR_BRI_ERR"]) set_stat("chi2") set_method("levmar") set_source("beta1d.src") src.beta = 1.0 src.r0 = 10.0 src.ampl = 0.8 * S0 freeze(src.xpos) fit() set_covar_opt("sigma", 1.645) covar() res = get_covar_results() assert np.abs(res.parvals[0] - r_c) < res.parmaxes[0] assert np.abs(res.parvals[1] - beta) < res.parmaxes[1] assert np.abs(res.parvals[2] - S0) < res.parmaxes[2] os.chdir(curdir) shutil.rmtree(tmpdir)
def arf(self): if self._arf is None: self._arf = AuxiliaryResponseFile(self.arf_file) return self._arf
def simulate_spectrum(spec, instrument, exp_time, out_file, overwrite=False, prng=None): """ Generate a PI or PHA spectrum from a :class:`~soxs.spectra.Spectrum` by convolving it with responses. To be used if one wants to create a spectrum without worrying about spatial response. Similar to XSPEC's "fakeit". Parameters ---------- spec : :class:`~soxs.spectra.Spectrum` The spectrum to be convolved. instrument : string The name of the instrument to use, which picks an instrument specification from the instrument registry. exp_time : float, (value, unit) tuple, or :class:`~astropy.units.Quantity` The exposure time in seconds. out_file : string The file to write the spectrum to. overwrite : boolean, optional Whether or not to overwrite an existing file. 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. Examples -------- >>> spec = soxs.Spectrum.from_file("my_spectrum.txt") >>> soxs.simulate_spectrum(spec, "mucal", 100000.0, ... "my_spec.pi", overwrite=True) """ from soxs.events import write_spectrum from soxs.instrument import RedistributionMatrixFile, \ AuxiliaryResponseFile from soxs.spectra import ConvolvedSpectrum prng = parse_prng(prng) exp_time = parse_value(exp_time, "s") try: instrument_spec = instrument_registry[instrument] except KeyError: raise KeyError("Instrument %s is not in the instrument registry!" % instrument) arf_file = check_file_location(instrument_spec["arf"], "files") rmf_file = check_file_location(instrument_spec["rmf"], "files") arf = AuxiliaryResponseFile(arf_file) rmf = RedistributionMatrixFile(rmf_file) cspec = ConvolvedSpectrum(spec, arf) events = {} events["energy"] = cspec.generate_energies(exp_time, prng=prng).value events = rmf.scatter_energies(events, prng=prng) events["arf"] = arf.filename events["rmf"] = rmf.filename events["exposure_time"] = exp_time events["channel_type"] = rmf.header["CHANTYPE"] events["telescope"] = rmf.header["TELESCOP"] events["instrument"] = rmf.header["INSTRUME"] events["mission"] = rmf.header.get("MISSION", "") write_spectrum(events, out_file, overwrite=overwrite)