Project
Loading...
Searching...
No Matches
TrackingInterface.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
12#include <memory>
13
14#include <oneapi/tbb/task_arena.h>
15
18
21
24
32
33using namespace o2::framework;
34using namespace o2::its;
35
37{
38 // get parameters
39 const auto& trackConf = o2::its::TrackerParamConfig::Instance();
40 const auto& vertConf = o2::its::VertexerParamConfig::Instance();
41 if (auto parmode = (TrackingMode::Type)trackConf.trackingMode; mMode == TrackingMode::Unset || (parmode != TrackingMode::Unset && mMode != parmode)) {
42 LOGP(info, "Tracking mode overwritten by configurable params from {} to {}", TrackingMode::toString(mMode), TrackingMode::toString(parmode));
43 mMode = parmode;
44 }
45 auto trackParams = TrackingMode::getTrackingParameters(mMode);
46 auto vertParams = TrackingMode::getVertexingParameters(mMode);
47 LOGP(info, "Initializing tracker in {} phase reconstruction with {} passes for tracking and {}/{} for vertexing", TrackingMode::toString(mMode), trackParams.size(), o2::its::VertexerParamConfig::Instance().nIterations, vertParams.size());
48 mTracker->setParameters(trackParams);
49 mVertexer->setParameters(vertParams);
50
51 if (mMode == TrackingMode::Cosmics) {
52 mRunVertexer = false;
53 mCosmicsProcessing = true;
54 LOGP(info, "Cosmic mode enabled, will skip vertexing");
55 }
56
57 // threading
58 if (trackConf.nThreads == vertConf.nThreads) {
59 bool clamped{false};
60 int nThreads = trackConf.nThreads;
61 if (nThreads > 0) {
62 const int hw = std::thread::hardware_concurrency();
63 const int maxThreads = (hw == 0 ? 1 : hw);
64 nThreads = std::clamp(nThreads, 1, maxThreads);
65 clamped = trackConf.nThreads > maxThreads;
66 }
67 LOGP(info, "Tracker and Vertexer will share the task arena with {} thread(s){}", nThreads, (clamped) ? " (clamped)" : "");
68 mTaskArena = std::make_shared<tbb::task_arena>(std::abs(nThreads));
69 }
70 mVertexer->setNThreads(vertConf.nThreads, mTaskArena);
71 mTracker->setNThreads(trackConf.nThreads, mTaskArena);
72}
73
75{
76 auto compClusters = pc.inputs().get<gsl::span<o2::itsmft::CompClusterExt>>("compClusters");
77 gsl::span<const unsigned char> patterns = pc.inputs().get<gsl::span<unsigned char>>("patterns");
78 gsl::span<const o2::itsmft::PhysTrigger> physTriggers;
79 std::vector<o2::itsmft::PhysTrigger> fromTRD;
80 if (mUseTriggers == 2) { // use TRD triggers
82 auto trdTriggers = pc.inputs().get<gsl::span<o2::trd::TriggerRecord>>("phystrig");
83 for (const auto& trig : trdTriggers) {
84 if (trig.getBCData() >= ir && trig.getNumberOfTracklets()) {
85 ir = trig.getBCData();
86 fromTRD.emplace_back(o2::itsmft::PhysTrigger{ir, 0});
87 }
88 }
89 physTriggers = gsl::span<const o2::itsmft::PhysTrigger>(fromTRD.data(), fromTRD.size());
90 } else if (mUseTriggers == 1) { // use Phys triggers from ITS stream
91 physTriggers = pc.inputs().get<gsl::span<o2::itsmft::PhysTrigger>>("phystrig");
92 }
93
94 auto rofsinput = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>("ROframes");
95 auto& trackROFvec = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{"ITS", "ITSTrackROF", 0}, rofsinput.begin(), rofsinput.end());
96 auto& irFrames = pc.outputs().make<std::vector<o2::dataformats::IRFrame>>(Output{"ITS", "IRFRAMES", 0});
97 const auto& alpParams = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance(); // RS: this should come from CCDB
98
99 irFrames.reserve(trackROFvec.size());
100 int nBCPerTF = alpParams.roFrameLengthInBC;
101
102 LOGP(info, "ITSTracker pulled {} clusters, {} RO frames", compClusters.size(), trackROFvec.size());
103 const dataformats::MCTruthContainer<MCCompLabel>* labels = nullptr;
104 gsl::span<itsmft::MC2ROFRecord const> mc2rofs;
105 if (mIsMC) {
106 labels = pc.inputs().get<const dataformats::MCTruthContainer<MCCompLabel>*>("itsmclabels").release();
107 // get the array as read-only span, a snapshot is sent forward
108 pc.outputs().snapshot(Output{"ITS", "ITSTrackMC2ROF", 0}, pc.inputs().get<gsl::span<itsmft::MC2ROFRecord>>("ITSMC2ROframes"));
109 LOG(info) << labels->getIndexedSize() << " MC label objects , in " << mc2rofs.size() << " MC events";
110 }
111
112 auto& allClusIdx = pc.outputs().make<std::vector<int>>(Output{"ITS", "TRACKCLSID", 0});
113 auto& allTracks = pc.outputs().make<std::vector<o2::its::TrackITS>>(Output{"ITS", "TRACKS", 0});
114 auto& vertROFvec = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{"ITS", "VERTICESROF", 0});
115 auto& vertices = pc.outputs().make<std::vector<Vertex>>(Output{"ITS", "VERTICES", 0});
116
117 // MC
118 static pmr::vector<o2::MCCompLabel> dummyMCLabTracks, dummyMCLabVerts;
119 static pmr::vector<float> dummyMCPurVerts;
120 auto& allTrackLabels = mIsMC ? pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{"ITS", "TRACKSMCTR", 0}) : dummyMCLabTracks;
121 auto& allVerticesLabels = mIsMC ? pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{"ITS", "VERTICESMCTR", 0}) : dummyMCLabVerts;
122 bool writeContLabels = mIsMC && o2::its::VertexerParamConfig::Instance().outputContLabels;
123 auto& allVerticesContLabels = writeContLabels ? pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{"ITS", "VERTICESMCTRCONT", 0}) : dummyMCLabVerts;
124 auto& allVerticesPurities = mIsMC ? pc.outputs().make<std::vector<float>>(Output{"ITS", "VERTICESMCPUR", 0}) : dummyMCPurVerts;
125
126 std::uint32_t roFrame = 0;
127
128 bool continuous = o2::base::GRPGeomHelper::instance().getGRPECS()->isDetContinuousReadOut(o2::detectors::DetID::ITS);
129 LOG(info) << "ITSTracker RO: continuous=" << continuous;
130
131 if (mOverrideBeamEstimation) {
132 mTimeFrame->setBeamPosition(mMeanVertex->getX(),
133 mMeanVertex->getY(),
134 mMeanVertex->getSigmaY2(),
135 mTracker->getParameters()[0].LayerResolution[0],
136 mTracker->getParameters()[0].SystErrorY2[0]);
137 }
138
139 mTracker->setBz(o2::base::Propagator::Instance()->getNominalBz());
140
141 gsl::span<const unsigned char>::iterator pattIt = patterns.begin();
142
143 gsl::span<itsmft::ROFRecord> trackROFspan(trackROFvec);
144 loadROF(trackROFspan, compClusters, pattIt, labels);
145 pattIt = patterns.begin();
146 std::vector<int> savedROF;
147 auto logger = [&](const std::string& s) { LOG(info) << s; };
148 auto fatalLogger = [&](const std::string& s) { LOG(fatal) << s; };
149 auto errorLogger = [&](const std::string& s) { LOG(error) << s; };
150
151 FastMultEst multEst; // mult estimator
152 std::vector<uint8_t> processingMask, processUPCMask;
153 int cutVertexMult{0}, cutUPCVertex{0}, cutRandomMult = int(trackROFvec.size()) - multEst.selectROFs(trackROFvec, compClusters, physTriggers, processingMask);
154 processUPCMask.resize(processingMask.size(), false);
155 mTimeFrame->setMultiplicityCutMask(processingMask);
156 float vertexerElapsedTime{0.f};
157 if (mRunVertexer) {
158 vertROFvec.reserve(trackROFvec.size());
159 // Run seeding vertexer
160 vertexerElapsedTime = mVertexer->clustersToVertices(logger);
161 } else { // cosmics
163 }
164 const auto& multEstConf = FastMultEstConfig::Instance(); // parameters for mult estimation and cuts
165 gsl::span<const std::pair<MCCompLabel, float>> vMCRecInfo;
166 gsl::span<const MCCompLabel> vMCContLabels;
167 for (auto iRof{0}; iRof < trackROFspan.size(); ++iRof) {
168 bounded_vector<Vertex> vtxVecLoc;
169 auto& vtxROF = vertROFvec.emplace_back(trackROFspan[iRof]);
170 vtxROF.setFirstEntry(vertices.size());
171 if (mRunVertexer) {
172 auto vtxSpan = mTimeFrame->getPrimaryVertices(iRof);
173 if (mIsMC) {
174 vMCRecInfo = mTimeFrame->getPrimaryVerticesMCRecInfo(iRof);
175 if (o2::its::VertexerParamConfig::Instance().outputContLabels) {
176 vMCContLabels = mTimeFrame->getPrimaryVerticesContributors(iRof);
177 }
178 }
179 if (o2::its::TrackerParamConfig::Instance().doUPCIteration) {
180 if (!vtxSpan.empty()) {
181 if (vtxSpan[0].isFlagSet(Vertex::UPCMode) == 1) { // at least one vertex in this ROF and it is from second vertex iteration
182 LOGP(debug, "ROF {} rejected as vertices are from the UPC iteration", iRof);
183 processUPCMask[iRof] = true;
184 cutUPCVertex++;
185 vtxROF.setFlag(o2::itsmft::ROFRecord::VtxUPCMode);
186 } else { // in all cases except if as standard mode vertex was found, the ROF was processed with UPC settings
187 vtxROF.setFlag(o2::itsmft::ROFRecord::VtxStdMode);
188 }
189 } else {
190 vtxROF.setFlag(o2::itsmft::ROFRecord::VtxUPCMode);
191 }
192 } else {
193 vtxROF.setFlag(o2::itsmft::ROFRecord::VtxStdMode);
194 }
195 vtxROF.setNEntries(vtxSpan.size());
196 bool selROF = vtxSpan.empty();
197 for (int iV{0}, iVC{0}; iV < vtxSpan.size(); ++iV) {
198 const auto& v = vtxSpan[iV];
199 if (multEstConf.isVtxMultCutRequested() && !multEstConf.isPassingVtxMultCut(v.getNContributors())) {
200 iVC += v.getNContributors();
201 continue; // skip vertex of unwanted multiplicity
202 }
203 selROF = true;
204 vertices.push_back(v);
205 if (mIsMC && !VertexerParamConfig::Instance().useTruthSeeding) {
206 allVerticesLabels.push_back(vMCRecInfo[iV].first);
207 allVerticesPurities.push_back(vMCRecInfo[iV].second);
208 if (o2::its::VertexerParamConfig::Instance().outputContLabels) {
209 allVerticesContLabels.insert(allVerticesContLabels.end(), vMCContLabels.begin() + iVC, vMCContLabels.begin() + iVC + v.getNContributors());
210 }
211 }
212 iVC += v.getNContributors();
213 }
214 if (processingMask[iRof] && !selROF) { // passed selection in clusters and not in vertex multiplicity
215 LOGP(info, "ROF {} rejected by the vertex multiplicity selection [{},{}]", iRof, multEstConf.cutMultVtxLow, multEstConf.cutMultVtxHigh);
216 processingMask[iRof] = selROF;
217 cutVertexMult++;
218 }
219 } else { // cosmics
220 vtxVecLoc.emplace_back();
221 vtxVecLoc.back().setNContributors(1);
222 vtxROF.setNEntries(vtxVecLoc.size());
223 for (auto& v : vtxVecLoc) {
224 vertices.push_back(v);
225 }
226 mTimeFrame->addPrimaryVertices(vtxVecLoc, 0);
227 }
228 }
229 if (mRunVertexer) {
230 LOG(info) << fmt::format(" - Vertex seeding total elapsed time: {} ms for {} ({} + {}) vertices found in {}/{} ROFs",
231 vertexerElapsedTime,
235 trackROFspan.size() - mTimeFrame->getNoVertexROF(),
236 trackROFspan.size());
237 LOG(info) << fmt::format(" - FastMultEst: rejected {}/{} ROFs: random/mult.sel:{} (seed {}), vtx.sel:{}", cutRandomMult + cutVertexMult, trackROFspan.size(), cutRandomMult, multEst.lastRandomSeed, cutVertexMult);
238 }
239 if (mOverrideBeamEstimation) {
240 LOG(info) << fmt::format(" - Beam position set to: {}, {} from meanvertex object", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
241 } else {
242 LOG(info) << fmt::format(" - Beam position computed for the TF: {}, {}", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
243 }
244 if (mCosmicsProcessing && compClusters.size() > 1500 * trackROFspan.size()) {
245 LOG(error) << "Cosmics processing was requested with an average detector occupancy exceeding 1.e-7, skipping TF processing.";
246 } else {
247
248 mTimeFrame->setMultiplicityCutMask(processingMask);
249 mTimeFrame->setROFMask(processUPCMask);
250 // Run CA tracker
251 if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
252 mTracker->clustersToTracks(logger, fatalLogger);
253 } else {
254 mTracker->clustersToTracks(logger, errorLogger);
255 }
256 size_t totTracks{mTimeFrame->getNumberOfTracks()}, totClusIDs{mTimeFrame->getNumberOfUsedClusters()};
257 if (totTracks) {
258 allTracks.reserve(totTracks);
259 allClusIdx.reserve(totClusIDs);
260
262 LOG(warning) << fmt::format(" - The processed timeframe had {} clusters with wild z coordinates, check the dictionaries", mTimeFrame->hasBogusClusters());
263 }
264
265 for (unsigned int iROF{0}; iROF < trackROFvec.size(); ++iROF) {
266 auto& tracksROF{trackROFvec[iROF]};
267 auto& vtxROF = vertROFvec[iROF];
268 auto& tracks = mTimeFrame->getTracks(iROF);
269 auto number{tracks.size()};
270 auto first{allTracks.size()};
271 int offset = -tracksROF.getFirstEntry(); // cluster entry!!!
272 tracksROF.setFirstEntry(first);
273 tracksROF.setNEntries(number);
274 tracksROF.setFlags(vtxROF.getFlags()); // copies 0xffffffff if cosmics
275 if (processingMask[iROF]) {
276 irFrames.emplace_back(tracksROF.getBCData(), tracksROF.getBCData() + nBCPerTF - 1).info = tracks.size();
277 }
278 allTrackLabels.reserve(mTimeFrame->getTracksLabel(iROF).size()); // should be 0 if not MC
279 std::copy(mTimeFrame->getTracksLabel(iROF).begin(), mTimeFrame->getTracksLabel(iROF).end(), std::back_inserter(allTrackLabels));
280 // Some conversions that needs to be moved in the tracker internals
281 for (unsigned int iTrk{0}; iTrk < tracks.size(); ++iTrk) {
282 auto& trc{tracks[iTrk]};
283 trc.setFirstClusterEntry(allClusIdx.size()); // before adding tracks, create final cluster indices
284 int ncl = trc.getNumberOfClusters(), nclf = 0;
285 for (int ic = TrackITSExt::MaxClusters; ic--;) { // track internally keeps in->out cluster indices, but we want to store the references as out->in!!!
286 auto clid = trc.getClusterIndex(ic);
287 if (clid >= 0) {
288 trc.setClusterSize(ic, mTimeFrame->getClusterSize(clid));
289 allClusIdx.push_back(clid);
290 nclf++;
291 }
292 }
293 assert(ncl == nclf);
294 allTracks.emplace_back(trc);
295 }
296 }
297 } else {
298 for (auto& r : trackROFvec) { // reset data copied from the clusters
299 r.setFirstEntry(0);
300 r.setNEntries(0);
301 }
302 }
303 LOGP(info, "ITSTracker pushed {} tracks and {} vertices", allTracks.size(), vertices.size());
304 if (mIsMC) {
305 LOGP(info, "ITSTracker pushed {} track labels", allTrackLabels.size());
306 LOGP(info, "ITSTracker pushed {} vertex labels", allVerticesLabels.size());
307 if (!allVerticesContLabels.empty()) {
308 LOGP(info, "ITSTracker pushed {} vertex contributor labels", allVerticesContLabels.size());
309 }
310 LOGP(info, "ITSTracker pushed {} vertex purities", allVerticesPurities.size());
311 }
312 }
313 mTimeFrame->wipe();
314}
315
317{
319 static bool initOnceDone = false;
320 if (mOverrideBeamEstimation) {
322 }
323 if (!initOnceDone) { // this params need to be queried only once
324 initOnceDone = true;
325 pc.inputs().get<o2::itsmft::TopologyDictionary*>("itscldict"); // just to trigger the finaliseCCDB
327 if (pc.inputs().getPos("itsTGeo") >= 0) {
328 pc.inputs().get<o2::its::GeometryTGeo*>("itsTGeo");
329 }
332 initialise();
333
334 if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // print settings only for the 1st pipeling
337 const auto& vtxParams = mVertexer->getParameters();
338 for (size_t it = 0; it < vtxParams.size(); it++) {
339 const auto& par = vtxParams[it];
340 LOGP(info, "vtxIter#{} : {}", it, par.asString());
341 }
342 const auto& trParams = mTracker->getParameters();
343 for (size_t it = 0; it < trParams.size(); it++) {
344 const auto& par = trParams[it];
345 LOGP(info, "recoIter#{} : {}", it, par.asString());
346 }
347 }
348 }
349}
350
352{
354 return;
355 }
356 if (matcher == ConcreteDataMatcher("ITS", "CLUSDICT", 0)) {
357 LOG(info) << "cluster dictionary updated";
359 return;
360 }
361 // Note: strictly speaking, for Configurable params we don't need finaliseCCDB check, the singletons are updated at the CCDB fetcher level
362 if (matcher == ConcreteDataMatcher("ITS", "ALPIDEPARAM", 0)) {
363 LOG(info) << "Alpide param updated";
365 par.printKeyValues();
366 return;
367 }
368 if (matcher == ConcreteDataMatcher("GLO", "MEANVERTEX", 0)) {
369 LOGP(info, "Mean vertex acquired");
371 return;
372 }
373 if (matcher == ConcreteDataMatcher("ITS", "GEOMTGEO", 0)) {
374 LOG(info) << "ITS GeometryTGeo loaded from ccdb";
376 return;
377 }
378}
379
381{
382 mTracker->printSummary();
383}
384
386 TrackerTraits7* trackerTraits,
387 TimeFrame7* frame)
388{
389 mVertexer = std::make_unique<Vertexer>(vertexerTraits);
390 mTracker = std::make_unique<Tracker>(trackerTraits);
391 mTimeFrame = frame;
392 mVertexer->adoptTimeFrame(*mTimeFrame);
393 mTracker->adoptTimeFrame(*mTimeFrame);
394
395 // set common memory resource
396 if (!mMemoryPool) {
397 mMemoryPool = std::make_shared<BoundedMemoryResource>();
398 }
399 vertexerTraits->setMemoryPool(mMemoryPool);
400 trackerTraits->setMemoryPool(mMemoryPool);
401 mTimeFrame->setMemoryPool(mMemoryPool);
402 mTracker->setMemoryPool(mMemoryPool);
403 mVertexer->setMemoryPool(mMemoryPool);
404}
405
406void ITSTrackingInterface::loadROF(gsl::span<itsmft::ROFRecord>& trackROFspan,
407 gsl::span<const itsmft::CompClusterExt> clusters,
408 gsl::span<const unsigned char>::iterator& pattIt,
410{
411 mTimeFrame->loadROFrameData(trackROFspan, clusters, pattIt, mDict, mcLabels);
412}
Helper for geometry and GRP related CCDB requests.
Class to delimit start and end IR of certain time period.
Definition of the GeometryTGeo class.
Configuration parameters for ITS fast multiplicity estimator.
Fast multiplicity estimator for ITS.
Definition of the ITSMFT ROFrame (trigger) record.
Definition Physics trigger record extracted from the ITS/MFT stream.
std::ostringstream debug
void checkUpdates(o2::framework::ProcessingContext &pc)
static GRPGeomHelper & instance()
GPUd() value_type estimateLTFast(o2 static GPUd() float estimateLTIncrement(const o2 PropagatorImpl * Instance(bool uninitialized=false)
Definition Propagator.h:143
void printKeyValues(bool showProv=true, bool useLogger=false, bool withPadding=true, bool showHash=true) const final
A container to hold and manage MC truth information/labels.
static constexpr ID ITS
Definition DetID.h:63
void snapshot(const Output &spec, T const &object)
decltype(auto) make(const Output &spec, Args... args)
int getPos(const char *name) const
decltype(auto) get(R binding, int part=0) const
DataAllocator & outputs()
The data allocator is used to allocate memory for the output data.
InputRecord & inputs()
The inputs associated with this processing context.
ServiceRegistryRef services()
The services registry associated with this processing context.
static GeometryTGeo * Instance()
void fillMatrixCache(int mask) override
static void adopt(GeometryTGeo *raw, bool canDelete=false)
void run(framework::ProcessingContext &pc)
void setMeanVertex(const o2::dataformats::MeanVertexObject *v)
virtual void loadROF(gsl::span< itsmft::ROFRecord > &trackROFspan, gsl::span< const itsmft::CompClusterExt > clusters, gsl::span< const unsigned char >::iterator &pattIt, const dataformats::MCTruthContainer< MCCompLabel > *mcLabels)
void setClusterDictionary(const o2::itsmft::TopologyDictionary *d)
virtual void updateTimeDependentParams(framework::ProcessingContext &pc)
virtual void finaliseCCDB(framework::ConcreteDataMatcher &matcher, void *obj)
void setTraitsFromProvider(VertexerTraits *, TrackerTraits7 *, TimeFrame7 *)
static constexpr int MaxClusters
< heavy version of TrackITS, with clusters embedded
Definition TrackITS.h:169
void setMemoryPool(std::shared_ptr< BoundedMemoryResource > &pool) noexcept
void setMemoryPool(std::shared_ptr< BoundedMemoryResource > &pool)
const GLdouble * v
Definition glcorearb.h:832
GLintptr offset
Definition glcorearb.h:660
GLboolean r
Definition glcorearb.h:1233
Defining PrimaryVertex explicitly as messageable.
Definition TFIDInfo.h:20
auto get(const std::byte *buffer, size_t=0)
Definition DataHeader.h:454
std::vector< VertexingParameters > getVertexingParameters(Type mode)
std::string toString(Type mode)
std::vector< TrackingParameters > getTrackingParameters(Type mode)
std::pmr::vector< T > bounded_vector
std::vector< T, fair::mq::pmr::polymorphic_allocator< T > > vector
size_t inputTimesliceId
The time pipelining id of this particular device.
Definition DeviceSpec.h:68
uint32_t lastRandomSeed
number of layers actually used
Definition FastMultEst.h:41
int selectROFs(const gsl::span< const o2::itsmft::ROFRecord > rofs, const gsl::span< const o2::itsmft::CompClusterExt > clus, const gsl::span< const o2::itsmft::PhysTrigger > trig, std::vector< uint8_t > &sel)
gsl::span< const MCCompLabel > getPrimaryVerticesContributors(const int rofId) const
Definition TimeFrame.h:377
void addPrimaryVertices(const bounded_vector< Vertex > &vertices, const int iteration)
Definition TimeFrame.cxx:62
float getBeamX() const
Definition TimeFrame.h:111
auto & getTracks(int rofId)
Definition TimeFrame.h:173
size_t getNumberOfTracks() const
Definition TimeFrame.h:674
unsigned int & getNoVertexROF()
Definition TimeFrame.h:217
gsl::span< const std::pair< MCCompLabel, float > > getPrimaryVerticesMCRecInfo(const int rofId) const
Definition TimeFrame.h:368
virtual void wipe()
void setMultiplicityCutMask(const std::vector< uint8_t > &cutMask)
Definition TimeFrame.h:226
size_t getNumberOfUsedClusters() const
Definition TimeFrame.h:684
void setBeamPosition(const float x, const float y, const float s2, const float base=50.f, const float systematic=0.f)
Definition TimeFrame.h:105
auto & getTotVertIteration()
Definition TimeFrame.h:98
int getPrimaryVerticesNum(int rofId=-1) const
Definition TimeFrame.h:412
void setROFMask(const std::vector< uint8_t > &rofMask)
Definition TimeFrame.h:227
int loadROFrameData(const o2::itsmft::ROFRecord &rof, gsl::span< const itsmft::Cluster > clusters, const dataformats::MCTruthContainer< MCCompLabel > *mcLabels=nullptr)
gsl::span< const Vertex > getPrimaryVertices(int rofId) const
Definition TimeFrame.h:356
void setMemoryPool(std::shared_ptr< BoundedMemoryResource > &pool)
memory management
auto & getTracksLabel(const int rofId)
Definition TimeFrame.h:174
float getBeamY() const
Definition TimeFrame.h:112
int hasBogusClusters() const
Definition TimeFrame.h:230
int getClusterSize(int clusterId) const
Definition TimeFrame.h:142
static constexpr int T2L
Definition Cartesian.h:55
static constexpr int T2GRot
Definition Cartesian.h:57
static constexpr int T2G
Definition Cartesian.h:56
LOG(info)<< "Compressed in "<< sw.CpuTime()<< " s"
o2::InteractionRecord ir(0, 0)
std::vector< Cluster > clusters