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