[PWGJE] add min pThat cut (AliceO2Group#9603)

jaimenorman · web-flow · commit 6ead9cdd5d1b · 2025-01-29T15:03:21.000+01:00
diff --git a/PWGJE/Tasks/jetFinderFullQA.cxx b/PWGJE/Tasks/jetFinderFullQA.cxx
@@ -74,6 +74,7 @@ struct JetFinderFullQATask {
   Configurable<float> pTHatMaxMCD{"pTHatMaxMCD", 999.0, "maximum fraction of hard scattering for jet acceptance in detector MC"};
   Configurable<float> pTHatMaxMCP{"pTHatMaxMCP", 999.0, "maximum fraction of hard scattering for jet acceptance in particle MC"};
   Configurable<float> pTHatExponent{"pTHatExponent", 6.0, "exponent of the event weight for the calculation of pTHat"};
+  Configurable<float> pTHatAbsoluteMin{"pTHatAbsoluteMin", -99.0, "minimum value of pTHat"};
   Configurable<bool> skipMBGapEvents{"skipMBGapEvents", false, "flag to choose to reject min. bias gap events; jet-level rejection applied at the jet finder level, here rejection is applied for collision and track process functions"};
 
   std::vector<bool> filledJetR;
@@ -278,7 +279,7 @@ struct JetFinderFullQATask {
   {
 
     float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));
-    if (jet.pt() > pTHatMaxMCD * pTHat) {
+    if (jet.pt() > pTHatMaxMCD * pTHat || pTHat < pTHatAbsoluteMin) {
       return;
     }
     registry.fill(HIST("h_jet_phat_weighted"), pTHat, weight);
@@ -328,7 +329,7 @@ struct JetFinderFullQATask {
   {
 
     float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));
-    if (jet.pt() > pTHatMaxMCP * pTHat) {
+    if (jet.pt() > pTHatMaxMCP * pTHat || pTHat < pTHatAbsoluteMin) {
       return;
     }
     registry.fill(HIST("h_jet_phat_part_weighted"), pTHat, weight);
@@ -363,7 +364,7 @@ struct JetFinderFullQATask {
   {
 
     float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));
-    if (jetBase.pt() > pTHatMaxMCD * pTHat) {
+    if (jetBase.pt() > pTHatMaxMCD * pTHat || pTHat < pTHatAbsoluteMin) {
       return;
     }
 
@@ -436,6 +437,10 @@ struct JetFinderFullQATask {
   template <typename T, typename U>
   void fillTrackHistograms(T const& tracks, U const& clusters, float weight = 1.0)
   {
+    float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));
+    if (pTHat < pTHatAbsoluteMin) {
+      return;
+    }
     for (auto const& track : tracks) {
       if (!jetderiveddatautilities::selectTrack(track, trackSelection)) {
         continue;
diff --git a/PWGJE/Tasks/jetFinderHFQA.cxx b/PWGJE/Tasks/jetFinderHFQA.cxx
@@ -68,6 +68,7 @@ struct JetFinderHFQATask {
   Configurable<float> pTHatMaxMCD{"pTHatMaxMCD", 999.0, "maximum fraction of hard scattering for jet acceptance in detector MC"};
   Configurable<float> pTHatMaxMCP{"pTHatMaxMCP", 999.0, "maximum fraction of hard scattering for jet acceptance in particle MC"};
   Configurable<float> pTHatExponent{"pTHatExponent", 6.0, "exponent of the event weight for the calculation of pTHat"};
+  Configurable<float> pTHatAbsoluteMin{"pTHatAbsoluteMin", -99.0, "minimum value of pTHat"};
   Configurable<float> randomConeR{"randomConeR", 0.4, "size of random Cone for estimating background fluctuations"};
   Configurable<bool> skipMBGapEvents{"skipMBGapEvents", false, "flag to choose to reject min. bias gap events; jet-level rejection applied at the jet finder level, here rejection is applied for collision and track process functions"};
 
@@ -527,7 +528,7 @@ struct JetFinderHFQATask {
   {
 
     float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));
-    if (jet.pt() > pTHatMaxMCD * pTHat) {
+    if (jet.pt() > pTHatMaxMCD * pTHat || pTHat < pTHatAbsoluteMin) {
       return;
     }
     registry.fill(HIST("h_jet_phat_weighted"), pTHat, weight);
@@ -656,7 +657,7 @@ struct JetFinderHFQATask {
   {
 
     float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));
-    if (jet.pt() > pTHatMaxMCP * pTHat) {
+    if (jet.pt() > pTHatMaxMCP * pTHat || pTHat < pTHatAbsoluteMin) {
       return;
     }
     registry.fill(HIST("h_jet_phat_part_weighted"), pTHat, weight);
@@ -698,7 +699,7 @@ struct JetFinderHFQATask {
   {
 
     float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));
-    if (jetBase.pt() > pTHatMaxMCD * pTHat) {
+    if (jetBase.pt() > pTHatMaxMCD * pTHat || pTHat < pTHatAbsoluteMin) {
       return;
     }
     auto candidateBasePt = 0.0;
@@ -930,6 +931,10 @@ struct JetFinderHFQATask {
   template <typename T, typename U>
   void fillTrackHistograms(T const& collision, U const& tracks, float weight = 1.0)
   {
+    float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));
+    if (pTHat < pTHatAbsoluteMin) {
+      return;
+    }
     for (auto const& track : tracks) {
       if (!jetderiveddatautilities::selectTrack(track, trackSelection)) {
         continue;
diff --git a/PWGJE/Tasks/jetFinderQA.cxx b/PWGJE/Tasks/jetFinderQA.cxx
@@ -60,6 +60,7 @@ struct JetFinderQATask {
   Configurable<float> pTHatMaxMCD{"pTHatMaxMCD", 999.0, "maximum fraction of hard scattering for jet acceptance in detector MC"};
   Configurable<float> pTHatMaxMCP{"pTHatMaxMCP", 999.0, "maximum fraction of hard scattering for jet acceptance in particle MC"};
   Configurable<float> pTHatExponent{"pTHatExponent", 6.0, "exponent of the event weight for the calculation of pTHat"};
+  Configurable<float> pTHatAbsoluteMin{"pTHatAbsoluteMin", -99.0, "minimum value of pTHat"};
   Configurable<double> jetPtMax{"jetPtMax", 200., "set jet pT bin max"};
   Configurable<float> jetEtaMin{"jetEtaMin", -99.0, "minimum jet pseudorapidity"};
   Configurable<float> jetEtaMax{"jetEtaMax", 99.0, "maximum jet pseudorapidity"};
@@ -382,7 +383,7 @@ struct JetFinderQATask {
   {
 
     float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));
-    if (jet.pt() > pTHatMaxMCD * pTHat) {
+    if (jet.pt() > pTHatMaxMCD * pTHat || pTHat < pTHatAbsoluteMin) {
       return;
     }
     registry.fill(HIST("h_jet_phat"), pTHat);
@@ -482,7 +483,7 @@ struct JetFinderQATask {
   {
 
     float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));
-    if (jet.pt() > pTHatMaxMCP * pTHat) {
+    if (jet.pt() > pTHatMaxMCP * pTHat || pTHat < pTHatAbsoluteMin) {
       return;
     }
     registry.fill(HIST("h_jet_phat_part"), pTHat);
@@ -512,7 +513,7 @@ struct JetFinderQATask {
   void fillMatchedHistograms(T const& jetBase, float weight = 1.0)
   {
     float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));
-    if (jetBase.pt() > pTHatMaxMCD * pTHat) {
+    if (jetBase.pt() > pTHatMaxMCD * pTHat || pTHat < pTHatAbsoluteMin) {
       return;
     }
 
@@ -592,6 +593,10 @@ struct JetFinderQATask {
   template <typename T, typename U>
   void fillTrackHistograms(T const& collision, U const& tracks, float weight = 1.0)
   {
+    float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));
+    if (pTHat < pTHatAbsoluteMin) {
+      return;
+    }
     for (auto const& track : tracks) {
       if (!jetderiveddatautilities::selectTrack(track, trackSelection)) {
         continue;

Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,7 @@ struct JetFinderFullQATask {`
`74`	`74`	`Configurable<float> pTHatMaxMCD{"pTHatMaxMCD", 999.0, "maximum fraction of hard scattering for jet acceptance in detector MC"};`
`75`	`75`	`Configurable<float> pTHatMaxMCP{"pTHatMaxMCP", 999.0, "maximum fraction of hard scattering for jet acceptance in particle MC"};`
`76`	`76`	`Configurable<float> pTHatExponent{"pTHatExponent", 6.0, "exponent of the event weight for the calculation of pTHat"};`
	`77`	`+ Configurable<float> pTHatAbsoluteMin{"pTHatAbsoluteMin", -99.0, "minimum value of pTHat"};`
`77`	`78`	`Configurable<bool> skipMBGapEvents{"skipMBGapEvents", false, "flag to choose to reject min. bias gap events; jet-level rejection applied at the jet finder level, here rejection is applied for collision and track process functions"};`
`78`	`79`
`79`	`80`	`std::vector<bool> filledJetR;`
`@@ -278,7 +279,7 @@ struct JetFinderFullQATask {`
`278`	`279`	`{`
`279`	`280`
`280`	`281`	`float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));`
`281`		`- if (jet.pt() > pTHatMaxMCD * pTHat) {`
	`282`	`+ if (jet.pt() > pTHatMaxMCD * pTHat \|\| pTHat < pTHatAbsoluteMin) {`
`282`	`283`	`return;`
`283`	`284`	`}`
`284`	`285`	`registry.fill(HIST("h_jet_phat_weighted"), pTHat, weight);`
`@@ -328,7 +329,7 @@ struct JetFinderFullQATask {`
`328`	`329`	`{`
`329`	`330`
`330`	`331`	`float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));`
`331`		`- if (jet.pt() > pTHatMaxMCP * pTHat) {`
	`332`	`+ if (jet.pt() > pTHatMaxMCP * pTHat \|\| pTHat < pTHatAbsoluteMin) {`
`332`	`333`	`return;`
`333`	`334`	`}`
`334`	`335`	`registry.fill(HIST("h_jet_phat_part_weighted"), pTHat, weight);`
`@@ -363,7 +364,7 @@ struct JetFinderFullQATask {`
`363`	`364`	`{`
`364`	`365`
`365`	`366`	`float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));`
`366`		`- if (jetBase.pt() > pTHatMaxMCD * pTHat) {`
	`367`	`+ if (jetBase.pt() > pTHatMaxMCD * pTHat \|\| pTHat < pTHatAbsoluteMin) {`
`367`	`368`	`return;`
`368`	`369`	`}`
`369`	`370`
`@@ -436,6 +437,10 @@ struct JetFinderFullQATask {`
`436`	`437`	`template <typename T, typename U>`
`437`	`438`	`void fillTrackHistograms(T const& tracks, U const& clusters, float weight = 1.0)`
`438`	`439`	`{`
	`440`	`+ float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));`
	`441`	`+ if (pTHat < pTHatAbsoluteMin) {`
	`442`	`+ return;`
	`443`	`+ }`
`439`	`444`	`for (auto const& track : tracks) {`
`440`	`445`	`if (!jetderiveddatautilities::selectTrack(track, trackSelection)) {`
`441`	`446`	`continue;`
Original file line number	Diff line number	Diff line change
`@@ -68,6 +68,7 @@ struct JetFinderHFQATask {`
`68`	`68`	`Configurable<float> pTHatMaxMCD{"pTHatMaxMCD", 999.0, "maximum fraction of hard scattering for jet acceptance in detector MC"};`
`69`	`69`	`Configurable<float> pTHatMaxMCP{"pTHatMaxMCP", 999.0, "maximum fraction of hard scattering for jet acceptance in particle MC"};`
`70`	`70`	`Configurable<float> pTHatExponent{"pTHatExponent", 6.0, "exponent of the event weight for the calculation of pTHat"};`
	`71`	`+ Configurable<float> pTHatAbsoluteMin{"pTHatAbsoluteMin", -99.0, "minimum value of pTHat"};`
`71`	`72`	`Configurable<float> randomConeR{"randomConeR", 0.4, "size of random Cone for estimating background fluctuations"};`
`72`	`73`	`Configurable<bool> skipMBGapEvents{"skipMBGapEvents", false, "flag to choose to reject min. bias gap events; jet-level rejection applied at the jet finder level, here rejection is applied for collision and track process functions"};`
`73`	`74`
`@@ -527,7 +528,7 @@ struct JetFinderHFQATask {`
`527`	`528`	`{`
`528`	`529`
`529`	`530`	`float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));`
`530`		`- if (jet.pt() > pTHatMaxMCD * pTHat) {`
	`531`	`+ if (jet.pt() > pTHatMaxMCD * pTHat \|\| pTHat < pTHatAbsoluteMin) {`
`531`	`532`	`return;`
`532`	`533`	`}`
`533`	`534`	`registry.fill(HIST("h_jet_phat_weighted"), pTHat, weight);`
`@@ -656,7 +657,7 @@ struct JetFinderHFQATask {`
`656`	`657`	`{`
`657`	`658`
`658`	`659`	`float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));`
`659`		`- if (jet.pt() > pTHatMaxMCP * pTHat) {`
	`660`	`+ if (jet.pt() > pTHatMaxMCP * pTHat \|\| pTHat < pTHatAbsoluteMin) {`
`660`	`661`	`return;`
`661`	`662`	`}`
`662`	`663`	`registry.fill(HIST("h_jet_phat_part_weighted"), pTHat, weight);`
`@@ -698,7 +699,7 @@ struct JetFinderHFQATask {`
`698`	`699`	`{`
`699`	`700`
`700`	`701`	`float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));`
`701`		`- if (jetBase.pt() > pTHatMaxMCD * pTHat) {`
	`702`	`+ if (jetBase.pt() > pTHatMaxMCD * pTHat \|\| pTHat < pTHatAbsoluteMin) {`
`702`	`703`	`return;`
`703`	`704`	`}`
`704`	`705`	`auto candidateBasePt = 0.0;`
`@@ -930,6 +931,10 @@ struct JetFinderHFQATask {`
`930`	`931`	`template <typename T, typename U>`
`931`	`932`	`void fillTrackHistograms(T const& collision, U const& tracks, float weight = 1.0)`
`932`	`933`	`{`
	`934`	`+ float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));`
	`935`	`+ if (pTHat < pTHatAbsoluteMin) {`
	`936`	`+ return;`
	`937`	`+ }`
`933`	`938`	`for (auto const& track : tracks) {`
`934`	`939`	`if (!jetderiveddatautilities::selectTrack(track, trackSelection)) {`
`935`	`940`	`continue;`
Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,7 @@ struct JetFinderQATask {`
`60`	`60`	`Configurable<float> pTHatMaxMCD{"pTHatMaxMCD", 999.0, "maximum fraction of hard scattering for jet acceptance in detector MC"};`
`61`	`61`	`Configurable<float> pTHatMaxMCP{"pTHatMaxMCP", 999.0, "maximum fraction of hard scattering for jet acceptance in particle MC"};`
`62`	`62`	`Configurable<float> pTHatExponent{"pTHatExponent", 6.0, "exponent of the event weight for the calculation of pTHat"};`
	`63`	`+ Configurable<float> pTHatAbsoluteMin{"pTHatAbsoluteMin", -99.0, "minimum value of pTHat"};`
`63`	`64`	`Configurable<double> jetPtMax{"jetPtMax", 200., "set jet pT bin max"};`
`64`	`65`	`Configurable<float> jetEtaMin{"jetEtaMin", -99.0, "minimum jet pseudorapidity"};`
`65`	`66`	`Configurable<float> jetEtaMax{"jetEtaMax", 99.0, "maximum jet pseudorapidity"};`
`@@ -382,7 +383,7 @@ struct JetFinderQATask {`
`382`	`383`	`{`
`383`	`384`
`384`	`385`	`float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));`
`385`		`- if (jet.pt() > pTHatMaxMCD * pTHat) {`
	`386`	`+ if (jet.pt() > pTHatMaxMCD * pTHat \|\| pTHat < pTHatAbsoluteMin) {`
`386`	`387`	`return;`
`387`	`388`	`}`
`388`	`389`	`registry.fill(HIST("h_jet_phat"), pTHat);`
`@@ -482,7 +483,7 @@ struct JetFinderQATask {`
`482`	`483`	`{`
`483`	`484`
`484`	`485`	`float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));`
`485`		`- if (jet.pt() > pTHatMaxMCP * pTHat) {`
	`486`	`+ if (jet.pt() > pTHatMaxMCP * pTHat \|\| pTHat < pTHatAbsoluteMin) {`
`486`	`487`	`return;`
`487`	`488`	`}`
`488`	`489`	`registry.fill(HIST("h_jet_phat_part"), pTHat);`
`@@ -512,7 +513,7 @@ struct JetFinderQATask {`
`512`	`513`	`void fillMatchedHistograms(T const& jetBase, float weight = 1.0)`
`513`	`514`	`{`
`514`	`515`	`float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));`
`515`		`- if (jetBase.pt() > pTHatMaxMCD * pTHat) {`
	`516`	`+ if (jetBase.pt() > pTHatMaxMCD * pTHat \|\| pTHat < pTHatAbsoluteMin) {`
`516`	`517`	`return;`
`517`	`518`	`}`
`518`	`519`
`@@ -592,6 +593,10 @@ struct JetFinderQATask {`
`592`	`593`	`template <typename T, typename U>`
`593`	`594`	`void fillTrackHistograms(T const& collision, U const& tracks, float weight = 1.0)`
`594`	`595`	`{`
	`596`	`+ float pTHat = 10. / (std::pow(weight, 1.0 / pTHatExponent));`
	`597`	`+ if (pTHat < pTHatAbsoluteMin) {`
	`598`	`+ return;`
	`599`	`+ }`
`595`	`600`	`for (auto const& track : tracks) {`
`596`	`601`	`if (!jetderiveddatautilities::selectTrack(track, trackSelection)) {`
`597`	`602`	`continue;`