PWGJE/UserTasks/AliAnalysisTaskPID.h

   1 #ifndef ALI_ANALYSIS_TASK_PID_H\r
   2 #define ALI_ANALYSIS_TASK_PID_H\r
   3 \r
   4 /*\r
   5 This task collects PID output from different detectors.\r
   6 Only tracks fulfilling some standard quality cuts are taken into account.\r
   7 At the moment, only data from TPC and TOF is collected. But in future,\r
   8 data from e.g. HMPID is also foreseen.\r
   9 \r
  10 Class written by Benjamin Hess.\r
  11 Contact: bhess@cern.ch\r
  12 */\r
  13 \r
  14 class TF1;\r
  15 class TRandom3;\r
  16 class AliAnalysisFilter;\r
  17 class AliCFContainer;\r
  18 class AliESDEvent;\r
  19 class AliMCEvent;\r
  20 class AliMCParticle;\r
  21 class AliPID;\r
  22 class AliPIDCombined;\r
  23 class AliPIDResponse;\r
  24 class AliTOFPIDResponse;\r
  25 class AliVEvent;\r
  26 class AliVTrack;\r
  27 \r
  28 #include "TH1D.h"\r
  29 #include "TH2D.h"\r
  30 #include "TH3D.h"\r
  31 #include "THnSparse.h"\r
  32 #include "TProfile.h"\r
  33 #include "TString.h"\r
  34 \r
  35 #include "AliCentrality.h"\r
  36 #include "AliCFContainer.h"\r
  37 \r
  38 #include "AliPID.h"\r
  39 #include "AliAnalysisTaskPIDV0base.h"\r
  40 \r
  41 class AliAnalysisTaskPID : public AliAnalysisTaskPIDV0base {\r
  42  public:\r
  43   AliAnalysisTaskPID();\r
  44   AliAnalysisTaskPID(const char *name);\r
  45   virtual ~AliAnalysisTaskPID();\r
  46   \r
  47   virtual void   UserCreateOutputObjects();\r
  48   virtual void   UserExec(Option_t *option);\r
  49   virtual void   Terminate(const Option_t*);\r
  50   \r
  51   enum ErrorCode { kNoErrors = 1, kWarning = 0, kError = -1};\r
  52   \r
  53   enum dataAxes { kDataMCID = 0, kDataSelectSpecies = 1, kDataPt = 2, kDataDeltaPrimeSpecies = 3, kDataCentrality = 4,\r
  54                   kDataJetPt = 5, kDataZ = 6, kDataXi = 7, kDataCharge = 8, kDataNumAxes = 9 };\r
  55 \r
  56   enum genAxes { kGenMCID = 0, kGenSelectSpecies = 1, kGenPt = 2, kGenDeltaPrimeSpecies = 3, kGenCentrality = 4,\r
  57                  kGenJetPt = 5, kGenZ = 6, kGenXi = 7, kGenCharge = 8, kGenNumAxes = 9 };\r
  58   \r
  59   enum genYieldAxes { kGenYieldMCID = 0, kGenYieldPt = 1, kGenYieldCentrality = 2, kGenYieldJetPt = 3, kGenYieldZ = 4, kGenYieldXi = 5,\r
  60                       kGenYieldCharge = 6, kGenYieldNumAxes = 7 };\r
  61   \r
  62   enum efficiencyAxes { kEffMCID = 0, kEffTrackPt = 1, kEffTrackEta = 2, kEffTrackCharge = 3, kEffCentrality = 4, kEffJetPt = 5,\r
  63                         kEffZ = 6, kEffXi = 7, kEffNumAxes = 8 };\r
  64   \r
  65   enum EffSteps { kStepGenWithGenCuts = 0, kStepRecWithGenCuts = 1, kStepRecWithGenCutsMeasuredObs = 2,\r
  66                   kStepRecWithRecCutsMeasuredObs = 3, kStepRecWithRecCutsMeasuredObsPrimaries = 4,\r
  67                   kStepRecWithRecCutsMeasuredObsStrangenessScaled = 5, kNumSteps = 6};\r
  68   \r
  69   static Int_t PDGtoMCID(Int_t pdg);\r
  70   \r
  71   static void GetJetTrackObservables(const Double_t trackPt, const Double_t jetPt, Double_t& z, Double_t& xi);\r
  72   \r
  73   static Double_t GetMCStrangenessFactorCMS(Int_t motherPDG, Double_t motherGenPt);\r
  74   static Double_t GetMCStrangenessFactorCMS(AliMCEvent* mcEvent, AliMCParticle* daughter);\r
  75   \r
  76   static Bool_t IsSecondaryWithStrangeMotherMC(AliMCEvent* mcEvent, Int_t partLabel);\r
  77   \r
  78   Int_t GetIndexOfChargeAxisData() const\r
  79     { return fStoreAdditionalJetInformation ? kDataCharge : kDataCharge - fgkNumJetAxes; };\r
  80   Int_t GetIndexOfChargeAxisGen() const\r
  81     { return fStoreAdditionalJetInformation ? kGenCharge : kGenCharge - fgkNumJetAxes; };\r
  82   Int_t GetIndexOfChargeAxisGenYield() const\r
  83     { return fStoreAdditionalJetInformation ? kGenYieldCharge : kGenYieldCharge - fgkNumJetAxes; };\r
  84   \r
  85   Bool_t FillXsec(const Double_t xsection)\r
  86     { if (!fh1Xsec) return kFALSE; fh1Xsec->Fill("<#sigma>", xsection); return kTRUE; };\r
  87   Bool_t FillPythiaTrials(const Double_t avgTrials)\r
  88     { if (!fh1Trials) return kFALSE; fh1Trials->Fill("#sum{ntrials}", avgTrials); return kTRUE; };\r
  89     \r
  90   Bool_t FillEfficiencyContainer(const Double_t* values, const EffSteps step, const Double_t weight = 1.0);\r
  91   \r
  92   Bool_t FillGeneratedYield(const Double_t* values, const Double_t weight = 1.0);\r
  93   Bool_t FillGenJets(const Double_t centralityPercentile, const Double_t jetPt, const Double_t norm = -1.);\r
  94   Bool_t FillRecJets(const Double_t centralityPercentile, const Double_t jetPt, const Double_t norm = -1.);\r
  95   \r
  96   Bool_t IncrementEventsProcessed(const Double_t centralityPercentile);\r
  97   \r
  98   void PostOutputData() { PostData(1, fOutputContainer);  PostData(2, fContainerEff); };\r
  99   \r
 100   void PrintSettings(Bool_t printSystematicsSettings = kFALSE) const;\r
 101   \r
 102   void PrintSystematicsSettings() const;\r
 103   \r
 104   Bool_t ProcessTrack(const AliVTrack* track, Int_t particlePDGcode, Double_t centralityPercentile, Double_t jetPt) ;\r
 105   \r
 106   ErrorCode GenerateDetectorResponse(const ErrorCode errCode, const Double_t mean, const Double_t sigma, Double_t* responses,\r
 107                                      const Int_t nResponses,\r
 108                                      const Bool_t usePureGaus = kFALSE);\r
 109   ErrorCode SetParamsForConvolutedGaus(const Double_t gausMean, const Double_t gausSigma);\r
 110   \r
 111   const TString GetCentralityEstimator() const { return fCentralityEstimator; };\r
 112   void SetCentralityEstimator(TString estimator) { fCentralityEstimator = estimator; };\r
 113   \r
 114   Double_t GetCentralityPercentile(AliVEvent* evt) const;\r
 115   \r
 116   inline Double_t GetConvolutedGaussTransitionPar(Int_t index) const;\r
 117   \r
 118   Bool_t SetConvolutedGaussLambdaParameter(Double_t lambda);\r
 119 \r
 120   Bool_t GetInputFromOtherTask() const { return fInputFromOtherTask; };\r
 121   void SetInputFromOtherTask(Bool_t flag) { fInputFromOtherTask = flag; };\r
 122   \r
 123   Bool_t GetStoreCentralityPercentile() const { return fStoreCentralityPercentile; };\r
 124   void SetStoreCentralityPercentile(Bool_t flag) { fStoreCentralityPercentile = flag; };\r
 125   \r
 126   Bool_t GetStoreAdditionalJetInformation() const { return fStoreAdditionalJetInformation; };\r
 127   void SetStoreAdditionalJetInformation(Bool_t flag) { fStoreAdditionalJetInformation = flag; };\r
 128   \r
 129   Bool_t GetUseMCidForGeneration() const { return fUseMCidForGeneration; };\r
 130   void SetUseMCidForGeneration(Bool_t flag) { fUseMCidForGeneration = flag; };\r
 131   \r
 132   Bool_t GetUseConvolutedGaus() const { return fUseConvolutedGaus; };\r
 133   void SetUseConvolutedGaus(Bool_t flag) { fUseConvolutedGaus = flag; };\r
 134   \r
 135   Double_t GetAccuracyNonGaussianTail() const { return fAccuracyNonGaussianTail; };\r
 136   void SetAccuracyNonGaussianTail(Double_t value) { fAccuracyNonGaussianTail = value; };\r
 137   \r
 138   Bool_t GetTakeIntoAccountMuons() const { return fTakeIntoAccountMuons; };\r
 139   void SetTakeIntoAccountMuons(Bool_t flag) { fTakeIntoAccountMuons = flag; };\r
 140   \r
 141   Bool_t GetUseTPCDefaultPriors() const { return fTPCDefaultPriors; };\r
 142   void SetUseTPCDefaultPriors(Bool_t flag) { fTPCDefaultPriors = flag; };\r
 143   \r
 144   Bool_t GetUsePriors() const { return fUsePriors; };\r
 145   void SetUsePriors(Bool_t flag) { fUsePriors = flag; };\r
 146   \r
 147   Bool_t GetUseITS() const { return fUseITS; };\r
 148   void SetUseITS(Bool_t flag) { fUseITS = flag; };\r
 149   \r
 150   Bool_t GetUseTOF() const { return fUseTOF; };\r
 151   void SetUseTOF(Bool_t flag) { fUseTOF = flag; };\r
 152   \r
 153   Double_t GetEtaAbsCutLow() const { return fEtaAbsCutLow; };\r
 154   Double_t GetEtaAbsCutUp() const { return fEtaAbsCutUp; };\r
 155   Bool_t SetEtaAbsCutRange(Double_t lowerLimit, Double_t upperLimit);\r
 156   \r
 157   Double_t GetSystematicScalingSplines() const { return fSystematicScalingSplines; };\r
 158   void SetSystematicScalingSplines(Double_t scaleFactor) \r
 159     { fSystematicScalingSplines = scaleFactor; CheckDoAnyStematicStudiesOnTheExpectedSignal(); };\r
 160   \r
 161   Double_t GetSystematicScalingEtaCorrectionMomentumThr() const { return fSystematicScalingEtaCorrectionMomentumThr; };\r
 162   void SetSystematicScalingEtaCorrectionMomentumThr(Double_t threshold) { fSystematicScalingEtaCorrectionMomentumThr = threshold; };\r
 163   \r
 164   Double_t GetSystematicScalingEtaCorrectionLowMomenta() const { return fSystematicScalingEtaCorrectionLowMomenta; };\r
 165   void SetSystematicScalingEtaCorrectionLowMomenta(Double_t scaleFactor) \r
 166     { fSystematicScalingEtaCorrectionLowMomenta = scaleFactor; CheckDoAnyStematicStudiesOnTheExpectedSignal(); };\r
 167   \r
 168   Double_t GetSystematicScalingEtaCorrectionHighMomenta() const { return fSystematicScalingEtaCorrectionHighMomenta; };\r
 169   void SetSystematicScalingEtaCorrectionHighMomenta(Double_t scaleFactor) \r
 170     { fSystematicScalingEtaCorrectionHighMomenta = scaleFactor; CheckDoAnyStematicStudiesOnTheExpectedSignal(); };\r
 171   \r
 172   Double_t GetSystematicScalingEtaSigmaPara() const { return fSystematicScalingEtaSigmaPara; };\r
 173   void SetSystematicScalingEtaSigmaPara(Double_t scaleFactor)\r
 174     { fSystematicScalingEtaSigmaPara = scaleFactor; CheckDoAnyStematicStudiesOnTheExpectedSignal(); };\r
 175   \r
 176   Double_t GetSystematicScalingMultCorrection() const { return fSystematicScalingMultCorrection; };\r
 177   void SetSystematicScalingMultCorrection(Double_t scaleFactor) \r
 178     { fSystematicScalingMultCorrection = scaleFactor; CheckDoAnyStematicStudiesOnTheExpectedSignal(); };\r
 179   \r
 180   void CleanupParticleFractionHistos();\r
 181   Bool_t GetParticleFraction(const Double_t trackPt, const Double_t jetPt, const Double_t multiplicity,\r
 182                              const AliPID::EParticleType species, Double_t& fraction, Double_t& fractionErrorStat,\r
 183                              Double_t& fractionErrorSys) const;\r
 184   Bool_t GetParticleFractions(const Double_t trackPt, const Double_t jetPt, const Double_t centralityPercentile,\r
 185                               Double_t* prob, const Int_t smearSpeciesByError, const Int_t takeIntoAccountSpeciesSysError,\r
 186                               const Bool_t uniformSystematicError = kFALSE) const;\r
 187   const TH3D* GetParticleFractionHisto(const Int_t species, const Bool_t sysError = kFALSE) const;\r
 188   Bool_t SetParticleFractionHisto(const TH3D* hist, const Int_t species, const Bool_t sysError = kFALSE);\r
 189   Int_t GetParticleFractionHistoNbinsTrackPt() const;\r
 190   Int_t GetParticleFractionHistoNbinsJetPt() const;\r
 191   Int_t GetParticleFractionHistoNbinsCentrality() const;\r
 192   Bool_t SetParticleFractionHistosFromFile(const TString filePathName, const Bool_t sysError = kFALSE);\r
 193   Int_t GetRandomParticleTypeAccordingToParticleFractions(const Double_t trackPt, const Double_t jetPt, \r
 194                                                           const Double_t centralityPercentile,\r
 195                                                           const Bool_t smearByError,\r
 196                                                           const Bool_t takeIntoAccountSysError = kFALSE) const;\r
 197   \r
 198   \r
 199  protected:\r
 200   void CheckDoAnyStematicStudiesOnTheExpectedSignal();\r
 201   Double_t ConvolutedGaus(const Double_t* xx, const Double_t* par) const;\r
 202   inline Double_t FastGaus(const Double_t x, const Double_t mean, const Double_t sigma) const;\r
 203   inline Double_t FastNormalisedGaus(const Double_t x, const Double_t mean, const Double_t sigma) const;\r
 204   Int_t FindBinWithinRange(TAxis* axis, Double_t value) const;\r
 205   Int_t FindFirstBinAboveIn3dSubset(const TH3* hist, const Double_t threshold, const Int_t yValue, const Int_t zValue) const;\r
 206   Int_t FindLastBinAboveIn3dSubset(const TH3* hist, const Double_t threshold, const Int_t yValue, const Int_t zValue) const;\r
 207   virtual void SetUpGenHist(THnSparse* hist, Double_t* binsPt, Double_t* binsDeltaPrime, Double_t* binsCent, Double_t* binsJetPt) const;\r
 208   virtual void SetUpGenYieldHist(THnSparse* hist, Double_t* binsPt, Double_t* binsCent, Double_t* binsJetPt) const;\r
 209   virtual void SetUpHist(THnSparse* hist, Double_t* binsPt, Double_t* binsDeltaPrime, Double_t* binsCent, Double_t* binsJetPt) const;\r
 210   virtual void SetUpPIDcombined();\r
 211   \r
 212   static const Int_t fgkNumJetAxes = 3; // Number of additional axes for jets\r
 213   static const Double_t fgkEpsilon = 1e-8; // Double_t threshold above zero\r
 214   static const Int_t fgkMaxNumGenEntries = 1000; // Maximum number of generated detector responses per track and delta(Prime) and associated species\r
 215 \r
 216  private:\r
 217   static const Double_t fgkOneOverSqrt2 = 0.707106781186547462; // = 1. / TMath::Sqrt2();\r
 218   \r
 219   AliPIDCombined* fPIDcombined; //! PID combined object\r
 220   \r
 221   Bool_t fInputFromOtherTask; // If set to kTRUE, no events are processed and the input must be fed in from another task. If set to kFALSE, normal event processing\r
 222   \r
 223   Bool_t fStoreCentralityPercentile; // If set to kTRUE, store centrality percentile for each event. In case of kFALSE (appropriate for pp), centrality percentile will be set to -1 for every event\r
 224   Bool_t fStoreAdditionalJetInformation; // If set to kTRUE, additional jet information like jetPt, z, xi will be stored in the THnSparses\r
 225 \r
 226   Bool_t fTakeIntoAccountMuons; // Also take into account muons for the generation of the expected response and the most probable PID\r
 227   Bool_t fUseITS; // Use ITS for PID combined probabilities\r
 228   Bool_t fUseTOF; // Use TOF for PID combined probabilities\r
 229   Bool_t fUsePriors; // Use priors for PID combined probabilities\r
 230   Bool_t fTPCDefaultPriors; // Use TPC default priors for PID combined probabilities, if priors are enabled\r
 231     \r
 232   Bool_t fUseMCidForGeneration; // If MC, use MCid instead of PIDcombined to generate the signals\r
 233   \r
 234   Bool_t fUseConvolutedGaus; // Use convoluted gaus to generate detector response instead of pure gaus  \r
 235   const Int_t fkConvolutedGausNPar; // Number of parameters for convoluted gaus\r
 236   Double_t fAccuracyNonGaussianTail; // Accuracy of the non-gaussian tail (fraction of the maximum)\r
 237   const Double_t fkDeltaPrimeLowLimit; // Lower deltaPrime limit\r
 238   const Double_t fkDeltaPrimeUpLimit; // Upper deltaPrime limit\r
 239   TF1* fConvolutedGausDeltaPrime; // Gaus convoluted with exponential tail to generate detector response (deltaPrime)\r
 240   \r
 241   Double_t fConvolutedGaussTransitionPars[3]; // Parameter for transition from gaussian parameters to asymmetric shape\r
 242   static const Double_t fgkSigmaReferenceForTransitionPars = 0.05; // Reference sigma chosen to calculate transition parameters\r
 243   \r
 244   Double_t fEtaAbsCutLow; // Lower cut value on |eta|\r
 245   Double_t fEtaAbsCutUp;  // Upper cut value on |eta|\r
 246   \r
 247   // For systematic studies\r
 248   Bool_t   fDoAnySystematicStudiesOnTheExpectedSignal; // Internal flag indicating whether any systematic studies are going to be performed\r
 249   Double_t fSystematicScalingSplines;        // Systematic scale factor for the splines (1. = no systematics) \r
 250   Double_t fSystematicScalingEtaCorrectionMomentumThr;  // Momentum threshold for the systematic scale factor for the eta correction (separates low-p from high-p\r
 251   Double_t fSystematicScalingEtaCorrectionLowMomenta;   // Systematic scale factor for the eta correction (1. = no systematics) at low momenta\r
 252   Double_t fSystematicScalingEtaCorrectionHighMomenta;  // Systematic scale factor for the eta correction (1. = no systematics) at high momenta\r
 253   Double_t fSystematicScalingEtaSigmaPara;   // Systematic scale factor for the parametrisation of the relative signal width (1. = no systematics) \r
 254   Double_t fSystematicScalingMultCorrection; // Systematic scale factor for the multiplicity correction (1. = no systematics) \r
 255   \r
 256   TH3D* fFractionHists[AliPID::kSPECIES]; // 3D histos of particle fraction as function  with trackPt, jetPt (-1 for inclusive spectra), centralityPercentile (-1 for pp)\r
 257   TH3D* fFractionSysErrorHists[AliPID::kSPECIES]; // 3D histos of sys. error of particle fraction as function  with trackPt, jetPt (-1 for inclusive spectra), centralityPercentile (-1 for pp)\r
 258   \r
 259   TString fCentralityEstimator; // Estimator for the centrality (e.g. V0A, V0M)\r
 260   \r
 261   THnSparseD* fhPIDdataAll; // Data histo\r
 262   \r
 263   // Generated response information\r
 264   THnSparseD* fhGenEl; // Generated response for el\r
 265   THnSparseD* fhGenKa; // Generated response for ka\r
 266   THnSparseD* fhGenPi; // Generated response for pi\r
 267   THnSparseD* fhGenMu; // Generated response for mu\r
 268   THnSparseD* fhGenPr; // Generated response for pr\r
 269   \r
 270   // Generated responses for a single track\r
 271   Double_t* fGenRespElDeltaPrimeEl; //! Generated responses for a single track\r
 272   Double_t* fGenRespElDeltaPrimeKa; //! Generated responses for a single track\r
 273   Double_t* fGenRespElDeltaPrimePi; //! Generated responses for a single track\r
 274   Double_t* fGenRespElDeltaPrimePr; //! Generated responses for a single track\r
 275   Double_t* fGenRespKaDeltaPrimeEl; //! Generated responses for a single track\r
 276   Double_t* fGenRespKaDeltaPrimeKa; //! Generated responses for a single track\r
 277   Double_t* fGenRespKaDeltaPrimePi; //! Generated responses for a single track\r
 278   Double_t* fGenRespKaDeltaPrimePr; //! Generated responses for a single track\r
 279   Double_t* fGenRespPiDeltaPrimeEl; //! Generated responses for a single track\r
 280   Double_t* fGenRespPiDeltaPrimeKa; //! Generated responses for a single track\r
 281   Double_t* fGenRespPiDeltaPrimePi; //! Generated responses for a single track\r
 282   Double_t* fGenRespPiDeltaPrimePr; //! Generated responses for a single track\r
 283   Double_t* fGenRespMuDeltaPrimeEl; //! Generated responses for a single track\r
 284   Double_t* fGenRespMuDeltaPrimeKa; //! Generated responses for a single track\r
 285   Double_t* fGenRespMuDeltaPrimePi; //! Generated responses for a single track\r
 286   Double_t* fGenRespMuDeltaPrimePr; //! Generated responses for a single track\r
 287   Double_t* fGenRespPrDeltaPrimeEl; //! Generated responses for a single track\r
 288   Double_t* fGenRespPrDeltaPrimeKa; //! Generated responses for a single track\r
 289   Double_t* fGenRespPrDeltaPrimePi; //! Generated responses for a single track\r
 290   Double_t* fGenRespPrDeltaPrimePr; //! Generated responses for a single track\r
 291   /*\r
 292   Double_t* fGenRespElDeltaEl; //! Generated responses for a single track\r
 293   Double_t* fGenRespElDeltaKa; //! Generated responses for a single track\r
 294   Double_t* fGenRespElDeltaPi; //! Generated responses for a single track\r
 295   Double_t* fGenRespElDeltaPr; //! Generated responses for a single track\r
 296   Double_t* fGenRespKaDeltaEl; //! Generated responses for a single track\r
 297   Double_t* fGenRespKaDeltaKa; //! Generated responses for a single track\r
 298   Double_t* fGenRespKaDeltaPi; //! Generated responses for a single track\r
 299   Double_t* fGenRespKaDeltaPr; //! Generated responses for a single track\r
 300   Double_t* fGenRespPiDeltaEl; //! Generated responses for a single track\r
 301   Double_t* fGenRespPiDeltaKa; //! Generated responses for a single track\r
 302   Double_t* fGenRespPiDeltaPi; //! Generated responses for a single track\r
 303   Double_t* fGenRespPiDeltaPr; //! Generated responses for a single track\r
 304   Double_t* fGenRespMuDeltaEl; //! Generated responses for a single track\r
 305   Double_t* fGenRespMuDeltaKa; //! Generated responses for a single track\r
 306   Double_t* fGenRespMuDeltaPi; //! Generated responses for a single track\r
 307   Double_t* fGenRespMuDeltaPr; //! Generated responses for a single track\r
 308   Double_t* fGenRespPrDeltaEl; //! Generated responses for a single track\r
 309   Double_t* fGenRespPrDeltaKa; //! Generated responses for a single track\r
 310   Double_t* fGenRespPrDeltaPi; //! Generated responses for a single track\r
 311   Double_t* fGenRespPrDeltaPr; //! Generated responses for a single track\r
 312   */\r
 313   \r
 314   TH1D* fhEventsProcessed; // Histo holding the number of processed events\r
 315   TH2D* fhSkippedTracksForSignalGeneration; // Number of tracks that have been skipped for the signal generation\r
 316   THnSparseD* fhMCgeneratedYieldsPrimaries; // Histo holding the generated (no reco, no cuts) primary particle yields in considered eta range\r
 317   \r
 318   TH2D* fh2FFJetPtRec;            // Number of reconstructed jets vs. jetPt and centrality\r
 319   TH2D* fh2FFJetPtGen;            // Number of generated jets vs. jetPt and centrality\r
 320   \r
 321   TProfile* fh1Xsec;              // pythia cross section and trials\r
 322   TH1D*     fh1Trials;            // sum of trials\r
 323   \r
 324   AliCFContainer* fContainerEff; // Container for efficiency determination\r
 325   \r
 326   TObjArray * fOutputContainer; // output data container\r
 327   \r
 328   AliAnalysisTaskPID(const AliAnalysisTaskPID&); // not implemented\r
 329   AliAnalysisTaskPID& operator=(const AliAnalysisTaskPID&); // not implemented\r
 330   \r
 331   ClassDef(AliAnalysisTaskPID, 12);\r
 332 };\r
 333 \r
 334 \r
 335 //_____________________________________________________________________________\r
 336 inline Bool_t AliAnalysisTaskPID::FillEfficiencyContainer(const Double_t* values, const AliAnalysisTaskPID::EffSteps step,\r
 337                                                           const Double_t weight) \r
 338 {\r
 339   // Fill efficiency container at step "step" with the values\r
 340   \r
 341   if (!fContainerEff) {\r
 342     AliError("Efficiency container not initialised -> cannot be filled!");\r
 343     return kFALSE;\r
 344   }\r
 345   \r
 346   fContainerEff->Fill(values, step, weight);    \r
 347   \r
 348   return kTRUE;\r
 349 }\r
 350 \r
 351 \r
 352 //_____________________________________________________________________________\r
 353 inline Bool_t AliAnalysisTaskPID::FillGeneratedYield(const Double_t* values, const Double_t weight)\r
 354 {\r
 355   // Fill histos with generated primary yields with provided values\r
 356   \r
 357   if (!fhMCgeneratedYieldsPrimaries) {\r
 358     AliError("Histo for generated primary yield not initialised -> cannot be filled!");\r
 359     return kFALSE;\r
 360   }\r
 361   \r
 362   fhMCgeneratedYieldsPrimaries->Fill(values, weight);\r
 363     \r
 364   return kTRUE;\r
 365 }\r
 366 \r
 367 \r
 368 //_____________________________________________________________________________\r
 369 inline Bool_t AliAnalysisTaskPID::FillGenJets(const Double_t centralityPercentile, const Double_t jetPt, const Double_t norm)\r
 370 {\r
 371   if (!fh2FFJetPtGen)\r
 372     return kFALSE;\r
 373   \r
 374   if (norm > 0.)\r
 375     fh2FFJetPtGen->Fill(centralityPercentile, jetPt, 1. / norm);\r
 376   else\r
 377     fh2FFJetPtGen->Fill(centralityPercentile, jetPt);\r
 378   \r
 379   return kTRUE;\r
 380 }\r
 381 \r
 382 \r
 383 //_____________________________________________________________________________\r
 384 inline Bool_t AliAnalysisTaskPID::FillRecJets(const Double_t centralityPercentile, const Double_t jetPt, const Double_t norm)\r
 385 {\r
 386   if (!fh2FFJetPtRec)\r
 387     return kFALSE;\r
 388   \r
 389   if (norm > 0.)\r
 390     fh2FFJetPtRec->Fill(centralityPercentile, jetPt, 1. / norm);\r
 391   else\r
 392     fh2FFJetPtRec->Fill(centralityPercentile, jetPt);\r
 393   \r
 394   return kTRUE;\r
 395 }\r
 396  \r
 397 \r
 398 //_____________________________________________________________________________\r
 399 inline Bool_t AliAnalysisTaskPID::IncrementEventsProcessed(const Double_t centralityPercentile)\r
 400 {\r
 401   // Increment the number of processed events for the given centrality percentile\r
 402   \r
 403   if (!fhEventsProcessed) {\r
 404     AliError("Histogram for number of events not initialised -> cannot be incremented!");\r
 405     return kFALSE;\r
 406   }\r
 407   \r
 408   fhEventsProcessed->Fill(centralityPercentile);\r
 409   return kTRUE;\r
 410 };\r
 411 \r
 412 \r
 413 //_____________________________________________________________________________\r
 414 inline Bool_t AliAnalysisTaskPID::SetEtaAbsCutRange(Double_t lowerLimit, Double_t upperLimit)\r
 415 {\r
 416   if (lowerLimit >= upperLimit) {\r
 417     AliError(Form("Requested lower |eta| cut limit >= upper |eta| cut limit. Old eta cut range will be used (low %f, high %f).",\r
 418                   fEtaAbsCutLow, fEtaAbsCutUp));\r
 419     return kFALSE;\r
 420   }\r
 421   \r
 422   fEtaAbsCutLow = lowerLimit;\r
 423   fEtaAbsCutUp = upperLimit;\r
 424   \r
 425   return kTRUE;\r
 426 };\r
 427 \r
 428 \r
 429 //_____________________________________________________________________________\r
 430 inline Double_t AliAnalysisTaskPID::GetConvolutedGaussTransitionPar(Int_t index) const\r
 431 {\r
 432   if (index < 0 || index >= 3) {\r
 433     printf("Invalid index %d!\n", index);\r
 434     return -1;\r
 435   }\r
 436   return fConvolutedGaussTransitionPars[index];\r
 437 }\r
 438 \r
 439 \r
 440 //_____________________________________________________________________________\r
 441 inline Int_t AliAnalysisTaskPID::GetParticleFractionHistoNbinsTrackPt() const\r
 442 {\r
 443   if (!fFractionHists[AliPID::kPion])\r
 444     return -1;\r
 445   \r
 446   return fFractionHists[AliPID::kPion]->GetNbinsX();\r
 447 }\r
 448 \r
 449 \r
 450 //_____________________________________________________________________________\r
 451 inline Int_t AliAnalysisTaskPID::GetParticleFractionHistoNbinsJetPt() const\r
 452 {\r
 453   if (!fFractionHists[AliPID::kPion])\r
 454     return -1;\r
 455   \r
 456   return fFractionHists[AliPID::kPion]->GetNbinsY();\r
 457 }\r
 458 \r
 459 \r
 460 //_____________________________________________________________________________\r
 461 inline Int_t AliAnalysisTaskPID::GetParticleFractionHistoNbinsCentrality() const\r
 462 {\r
 463   if (!fFractionHists[AliPID::kPion])\r
 464     return -1;\r
 465   \r
 466   return fFractionHists[AliPID::kPion]->GetNbinsZ();\r
 467 }\r
 468 \r
 469 \r
 470 //_____________________________________________________________________________\r
 471 inline Double_t AliAnalysisTaskPID::GetCentralityPercentile(AliVEvent* evt) const\r
 472 {\r
 473   if (!evt)\r
 474     return -1;\r
 475   \r
 476   Double_t centralityPercentile = -1.;\r
 477   if (fStoreCentralityPercentile)\r
 478     centralityPercentile = evt->GetCentrality()->GetCentralityPercentile(fCentralityEstimator.Data());\r
 479   \r
 480   return centralityPercentile;\r
 481 }\r
 482 \r
 483 #endif\r