I changed the method for measuring energy loss outside the jet

Author: ynishida-style

PWGJE/Tasks/jetShape.cxx

@@ -43,8 +43,8 @@ struct JetShapeTask {
   Configurable<int> nBinsNSigma{"nBinsNSigma", 101, "Number of nsigma bins"};
   Configurable<float> nSigmaMin{"nSigmaMin", -10.1f, "Min value of nsigma"};
   Configurable<float> nSigmaMax{"nSigmaMax", 10.1f, "Max value of nsigma"};
-  Configurable<int> nBinsP{"nBinsP", 700, "Number of p bins"};
-  Configurable<int> nBinsPt{"nBinsPt", 500, "Number of pT bins"};
+  Configurable<int> nBinsPForDedx{"nBinsPForDedx", 700, "Number of p bins"};
+  Configurable<int> nBinsPForBeta{"nBinsPForBeta", 500, "Number of pT bins"};
   Configurable<int> nBinsTpcDedx{"nBinsTpcDedx", 500, "Number of DEdx bins"};
   Configurable<int> nBinsTofBeta{"nBinsTofBeta", 350, "Number of Beta bins"};
   Configurable<float> pMax{"pMax", 7.0f, "Max value of p"};
@@ -60,11 +60,20 @@ struct JetShapeTask {
                               {"tofPi", "tofPi", {HistType::kTH2F, {{50, 0, ptMax}, {nBinsNSigma, nSigmaMin, nSigmaMax}}}},
                               {"tpcPr", "tpcPr", {HistType::kTH2F, {{70, 0, pMax}, {nBinsNSigma, nSigmaMin, nSigmaMax}}}},
                               {"tofPr", "tofPr", {HistType::kTH2F, {{50, 0, ptMax}, {nBinsNSigma, nSigmaMin, nSigmaMax}}}},
-                              {"tpcDedx", "tpcDedx", {HistType::kTHnSparseD, {{nBinsP, 0, pMax}, {nBinsTpcDedx, 0, 1000}, {nBinsDistance, 0, distanceMax}}}},
-                              {"tofBeta", "tofBeta", {HistType::kTHnSparseD, {{nBinsPt, 0, ptMax}, {nBinsTofBeta, 0.4, 1.1}, {nBinsDistance, 0, distanceMax}}}},
+                              {"tpcDedx", "tpcDedx", {HistType::kTHnSparseD, {{nBinsPForDedx, 0, pMax}, {nBinsTpcDedx, 0, 1000}, {nBinsDistance, 0, distanceMax}}}},
+                              {"tpcDedxOutOfJet", "tpcDedxOutOfJet", {HistType::kTH2F, {{nBinsPForDedx, 0, pMax}, {nBinsTpcDedx, 0, 1000}}}},
+                              {"tofBeta", "tofBeta", {HistType::kTHnSparseD, {{nBinsPForBeta, 0, pMax}, {nBinsTofBeta, 0.4, 1.1}, {nBinsDistance, 0, distanceMax}}}},
                               {"pVsPtForProton", "pVsPtForProton", {HistType::kTHnSparseD, {{70, 0, pMax}, {50, 0, ptMax}, {nBinsDistance, 0, distanceMax}}}},
                               {"pVsPtForPion", "pVsPtPion", {HistType::kTHnSparseD, {{70, 0, pMax}, {50, 0, ptMax}, {nBinsDistance, 0, distanceMax}}}},
                               {"tofMass", "tofMass", {HistType::kTH1F, {{300, 0, 3}}}},
+                              {"trackPhi", "trackPhi", {HistType::kTH1F, {{80, -1, 7}}}},
+                              {"trackEta", "trackEta", {HistType::kTH1F, {{100, -1, 1}}}},
+                              {"trackTpcNClsCrossedRows", "trackTpcNClsCrossedRows", {HistType::kTH1F, {{50, 0, 200}}}},
+                              {"trackDcaXY", "trackDcaXY", {HistType::kTH1F, {{40, -10, 10}}}},
+                              {"trackItsChi2NCl", "trackItsChi2NCl", {HistType::kTH1F, {{60, 0, 30}}}},
+                              {"trackTpcChi2NCl", "trackTpcChi2NCl", {HistType::kTH1F, {{100, 0, 50}}}},
+                              {"trackTpcNClsFound", "trackTpcNClsFound", {HistType::kTH1F, {{100, 0, 200}}}},
+                              {"trackItsNCls", "trackItsNCls", {HistType::kTH1F, {{10, 0, 10}}}},
                               {"jetPt", "jet pT;#it{p}_{T,jet} (GeV/#it{c});entries", {HistType::kTH1F, {{200, 0., 200.}}}},
                               {"jetEta", "jet #eta;#eta_{jet};entries", {HistType::kTH1F, {{100, -1.0, 1.0}}}},
                               {"jetPhi", "jet #phi;#phi_{jet};entries", {HistType::kTH1F, {{80, -1.0, 7.}}}},
@@ -179,6 +188,7 @@ struct JetShapeTask {
       float ptCorr = jet.pt() - collision.rho() * jet.area();
 
       for (const auto& track : tracks) {
+
         float preDeltaPhi1 = track.phi() - jet.phi();
         float deltaPhi1 = RecoDecay::constrainAngle(preDeltaPhi1);
         float deltaEta = track.eta() - jet.eta();
@@ -257,6 +267,16 @@ struct JetShapeTask {
 
       // tracks conditions
       for (const auto& track : tracks) {
+
+        registry.fill(HIST("trackTpcNClsCrossedRows"), track.tpcNClsCrossedRows());
+        registry.fill(HIST("trackDcaXY"), track.dcaXY());
+        registry.fill(HIST("trackItsChi2NCl"), track.itsChi2NCl());
+        registry.fill(HIST("trackTpcChi2NCl"), track.tpcChi2NCl());
+        registry.fill(HIST("trackTpcNClsFound"), track.tpcNClsFound());
+        registry.fill(HIST("trackItsNCls"), track.itsNCls());
+        registry.fill(HIST("trackEta"), track.eta());
+        registry.fill(HIST("trackPhi"), track.phi());
+
         if (std::abs(track.eta()) > etaTrUp)
           continue;
         if (track.tpcNClsCrossedRows() < nclcrossTpcMin)
@@ -289,9 +309,29 @@ struct JetShapeTask {
         // calculate distance from jet axis
         float distance = std::sqrt(deltaEta * deltaEta + deltaPhi1 * deltaPhi1);
 
+        // Define perpendicular cone axes in phi
+        float phiBg1 = jet.phi() + (o2::constants::math::PIHalf);
+        float phiBg2 = jet.phi() - (o2::constants::math::PIHalf);
+
+        // Calculate delta phi for background cones
+        float preDeltaPhiBg1 = track.phi() - phiBg1;
+        float preDeltaPhiBg2 = track.phi() - phiBg2;
+        float deltaPhiBg1 = RecoDecay::constrainAngle(preDeltaPhiBg1);
+        float deltaPhiBg2 = RecoDecay::constrainAngle(preDeltaPhiBg2);
+
+        // Calculate distance to background cone axes
+        // Note: deltaEta is the same for all cones at the same eta
+        float distanceBg1 = std::sqrt(deltaEta * deltaEta + deltaPhiBg1 * deltaPhiBg1);
+        float distanceBg2 = std::sqrt(deltaEta * deltaEta + deltaPhiBg2 * deltaPhiBg2);
+
+        // Fill histogram if track is inside one of the perpendicular cones
+        if (distanceBg1 < jetR || distanceBg2 < jetR) {
+          registry.fill(HIST("tpcDedxOutOfJet"), track.p(), track.tpcSignal());
+        }
+
         registry.fill(HIST("distanceVsTrackpt"), distance, track.pt());
         registry.fill(HIST("tpcDedx"), track.p(), track.tpcSignal(), distance);
-        registry.fill(HIST("tofBeta"), track.pt(), track.beta(), distance);
+        registry.fill(HIST("tofBeta"), track.p(), track.beta(), distance);
 
         if (std::abs(track.tofNSigmaPr()) < nSigmaTofCut) {
           registry.fill(HIST("pVsPtForProton"), track.p(), track.pt(), distance);