def test_ground_to_tilt():
from ctapipe.coordinates import GroundFrame, TiltedGroundFrame
# define ground coordinate
grd_coord = GroundFrame(x=1 * u.m, y=2 * u.m, z=0 * u.m)
pointing_direction = SkyCoord(alt=90 * u.deg, az=0 * u.deg, frame=AltAz())
# Convert to tilted frame at zenith (should be the same)
tilt_coord = grd_coord.transform_to(
TiltedGroundFrame(pointing_direction=pointing_direction)
)
assert tilt_coord.separation_3d(grd_coord) == 0 * u.m
# Check 180 degree rotation reverses y coordinate
pointing_direction = SkyCoord(alt=90 * u.deg, az=180 * u.deg, frame=AltAz())
tilt_coord = grd_coord.transform_to(
TiltedGroundFrame(pointing_direction=pointing_direction)
)
assert np.abs(tilt_coord.y + 2. * u.m) < 1e-5 * u.m
# Check that if we look at horizon the x coordinate is 0
pointing_direction = SkyCoord(alt=0 * u.deg, az=0 * u.deg, frame=AltAz())
tilt_coord = grd_coord.transform_to(
TiltedGroundFrame(pointing_direction=pointing_direction)
)
assert np.abs(tilt_coord.x) < 1e-5 * u.m
def overlay_hillas(self, hillas, scale_fac=10000, draw_axes=False, **kwargs):
"""
Overlay hillas parameters on top of the array map
Parameters
----------
hillas: dictionary
Hillas moments objects to overlay
scale_fac: float
Scaling factor to array to hillas width and length when drawing
kwargs: key=value
any style keywords to pass to matplotlib
Returns
-------
None
"""
tel_x = [self.instrument.tel_pos[i][0].to(u.m).value for i in hillas]
tel_y = [self.instrument.tel_pos[i][1].to(u.m).value for i in hillas]
tel_z = [self.instrument.tel_pos[i][2].to(u.m).value for i in hillas]
if self.system is not None:
ground = GroundFrame(x=np.asarray(tel_x)*u.m, y=np.asarray(tel_y)*u.m, z=np.asarray(tel_z)*u.m)
new_sys = ground.transform_to(self.system)
self.array.overlay_moments(hillas, (new_sys.x, new_sys.y), scale_fac,
cmap="Greys", alpha=0.5, **kwargs)
if draw_axes:
self.array.overlay_axis(hillas, (new_sys.x, new_sys.y))
else:
self.array.overlay_moments(hillas, (tel_x, tel_y), scale_fac, alpha=0.5,
cmap="Greys", **kwargs)
self.hillas = hillas
def draw_position(self, core_x, core_y, use_centre=False, **kwargs):
"""
Draw a marker at a position in the array plotter (for marking reconstructed
positions etc)
Parameters
----------
core_x: float
X position of point
core_y: float
Y position of point
use_centre: bool
Centre the plotter on this position
kwargs: key=value
any style keywords to pass to matplotlib
Returns
-------
None
"""
ground = GroundFrame(x=np.asarray(core_x) * u.m, y=np.asarray(core_y) * u.m, z=np.asarray(0) * u.m)
if self.system is not None:
new_sys = ground.transform_to(self.system)
else:
new_sys = ground
self.array.add_polygon(centroid=(new_sys.x.value,new_sys.y.value), radius=10, nsides=3, **kwargs)
if use_centre:
self.centre = (new_sys.x.value,new_sys.y.value)
def get_prediction(self, tel_id, shower_reco, energy_reco):
horizon_seed = HorizonFrame(az=shower_reco.az, alt=shower_reco.alt)
nominal_seed = horizon_seed.transform_to(
NominalFrame(array_direction=horizon_seed))
source_x = nominal_seed.x.to(u.rad).value
source_y = nominal_seed.y.to(u.rad).value
ground = GroundFrame(x=shower_reco.core_x, y=shower_reco.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
azimuth = self.array_direction.az
x_max = shower_reco.h_max / np.cos(zenith)
# Calculate expected Xmax given this energy
x_max_exp = guess_shower_depth(energy_reco.energy)
# Convert to binning of Xmax, addition of 100 can probably be removed
x_max_bin = x_max - x_max_exp
# Check for range
if x_max_bin > 250 * (u.g*u.cm**-2):
x_max_bin = 250 * (u.g*u.cm**-2)
if x_max_bin < -250 * (u.g*u.cm**-2):
x_max_bin = -250 * (u.g*u.cm**-2)
x_max_bin = x_max_bin.value
impact = np.sqrt(pow(self.tel_pos_x[tel_id] - tilt_x, 2) +
pow(self.tel_pos_y[tel_id] - tilt_y, 2))
phi = np.arctan2( (self.tel_pos_y[tel_id] - tilt_y),
(self.tel_pos_x[tel_id] - tilt_x))
pix_x_rot, pix_y_rot = self.rotate_translate(self.pixel_x[tel_id]
* -1,
self.pixel_y[tel_id],
source_x,
source_y, phi)
prediction = self.image_prediction(self.type[tel_id],
(90 * u.deg) - shower_reco.alt,
shower_reco.az,
energy_reco.energy.value,
impact, x_max_bin,
pix_x_rot * (180 / math.pi),
pix_y_rot * (180 / math.pi))
prediction *= self.scale[self.type[tel_id]]
#prediction *= self.pixel_area[tel_id]
prediction[prediction < 0] = 0
prediction[np.isnan(prediction)] = 0
return prediction
def draw_tilted_surface(self, shower_seed, energy_seed,
bins=50, core_range=100 * u.m):
"""
Simple reconstruction for evaluating the likelihood in a grid across the
nominal system, fixing all values but the core position of the gamma rays.
Useful for checking the reconstruction performance of the algorithm
Parameters
----------
shower_seed: ReconstructedShowerContainer
Best fit ImPACT shower geometry
energy_seed: ReconstructedEnergyContainer
Best fit ImPACT energy
bins: int
Number of bins in surface evaluation
nominal_range: Quantity
Range over which to create likelihood surface
Returns
-------
ndarray, ndarray, ndarray:
Bin centres in X and Y coordinates and the values of the likelihood at each
position
"""
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[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)
tilt_y = tilted.y.to(u.m)
x_ground_list = np.linspace(tilt_x - core_range, tilt_x + core_range, num=bins)
y_ground_list = np.linspace(tilt_y - core_range, tilt_y + core_range, num=bins)
w = np.zeros([bins, bins])
zenith = 90*u.deg - self.array_direction.alt
for xb in range(bins):
for yb in range(bins):
x_max_scale = shower_seed.h_max / \
self.get_shower_max(source_x,
source_y,
x_ground_list[xb].value,
y_ground_list[yb].value,
zenith.to(u.rad).value)
w[xb][yb] = self.get_likelihood(source_x,
source_y,
x_ground_list[xb].value,
y_ground_list[yb].value,
energy_seed.energy.value, x_max_scale)
return x_ground_list, y_ground_list, w
def get_prediction(self, tel_id, shower_reco, energy_reco):
horizon_seed = HorizonFrame(az=shower_reco.az, alt=shower_reco.alt)
nominal_seed = horizon_seed.transform_to(
NominalFrame(array_direction=horizon_seed))
source_x = nominal_seed.x.to(u.rad).value
source_y = nominal_seed.y.to(u.rad).value
print(self.array_direction[0])
ground = GroundFrame(x=shower_reco.core_x,
y=shower_reco.core_y, z=0 * u.m)
tilted = ground.transform_to(
TiltedGroundFrame(
pointing_direction=HorizonFrame(alt=self.array_direction[0],
az=self.array_direction[1])
)
)
tilt_x = tilted.x.to(u.m).value
tilt_y = tilted.y.to(u.m).value
zenith = 90 * u.deg - self.array_direction[0]
azimuth = self.array_direction[1]
x_max_exp = 300 + 93 * np.log10(energy_reco.energy.value)
x_max = shower_reco.h_max / np.cos(zenith)
# Convert to binning of Xmax, addition of 100 can probably be removed
x_max_bin = x_max.value - x_max_exp
if x_max_bin > 100:
x_max_bin = 100
if x_max_bin < -100:
x_max_bin = -100
impact = np.sqrt(pow(self.tel_pos_x[tel_id] - tilt_x, 2) +
pow(self.tel_pos_y[tel_id] - tilt_y, 2))
phi = np.arctan2( (self.tel_pos_y[tel_id] - tilt_y),
(self.tel_pos_x[tel_id] - tilt_x))
pix_x_rot, pix_y_rot = self.rotate_translate(self.pixel_x[tel_id]
* -1,
self.pixel_y[tel_id],
source_x,
source_y, phi)
prediction = self.image_prediction(self.type[tel_id],
20 * u.deg,
0 * u.deg,
energy_reco.energy.value,
impact, x_max_bin,
pix_x_rot * (180 / math.pi),
pix_y_rot * (180 / math.pi))
prediction *= self.scale[self.type[tel_id]]
prediction[prediction < 0] = 0
prediction[np.isnan(prediction)] = 0
return prediction
def grd_to_tilt():
grd_coord = GroundFrame(x=1 * u.m, y=2 * u.m, z=0 * u.m)
tilt_coord = grd_coord.transform_to(
TiltedGroundFrame(
pointing_direction=HorizonFrame(alt=90 * u.deg, az=180 * u.deg)
)
)
print(project_to_ground(tilt_coord))
print("Tilted Coordinate", tilt_coord)
def __init__(self, instrument, telescopes=None, system=None, ax=None):
"""
Parameters
----------
instrument: dictionary
intrument containers for this event
telescopes: list
List of telescopes included
system: Coordinate system
Coordinate system to transform coordinates into
"""
self.instrument = instrument
self.system = system
if telescopes is None:
self.telescopes = instrument.telescope_ids
else:
self.telescopes = telescopes
type_dict = {28.0: 1, 16.0: 2,
2.1500000953674316: 3,
2.2829999923706055: 4,
5.599999904632568: 5}
tel_x = [self.instrument.tel_pos[i][0].to(u.m).value for i in self.telescopes]
tel_y = [self.instrument.tel_pos[i][1].to(u.m).value for i in self.telescopes]
tel_z = [self.instrument.tel_pos[i][2].to(u.m).value for i in self.telescopes]
self.axes = ax if ax is not None else plt.gca()
tel_type = np.asarray([type_dict[self.instrument.optical_foclen[i].to(u.m).value] for i in self.telescopes])
self.tel_type = tel_type
if system is not None:
ground = GroundFrame(x=np.asarray(tel_x)*u.m, y=np.asarray(tel_y)*u.m, z=np.asarray(tel_z)*u.m)
new_sys = ground.transform_to(system)
self.tel_x = new_sys.x
self.tel_y = new_sys.y
else:
self.tel_x = tel_x*u.m
self.tel_y = tel_y*u.m
self.centre = (0,0)
self.array = ArrayDisplay(telx=np.asarray(self.tel_x), tely=np.asarray(self.tel_y), tel_type=tel_type,
axes=self.axes)
self.hillas = None
def get_prediction(self, tel_id, shower_reco, energy_reco):
horizon_seed = HorizonFrame(az=shower_reco.az, alt=shower_reco.alt)
nominal_seed = horizon_seed.transform_to(
NominalFrame(array_direction=horizon_seed))
source_x = nominal_seed.x.to(u.rad).value
source_y = nominal_seed.y.to(u.rad).value
ground = GroundFrame(x=shower_reco.core_x,
y=shower_reco.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
x_max = shower_reco.h_max / np.cos(zenith)
# Calculate expected Xmax given this energy
x_max_exp = guess_shower_depth(energy_reco.energy)
# Convert to binning of Xmax, addition of 100 can probably be removed
x_max_bin = x_max - x_max_exp
# Check for range
if x_max_bin > 250 * (u.g * u.cm**-2):
x_max_bin = 250 * (u.g * u.cm**-2)
if x_max_bin < -250 * (u.g * u.cm**-2):
x_max_bin = -250 * (u.g * u.cm**-2)
x_max_bin = x_max_bin.value
impact = np.sqrt(
pow(self.tel_pos_x[tel_id] - tilt_x, 2) +
pow(self.tel_pos_y[tel_id] - tilt_y, 2))
phi = np.arctan2((self.tel_pos_y[tel_id] - tilt_y),
(self.tel_pos_x[tel_id] - tilt_x))
pix_x_rot, pix_y_rot = self.rotate_translate(self.pixel_x[tel_id] * -1,
self.pixel_y[tel_id],
source_x, source_y, phi)
prediction = self.image_prediction(
self.tel_type[tel_id],
# (90 * u.deg) - shower_reco.alt,
# shower_reco.az,
energy_reco.energy.value,
impact,
x_max_bin,
pix_x_rot * (180 / math.pi),
pix_y_rot * (180 / math.pi))
prediction *= self.scale[self.tel_type[tel_id]]
# prediction *= self.pixel_area[tel_id]
prediction[prediction < 0] = 0
prediction[np.isnan(prediction)] = 0
return prediction
def grd_to_tilt():
grd_coord = GroundFrame(x=1 * u.m, y=2 * u.m, z=0 * u.m)
tilt_coord = grd_coord.transform_to(
TiltedGroundFrame(pointing_direction=[90 * u.deg, 180 * u.deg]))
print(project_to_ground(tilt_coord))
print("Tilted Coordinate", tilt_coord)
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.fov_lon.to_value(u.rad)
source_y = nominal_seed.fov_lat.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(fov_lon=fit_params[0] * u.rad,
fov_lat=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, 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 __init__(self, instrument, telescopes=None, system=None, ax=None):
"""
Parameters
----------
instrument: dictionary
intrument containers for this event
telescopes: list
List of telescopes included
system: Coordinate system
Coordinate system to transform coordinates into
"""
self.instrument = instrument
self.system = system
if telescopes is None:
self.telescopes = instrument.telescope_ids
else:
self.telescopes = telescopes
type_dict = {
28.0: 1,
16.0: 2,
2.1500000953674316: 3,
2.2829999923706055: 4,
5.599999904632568: 5
}
tel_x = [
self.instrument.tel_pos[i][0].to(u.m).value
for i in self.telescopes
]
tel_y = [
self.instrument.tel_pos[i][1].to(u.m).value
for i in self.telescopes
]
tel_z = [
self.instrument.tel_pos[i][2].to(u.m).value
for i in self.telescopes
]
self.axes = ax if ax is not None else plt.gca()
tel_type = np.asarray([
type_dict[self.instrument.optical_foclen[i].to(u.m).value]
for i in self.telescopes
])
self.tel_type = tel_type
if system is not None:
ground = GroundFrame(x=np.asarray(tel_x) * u.m,
y=np.asarray(tel_y) * u.m,
z=np.asarray(tel_z) * u.m)
new_sys = ground.transform_to(system)
self.tel_x = new_sys.x
self.tel_y = new_sys.y
else:
self.tel_x = tel_x * u.m
self.tel_y = tel_y * u.m
self.centre = (0, 0)
self.array = ArrayDisplay(telx=np.asarray(self.tel_x),
tely=np.asarray(self.tel_y),
tel_type=tel_type,
axes=self.axes)
self.hillas = None
def draw_nominal_surface(self, shower_seed, energy_seed, bins=30,
nominal_range=2.5*u.deg):
"""
Simple reconstruction for evaluating the likelihood in a grid across the
nominal system, fixing all values but the source position of the gamma rays.
Useful for checking the reconstruction performance of the algorithm
Parameters
----------
shower_seed: ReconstructedShowerContainer
Best fit ImPACT shower geometry
energy_seed: ReconstructedEnergyContainer
Best fit ImPACT energy
bins: int
Number of bins in surface evaluation
nominal_range: Quantity
Range over which to create likelihood surface
Returns
-------
ndarray, ndarray, ndarray:
Bin centres in X and Y coordinates and the values of the likelihood at each
position
"""
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[0].to(u.rad)
source_y = nominal_seed.y[0].to(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)
tilt_y = tilted.y.to(u.m)
x_dir = np.linspace(source_x - nominal_range, source_x + nominal_range, num=bins)
y_dir = np.linspace(source_y - nominal_range, source_y + nominal_range, num=bins)
w = np.zeros([bins, bins])
zenith = 90*u.deg - self.array_direction.alt
for xb in range(bins):
for yb in range(bins):
x_max_scale = shower_seed.h_max / \
self.get_shower_max(x_dir[xb].to(u.rad).value,
y_dir[yb].to(u.rad).value,
tilt_x.value,
tilt_y.value,
zenith.to(u.rad).value)
w[xb][yb] = self.get_likelihood(x_dir[xb].to(u.rad).value,
y_dir[yb].to(u.rad).value,
tilt_x.value,
tilt_y.value,
energy_seed.energy.value, x_max_scale)
w = w - np.min(w)
return x_dir.to(u.deg), y_dir.to(u.deg), w
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 tilted_grid(event, tel_pos=False, zen_az_arrows=False):
"""
Return the telescopes positions in the TiltedGroundFrame and plot them according to azimuth and zenith of simulation
:param event: event selected from simtel
:param tel_pos: (bool) If True, plot the telescopes as spheres
:param zen_az_arrows: plot curved arrows for ZEN and AZ in titled ref frame
:return:
"""
alt = event.mcheader.run_array_direction[1]
az = event.mcheader.run_array_direction[0]
array_pointing = HorizonFrame(alt=alt, az=az)
ground_coordinates = GroundFrame(
x=event.inst.subarray.tel_coords.x,
y=event.inst.subarray.tel_coords.y,
z=event.inst.subarray.tel_coords.z, # *0+15.0*u.m,
pointing_direction=array_pointing)
tilted_system = TiltedGroundFrame(pointing_direction=array_pointing)
tilted = ground_coordinates.transform_to(tilted_system)
grid_unit = 20000 # in centimeters
tilted_system = union()
# ADD TELESCOPES AS SPHERES
if tel_pos:
# for i in range(tilted.x.size):
for i in range(50):
coords = [100 * tilted.x[i].value, 100 * tilted.y[i].value]
position = translate(coords)(color([1, 0, 0])(sphere(r=800)))
tilted_system.add(position)
# add GRID
grid_tilted = grid_plane(
grid_unit=grid_unit,
count=2 *
int(100 * np.max(np.abs(ground_coordinates.x.value)) / grid_unit),
line_weight=200,
plane='xy')
grid_tilted = color([1, 0, 0, 0.5])(grid_tilted)
grid_tilted = grid_tilted + ref_arrow_2d(
8000, label={
'x': "x_tilted",
'y': "y_tilted"
}, origin=(0, 0))
tilted_system = rotate([0, 90 - alt.to('deg').value,
az.to('deg').value])(tilted_system)
tilted_system.add(grid_tilted)
arr_curved_az = color([1, 1, 0])(rot_arrow(8000,
az.to('deg').value,
0,
label='AZ'))
tilted_system.add(arr_curved_az)
arr_curved_alt = color([1, 0, 1])(rot_arrow(8000,
0,
90 - alt.to('deg').value,
label='ZEN'))
arr_curved_alt = rotate([90, 0, 0])(arr_curved_alt)
tilted_system.add(arr_curved_alt)
return tilted_system
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, 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 grd_to_tilt():
grd_coord = GroundFrame(x=1*u.m, y=2*u.m, z=0*u.m)
tilt_coord = grd_coord.transform_to(TiltedGroundFrame(pointing_direction = [90*u.deg,180*u.deg]))
print("Tilted Coordinate",tilt_coord)
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