[PWGCF] further support for internal validation and occuancy studies (#8415)

Author: abilandz

PWGCF/MultiparticleCorrelations/Core/MuPa-Configurables.h

@@ -38,7 +38,7 @@ struct : ConfigurableGroup {
 struct : ConfigurableGroup {
   Configurable<bool> cfCheckUnderflowAndOverflow{"cfCheckUnderflowAndOverflow", false, "check and bail out if in event and particle histograms there are entries which went to underflow or overflow bins (use only locally)"};
   Configurable<bool> cfFillQAEventHistograms2D{"cfFillQAEventHistograms2D", false, "if false, all QA 2D event histograms are not filled. if true, only the ones for which fBookQAEventHistograms2D[...] is true, are filled"};
-  Configurable<vector<string>> cfBookQAEventHistograms2D{"cfBookQAEventHistograms2D", {"MultTPC_vs_NContributors-1", "Vertex_z_vs_MultTPC-1", "Vertex_z_vs_NContributors-1", "CentFT0M_vs_CentNTPV-1", "CentRun2V0M_vs_CentRun2SPDTracklets-1", "CentRun2V0M_vs_NContributors-1", "TrackOccupancyInTimeRange_vs_FT0COccupancyInTimeRange-1"}, "book (1) or do not book (0) this QA 2D event histogram"};
+  Configurable<vector<string>> cfBookQAEventHistograms2D{"cfBookQAEventHistograms2D", {"MultTPC_vs_NContributors-1", "Vertex_z_vs_MultTPC-1", "Vertex_z_vs_NContributors-1", "CentFT0M_vs_CentNTPV-1", "CentRun2V0M_vs_CentRun2SPDTracklets-1", "CentRun2V0M_vs_NContributors-1", "TrackOccupancyInTimeRange_vs_FT0COccupancyInTimeRange-1", "TrackOccupancyInTimeRange_vs_MultTPC-1", "TrackOccupancyInTimeRange_vs_Vertex_z-1"}, "book (1) or do not book (0) this QA 2D event histogram"};
   Configurable<bool> cfFillQAParticleHistograms2D{"cfFillQAParticleHistograms2D", false, "if false, all QA 2D particle histograms are not filled. if true, only the ones for which fBookQAParticleHistograms2D[...] is true, are filled"};
   Configurable<vector<string>> cfBookQAParticleHistograms2D{"cfBookQAParticleHistograms2D", {"Pt_vs_dcaXY-1"}, "book (1) or do not book (0) this QA 2D particle histogram"};
 } cf_qa;
@@ -131,6 +131,12 @@ struct : ConfigurableGroup {
 // *) Multiparticle correlations:
 struct : ConfigurableGroup {
   Configurable<bool> cfCalculateCorrelations{"cfCalculateCorrelations", false, "calculate or not multiparticle correlations"};
+  Configurable<bool> cfCalculateCorrelationsAsFunctionOfIntegrated{"cfCalculateCorrelationsAsFunctionOfIntegrated", false, "calculate or not correlations as a function of integrated"};
+  Configurable<bool> cfCalculateCorrelationsAsFunctionOfMultiplicity{"cfCalculateCorrelationsAsFunctionOfMultiplicity", false, "calculate or not correlations as a function of multiplicity"};
+  Configurable<bool> cfCalculateCorrelationsAsFunctionOfCentrality{"cfCalculateCorrelationsAsFunctionOfCentrality", false, "calculate or not correlations as a function of centrality"};
+  Configurable<bool> cfCalculateCorrelationsAsFunctionOfPt{"cfCalculateCorrelationsAsFunctionOfPt", false, "calculate or not correlations as a function of pt"};
+  Configurable<bool> cfCalculateCorrelationsAsFunctionOfEta{"cfCalculateCorrelationsAsFunctionOfEta", false, "calculate or not correlations as a function of eta"};
+  Configurable<bool> cfCalculateCorrelationsAsFunctionOfOccupancy{"cfCalculateCorrelationsAsFunctionOfOccupancy", false, "calculate or not correlations as a function of occupancy"};
 } cf_mupa;
 
 // *) Test0:
@@ -176,7 +182,7 @@ struct : ConfigurableGroup {
   Configurable<bool> cfUseInternalValidation{"cfUseInternalValidation", false, "perform internal validation using flow analysis on-the-fly"};
   Configurable<bool> cfInternalValidationForceBailout{"cfInternalValidationForceBailout", false, "force bailout (use only locally, since there is no graceful exit (yet))"};
   Configurable<unsigned int> cfnEventsInternalValidation{"cfnEventsInternalValidation", 0, "number of events simulated on-the-fly for internal validation"};
-  Configurable<string> cfHarmonicsOptionInternalValidation{"cfHarmonicsOptionInternalValidation", "constant", "for internal validation, set whether flow amplitudes are \"constant\" or \"correlared\""};
+  Configurable<string> cfHarmonicsOptionInternalValidation{"cfHarmonicsOptionInternalValidation", "constant", "for internal validation, set whether flow amplitudes are \"constant\" or \"correlated\""};
   Configurable<bool> cfRescaleWithTheoreticalInput{"cfRescaleWithTheoreticalInput", false, "if kTRUE, all correlators are rescaled with theoretical input, so that all results in profiles are 1"};
   Configurable<vector<float>> cfInternalValidationAmplitudes{"cfInternalValidationAmplitudes", {0.01, 0.02, 0.03, 0.04}, "{v1, v2, v3, v4, ...} + has an effect only in combination with cfHarmonicsOptionInternalValidation = \"constant\". Max number of vn's is gMaxHarmonic."};
   Configurable<vector<float>> cfInternalValidationPlanes{"cfInternalValidationPlanes", {0.0, 0.0, 0.0, 0.0}, "{Psi1, Psi2, Psi3, Psi4, ...} + has an effect only in combination with cfHarmonicsOptionInternalValidation = \"constant\". Max number of Psin's is gMaxHarmonic."};

PWGCF/MultiparticleCorrelations/Core/MuPa-DataMembers.h

@@ -181,13 +181,15 @@ struct Qvector {
 
 // *) Multiparticle correlations (standard, isotropic, same harmonic):
 struct MultiparticleCorrelations {
-  TList* fCorrelationsList = NULL;                                           // list to hold all correlations objects
-  TProfile* fCorrelationsFlagsPro = NULL;                                    // profile to hold all flags for correlations
-  Bool_t fCalculateCorrelations = kTRUE;                                     // calculate and store integrated correlations
-  TProfile* fCorrelationsPro[4][gMaxHarmonic][eAsFunctionOf_N] = {{{NULL}}}; //! multiparticle correlations
-                                                                             //! [2p=0,4p=1,6p=2,8p=3][n=1,n=2,...,n=gMaxHarmonic][0=integrated,1=vs.
-                                                                             //! multiplicity,2=vs. centrality,3=pT,4=eta]
-} mupa;                                                                      // "mupa" is a common label for objects in this struct
+  TList* fCorrelationsList = NULL;                                                                     // list to hold all correlations objects
+  TProfile* fCorrelationsFlagsPro = NULL;                                                              // profile to hold all flags for correlations
+  Bool_t fCalculateCorrelations = kTRUE;                                                               // calculate and store integrated correlations
+  TProfile* fCorrelationsPro[4][gMaxHarmonic][eAsFunctionOf_N] = {{{NULL}}};                           //! multiparticle correlations
+                                                                                                       //  [2p=0,4p=1,6p=2,8p=3][n=1,n=2,...,n=gMaxHarmonic]
+                                                                                                       //  [0=integrated,1=vs. multiplicity,2=vs. centrality,3=pT,4=eta,5=vs. occupancy]
+  Bool_t fCalculateCorrelationsAsFunctionOf[eAsFunctionOf_N] = {true, true, true, false, false, true}; //! [0=integrated,1=vs. multiplicity,2=vs. centrality,3=pT,4=eta,5=vs. occupancy]
+                                                                                                       //  As of 20241111, 3=pT and 4=eta are not implemented, see void CalculateKineCorrelations(...)
+} mupa;                                                                                                // "mupa" is a common label for objects in this struct
 
 // *) Particle weights:
 struct ParticleWeights {
@@ -234,25 +236,27 @@ struct InternalValidation {
   TList* fInternalValidationList = NULL;              // list to hold all objects for internal validation
   TProfile* fInternalValidationFlagsPro = NULL;       // profile to hold all flags for internal validation
   Bool_t fUseInternalValidation = kFALSE;             // use internal validation
-  Bool_t fInternalValidationForceBailout = kFALSE;    // force bailout after fnEventsInternalValidation is reached. In HL, for each real event, I do fnEventsInternalValidation events
-  UInt_t fnEventsInternalValidation = 0;              // how many events will be sampled on-the-fly for internal validation
-  TString* fHarmonicsOptionInternalValidation = NULL; // see .cxx for full documentation
+  Bool_t fInternalValidationForceBailout = kFALSE;    // force bailout in internal validation after either eNumberOfEvents or eSelectedEvents is reached.
+                                                      // This is OK as long as I do not apply any event cuts in InternalValidation().
+                                                      // Remember that for each real event, I do fnEventsInternalValidation events on-the-fly.
+  UInt_t fnEventsInternalValidation = 0;              // how many on-the-fly events will be sampled for each real event, for internal validation
+  TString* fHarmonicsOptionInternalValidation = NULL; // "constant" or "correlated", see .cxx for full documentation
   Bool_t fRescaleWithTheoreticalInput = kFALSE;       // if kTRUE, all measured correlators are rescaled with theoretical input, so that in profiles everything is at 1
   TArrayD* fInternalValidationVnPsin[2] = {NULL};     // 0 = { v1, v2, ... }, 1 = { Psi1, Psi2, ... }
   Int_t fMultRangeInternalValidation[2] = {0, 0};     // min and max values for uniform multiplicity distribution in on-the-fly analysis (convention: min <= M < max)
 } iv;
 
 // *) Test0:
 struct Test0 {
-  TList* fTest0List = NULL;                                                               // list to hold all objects for Test0
-  TProfile* fTest0FlagsPro = NULL;                                                        // store all flags for Test0
-  Bool_t fCalculateTest0 = kFALSE;                                                        // calculate or not Test0
-  TProfile* fTest0Pro[gMaxCorrelator][gMaxIndex][eAsFunctionOf_N] = {{{NULL}}};           //! [order][index][0=integrated,1=vs. multiplicity,2=vs. centrality,3=pT,4=eta]
-  TString* fTest0Labels[gMaxCorrelator][gMaxIndex] = {{NULL}};                            // all labels: k-p'th order is stored in k-1'th index. So yes, I also store 1-p
-  Bool_t fCalculateTest0AsFunctionOf[eAsFunctionOf_N] = {true, true, true, false, false}; //! [0=integrated,1=vs. multiplicity,2=vs. centrality,3=pT,4=eta]
-  TString fFileWithLabels = "";                                                           // path to external ROOT file which specifies all labels of interest
-  TH1I* fTest0LabelsPlaceholder = NULL;                                                   // store all Test0 labels in this histogram
-} t0;                                                                                     // "t0" labels an instance of this group of histograms
+  TList* fTest0List = NULL;                                                                      // list to hold all objects for Test0
+  TProfile* fTest0FlagsPro = NULL;                                                               // store all flags for Test0
+  Bool_t fCalculateTest0 = kFALSE;                                                               // calculate or not Test0
+  TProfile* fTest0Pro[gMaxCorrelator][gMaxIndex][eAsFunctionOf_N] = {{{NULL}}};                  //! [order][index][0=integrated,1=vs. multiplicity,2=vs. centrality,3=pT,4=eta]
+  TString* fTest0Labels[gMaxCorrelator][gMaxIndex] = {{NULL}};                                   // all labels: k-p'th order is stored in k-1'th index. So yes, I also store 1-p
+  Bool_t fCalculateTest0AsFunctionOf[eAsFunctionOf_N] = {true, true, true, false, false, false}; //! [0=integrated,1=vs. multiplicity,2=vs. centrality,3=pT,4=eta,5=vs. occupancy]
+  TString fFileWithLabels = "";                                                                  // path to external ROOT file which specifies all labels of interest
+  TH1I* fTest0LabelsPlaceholder = NULL;                                                          // store all Test0 labels in this histogram
+} t0;                                                                                            // "t0" labels an instance of this group of histograms
 
 // *) Results:
 struct Results {                                   // This is in addition also sort of "abstract" interface, which defines common binning, etc., for other groups of histograms.

PWGCF/MultiparticleCorrelations/Core/MuPa-Enums.h

@@ -229,12 +229,12 @@ enum eQAEventHistograms2D {
   eMultTPC_vs_NContributors = 0,
   eVertex_z_vs_MultTPC,
   eVertex_z_vs_NContributors,
-  // Run 3:
-  eCentFT0M_vs_CentNTPV,
-  // Run 2 (do not use in Run 1 converted, because there is no centrality information):
-  eCentRun2V0M_vs_CentRun2SPDTracklets,
-  eCentRun2V0M_vs_NContributors,
+  eCentFT0M_vs_CentNTPV,                // Run 3 centrality
+  eCentRun2V0M_vs_CentRun2SPDTracklets, // Run 2 centrality (do not use in Run 1 converted, because there is no centrality information)
+  eCentRun2V0M_vs_NContributors,        // Run 2 centrality (do not use in Run 1 converted, because there is no centrality information)
   eTrackOccupancyInTimeRange_vs_FT0COccupancyInTimeRange,
+  eTrackOccupancyInTimeRange_vs_MultTPC,
+  eTrackOccupancyInTimeRange_vs_Vertex_z,
   eQAEventHistograms2D_N
 };