diff --git a/PWGLF/DataModel/LFStrangenessTables.h b/PWGLF/DataModel/LFStrangenessTables.h index 56322a0e47c..ec7412e9556 100644 --- a/PWGLF/DataModel/LFStrangenessTables.h +++ b/PWGLF/DataModel/LFStrangenessTables.h @@ -58,8 +58,8 @@ enum EventSelectionFlags { kNsel // counter }; -DECLARE_SOA_COLUMN(TotalNbrOfCollisions, totalNbrOfCollisions, int); //! total number of analysed collisions -DECLARE_SOA_COLUMN(TotalNbrOfSelCollisions, totalNbrOfSelCollisions, int); //! total number of selected collisions +DECLARE_SOA_COLUMN(TotalNbrOfCollisions, totalNbrOfCollisions, int); //! total number of analysed collisions +DECLARE_SOA_COLUMN(TotalNbrOfSelCollisions, totalNbrOfSelCollisions, int); //! total number of selected collisions DECLARE_SOA_COLUMN(TotalIsTriggerTVXCollisions, totalIsTriggerTVXCollisions, int); //! N selected collisions after applying IsTriggerTVX DECLARE_SOA_COLUMN(TotalNoITSROFBorderCollisions, totalNoITSROFBorderCollisions, int); //! N selected collisions after applying IsTriggerTVX, NoITSROF DECLARE_SOA_COLUMN(TotalNoTFBorderCollisions, totalNoTFBorderCollisions, int); //! N selected collisions after applying IsTriggerTVX, NoITSROF, NoTF diff --git a/PWGLF/TableProducer/Common/lfTPCPID.cxx b/PWGLF/TableProducer/Common/lfTPCPID.cxx index d84c977c101..15529a63b8f 100644 --- a/PWGLF/TableProducer/Common/lfTPCPID.cxx +++ b/PWGLF/TableProducer/Common/lfTPCPID.cxx @@ -203,7 +203,7 @@ struct bbParams { void setValues(TList* l) { const char* bbname = Form("BBParameter_%s", name.c_str()); - TH1F* h = static_cast(l->FindObject(bbname)); + TH1F* h = dynamic_cast(l->FindObject(bbname)); if (!h) { l->ls(); LOG(fatal) << "bbParams `" << name << "` :: did not find BetheBloch parametrization " << bbname << " in the input list"; @@ -237,9 +237,9 @@ struct bbParams { } else { TString cn = obj->ClassName(); if (cn.Contains("TF1")) { - postCorrectionFun = static_cast(l->FindObject(obj->GetName())); + postCorrectionFun = dynamic_cast(l->FindObject(obj->GetName())); } else if (cn.Contains("TGraph")) { - postCorrection = static_cast(l->FindObject(obj->GetName())); + postCorrection = dynamic_cast(l->FindObject(obj->GetName())); } else { LOG(fatal) << "Cannot hanlde class " << cn << " for post calib object " << objname; } @@ -255,9 +255,9 @@ struct bbParams { } else { TString cn = obj->ClassName(); if (cn.Contains("TF1")) { - postCorrectionFunSigma = static_cast(l->FindObject(obj->GetName())); + postCorrectionFunSigma = dynamic_cast(l->FindObject(obj->GetName())); } else if (cn.Contains("TGraph")) { - postCorrectionSigma = static_cast(l->FindObject(obj->GetName())); + postCorrectionSigma = dynamic_cast(l->FindObject(obj->GetName())); } else { LOG(fatal) << "Cannot hanlde class " << cn << " for post calib sigma object " << objname; } @@ -349,7 +349,7 @@ struct bbParams { if (!f->IsOpen()) { LOG(fatal) << "The input file " << f->GetName() << " is not open"; } - TList* l = static_cast(f->Get("ccdb_object")); + TList* l = dynamic_cast(f->Get("ccdb_object")); if (!l) { f->ls(); LOG(fatal) << "The input file " << post << " does not contain the TList ccdb_object"; diff --git a/PWGLF/TableProducer/Nuspex/he3HadronFemto.cxx b/PWGLF/TableProducer/Nuspex/he3HadronFemto.cxx index c90bc73c6cb..f7f538c1f56 100644 --- a/PWGLF/TableProducer/Nuspex/he3HadronFemto.cxx +++ b/PWGLF/TableProducer/Nuspex/he3HadronFemto.cxx @@ -1407,7 +1407,7 @@ struct he3HadronFemto { he3Hadcand.flags |= Flags::kMixedPair; } - LOG(info) << "He3 flags: " << int(he3Hadcand.flagsHe3) << ", Hadron flags: " << int(he3Hadcand.flagsHad) << ", Pair flags: " << int(he3Hadcand.flags); + LOG(info) << "He3 flags: " << static_cast(he3Hadcand.flagsHe3) << ", Hadron flags: " << static_cast(he3Hadcand.flagsHad) << ", Pair flags: " << static_cast(he3Hadcand.flags); if (!settingFillPrimariesMc && (he3Hadcand.flags == Flags::kBothPrimaries)) { continue; } diff --git a/PWGLF/TableProducer/Nuspex/hypKfRecoTask.cxx b/PWGLF/TableProducer/Nuspex/hypKfRecoTask.cxx index c164f9233ca..0a1017a351b 100644 --- a/PWGLF/TableProducer/Nuspex/hypKfRecoTask.cxx +++ b/PWGLF/TableProducer/Nuspex/hypKfRecoTask.cxx @@ -254,8 +254,8 @@ struct HyperNucleus { } return vec; }; - const char* motherName() { return name.Contains("->") ? ((TString)name(0, name.First("-"))).Data() : name.Data(); } - const char* daughterNames() { return name.Contains("->") ? ((TString)name(name.First("-") + 2, name.Length())).Data() : ""; } + const char* motherName() { return name.Contains("->") ? (TString(name(0, name.First("-")))).Data() : name.Data(); } + const char* daughterNames() { return name.Contains("->") ? (TString(name(name.First("-") + 2, name.Length()))).Data() : ""; } }; // struct HyperNucleus struct DaughterKf { diff --git a/PWGLF/TableProducer/Nuspex/nucleiSpectra.cxx b/PWGLF/TableProducer/Nuspex/nucleiSpectra.cxx index 17dcdd62ec5..f64e5a7a2d6 100644 --- a/PWGLF/TableProducer/Nuspex/nucleiSpectra.cxx +++ b/PWGLF/TableProducer/Nuspex/nucleiSpectra.cxx @@ -513,7 +513,7 @@ struct nucleiSpectra { ccdb->setLocalObjectValidityChecking(); ccdb->setFatalWhenNull(false); - const AxisSpec centAxis{cfgCentralityBins, fmt::format("{} percentile", (std::string)nuclei::centDetectorNames[cfgCentralityEstimator])}; + const AxisSpec centAxis{cfgCentralityBins, fmt::format("{} percentile", std::string(nuclei::centDetectorNames[cfgCentralityEstimator]))}; const AxisSpec nSigmaAxes[2]{{cfgNsigmaTPCbins, "n#sigma_{TPC}"}, {cfgNsigmaTOFbins, "n#sigma_{TOF}"}}; const AxisSpec tofMassAxis{cfgTOFmassBins, "TOF mass - PDG mass"}; const AxisSpec ptResAxis{cfgMomResBins, "#Delta#it{p}_{T}/#it{p}_{T}"}; @@ -1181,7 +1181,7 @@ struct nucleiSpectra { track.itsChi2NCl() > cfgTrackCut.ITSchi2ClusMax) { continue; } - double expBethe{common::BetheBlochAleph(static_cast(track.tpcInnerParam() * 2. / o2::constants::physics::MassHelium3), cfgBetheBlochParams->get(4, 0u), cfgBetheBlochParams->get(4, 1u), cfgBetheBlochParams->get(4, 2u), cfgBetheBlochParams->get(4, 3u), cfgBetheBlochParams->get(4, 4u))}; + double expBethe{common::BetheBlochAleph((track.tpcInnerParam() * 2. / o2::constants::physics::MassHelium3), cfgBetheBlochParams->get(4, 0u), cfgBetheBlochParams->get(4, 1u), cfgBetheBlochParams->get(4, 2u), cfgBetheBlochParams->get(4, 3u), cfgBetheBlochParams->get(4, 4u))}; double expSigma{expBethe * cfgBetheBlochParams->get(4, 5u)}; double nSigmaTPC{(track.tpcSignal() - expBethe) / expSigma}; int iC = track.signed1Pt() > 0; diff --git a/PWGLF/TableProducer/Nuspex/threebodymcfinder.cxx b/PWGLF/TableProducer/Nuspex/threebodymcfinder.cxx index 4c2c2dc2ef3..812a7044561 100644 --- a/PWGLF/TableProducer/Nuspex/threebodymcfinder.cxx +++ b/PWGLF/TableProducer/Nuspex/threebodymcfinder.cxx @@ -69,8 +69,8 @@ struct threebodymcfinder { void init(InitContext&) { // initialize histograms - const AxisSpec axisNTimesCollRecoed{(int)10, -0.5f, +9.5f, ""}; - const AxisSpec axisPt{(int)100, +0.0f, +10.0f, "p_{T} (GeV/c)"}; + const AxisSpec axisNTimesCollRecoed{10, -0.5f, +9.5f, ""}; + const AxisSpec axisPt{100, +0.0f, +10.0f, "p_{T} (GeV/c)"}; histos.add("hNTimesCollRecoed", "hNTimesCollRecoed", kTH1F, {axisNTimesCollRecoed}); histos.add("hNDaughters", "hNDaughters", kTH1F, {axisNTimesCollRecoed}); diff --git a/PWGLF/TableProducer/QC/flowQC.cxx b/PWGLF/TableProducer/QC/flowQC.cxx index 6c9606bdef2..218f7c82c84 100644 --- a/PWGLF/TableProducer/QC/flowQC.cxx +++ b/PWGLF/TableProducer/QC/flowQC.cxx @@ -178,7 +178,7 @@ struct flowQC { const AxisSpec centFT0mAxis{cfgCentralityBins, "FT0M percentile"}; const AxisSpec centFV0aAxis{cfgCentralityBins, "FV0A percentile"}; - const AxisSpec centAxis{cfgCentralityBins, fmt::format("{} percentile", (std::string)centDetectorNames[cfgCentralityEstimator])}; + const AxisSpec centAxis{cfgCentralityBins, fmt::format("{} percentile", std::string(centDetectorNames[cfgCentralityEstimator]))}; const char* qLabel = cfgQuadraticResponse ? "Q^{2}" : "Q"; diff --git a/PWGLF/TableProducer/Resonances/cksspinalignment.cxx b/PWGLF/TableProducer/Resonances/cksspinalignment.cxx index 8a62bb13ad4..f916fd116bf 100644 --- a/PWGLF/TableProducer/Resonances/cksspinalignment.cxx +++ b/PWGLF/TableProducer/Resonances/cksspinalignment.cxx @@ -468,8 +468,8 @@ struct cksspinalignment { auto postrack = v0.template posTrack_as(); auto negtrack = v0.template negTrack_as(); - const auto posId = static_cast(postrack.globalIndex()); - const auto negId = static_cast(negtrack.globalIndex()); + const auto posId = postrack.globalIndex(); + const auto negId = negtrack.globalIndex(); ROOT::Math::PxPyPzMVector pionPos(v0.pxpos(), v0.pypos(), v0.pzpos(), o2::constants::physics::MassPionCharged); ROOT::Math::PxPyPzMVector pionNeg(v0.pxneg(), v0.pyneg(), v0.pzneg(), o2::constants::physics::MassPionCharged); @@ -485,8 +485,8 @@ struct cksspinalignment { static_cast(k0s.M()), static_cast(v0.v0cosPA()), static_cast(v0.v0radius()), - static_cast(std::abs(v0.dcapostopv())), - static_cast(std::abs(v0.dcanegtopv())), + std::abs(v0.dcapostopv()), + std::abs(v0.dcanegtopv()), // static_cast(std::abs(v0.dcaV0daughters())), // lifetime, posId, diff --git a/PWGLF/TableProducer/Resonances/resonanceInitializer.cxx b/PWGLF/TableProducer/Resonances/resonanceInitializer.cxx index f1ab80425f5..39dbbfe769f 100644 --- a/PWGLF/TableProducer/Resonances/resonanceInitializer.cxx +++ b/PWGLF/TableProducer/Resonances/resonanceInitializer.cxx @@ -255,8 +255,8 @@ struct ResonanceInitializer { EventPlaneHelper helperEP; - int evtPlRefAId = static_cast(cfgEvtPl / 10000); - int evtPlRefBId = static_cast((cfgEvtPl - evtPlRefAId * 10000) / 100); + int evtPlRefAId = (cfgEvtPl / 10000); + int evtPlRefBId = ((cfgEvtPl - evtPlRefAId * 10000) / 100); int evtPlDetId = cfgEvtPl - evtPlRefAId * 10000 - evtPlRefBId * 100; // MC Resonance parent filter @@ -793,18 +793,18 @@ struct ResonanceInitializer { v0.py(), v0.pz(), childIDs, - (int8_t)(v0.template posTrack_as().tpcNSigmaPi() * 10), - (int8_t)(v0.template posTrack_as().tpcNSigmaKa() * 10), - (int8_t)(v0.template posTrack_as().tpcNSigmaPr() * 10), - (int8_t)(v0.template negTrack_as().tpcNSigmaPi() * 10), - (int8_t)(v0.template negTrack_as().tpcNSigmaKa() * 10), - (int8_t)(v0.template negTrack_as().tpcNSigmaPr() * 10), - (int8_t)(v0.template negTrack_as().tofNSigmaPi() * 10), - (int8_t)(v0.template negTrack_as().tofNSigmaKa() * 10), - (int8_t)(v0.template negTrack_as().tofNSigmaPr() * 10), - (int8_t)(v0.template posTrack_as().tofNSigmaPi() * 10), - (int8_t)(v0.template posTrack_as().tofNSigmaKa() * 10), - (int8_t)(v0.template posTrack_as().tofNSigmaPr() * 10), + static_cast(v0.template posTrack_as().tpcNSigmaPi() * 10), + static_cast(v0.template posTrack_as().tpcNSigmaKa() * 10), + static_cast(v0.template posTrack_as().tpcNSigmaPr() * 10), + static_cast(v0.template negTrack_as().tpcNSigmaPi() * 10), + static_cast(v0.template negTrack_as().tpcNSigmaKa() * 10), + static_cast(v0.template negTrack_as().tpcNSigmaPr() * 10), + static_cast(v0.template negTrack_as().tofNSigmaPi() * 10), + static_cast(v0.template negTrack_as().tofNSigmaKa() * 10), + static_cast(v0.template negTrack_as().tofNSigmaPr() * 10), + static_cast(v0.template posTrack_as().tofNSigmaPi() * 10), + static_cast(v0.template posTrack_as().tofNSigmaKa() * 10), + static_cast(v0.template posTrack_as().tofNSigmaPr() * 10), v0.v0cosPA(), v0.dcaV0daughters(), v0.dcapostopv(), @@ -845,24 +845,24 @@ struct ResonanceInitializer { casc.py(), casc.pz(), childIDs, - (int8_t)(casc.template posTrack_as().tpcNSigmaPi() * 10), - (int8_t)(casc.template posTrack_as().tpcNSigmaKa() * 10), - (int8_t)(casc.template posTrack_as().tpcNSigmaPr() * 10), - (int8_t)(casc.template negTrack_as().tpcNSigmaPi() * 10), - (int8_t)(casc.template negTrack_as().tpcNSigmaKa() * 10), - (int8_t)(casc.template negTrack_as().tpcNSigmaPr() * 10), - (int8_t)(casc.template bachelor_as().tpcNSigmaPi() * 10), - (int8_t)(casc.template bachelor_as().tpcNSigmaKa() * 10), - (int8_t)(casc.template bachelor_as().tpcNSigmaPr() * 10), - (int8_t)(casc.template posTrack_as().tofNSigmaPi() * 10), - (int8_t)(casc.template posTrack_as().tofNSigmaKa() * 10), - (int8_t)(casc.template posTrack_as().tofNSigmaPr() * 10), - (int8_t)(casc.template negTrack_as().tofNSigmaPi() * 10), - (int8_t)(casc.template negTrack_as().tofNSigmaKa() * 10), - (int8_t)(casc.template negTrack_as().tofNSigmaPr() * 10), - (int8_t)(casc.template bachelor_as().tofNSigmaPi() * 10), - (int8_t)(casc.template bachelor_as().tofNSigmaKa() * 10), - (int8_t)(casc.template bachelor_as().tofNSigmaPr() * 10), + static_cast(casc.template posTrack_as().tpcNSigmaPi() * 10), + static_cast(casc.template posTrack_as().tpcNSigmaKa() * 10), + static_cast(casc.template posTrack_as().tpcNSigmaPr() * 10), + static_cast(casc.template negTrack_as().tpcNSigmaPi() * 10), + static_cast(casc.template negTrack_as().tpcNSigmaKa() * 10), + static_cast(casc.template negTrack_as().tpcNSigmaPr() * 10), + static_cast(casc.template bachelor_as().tpcNSigmaPi() * 10), + static_cast(casc.template bachelor_as().tpcNSigmaKa() * 10), + static_cast(casc.template bachelor_as().tpcNSigmaPr() * 10), + static_cast(casc.template posTrack_as().tofNSigmaPi() * 10), + static_cast(casc.template posTrack_as().tofNSigmaKa() * 10), + static_cast(casc.template posTrack_as().tofNSigmaPr() * 10), + static_cast(casc.template negTrack_as().tofNSigmaPi() * 10), + static_cast(casc.template negTrack_as().tofNSigmaKa() * 10), + static_cast(casc.template negTrack_as().tofNSigmaPr() * 10), + static_cast(casc.template bachelor_as().tofNSigmaPi() * 10), + static_cast(casc.template bachelor_as().tofNSigmaKa() * 10), + static_cast(casc.template bachelor_as().tofNSigmaPr() * 10), casc.v0cosPA(collision.posX(), collision.posY(), collision.posZ()), casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()), casc.dcaV0daughters(), diff --git a/PWGLF/TableProducer/Resonances/resonanceMergeDF.cxx b/PWGLF/TableProducer/Resonances/resonanceMergeDF.cxx index 1c544ab1874..318c69cd435 100644 --- a/PWGLF/TableProducer/Resonances/resonanceMergeDF.cxx +++ b/PWGLF/TableProducer/Resonances/resonanceMergeDF.cxx @@ -96,7 +96,7 @@ struct ResonanceMergeDF { uint8_t>>> vecOfVecOfTuples; std::vector(track.tpcNClsCrossedRows()), + static_cast(track.tpcNClsFound()), static_cast(track.dcaXY() * 10000), static_cast(track.dcaZ() * 10000), - (int8_t)(track.tpcNSigmaPi() * 10), - (int8_t)(track.tpcNSigmaKa() * 10), - (int8_t)(track.tpcNSigmaPr() * 10), - (int8_t)(track.tofNSigmaPi() * 10), - (int8_t)(track.tofNSigmaKa() * 10), - (int8_t)(track.tofNSigmaPr() * 10), + static_cast(track.tpcNSigmaPi() * 10), + static_cast(track.tpcNSigmaKa() * 10), + static_cast(track.tpcNSigmaPr() * 10), + static_cast(track.tofNSigmaPi() * 10), + static_cast(track.tofNSigmaKa() * 10), + static_cast(track.tofNSigmaPr() * 10), static_cast(track.tpcSignal() * 100), track.trackFlags())); } @@ -219,7 +219,7 @@ struct ResonanceMergeDF { uint8_t>> innerVector; std::vector(track.tpcNClsCrossedRows()), + static_cast(track.tpcNClsFound()), static_cast(track.dcaXY() * 10000), static_cast(track.dcaZ() * 10000), - (int8_t)(track.tpcNSigmaPi() * 10), - (int8_t)(track.tpcNSigmaKa() * 10), - (int8_t)(track.tpcNSigmaPr() * 10), - (int8_t)(track.tofNSigmaPi() * 10), - (int8_t)(track.tofNSigmaKa() * 10), - (int8_t)(track.tofNSigmaPr() * 10), + static_cast(track.tpcNSigmaPi() * 10), + static_cast(track.tpcNSigmaKa() * 10), + static_cast(track.tpcNSigmaPr() * 10), + static_cast(track.tofNSigmaPi() * 10), + static_cast(track.tofNSigmaKa() * 10), + static_cast(track.tofNSigmaPr() * 10), static_cast(track.tpcSignal() * 100), track.trackFlags())); } @@ -281,25 +281,25 @@ struct ResonanceMergeDF { trackCasc.px(), trackCasc.py(), trackCasc.pz(), - const_cast(trackCasc.cascadeIndices()), - (int8_t)(trackCasc.daughterTPCNSigmaPosPi() * 10), - (int8_t)(trackCasc.daughterTPCNSigmaPosKa() * 10), - (int8_t)(trackCasc.daughterTPCNSigmaPosPr() * 10), - (int8_t)(trackCasc.daughterTPCNSigmaNegPi() * 10), - (int8_t)(trackCasc.daughterTPCNSigmaNegKa() * 10), - (int8_t)(trackCasc.daughterTPCNSigmaNegPr() * 10), - (int8_t)(trackCasc.daughterTPCNSigmaBachPi() * 10), - (int8_t)(trackCasc.daughterTPCNSigmaBachKa() * 10), - (int8_t)(trackCasc.daughterTPCNSigmaBachPr() * 10), - (int8_t)(trackCasc.daughterTOFNSigmaPosPi() * 10), - (int8_t)(trackCasc.daughterTOFNSigmaPosKa() * 10), - (int8_t)(trackCasc.daughterTOFNSigmaPosPr() * 10), - (int8_t)(trackCasc.daughterTOFNSigmaNegPi() * 10), - (int8_t)(trackCasc.daughterTOFNSigmaNegKa() * 10), - (int8_t)(trackCasc.daughterTOFNSigmaNegPr() * 10), - (int8_t)(trackCasc.daughterTOFNSigmaBachPi() * 10), - (int8_t)(trackCasc.daughterTOFNSigmaBachKa() * 10), - (int8_t)(trackCasc.daughterTOFNSigmaBachPr() * 10), + trackCasc.cascadeIndices(), + static_cast(trackCasc.daughterTPCNSigmaPosPi() * 10), + static_cast(trackCasc.daughterTPCNSigmaPosKa() * 10), + static_cast(trackCasc.daughterTPCNSigmaPosPr() * 10), + static_cast(trackCasc.daughterTPCNSigmaNegPi() * 10), + static_cast(trackCasc.daughterTPCNSigmaNegKa() * 10), + static_cast(trackCasc.daughterTPCNSigmaNegPr() * 10), + static_cast(trackCasc.daughterTPCNSigmaBachPi() * 10), + static_cast(trackCasc.daughterTPCNSigmaBachKa() * 10), + static_cast(trackCasc.daughterTPCNSigmaBachPr() * 10), + static_cast(trackCasc.daughterTOFNSigmaPosPi() * 10), + static_cast(trackCasc.daughterTOFNSigmaPosKa() * 10), + static_cast(trackCasc.daughterTOFNSigmaPosPr() * 10), + static_cast(trackCasc.daughterTOFNSigmaNegPi() * 10), + static_cast(trackCasc.daughterTOFNSigmaNegKa() * 10), + static_cast(trackCasc.daughterTOFNSigmaNegPr() * 10), + static_cast(trackCasc.daughterTOFNSigmaBachPi() * 10), + static_cast(trackCasc.daughterTOFNSigmaBachKa() * 10), + static_cast(trackCasc.daughterTOFNSigmaBachPr() * 10), trackCasc.v0CosPA(), trackCasc.cascCosPA(), trackCasc.daughDCA(), @@ -448,16 +448,16 @@ struct ResonanceMergeDF { track.px(), track.py(), track.pz(), - (uint8_t)track.tpcNClsCrossedRows(), - (uint8_t)track.tpcNClsFound(), + static_cast(track.tpcNClsCrossedRows()), + static_cast(track.tpcNClsFound()), static_cast(track.dcaXY() * 10000), static_cast(track.dcaZ() * 10000), - (int8_t)(track.tpcNSigmaPi() * 10), - (int8_t)(track.tpcNSigmaKa() * 10), - (int8_t)(track.tpcNSigmaPr() * 10), - (int8_t)(track.tofNSigmaPi() * 10), - (int8_t)(track.tofNSigmaKa() * 10), - (int8_t)(track.tofNSigmaPr() * 10), + static_cast(track.tpcNSigmaPi() * 10), + static_cast(track.tpcNSigmaKa() * 10), + static_cast(track.tpcNSigmaPr() * 10), + static_cast(track.tofNSigmaPi() * 10), + static_cast(track.tofNSigmaKa() * 10), + static_cast(track.tofNSigmaPr() * 10), static_cast(track.tpcSignal() * 100), track.trackFlags()); } @@ -511,16 +511,16 @@ struct ResonanceMergeDF { track.px(), track.py(), track.pz(), - (uint8_t)track.tpcNClsCrossedRows(), - (uint8_t)track.tpcNClsFound(), + static_cast(track.tpcNClsCrossedRows()), + static_cast(track.tpcNClsFound()), static_cast(track.dcaXY() * 10000), static_cast(track.dcaZ() * 10000), - (int8_t)(track.tpcNSigmaPi() * 10), - (int8_t)(track.tpcNSigmaKa() * 10), - (int8_t)(track.tpcNSigmaPr() * 10), - (int8_t)(track.tofNSigmaPi() * 10), - (int8_t)(track.tofNSigmaKa() * 10), - (int8_t)(track.tofNSigmaPr() * 10), + static_cast(track.tpcNSigmaPi() * 10), + static_cast(track.tpcNSigmaKa() * 10), + static_cast(track.tpcNSigmaPr() * 10), + static_cast(track.tofNSigmaPi() * 10), + static_cast(track.tofNSigmaKa() * 10), + static_cast(track.tofNSigmaPr() * 10), static_cast(track.tpcSignal() * 100), track.trackFlags()); } @@ -533,25 +533,25 @@ struct ResonanceMergeDF { track.px(), track.py(), track.pz(), - const_cast(track.cascadeIndices()), - (int8_t)(track.daughterTPCNSigmaPosPi() * 10), - (int8_t)(track.daughterTPCNSigmaPosKa() * 10), - (int8_t)(track.daughterTPCNSigmaPosPr() * 10), - (int8_t)(track.daughterTPCNSigmaNegPi() * 10), - (int8_t)(track.daughterTPCNSigmaNegKa() * 10), - (int8_t)(track.daughterTPCNSigmaNegPr() * 10), - (int8_t)(track.daughterTPCNSigmaBachPi() * 10), - (int8_t)(track.daughterTPCNSigmaBachKa() * 10), - (int8_t)(track.daughterTPCNSigmaBachPr() * 10), - (int8_t)(track.daughterTOFNSigmaPosPi() * 10), - (int8_t)(track.daughterTOFNSigmaPosKa() * 10), - (int8_t)(track.daughterTOFNSigmaPosPr() * 10), - (int8_t)(track.daughterTOFNSigmaNegPi() * 10), - (int8_t)(track.daughterTOFNSigmaNegKa() * 10), - (int8_t)(track.daughterTOFNSigmaNegPr() * 10), - (int8_t)(track.daughterTOFNSigmaBachPi() * 10), - (int8_t)(track.daughterTOFNSigmaBachKa() * 10), - (int8_t)(track.daughterTOFNSigmaBachPr() * 10), + track.cascadeIndices(), + static_cast(track.daughterTPCNSigmaPosPi() * 10), + static_cast(track.daughterTPCNSigmaPosKa() * 10), + static_cast(track.daughterTPCNSigmaPosPr() * 10), + static_cast(track.daughterTPCNSigmaNegPi() * 10), + static_cast(track.daughterTPCNSigmaNegKa() * 10), + static_cast(track.daughterTPCNSigmaNegPr() * 10), + static_cast(track.daughterTPCNSigmaBachPi() * 10), + static_cast(track.daughterTPCNSigmaBachKa() * 10), + static_cast(track.daughterTPCNSigmaBachPr() * 10), + static_cast(track.daughterTOFNSigmaPosPi() * 10), + static_cast(track.daughterTOFNSigmaPosKa() * 10), + static_cast(track.daughterTOFNSigmaPosPr() * 10), + static_cast(track.daughterTOFNSigmaNegPi() * 10), + static_cast(track.daughterTOFNSigmaNegKa() * 10), + static_cast(track.daughterTOFNSigmaNegPr() * 10), + static_cast(track.daughterTOFNSigmaBachPi() * 10), + static_cast(track.daughterTOFNSigmaBachKa() * 10), + static_cast(track.daughterTOFNSigmaBachPr() * 10), track.v0CosPA(), track.cascCosPA(), track.daughDCA(), diff --git a/PWGLF/TableProducer/Strangeness/cascadefinder.cxx b/PWGLF/TableProducer/Strangeness/cascadefinder.cxx index c7c20d305c0..cd99e23bdc2 100644 --- a/PWGLF/TableProducer/Strangeness/cascadefinder.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadefinder.cxx @@ -223,7 +223,7 @@ struct cascadefinder { covV0[4] = covVtxV0(2, 1); covV0[5] = covVtxV0(2, 2); - const std::array vertex = {(float)v0vtx[0], (float)v0vtx[1], (float)v0vtx[2]}; + const std::array vertex = {static_cast(v0vtx[0]), static_cast(v0vtx[1]), static_cast(v0vtx[2])}; const std::array momentum = {pvecpos[0] + pvecneg[0], pvecpos[1] + pvecneg[1], pvecpos[2] + pvecneg[2]}; auto tV0 = o2::track::TrackParCov(vertex, momentum, covV0, 0); @@ -313,7 +313,7 @@ struct cascadefinder { covV0[4] = covVtxV0(2, 1); covV0[5] = covVtxV0(2, 2); - const std::array vertex = {(float)v0vtx[0], (float)v0vtx[1], (float)v0vtx[2]}; + const std::array vertex = {static_cast(v0vtx[0]), static_cast(v0vtx[1]), static_cast(v0vtx[2])}; const std::array momentum = {pvecpos[0] + pvecneg[0], pvecpos[1] + pvecneg[1], pvecpos[2] + pvecneg[2]}; auto tV0 = o2::track::TrackParCov(vertex, momentum, covV0, 0); diff --git a/PWGLF/TableProducer/Strangeness/cascadeflow.cxx b/PWGLF/TableProducer/Strangeness/cascadeflow.cxx index 92472e75394..5a53bfa2b03 100644 --- a/PWGLF/TableProducer/Strangeness/cascadeflow.cxx +++ b/PWGLF/TableProducer/Strangeness/cascadeflow.cxx @@ -845,22 +845,22 @@ struct cascadeFlow { if (!listAcceptancePrimaryLambda) LOG(fatal) << "Problem getting TList object with acceptance for Primary Lambda!"; - hAcceptanceXi = static_cast(listAcceptanceXi->FindObject(Form("%s", ccdbConfigs.acceptanceHistoNameCasc->data()))); + hAcceptanceXi = dynamic_cast(listAcceptanceXi->FindObject(Form("%s", ccdbConfigs.acceptanceHistoNameCasc->data()))); if (!hAcceptanceXi) { LOG(fatal) << "The histogram for Xi is not there!"; } hAcceptanceXi->SetName("hAcceptanceXi"); - hAcceptanceOmega = static_cast(listAcceptanceOmega->FindObject(Form("%s", ccdbConfigs.acceptanceHistoNameCasc->data()))); + hAcceptanceOmega = dynamic_cast(listAcceptanceOmega->FindObject(Form("%s", ccdbConfigs.acceptanceHistoNameCasc->data()))); if (!hAcceptanceOmega) { LOG(fatal) << "The histogram for omega is not there!"; } hAcceptanceOmega->SetName("hAcceptanceOmega"); - hAcceptanceLambda = static_cast(listAcceptanceLambda->FindObject(Form("%s", ccdbConfigs.acceptanceHistoNameLambda->data()))); + hAcceptanceLambda = dynamic_cast(listAcceptanceLambda->FindObject(Form("%s", ccdbConfigs.acceptanceHistoNameLambda->data()))); if (!hAcceptanceLambda) { LOG(fatal) << "The histogram for Lambda is not there!"; } hAcceptanceLambda->SetName("hAcceptanceLambda"); - hAcceptancePrimaryLambda = static_cast(listAcceptancePrimaryLambda->FindObject(Form("%s", ccdbConfigs.acceptanceHistoNamePrimaryLambda->data()))); + hAcceptancePrimaryLambda = dynamic_cast(listAcceptancePrimaryLambda->FindObject(Form("%s", ccdbConfigs.acceptanceHistoNamePrimaryLambda->data()))); if (!hAcceptancePrimaryLambda) { LOG(fatal) << "The histogram for Primary Lambda is not there!"; } @@ -874,7 +874,7 @@ struct cascadeFlow { if (!listReso) LOG(fatal) << "Problem getting TList object with resolution!"; - hReso = static_cast(listReso->FindObject(Form("%s", ccdbConfigs.resoHistoName->data()))); + hReso = dynamic_cast(listReso->FindObject(Form("%s", ccdbConfigs.resoHistoName->data()))); if (!hReso) { LOG(fatal) << "The histogram for resolution is not there"; } @@ -889,7 +889,7 @@ struct cascadeFlow { if (!listCentWeight) LOG(fatal) << "Problem getting TList object with resolution!"; - hCentWeight = static_cast(listCentWeight->FindObject(Form("%s", ccdbConfigs.centWeightHistoName->data()))); + hCentWeight = dynamic_cast(listCentWeight->FindObject(Form("%s", ccdbConfigs.centWeightHistoName->data()))); if (!hCentWeight) { LOG(fatal) << "The histogram for resolution is not there"; } diff --git a/PWGLF/TableProducer/Strangeness/cascademcfinder.cxx b/PWGLF/TableProducer/Strangeness/cascademcfinder.cxx index 8c95a1579d4..99553194f97 100644 --- a/PWGLF/TableProducer/Strangeness/cascademcfinder.cxx +++ b/PWGLF/TableProducer/Strangeness/cascademcfinder.cxx @@ -76,8 +76,8 @@ struct cascademcfinder { void init(InitContext&) { // initialize histograms - const AxisSpec axisNTimesCollRecoed{static_cast(10), -0.5f, +9.5f, ""}; - const AxisSpec axisPt{static_cast(100), +0.0f, +10.0f, "p_{T} (GeV/c)"}; + const AxisSpec axisNTimesCollRecoed{10, -0.5f, +9.5f, ""}; + const AxisSpec axisPt{100, +0.0f, +10.0f, "p_{T} (GeV/c)"}; histos.add("hNTimesCollRecoed", "hNTimesCollRecoed", kTH1F, {axisNTimesCollRecoed}); diff --git a/PWGLF/TableProducer/Strangeness/lambdaJetpolarizationbuilder.cxx b/PWGLF/TableProducer/Strangeness/lambdaJetpolarizationbuilder.cxx index 059fd2d4e7e..ffcf5752c5e 100644 --- a/PWGLF/TableProducer/Strangeness/lambdaJetpolarizationbuilder.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdaJetpolarizationbuilder.cxx @@ -216,7 +216,7 @@ struct myAnalysis { JEhistos.add("hKaonminusCounts", "hKaonminusCounts", {HistType::kTH1F, {{1, -0.5, 0.5f}}}); eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(cfgeventSelections)); - trackSelection = jetderiveddatautilities::initialiseTrackSelection(static_cast(trackSelections)); + trackSelection = jetderiveddatautilities::initialiseTrackSelection(trackSelections); } // end of init double massPi = o2::constants::physics::MassPiMinus; diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeromcfinder.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeromcfinder.cxx index d5d5ef1fbf6..d6e2c3e5ca7 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeromcfinder.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeromcfinder.cxx @@ -93,7 +93,7 @@ struct lambdakzeromcfinder { void init(InitContext&) { // initialize histograms - const AxisSpec axisNTimesRecoed{static_cast(10), -0.5f, +9.5f, ""}; + const AxisSpec axisNTimesRecoed{10, -0.5f, +9.5f, ""}; histos.add("hNTimesCollRecoed", "hNTimesCollRecoed", kTH1F, {axisNTimesRecoed}); diff --git a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx index 3fd13a7aa95..706d7f43a25 100644 --- a/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx +++ b/PWGLF/TableProducer/Strangeness/lambdakzeromlselection.cxx @@ -170,8 +170,8 @@ struct lambdakzeromlselection { } /// Here the Configurables are passed to std::vectors - CastKine_SelMap = (std::vector)Kine_SelMap; - CastTopo_SelMap = (std::vector)Topo_SelMap; + CastKine_SelMap = std::vector(Kine_SelMap); + CastTopo_SelMap = std::vector(Topo_SelMap); // Concatenate the selection masks Feature_SelMask.reserve(CastKine_SelMap.size() + CastTopo_SelMap.size()); // Reserve space to avoid reallocations diff --git a/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx b/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx index 7d3fca0718b..456466e1627 100644 --- a/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx +++ b/PWGLF/TableProducer/Strangeness/phiStrangeCorrelator.cxx @@ -136,8 +136,8 @@ struct PhiMesonCandProducer { void init(InitContext&) { - AxisSpec binnedmultAxis{(std::vector)binsMult, "centFT0M"}; - AxisSpec binnedpTPhiAxis{(std::vector)binspTPhi, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedmultAxis{std::vector(binsMult), "centFT0M"}; + AxisSpec binnedpTPhiAxis{std::vector(binspTPhi), "#it{p}_{T} (GeV/#it{c})"}; AxisSpec massPhiAxis = {200, 0.9f, 1.2f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; histos.add("h3PhiCandidatesMass", "Phi candidate invariant mass", kTH3F, {binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); @@ -499,10 +499,10 @@ struct V0ReducedCandProducer { void init(InitContext&) { - AxisSpec binnedmultAxis{(std::vector)binsMult, "centFT0M"}; - AxisSpec binnedpTK0SAxis{(std::vector)v0Configs.k0sConfigs.binspTK0S, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTLambdaAxis{(std::vector)v0Configs.lambdaConfigs.binspTLambda, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTXiAxis{(std::vector)binspTXi, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedmultAxis{std::vector(binsMult), "centFT0M"}; + AxisSpec binnedpTK0SAxis{std::vector(v0Configs.k0sConfigs.binspTK0S), "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTLambdaAxis{std::vector(v0Configs.lambdaConfigs.binspTLambda), "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTXiAxis{std::vector(binspTXi), "#it{p}_{T} (GeV/#it{c})"}; AxisSpec massK0SAxis = {200, 0.45f, 0.55f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; AxisSpec massLambdaAxis = {200, 1.08f, 1.15f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; @@ -816,9 +816,9 @@ struct CascadeReducedCandProducer { void init(InitContext&) { - AxisSpec binnedmultAxis{(std::vector)binsMult, "centFT0M"}; - AxisSpec binnedpTXiAxis{(std::vector)cascadeConfigs.xiConfigs.binspTXi, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTOmegaAxis{(std::vector)cascadeConfigs.omegaConfigs.binspTOmega, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedmultAxis{std::vector(binsMult), "centFT0M"}; + AxisSpec binnedpTXiAxis{std::vector(cascadeConfigs.xiConfigs.binspTXi), "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTOmegaAxis{std::vector(cascadeConfigs.omegaConfigs.binspTOmega), "#it{p}_{T} (GeV/#it{c})"}; AxisSpec massXiAxis = {200, 1.2f, 1.4f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; AxisSpec massOmegaAxis = {200, 1.6f, 1.8f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; @@ -1075,8 +1075,8 @@ struct PionTrackProducer { void init(InitContext&) { - AxisSpec binnedmultAxis{(std::vector)binsMult, "centFT0M"}; - AxisSpec binnedpTPiAxis{(std::vector)binspTPi, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedmultAxis{std::vector(binsMult), "centFT0M"}; + AxisSpec binnedpTPiAxis{std::vector(binspTPi), "#it{p}_{T} (GeV/#it{c})"}; AxisSpec nSigmaPiAxis = {100, -10.0f, 10.0f, "N#sigma #pi"}; histos.add("h3PionTPCnSigma", "Pion TPC nSigma distribution", kTH3F, {binnedmultAxis, binnedpTPiAxis, nSigmaPiAxis}); @@ -1339,7 +1339,7 @@ struct EventSelectionProducer { // Defining histogram axes AxisSpec vertexZAxis = {100, -cutZVertex, cutZVertex, "vrtx_{Z} [cm]"}; AxisSpec multAxis = {120, 0.0f, 120.0f, "centFT0M"}; - AxisSpec binnedmultAxis{(std::vector)binsMult, "centFT0M"}; + AxisSpec binnedmultAxis{std::vector(binsMult), "centFT0M"}; // Booking histograms for event selection QA // Number of events per selection in Data diff --git a/PWGLF/TableProducer/Strangeness/sigmaminustask.cxx b/PWGLF/TableProducer/Strangeness/sigmaminustask.cxx index cd4c6f690c3..d1fae95544c 100644 --- a/PWGLF/TableProducer/Strangeness/sigmaminustask.cxx +++ b/PWGLF/TableProducer/Strangeness/sigmaminustask.cxx @@ -219,8 +219,8 @@ struct sigmaminustask { } // Cast configurables to std::vector - cast_mothPdgCodes = (std::vector)mothPdgCodes; - cast_daugPdgCodes = (std::vector)daugPdgCodes; + cast_mothPdgCodes = std::vector(mothPdgCodes); + cast_daugPdgCodes = std::vector(daugPdgCodes); } void initCCDB(aod::BCs::iterator const& bc) diff --git a/PWGLF/TableProducer/Strangeness/stracents.cxx b/PWGLF/TableProducer/Strangeness/stracents.cxx index ad34db13e92..13db97208ba 100644 --- a/PWGLF/TableProducer/Strangeness/stracents.cxx +++ b/PWGLF/TableProducer/Strangeness/stracents.cxx @@ -272,11 +272,11 @@ struct straCents { if constexpr (requires { collision.sel7(); }) { // check if we are in Run 2 auto getccdb = [lCalibObjects_Centrality](const char* ccdbhname) { - TH1* h = reinterpret_cast(lCalibObjects_Centrality->FindObject(ccdbhname)); + TH1* h = dynamic_cast(lCalibObjects_Centrality->FindObject(ccdbhname)); return h; }; auto getformulaccdb = [lCalibObjects_Centrality](const char* ccdbhname) { - TFormula* f = reinterpret_cast(lCalibObjects_Centrality->FindObject(ccdbhname)); + TFormula* f = dynamic_cast(lCalibObjects_Centrality->FindObject(ccdbhname)); return f; }; @@ -350,8 +350,8 @@ struct straCents { } else { // we are in Run 3 auto getccdb = [lCalibObjects_Centrality, collision](struct CalibrationInfo& estimator, const Configurable& generatorName, const Configurable& notCrashOnNull) { // TODO: to consider the name inside the estimator structure - estimator.mhMultSelCalib = reinterpret_cast(lCalibObjects_Centrality->FindObject(TString::Format("hCalibZeq%s", estimator.name.c_str()).Data())); - estimator.mMCScale = reinterpret_cast(lCalibObjects_Centrality->FindObject(TString::Format("%s-%s", generatorName->c_str(), estimator.name.c_str()).Data())); + estimator.mhMultSelCalib = dynamic_cast(lCalibObjects_Centrality->FindObject(TString::Format("hCalibZeq%s", estimator.name.c_str()).Data())); + estimator.mMCScale = dynamic_cast(lCalibObjects_Centrality->FindObject(TString::Format("%s-%s", generatorName->c_str(), estimator.name.c_str()).Data())); if (estimator.mhMultSelCalib != nullptr) { if (generatorName->length() != 0) { LOGF(info, "Retrieving MC calibration for %d, generator name: %s", collision.runNumber(), generatorName->c_str()); @@ -390,12 +390,12 @@ struct straCents { listCalib->Add(lCalibObjects_Multiplicity->Clone(Form("Multiplicity_%i", collision.runNumber()))); } - hVtxZFV0A = static_cast(lCalibObjects_Multiplicity->FindObject("hVtxZFV0A")); - hVtxZFT0A = static_cast(lCalibObjects_Multiplicity->FindObject("hVtxZFT0A")); - hVtxZFT0C = static_cast(lCalibObjects_Multiplicity->FindObject("hVtxZFT0C")); - hVtxZFDDA = static_cast(lCalibObjects_Multiplicity->FindObject("hVtxZFDDA")); - hVtxZFDDC = static_cast(lCalibObjects_Multiplicity->FindObject("hVtxZFDDC")); - hVtxZNTracks = static_cast(lCalibObjects_Multiplicity->FindObject("hVtxZNTracksPV")); + hVtxZFV0A = dynamic_cast(lCalibObjects_Multiplicity->FindObject("hVtxZFV0A")); + hVtxZFT0A = dynamic_cast(lCalibObjects_Multiplicity->FindObject("hVtxZFT0A")); + hVtxZFT0C = dynamic_cast(lCalibObjects_Multiplicity->FindObject("hVtxZFT0C")); + hVtxZFDDA = dynamic_cast(lCalibObjects_Multiplicity->FindObject("hVtxZFDDA")); + hVtxZFDDC = dynamic_cast(lCalibObjects_Multiplicity->FindObject("hVtxZFDDC")); + hVtxZNTracks = dynamic_cast(lCalibObjects_Multiplicity->FindObject("hVtxZNTracksPV")); lCalibLoaded = true; // Capture error if (!hVtxZFV0A || !hVtxZFT0A || !hVtxZFT0C || !hVtxZFDDA || !hVtxZFDDC || !hVtxZNTracks) { diff --git a/PWGLF/TableProducer/Strangeness/strangenesstofpid.cxx b/PWGLF/TableProducer/Strangeness/strangenesstofpid.cxx index 5284394277e..0439eec0b55 100644 --- a/PWGLF/TableProducer/Strangeness/strangenesstofpid.cxx +++ b/PWGLF/TableProducer/Strangeness/strangenesstofpid.cxx @@ -672,19 +672,19 @@ struct strangenesstofpid { nSigmaCalibLoaded = true; // made it thus far, mark loaded if (calculateV0s.value) { - hMeanPosLaPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanPosLaPi")); - hMeanPosLaPr = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanPosLaPr")); - hMeanNegLaPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanNegLaPi")); - hMeanNegLaPr = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanNegLaPr")); - hMeanPosK0Pi = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanPosK0Pi")); - hMeanNegK0Pi = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanNegK0Pi")); - - hSigmaPosLaPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaPosLaPi")); - hSigmaPosLaPr = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaPosLaPr")); - hSigmaNegLaPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaNegLaPi")); - hSigmaNegLaPr = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaNegLaPr")); - hSigmaPosK0Pi = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaPosK0Pi")); - hSigmaNegK0Pi = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaNegK0Pi")); + hMeanPosLaPi = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanPosLaPi")); + hMeanPosLaPr = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanPosLaPr")); + hMeanNegLaPi = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanNegLaPi")); + hMeanNegLaPr = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanNegLaPr")); + hMeanPosK0Pi = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanPosK0Pi")); + hMeanNegK0Pi = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanNegK0Pi")); + + hSigmaPosLaPi = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaPosLaPi")); + hSigmaPosLaPr = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaPosLaPr")); + hSigmaNegLaPi = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaNegLaPi")); + hSigmaNegLaPr = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaNegLaPr")); + hSigmaPosK0Pi = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaPosK0Pi")); + hSigmaNegK0Pi = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaNegK0Pi")); if (!hMeanPosLaPi) LOG(info) << "Problems finding mean histogram hMeanPosLaPi!"; @@ -704,27 +704,27 @@ struct strangenesstofpid { } if (calculateCascades.value) { - hMeanPosXiPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanPosXiPi")); - hMeanPosXiPr = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanPosXiPr")); - hMeanNegXiPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanNegXiPi")); - hMeanNegXiPr = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanNegXiPr")); - hMeanBachXiPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanBachXiPi")); - hMeanPosOmPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanPosOmPi")); - hMeanPosOmPr = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanPosOmPr")); - hMeanNegOmPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanNegOmPi")); - hMeanNegOmPr = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanNegOmPr")); - hMeanBachOmKa = reinterpret_cast(nSigmaCalibObjects->FindObject("hMeanBachOmKa")); - - hSigmaPosXiPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaPosXiPi")); - hSigmaPosXiPr = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaPosXiPr")); - hSigmaNegXiPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaNegXiPi")); - hSigmaNegXiPr = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaNegXiPr")); - hSigmaBachXiPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaBachXiPi")); - hSigmaPosOmPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaPosOmPi")); - hSigmaPosOmPr = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaPosOmPr")); - hSigmaNegOmPi = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaNegOmPi")); - hSigmaNegOmPr = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaNegOmPr")); - hSigmaBachOmKa = reinterpret_cast(nSigmaCalibObjects->FindObject("hSigmaBachOmKa")); + hMeanPosXiPi = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanPosXiPi")); + hMeanPosXiPr = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanPosXiPr")); + hMeanNegXiPi = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanNegXiPi")); + hMeanNegXiPr = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanNegXiPr")); + hMeanBachXiPi = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanBachXiPi")); + hMeanPosOmPi = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanPosOmPi")); + hMeanPosOmPr = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanPosOmPr")); + hMeanNegOmPi = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanNegOmPi")); + hMeanNegOmPr = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanNegOmPr")); + hMeanBachOmKa = dynamic_cast(nSigmaCalibObjects->FindObject("hMeanBachOmKa")); + + hSigmaPosXiPi = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaPosXiPi")); + hSigmaPosXiPr = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaPosXiPr")); + hSigmaNegXiPi = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaNegXiPi")); + hSigmaNegXiPr = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaNegXiPr")); + hSigmaBachXiPi = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaBachXiPi")); + hSigmaPosOmPi = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaPosOmPi")); + hSigmaPosOmPr = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaPosOmPr")); + hSigmaNegOmPi = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaNegOmPi")); + hSigmaNegOmPr = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaNegOmPr")); + hSigmaBachOmKa = dynamic_cast(nSigmaCalibObjects->FindObject("hSigmaBachOmKa")); if (!hMeanPosXiPi || !hMeanPosXiPr || !hMeanNegXiPi || !hMeanNegXiPr || !hMeanBachXiPi) LOG(info) << "Problems finding xi mean histograms!"; diff --git a/PWGLF/Tasks/GlobalEventProperties/PseudorapidityDensityMFT.cxx b/PWGLF/Tasks/GlobalEventProperties/PseudorapidityDensityMFT.cxx index 8390f501389..6408ab36b9a 100644 --- a/PWGLF/Tasks/GlobalEventProperties/PseudorapidityDensityMFT.cxx +++ b/PWGLF/Tasks/GlobalEventProperties/PseudorapidityDensityMFT.cxx @@ -1374,13 +1374,13 @@ struct PseudorapidityDensityMFT { {HistType::kTH1F, {{100000, -50000.0, 50000.0}}}}); // registry.add({"collisionIDamb", " ; Collision ID amb", // {HistType::kTH1F,{{100000, 0.5, 100000.0}}}}); // - {HistType::kTH1F, {{100000, -50000.0, 50000.0}}}}); // - registry.add({"NonambEventCounts", " ; EventCounts Nonamb", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); // + {HistType::kTH1F, {{100000, -50000.0, 50000.0}}}}); // + registry.add({"NonambEventCounts", " ; EventCounts Nonamb", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); // registry.add({"hNumCollisionsNonAmb_InelMFT", ";Selected collisions with nonambiguous tracks;Count", {HistType::kTH1D, {{1, 0.5, 1.5}}}}); registry.add({"hNumCollisionsAmb_InelMFT", ";Selected collisions with ambiguous tracks;Count", {HistType::kTH1D, {{1, 0.5, 1.5}}}}); - registry.add({"hNumCollisions_InelMFT", " ; Number of selected events with Inel>0 and MFT>0;Count;Frequency", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); // - registry.add({"hNumCollisions_Inel", " ; Number of selected events with Inel>0;Count;Frequency", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); // - registry.add({"ambEventCounts", " ; EventCounts Nonamb", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); // + registry.add({"hNumCollisions_InelMFT", " ; Number of selected events with Inel>0 and MFT>0;Count;Frequency", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); // + registry.add({"hNumCollisions_Inel", " ; Number of selected events with Inel>0;Count;Frequency", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); // + registry.add({"ambEventCounts", " ; EventCounts Nonamb", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); // } if (doprocessCountingCentrality) { @@ -1541,8 +1541,8 @@ struct PseudorapidityDensityMFT { expressions::Filter trackSelectionCentral = ((aod::track::trackCutFlag & TrackSelectionIts) == TrackSelectionIts) && - ifnode((aod::track::v001::detectorMap & (uint8_t)o2::aod::track::TPC) == - (uint8_t)o2::aod::track::TPC, + ifnode((aod::track::v001::detectorMap & static_cast(o2::aod::track::TPC)) == + static_cast(o2::aod::track::TPC), (aod::track::trackCutFlag & TrackSelectionTpc) == TrackSelectionTpc, true) && @@ -1976,8 +1976,8 @@ struct PseudorapidityDensityMFT { using ParticlesGenReco = aod::McParticles; expressions::Filter primaries = (aod::mcparticle::flags & - (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary) == - (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary; + static_cast(o2::aod::mcparticle::enums::PhysicalPrimary)) == + static_cast(o2::aod::mcparticle::enums::PhysicalPrimary); static constexpr float McSampleEtaMax = 1.1f; Partition mcSample = nabs(aod::mcparticle::eta) < McSampleEtaMax; Partition mcSampleCentral = diff --git a/PWGLF/Tasks/GlobalEventProperties/flattenictyPikp.cxx b/PWGLF/Tasks/GlobalEventProperties/flattenictyPikp.cxx index e7d70cf152d..90a9729e2a7 100644 --- a/PWGLF/Tasks/GlobalEventProperties/flattenictyPikp.cxx +++ b/PWGLF/Tasks/GlobalEventProperties/flattenictyPikp.cxx @@ -475,19 +475,19 @@ struct FlattenictyPikp { void init(InitContext&) { - auto vecParamsMIPposEtaP = (std::vector)defOpt.paramsFuncMIPposEtaP; - auto vecParamsMIPposEtaN = (std::vector)defOpt.paramsFuncMIPposEtaN; - auto vecParamsMIPnegEtaP = (std::vector)defOpt.paramsFuncMIPnegEtaP; - auto vecParamsMIPnegEtaN = (std::vector)defOpt.paramsFuncMIPnegEtaN; - auto vecParamsMIPallEtaP = (std::vector)defOpt.paramsFuncMIPallEtaP; - auto vecParamsMIPallEtaN = (std::vector)defOpt.paramsFuncMIPallEtaN; - - auto vecParamsPLAposEtaP = (std::vector)defOpt.paramsFuncPlateaUposEtaP; - auto vecParamsPLAposEtaN = (std::vector)defOpt.paramsFuncPlateaUposEtaN; - auto vecParamsPLAnegEtaP = (std::vector)defOpt.paramsFuncPlateaUnegEtaP; - auto vecParamsPLAnegEtaN = (std::vector)defOpt.paramsFuncPlateaUnegEtaN; - auto vecParamsPLAallEtaP = (std::vector)defOpt.paramsFuncPlateaUallEtaP; - auto vecParamsPLAallEtaN = (std::vector)defOpt.paramsFuncPlateaUallEtaN; + auto vecParamsMIPposEtaP = std::vector(defOpt.paramsFuncMIPposEtaP); + auto vecParamsMIPposEtaN = std::vector(defOpt.paramsFuncMIPposEtaN); + auto vecParamsMIPnegEtaP = std::vector(defOpt.paramsFuncMIPnegEtaP); + auto vecParamsMIPnegEtaN = std::vector(defOpt.paramsFuncMIPnegEtaN); + auto vecParamsMIPallEtaP = std::vector(defOpt.paramsFuncMIPallEtaP); + auto vecParamsMIPallEtaN = std::vector(defOpt.paramsFuncMIPallEtaN); + + auto vecParamsPLAposEtaP = std::vector(defOpt.paramsFuncPlateaUposEtaP); + auto vecParamsPLAposEtaN = std::vector(defOpt.paramsFuncPlateaUposEtaN); + auto vecParamsPLAnegEtaP = std::vector(defOpt.paramsFuncPlateaUnegEtaP); + auto vecParamsPLAnegEtaN = std::vector(defOpt.paramsFuncPlateaUnegEtaN); + auto vecParamsPLAallEtaP = std::vector(defOpt.paramsFuncPlateaUallEtaP); + auto vecParamsPLAallEtaN = std::vector(defOpt.paramsFuncPlateaUallEtaN); auto addVec = [&](std::vector>& targetVec, const std::string& name, bool isMIP) { if (isMIP) { diff --git a/PWGLF/Tasks/Nuspex/NucleiHistTask.cxx b/PWGLF/Tasks/Nuspex/NucleiHistTask.cxx index 6239a7b32c3..e9b9aa30e8d 100644 --- a/PWGLF/Tasks/Nuspex/NucleiHistTask.cxx +++ b/PWGLF/Tasks/Nuspex/NucleiHistTask.cxx @@ -662,7 +662,7 @@ struct NucleiHistTask { if (enable_pT_shift_tpc_nSigma) { Particle_Tpc_nSigma_shift = new TF1("Particle_Tpc_nSigma_shift", "[0] * TMath::Exp([1] + [2] * x) + [3] + [4] * x + [5] * x * x", 0.f, 14.f); - auto par = (std::vector)parShiftPt; + auto par = std::vector(parShiftPt); Particle_Tpc_nSigma_shift->SetParameters(par[0], par[1], par[2], par[3], par[4], par[5]); } for (const auto& track : tracks) { @@ -877,7 +877,7 @@ struct NucleiHistTask { if (enable_pT_shift_tpc_nSigma) { Particle_Tpc_nSigma_shift = new TF1("Particle_Tpc_nSigma_shift", "[0] * TMath::Exp([1] + [2] * x) + [3] + [4] * x + [5] * x * x", 0.f, 14.f); - auto par = (std::vector)parShiftPt; + auto par = std::vector(parShiftPt); Particle_Tpc_nSigma_shift->SetParameters(par[0], par[1], par[2], par[3], par[4], par[5]); } @@ -1212,32 +1212,32 @@ struct NucleiHistTask { if (enable_pT_shift_pion_tpc_nSigma) { Pion_Tpc_nSigma_shift = new TF1("Pion_Tpc_nSigma_shift", "[0] * TMath::Exp([1] + [2] * x) + [3] + [4] * x + [5] * x * x", 0.f, 14.f); - auto par = (std::vector)parShiftPtPion; + auto par = std::vector(parShiftPtPion); Pion_Tpc_nSigma_shift->SetParameters(par[0], par[1], par[2], par[3], par[4], par[5]); } if (enable_pT_shift_proton_tpc_nSigma) { Proton_Tpc_nSigma_shift = new TF1("Proton_Tpc_nSigma_shift", "[0] * TMath::Exp([1] + [2] * x) + [3] + [4] * x + [5] * x * x", 0.f, 14.f); - auto par = (std::vector)parShiftPtProton; + auto par = std::vector(parShiftPtProton); Proton_Tpc_nSigma_shift->SetParameters(par[0], par[1], par[2], par[3], par[4], par[5]); } if (enable_pT_shift_deuteron_tpc_nSigma) { Deuteron_Tpc_nSigma_shift = new TF1("Deuteron_Tpc_nSigma_shift", "[0] * TMath::Exp([1] + [2] * x) + [3] + [4] * x + [5] * x * x", 0.f, 14.f); - auto par = (std::vector)parShiftPtDeuteron; + auto par = std::vector(parShiftPtDeuteron); Deuteron_Tpc_nSigma_shift->SetParameters(par[0], par[1], par[2], par[3], par[4], par[5]); } if (enable_pT_shift_triton_tpc_nSigma) { Triton_Tpc_nSigma_shift = new TF1("Triton_Tpc_nSigma_shift", "[0] * TMath::Exp([1] + [2] * x) + [3] + [4] * x + [5] * x * x", 0.f, 14.f); - auto par = (std::vector)parShiftPtTriton; + auto par = std::vector(parShiftPtTriton); Triton_Tpc_nSigma_shift->SetParameters(par[0], par[1], par[2], par[3], par[4], par[5]); } if (enable_pT_shift_He3_tpc_nSigma) { He3_Tpc_nSigma_shift = new TF1("He3_Tpc_nSigma_shift", "[0] * TMath::Exp([1] + [2] * x) + [3] + [4] * x + [5] * x * x", 0.f, 14.f); - auto par = (std::vector)parShiftPtHe3; + auto par = std::vector(parShiftPtHe3); He3_Tpc_nSigma_shift->SetParameters(par[0], par[1], par[2], par[3], par[4], par[5]); } if (enable_pT_shift_He4_tpc_nSigma) { He4_Tpc_nSigma_shift = new TF1("He4_Tpc_nSigma_shift", "[0] * TMath::Exp([1] + [2] * x) + [3] + [4] * x + [5] * x * x", 0.f, 14.f); - auto par = (std::vector)parShiftPtHe4; + auto par = std::vector(parShiftPtHe4); He4_Tpc_nSigma_shift->SetParameters(par[0], par[1], par[2], par[3], par[4], par[5]); } diff --git a/PWGLF/Tasks/Nuspex/antinucleiInJets.cxx b/PWGLF/Tasks/Nuspex/antinucleiInJets.cxx index e636fba327a..0220e6629ec 100644 --- a/PWGLF/Tasks/Nuspex/antinucleiInJets.cxx +++ b/PWGLF/Tasks/Nuspex/antinucleiInJets.cxx @@ -1410,7 +1410,7 @@ struct AntinucleiInJets { registryData.fill(HIST("antihelium3_jet_tpc"), 2.0 * pt, nsigmaTPCHe); // custom nsigma He3 based on bethe bloch fit of TPC signal double tpcSignal = track.tpcSignal(); - double expectedSignalHe3 = common::BetheBlochAleph(static_cast(track.tpcInnerParam() * 2. / o2::constants::physics::MassHelium3), cfgBetheBlochParams.value[0], cfgBetheBlochParams.value[1], cfgBetheBlochParams.value[2], cfgBetheBlochParams.value[3], cfgBetheBlochParams.value[4]); + double expectedSignalHe3 = common::BetheBlochAleph((track.tpcInnerParam() * 2. / o2::constants::physics::MassHelium3), cfgBetheBlochParams.value[0], cfgBetheBlochParams.value[1], cfgBetheBlochParams.value[2], cfgBetheBlochParams.value[3], cfgBetheBlochParams.value[4]); double nSigmaTPCHe3Custom = ((tpcSignal / expectedSignalHe3) - 1.) / 0.045; registryData.fill(HIST("antihelium3_jet_tpc_custom"), 2.0 * pt, nSigmaTPCHe3Custom); } @@ -1427,7 +1427,7 @@ struct AntinucleiInJets { registryData.fill(HIST("helium3_jet_tpc"), 2.0 * pt, nsigmaTPCHe); // custom nsigma He3 based on bethe bloch fit of TPC signal double tpcSignal = track.tpcSignal(); - double expectedSignalHe3 = common::BetheBlochAleph(static_cast(track.tpcInnerParam() * 2. / o2::constants::physics::MassHelium3), cfgBetheBlochParams.value[0], cfgBetheBlochParams.value[1], cfgBetheBlochParams.value[2], cfgBetheBlochParams.value[3], cfgBetheBlochParams.value[4]); + double expectedSignalHe3 = common::BetheBlochAleph((track.tpcInnerParam() * 2. / o2::constants::physics::MassHelium3), cfgBetheBlochParams.value[0], cfgBetheBlochParams.value[1], cfgBetheBlochParams.value[2], cfgBetheBlochParams.value[3], cfgBetheBlochParams.value[4]); double nSigmaTPCHe3Custom = ((tpcSignal / expectedSignalHe3) - 1.) / 0.045; registryData.fill(HIST("helium3_jet_tpc_custom"), 2.0 * pt, nSigmaTPCHe3Custom); } @@ -1504,7 +1504,7 @@ struct AntinucleiInJets { registryData.fill(HIST("antihelium3_ue_tpc"), 2.0 * pt, nsigmaTPCHe); // custom nsigma He3 based on bethe bloch fit of TPC signal double tpcSignal = track.tpcSignal(); - double expectedSignalHe3 = common::BetheBlochAleph(static_cast(track.tpcInnerParam() * 2. / o2::constants::physics::MassHelium3), cfgBetheBlochParams.value[0], cfgBetheBlochParams.value[1], cfgBetheBlochParams.value[2], cfgBetheBlochParams.value[3], cfgBetheBlochParams.value[4]); + double expectedSignalHe3 = common::BetheBlochAleph((track.tpcInnerParam() * 2. / o2::constants::physics::MassHelium3), cfgBetheBlochParams.value[0], cfgBetheBlochParams.value[1], cfgBetheBlochParams.value[2], cfgBetheBlochParams.value[3], cfgBetheBlochParams.value[4]); double nSigmaTPCHe3Custom = ((tpcSignal / expectedSignalHe3) - 1.) / 0.045; registryData.fill(HIST("antihelium3_ue_tpc_custom"), 2.0 * pt, nSigmaTPCHe3Custom); } @@ -1521,7 +1521,7 @@ struct AntinucleiInJets { registryData.fill(HIST("helium3_ue_tpc"), 2.0 * pt, nsigmaTPCHe); // custom nsigma He3 based on bethe bloch fit of TPC signal double tpcSignal = track.tpcSignal(); - double expectedSignalHe3 = common::BetheBlochAleph(static_cast(track.tpcInnerParam() * 2. / o2::constants::physics::MassHelium3), cfgBetheBlochParams.value[0], cfgBetheBlochParams.value[1], cfgBetheBlochParams.value[2], cfgBetheBlochParams.value[3], cfgBetheBlochParams.value[4]); + double expectedSignalHe3 = common::BetheBlochAleph((track.tpcInnerParam() * 2. / o2::constants::physics::MassHelium3), cfgBetheBlochParams.value[0], cfgBetheBlochParams.value[1], cfgBetheBlochParams.value[2], cfgBetheBlochParams.value[3], cfgBetheBlochParams.value[4]); double nSigmaTPCHe3Custom = ((tpcSignal / expectedSignalHe3) - 1.) / 0.045; registryData.fill(HIST("helium3_ue_tpc_custom"), 2.0 * pt, nSigmaTPCHe3Custom); } diff --git a/PWGLF/Tasks/Nuspex/hyhe4analysis.cxx b/PWGLF/Tasks/Nuspex/hyhe4analysis.cxx index c6162dcc7a2..b3e9b550dde 100644 --- a/PWGLF/Tasks/Nuspex/hyhe4analysis.cxx +++ b/PWGLF/Tasks/Nuspex/hyhe4analysis.cxx @@ -60,13 +60,13 @@ struct hyhefouranalysis { void init(InitContext&) { - const AxisSpec axisMassHyHe4{(int)400, 3.7f, 4.1f, "Hyperhelium4 Mass Distribution (GeV/c^{2})"}; - const AxisSpec axisNCandidates{(int)100, -0.5f, 99.5f, "Number of 3-body candidates"}; + const AxisSpec axisMassHyHe4{400, 3.7f, 4.1f, "Hyperhelium4 Mass Distribution (GeV/c^{2})"}; + const AxisSpec axisNCandidates{100, -0.5f, 99.5f, "Number of 3-body candidates"}; - const AxisSpec axisEventCounter{(int)1, 0.0f, 1.0f, "Number of events"}; - const AxisSpec axisPt{(int)1000, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; - const AxisSpec axisDCADaughters{(int)1000, 0.0f, 10.0f, "DCA Daughters (cm)"}; - const AxisSpec axisDCAtoPV{(int)1000, -10.0f, 10.0f, "DCA to PV (cm)"}; + const AxisSpec axisEventCounter{1, 0.0f, 1.0f, "Number of events"}; + const AxisSpec axisPt{1000, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; + const AxisSpec axisDCADaughters{1000, 0.0f, 10.0f, "DCA Daughters (cm)"}; + const AxisSpec axisDCAtoPV{1000, -10.0f, 10.0f, "DCA to PV (cm)"}; // Base counters histos.add("hNEvents", "hNEvents", kTH1F, {axisEventCounter}); diff --git a/PWGLF/Tasks/Nuspex/lfNucleiBATask.cxx b/PWGLF/Tasks/Nuspex/lfNucleiBATask.cxx index 27d7abcbddc..595e23043fd 100644 --- a/PWGLF/Tasks/Nuspex/lfNucleiBATask.cxx +++ b/PWGLF/Tasks/Nuspex/lfNucleiBATask.cxx @@ -2635,8 +2635,8 @@ struct lfNucleiBATask { } tracks.copyIndexBindings(tracksWithITS); - auto tpcChi2NclRange = (std::vector)trkqcOptions.tpcChi2NclCuts; - auto itsChi2NclRange = (std::vector)trkqcOptions.itsChi2NclCuts; + auto tpcChi2NclRange = std::vector(trkqcOptions.tpcChi2NclCuts); + auto itsChi2NclRange = std::vector(trkqcOptions.itsChi2NclCuts); for (auto const& track : tracksWithITS) { // Init all temp variables inside the track loop diff --git a/PWGLF/Tasks/Nuspex/mcspectraefficiency.cxx b/PWGLF/Tasks/Nuspex/mcspectraefficiency.cxx index 4ca792b3c27..05e57b98a97 100644 --- a/PWGLF/Tasks/Nuspex/mcspectraefficiency.cxx +++ b/PWGLF/Tasks/Nuspex/mcspectraefficiency.cxx @@ -112,7 +112,7 @@ struct ReconstructedTask { OutputObj pDiff{TH2F("pDiff", "pDiff;#it{p}_{MC} #it{p}_{Rec} (GeV/#it{c})", 500, -2, 2, PDGBINNING)}; Filter trackAcceptance = (nabs(aod::track::eta) < 0.8f); - Filter trackCuts = ((requireGlobalTrackInFilter()) || (aod::track::isGlobalTrackSDD == (uint8_t) true)); + Filter trackCuts = ((requireGlobalTrackInFilter()) || (aod::track::isGlobalTrackSDD == static_cast(true))); void process(soa::Join::iterator const& collision, soa::Filtered> const& tracks, diff --git a/PWGLF/Tasks/Nuspex/nucleitpcPbPb.cxx b/PWGLF/Tasks/Nuspex/nucleitpcPbPb.cxx index 1658ffb009e..a18136a38ee 100644 --- a/PWGLF/Tasks/Nuspex/nucleitpcPbPb.cxx +++ b/PWGLF/Tasks/Nuspex/nucleitpcPbPb.cxx @@ -1391,7 +1391,7 @@ struct NucleitpcPbPb { if (particle.name == "alpha" && cfgTrackPIDsettings->get("alpha", "useBBparams") < 1) return cfgTrackPIDsettings->get("alpha", "useBBparams") == 0 ? track.tpcNSigmaAl() : 0; - double expBethe{common::BetheBlochAleph(static_cast(particle.charge * rigidity / particle.mass), particle.betheParams[0], particle.betheParams[1], particle.betheParams[2], particle.betheParams[3], particle.betheParams[4])}; + double expBethe{common::BetheBlochAleph((particle.charge * rigidity / particle.mass), particle.betheParams[0], particle.betheParams[1], particle.betheParams[2], particle.betheParams[3], particle.betheParams[4])}; double expSigma{expBethe * particle.resolution}; return static_cast((track.tpcSignal() - expBethe) / expSigma); } diff --git a/PWGLF/Tasks/Nuspex/piKpRAA.cxx b/PWGLF/Tasks/Nuspex/piKpRAA.cxx index c45074ecae0..c6bed5c270e 100644 --- a/PWGLF/Tasks/Nuspex/piKpRAA.cxx +++ b/PWGLF/Tasks/Nuspex/piKpRAA.cxx @@ -369,8 +369,8 @@ struct PiKpRAA { const AxisSpec axisPt{binsPt, "#it{p}_{T} (GeV/#it{c})"}; const AxisSpec axisPtV0s{binsPtV0s, "#it{p}_{T} (GeV/#it{c})"}; const AxisSpec axisCent{binsCent, "Centrality Perc."}; - const auto latexEta = (std::vector)vecLatexEta; - const auto endingEta = (std::vector)vecEndingEta; + const auto latexEta = std::vector(vecLatexEta); + const auto endingEta = std::vector(vecEndingEta); registry.add("EventCounter", ";;Events", kTH1F, {axisEvent}); registry.add("HasBCVsFT0VsTVXVsEvSel", "Alls=1 | BC=2 | FT0=3 | TVX=4 | EvSel=5;;", kTH1F, {{5, 0.5, 5.5}}); @@ -691,8 +691,8 @@ struct PiKpRAA { LOG(info) << "\tdcaSelectionsLoaded=" << cfgDCA.dcaSelectionsLoaded; } - auto vecLowEtaSel = (std::vector)vecLowEta; - auto vecUpEtaSel = (std::vector)vecUpEta; + auto vecLowEtaSel = std::vector(vecLowEta); + auto vecUpEtaSel = std::vector(vecUpEta); LOGF(info, "vecLowEta: %s", printArray(vecLowEtaSel).c_str()); LOGF(info, "vecUpEta: %s", printArray(vecUpEtaSel).c_str()); LOGF(info, "vecEndingEta: %s", printArray(endingEta).c_str()); @@ -705,8 +705,8 @@ struct PiKpRAA { // Table's size: " << collisions.tableSize() << "\n"; // LOG(info) << "Run number: " << foundBC.runNumber() << "\n"; - const auto& kLowEta = (std::vector)vecLowEta; - const auto& kHighEta = (std::vector)vecUpEta; + const auto& kLowEta = std::vector(vecLowEta); + const auto& kHighEta = std::vector(vecUpEta); const auto& foundBC = collision.foundBC_as(); const uint64_t timeStamp{foundBC.timestamp()}; @@ -1297,8 +1297,8 @@ struct PiKpRAA { void processSignalLoss(aod::McCollisions::iterator const& mccollision, soa::SmallGroups const& collisions, BCsRun3 const& /*bcs*/, aod::FT0s const& /*ft0s*/, aod::McParticles const& mcParticles, TracksMC const& tracksMC) { - const auto& kLowEta = (std::vector)vecLowEta; - const auto& kHighEta = (std::vector)vecUpEta; + const auto& kLowEta = std::vector(vecLowEta); + const auto& kHighEta = std::vector(vecUpEta); registry.fill(HIST("EventCounterMC"), 0.5); //--------------------------- diff --git a/PWGLF/Tasks/QC/efficiencyQA.cxx b/PWGLF/Tasks/QC/efficiencyQA.cxx index 822b6bb24b6..e54f06ce874 100644 --- a/PWGLF/Tasks/QC/efficiencyQA.cxx +++ b/PWGLF/Tasks/QC/efficiencyQA.cxx @@ -507,7 +507,7 @@ struct efficiencyQA { probe.collIndex = probeTrack.collisionId(); if (probeTrack.has_collision()) { auto collisionIts = probeTrack.template collision_as(); - probe.bcIndex = int64_t(collisionIts.bcId()); + probe.bcIndex = static_cast(collisionIts.bcId()); } else { continue; // TODO: check ambiguous tracks (?) } @@ -529,7 +529,7 @@ struct efficiencyQA { continue; } auto collisionTpc = tpcTrack.template collision_as(); - auto bcTpc = int64_t(collisionTpc.bcId()); + auto bcTpc = static_cast(collisionTpc.bcId()); float tdiff = (bcTpc - probe.bcIndex) * LHCBunchSpacingNS + tpcTrack.trackTime() - probe.time; float nsigmaT = tdiff / std::sqrt(std::pow(tpcTrack.trackTimeRes(), 2) + std::pow(probe.timeRes, 2)); if (nsigmaT > trackTimingCut) { @@ -707,7 +707,7 @@ struct efficiencyQA { histos.fill(HIST("collTpcV0"), tpcTrack.collisionId() - collision.globalIndex()); auto collisionTpc = tpcTrack.template collision_as(); - float tdiff = (int64_t(collisionTpc.bcId()) - probeTrack.bcIndex) * LHCBunchSpacingNS + tpcTrack.trackTime() - probeTrack.time; + float tdiff = (static_cast(collisionTpc.bcId()) - probeTrack.bcIndex) * LHCBunchSpacingNS + tpcTrack.trackTime() - probeTrack.time; float nsigmaT = tdiff / std::sqrt(std::pow(tpcTrack.trackTimeRes(), 2) + std::pow(probeTrack.timeRes, 2)); histos.fill(HIST("timeTpcIts"), nsigmaT); histos.fill(HIST("timeTpcItsNoNorm"), tdiff); diff --git a/PWGLF/Tasks/QC/findableStudy.cxx b/PWGLF/Tasks/QC/findableStudy.cxx index fe04a591831..36dfe4ecde9 100644 --- a/PWGLF/Tasks/QC/findableStudy.cxx +++ b/PWGLF/Tasks/QC/findableStudy.cxx @@ -319,17 +319,17 @@ struct findableStudy { histos.fill(HIST("hFoundVsTracksOK"), nTrackOK && pTrackOK, recv0.isFound()); // encode conditions of tracks - uint8_t positiveTrackCode = ((uint8_t(pTrack.hasTPC()) << hasTPC) | - (uint8_t(pTrack.hasITSTracker()) << hasITSTracker) | - (uint8_t(pTrack.hasITSAfterburner()) << hasITSAfterburner) | - (uint8_t(pTrack.hasTRD()) << hasTRD) | - (uint8_t(pTrack.hasTOF()) << hasTOF)); - - uint8_t negativeTrackCode = ((uint8_t(nTrack.hasTPC()) << hasTPC) | - (uint8_t(nTrack.hasITSTracker()) << hasITSTracker) | - (uint8_t(nTrack.hasITSAfterburner()) << hasITSAfterburner) | - (uint8_t(nTrack.hasTRD()) << hasTRD) | - (uint8_t(nTrack.hasTOF()) << hasTOF)); + uint8_t positiveTrackCode = ((static_cast(pTrack.hasTPC()) << hasTPC) | + (static_cast(pTrack.hasITSTracker()) << hasITSTracker) | + (static_cast(pTrack.hasITSAfterburner()) << hasITSAfterburner) | + (static_cast(pTrack.hasTRD()) << hasTRD) | + (static_cast(pTrack.hasTOF()) << hasTOF)); + + uint8_t negativeTrackCode = ((static_cast(nTrack.hasTPC()) << hasTPC) | + (static_cast(nTrack.hasITSTracker()) << hasITSTracker) | + (static_cast(nTrack.hasITSAfterburner()) << hasITSAfterburner) | + (static_cast(nTrack.hasTRD()) << hasTRD) | + (static_cast(nTrack.hasTOF()) << hasTOF)); if (pTrackOK && nTrackOK && ptmc > 1.0 && ptmc < 1.1) { // this particular V0 reco entry has been acceptably tracked. Do bookkeeping @@ -357,7 +357,7 @@ struct findableStudy { uint64_t selMap = v0data::computeReconstructionBitmap(recv0, pTrack, nTrack, coll, recv0.yLambda(), recv0.yK0Short(), v0Selections); // Consider in all cases - selMap = selMap | (uint64_t(1) << v0data::selConsiderK0Short) | (uint64_t(1) << v0data::selConsiderLambda) | (uint64_t(1) << v0data::selConsiderAntiLambda); + selMap = selMap | (static_cast(1) << v0data::selConsiderK0Short) | (static_cast(1) << v0data::selConsiderLambda) | (static_cast(1) << v0data::selConsiderAntiLambda); // selection checker: ensure this works on subset of actual svertexer-findable bool validTrackProperties = v0Selections->verifyMask(selMap, maskTrackProperties) && pTrackOK && nTrackOK; @@ -373,12 +373,12 @@ struct findableStudy { bool validThisSpecies = v0Selections->verifyMask(selMap, thisSpeciesMask); // specific selection (not cumulative) - topoV0RadiusOK = v0Selections->verifyMask(selMap, uint64_t(1) << v0data::selRadius); - topoV0RadiusMaxOK = v0Selections->verifyMask(selMap, uint64_t(1) << v0data::selRadiusMax); - topoV0CosPAOK = v0Selections->verifyMask(selMap, uint64_t(1) << v0data::selCosPA); - topoDcaPosToPVOK = v0Selections->verifyMask(selMap, uint64_t(1) << v0data::selDCAPosToPV); - topoDcaNegToPVOK = v0Selections->verifyMask(selMap, uint64_t(1) << v0data::selDCANegToPV); - topoDcaV0DauOK = v0Selections->verifyMask(selMap, uint64_t(1) << v0data::selDCAV0Dau); + topoV0RadiusOK = v0Selections->verifyMask(selMap, static_cast(1) << v0data::selRadius); + topoV0RadiusMaxOK = v0Selections->verifyMask(selMap, static_cast(1) << v0data::selRadiusMax); + topoV0CosPAOK = v0Selections->verifyMask(selMap, static_cast(1) << v0data::selCosPA); + topoDcaPosToPVOK = v0Selections->verifyMask(selMap, static_cast(1) << v0data::selDCAPosToPV); + topoDcaNegToPVOK = v0Selections->verifyMask(selMap, static_cast(1) << v0data::selDCANegToPV); + topoDcaV0DauOK = v0Selections->verifyMask(selMap, static_cast(1) << v0data::selDCAV0Dau); // trackTPCRowsOK = v0Selections->verifyMask(selMap, (uint64_t(1) << v0data::selPosGoodTPCTrack) | (uint64_t(1) << v0data::selNegGoodTPCTrack) ); // uint64_t tpcPidMask = (uint64_t(1) << v0data::selTPCPIDPositivePion) | (uint64_t(1) << v0data::selTPCPIDNegativePion); diff --git a/PWGLF/Tasks/QC/straRecoStudy.cxx b/PWGLF/Tasks/QC/straRecoStudy.cxx index 4eddea21f14..3bc0c6e6740 100644 --- a/PWGLF/Tasks/QC/straRecoStudy.cxx +++ b/PWGLF/Tasks/QC/straRecoStudy.cxx @@ -99,20 +99,20 @@ struct preProcessMCcollisions { void init(InitContext const&) { - const AxisSpec axisNTimesCollRecoed{(int)10, -0.5f, +9.5f, ""}; - const AxisSpec axisTrackCount{(int)50, -0.5f, +49.5f, ""}; - const AxisSpec axisContributors{(int)200, -0.5f, +199.5f, ""}; - const AxisSpec axisContributorsTRD{(int)200, -0.5f, +199.5f, "N_{contribs}^{TRD}"}; - const AxisSpec axisContributorsTOF{(int)200, -0.5f, +199.5f, "N_{contribs}^{TOF}"}; - const AxisSpec axisCovariance{(int)400, 0.0f, +0.1f, ""}; - const AxisSpec axisCovarianceTest{(int)400, -0.05f, +0.05f, ""}; - const AxisSpec axisTwenty{(int)20, -0.5f, +19.5f, ""}; - const AxisSpec axisTwentyWithNegative{(int)20, -10.5, +9.5f, ""}; - const AxisSpec axisTwentyFloatWithNegative{(int)100, -10.0f, +10.0f, ""}; - - const AxisSpec axisPVResolutionXY{(int)400, 0.0f, +0.05f, ""}; - const AxisSpec axisPVResolutionZ{(int)400, -0.1f, +0.1f, ""}; - const AxisSpec axisPVResolutionT{(int)500, -20.0f, +20.0f, ""}; + const AxisSpec axisNTimesCollRecoed{10, -0.5f, +9.5f, ""}; + const AxisSpec axisTrackCount{50, -0.5f, +49.5f, ""}; + const AxisSpec axisContributors{200, -0.5f, +199.5f, ""}; + const AxisSpec axisContributorsTRD{200, -0.5f, +199.5f, "N_{contribs}^{TRD}"}; + const AxisSpec axisContributorsTOF{200, -0.5f, +199.5f, "N_{contribs}^{TOF}"}; + const AxisSpec axisCovariance{400, 0.0f, +0.1f, ""}; + const AxisSpec axisCovarianceTest{400, -0.05f, +0.05f, ""}; + const AxisSpec axisTwenty{20, -0.5f, +19.5f, ""}; + const AxisSpec axisTwentyWithNegative{20, -10.5, +9.5f, ""}; + const AxisSpec axisTwentyFloatWithNegative{100, -10.0f, +10.0f, ""}; + + const AxisSpec axisPVResolutionXY{400, 0.0f, +0.05f, ""}; + const AxisSpec axisPVResolutionZ{400, -0.1f, +0.1f, ""}; + const AxisSpec axisPVResolutionT{500, -20.0f, +20.0f, ""}; histos.add("hNTimesCollRecoed", "hNTimesCollRecoed", kTH1F, {axisNTimesCollRecoed}); histos.add("hNTimesCollWithXiRecoed", "hNTimesCollWithXiRecoed", kTH1F, {axisNTimesCollRecoed}); @@ -353,12 +353,12 @@ struct straRecoStudy { void init(InitContext const&) { - const AxisSpec axisEventSelection{(int)10, -0.5f, +9.5f, ""}; + const AxisSpec axisEventSelection{10, -0.5f, +9.5f, ""}; histos.add("hEventSelection", "hEventSelection", kTH1F, {axisEventSelection}); // Creation of axes - const AxisSpec axisVsPt{(int)NBinsPt, 0, MaxPt, "#it{p}_{T} (GeV/c)"}; - const AxisSpec axisVsPtCoarse{(int)NBinsPtCoarse, 0, MaxPt, "#it{p}_{T} (GeV/c)"}; + const AxisSpec axisVsPt{NBinsPt.value, 0, MaxPt, "#it{p}_{T} (GeV/c)"}; + const AxisSpec axisVsPtCoarse{NBinsPtCoarse.value, 0, MaxPt, "#it{p}_{T} (GeV/c)"}; const AxisSpec axisGammaMass{400, 0.000f, 0.400f, "Inv. Mass (GeV/c^{2})"}; const AxisSpec axisK0ShortMass{400, 0.400f, 0.600f, "Inv. Mass (GeV/c^{2})"}; @@ -377,8 +377,8 @@ struct straRecoStudy { const AxisSpec axisTPCCroRo{160, -0.5f, +159.5f, "TPC crossed rows"}; // bit packed ITS cluster map - const AxisSpec axisITSCluMap{(int)128, -0.5f, +127.5f, "Packed ITS map"}; - const AxisSpec axisRadius{(int)160, 0.0f, +80.0f, "Radius (cm)"}; + const AxisSpec axisITSCluMap{128, -0.5f, +127.5f, "Packed ITS map"}; + const AxisSpec axisRadius{160, 0.0f, +80.0f, "Radius (cm)"}; TString lSpecies[] = {"Gamma", "K0Short", "Lambda", "AntiLambda", "XiMinus", "XiPlus", "OmegaMinus", "OmegaPlus"}; const AxisSpec lMassAxis[] = {axisGammaMass, axisK0ShortMass, axisLambdaMass, axisLambdaMass, axisXiMass, axisXiMass, axisOmegaMass, axisOmegaMass}; @@ -566,8 +566,8 @@ struct straRecoStudy { // MC association auto posPartTrack = v0.posTrack_as(); auto negPartTrack = v0.negTrack_as(); - histos.fill(HIST("h2dITSCluMap_V0Positive"), (float)posPartTrack.itsClusterMap(), v0.v0radius()); - histos.fill(HIST("h2dITSCluMap_V0Negative"), (float)negPartTrack.itsClusterMap(), v0.v0radius()); + histos.fill(HIST("h2dITSCluMap_V0Positive"), static_cast(posPartTrack.itsClusterMap()), v0.v0radius()); + histos.fill(HIST("h2dITSCluMap_V0Negative"), static_cast(negPartTrack.itsClusterMap()), v0.v0radius()); if (posPartTrack.itsNCls() < itsminclusters || negPartTrack.itsNCls() < itsminclusters) continue; @@ -717,9 +717,9 @@ struct straRecoStudy { auto posPartTrack = casc.posTrack_as(); auto negPartTrack = casc.negTrack_as(); - histos.fill(HIST("h2dITSCluMap_CascPositive"), (float)posPartTrack.itsClusterMap(), casc.v0radius()); - histos.fill(HIST("h2dITSCluMap_CascNegative"), (float)negPartTrack.itsClusterMap(), casc.v0radius()); - histos.fill(HIST("h2dITSCluMap_CascBachelor"), (float)bachPartTrack.itsClusterMap(), casc.cascradius()); + histos.fill(HIST("h2dITSCluMap_CascPositive"), static_cast(posPartTrack.itsClusterMap()), casc.v0radius()); + histos.fill(HIST("h2dITSCluMap_CascNegative"), static_cast(negPartTrack.itsClusterMap()), casc.v0radius()); + histos.fill(HIST("h2dITSCluMap_CascBachelor"), static_cast(bachPartTrack.itsClusterMap()), casc.cascradius()); if (casc.sign() < 0) { histos.fill(HIST("h3dTrackPtsXiMinusP"), casc.pt(), posPartTrack.itsNCls(), posPartTrack.tpcNClsCrossedRows()); diff --git a/PWGLF/Tasks/QC/strangenessQCPP.cxx b/PWGLF/Tasks/QC/strangenessQCPP.cxx index 818de36a0b7..6806f0e22ba 100644 --- a/PWGLF/Tasks/QC/strangenessQCPP.cxx +++ b/PWGLF/Tasks/QC/strangenessQCPP.cxx @@ -94,7 +94,7 @@ struct strangenessQCPP { ConfigurableAxis binCosPA{"binCosPA", {200, 0.8f, 1.0f}, ""}; ConfigurableAxis binEtaSmall{"binEtaSmall", {2, -1.0f, 1.0f}, ""}; ConfigurableAxis binEta{"binEta", {100, -1.0f, 1.0f}, ""}; - ConfigurableAxis binPhi{"binPhi", {(int)TMath::Pi() * 10 / 2, 0.0f, 2. * TMath::Pi()}, ""}; + ConfigurableAxis binPhi{"binPhi", {static_cast(TMath::Pi()) * 10 / 2, 0.0f, 2. * TMath::Pi()}, ""}; ConfigurableAxis binRadius{"binRadius", {100, 0.0f, 50.0f}, ""}; ConfigurableAxis binRadiussmall{"binRadiussmall", {30, 0.0f, 30.0f}, ""}; ConfigurableAxis binITSMapDaughters{"binITSMapDaughters", {8, -0.5f, 7.5f}, ""}; diff --git a/PWGLF/Tasks/QC/strderivedGenQA.cxx b/PWGLF/Tasks/QC/strderivedGenQA.cxx index b9223226614..884ebac31d0 100644 --- a/PWGLF/Tasks/QC/strderivedGenQA.cxx +++ b/PWGLF/Tasks/QC/strderivedGenQA.cxx @@ -734,17 +734,17 @@ struct strderivedGenQA { auto posTrack = v0.template posTrackExtra_as(); auto negTrack = v0.template negTrackExtra_as(); - uint8_t positiveTrackCode = ((uint8_t(posTrack.hasTPC()) << hasTPC) | - (uint8_t(posTrack.hasITSTracker()) << hasITSTracker) | - (uint8_t(posTrack.hasITSAfterburner()) << hasITSAfterburner) | - (uint8_t(posTrack.hasTRD()) << hasTRD) | - (uint8_t(posTrack.hasTOF()) << hasTOF)); - - uint8_t negativeTrackCode = ((uint8_t(negTrack.hasTPC()) << hasTPC) | - (uint8_t(negTrack.hasITSTracker()) << hasITSTracker) | - (uint8_t(negTrack.hasITSAfterburner()) << hasITSAfterburner) | - (uint8_t(negTrack.hasTRD()) << hasTRD) | - (uint8_t(negTrack.hasTOF()) << hasTOF)); + uint8_t positiveTrackCode = ((static_cast(posTrack.hasTPC()) << hasTPC) | + (static_cast(posTrack.hasITSTracker()) << hasITSTracker) | + (static_cast(posTrack.hasITSAfterburner()) << hasITSAfterburner) | + (static_cast(posTrack.hasTRD()) << hasTRD) | + (static_cast(posTrack.hasTOF()) << hasTOF)); + + uint8_t negativeTrackCode = ((static_cast(negTrack.hasTPC()) << hasTPC) | + (static_cast(negTrack.hasITSTracker()) << hasITSTracker) | + (static_cast(negTrack.hasITSAfterburner()) << hasITSAfterburner) | + (static_cast(negTrack.hasTRD()) << hasTRD) | + (static_cast(negTrack.hasTOF()) << hasTOF)); histos.fill(HIST("V0/Track/h2dITSNCls"), v0.positivept(), posTrack.itsNCls()); histos.fill(HIST("V0/Track/h2dITSNCls"), -1 * v0.negativept(), negTrack.itsNCls()); @@ -897,23 +897,23 @@ struct strderivedGenQA { auto posTrack = casc.template posTrackExtra_as(); auto bachTrack = casc.template bachTrackExtra_as(); - uint8_t positiveTrackCode = ((uint8_t(posTrack.hasTPC()) << hasTPC) | - (uint8_t(posTrack.hasITSTracker()) << hasITSTracker) | - (uint8_t(posTrack.hasITSAfterburner()) << hasITSAfterburner) | - (uint8_t(posTrack.hasTRD()) << hasTRD) | - (uint8_t(posTrack.hasTOF()) << hasTOF)); - - uint8_t negativeTrackCode = ((uint8_t(negTrack.hasTPC()) << hasTPC) | - (uint8_t(negTrack.hasITSTracker()) << hasITSTracker) | - (uint8_t(negTrack.hasITSAfterburner()) << hasITSAfterburner) | - (uint8_t(negTrack.hasTRD()) << hasTRD) | - (uint8_t(negTrack.hasTOF()) << hasTOF)); - - uint8_t bachTrackCode = ((uint8_t(bachTrack.hasTPC()) << hasTPC) | - (uint8_t(bachTrack.hasITSTracker()) << hasITSTracker) | - (uint8_t(bachTrack.hasITSAfterburner()) << hasITSAfterburner) | - (uint8_t(bachTrack.hasTRD()) << hasTRD) | - (uint8_t(bachTrack.hasTOF()) << hasTOF)); + uint8_t positiveTrackCode = ((static_cast(posTrack.hasTPC()) << hasTPC) | + (static_cast(posTrack.hasITSTracker()) << hasITSTracker) | + (static_cast(posTrack.hasITSAfterburner()) << hasITSAfterburner) | + (static_cast(posTrack.hasTRD()) << hasTRD) | + (static_cast(posTrack.hasTOF()) << hasTOF)); + + uint8_t negativeTrackCode = ((static_cast(negTrack.hasTPC()) << hasTPC) | + (static_cast(negTrack.hasITSTracker()) << hasITSTracker) | + (static_cast(negTrack.hasITSAfterburner()) << hasITSAfterburner) | + (static_cast(negTrack.hasTRD()) << hasTRD) | + (static_cast(negTrack.hasTOF()) << hasTOF)); + + uint8_t bachTrackCode = ((static_cast(bachTrack.hasTPC()) << hasTPC) | + (static_cast(bachTrack.hasITSTracker()) << hasITSTracker) | + (static_cast(bachTrack.hasITSAfterburner()) << hasITSAfterburner) | + (static_cast(bachTrack.hasTRD()) << hasTRD) | + (static_cast(bachTrack.hasTOF()) << hasTOF)); histos.fill(HIST("Casc/Track/h3dTrackProperties"), positiveTrackCode, negativeTrackCode, bachTrackCode); // complete tracking info histos.fill(HIST("Casc/Track/h2dPosTrackProperties"), positiveTrackCode, casc.positivept()); // positive track info diff --git a/PWGLF/Tasks/Resonances/f1protoncorrelation.cxx b/PWGLF/Tasks/Resonances/f1protoncorrelation.cxx index ead7c9b294f..e630cd65d14 100644 --- a/PWGLF/Tasks/Resonances/f1protoncorrelation.cxx +++ b/PWGLF/Tasks/Resonances/f1protoncorrelation.cxx @@ -196,21 +196,21 @@ struct f1protoncorrelation { auto packCode = [&](const std::array& idx) -> uint32_t { uint32_t code = 0u; for (int k = 0; k < 14; ++k) { - code |= (uint32_t(idx[k] & 0x3) << (2 * k)); + code |= (static_cast(idx[k] & 0x3) << (2 * k)); } return code; }; sysCuts.clear(); - sysCuts.reserve(1 + (size_t)nSysRand); + sysCuts.reserve(1 + static_cast(nSysRand)); sysCuts.push_back(def); // sysId=0 std::unordered_set used; - used.reserve((size_t)nSysRand * 2); + used.reserve(static_cast(nSysRand) * 2); used.insert(0u); // all-default code - const int nPick = std::max(0, (int)nSysRand); - while ((int)sysCuts.size() < 1 + nPick) { + const int nPick = std::max(0, nSysRand.value); + while (static_cast(sysCuts.size()) < 1 + nPick) { std::array idx{}; for (int k = 0; k < 14; ++k) @@ -230,7 +230,7 @@ struct f1protoncorrelation { idx[11], idx[12], idx[13])); } - nSysTotal = (int)sysCuts.size(); + nSysTotal = static_cast(sysCuts.size()); } // ------------------------- @@ -242,9 +242,9 @@ struct f1protoncorrelation { return false; if (std::abs(dcaz) > c.maxDcaz) return false; - if ((int)ncrs < c.minTPCCrossedRows) + if (static_cast(ncrs) < c.minTPCCrossedRows) return false; - if ((int)ncls < c.minTPCClusters) + if (static_cast(ncls) < c.minTPCClusters) return false; return true; } @@ -390,9 +390,9 @@ struct f1protoncorrelation { { buildSystematicCuts(); - nSysTotal = (int)sysCuts.size(); // or whatever vector you fill + nSysTotal = static_cast(sysCuts.size()); // or whatever vector you fill LOGF(info, "sysCuts.size()=%zu nSysTotal=%d", sysCuts.size(), nSysTotal); - const AxisSpec thnAxisSys{nSysTotal, -0.5f, float(nSysTotal) - 0.5f, "sysId"}; + const AxisSpec thnAxisSys{nSysTotal, -0.5f, static_cast(nSysTotal) - 0.5f, "sysId"}; const AxisSpec thnAxisInvMass{configThnAxisInvMass, "#it{M} (GeV/#it{c}^{2})"}; const AxisSpec thnAxisPt{configThnAxisPt, "#it{p}_{T} (GeV/#it{c})"}; const AxisSpec thnAxisMt{configThnAxisMt, "#it{M}_{T} (GeV/#it{c})"}; @@ -988,7 +988,7 @@ struct f1protoncorrelation { if (F1.Pt() < lowPtF1 || F1.Pt() > 50.0) continue; std::vector activeSys; - activeSys.reserve((size_t)nSysTotal); + activeSys.reserve(static_cast(nSysTotal)); for (int sysId = 0; sysId < nSysTotal; ++sysId) { const auto& sc = sysCuts[sysId]; @@ -1134,7 +1134,7 @@ struct f1protoncorrelation { auto mT = getmT(F1, Proton); // sys list for this (F1, p) pair std::vector activePair; - activePair.reserve((size_t)nSysTotal); + activePair.reserve(static_cast(nSysTotal)); for (int sysId = 0; sysId < nSysTotal; ++sysId) { const auto& sc = sysCuts[sysId]; diff --git a/PWGLF/Tasks/Resonances/hResonanceCorrelation.cxx b/PWGLF/Tasks/Resonances/hResonanceCorrelation.cxx index 5d8989567fe..35280ff36b2 100644 --- a/PWGLF/Tasks/Resonances/hResonanceCorrelation.cxx +++ b/PWGLF/Tasks/Resonances/hResonanceCorrelation.cxx @@ -430,29 +430,29 @@ struct HResonanceCorrelation { LOG(fatal) << "Problem getting TList object with efficiencies!"; } - hEfficiencyTrigger = static_cast(listEfficiencies->FindObject("hEfficiencyTrigger")); - hEfficiencyTriggerMult = static_cast(listEfficiencies->FindObject("hEfficiencyTriggerMult")); - hEfficiencyTriggerMultVsPhi = static_cast(listEfficiencies->FindObject("hEfficiencyTriggerMultVsPhi")); - hEfficiencyPhi = static_cast(listEfficiencies->FindObject("hEfficiencyPhi")); - hEfficiencyPhiMultVsPhi = static_cast(listEfficiencies->FindObject("hEfficiencyPhiMultVsPhi")); - hEfficiencyKstar = static_cast(listEfficiencies->FindObject("hEfficiencyKstar")); - hEfficiencyKstarMultVsPhi = static_cast(listEfficiencies->FindObject("hEfficiencyKstarMultVsPhi")); - hEfficiencyHadron = static_cast(listEfficiencies->FindObject("hEfficiencyHadron")); - hEfficiencyHadronMult = static_cast(listEfficiencies->FindObject("hEfficiencyHadronMult")); - hEfficiencyPion = static_cast(listEfficiencies->FindObject("hEfficiencyPion")); - hEfficiencyKaon = static_cast(listEfficiencies->FindObject("hEfficiencyKaon")); - hPurityHadron = static_cast(listEfficiencies->FindObject("hPurityHadron")); - hPurityHadronMult = static_cast(listEfficiencies->FindObject("hPurityHadronMult")); - hEfficiencyUncertaintyTrigger = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyTrigger")); - hEfficiencyUncertaintyTriggerMult = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyTriggerMult")); - hEfficiencyUncertaintyPhi = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyPhi")); - hEfficiencyUncertaintyKstar = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyKstar")); - hEfficiencyUncertaintyPion = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyPion")); - hEfficiencyUncertaintyKaon = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyKaon")); - hEfficiencyUncertaintyHadron = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyHadron")); - hEfficiencyUncertaintyHadronMult = static_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyHadronMult")); - hPurityUncertaintyHadron = static_cast(listEfficiencies->FindObject("hPurityUncertaintyHadron")); - hPurityUncertaintyHadronMult = static_cast(listEfficiencies->FindObject("hPurityUncertaintyHadronMult")); + hEfficiencyTrigger = dynamic_cast(listEfficiencies->FindObject("hEfficiencyTrigger")); + hEfficiencyTriggerMult = dynamic_cast(listEfficiencies->FindObject("hEfficiencyTriggerMult")); + hEfficiencyTriggerMultVsPhi = dynamic_cast(listEfficiencies->FindObject("hEfficiencyTriggerMultVsPhi")); + hEfficiencyPhi = dynamic_cast(listEfficiencies->FindObject("hEfficiencyPhi")); + hEfficiencyPhiMultVsPhi = dynamic_cast(listEfficiencies->FindObject("hEfficiencyPhiMultVsPhi")); + hEfficiencyKstar = dynamic_cast(listEfficiencies->FindObject("hEfficiencyKstar")); + hEfficiencyKstarMultVsPhi = dynamic_cast(listEfficiencies->FindObject("hEfficiencyKstarMultVsPhi")); + hEfficiencyHadron = dynamic_cast(listEfficiencies->FindObject("hEfficiencyHadron")); + hEfficiencyHadronMult = dynamic_cast(listEfficiencies->FindObject("hEfficiencyHadronMult")); + hEfficiencyPion = dynamic_cast(listEfficiencies->FindObject("hEfficiencyPion")); + hEfficiencyKaon = dynamic_cast(listEfficiencies->FindObject("hEfficiencyKaon")); + hPurityHadron = dynamic_cast(listEfficiencies->FindObject("hPurityHadron")); + hPurityHadronMult = dynamic_cast(listEfficiencies->FindObject("hPurityHadronMult")); + hEfficiencyUncertaintyTrigger = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyTrigger")); + hEfficiencyUncertaintyTriggerMult = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyTriggerMult")); + hEfficiencyUncertaintyPhi = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyPhi")); + hEfficiencyUncertaintyKstar = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyKstar")); + hEfficiencyUncertaintyPion = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyPion")); + hEfficiencyUncertaintyKaon = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyKaon")); + hEfficiencyUncertaintyHadron = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyHadron")); + hEfficiencyUncertaintyHadronMult = dynamic_cast(listEfficiencies->FindObject("hEfficiencyUncertaintyHadronMult")); + hPurityUncertaintyHadron = dynamic_cast(listEfficiencies->FindObject("hPurityUncertaintyHadron")); + hPurityUncertaintyHadronMult = dynamic_cast(listEfficiencies->FindObject("hPurityUncertaintyHadronMult")); if (efficiencyFlags.applyEfficiencyPropagation && !efficiencyFlags.applyEffAsFunctionOfMultAndPhi && !hEfficiencyUncertaintyTrigger) LOG(fatal) << "Problem getting hEfficiencyUncertaintyTrigger!"; if (efficiencyFlags.applyEffAsFunctionOfMult && !hEfficiencyTriggerMult) diff --git a/PWGLF/Tasks/Resonances/lambda1520analysisinOO.cxx b/PWGLF/Tasks/Resonances/lambda1520analysisinOO.cxx index 413690fc58c..4c176e64e11 100644 --- a/PWGLF/Tasks/Resonances/lambda1520analysisinOO.cxx +++ b/PWGLF/Tasks/Resonances/lambda1520analysisinOO.cxx @@ -422,14 +422,14 @@ struct Lstaranalysis { float massKa = MassKaonCharged; float massPr = MassProton; - int kLambda1520PDG = static_cast(102134); // PDG code for Lambda(1520) + int kLambda1520PDG = 102134; // PDG code for Lambda(1520) template float getCentrality(CollisionType const& collision) { - if (cfgCentEst == static_cast(1)) { + if (cfgCentEst == 1) { return collision.multFT0C(); - } else if (cfgCentEst == static_cast(2)) { + } else if (cfgCentEst == 2) { return collision.multFT0M(); } else { return -999; diff --git a/PWGLF/Tasks/Resonances/omega2012TrainingTable.cxx b/PWGLF/Tasks/Resonances/omega2012TrainingTable.cxx index 3d2a397f6d6..dd7f3b2039c 100644 --- a/PWGLF/Tasks/Resonances/omega2012TrainingTable.cxx +++ b/PWGLF/Tasks/Resonances/omega2012TrainingTable.cxx @@ -268,7 +268,7 @@ struct Omega2012TrainingTable { return -1; } const auto row = trackId - static_cast(mcTrackLabelsDf->offset()); - if (row < 0 || row >= static_cast(mcTrackLabelsDf->size())) { + if (row < 0 || row >= mcTrackLabelsDf->size()) { return -1; } return mcTrackLabelsDf->rawIteratorAt(row).mcParticleId(); @@ -283,7 +283,7 @@ struct Omega2012TrainingTable { int64_t row = label; for (int step = 0; step <= MaxAncestorSteps; ++step) { const auto local = row - static_cast(mcParticlesDf->offset()); - if (row < 0 || local < 0 || local >= static_cast(mcParticlesDf->size())) { + if (row < 0 || local < 0 || local >= mcParticlesDf->size()) { return; } const auto particle = mcParticlesDf->rawIteratorAt(local); @@ -551,14 +551,14 @@ struct Omega2012TrainingTable { { mlAncestryRows.clear(); const auto offset = static_cast(mcParticles.offset()); - const auto nRows = static_cast(mcParticles.size()); + const auto nRows = mcParticles.size(); std::unordered_set treeRows; std::vector> stack; for (const auto& parent : mcParticles) { if (std::abs(parent.pdgCode()) != o2::constants::physics::Pdg::kOmega2012Minus) { continue; } - stack.assign(1, {static_cast(parent.globalIndex()), 0}); + stack.assign(1, {parent.globalIndex(), 0}); while (!stack.empty()) { const auto [row, depth] = stack.back(); stack.pop_back(); diff --git a/PWGLF/Tasks/Strangeness/cascadecorrelations.cxx b/PWGLF/Tasks/Strangeness/cascadecorrelations.cxx index d8fbf39ca88..f8b55ae8328 100644 --- a/PWGLF/Tasks/Strangeness/cascadecorrelations.cxx +++ b/PWGLF/Tasks/Strangeness/cascadecorrelations.cxx @@ -666,10 +666,10 @@ struct CascadeCorrelations { if (!effList) { LOGF(fatal, "null ptr in efficiency list!"); } - hEffXiMin = static_cast(effList->FindObject("hXiMinEff")); - hEffXiPlus = static_cast(effList->FindObject("hXiPlusEff")); - hEffOmegaMin = static_cast(effList->FindObject("hOmegaMinEff")); - hEffOmegaPlus = static_cast(effList->FindObject("hOmegaPlusEff")); + hEffXiMin = dynamic_cast(effList->FindObject("hXiMinEff")); + hEffXiPlus = dynamic_cast(effList->FindObject("hXiPlusEff")); + hEffOmegaMin = dynamic_cast(effList->FindObject("hOmegaMinEff")); + hEffOmegaPlus = dynamic_cast(effList->FindObject("hOmegaPlusEff")); } zorroSummary.setObject(zorro.getZorroSummary()); diff --git a/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx b/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx index 1d7a4877abd..80cbffb8279 100644 --- a/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx @@ -1760,68 +1760,68 @@ struct derivedlambdakzeroanalysis { { int bitMap = 0; - if (verifyMask(itsClusMap, ((uint8_t(1) << 0) | (uint8_t(1) << 1) | (uint8_t(1) << 2) | (uint8_t(1) << 3) | (uint8_t(1) << 4) | (uint8_t(1) << 5) | (uint8_t(1) << 6)))) { + if (verifyMask(itsClusMap, ((static_cast(1) << 0) | (static_cast(1) << 1) | (static_cast(1) << 2) | (static_cast(1) << 3) | (static_cast(1) << 4) | (static_cast(1) << 5) | (static_cast(1) << 6)))) { // ITS : IB OB // ITS : L0 L1 L2 L3 L4 L5 L6 // ITS : x x x x x x x bitMap = 12; - } else if (verifyMask(itsClusMap, ((uint8_t(1) << 1) | (uint8_t(1) << 2) | (uint8_t(1) << 3) | (uint8_t(1) << 4) | (uint8_t(1) << 5) | (uint8_t(1) << 6)))) { + } else if (verifyMask(itsClusMap, ((static_cast(1) << 1) | (static_cast(1) << 2) | (static_cast(1) << 3) | (static_cast(1) << 4) | (static_cast(1) << 5) | (static_cast(1) << 6)))) { // ITS : IB OB // ITS : L0 L1 L2 L3 L4 L5 L6 // ITS : x x x x x x bitMap = 11; - } else if (verifyMask(itsClusMap, ((uint8_t(1) << 2) | (uint8_t(1) << 3) | (uint8_t(1) << 4) | (uint8_t(1) << 5) | (uint8_t(1) << 6)))) { + } else if (verifyMask(itsClusMap, ((static_cast(1) << 2) | (static_cast(1) << 3) | (static_cast(1) << 4) | (static_cast(1) << 5) | (static_cast(1) << 6)))) { // ITS : IB OB // ITS : L0 L1 L2 L3 L4 L5 L6 // ITS : x x x x x bitMap = 10; - } else if (verifyMask(itsClusMap, ((uint8_t(1) << 3) | (uint8_t(1) << 4) | (uint8_t(1) << 5) | (uint8_t(1) << 6)))) { + } else if (verifyMask(itsClusMap, ((static_cast(1) << 3) | (static_cast(1) << 4) | (static_cast(1) << 5) | (static_cast(1) << 6)))) { // ITS : IB OB // ITS : L0 L1 L2 L3 L4 L5 L6 // ITS : x x x x bitMap = 9; if (fromAfterburner) bitMap = -3; - } else if (verifyMask(itsClusMap, ((uint8_t(1) << 4) | (uint8_t(1) << 5) | (uint8_t(1) << 6)))) { + } else if (verifyMask(itsClusMap, ((static_cast(1) << 4) | (static_cast(1) << 5) | (static_cast(1) << 6)))) { // ITS : IB OB // ITS : L0 L1 L2 L3 L4 L5 L6 // ITS : x x x bitMap = 8; if (fromAfterburner) bitMap = -2; - } else if (verifyMask(itsClusMap, ((uint8_t(1) << 5) | (uint8_t(1) << 6)))) { + } else if (verifyMask(itsClusMap, ((static_cast(1) << 5) | (static_cast(1) << 6)))) { // ITS : IB OB // ITS : L0 L1 L2 L3 L4 L5 L6 // ITS : x x bitMap = 7; if (fromAfterburner) bitMap = -1; - } else if (verifyMask(itsClusMap, ((uint8_t(1) << 0) | (uint8_t(1) << 1) | (uint8_t(1) << 2) | (uint8_t(1) << 3) | (uint8_t(1) << 4) | (uint8_t(1) << 5)))) { + } else if (verifyMask(itsClusMap, ((static_cast(1) << 0) | (static_cast(1) << 1) | (static_cast(1) << 2) | (static_cast(1) << 3) | (static_cast(1) << 4) | (static_cast(1) << 5)))) { // ITS : IB OB // ITS : L0 L1 L2 L3 L4 L5 L6 // ITS : x x x x x x bitMap = 6; - } else if (verifyMask(itsClusMap, ((uint8_t(1) << 1) | (uint8_t(1) << 2) | (uint8_t(1) << 3) | (uint8_t(1) << 4) | (uint8_t(1) << 5)))) { + } else if (verifyMask(itsClusMap, ((static_cast(1) << 1) | (static_cast(1) << 2) | (static_cast(1) << 3) | (static_cast(1) << 4) | (static_cast(1) << 5)))) { // ITS : IB OB // ITS : L0 L1 L2 L3 L4 L5 L6 // ITS : x x x x x bitMap = 5; - } else if (verifyMask(itsClusMap, ((uint8_t(1) << 2) | (uint8_t(1) << 3) | (uint8_t(1) << 4) | (uint8_t(1) << 5)))) { + } else if (verifyMask(itsClusMap, ((static_cast(1) << 2) | (static_cast(1) << 3) | (static_cast(1) << 4) | (static_cast(1) << 5)))) { // ITS : IB OB // ITS : L0 L1 L2 L3 L4 L5 L6 // ITS : x x x x bitMap = 4; - } else if (verifyMask(itsClusMap, ((uint8_t(1) << 0) | (uint8_t(1) << 1) | (uint8_t(1) << 2) | (uint8_t(1) << 3) | (uint8_t(1) << 4)))) { + } else if (verifyMask(itsClusMap, ((static_cast(1) << 0) | (static_cast(1) << 1) | (static_cast(1) << 2) | (static_cast(1) << 3) | (static_cast(1) << 4)))) { // ITS : IB OB // ITS : L0 L1 L2 L3 L4 L5 L6 // ITS : x x x x x bitMap = 3; - } else if (verifyMask(itsClusMap, ((uint8_t(1) << 1) | (uint8_t(1) << 2) | (uint8_t(1) << 3) | (uint8_t(1) << 4)))) { + } else if (verifyMask(itsClusMap, ((static_cast(1) << 1) | (static_cast(1) << 2) | (static_cast(1) << 3) | (static_cast(1) << 4)))) { // ITS : IB OB // ITS : L0 L1 L2 L3 L4 L5 L6 // ITS : x x x x bitMap = 2; - } else if (verifyMask(itsClusMap, ((uint8_t(1) << 0) | (uint8_t(1) << 1) | (uint8_t(1) << 2) | (uint8_t(1) << 3)))) { + } else if (verifyMask(itsClusMap, ((static_cast(1) << 0) | (static_cast(1) << 1) | (static_cast(1) << 2) | (static_cast(1) << 3)))) { // ITS : IB OB // ITS : L0 L1 L2 L3 L4 L5 L6 // ITS : x x x x diff --git a/PWGLF/Tasks/Strangeness/k0_mixed_events.cxx b/PWGLF/Tasks/Strangeness/k0_mixed_events.cxx index 6790d9e2c57..6e31bbedba4 100644 --- a/PWGLF/Tasks/Strangeness/k0_mixed_events.cxx +++ b/PWGLF/Tasks/Strangeness/k0_mixed_events.cxx @@ -206,7 +206,7 @@ struct K0MixedEvents { Filter pFilter = o2::aod::singletrackselector::p > momentumCut.value.first&& o2::aod::singletrackselector::p < momentumCut.value.second; Filter etaFilter = nabs(o2::aod::singletrackselector::eta) < _eta; - Filter tpcTrkFilter = o2::aod::singletrackselector::tpcNClsFound >= _tpcNClsFound && o2::aod::singletrackselector::tpcNClsShared <= (uint8_t)_tpcNClsShared; + Filter tpcTrkFilter = o2::aod::singletrackselector::tpcNClsFound >= _tpcNClsFound && o2::aod::singletrackselector::tpcNClsShared <= static_cast(_tpcNClsShared); // Filter itsNClsFilter = o2::aod::singletrackselector::itsNCls >= (uint8_t)_itsNCls; diff --git a/PWGLF/Tasks/Strangeness/lambdaspincorrderived.cxx b/PWGLF/Tasks/Strangeness/lambdaspincorrderived.cxx index 1a3b71e02f8..7cb80f9630e 100644 --- a/PWGLF/Tasks/Strangeness/lambdaspincorrderived.cxx +++ b/PWGLF/Tasks/Strangeness/lambdaspincorrderived.cxx @@ -525,7 +525,7 @@ struct lambdaspincorrderived { // sysId = 10 sysCuts.push_back(buildFromIdx(0, 0, 0, 0, 0, 0, 2)); - nSysTotal = (int)sysCuts.size(); + nSysTotal = static_cast(sysCuts.size()); // print all configurations LOGF(info, "========================================"); @@ -600,9 +600,9 @@ struct lambdaspincorrderived { buildSystematicCuts(); - nSysTotal = (int)sysCuts.size(); // or whatever vector you fill + nSysTotal = static_cast(sysCuts.size()); // or whatever vector you fill LOGF(info, "sysCuts.size()=%zu nSysTotal=%d", sysCuts.size(), nSysTotal); - const AxisSpec thnAxisSys{nSysTotal, -0.5f, float(nSysTotal) - 0.5f, "sysId"}; + const AxisSpec thnAxisSys{nSysTotal, -0.5f, static_cast(nSysTotal) - 0.5f, "sysId"}; if (fillHistConfig.fillBasicQAHistos) { histos.add("hPtRadiusV0", "V0 QA;#it{p}_{T}^{V0} (GeV/#it{c});V0 decay radius (cm)", kTH2F, {{100, 0.0, 10.0}, {120, 0.0, 45.0}}); @@ -1032,7 +1032,7 @@ struct lambdaspincorrderived { } } - const float dphi = deltaPhiMinusPiToPi((float)c1.lambdaPhi(), (float)c2.lambdaPhi()); + const float dphi = deltaPhiMinusPiToPi(static_cast(c1.lambdaPhi()), static_cast(c2.lambdaPhi())); if (std::abs(dphi) > phiMix) { return false; } @@ -1857,7 +1857,7 @@ struct lambdaspincorrderived { for (const auto& v0 : V0s) { std::vector activeSys; - activeSys.reserve((size_t)nSysTotal); + activeSys.reserve(static_cast(nSysTotal)); for (int sysId = 0; sysId < nSysTotal; ++sysId) { const auto& sc = sysCuts[sysId]; @@ -2073,7 +2073,7 @@ struct lambdaspincorrderived { // if pool empty, push and continue if (eventPools[bin].empty()) { eventPools[bin].emplace_back(collision1.index(), std::move(poolA)); - if ((int)eventPools[bin].size() > nEvtMixing) { + if (static_cast(eventPools[bin].size()) > nEvtMixing) { eventPools[bin].pop_front(); } continue; @@ -2240,7 +2240,7 @@ struct lambdaspincorrderived { // push current event into pool auto sliced = V0s.sliceBy(tracksPerCollisionV0, collision1.index()); eventPools[bin].emplace_back(collision1.index(), std::move(sliced)); - if ((int)eventPools[bin].size() > nEvtMixing) { + if (static_cast(eventPools[bin].size()) > nEvtMixing) { eventPools[bin].pop_front(); } } @@ -2265,7 +2265,7 @@ struct lambdaspincorrderived { usedEvents.reserve(nMixEvents * 2); for (const auto& m : matches) { - if (usedEvents.count(m.collisionIdx) || (int)usedEvents.size() < nMixEvents) { + if (usedEvents.count(m.collisionIdx) || static_cast(usedEvents.size()) < nMixEvents) { kept.push_back(m); usedEvents.insert(m.collisionIdx); } @@ -2454,7 +2454,7 @@ struct lambdaspincorrderived { fillFixedLegControlMap(repStatus, fixedStatus, 1, false, fixedLambda, controlWeight); if ((repStatus == 0 && fixedStatus == 1) || (repStatus == 1 && fixedStatus == 0)) { if (fillHistConfig.fillBasicQAHistos) { - histos.fill(HIST("deltaPhiMix"), deltaPhiMinusPiToPi((float)repLambda.Phi(), (float)fixedLambda.Phi()), mixWeight); + histos.fill(HIST("deltaPhiMix"), deltaPhiMinusPiToPi(static_cast(repLambda.Phi()), static_cast(fixedLambda.Phi())), mixWeight); } } if (repStatus == 0 && fixedStatus == 1) { @@ -2470,7 +2470,7 @@ struct lambdaspincorrderived { fillReplacementControlMap(fixedStatus, repStatus, 2, false, repLambda, controlWeight); fillFixedLegControlMap(fixedStatus, repStatus, 2, false, fixedLambda, controlWeight); if (fillHistConfig.fillBasicQAHistos) { - histos.fill(HIST("deltaPhiMix"), deltaPhiMinusPiToPi((float)fixedLambda.Phi(), (float)repLambda.Phi()), mixWeight); + histos.fill(HIST("deltaPhiMix"), deltaPhiMinusPiToPi(static_cast(fixedLambda.Phi()), static_cast(repLambda.Phi())), mixWeight); } if (fixedStatus == 0 && repStatus == 1) { fillHistograms(0, 1, fixedLambda, repLambda, fixedProton, repProton, 1, mixWeight, 2, 2); @@ -2559,7 +2559,7 @@ struct lambdaspincorrderived { fillReplacementControlMap(repStatus, fixedStatus, 1, false, repLambda, controlWeight); fillFixedLegControlMap(repStatus, fixedStatus, 1, false, fixedLambda, controlWeight); if (fillHistConfig.fillBasicQAHistos) { - histos.fill(HIST("deltaPhiMix"), deltaPhiMinusPiToPi((float)repLambda.Phi(), (float)fixedLambda.Phi()), mixWeight); + histos.fill(HIST("deltaPhiMix"), deltaPhiMinusPiToPi(static_cast(repLambda.Phi()), static_cast(fixedLambda.Phi())), mixWeight); } if (repStatus == 0 && fixedStatus == 1) { fillHistograms(0, 1, repLambda, fixedLambda, repProton, fixedProton, 1, mixWeight, 1, 1); @@ -2574,7 +2574,7 @@ struct lambdaspincorrderived { fillReplacementControlMap(fixedStatus, repStatus, 2, false, repLambda, controlWeight); fillFixedLegControlMap(fixedStatus, repStatus, 2, false, fixedLambda, controlWeight); if (fillHistConfig.fillBasicQAHistos) { - histos.fill(HIST("deltaPhiMix"), deltaPhiMinusPiToPi((float)fixedLambda.Phi(), (float)repLambda.Phi()), mixWeight); + histos.fill(HIST("deltaPhiMix"), deltaPhiMinusPiToPi(static_cast(fixedLambda.Phi()), static_cast(repLambda.Phi())), mixWeight); } if (fixedStatus == 0 && repStatus == 1) { fillHistograms(0, 1, fixedLambda, repLambda, fixedProton, repProton, 1, mixWeight, 2, 2); @@ -2672,8 +2672,8 @@ struct lambdaspincorrderived { } // delta-phi window (wrapped) - const float dphi = deltaPhiMinusPiToPi((float)mcacc::lamPhi(candidate1), - (float)mcacc::lamPhi(candidate2)); + const float dphi = deltaPhiMinusPiToPi(static_cast(mcacc::lamPhi(candidate1)), + static_cast(mcacc::lamPhi(candidate2))); if (std::abs(dphi) > phiMix) { return false; } @@ -2947,8 +2947,8 @@ struct lambdaspincorrderived { nStat, nPt, nEta, nPhi, nM, nR); buffer[key].push_back(BufferCandR{ - .collisionIdx = static_cast(col.index()), - .rowIndex = static_cast(t.globalIndex()), + .collisionIdx = col.index(), + .rowIndex = t.globalIndex(), .v0Status = static_cast(status), .ptBin = static_cast(ptB), .etaBin = static_cast(etaB), @@ -3043,7 +3043,7 @@ struct lambdaspincorrderived { // 2) if exact bin gives fewer than required matches, also search neighbors const int targetMatches = (cfgV5MaxMatches.value > 0) ? cfgV5MaxMatches.value : 1; - if ((int)matches.size() < targetMatches) { + if (static_cast(matches.size()) < targetMatches) { std::vector ptBinsN, etaBinsN, phiBinsN; collectNeighborBinsClamp(ptB, nPt, nN_pt, ptBinsN); collectNeighborBinsClamp(etaB, nEta, nN_eta, etaBinsN); @@ -3098,12 +3098,12 @@ struct lambdaspincorrderived { }; auto downsampleMatches = [&](std::vector& matches, uint64_t seedBase) { - if (cfgV5MaxMatches.value > 0 && (int)matches.size() > cfgV5MaxMatches.value) { + if (cfgV5MaxMatches.value > 0 && static_cast(matches.size()) > cfgV5MaxMatches.value) { uint64_t seed = cfgMixSeed.value ^ splitmix64(seedBase); const int K = cfgV5MaxMatches.value; for (int i = 0; i < K; ++i) { seed = splitmix64(seed); - const int j = i + (int)(seed % (uint64_t)(matches.size() - i)); + const int j = i + static_cast(seed % static_cast(matches.size() - i)); std::swap(matches[i], matches[j]); } matches.resize(K); @@ -3179,7 +3179,7 @@ struct lambdaspincorrderived { continue; } - const int64_t curColIdx = static_cast(col1.index()); + const int64_t curColIdx = col1.index(); auto poolA = V0s.sliceBy(tracksPerCollisionV0, col1.index()); for (auto const& [t1, t2] : soa::combinations(o2::soa::CombinationsFullIndexPolicy(poolA, poolA))) { @@ -3217,7 +3217,7 @@ struct lambdaspincorrderived { if (doMixLeg1) { collectMatchesForReplacedLeg(t1, t2, colBin, curColIdx, matches1); limitMatchesToNEvents(matches1, nEvtMixing.value); - downsampleMatches(matches1, (uint64_t)t1.globalIndex() ^ (splitmix64((uint64_t)t2.globalIndex()) + 0x111ULL) ^ splitmix64((uint64_t)curColIdx)); + downsampleMatches(matches1, static_cast(t1.globalIndex()) ^ (splitmix64(static_cast(t2.globalIndex())) + 0x111ULL) ^ splitmix64(static_cast(curColIdx))); } else { matches1.clear(); } @@ -3225,7 +3225,7 @@ struct lambdaspincorrderived { if (doMixLeg2) { collectMatchesForReplacedLeg(t2, t1, colBin, curColIdx, matches2); limitMatchesToNEvents(matches2, nEvtMixing.value); - downsampleMatches(matches2, (uint64_t)t2.globalIndex() ^ (splitmix64((uint64_t)t1.globalIndex()) + 0x222ULL) ^ splitmix64((uint64_t)curColIdx)); + downsampleMatches(matches2, static_cast(t2.globalIndex()) ^ (splitmix64(static_cast(t1.globalIndex())) + 0x222ULL) ^ splitmix64(static_cast(curColIdx))); } else { matches2.clear(); } @@ -3352,7 +3352,7 @@ struct lambdaspincorrderived { // const int ptype = pairTypeCode(tX.v0Status(), t2.v0Status()); const float meWeight = finalMixWeightLeg1; - const float dPhi = deltaPhiMinusPiToPi((float)lambda.Phi(), (float)lambda2.Phi()); + const float dPhi = deltaPhiMinusPiToPi(static_cast(lambda.Phi()), static_cast(lambda2.Phi())); if ((tX.v0Status() == 0 && t2.v0Status() == 1) || (tX.v0Status() == 1 && t2.v0Status() == 0)) if (fillHistConfig.fillBasicQAHistos) histos.fill(HIST("deltaPhiMix"), dPhi, meWeight); @@ -3402,7 +3402,7 @@ struct lambdaspincorrderived { // const int ptype = pairTypeCode(t1.v0Status(), tY.v0Status()); const float meWeight = finalMixWeightLeg2; - const float dPhi = deltaPhiMinusPiToPi((float)lambda.Phi(), (float)lambda2.Phi()); + const float dPhi = deltaPhiMinusPiToPi(static_cast(lambda.Phi()), static_cast(lambda2.Phi())); if (fillHistConfig.fillBasicQAHistos) histos.fill(HIST("deltaPhiMix"), dPhi, meWeight); const int s1 = t1.v0Status(); @@ -3496,8 +3496,8 @@ struct lambdaspincorrderived { nStat, nPt, nEta, nPhi, nM, nR); buffer[key].push_back(BufferCandR{ - .collisionIdx = static_cast(col.index()), - .rowIndex = static_cast(t.globalIndex()), + .collisionIdx = col.index(), + .rowIndex = t.globalIndex(), .v0Status = static_cast(status), .ptBin = static_cast(ptB), .etaBin = static_cast(etaB), @@ -3600,7 +3600,7 @@ struct lambdaspincorrderived { // 2) if exact bin gives fewer than required matches, also search neighbors const int targetMatches = (cfgV5MaxMatches.value > 0) ? cfgV5MaxMatches.value : 1; - if ((int)matches.size() < targetMatches) { + if (static_cast(matches.size()) < targetMatches) { std::vector ptBinsN, etaBinsN, phiBinsN; collectNeighborBinsClamp(ptB, nPt, nN_pt, ptBinsN); collectNeighborBinsClamp(etaB, nEta, nN_eta, etaBinsN); @@ -3663,12 +3663,12 @@ struct lambdaspincorrderived { }; auto downsampleMatches = [&](std::vector& matches, uint64_t seedBase) { - if (cfgV5MaxMatches.value > 0 && (int)matches.size() > cfgV5MaxMatches.value) { + if (cfgV5MaxMatches.value > 0 && static_cast(matches.size()) > cfgV5MaxMatches.value) { uint64_t seed = cfgMixSeed.value ^ splitmix64(seedBase); const int K = cfgV5MaxMatches.value; for (int i = 0; i < K; ++i) { seed = splitmix64(seed); - const int j = i + (int)(seed % (uint64_t)(matches.size() - i)); + const int j = i + static_cast(seed % static_cast(matches.size() - i)); std::swap(matches[i], matches[j]); } matches.resize(K); @@ -3744,7 +3744,7 @@ struct lambdaspincorrderived { continue; } - const int64_t curColIdx = static_cast(col1.index()); + const int64_t curColIdx = col1.index(); auto poolA = V0s.sliceBy(tracksPerCollisionV0, col1.index()); for (auto const& [t1, t2] : soa::combinations(o2::soa::CombinationsFullIndexPolicy(poolA, poolA))) { @@ -3787,7 +3787,7 @@ struct lambdaspincorrderived { if (doMixLeg1) { collectMatchesForReplacedLeg(t1, t2, colBin, curColIdx, matches1); limitMatchesToNEvents(matches1, nEvtMixing.value); - downsampleMatches(matches1, (uint64_t)t1.globalIndex() ^ (splitmix64((uint64_t)t2.globalIndex()) + 0x111ULL) ^ splitmix64((uint64_t)curColIdx)); + downsampleMatches(matches1, static_cast(t1.globalIndex()) ^ (splitmix64(static_cast(t2.globalIndex())) + 0x111ULL) ^ splitmix64(static_cast(curColIdx))); } else { matches1.clear(); } @@ -3795,7 +3795,7 @@ struct lambdaspincorrderived { if (doMixLeg2) { collectMatchesForReplacedLeg(t2, t1, colBin, curColIdx, matches2); limitMatchesToNEvents(matches2, nEvtMixing.value); - downsampleMatches(matches2, (uint64_t)t2.globalIndex() ^ (splitmix64((uint64_t)t1.globalIndex()) + 0x222ULL) ^ splitmix64((uint64_t)curColIdx)); + downsampleMatches(matches2, static_cast(t2.globalIndex()) ^ (splitmix64(static_cast(t1.globalIndex())) + 0x222ULL) ^ splitmix64(static_cast(curColIdx))); } else { matches2.clear(); } @@ -3924,7 +3924,7 @@ struct lambdaspincorrderived { auto lambda2 = ROOT::Math::PtEtaPhiMVector(t2.lambdaPt(), t2.lambdaEta(), t2.lambdaPhi(), t2.lambdaMass()); const float meWeight = finalMixWeightLeg1; - const float dPhi = deltaPhiMinusPiToPi((float)lambda.Phi(), (float)lambda2.Phi()); + const float dPhi = deltaPhiMinusPiToPi(static_cast(lambda.Phi()), static_cast(lambda2.Phi())); if ((tX.v0Status() == 0 && t2.v0Status() == 1) || (tX.v0Status() == 1 && t2.v0Status() == 0)) if (fillHistConfig.fillBasicQAHistos) histos.fill(HIST("deltaPhiMix"), dPhi, meWeight); @@ -3977,7 +3977,7 @@ struct lambdaspincorrderived { auto lambda2 = ROOT::Math::PtEtaPhiMVector(tY.lambdaPt(), tY.lambdaEta(), tY.lambdaPhi(), tY.lambdaMass()); const float meWeight = finalMixWeightLeg2; - const float dPhi = deltaPhiMinusPiToPi((float)lambda.Phi(), (float)lambda2.Phi()); + const float dPhi = deltaPhiMinusPiToPi(static_cast(lambda.Phi()), static_cast(lambda2.Phi())); if (fillHistConfig.fillBasicQAHistos) histos.fill(HIST("deltaPhiMix"), dPhi, meWeight); @@ -4070,8 +4070,8 @@ struct lambdaspincorrderived { nStat, nPt, nEta, nPhi, nM, nR); buffer[key].push_back(BufferCandR{ - .collisionIdx = static_cast(col.index()), - .rowIndex = static_cast(t.globalIndex()), + .collisionIdx = col.index(), + .rowIndex = t.globalIndex(), .v0Status = static_cast(status), .ptBin = static_cast(ptB), .etaBin = static_cast(etaB), @@ -4165,7 +4165,7 @@ struct lambdaspincorrderived { // 2) if exact bin gives fewer than required matches, also search neighbors const int targetMatches = (cfgV5MaxMatches.value > 0) ? cfgV5MaxMatches.value : 1; - if ((int)matches.size() < targetMatches) { + if (static_cast(matches.size()) < targetMatches) { std::vector ptBinsN, etaBinsN, phiBinsN; collectNeighborBinsClamp(ptB, nPt, nN_pt, ptBinsN); collectNeighborBinsClamp(etaB, nEta, nN_eta, etaBinsN); @@ -4227,12 +4227,12 @@ struct lambdaspincorrderived { }; auto downsampleMatches = [&](std::vector& matches, uint64_t seedBase) { - if (cfgV5MaxMatches.value > 0 && (int)matches.size() > cfgV5MaxMatches.value) { + if (cfgV5MaxMatches.value > 0 && static_cast(matches.size()) > cfgV5MaxMatches.value) { uint64_t seed = cfgMixSeed.value ^ splitmix64(seedBase); const int K = cfgV5MaxMatches.value; for (int i = 0; i < K; ++i) { seed = splitmix64(seed); - const int j = i + (int)(seed % (uint64_t)(matches.size() - i)); + const int j = i + static_cast(seed % static_cast(matches.size() - i)); std::swap(matches[i], matches[j]); } matches.resize(K); @@ -4308,7 +4308,7 @@ struct lambdaspincorrderived { continue; } - const int64_t curColIdx = static_cast(col1.index()); + const int64_t curColIdx = col1.index(); auto poolA = V0sMC.sliceBy(tracksPerCollisionV0mc, col1.index()); for (auto const& [t1, t2] : soa::combinations(o2::soa::CombinationsFullIndexPolicy(poolA, poolA))) { @@ -4345,14 +4345,14 @@ struct lambdaspincorrderived { if (doMixLeg1) { collectMatchesForReplacedLeg(t1, t2, colBin, curColIdx, matches1); limitMatchesToNEvents(matches1, nEvtMixing.value); - downsampleMatches(matches1, (uint64_t)t1.globalIndex() ^ (splitmix64((uint64_t)t2.globalIndex()) + 0x111ULL) ^ splitmix64((uint64_t)curColIdx)); + downsampleMatches(matches1, static_cast(t1.globalIndex()) ^ (splitmix64(static_cast(t2.globalIndex())) + 0x111ULL) ^ splitmix64(static_cast(curColIdx))); } else { matches1.clear(); } if (doMixLeg2) { collectMatchesForReplacedLeg(t2, t1, colBin, curColIdx, matches2); limitMatchesToNEvents(matches2, nEvtMixing.value); - downsampleMatches(matches2, (uint64_t)t2.globalIndex() ^ (splitmix64((uint64_t)t1.globalIndex()) + 0x222ULL) ^ splitmix64((uint64_t)curColIdx)); + downsampleMatches(matches2, static_cast(t2.globalIndex()) ^ (splitmix64(static_cast(t1.globalIndex())) + 0x222ULL) ^ splitmix64(static_cast(curColIdx))); } else { matches2.clear(); } @@ -4480,7 +4480,7 @@ struct lambdaspincorrderived { // const int ptype = pairTypeCode(mcacc::v0Status(tX), mcacc::v0Status(t2)); const float meWeight = finalMixWeightLeg1; - const float dPhi = deltaPhiMinusPiToPi((float)lX.Phi(), (float)l2.Phi()); + const float dPhi = deltaPhiMinusPiToPi(static_cast(lX.Phi()), static_cast(l2.Phi())); if (fillHistConfig.fillBasicQAHistos) histos.fill(HIST("deltaPhiMix"), dPhi, meWeight); const int s1 = mcacc::v0Status(tX); @@ -4535,7 +4535,7 @@ struct lambdaspincorrderived { // const int ptype = pairTypeCode(mcacc::v0Status(t1), mcacc::v0Status(tY)); const float meWeight = finalMixWeightLeg2; - const float dPhi = deltaPhiMinusPiToPi((float)l1.Phi(), (float)lY.Phi()); + const float dPhi = deltaPhiMinusPiToPi(static_cast(l1.Phi()), static_cast(lY.Phi())); if (fillHistConfig.fillBasicQAHistos) histos.fill(HIST("deltaPhiMix"), dPhi, meWeight); const int s1 = mcacc::v0Status(t1); diff --git a/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx b/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx index 4f95c222ce5..83d250781e4 100644 --- a/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx +++ b/PWGLF/Tasks/Strangeness/phiStrangeCorrelation.cxx @@ -397,31 +397,31 @@ struct PhiStrangeCorrelation { AxisSpec deltayAxis = {yConfigs.nBinsDeltaY, -1.0f, 1.0f, "#Delta#it{y}"}; AxisSpec deltaphiAxis = {72, -o2::constants::math::PIHalf, o2::constants::math::PIHalf * 3, "#Delta#varphi"}; AxisSpec multAxis = {120, 0.0f, 120.0f, "centFT0M"}; - AxisSpec binnedmultAxis{(std::vector)binsMult, "centFT0M"}; + AxisSpec binnedmultAxis{std::vector(binsMult), "centFT0M"}; AxisSpec massPhiAxis = {200, 0.9f, 1.2f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; AxisSpec pTPhiAxis = {120, 0.0f, 12.0f, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTPhiAxis{(std::vector)binspTPhi, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTPhiAxisExt{(std::vector)binspTPhiExt, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTPhiAxis{std::vector(binspTPhi), "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTPhiAxisExt{std::vector(binspTPhiExt), "#it{p}_{T} (GeV/#it{c})"}; AxisSpec massK0SAxis = {200, 0.45f, 0.55f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; AxisSpec pTK0SAxis = {100, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTK0SAxis{(std::vector)binspTK0S, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTK0SAxisExt{(std::vector)binspTK0SExt, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTK0SAxis{std::vector(binspTK0S), "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTK0SAxisExt{std::vector(binspTK0SExt), "#it{p}_{T} (GeV/#it{c})"}; AxisSpec massLambdaAxis = {200, 1.1f, 1.13f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; AxisSpec pTLambdaAxis = {100, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTLambdaAxis{(std::vector)binspTLambda, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTLambdaAxisExt{(std::vector)binspTLambdaExt, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTLambdaAxis{std::vector(binspTLambda), "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTLambdaAxisExt{std::vector(binspTLambdaExt), "#it{p}_{T} (GeV/#it{c})"}; AxisSpec massXiAxis = {200, 1.3f, 1.4f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; AxisSpec pTXiAxis = {100, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTXiAxis{(std::vector)binspTXi, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTXiAxisExt{(std::vector)binspTXiExt, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTXiAxis{std::vector(binspTXi), "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTXiAxisExt{std::vector(binspTXiExt), "#it{p}_{T} (GeV/#it{c})"}; AxisSpec massOmegaAxis = {200, 1.65f, 1.7f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; AxisSpec pTOmegaAxis = {100, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTOmegaAxis{(std::vector)binspTOmega, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTOmegaAxisExt{(std::vector)binspTOmegaExt, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTOmegaAxis{std::vector(binspTOmega), "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTOmegaAxisExt{std::vector(binspTOmegaExt), "#it{p}_{T} (GeV/#it{c})"}; AxisSpec nSigmaPiAxis = {100, -10.0f, 10.0f, "N#sigma #pi"}; AxisSpec pTPiAxis = {50, 0.0f, 5.0f, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTPiAxis{(std::vector)binspTPi, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTPiAxisExt{(std::vector)binspTPiExt, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTPiAxis{std::vector(binspTPi), "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTPiAxisExt{std::vector(binspTPiExt), "#it{p}_{T} (GeV/#it{c})"}; std::array massAxes = {massK0SAxis, massLambdaAxis, massLambdaAxis, massXiAxis, massOmegaAxis, nSigmaPiAxis}; std::array binnedpTAxes = {binnedpTK0SAxis, binnedpTLambdaAxis, binnedpTLambdaAxis, binnedpTXiAxis, binnedpTOmegaAxis, binnedpTPiAxis}; diff --git a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx index 40b9cc698cb..f3774f61dd3 100644 --- a/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/phik0shortanalysis.cxx @@ -344,13 +344,13 @@ struct Phik0shortanalysis { AxisSpec deltaphiAxis = {72, -o2::constants::math::PIHalf, o2::constants::math::PIHalf * 3, "#Delta#varphi"}; AxisSpec phiAxis = {629, 0, o2::constants::math::TwoPI, "#phi"}; AxisSpec multAxis = {120, 0.0f, 120.0f, "centFT0M"}; - AxisSpec binnedmultAxis{(std::vector)binsMult, "centFT0M"}; + AxisSpec binnedmultAxis{std::vector(binsMult), "centFT0M"}; AxisSpec pTPhiAxis = {120, 0.0f, 12.0f, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTPhiAxis{(std::vector)binspTPhi, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTPhiAxis{std::vector(binspTPhi), "#it{p}_{T} (GeV/#it{c})"}; AxisSpec pTK0SAxis = {100, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTK0SAxis{(std::vector)binspTK0S, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTK0SAxis{std::vector(binspTK0S), "#it{p}_{T} (GeV/#it{c})"}; AxisSpec pTPiAxis = {50, 0.0f, 5.0f, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec binnedpTPiAxis{(std::vector)binspTPi, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec binnedpTPiAxis{std::vector(binspTPi), "#it{p}_{T} (GeV/#it{c})"}; // Histograms // Number of events per selection @@ -425,13 +425,13 @@ struct Phik0shortanalysis { // Phi invariant mass for computing purities and normalisation dataPhiHist.add("h3PhipurData", "Invariant mass of Phi for Purity (no K0S/Pi) in Data", kTH3F, {binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); - dataPhiHist.add("h4PhipurK0SData", "Invariant mass of Phi for Purity (K0S) in Data", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); + dataPhiHist.add("h4PhipurK0SData", "Invariant mass of Phi for Purity (K0S) in Data", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); dataPhiHist.get(HIST("h4PhipurK0SData"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { dataPhiHist.get(HIST("h4PhipurK0SData"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); } - dataPhiHist.add("h4PhipurPiData", "Invariant mass of Phi for Purity (Pi) in Data", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); + dataPhiHist.add("h4PhipurPiData", "Invariant mass of Phi for Purity (Pi) in Data", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); dataPhiHist.get(HIST("h4PhipurPiData"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { dataPhiHist.get(HIST("h4PhipurPiData"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); @@ -448,13 +448,13 @@ struct Phik0shortanalysis { // MCPhi invariant mass for computing purities closureMCPhiHist.add("h3PhipurMCClosure", "Invariant mass of Phi for Purity (no K0S/Pi)", kTH3F, {binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); - closureMCPhiHist.add("h4PhipurK0SMCClosure", "Invariant mass of Phi for Purity (K0S) in MCClosure", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); + closureMCPhiHist.add("h4PhipurK0SMCClosure", "Invariant mass of Phi for Purity (K0S) in MCClosure", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); closureMCPhiHist.get(HIST("h4PhipurK0SMCClosure"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { closureMCPhiHist.get(HIST("h4PhipurK0SMCClosure"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); } - closureMCPhiHist.add("h4PhipurPiMCClosure", "Invariant mass of Phi for Purity (Pi) in MCClosure", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); + closureMCPhiHist.add("h4PhipurPiMCClosure", "Invariant mass of Phi for Purity (Pi) in MCClosure", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPhiAxis, massPhiAxis}); closureMCPhiHist.get(HIST("h4PhipurPiMCClosure"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { closureMCPhiHist.get(HIST("h4PhipurPiMCClosure"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); @@ -469,7 +469,7 @@ struct Phik0shortanalysis { if (analysisModeConfigs.isData) { // 2D mass of Phi and K0S for Data - dataPhiK0SHist.add("h5PhiK0SData", "2D Invariant mass of Phi and K0Short for Data", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis, massK0SAxis, sigmassPhiAxis}); + dataPhiK0SHist.add("h5PhiK0SData", "2D Invariant mass of Phi and K0Short for Data", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis, massK0SAxis, sigmassPhiAxis}); dataPhiK0SHist.get(HIST("h5PhiK0SData"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { dataPhiK0SHist.get(HIST("h5PhiK0SData"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); @@ -486,20 +486,20 @@ struct Phik0shortanalysis { if (analysisModeConfigs.isMC) { // RecMC K0S coupled to Phi - mcPhiK0SHist.add("h4PhiK0SMCReco", "K0S coupled to Phi in MCReco", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis, massK0SAxis}); + mcPhiK0SHist.add("h4PhiK0SMCReco", "K0S coupled to Phi in MCReco", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis, massK0SAxis}); mcPhiK0SHist.get(HIST("h4PhiK0SMCReco"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { mcPhiK0SHist.get(HIST("h4PhiK0SMCReco"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); } // GenMC K0S coupled to Phi - mcPhiK0SHist.add("h3PhiK0SMCGen", "K0S coupled toPhi in MCGen", kTH3F, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis}); + mcPhiK0SHist.add("h3PhiK0SMCGen", "K0S coupled toPhi in MCGen", kTH3F, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis}); mcPhiK0SHist.get(HIST("h3PhiK0SMCGen"))->GetXaxis()->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { mcPhiK0SHist.get(HIST("h3PhiK0SMCGen"))->GetXaxis()->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); } - mcPhiK0SHist.add("h3PhiK0SMCGenAssocReco", "K0S coupled toPhi in MCGen Associated MCReco Collision", kTH3F, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis}); + mcPhiK0SHist.add("h3PhiK0SMCGenAssocReco", "K0S coupled toPhi in MCGen Associated MCReco Collision", kTH3F, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis}); mcPhiK0SHist.get(HIST("h3PhiK0SMCGenAssocReco"))->GetXaxis()->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { mcPhiK0SHist.get(HIST("h3PhiK0SMCGenAssocReco"))->GetXaxis()->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); @@ -508,7 +508,7 @@ struct Phik0shortanalysis { if (analysisModeConfigs.isClosure) { // 2D mass of Phi and K0S for Closure Test - closureMCPhiK0SHist.add("h5PhiK0SMCClosure", "2D Invariant mass of Phi and K0Short for MC Closure Test", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis, massK0SAxis, sigmassPhiAxis}); + closureMCPhiK0SHist.add("h5PhiK0SMCClosure", "2D Invariant mass of Phi and K0Short for MC Closure Test", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTK0SAxis, massK0SAxis, sigmassPhiAxis}); closureMCPhiK0SHist.get(HIST("h5PhiK0SMCClosure"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { closureMCPhiK0SHist.get(HIST("h5PhiK0SMCClosure"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); @@ -522,7 +522,7 @@ struct Phik0shortanalysis { if (analysisModeConfigs.isData) { // Phi mass vs Pion NSigma dE/dx for Data - dataPhiPionHist.add("h6PhiPiData", "Phi Invariant mass vs Pion nSigma TPC/TOF for Data", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, sigmassPhiAxis}); + dataPhiPionHist.add("h6PhiPiData", "Phi Invariant mass vs Pion nSigma TPC/TOF for Data", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, sigmassPhiAxis}); dataPhiPionHist.get(HIST("h6PhiPiData"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { dataPhiPionHist.get(HIST("h6PhiPiData"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); @@ -556,26 +556,26 @@ struct Phik0shortanalysis { if (analysisModeConfigs.isMC) { // RecMC Pion coupled to Phi with TPC - mcPhiPionHist.add("h4PhiPiTPCMCReco", "Pion coupled to Phi in MCReco (TPC)", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}}); + mcPhiPionHist.add("h4PhiPiTPCMCReco", "Pion coupled to Phi in MCReco (TPC)", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}}); mcPhiPionHist.get(HIST("h4PhiPiTPCMCReco"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { mcPhiPionHist.get(HIST("h4PhiPiTPCMCReco"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); } // RecMC Pion coupled to Phi with TPC and TOF - mcPhiPionHist.add("h5PhiPiTPCTOFMCReco", "Pion coupled to Phi in MCReco (TPC and TOF)", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); + mcPhiPionHist.add("h5PhiPiTPCTOFMCReco", "Pion coupled to Phi in MCReco (TPC and TOF)", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}}); mcPhiPionHist.get(HIST("h5PhiPiTPCTOFMCReco"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { mcPhiPionHist.get(HIST("h5PhiPiTPCTOFMCReco"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); } - mcPhiPionHist.add("h3PhiPiMCGen", "Pion coupled to Phi in MCGen", kTH3F, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis}); + mcPhiPionHist.add("h3PhiPiMCGen", "Pion coupled to Phi in MCGen", kTH3F, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis}); mcPhiPionHist.get(HIST("h3PhiPiMCGen"))->GetXaxis()->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { mcPhiPionHist.get(HIST("h3PhiPiMCGen"))->GetXaxis()->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); } - mcPhiPionHist.add("h3PhiPiMCGenAssocReco", "Pion coupled to Phi in MCGen Associated Reco Collision", kTH3F, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis}); + mcPhiPionHist.add("h3PhiPiMCGenAssocReco", "Pion coupled to Phi in MCGen Associated Reco Collision", kTH3F, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis}); mcPhiPionHist.get(HIST("h3PhiPiMCGenAssocReco"))->GetXaxis()->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { mcPhiPionHist.get(HIST("h3PhiPiMCGenAssocReco"))->GetXaxis()->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); @@ -584,7 +584,7 @@ struct Phik0shortanalysis { if (analysisModeConfigs.isClosure) { // Phi mass vs Pion NSigma dE/dx for Closure Test - closureMCPhiPionHist.add("h6PhiPiMCClosure", "Phi Invariant mass vs Pion nSigma TPC/TOF for MC Closure Test", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, sigmassPhiAxis}); + closureMCPhiPionHist.add("h6PhiPiMCClosure", "Phi Invariant mass vs Pion nSigma TPC/TOF for MC Closure Test", kTHnSparseF, {{static_cast(deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1), -0.5f, (deltaYConfigs.cfgDeltaYAcceptanceBins->size() + 1.0f - 0.5f)}, binnedmultAxis, binnedpTPiAxis, {100, -10.0f, 10.0f}, {100, -10.0f, 10.0f}, sigmassPhiAxis}); closureMCPhiPionHist.get(HIST("h6PhiPiMCClosure"))->GetAxis(0)->SetBinLabel(1, "Inclusive"); for (size_t i = 0; i < deltaYConfigs.cfgDeltaYAcceptanceBins->size(); i++) { closureMCPhiPionHist.get(HIST("h6PhiPiMCClosure"))->GetAxis(0)->SetBinLabel(i + 2, Form("|Delta#it{y}| < %.1f", deltaYConfigs.cfgDeltaYAcceptanceBins->at(i))); @@ -1160,7 +1160,7 @@ struct Phik0shortanalysis { for (size_t multIdx = 0; multIdx < binsMult->size() - 1; multIdx++) { for (size_t ptIdx = 0; ptIdx < binspTPhi->size() - 1; ptIdx++) { - phiPurityFunctions[multIdx][ptIdx] = static_cast(listPhiPurityFunctions->FindObject(Form("funcFitPhiPur_%zu_%zu", multIdx, ptIdx))); + phiPurityFunctions[multIdx][ptIdx] = dynamic_cast(listPhiPurityFunctions->FindObject(Form("funcFitPhiPur_%zu_%zu", multIdx, ptIdx))); } } } @@ -1199,22 +1199,22 @@ struct Phik0shortanalysis { if (!listEfficiencyMaps) LOG(error) << "Problem getting TList object with efficiency maps!"; - effMapPhi = static_cast(listEfficiencyMaps->FindObject("h3EfficiencyPhi")); + effMapPhi = dynamic_cast(listEfficiencyMaps->FindObject("h3EfficiencyPhi")); if (!effMapPhi) { LOG(error) << "Problem getting efficiency map for Phi!"; return; } - effMapK0S = static_cast(listEfficiencyMaps->FindObject("h3EfficiencyK0S")); + effMapK0S = dynamic_cast(listEfficiencyMaps->FindObject("h3EfficiencyK0S")); if (!effMapK0S) { LOG(error) << "Problem getting efficiency map for K0S!"; return; } - effMapPionTPC = static_cast(listEfficiencyMaps->FindObject("h3EfficiencyPionTPC")); + effMapPionTPC = dynamic_cast(listEfficiencyMaps->FindObject("h3EfficiencyPionTPC")); if (!effMapPionTPC) { LOG(error) << "Problem getting efficiency map for Pion with TPC!"; return; } - effMapPionTPCTOF = static_cast(listEfficiencyMaps->FindObject("h3EfficiencyPionTPCTOF")); + effMapPionTPCTOF = dynamic_cast(listEfficiencyMaps->FindObject("h3EfficiencyPionTPCTOF")); if (!effMapPionTPCTOF) { LOG(error) << "Problem getting efficiency map for Pion with TPC and TOF!"; return; diff --git a/PWGLF/Tasks/Strangeness/sjetTreeCreator.cxx b/PWGLF/Tasks/Strangeness/sjetTreeCreator.cxx index 3e696fe6134..1189692df48 100644 --- a/PWGLF/Tasks/Strangeness/sjetTreeCreator.cxx +++ b/PWGLF/Tasks/Strangeness/sjetTreeCreator.cxx @@ -202,11 +202,11 @@ struct SjetTreeCreator { // Seed the random number generator using current time std::srand(static_cast(std::time(nullptr))); - jetRadiiValues = (std::vector)jetRadii; - jetPtBinsReduction = (std::vector)jetPtBins; - jetReductionFactorsPt = (std::vector)jetReductionFactors; + jetRadiiValues = jetRadii; + jetPtBinsReduction = jetPtBins; + jetReductionFactorsPt = jetReductionFactors; - eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(static_cast(eventSelections)); + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(eventSelections); registry.add("h_vertexZ", "Vertex Z;#it{Z} (cm)", {HistType::kTH1F, {{40, -20.0, 20.0}}}); diff --git a/PWGLF/Utils/mcCentralityModule.h b/PWGLF/Utils/mcCentralityModule.h index dd53bbb2ac8..0aa51448914 100644 --- a/PWGLF/Utils/mcCentralityModule.h +++ b/PWGLF/Utils/mcCentralityModule.h @@ -377,9 +377,9 @@ struct BuilderModule { THist* getHist(const char* name) { if (!this->MCCentralityCalibObjects) { - return (THist*)0x0; + return nullptr; } - auto hist = reinterpret_cast(this->MCCentralityCalibObjects->FindObject(name)); + auto hist = dynamic_cast(this->MCCentralityCalibObjects->FindObject(name)); if (!hist) { if (this->baseOpts.verbose) { this->MCCentralityCalibObjects->ls(); @@ -406,7 +406,7 @@ struct BuilderModule { TH2D* h2dMultVsCent_Data = getHist(Form("hMultEta05VsCent%s_Data", estimator.Data())); TH2D* h2dMultRecoVsMultGen_MC = getHist(Form("hMultEta05VsGenMult%s", estimator.Data())); if (!h2dMultVsCent_Data || !h2dMultRecoVsMultGen_MC) { - return (TH1D*)0x0; + return static_cast(nullptr); } // QA of this on-the-fly calibration: mean _{|eta|<0.5} in data/MC per centrality class, diff --git a/PWGLF/Utils/svPoolCreator.h b/PWGLF/Utils/svPoolCreator.h index fedcaa95ce7..46cc00b52f3 100644 --- a/PWGLF/Utils/svPoolCreator.h +++ b/PWGLF/Utils/svPoolCreator.h @@ -194,13 +194,13 @@ class svPoolCreator const auto& tref = tmap.find(trackCand.globalIndex()); if (tref != tmap.end()) { LOG(debug) << "Track: " << trackCand.globalIndex() << " already processed with other vertex"; - trackCandPool[tref->second.second][tref->second.first].collBracket.setMax(static_cast(collIdx)); // this track was already processed with other vertex, account the latter + trackCandPool[tref->second.second][tref->second.first].collBracket.setMax(collIdx); // this track was already processed with other vertex, account the latter continue; } int poolIndex = (1 - isDau0) * 2 + (trackCand.sign() < 0); trForpool.Idxtr = trackCand.globalIndex(); - trForpool.collBracket = {static_cast(collIdx), static_cast(collIdx)}; + trForpool.collBracket = {collIdx, collIdx}; // LOG(info) << "Adding track to pool: " << trForpool.Idxtr << " with bracket: " << trForpool.collBracket.getMin() << " " << trForpool.collBracket.getMax() << " and pool index: " << poolIndex; trackCandPool[poolIndex].emplace_back(trForpool); tmap[trackCand.globalIndex()] = {trackCandPool[poolIndex].size() - 1, poolIndex}; diff --git a/PWGLF/Utils/v0SelectionGroup.cxx b/PWGLF/Utils/v0SelectionGroup.cxx index f5a816567cb..360ab04b75b 100644 --- a/PWGLF/Utils/v0SelectionGroup.cxx +++ b/PWGLF/Utils/v0SelectionGroup.cxx @@ -32,54 +32,54 @@ bool v0SelectionGroup::verifyMask(uint64_t bitmap, uint64_t mask) const // provides standard masks given current event selection criteria. void v0SelectionGroup::provideMasks(uint64_t& maskTopological, uint64_t& maskTrackProperties, uint64_t& maskK0ShortSpecific, uint64_t& maskLambdaSpecific, uint64_t& maskAntiLambdaSpecific) const { - maskTopological = (uint64_t(1) << v0data::selCosPA) | (uint64_t(1) << v0data::selRadius) | (uint64_t(1) << v0data::selDCANegToPV) | (uint64_t(1) << v0data::selDCAPosToPV) | (uint64_t(1) << v0data::selDCAV0Dau) | (uint64_t(1) << v0data::selRadiusMax); - maskK0ShortSpecific = (uint64_t(1) << v0data::selK0ShortRapidity) | (uint64_t(1) << v0data::selK0ShortCTau) | (uint64_t(1) << v0data::selK0ShortArmenteros) | (uint64_t(1) << v0data::selConsiderK0Short); - maskLambdaSpecific = (uint64_t(1) << v0data::selLambdaRapidity) | (uint64_t(1) << v0data::selLambdaCTau) | (uint64_t(1) << v0data::selConsiderLambda); - maskAntiLambdaSpecific = (uint64_t(1) << v0data::selLambdaRapidity) | (uint64_t(1) << v0data::selLambdaCTau) | (uint64_t(1) << v0data::selConsiderAntiLambda); + maskTopological = (static_cast(1) << v0data::selCosPA) | (static_cast(1) << v0data::selRadius) | (static_cast(1) << v0data::selDCANegToPV) | (static_cast(1) << v0data::selDCAPosToPV) | (static_cast(1) << v0data::selDCAV0Dau) | (static_cast(1) << v0data::selRadiusMax); + maskK0ShortSpecific = (static_cast(1) << v0data::selK0ShortRapidity) | (static_cast(1) << v0data::selK0ShortCTau) | (static_cast(1) << v0data::selK0ShortArmenteros) | (static_cast(1) << v0data::selConsiderK0Short); + maskLambdaSpecific = (static_cast(1) << v0data::selLambdaRapidity) | (static_cast(1) << v0data::selLambdaCTau) | (static_cast(1) << v0data::selConsiderLambda); + maskAntiLambdaSpecific = (static_cast(1) << v0data::selLambdaRapidity) | (static_cast(1) << v0data::selLambdaCTau) | (static_cast(1) << v0data::selConsiderAntiLambda); // ask for specific TPC/TOF PID v0data::selections maskTrackProperties = 0; if (requirePosITSonly) { - maskTrackProperties = maskTrackProperties | (uint64_t(1) << v0data::selPosItsOnly) | (uint64_t(1) << v0data::selPosGoodITSTrack); + maskTrackProperties = maskTrackProperties | (static_cast(1) << v0data::selPosItsOnly) | (static_cast(1) << v0data::selPosGoodITSTrack); } else { - maskTrackProperties = maskTrackProperties | (uint64_t(1) << v0data::selPosGoodTPCTrack) | (uint64_t(1) << v0data::selPosGoodITSTrack); + maskTrackProperties = maskTrackProperties | (static_cast(1) << v0data::selPosGoodTPCTrack) | (static_cast(1) << v0data::selPosGoodITSTrack); // TPC signal is available: ask for positive track PID if (TpcPidNsigmaCut < 1e+5) { // safeguard for no cut - maskK0ShortSpecific = maskK0ShortSpecific | (uint64_t(1) << v0data::selTPCPIDPositivePion); - maskLambdaSpecific = maskLambdaSpecific | (uint64_t(1) << v0data::selTPCPIDPositiveProton); - maskAntiLambdaSpecific = maskAntiLambdaSpecific | (uint64_t(1) << v0data::selTPCPIDPositivePion); + maskK0ShortSpecific = maskK0ShortSpecific | (static_cast(1) << v0data::selTPCPIDPositivePion); + maskLambdaSpecific = maskLambdaSpecific | (static_cast(1) << v0data::selTPCPIDPositiveProton); + maskAntiLambdaSpecific = maskAntiLambdaSpecific | (static_cast(1) << v0data::selTPCPIDPositivePion); } // TOF PID if (TofPidNsigmaCutK0Pi < 1e+5) // safeguard for no cut - maskK0ShortSpecific = maskK0ShortSpecific | (uint64_t(1) << v0data::selTOFNSigmaPositivePionK0Short) | (uint64_t(1) << v0data::selTOFDeltaTPositivePionK0Short); + maskK0ShortSpecific = maskK0ShortSpecific | (static_cast(1) << v0data::selTOFNSigmaPositivePionK0Short) | (static_cast(1) << v0data::selTOFDeltaTPositivePionK0Short); if (TofPidNsigmaCutLaPr < 1e+5) // safeguard for no cut - maskLambdaSpecific = maskLambdaSpecific | (uint64_t(1) << v0data::selTOFNSigmaPositiveProtonLambda) | (uint64_t(1) << v0data::selTOFDeltaTPositiveProtonLambda); + maskLambdaSpecific = maskLambdaSpecific | (static_cast(1) << v0data::selTOFNSigmaPositiveProtonLambda) | (static_cast(1) << v0data::selTOFDeltaTPositiveProtonLambda); if (TofPidNsigmaCutLaPi < 1e+5) // safeguard for no cut - maskAntiLambdaSpecific = maskAntiLambdaSpecific | (uint64_t(1) << v0data::selTOFNSigmaPositivePionLambda) | (uint64_t(1) << v0data::selTOFDeltaTPositivePionLambda); + maskAntiLambdaSpecific = maskAntiLambdaSpecific | (static_cast(1) << v0data::selTOFNSigmaPositivePionLambda) | (static_cast(1) << v0data::selTOFDeltaTPositivePionLambda); } if (requireNegITSonly) { - maskTrackProperties = maskTrackProperties | (uint64_t(1) << v0data::selNegItsOnly) | (uint64_t(1) << v0data::selNegGoodITSTrack); + maskTrackProperties = maskTrackProperties | (static_cast(1) << v0data::selNegItsOnly) | (static_cast(1) << v0data::selNegGoodITSTrack); } else { - maskTrackProperties = maskTrackProperties | (uint64_t(1) << v0data::selNegGoodTPCTrack) | (uint64_t(1) << v0data::selNegGoodITSTrack); + maskTrackProperties = maskTrackProperties | (static_cast(1) << v0data::selNegGoodTPCTrack) | (static_cast(1) << v0data::selNegGoodITSTrack); // TPC signal is available: ask for negative track PID if (TpcPidNsigmaCut < 1e+5) { // safeguard for no cut - maskK0ShortSpecific = maskK0ShortSpecific | (uint64_t(1) << v0data::selTPCPIDNegativePion); - maskLambdaSpecific = maskLambdaSpecific | (uint64_t(1) << v0data::selTPCPIDNegativePion); - maskAntiLambdaSpecific = maskAntiLambdaSpecific | (uint64_t(1) << v0data::selTPCPIDNegativeProton); + maskK0ShortSpecific = maskK0ShortSpecific | (static_cast(1) << v0data::selTPCPIDNegativePion); + maskLambdaSpecific = maskLambdaSpecific | (static_cast(1) << v0data::selTPCPIDNegativePion); + maskAntiLambdaSpecific = maskAntiLambdaSpecific | (static_cast(1) << v0data::selTPCPIDNegativeProton); } // TOF PID if (TofPidNsigmaCutK0Pi < 1e+5) // safeguard for no cut - maskK0ShortSpecific = maskK0ShortSpecific | (uint64_t(1) << v0data::selTOFNSigmaNegativePionK0Short) | (uint64_t(1) << v0data::selTOFDeltaTNegativePionK0Short); + maskK0ShortSpecific = maskK0ShortSpecific | (static_cast(1) << v0data::selTOFNSigmaNegativePionK0Short) | (static_cast(1) << v0data::selTOFDeltaTNegativePionK0Short); if (TofPidNsigmaCutLaPr < 1e+5) // safeguard for no cut - maskLambdaSpecific = maskLambdaSpecific | (uint64_t(1) << v0data::selTOFNSigmaNegativePionLambda) | (uint64_t(1) << v0data::selTOFDeltaTNegativePionLambda); + maskLambdaSpecific = maskLambdaSpecific | (static_cast(1) << v0data::selTOFNSigmaNegativePionLambda) | (static_cast(1) << v0data::selTOFDeltaTNegativePionLambda); if (TofPidNsigmaCutLaPi < 1e+5) // safeguard for no cut - maskAntiLambdaSpecific = maskAntiLambdaSpecific | (uint64_t(1) << v0data::selTOFNSigmaNegativeProtonLambda) | (uint64_t(1) << v0data::selTOFDeltaTNegativeProtonLambda); + maskAntiLambdaSpecific = maskAntiLambdaSpecific | (static_cast(1) << v0data::selTOFNSigmaNegativeProtonLambda) | (static_cast(1) << v0data::selTOFDeltaTNegativeProtonLambda); } if (skipTPConly) { - maskK0ShortSpecific = maskK0ShortSpecific | (uint64_t(1) << v0data::selPosNotTPCOnly) | (uint64_t(1) << v0data::selNegNotTPCOnly); - maskLambdaSpecific = maskLambdaSpecific | (uint64_t(1) << v0data::selPosNotTPCOnly) | (uint64_t(1) << v0data::selNegNotTPCOnly); - maskAntiLambdaSpecific = maskAntiLambdaSpecific | (uint64_t(1) << v0data::selPosNotTPCOnly) | (uint64_t(1) << v0data::selNegNotTPCOnly); + maskK0ShortSpecific = maskK0ShortSpecific | (static_cast(1) << v0data::selPosNotTPCOnly) | (static_cast(1) << v0data::selNegNotTPCOnly); + maskLambdaSpecific = maskLambdaSpecific | (static_cast(1) << v0data::selPosNotTPCOnly) | (static_cast(1) << v0data::selNegNotTPCOnly); + maskAntiLambdaSpecific = maskAntiLambdaSpecific | (static_cast(1) << v0data::selPosNotTPCOnly) | (static_cast(1) << v0data::selNegNotTPCOnly); } }