def test_root_to_hdf_response(response):
r = hawc_response_factory(response)
test_filename = "response.hd5"
# Make sure it doesn't exist yet, if it does,remove it
if os.path.exists(test_filename):
os.remove(test_filename)
r.write(test_filename)
# Try to open and use it
r2 = hawc_response_factory(test_filename)
check_responses(r, r2)
os.remove(test_filename)
def __init__(self, name, maptree, response_file, roi, flat_sky_pixels_size=0.17):
# Store ROI
self._roi = roi
# Set up the flat-sky projection
self._flat_sky_projection = roi.get_flat_sky_projection(flat_sky_pixels_size)
# Read map tree (data)
self._maptree = map_tree_factory(maptree, roi=roi)
# Read detector response_file
self._response = hawc_response_factory(response_file)
# Use a renormalization of the background as nuisance parameter
# NOTE: it is fixed to 1.0 unless the user explicitly sets it free (experimental)
self._nuisance_parameters = collections.OrderedDict()
self._nuisance_parameters['%s_bkg_renorm' % name] = Parameter('%s_bkg_renorm' % name, 1.0,
min_value=0.5, max_value=1.5,
delta=0.01,
desc="Renormalization for background map",
free=False,
is_normalization=False)
# Instance parent class
super(HAL, self).__init__(name, self._nuisance_parameters)
self._likelihood_model = None
# These lists will contain the maps for the point sources
self._convolved_point_sources = ConvolvedSourcesContainer()
# and this one for extended sources
self._convolved_ext_sources = ConvolvedSourcesContainer()
# All energy/nHit bins are loaded in memory
self._all_planes = list(self._maptree.analysis_bins_labels)
# The active planes list always contains the list of *indexes* of the active planes
self._active_planes = None
# Set up the transformations from the flat-sky projection to Healpix, as well as the list of active pixels
# (one for each energy/nHit bin). We make a separate transformation because different energy bins might have
# different nsides
self._active_pixels = collections.OrderedDict()
self._flat_sky_to_healpix_transform = collections.OrderedDict()
for bin_id in self._maptree:
this_maptree = self._maptree[bin_id]
this_nside = this_maptree.nside
this_active_pixels = roi.active_pixels(this_nside)
this_flat_sky_to_hpx_transform = FlatSkyToHealpixTransform(self._flat_sky_projection.wcs,
'icrs',
this_nside,
this_active_pixels,
(self._flat_sky_projection.npix_width,
self._flat_sky_projection.npix_height),
order='bilinear')
self._active_pixels[bin_id] = this_active_pixels
self._flat_sky_to_healpix_transform[bin_id] = this_flat_sky_to_hpx_transform
# This will contain a list of PSF convolutors for extended sources, if there is any in the model
self._psf_convolutors = None
# Pre-compute the log-factorial factor in the likelihood, so we do not keep to computing it over and over
# again.
self._log_factorials = collections.OrderedDict()
# We also apply a bias so that the numerical value of the log-likelihood stays small. This helps when
# fitting with algorithms like MINUIT because the convergence criterium involves the difference between
# two likelihood values, which would be affected by numerical precision errors if the two values are
# too large
self._saturated_model_like_per_maptree = collections.OrderedDict()
# The actual computation is in a method so we can recall it on clone (see the get_simulated_dataset method)
self._compute_likelihood_biases()
# This will save a clone of self for simulations
self._clone = None
# Integration method for the PSF (see psf_integration_method)
self._psf_integration_method = "exact"