def _generate_pad_collection(data, pads=None):
sm = mpl.cm.ScalarMappable(cmap=pad_cm, norm=LogNorm())
sm.set_array(data)
colors = sm.to_rgba(data)
if pads is None:
pads = generate_pad_plane()
c = mpl.collections.PolyCollection(pads, facecolors=colors, edgecolors='none')
return c
def event_view(evt, pads=None):
if pads is None:
pads = generate_pad_plane()
data = evt.xyzs(pads)
hits = evt.hits()
mesh = evt.traces['data'].sum(0)
fig = plt.figure()
chax = fig.add_subplot(223)
chax.set_xlim(0, 511)
chax.set_ylim(-290, 290)
chax.set_axis_bgcolor('#c4cccc')
chax.scatter(data[:, 2],
data[:, 1],
marker='.',
linewidths=0,
s=2,
cmap='winter',
norm=LogNorm(),
c=data[:, 3])
for sp in chax.spines.values():
sp.visible = False
msax = fig.add_subplot(221, sharex=chax)
msax.plot(mesh)
pdax = fig.add_subplot(224, sharey=chax)
pdax.axison = False
pdax.set_aspect('equal')
pdax.set_xlim(-250, 250)
hit_pads = _generate_pad_collection(hits, pads)
bg_pads = mpl.collections.PolyCollection(pads,
facecolors='white',
edgecolors='none')
bg_circ = plt.Circle((0, 0),
radius=290.,
facecolor='#c4cccc',
edgecolor='none')
bg_circ.set_zorder(0)
bg_pads.set_zorder(1)
hit_pads.set_zorder(2)
pdax.add_artist(bg_circ)
pdax.add_collection(bg_pads)
pdax.add_collection(hit_pads)
return fig
def _generate_pad_collection(data, pads=None):
sm = mpl.cm.ScalarMappable(cmap=pad_cm, norm=LogNorm())
sm.set_array(data)
colors = sm.to_rgba(data)
if pads is None:
pads = generate_pad_plane()
c = mpl.collections.PolyCollection(pads,
facecolors=colors,
edgecolors='none')
return c
def show_pad_plane(pads=None):
"""Displays the pad plane"""
if pads is None:
pads = generate_pad_plane()
c = mpl.collections.PolyCollection(pads)
fig, ax = plt.subplots()
ax.add_collection(c)
ax.autoscale_view()
fig.show()
def show_pad_plane(pads=None):
"""Displays the pad plane"""
if pads is None:
pads = generate_pad_plane()
c = mpl.collections.PolyCollection(pads)
fig, ax = plt.subplots()
ax.add_collection(c)
ax.autoscale_view()
fig.show()
def __init__(self, config, pedestals=None, corrupt_cobo_clocks=False):
config = copy(config)
config['mass_num'] = config['beam_mass']
config['charge_num'] = config['beam_charge']
config['tracker_max_en'] = config['beam_enu0'] * config[
'beam_mass'] * 1.1 # The last part is just to be safe
self.beam_sim = EventSimulator(config)
beam_evt, _ = self.beam_sim.make_event(0, 0, 1.0, config['beam_enu0'],
0, pi)
self.beam_mesh = sum((v for v in beam_evt.values()))
self.beam_mesh /= self.beam_mesh.max()
pads = generate_pad_plane()
self.bigpads = np.where(
np.round(np.abs(pads[:, 1, 1] - pads[:, 0, 1])) > 6)[0]
self.smallpads = np.where(
np.round(np.abs(pads[:, 1, 1] - pads[:, 0, 1])) < 6)[0]
assert (len(self.bigpads) + len(self.smallpads) == 10240)
self.baseline_depression_scale = config['baseline_depression_scale']
self.big_pad_multiplier = config['big_pad_multiplier']
self.noise_stddev = config['noise_stddev']
if pedestals is not None:
self.pedestals = pedestals
else:
self.pedestals = np.zeros(10240, dtype='float64')
self.padmap = read_lookup_table(
config['padmap_path']) # maps (cobo, asad, aget, ch) -> pad
self.pad_cobos = np.zeros(
10240, dtype=np.int64) # List index = pad, value = cobo
for (cobo, asad, aget, ch), pad in self.padmap.items():
self.pad_cobos[pad] = cobo
self.cobo_offsets = self.make_cobo_clock_offsets()
if corrupt_cobo_clocks:
self.apply_cobo_clock_patch()
def event_view(evt, pads=None):
if pads is None:
pads = generate_pad_plane()
data = evt.xyzs(pads)
hits = evt.hits()
mesh = evt.traces['data'].sum(0)
fig = plt.figure()
chax = fig.add_subplot(223)
chax.set_xlim(0, 511)
chax.set_ylim(-290, 290)
chax.set_axis_bgcolor('#c4cccc')
chax.scatter(data[:, 2], data[:, 1], marker='.', linewidths=0, s=2, cmap='winter', norm=LogNorm(), c=data[:, 3])
for sp in chax.spines.values():
sp.visible = False
msax = fig.add_subplot(221, sharex=chax)
msax.plot(mesh)
pdax = fig.add_subplot(224, sharey=chax)
pdax.axison = False
pdax.set_aspect('equal')
pdax.set_xlim(-250, 250)
hit_pads = _generate_pad_collection(hits, pads)
bg_pads = mpl.collections.PolyCollection(pads, facecolors='white', edgecolors='none')
bg_circ = plt.Circle((0, 0), radius=290., facecolor='#c4cccc', edgecolor='none')
bg_circ.set_zorder(0)
bg_pads.set_zorder(1)
hit_pads.set_zorder(2)
pdax.add_artist(bg_circ)
pdax.add_collection(bg_pads)
pdax.add_collection(hit_pads)
return fig
This module contains code to track a particle in data.
"""
from __future__ import division, print_function
import numpy as np
from sklearn.cluster import DBSCAN
from functools import lru_cache
from pytpc.constants import *
import pytpc.simulation as sim
from pytpc.ukf import UnscentedKalmanFilter as UKF
from pytpc.padplane import generate_pad_plane
pads = generate_pad_plane() # FIXME: Take rotation angle
pr = np.round(pads)
@lru_cache(maxsize=10240)
def find_adj(p, depth=0):
"""Recursively finds the neighboring pads to pad `p`.
This function returns a set of neighboring pad numbers. The neighboring pads are determined by looking for
all pads that (approximately) share a vertex with the given pad.
.. note::
Since only vertices are compared, this algorithm will not identify a neighboring pad that only shares a side,
and not a vertex.
The `depth` parameter allows recursion an arbitrary number of times. For instance, if `depth == 1`, the function
"""Particle Tracking
This module contains code to track a particle in data.
"""
from __future__ import division, print_function
import numpy as np
from functools import lru_cache
from pytpc.padplane import generate_pad_plane
pads = generate_pad_plane() # FIXME: Take rotation angle
pr = np.round(pads)
@lru_cache(maxsize=10240)
def find_adj(p, depth=0):
"""Recursively finds the neighboring pads to pad `p`.
This function returns a set of neighboring pad numbers. The neighboring pads are determined by looking for
all pads that (approximately) share a vertex with the given pad.
.. note::
Since only vertices are compared, this algorithm will not identify a neighboring pad that only shares a side,
and not a vertex.
The `depth` parameter allows recursion an arbitrary number of times. For instance, if `depth == 1`, the function
will return the pads adjacent to pad `p` and those adjacent to its immediate neighbors.
def pad_plot(data, pads=None, scale='log', cmap_type='seq'):
""" Plot the given data on the pads of the Micromegas.
Parameters
----------
data : array-like
The data to be plotted. This should be a 1-D array with an entry for each pad.
pads : array-like, optional
The vertices of the pads. If this is not provided, the default pad plane will be generated using
`generate_pad_plane`. This can be used for a rotated pad plane, for example.
Returns
-------
fig : matplotlib figure
The generated figure
"""
data = numpy.asanyarray(data)
if scale is 'log':
nm = LogNorm()
elif scale is 'linear':
nm = None
else:
raise ValueError('invalid scale. Must be in set {}'.format(('log', 'linear')))
if cmap_type == 'div':
cmap = 'BrBG'
else:
cmap = pad_cm
sm = mpl.cm.ScalarMappable(cmap=cmap, norm=nm)
sm.set_array(data)
if cmap_type == 'div':
extr = numpy.abs(data).max()
sm.set_clim(-extr, extr)
colors = sm.to_rgba(data)
if pads is None:
pads = generate_pad_plane()
else:
pads = numpy.asanyarray(pads)
c = mpl.collections.PolyCollection(pads, facecolors=colors, edgecolors='none')
cbg = mpl.collections.PolyCollection(pads, facecolors='white', edgecolors='none')
c.set_zorder(2)
cbg.set_zorder(1)
fig, ax = plt.subplots()
ax.axison = False
bdcirc = plt.Circle((0, 0), radius=290., facecolor='#c4cccc', edgecolor='none')
bdcirc.set_zorder(0)
ax.add_artist(bdcirc)
ax.add_collection(cbg)
ax.add_collection(c)
plt.axis('equal')
cbar = fig.colorbar(sm)
cbar.set_label('Activation')
return fig
def pad_plot(data, pads=None, scale='log', cmap=pad_cm, cmin=None, cmax=None):
""" Plot the given data on the pads of the Micromegas.
Parameters
----------
data : array-like
The data to be plotted. This should be a 1-D array with an entry for each pad.
pads : array-like, optional
The vertices of the pads. If this is not provided, the default pad plane will be generated using
`generate_pad_plane`. This can be used for a rotated pad plane, for example.
scale : string, optional
Scale for color map. 'log' for log scale, or 'linear' for linear.
cmap : string or Matplotlib color map, optional
Matplotlib color map or name of a color map
cmin, cmax: float, optional
The min and max values for the color scale. If omitted, Matplotlib will choose its default values.
Returns
-------
fig : Figure
The generated figure
sm : matplotlib.cm.ScalarMappable
The color mapping object used in the plot. This can be used to generate a colorbar with
`plt.colorbar(sm)`.
"""
data = numpy.asanyarray(data)
if scale is 'log':
nm = LogNorm()
elif scale is 'linear':
nm = None
else:
raise ValueError('invalid scale. Must be in set {}'.format(
('log', 'linear')))
sm = mpl.cm.ScalarMappable(cmap=cmap, norm=nm)
sm.set_array(data)
sm.set_clim(cmin, cmax)
colors = sm.to_rgba(data)
if pads is None:
pads = generate_pad_plane()
else:
pads = numpy.asanyarray(pads)
c = mpl.collections.PolyCollection(pads,
facecolors=colors,
edgecolors='none')
cbg = mpl.collections.PolyCollection(pads,
facecolors='white',
edgecolors='none')
c.set_zorder(2)
cbg.set_zorder(1)
fig, ax = plt.subplots()
ax.axison = False
bdcirc = plt.Circle((0, 0),
radius=290.,
facecolor='#c4cccc',
edgecolor='none')
bdcirc.set_zorder(0)
ax.add_artist(bdcirc)
ax.add_collection(cbg)
ax.add_collection(c)
plt.axis('equal')
return fig, sm
