def predict(self, tels_dict):
"""overwrite this method with your favourite direction reconstruction
algorithm
Parameters
----------
tels_dict : dict
general dictionary containing all triggered telescopes data
Returns
-------
Standard `RecoShowerGeom` container
"""
return ReconstructedShowerContainer()
class ArrayEventContainer(Container):
container_prefix = ''
run_id = Field(-1, 'run id')
array_event_id = Field(-1, 'array event id')
reco = Field(ReconstructedShowerContainer(),
'reconstructed shower container')
mc = Field(MCEventContainer(), 'array wide MC information')
total_intensity = Field(np.nan, 'sum of all intensities')
num_triggered_telescopes = Field(np.nan, 'Number of triggered Telescopes')
num_triggered_lst = Field(np.nan, 'Number of triggered LSTs')
num_triggered_mst = Field(np.nan, 'Number of triggered MSTs')
num_triggered_sst = Field(np.nan, 'Number of triggered SSTs')
def test_image_prediction(self):
pixel_x = np.array([0]) * u.deg
pixel_y = np.array([0]) * u.deg
image = np.array([1])
pixel_area = np.array([1]) * u.deg * u.deg
self.impact_reco.set_event_properties(
{1: image}, {1: pixel_x}, {1: pixel_y}, {1: pixel_area},
{1: "CHEC"}, {1: 0 * u.m}, {1: 0 * u.m},
array_direction=[0 * u.deg, 0 * u.deg])
"""First check image prediction by directly accessing the function"""
pred = self.impact_reco.image_prediction("CHEC",
zenith=0,
azimuth=0,
energy=1,
impact=50,
x_max=0,
pix_x=pixel_x,
pix_y=pixel_y)
assert np.sum(pred) != 0
"""Then check helper function gives the same answer"""
shower = ReconstructedShowerContainer()
shower.is_valid = True
shower.alt = 0 * u.deg
shower.az = 0 * u.deg
shower.core_x = 0 * u.m
shower.core_y = 100 * u.m
shower.h_max = 300 + 93 * np.log10(1)
energy = ReconstructedEnergyContainer()
energy.is_valid = True
energy.energy = 1 * u.TeV
pred2 = self.impact_reco.get_prediction(1,
shower_reco=shower,
energy_reco=energy)
print(pred, pred2)
assert pred.all() == pred2.all()
def test_image_prediction(self):
pixel_x = np.array([0]) * u.deg
pixel_y = np.array([0]) * u.deg
image = np.array([1])
pixel_area = np.array([1]) * u.deg * u.deg
self.impact_reco.set_event_properties({1: image}, {1: pixel_x},
{1: pixel_y}, {1: pixel_area},
{1: "CHEC"}, {1: 0 * u.m},
{1: 0 * u.m},
array_direction=[0 * u.deg,
0 * u.deg])
"""First check image prediction by directly accessing the function"""
pred = self.impact_reco.image_prediction("CHEC", zenith=0, azimuth=0,
energy=1, impact=50, x_max=0,
pix_x=pixel_x, pix_y=pixel_y)
assert np.sum(pred) != 0
"""Then check helper function gives the same answer"""
shower = ReconstructedShowerContainer()
shower.is_valid = True
shower.alt = 0 * u.deg
shower.az = 0 * u.deg
shower.core_x = 0 * u.m
shower.core_y = 100 * u.m
shower.h_max = 300 + 93 * np.log10(1)
energy = ReconstructedEnergyContainer()
energy.is_valid = True
energy.energy = 1 * u.TeV
pred2 = self.impact_reco.get_prediction(1, shower_reco=shower,
energy_reco=energy)
print(pred, pred2)
assert pred.all() == pred2.all()
def predict(self, shower_seed, energy_seed):
"""
Parameters
----------
shower_seed: ReconstructedShowerContainer
Seed shower geometry to be used in the fit
energy_seed: ReconstructedEnergyContainer
Seed energy to be used in fit
Returns
-------
ReconstructedShowerContainer, ReconstructedEnergyContainer:
Reconstructed ImPACT shower geometry and energy
"""
horizon_seed = HorizonFrame(az=shower_seed.az, alt=shower_seed.alt)
nominal_seed = horizon_seed.transform_to(
NominalFrame(array_direction=self.array_direction))
print(nominal_seed)
print(horizon_seed)
print(self.array_direction)
source_x = nominal_seed.x[0].to(u.rad).value
source_y = nominal_seed.y[0].to(u.rad).value
ground = GroundFrame(x=shower_seed.core_x,
y=shower_seed.core_y,
z=0 * u.m)
tilted = ground.transform_to(
TiltedGroundFrame(pointing_direction=self.array_direction))
tilt_x = tilted.x.to(u.m).value
tilt_y = tilted.y.to(u.m).value
lower_en_limit = energy_seed.energy * 0.5
en_seed = energy_seed.energy
if lower_en_limit < 0.04 * u.TeV:
lower_en_limit = 0.04 * u.TeV
en_seed = 0.041 * u.TeV
seed = (source_x, source_y, tilt_x, tilt_y, en_seed.value, 0.8)
step = (0.001, 0.001, 10, 10, en_seed.value * 0.1, 0.1)
limits = ((source_x - 0.01, source_x + 0.01), (source_y - 0.01,
source_y + 0.01),
(tilt_x - 100, tilt_x + 100), (tilt_y - 100, tilt_y + 100),
(lower_en_limit.value, en_seed.value * 2), (0.5, 2))
fit_params, errors = self.minimise(params=seed,
step=step,
limits=limits,
minimiser_name=self.minimiser_name)
# container class for reconstructed showers '''
shower_result = ReconstructedShowerContainer()
nominal = NominalFrame(x=fit_params[0] * u.rad,
y=fit_params[1] * u.rad,
array_direction=self.array_direction)
horizon = nominal.transform_to(HorizonFrame())
shower_result.alt, shower_result.az = horizon.alt, horizon.az
tilted = TiltedGroundFrame(x=fit_params[2] * u.m,
y=fit_params[3] * u.m,
pointing_direction=self.array_direction)
ground = project_to_ground(tilted)
shower_result.core_x = ground.x
shower_result.core_y = ground.y
shower_result.is_valid = True
shower_result.alt_uncert = np.nan
shower_result.az_uncert = np.nan
shower_result.core_uncert = np.nan
zenith = 90 * u.deg - self.array_direction.alt
shower_result.h_max = fit_params[5] * \
self.get_shower_max(fit_params[0],
fit_params[1],
fit_params[2],
fit_params[3],
zenith.to(u.rad).value)
shower_result.h_max_uncert = errors[5] * shower_result.h_max
shower_result.goodness_of_fit = np.nan
shower_result.tel_ids = list(self.image.keys())
energy_result = ReconstructedEnergyContainer()
energy_result.energy = fit_params[4] * u.TeV
energy_result.energy_uncert = errors[4] * u.TeV
energy_result.is_valid = True
energy_result.tel_ids = list(self.image.keys())
# Return interesting stuff
return shower_result, energy_result
def predict(self, hillas_dict, inst, tel_phi, tel_theta, seed_pos=(0, 0)):
'''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 : python dictionary
dictionary with telescope IDs as key and
MomentParameters instances as values
seed_pos : python tuple
shape (2) tuple with a possible seed for
the core position fit (e.g. CoG of all telescope images)
'''
self.get_great_circles(hillas_dict, inst, tel_phi, tel_theta)
# algebraic direction estimate
dir1 = self.fit_origin_crosses()[0]
# direction estimate using numerical minimisation
# does not really improve the fit for now
# dir2 = self.fit_origin_minimise(dir1)
# core position estimate using numerical minimisation
# pos = self.fit_core_minimise(seed_pos)
# core position estimate using a geometric approach
pos = self.fit_core_crosses()
# container class for reconstructed showers '''
result = ReconstructedShowerContainer()
(phi, theta) = linalg.get_phi_theta(dir1).to(u.deg)
# TODO make sure az and phi turn in same direction...
result.alt, result.az = 90 * u.deg - theta, phi
result.core_x = pos[0]
result.core_y = pos[1]
result.tel_ids = [h for h in hillas_dict.keys()]
result.average_size = np.mean([h.size for h in hillas_dict.values()])
result.is_valid = True
result.alt_uncert = np.nan
result.az_uncert = np.nan
result.core_uncert = np.nan
result.h_max = np.nan
result.h_max_uncert = np.nan
result.goodness_of_fit = np.nan
return result
def predict(self, shower_seed, energy_seed):
"""
Parameters
----------
shower_seed: ReconstructedShowerContainer
Seed shower geometry to be used in the fit
energy_seed: ReconstructedEnergyContainer
Seed energy to be used in fit
Returns
-------
ReconstructedShowerContainer, ReconstructedEnergyContainer:
Reconstructed ImPACT shower geometry and energy
"""
horizon_seed = HorizonFrame(az=shower_seed.az, alt=shower_seed.alt)
nominal_seed = horizon_seed.transform_to(NominalFrame(
array_direction=self.array_direction))
source_x = nominal_seed.x.to(u.rad).value
source_y = nominal_seed.y.to(u.rad).value
ground = GroundFrame(x=shower_seed.core_x,
y=shower_seed.core_y, z=0 * u.m)
tilted = ground.transform_to(
TiltedGroundFrame(pointing_direction=self.array_direction)
)
tilt_x = tilted.x.to(u.m).value
tilt_y = tilted.y.to(u.m).value
zenith = 90 * u.deg - self.array_direction.alt
if len(self.hillas_parameters) > 3:
shift = [1]
else:
shift = [1.5, 1, 0.5, 0, -0.5, -1, -1.5]
seed_list = spread_line_seed(self.hillas_parameters,
self.tel_pos_x, self.tel_pos_y,
source_x[0], source_y[0], tilt_x, tilt_y,
energy_seed.energy.value,
shift_frac = shift)
chosen_seed = self.choose_seed(seed_list)
# Perform maximum likelihood fit
fit_params, errors, like = self.minimise(params=chosen_seed[0],
step=chosen_seed[1],
limits=chosen_seed[2],
minimiser_name=self.minimiser_name)
# Create a container class for reconstructed shower
shower_result = ReconstructedShowerContainer()
# Convert the best fits direction and core to Horizon and ground systems and
# copy to the shower container
nominal = NominalFrame(x=fit_params[0] * u.rad,
y=fit_params[1] * u.rad,
array_direction=self.array_direction)
horizon = nominal.transform_to(HorizonFrame())
shower_result.alt, shower_result.az = horizon.alt, horizon.az
tilted = TiltedGroundFrame(x=fit_params[2] * u.m,
y=fit_params[3] * u.m,
pointing_direction=self.array_direction)
ground = project_to_ground(tilted)
shower_result.core_x = ground.x
shower_result.core_y = ground.y
shower_result.is_valid = True
# Currently no errors not availible to copy NaN
shower_result.alt_uncert = np.nan
shower_result.az_uncert = np.nan
shower_result.core_uncert = np.nan
# Copy reconstructed Xmax
shower_result.h_max = fit_params[5] * self.get_shower_max(fit_params[0],
fit_params[1],
fit_params[2],
fit_params[3],
zenith.to(u.rad).value)
shower_result.h_max *= np.cos(zenith)
shower_result.h_max_uncert = errors[5] * shower_result.h_max
shower_result.goodness_of_fit = like
# Create a container class for reconstructed energy
energy_result = ReconstructedEnergyContainer()
# Fill with results
energy_result.energy = fit_params[4] * u.TeV
energy_result.energy_uncert = errors[4] * u.TeV
energy_result.is_valid = True
return shower_result, energy_result
def predict(self, hillas_dict, inst, pointing_alt, pointing_az):
'''
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
pointing_alt: dict[astropy.coordinates.Angle]
dict mapping telescope ids to pointing altitude
pointing_az: dict[astropy.coordinates.Angle]
dict mapping telescope ids to pointing azimuth
Raises
------
TooFewTelescopesException
if len(hillas_dict) < 2
'''
# stereoscopy needs at least two telescopes
if len(hillas_dict) < 2:
raise TooFewTelescopesException(
"need at least two telescopes, have {}".format(
len(hillas_dict)))
self.initialize_hillas_planes(hillas_dict, inst.subarray, pointing_alt,
pointing_az)
# algebraic direction estimate
direction, err_est_dir = self.estimate_direction()
alt = u.Quantity(list(pointing_alt.values()))
az = u.Quantity(list(pointing_az.values()))
if np.any(alt != alt[0]) or np.any(az != az[0]):
raise ValueError('Divergent pointing not supported')
pointing_direction = SkyCoord(alt=alt[0], az=az[0], frame='altaz')
# core position estimate using a geometric approach
core_pos = self.estimate_core_position(hillas_dict, pointing_direction)
# 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_size = 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, shower_seed, energy_seed):
"""Predict method for the ImPACT reconstructor.
Used to calculate the reconstructed ImPACT shower geometry and energy.
Parameters
----------
shower_seed: ReconstructedShowerContainer
Seed shower geometry to be used in the fit
energy_seed: ReconstructedEnergyContainer
Seed energy to be used in fit
Returns
-------
ReconstructedShowerContainer, ReconstructedEnergyContainer:
"""
self.reset_interpolator()
horizon_seed = SkyCoord(az=shower_seed.az,
alt=shower_seed.alt,
frame=AltAz())
nominal_seed = horizon_seed.transform_to(self.nominal_frame)
source_x = nominal_seed.delta_az.to_value(u.rad)
source_y = nominal_seed.delta_alt.to_value(u.rad)
ground = GroundFrame(x=shower_seed.core_x,
y=shower_seed.core_y,
z=0 * u.m)
tilted = ground.transform_to(
TiltedGroundFrame(pointing_direction=self.array_direction))
tilt_x = tilted.x.to(u.m).value
tilt_y = tilted.y.to(u.m).value
zenith = 90 * u.deg - self.array_direction.alt
seeds = spread_line_seed(self.hillas_parameters,
self.tel_pos_x,
self.tel_pos_y,
source_x,
source_y,
tilt_x,
tilt_y,
energy_seed.energy.value,
shift_frac=[1])[0]
# Perform maximum likelihood fit
fit_params, errors, like = self.minimise(
params=seeds[0],
step=seeds[1],
limits=seeds[2],
minimiser_name=self.minimiser_name)
# Create a container class for reconstructed shower
shower_result = ReconstructedShowerContainer()
# Convert the best fits direction and core to Horizon and ground systems and
# copy to the shower container
nominal = SkyCoord(delta_az=fit_params[0] * u.rad,
delta_alt=fit_params[1] * u.rad,
frame=self.nominal_frame)
horizon = nominal.transform_to(AltAz())
shower_result.alt, shower_result.az = horizon.alt, horizon.az
tilted = TiltedGroundFrame(x=fit_params[2] * u.m,
y=fit_params[3] * u.m,
pointing_direction=self.array_direction)
ground = project_to_ground(tilted)
shower_result.core_x = ground.x
shower_result.core_y = ground.y
shower_result.is_valid = True
# Currently no errors not available to copy NaN
shower_result.alt_uncert = np.nan
shower_result.az_uncert = np.nan
shower_result.core_uncert = np.nan
# Copy reconstructed Xmax
shower_result.h_max = fit_params[5] * self.get_shower_max(
fit_params[0], fit_params[1], fit_params[2], fit_params[3],
zenith.to(u.rad).value)
shower_result.h_max *= np.cos(zenith)
shower_result.h_max_uncert = errors[5] * shower_result.h_max
shower_result.goodness_of_fit = like
# Create a container class for reconstructed energy
energy_result = ReconstructedEnergyContainer()
# Fill with results
energy_result.energy = fit_params[4] * u.TeV
energy_result.energy_uncert = errors[4] * u.TeV
energy_result.is_valid = True
return shower_result, energy_result
def predict(self, hillas_dict, inst, pointing_alt, pointing_az):
'''
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
pointing_alt: dict[astropy.coordinates.Angle]
dict mapping telescope ids to pointing altitude
pointing_az: dict[astropy.coordinates.Angle]
dict mapping telescope ids to pointing azimuth
Raises
------
TooFewTelescopesException
if len(hillas_dict) < 2
'''
# 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)))
self.initialize_hillas_planes(
hillas_dict,
inst.subarray,
pointing_alt,
pointing_az
)
# algebraic direction estimate
direction, err_est_dir = self.estimate_direction()
alt = u.Quantity(list(pointing_alt.values()))
az = u.Quantity(list(pointing_az.values()))
if np.any(alt != alt[0]) or np.any(az != az[0]):
warnings.warn('Divergent pointing not supported')
telescope_pointing = SkyCoord(alt=alt[0], az=az[0], frame=HorizonFrame())
# core position estimate using a geometric approach
core_pos = self.estimate_core_position(hillas_dict, telescope_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, shower_seed, energy_seed):
"""
Parameters
----------
shower_seed: ReconstructedShowerContainer
Seed shower geometry to be used in the fit
energy_seed: ReconstructedEnergyContainer
Seed energy to be used in fit
Returns
-------
ReconstructedShowerContainer, ReconstructedEnergyContainer:
Reconstructed ImPACT shower geometry and energy
"""
horizon_seed = SkyCoord(
az=shower_seed.az, alt=shower_seed.alt, frame=HorizonFrame()
)
nominal_seed = horizon_seed.transform_to(
NominalFrame(origin=self.array_direction)
)
source_x = nominal_seed.delta_az.to_value(u.rad)
source_y = nominal_seed.delta_alt.to_value(u.rad)
ground = GroundFrame(x=shower_seed.core_x,
y=shower_seed.core_y, z=0 * u.m)
tilted = ground.transform_to(
TiltedGroundFrame(pointing_direction=self.array_direction)
)
tilt_x = tilted.x.to(u.m).value
tilt_y = tilted.y.to(u.m).value
zenith = 90 * u.deg - self.array_direction.alt
if len(self.hillas_parameters) > 3:
shift = [1]
else:
shift = [1.5, 1, 0.5, 0, -0.5, -1, -1.5]
seed_list = spread_line_seed(self.hillas_parameters,
self.tel_pos_x, self.tel_pos_y,
source_x[0], source_y[0], tilt_x, tilt_y,
energy_seed.energy.value,
shift_frac = shift)
chosen_seed = self.choose_seed(seed_list)
# Perform maximum likelihood fit
fit_params, errors, like = self.minimise(params=chosen_seed[0],
step=chosen_seed[1],
limits=chosen_seed[2],
minimiser_name=self.minimiser_name)
# Create a container class for reconstructed shower
shower_result = ReconstructedShowerContainer()
# Convert the best fits direction and core to Horizon and ground systems and
# copy to the shower container
nominal = SkyCoord(
x=fit_params[0] * u.rad,
y=fit_params[1] * u.rad,
frame=NominalFrame(origin=self.array_direction)
)
horizon = nominal.transform_to(HorizonFrame())
shower_result.alt, shower_result.az = horizon.alt, horizon.az
tilted = TiltedGroundFrame(
x=fit_params[2] * u.m,
y=fit_params[3] * u.m,
pointing_direction=self.array_direction
)
ground = project_to_ground(tilted)
shower_result.core_x = ground.x
shower_result.core_y = ground.y
shower_result.is_valid = True
# Currently no errors not availible to copy NaN
shower_result.alt_uncert = np.nan
shower_result.az_uncert = np.nan
shower_result.core_uncert = np.nan
# Copy reconstructed Xmax
shower_result.h_max = fit_params[5] * self.get_shower_max(fit_params[0],
fit_params[1],
fit_params[2],
fit_params[3],
zenith.to(u.rad).value)
shower_result.h_max *= np.cos(zenith)
shower_result.h_max_uncert = errors[5] * shower_result.h_max
shower_result.goodness_of_fit = like
# Create a container class for reconstructed energy
energy_result = ReconstructedEnergyContainer()
# Fill with results
energy_result.energy = fit_params[4] * u.TeV
energy_result.energy_uncert = errors[4] * u.TeV
energy_result.is_valid = True
return shower_result, energy_result
def predict(self, shower_seed, energy_seed):
"""
Parameters
----------
source_x: float
Initial guess of source position in the nominal frame
source_y: float
Initial guess of source position in the nominal frame
core_x: float
Initial guess of the core position in the tilted system
core_y: float
Initial guess of the core position in the tilted system
energy: float
Initial guess of energy
Returns
-------
Shower object with fit results
"""
horizon_seed = HorizonFrame(az=shower_seed.az, alt=shower_seed.alt)
nominal_seed = horizon_seed.transform_to(
NominalFrame(array_direction=self.array_direction)
)
source_x = nominal_seed.x.to(u.rad).value
source_y = nominal_seed.y.to(u.rad).value
ground = GroundFrame(x=shower_seed.core_x,
y=shower_seed.core_y, z=0 * u.m)
tilted = ground.transform_to(
TiltedGroundFrame(pointing_direction=self.array_direction)
)
tilt_x = tilted.x.to(u.m).value
tilt_y = tilted.y.to(u.m).value
lower_en_limit = energy_seed.energy * 0.1
if lower_en_limit < 0.04 * u.TeV:
lower_en_limit = 0.04 * u.TeV
# Create Minuit object with first guesses at parameters, strip away the
# units as Minuit doesnt like them
min = Minuit(self.get_likelihood,
print_level=1,
source_x=source_x,
error_source_x=0.01 / 57.3,
fix_source_x=False,
limit_source_x=(source_x - 0.5 / 57.3,
source_x + 0.5 / 57.3),
source_y=source_y,
error_source_y=0.01 / 57.3,
fix_source_y=False,
limit_source_y=(source_y - 0.5 / 57.3,
source_y + 0.5 / 57.3),
core_x=tilt_x,
error_core_x=10,
limit_core_x=(tilt_x - 200, tilt_x + 200),
core_y=tilt_y,
error_core_y=10,
limit_core_y=(tilt_y - 200, tilt_y + 200),
energy=energy_seed.energy.value,
error_energy=energy_seed.energy.value * 0.05,
limit_energy=(lower_en_limit.value,
energy_seed.energy.value * 10.),
x_max_scale=1, error_x_max_scale=0.1,
limit_x_max_scale=(0.5, 2),
fix_x_max_scale=False,
errordef=1)
min.tol *= 1000
min.strategy = 0
# Perform minimisation
migrad = min.migrad()
fit_params = min.values
errors = min.errors
# print(migrad)
# print(min.minos())
# container class for reconstructed showers '''
shower_result = ReconstructedShowerContainer()
nominal = NominalFrame(x=fit_params["source_x"] * u.rad,
y=fit_params["source_y"] * u.rad,
array_direction=self.array_direction)
horizon = nominal.transform_to(HorizonFrame())
shower_result.alt, shower_result.az = horizon.alt, horizon.az
tilted = TiltedGroundFrame(x=fit_params["core_x"] * u.m,
y=fit_params["core_y"] * u.m,
pointing_direction=self.array_direction)
ground = project_to_ground(tilted)
shower_result.core_x = ground.x
shower_result.core_y = ground.y
shower_result.is_valid = True
shower_result.alt_uncert = np.nan
shower_result.az_uncert = np.nan
shower_result.core_uncert = np.nan
zenith = 90 * u.deg - self.array_direction[0]
shower_result.h_max = fit_params["x_max_scale"] * \
self.get_shower_max(fit_params["source_x"],
fit_params["source_y"],
fit_params["core_x"],
fit_params["core_y"],
zenith.to(u.rad).value)
shower_result.h_max_uncert = errors["x_max_scale"] * shower_result.h_max
shower_result.goodness_of_fit = np.nan
shower_result.tel_ids = list(self.image.keys())
energy_result = ReconstructedEnergyContainer()
energy_result.energy = fit_params["energy"] * u.TeV
energy_result.energy_uncert = errors["energy"] * u.TeV
energy_result.is_valid = True
energy_result.tel_ids = list(self.image.keys())
# Return interesting stuff
return shower_result, energy_result
def predict(self, hillas_dict, inst, pointing_alt, pointing_az):
'''
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
pointing_alt: dict[astropy.coordinates.Angle]
dict mapping telescope ids to pointing altitude
pointing_az: dict[astropy.coordinates.Angle]
dict mapping telescope ids to pointing azimuth
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")
self.initialize_hillas_planes(hillas_dict, inst.subarray, pointing_alt,
pointing_az)
# algebraic direction estimate
direction, err_est_dir = self.estimate_direction()
alt = u.Quantity(list(pointing_alt.values()))
az = u.Quantity(list(pointing_az.values()))
if np.any(alt != alt[0]) or np.any(az != az[0]):
warnings.warn('Divergent pointing not supported')
telescope_pointing = SkyCoord(alt=alt[0], az=az[0], frame=AltAz())
# core position estimate using a geometric approach
core_pos = self.estimate_core_position(hillas_dict, telescope_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, pointing_alt, pointing_az, seed_pos=(0, 0)):
"""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 : python dictionary
dictionary with telescope IDs as key and
MomentParameters instances as values
inst : ctapipe.io.InstrumentContainer
instrumental description
pointing_alt:
pointing_az:
seed_pos : python tuple
shape (2) tuple with a possible seed for
the core position fit (e.g. CoG of all telescope images)
Raises
------
TooFewTelescopesException
if len(hillas_dict) < 2
"""
# stereoscopy needs at least two telescopes
if len(hillas_dict) < 2:
raise TooFewTelescopesException(
"need at least two telescopes, have {}"
.format(len(hillas_dict)))
self.inititialize_hillas_planes(
hillas_dict,
inst.subarray,
pointing_alt,
pointing_az
)
# algebraic direction estimate
direction, err_est_dir = self.estimate_direction()
# core position estimate using a geometric approach
pos, err_est_pos = self.estimate_core_position()
# container class for reconstructed showers
result = ReconstructedShowerContainer()
_, lat, lon = cartesian_to_spherical(*direction)
# estimate max height of shower
h_max = self.estimate_h_max(hillas_dict, inst.subarray, pointing_alt, pointing_az)
result.alt, result.az = lat, lon
result.core_x = pos[0]
result.core_y = pos[1]
result.core_uncert = err_est_pos
result.tel_ids = [h for h in hillas_dict.keys()]
result.average_size = np.mean([h.size 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_parameters, tel_x, tel_y, array_direction):
"""
Parameters
----------
hillas_parameters: dict
Dictionary containing Hillas parameters for all telescopes in reconstruction
tel_x: dict
Dictionary containing telescope position on ground for all telescopes in
reconstruction
tel_y: dict
Dictionary containing telescope position on ground for all telescopes in
reconstruction
array_direction: HorizonFrame
Pointing direction of the array
Returns
-------
"""
src_x, src_y, err_x, err_y = self.reconstruct_nominal(hillas_parameters)
core_x, core_y, core_err_x, core_err_y = self.reconstruct_tilted(
hillas_parameters, tel_x, tel_y)
err_x *= u.rad
err_y *= u.rad
nom = NominalFrame(x=src_x * u.rad, y=src_y * u.rad,
array_direction=array_direction)
horiz = nom.transform_to(HorizonFrame())
result = ReconstructedShowerContainer()
result.alt, result.az = horiz.alt, horiz.az
tilt = TiltedGroundFrame(x=core_x * u.m, y=core_y * u.m,
pointing_direction=array_direction)
grd = project_to_ground(tilt)
result.core_x = grd.x
result.core_y = grd.y
x_max = self.reconstruct_xmax(nom.x, nom.y, tilt.x, tilt.y, hillas_parameters,
tel_x, tel_y, 90 * u.deg - array_direction.alt)
result.core_uncert = np.sqrt(
core_err_x * core_err_x + core_err_y * core_err_y) * u.m
result.tel_ids = [h for h in hillas_parameters.keys()]
result.average_size = np.mean([h.size for h in hillas_parameters.values()])
result.is_valid = True
src_error = np.sqrt(err_x * err_x + err_y * err_y)
result.alt_uncert = src_error.to(u.deg)
result.az_uncert = src_error.to(u.deg)
result.h_max = x_max
result.h_max_uncert = np.nan
result.goodness_of_fit = np.nan
return result
def predict(self, hillas_dict, inst, tel_phi, tel_theta, seed_pos=(0, 0)):
'''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 : python dictionary
dictionary with telescope IDs as key and
MomentParameters instances as values
seed_pos : python tuple
shape (2) tuple with a possible seed for
the core position fit (e.g. CoG of all telescope images)
'''
self.get_great_circles(hillas_dict, inst, tel_phi, tel_theta)
# algebraic direction estimate
dir1 = self.fit_origin_crosses()[0]
# direction estimate using numerical minimisation
#
# does not really improve the fit for now
# dir2 = self.fit_origin_minimise(dir1)
#
# core position estimate using numerical minimisation '''
pos = self.fit_core(seed_pos)
# container class for reconstructed showers '''
result = ReconstructedShowerContainer()
(phi, theta) = linalg.get_phi_theta(dir1)
# TODO make sure az and phi turn in same direction...
result.alt, result.az = theta - 90 * u.deg, phi
result.core_x = pos[0]
result.core_y = pos[1]
result.tel_ids = [h for h in hillas_dict.keys()]
result.average_size = np.mean([h.size for h in hillas_dict.values()])
result.is_valid = True
result.alt_uncert = np.nan
result.az_uncert = np.nan
result.core_uncert = np.nan
result.h_max = np.nan
result.h_max_uncert = np.nan
result.goodness_of_fit = np.nan
return result
def process_event(event, calibrator, config):
'''Processes one event.
Calls calculate_image_features and performs a stereo hillas reconstruction.
ReconstructedShowerContainer will be filled with nans (+units) if hillas failed.
Returns:
--------
ArrayEventContainer
list(telescope_event_containers.values())
'''
logging.info(f'processing event {event.dl0.event_id}')
calibrator(event)
telescope_types = []
hillas_reconstructor = HillasReconstructor()
telescope_event_containers = {}
horizon_frame = AltAz()
telescope_pointings = {}
array_pointing = SkyCoord(
az=event.mcheader.run_array_direction[0],
alt=event.mcheader.run_array_direction[1],
frame=horizon_frame,
)
for telescope_id, dl1 in event.dl1.tel.items():
cam_type = event.inst.subarray.tels[telescope_id].camera.cam_id
if cam_type not in config.cleaning_level.keys():
logging.info(f"No cleaning levels for camera {cam_type}. Skipping event")
continue
telescope_types.append(str(event.inst.subarray.tels[telescope_id].optics))
try:
telescope_event_containers[telescope_id] = calculate_image_features(
telescope_id, event, dl1, config
)
except HillasParameterizationError:
logging.info(
f'Error calculating hillas features for event {event.dl0.event_id, telescope_id}',
exc_info=True,
)
continue
except Exception:
logging.info(
f'Error calculating image features for event {event.dl0.event_id, telescope_id}',
exc_info=True,
)
continue
telescope_pointings[telescope_id] = SkyCoord(
alt=telescope_event_containers[telescope_id].pointing.altitude,
az=telescope_event_containers[telescope_id].pointing.azimuth,
frame=horizon_frame,
)
if len(telescope_event_containers) < 1:
raise Exception('None of the allowed telescopes triggered for event %s', event.dl0.event_id)
parameters = {tel_id: telescope_event_containers[tel_id].hillas for tel_id in telescope_event_containers}
try:
reconstruction_container = hillas_reconstructor.predict(
parameters, event.inst, array_pointing, telescopes_pointings=telescope_pointings
)
reconstruction_container.prefix = ''
except Exception:
logging.info(
'Not enough telescopes for which Hillas parameters could be reconstructed', exc_info=True
)
reconstruction_container = ReconstructedShowerContainer()
reconstruction_container.alt = u.Quantity(np.nan, u.rad)
reconstruction_container.alt_uncert = u.Quantity(np.nan, u.rad)
reconstruction_container.az = u.Quantity(np.nan, u.rad)
reconstruction_container.az_uncert = np.nan
reconstruction_container.core_x = u.Quantity(np.nan, u.m)
reconstruction_container.core_y = u.Quantity(np.nan, u.m)
reconstruction_container.core_uncert = np.nan
reconstruction_container.h_max = u.Quantity(np.nan, u.m)
reconstruction_container.h_max_uncert = np.nan
reconstruction_container.is_valid = False
reconstruction_container.tel_ids = []
reconstruction_container.average_intensity = np.nan
reconstruction_container.goodness_of_fit = np.nan
reconstruction_container.prefix = ''
calculate_distance_to_core(telescope_event_containers, event, reconstruction_container)
mc_container = copy.deepcopy(event.mc)
mc_container.tel = None
mc_container.prefix = 'mc'
counter = Counter(telescope_types)
array_event = ArrayEventContainer(
array_event_id=event.dl0.event_id,
run_id=event.r0.obs_id,
reco=reconstruction_container,
total_intensity=sum([t.hillas.intensity for t in telescope_event_containers.values()]),
num_triggered_lst=counter['LST'],
num_triggered_mst=counter['MST'],
num_triggered_sst=counter['SST'],
num_triggered_telescopes=len(telescope_types),
mc=mc_container,
)
return array_event, list(telescope_event_containers.values())
def predict(self, hillas_dict, inst, tel_phi, tel_theta, seed_pos=(0, 0)):
"""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 : python dictionary
dictionary with telescope IDs as key and
MomentParameters instances as values
seed_pos : python tuple
shape (2) tuple with a possible seed for
the core position fit (e.g. CoG of all telescope images)
Raises
------
TooFewTelescopesException
if len(hillas_dict) < 2
"""
# stereoscopy needs at least two telescopes
if len(hillas_dict) < 2:
raise TooFewTelescopesException(
"need at least two telescopes, have {}".format(
len(hillas_dict)))
self.get_great_circles(hillas_dict, inst.subarray, tel_phi, tel_theta)
# algebraic direction estimate
dir, err_est_dir = self.fit_origin_crosses()
# core position estimate using a geometric approach
pos, err_est_pos = self.fit_core_crosses()
# numerical minimisations do not really improve the fit
# direction estimate using numerical minimisation
# dir = self.fit_origin_minimise(dir)
#
# core position estimate using numerical minimisation
# pos = self.fit_core_minimise(seed_pos)
# container class for reconstructed showers
result = ReconstructedShowerContainer()
phi, theta = linalg.get_phi_theta(dir).to(u.deg)
# TODO fix coordinates!
result.alt, result.az = 90 * u.deg - theta, -phi
result.core_x = pos[0]
result.core_y = pos[1]
result.core_uncert = err_est_pos
result.tel_ids = [h for h in hillas_dict.keys()]
result.average_size = np.mean([h.size for h in hillas_dict.values()])
result.is_valid = True
result.alt_uncert = err_est_dir
result.az_uncert = np.nan
result.h_max = self.fit_h_max(hillas_dict, inst.subarray, tel_phi,
tel_theta)
result.h_max_uncert = np.nan
result.goodness_of_fit = np.nan
return result
def predict(self, shower_seed, energy_seed):
"""
Parameters
----------
shower_seed: ReconstructedShowerContainer
Seed shower geometry to be used in the fit
energy_seed: ReconstructedEnergyContainer
Seed energy to be used in fit
Returns
-------
ReconstructedShowerContainer, ReconstructedEnergyContainer:
Reconstructed ImPACT shower geometry and energy
"""
horizon_seed = HorizonFrame(az=shower_seed.az, alt=shower_seed.alt)
nominal_seed = horizon_seed.transform_to(NominalFrame(array_direction=self.array_direction))
print(nominal_seed)
print(horizon_seed)
print(self.array_direction)
source_x = nominal_seed.x[0].to(u.rad).value
source_y = nominal_seed.y[0].to(u.rad).value
ground = GroundFrame(x=shower_seed.core_x,
y=shower_seed.core_y, z=0 * u.m)
tilted = ground.transform_to(
TiltedGroundFrame(pointing_direction=self.array_direction)
)
tilt_x = tilted.x.to(u.m).value
tilt_y = tilted.y.to(u.m).value
lower_en_limit = energy_seed.energy * 0.5
en_seed = energy_seed.energy
if lower_en_limit < 0.04 * u.TeV:
lower_en_limit = 0.04 * u.TeV
en_seed = 0.041 * u.TeV
seed = (source_x, source_y, tilt_x,
tilt_y, en_seed.value, 0.8)
step = (0.001, 0.001, 10, 10, en_seed.value*0.1, 0.1)
limits = ((source_x-0.01, source_x+0.01),
(source_y-0.01, source_y+0.01),
(tilt_x-100, tilt_x+100),
(tilt_y-100, tilt_y+100),
(lower_en_limit.value, en_seed.value*2),
(0.5,2))
fit_params, errors = self.minimise(params=seed, step=step, limits=limits,
minimiser_name=self.minimiser_name)
# container class for reconstructed showers '''
shower_result = ReconstructedShowerContainer()
nominal = NominalFrame(x=fit_params[0] * u.rad,
y=fit_params[1] * u.rad,
array_direction=self.array_direction)
horizon = nominal.transform_to(HorizonFrame())
shower_result.alt, shower_result.az = horizon.alt, horizon.az
tilted = TiltedGroundFrame(x=fit_params[2] * u.m,
y=fit_params[3] * u.m,
pointing_direction=self.array_direction)
ground = project_to_ground(tilted)
shower_result.core_x = ground.x
shower_result.core_y = ground.y
shower_result.is_valid = True
shower_result.alt_uncert = np.nan
shower_result.az_uncert = np.nan
shower_result.core_uncert = np.nan
zenith = 90*u.deg - self.array_direction.alt
shower_result.h_max = fit_params[5] * \
self.get_shower_max(fit_params[0],
fit_params[1],
fit_params[2],
fit_params[3],
zenith.to(u.rad).value)
shower_result.h_max_uncert = errors[5] * shower_result.h_max
shower_result.goodness_of_fit = np.nan
shower_result.tel_ids = list(self.image.keys())
energy_result = ReconstructedEnergyContainer()
energy_result.energy = fit_params[4] * u.TeV
energy_result.energy_uncert = errors[4] * u.TeV
energy_result.is_valid = True
energy_result.tel_ids = list(self.image.keys())
# Return interesting stuff
return shower_result, energy_result
def predict(self, hillas_parameters, tel_x, tel_y, array_direction):
"""
Parameters
----------
hillas_parameters: dict
Dictionary containing Hillas parameters for all telescopes
in reconstruction
tel_x: dict
Dictionary containing telescope position on ground for all
telescopes in reconstruction
tel_y: dict
Dictionary containing telescope position on ground for all
telescopes in reconstruction
array_direction: AltAz
Pointing direction of the array
Returns
-------
ReconstructedShowerContainer:
"""
src_x, src_y, err_x, err_y = self.reconstruct_nominal(
hillas_parameters)
core_x, core_y, core_err_x, core_err_y = self.reconstruct_tilted(
hillas_parameters, tel_x, tel_y)
err_x *= u.rad
err_y *= u.rad
nom = SkyCoord(x=src_x * u.rad,
y=src_y * u.rad,
frame=NominalFrame(array_direction=array_direction))
horiz = nom.transform_to(AltAz())
result = ReconstructedShowerContainer()
result.alt, result.az = horiz.alt, horiz.az
tilt = SkyCoord(
x=core_x * u.m,
y=core_y * u.m,
frame=TiltedGroundFrame(pointing_direction=array_direction),
)
grd = project_to_ground(tilt)
result.core_x = grd.x
result.core_y = grd.y
x_max = self.reconstruct_xmax(
nom.x,
nom.y,
tilt.x,
tilt.y,
hillas_parameters,
tel_x,
tel_y,
90 * u.deg - array_direction.alt,
)
result.core_uncert = np.sqrt(core_err_x**2 + core_err_y**2) * u.m
result.tel_ids = [h for h in hillas_parameters.keys()]
result.average_intensity = np.mean(
[h.intensity for h in hillas_parameters.values()])
result.is_valid = True
src_error = np.sqrt(err_x**2 + err_y**2)
result.alt_uncert = src_error.to(u.deg)
result.az_uncert = src_error.to(u.deg)
result.h_max = x_max
result.h_max_uncert = np.nan
result.goodness_of_fit = np.nan
return result
def predict(self, shower_seed, energy_seed):
"""
Parameters
----------
source_x: float
Initial guess of source position in the nominal frame
source_y: float
Initial guess of source position in the nominal frame
core_x: float
Initial guess of the core position in the tilted system
core_y: float
Initial guess of the core position in the tilted system
energy: float
Initial guess of energy
Returns
-------
Shower object with fit results
"""
horizon_seed = HorizonFrame(az=shower_seed.az, alt=shower_seed.alt)
nominal_seed = horizon_seed.transform_to(
NominalFrame(array_direction=self.array_direction))
source_x = nominal_seed.x.to(u.rad).value
source_y = nominal_seed.y.to(u.rad).value
ground = GroundFrame(x=shower_seed.core_x,
y=shower_seed.core_y,
z=0 * u.m)
tilted = ground.transform_to(
TiltedGroundFrame(pointing_direction=self.array_direction))
tilt_x = tilted.x.to(u.m).value
tilt_y = tilted.y.to(u.m).value
lower_en_limit = energy_seed.energy * 0.1
if lower_en_limit < 0.04 * u.TeV:
lower_en_limit = 0.04 * u.TeV
# Create Minuit object with first guesses at parameters, strip away the
# units as Minuit doesnt like them
min = Minuit(self.get_likelihood,
print_level=1,
source_x=source_x,
error_source_x=0.01 / 57.3,
fix_source_x=False,
limit_source_x=(source_x - 0.5 / 57.3,
source_x + 0.5 / 57.3),
source_y=source_y,
error_source_y=0.01 / 57.3,
fix_source_y=False,
limit_source_y=(source_y - 0.5 / 57.3,
source_y + 0.5 / 57.3),
core_x=tilt_x,
error_core_x=10,
limit_core_x=(tilt_x - 200, tilt_x + 200),
core_y=tilt_y,
error_core_y=10,
limit_core_y=(tilt_y - 200, tilt_y + 200),
energy=energy_seed.energy.value,
error_energy=energy_seed.energy.value * 0.05,
limit_energy=(lower_en_limit.value,
energy_seed.energy.value * 10.),
x_max_scale=1,
error_x_max_scale=0.1,
limit_x_max_scale=(0.5, 2),
fix_x_max_scale=False,
errordef=1)
min.tol *= 1000
min.strategy = 0
# Perform minimisation
migrad = min.migrad()
fit_params = min.values
errors = min.errors
# print(migrad)
# print(min.minos())
# container class for reconstructed showers '''
shower_result = ReconstructedShowerContainer()
nominal = NominalFrame(x=fit_params["source_x"] * u.rad,
y=fit_params["source_y"] * u.rad,
array_direction=self.array_direction)
horizon = nominal.transform_to(HorizonFrame())
shower_result.alt, shower_result.az = horizon.alt, horizon.az
tilted = TiltedGroundFrame(x=fit_params["core_x"] * u.m,
y=fit_params["core_y"] * u.m,
pointing_direction=self.array_direction)
ground = project_to_ground(tilted)
shower_result.core_x = ground.x
shower_result.core_y = ground.y
shower_result.is_valid = True
shower_result.alt_uncert = np.nan
shower_result.az_uncert = np.nan
shower_result.core_uncert = np.nan
zenith = 90 * u.deg - self.array_direction[0]
shower_result.h_max = fit_params["x_max_scale"] * \
self.get_shower_max(fit_params["source_x"],
fit_params["source_y"],
fit_params["core_x"],
fit_params["core_y"],
zenith.to(u.rad).value)
shower_result.h_max_uncert = errors["x_max_scale"] * shower_result.h_max
shower_result.goodness_of_fit = np.nan
shower_result.tel_ids = list(self.image.keys())
energy_result = ReconstructedEnergyContainer()
energy_result.energy = fit_params["energy"] * u.TeV
energy_result.energy_uncert = errors["energy"] * u.TeV
energy_result.is_valid = True
energy_result.tel_ids = list(self.image.keys())
# Return interesting stuff
return shower_result, energy_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
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
