Project
Loading...
Searching...
No Matches
testTPCHwClusterer.cxx
Go to the documentation of this file.
1// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
2// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
3// All rights not expressly granted are reserved.
4//
5// This software is distributed under the terms of the GNU General Public
6// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
7//
8// In applying this license CERN does not waive the privileges and immunities
9// granted to it by virtue of its status as an Intergovernmental Organization
10// or submit itself to any jurisdiction.
11
15
16#define BOOST_TEST_MODULE Test TPC HwClusterer
17#define BOOST_TEST_MAIN
18#define BOOST_TEST_DYN_LINK
19#include <boost/test/unit_test.hpp>
20#include "DataFormatsTPC/Helpers.h"
21#include "DataFormatsTPC/Digit.h"
22#include "TPCBase/Mapper.h"
23#include "TPCReconstruction/HwClusterer.h"
24
25#include "SimulationDataFormat/ConstMCTruthContainer.h"
26#include "SimulationDataFormat/MCCompLabel.h"
27
28#include <vector>
29#include <memory>
30#include <iostream>
31
32using MCLabelContainer = o2::dataformats::MCLabelContainer;
33
34namespace o2
35{
36namespace tpc
37{
38// some helper functions / struct
39struct sortTime {
40 inline bool operator()(const o2::tpc::Digit& d1, const o2::tpc::Digit& d2)
41 {
42 return (d1.getTimeStamp() < d2.getTimeStamp());
43 }
44};
45
46float p_pre(std::array<int, 25>& data)
47{
48 int ret = 0;
49 ret += -2 * (data[0]) - (data[1]) + 0 * (data[3]) + (data[3]) + 2 * (data[4]);
50 ret += -2 * (data[5]) - (data[6]) + 0 * (data[8]) + (data[8]) + 2 * (data[9]);
51 ret += -2 * (data[10]) - (data[11]) + 0 * (data[13]) + (data[13]) + 2 * (data[14]);
52 ret += -2 * (data[15]) - (data[16]) + 0 * (data[18]) + (data[18]) + 2 * (data[19]);
53 ret += -2 * (data[20]) - (data[21]) + 0 * (data[23]) + (data[23]) + 2 * (data[24]);
54 return ret;
55};
56
57float sigma_p_pre(std::array<int, 25>& data)
58{
59 int ret = 0;
60 ret += 4 * (data[0]) + (data[1]) + 0 * (data[3]) + (data[3]) + 4 * (data[4]);
61 ret += 4 * (data[5]) + (data[6]) + 0 * (data[8]) + (data[8]) + 4 * (data[9]);
62 ret += 4 * (data[10]) + (data[11]) + 0 * (data[13]) + (data[13]) + 4 * (data[14]);
63 ret += 4 * (data[15]) + (data[16]) + 0 * (data[18]) + (data[18]) + 4 * (data[19]);
64 ret += 4 * (data[20]) + (data[21]) + 0 * (data[23]) + (data[23]) + 4 * (data[24]);
65 return ret;
66};
67
68float t_pre(std::array<int, 25>& data)
69{
70 int ret = 0;
71 ret += -2 * (data[0]) - 2 * (data[1]) - 2 * (data[2]) - 2 * (data[3]) - 2 * (data[4]);
72 ret += -1 * (data[5]) - 1 * (data[6]) - 1 * (data[7]) - 1 * (data[8]) - 1 * (data[9]);
73 ret += 0 * (data[10]) + 0 * (data[11]) + 0 * (data[12]) + 0 * (data[13]) + 0 * (data[14]);
74 ret += 1 * (data[15]) + 1 * (data[16]) + 1 * (data[17]) + 1 * (data[18]) + 1 * (data[19]);
75 ret += 2 * (data[20]) + 2 * (data[21]) + 2 * (data[22]) + 2 * (data[23]) + 2 * (data[24]);
76 return ret;
77};
78
79float sigma_t_pre(std::array<int, 25>& data)
80{
81 int ret = 0;
82 ret += 4 * (data[0]) + 4 * (data[1]) + 4 * (data[2]) + 4 * (data[3]) + 4 * (data[4]);
83 ret += 1 * (data[5]) + 1 * (data[6]) + 1 * (data[7]) + 1 * (data[8]) + 1 * (data[9]);
84 ret += 0 * (data[10]) + 0 * (data[11]) + 0 * (data[12]) + 0 * (data[13]) + 0 * (data[14]);
85 ret += 1 * (data[15]) + 1 * (data[16]) + 1 * (data[17]) + 1 * (data[18]) + 1 * (data[19]);
86 ret += 4 * (data[20]) + 4 * (data[21]) + 4 * (data[22]) + 4 * (data[23]) + 4 * (data[24]);
87 return ret;
88};
89
90float p_pre_fp(std::array<float, 25>& data)
91{
92 int ret = 0;
93 ret += -2 * (data[0] * 16) - (data[1] * 16) + 0 * (data[3] * 16) + (data[3] * 16) + 2 * (data[4] * 16);
94 ret += -2 * (data[5] * 16) - (data[6] * 16) + 0 * (data[8] * 16) + (data[8] * 16) + 2 * (data[9] * 16);
95 ret += -2 * (data[10] * 16) - (data[11] * 16) + 0 * (data[13] * 16) + (data[13] * 16) + 2 * (data[14] * 16);
96 ret += -2 * (data[15] * 16) - (data[16] * 16) + 0 * (data[18] * 16) + (data[18] * 16) + 2 * (data[19] * 16);
97 ret += -2 * (data[20] * 16) - (data[21] * 16) + 0 * (data[23] * 16) + (data[23] * 16) + 2 * (data[24] * 16);
98 return ret;
99};
100
101float sigma_p_pre_fp(std::array<float, 25>& data)
102{
103 int ret = 0;
104 ret += 4 * (data[0] * 16) + (data[1] * 16) + 0 * (data[3] * 16) + (data[3] * 16) + 4 * (data[4] * 16);
105 ret += 4 * (data[5] * 16) + (data[6] * 16) + 0 * (data[8] * 16) + (data[8] * 16) + 4 * (data[9] * 16);
106 ret += 4 * (data[10] * 16) + (data[11] * 16) + 0 * (data[13] * 16) + (data[13] * 16) + 4 * (data[14] * 16);
107 ret += 4 * (data[15] * 16) + (data[16] * 16) + 0 * (data[18] * 16) + (data[18] * 16) + 4 * (data[19] * 16);
108 ret += 4 * (data[20] * 16) + (data[21] * 16) + 0 * (data[23] * 16) + (data[23] * 16) + 4 * (data[24] * 16);
109 return ret;
110};
111
112float t_pre_fp(std::array<float, 25>& data)
113{
114 int ret = 0;
115 ret += -2 * (data[0] * 16) - 2 * (data[1] * 16) - 2 * (data[2] * 16) - 2 * (data[3] * 16) - 2 * (data[4] * 16);
116 ret += -1 * (data[5] * 16) - 1 * (data[6] * 16) - 1 * (data[7] * 16) - 1 * (data[8] * 16) - 1 * (data[9] * 16);
117 ret += 0 * (data[10] * 16) + 0 * (data[11] * 16) + 0 * (data[12] * 16) + 0 * (data[13] * 16) + 0 * (data[14] * 16);
118 ret += 1 * (data[15] * 16) + 1 * (data[16] * 16) + 1 * (data[17] * 16) + 1 * (data[18] * 16) + 1 * (data[19] * 16);
119 ret += 2 * (data[20] * 16) + 2 * (data[21] * 16) + 2 * (data[22] * 16) + 2 * (data[23] * 16) + 2 * (data[24] * 16);
120 return ret;
121};
122
123float sigma_t_pre_fp(std::array<float, 25>& data)
124{
125 int ret = 0;
126 ret += 4 * (data[0] * 16) + 4 * (data[1] * 16) + 4 * (data[2] * 16) + 4 * (data[3] * 16) + 4 * (data[4] * 16);
127 ret += 1 * (data[5] * 16) + 1 * (data[6] * 16) + 1 * (data[7] * 16) + 1 * (data[8] * 16) + 1 * (data[9] * 16);
128 ret += 0 * (data[10] * 16) + 0 * (data[11] * 16) + 0 * (data[12] * 16) + 0 * (data[13] * 16) + 0 * (data[14] * 16);
129 ret += 1 * (data[15] * 16) + 1 * (data[16] * 16) + 1 * (data[17] * 16) + 1 * (data[18] * 16) + 1 * (data[19] * 16);
130 ret += 4 * (data[20] * 16) + 4 * (data[21] * 16) + 4 * (data[22] * 16) + 4 * (data[23] * 16) + 4 * (data[24] * 16);
131 return ret;
132};
133
135BOOST_AUTO_TEST_CASE(HwClusterer_test1)
136{
137 std::cout << "##" << std::endl;
138 std::cout << "## Starting test 1, basic class tests." << std::endl;
139 auto clusterArray = std::make_unique<std::vector<ClusterHardwareContainer8kb>>();
140 auto labelArray = std::make_unique<MCLabelContainer>();
141
142 HwClusterer clusterer(clusterArray.get(), 0, labelArray.get());
143 // If continuous readout is false, all clusters are written directly to the output
144 clusterer.setContinuousReadout(false);
145
146 auto digitVec = std::vector<Digit>();
147 MCLabelContainer labelContainer;
148
149 // create three digits above peak charge threshold, two close to each other
150 // which should result in one cluster
151 digitVec.emplace_back(0, 123, 13, 4, 2);
152 digitVec.emplace_back(0, 12, 13, 5, 2);
153 digitVec.emplace_back(0, 321, 7, 10, 10);
154
155 labelContainer.addElement(0, {1, 0, 0, false});
156 labelContainer.addElement(1, {2, 0, 0, false});
157 labelContainer.addElement(2, {3, 0, 0, false});
158
159 auto digits = std::make_unique<const std::vector<Digit>>(digitVec);
160 auto mcDigitTruth = std::make_unique<const MCLabelContainer>(labelContainer);
161 o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel> flatLabels;
162 mcDigitTruth->flatten_to(flatLabels);
163
164 clusterer.process(*digits.get(), flatLabels);
165
166 // check if clusters were found
167 BOOST_CHECK_EQUAL(clusterArray->size(), 1);
168
169 // check if two lusters were found, one in row 13 with charge 123 and one in 12 with charge 321
170 BOOST_CHECK_EQUAL(clusterArray->at(0).getContainer()->numberOfClusters, 2);
171 BOOST_CHECK_EQUAL(clusterArray->at(0).getContainer()->clusters[0].getRow(), 13);
172 BOOST_CHECK_EQUAL(clusterArray->at(0).getContainer()->clusters[0].getQMax(), 123);
173 BOOST_CHECK_EQUAL(clusterArray->at(0).getContainer()->clusters[1].getRow(), 7);
174 BOOST_CHECK_EQUAL(clusterArray->at(0).getContainer()->clusters[1].getQMax(), 321);
175
176 // check if MC labels are propagated correctly
177 BOOST_CHECK_EQUAL(labelArray->getLabels(0).size(), 2); // first cluster got two MC labels
178 BOOST_CHECK_EQUAL(labelArray->getLabels(0)[0].getTrackID(), 1);
179 BOOST_CHECK_EQUAL(labelArray->getLabels(0)[1].getTrackID(), 2);
180 BOOST_CHECK_EQUAL(labelArray->getLabels(1).size(), 1); // second cluster got one MC label
181 BOOST_CHECK_EQUAL(labelArray->getLabels(1)[0].getTrackID(), 3);
182
183 std::cout << "## Test 1 done." << std::endl;
184 std::cout << "##" << std::endl
185 << std::endl;
186}
187
189BOOST_AUTO_TEST_CASE(HwClusterer_test2)
190{
191 std::cout << "##" << std::endl;
192 std::cout << "## Starting test 2, finding single pad clusters." << std::endl;
193 auto clusterArray = std::make_unique<std::vector<o2::tpc::ClusterHardwareContainer8kb>>();
194 auto labelArray = std::make_unique<o2::dataformats::MCTruthContainer<o2::MCCompLabel>>();
195
196 o2::tpc::HwClusterer clusterer(clusterArray.get(), 0, labelArray.get());
197 // If continuous readout is false, all clusters are written directly to the output
198 clusterer.setContinuousReadout(false);
199
200 auto digits = std::make_unique<std::vector<o2::tpc::Digit>>();
201
202 // create a lot of single pad clusters, one in every pad, well separated in time
203 // which should result in one cluster
204 // Digit(int cru, float charge, int row, int pad, int time)
205 o2::tpc::Mapper& mapper = o2::tpc::Mapper::instance();
206 std::vector<unsigned> clusterPerRegionGenerated(10, 0);
207 int globalRow = 0;
208 for (int region = 0; region < 10; ++region) {
209 for (int row = 0; row < mapper.getNumberOfRowsRegion(region); ++row) {
210 int time = 0;
211 for (int pad = 0; pad < mapper.getNumberOfPadsInRowSector(globalRow); ++pad) {
212 ++clusterPerRegionGenerated[region];
213 digits->emplace_back(region, 20, globalRow, pad, time);
214 time += 7;
215 }
216 ++globalRow;
217 }
218 }
219 std::sort(digits->begin(), digits->end(), sortTime());
220
221 // Search clusters
222 o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> flatLabelsViewEmpty;
223 clusterer.process(*digits.get(), flatLabelsViewEmpty);
224
225 // Check result
226 BOOST_CHECK_EQUAL(clusterArray->size(), 47);
227
228 // check if all clusters were found
229 std::vector<unsigned> clusterPerRegionFound(10, 0);
230 for (auto& cont : *clusterArray) {
231 auto clusterContainer = cont.getContainer();
232 clusterPerRegionFound[clusterContainer->CRU] += clusterContainer->numberOfClusters;
233 }
234 for (int region = 0; region < 10; ++region) {
235 BOOST_CHECK_EQUAL(clusterPerRegionFound[region], clusterPerRegionGenerated[region]);
236 }
237
238 // check if all cluster charges (tot and max) are 20
239 for (auto& cont : *clusterArray) {
240 auto clusterContainer = cont.getContainer();
241 for (int clIndex = 0; clIndex < clusterContainer->numberOfClusters; ++clIndex) {
242 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQTot(), 20);
243 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQMax(), 20);
244 }
245 }
246
247 // check the pad and time positions of the clusters and sigmas (all 0 because single pad lcusters)
248 for (auto& cont : *clusterArray) {
249 auto clusterContainer = cont.getContainer();
250 for (int clIndex = 0; clIndex < clusterContainer->numberOfClusters; ++clIndex) {
251 BOOST_CHECK_EQUAL((clusterContainer->clusters[clIndex].getTimeLocal() + clusterContainer->timeBinOffset) / 7,
252 clusterContainer->clusters[clIndex].getPad());
253 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getSigmaPad2(), 0);
254 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getSigmaTime2(), 0);
255 }
256 }
257 std::cout << "## Test 2 done." << std::endl;
258 std::cout << "##" << std::endl
259 << std::endl;
260}
261
263BOOST_AUTO_TEST_CASE(HwClusterer_test3)
264{
265 std::cout << "##" << std::endl;
266 std::cout << "## Starting test 3, computing cluster properties." << std::endl;
267 auto clusterArray = std::make_unique<std::vector<o2::tpc::ClusterHardwareContainer8kb>>();
268 auto labelArray = std::make_unique<o2::dataformats::MCTruthContainer<o2::MCCompLabel>>();
269
270 o2::tpc::HwClusterer clusterer(clusterArray.get(), 0, labelArray.get());
271 // If continuous readout is false, all clusters are written directly to the output
272 clusterer.setContinuousReadout(false);
273
274 auto digits = std::make_unique<std::vector<o2::tpc::Digit>>();
275
276 // Digit(int cru, float charge, int row, int pad, int time)
277 // Create digits for different clusters
278 std::array<std::array<int, 25>, 6> clusters = {{{7, 10, 11, 8, 5,
279 10, 18, 21, 15, 8,
280 12, 22, 50, 20, 10,
281 9, 16, 20, 15, 8,
282 6, 9, 10, 8, 5},
283 {7, 10, 11, 8, 5,
284 11, 19, 22, 16, 9,
285 14, 24, 52, 22, 12,
286 12, 19, 23, 18, 11,
287 10, 13, 14, 12, 9},
288 {12, 15, 16, 13, 10,
289 16, 24, 27, 21, 14,
290 19, 29, 57, 27, 17,
291 17, 24, 28, 23, 16,
292 15, 18, 19, 17, 14},
293 {17, 20, 21, 18, 15,
294 21, 29, 32, 26, 19,
295 24, 34, 62, 32, 22,
296 22, 29, 33, 28, 21,
297 20, 23, 24, 22, 19},
298 {22, 25, 26, 23, 20,
299 26, 34, 37, 31, 24,
300 29, 39, 67, 37, 27,
301 27, 34, 38, 33, 26,
302 25, 28, 29, 27, 24},
303 {27, 30, 31, 28, 25,
304 31, 39, 42, 36, 29,
305 34, 44, 72, 42, 32,
306 32, 39, 43, 38, 31,
307 30, 33, 34, 32, 29}}};
308
309 for (int dp = 0; dp < 5; ++dp) {
310 for (int dt = 0; dt < 5; ++dt) {
311 for (int cl = 0; cl < clusters.size(); ++cl) {
312 digits->emplace_back(0, clusters[cl][dt * 5 + dp], cl, cl + dp, cl * 10 + dt);
313 }
314 }
315 }
316
317 std::sort(digits->begin(), digits->end(), sortTime());
318
319 // Search clusters
320 o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> flatLabelsViewEmpty;
321 clusterer.process(*digits.get(), flatLabelsViewEmpty);
322
323 // Check outcome
324 BOOST_CHECK_EQUAL(clusterArray->size(), 1);
325
326 auto clusterContainer = (*clusterArray)[0].getContainer();
327 // Checking cluster properties
328 for (int clIndex = 0; clIndex < clusterContainer->numberOfClusters; ++clIndex) {
329 float qtot = std::accumulate(clusters[clIndex].begin(), clusters[clIndex].end(), 0);
330 // Check QTot
331 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQTot(), std::accumulate(clusters[clIndex].begin(), clusters[clIndex].end(), 0));
332 // Check QMax
333 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQMax(), clusters[clIndex][12]);
334 // Check row
335 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getRow(), clIndex);
336 // Check Flags
337 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getFlags(), 0);
338 // Check pad
339 BOOST_CHECK_CLOSE(
340 clusterContainer->clusters[clIndex].getPad(),
341 p_pre(clusters[clIndex]) / qtot + clIndex + 2,
342 0.0001);
343 // Check time
344 BOOST_CHECK_CLOSE(
345 clusterContainer->clusters[clIndex].getTimeLocal() + clusterContainer->timeBinOffset,
346 t_pre(clusters[clIndex]) / qtot + clIndex * 10 + 2,
347 0.0001);
348 // Check pad sigma
349 BOOST_CHECK_CLOSE(
350 clusterContainer->clusters[clIndex].getSigmaPad2(),
351 (sigma_p_pre(clusters[clIndex]) / qtot) - ((p_pre(clusters[clIndex]) * p_pre(clusters[clIndex])) / (qtot * qtot)),
352 0.0001);
353 // Check time sigma
354 BOOST_CHECK_CLOSE(
355 clusterContainer->clusters[clIndex].getSigmaTime2(),
356 (sigma_t_pre(clusters[clIndex]) / qtot) - ((t_pre(clusters[clIndex]) * t_pre(clusters[clIndex])) / (qtot * qtot)),
357 0.0001);
358 }
359
360 std::cout << "## Test 3 done." << std::endl;
361 std::cout << "##" << std::endl
362 << std::endl;
363}
364
366BOOST_AUTO_TEST_CASE(HwClusterer_test4)
367{
368 std::cout << "##" << std::endl;
369 std::cout << "## Starting test 4, rejecting single pad clusters." << std::endl;
370 auto clusterArray = std::make_unique<std::vector<o2::tpc::ClusterHardwareContainer8kb>>();
371 auto labelArray = std::make_unique<o2::dataformats::MCTruthContainer<o2::MCCompLabel>>();
372
373 o2::tpc::HwClusterer clusterer(clusterArray.get(), 0, labelArray.get());
374 // If continuous readout is false, all clusters are written directly to the output
375 clusterer.setContinuousReadout(false);
376
377 auto digits = std::make_unique<std::vector<o2::tpc::Digit>>();
378 // Digit(int cru, float charge, int row, int pad, int time)
379 // single pad and time cluster
380 std::array<std::array<int, 25>, 4> clusters;
381 clusters[0] = {{0, 0, 0, 0, 0,
382 0, 0, 0, 0, 0,
383 0, 0, 67, 0, 0,
384 0, 0, 0, 0, 0,
385 0, 0, 0, 0, 0}};
386
387 // single time cluster, but enlarged in pad direction
388 clusters[1] = {{0, 0, 0, 0, 0,
389 0, 0, 0, 0, 0,
390 0, 12, 72, 24, 0,
391 0, 0, 0, 0, 0,
392 0, 0, 0, 0, 0}};
393
394 // single pad cluster, but enlarged in tim direction
395 clusters[2] = {{0, 0, 0, 0, 0,
396 0, 0, 33, 0, 0,
397 0, 0, 57, 0, 0,
398 0, 0, 12, 0, 0,
399 0, 0, 0, 0, 0}};
400
401 // wide cluster in both direction
402 clusters[3] = {{0, 0, 0, 0, 0,
403 0, 46, 71, 32, 0,
404 0, 32, 129, 16, 0,
405 0, 19, 53, 23, 0,
406 0, 0, 0, 0, 0}};
407
408 for (int dp = 0; dp < 5; ++dp) {
409 for (int dt = 0; dt < 5; ++dt) {
410 for (int cl = 0; cl < clusters.size(); ++cl) {
411 digits->emplace_back(0, clusters[cl][dt * 5 + dp], cl, cl + dp, cl * 10 + dt);
412 }
413 }
414 }
415
416 std::sort(digits->begin(), digits->end(), sortTime());
417
418 // Search clusters without thresholds, all 4 clusters shoud be found
419 std::cout << "testing without thresholds..." << std::endl;
420 clusterer.setRejectSinglePadClusters(false);
421 clusterer.setRejectSingleTimeClusters(false);
422 o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> flatLabelsViewEmpty;
423 clusterer.process(*digits.get(), flatLabelsViewEmpty);
424 BOOST_CHECK_EQUAL(clusterArray->size(), 1);
425 auto clusterContainer = (*clusterArray)[0].getContainer();
426 BOOST_CHECK_EQUAL(clusterContainer->numberOfClusters, 4);
427 for (int clIndex = 0; clIndex < clusterContainer->numberOfClusters; ++clIndex) {
428 float qtot = std::accumulate(clusters[clIndex].begin(), clusters[clIndex].end(), 0);
429 // Check QTot
430 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQTot(), std::accumulate(clusters[clIndex].begin(), clusters[clIndex].end(), 0));
431 // Check QMax
432 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQMax(), clusters[clIndex][12]);
433 // Check row
434 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getRow(), clIndex);
435 // Check Flags
436 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getFlags(), 0);
437 // Check pad
438 BOOST_CHECK_CLOSE(
439 clusterContainer->clusters[clIndex].getPad(),
440 p_pre(clusters[clIndex]) / qtot + clIndex + 2,
441 0.0001);
442 // Check time
443 BOOST_CHECK_CLOSE(
444 clusterContainer->clusters[clIndex].getTimeLocal() + clusterContainer->timeBinOffset,
445 t_pre(clusters[clIndex]) / qtot + clIndex * 10 + 2,
446 0.0001);
447 // Check pad sigma
448 BOOST_CHECK_CLOSE(
449 clusterContainer->clusters[clIndex].getSigmaPad2(),
450 (sigma_p_pre(clusters[clIndex]) / qtot) - ((p_pre(clusters[clIndex]) * p_pre(clusters[clIndex])) / (qtot * qtot)),
451 0.0001);
452 // Check time sigma
453 BOOST_CHECK_CLOSE(
454 clusterContainer->clusters[clIndex].getSigmaTime2(),
455 (sigma_t_pre(clusters[clIndex]) / qtot) - ((t_pre(clusters[clIndex]) * t_pre(clusters[clIndex])) / (qtot * qtot)),
456 0.0001);
457 }
458
459 // Search clusters with threshold in pad direction, only clusters 1 and 3 should be found
460 std::cout << "testing with pad threshold..." << std::endl;
461 clusterer.setRejectSinglePadClusters(true);
462 clusterer.setRejectSingleTimeClusters(false);
463 clusterer.process(*digits.get(), flatLabelsViewEmpty);
464 BOOST_CHECK_EQUAL(clusterArray->size(), 1);
465 clusterContainer = (*clusterArray)[0].getContainer();
466 BOOST_CHECK_EQUAL(clusterContainer->numberOfClusters, 2);
467 for (int clIndex = 0; clIndex < clusterContainer->numberOfClusters; ++clIndex) {
468 float qtot = std::accumulate(clusters[clIndex * 2 + 1].begin(), clusters[clIndex * 2 + 1].end(), 0);
469 // Check QTot
470 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQTot(), std::accumulate(clusters[clIndex * 2 + 1].begin(), clusters[clIndex * 2 + 1].end(), 0));
471 // Check QMax
472 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQMax(), clusters[clIndex * 2 + 1][12]);
473 // Check row
474 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getRow(), clIndex * 2 + 1);
475 // Check Flags
476 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getFlags(), 0);
477 // Check pad
478 BOOST_CHECK_CLOSE(
479 clusterContainer->clusters[clIndex].getPad(),
480 p_pre(clusters[clIndex * 2 + 1]) / qtot + (clIndex * 2 + 1) + 2,
481 0.0001);
482 // Check time
483 BOOST_CHECK_CLOSE(
484 clusterContainer->clusters[clIndex].getTimeLocal() + clusterContainer->timeBinOffset,
485 t_pre(clusters[clIndex * 2 + 1]) / qtot + (clIndex * 2 + 1) * 10 + 2,
486 0.0001);
487 // Check pad sigma
488 BOOST_CHECK_CLOSE(
489 clusterContainer->clusters[clIndex].getSigmaPad2(),
490 (sigma_p_pre(clusters[clIndex * 2 + 1]) / qtot) - ((p_pre(clusters[clIndex * 2 + 1]) * p_pre(clusters[clIndex * 2 + 1])) / (qtot * qtot)),
491 0.0001);
492 // Check time sigma
493 BOOST_CHECK_CLOSE(
494 clusterContainer->clusters[clIndex].getSigmaTime2(),
495 (sigma_t_pre(clusters[clIndex * 2 + 1]) / qtot) - ((t_pre(clusters[clIndex * 2 + 1]) * t_pre(clusters[clIndex * 2 + 1])) / (qtot * qtot)),
496 0.0001);
497 }
498
499 // Search clusters with threshold in time direction, only clusters 2 and 3 should be found
500 std::cout << "testing with time threshold..." << std::endl;
501 clusterer.setRejectSinglePadClusters(false);
502 clusterer.setRejectSingleTimeClusters(true);
503 clusterer.process(*digits.get(), flatLabelsViewEmpty);
504 BOOST_CHECK_EQUAL(clusterArray->size(), 1);
505 clusterContainer = (*clusterArray)[0].getContainer();
506 BOOST_CHECK_EQUAL(clusterContainer->numberOfClusters, 2);
507 for (int clIndex = 0; clIndex < clusterContainer->numberOfClusters; ++clIndex) {
508 float qtot = std::accumulate(clusters[clIndex + 2].begin(), clusters[clIndex + 2].end(), 0);
509 // Check QTot
510 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQTot(), std::accumulate(clusters[clIndex + 2].begin(), clusters[clIndex + 2].end(), 0));
511 // Check QMax
512 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQMax(), clusters[clIndex + 2][12]);
513 // Check row
514 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getRow(), clIndex + 2);
515 // Check Flags
516 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getFlags(), 0);
517 // Check pad
518 BOOST_CHECK_CLOSE(
519 clusterContainer->clusters[clIndex].getPad(),
520 p_pre(clusters[clIndex + 2]) / qtot + (clIndex + 2) + 2,
521 0.0001);
522 // Check time
523 BOOST_CHECK_CLOSE(
524 clusterContainer->clusters[clIndex].getTimeLocal() + clusterContainer->timeBinOffset,
525 t_pre(clusters[clIndex + 2]) / qtot + (clIndex + 2) * 10 + 2,
526 0.0001);
527 // Check pad sigma
528 BOOST_CHECK_CLOSE(
529 clusterContainer->clusters[clIndex].getSigmaPad2(),
530 (sigma_p_pre(clusters[clIndex + 2]) / qtot) - ((p_pre(clusters[clIndex + 2]) * p_pre(clusters[clIndex + 2])) / (qtot * qtot)),
531 0.0001);
532 // Check time sigma
533 BOOST_CHECK_CLOSE(
534 clusterContainer->clusters[clIndex].getSigmaTime2(),
535 (sigma_t_pre(clusters[clIndex + 2]) / qtot) - ((t_pre(clusters[clIndex + 2]) * t_pre(clusters[clIndex + 2])) / (qtot * qtot)),
536 0.0001);
537 }
538
539 // Search clusters with both thresholds, only cluster 3 should be found
540 std::cout << "testing both thresholds..." << std::endl;
541 clusterer.setRejectSinglePadClusters(true);
542 clusterer.setRejectSingleTimeClusters(true);
543 clusterer.process(*digits.get(), flatLabelsViewEmpty);
544 BOOST_CHECK_EQUAL(clusterArray->size(), 1);
545 clusterContainer = (*clusterArray)[0].getContainer();
546 BOOST_CHECK_EQUAL(clusterContainer->numberOfClusters, 1);
547 for (int clIndex = 0; clIndex < clusterContainer->numberOfClusters; ++clIndex) {
548 float qtot = std::accumulate(clusters[clIndex + 3].begin(), clusters[clIndex + 3].end(), 0);
549 // Check QTot
550 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQTot(), std::accumulate(clusters[clIndex + 3].begin(), clusters[clIndex + 3].end(), 0));
551 // Check QMax
552 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQMax(), clusters[clIndex + 3][12]);
553 // Check row
554 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getRow(), clIndex + 3);
555 // Check Flags
556 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getFlags(), 0);
557 // Check pad
558 BOOST_CHECK_CLOSE(
559 clusterContainer->clusters[clIndex].getPad(),
560 p_pre(clusters[clIndex + 3]) / qtot + (clIndex + 3) + 2,
561 0.0001);
562 // Check time
563 BOOST_CHECK_CLOSE(
564 clusterContainer->clusters[clIndex].getTimeLocal() + clusterContainer->timeBinOffset,
565 t_pre(clusters[clIndex + 3]) / qtot + (clIndex + 3) * 10 + 2,
566 0.0001);
567 // Check pad sigma
568 BOOST_CHECK_CLOSE(
569 clusterContainer->clusters[clIndex].getSigmaPad2(),
570 (sigma_p_pre(clusters[clIndex + 3]) / qtot) - ((p_pre(clusters[clIndex + 3]) * p_pre(clusters[clIndex + 3])) / (qtot * qtot)),
571 0.0001);
572 // Check time sigma
573 BOOST_CHECK_CLOSE(
574 clusterContainer->clusters[clIndex].getSigmaTime2(),
575 (sigma_t_pre(clusters[clIndex + 3]) / qtot) - ((t_pre(clusters[clIndex + 3]) * t_pre(clusters[clIndex + 3])) / (qtot * qtot)),
576 0.0001);
577 }
578
579 std::cout << "## Test 4 done." << std::endl;
580 std::cout << "##" << std::endl
581 << std::endl;
582}
583
585BOOST_AUTO_TEST_CASE(HwClusterer_test5)
586{
587 std::cout << "##" << std::endl;
588 std::cout << "## Starting test 5, rejecting peaks in subsequent." << std::endl;
589 auto clusterArray = std::make_unique<std::vector<o2::tpc::ClusterHardwareContainer8kb>>();
590 auto labelArray = std::make_unique<o2::dataformats::MCTruthContainer<o2::MCCompLabel>>();
591
592 o2::tpc::HwClusterer clusterer(clusterArray.get(), 0, labelArray.get());
593 // If continuous readout is false, all clusters are written directly to the output
594 clusterer.setContinuousReadout(false);
595
596 auto digits = std::make_unique<std::vector<o2::tpc::Digit>>();
597 // Digit(int cru, float charge, int row, int pad, int time)
598 // two peaks, with the greater one afterwards
599 std::array<std::array<int, 25>, 2> clusters;
600 clusters[0] = {{0, 0, 6, 0, 0,
601 0, 0, 23, 0, 0,
602 0, 0, 7, 0, 0,
603 0, 0, 77, 0, 0,
604 0, 0, 5, 0, 0}};
605
606 // two peaks, with the greater one first
607 clusters[1] = {{0, 0, 6, 0, 0,
608 0, 0, 67, 0, 0,
609 0, 0, 7, 0, 0,
610 0, 0, 13, 0, 0,
611 0, 0, 5, 0, 0}};
612
613 for (int dp = 0; dp < 5; ++dp) {
614 for (int dt = 0; dt < 5; ++dt) {
615 for (int cl = 0; cl < clusters.size(); ++cl) {
616 digits->emplace_back(0, clusters[cl][dt * 5 + dp], cl, cl + dp, cl * 10 + dt);
617 }
618 }
619 }
620
621 std::sort(digits->begin(), digits->end(), sortTime());
622
623 // Search clusters without rejection, all 4 clusters shoud be found
624 std::cout << "testing without rejection..." << std::endl;
625 clusterer.setRejectLaterTimebin(false);
626 o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> flatLabelsViewEmpty;
627 clusterer.process(*digits.get(), flatLabelsViewEmpty);
628 BOOST_CHECK_EQUAL(clusterArray->size(), 1);
629 auto clusterContainer = (*clusterArray)[0].getContainer();
630 BOOST_CHECK_EQUAL(clusterContainer->numberOfClusters, 4);
631 BOOST_CHECK_EQUAL(clusterContainer->clusters[0].getQMax(), clusters[0][7]);
632 BOOST_CHECK_EQUAL(clusterContainer->clusters[1].getQMax(), clusters[0][17]);
633 BOOST_CHECK_EQUAL(clusterContainer->clusters[2].getQMax(), clusters[1][7]);
634 BOOST_CHECK_EQUAL(clusterContainer->clusters[3].getQMax(), clusters[1][17]);
635
636 // Search clusters with rejection, cluster with peak charge 13 should be surpressed
637 std::cout << "testing with with rejection..." << std::endl;
638 clusterer.setRejectLaterTimebin(true);
639 clusterer.process(*digits.get(), flatLabelsViewEmpty);
640 BOOST_CHECK_EQUAL(clusterArray->size(), 1);
641 clusterContainer = (*clusterArray)[0].getContainer();
642 BOOST_CHECK_EQUAL(clusterContainer->numberOfClusters, 3);
643 BOOST_CHECK_EQUAL(clusterContainer->clusters[0].getQMax(), clusters[0][7]);
644 BOOST_CHECK_EQUAL(clusterContainer->clusters[1].getQMax(), clusters[0][17]);
645 BOOST_CHECK_EQUAL(clusterContainer->clusters[2].getQMax(), clusters[1][7]);
646
647 std::cout << "## Test 5 done." << std::endl;
648 std::cout << "##" << std::endl
649 << std::endl;
650}
651
653BOOST_AUTO_TEST_CASE(HwClusterer_test6)
654{
655 std::cout << "##" << std::endl;
656 std::cout << "## Starting test 6, split charge among nearby clusters." << std::endl;
657 auto clusterArray = std::make_unique<std::vector<o2::tpc::ClusterHardwareContainer8kb>>();
658 auto labelArray = std::make_unique<o2::dataformats::MCTruthContainer<o2::MCCompLabel>>();
659
660 o2::tpc::HwClusterer clusterer(clusterArray.get(), 0, labelArray.get());
661 // If continuous readout is false, all clusters are written directly to the output
662 clusterer.setContinuousReadout(false);
663
664 auto digits = std::make_unique<std::vector<o2::tpc::Digit>>();
665 // Digit(int cru, float charge, int row, int pad, int time)
666 std::array<std::array<int, 100>, 6> clusters;
667 // Just a single cluster
668 clusters[0] = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
669 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
670 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
671 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
672 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
673 4, 9, 12, 6, 1, 0, 0, 0, 0, 0,
674 8, 17, 25, 18, 5, 0, 0, 0, 0, 0,
675 13, 22, 50, 28, 14, 0, 0, 0, 0, 0,
676 9, 16, 27, 19, 7, 0, 0, 0, 0, 0,
677 2, 7, 11, 6, 3, 0, 0, 0, 0, 0}};
678
679 // Two clusters next to each other in pad direction, peaks well separated
680 clusters[1] = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
681 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
682 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
683 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
684 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
685 4, 9, 12, 6, 1, 4, 9, 12, 6, 1,
686 8, 17, 25, 18, 5, 8, 17, 25, 18, 5,
687 13, 22, 51, 28, 14, 13, 22, 52, 28, 15,
688 9, 16, 27, 19, 7, 9, 16, 27, 19, 7,
689 2, 7, 11, 6, 3, 2, 7, 11, 6, 3}};
690
691 // Two clusters next to each other in pad direction, peaks 4 pads appart
692 clusters[2] = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
693 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
694 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
695 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
696 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
697 4, 9, 12, 6, 1, 9, 12, 6, 1, 0,
698 8, 17, 25, 18, 5, 17, 25, 18, 5, 0,
699 13, 22, 53, 28, 14, 22, 54, 28, 15, 0,
700 9, 16, 27, 19, 7, 16, 27, 19, 7, 0,
701 2, 7, 11, 6, 3, 7, 11, 6, 3, 0}};
702
703 // Two clusters next to each other in pad direction, peaks 3 pads appartd
704 clusters[3] = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
705 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
706 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
707 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
708 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
709 0, 4, 9, 12, 6, 9, 12, 6, 1, 0,
710 0, 8, 17, 25, 18, 17, 25, 18, 5, 0,
711 0, 13, 22, 55, 28, 22, 56, 28, 15, 0,
712 0, 9, 16, 27, 19, 16, 27, 19, 7, 0,
713 0, 2, 7, 11, 6, 7, 11, 6, 3, 0}};
714
715 // Two clusters next to each other in pad direction, peaks 2 pads appartd
716 clusters[4] = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
717 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
718 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
719 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
720 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
721 0, 4, 9, 12, 6, 12, 6, 1, 0, 0,
722 0, 8, 17, 25, 18, 25, 18, 5, 0, 0,
723 0, 13, 22, 57, 28, 58, 28, 15, 0, 0,
724 0, 9, 16, 27, 19, 27, 19, 7, 0, 0,
725 0, 2, 7, 11, 6, 11, 6, 3, 0, 0}};
726
727 // Two clusters next to each other in diagonal direction
728 clusters[5] = {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
729 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
730 0, 0, 0, 0, 4, 9, 12, 6, 1, 0,
731 0, 0, 0, 0, 8, 17, 25, 18, 5, 0,
732 0, 0, 0, 0, 13, 22, 59, 28, 15, 0,
733 4, 9, 12, 6, 9, 16, 27, 19, 7, 0,
734 8, 17, 25, 18, 2, 7, 11, 6, 3, 0,
735 13, 22, 60, 28, 14, 0, 0, 0, 0, 0,
736 9, 16, 27, 19, 7, 0, 0, 0, 0, 0,
737 2, 7, 11, 6, 3, 0, 0, 0, 0, 0}};
738
739 std::array<std::array<float, 25>, 11> clustersMode0;
740 clustersMode0[0] = {{4, 9, 12, 6, 1,
741 8, 17, 25, 18, 5,
742 13, 22, 50, 28, 14,
743 9, 16, 27, 19, 7,
744 2, 7, 11, 6, 3}};
745
746 clustersMode0[1] = {{4, 9, 12, 6, 1,
747 8, 17, 25, 18, 5,
748 13, 22, 51, 28, 14,
749 9, 16, 27, 19, 7,
750 2, 7, 11, 6, 3}};
751
752 clustersMode0[2] = {{4, 9, 12, 6, 1,
753 8, 17, 25, 18, 5,
754 13, 22, 52, 28, 15,
755 9, 16, 27, 19, 7,
756 2, 7, 11, 6, 3}};
757
758 clustersMode0[3] = {{4, 9, 12, 6, 1,
759 8, 17, 25, 18, 5,
760 13, 22, 53, 28, 14,
761 9, 16, 27, 19, 7,
762 2, 7, 11, 6, 3}};
763
764 clustersMode0[4] = {{1, 9, 12, 6, 1,
765 5, 17, 25, 18, 5,
766 14, 22, 54, 28, 15,
767 7, 16, 27, 19, 7,
768 3, 7, 11, 6, 3}};
769
770 clustersMode0[5] = {{4, 9, 12, 6, 9,
771 8, 17, 25, 18, 17,
772 13, 22, 55, 28, 22,
773 9, 16, 27, 19, 16,
774 2, 7, 11, 6, 7}};
775
776 clustersMode0[6] = {{6, 9, 12, 6, 1,
777 18, 17, 25, 18, 5,
778 28, 22, 56, 28, 15,
779 19, 16, 27, 19, 7,
780 6, 7, 11, 6, 3}};
781
782 clustersMode0[7] = {{4, 9, 12, 6, 12,
783 8, 17, 25, 18, 25,
784 13, 22, 57, 28, 58,
785 9, 16, 27, 19, 27,
786 2, 7, 11, 6, 11}};
787
788 clustersMode0[8] = {{12, 6, 12, 6, 1,
789 25, 18, 25, 18, 5,
790 57, 28, 58, 28, 15,
791 27, 19, 27, 19, 7,
792 11, 6, 11, 6, 3}};
793
794 clustersMode0[9] = {{4, 9, 12, 6, 1,
795 8, 17, 25, 18, 5,
796 13, 22, 59, 28, 15,
797 9, 16, 27, 19, 7,
798 2, 7, 11, 6, 3}};
799
800 clustersMode0[10] = {{4, 9, 12, 6, 9,
801 8, 17, 25, 18, 2,
802 13, 22, 60, 28, 14,
803 9, 16, 27, 19, 7,
804 2, 7, 11, 6, 3}};
805
806 std::array<std::array<float, 25>, 11> clustersMode1;
807 clustersMode1[0] = {{4, 9, 12, 6, 1,
808 8, 17, 25, 18, 5,
809 13, 22, 50, 28, 14,
810 9, 16, 27, 19, 7,
811 2, 7, 11, 6, 3}};
812
813 clustersMode1[1] = {{4, 9, 12, 6, 0.5,
814 8, 17, 25, 18, 2.5,
815 13, 22, 51, 28, 14,
816 9, 16, 27, 19, 3.5,
817 2, 7, 11, 6, 3}};
818
819 clustersMode1[2] = {{4, 9, 12, 6, 1,
820 8, 17, 25, 18, 5,
821 6.5, 22, 52, 28, 15,
822 9, 16, 27, 19, 7,
823 1, 7, 11, 6, 3}};
824
825 clustersMode1[3] = {{4, 9, 12, 6, 0.5,
826 8, 17, 25, 18, 2.5,
827 13, 22, 53, 28, 7,
828 9, 16, 27, 19, 3.5,
829 2, 7, 11, 6, 1.5}};
830
831 clustersMode1[4] = {{0.5, 9, 12, 6, 1,
832 2.5, 17, 25, 18, 5,
833 7, 22, 54, 28, 15,
834 3.5, 16, 27, 19, 7,
835 1.5, 7, 11, 6, 3}};
836
837 clustersMode1[5] = {{4, 9, 12, 6, 0,
838 8, 17, 25, 18, 8.5,
839 13, 22, 55, 28, 11,
840 9, 16, 27, 19, 8,
841 2, 7, 11, 6, 0}};
842
843 clustersMode1[6] = {{0, 9, 12, 6, 1,
844 0, 8.5, 25, 18, 5,
845 0, 11, 56, 28, 15,
846 0, 8, 27, 19, 7,
847 0, 7, 11, 6, 3}};
848
849 clustersMode1[7] = {{4, 9, 12, 6, 0,
850 8, 17, 25, 9, 0,
851 13, 22, 57, 14, 0,
852 9, 16, 27, 9.5, 0,
853 2, 7, 11, 6, 0}};
854
855 clustersMode1[8] = {{0, 6, 12, 6, 1,
856 0, 9, 25, 18, 5,
857 0, 14, 58, 28, 15,
858 0, 9.5, 27, 19, 7,
859 0, 6, 11, 6, 3}};
860
861 clustersMode1[9] = {{4, 9, 12, 6, 1,
862 8, 17, 25, 18, 5,
863 13, 22, 59, 28, 15,
864 4.5, 16, 27, 19, 7,
865 1, 3.5, 11, 6, 3}};
866
867 clustersMode1[10] = {{4, 9, 12, 3, 0,
868 8, 17, 25, 18, 1,
869 13, 22, 60, 28, 14,
870 9, 16, 27, 19, 7,
871 2, 7, 11, 6, 3}};
872
873 for (int cl = 0; cl < clusters.size(); ++cl) {
874 for (int dt = 0; dt < 10; ++dt) {
875 for (int dp = 0; dp < 10; ++dp) {
876 // Digit(int cru, float charge, int row, int pad, int time)
877 digits->emplace_back(0, clusters[cl][dt * 10 + dp], cl, dp, dt + 20 * cl);
878 }
879 }
880 }
881
882 std::sort(digits->begin(), digits->end(), sortTime());
883
884 std::cout << "testing without splitting..." << std::endl;
885
886 std::vector<ClusterHardware> clustersToCompare;
887 clustersToCompare.emplace_back();
888 clustersToCompare.back().setCluster(2, 7, p_pre_fp(clustersMode0[0]), t_pre_fp(clustersMode0[0]), sigma_p_pre_fp(clustersMode0[0]), sigma_t_pre_fp(clustersMode0[0]), (clustersMode0[0][12] * 2), (std::accumulate(clustersMode0[0].begin(), clustersMode0[0].end(), 0.0) * 16), 0, 0);
889 clustersToCompare.emplace_back();
890 clustersToCompare.back().setCluster(2, 7 + 20, p_pre_fp(clustersMode0[1]), t_pre_fp(clustersMode0[1]), sigma_p_pre_fp(clustersMode0[1]), sigma_t_pre_fp(clustersMode0[1]), (clustersMode0[1][12] * 2), (std::accumulate(clustersMode0[1].begin(), clustersMode0[1].end(), 0.0) * 16), 0, 0);
891 clustersToCompare.emplace_back();
892 clustersToCompare.back().setCluster(2 + 5, 7 + 20, p_pre_fp(clustersMode0[2]), t_pre_fp(clustersMode0[2]), sigma_p_pre_fp(clustersMode0[2]), sigma_t_pre_fp(clustersMode0[2]), (clustersMode0[2][12] * 2), (std::accumulate(clustersMode0[2].begin(), clustersMode0[2].end(), 0.0) * 16), 0, 0);
893 clustersToCompare.emplace_back();
894 clustersToCompare.back().setCluster(2, 7 + 40, p_pre_fp(clustersMode0[3]), t_pre_fp(clustersMode0[3]), sigma_p_pre_fp(clustersMode0[3]), sigma_t_pre_fp(clustersMode0[3]), (clustersMode0[3][12] * 2), (std::accumulate(clustersMode0[3].begin(), clustersMode0[3].end(), 0.0) * 16), 0, 0);
895 clustersToCompare.emplace_back();
896 clustersToCompare.back().setCluster(2 + 4, 7 + 40, p_pre_fp(clustersMode0[4]), t_pre_fp(clustersMode0[4]), sigma_p_pre_fp(clustersMode0[4]), sigma_t_pre_fp(clustersMode0[4]), (clustersMode0[4][12] * 2), (std::accumulate(clustersMode0[4].begin(), clustersMode0[4].end(), 0.0) * 16), 0, 0);
897 clustersToCompare.emplace_back();
898 clustersToCompare.back().setCluster(2 + 1, 7 + 60, p_pre_fp(clustersMode0[5]), t_pre_fp(clustersMode0[5]), sigma_p_pre_fp(clustersMode0[5]), sigma_t_pre_fp(clustersMode0[5]), (clustersMode0[5][12] * 2), (std::accumulate(clustersMode0[5].begin(), clustersMode0[5].end(), 0.0) * 16), 0, 0);
899 clustersToCompare.emplace_back();
900 clustersToCompare.back().setCluster(2 + 4, 7 + 60, p_pre_fp(clustersMode0[6]), t_pre_fp(clustersMode0[6]), sigma_p_pre_fp(clustersMode0[6]), sigma_t_pre_fp(clustersMode0[6]), (clustersMode0[6][12] * 2), (std::accumulate(clustersMode0[6].begin(), clustersMode0[6].end(), 0.0) * 16), 0, 0);
901 clustersToCompare.emplace_back();
902 clustersToCompare.back().setCluster(2 + 1, 7 + 80, p_pre_fp(clustersMode0[7]), t_pre_fp(clustersMode0[7]), sigma_p_pre_fp(clustersMode0[7]), sigma_t_pre_fp(clustersMode0[7]), (clustersMode0[7][12] * 2), (std::accumulate(clustersMode0[7].begin(), clustersMode0[7].end(), 0.0) * 16), 0, 0);
903 clustersToCompare.emplace_back();
904 clustersToCompare.back().setCluster(2 + 3, 7 + 80, p_pre_fp(clustersMode0[8]), t_pre_fp(clustersMode0[8]), sigma_p_pre_fp(clustersMode0[8]), sigma_t_pre_fp(clustersMode0[8]), (clustersMode0[8][12] * 2), (std::accumulate(clustersMode0[8].begin(), clustersMode0[8].end(), 0.0) * 16), 0, 0);
905 clustersToCompare.emplace_back();
906 clustersToCompare.back().setCluster(2 + 4, 7 + 97, p_pre_fp(clustersMode0[9]), t_pre_fp(clustersMode0[9]), sigma_p_pre_fp(clustersMode0[9]), sigma_t_pre_fp(clustersMode0[9]), (clustersMode0[9][12] * 2), (std::accumulate(clustersMode0[9].begin(), clustersMode0[9].end(), 0.0) * 16), 0, 0);
907 clustersToCompare.emplace_back();
908 clustersToCompare.back().setCluster(2, 7 + 100, p_pre_fp(clustersMode0[10]), t_pre_fp(clustersMode0[10]), sigma_p_pre_fp(clustersMode0[10]), sigma_t_pre_fp(clustersMode0[10]), (clustersMode0[10][12] * 2), (std::accumulate(clustersMode0[10].begin(), clustersMode0[10].end(), 0.0) * 16), 0, 0);
909 clusterer.setSplittingMode(0);
910 o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> flatLabelsViewEmpty;
911 clusterer.process(*digits.get(), flatLabelsViewEmpty);
912 BOOST_CHECK_EQUAL(clusterArray->size(), 1);
913 auto clusterContainer = (*clusterArray)[0].getContainer();
914 BOOST_CHECK_EQUAL(clusterContainer->numberOfClusters, 11);
915 for (int clIndex = 0; clIndex < clusterContainer->numberOfClusters; ++clIndex) {
916 std::cout << "Testing cluster " << clIndex << std::endl;
917 // Checking row and flags are not relevant for this test
918 // Check QTot
919 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQTot(), clustersToCompare[clIndex].getQTot());
920 // Check QMax
921 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQMax(), clustersToCompare[clIndex].getQMax());
922 // Check pad
923 BOOST_CHECK_CLOSE(
924 clusterContainer->clusters[clIndex].getPad(),
925 clustersToCompare[clIndex].getPad(),
926 0.0001);
927 // Check time
928 BOOST_CHECK_CLOSE(
929 clusterContainer->clusters[clIndex].getTimeLocal() + clusterContainer->timeBinOffset,
930 clustersToCompare[clIndex].getTimeLocal(),
931 0.0001);
932 // Check pad sigma
933 BOOST_CHECK_CLOSE(
934 clusterContainer->clusters[clIndex].getSigmaPad2(),
935 clustersToCompare[clIndex].getSigmaPad2(),
936 0.0001);
937 // Check time sigma
938 BOOST_CHECK_CLOSE(
939 clusterContainer->clusters[clIndex].getSigmaTime2(),
940 clustersToCompare[clIndex].getSigmaTime2(),
941 0.0001);
942 }
943
944 std::cout << "testing splitting mode 1..." << std::endl;
945 clustersToCompare.clear();
946 clustersToCompare.emplace_back();
947 clustersToCompare.back().setCluster(2, 7, p_pre_fp(clustersMode1[0]), t_pre_fp(clustersMode1[0]), sigma_p_pre_fp(clustersMode1[0]), sigma_t_pre_fp(clustersMode1[0]), (clustersMode1[0][12] * 2), (std::accumulate(clustersMode1[0].begin(), clustersMode1[0].end(), 0.0) * 16), 0, 0);
948 clustersToCompare.emplace_back();
949 clustersToCompare.back().setCluster(2, 7 + 20, p_pre_fp(clustersMode1[1]), t_pre_fp(clustersMode1[1]), sigma_p_pre_fp(clustersMode1[1]), sigma_t_pre_fp(clustersMode1[1]), (clustersMode1[1][12] * 2), (std::accumulate(clustersMode1[1].begin(), clustersMode1[1].end(), 0.0) * 16), 0, 0);
950 clustersToCompare.emplace_back();
951 clustersToCompare.back().setCluster(2 + 5, 7 + 20, p_pre_fp(clustersMode1[2]), t_pre_fp(clustersMode1[2]), sigma_p_pre_fp(clustersMode1[2]), sigma_t_pre_fp(clustersMode1[2]), (clustersMode1[2][12] * 2), (std::accumulate(clustersMode1[2].begin(), clustersMode1[2].end(), 0.0) * 16), 0, 0);
952 clustersToCompare.emplace_back();
953 clustersToCompare.back().setCluster(2, 7 + 40, p_pre_fp(clustersMode1[3]), t_pre_fp(clustersMode1[3]), sigma_p_pre_fp(clustersMode1[3]), sigma_t_pre_fp(clustersMode1[3]), (clustersMode1[3][12] * 2), (std::accumulate(clustersMode1[3].begin(), clustersMode1[3].end(), 0.0) * 16), 0, 0);
954 clustersToCompare.emplace_back();
955 clustersToCompare.back().setCluster(2 + 4, 7 + 40, p_pre_fp(clustersMode1[4]), t_pre_fp(clustersMode1[4]), sigma_p_pre_fp(clustersMode1[4]), sigma_t_pre_fp(clustersMode1[4]), (clustersMode1[4][12] * 2), (std::accumulate(clustersMode1[4].begin(), clustersMode1[4].end(), 0.0) * 16), 0, 0);
956 clustersToCompare.emplace_back();
957 clustersToCompare.back().setCluster(2 + 1, 7 + 60, p_pre_fp(clustersMode1[5]), t_pre_fp(clustersMode1[5]), sigma_p_pre_fp(clustersMode1[5]), sigma_t_pre_fp(clustersMode1[5]), (clustersMode1[5][12] * 2), (std::accumulate(clustersMode1[5].begin(), clustersMode1[5].end(), 0.0) * 16), 0, 0);
958 clustersToCompare.emplace_back();
959 clustersToCompare.back().setCluster(2 + 4, 7 + 60, p_pre_fp(clustersMode1[6]), t_pre_fp(clustersMode1[6]), sigma_p_pre_fp(clustersMode1[6]), sigma_t_pre_fp(clustersMode1[6]), (clustersMode1[6][12] * 2), (std::accumulate(clustersMode1[6].begin(), clustersMode1[6].end(), 0.0) * 16), 0, 0);
960 clustersToCompare.emplace_back();
961 clustersToCompare.back().setCluster(2 + 1, 7 + 80, p_pre_fp(clustersMode1[7]), t_pre_fp(clustersMode1[7]), sigma_p_pre_fp(clustersMode1[7]), sigma_t_pre_fp(clustersMode1[7]), (clustersMode1[7][12] * 2), (std::accumulate(clustersMode1[7].begin(), clustersMode1[7].end(), 0.0) * 16), 0, 0);
962 clustersToCompare.emplace_back();
963 clustersToCompare.back().setCluster(2 + 3, 7 + 80, p_pre_fp(clustersMode1[8]), t_pre_fp(clustersMode1[8]), sigma_p_pre_fp(clustersMode1[8]), sigma_t_pre_fp(clustersMode1[8]), (clustersMode1[8][12] * 2), (std::accumulate(clustersMode1[8].begin(), clustersMode1[8].end(), 0.0) * 16), 0, 0);
964 clustersToCompare.emplace_back();
965 clustersToCompare.back().setCluster(2 + 4, 7 + 97, p_pre_fp(clustersMode1[9]), t_pre_fp(clustersMode1[9]), sigma_p_pre_fp(clustersMode1[9]), sigma_t_pre_fp(clustersMode1[9]), (clustersMode1[9][12] * 2), (std::accumulate(clustersMode1[9].begin(), clustersMode1[9].end(), 0.0) * 16), 0, 0);
966 clustersToCompare.emplace_back();
967 clustersToCompare.back().setCluster(2, 7 + 100, p_pre_fp(clustersMode1[10]), t_pre_fp(clustersMode1[10]), sigma_p_pre_fp(clustersMode1[10]), sigma_t_pre_fp(clustersMode1[10]), (clustersMode1[10][12] * 2), (std::accumulate(clustersMode1[10].begin(), clustersMode1[10].end(), 0.0) * 16), 0, 0);
968 clusterer.setSplittingMode(1);
969 clusterer.process(*digits.get(), flatLabelsViewEmpty);
970 BOOST_CHECK_EQUAL(clusterArray->size(), 1);
971 clusterContainer = (*clusterArray)[0].getContainer();
972 BOOST_CHECK_EQUAL(clusterContainer->numberOfClusters, 11);
973 for (int clIndex = 0; clIndex < clusterContainer->numberOfClusters; ++clIndex) {
974 std::cout << "Testing cluster " << clIndex << std::endl;
975 // Checking row and flags are not relevant for this test
976 // Check QTot
977 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQTot(), clustersToCompare[clIndex].getQTot());
978 // Check QMax
979 BOOST_CHECK_EQUAL(clusterContainer->clusters[clIndex].getQMax(), clustersToCompare[clIndex].getQMax());
980 // Check pad
981 BOOST_CHECK_CLOSE(
982 clusterContainer->clusters[clIndex].getPad(),
983 clustersToCompare[clIndex].getPad(),
984 0.0001);
985 // Check time
986 BOOST_CHECK_CLOSE(
987 clusterContainer->clusters[clIndex].getTimeLocal() + clusterContainer->timeBinOffset,
988 clustersToCompare[clIndex].getTimeLocal(),
989 0.0001);
990 // Check pad sigma
991 BOOST_CHECK_CLOSE(
992 clusterContainer->clusters[clIndex].getSigmaPad2(),
993 clustersToCompare[clIndex].getSigmaPad2(),
994 0.0001);
995 // Check time sigma
996 BOOST_CHECK_CLOSE(
997 clusterContainer->clusters[clIndex].getSigmaTime2(),
998 clustersToCompare[clIndex].getSigmaTime2(),
999 0.0001);
1000 }
1001
1002 std::cout << "## Test 6 done." << std::endl;
1003 std::cout << "##" << std::endl
1004 << std::endl;
1005}
1006} // namespace tpc
1007} // namespace o2
ConstMCTruthContainer.h
A const (ready only) version of MCTruthContainer.
Digit.h
Definition of the TPC Digit.
Helpers.h
Helper class for memory management of TPC Data Formats, external from the actual data type classes to...
time
int16_t time
Definition RawEventData.h:4
HwClusterer.h
Class for TPC HW cluster finding.
o2::dataformats::ConstMCTruthContainer
A read-only version of MCTruthContainer allowing for storage optimisation.
Definition ConstMCTruthContainer.h:40
o2::dataformats::MCTruthContainer::addElement
void addElement(uint32_t dataindex, TruthElement const &element, bool noElement=false)
Definition MCTruthContainer.h:190
o2::tpc::HwClusterer
Class for TPC HW cluster finding.
Definition HwClusterer.h:42
o2::tpc::HwClusterer::process
void process(gsl::span< o2::tpc::Digit const > const &digits, ConstMCLabelContainerView const &mcDigitTruth) override
Definition HwClusterer.h:221
o2::tpc::HwClusterer::setContinuousReadout
void setContinuousReadout(bool isContinuous)
Definition HwClusterer.h:231
o2::tpc::Mapper::instance
static Mapper & instance(const std::string mappingDir="")
Definition Mapper.h:44
end
GLuint GLuint end
Definition glcorearb.h:469
data
GLboolean * data
Definition glcorearb.h:298
o2::dataformats::MCLabelContainer
o2::dataformats::MCTruthContainer< o2::MCCompLabel > MCLabelContainer
Definition MCTruthContainer.h:437
o2::tpc::BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(ClusterHardware_test1)
Definition testClusterHardware.cxx:28
o2::tpc::sigma_p_pre_fp
float sigma_p_pre_fp(std::array< float, 25 > &data)
Definition testTPCHwClusterer.cxx:101
o2::tpc::sigma_t_pre_fp
float sigma_t_pre_fp(std::array< float, 25 > &data)
Definition testTPCHwClusterer.cxx:123
o2::tpc::p_pre_fp
float p_pre_fp(std::array< float, 25 > &data)
Definition testTPCHwClusterer.cxx:90
o2::tpc::t_pre_fp
float t_pre_fp(std::array< float, 25 > &data)
Definition testTPCHwClusterer.cxx:112
o2::tpc::t_pre
float t_pre(std::array< int, 25 > &data)
Definition testTPCHwClusterer.cxx:68
o2::tpc::p_pre
float p_pre(std::array< int, 25 > &data)
Definition testTPCHwClusterer.cxx:46
o2::tpc::begin
Enum< T >::Iterator begin(Enum< T >)
Definition Defs.h:173
o2::tpc::sigma_p_pre
float sigma_p_pre(std::array< int, 25 > &data)
Definition testTPCHwClusterer.cxx:57
o2::tpc::sigma_t_pre
float sigma_t_pre(std::array< int, 25 > &data)
Definition testTPCHwClusterer.cxx:79
o2
a couple of static helper functions to create timestamp values for CCDB queries or override obsolete ...
Definition BitstreamReader.h:24
o2::tpc::sortTime::operator()
bool operator()(const o2::tpc::Digit &d1, const o2::tpc::Digit &d2)
Definition testTPCHwClusterer.cxx:40
clusters
std::vector< Cluster > clusters
Definition test_ctf_io_cpv.cxx:41
BOOST_CHECK_EQUAL
BOOST_CHECK_EQUAL(triggersD.size(), triggers.size())
digits
std::vector< Digit > digits
Definition test_ctf_io_hmpid.cxx:40
row
std::vector< int > row
Definition test_ctf_io_itsmft.cxx:48