class EventObservables(tables.IsDescription):
"""Store information about the observables of an event.
The observables are described for each station independently. So, for each
event (with a unique :attr:`id`), there is a table row for each station
(with a unique :attr:`station_id`), such that only the (id, station_id)
combinations are unique in the table.
.. attribute:: id
a unique identifier for the simulated event (only unique in this table)
.. attribute:: station_id
station identifier, such that you can do::
>>> station = cluster.stations[station_id]
.. attribute:: r, phi, x, y
coordinates of the station. Depending on the simulation, this might be
constant throughout the simulation, or it might change event by event.
.. attribute:: alpha
rotation of the station around its center
.. attribute:: N
number of detectors with at least one particle
"""
id = tables.UInt32Col()
station_id = tables.UInt8Col()
timestamp = tables.Time32Col()
nanoseconds = tables.UInt32Col()
ext_timestamp = tables.UInt64Col()
r = tables.Float32Col()
phi = tables.Float32Col()
x = tables.Float32Col()
y = tables.Float32Col()
alpha = tables.Float32Col()
N = tables.UInt8Col()
t1 = tables.Float32Col()
t2 = tables.Float32Col()
t3 = tables.Float32Col()
t4 = tables.Float32Col()
n1 = tables.Float32Col()
n2 = tables.Float32Col()
n3 = tables.Float32Col()
n4 = tables.Float32Col()
class TraceWriteRange(tables.IsDescription):
index = tables.UInt32Col()
destlo = tables.UInt32Col()
desthi = tables.UInt32Col()
pc = tables.UInt32Col()
relocatedpc = tables.UInt32Col()
lr = tables.UInt32Col()
relocatedlr = tables.UInt32Col()
byteswritten = tables.UInt32Col()
numops = tables.UInt32Col()
cpsr = tables.UInt32Col()
caller = tables.StringCol(40)
substage = tables.UInt8Col()
class HitInfoTable(tb.IsDescription):
event_number = tb.Int64Col(pos=0)
trigger_number = tb.UInt32Col(pos=1)
relative_BCID = tb.UInt8Col(pos=2)
LVL1ID = tb.UInt16Col(pos=3)
column = tb.UInt8Col(pos=4)
row = tb.UInt16Col(pos=5)
tot = tb.UInt8Col(pos=6)
BCID = tb.UInt16Col(pos=7)
TDC = tb.UInt16Col(pos=8)
TDC_time_stamp = tb.UInt8Col(pos=9)
trigger_status = tb.UInt8Col(pos=10)
service_record = tb.UInt32Col(pos=11)
event_status = tb.UInt16Col(pos=12)
class TriggerInfo(tables.IsDescription):
"""
Describe the trigger informations of the telescopes events
Attributes:
-----------
event_id : id of the corresponding event
time_s : time of the event in second since 1st january 1970
time_qns : time in nanosecond (or picosecond) to complete the time in second
obs_id : id of the observation
"""
event_id = tables.UInt64Col()
time_s = tables.UInt32Col()
time_qns = tables.UInt32Col()
obs_id = tables.UInt64Col()
class GenomeTable(tables.IsDescription):
NCBITaxonId = tables.UInt32Col(pos=0)
UniProtSpeciesCode = tables.StringCol(5, pos=1)
TotEntries = tables.UInt32Col(pos=2)
TotAA = tables.UInt32Col(pos=3)
EntryOff = tables.UInt32Col(pos=4)
SciName = tables.StringCol(255, pos=5)
CommonName = tables.StringCol(64, pos=6)
SynName = tables.StringCol(64, pos=7)
Release = tables.StringCol(128, pos=8)
Url = tables.StringCol(255, pos=9)
Source = tables.StringCol(255, pos=10)
Date = tables.Time32Col(pos=11)
IsPolyploid = tables.BoolCol(pos=12)
class ClusterInfoTable(tb.IsDescription):
event_number = tb.Int64Col(pos=0)
cluster_id = tb.UInt16Col(pos=1)
n_hits = tb.UInt32Col(pos=2)
charge = tb.Float32Col(pos=3)
frame = tb.UInt16Col(pos=4)
seed_column = tb.UInt16Col(pos=5)
seed_row = tb.UInt16Col(pos=6)
mean_column = tb.Float64Col(pos=7)
mean_row = tb.Float64Col(pos=8)
err_column = tb.Float32Col(pos=9)
err_row = tb.Float32Col(pos=10)
n_cluster = tb.UInt32Col(pos=11)
cluster_shape = tb.Int64Col(pos=12)
class cells(tb.IsDescription):
galID = tb.StringCol(8) # 8-character string
expn = tb.StringCol(8)
cellID = tb.UInt32Col() # Unsigned integer
xPos = tb.Float32Col()
yPos = tb.Float32Col()
zPos = tb.Float32Col()
lognH = tb.Float32Col()
logT = tb.Float32Col()
SNII = tb.Float32Col()
cellsize = tb.Float32Col() # float (single-precision) (64 bits)
HI = tb.UInt32Col()
MgII = tb.UInt32Col()
CIV = tb.UInt32Col()
OVI = tb.UInt32Col()
class HisparcEvent(tables.IsDescription):
# DISCUSS: use of signed (dflt -1) vs unsigned (labview code)
event_id = tables.UInt32Col(pos=0)
timestamp = tables.Time32Col(pos=2)
nanoseconds = tables.UInt32Col(pos=3)
ext_timestamp = tables.UInt64Col(pos=4)
data_reduction = tables.BoolCol(pos=5)
trigger_pattern = tables.UInt32Col(pos=6)
baseline = tables.Int16Col(shape=4, dflt=-1, pos=7)
std_dev = tables.Int16Col(shape=4, dflt=-1, pos=8)
n_peaks = tables.Int16Col(shape=4, dflt=-1, pos=9)
pulseheights = tables.Int16Col(shape=4, dflt=-1, pos=10)
integrals = tables.Int32Col(shape=4, dflt=-1, pos=11)
traces = tables.Int32Col(shape=4, dflt=-1, pos=12)
event_rate = tables.Float32Col(pos=13)
class Summary(tables.IsDescription):
bin_number = tables.UInt32Col( pos=0)
chromosome = tables.StringCol(chromosome_name_length, pos=2)
avg_cell_type_percentile = tables.Float64Col( pos=1)
cell_types_gte_95th_percentile = tables.UInt32Col(pos=2)
cell_types_lt_95th_percentile = tables.UInt32Col( pos=3)
lines_gte_95th_percentile = tables.UInt32Col( pos=4)
lines_lt_95th_percentile = tables.UInt32Col( pos=5)
cell_types_gte_5th_percentile = tables.UInt32Col( pos=6)
cell_types_lt_5th_percentile = tables.UInt32Col( pos=7)
lines_gte_5th_percentile = tables.UInt32Col( pos=8)
lines_lt_5th_percentile = tables.UInt32Col( pos=9)
def _prepare_coincidence_tables(self):
"""Create coincidence tables
These are the same as the tables created by
:class:`~sapphire.analysis.coincidences.CoincidencesESD`.
This makes it easy to link events detected by multiple stations.
"""
self.coincidence_group = self.data.create_group(self.output_path,
'coincidences',
createparents=True)
try:
self.coincidence_group._v_attrs.cluster = self.cluster
except tables.HDF5ExtError:
warnings.warn('Unable to store cluster object, to large for HDF.')
description = storage.Coincidence
s_columns = {
's%d' % station.number: tables.BoolCol(pos=p)
for p, station in enumerate(self.cluster.stations, 12)
}
description.columns.update(s_columns)
self.coincidences = self.data.create_table(self.coincidence_group,
'coincidences', description)
self.c_index = self.data.create_vlarray(self.coincidence_group,
'c_index',
tables.UInt32Col(shape=2))
self.s_index = self.data.create_vlarray(self.coincidence_group,
's_index',
tables.VLStringAtom())
def test_create_weather_table(self):
description = {
'event_id': tables.UInt32Col(pos=0),
'timestamp': tables.Time32Col(pos=1),
'temp_inside': tables.Float32Col(pos=2),
'temp_outside': tables.Float32Col(pos=3),
'humidity_inside': tables.Int16Col(pos=4),
'humidity_outside': tables.Int16Col(pos=5),
'barometer': tables.Float32Col(pos=6),
'wind_dir': tables.Int16Col(pos=7),
'wind_speed': tables.Int16Col(pos=8),
'solar_rad': tables.Int16Col(pos=9),
'uv': tables.Int16Col(pos=10),
'evapotranspiration': tables.Float32Col(pos=11),
'rain_rate': tables.Float32Col(pos=12),
'heat_index': tables.Int16Col(pos=13),
'dew_point': tables.Float32Col(pos=14),
'wind_chill': tables.Float32Col(pos=15)
}
file = MagicMock()
result = esd._create_weather_table(file, sentinel.group)
file.create_table.assert_called_once_with(sentinel.group,
'weather',
description,
createparents=True)
self.assertEqual(result, file.create_table.return_value)
class ReconstructedKascadeEvent(tables.IsDescription):
"""Store information about reconstructed events"""
# r, phi is core position
id = tables.UInt32Col()
station_id = tables.UInt8Col()
r = tables.Float32Col()
phi = tables.Float32Col()
alpha = tables.Float32Col()
t1 = tables.Float32Col()
t2 = tables.Float32Col()
t3 = tables.Float32Col()
t4 = tables.Float32Col()
n1 = tables.Float32Col()
n2 = tables.Float32Col()
n3 = tables.Float32Col()
n4 = tables.Float32Col()
reference_theta = tables.Float32Col()
reference_phi = tables.Float32Col()
reconstructed_theta = tables.Float32Col()
reconstructed_phi = tables.Float32Col()
min_n134 = tables.Float32Col()
k_energy = tables.FloatCol()
k_core_pos = tables.FloatCol(shape=2)
k_Num_e = tables.FloatCol()
k_Num_mu = tables.FloatCol()
k_dens_e = tables.FloatCol(shape=4)
k_dens_mu = tables.FloatCol(shape=4)
k_P200 = tables.FloatCol()
k_T200 = tables.FloatCol()
class ReconstructedCoincidence(tables.IsDescription):
"""Store information about reconstructed coincidences"""
id = tables.UInt32Col(pos=1)
ext_timestamp = tables.UInt64Col(pos=2)
min_n = tables.Float32Col(pos=3)
x = tables.Float32Col(pos=4)
y = tables.Float32Col(pos=5)
zenith = tables.Float32Col(pos=6)
azimuth = tables.Float32Col(pos=7)
size = tables.Float32Col(pos=8)
energy = tables.Float32Col(pos=9)
error_x = tables.Float32Col(pos=10)
error_y = tables.Float32Col(pos=11)
error_zenith = tables.Float32Col(pos=12)
error_azimuth = tables.Float32Col(pos=13)
error_size = tables.Float32Col(pos=14)
error_energy = tables.Float32Col(pos=15)
reference_x = tables.Float32Col(pos=16)
reference_y = tables.Float32Col(pos=17)
reference_zenith = tables.Float32Col(pos=18)
reference_azimuth = tables.Float32Col(pos=19)
reference_size = tables.Float32Col(pos=20)
reference_energy = tables.Float32Col(pos=21)
class BlastTable(SimpleTable):
query = tables.StringCol(5)
subject = tables.StringCol(5)
pctid = tables.Float32Col()
hitlen = tables.UInt16Col()
nmismatch = tables.UInt16Col()
ngaps = tables.UInt16Col()
qstart = tables.UInt32Col()
qstop = tables.UInt32Col()
sstart = tables.UInt32Col()
sstop = tables.UInt32Col()
evalue = tables.Float64Col()
score = tables.Float32Col()
def _create_singles_table(file, group):
"""Create singles table in PyTables file
Create a singles table containing the ESD singles columns which are
available in the TSV download.
:param file: PyTables file.
:param group: the group to contain the singles table, which need not
exist.
"""
description = {
'event_id': tables.UInt32Col(pos=0),
'timestamp': tables.Time32Col(pos=1),
'mas_ch1_low': tables.Int32Col(pos=2),
'mas_ch1_high': tables.Int32Col(pos=3),
'mas_ch2_low': tables.Int32Col(pos=4),
'mas_ch2_high': tables.Int32Col(pos=5),
'slv_ch1_low': tables.Int32Col(pos=6),
'slv_ch1_high': tables.Int32Col(pos=7),
'slv_ch2_low': tables.Int32Col(pos=8),
'slv_ch2_high': tables.Int32Col(pos=9)
}
return file.create_table(group, 'singles', description, createparents=True)
class KalmanEstimatesVelOnlyWithDirectionPositionCovariance(PT.IsDescription):
obj_id = PT.UInt32Col(pos=0)
frame = PT.Int64Col(pos=1)
timestamp = PT.Float64Col(pos=2) # time of reconstruction
x = PT.Float32Col(pos=3)
y = PT.Float32Col(pos=4)
z = PT.Float32Col(pos=5)
xvel = PT.Float32Col(pos=6)
yvel = PT.Float32Col(pos=7)
zvel = PT.Float32Col(pos=8)
# save parts of P matrix
P00 = PT.Float32Col(pos=9)
P01 = PT.Float32Col(pos=10)
P02 = PT.Float32Col(pos=11)
P11 = PT.Float32Col(pos=12)
P12 = PT.Float32Col(pos=13)
P22 = PT.Float32Col(pos=14)
P33 = PT.Float32Col(pos=15)
P44 = PT.Float32Col(pos=16)
P55 = PT.Float32Col(pos=17)
# save estimated direction of long body axis
rawdir_x = PT.Float32Col(pos=18)
rawdir_y = PT.Float32Col(pos=19)
rawdir_z = PT.Float32Col(pos=20)
dir_x = PT.Float32Col(pos=21)
dir_y = PT.Float32Col(pos=22)
dir_z = PT.Float32Col(pos=23)
def store_coincidences(self):
if '/coincidences' not in self.data:
group = self.data.createGroup('/', 'coincidences')
group._v_attrs.cluster = self.cluster
self.c_index = []
self.coincidences = self.data.createTable(group, 'coincidences',
storage.Coincidence)
self.observables = self.data.createTable(group, 'observables',
storage.EventObservables)
progress = pb.ProgressBar(
widgets=[pb.Percentage(), pb.Bar(),
pb.ETA()])
for coincidence in progress(self.data.root.c_index):
self.store_coincidence(coincidence)
c_index = self.data.createVLArray(group, 'c_index',
tables.UInt32Col())
for coincidence in self.c_index:
c_index.append(coincidence)
c_index.flush()
self.c_index = c_index
else:
# Force new cluster geometry
group = self.data.getNode('/', 'coincidences')
group._v_attrs.cluster = self.cluster
def store_coincidences(self, cluster=None):
"""Store the previously found coincidences.
After you have searched for coincidences, you can store the
more user-friendly results in the coincidences group using this
method.
:param cluster: optionally store a
:class:`~sapphire.clusters.BaseCluster` instance in the
coincidences group for future reference.
"""
if cluster:
self.coincidence_group._v_attrs.cluster = cluster
self.c_index = []
self.coincidences = self.data.create_table(self.coincidence_group,
'coincidences',
storage.Coincidence)
self.observables = self.data.create_table(self.coincidence_group,
'observables',
storage.EventObservables)
for coincidence in pbar(self.coincidence_group._src_c_index,
show=self.progress):
self._store_coincidence(coincidence)
c_index = self.data.create_vlarray(self.coincidence_group, 'c_index',
tables.UInt32Col())
for coincidence in self.c_index:
c_index.append(coincidence)
c_index.flush()
self.c_index = c_index
def store_coincidences(self):
"""Store the previously found coincidences.
After you have searched for coincidences, you can store the
more user-friendly results in the coincidences group using this
method.
"""
self.c_index = []
self.coincidences = self.data.create_table(self.coincidence_group,
'coincidences',
storage.Coincidence)
self.observables = self.data.create_table(self.coincidence_group,
'observables',
storage.EventObservables)
for coincidence in pbar(self.coincidence_group._src_c_index,
show=self.progress):
self._store_coincidence(coincidence)
c_index = self.data.create_vlarray(self.coincidence_group, 'c_index',
tables.UInt32Col())
for coincidence in self.c_index:
c_index.append(coincidence)
c_index.flush()
self.c_index = c_index
def store_coincidences(self):
print "Storing coincidences..."
if '/coincidences' not in self.data:
group = self.data.create_group('/', 'coincidences')
group._v_attrs.cluster = self.cluster
self.c_index = []
self.coincidences = self.data.create_table(group, 'coincidences',
storage.Coincidence)
self.observables = self.data.create_table(group, 'observables',
storage.EventObservables)
for coincidence in pbar(self.data.root.c_index):
self.store_coincidence(coincidence)
c_index = self.data.create_vlarray(group, 'c_index',
tables.UInt32Col())
for coincidence in self.c_index:
c_index.append(coincidence)
c_index.flush()
self.c_index = c_index
else:
# Force new cluster geometry
group = self.data.get_node('/', 'coincidences')
group._v_attrs.cluster = self.cluster
class LightningEvent(tables.IsDescription):
event_id = tables.UInt32Col(pos=0)
timestamp = tables.Time32Col(pos=1)
corr_distance = tables.Int16Col(pos=2)
uncorr_distance = tables.Int16Col(pos=3)
uncorr_angle = tables.Float32Col(pos=4)
corr_angle = tables.Float32Col(pos=5)
def state_to_table_dtype(
state, str_buffer_safety_factor=DTYPE_STR_BUFFER_SAFETY_FACTOR):
"""
Get a state of an object represented as a dictionary and derive the
appropriate type of a tables.Table.
:param state: The state of an object.
:type state: dict
:raises: :class:`pymc.UnknownTypeException`
"""
dtype_dict = {}
for name in state.keys():
if isinstance(state[name], int):
dtype = pt.UInt32Col()
elif isinstance(state[name], float):
dtype = pt.Float64Col()
elif isinstance(state[name], str):
dtype = pt.StringCol(itemsize=len(state[name]) *
str_buffer_safety_factor)
elif isinstance(state[name], np.ndarray):
dtype = pt.Float64Col(shape=state[name].shape)
else:
raise UnknownTypeException(
'I cannot deal with the type of %s (%s)' %
(name, type(state[name])))
dtype_dict[name] = dtype
return dtype_dict
class Spectrum_12_4096(tb.IsDescription):
""" PyTables table descriptor: storage of spectral data
For hipsr_200_16384 firmware: 200 MHz, 16384 channels
"""
id = tb.Int32Col(pos=0) # Unique ID
timestamp = tb.Time64Col(pos=1) # Timestamp (at BRAM read)
xx = tb.UInt32Col(shape=4096, pos=2) # XX Autocorrelation data
yy = tb.UInt32Col(shape=4096, pos=3) # YY Autocorrelation data
# re_xy = tb.Int32Col(shape=16384,pos=4) # XY Cross correlation - real
#im_xy = tb.Int32Col(shape=16384,pos=5) # XY Cross correlation - imag
xx_cal_on = tb.Int32Col(shape=16, pos=6) # Noise diode ON, X pol
xx_cal_off = tb.Int32Col(shape=16, pos=7) # Noise diode OFF, X pol
yy_cal_on = tb.Int32Col(shape=16, pos=8) # Noise diode ON, Y pol
yy_cal_off = tb.Int32Col(shape=16, pos=9) # Noise diode OFF, Y pol
fft_of = tb.BoolCol(pos=10) # FFT overflow flag
adc_clip = tb.BoolCol(pos=11) # ADC clipping flag
def _create_weather_table(file, group):
"""Create weather table in PyTables file
Create a weather table containing the ESD weather columns which are
available in the TSV download.
:param file: PyTables file.
:param group: the group to contain the weather table, which need not
exist.
"""
description = {
'event_id': tables.UInt32Col(pos=0),
'timestamp': tables.Time32Col(pos=1),
'temp_inside': tables.Float32Col(pos=2),
'temp_outside': tables.Float32Col(pos=3),
'humidity_inside': tables.Int16Col(pos=4),
'humidity_outside': tables.Int16Col(pos=5),
'barometer': tables.Float32Col(pos=6),
'wind_dir': tables.Int16Col(pos=7),
'wind_speed': tables.Int16Col(pos=8),
'solar_rad': tables.Int16Col(pos=9),
'uv': tables.Int16Col(pos=10),
'evapotranspiration': tables.Float32Col(pos=11),
'rain_rate': tables.Float32Col(pos=12),
'heat_index': tables.Int16Col(pos=13),
'dew_point': tables.Float32Col(pos=14),
'wind_chill': tables.Float32Col(pos=15)
}
return file.create_table(group, 'weather', description, createparents=True)
class Record(tb.IsDescription):
var1 = tb.StringCol(itemsize=4, dflt=b"abcd", pos=0)
var2 = tb.StringCol(itemsize=1, dflt=b"a", pos=1)
var3 = tb.BoolCol(dflt=1)
var4 = tb.Int8Col(dflt=1)
var5 = tb.UInt8Col(dflt=1)
var6 = tb.Int16Col(dflt=1)
var7 = tb.UInt16Col(dflt=1)
var8 = tb.Int32Col(dflt=1)
var9 = tb.UInt32Col(dflt=1)
var10 = tb.Int64Col(dflt=1)
var11 = tb.Float32Col(dflt=1.0)
var12 = tb.Float64Col(dflt=1.0)
var13 = tb.ComplexCol(itemsize=8, dflt=(1.+0.j))
var14 = tb.ComplexCol(itemsize=16, dflt=(1.+0.j))
if hasattr(tb, 'Float16Col'):
var15 = tb.Float16Col(dflt=1.0)
if hasattr(tb, 'Float96Col'):
var16 = tb.Float96Col(dflt=1.0)
if hasattr(tb, 'Float128Col'):
var17 = tb.Float128Col(dflt=1.0)
if hasattr(tb, 'Complex196Col'):
var18 = tb.ComplexCol(itemsize=24, dflt=(1.+0.j))
if hasattr(tb, 'Complex256Col'):
var19 = tb.ComplexCol(itemsize=32, dflt=(1.+0.j))
class HisparcEvent(tables.IsDescription):
"""HiSPARC event table description."""
event_id = tables.UInt32Col(pos=0)
timestamp = tables.Time32Col(pos=1)
nanoseconds = tables.UInt32Col(pos=2)
ext_timestamp = tables.UInt64Col(pos=3)
data_reduction = tables.BoolCol(pos=4)
trigger_pattern = tables.UInt32Col(pos=5)
baseline = tables.Int16Col(shape=4, dflt=-1, pos=6)
std_dev = tables.Int16Col(shape=4, dflt=-1, pos=7)
n_peaks = tables.Int16Col(shape=4, dflt=-1, pos=8)
pulseheights = tables.Int16Col(shape=4, dflt=-1, pos=9)
integrals = tables.Int32Col(shape=4, dflt=-1, pos=10)
traces = tables.Int32Col(shape=4, dflt=-1, pos=11)
event_rate = tables.Float32Col(pos=12)
def _create_coincidences_tables(file, group, station_groups):
"""Setup coincidence tables
:return: the created coincidences group.
"""
coin_group = group + '/coincidences'
# Create coincidences table
description = storage.Coincidence
s_columns = {
's%d' % station: tables.BoolCol(pos=p)
for p, station in enumerate(station_groups, 12)
}
description.columns.update(s_columns)
coincidences = file.create_table(coin_group,
'coincidences',
description,
createparents=True)
# Create c_index
file.create_vlarray(coin_group, 'c_index', tables.UInt32Col(shape=2))
# Create and fill s_index
s_index = file.create_vlarray(coin_group, 's_index', tables.VLStringAtom())
for station_group in itervalues(station_groups):
s_index.append(station_group['group'].encode('utf-8'))
return coincidences._v_parent
class Lumitable(t.IsDescription):
fillnum = t.UInt32Col(shape=(), dflt=0, pos=0)
runnum = t.UInt32Col(shape=(), dflt=0, pos=1)
lsnum = t.UInt32Col(shape=(), dflt=0, pos=2)
nbnum = t.UInt32Col(shape=(), dflt=0, pos=3)
#timestampsec = t.Float32Col(shape=(3564), dflt=0, pos=4)
#timestampsec = t.UInt32Col(shape=(3564,), dflt=0, pos=4)
timestampsec = t.UInt32Col(shape=(), dflt=0, pos=4)
#totsize = t.UInt32Col(shape=(), dflt=0, pos=6)
#publishnnb = t.UInt8Col(shape=(), dflt=0, pos=7)
#avg = t.Float32Col(shape=(), dflt=0.0, pos=14)
avgraw = t.Float32Col(shape=(), dflt=0.0, pos=5) #new
avg = t.Float32Col(shape=(), dflt=0.0, pos=6) #new
bxraw = t.Float32Col(shape=(3564, ), dflt=0.0, pos=7) #new
bx = t.Float32Col(shape=(3564, ), dflt=0.0, pos=8) #new
def store_coincidences(self, station_numbers=None):
"""Store the previously found coincidences.
After having searched for coincidences, you can store the more
user-friendly results in the ``coincidences`` group using this
method. It also created a ``c_index`` and ``s_index`` table to
find the source events.
:param station_numbers: optional list of station_numbers.
If given these will be used to attach correct numbers to the
station column names in the coincidences table. Otherwise
they will simply be numbered by id. This list must be the
same length as the station_groups.
"""
n_coincidences = len(self._src_c_index)
if station_numbers is not None:
if len(station_numbers) != len(self.station_groups):
raise RuntimeError(
"Number of station numbers must equal number of groups.")
self.station_numbers = station_numbers
s_columns = {
's%d' % number: tables.BoolCol(pos=p)
for p, number in enumerate(station_numbers, 12)
}
else:
self.station_numbers = None
s_columns = {
's%d' % n: tables.BoolCol(pos=(n + 12))
for n, _ in enumerate(self.station_groups)
}
description = storage.Coincidence
description.columns.update(s_columns)
self.coincidences = self.data.create_table(self.coincidence_group,
'coincidences',
description,
expectedrows=n_coincidences)
self.c_index = []
for coincidence in pbar(self._src_c_index, show=self.progress):
self._store_coincidence(coincidence)
c_index = self.data.create_vlarray(self.coincidence_group,
'c_index',
tables.UInt32Col(shape=2),
expectedrows=n_coincidences)
for observables_idx in pbar(self.c_index, show=self.progress):
c_index.append(observables_idx)
c_index.flush()
s_index = self.data.create_vlarray(self.coincidence_group,
's_index',
tables.VLStringAtom(),
expectedrows=len(
self.station_groups))
for station_group in self.station_groups:
s_index.append(station_group.encode('utf-8'))
s_index.flush()
class ReconstructedEvent(tables.IsDescription):
"""Store information about reconstructed events"""
# r, phi is core position
id = tables.UInt32Col()
station_id = tables.UInt8Col()
r = tables.Float32Col()
phi = tables.Float32Col()
alpha = tables.Float32Col()
t1 = tables.Float32Col()
t2 = tables.Float32Col()
t3 = tables.Float32Col()
t4 = tables.Float32Col()
n1 = tables.Float32Col()
n2 = tables.Float32Col()
n3 = tables.Float32Col()
n4 = tables.Float32Col()
reference_theta = tables.Float32Col()
reference_phi = tables.Float32Col()
reconstructed_theta = tables.Float32Col()
reconstructed_phi = tables.Float32Col()
reference_core_pos = tables.Float32Col(shape=2)
reconstructed_core_pos = tables.Float32Col(shape=2)
reference_shower_size = tables.Float32Col()
reconstructed_shower_size = tables.Float32Col()
min_n134 = tables.Float32Col()
