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(), compClusters.empty() ? " -> received no processable data will skip" : "");
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 gsl::span<const itsmft::ROFRecord> trackROFspan(trackROFvec);
143 loadROF(trackROFspan, compClusters, pattIt, labels);
144 pattIt = patterns.begin();
145
146 auto logger = [&](const std::string& s) { LOG(info) << s; };
147 auto fatalLogger = [&](const std::string& s) { LOG(fatal) << s; };
148 auto errorLogger = [&](const std::string& s) { LOG(error) << s; };
149
150 FastMultEst multEst; // mult estimator
151 std::vector<uint8_t> processingMask, processUPCMask;
152 int cutVertexMult{0}, cutUPCVertex{0}, cutRandomMult = int(trackROFvec.size()) - multEst.selectROFs(trackROFvec, compClusters, physTriggers, processingMask);
153 processUPCMask.resize(processingMask.size(), false);
154 mTimeFrame->setMultiplicityCutMask(processingMask);
155 float vertexerElapsedTime{0.f};
156 if (mRunVertexer) {
157 vertROFvec.reserve(trackROFvec.size());
158 // Run seeding vertexer
159 if (!compClusters.empty()) {
160 vertexerElapsedTime = mVertexer->clustersToVertices(logger);
161 }
162 } else { // cosmics
164 }
165 const auto& multEstConf = FastMultEstConfig::Instance(); // parameters for mult estimation and cuts
166 gsl::span<const std::pair<MCCompLabel, float>> vMCRecInfo;
167 gsl::span<const MCCompLabel> vMCContLabels;
168 for (auto iRof{0}; iRof < trackROFspan.size(); ++iRof) {
169 bounded_vector<Vertex> vtxVecLoc;
170 auto& vtxROF = vertROFvec.emplace_back(trackROFspan[iRof]);
171 vtxROF.setFirstEntry(vertices.size());
172 if (mRunVertexer) {
173 auto vtxSpan = mTimeFrame->getPrimaryVertices(iRof);
174 if (mIsMC) {
175 vMCRecInfo = mTimeFrame->getPrimaryVerticesMCRecInfo(iRof);
176 if (o2::its::VertexerParamConfig::Instance().outputContLabels) {
177 vMCContLabels = mTimeFrame->getPrimaryVerticesContributors(iRof);
178 }
179 }
180 if (o2::its::TrackerParamConfig::Instance().doUPCIteration) {
181 if (!vtxSpan.empty()) {
182 if (vtxSpan[0].isFlagSet(Vertex::UPCMode) == 1) { // at least one vertex in this ROF and it is from second vertex iteration
183 LOGP(debug, "ROF {} rejected as vertices are from the UPC iteration", iRof);
184 processUPCMask[iRof] = true;
185 cutUPCVertex++;
186 vtxROF.setFlag(o2::itsmft::ROFRecord::VtxUPCMode);
187 } else { // in all cases except if as standard mode vertex was found, the ROF was processed with UPC settings
188 vtxROF.setFlag(o2::itsmft::ROFRecord::VtxStdMode);
189 }
190 } else {
191 vtxROF.setFlag(o2::itsmft::ROFRecord::VtxUPCMode);
192 }
193 } else {
194 vtxROF.setFlag(o2::itsmft::ROFRecord::VtxStdMode);
195 }
196 vtxROF.setNEntries(vtxSpan.size());
197 bool selROF = vtxSpan.empty();
198 for (int iV{0}, iVC{0}; iV < vtxSpan.size(); ++iV) {
199 const auto& v = vtxSpan[iV];
200 if (multEstConf.isVtxMultCutRequested() && !multEstConf.isPassingVtxMultCut(v.getNContributors())) {
201 iVC += v.getNContributors();
202 continue; // skip vertex of unwanted multiplicity
203 }
204 selROF = true;
205 vertices.push_back(v);
206 if (mIsMC && !VertexerParamConfig::Instance().useTruthSeeding) {
207 allVerticesLabels.push_back(vMCRecInfo[iV].first);
208 allVerticesPurities.push_back(vMCRecInfo[iV].second);
209 if (o2::its::VertexerParamConfig::Instance().outputContLabels) {
210 allVerticesContLabels.insert(allVerticesContLabels.end(), vMCContLabels.begin() + iVC, vMCContLabels.begin() + iVC + v.getNContributors());
211 }
212 }
213 iVC += v.getNContributors();
214 }
215 if (processingMask[iRof] && !selROF) { // passed selection in clusters and not in vertex multiplicity
216 LOGP(info, "ROF {} rejected by the vertex multiplicity selection [{},{}]", iRof, multEstConf.cutMultVtxLow, multEstConf.cutMultVtxHigh);
217 processingMask[iRof] = selROF;
218 cutVertexMult++;
219 }
220 } else { // cosmics
221 vtxVecLoc.emplace_back();
222 vtxVecLoc.back().setNContributors(1);
223 vtxROF.setNEntries(vtxVecLoc.size());
224 for (auto& v : vtxVecLoc) {
225 vertices.push_back(v);
226 }
227 mTimeFrame->addPrimaryVertices(vtxVecLoc, 0);
228 }
229 }
230 if (mRunVertexer && !compClusters.empty()) {
231 LOG(info) << fmt::format(" - Vertex seeding total elapsed time: {} ms for {} ({} + {}) vertices found in {}/{} ROFs",
232 vertexerElapsedTime,
236 trackROFspan.size() - mTimeFrame->getNoVertexROF(),
237 trackROFspan.size());
238 LOG(info) << fmt::format(" - FastMultEst: rejected {}/{} ROFs: random/mult.sel:{} (seed {}), vtx.sel:{}", cutRandomMult + cutVertexMult, trackROFspan.size(), cutRandomMult, multEst.lastRandomSeed, cutVertexMult);
239 }
240 if (mOverrideBeamEstimation) {
241 LOG(info) << fmt::format(" - Beam position set to: {}, {} from meanvertex object", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
242 } else {
243 LOG(info) << fmt::format(" - Beam position computed for the TF: {}, {}", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
244 }
245 if (mCosmicsProcessing && compClusters.size() > 1500 * trackROFspan.size()) {
246 LOG(error) << "Cosmics processing was requested with an average detector occupancy exceeding 1.e-7, skipping TF processing.";
247 } else {
248 if (!compClusters.empty()) {
249 mTimeFrame->setMultiplicityCutMask(processingMask);
250 mTimeFrame->setROFMask(processUPCMask);
251 // Run CA tracker
252 if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
253 mTracker->clustersToTracks(logger, fatalLogger);
254 } else {
255 mTracker->clustersToTracks(logger, errorLogger);
256 }
257 }
258 size_t totTracks{mTimeFrame->getNumberOfTracks()}, totClusIDs{mTimeFrame->getNumberOfUsedClusters()};
259 if (totTracks) {
260 allTracks.reserve(totTracks);
261 allClusIdx.reserve(totClusIDs);
262
264 LOG(warning) << fmt::format(" - The processed timeframe had {} clusters with wild z coordinates, check the dictionaries", mTimeFrame->hasBogusClusters());
265 }
266
267 for (unsigned int iROF{0}; iROF < trackROFvec.size(); ++iROF) {
268 auto& tracksROF{trackROFvec[iROF]};
269 auto& vtxROF = vertROFvec[iROF];
270 auto& tracks = mTimeFrame->getTracks(iROF);
271 auto number{tracks.size()};
272 auto first{allTracks.size()};
273 int offset = -tracksROF.getFirstEntry(); // cluster entry!!!
274 tracksROF.setFirstEntry(first);
275 tracksROF.setNEntries(number);
276 tracksROF.setFlags(vtxROF.getFlags()); // copies 0xffffffff if cosmics
277 if (processingMask[iROF]) {
278 irFrames.emplace_back(tracksROF.getBCData(), tracksROF.getBCData() + nBCPerTF - 1).info = tracks.size();
279 }
280 allTrackLabels.reserve(mTimeFrame->getTracksLabel(iROF).size()); // should be 0 if not MC
281 std::copy(mTimeFrame->getTracksLabel(iROF).begin(), mTimeFrame->getTracksLabel(iROF).end(), std::back_inserter(allTrackLabels));
282 // Some conversions that needs to be moved in the tracker internals
283 for (unsigned int iTrk{0}; iTrk < tracks.size(); ++iTrk) {
284 auto& trc{tracks[iTrk]};
285 trc.setFirstClusterEntry(allClusIdx.size()); // before adding tracks, create final cluster indices
286 int ncl = trc.getNumberOfClusters(), nclf = 0;
287 for (int ic = TrackITSExt::MaxClusters; ic--;) { // track internally keeps in->out cluster indices, but we want to store the references as out->in!!!
288 auto clid = trc.getClusterIndex(ic);
289 if (clid >= 0) {
290 trc.setClusterSize(ic, mTimeFrame->getClusterSize(clid));
291 allClusIdx.push_back(clid);
292 nclf++;
293 }
294 }
295 assert(ncl == nclf);
296 allTracks.emplace_back(trc);
297 }
298 }
299 } else {
300 for (auto& r : trackROFvec) { // reset data copied from the clusters
301 r.setFirstEntry(0);
302 r.setNEntries(0);
303 }
304 }
305 LOGP(info, "ITSTracker pushed {} tracks and {} vertices", allTracks.size(), vertices.size());
306 if (mIsMC) {
307 LOGP(info, "ITSTracker pushed {} track labels", allTrackLabels.size());
308 LOGP(info, "ITSTracker pushed {} vertex labels", allVerticesLabels.size());
309 if (!allVerticesContLabels.empty()) {
310 LOGP(info, "ITSTracker pushed {} vertex contributor labels", allVerticesContLabels.size());
311 }
312 LOGP(info, "ITSTracker pushed {} vertex purities", allVerticesPurities.size());
313 }
314 }
315 mTimeFrame->wipe();
316}
317
319{
321 static bool initOnceDone = false;
322 if (mOverrideBeamEstimation) {
324 }
325 if (!initOnceDone) { // this params need to be queried only once
326 initOnceDone = true;
327 pc.inputs().get<o2::itsmft::TopologyDictionary*>("itscldict"); // just to trigger the finaliseCCDB
329 if (pc.inputs().getPos("itsTGeo") >= 0) {
330 pc.inputs().get<o2::its::GeometryTGeo*>("itsTGeo");
331 }
334 initialise();
335
336 if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // print settings only for the 1st pipeling
339 const auto& vtxParams = mVertexer->getParameters();
340 for (size_t it = 0; it < vtxParams.size(); it++) {
341 const auto& par = vtxParams[it];
342 LOGP(info, "vtxIter#{} : {}", it, par.asString());
343 }
344 const auto& trParams = mTracker->getParameters();
345 for (size_t it = 0; it < trParams.size(); it++) {
346 const auto& par = trParams[it];
347 LOGP(info, "recoIter#{} : {}", it, par.asString());
348 }
349 }
350 }
351}
352
354{
356 return;
357 }
358 if (matcher == ConcreteDataMatcher("ITS", "CLUSDICT", 0)) {
359 LOG(info) << "cluster dictionary updated";
361 return;
362 }
363 // Note: strictly speaking, for Configurable params we don't need finaliseCCDB check, the singletons are updated at the CCDB fetcher level
364 if (matcher == ConcreteDataMatcher("ITS", "ALPIDEPARAM", 0)) {
365 LOG(info) << "Alpide param updated";
367 par.printKeyValues();
368 return;
369 }
370 if (matcher == ConcreteDataMatcher("GLO", "MEANVERTEX", 0)) {
371 LOGP(info, "Mean vertex acquired");
373 return;
374 }
375 if (matcher == ConcreteDataMatcher("ITS", "GEOMTGEO", 0)) {
376 LOG(info) << "ITS GeometryTGeo loaded from ccdb";
378 return;
379 }
380}
381
383{
384 mTracker->printSummary();
385}
386
388 TrackerTraitsN* trackerTraits,
389 TimeFrameN* frame)
390{
391 mVertexer = std::make_unique<VertexerN>(vertexerTraits);
392 mTracker = std::make_unique<TrackerN>(trackerTraits);
393 mTimeFrame = frame;
394 mVertexer->adoptTimeFrame(*mTimeFrame);
395 mTracker->adoptTimeFrame(*mTimeFrame);
396
397 // set common memory resource
398 if (!mMemoryPool) {
399 mMemoryPool = std::make_shared<BoundedMemoryResource>();
400 }
401 vertexerTraits->setMemoryPool(mMemoryPool);
402 trackerTraits->setMemoryPool(mMemoryPool);
403 mTimeFrame->setMemoryPool(mMemoryPool);
404 mTracker->setMemoryPool(mMemoryPool);
405 mVertexer->setMemoryPool(mMemoryPool);
406}
407
408void ITSTrackingInterface::loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
409 gsl::span<const itsmft::CompClusterExt> clusters,
410 gsl::span<const unsigned char>::iterator& pattIt,
412{
413 mTimeFrame->loadROFrameData(trackROFspan, clusters, pattIt, mDict, mcLabels);
414}
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:147
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< const 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(VertexerTraitsN *, TrackerTraitsN *, TimeFrameN *)
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:50
float getBeamX() const
Definition TimeFrame.h:116
auto & getTracks(int rofId)
Definition TimeFrame.h:178
size_t getNumberOfTracks() const
Definition TimeFrame.h:674
unsigned int & getNoVertexROF()
Definition TimeFrame.h:220
gsl::span< const std::pair< MCCompLabel, float > > getPrimaryVerticesMCRecInfo(const int rofId) const
Definition TimeFrame.h:368
virtual void wipe()
void setMemoryPool(std::shared_ptr< BoundedMemoryResource > pool)
memory management
void setMultiplicityCutMask(const std::vector< uint8_t > &cutMask)
Definition TimeFrame.h:229
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:110
auto & getTotVertIteration()
Definition TimeFrame.h:103
int getPrimaryVerticesNum(int rofId=-1) const
Definition TimeFrame.h:412
void setROFMask(const std::vector< uint8_t > &rofMask)
Definition TimeFrame.h:230
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
auto & getTracksLabel(const int rofId)
Definition TimeFrame.h:179
float getBeamY() const
Definition TimeFrame.h:117
int hasBogusClusters() const
Definition TimeFrame.h:233
int getClusterSize(int clusterId) const
Definition TimeFrame.h:147
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