Project
Loading...
Searching...
No Matches
SVStudy.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 <vector>
13#include <TStopwatch.h>
45#include "MathUtils/fit.h"
48// #include "GPUSettingsO2.h"
49#include "GPUParam.h"
50#include "GPUParam.inc"
51#include "GPUTPCGeometry.h"
52#include "GPUO2InterfaceRefit.h"
53#include "GPUO2InterfaceUtils.h"
54
55namespace o2::svstudy
56{
57
58using namespace o2::framework;
61
68
70
71class SVStudySpec : public Task
72{
73 public:
74 SVStudySpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool useTPCCl, bool useMC)
75 : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mUseTPCCl(useTPCCl), mUseMC(useMC) {}
76 ~SVStudySpec() final = default;
77 void init(InitContext& ic) final;
78 void run(ProcessingContext& pc) final;
79 void endOfStream(EndOfStreamContext& ec) final;
80 void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final;
81 void process(o2::globaltracking::RecoContainer& recoData);
82 o2::dataformats::V0Ext processV0(int iv, o2::globaltracking::RecoContainer& recoData);
83
84 private:
85 void updateTimeDependentParams(ProcessingContext& pc);
86 bool refitV0(const V0ID& id, o2::dataformats::V0& v0, o2::globaltracking::RecoContainer& recoData);
87 std::shared_ptr<DataRequest> mDataRequest;
88 std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
89 bool mUseMC{false};
90 std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOut;
91 float mSelK0 = -1;
92 bool mRefit = false;
93 bool mUseTPCCl = false;
94 float mMaxEta = 0.8;
95 float mBz = 0;
96 int mNHBPerTF = 0;
97 int mNTPCOccBinLength = 0;
98 float mNTPCOccBinLengthInv;
99 float mTPCTBinMUSInv = 0.f;
100 GTrackID::mask_t mTracksSrc{};
102 std::vector<float> mTBinClOccAft, mTBinClOccBef;
103 std::unique_ptr<o2::steer::MCKinematicsReader> mcReader; // reader of MC information
104 std::shared_ptr<o2::gpu::GPUParam> mParam = nullptr;
105};
106
108{
110 mDBGOut = std::make_unique<o2::utils::TreeStreamRedirector>("svStudy.root", "recreate");
111 mRefit = ic.options().get<bool>("refit");
112 mSelK0 = ic.options().get<float>("sel-k0");
113 mMaxEta = ic.options().get<float>("max-eta");
114 if (mUseMC) {
115 mcReader = std::make_unique<o2::steer::MCKinematicsReader>("collisioncontext.root");
116 }
117}
118
120{
122 recoData.collectData(pc, *mDataRequest.get()); // select tracks of needed type, with minimal cuts, the real selected will be done in the vertexer
123 updateTimeDependentParams(pc); // Make sure this is called after recoData.collectData, which may load some conditions
124
125 size_t occupancyMapSizeBytes = o2::gpu::GPUO2InterfaceRefit::fillOccupancyMapGetSize(mNHBPerTF, mParam.get());
126 gsl::span<const unsigned int> TPCRefitterOccMap = recoData.occupancyMapTPC;
127 o2::gpu::GPUO2InterfaceUtils::paramUseExternalOccupancyMap(mParam.get(), mNHBPerTF, TPCRefitterOccMap.data(), occupancyMapSizeBytes);
128
129 mTBinClOccBef.resize(1);
130 mTBinClOccAft.resize(1);
131 if (recoData.inputsTPCclusters && mUseTPCCl) {
132 mNTPCOccBinLength = mParam->rec.tpc.occupancyMapTimeBins;
133 mTBinClOccBef.clear();
134 mTBinClOccAft.clear();
135 // prepare TPC occupancy data
136 if (mNTPCOccBinLength > 1 && recoData.occupancyMapTPC.size()) {
137 mNTPCOccBinLengthInv = 1. / mNTPCOccBinLength;
138 int nTPCBins = mNHBPerTF * o2::constants::lhc::LHCMaxBunches / 8, ninteg = 0;
139 int nTPCOccBins = nTPCBins * mNTPCOccBinLengthInv, sumBins = std::max(1, int(o2::constants::lhc::LHCMaxBunches / 8 * mNTPCOccBinLengthInv));
140 mTBinClOccAft.resize(nTPCOccBins);
141 mTBinClOccBef.resize(nTPCOccBins);
142 float sm = 0., tb = 0.5 * mNTPCOccBinLength;
143 std::vector<float> mltHistTB(nTPCOccBins);
144 for (int i = 0; i < nTPCOccBins; i++) {
145 mltHistTB[i] = mParam->GetUnscaledMult(tb);
146 tb += mNTPCOccBinLength;
147 }
148 for (int i = nTPCOccBins; i--;) {
149 sm += mltHistTB[i];
150 if (i + sumBins < nTPCOccBins) {
151 sm -= mltHistTB[i + sumBins];
152 }
153 mTBinClOccAft[i] = sm;
154 }
155 sm = 0;
156 for (int i = 0; i < nTPCOccBins; i++) {
157 sm += mltHistTB[i];
158 if (i - sumBins > 0) {
159 sm -= mltHistTB[i - sumBins];
160 }
161 mTBinClOccBef[i] = sm;
162 }
163 }
164 }
165
166 process(recoData);
167}
168
169void SVStudySpec::updateTimeDependentParams(ProcessingContext& pc)
170{
172 static bool initOnceDone = false;
173 if (!initOnceDone) { // this params need to be queried only once
174 initOnceDone = true;
175 const auto& svparam = o2::vertexing::SVertexerParams::Instance();
176 // Note: reading of the ITS AlpideParam needed for ITS timing is done by the RecoContainer
177 mFitterV0.setBz(mBz);
178 mFitterV0.setUseAbsDCA(svparam.useAbsDCA);
179 mFitterV0.setPropagateToPCA(false);
180 mFitterV0.setMaxR(svparam.maxRIni);
181 mFitterV0.setMinParamChange(svparam.minParamChange);
182 mFitterV0.setMinRelChi2Change(svparam.minRelChi2Change);
183 mFitterV0.setMaxDZIni(svparam.maxDZIni);
184 mFitterV0.setMaxDXYIni(svparam.maxDXYIni);
185 mFitterV0.setMaxChi2(svparam.maxChi2);
186 mFitterV0.setMatCorrType(o2::base::Propagator::MatCorrType(svparam.matCorr));
187 mFitterV0.setUsePropagator(svparam.usePropagator);
188 mFitterV0.setRefitWithMatCorr(svparam.refitWithMatCorr);
189 mFitterV0.setMaxStep(svparam.maxStep);
190 mFitterV0.setMaxSnp(svparam.maxSnp);
191 mFitterV0.setMinXSeed(svparam.minXSeed);
192
193 mNHBPerTF = o2::base::GRPGeomHelper::instance().getGRPECS()->getNHBFPerTF();
194 if (!mParam) {
195 // for occupancy estimator
197 }
199 mTPCTBinMUSInv = 1. / elParam.ZbinWidth; // 1./TPC bin in microseconds
200 }
201 mBz = o2::base::Propagator::Instance()->getNominalBz();
202 mFitterV0.setBz(mBz);
203}
204
206{
208 auto invalidate = [&v0ext]() { v0ext.v0ID.setVertexID(-1); };
209
210 auto v0s = recoData.getV0s();
211 auto v0IDs = recoData.getV0sIdx();
212 static int tfID = 0;
213
214 const auto& v0id = v0IDs[iv];
215 if (mRefit && !refitV0(v0id, v0ext.v0, recoData)) {
216 invalidate();
217 return v0ext;
218 }
219 const auto& v0sel = mRefit ? v0ext.v0 : v0s[iv];
220 if (mMaxEta < std::abs(v0sel.getEta())) {
221 invalidate();
222 return v0ext;
223 }
224 if (mSelK0 > 0 && std::abs(std::sqrt(v0sel.calcMass2AsK0()) - 0.497) > mSelK0) {
225 invalidate();
226 return v0ext;
227 }
228 if (!mRefit) {
229 v0ext.v0 = v0sel;
230 }
231 v0ext.v0ID = v0id;
232 const auto clRefs = recoData.getTPCTracksClusterRefs();
233 o2::MCCompLabel lb[2];
234 const o2::MCTrack* mcTrks[2];
235 for (int ip = 0; ip < 2; ip++) {
236 auto& prInfo = v0ext.prInfo[ip];
237 auto gid = v0ext.v0ID.getProngID(ip);
238 auto gidset = recoData.getSingleDetectorRefs(gid);
239 lb[ip] = recoData.getTrackMCLabel(gid);
240 if (lb[ip].isValid()) {
241 prInfo.corrGlo = !lb[ip].isFake();
242 }
243 // get TPC tracks, if any
244 if (gidset[GTrackID::TPC].isSourceSet()) {
245 const auto& tpcTr = recoData.getTPCTrack(gidset[GTrackID::TPC]);
246 prInfo.trackTPC = tpcTr;
247 prInfo.nClTPC = tpcTr.getNClusters();
248 lb[ip] = recoData.getTrackMCLabel(gidset[GTrackID::TPC]);
249 if (lb[ip].isValid()) {
250 prInfo.corrTPC = !lb[ip].isFake();
251 }
252 if (mParam && mUseTPCCl) {
253 uint8_t clSect = 0, clRow = 0;
254 uint32_t clIdx = 0;
255 tpcTr.getClusterReference(clRefs, tpcTr.getNClusterReferences() - 1, clSect, clRow, clIdx);
256 const auto& clus = recoData.getTPCClusters().clusters[clSect][clRow][clIdx];
257 prInfo.lowestRow = clRow;
258 int npads = o2::gpu::GPUTPCGeometry::NPads(clRow);
259 prInfo.padFromEdge = uint8_t(clus.getPad());
260 if (prInfo.padFromEdge > npads / 2) {
261 prInfo.padFromEdge = npads - 1 - prInfo.padFromEdge;
262 }
263 }
264 }
265 // get ITS tracks, if any
266 if (gid.includesDet(DetID::ITS)) {
267 auto gidITS = recoData.getITSContributorGID(gid);
268 if (gidset[GTrackID::ITS].isSourceSet()) {
269 const auto& itsTr = recoData.getITSTrack(gidset[GTrackID::ITS]);
270 prInfo.nClITS = itsTr.getNClusters();
271 lb[ip] = recoData.getTrackMCLabel(gidset[GTrackID::ITS]);
272 if (lb[ip].isValid()) {
273 prInfo.corrITS = !lb[ip].isFake();
274 }
275 for (int il = 0; il < 7; il++) {
276 if (itsTr.hasHitOnLayer(il)) {
277 prInfo.pattITS |= 0x1 << il;
278 }
279 }
280 } else {
281 const auto& itsTrf = recoData.getITSABRefs()[gidset[GTrackID::ITSAB]];
282 prInfo.nClITS = itsTrf.getNClusters();
283 lb[ip] = recoData.getTrackMCLabel(gidset[GTrackID::ITSAB]);
284 if (lb[ip].isValid()) {
285 prInfo.corrITS = !lb[ip].isFake();
286 }
287 for (int il = 0; il < 7; il++) {
288 if (itsTrf.hasHitOnLayer(il)) {
289 prInfo.pattITS |= 0x1 << il;
290 }
291 }
292 prInfo.pattITS |= 0x1 << 31; // flag AB
293 }
294 if (gidset[GTrackID::ITSTPC].isSourceSet()) {
295 auto mtc = recoData.getTPCITSTrack(gidset[GTrackID::ITSTPC]);
296 lb[ip] = recoData.getTrackMCLabel(gidset[GTrackID::ITSTPC]);
297 prInfo.chi2ITSTPC = mtc.getChi2Match();
298 if (lb[ip].isValid()) {
299 prInfo.corrITSTPC = !lb[ip].isFake();
300 }
301 }
302 }
303 if (mUseMC && lb[ip].isValid()) { // temp store of mctrks
304 mcTrks[ip] = mcReader->getTrack(lb[ip]);
305 }
306 }
307 if (mUseMC && (mcTrks[0] != nullptr) && (mcTrks[1] != nullptr)) {
308 // check majority vote on mother particle otherwise leave pdg -1
309 if (lb[0].getSourceID() == lb[1].getSourceID() && lb[0].getEventID() == lb[1].getEventID() &&
310 mcTrks[0]->getMotherTrackId() == mcTrks[1]->getMotherTrackId() && mcTrks[0]->getMotherTrackId() >= 0) {
311 const auto mother = mcReader->getTrack(lb[0].getSourceID(), lb[0].getEventID(), mcTrks[0]->getMotherTrackId());
312 v0ext.mcPID = mother->GetPdgCode();
313 }
314 }
315 return v0ext;
316}
317
319{
320 auto v0IDs = recoData.getV0sIdx();
321 auto nv0 = v0IDs.size();
322 if (nv0 > recoData.getV0s().size()) {
323 mRefit = true;
324 }
325 std::map<int, std::vector<int>> pv2sv;
326 static int tfID = 0;
327 for (int iv = 0; iv < nv0; iv++) {
328 const auto v0id = v0IDs[iv];
329 pv2sv[v0id.getVertexID()].push_back(iv);
330 }
331 std::vector<o2::dataformats::V0Ext> v0extVec;
332 for (auto it : pv2sv) {
333 int pvID = it.first;
334 auto& vv = it.second;
335 if (pvID < 0 || vv.size() == 0) {
336 continue;
337 }
338 v0extVec.clear();
339 for (int iv0 : vv) {
340 auto v0ext = processV0(iv0, recoData);
341 if (v0ext.v0ID.getVertexID() < 0) {
342 continue;
343 }
344 v0extVec.push_back(v0ext);
345 }
346 if (v0extVec.size()) {
347 const auto& pv = recoData.getPrimaryVertex(pvID);
348 float tpcOccBef = 0., tpcOccAft = 0.;
349 int tb = pv.getTimeStamp().getTimeStamp() * mTPCTBinMUSInv * mNTPCOccBinLengthInv;
350 tpcOccBef = tb < 0 ? mTBinClOccBef[0] : (tb >= mTBinClOccBef.size() ? mTBinClOccBef.back() : mTBinClOccBef[tb]);
351 tpcOccAft = tb < 0 ? mTBinClOccAft[0] : (tb >= mTBinClOccAft.size() ? mTBinClOccAft.back() : mTBinClOccAft[tb]);
352
353 (*mDBGOut) << "v0"
354 << "orbit=" << recoData.startIR.orbit << "tfID=" << tfID << "tpcOccBef=" << tpcOccBef << "tpcOccAft=" << tpcOccAft
355 << "v0Ext=" << v0extVec
356 << "pv=" << pv
357 << "\n";
358 }
359 }
360 tfID++;
361}
362
363bool SVStudySpec::refitV0(const V0ID& id, o2::dataformats::V0& v0, o2::globaltracking::RecoContainer& recoData)
364{
365 auto seedP = recoData.getTrackParam(id.getProngID(0));
366 auto seedN = recoData.getTrackParam(id.getProngID(1));
367 bool isTPConly = (id.getProngID(0).getSource() == GTrackID::TPC) || (id.getProngID(1).getSource() == GTrackID::TPC);
368 const auto& svparam = o2::vertexing::SVertexerParams::Instance();
369 if (svparam.mTPCTrackPhotonTune && isTPConly) {
370 mFitterV0.setMaxDZIni(svparam.mTPCTrackMaxDZIni);
371 mFitterV0.setMaxDXYIni(svparam.mTPCTrackMaxDXYIni);
372 mFitterV0.setMaxChi2(svparam.mTPCTrackMaxChi2);
373 mFitterV0.setCollinear(true);
374 }
375 int nCand = mFitterV0.process(seedP, seedN);
376 if (svparam.mTPCTrackPhotonTune && isTPConly) { // restore
377 // Reset immediately to the defaults
378 mFitterV0.setMaxDZIni(svparam.maxDZIni);
379 mFitterV0.setMaxDXYIni(svparam.maxDXYIni);
380 mFitterV0.setMaxChi2(svparam.maxChi2);
381 mFitterV0.setCollinear(false);
382 }
383 if (nCand == 0) { // discard this pair
384 return false;
385 }
386 const int cand = 0;
387 if (!mFitterV0.isPropagateTracksToVertexDone(cand) && !mFitterV0.propagateTracksToVertex(cand)) {
388 return false;
389 }
390 const auto& trPProp = mFitterV0.getTrack(0, cand);
391 const auto& trNProp = mFitterV0.getTrack(1, cand);
392 std::array<float, 3> pP{}, pN{};
393 trPProp.getPxPyPzGlo(pP);
394 trNProp.getPxPyPzGlo(pN);
395 std::array<float, 3> pV0 = {pP[0] + pN[0], pP[1] + pN[1], pP[2] + pN[2]};
396 auto p2V0 = pV0[0] * pV0[0] + pV0[1] * pV0[1] + pV0[2] * pV0[2];
397 const auto& pv = recoData.getPrimaryVertex(id.getVertexID());
398 const auto v0XYZ = mFitterV0.getPCACandidatePos(cand);
399 float dx = v0XYZ[0] - pv.getX(), dy = v0XYZ[1] - pv.getY(), dz = v0XYZ[2] - pv.getZ(), prodXYZv0 = dx * pV0[0] + dy * pV0[1] + dz * pV0[2];
400 float cosPA = prodXYZv0 / std::sqrt((dx * dx + dy * dy + dz * dz) * p2V0);
401 new (&v0) o2::dataformats::V0(v0XYZ, pV0, mFitterV0.calcPCACovMatrixFlat(cand), trPProp, trNProp);
402 v0.setDCA(mFitterV0.getChi2AtPCACandidate(cand));
403 v0.setCosPA(cosPA);
404 return true;
405}
406
408{
409 mDBGOut.reset();
410}
411
413{
415 return;
416 }
417}
418
420{
421 std::vector<OutputSpec> outputs;
422 auto dataRequest = std::make_shared<DataRequest>();
423
424 dataRequest->requestTracks(srcTracks, useMC);
425 dataRequest->requestClusters(srcCls, false);
426 dataRequest->requestPrimaryVertices(useMC);
427 dataRequest->requestSecondaryVertices(useMC);
428 dataRequest->inputs.emplace_back("meanvtx", "GLO", "MEANVERTEX", 0, Lifetime::Condition, ccdbParamSpec("GLO/Calib/MeanVertex", {}, 1));
429 auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(true, // orbitResetTime
430 true, // GRPECS=true
431 false, // GRPLHCIF
432 true, // GRPMagField
433 true, // askMatLUT
435 dataRequest->inputs,
436 true);
437 bool useTPCcl = srcCls[GTrackID::TPC];
438 return DataProcessorSpec{
439 "sv-study",
440 dataRequest->inputs,
441 outputs,
442 AlgorithmSpec{adaptFromTask<SVStudySpec>(dataRequest, ggRequest, srcTracks, useTPCcl, useMC)},
443 Options{
444 {"refit", VariantType::Bool, false, {"refit SVertices"}},
445 {"sel-k0", VariantType::Float, -1.f, {"If positive, select K0s with this mass margin"}},
446 {"max-eta", VariantType::Float, 1.2f, {"Cut on track eta"}},
447 }};
448}
449
450} // namespace o2::svstudy
Defintions for N-prongs secondary vertex fit.
Wrapper container for different reconstructed object types.
Definition of the GeometryManager class.
Definition of the FIT RecPoints class.
int32_t i
Helper for geometry and GRP related CCDB requests.
Global index for barrel track: provides provenance (detectors combination), index in respective array...
Definition of the MCTrack class.
Utility functions for MC particles.
Definition of the Names Generator class.
Definition of the parameter class for the detector electronics.
Wrapper container for different reconstructed object types.
Configurable params for secondary vertexer.
Result of refitting TPC-ITS matched track.
Reference on ITS/MFT clusters set.
Referenc on track indices contributing to the vertex, with possibility chose tracks from specific sou...
bool isFake() const
Definition MCCompLabel.h:78
void checkUpdates(o2::framework::ProcessingContext &pc)
static GRPGeomHelper & instance()
void setRequest(std::shared_ptr< GRPGeomRequest > req)
GPUd() value_type estimateLTFast(o2 static GPUd() float estimateLTIncrement(const o2 PropagatorImpl * Instance(bool uninitialized=false)
Definition Propagator.h:143
void setDCA(float d)
Definition V0.h:47
Static class with identifiers, bitmasks and names for ALICE detectors.
Definition DetID.h:58
static constexpr ID ITS
Definition DetID.h:63
ConfigParamRegistry const & options()
Definition InitContext.h:33
static size_t fillOccupancyMapGetSize(uint32_t nHbfPerTf, const GPUParam *param=nullptr)
static void paramUseExternalOccupancyMap(GPUParam *param, uint32_t nHbfPerTf, const uint32_t *occupancymap, int32_t occupancyMapSize)
static std::shared_ptr< GPUParam > getFullParamShared(float solenoidBz, uint32_t nHbfPerTf=0, std::unique_ptr< GPUO2InterfaceConfiguration > *pConfiguration=nullptr, std::unique_ptr< GPUSettingsO2 > *pO2Settings=nullptr, bool *autoMaxTimeBin=nullptr)
void finaliseCCDB(ConcreteDataMatcher &matcher, void *obj) final
Definition SVStudy.cxx:412
SVStudySpec(std::shared_ptr< DataRequest > dr, std::shared_ptr< o2::base::GRPGeomRequest > gr, GTrackID::mask_t src, bool useTPCCl, bool useMC)
Definition SVStudy.cxx:74
o2::dataformats::V0Ext processV0(int iv, o2::globaltracking::RecoContainer &recoData)
Definition SVStudy.cxx:205
void init(InitContext &ic) final
Definition SVStudy.cxx:107
~SVStudySpec() final=default
void process(o2::globaltracking::RecoContainer &recoData)
Definition SVStudy.cxx:318
void endOfStream(EndOfStreamContext &ec) final
This is invoked whenever we have an EndOfStream event.
Definition SVStudy.cxx:407
void run(ProcessingContext &pc) final
Definition SVStudy.cxx:119
o2::gpu::gpustd::array< float, 6 > calcPCACovMatrixFlat(int cand=0) const
Definition DCAFitterN.h:196
Track & getTrack(int i, int cand=0)
Definition DCAFitterN.h:162
float getChi2AtPCACandidate(int cand=0) const
Definition DCAFitterN.h:148
GLenum src
Definition glcorearb.h:1767
GLfloat v0
Definition glcorearb.h:811
constexpr int LHCMaxBunches
Defining PrimaryVertex explicitly as messageable.
Definition TFIDInfo.h:20
std::vector< ConfigParamSpec > ccdbParamSpec(std::string const &path, int runDependent, std::vector< CCDBMetadata > metadata={}, int qrate=0)
std::vector< ConfigParamSpec > Options
detail::Bracket< float > Bracketf_t
Definition Primitive2D.h:40
o2::framework::DataProcessorSpec getSVStudySpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcCls, bool useMC)
create a processor spec
Definition SVStudy.cxx:419
a couple of static helper functions to create timestamp values for CCDB queries or override obsolete ...
Defining DataPointCompositeObject explicitly as copiable.
bool isValid(std::string alias)
uint32_t orbit
LHC orbit.
std::array< ProngInfoExt, 2 > prInfo
Definition V0Ext.h:41
GTrackID getITSContributorGID(GTrackID source) const
GlobalIDSet getSingleDetectorRefs(GTrackID gidx) const
const o2::tpc::TrackTPC & getTPCTrack(GTrackID id) const
const o2::tpc::ClusterNativeAccess & getTPCClusters() const
o2::MCCompLabel getTrackMCLabel(GTrackID id) const
const o2::track::TrackParCov & getTrackParam(GTrackID gidx) const
const o2::dataformats::TrackTPCITS & getTPCITSTrack(GTrackID gid) const
void collectData(o2::framework::ProcessingContext &pc, const DataRequest &request)
const o2::dataformats::PrimaryVertex & getPrimaryVertex(int i) const
const o2::its::TrackITS & getITSTrack(GTrackID gid) const
std::unique_ptr< o2::tpc::internal::getWorkflowTPCInput_ret > inputsTPCclusters
gsl::span< const unsigned int > occupancyMapTPC
externally set TPC clusters occupancy map
const ClusterNative * clusters[constants::MAXSECTOR][constants::MAXGLOBALPADROW]