def background_contour(self, x, y, background, **kwargs):
"""
Draw image contours in background of the display, useful when likelihood fitting
Parameters
----------
x: ndarray
array of image X coordinates
y: ndarray
array of image Y coordinates
background: ndarray
Array of image to use in background
kwargs: key=value
any style keywords to pass to matplotlib
Returns
-------
None
"""
self.axes.contour(x, y, background, **kwargs)
# Annoyingly we need to redraw everything
self.array = ArrayDisplay(telx=np.asarray(self.cen_x),
tely=np.asarray(self.cen_y),
tel_type=np.ones(len(self.cen_y)),
axes=self.axes)
def __init__(self, hillas_parameters, draw_axes=False, ax=None, **kwargs):
"""
Parameters
----------
instrument: dictionary
intrument containers for this event
telescopes: list
List of telescopes included
system: Coordinate system
Coordinate system to transform coordinates into
"""
self.axes = ax if ax is not None else plt.gca()
self.cen_x = [i.cen_x.to(u.deg).value for i in hillas_parameters.values()]
self.cen_y = [i.cen_y.to(u.deg).value for i in hillas_parameters.values()]
self.centre = (0, 0)
self.array = ArrayDisplay(telx=np.asarray(self.cen_x),
tely=np.asarray(self.cen_y),
tel_type=np.ones(len(self.cen_y)),
axes=self.axes)
self.hillas = hillas_parameters
scale_fac = 57.3 * 2
self.array.overlay_moments(hillas_parameters, (self.cen_x, self.cen_y), scale_fac,
cmap="Greys", alpha=0.5, **kwargs)
if draw_axes:
self.array.overlay_axis(hillas_parameters, (self.cen_x, self.cen_y))
def peek(self):
"""
Draw a quick matplotlib plot of the array
"""
from ctapipe.coordinates.ground_frames import EastingNorthingFrame
from ctapipe.visualization import ArrayDisplay
from matplotlib import pyplot as plt
plt.figure(figsize=(8, 8))
ad = ArrayDisplay(subarray=self, frame=EastingNorthingFrame(), tel_scale=0.75)
ad.add_labels()
plt.title(self.name)
plt.tight_layout()
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 plot_telescope_layout(tel_layout_file_name):
layout_file = "/Users/alicedonini/PycharmProjects/Pointing_tool/layout-3AL4-BN15-MST.txt"
grd_coords = pd.read_csv(layout_file,
header=None,
delimiter=" ",
names=["x", "y", "z"],
engine='python')
# convert to m
grd_coords = grd_coords / 100
# create a dictionary with the tel position on the ground by tel_id and the tel description
tel_descr = {}
G_coords = {}
for tel_id, coord in enumerate(grd_coords.values, 1):
G_coords[tel_id] = coord * u.m
tel_descr[tel_id] = TelescopeDescription.from_name(
optics_name='MST', camera_name='NectarCam')
# create the subarray
sub = SubarrayDescription(name="Baseline only MST",
tel_positions=G_coords,
tel_descriptions=tel_descr)
#sub.info()
#sub.to_table(kind='optics')
# display the array
plt.figure(num=None, figsize=(7, 7), facecolor='w', edgecolor='k')
disp = ArrayDisplay(sub, tel_scale=3.0)
return sub
def background_contour(self, x, y, background, **kwargs):
"""
Draw image contours in background of the display, useful when likelihood fitting
Parameters
----------
x: ndarray
array of image X coordinates
y: ndarray
array of image Y coordinates
background: ndarray
Array of image to use in background
kwargs: key=value
any style keywords to pass to matplotlib
Returns
-------
None
"""
self.axes.contour(x, y, background, **kwargs)
# Annoyingly we need to redraw everything
self.array = ArrayDisplay(telx=np.asarray(self.tel_x),
tely=np.asarray(self.tel_y),
tel_type=self.tel_type)
if self.hillas is not None:
self.overlay_hillas(self.hillas)
def __init__(self, hillas_parameters, draw_axes=False, ax=None, **kwargs):
"""
Parameters
----------
instrument: dictionary
intrument containers for this event
telescopes: list
List of telescopes included
system: Coordinate system
Coordinate system to transform coordinates into
"""
self.axes = ax if ax is not None else plt.gca()
self.cen_x = [i.cen_x.to(u.deg).value for i in hillas_parameters.values()]
self.cen_y = [i.cen_y.to(u.deg).value for i in hillas_parameters.values()]
self.centre = (0,0)
self.array = ArrayDisplay(telx=np.asarray(self.cen_x), tely=np.asarray(self.cen_y),
tel_type=np.ones(len(self.cen_y)), axes=self.axes)
self.hillas = hillas_parameters
scale_fac = 57.3 * 2
self.array.overlay_moments(hillas_parameters, (self.cen_x, self.cen_y), scale_fac,
cmap="Greys", alpha=0.5, **kwargs)
if draw_axes:
self.array.overlay_axis(hillas_parameters, (self.cen_x, self.cen_y))
def plotSubArray(self):
ad = ArrayDisplay(ld.telescope_posX, ld.telescope_posY, ld.mirror_area)
for i in range(len(ld.telescope_id)):
name = "CT%i" % ld.telescope_id[i]
plt.text(ld.telescope_posX[i],
ld.telescope_posY[i],
name,
fontsize=8)
ad.axes.set_xlim(-1000, 1000)
ad.axes.set_ylim(-1000, 1000)
plt.show()
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
source = EventSource(filename)
# pointing direction of the telescopes
point_azimuth = {}
point_altitude = {}
subarray = source.subarray
calib = CameraCalibrator(subarray=subarray)
off_angles = []
first_event = True
markers = None
for event in source:
if first_event:
fig, ax = plt.subplots(1, 1, figsize=(10, 8))
array_disp = ArrayDisplay(subarray, axes=ax, tel_scale=1.0)
array_disp.telescopes.set_linewidth(3)
array_disp.add_labels()
first_event = False
hit_pattern = np.zeros(subarray.num_tels)
if len(event.r0.tel.keys()) < 3:
continue
# calibrating the event
calib(event)
hillas_dict = {}
timing_dict = {}
# plot the core position, which must be transformed from the tilted
# system to the system that the ArrayDisplay is in (default
class ArrayPlotter:
"""
Simple plotter for drawing array level items
"""
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 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 background_contour(self, x, y, background, **kwargs):
"""
Draw image contours in background of the display, useful when likelihood fitting
Parameters
----------
x: ndarray
array of image X coordinates
y: ndarray
array of image Y coordinates
background: ndarray
Array of image to use in background
kwargs: key=value
any style keywords to pass to matplotlib
Returns
-------
None
"""
self.axes.contour(x, y, background, **kwargs)
# Annoyingly we need to redraw everything
self.array = ArrayDisplay(telx=np.asarray(self.tel_x),
tely=np.asarray(self.tel_y),
tel_type=self.tel_type)
if self.hillas is not None:
self.overlay_hillas(self.hillas)
def draw_array(self, range=((-2000, 2000), (-2000, 2000)), annotate=False):
"""
Draw the array plotter (including any overlayed elements)
Parameters
----------
range: tuple
XY range in which to draw plotter
Returns
-------
None
"""
self.array.axes.set_xlim(
(self.centre[0] + range[0][0], range[0][1] + self.centre[0]))
self.array.axes.set_ylim(
(self.centre[1] + range[1][0], range[1][1] + self.centre[1]))
if annotate:
for txt, x, y in zip(self.telescopes, self.tel_x.value,
self.tel_y.value):
self.axes.annotate(txt, (x, y))
#self.axes.tight_layout()
#self.axes.show()
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)
import numpy as np
from astropy.table import Table
from ctapipe.utils import datasets
from ctapipe.visualization import ArrayDisplay
from matplotlib import pyplot as plt
if __name__ == '__main__':
plt.style.use("ggplot")
plt.figure(figsize=(10, 8))
arrayfile = datasets.get_path("PROD2_telconfig.fits.gz")
tels = Table.read(arrayfile, hdu="TELESCOPE_LEVEL0")
adisp = ArrayDisplay(tels['TelX'], tels['TelY'], tels['MirrorArea'] * 2,
title='PROD2 telescopes', autoupdate=True)
plt.tight_layout()
values = np.zeros(len(tels))
# do a small animation to show various trigger patterns:
for ii in range(20):
# generate a random trigger pattern and integrated intensity:
ntrig = np.random.poisson(10)
trigmask = np.random.random_integers(len(tels) - 1, size=ntrig)
values[:] = 0
values[trigmask] = np.random.uniform(0, 100, size=ntrig)
# update the display:
class NominalPlotter:
"""
Simple plotter for drawing camera level items in the nominal system
"""
def __init__(self, hillas_parameters, draw_axes=False, ax=None, **kwargs):
"""
Parameters
----------
instrument: dictionary
intrument containers for this event
telescopes: list
List of telescopes included
system: Coordinate system
Coordinate system to transform coordinates into
"""
self.axes = ax if ax is not None else plt.gca()
self.cen_x = [
i.cen_x.to(u.deg).value for i in hillas_parameters.values()
]
self.cen_y = [
i.cen_y.to(u.deg).value for i in hillas_parameters.values()
]
self.centre = (0, 0)
self.array = ArrayDisplay(telx=np.asarray(self.cen_x),
tely=np.asarray(self.cen_y),
tel_type=np.ones(len(self.cen_y)),
axes=self.axes)
self.hillas = hillas_parameters
scale_fac = 57.3 * 2
self.array.overlay_moments(hillas_parameters, (self.cen_x, self.cen_y),
scale_fac,
cmap="Greys",
alpha=0.5,
**kwargs)
if draw_axes:
self.array.overlay_axis(hillas_parameters,
(self.cen_x, self.cen_y))
def background_contour(self, x, y, background, **kwargs):
"""
Draw image contours in background of the display, useful when likelihood fitting
Parameters
----------
x: ndarray
array of image X coordinates
y: ndarray
array of image Y coordinates
background: ndarray
Array of image to use in background
kwargs: key=value
any style keywords to pass to matplotlib
Returns
-------
None
"""
self.axes.contour(x, y, background, **kwargs)
# Annoyingly we need to redraw everything
self.array = ArrayDisplay(telx=np.asarray(self.cen_x),
tely=np.asarray(self.cen_y),
tel_type=np.ones(len(self.cen_y)),
axes=self.axes)
def draw_array(self, range=((-4, 4), (-4, 4))):
"""
Draw the array plotter (including any overlayed elements)
Parameters
----------
range: tuple
XY range in which to draw plotter
Returns
-------
None
"""
self.array.axes.set_xlim(
(self.centre[0] + range[0][0], range[0][1] + self.centre[0]))
self.array.axes.set_ylim(
(self.centre[1] + range[1][0], range[1][1] + self.centre[1]))
#self.axes.tight_layout()
#self.axes.show()
def draw_position(self, source_x, source_y, use_centre=False, **kwargs):
"""
Draw a marker at a position in the array plotter (for marking reconstructed
positions etc)
Parameters
----------
source_x: float
X position of point
source_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
"""
self.array.add_polygon(centroid=(source_x.to(u.deg).value,
source_y.to(u.deg).value),
radius=0.1,
nsides=3,
**kwargs)
if use_centre:
self.centre = (source_x.value, source_y.value)
class ArrayPlotter:
"""
Simple plotter for drawing array level items
"""
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 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 background_contour(self, x, y, background, **kwargs):
"""
Draw image contours in background of the display, useful when likelihood fitting
Parameters
----------
x: ndarray
array of image X coordinates
y: ndarray
array of image Y coordinates
background: ndarray
Array of image to use in background
kwargs: key=value
any style keywords to pass to matplotlib
Returns
-------
None
"""
self.axes.contour(x, y, background, **kwargs)
# Annoyingly we need to redraw everything
self.array = ArrayDisplay(telx=np.asarray(self.tel_x),
tely=np.asarray(self.tel_y),
tel_type=self.tel_type)
if self.hillas is not None:
self.overlay_hillas(self.hillas)
def draw_array(self, range=((-2000, 2000), (-2000, 2000)),
annotate=False):
"""
Draw the array plotter (including any overlayed elements)
Parameters
----------
range: tuple
XY range in which to draw plotter
Returns
-------
None
"""
self.array.axes.set_xlim((self.centre[0]+range[0][0], range[0][1]+self.centre[0]))
self.array.axes.set_ylim((self.centre[1]+range[1][0], range[1][1]+self.centre[1]))
if annotate:
for txt, x, y in zip(self.telescopes,
self.tel_x.value, self.tel_y.value):
self.axes.annotate(txt, (x, y))
#self.axes.tight_layout()
#self.axes.show()
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)
if __name__ == '__main__':
plt.figure(figsize=(9.5, 8.5))
# load up a single event, so we can get the subarray info:
source = event_source(
datasets.get_dataset_path("gamma_test_large.simtel.gz"),
max_events=1,
)
event = next(iter(source))
# display the array
subarray = event.inst.subarray
ad = ArrayDisplay(subarray, tel_scale=3.0)
print("Now setting vectors")
plt.pause(1.0)
plt.tight_layout()
for phi in np.linspace(0, 360, 30) * u.deg:
r = np.cos(phi / 2)
ad.set_vector_rho_phi(r, phi)
plt.pause(0.01)
ad.set_vector_rho_phi(0, 0 * u.deg)
plt.pause(1.0)
print("Now setting values")
ad.telescopes.set_linewidth(0)
# ignore events with less than two telescopes
if len(hillas_containers) < 2:
continue
array_pointing = SkyCoord(az=event.mcheader.run_array_direction[0],
alt=event.mcheader.run_array_direction[1],
frame=horizon_frame)
stereo = reco.predict(
hillas_containers,
event_source.subarray,
array_pointing,
)
plt.figure()
angle_offset = event.mcheader.run_array_direction[0]
disp = ArrayDisplay(event_source.subarray)
disp.set_vector_hillas(hillas_containers,
time_gradient=time_gradients,
angle_offset=angle_offset,
length=500)
plt.scatter(
event.mc.core_x,
event.mc.core_y,
s=200,
c='k',
marker='x',
label='True Impact',
)
plt.scatter(
stereo.core_x,
import numpy as np
from astropy.table import Table
from ctapipe.utils import datasets
from ctapipe.visualization import ArrayDisplay
from matplotlib import pyplot as plt
if __name__ == '__main__':
plt.style.use("ggplot")
arrayfile = datasets.get_path("PROD2_telconfig.fits.gz")
tels = Table.read(arrayfile, hdu="TELESCOPE_LEVEL0")
plt.figure(figsize=(10, 8))
adisp = ArrayDisplay(tels['TelX'], tels['TelY'], tels['MirrorArea'] * 2,
title='PROD2 all telescopes', autoupdate=False)
plt.tight_layout()
intensities = np.zeros(len(tels))
# do a small animation to show various trigger patterns:
for ii in range(20):
# generate a random trigger pattern and integrated intensity:
ntrig = np.random.poisson(10)
trigmask = np.random.random_integers(len(tels) - 1, size=ntrig)
intensities[:] = 0
intensities[trigmask] = np.random.uniform(0, 100, size=ntrig)
# update the display:
adisp.intensities = intensities
plt.pause(0.5)
time_gradients[telescope_id] = 1
# ignore events with less than two telescopes
if len(hillas_containers) < 2:
continue
stereo = reco.predict(
hillas_containers,
event.inst,
pointing_alt=pointing_altitude,
pointing_az=pointing_azimuth
)
plt.figure()
angle_offset = event.mcheader.run_array_direction[0]
disp = ArrayDisplay(event.inst.subarray)
disp.set_vector_hillas(
hillas_containers,
time_gradient=time_gradients,
angle_offset=angle_offset,
length=500
)
plt.scatter(
event.mc.core_x, event.mc.core_y,
s=200, c='k', marker='x', label='True Impact',
)
plt.scatter(
stereo.core_x, stereo.core_y,
s=200, c='r', marker='x', label='Estimated Impact',
)
from astropy.table import Table
from ctapipe.utils import datasets
from ctapipe.visualization import ArrayDisplay
from matplotlib import pyplot as plt
if __name__ == '__main__':
plt.style.use("ggplot")
plt.figure(figsize=(10, 8))
arrayfile = datasets.get_path("PROD2_telconfig.fits.gz")
tels = Table.read(arrayfile, hdu="TELESCOPE_LEVEL0")
adisp = ArrayDisplay(tels['TelX'],
tels['TelY'],
tels['MirrorArea'] * 2,
title='PROD2 telescopes',
autoupdate=True)
plt.tight_layout()
values = np.zeros(len(tels))
# do a small animation to show various trigger patterns:
for ii in range(20):
# generate a random trigger pattern and integrated intensity:
ntrig = np.random.poisson(10)
trigmask = np.random.random_integers(len(tels) - 1, size=ntrig)
values[:] = 0
values[trigmask] = np.random.uniform(0, 100, size=ntrig)
from numpy import ones_like
import matplotlib.pylab as plt
if __name__ == '__main__':
plt.style.use("ggplot")
plt.figure(figsize=(9.5, 8.5))
# load up an example table that has the telescope positions and
# mirror areas in it:
arrayfile = datasets.get_path("PROD2_telconfig.fits.gz")
tels = Table.read(arrayfile, hdu="TELESCOPE_LEVEL0")
X = tels['TelX']
Y = tels['TelY']
A = tels['MirrorArea'] * 2 # exaggerate scale a bit
# display the array, and set the color value to 50
ad = ArrayDisplay(X, Y, A, title="Prod 2 Full Array")
ad.values = ones_like(X) * 50
# label them
for tel in tels:
name = "CT{tid}".format(tid=tel['TelID'])
plt.text(tel['TelX'], tel['TelY'], name, fontsize=8)
ad.axes.set_xlim(-1000, 1000)
ad.axes.set_ylim(-1000, 1000)
plt.tight_layout()
plt.show()
class NominalPlotter:
"""
Simple plotter for drawing camera level items in the nominal system
"""
def __init__(self, hillas_parameters, draw_axes=False, ax=None, **kwargs):
"""
Parameters
----------
instrument: dictionary
intrument containers for this event
telescopes: list
List of telescopes included
system: Coordinate system
Coordinate system to transform coordinates into
"""
self.axes = ax if ax is not None else plt.gca()
self.cen_x = [i.cen_x.to(u.deg).value for i in hillas_parameters.values()]
self.cen_y = [i.cen_y.to(u.deg).value for i in hillas_parameters.values()]
self.centre = (0,0)
self.array = ArrayDisplay(telx=np.asarray(self.cen_x), tely=np.asarray(self.cen_y),
tel_type=np.ones(len(self.cen_y)), axes=self.axes)
self.hillas = hillas_parameters
scale_fac = 57.3 * 2
self.array.overlay_moments(hillas_parameters, (self.cen_x, self.cen_y), scale_fac,
cmap="Greys", alpha=0.5, **kwargs)
if draw_axes:
self.array.overlay_axis(hillas_parameters, (self.cen_x, self.cen_y))
def background_contour(self, x, y, background, **kwargs):
"""
Draw image contours in background of the display, useful when likelihood fitting
Parameters
----------
x: ndarray
array of image X coordinates
y: ndarray
array of image Y coordinates
background: ndarray
Array of image to use in background
kwargs: key=value
any style keywords to pass to matplotlib
Returns
-------
None
"""
self.axes.contour(x, y, background, **kwargs)
# Annoyingly we need to redraw everything
self.array = ArrayDisplay(telx=np.asarray(self.cen_x), tely=np.asarray(self.cen_y),
tel_type=np.ones(len(self.cen_y)), axes=self.axes)
def draw_array(self, range=((-4,4),(-4,4))):
"""
Draw the array plotter (including any overlayed elements)
Parameters
----------
range: tuple
XY range in which to draw plotter
Returns
-------
None
"""
self.array.axes.set_xlim((self.centre[0]+range[0][0], range[0][1]+self.centre[0]))
self.array.axes.set_ylim((self.centre[1]+range[1][0], range[1][1]+self.centre[1]))
#self.axes.tight_layout()
#self.axes.show()
def draw_position(self, source_x, source_y, use_centre=False, **kwargs):
"""
Draw a marker at a position in the array plotter (for marking reconstructed
positions etc)
Parameters
----------
source_x: float
X position of point
source_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
"""
self.array.add_polygon(centroid=(source_x.to(u.deg).value,source_y.to(u.deg).value), radius=0.1, nsides=3, **kwargs)
if use_centre:
self.centre = (source_x.value,source_y.value)
from ctapipe import io
from ctapipe.visualization import ArrayDisplay
import matplotlib.pylab as plt
if __name__ == '__main__':
plt.style.use("ggplot")
layout = io.get_array_layout("hess")
X = layout['POSX']
Y = layout['POSY']
A = layout['MIRAREA']
A[:] = 132
ad = ArrayDisplay(X, Y, A, title="HESS")
# label them
for tel in layout:
name = "CT{tid}:{tclass}".format(tid=tel['TELID'],
tclass=io.tel_class_name(
tel['CLASS']))
plt.text(tel['POSX'], tel['POSY'], name)
ad.axes.set_xlim(-300, 300)
ad.axes.set_ylim(-300, 300)
plt.show()
# pointing direction of the telescopes
point_azimuth = {}
point_altitude = {}
calib = CameraCalibrator(eventsource=source)
off_angles = []
first_event = True
markers = None
for event in source:
subarray = event.inst.subarray
if first_event:
fig, ax = plt.subplots(1, 1, figsize=(10, 8))
array_disp = ArrayDisplay(subarray, axes=ax, tel_scale=1.0)
array_disp.telescopes.set_linewidth(3)
array_disp.add_labels()
first_event = False
hit_pattern = np.zeros(subarray.num_tels)
if len(event.r0.tels_with_data) < 3:
continue
# calibrating the event
calib.calibrate(event)
hillas_dict = {}
# plot the core position, which must be transformed from the tilted
# system to the system that the ArrayDisplay is in (default
# GroundFrame)
