def predict(self,
hillas_dict,
inst,
array_pointing,
telescopes_pointings=None):
"""
The function you want to call for the reconstruction of the
event. It takes care of setting up the event and consecutively
calls the functions for the direction and core position
reconstruction. Shower parameters not reconstructed by this
class are set to np.nan
Parameters
-----------
hillas_dict: dict
dictionary with telescope IDs as key and
HillasParametersContainer instances as values
inst : ctapipe.io.InstrumentContainer
instrumental description
array_pointing: SkyCoord[AltAz]
pointing direction of the array
telescopes_pointings: dict[SkyCoord[AltAz]]
dictionary of pointing direction per each telescope
Raises
------
TooFewTelescopesException
if len(hillas_dict) < 2
InvalidWidthException
if any width is np.nan or 0
"""
# filter warnings for missing obs time. this is needed because MC data has no obs time
warnings.filterwarnings(action='ignore',
category=MissingFrameAttributeWarning)
# stereoscopy needs at least two telescopes
if len(hillas_dict) < 2:
raise TooFewTelescopesException(
"need at least two telescopes, have {}".format(
len(hillas_dict)))
# check for np.nan or 0 width's as these screw up weights
if any(
[np.isnan(hillas_dict[tel]['width'].value)
for tel in hillas_dict]):
raise InvalidWidthException(
"A HillasContainer contains an ellipse of width==np.nan")
if any([hillas_dict[tel]['width'].value == 0 for tel in hillas_dict]):
raise InvalidWidthException(
"A HillasContainer contains an ellipse of width==0")
# use the single telescope pointing also for parallel pointing: code is more general
if telescopes_pointings is None:
telescopes_pointings = {
tel_id: array_pointing
for tel_id in hillas_dict.keys()
}
else:
self.divergent_mode = True
self.corrected_angle_dict = {}
self.initialize_hillas_planes(hillas_dict, inst.subarray,
telescopes_pointings, array_pointing)
# algebraic direction estimate
direction, err_est_dir = self.estimate_direction()
# array pointing is needed to define the tilted frame
core_pos = self.estimate_core_position(hillas_dict, array_pointing)
# container class for reconstructed showers
result = ReconstructedShowerContainer()
_, lat, lon = cartesian_to_spherical(*direction)
# estimate max height of shower
h_max = self.estimate_h_max()
# astropy's coordinates system rotates counter-clockwise.
# Apparently we assume it to be clockwise.
result.alt, result.az = lat, -lon
result.core_x = core_pos[0]
result.core_y = core_pos[1]
result.core_uncert = np.nan
result.tel_ids = [h for h in hillas_dict.keys()]
result.average_intensity = np.mean(
[h.intensity for h in hillas_dict.values()])
result.is_valid = True
result.alt_uncert = err_est_dir
result.az_uncert = np.nan
result.h_max = h_max
result.h_max_uncert = np.nan
result.goodness_of_fit = np.nan
return result
def predict(self, hillas_dict, inst, array_pointing, telescopes_pointings=None):
"""
Parameters
----------
hillas_dict: dict
Dictionary containing Hillas parameters for all telescopes
in reconstruction
inst : ctapipe.io.InstrumentContainer
instrumental description
array_pointing: SkyCoord[AltAz]
pointing direction of the array
telescopes_pointings: dict[SkyCoord[AltAz]]
dictionary of pointing direction per each telescope
Returns
-------
ReconstructedShowerContainer:
"""
# filter warnings for missing obs time. this is needed because MC data has no obs time
warnings.filterwarnings(action='ignore', category=MissingFrameAttributeWarning)
# stereoscopy needs at least two telescopes
if len(hillas_dict) < 2:
raise TooFewTelescopesException(
"need at least two telescopes, have {}"
.format(len(hillas_dict)))
# check for np.nan or 0 width's as these screw up weights
if any([np.isnan(hillas_dict[tel]['width'].value) for tel in hillas_dict]):
raise InvalidWidthException(
"A HillasContainer contains an ellipse of width==np.nan")
if any([hillas_dict[tel]['width'].value == 0 for tel in hillas_dict]):
raise InvalidWidthException(
"A HillasContainer contains an ellipse of width==0")
if telescopes_pointings is None:
telescopes_pointings = {tel_id: array_pointing for tel_id in hillas_dict.keys()}
tilted_frame = TiltedGroundFrame(pointing_direction=array_pointing)
ground_positions = inst.subarray.tel_coords
grd_coord = GroundFrame(x=ground_positions.x,
y=ground_positions.y,
z=ground_positions.z)
tilt_coord = grd_coord.transform_to(tilted_frame)
tel_x = {tel_id: tilt_coord.x[tel_id-1] for tel_id in list(hillas_dict.keys())}
tel_y = {tel_id: tilt_coord.y[tel_id-1] for tel_id in list(hillas_dict.keys())}
nom_frame = NominalFrame(origin=array_pointing)
hillas_dict_mod = copy.deepcopy(hillas_dict)
for tel_id, hillas in hillas_dict_mod.items():
# prevent from using rads instead of meters as inputs
assert hillas.x.to(u.m).unit == u.Unit('m')
focal_length = inst.subarray.tel[tel_id].optics.equivalent_focal_length
camera_frame = CameraFrame(
telescope_pointing=telescopes_pointings[tel_id],
focal_length=focal_length,
)
cog_coords = SkyCoord(x=hillas.x, y=hillas.y, frame=camera_frame)
cog_coords_nom = cog_coords.transform_to(nom_frame)
hillas.x = cog_coords_nom.delta_alt
hillas.y = cog_coords_nom.delta_az
src_x, src_y, err_x, err_y = self.reconstruct_nominal(hillas_dict_mod)
core_x, core_y, core_err_x, core_err_y = self.reconstruct_tilted(
hillas_dict_mod, tel_x, tel_y)
err_x *= u.rad
err_y *= u.rad
nom = SkyCoord(
delta_az=src_x * u.rad,
delta_alt=src_y * u.rad,
frame=nom_frame
)
# nom = sky_pos.transform_to(nom_frame)
sky_pos = nom.transform_to(array_pointing.frame)
result = ReconstructedShowerContainer()
result.alt = sky_pos.altaz.alt.to(u.rad)
result.az = sky_pos.altaz.az.to(u.rad)
tilt = SkyCoord(
x=core_x * u.m,
y=core_y * u.m,
frame=tilted_frame,
)
grd = project_to_ground(tilt)
result.core_x = grd.x
result.core_y = grd.y
x_max = self.reconstruct_xmax(
nom.delta_az,
nom.delta_alt,
tilt.x, tilt.y,
hillas_dict_mod,
tel_x, tel_y,
90 * u.deg - array_pointing.alt,
)
result.core_uncert = np.sqrt(core_err_x**2 + core_err_y**2) * u.m
result.tel_ids = [h for h in hillas_dict_mod.keys()]
result.average_intensity = np.mean([h.intensity for h in hillas_dict_mod.values()])
result.is_valid = True
src_error = np.sqrt(err_x**2 + err_y**2)
result.alt_uncert = src_error.to(u.rad)
result.az_uncert = src_error.to(u.rad)
result.h_max = x_max
result.h_max_uncert = np.nan
result.goodness_of_fit = np.nan
return result
