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_instrument_background(bkgnd_name, event_params, focal_length, rmf, prng=None): prng = parse_prng(prng) bkgnd_spec = instrument_backgrounds[bkgnd_name] # Generate background events energy = bkgnd_spec.generate_energies(event_params["exposure_time"], event_params["fov"], focal_length=focal_length, prng=prng, quiet=True).value if energy.size == 0: raise RuntimeError( "No instrumental background events were detected!!!") else: mylog.info("Making %d events from the instrumental background." % energy.size) return make_uniform_background(energy, event_params, rmf, prng=prng)
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 _generate_energies(spec, t_exp, rate, prng, quiet=False): cumspec = spec.cumspec n_ph = prng.poisson(t_exp*rate) if not quiet: mylog.info("Creating %d energies from this spectrum." % n_ph) randvec = prng.uniform(size=n_ph) randvec.sort() e = np.interp(randvec, cumspec, spec.ebins.value) if not quiet: mylog.info("Finished creating energies.") return e
def make_instrument_background(inst_spec, event_params, rmf, prng=None): from collections import defaultdict prng = parse_prng(prng) bkgnd_spec = inst_spec["bkgnd"] if isinstance(bkgnd_spec[0], str): nchips = len(event_params["chips"]) bkgnd_spec = [bkgnd_spec] * nchips bkg_events = defaultdict(list) pixel_area = (event_params["plate_scale"] * 60.0)**2 for i, chip in enumerate(event_params["chips"]): rtype = chip[0] args = chip[1:] r, bounds = create_region(rtype, args, 0.0, 0.0) sa = (bounds[1] - bounds[0]) * (bounds[3] - bounds[2]) * pixel_area bspec = InstrumentalBackground.from_filename(bkgnd_spec[i][0], bkgnd_spec[i][1], inst_spec['focal_length']) chan = bspec.generate_channels(event_params["exposure_time"], sa, prng=prng) n_events = chan.size detx = prng.uniform(low=bounds[0], high=bounds[1], size=n_events) dety = prng.uniform(low=bounds[2], high=bounds[3], size=n_events) if rtype in ["Box", "Rectangle"]: thisc = slice(None, None, None) n_det = n_events else: thisc = r.contains(PixCoord(detx, dety)) n_det = thisc.sum() ch = chan[thisc].astype('int') e = rmf.ch_to_eb(ch, prng=prng) bkg_events["energy"].append(e) bkg_events[rmf.chan_type].append(ch) bkg_events["detx"].append(detx[thisc]) bkg_events["dety"].append(dety[thisc]) bkg_events["chip_id"].append(i * np.ones(n_det)) for key in bkg_events: bkg_events[key] = np.concatenate(bkg_events[key]) if bkg_events["energy"].size == 0: raise RuntimeError( "No instrumental background events were detected!!!") else: mylog.info(f"Making {bkg_events['energy'].size} events " f"from the instrumental background.") return make_diffuse_background(bkg_events, event_params, rmf, prng=prng)
def detect_events(self, events, exp_time, flux, refband, prng=None): """ Use the ARF to determine a subset of photons which will be detected. Returns a boolean NumPy array which is the same is the same size as the number of photons, wherever it is "true" means those photons have been detected. Parameters ---------- events : dict of np.ndarrays The energies and positions of the photons. exp_time : float The exposure time in seconds. flux : float The total flux of the photons in erg/s/cm^2. refband : array_like A two-element array or list containing the limits of the energy band which the flux was computed in. 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. """ prng = parse_prng(prng) energy = events["energy"] if energy.size == 0: return events earea = self.interpolate_area(energy).value idxs = np.logical_and(energy >= refband[0], energy <= refband[1]) rate = flux / (energy[idxs].sum() * erg_per_keV) * earea[idxs].sum() n_ph = prng.poisson(lam=rate * exp_time) fak = float(n_ph) / energy.size if fak > 1.0: mylog.error( "Number of events in sample: %d, Number of events wanted: %d" % (energy.size, n_ph)) raise ValueError( "This combination of exposure time and effective area " "will result in more photons being drawn than are available " "in the sample!!!") w = earea / self.max_area randvec = prng.uniform(size=energy.size) eidxs = prng.permutation( np.where(randvec < w)[0])[:n_ph].astype("int64") mylog.info("%s events detected." % n_ph) for key in events: events[key] = events[key][eidxs] return events
def make_foreground(event_params, arf, rmf, prng=None): import pyregion._region_filter as rfilter prng = parse_prng(prng) conv_frgnd_spec = ConvolvedBackgroundSpectrum(hm_astro_bkgnd, arf) energy = conv_frgnd_spec.generate_energies(event_params["exposure_time"], event_params["fov"], prng=prng, quiet=True).value 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 if keep.sum() == 0: raise RuntimeError("No astrophysical foreground events were detected!!!") else: mylog.info("Making %d events from the astrophysical foreground." % keep.sum()) for key in bkg_events: bkg_events[key] = bkg_events[key][keep] return make_diffuse_background(bkg_events, event_params, rmf, prng=prng)
def detect_events_spec(self, src, exp_time, refband, prng=None): from soxs.spectra import ConvolvedSpectrum prng = parse_prng(prng) cspec = ConvolvedSpectrum.convolve( src.spec, self).new_spec_from_band(refband[0], refband[1]) energy = cspec.generate_energies(exp_time, quiet=True, prng=prng).value if getattr(src, "imhdu", None): x, y = image_pos(src.imhdu.data, energy.size, prng) w = pywcs.WCS(header=src.imhdu.header) w.wcs.crval = [src.ra, src.dec] ra, dec = w.wcs_pix2world(x, y, 1) else: pones = np.ones_like(energy) ra = src.ra*pones dec = src.dec*pones mylog.info(f"{energy.size} events detected.") return {"energy": energy, "ra": ra, "dec": dec}
def detect_events(self, events, exp_time, flux, refband, prng=None): """ Use the ARF to determine a subset of photons which will be detected. Returns a boolean NumPy array which is the same is the same size as the number of photons, wherever it is "true" means those photons have been detected. Parameters ---------- events : dict of np.ndarrays The energies and positions of the photons. exp_time : float The exposure time in seconds. flux : float The total flux of the photons in erg/s/cm^2. refband : array_like A two-element array or list containing the limits of the energy band which the flux was computed in. 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. """ prng = parse_prng(prng) energy = events["energy"] if energy.size == 0: return events earea = self.interpolate_area(energy).value idxs = np.logical_and(energy >= refband[0], energy <= refband[1]) rate = flux/(energy[idxs].sum()*erg_per_keV)*earea[idxs].sum() n_ph = prng.poisson(lam=rate*exp_time) fak = float(n_ph)/energy.size if fak > 1.0: mylog.error("Number of events in sample: %d, Number of events wanted: %d" % (energy.size, n_ph)) raise ValueError("This combination of exposure time and effective area " "will result in more photons being drawn than are available " "in the sample!!!") w = earea / self.max_area randvec = prng.uniform(size=energy.size) eidxs = prng.permutation(np.where(randvec < w)[0])[:n_ph].astype("int64") mylog.info("%s events detected." % n_ph) for key in events: events[key] = events[key][eidxs] return events
def make_foreground(event_params, arf, rmf, prng=None): prng = parse_prng(prng) conv_frgnd_spec = ConvolvedBackgroundSpectrum.convolve(hm_astro_bkgnd, arf) bkg_events = {"energy": [], "detx": [], "dety": [], "chip_id": []} pixel_area = (event_params["plate_scale"]*60.0)**2 for i, chip in enumerate(event_params["chips"]): rtype = chip[0] args = chip[1:] r, bounds = create_region(rtype, args, 0.0, 0.0) fov = np.sqrt((bounds[1]-bounds[0])*(bounds[3]-bounds[2])*pixel_area) e = conv_frgnd_spec.generate_energies(event_params["exposure_time"], fov, prng=prng, quiet=True).value n_events = e.size detx = prng.uniform(low=bounds[0], high=bounds[1], size=n_events) dety = prng.uniform(low=bounds[2], high=bounds[3], size=n_events) if rtype in ["Box", "Rectangle"]: thisc = slice(None, None, None) n_det = n_events else: thisc = r.contains(PixCoord(detx, dety)) n_det = thisc.sum() bkg_events["energy"].append(e[thisc]) bkg_events["detx"].append(detx[thisc]) bkg_events["dety"].append(dety[thisc]) bkg_events["chip_id"].append(i*np.ones(n_det)) for key in bkg_events: bkg_events[key] = np.concatenate(bkg_events[key]) if bkg_events["energy"].size == 0: raise RuntimeError("No astrophysical foreground events " "were detected!!!") else: mylog.info(f"Making {bkg_events['energy'].size} events from the " f"astrophysical foreground.") bkg_events = make_diffuse_background(bkg_events, event_params, rmf, prng=prng) mylog.info(f"Scattering energies with " f"RMF {os.path.split(rmf.filename)[-1]}.") return rmf.scatter_energies(bkg_events, prng=prng)
def make_foreground(event_params, arf, rmf, prng=None): prng = parse_prng(prng) conv_bkgnd_spec = ConvolvedBackgroundSpectrum(hm_astro_bkgnd, arf) energy = conv_bkgnd_spec.generate_energies(event_params["exposure_time"], event_params["fov"], prng=prng, quiet=True).value if energy.size == 0: raise RuntimeError( "No astrophysical foreground events were detected!!!") else: mylog.info("Making %d events from the astrophysical foreground." % energy.size) return make_uniform_background(energy, event_params, rmf, prng=prng)
def write_catalog(self, overwrite=False): """ Write the SIMPUT catalog and associated photon lists to disk. Parameters ---------- overwrite : boolean, optional Whether or not to overwrite an existing file with the same name. Default: False """ for i, phlist in enumerate(self.photon_lists): if i == 0: append = False mylog.info("Writing SIMPUT catalog file %s_simput.fits." % self.name) else: append = True mylog.info("Writing SIMPUT photon list file %s_phlist.fits." % phlist.name) phlist.write_photon_list(self.name, append=append, overwrite=overwrite)
def generate_energies(self, t_exp, area, prng=None): """ Generate photon energies from this spectrum given an exposure time and effective area. Parameters ---------- t_exp : float The exposure time in seconds. area : float or NumPy array The effective area in cm**2, or the effective area multiplied by the field of view area in cm**2*arcmin**2 if the spectrum has units of intensity. If one is creating events for a SIMPUT file, a constant should be used and it must be large enough so that a sufficiently large sample is drawn for the ARF. prng : :class:`~numpy.random.RandomState` object or :mod:`~numpy.random`, optional 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 the :mod:`numpy.random` module. """ if "arcmin" in self._units: A = u.Quantity(area, "cm**2*arcmin**2") else: A = u.Quantity(area, "cm**2") if prng is None: prng = np.random if isinstance(area, np.ndarray): rate_arr = A*self.flux*self.de rate = rate_arr.sum() cumspec = np.cumsum(rate_arr.value) cumspec = np.insert(cumspec, 0, 0.0) cumspec /= cumspec[-1] else: rate = A*self.total_flux cumspec = self.cumspec n_ph = np.modf(t_exp*rate.value) n_ph = np.int64(n_ph[1]) + np.int64(n_ph[0] >= prng.uniform()) mylog.info("Creating %d events from this spectrum." % n_ph) randvec = prng.uniform(size=n_ph) randvec.sort() energy = np.interp(randvec, cumspec, self.ebins.value) flux = np.sum(energy)*erg_per_keV/t_exp/area energies = Energies(energy, flux) return energies
def _write_source(self, filename, extver, img_extver=None, overwrite=False): coldefs, header = self._get_source_hdu() tbhdu = pyfits.BinTableHDU.from_columns(coldefs) tbhdu.name = self.src_type.upper() if self.src_type == "phlist": hduclas1 = "PHOTONS" else: hduclas1 = self.src_type.upper() tbhdu.header["HDUCLASS"] = "HEASARC/SIMPUT" tbhdu.header["HDUCLAS1"] = hduclas1 tbhdu.header["HDUVERS"] = "1.1.0" tbhdu.header.update(header) tbhdu.header["EXTVER"] = extver if self.imhdu is not None: self.imhdu.header["EXTVER"] = img_extver if os.path.exists(filename) and not overwrite: mylog.info(f"Appending this source to {filename}.") with pyfits.open(filename, mode='append') as f: f.append(tbhdu) if self.imhdu is not None: f.append(self.imhdu) f.flush() else: if os.path.exists(filename): mylog.warning(f"Overwriting {filename} with this source.") else: mylog.info(f"Writing source to {filename}.") f = [pyfits.PrimaryHDU(), tbhdu] if self.imhdu is not None: f.append(self.imhdu) pyfits.HDUList(f).writeto(filename, overwrite=overwrite) if self.imhdu is not None: self.imhdu.header["EXTVER"] = 1
def add_instrument_to_registry(inst_spec): """ Add an instrument specification to the registry, contained in either a dictionary or a JSON file. The *inst_spec* must have the structure as shown below. The order is not important. If you use a JSON file, the structure is the same, but the file cannot include comments. >>> { ... "name": "hdxi_3x10", # The short name of the instrument ... "arf": "xrs_hdxi_3x10.arf", # The file containing the ARF ... "rmf": "xrs_hdxi.rmf" # The file containing the RMF ... "bkgnd": "acisi" # The name of the particle background ... "fov": 20.0, # The field of view in arcminutes ... "focal_length": 10.0, # The focal length in meters ... "num_pixels": 4096, # The number of pixels on a side in the FOV ... "psf": ["gaussian", 0.5] # The type of PSF and its FWHM ... } """ if isinstance(inst_spec, dict): inst = inst_spec elif os.path.exists(inst_spec): f = open(inst_spec, "r") inst = json.load(f) f.close() name = inst["name"] if name in instrument_registry: raise KeyError( "The instrument with name %s is already in the registry! Assign a different name!" % name) # Catch old JSON files with plate scale if "plate_scale" in inst: inst["fov"] = inst["num_pixels"] * inst["plate_scale"] / 60.0 inst.pop("plate_scale") instrument_registry[name] = inst mylog.info( "The %s instrument specification has been added to the instrument registry." % name) return name
def fetch_files(self, key, loc=None): """ A handy method to fetch ARF, RMF, background, and PSF files to a location of one's choice. Files are only actually downloaded if they are not present already. Parameters ---------- key : string The instrument specification to download the files for. loc : string, optional The path to download the files to. If not specified, it will download them to the current working directory. """ inst_spec = self[key] if loc is None: loc = os.getcwd() dog = PoochHandle(cache_dir=loc) log_msg = f"Downloading %s \"%s\" for instrument \"{key}\"." fns = [inst_spec['arf'], inst_spec['rmf']] logs = ["ARF", "RMF"] if inst_spec['bkgnd'] is not None: bkgnd = inst_spec['bkgnd'][0] if isinstance(bkgnd, list): for b in inst_spec['bkgnd']: fns.append(b[0]) else: fns.append(bkgnd) logs.append("instrumental background model") if inst_spec['psf'] is not None: if "image" in inst_spec['psf'][0]: fns.append(inst_spec['psf'][1]) logs.append("PSF model") for fn, log in zip(fns, logs): mylog.info(log_msg % (log, fn)) dog.fetch(fn)
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_ptsrc_background(exp_time, fov, sky_center, absorb_model="wabs", nH=0.05, area=40000.0, input_sources=None, output_sources=None, prng=None): r""" Make a point-source background. Parameters ---------- exp_time : float, (value, unit) tuple, or :class:`~astropy.units.Quantity` The exposure time of the observation in seconds. fov : float, (value, unit) tuple, or :class:`~astropy.units.Quantity` The field of view in arcminutes. sky_center : array-like The center RA, Dec of the field of view in degrees. absorb_model : string, optional The absorption model to use, "wabs" or "tbabs". Default: "wabs" nH : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`, optional The hydrogen column in units of 10**22 atoms/cm**2. Default: 0.05 area : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`, optional The effective area in cm**2. It must be large enough so that a sufficiently large sample is drawn for the ARF. Default: 40000. input_sources : string, optional If set to a filename, input the source positions, fluxes, and spectral indices from an ASCII table instead of generating them. Default: None output_sources : string, optional If set to a filename, output the properties of the sources within the field of view to a file. Default: None 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. """ prng = parse_prng(prng) exp_time = parse_value(exp_time, "s") fov = parse_value(fov, "arcmin") if nH is not None: nH = parse_value(nH, "1.0e22*cm**-2") area = parse_value(area, "cm**2") if input_sources is None: ra0, dec0, fluxes, ind = generate_sources(fov, sky_center, prng=prng) num_sources = fluxes.size else: mylog.info(f"Reading in point-source properties from {input_sources}.") t = ascii.read(input_sources) ra0 = t["RA"].data dec0 = t["Dec"].data fluxes = t["flux_0.5_2.0_keV"].data ind = t["index"].data num_sources = fluxes.size mylog.debug(f"Generating spectra from {num_sources} sources.") # If requested, output the source properties to a file if output_sources is not None: t = Table([ra0, dec0, fluxes, ind], names=('RA', 'Dec', 'flux_0.5_2.0_keV', 'index')) t["RA"].unit = "deg" t["Dec"].unit = "deg" t["flux_0.5_2.0_keV"].unit = "erg/(cm**2*s)" t["index"].unit = "" t.write(output_sources, format='ascii.ecsv', overwrite=True) # Pre-calculate for optimization eratio = spec_emax / spec_emin oma = 1.0 - ind invoma = 1.0 / oma invoma[oma == 0.0] = 1.0 fac1 = spec_emin**oma fac2 = spec_emax**oma - fac1 fluxscale = get_flux_scale(ind, fb_emin, fb_emax, spec_emin, spec_emax) # Using the energy flux, determine the photon flux by simple scaling ref_ph_flux = fluxes * fluxscale * keV_per_erg # Now determine the number of photons we will generate n_photons = prng.poisson(ref_ph_flux * exp_time * area) all_energies = [] all_ra = [] all_dec = [] for i, nph in enumerate(n_photons): if nph > 0: # Generate the energies in the source frame u = prng.uniform(size=nph) if ind[i] == 1.0: energies = spec_emin * (eratio**u) else: energies = fac1[i] + u * fac2[i] energies **= invoma[i] # Assign positions for this source ra = ra0[i] * np.ones(nph) dec = dec0[i] * np.ones(nph) all_energies.append(energies) all_ra.append(ra) all_dec.append(dec) mylog.debug("Finished generating spectra.") all_energies = np.concatenate(all_energies) all_ra = np.concatenate(all_ra) all_dec = np.concatenate(all_dec) all_nph = all_energies.size # Remove some of the photons due to Galactic foreground absorption. # We will throw a lot of stuff away, but this is more general and still # faster. if nH is not None: if absorb_model == "wabs": absorb = get_wabs_absorb(all_energies, nH) elif absorb_model == "tbabs": absorb = get_tbabs_absorb(all_energies, nH) randvec = prng.uniform(size=all_energies.size) all_energies = all_energies[randvec < absorb] all_ra = all_ra[randvec < absorb] all_dec = all_dec[randvec < absorb] all_nph = all_energies.size mylog.debug( f"{all_nph} photons remain after foreground galactic absorption.") all_flux = np.sum(all_energies) * erg_per_keV / (exp_time * area) output_events = { "ra": all_ra, "dec": all_dec, "energy": all_energies, "flux": all_flux } return output_events
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 write_event_file(events, parameters, filename, overwrite=False): from astropy.time import Time, TimeDelta mylog.info("Writing events to file %s." % filename) t_begin = Time.now() dt = TimeDelta(parameters["exposure_time"], format='sec') t_end = t_begin + dt col_x = pyfits.Column(name='X', format='D', unit='pixel', array=events["xpix"]) col_y = pyfits.Column(name='Y', format='D', unit='pixel', array=events["ypix"]) col_e = pyfits.Column(name='ENERGY', format='E', unit='eV', array=events["energy"]*1000.) col_dx = pyfits.Column(name='DETX', format='D', unit='pixel', array=events["detx"]) col_dy = pyfits.Column(name='DETY', format='D', unit='pixel', array=events["dety"]) col_id = pyfits.Column(name='CCD_ID', format='D', unit='pixel', array=events["ccd_id"]) chantype = parameters["channel_type"] if chantype == "PHA": cunit = "adu" elif chantype == "PI": cunit = "Chan" col_ch = pyfits.Column(name=chantype.upper(), format='1J', unit=cunit, array=events[chantype]) col_t = pyfits.Column(name="TIME", format='1D', unit='s', array=events['time']) cols = [col_e, col_x, col_y, col_ch, col_t, col_dx, col_dy, col_id] coldefs = pyfits.ColDefs(cols) tbhdu = pyfits.BinTableHDU.from_columns(coldefs) tbhdu.name = "EVENTS" tbhdu.header["MTYPE1"] = "sky" tbhdu.header["MFORM1"] = "x,y" tbhdu.header["MTYPE2"] = "EQPOS" tbhdu.header["MFORM2"] = "RA,DEC" tbhdu.header["TCTYP2"] = "RA---TAN" tbhdu.header["TCTYP3"] = "DEC--TAN" tbhdu.header["TCRVL2"] = parameters["sky_center"][0] tbhdu.header["TCRVL3"] = parameters["sky_center"][1] tbhdu.header["TCDLT2"] = -parameters["plate_scale"] tbhdu.header["TCDLT3"] = parameters["plate_scale"] tbhdu.header["TCRPX2"] = parameters["pix_center"][0] tbhdu.header["TCRPX3"] = parameters["pix_center"][1] tbhdu.header["TCUNI2"] = "deg" tbhdu.header["TCUNI3"] = "deg" tbhdu.header["TLMIN2"] = 0.5 tbhdu.header["TLMIN3"] = 0.5 tbhdu.header["TLMAX2"] = 2.0*parameters["num_pixels"]+0.5 tbhdu.header["TLMAX3"] = 2.0*parameters["num_pixels"]+0.5 tbhdu.header["TLMIN4"] = parameters["chan_lim"][0] tbhdu.header["TLMAX4"] = parameters["chan_lim"][1] tbhdu.header["TLMIN6"] = -0.5*parameters["num_pixels"] tbhdu.header["TLMAX6"] = 0.5*parameters["num_pixels"] tbhdu.header["TLMIN7"] = -0.5*parameters["num_pixels"] tbhdu.header["TLMAX7"] = 0.5*parameters["num_pixels"] tbhdu.header["EXPOSURE"] = parameters["exposure_time"] tbhdu.header["TSTART"] = 0.0 tbhdu.header["TSTOP"] = parameters["exposure_time"] tbhdu.header["HDUVERS"] = "1.1.0" tbhdu.header["RADECSYS"] = "FK5" tbhdu.header["EQUINOX"] = 2000.0 tbhdu.header["HDUCLASS"] = "OGIP" tbhdu.header["HDUCLAS1"] = "EVENTS" tbhdu.header["HDUCLAS2"] = "ACCEPTED" tbhdu.header["DATE"] = t_begin.tt.isot tbhdu.header["DATE-OBS"] = t_begin.tt.isot tbhdu.header["DATE-END"] = t_end.tt.isot tbhdu.header["RESPFILE"] = os.path.split(parameters["rmf"])[-1] tbhdu.header["PHA_BINS"] = parameters["nchan"] tbhdu.header["ANCRFILE"] = os.path.split(parameters["arf"])[-1] tbhdu.header["CHANTYPE"] = parameters["channel_type"] tbhdu.header["MISSION"] = parameters["mission"] tbhdu.header["TELESCOP"] = parameters["telescope"] tbhdu.header["INSTRUME"] = parameters["instrument"] tbhdu.header["RA_PNT"] = parameters["sky_center"][0] tbhdu.header["DEC_PNT"] = parameters["sky_center"][1] tbhdu.header["ROLL_PNT"] = parameters["roll_angle"] tbhdu.header["AIMPT_X"] = parameters["aimpt_coords"][0] tbhdu.header["AIMPT_Y"] = parameters["aimpt_coords"][1] if parameters["dither_params"]["dither_on"]: tbhdu.header["DITHXAMP"] = parameters["dither_params"]["x_amp"] tbhdu.header["DITHYAMP"] = parameters["dither_params"]["y_amp"] tbhdu.header["DITHXPER"] = parameters["dither_params"]["x_period"] tbhdu.header["DITHYPER"] = parameters["dither_params"]["y_period"] start = pyfits.Column(name='START', format='1D', unit='s', array=np.array([0.0])) stop = pyfits.Column(name='STOP', format='1D', unit='s', array=np.array([parameters["exposure_time"]])) tbhdu_gti = pyfits.BinTableHDU.from_columns([start,stop]) tbhdu_gti.name = "STDGTI" tbhdu_gti.header["TSTART"] = 0.0 tbhdu_gti.header["TSTOP"] = parameters["exposure_time"] tbhdu_gti.header["HDUCLASS"] = "OGIP" tbhdu_gti.header["HDUCLAS1"] = "GTI" tbhdu_gti.header["HDUCLAS2"] = "STANDARD" tbhdu_gti.header["RADECSYS"] = "FK5" tbhdu_gti.header["EQUINOX"] = 2000.0 tbhdu_gti.header["DATE"] = t_begin.tt.isot tbhdu_gti.header["DATE-OBS"] = t_begin.tt.isot tbhdu_gti.header["DATE-END"] = t_end.tt.isot hdulist = [pyfits.PrimaryHDU(), tbhdu, tbhdu_gti] pyfits.HDUList(hdulist).writeto(filename, overwrite=overwrite)
def make_cosmological_sources(exp_time, fov, sky_center, cat_center=None, absorb_model="wabs", nH=0.05, area=40000.0, output_sources=None, prng=None): r""" Make an X-ray source made up of contributions from galaxy clusters, galaxy groups, and galaxies. Parameters ---------- exp_time : float, (value, unit) tuple, or :class:`~astropy.units.Quantity` The exposure time of the observation in seconds. fov : float, (value, unit) tuple, or :class:`~astropy.units.Quantity` The field of view in arcminutes. sky_center : array-like The center RA, Dec of the field of view in degrees. cat_center : array-like The center of the field in the coordinates of the halo catalog, which range from -5.0 to 5.0 in degrees in both directions. If None is given, a center will be randomly chosen. absorb_model : string, optional The absorption model to use, "wabs" or "tbabs". Default: "wabs" nH : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`, optional The hydrogen column in units of 10**22 atoms/cm**2. Default: 0.05 area : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`, optional The effective area in cm**2. It must be large enough so that a sufficiently large sample is drawn for the ARF. Default: 40000. output_sources : string, optional If set to a filename, output the properties of the sources within the field of view to a file. Default: None 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") fov = parse_value(fov, "arcmin") if nH is not None: nH = parse_value(nH, "1.0e22*cm**-2") area = parse_value(area, "cm**2") prng = parse_prng(prng) cosmo = FlatLambdaCDM(H0=100.0*h0, Om0=omega_m) agen = ApecGenerator(0.1, 10.0, 10000, broadening=False) mylog.info("Creating photons from cosmological sources.") mylog.info("Loading halo data from catalog: %s" % halos_cat_file) halo_data = h5py.File(halos_cat_file, "r") scale = cosmo.kpc_proper_per_arcmin(halo_data["redshift"]).to("Mpc/arcmin") # 600. arcmin = 10 degrees (total FOV of catalog = 100 deg^2) fov_cat = 10.0*60.0 w = construct_wcs(*sky_center) cat_min = -0.5*fov_cat cat_max = 0.5*fov_cat if cat_center is None: xc, yc = prng.uniform(low=cat_min+0.5*fov, high=cat_max-0.5*fov, size=2) else: xc, yc = cat_center xc *= 60.0 yc *= 60.0 xc, yc = np.clip([xc, yc], cat_min+0.5*fov, cat_max-0.5*fov) mylog.info("Coordinates of the FOV within the catalog are (%g, %g) deg." % (xc/60.0, yc/60.0)) xlo = (xc-1.1*0.5*fov)*scale.value*h0 xhi = (xc+1.1*0.5*fov)*scale.value*h0 ylo = (yc-1.1*0.5*fov)*scale.value*h0 yhi = (yc+1.1*0.5*fov)*scale.value*h0 mylog.info("Selecting halos in the FOV.") fov_idxs = (halo_data["x"] >= xlo) & (halo_data["x"] <= xhi) fov_idxs = (halo_data["y"] >= ylo) & (halo_data["y"] <= yhi) & fov_idxs n_halos = fov_idxs.sum() mylog.info("Number of halos in the field of view: %d" % n_halos) # Now select the specific halos which are in the FOV z = halo_data["redshift"][fov_idxs].astype("float64") m = halo_data["M500c"][fov_idxs].astype("float64")/h0 s = scale[fov_idxs].to("Mpc/arcsec").value ra0, dec0 = w.wcs_pix2world(halo_data["x"][fov_idxs]/(h0*s)-xc*60.0, halo_data["y"][fov_idxs]/(h0*s)-yc*60.0, 1) # Close the halo catalog file halo_data.close() # Some cosmological stuff rho_crit = cosmo.critical_density(z).to("Msun/Mpc**3").value # halo temperature and k-corrected flux kT = Tx(m, z) flux_kcorr = 1.0e-14*lum(m, z)/flux2lum(kT, z) # halo scale radius r500 = (3.0*m/(4.0*np.pi*500*rho_crit))**(1.0/3.0) r500_kpc = r500 * 1000.0 rc_kpc = r500/conc * 1000.0 rc = r500/conc/s # Halo slope parameter beta = prng.normal(loc=0.666, scale=0.05, size=n_halos) beta[beta < 0.5] = 0.5 # Halo ellipticity ellip = prng.normal(loc=0.85, scale=0.15, size=n_halos) ellip[ellip < 0.0] = 1.0e-3 # Halo orientation theta = 360.0*prng.uniform(size=n_halos) # If requested, output the source properties to a file if output_sources is not None: t = Table([ra0, dec0, rc_kpc, beta, ellip, theta, m, r500_kpc, kT, z, flux_kcorr], names=('RA', 'Dec', 'r_c', 'beta', 'ellipticity', 'theta', 'M500c', 'r500', 'kT', 'redshift', 'flux_0.5_2.0_keV')) t["RA"].unit = "deg" t["Dec"].unit = "deg" t["flux_0.5_2.0_keV"].unit = "erg/(cm**2*s)" t["r_c"].unit = "kpc" t["theta"].unit = "deg" t["M500c"].unit = "solMass" t["r500"].unit = "kpc" t["kT"].unit = "kT" t.write(output_sources, format='ascii.ecsv', overwrite=True) tot_flux = 0.0 ee = [] ra = [] dec = [] pbar = tqdm(leave=True, total=n_halos, desc="Generating photons from halos ") for halo in range(n_halos): spec = agen.get_spectrum(kT[halo], abund, z[halo], 1.0) spec.rescale_flux(flux_kcorr[halo], emin=emin, emax=emax, flux_type="energy") if nH is not None: spec.apply_foreground_absorption(nH, model=absorb_model) e = spec.generate_energies(exp_time, area, prng=prng, quiet=True) beta_model = BetaModel(ra0[halo], dec0[halo], rc[halo], beta[halo], ellipticity=ellip[halo], theta=theta[halo]) xsky, ysky = beta_model.generate_coords(e.size, prng=prng) tot_flux += e.flux ee.append(e.value) ra.append(xsky.value) dec.append(ysky.value) pbar.update() pbar.close() ra = np.concatenate(ra) dec = np.concatenate(dec) ee = np.concatenate(ee) mylog.info("Created %d photons from cosmological sources." % ee.size) output_events = {"ra": ra, "dec": dec, "energy": ee, "flux": tot_flux.value} return output_events
def __init__(self, emin, emax, nbins, var_elem=None, apec_root=None, apec_vers=None, broadening=True, nolines=False, abund_table=None, nei=False): if apec_vers is None: filedir = os.path.join(os.path.dirname(__file__), 'files') cfile = glob.glob("%s/apec_*_coco.fits" % filedir)[0] apec_vers = cfile.split("/")[-1].split("_")[1][1:] mylog.info("Using APEC version %s." % apec_vers) if nei and apec_root is None: raise RuntimeError("The NEI APEC tables are not supplied with " "SOXS! Download them from http://www.atomdb.org " "and set 'apec_root' to their location.") if nei and var_elem is None: raise RuntimeError("For NEI spectra, you must specify which elements " "you want to vary using the 'var_elem' argument!") self.nei = nei emin = parse_value(emin, "keV") emax = parse_value(emax, 'keV') self.emin = emin self.emax = emax self.nbins = nbins self.ebins = np.linspace(self.emin, self.emax, nbins+1) self.de = np.diff(self.ebins) self.emid = 0.5*(self.ebins[1:]+self.ebins[:-1]) if apec_root is None: apec_root = soxs_files_path if nei: neistr = "_nei" ftype = "comp" else: neistr = "" ftype = "coco" self.cocofile = os.path.join(apec_root, "apec_v%s%s_%s.fits" % (apec_vers, neistr, ftype)) self.linefile = os.path.join(apec_root, "apec_v%s%s_line.fits" % (apec_vers, neistr)) if not os.path.exists(self.cocofile) or not os.path.exists(self.linefile): raise IOError("Cannot find the APEC files!\n %s\n, %s" % (self.cocofile, self.linefile)) mylog.info("Using %s for generating spectral lines." % os.path.split(self.linefile)[-1]) mylog.info("Using %s for generating the continuum." % os.path.split(self.cocofile)[-1]) self.nolines = nolines self.wvbins = hc/self.ebins[::-1] self.broadening = broadening try: self.line_handle = pyfits.open(self.linefile) except IOError: raise IOError("Line file %s does not exist" % self.linefile) try: self.coco_handle = pyfits.open(self.cocofile) except IOError: raise IOError("Continuum file %s does not exist" % self.cocofile) self.Tvals = self.line_handle[1].data.field("kT") self.nT = len(self.Tvals) self.dTvals = np.diff(self.Tvals) self.minlam = self.wvbins.min() self.maxlam = self.wvbins.max() self.var_elem_names = [] self.var_ion_names = [] if var_elem is None: self.var_elem = np.empty((0,1), dtype='int') else: self.var_elem = [] if len(var_elem) != len(set(var_elem)): raise RuntimeError("Duplicates were found in the \"var_elem\" list! %s" % var_elem) for elem in var_elem: if "^" in elem: if not self.nei: raise RuntimeError("Cannot use different ionization states with a " "CIE plasma!") el = elem.split("^") e = el[0] ion = int(el[1]) else: if self.nei: raise RuntimeError("Variable elements must include the ionization " "state for NEI plasmas!") e = elem ion = 0 self.var_elem.append([elem_names.index(e), ion]) self.var_elem.sort(key=lambda x: (x[0], x[1])) self.var_elem = np.array(self.var_elem, dtype='int') self.var_elem_names = [elem_names[e[0]] for e in self.var_elem] self.var_ion_names = ["%s^%d" % (elem_names[e[0]], e[1]) for e in self.var_elem] self.num_var_elem = len(self.var_elem) if self.nei: self.cosmic_elem = [elem for elem in [1, 2] if elem not in self.var_elem[:, 0]] self.metal_elem = [] else: self.cosmic_elem = [elem for elem in cosmic_elem if elem not in self.var_elem[:,0]] self.metal_elem = [elem for elem in metal_elem if elem not in self.var_elem[:,0]] if abund_table is None: abund_table = soxs_cfg.get("soxs", "abund_table") if not isinstance(abund_table, string_types): if len(abund_table) != 30: raise RuntimeError("User-supplied abundance tables " "must be 30 elements long!") self.atable = np.concatenate([[0.0], np.array(abund_table)]) else: self.atable = abund_tables[abund_table].copy() self._atable = self.atable.copy() self._atable[1:] /= abund_tables["angr"][1:]
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, \ ConvolvedBackgroundSpectrum 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 = ConvolvedBackgroundSpectrum(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_cosmological_sources(exp_time, fov, sky_center, cat_center=None, absorb_model="wabs", nH=0.05, area=40000.0, output_sources=None, write_regions=None, prng=None): r""" Make an X-ray source made up of contributions from galaxy clusters, galaxy groups, and galaxies. Parameters ---------- exp_time : float, (value, unit) tuple, or :class:`~astropy.units.Quantity` The exposure time of the observation in seconds. fov : float, (value, unit) tuple, or :class:`~astropy.units.Quantity` The field of view in arcminutes. sky_center : array-like The center RA, Dec of the field of view in degrees. cat_center : array-like The center of the field in the coordinates of the halo catalog, which range from -5.0 to 5.0 in degrees in both directions. If None is given, a center will be randomly chosen. absorb_model : string, optional The absorption model to use, "wabs" or "tbabs". Default: "wabs" nH : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`, optional The hydrogen column in units of 10**22 atoms/cm**2. Default: 0.05 area : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`, optional The effective area in cm**2. It must be large enough so that a sufficiently large sample is drawn for the ARF. Default: 40000. output_sources : string, optional If set to a filename, output the properties of the sources within the field of view to a file. Default: None write_regions : string, optional If set to a filename, output circle ds9 regions corresponding to the positions of the halos with radii corresponding to their R500 projected on the sky. Default: None 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") fov = parse_value(fov, "arcmin") if nH is not None: nH = parse_value(nH, "1.0e22*cm**-2") area = parse_value(area, "cm**2") prng = parse_prng(prng) cosmo = FlatLambdaCDM(H0=100.0*h0, Om0=omega_m) agen = ApecGenerator(0.1, 10.0, 10000, broadening=False) mylog.info("Creating photons from cosmological sources.") mylog.info("Loading halo data from catalog: %s" % halos_cat_file) halo_data = h5py.File(halos_cat_file, "r") scale = cosmo.kpc_comoving_per_arcmin(halo_data["redshift"][()]).to("Mpc/arcmin") # 600. arcmin = 10 degrees (total FOV of catalog = 100 deg^2) fov_cat = 10.0*60.0 w = construct_wcs(*sky_center) cat_min = -0.5*fov_cat cat_max = 0.5*fov_cat if cat_center is None: xc, yc = prng.uniform(low=cat_min+0.5*fov, high=cat_max-0.5*fov, size=2) else: xc, yc = cat_center xc *= 60.0 yc *= 60.0 xc, yc = np.clip([xc, yc], cat_min+0.5*fov, cat_max-0.5*fov) mylog.info("Coordinates of the FOV within the catalog are (%g, %g) deg." % (xc/60.0, yc/60.0)) xlo = (xc-1.1*0.5*fov) xhi = (xc+1.1*0.5*fov) ylo = (yc-1.1*0.5*fov) yhi = (yc+1.1*0.5*fov) mylog.info("Selecting halos in the FOV.") halo_x = halo_data["x"][()].astype("float64")/(h0*scale.value) halo_y = halo_data["y"][()].astype("float64")/(h0*scale.value) fov_idxs = (halo_x >= xlo) & (halo_x <= xhi) fov_idxs = (halo_y >= ylo) & (halo_y <= yhi) & fov_idxs n_halos = fov_idxs.sum() mylog.info("Number of halos in the field of view: %d" % n_halos) # Now select the specific halos which are in the FOV z = halo_data["redshift"][fov_idxs].astype("float64") m = halo_data["M500c"][fov_idxs].astype("float64")/h0 # We need to compute proper scales here s = scale[fov_idxs].to("Mpc/arcsec").value/(1.0+z) ra0, dec0 = w.wcs_pix2world((halo_x[fov_idxs]-xc)*60.0, (halo_y[fov_idxs]-yc)*60.0, 1) # Close the halo catalog file halo_data.close() # Some cosmological stuff rho_crit = cosmo.critical_density(z).to("Msun/Mpc**3").value # halo temperature and k-corrected flux kT = Tx(m, z) flux_kcorr = 1.0e-14*lum(m, z)/flux2lum(kT, z) # halo scale radius r500 = (3.0*m/(4.0*np.pi*500*rho_crit))**(1.0/3.0) r500_kpc = r500 * 1000.0 rc_kpc = r500/conc * 1000.0 rc = r500/conc/s # Halo slope parameter beta = prng.normal(loc=0.666, scale=0.05, size=n_halos) beta[beta < 0.5] = 0.5 # Halo ellipticity ellip = prng.normal(loc=0.85, scale=0.15, size=n_halos) ellip[ellip < 0.0] = 1.0e-3 # Halo orientation theta = 360.0*prng.uniform(size=n_halos) # If requested, output the source properties to a file if output_sources is not None: t = Table([ra0, dec0, rc_kpc, beta, ellip, theta, m, r500_kpc, kT, z, flux_kcorr], names=('RA', 'Dec', 'r_c', 'beta', 'ellipticity', 'theta', 'M500c', 'r500', 'kT', 'redshift', 'flux_0.5_2.0_keV')) t["RA"].unit = "deg" t["Dec"].unit = "deg" t["flux_0.5_2.0_keV"].unit = "erg/(cm**2*s)" t["r_c"].unit = "kpc" t["theta"].unit = "deg" t["M500c"].unit = "solMass" t["r500"].unit = "kpc" t["kT"].unit = "kT" t.write(output_sources, format='ascii.ecsv', overwrite=True) if write_regions is not None: from regions import CircleSkyRegion, write_ds9 from astropy.coordinates import Angle, SkyCoord regs = [] for halo in range(n_halos): c = SkyCoord(ra0[halo], dec0[halo], unit=("deg", "deg"), frame='fk5') scale = cosmo.kpc_proper_per_arcmin(z[halo]).to("kpc/deg") r500c = r500_kpc / scale.value r = Angle(r500c, 'deg') reg = CircleSkyRegion(c, r) regs.append(reg) write_ds9(regs, write_regions) tot_flux = 0.0 ee = [] ra = [] dec = [] pbar = tqdm(leave=True, total=n_halos, desc="Generating photons from halos ") for halo in range(n_halos): spec = agen.get_spectrum(kT[halo], abund, z[halo], 1.0) spec.rescale_flux(flux_kcorr[halo], emin=emin, emax=emax, flux_type="energy") if nH is not None: spec.apply_foreground_absorption(nH, model=absorb_model) e = spec.generate_energies(exp_time, area, prng=prng, quiet=True) beta_model = BetaModel(ra0[halo], dec0[halo], rc[halo], beta[halo], ellipticity=ellip[halo], theta=theta[halo]) xsky, ysky = beta_model.generate_coords(e.size, prng=prng) tot_flux += e.flux ee.append(e.value) ra.append(xsky.value) dec.append(ysky.value) pbar.update() pbar.close() ra = np.concatenate(ra) dec = np.concatenate(dec) ee = np.concatenate(ee) mylog.info("Created %d photons from cosmological sources." % ee.size) output_events = {"ra": ra, "dec": dec, "energy": ee, "flux": tot_flux.value} return output_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 instrument_simulator(input_events, out_file, exp_time, instrument, sky_center, overwrite=False, instr_bkgnd=True, foreground=True, ptsrc_bkgnd=True, bkgnd_file=None, no_dither=False, dither_params=None, roll_angle=0.0, subpixel_res=False, prng=None): """ Take unconvolved events and create an event file from them. This function calls generate_events to do 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 and then calls make_background to add instrumental and astrophysical backgrounds, unless a background file is provided, in which case the background events are read from this file. The events are then written out to a file. 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. overwrite : boolean, optional Whether or not to overwrite an existing file with the same name. Default: False instr_bkgnd : boolean, optional Whether or not to include the instrumental/particle background. Default: True foreground : boolean, optional Whether or not to include the local foreground. Default: True ptsrc_bkgnd : boolean, optional Whether or not to include the point-source background. Default: True bkgnd_file : string, optional If set, backgrounds will be loaded from this file and not generated on the fly. Default: None 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. Examples -------- >>> instrument_simulator("sloshing_simput.fits", "sloshing_evt.fits", ... 300000.0, "hdxi_3x10", [30., 45.], overwrite=True) """ from soxs.background import add_background_from_file if not out_file.endswith(".fits"): out_file += ".fits" mylog.info("Making observation of source in %s." % out_file) # Make the source first 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) # If the user wants backgrounds, either make the background or add an already existing # background event file. It may be necessary to reproject events to a new coordinate system. if bkgnd_file is None: if not instr_bkgnd and not ptsrc_bkgnd and not foreground: mylog.info("No backgrounds will be added to this observation.") else: mylog.info("Adding background events.") bkg_events, _ = make_background(exp_time, instrument, sky_center, foreground=foreground, instr_bkgnd=instr_bkgnd, no_dither=no_dither, dither_params=dither_params, ptsrc_bkgnd=ptsrc_bkgnd, prng=prng, subpixel_res=subpixel_res, roll_angle=roll_angle) for key in events: events[key] = np.concatenate([events[key], bkg_events[key]]) else: mylog.info("Adding background events from the file %s." % bkgnd_file) if not os.path.exists(bkgnd_file): raise IOError("Cannot find the background event file %s!" % bkgnd_file) events = add_background_from_file(events, event_params, bkgnd_file) if len(events["energy"]) == 0: raise RuntimeError("No events were detected from source or background!!") write_event_file(events, event_params, out_file, overwrite=overwrite) mylog.info("Observation complete.")
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 __init__(self, emin, emax, nbins, var_elem=None, apec_root=None, apec_vers=None, broadening=True, nolines=False, abund_table=None, nei=False): if apec_vers is None: filedir = os.path.join(os.path.dirname(__file__), 'files') cfile = glob.glob("%s/apec_*_coco.fits" % filedir)[0] apec_vers = cfile.split("/")[-1].split("_")[1][1:] mylog.info("Using APEC version %s." % apec_vers) if nei and apec_root is None: raise RuntimeError( "The NEI APEC tables are not supplied with " "SOXS! Download them from http://www.atomdb.org " "and set 'apec_root' to their location.") if nei and var_elem is None: raise RuntimeError( "For NEI spectra, you must specify which elements " "you want to vary using the 'var_elem' argument!") self.nei = nei emin = parse_value(emin, "keV") emax = parse_value(emax, 'keV') self.emin = emin self.emax = emax self.nbins = nbins self.ebins = np.linspace(self.emin, self.emax, nbins + 1) self.de = np.diff(self.ebins) self.emid = 0.5 * (self.ebins[1:] + self.ebins[:-1]) if apec_root is None: apec_root = soxs_files_path if nei: neistr = "_nei" ftype = "comp" else: neistr = "" ftype = "coco" self.cocofile = os.path.join( apec_root, "apec_v%s%s_%s.fits" % (apec_vers, neistr, ftype)) self.linefile = os.path.join( apec_root, "apec_v%s%s_line.fits" % (apec_vers, neistr)) if not os.path.exists(self.cocofile) or not os.path.exists( self.linefile): raise IOError("Cannot find the APEC files!\n %s\n, %s" % (self.cocofile, self.linefile)) mylog.info("Using %s for generating spectral lines." % os.path.split(self.linefile)[-1]) mylog.info("Using %s for generating the continuum." % os.path.split(self.cocofile)[-1]) self.nolines = nolines self.wvbins = hc / self.ebins[::-1] self.broadening = broadening try: self.line_handle = pyfits.open(self.linefile) except IOError: raise IOError("Line file %s does not exist" % self.linefile) try: self.coco_handle = pyfits.open(self.cocofile) except IOError: raise IOError("Continuum file %s does not exist" % self.cocofile) self.Tvals = self.line_handle[1].data.field("kT") self.nT = len(self.Tvals) self.dTvals = np.diff(self.Tvals) self.minlam = self.wvbins.min() self.maxlam = self.wvbins.max() self.var_elem_names = [] self.var_ion_names = [] if var_elem is None: self.var_elem = np.empty((0, 1), dtype='int') else: self.var_elem = [] if len(var_elem) != len(set(var_elem)): raise RuntimeError( "Duplicates were found in the \"var_elem\" list! %s" % var_elem) for elem in var_elem: if "^" in elem: if not self.nei: raise RuntimeError( "Cannot use different ionization states with a " "CIE plasma!") el = elem.split("^") e = el[0] ion = int(el[1]) else: if self.nei: raise RuntimeError( "Variable elements must include the ionization " "state for NEI plasmas!") e = elem ion = 0 self.var_elem.append([elem_names.index(e), ion]) self.var_elem.sort(key=lambda x: (x[0], x[1])) self.var_elem = np.array(self.var_elem, dtype='int') self.var_elem_names = [elem_names[e[0]] for e in self.var_elem] self.var_ion_names = [ "%s^%d" % (elem_names[e[0]], e[1]) for e in self.var_elem ] self.num_var_elem = len(self.var_elem) if self.nei: self.cosmic_elem = [ elem for elem in [1, 2] if elem not in self.var_elem[:, 0] ] self.metal_elem = [] else: self.cosmic_elem = [ elem for elem in cosmic_elem if elem not in self.var_elem[:, 0] ] self.metal_elem = [ elem for elem in metal_elem if elem not in self.var_elem[:, 0] ] if abund_table is None: abund_table = soxs_cfg.get("soxs", "abund_table") if not isinstance(abund_table, string_types): if len(abund_table) != 30: raise RuntimeError("User-supplied abundance tables " "must be 30 elements long!") self.atable = np.concatenate([[0.0], np.array(abund_table)]) else: self.atable = abund_tables[abund_table].copy() self._atable = self.atable.copy() self._atable[1:] /= abund_tables["angr"][1:]
def make_mosaic_events(pointing_list, input_source, out_prefix, exp_time, instrument, overwrite=False, instr_bkgnd=True, foreground=True, ptsrc_bkgnd=True, bkgnd_file=None, no_dither=False, dither_params=None, subpixel_res=False, aimpt_shift=None, prng=None): """ Observe a source from many different pointings. Parameters ---------- pointing_list : list of tuples or str Either a list of tuples or a two-column ASCII table, containing RA and Dec pointings for each mock observation. input_source : string The path to the SIMPUT catalog file which contains the input source(s). out_prefix : string The prefix for the event files which will be generated. exp_time : float, (value, unit) tuple, or :class:`~astropy.units.Quantity` The exposure time in seconds. instrument : string The name of the instrument to use, which picks an instrument specification from the instrument registry. overwrite : boolean, optional Whether or not to overwrite an existing file with the same name. Default: False instr_bkgnd : boolean, optional Whether or not to include the instrumental/particle background. Default: True foreground : boolean, optional Whether or not to include the local foreground. Default: True ptsrc_bkgnd : boolean, optional Whether or not to include the point-source background. Default: True bkgnd_file : string, optional If set, backgrounds will be loaded from this file and not generated on the fly. Default: None 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]. 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. """ if isinstance(pointing_list, str): t = ascii.read(pointing_list, format='commented_header', guess=False, header_start=0, delimiter="\t") elif not isinstance(pointing_list, Table): t = Table(np.array(pointing_list), names=["ra", "dec"]) out_list = [] for i, row in enumerate(t): out_file = f"{out_prefix}_{i}_evt.fits" out_list.append(out_file) instrument_simulator(input_source, out_file, exp_time, instrument, (row["ra"], row["dec"]), overwrite=overwrite, instr_bkgnd=instr_bkgnd, foreground=foreground, ptsrc_bkgnd=ptsrc_bkgnd, bkgnd_file=bkgnd_file, no_dither=no_dither, dither_params=dither_params, subpixel_res=subpixel_res, aimpt_shift=aimpt_shift, prng=prng) t["evtfile"] = out_list outfile = f"{out_prefix}_event_mosaic.dat" mylog.info(f"Writing mosaic information to {outfile}.") t.write(outfile, overwrite=overwrite, delimiter="\t", format='ascii.commented_header') return outfile
def instrument_simulator(input_events, out_file, exp_time, instrument, sky_center, overwrite=False, instr_bkgnd=True, foreground=True, ptsrc_bkgnd=True, bkgnd_file=None, no_dither=False, dither_params=None, roll_angle=0.0, subpixel_res=False, aimpt_shift=None, prng=None): """ Take unconvolved events and create an event file from them. This function calls generate_events to do 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 and then calls make_background to add instrumental and astrophysical backgrounds, unless a background file is provided, in which case the background events are read from this file. The events are then written out to a file. 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. overwrite : boolean, optional Whether or not to overwrite an existing file with the same name. Default: False instr_bkgnd : boolean, optional Whether or not to include the instrumental/particle background. Default: True foreground : boolean, optional Whether or not to include the local foreground. Default: True ptsrc_bkgnd : boolean, optional Whether or not to include the point-source background. Default: True bkgnd_file : string, optional If set, backgrounds will be loaded from this file and not generated on the fly. Default: None 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. Examples -------- >>> instrument_simulator("sloshing_simput.fits", "sloshing_evt.fits", ... 300000.0, "lynx_hdxi", [30., 45.], overwrite=True) """ from soxs.background import add_background_from_file if not out_file.endswith(".fits"): out_file += ".fits" mylog.info(f"Making observation of source in {out_file}.") # Make the source first 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, aimpt_shift=aimpt_shift, prng=prng) # If the user wants backgrounds, either make the background or add an already existing # background event file. It may be necessary to reproject events to a new coordinate system. if bkgnd_file is None: if not instr_bkgnd and not ptsrc_bkgnd and not foreground: mylog.info("No backgrounds will be added to this observation.") else: mylog.info("Adding background events.") bkg_events, _ = make_background(exp_time, instrument, sky_center, foreground=foreground, instr_bkgnd=instr_bkgnd, no_dither=no_dither, dither_params=dither_params, ptsrc_bkgnd=ptsrc_bkgnd, prng=prng, subpixel_res=subpixel_res, roll_angle=roll_angle, aimpt_shift=aimpt_shift) for key in events: events[key] = np.concatenate([events[key], bkg_events[key]]) else: mylog.info(f"Adding background events from the file {bkgnd_file}.") if not os.path.exists(bkgnd_file): raise IOError( f"Cannot find the background event file {bkgnd_file}!") events = add_background_from_file(events, event_params, bkgnd_file) if len(events["energy"]) == 0: raise RuntimeError( "No events were detected from source or background!!") write_event_file(events, event_params, out_file, overwrite=overwrite) mylog.info("Observation complete.")
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 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 write_event_file(events, parameters, filename, overwrite=False): from astropy.time import Time, TimeDelta mylog.info("Writing events to file %s." % filename) t_begin = Time.now() dt = TimeDelta(parameters["exposure_time"], format='sec') t_end = t_begin + dt col_x = pyfits.Column(name='X', format='D', unit='pixel', array=events["xpix"]) col_y = pyfits.Column(name='Y', format='D', unit='pixel', array=events["ypix"]) col_e = pyfits.Column(name='ENERGY', format='E', unit='eV', array=events["energy"] * 1000.) col_dx = pyfits.Column(name='DETX', format='D', unit='pixel', array=events["detx"]) col_dy = pyfits.Column(name='DETY', format='D', unit='pixel', array=events["dety"]) col_id = pyfits.Column(name='CCD_ID', format='D', unit='pixel', array=events["ccd_id"]) chantype = parameters["channel_type"] if chantype == "PHA": cunit = "adu" elif chantype == "PI": cunit = "Chan" col_ch = pyfits.Column(name=chantype.upper(), format='1J', unit=cunit, array=events[chantype]) col_t = pyfits.Column(name="TIME", format='1D', unit='s', array=events['time']) cols = [col_e, col_x, col_y, col_ch, col_t, col_dx, col_dy, col_id] coldefs = pyfits.ColDefs(cols) tbhdu = pyfits.BinTableHDU.from_columns(coldefs) tbhdu.name = "EVENTS" tbhdu.header["MTYPE1"] = "sky" tbhdu.header["MFORM1"] = "x,y" tbhdu.header["MTYPE2"] = "EQPOS" tbhdu.header["MFORM2"] = "RA,DEC" tbhdu.header["TCTYP2"] = "RA---TAN" tbhdu.header["TCTYP3"] = "DEC--TAN" tbhdu.header["TCRVL2"] = parameters["sky_center"][0] tbhdu.header["TCRVL3"] = parameters["sky_center"][1] tbhdu.header["TCDLT2"] = -parameters["plate_scale"] tbhdu.header["TCDLT3"] = parameters["plate_scale"] tbhdu.header["TCRPX2"] = parameters["pix_center"][0] tbhdu.header["TCRPX3"] = parameters["pix_center"][1] tbhdu.header["TCUNI2"] = "deg" tbhdu.header["TCUNI3"] = "deg" tbhdu.header["TLMIN2"] = 0.5 tbhdu.header["TLMIN3"] = 0.5 tbhdu.header["TLMAX2"] = 2.0 * parameters["num_pixels"] + 0.5 tbhdu.header["TLMAX3"] = 2.0 * parameters["num_pixels"] + 0.5 tbhdu.header["TLMIN4"] = parameters["chan_lim"][0] tbhdu.header["TLMAX4"] = parameters["chan_lim"][1] tbhdu.header["TLMIN6"] = -0.5 * parameters["num_pixels"] tbhdu.header["TLMAX6"] = 0.5 * parameters["num_pixels"] tbhdu.header["TLMIN7"] = -0.5 * parameters["num_pixels"] tbhdu.header["TLMAX7"] = 0.5 * parameters["num_pixels"] tbhdu.header["EXPOSURE"] = parameters["exposure_time"] tbhdu.header["TSTART"] = 0.0 tbhdu.header["TSTOP"] = parameters["exposure_time"] tbhdu.header["HDUVERS"] = "1.1.0" tbhdu.header["RADECSYS"] = "FK5" tbhdu.header["EQUINOX"] = 2000.0 tbhdu.header["HDUCLASS"] = "OGIP" tbhdu.header["HDUCLAS1"] = "EVENTS" tbhdu.header["HDUCLAS2"] = "ACCEPTED" tbhdu.header["DATE"] = t_begin.tt.isot tbhdu.header["DATE-OBS"] = t_begin.tt.isot tbhdu.header["DATE-END"] = t_end.tt.isot tbhdu.header["RESPFILE"] = os.path.split(parameters["rmf"])[-1] tbhdu.header["PHA_BINS"] = parameters["nchan"] tbhdu.header["ANCRFILE"] = os.path.split(parameters["arf"])[-1] tbhdu.header["CHANTYPE"] = parameters["channel_type"] tbhdu.header["MISSION"] = parameters["mission"] tbhdu.header["TELESCOP"] = parameters["telescope"] tbhdu.header["INSTRUME"] = parameters["instrument"] tbhdu.header["RA_PNT"] = parameters["sky_center"][0] tbhdu.header["DEC_PNT"] = parameters["sky_center"][1] tbhdu.header["ROLL_PNT"] = parameters["roll_angle"] tbhdu.header["AIMPT_X"] = parameters["aimpt_coords"][0] tbhdu.header["AIMPT_Y"] = parameters["aimpt_coords"][1] if parameters["dither_params"]["dither_on"]: tbhdu.header["DITHXAMP"] = parameters["dither_params"]["x_amp"] tbhdu.header["DITHYAMP"] = parameters["dither_params"]["y_amp"] tbhdu.header["DITHXPER"] = parameters["dither_params"]["x_period"] tbhdu.header["DITHYPER"] = parameters["dither_params"]["y_period"] start = pyfits.Column(name='START', format='1D', unit='s', array=np.array([0.0])) stop = pyfits.Column(name='STOP', format='1D', unit='s', array=np.array([parameters["exposure_time"]])) tbhdu_gti = pyfits.BinTableHDU.from_columns([start, stop]) tbhdu_gti.name = "STDGTI" tbhdu_gti.header["TSTART"] = 0.0 tbhdu_gti.header["TSTOP"] = parameters["exposure_time"] tbhdu_gti.header["HDUCLASS"] = "OGIP" tbhdu_gti.header["HDUCLAS1"] = "GTI" tbhdu_gti.header["HDUCLAS2"] = "STANDARD" tbhdu_gti.header["RADECSYS"] = "FK5" tbhdu_gti.header["EQUINOX"] = 2000.0 tbhdu_gti.header["DATE"] = t_begin.tt.isot tbhdu_gti.header["DATE-OBS"] = t_begin.tt.isot tbhdu_gti.header["DATE-END"] = t_end.tt.isot hdulist = [pyfits.PrimaryHDU(), tbhdu, tbhdu_gti] pyfits.HDUList(hdulist).writeto(filename, overwrite=overwrite)
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 make_instrument_background(bkgnd_name, event_params, rmf, prng=None): import pyregion._region_filter as rfilter prng = parse_prng(prng) if event_params["chips"] is None: bkgnd_spec = [instrument_backgrounds[bkgnd_name]] else: if isinstance(bkgnd_name, string_types): nchips = len(event_params["chips"]) bkgnd_names = [bkgnd_name] * nchips else: bkgnd_names = bkgnd_name bkgnd_spec = [] for name in bkgnd_names: spec = instrument_backgrounds[name].new_spec_from_band( rmf.elo[0], rmf.ehi[-1]) bkgnd_spec.append(spec) bkg_events = {} nx = event_params["num_pixels"] if event_params["chips"] is None: bkg_events["energy"] = bkgnd_spec[0].generate_energies( event_params["exposure_time"], event_params["fov"], prng=prng, quiet=True).value n_events = bkg_events["energy"].size bkg_events["chip_id"] = np.zeros(n_events, dtype='int') 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) else: bkg_events["energy"] = [] bkg_events["detx"] = [] bkg_events["dety"] = [] bkg_events["chip_id"] = [] for i, chip in enumerate(event_params["chips"]): e = bkgnd_spec[i].generate_energies(event_params["exposure_time"], event_params["fov"], prng=prng, quiet=True).value n_events = e.size detx = prng.uniform(low=-0.5 * nx, high=0.5 * nx, size=n_events) dety = prng.uniform(low=-0.5 * nx, high=0.5 * nx, size=n_events) thisc = np.ones(n_events, dtype='bool') rtype = chip[0] args = chip[1:] r = getattr(rfilter, rtype)(*args) inside = r.inside(detx, dety) thisc = np.logical_and(thisc, inside) bkg_events["energy"].append(e[thisc]) bkg_events["detx"].append(detx[thisc]) bkg_events["dety"].append(dety[thisc]) bkg_events["chip_id"].append(i * np.ones(thisc.sum())) for key in bkg_events: bkg_events[key] = np.concatenate(bkg_events[key]) if bkg_events["energy"].size == 0: raise RuntimeError( "No instrumental background events were detected!!!") else: mylog.info("Making %d events from the instrumental background." % bkg_events["energy"].size) return make_diffuse_background(bkg_events, event_params, rmf, prng=prng)
def __init__(self, emin, emax, nbins, var_elem=None, apec_root=None, apec_vers=None, broadening=True, nolines=False, abund_table=None, nei=False): if apec_vers is None: apec_vers = default_apec_vers mylog.info(f"Using APEC version {apec_vers}.") if nei and var_elem is None: raise RuntimeError("For NEI spectra, you must specify which elements " "you want to vary using the 'var_elem' argument!") self.nei = nei emin = parse_value(emin, "keV") emax = parse_value(emax, 'keV') self.emin = emin self.emax = emax self.nbins = nbins self.ebins = np.linspace(self.emin, self.emax, nbins+1) self.de = np.diff(self.ebins) self.emid = 0.5*(self.ebins[1:]+self.ebins[:-1]) if nei: neistr = "_nei" ftype = "comp" else: neistr = "" ftype = "coco" cocofile = f"apec_v{apec_vers}{neistr}_{ftype}.fits" linefile = f"apec_v{apec_vers}{neistr}_line.fits" if apec_root is None: self.cocofile = get_data_file(cocofile) self.linefile = get_data_file(linefile) else: self.cocofile = os.path.join(apec_root, cocofile) self.linefile = os.path.join(apec_root, linefile) if not os.path.exists(self.cocofile) or not os.path.exists(self.linefile): raise IOError(f"Cannot find the APEC files!\n {self.cocofile}\n, " f"{self.linefile}") mylog.info(f"Using {cocofile} for generating spectral lines.") mylog.info(f"Using {linefile} for generating the continuum.") self.nolines = nolines self.wvbins = hc/self.ebins[::-1] self.broadening = broadening self.line_handle = pyfits.open(self.linefile) self.coco_handle = pyfits.open(self.cocofile) self.nT = self.line_handle[1].data.shape[0] self.Tvals = self.line_handle[1].data.field("kT") self.dTvals = np.diff(self.Tvals) self.minlam = self.wvbins.min() self.maxlam = self.wvbins.max() self.var_elem_names = [] self.var_ion_names = [] if var_elem is None: self.var_elem = np.empty((0, 1), dtype='int') else: self.var_elem = [] if len(var_elem) != len(set(var_elem)): raise RuntimeError("Duplicates were found in the \"var_elem\" list! %s" % var_elem) for elem in var_elem: if "^" in elem: if not self.nei: raise RuntimeError("Cannot use different ionization states with a " "CIE plasma!") el = elem.split("^") e = el[0] ion = int(el[1]) else: if self.nei: raise RuntimeError("Variable elements must include the ionization " "state for NEI plasmas!") e = elem ion = 0 self.var_elem.append([elem_names.index(e), ion]) self.var_elem.sort(key=lambda x: (x[0], x[1])) self.var_elem = np.array(self.var_elem, dtype='int') self.var_elem_names = [elem_names[e[0]] for e in self.var_elem] self.var_ion_names = ["%s^%d" % (elem_names[e[0]], e[1]) for e in self.var_elem] self.num_var_elem = len(self.var_elem) if self.nei: self.cosmic_elem = [elem for elem in [1, 2] if elem not in self.var_elem[:, 0]] self.metal_elem = [] else: self.cosmic_elem = [elem for elem in cosmic_elem if elem not in self.var_elem[:,0]] self.metal_elem = [elem for elem in metal_elem if elem not in self.var_elem[:,0]] if abund_table is None: abund_table = soxs_cfg.get("soxs", "abund_table") if not isinstance(abund_table, str): if len(abund_table) != 30: raise RuntimeError("User-supplied abundance tables " "must be 30 elements long!") self.atable = np.concatenate([[0.0], np.array(abund_table)]) else: self.atable = abund_tables[abund_table].copy() self._atable = self.atable.copy() self._atable[1:] /= abund_tables["angr"][1:]
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, aimpt_shift=None, 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 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. """ 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(f"Instrument {instrument} is not in the " f"instrument registry!") if not instrument_spec["imaging"]: raise RuntimeError(f"Instrument '{instrument_spec['name']}' is not " f"designed for imaging observations!") fov = instrument_spec["fov"] input_events = defaultdict(list) arf_file = get_data_file(instrument_spec["arf"]) arf = AuxiliaryResponseFile(arf_file) rmf_file = get_data_file(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["src_names"].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, aimpt_shift=aimpt_shift, prng=prng) mylog.info(f"Generated {events['energy'].size} photons from " f"the point-source background.") else: nx = instrument_spec["num_pixels"] plate_scale = instrument_spec["fov"] / nx / 60.0 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 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": plate_scale, "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"], "aimpt_shift": aimpt_shift } 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, event_params, rmf, prng=prng) for key in bkg_events: events[key] = np.concatenate([events[key], bkg_events[key]]) return events, event_params
def instrument_simulator(simput_file, out_file, exp_time, instrument, sky_center, clobber=False, dither_shape="square", dither_size=16.0, roll_angle=0.0, astro_bkgnd=True, instr_bkgnd=True, prng=np.random): """ Take unconvolved events in a SIMPUT catalog and create an event file from them. This function does the following: 1. Determines which events are observed using the ARF 2. Pixelizes the events, applying PSF effects and dithering 3. Adds instrumental and astrophysical background events 4. Determines energy channels using the RMF 5. Writes the events to a file Parameters ---------- simput_file : string The SIMPUT catalog file to be used as input. out_file : string The name of the event file to be written. exp_time : float 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. Can also be a JSON file with a new instrument specification. If this is the case, it will be loaded into the instrument registry. sky_center : array, tuple, or list The center RA, Dec coordinates of the observation, in degrees. clobber : boolean, optional Whether or not to clobber an existing file with the same name. Default: False dither_shape : string The shape of the dither. Currently "circle" or "square" Default: "square" dither_size : float The size of the dither in arcseconds. Width of square or radius of circle. Default: 16.0 roll_angle : float The roll angle of the observation in degrees. Default: 0.0 astro_bkgnd : boolean, optional Whether or not to include astrophysical background. Default: True instr_bkgnd : boolean, optional Whether or not to include instrumental/particle background. Default: True prng : :class:`~numpy.random.RandomState` object or :mod:`~numpy.random`, optional 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 the :mod:`numpy.random` module. Examples -------- >>> instrument_simulator("sloshing_simput.fits", "sloshing_evt.fits", "hdxi_3x10", ... [30., 45.], clobber=True) """ event_list, parameters = read_simput_catalog(simput_file) 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) nx = instrument_spec["num_pixels"] plate_scale = instrument_spec["fov"] / nx / 60. # arcmin to deg plate_scale_arcsec = plate_scale * 3600.0 dsize = dither_size / plate_scale_arcsec event_params = {} event_params["exposure_time"] = exp_time event_params["arf"] = os.path.split(arf.filename)[-1] event_params["sky_center"] = sky_center event_params["pix_center"] = np.array([0.5 * (nx + 1)] * 2) event_params["num_pixels"] = nx event_params["plate_scale"] = plate_scale event_params["rmf"] = os.path.split(rmf.filename)[-1] event_params["channel_type"] = rmf.header["CHANTYPE"] event_params["telescope"] = rmf.header["TELESCOP"] event_params["instrument"] = rmf.header["INSTRUME"] event_params["mission"] = rmf.header.get("MISSION", "") event_params["nchan"] = rmf.ebounds_header["DETCHANS"] event_params["roll_angle"] = roll_angle event_params["fov"] = instrument_spec["fov"] num = 0 for i in range(1, rmf.num_mat_columns + 1): if rmf.header["TTYPE%d" % i] == "F_CHAN": num = i break event_params["chan_lim"] = [ rmf.header["TLMIN%d" % num], rmf.header["TLMAX%d" % num] ] 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 roll_angle = np.deg2rad(roll_angle) rot_mat = np.array([[np.sin(roll_angle), -np.cos(roll_angle)], [-np.cos(roll_angle), -np.sin(roll_angle)]]) all_events = {} first = True for i, evts in enumerate(event_list): mylog.info("Detecting events from source %d" % (i + 1)) # Step 1: Use ARF to determine which photons are observed mylog.info("Applying energy-dependent effective area from %s." % event_params["arf"]) 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 # Dither pixel coordinates x_offset = np.zeros(n_evt) y_offset = np.zeros(n_evt) if dither_shape == "circle": r = dsize * np.sqrt(prng.uniform(size=n_evt)) theta = 2. * np.pi * prng.uniform(size=n_evt) x_offset = r * np.cos(theta) y_offset = r * np.sin(theta) elif dither_shape == "square": x_offset = dsize * prng.uniform(low=-0.5, high=0.5, size=n_evt) y_offset = dsize * prng.uniform(low=-0.5, high=0.5, size=n_evt) xpix -= x_offset ypix -= y_offset # Rotate physical coordinates to detector coordinates det = np.dot(rot_mat, np.array([xpix, ypix])) detx = det[0, :] dety = det[1, :] # PSF scattering of detector coordinates 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 events["chipx"] = np.round(detx + event_params['pix_center'][0]) events["chipy"] = np.round(dety + event_params['pix_center'][1]) # Throw out events that don't fall on the chip keepx = np.logical_and(events["chipx"] >= 1.0, events["chipx"] <= nx) keepy = np.logical_and(events["chipy"] >= 1.0, events["chipy"] <= nx) keep = np.logical_and(keepx, keepy) mylog.info("%d events were rejected because " % (n_evt - keep.sum()) + "they fall outside the field of view.") n_evt = keep.sum() if n_evt == 0: mylog.warning( "No events are within the field of view for this source!!!" ) else: for key in events: events[key] = events[key][keep] # Convert chip coordinates back to detector coordinates events["detx"] = np.round( events["chipx"] - event_params['pix_center'][0] + prng.uniform(low=-0.5, high=0.5, size=n_evt)) events["dety"] = np.round( events["chipy"] - event_params['pix_center'][1] + prng.uniform(low=-0.5, high=0.5, size=n_evt)) # Convert detector coordinates back to pixel coordinates pix = np.dot(rot_mat, np.array([events["detx"], events["dety"]])) events["xpix"] = pix[ 0, :] + event_params['pix_center'][0] + x_offset[keep] events["ypix"] = pix[ 1, :] + event_params['pix_center'][1] + y_offset[keep] if n_evt > 0: for key in events: if first: all_events[key] = events[key] else: all_events[key] = np.concatenate( [all_events[key], events[key]]) first = False if all_events["energy"].size == 0: mylog.warning( "No events from any of the sources in the catalog were detected!") # Step 3: Add astrophysical background if astro_bkgnd: mylog.info("Adding in astrophysical background.") bkg_events = add_background(astro_bkgnd, event_params, rot_mat, prng=prng) for key in all_events: all_events[key] = np.concatenate( [all_events[key], bkg_events[key]]) # Step 4: Add particle background if instr_bkgnd: mylog.info("Adding in instrumental background.") bkg_events = add_background( instrument_spec["bkgnd"], event_params, rot_mat, prng=prng, focal_length=instrument_spec["focal_length"]) for key in all_events: all_events[key] = np.concatenate( [all_events[key], bkg_events[key]]) if all_events["energy"].size == 0: raise RuntimeError("No events were detected!!!") # Step 5: Scatter energies with RMF if all_events["energy"].size > 0: mylog.info("Scattering energies with RMF %s." % event_params['rmf']) all_events = rmf.scatter_energies(all_events, prng=prng) # Step 6: Add times to events all_events['time'] = np.random.uniform(size=all_events["energy"].size, low=0.0, high=event_params["exposure_time"]) write_event_file(all_events, event_params, out_file, clobber=clobber)
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.response import RedistributionMatrixFile, \ AuxiliaryResponseFile from soxs.spectra import ConvolvedSpectrum from soxs.background.foreground import hm_astro_bkgnd from soxs.background.spectra import BackgroundSpectrum from soxs.background.instrument import InstrumentalBackground prng = parse_prng(prng) exp_time = parse_value(exp_time, "s") try: instrument_spec = instrument_registry[instrument] except KeyError: raise KeyError( f"Instrument {instrument} is not in the instrument registry!") 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_data_file(instrument_spec["arf"]) rmf_file = get_data_file(instrument_spec["rmf"]) arf = AuxiliaryResponseFile(arf_file) rmf = RedistributionMatrixFile(rmf_file) event_params = { "RESPFILE": os.path.split(rmf.filename)[-1], "ANCRFILE": os.path.split(arf.filename)[-1], "TELESCOP": rmf.header["TELESCOP"], "INSTRUME": rmf.header["INSTRUME"], "MISSION": rmf.header.get("MISSION", "") } out_spec = np.zeros(rmf.n_ch) if spec is not None: cspec = ConvolvedSpectrum.convolve(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.convolve( 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.") bkgnd_spec = instrument_spec["bkgnd"] # Temporary hack for ACIS-S if "aciss" in instrument_spec["name"]: bkgnd_spec = bkgnd_spec[1] bkgnd_spec = InstrumentalBackground.from_filename( bkgnd_spec[0], bkgnd_spec[1], instrument_spec['focal_length']) out_spec += bkgnd_spec.generate_channel_spectrum(exp_time, bkgnd_area, 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.convolve(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_ptsrc_background(exp_time, fov, sky_center, absorb_model="wabs", nH=0.05, area=40000.0, input_sources=None, output_sources=None, prng=None): r""" Make a point-source background. Parameters ---------- exp_time : float, (value, unit) tuple, or :class:`~astropy.units.Quantity` The exposure time of the observation in seconds. fov : float, (value, unit) tuple, or :class:`~astropy.units.Quantity` The field of view in arcminutes. sky_center : array-like The center RA, Dec of the field of view in degrees. absorb_model : string, optional The absorption model to use, "wabs" or "tbabs". Default: "wabs" nH : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`, optional The hydrogen column in units of 10**22 atoms/cm**2. Default: 0.05 area : float, (value, unit) tuple, or :class:`~astropy.units.Quantity`, optional The effective area in cm**2. It must be large enough so that a sufficiently large sample is drawn for the ARF. Default: 40000. input_sources : string, optional If set to a filename, input the source positions, fluxes, and spectral indices from an ASCII table instead of generating them. Default: None output_sources : string, optional If set to a filename, output the properties of the sources within the field of view to a file. Default: None 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. """ prng = parse_prng(prng) exp_time = parse_value(exp_time, "s") fov = parse_value(fov, "arcmin") if nH is not None: nH = parse_value(nH, "1.0e22*cm**-2") area = parse_value(area, "cm**2") if input_sources is None: ra0, dec0, fluxes, ind = generate_sources(exp_time, fov, sky_center, area=area, prng=prng) num_sources = fluxes.size else: mylog.info("Reading in point-source properties from %s." % input_sources) t = ascii.read(input_sources) ra0 = t["RA"].data dec0 = t["Dec"].data fluxes = t["flux_0.5_2.0_keV"].data ind = t["index"].data num_sources = fluxes.size mylog.debug("Generating spectra from %d sources." % num_sources) # If requested, output the source properties to a file if output_sources is not None: t = Table([ra0, dec0, fluxes, ind], names=('RA', 'Dec', 'flux_0.5_2.0_keV', 'index')) t["RA"].unit = "deg" t["Dec"].unit = "deg" t["flux_0.5_2.0_keV"].unit = "erg/(cm**2*s)" t["index"].unit = "" t.write(output_sources, format='ascii.ecsv', overwrite=True) # Pre-calculate for optimization eratio = spec_emax/spec_emin oma = 1.0-ind invoma = 1.0/oma invoma[oma == 0.0] = 1.0 fac1 = spec_emin**oma fac2 = spec_emax**oma-fac1 fluxscale = get_flux_scale(ind, fb_emin, fb_emax, spec_emin, spec_emax) # Using the energy flux, determine the photon flux by simple scaling ref_ph_flux = fluxes*fluxscale*keV_per_erg # Now determine the number of photons we will generate n_photons = prng.poisson(ref_ph_flux*exp_time*area) all_energies = [] all_ra = [] all_dec = [] for i, nph in enumerate(n_photons): if nph > 0: # Generate the energies in the source frame u = prng.uniform(size=nph) if ind[i] == 1.0: energies = spec_emin*(eratio**u) else: energies = fac1[i] + u*fac2[i] energies **= invoma[i] # Assign positions for this source ra = ra0[i]*np.ones(nph) dec = dec0[i]*np.ones(nph) all_energies.append(energies) all_ra.append(ra) all_dec.append(dec) mylog.debug("Finished generating spectra.") all_energies = np.concatenate(all_energies) all_ra = np.concatenate(all_ra) all_dec = np.concatenate(all_dec) all_nph = all_energies.size # Remove some of the photons due to Galactic foreground absorption. # We will throw a lot of stuff away, but this is more general and still # faster. if nH is not None: if absorb_model == "wabs": absorb = get_wabs_absorb(all_energies, nH) elif absorb_model == "tbabs": absorb = get_tbabs_absorb(all_energies, nH) randvec = prng.uniform(size=all_energies.size) all_energies = all_energies[randvec < absorb] all_ra = all_ra[randvec < absorb] all_dec = all_dec[randvec < absorb] all_nph = all_energies.size mylog.debug("%d photons remain after foreground galactic absorption." % all_nph) all_flux = np.sum(all_energies)*erg_per_keV/(exp_time*area) output_events = {"ra": all_ra, "dec": all_dec, "energy": all_energies, "flux": all_flux} return output_events