def test_alignment(self):
dut_alignment.alignment(
input_track_candidates_file=analysis_utils.get_data(
'fixtures/dut_alignment/TrackCandidates_prealigned.h5',
output=os.path.join(
testing_path,
'fixtures/dut_alignment/TrackCandidates_prealigned.h5')),
input_alignment_file=analysis_utils.get_data(
'fixtures/dut_alignment/Alignment.h5',
output=os.path.join(testing_path,
'fixtures/dut_alignment/Alignment.h5')),
n_pixels=[(1152, 576)] * 6,
pixel_size=[(18.4, 18.4)] * 6)
# FIXME: test should check residuals not alignment resulds
# FIXME: translation error can be in the order of um, angle error not
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
'fixtures/dut_alignment/Alignment.h5',
output=os.path.join(testing_path,
'fixtures/dut_alignment/Alignment.h5')),
analysis_utils.get_data(
'fixtures/dut_alignment/Alignment_result.h5',
output=os.path.join(
testing_path,
'fixtures/dut_alignment/Alignment_result.h5')),
exact=False,
rtol=0.01, # 1 % error allowed
atol=5) # 0.0001 absolute tolerance allowed
self.assertTrue(data_equal, msg=error_msg)
def test_cluster_correlation(
self): # Check the cluster correlation function
dut_alignment.correlate_cluster(input_cluster_files=self.data_files,
output_correlation_file=os.path.join(
self.output_folder,
'Correlation.h5'),
n_pixels=self.n_pixels,
pixel_size=self.pixel_size)
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
'fixtures/dut_alignment/Correlation_result.h5',
output=os.path.join(
testing_path,
'fixtures/dut_alignment/Correlation_result.h5')),
os.path.join(self.output_folder, 'Correlation.h5'),
exact=True)
self.assertTrue(data_equal, msg=error_msg)
# Retest with tiny chunk size to force chunked correlation
dut_alignment.correlate_cluster(input_cluster_files=self.data_files,
output_correlation_file=os.path.join(
self.output_folder,
'Correlation_2.h5'),
n_pixels=self.n_pixels,
pixel_size=self.pixel_size,
chunk_size=293)
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
'fixtures/dut_alignment/Correlation_result.h5',
output=os.path.join(
testing_path,
'fixtures/dut_alignment/Correlation_result.h5')),
os.path.join(self.output_folder, 'Correlation_2.h5'),
exact=True)
self.assertTrue(data_equal, msg=error_msg)
def test_noisy_pixel_masking(self):
# Test 1:
output_mask_file = hit_analysis.generate_pixel_mask(
input_hits_file=self.noisy_data_file,
output_mask_file=os.path.join(
self.output_folder,
'TestBeamData_Mimosa26_DUT0_small_noisy_pixel_mask.h5'),
pixel_mask_name="NoisyPixelMask",
threshold=10.0,
n_pixel=(1152, 576),
pixel_size=(18.4, 18.4),
plot=True)
output_cluster_file = hit_analysis.cluster_hits(
input_hits_file=self.noisy_data_file,
input_noisy_pixel_mask_file=output_mask_file,
min_hit_charge=1,
max_hit_charge=1,
column_cluster_distance=2,
row_cluster_distance=2,
frame_cluster_distance=1)
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
'fixtures/hit_analysis/Mimosa26_noisy_pixels_cluster_result.h5',
output=os.path.join(
testing_path,
'fixtures/hit_analysis/Mimosa26_noisy_pixels_cluster_result.h5'
)),
output_cluster_file,
exact=False)
self.assertTrue(data_equal, msg=error_msg)
# Test 2: smaller chunks
output_mask_file = hit_analysis.generate_pixel_mask(
input_hits_file=self.noisy_data_file,
output_mask_file=os.path.join(
self.output_folder,
'TestBeamData_Mimosa26_DUT0_small_noisy_pixel_mask.h5'),
pixel_mask_name="NoisyPixelMask",
threshold=10.0,
n_pixel=(1152, 576),
pixel_size=(18.4, 18.4),
plot=True)
output_cluster_file = hit_analysis.cluster_hits(
input_hits_file=self.noisy_data_file,
input_noisy_pixel_mask_file=output_mask_file,
min_hit_charge=1,
max_hit_charge=1,
column_cluster_distance=2,
row_cluster_distance=2,
frame_cluster_distance=1,
chunk_size=4999)
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
'fixtures/hit_analysis/Mimosa26_noisy_pixels_cluster_result.h5',
output=os.path.join(
testing_path,
'fixtures/hit_analysis/Mimosa26_noisy_pixels_cluster_result.h5'
)),
output_cluster_file,
exact=False)
self.assertTrue(data_equal, msg=error_msg)
def test_residuals_calculation(self):
residuals = result_analysis.calculate_residuals(
input_tracks_file=analysis_utils.get_data(
'fixtures/result_analysis/Tracks_result.h5'),
input_alignment_file=analysis_utils.get_data(
'fixtures/result_analysis/Alignment_result.h5'),
output_residuals_file=os.path.join(self.output_folder,
'Residuals.h5'),
n_pixels=self.n_pixels,
pixel_size=self.pixel_size)
# Only test row residuals, columns are too large (250 um) for meaningfull gaussian residuals distribution
self.assertAlmostEqual(residuals[1],
22.9135,
msg='DUT 0 row residuals do not match',
places=3)
self.assertAlmostEqual(residuals[3],
18.7317,
msg='DUT 1 row residuals do not match',
places=3)
self.assertAlmostEqual(residuals[5],
22.8645,
msg='DUT 2 row residuals do not match',
places=3)
self.assertAlmostEqual(residuals[7],
27.2816,
msg='DUT 3 row residuals do not match',
places=3)
def setUpClass(cls):
# virtual X server for plots under headless LINUX travis testing is needed
if os.getenv('TRAVIS', False) and os.getenv('TRAVIS_OS_NAME',
False) == 'linux':
from xvfbwrapper import Xvfb # virtual X server for plots under headless LINUX travis testing is needed
cls.vdisplay = Xvfb()
cls.vdisplay.start()
cls.big_noisy_data_file = analysis_utils.get_data(
path='fixtures/hit_analysis/TestBeamData_Mimosa26_DUT0.h5',
output=os.path.join(
testing_path,
'fixtures/hit_analysis/TestBeamData_Mimosa26_DUT0.h5'))
cls.noisy_data_file = analysis_utils.get_data(
'fixtures/hit_analysis/TestBeamData_Mimosa26_DUT0_small.h5',
output=os.path.join(
testing_path,
'fixtures/hit_analysis/TestBeamData_Mimosa26_DUT0_small.h5'))
cls.data_file = analysis_utils.get_data(
'fixtures/hit_analysis/TestBeamData_FEI4_DUT0_small.h5',
output=os.path.join(
testing_path,
'fixtures/hit_analysis/TestBeamData_FEI4_DUT0_small.h5'))
cls.output_folder = 'tmp_hit_test_output'
test_tools.create_folder(cls.output_folder)
cls.pixel_size = ((250, 50), (250, 50), (250, 50), (250, 50)) # in um
def setUpClass(cls):
# virtual X server for plots under headless LINUX travis testing is needed
if os.getenv('TRAVIS', False) and os.getenv('TRAVIS_OS_NAME',
False) == 'linux':
from xvfbwrapper import Xvfb
cls.vdisplay = Xvfb()
cls.vdisplay.start()
# Download example data
# Reduce the example data to make it possible to test the examples in
# CI environments
try:
cls.examples_fei4_hit_files = [
analysis_utils.get_data(
path='examples/TestBeamData_FEI4_DUT%d.h5' % i,
output=os.path.join(
testing_path,
'examples/TestBeamData_FEI4_DUT%d.h5' % i),
fail_on_overwrite=True) for i in [0, 1, 4, 5]
]
data_selection.reduce_hit_files(cls.examples_fei4_hit_files,
fraction=100)
# Remove old files and rename reduced files
for file_name in cls.examples_fei4_hit_files:
os.remove(file_name)
os.rename(
os.path.splitext(file_name)[0] + '_reduced.h5', file_name)
except RuntimeError: # Files are already downloaded and reduced
cls.examples_fei4_hit_files = [
os.path.join(testing_path,
'examples/TestBeamData_FEI4_DUT%d.h5' % i)
for i in [0, 1, 4, 5]
]
try:
cls.examples_mimosa_hit_files = [
analysis_utils.get_data(
path='examples/TestBeamData_Mimosa26_DUT%d.h5' % i,
output=os.path.join(
testing_path,
'examples/TestBeamData_Mimosa26_DUT%d.h5' % i),
fail_on_overwrite=True) for i in range(6)
]
data_selection.reduce_hit_files(cls.examples_mimosa_hit_files,
fraction=100)
# Remove old files and rename reduced files
for file_name in cls.examples_mimosa_hit_files:
os.remove(file_name)
os.rename(
os.path.splitext(file_name)[0] + '_reduced.h5', file_name)
except RuntimeError: # Files are already downloaded and reduced
cls.examples_mimosa_hit_files = [
os.path.join(testing_path,
'examples/TestBeamData_Mimosa26_DUT%d.h5' % i)
for i in range(6)
]
def test_prealignment(self): # Check the hit alignment function
dut_alignment.prealignment(
input_correlation_file=analysis_utils.get_data(
'fixtures/dut_alignment/Correlation_result.h5',
output=os.path.join(
testing_path,
'fixtures/dut_alignment/Correlation_result.h5')),
output_alignment_file=os.path.join(self.output_folder,
'Alignment.h5'),
z_positions=self.z_positions,
pixel_size=self.pixel_size,
non_interactive=True,
fit_background=False,
iterations=3
) # Due to too little test data the alignment result is only rather stable for more iterations
# FIXME: residuals should be checked not prealingment data
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
'fixtures/dut_alignment/Prealignment_result.h5',
output=os.path.join(
testing_path,
'fixtures/dut_alignment/Prealignment_result.h5')),
os.path.join(self.output_folder, 'Alignment.h5'),
exact=False,
rtol=0.05, # 5 % error allowed
atol=5) # 5 um absolute tolerance allowed
self.assertTrue(data_equal, msg=error_msg)
dut_alignment.prealignment(
input_correlation_file=analysis_utils.get_data(
'fixtures/dut_alignment/Correlation_difficult.h5',
output=os.path.join(
testing_path,
'fixtures/dut_alignment/Correlation_difficult.h5')),
output_alignment_file=os.path.join(self.output_folder,
'Alignment_difficult.h5'),
z_positions=self.z_positions,
pixel_size=self.pixel_size,
non_interactive=True,
fit_background=True,
iterations=2
) # Due to too little test data the alignment result is only rather stable for more iterations
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
r'fixtures/dut_alignment/Alignment_difficult_result.h5',
output=os.path.join(
testing_path,
'fixtures/dut_alignment/Alignment_difficult_result.h5')),
os.path.join(self.output_folder, 'Alignment_difficult.h5'),
exact=False,
rtol=0.05, # 5 % error allowed
atol=5) # 5 um absolute tolerance allowed
self.assertTrue(data_equal, msg=error_msg)
def test_3d_index_histograming(
self): # check compiled hist_3D_index function
with tb.open_file(analysis_utils.get_data(
'fixtures/analysis_utils/hist_data.h5',
output=os.path.join(testing_path,
'fixtures/analysis_utils/hist_data.h5')),
mode="r") as in_file_h5:
xyz = in_file_h5.root.HistDataXYZ[:]
x, y, z = xyz[0], xyz[1], xyz[2]
shape = (100, 100, 100)
array_fast = analysis_utils.hist_3d_index(x, y, z, shape=shape)
array = np.histogramdd(np.column_stack((x, y, z)),
bins=shape,
range=[[0, shape[0] - 1], [0, shape[1] - 1],
[0, shape[2] - 1]])[0]
shape = (
50, 200, 200
) # shape that is too small for the indices to trigger exception
exception_ok = False
try:
array_fast = analysis_utils.hist_3d_index(x, y, z, shape=shape)
except IndexError:
exception_ok = True
except: # other exception that should not occur
pass
self.assertTrue(exception_ok & np.all(array == array_fast))
def test_hit_clustering(self):
# Test 1:
output_cluster_file = hit_analysis.cluster_hits(
input_hits_file=self.data_file,
min_hit_charge=0,
max_hit_charge=13,
output_cluster_file=os.path.join(
self.output_folder,
'TestBeamData_FEI4_DUT0_small_clustered.h5'),
column_cluster_distance=1,
row_cluster_distance=2,
frame_cluster_distance=2)
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
'fixtures/hit_analysis/FEI4_cluster_result.h5',
output=os.path.join(
testing_path,
'fixtures/hit_analysis/FEI4_cluster_result.h5')),
output_cluster_file,
exact=False)
self.assertTrue(data_equal, msg=error_msg)
# Test 2: smaller chunks
output_cluster_file = hit_analysis.cluster_hits(
input_hits_file=self.data_file,
min_hit_charge=0,
max_hit_charge=13,
output_cluster_file=os.path.join(
self.output_folder,
'TestBeamData_FEI4_DUT0_small_clustered.h5'),
column_cluster_distance=1,
row_cluster_distance=2,
frame_cluster_distance=2,
chunk_size=4999)
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
'fixtures/hit_analysis/FEI4_cluster_result.h5',
output=os.path.join(
testing_path,
'fixtures/hit_analysis/FEI4_cluster_result.h5')),
output_cluster_file,
exact=False)
self.assertTrue(data_equal, msg=error_msg)
def test_track_finding(self):
# Test 1:
track_analysis.find_tracks(input_tracklets_file=analysis_utils.get_data('fixtures/track_analysis/Tracklets_small.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/Tracklets_small.h5')),
input_alignment_file=analysis_utils.get_data('fixtures/track_analysis/Alignment_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/Alignment_result.h5')),
output_track_candidates_file=os.path.join(self.output_folder, 'TrackCandidates.h5'))
data_equal, error_msg = test_tools.compare_h5_files(analysis_utils.get_data('fixtures/track_analysis/TrackCandidates_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/TrackCandidates_result.h5')), os.path.join(self.output_folder, 'TrackCandidates.h5'))
self.assertTrue(data_equal, msg=error_msg)
# Test 2: chunked
track_analysis.find_tracks(input_tracklets_file=analysis_utils.get_data('fixtures/track_analysis/Tracklets_small.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/Tracklets_small.h5')),
input_alignment_file=analysis_utils.get_data('fixtures/track_analysis/Alignment_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/Alignment_result.h5')),
output_track_candidates_file=os.path.join(self.output_folder, 'TrackCandidates_2.h5'),
chunk_size=293)
data_equal, error_msg = test_tools.compare_h5_files(analysis_utils.get_data('fixtures/track_analysis/TrackCandidates_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/TrackCandidates_result.h5')),
os.path.join(self.output_folder, 'TrackCandidates_2.h5'))
self.assertTrue(data_equal, msg=error_msg)
def test_cluster_merging(self):
cluster_files = [
analysis_utils.get_data(
'fixtures/dut_alignment/Cluster_DUT%d_cluster.h5' % i,
output=os.path.join(
testing_path,
'fixtures/dut_alignment/Cluster_DUT%d_cluster.h5' % i))
for i in range(4)
]
dut_alignment.merge_cluster_data(cluster_files,
output_merged_file=os.path.join(
self.output_folder, 'Merged.h5'),
n_pixels=self.n_pixels,
pixel_size=self.pixel_size)
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
'fixtures/dut_alignment/Merged_result.h5',
output=os.path.join(
testing_path, 'fixtures/dut_alignment/Merged_result.h5')),
os.path.join(self.output_folder, 'Merged.h5'))
self.assertTrue(data_equal, msg=error_msg)
# Retest with tiny chunk size to force chunked merging
dut_alignment.merge_cluster_data(cluster_files,
output_merged_file=os.path.join(
self.output_folder,
'Merged_2.h5'),
pixel_size=self.pixel_size,
n_pixels=self.n_pixels,
chunk_size=293)
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
'fixtures/dut_alignment/Merged_result.h5',
output=os.path.join(
testing_path, 'fixtures/dut_alignment/Merged_result.h5')),
os.path.join(self.output_folder, 'Merged_2.h5'))
self.assertTrue(data_equal, msg=error_msg)
def test_efficiency_calculation(self):
efficiencies = result_analysis.calculate_efficiency(
input_tracks_file=analysis_utils.get_data(
'fixtures/result_analysis/Tracks_result.h5'),
input_alignment_file=analysis_utils.get_data(
'fixtures/result_analysis/Alignment_result.h5'),
output_efficiency_file=os.path.join(self.output_folder,
'Efficiency.h5'),
bin_size=[(250, 50)] * 4,
sensor_size=[(250 * 80., 336 * 50.)] * 4,
pixel_size=[(250, 50)] * 4,
n_pixels=[(80, 336)] * 4,
minimum_track_density=2,
use_duts=None,
cut_distance=500,
max_distance=500,
#col_range=[(1250, 17500)]*4,
#row_range=[(1000, 16000)]*4,
force_prealignment=True)
self.assertAlmostEqual(efficiencies[0],
100.000,
msg='DUT 0 efficiencies do not match',
places=3)
self.assertAlmostEqual(efficiencies[1],
98.7013,
msg='DUT 1 efficiencies do not match',
places=3)
self.assertAlmostEqual(efficiencies[2],
97.4684,
msg='DUT 2 efficiencies do not match',
places=3)
self.assertAlmostEqual(efficiencies[3],
100.000,
msg='DUT 3 efficiencies do not match',
places=3)
def test_generate_pixel_mask(self):
output_mask_file = hit_analysis.generate_pixel_mask(
input_hits_file=self.big_noisy_data_file,
output_mask_file=os.path.join(
self.output_folder,
'TestBeamData_Mimosa26_DUT0_noisy_pixel_mask.h5'),
pixel_mask_name="NoisyPixelMask",
threshold=0.5,
n_pixel=(1152, 576),
pixel_size=(18.4, 18.4),
plot=True)
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
'fixtures/hit_analysis/TestBeamData_Mimosa26_DUT0_noisy_pixel_mask.h5',
output=os.path.join(
testing_path,
'fixtures/hit_analysis/TestBeamData_Mimosa26_DUT0_noisy_pixel_mask.h5'
)), output_mask_file)
self.assertTrue(data_equal, msg=error_msg)
def test_simulation(self):
''' Check the full simulation '''
self.simulate_data.reset()
self.simulate_data.set_std_settings()
self.assertEqual(self.simulate_data.n_duts, 6)
self.simulate_data.create_data_and_store('simulated_data',
n_events=10000)
for dut_index in range(self.simulate_data.n_duts):
data_equal, error_msg = test_tools.compare_h5_files(
'simulated_data_DUT%d.h5' % dut_index,
analysis_utils.get_data(
'fixtures/simulation/simulated_data_DUT%d.h5' % dut_index,
output=os.path.join(
testing_path,
'fixtures/simulation/simulated_data_DUT%d.h5' %
dut_index)),
exact=False)
self.assertTrue(data_equal, msg=error_msg)
def setUpClass(cls):
# virtual X server for plots under headless LINUX travis testing is needed
if os.getenv('TRAVIS', False) and os.getenv('TRAVIS_OS_NAME',
False) == 'linux':
from xvfbwrapper import Xvfb
cls.vdisplay = Xvfb()
cls.vdisplay.start()
# Define test data input files, download if needed
cls.data_files = [
analysis_utils.get_data(
'fixtures/dut_alignment/Cluster_DUT%d_cluster.h5' % i,
output=os.path.join(
testing_path,
'fixtures/dut_alignment/Cluster_DUT%d_cluster.h5' % i))
for i in range(4)
]
# Define and create tests output folder, is deleted at the end of tests
cls.output_folder = os.path.join(
os.path.dirname(os.path.realpath(cls.data_files[0])), 'output')
test_tools.create_folder(cls.output_folder)
cls.n_pixels = [(80, 336)] * 4
cls.pixel_size = [(250, 50)] * 4 # in um
cls.z_positions = [0., 19500, 108800, 128300]
def test_apply_alignment(self):
dut_alignment.apply_alignment(
input_hit_file=analysis_utils.get_data(
'fixtures/dut_alignment/Merged_result.h5',
output=os.path.join(
testing_path, 'fixtures/dut_alignment/Merged_result.h5')),
input_alignment_file=analysis_utils.get_data(
'fixtures/dut_alignment/Prealignment_result.h5',
output=os.path.join(
testing_path,
'fixtures/dut_alignment/Prealignment_result.h5')),
output_hit_file=os.path.join(self.output_folder, 'Tracklets.h5'),
use_prealignment=True)
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
'fixtures/dut_alignment/Tracklets_result.h5',
output=os.path.join(
testing_path,
'fixtures/dut_alignment/Tracklets_result.h5')),
os.path.join(self.output_folder, 'Tracklets.h5'))
self.assertTrue(data_equal, msg=error_msg)
# Retest with tiny chunk size to force chunked alignment apply
dut_alignment.apply_alignment(
input_hit_file=analysis_utils.get_data(
'fixtures/dut_alignment/Merged_result.h5',
output=os.path.join(
testing_path, 'fixtures/dut_alignment/Merged_result.h5')),
input_alignment_file=analysis_utils.get_data(
'fixtures/dut_alignment/Prealignment_result.h5',
output=os.path.join(
testing_path,
'fixtures/dut_alignment/Prealignment_result.h5')),
output_hit_file=os.path.join(self.output_folder, 'Tracklets_2.h5'),
use_prealignment=True,
chunk_size=293)
data_equal, error_msg = test_tools.compare_h5_files(
analysis_utils.get_data(
'fixtures/dut_alignment/Tracklets_result.h5',
output=os.path.join(
testing_path,
'fixtures/dut_alignment/Tracklets_result.h5')),
os.path.join(self.output_folder, 'Tracklets_2.h5'))
self.assertTrue(data_equal, msg=error_msg)
class TestExamples(unittest.TestCase):
@classmethod
def setUpClass(cls):
# virtual X server for plots under headless LINUX travis testing is needed
if os.getenv('TRAVIS', False) and os.getenv('TRAVIS_OS_NAME',
False) == 'linux':
from xvfbwrapper import Xvfb
cls.vdisplay = Xvfb()
cls.vdisplay.start()
# Download example data
# Reduce the example data to make it possible to test the examples in
# CI environments
try:
cls.examples_fei4_hit_files = [
analysis_utils.get_data(
path='examples/TestBeamData_FEI4_DUT%d.h5' % i,
output=os.path.join(
testing_path,
'examples/TestBeamData_FEI4_DUT%d.h5' % i),
fail_on_overwrite=True) for i in [0, 1, 4, 5]
]
data_selection.reduce_hit_files(cls.examples_fei4_hit_files,
fraction=100)
# Remove old files and rename reduced files
for file_name in cls.examples_fei4_hit_files:
os.remove(file_name)
os.rename(
os.path.splitext(file_name)[0] + '_reduced.h5', file_name)
except RuntimeError: # Files are already downloaded and reduced
cls.examples_fei4_hit_files = [
os.path.join(testing_path,
'examples/TestBeamData_FEI4_DUT%d.h5' % i)
for i in [0, 1, 4, 5]
]
try:
cls.examples_mimosa_hit_files = [
analysis_utils.get_data(
path='examples/TestBeamData_Mimosa26_DUT%d.h5' % i,
output=os.path.join(
testing_path,
'examples/TestBeamData_Mimosa26_DUT%d.h5' % i),
fail_on_overwrite=True) for i in range(6)
]
data_selection.reduce_hit_files(cls.examples_mimosa_hit_files,
fraction=100)
# Remove old files and rename reduced files
for file_name in cls.examples_mimosa_hit_files:
os.remove(file_name)
os.rename(
os.path.splitext(file_name)[0] + '_reduced.h5', file_name)
except RuntimeError: # Files are already downloaded and reduced
cls.examples_mimosa_hit_files = [
os.path.join(testing_path,
'examples/TestBeamData_Mimosa26_DUT%d.h5' % i)
for i in range(6)
]
# Alignments do not converge for reduced data set
# Thus mock out the alignment steps
@mock.patch('beam_telescope_analysis.dut_alignment.prealignment',
side_effect=copy_data(
path=analysis_utils.get_data(
path='fixtures/examples/eutelescope/Alignment.h5',
output=os.path.join(
testing_path,
'fixtures/examples/eutelescope/Alignment.h5')),
out_path=os.path.join(
testing_path,
'examples/data/output_eutelescope/Alignment.h5')))
@mock.patch('beam_telescope_analysis.dut_alignment.alignment')
# TODO: Analysis fails, to be checked why
@mock.patch('beam_telescope_analysis.track_analysis.fit_tracks',
side_effect=fit_tracks_fast)
@mock.patch('beam_telescope_analysis.result_analysis.calculate_residuals')
def test_mimosa_example(self, m1, m2, m3, m4):
eutelescope.run_analysis(self.examples_mimosa_hit_files)
# Prealignment does not converge for reduced data set
# Thus mock out the prealignment
@mock.patch('beam_telescope_analysis.dut_alignment.prealignment',
side_effect=copy_data(
path=analysis_utils.get_data(
path='fixtures/examples/fei4_telescope/Alignment.h5',
output=os.path.join(
testing_path,
'fixtures/examples/fei4_telescope/Alignment.h5')),
out_path=os.path.join(
testing_path,
'examples/data/output_fei4_telescope/Alignment.h5')))
def test_fei4_example(self, mock):
fei4_telescope.run_analysis(self.examples_fei4_hit_files)
def test_simulated_data_example(self):
''' Check the example and the overall analysis that a efficiency of
about 100% is reached. Not a perfect 100% is expected due to the
finite propability that tracks are merged since > 2 tracks per
event are simulated
'''
simulated_data.run_analysis(1000)
with tb.open_file('simulation/Efficiency.h5') as in_file_h5:
for i in range(5): # Loop over DUT index
eff = in_file_h5.get_node('/DUT%d/Efficiency' % i)[:]
mask = in_file_h5.get_node('/DUT%d/Efficiency_mask' % i)[:]
self.assertAlmostEqual(eff[~mask].mean(), 100., delta=0.0001)
def test_track_fitting(self):
# Test 1: Fit DUTs and always exclude one DUT (normal mode for unbiased residuals and efficiency determination)
track_analysis.fit_tracks(input_track_candidates_file=analysis_utils.get_data('fixtures/track_analysis/TrackCandidates_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/TrackCandidates_result.h5')),
input_alignment_file=analysis_utils.get_data('fixtures/track_analysis/Alignment_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/Alignment_result.h5')),
output_tracks_file=os.path.join(self.output_folder, 'Tracks.h5'),
selection_track_quality=1,
use_prealignment=True)
data_equal, error_msg = test_tools.compare_h5_files(analysis_utils.get_data('fixtures/track_analysis/Tracks_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/Tracks_result.h5')),
os.path.join(self.output_folder, 'Tracks.h5'), exact=False)
self.assertTrue(data_equal, msg=error_msg)
# Test 2: As test 1 but chunked data analysis, should result in the same tracks
track_analysis.fit_tracks(input_track_candidates_file=analysis_utils.get_data('fixtures/track_analysis/TrackCandidates_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/TrackCandidates_result.h5')),
input_alignment_file=analysis_utils.get_data('fixtures/track_analysis/Alignment_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/Alignment_result.h5')),
output_tracks_file=os.path.join(self.output_folder, 'Tracks_2.h5'),
selection_track_quality=1,
use_prealignment=True,
chunk_size=4999)
data_equal, error_msg = test_tools.compare_h5_files(analysis_utils.get_data('fixtures/track_analysis/Tracks_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/Tracks_result.h5')),
os.path.join(self.output_folder, 'Tracks_2.h5'), exact=False)
self.assertTrue(data_equal, msg=error_msg)
# Test 3: Fit all DUTs at once (special mode for constrained residuals)
track_analysis.fit_tracks(input_track_candidates_file=analysis_utils.get_data('fixtures/track_analysis/TrackCandidates_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/TrackCandidates_result.h5')),
input_alignment_file=analysis_utils.get_data('fixtures/track_analysis/Alignment_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/Alignment_result.h5')),
output_tracks_file=os.path.join(self.output_folder, 'Tracks_All.h5'),
exclude_dut_hit=False,
selection_track_quality=1,
use_prealignment=True)
# Fit DUTs consecutevly, but use always the same DUTs. Should result in the same data as above
track_analysis.fit_tracks(input_track_candidates_file=analysis_utils.get_data('fixtures/track_analysis/TrackCandidates_result.h5',
output=os.path.join(testing_path, 'fixtures/track_analysis/TrackCandidates_result.h5')),
input_alignment_file=analysis_utils.get_data('fixtures/track_analysis/Alignment_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/Alignment_result.h5')),
output_tracks_file=os.path.join(self.output_folder, 'Tracks_All_Iter.h5'),
select_hit_duts=range(4),
exclude_dut_hit=False,
selection_track_quality=1,
use_prealignment=True)
data_equal, error_msg = test_tools.compare_h5_files(os.path.join(self.output_folder, 'Tracks_All.h5'), os.path.join(self.output_folder, 'Tracks_All_Iter.h5'), exact=False)
self.assertTrue(data_equal, msg=error_msg)
# Fit DUTs consecutevly, but use always the same DUTs defined for each DUT separately. Should result in the same data as above
track_analysis.fit_tracks(input_track_candidates_file=analysis_utils.get_data('fixtures/track_analysis/TrackCandidates_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/TrackCandidates_result.h5')),
input_alignment_file=analysis_utils.get_data('fixtures/track_analysis/Alignment_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/Alignment_result.h5')),
output_tracks_file=os.path.join(self.output_folder, 'Tracks_All_Iter_2.h5'),
select_hit_duts=[range(4), range(4), range(4), range(4)],
exclude_dut_hit=False,
selection_track_quality=1,
use_prealignment=True)
data_equal, error_msg = test_tools.compare_h5_files(os.path.join(self.output_folder, 'Tracks_All.h5'), os.path.join(self.output_folder, 'Tracks_All_Iter_2.h5'), exact=False)
self.assertTrue(data_equal, msg=error_msg)
# Fit tracks and eliminate merged tracks
track_analysis.fit_tracks(input_track_candidates_file=analysis_utils.get_data('fixtures/track_analysis/TrackCandidates_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/TrackCandidates_result.h5')),
input_alignment_file=analysis_utils.get_data('fixtures/track_analysis/Alignment_result.h5',
output=os.path.join(testing_path,
'fixtures/track_analysis/Alignment_result.h5')),
output_tracks_file=os.path.join(self.output_folder, 'Tracks_merged.h5'),
selection_track_quality=1,
min_track_distance=True, # Activate track merge cut,
use_prealignment=True)
data_equal, error_msg = test_tools.compare_h5_files(analysis_utils.get_data('fixtures/track_analysis/Tracks_merged_result.h5',
output=os.path.join(testing_path, 'fixtures/track_analysis/Tracks_merged_result.h5')), os.path.join(self.output_folder, 'Tracks_merged.h5'), exact=False)
self.assertTrue(data_equal, msg=error_msg)
# select_no_hit_duts=None,
# select_quality_duts=[[1, 2, 3, 4, 5], [0, 2, 3, 4, 5], [0, 1, 3, 4, 5], [0, 1, 2, 4, 5], [0, 1, 2, 3, 5], [0, 1, 2, 3, 4]],
# query='(track_chi2 < 5.0)')
# # Calculate the unconstrained residuals from final from final tracks (with chi^2 cut and quality selection)
# result_analysis.calculate_residuals(
# telescope_configuration=aligned_configuration,
# input_tracks_file=os.path.join(output_folder, 'Tracks_aligned_kalman_selected.h5'),
# output_residuals_file=os.path.join(output_folder, 'Residuals_aligned_kalman.h5'),
# select_duts=[0, 1, 2, 3, 4, 5],
# nbins_per_pixel=20,
# use_limits=True)
# Main entry point is needed for multiprocessing under Windows
if __name__ == '__main__':
# Get the absolute path of example data
tests_data_folder = os.path.join(
os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe()))), 'data')
# The location of the data files, one file per DUT
hit_files = [
analysis_utils.get_data(
path='examples/TestBeamData_Mimosa26_DUT%d.h5' % i,
output=os.path.join(tests_data_folder,
'TestBeamData_Mimosa26_DUT%d.h5' % i))
for i in range(6)
]
run_analysis(hit_files=hit_files)
