def test_camera_to_sky():
pos_x = np.array([0, 0]) * u.m
pos_y = np.array([0, 0]) * u.m
focal = 28*u.m
pointing_alt = np.array([1.0, 1.0]) * u.rad
pointing_az = np.array([0.2, 0.5]) * u.rad
sky_coords = utils.camera_to_sky(pos_x, pos_y, focal, pointing_alt, pointing_az)
np.testing.assert_allclose(sky_coords.alt, pointing_alt, rtol=1e-4)
np.testing.assert_allclose(sky_coords.az, pointing_az, rtol=1e-4)
def test_change_frame_camera_sky():
from lstchain.reco.utils import sky_to_camera, camera_to_sky
import astropy.units as u
x = np.random.rand(1) * u.m
y = np.random.rand(1) * u.m
focal_length = 5 * u.m
pointing_alt = np.pi / 3. * u.rad
pointing_az = 0. * u.rad
sky_pos = camera_to_sky(x, y, focal_length, pointing_alt, pointing_az)
cam_pos = sky_to_camera(sky_pos.alt, sky_pos.az, focal_length,
pointing_alt, pointing_az)
np.testing.assert_almost_equal([x, y], [cam_pos.x, cam_pos.y])
# TEMPORARY - just to speed up the code for tests as astropy transformations takes ages
#################################################
f = 0.1 / 0.05 # deg / m
src_separation_approx = f * np.sqrt((x_reco.value - np.array(param_test['src_x'])[0])**2 + (y_reco.value - np.array(param_test['src_y'])[0])**2)
sorted = np.sort(src_separation_approx)
index_68 = int(0.6827 * sorted.size)
resolution_approx = sorted[index_68] * u.deg
print("APPROXIMATIVE Resolution (68% containment): {:.4f}".format(resolution_approx))
################################################
else:
# Resolution for all energy bins together
# transformation of reconstructed coordinates to horizon frame: (az, alt) in deg
# - transformace vcetne vypoctu .separation a rozliseni funguje dobre - overeno aproximacnim
# vypoctem pomoci prepoctu vzdalenosti v metrech s pomoci faktoru 0.1 deg / 0.05 m, coz
# je rozliseni a velikost jednoho pixelu LST kamery
sky_coords_reco = utils.camera_to_sky(x_reco, y_reco, focal_length, pointing_alt, pointing_az)
# Transformation of true source coordinates to horizon frame
sky_coords_source = utils.camera_to_sky(np.array(param_test['src_x'])[0] * u.m, np.array(param_test['src_y'])[0] * u.m, focal_length, pointing_alt[0], pointing_az[0])
# Angular distance of each reconstructed position to the true position of the source
src_separation = sky_coords_reco.separation(sky_coords_source)
# 68 % containment
sorted = np.sort(src_separation)
index_68 = int(0.6827 * sorted.size)
resolution = sorted[index_68]
print("Resolution (68% containment): {:.4f}".format(resolution))
# FIGURES
# Plotting feature importance
plt.figure()
source_position = [np.array(param_gamma['src_x'])[0], np.array(param_gamma['src_y'])[0]] # source position in the FOV [m]
pointing_alt_gamma = np.array(param_gamma['mc_alt_tel']) * u.rad
pointing_az_gamma = np.array(param_gamma['mc_az_tel']) * u.rad
pointing_alt_gamma_diffuse = np.array(param_gamma_diffuse['mc_alt_tel']) * u.rad
pointing_az_gamma_diffuse = np.array(param_gamma_diffuse['mc_az_tel']) * u.rad
pointing_alt_proton = np.array(param_proton['mc_alt_tel']) * u.rad
pointing_az_proton = np.array(param_proton['mc_az_tel']) * u.rad
focal_length = 28 * u.m
if args.fast:
# TEMPORARY - rychly vypocet bez transformace souradnic
f = 0.1 / 0.05 # deg / m
param_gamma['theta2'] = f**2 * ((source_position[0]-param_gamma['reco_src_x'])**2 + (source_position[1]-param_gamma['reco_src_y'])**2)
param_proton['theta2'] = f**2 * ((source_position[0]-param_proton['reco_src_x'])**2 + (source_position[1]-param_proton['reco_src_y'])**2)
param_proton['theta2_true'] = f**2 * ((source_position[0]-param_proton['src_x'])**2 + (source_position[1]-param_proton['src_y'])**2)
else:
sky_coords_reco_gamma = utils.camera_to_sky(np.array(param_gamma['reco_src_x']) * u.m, np.array(param_gamma['reco_src_y']) * u.m, focal_length, pointing_alt_gamma, pointing_az_gamma)
sky_coords_true_gamma = utils.camera_to_sky(np.array(param_gamma['src_x']) * u.m, np.array(param_gamma['src_y']) * u.m, focal_length, pointing_alt_gamma, pointing_az_gamma)
sky_coords_reco_gamma_diffuse = utils.camera_to_sky(np.array(param_gamma_diffuse['reco_src_x']) * u.m, np.array(param_gamma_diffuse['reco_src_y']) * u.m, focal_length, pointing_alt_gamma_diffuse, pointing_az_gamma_diffuse)
sky_coords_true_gamma_diffuse = utils.camera_to_sky(np.array(param_gamma_diffuse['src_x']) * u.m, np.array(param_gamma_diffuse['src_y']) * u.m, focal_length, pointing_alt_gamma_diffuse, pointing_az_gamma_diffuse)
sky_coords_reco_proton = utils.camera_to_sky(np.array(param_proton['reco_src_x']) * u.m, np.array(param_proton['reco_src_y']) * u.m, focal_length, pointing_alt_proton, pointing_az_proton)
sky_coords_true_proton = utils.camera_to_sky(np.array(param_proton['src_x']) * u.m, np.array(param_proton['src_y']) * u.m, focal_length, pointing_alt_proton, pointing_az_proton)
sky_coords_source_gamma = utils.camera_to_sky(source_position[0] * u.m, source_position[1] * u.m, focal_length, pointing_alt_gamma[0], pointing_az_gamma[0])
sky_coords_source_gamma_diffuse = utils.camera_to_sky(source_position[0] * u.m, source_position[1] * u.m, focal_length, pointing_alt_gamma[0], pointing_az_gamma[0])
sky_coords_source_proton = utils.camera_to_sky(source_position[0] * u.m, source_position[1] * u.m, focal_length, pointing_alt_proton[0], pointing_az_proton[0])
sky_coords_camera_center = utils.camera_to_sky(0 * u.m, 0 * u.m, focal_length, pointing_alt_gamma_diffuse[0], pointing_az_gamma_diffuse[0])
param_gamma['offaxis_angle'] = sky_coords_true_gamma.separation(sky_coords_camera_center)
param_gamma_diffuse['offaxis_angle'] = sky_coords_true_gamma_diffuse.separation(sky_coords_camera_center)
param_proton['offaxis_angle'] = sky_coords_true_proton.separation(sky_coords_camera_center)
# Theta2
param_gamma['theta2'] = sky_coords_reco_gamma.separation(sky_coords_source_gamma)**2
param_gamma['theta2_true'] = sky_coords_true_gamma.separation(sky_coords_source_gamma)**2
