[PWGCF] additions to IV, validations of banishment loop, support for ES, etc. (#8859)

Author: abilandz

PWGCF/MultiparticleCorrelations/Core/MuPa-Configurables.h

@@ -26,6 +26,7 @@ struct : ConfigurableGroup {
   Configurable<bool> cfVerboseUtility{"cfVerboseUtility", false, "run or not in verbose mode, also for simple utility functions (but not for function calls per particle)"};
   Configurable<bool> cfVerboseForEachParticle{"cfVerboseForEachParticle", false, "run or not in verbose mode (also for function calls per particle)"};
   Configurable<bool> cfVerboseEventCounter{"cfVerboseEventCounter", false, "print or not only event counter"};
+  Configurable<bool> cfVerboseEventCut{"cfVerboseEventCut", false, "print or not which event cut didn't survive"};
   Configurable<bool> cfPlainPrintout{"cfPlainPrintout", false, "print in color or in plain (use the latter in HL)"};
   Configurable<bool> cfDoAdditionalInsanityChecks{"cfDoAdditionalInsanityChecks", false, "do additional insanity checks at run time (this leads to small loss of performance)"};
   Configurable<bool> cfInsanityCheckForEachParticle{"cfInsanityCheckForEachParticle", false, "do insanity checks at run time for each particle, at the expense of losing a lot of performance. Use only during debugging."};
@@ -168,6 +169,21 @@ struct : ConfigurableGroup {
   Configurable<string> cfWhichDefaultLabels{"cfWhichDefaultLabels", "standard", "only for testing purposes, select one set of default labels, see GetDefaultObjArrayWithLabels for supported options"};
 } cf_t0;
 
+// *) Eta separation:
+struct : ConfigurableGroup {
+  Configurable<bool> cfCalculateEtaSeparations{"cfCalculateEtaSeparations", false, "calculate or not 2p corr. vs. eta separations"};
+  Configurable<bool> cfCalculateEtaSeparationsAsFunctionOfIntegrated{"cfCalculateEtaSeparationsAsFunctionOfIntegrated", false, "calculate or not 2p corr. vs. eta separations ..."};
+  Configurable<bool> cfCalculateEtaSeparationsAsFunctionOfMultiplicity{"cfCalculateEtaSeparationsAsFunctionOfMultiplicity", false, "calculate or not 2p corr. vs. eta separations as a function of multiplicity"};
+  Configurable<bool> cfCalculateEtaSeparationsAsFunctionOfCentrality{"cfCalculateEtaSeparationsAsFunctionOfCentrality", false, "calculate or not 2p corr. vs. eta separations as a function of centrality"};
+  Configurable<bool> cfCalculateEtaSeparationsAsFunctionOfPt{"cfCalculateEtaSeparationsAsFunctionOfPt", false, "calculate or not 2p corr. vs. eta separations as a function of pt"};
+  // Configurable<bool> cfCalculateEtaSeparationsAsFunctionOfEta{"cfCalculateEtaSeparationsAsFunctionOfEta", false, "this one doesn't make sense in this context"};
+  Configurable<bool> cfCalculateEtaSeparationsAsFunctionOfOccupancy{"cfCalculateEtaSeparationsAsFunctionOfOccupancy", false, "calculate or not 2p corr. vs. eta separations as a function of occupancy"};
+  Configurable<bool> cfCalculateEtaSeparationsAsFunctionOfInteractionRate{"cfCalculateEtaSeparationsAsFunctionOfInteractionRate", false, "calculate or not 2p corr. vs. eta separations as a function of interaction rate"};
+  Configurable<bool> cfCalculateEtaSeparationsAsFunctionOfCurrentRunDuration{"cfCalculateEtaSeparationsAsFunctionOfCurrentRunDuration", false, "calculate or not E2p corr. vs. eta separations as a function of current run duration (i.e. vs. seconds since start of run)"};
+  Configurable<vector<float>> cfEtaSeparationsValues{"cfEtaSeparationsValues", {0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8}, "Eta separation between interval A (-eta) and B (+eta)"};
+  Configurable<vector<string>> cfEtaSeparationsSkipHarmonics{"cfEtaSeparationsSkipHarmonics", {"0-v1", "0-v2", "0-v3", "0-v4", "1-v5", "1-v6", "1-v7", "1-v8", "1-v9"}, "For calculation of 2p correlation with eta separation these harmonics will be skipped (if first flag = \"0-v1\", v1 will be NOT be skipped in the calculus of 2p correlations with eta separations, etc.)"};
+} cf_es;
+
 // *) Particle weights:
 struct : ConfigurableGroup {
   Configurable<bool> cfUsePhiWeights{"cfUsePhiWeights", false, "use or not phi weights"};

PWGCF/MultiparticleCorrelations/Core/MuPa-DataMembers.h

@@ -47,6 +47,7 @@ struct TaskConfiguration {
   Bool_t fVerboseUtility = kFALSE;                 // print additional info during debugging also for simply utility function, but not for function calls per particle (see next)
   Bool_t fVerboseForEachParticle = kFALSE;         // print additional info during debugging, also for function calls per particle
   Bool_t fVerboseEventCounter = kTRUE;             // print or not only event counter
+  Bool_t fVerboseEventCut = kTRUE;                 // print or not only which event cut didn't survive
   Bool_t fPlainPrintout = kFALSE;                  // print in color or in plain (use the latter in HL)
   Bool_t fDoAdditionalInsanityChecks = kFALSE;     // do additional insanity checks at run time, at the expense of losing a bit of performance
                                                    // (for instance, check if the run number in the current 'collision' is the same as run number in the first 'collision', etc.)
@@ -183,10 +184,16 @@ struct Qvector {
   TList* fQvectorList = NULL;                                                                                                          // list to hold all Q-vector objects
   TProfile* fQvectorFlagsPro = NULL;                                                                                                   // profile to hold all flags for Q-vector
   Bool_t fCalculateQvectors = kTRUE;                                                                                                   // to calculate or not to calculate Q-vectors, that's a Boolean...
+                                                                                                                                       // Does NOT apply to Qa, Qb, etc., vectors, needed for eta separ.
   TComplex fQ[gMaxHarmonic * gMaxCorrelator + 1][gMaxCorrelator + 1] = {{TComplex(0., 0.)}};                                           //! generic Q-vector
   TComplex fQvector[gMaxHarmonic * gMaxCorrelator + 1][gMaxCorrelator + 1] = {{TComplex(0., 0.)}};                                     //! "integrated" Q-vector
   TComplex fqvector[eqvectorKine_N][gMaxNoBinsKine][gMaxHarmonic * gMaxCorrelator + 1][gMaxCorrelator + 1] = {{{{TComplex(0., 0.)}}}}; //! "differenttial" q-vector [kine var.][binNo][fMaxHarmonic*fMaxCorrelator+1][fMaxCorrelator+1] = [6*12+1][12+1]
   Int_t fqVectorEntries[eqvectorKine_N][gMaxNoBinsKine] = {{0}};                                                                       // count number of entries in each differential q-vector
+  TComplex fQabVector[2][gMaxHarmonic][gMaxNumberEtaSeparations] = {{{TComplex(0., 0.)}}};                                             //! integrated [-eta or +eta][harmonic][eta separation]
+  Double_t fMab[2][gMaxNumberEtaSeparations] = {{0.}};                                                                                 //! multiplicities in 2 eta separated intervals
+  TH1F* fMabDist[2][2][2][gMaxNumberEtaSeparations] = {{{{NULL}}}};                                                                    // multiplicity distributions in A and B, for each eta separation [ A or B ] [rec or sim] [ before or after cuts ] [ eta separation value ]
+  TComplex fqabVector[2][gMaxNoBinsKine][gMaxHarmonic][gMaxNumberEtaSeparations] = {{{{TComplex(0., 0.)}}}};                           //! differential in pt [-eta or +eta][binNo][harmonic][eta separation]
+  Double_t fmab[2][gMaxNoBinsKine][gMaxNumberEtaSeparations] = {{{0.}}};                                                               //! multiplicities vs pt in 2 eta separated intervals
 } qv;                                                                                                                                  // "qv" is a common label for objects in this struct
 
 // *) Multiparticle correlations (standard, isotropic, same harmonic):
@@ -208,7 +215,7 @@ struct ParticleWeights {
   Bool_t fUseWeights[eWeights_N] = {false};                               // use weights [phi,pt,eta]
   TH1D* fWeightsHist[eWeights_N] = {NULL};                                //!<! particle weights
   Bool_t fUseDiffWeights[eDiffWeights_N] = {false};                       // use differential weights [phipt,phieta]
-  TH1D* fDiffWeightsHist[eDiffWeights_N][fMaxBinsDiffWeights] = {{NULL}}; // histograms holding differential weights [phipt,phieta][bin number]
+  TH1D* fDiffWeightsHist[eDiffWeights_N][gMaxBinsDiffWeights] = {{NULL}}; // histograms holding differential weights [phipt,phieta][bin number]
   TString fFileWithWeights = "";                                          // path to external ROOT file which holds all particle weights
   Bool_t fParticleWeightsAreFetched = kFALSE;                             // ensures that particle weights are fetched only once
 } pw;                                                                     // "pw" labels an instance of this group of histograms
@@ -281,6 +288,28 @@ struct Test0 {
   TH1I* fTest0LabelsPlaceholder = NULL;                                         // store all Test0 labels in this histogram
 } t0;                                                                           // "t0" labels an instance of this group of histograms
 
+// *) Eta separations:
+struct EtaSeparations {
+  TList* fEtaSeparationsList;                                                            // list to hold all correlations with eta separations
+  TProfile* fEtaSeparationsFlagsPro;                                                     // profile to hold all flags for correlations with eta separations
+  bool fCalculateEtaSeparations;                                                         // calculate correlations with eta separations
+  bool fCalculateEtaSeparationsAsFunctionOf[eAsFunctionOf_N] = {false};                  //! [0=integrated,1=vs. multiplicity,2=vs. centrality,3=pT,4=eta,5=vs. occupancy, ...]
+  float fEtaSeparationsValues[gMaxNumberEtaSeparations] = {-1.};                         // this array holds eta separation interals for which 2p correlations with eta separation will be calculated
+                                                                                         // See the corresponding cofigurable cfEtaSeparationsValues. If entry is -1, it's ignored
+  bool fEtaSeparationsSkipHarmonics[gMaxHarmonic] = {false};                             // For calculation of 2p correlation with eta separation these harmonics will be skipped
+  TProfile* fEtaSeparationsPro[gMaxHarmonic][gMaxNumberEtaSeparations][eAsFunctionOf_N]; // [harmonic, 0 = v1, 8 = v9][ different eta Separations - see that enum ] [ AFO ]
+} es;
+
+// *) Common cosmetics:
+struct CommonCosmetics {
+  TString srs[2] = {"rec", "sim"};                              // used in the histogram name as index when saved to the file
+  TString srs_long[2] = {"reconstructed", "simulated"};         // used in the histogram title
+  TString sba[2] = {"before", "after"};                         // used in the histogram name as index when saved to the file
+  TString sba_long[2] = {"before cuts", "after cuts"};          // used in the histogram title
+  TString scc[eCutCounter_N] = {"abs", "seq"};                  // used in the histogram name as index when saved to the file
+  TString scc_long[eCutCounter_N] = {"absolute", "sequential"}; // used in the histogram title
+} cc;
+
 // *) Results:
 struct Results {                                   // This is in addition also sort of "abstract" interface, which defines common binning, etc., for other groups of histograms.
   TList* fResultsList = NULL;                      //!<! list to hold all results

PWGCF/MultiparticleCorrelations/Core/MuPa-Enums.h

@@ -95,8 +95,8 @@ enum eVnPsin { eVn = 0,
 enum eEventHistograms {
   eNumberOfEvents = 0,    // Total events = eNumberOfEvents + eBefore, Selected events = eNumberOfEvents + eAfter
   eTotalMultiplicity,     // TBI 20241123 I define it as tracks.size(), but most likely this I do not need this
-  eMultiplicity,          // see documentation below for ebye.fMultiplicity
-  eReferenceMultiplicity, // see documentation below for ebye.fReferenceMultiplicity
+  eMultiplicity,          // see documentation for ebye.fMultiplicity
+  eReferenceMultiplicity, // see documentation for ebye.fReferenceMultiplicity
   eCentrality,            // default centrality estimator
   eVertex_x,
   eVertex_y,
@@ -118,8 +118,8 @@ enum eEventCuts {
   eSel8,                           // See def. of sel7 in Ref. b) above. Event selection decision based on TVX => use only in Run 3, both for data and MC
                                    // *) As of 20240410, kNoITSROFrameBorder (only in MC) and kNoTimeFrameBorder event selection cuts are part of Sel8
                                    //    See also email from EK from 2024041
-  eMultiplicityEstimator,          // see documentation below for ebye.fMultiplicity
-  eReferenceMultiplicityEstimator, // see documentation below for ebye.fReferenceMultiplicity
+  eMultiplicityEstimator,          // see documentation for ebye.fMultiplicity
+  eReferenceMultiplicityEstimator, // see documentation for ebye.fReferenceMultiplicity
   eCentralityEstimator,            // the default centrality estimator, set via configurable. All supported centrality estimators, for QA, etc, are in enum eCentralityEstimators
   eSelectedEvents,                 // selected events = eNumberOfEvents + eAfter => therefore I do not need a special histogram for it
   eNoSameBunchPileup,              // reject collisions in case of pileup with another collision in the same foundBC (emails from IA on 20240404 and EK on 20240410)

PWGCF/MultiparticleCorrelations/Core/MuPa-GlobalConstants.h

@@ -14,8 +14,9 @@
 
 const Int_t gMaxCorrelator = 12;
 const Int_t gMaxHarmonic = 9;
-const Int_t gMaxIndex = 300;           // per order, used only in Test0
-const Int_t gMaxNoBinsKine = 1000;     // max number of bins for differential q-vector
-const Int_t fMaxBinsDiffWeights = 100; // max number of bins for differential weights, see MakeWeights.C
+const Int_t gMaxIndex = 300;              // per order, used only in Test0
+const Int_t gMaxNoBinsKine = 1000;        // max number of bins for differential q-vector
+const Int_t gMaxBinsDiffWeights = 100;    // max number of bins for differential weights, see MakeWeights.C
+const Int_t gMaxNumberEtaSeparations = 9; // max number of different eta separations used to calculated 2p corr. with eta separations
 
 #endif // PWGCF_MULTIPARTICLECORRELATIONS_CORE_MUPA_GLOBALCONSTANTS_H_