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
14
17
19#include <memory>
20
29
30using namespace o2::framework;
31using namespace o2::its;
32
34{
35 mRunVertexer = true;
36 mCosmicsProcessing = false;
37 std::vector<VertexingParameters> vertParams;
38 std::vector<TrackingParameters> trackParams;
39 const auto& vertConf = o2::its::VertexerParamConfig::Instance();
40 const auto& trackConf = o2::its::TrackerParamConfig::Instance();
41 float bFactor = std::abs(o2::base::Propagator::Instance()->getNominalBz()) / 5.0066791;
42 float bFactorTracklets = bFactor < 0.01 ? 1. : bFactor; // for tracklets only
43 if (mMode == TrackingMode::Unset) {
44 mMode = (TrackingMode)(trackConf.trackingMode);
45 LOGP(info, "Tracking mode not set, trying to fetch it from configurable params to: {}", asString(mMode));
46 }
47 if (mMode == TrackingMode::Async) {
48 trackParams.resize(trackConf.doUPCIteration ? 4 : 3);
49 vertParams.resize(2); // The number of actual iterations will be set as a configKeyVal to allow for pp/PbPb choice
50 trackParams[1].TrackletMinPt = 0.2f;
51 trackParams[1].CellDeltaTanLambdaSigma *= 2.;
52 trackParams[2].TrackletMinPt = 0.1f;
53 trackParams[2].CellDeltaTanLambdaSigma *= 4.;
54
55 trackParams[0].MinPt[0] = 1.f / 12; // 7cl
56
57 trackParams[1].MinPt[0] = 1.f / 12; // 7cl
58
59 trackParams[2].MinTrackLength = 4;
60 trackParams[2].MinPt[0] = 1.f / 12; // 7cl
61 trackParams[2].MinPt[1] = 1.f / 5; // 6cl
62 trackParams[2].MinPt[2] = 1.f / 1; // 5cl
63 trackParams[2].MinPt[3] = 1.f / 6; // 4cl
64
65 trackParams[2].StartLayerMask = (1 << 6) + (1 << 3);
67 trackParams[3].MinTrackLength = 4;
68 trackParams[3].TrackletMinPt = 0.1f;
69 trackParams[3].CellDeltaTanLambdaSigma *= 4.;
70 trackParams[3].DeltaROF = 0; // UPC specific setting
71 }
72 for (size_t ip = 0; ip < trackParams.size(); ip++) {
73 auto& param = trackParams[ip];
74 param.ZBins = 64;
75 param.PhiBins = 32;
76 param.CellsPerClusterLimit = 1.e3f;
77 param.TrackletsPerClusterLimit = 1.e3f;
78 // check if something was overridden via configurable params
79 if (ip < trackConf.MaxIter) {
80 if (trackConf.startLayerMask[ip] > 0) {
81 trackParams[2].StartLayerMask = trackConf.startLayerMask[ip];
82 }
83 if (trackConf.minTrackLgtIter[ip] > 0) {
84 param.MinTrackLength = trackConf.minTrackLgtIter[ip];
85 }
86 for (int ilg = trackConf.MaxTrackLength; ilg >= trackConf.MinTrackLength; ilg--) {
87 int lslot0 = (trackConf.MaxTrackLength - ilg), lslot = lslot0 + ip * (trackConf.MaxTrackLength - trackConf.MinTrackLength + 1);
88 if (trackConf.minPtIterLgt[lslot] > 0.) {
89 param.MinPt[lslot0] = trackConf.minPtIterLgt[lslot];
90 }
91 }
92 }
93 }
94 LOGP(info, "Initializing tracker in async. phase reconstruction with {} passes for tracking and {}/{} for vertexing", trackParams.size(), o2::its::VertexerParamConfig::Instance().nIterations, vertParams.size());
95 vertParams[1].phiCut = 0.015f;
96 vertParams[1].tanLambdaCut = 0.015f;
97 vertParams[1].vertPerRofThreshold = 0;
98 vertParams[1].deltaRof = 0;
99 } else if (mMode == TrackingMode::Sync) {
100 trackParams.resize(1);
101 trackParams[0].ZBins = 64;
102 trackParams[0].PhiBins = 32;
103 trackParams[0].MinTrackLength = 4;
104 LOGP(info, "Initializing tracker in sync. phase reconstruction with {} passes", trackParams.size());
105 vertParams.resize(1);
106 } else if (mMode == TrackingMode::Cosmics) {
107 mCosmicsProcessing = true;
108 mRunVertexer = false;
109 trackParams.resize(1);
110 trackParams[0].MinTrackLength = 4;
111 trackParams[0].CellDeltaTanLambdaSigma *= 10;
112 trackParams[0].PhiBins = 4;
113 trackParams[0].ZBins = 16;
114 trackParams[0].PVres = 1.e5f;
115 trackParams[0].MaxChi2ClusterAttachment = 60.;
116 trackParams[0].MaxChi2NDF = 40.;
117 trackParams[0].TrackletsPerClusterLimit = 100.;
118 trackParams[0].CellsPerClusterLimit = 100.;
119 LOGP(info, "Initializing tracker in reconstruction for cosmics with {} passes", trackParams.size());
120
121 } else {
122 throw std::runtime_error(fmt::format("Unsupported ITS tracking mode {:s} ", asString(mMode)));
123 }
124
125 // TODO this imposes the same memory limits on each iteration
126 for (auto& p : vertParams) {
127 p.PrintMemory = vertConf.printMemory;
128 p.MaxMemory = vertConf.maxMemory;
129 p.DropTFUponFailure = vertConf.dropTFUponFailure;
130 }
131 for (auto& p : trackParams) {
132 p.PrintMemory = trackConf.printMemory;
133 p.MaxMemory = trackConf.maxMemory;
134 p.DropTFUponFailure = trackConf.dropTFUponFailure;
135 }
136
137 for (auto& params : trackParams) {
139 }
140 // adjust pT settings to actual mag. field
141 for (size_t ip = 0; ip < trackParams.size(); ip++) {
142 auto& param = trackParams[ip];
143 param.TrackletMinPt *= bFactorTracklets;
144 for (int ilg = trackConf.MaxTrackLength; ilg >= trackConf.MinTrackLength; ilg--) {
145 int lslot = trackConf.MaxTrackLength - ilg;
146 param.MinPt[lslot] *= bFactor;
147 }
148 }
149 mTracker->setParameters(trackParams);
150 mVertexer->setParameters(vertParams);
151}
152
154{
155 auto compClusters = pc.inputs().get<gsl::span<o2::itsmft::CompClusterExt>>("compClusters");
156 gsl::span<const unsigned char> patterns = pc.inputs().get<gsl::span<unsigned char>>("patterns");
157 gsl::span<const o2::itsmft::PhysTrigger> physTriggers;
158 std::vector<o2::itsmft::PhysTrigger> fromTRD;
159 if (mUseTriggers == 2) { // use TRD triggers
161 auto trdTriggers = pc.inputs().get<gsl::span<o2::trd::TriggerRecord>>("phystrig");
162 for (const auto& trig : trdTriggers) {
163 if (trig.getBCData() >= ir && trig.getNumberOfTracklets()) {
164 ir = trig.getBCData();
165 fromTRD.emplace_back(o2::itsmft::PhysTrigger{ir, 0});
166 }
167 }
168 physTriggers = gsl::span<const o2::itsmft::PhysTrigger>(fromTRD.data(), fromTRD.size());
169 } else if (mUseTriggers == 1) { // use Phys triggers from ITS stream
170 physTriggers = pc.inputs().get<gsl::span<o2::itsmft::PhysTrigger>>("phystrig");
171 }
172
173 auto rofsinput = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>("ROframes");
174 auto& trackROFvec = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{"ITS", "ITSTrackROF", 0}, rofsinput.begin(), rofsinput.end());
175 auto& irFrames = pc.outputs().make<std::vector<o2::dataformats::IRFrame>>(Output{"ITS", "IRFRAMES", 0});
176 const auto& alpParams = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance(); // RS: this should come from CCDB
177
178 irFrames.reserve(trackROFvec.size());
179 int nBCPerTF = alpParams.roFrameLengthInBC;
180
181 LOGP(info, "ITSTracker pulled {} clusters, {} RO frames", compClusters.size(), trackROFvec.size());
182 const dataformats::MCTruthContainer<MCCompLabel>* labels = nullptr;
183 gsl::span<itsmft::MC2ROFRecord const> mc2rofs;
184 if (mIsMC) {
185 labels = pc.inputs().get<const dataformats::MCTruthContainer<MCCompLabel>*>("itsmclabels").release();
186 // get the array as read-only span, a snapshot is sent forward
187 pc.outputs().snapshot(Output{"ITS", "ITSTrackMC2ROF", 0}, pc.inputs().get<gsl::span<itsmft::MC2ROFRecord>>("ITSMC2ROframes"));
188 LOG(info) << labels->getIndexedSize() << " MC label objects , in " << mc2rofs.size() << " MC events";
189 }
190
191 auto& allClusIdx = pc.outputs().make<std::vector<int>>(Output{"ITS", "TRACKCLSID", 0});
192 auto& allTracks = pc.outputs().make<std::vector<o2::its::TrackITS>>(Output{"ITS", "TRACKS", 0});
193 auto& vertROFvec = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{"ITS", "VERTICESROF", 0});
194 auto& vertices = pc.outputs().make<std::vector<Vertex>>(Output{"ITS", "VERTICES", 0});
195
196 // MC
197 static pmr::vector<o2::MCCompLabel> dummyMCLabTracks, dummyMCLabVerts;
198 static pmr::vector<float> dummyMCPurVerts;
199 auto& allTrackLabels = mIsMC ? pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{"ITS", "TRACKSMCTR", 0}) : dummyMCLabTracks;
200 auto& allVerticesLabels = mIsMC ? pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{"ITS", "VERTICESMCTR", 0}) : dummyMCLabVerts;
201 auto& allVerticesPurities = mIsMC ? pc.outputs().make<std::vector<float>>(Output{"ITS", "VERTICESMCPUR", 0}) : dummyMCPurVerts;
202
203 std::uint32_t roFrame = 0;
204
205 bool continuous = o2::base::GRPGeomHelper::instance().getGRPECS()->isDetContinuousReadOut(o2::detectors::DetID::ITS);
206 LOG(info) << "ITSTracker RO: continuous=" << continuous;
207
208 if (mOverrideBeamEstimation) {
209 mTimeFrame->setBeamPosition(mMeanVertex->getX(),
210 mMeanVertex->getY(),
211 mMeanVertex->getSigmaY2(),
212 mTracker->getParameters()[0].LayerResolution[0],
213 mTracker->getParameters()[0].SystErrorY2[0]);
214 }
215
216 mTracker->setBz(o2::base::Propagator::Instance()->getNominalBz());
217
218 gsl::span<const unsigned char>::iterator pattIt = patterns.begin();
219
220 gsl::span<itsmft::ROFRecord> trackROFspan(trackROFvec);
221 loadROF(trackROFspan, compClusters, pattIt, labels);
222 pattIt = patterns.begin();
223 std::vector<int> savedROF;
224 auto logger = [&](const std::string& s) { LOG(info) << s; };
225 auto fatalLogger = [&](const std::string& s) { LOG(fatal) << s; };
226 auto errorLogger = [&](const std::string& s) { LOG(error) << s; };
227
228 FastMultEst multEst; // mult estimator
229 std::vector<uint8_t> processingMask, processUPCMask;
230 int cutVertexMult{0}, cutUPCVertex{0}, cutRandomMult = int(trackROFvec.size()) - multEst.selectROFs(trackROFvec, compClusters, physTriggers, processingMask);
231 processUPCMask.resize(processingMask.size(), false);
232 mTimeFrame->setMultiplicityCutMask(processingMask);
233 float vertexerElapsedTime{0.f};
234 if (mRunVertexer) {
235 vertROFvec.reserve(trackROFvec.size());
236 // Run seeding vertexer
237 vertexerElapsedTime = mVertexer->clustersToVertices(logger);
238 } else { // cosmics
240 }
241 const auto& multEstConf = FastMultEstConfig::Instance(); // parameters for mult estimation and cuts
242 gsl::span<const std::pair<MCCompLabel, float>> vMCRecInfo;
243 for (auto iRof{0}; iRof < trackROFspan.size(); ++iRof) {
244 std::vector<Vertex> vtxVecLoc;
245 auto& vtxROF = vertROFvec.emplace_back(trackROFspan[iRof]);
246 vtxROF.setFirstEntry(vertices.size());
247 if (mRunVertexer) {
248 auto vtxSpan = mTimeFrame->getPrimaryVertices(iRof);
249 if (mIsMC) {
250 vMCRecInfo = mTimeFrame->getPrimaryVerticesMCRecInfo(iRof);
251 }
252 if (o2::its::TrackerParamConfig::Instance().doUPCIteration) {
253 if (!vtxSpan.empty()) {
254 if (vtxSpan[0].isFlagSet(Vertex::UPCMode) == 1) { // at least one vertex in this ROF and it is from second vertex iteration
255 LOGP(debug, "ROF {} rejected as vertices are from the UPC iteration", iRof);
256 processUPCMask[iRof] = true;
257 cutUPCVertex++;
258 vtxROF.setFlag(o2::itsmft::ROFRecord::VtxUPCMode);
259 } else { // in all cases except if as standard mode vertex was found, the ROF was processed with UPC settings
260 vtxROF.setFlag(o2::itsmft::ROFRecord::VtxStdMode);
261 }
262 } else {
263 vtxROF.setFlag(o2::itsmft::ROFRecord::VtxUPCMode);
264 }
265 } else {
266 vtxROF.setFlag(o2::itsmft::ROFRecord::VtxStdMode);
267 }
268 vtxROF.setNEntries(vtxSpan.size());
269 bool selROF = vtxSpan.empty();
270 for (auto iV{0}; iV < vtxSpan.size(); ++iV) {
271 auto& v = vtxSpan[iV];
272 if (multEstConf.isVtxMultCutRequested() && !multEstConf.isPassingVtxMultCut(v.getNContributors())) {
273 continue; // skip vertex of unwanted multiplicity
274 }
275 selROF = true;
276 vertices.push_back(v);
277 if (mIsMC) {
278 allVerticesLabels.push_back(vMCRecInfo[iV].first);
279 allVerticesPurities.push_back(vMCRecInfo[iV].second);
280 }
281 }
282 if (processingMask[iRof] && !selROF) { // passed selection in clusters and not in vertex multiplicity
283 LOGP(info, "ROF {} rejected by the vertex multiplicity selection [{},{}]", iRof, multEstConf.cutMultVtxLow, multEstConf.cutMultVtxHigh);
284 processingMask[iRof] = selROF;
285 cutVertexMult++;
286 }
287 } else { // cosmics
288 vtxVecLoc.emplace_back();
289 vtxVecLoc.back().setNContributors(1);
290 vtxROF.setNEntries(vtxVecLoc.size());
291 for (auto& v : vtxVecLoc) {
292 vertices.push_back(v);
293 }
294 mTimeFrame->addPrimaryVertices(vtxVecLoc, iRof, 0);
295 }
296 }
297 if (mRunVertexer) {
298 LOG(info) << fmt::format(" - Vertex seeding total elapsed time: {} ms for {} ({} + {}) vertices found in {}/{} ROFs",
299 vertexerElapsedTime,
303 trackROFspan.size() - mTimeFrame->getNoVertexROF(),
304 trackROFspan.size());
305 LOG(info) << fmt::format(" - FastMultEst: rejected {}/{} ROFs: random/mult.sel:{} (seed {}), vtx.sel:{}", cutRandomMult + cutVertexMult, trackROFspan.size(), cutRandomMult, multEst.lastRandomSeed, cutVertexMult);
306 }
307 if (mOverrideBeamEstimation) {
308 LOG(info) << fmt::format(" - Beam position set to: {}, {} from meanvertex object", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
309 } else {
310 LOG(info) << fmt::format(" - Beam position computed for the TF: {}, {}", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
311 }
312 if (mCosmicsProcessing && compClusters.size() > 1500 * trackROFspan.size()) {
313 LOG(error) << "Cosmics processing was requested with an average detector occupancy exceeding 1.e-7, skipping TF processing.";
314 } else {
315
316 mTimeFrame->setMultiplicityCutMask(processingMask);
317 mTimeFrame->setROFMask(processUPCMask);
318 // Run CA tracker
319 if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
320 mTracker->clustersToTracks(logger, fatalLogger);
321 } else {
322 mTracker->clustersToTracks(logger, errorLogger);
323 }
324 size_t totTracks{mTimeFrame->getNumberOfTracks()}, totClusIDs{mTimeFrame->getNumberOfUsedClusters()};
325 allTracks.reserve(totTracks);
326 allClusIdx.reserve(totClusIDs);
327
329 LOG(warning) << fmt::format(" - The processed timeframe had {} clusters with wild z coordinates, check the dictionaries", mTimeFrame->hasBogusClusters());
330 }
331
332 for (unsigned int iROF{0}; iROF < trackROFvec.size(); ++iROF) {
333 auto& tracksROF{trackROFvec[iROF]};
334 auto& vtxROF = vertROFvec[iROF];
335 auto& tracks = mTimeFrame->getTracks(iROF);
336 auto number{tracks.size()};
337 auto first{allTracks.size()};
338 int offset = -tracksROF.getFirstEntry(); // cluster entry!!!
339 tracksROF.setFirstEntry(first);
340 tracksROF.setNEntries(number);
341 tracksROF.setFlags(vtxROF.getFlags()); // copies 0xffffffff if cosmics
342 if (processingMask[iROF]) {
343 irFrames.emplace_back(tracksROF.getBCData(), tracksROF.getBCData() + nBCPerTF - 1).info = tracks.size();
344 }
345 allTrackLabels.reserve(mTimeFrame->getTracksLabel(iROF).size()); // should be 0 if not MC
346 std::copy(mTimeFrame->getTracksLabel(iROF).begin(), mTimeFrame->getTracksLabel(iROF).end(), std::back_inserter(allTrackLabels));
347 // Some conversions that needs to be moved in the tracker internals
348 for (unsigned int iTrk{0}; iTrk < tracks.size(); ++iTrk) {
349 auto& trc{tracks[iTrk]};
350 trc.setFirstClusterEntry(allClusIdx.size()); // before adding tracks, create final cluster indices
351 int ncl = trc.getNumberOfClusters(), nclf = 0;
352 for (int ic = TrackITSExt::MaxClusters; ic--;) { // track internally keeps in->out cluster indices, but we want to store the references as out->in!!!
353 auto clid = trc.getClusterIndex(ic);
354 if (clid >= 0) {
355 trc.setClusterSize(ic, mTimeFrame->getClusterSize(clid));
356 allClusIdx.push_back(clid);
357 nclf++;
358 }
359 }
360 assert(ncl == nclf);
361 allTracks.emplace_back(trc);
362 }
363 }
364 LOGP(info, "ITSTracker pushed {} tracks and {} vertices", allTracks.size(), vertices.size());
365 if (mIsMC) {
366 LOGP(info, "ITSTracker pushed {} track labels", allTrackLabels.size());
367 LOGP(info, "ITSTracker pushed {} vertex labels", allVerticesLabels.size());
368 LOGP(info, "ITSTracker pushed {} vertex purities", allVerticesPurities.size());
369 }
370 }
371}
372
374{
376 static bool initOnceDone = false;
377 if (mOverrideBeamEstimation) {
379 }
380 if (!initOnceDone) { // this params need to be queried only once
381 initOnceDone = true;
382 pc.inputs().get<o2::itsmft::TopologyDictionary*>("itscldict"); // just to trigger the finaliseCCDB
384 if (pc.inputs().getPos("itsTGeo") >= 0) {
385 pc.inputs().get<o2::its::GeometryTGeo*>("itsTGeo");
386 }
389 initialise();
391
392 if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // print settings only for the 1st pipeling
395 const auto& vtxParams = mVertexer->getParameters();
396 for (size_t it = 0; it < vtxParams.size(); it++) {
397 const auto& par = vtxParams[it];
398 LOGP(info, "vtxIter#{} : {}", it, par.asString());
399 }
400 const auto& trParams = mTracker->getParameters();
401 for (size_t it = 0; it < trParams.size(); it++) {
402 const auto& par = trParams[it];
403 LOGP(info, "recoIter#{} : {}", it, par.asString());
404 }
405 }
406 }
407}
408
410{
411 mVertexer->getGlobalConfiguration();
412 mTracker->getGlobalConfiguration();
413}
414
416{
418 return;
419 }
420 if (matcher == ConcreteDataMatcher("ITS", "CLUSDICT", 0)) {
421 LOG(info) << "cluster dictionary updated";
423 return;
424 }
425 // Note: strictly speaking, for Configurable params we don't need finaliseCCDB check, the singletons are updated at the CCDB fetcher level
426 if (matcher == ConcreteDataMatcher("ITS", "ALPIDEPARAM", 0)) {
427 LOG(info) << "Alpide param updated";
429 par.printKeyValues();
430 return;
431 }
432 if (matcher == ConcreteDataMatcher("GLO", "MEANVERTEX", 0)) {
433 LOGP(info, "Mean vertex acquired");
435 return;
436 }
437 if (matcher == ConcreteDataMatcher("ITS", "GEOMTGEO", 0)) {
438 LOG(info) << "ITS GeometryTGeo loaded from ccdb";
440 return;
441 }
442}
443
445{
446 mMemoryPool->print();
447 mTracker->printSummary();
448}
449
451 TrackerTraits7* trackerTraits,
452 TimeFrame7* frame)
453{
454 mVertexer = std::make_unique<Vertexer>(vertexerTraits);
455 mTracker = std::make_unique<Tracker>(trackerTraits);
456 mTimeFrame = frame;
457 mVertexer->adoptTimeFrame(*mTimeFrame);
458 mTracker->adoptTimeFrame(*mTimeFrame);
459
460 // set common memory resource
461 if (!mMemoryPool) {
462 mMemoryPool = std::make_shared<BoundedMemoryResource>();
463 }
464 vertexerTraits->setMemoryPool(mMemoryPool);
465 trackerTraits->setMemoryPool(mMemoryPool);
466 mTimeFrame->setMemoryPool(mMemoryPool);
467 mTracker->setMemoryPool(mMemoryPool);
468 mVertexer->setMemoryPool(mMemoryPool);
469}
470
471void ITSTrackingInterface::loadROF(gsl::span<itsmft::ROFRecord>& trackROFspan,
472 gsl::span<const itsmft::CompClusterExt> clusters,
473 gsl::span<const unsigned char>::iterator& pattIt,
475{
476 mTimeFrame->loadROFrameData(trackROFspan, clusters, pattIt, mDict, mcLabels);
477}
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)
void getConfiguration(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
GLenum const GLfloat * params
Definition glcorearb.h:272
GLintptr offset
Definition glcorearb.h:660
GLenum GLfloat param
Definition glcorearb.h:271
Defining PrimaryVertex explicitly as messageable.
Definition TFIDInfo.h:20
auto get(const std::byte *buffer, size_t=0)
Definition DataHeader.h:454
std::string asString(TrackingMode mode)
std::vector< T, o2::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)
float getBeamX() const
Definition TimeFrame.h:109
auto & getTracks(int rofId)
Definition TimeFrame.h:171
size_t getNumberOfTracks() const
Definition TimeFrame.h:651
unsigned int & getNoVertexROF()
Definition TimeFrame.h:215
gsl::span< const std::pair< MCCompLabel, float > > getPrimaryVerticesMCRecInfo(const int rofId) const
Definition TimeFrame.h:362
void setMultiplicityCutMask(const std::vector< uint8_t > &cutMask)
Definition TimeFrame.h:224
size_t getNumberOfUsedClusters() const
Definition TimeFrame.h:661
void setBeamPosition(const float x, const float y, const float s2, const float base=50.f, const float systematic=0.f)
Definition TimeFrame.h:103
auto & getTotVertIteration()
Definition TimeFrame.h:96
int getPrimaryVerticesNum(int rofId=-1) const
Definition TimeFrame.h:389
void setROFMask(const std::vector< uint8_t > &rofMask)
Definition TimeFrame.h:225
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:350
void setMemoryPool(std::shared_ptr< BoundedMemoryResource > &pool)
memory management
auto & getTracksLabel(const int rofId)
Definition TimeFrame.h:172
float getBeamY() const
Definition TimeFrame.h:110
int hasBogusClusters() const
Definition TimeFrame.h:228
int getClusterSize(int clusterId) const
Definition TimeFrame.h:140
void addPrimaryVertices(const bounded_vector< Vertex > &vertices)
Definition TimeFrame.cxx:72
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