Skip to content

Commit 6bdfb95

Browse files
AlexianLAlexianL
committed
add more event selection
1 parent 906581c commit 6bdfb95

File tree

1 file changed

+173
-44
lines changed

1 file changed

+173
-44
lines changed

‎PWGMM/Mult/Tasks/mftReassociationValidation.cxx‎

Lines changed: 173 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@
1616
#include "PWGMM/Mult/DataModel/bestCollisionTable.h"
1717

1818
#include "Common/CCDB/EventSelectionParams.h"
19+
#include "Common/CCDB/RCTSelectionFlags.h"
1920
#include "Common/Core/RecoDecay.h"
2021
#include "Common/DataModel/CollisionAssociationTables.h"
2122
#include "Common/DataModel/EventSelection.h"
@@ -57,9 +58,11 @@
5758
#include <cstdlib>
5859
#include <string>
5960
#include <string_view>
61+
#include <unordered_map>
6062
#include <vector>
6163

6264
using namespace o2;
65+
using namespace o2::aod::rctsel;
6366
using namespace o2::aod::track;
6467
using namespace o2::constants::math;
6568
using namespace o2::framework;
@@ -91,10 +94,20 @@ enum DataType {
9194
Mc
9295
};
9396

94-
enum EventSelectionStep {
95-
AllEvents = 0,
96-
AfterEventSelection,
97-
NEventSelectionSteps
97+
enum SpecificEventSelectionStep {
98+
AllEventsPrecise = 0,
99+
HasMcCollision,
100+
IsSel8,
101+
IsNoSameBunchPileup,
102+
IsGoodItsLayersAll,
103+
IsGoodZvtxFT0vsPV,
104+
IsNoCollInRofStandard,
105+
IsNoCollInRofStrict,
106+
IsNoCollInTimeRangeStandard,
107+
IsNoCollInTimeRangeStrict,
108+
IsNoHighMultCollInPrevRof,
109+
IsRctFlagChecked,
110+
NSpecificEventSelectionSteps
98111
};
99112

100113
enum MonteCarloEventSelectionStep {
@@ -180,6 +193,9 @@ enum MultiplicityEstimators {
180193

181194
static constexpr std::string_view WhatDataType[] = {"Data/", "MC/"};
182195
static constexpr std::string_view WhatMultiplicityEstimator[] = {"multNTracksPV", "multNumContrib", "multFT0C", "multFT0M"};
196+
std::unordered_map<int, float> recoVtxX;
197+
std::unordered_map<int, float> recoVtxY;
198+
std::unordered_map<int, float> recoVtxZ;
183199

184200
struct MftReassociationValidation {
185201

@@ -206,7 +222,17 @@ struct MftReassociationValidation {
206222
Configurable<int> minMultiplicity{"minMultiplicity", 0, "minimum multiplicity selection for collision"};
207223
Configurable<int> multiplicityEstimator{"multiplicityEstimator", 0, "0: multNTracksPV, 1: numContrib, 2: multFT0C, 3: multFT0M, 4: centFT0C, 5: centFT0CVariants1s, 6: centFT0M, 7: centFV0A, 8: centNTracksPV, 9: centNGlobal, 10: centMFT"};
208224
Configurable<bool> isApplyNoCollInTimeRangeStrict{"isApplyNoCollInTimeRangeStrict", false, ""};
225+
Configurable<bool> isApplyNoCollInTimeRangeStandard{"isApplyNoCollInTimeRangeStandard", false, ""};
226+
Configurable<bool> isApplyNoCollInRofStrict{"isApplyNoCollInRofStrict", false, ""};
227+
Configurable<bool> isApplyNoCollInRofStandard{"isApplyNoCollInRofStandard", false, ""};
228+
Configurable<bool> isApplyNoHighMultCollInPrevRof{"isApplyNoHighMultCollInPrevRof", false, ""};
209229
Configurable<float> zVertexMax{"zVertexMax", 10.0f, "Accepted z-vertex range"};
230+
Configurable<bool> requireRCTFlagChecker{"requireRCTFlagChecker", false, "Check event quality in run condition table"};
231+
Configurable<bool> requireCorrelationAnalysisRCTFlagChecker{"requireCorrelationAnalysisRCTFlagChecker", false, "Check event quality in run condition table for correlation analysis"};
232+
Configurable<std::string> setRCTFlagCheckerLabel{"setRCTFlagCheckerLabel", "CBT_muon_global", "Evt sel: RCT flag checker label"};
233+
Configurable<bool> requireRCTFlagCheckerLimitAcceptanceAsBad{"requireRCTFlagCheckerLimitAcceptanceAsBad", true, "Evt sel: RCT flag checker treat Limited Acceptance As Bad"};
234+
Configurable<bool> requireZDCCheck{"requireZDCCheck", false, "Evt sel: RCT flag checker ZDC check"};
235+
Configurable<std::string> rctFlagCheckerLabel{"rctFlagCheckerLabel", "CBT_fw", "Evt sel: RCT flag checker label"};
210236
} configCollision;
211237

212238
// configurables for MFT tracks
@@ -231,6 +257,8 @@ struct MftReassociationValidation {
231257
Service<o2::framework::O2DatabasePDG> pdg;
232258
Service<o2::ccdb::BasicCCDBManager> ccdb;
233259
o2::ccdb::CcdbApi ccdbApi;
260+
RCTFlagsChecker rctChecker;
261+
RCTFlagsChecker correlationAnalysisRctChecker{kFT0Bad, kITSBad, kTPCBadTracking, kMFTBad};
234262
std::array<std::shared_ptr<THnSparse>, MatchedToTrueCollisionStep::NMatchedToTrueCollisionSteps> hZVtxDiffAmbiguousTracks;
235263
std::array<std::shared_ptr<THnSparse>, MatchedToTrueCollisionStep::NMatchedToTrueCollisionSteps> hZVtxDiffNonAmbiguousTracks;
236264
std::array<std::shared_ptr<THnSparse>, MatchedToTrueCollisionStep::NMatchedToTrueCollisionSteps> hZVtxDiff2dReassociatedTracks;
@@ -454,6 +482,8 @@ struct MftReassociationValidation {
454482
ccdb->setCaching(true);
455483
ccdb->setLocalObjectValidityChecking();
456484
ccdb->setCreatedNotAfter(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
485+
rctChecker.init(configCollision.setRCTFlagCheckerLabel, configCollision.requireZDCCheck, configCollision.requireRCTFlagCheckerLimitAcceptanceAsBad);
486+
correlationAnalysisRctChecker.init({kFT0Bad, kITSBad, kTPCBadTracking, kMFTBad}, configCollision.requireZDCCheck, configCollision.requireRCTFlagCheckerLimitAcceptanceAsBad);
457487

458488
// =========================
459489
// Event histograms
@@ -463,14 +493,24 @@ struct MftReassociationValidation {
463493
// registry.add("Data/hNTracks", "", {HistType::kTH1F, {configAxis.axisMultiplicity}});
464494
registry.add(Form("Data/hMultiplicity_%s", WhatMultiplicityEstimator[configCollision.multiplicityEstimator].data()), "", {HistType::kTH1D, {configAxis.axisMultiplicity}});
465495

466-
registry.add("Data/hEventCounter", "hEventCounter", {HistType::kTH1D, {{EventSelectionStep::NEventSelectionSteps, -0.5, +EventSelectionStep::NEventSelectionSteps - 0.5}}});
467-
std::string labels[EventSelectionStep::NEventSelectionSteps];
468-
labels[EventSelectionStep::AllEvents] = "all";
469-
labels[EventSelectionStep::AfterEventSelection] = "after Physics selection";
470-
registry.get<TH1>(HIST("Data/hEventCounter"))->SetMinimum(0);
471-
472-
for (int iBin = 0; iBin < EventSelectionStep::NEventSelectionSteps; iBin++) {
473-
registry.get<TH1>(HIST("Data/hEventCounter"))->GetXaxis()->SetBinLabel(iBin + 1, labels[iBin].data());
496+
registry.add("hPreciseEventCounter", "hPreciseEventCounter", {HistType::kTH1D, {{SpecificEventSelectionStep::NSpecificEventSelectionSteps, -0.5, +SpecificEventSelectionStep::NSpecificEventSelectionSteps - 0.5}}});
497+
std::string labels[SpecificEventSelectionStep::NSpecificEventSelectionSteps];
498+
labels[SpecificEventSelectionStep::AllEventsPrecise] = "all";
499+
labels[SpecificEventSelectionStep::HasMcCollision] = "has MC coll?";
500+
labels[SpecificEventSelectionStep::IsSel8] = "sel8";
501+
labels[SpecificEventSelectionStep::IsNoSameBunchPileup] = "IsNoSameBunchPileup";
502+
labels[SpecificEventSelectionStep::IsGoodItsLayersAll] = "IsGoodItsLayersAll";
503+
labels[SpecificEventSelectionStep::IsGoodZvtxFT0vsPV] = "IsGoodZvtxFT0vsPV";
504+
labels[SpecificEventSelectionStep::IsNoCollInRofStandard] = "IsNoCollInRofStandard";
505+
labels[SpecificEventSelectionStep::IsNoCollInRofStrict] = "IsNoCollInRofStrict";
506+
labels[SpecificEventSelectionStep::IsNoCollInTimeRangeStandard] = "IsNoCollInTimeRangeStandard";
507+
labels[SpecificEventSelectionStep::IsNoCollInTimeRangeStrict] = "IsNoCollInTimeRangeStrict";
508+
labels[SpecificEventSelectionStep::IsNoHighMultCollInPrevRof] = "IsNoHighMultCollInPrevRof";
509+
labels[SpecificEventSelectionStep::IsRctFlagChecked] = "IsRctFlagChecked";
510+
registry.get<TH1>(HIST("hPreciseEventCounter"))->SetMinimum(0);
511+
512+
for (int iBin = 0; iBin < SpecificEventSelectionStep::NSpecificEventSelectionSteps; iBin++) {
513+
registry.get<TH1>(HIST("hPreciseEventCounter"))->GetXaxis()->SetBinLabel(iBin + 1, labels[iBin].data());
474514
}
475515

476516
registry.add("MC/hMonteCarloEventCounter", "hMonteCarloEventCounter", {HistType::kTH1D, {{MonteCarloEventSelectionStep::NMonteCarloEventSelectionSteps, -0.5, +MonteCarloEventSelectionStep::NMonteCarloEventSelectionSteps - 0.5}}});
@@ -573,28 +613,69 @@ struct MftReassociationValidation {
573613
template <typename TCollision>
574614
bool isAcceptedCollision(TCollision const& collision, bool fillHistograms = false)
575615
{
576-
if (fillHistograms) {
577-
registry.fill(HIST("Data/hEventCounter"), EventSelectionStep::AllEvents);
578-
}
579616

580617
if (!collision.sel8()) {
581618
return false;
582619
}
620+
if (fillHistograms) {
621+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::IsSel8);
622+
}
583623
if (configCollision.isApplySameBunchPileup && !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) {
584624
return false;
585625
}
626+
if (fillHistograms) {
627+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::IsNoSameBunchPileup);
628+
}
629+
if (configCollision.isApplyGoodItsLayersAll && !collision.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll)) {
630+
return false;
631+
}
632+
if (fillHistograms) {
633+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::IsGoodItsLayersAll);
634+
}
586635
if (configCollision.isApplyGoodZvtxFT0vsPV && !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) {
587636
return false;
588637
}
638+
if (fillHistograms) {
639+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::IsGoodZvtxFT0vsPV);
640+
}
641+
if (configCollision.isApplyNoCollInRofStandard && !collision.selection_bit(o2::aod::evsel::kNoCollInRofStandard)) {
642+
return false;
643+
}
644+
if (fillHistograms) {
645+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::IsNoCollInRofStandard);
646+
}
647+
if (configCollision.isApplyNoCollInRofStrict && !collision.selection_bit(o2::aod::evsel::kNoCollInRofStrict)) {
648+
return false;
649+
}
650+
if (fillHistograms) {
651+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::IsNoCollInRofStrict);
652+
}
653+
if (configCollision.isApplyNoCollInTimeRangeStandard && !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) {
654+
return false;
655+
}
656+
if (fillHistograms) {
657+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::IsNoCollInTimeRangeStandard);
658+
}
589659
if (configCollision.isApplyNoCollInTimeRangeStrict && !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStrict)) {
590660
return false;
591661
}
592-
if (configCollision.isApplyGoodItsLayersAll && !collision.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll)) {
662+
if (fillHistograms) {
663+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::IsNoCollInTimeRangeStrict);
664+
}
665+
if (configCollision.isApplyNoHighMultCollInPrevRof && !collision.selection_bit(o2::aod::evsel::kNoHighMultCollInPrevRof)) {
666+
return false;
667+
}
668+
if (fillHistograms) {
669+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::IsNoHighMultCollInPrevRof);
670+
}
671+
if (configCollision.requireRCTFlagChecker && !rctChecker(collision)) {
672+
return false;
673+
}
674+
if (configCollision.requireCorrelationAnalysisRCTFlagChecker && !correlationAnalysisRctChecker(collision)) {
593675
return false;
594676
}
595-
596677
if (fillHistograms) {
597-
registry.fill(HIST("Data/hEventCounter"), EventSelectionStep::AfterEventSelection);
678+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::IsRctFlagChecked);
598679
}
599680

600681
registry.fill(HIST("Data/hVtxZ"), collision.posZ());
@@ -677,6 +758,7 @@ struct MftReassociationValidation {
677758
soa::SmallGroups<aod::BestCollisionsFwd> const& reassociated2dMftTracks,
678759
aod::BCsWithTimestamps const&)
679760
{
761+
680762
if (!(isAcceptedCollision(collision, true))) {
681763
return;
682764
}
@@ -704,26 +786,42 @@ struct MftReassociationValidation {
704786
}
705787
PROCESS_SWITCH(MftReassociationValidation, processData, "Process MFT reassociation validation for DATA", false);
706788

789+
void processCreateLookupTable(FilteredCollisionsWSelMultMcLabels const& collisions)
790+
{
791+
recoVtxX.reserve(collisions.size());
792+
recoVtxY.reserve(collisions.size());
793+
recoVtxZ.reserve(collisions.size());
794+
795+
for (auto const& col : collisions) {
796+
recoVtxX.emplace(col.globalIndex(), col.posX());
797+
recoVtxY.emplace(col.globalIndex(), col.posY());
798+
recoVtxZ.emplace(col.globalIndex(), col.posZ());
799+
}
800+
}
801+
PROCESS_SWITCH(MftReassociationValidation, processCreateLookupTable, "Process look uptable creation", false);
802+
707803
void processMcReassociated2d(FilteredCollisionsWSelMultMcLabels::iterator const& collision,
708804
FilteredMftTracksWCollsMcLabels const& /*mftTracks*/,
709805
soa::SmallGroups<MftReasso2dTracksWCollsMcLabels> const& reassociated2dMftTracks,
710806
aod::McCollisions const& /*mcCollisions*/,
711807
aod::McParticles const& /*particles*/)
712808
{
713809
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::AllMonteCarloEvents);
810+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::AllEventsPrecise);
714811

715-
if (!isAcceptedCollision(collision, false)) {
812+
if (!collision.has_mcCollision()) {
813+
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::HasNotMonteCarloCollision);
716814
return;
717815
}
718816

719-
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::MonteCarloEventsAfterEventSelection);
817+
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::HasMonteCarloCollision);
818+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::HasMcCollision);
720819

721-
if (!collision.has_mcCollision()) {
722-
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::HasNotMonteCarloCollision);
820+
if (!isAcceptedCollision(collision, true)) {
723821
return;
724822
}
725823

726-
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::HasMonteCarloCollision);
824+
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::MonteCarloEventsAfterEventSelection);
727825

728826
for (auto const& reassociated2dMftTrack : reassociated2dMftTracks) {
729827

@@ -749,14 +847,42 @@ struct MftReassociationValidation {
749847
float reassociatedDeltaX = -999.f;
750848
float reassociatedDeltaY = -999.f;
751849
float reassociatedDeltaZ = -999.f;
752-
auto collision = templatedTrack.collision_as<FilteredCollisionsWSelMultMcLabels>();
753-
auto mcCollision = particle.mcCollision_as<aod::McCollisions>();
754-
deltaX = collision.posX() - mcCollision.posX();
755-
deltaY = collision.posY() - mcCollision.posY();
756-
deltaZ = collision.posZ() - mcCollision.posZ();
757-
reassociatedDeltaX = reassociated2dMftTrack.collision().posX() - mcCollision.posX();
758-
reassociatedDeltaY = reassociated2dMftTrack.collision().posY() - mcCollision.posY();
759-
reassociatedDeltaZ = reassociated2dMftTrack.collision().posZ() - mcCollision.posZ();
850+
// auto collision = templatedTrack.collision_as<FilteredCollisionsWSelMultMcLabels>();
851+
// auto mcCollision = particle.mcCollision_as<aod::McCollisions>();
852+
// deltaZ = collision.posZ() - mcCollision.posZ();
853+
auto xPosTrue = reassociated2dMftTrack.mcParticle().mcCollision().posX();
854+
auto yPosTrue = reassociated2dMftTrack.mcParticle().mcCollision().posY();
855+
auto zPosTrue = reassociated2dMftTrack.mcParticle().mcCollision().posZ();
856+
857+
const int bestRecoCol = reassociated2dMftTrack.bestCollisionId();
858+
// if (bestRecoCol < 0) {
859+
// // no associated reco collision -> skip or count separately
860+
// continue;
861+
// }
862+
863+
auto iteratorRecoVtxX = recoVtxX.find(bestRecoCol);
864+
auto iteratorRecoVtxY = recoVtxY.find(bestRecoCol);
865+
auto iteratorRecoVtxZ = recoVtxZ.find(bestRecoCol);
866+
if (iteratorRecoVtxX == recoVtxX.end()) {
867+
// bestRecoCol not found in reco collisions map -> skip or count separately
868+
continue;
869+
}
870+
if (iteratorRecoVtxY == recoVtxY.end()) {
871+
// bestRecoCol not found in reco collisions map -> skip or count separately
872+
continue;
873+
}
874+
if (iteratorRecoVtxZ == recoVtxZ.end()) {
875+
// bestRecoCol not found in reco collisions map -> skip or count separately
876+
continue;
877+
}
878+
879+
const float xReco = iteratorRecoVtxX->second;
880+
const float yReco = iteratorRecoVtxY->second;
881+
const float zReco = iteratorRecoVtxZ->second;
882+
883+
reassociatedDeltaX = xReco - xPosTrue;
884+
reassociatedDeltaY = yReco - yPosTrue;
885+
reassociatedDeltaZ = zReco - zPosTrue;
760886

761887
if (reassociated2dMftTrack.ambDegree() > 1) { // AMBIGUOUS TRACKS
762888
registry.fill(HIST("MC/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::NumberOfAmbiguousTracks);
@@ -830,19 +956,21 @@ struct MftReassociationValidation {
830956
aod::McParticles const& /*particles*/)
831957
{
832958
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::AllMonteCarloEvents);
959+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::AllEventsPrecise);
833960

834-
if (!isAcceptedCollision(collision, false)) {
961+
if (!collision.has_mcCollision()) {
962+
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::HasNotMonteCarloCollision);
835963
return;
836964
}
837965

838-
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::MonteCarloEventsAfterEventSelection);
966+
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::HasMonteCarloCollision);
967+
registry.fill(HIST("hPreciseEventCounter"), SpecificEventSelectionStep::HasMcCollision);
839968

840-
if (!collision.has_mcCollision()) {
841-
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::HasNotMonteCarloCollision);
969+
if (!isAcceptedCollision(collision, true)) {
842970
return;
843971
}
844972

845-
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::HasMonteCarloCollision);
973+
registry.fill(HIST("MC/hMonteCarloEventCounter"), MonteCarloEventSelectionStep::MonteCarloEventsAfterEventSelection);
846974

847975
for (auto const& reassociated3dMftTrack : reassociated3dMftTracks) {
848976

@@ -868,14 +996,15 @@ struct MftReassociationValidation {
868996
float reassociatedDeltaX = -999.f;
869997
float reassociatedDeltaY = -999.f;
870998
float reassociatedDeltaZ = -999.f;
871-
auto collision = templatedTrack.collision_as<FilteredCollisionsWSelMultMcLabels>();
872-
auto mcCollision = particle.mcCollision_as<aod::McCollisions>();
873-
deltaX = collision.posX() - mcCollision.posX();
874-
deltaY = collision.posY() - mcCollision.posY();
875-
deltaZ = collision.posZ() - mcCollision.posZ();
876-
reassociatedDeltaX = reassociated3dMftTrack.collision().posX() - mcCollision.posX();
877-
reassociatedDeltaY = reassociated3dMftTrack.collision().posY() - mcCollision.posY();
878-
reassociatedDeltaZ = reassociated3dMftTrack.collision().posZ() - mcCollision.posZ();
999+
// auto collision = templatedTrack.collision_as<FilteredCollisionsWSelMultMcLabels>();
1000+
// auto mcCollision = particle.mcCollision_as<aod::McCollisions>();
1001+
// deltaZ = collision.posZ() - mcCollision.posZ();
1002+
auto xPosTrue = reassociated3dMftTrack.mcParticle().mcCollision().posX();
1003+
auto yPosTrue = reassociated3dMftTrack.mcParticle().mcCollision().posY();
1004+
auto zPosTrue = reassociated3dMftTrack.mcParticle().mcCollision().posZ();
1005+
reassociatedDeltaX = reassociated3dMftTrack.collision().posX() - xPosTrue;
1006+
reassociatedDeltaY = reassociated3dMftTrack.collision().posY() - yPosTrue;
1007+
reassociatedDeltaZ = reassociated3dMftTrack.collision().posZ() - zPosTrue;
8791008

8801009
if (reassociated3dMftTrack.ambDegree() > 1) { // AMBIGUOUS TRACKS
8811010
registry.fill(HIST("MC/hAmbiguityOfMftTracks"), MftTrackAmbiguityStep::NumberOfAmbiguousTracks);

0 commit comments

Comments
 (0)