PWGHF/hfe/AliAnalysisTaskHFE.h

   1 /**************************************************************************
   2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3 *                                                                        *
   4 * Author: The ALICE Off-line Project.                                    *
   5 * Contributors are mentioned in the code where appropriate.              *
   6 *                                                                        *
   7 * Permission to use, copy, modify and distribute this software and its   *
   8 * documentation strictly for non-commercial purposes is hereby granted   *
   9 * without fee, provided that the above copyright notice appears in all   *
  10 * copies and that both the copyright notice and this permission notice   *
  11 * appear in the supporting documentation. The authors make no claims     *
  12 * about the suitability of this software for any purpose. It is          *
  13 * provided "as is" without express or implied warranty.                  *
  14 **************************************************************************/
  15 //
  16 // Task for Heavy Flavour Electron Analysis
  17 // Fills a single-inclusive electron pt-spectrum
  18 // For further information see implementation file
  19 //
  20 #ifndef ALIANALYSISTASKHFE_H
  21 #define ALIANALYSISTASKHFE_H
  22
  23 #ifndef ALIANALYSISTASKSE_H
  24 #include "AliAnalysisTaskSE.h"
  25 #endif
  26
  27 #ifndef ROOT_TString
  28 #include <TString.h>
  29 #endif
  30
  31 #ifndef ROOT_TBits
  32 #include <TBits.h>
  33 #endif
  34
  35 class AliAnalysisUtils;
  36 class AliESDtrackCuts;
  37 class AliHFEcontainer;
  38 class AliHFEcollection;
  39 class AliHFEcuts;
  40 class AliHFEextraCuts;
  41 class AliHFEelecbackground;
  42 class AliHFENonPhotonicElectron;
  43 class AliHFEmcQA;
  44 class AliHFEpid;
  45 class AliHFEpidQAmanager;
  46 class AliHFEsecVtx;
  47 class AliHFEsignalCuts;
  48 class AliHFEvarManager;
  49 class AliHFEtaggedTrackAnalysis;
  50 class AliHFEV0taginfo;
  51 class AliCFManager;
  52 class AliMCEvent;
  53 class AliOADBContainer;
  54 class AliAODMCHeader;
  55 class AliVEvent;
  56 class AliVParticle;
  57 class AliTriggerAnalysis;
  58 class AliTRDTriggerAnalysis;
  59 class TH1I;
  60 class TList;
  61 class TClonesArray;
  62
  63 class AliAnalysisTaskHFE : public AliAnalysisTaskSE{
  64   public:
  65     enum{
  66       kPIDqa = 0,
  67       kMCqa =1
  68     };
  69     enum{
  70       kPriVtx = 0,
  71       kSecVtx = 1,
  72       kIsElecBackGround = 2,
  73       kPostProcess = 3,
  74       kDEstep = 4,
  75       kTaggedTrackAnalysis = 5,
  76       kNonPhotonicElectron = 6,
  77       kNonPhotonicElectronBeauty = 7
  78     };
  79     enum CreationProcess_t{
  80       kSignalCharm = 0,
  81       kSignalBeauty = 1,
  82       kGammaConv = 2,
  83       kOther = 3
  84     };
  85     enum{
  86       kBgPtBins = 44,
  87       kElecBgSpecies = 6,
  88       kCentBins = 11,
  89       kBgLevels = 3
  90     };
  91     typedef enum{
  92       kpp = 0,
  93       kpPb = 1,
  94       kPbPb = 2
  95     } ECollisionSystem_t;
  96
  97     AliAnalysisTaskHFE();
  98     AliAnalysisTaskHFE(const char * name);
  99     AliAnalysisTaskHFE(const AliAnalysisTaskHFE &ref);
 100     AliAnalysisTaskHFE& operator=(const AliAnalysisTaskHFE &ref);
 101     virtual void Copy(TObject &o) const;
 102     virtual ~AliAnalysisTaskHFE();
 103
 104     virtual void UserCreateOutputObjects();
 105     virtual void UserExec(Option_t *);
 106     virtual void Terminate(Option_t *);
 107
 108     virtual Bool_t IsEventInBinZero();
 109
 110     Bool_t IsQAOn(Int_t qaLevel) const { return TESTBIT(fQAlevel, qaLevel); };
 111     Bool_t IsAODanalysis() const { return TestBit(kAODanalysis); };
 112     Bool_t IsESDanalysis() const { return !TestBit(kAODanalysis); };
 113     Bool_t HasMCData() const { return TestBit(kHasMCdata); }
 114     Bool_t Ispp() const { return fCollisionSystem.TestBitNumber(kpp); }
 115     Bool_t IsPbPb() const { return fCollisionSystem.TestBitNumber(kPbPb); }
 116     Bool_t IspPb() const { return fCollisionSystem.TestBitNumber(kpPb); }
 117     Bool_t IsHeavyIon() const { return IsPbPb(); }
 118     Bool_t GetPlugin(Int_t plug) const { return TESTBIT(fPlugins, plug); };
 119
 120     // Get Components for configuration
 121     AliHFEvarManager *GetVarManager() const { return fVarManager; }
 122     AliHFEpidQAmanager *GetPIDQAManager() const { return fPIDqa; }
 123     AliHFEpid *GetPID() const { return fPID; }
 124     AliHFENonPhotonicElectron *GetHFEBackgroundSubtraction() const { return fBackgroundSubtraction; }
 125
 126     void SetHFECuts(AliHFEcuts * const cuts) { fCuts = cuts; };
 127     void SetTaggedTrackCuts(AliHFEcuts * const cuts) { fTaggedTrackCuts = cuts; }
 128     void SetCleanTaggedTrack(Bool_t clean) { fCleanTaggedTrack = clean; };
 129     void SetVariablesTRDTaggedTrack(Bool_t variablesTRD) { fVariablesTRDTaggedTrack = variablesTRD; };
 130     void SetHFECutsPreselect(AliESDtrackCuts * const cuts) { fCutspreselect = cuts; };
 131     void SetHFEElecBackGround(AliHFEelecbackground * const elecBackGround) { fElecBackGround = elecBackGround; };
 132     void SetHFEBackgroundSubtraction(AliHFENonPhotonicElectron * const backgroundSubtraction) { fBackgroundSubtraction = backgroundSubtraction; };
 133     void SetQAOn(Int_t qaLevel) { SETBIT(fQAlevel, qaLevel); };
 134     void SwitchOnPlugin(Int_t plug);
 135     void SetHasMCData(Bool_t hasMC = kTRUE) { SetBit(kHasMCdata, hasMC); };
 136     void SetFillSignalOnly(Bool_t signalOnly) { fFillSignalOnly = signalOnly; }
 137
 138     void SetFillNoCuts(Bool_t fillNoCuts) { fFillNoCuts = fillNoCuts; }
 139     void SetRemovePileUp(Bool_t removePileUp) { fRemovePileUp = removePileUp; }
 140     void SetRemoveFirstEventInChunk() {fRemoveFirstEvent = kTRUE;}
 141     void SetPIDPreselect(AliHFEpid * const cuts) { fPIDpreselect = cuts; };
 142     void SetAODAnalysis() { SetBit(kAODanalysis, kTRUE); };
 143     void SetESDAnalysis() { SetBit(kAODanalysis, kFALSE); };
 144     void SetTRDTrigger(Bool_t activateTRDTrigger, Int_t trdtrigger) {fTRDTrigger=activateTRDTrigger; fWhichTRDTrigger=trdtrigger;};
 145     void SetCollisionSystem(ECollisionSystem_t system){
 146       fCollisionSystem.Clear();
 147       fCollisionSystem.SetBitNumber(system, kTRUE);
 148     }
 149     void SetppAnalysis(){
 150       fCollisionSystem.SetBitNumber(kpPb, kFALSE);
 151       fCollisionSystem.SetBitNumber(kPbPb, kFALSE);
 152       fCollisionSystem.SetBitNumber(kpp, kTRUE);
 153     }
 154     void SetpPbAnalysis() {
 155       fCollisionSystem.SetBitNumber(kpp, kFALSE);
 156       fCollisionSystem.SetBitNumber(kPbPb, kFALSE);
 157       fCollisionSystem.SetBitNumber(kpPb, kTRUE);
 158     }
 159     void SetPbPbAnalysis() {
 160       fCollisionSystem.SetBitNumber(kpp, kFALSE);
 161       fCollisionSystem.SetBitNumber(kpPb, kFALSE);
 162       fCollisionSystem.SetBitNumber(kPbPb, kTRUE);
 163     };
 164     void SetCentralityEstimator(const char *estimator) { fCentralityEstimator = estimator; }
 165     void SetPbPbUserCentralityLimit(Bool_t isPbPbUserBinning = kFALSE){fPbPbUserCentralityBinning = isPbPbUserBinning; };
 166     void SetPbPbUserCentralityArray(Int_t icentr, Float_t valuecentr) {fCentralityLimits[icentr] = valuecentr;};
 167     void SetPPMultiBinAnalysis(Bool_t isppMultiBin) { fisppMultiBin = isppMultiBin; };
 168     void SetNonHFEsystematics(Bool_t isSystematics) {fisNonHFEsystematics = isSystematics; };
 169     void SetRejectKinkMother(Bool_t rejectKinkMother = kFALSE) { fRejectKinkMother = rejectKinkMother; };
 170     void SetRejectMCFakeTracks(Bool_t rejectFakes = kTRUE) { fRejectMCFakeTracks = rejectFakes; };
 171     void SetBackGroundFactorsFunction(const TF1 * const backGroundFactorsFunction, Int_t centralitybin=0){
 172       fkBackGroundFactorArray[centralitybin]=backGroundFactorsFunction;
 173       fBackGroundFactorApply=kTRUE;
 174       SetBit(kBackgroundInitialized);
 175     };
 176     void SetElecBackGroundFactors(Int_t iPt, Int_t iType, Int_t iCent, Int_t iError, Double_t elecBackGroundFactor) {fElecBackgroundFactor[iError][iCent][iType][iPt] = elecBackGroundFactor; };
 177     void SetBinLimits(Int_t iPt, Double_t momentum){fBinLimit[iPt] = momentum;};
 178     void PrintStatus() const;
 179     Bool_t ReadCentrality();
 180     void RejectionPileUpVertexRangeEventCut();
 181     void SelectSpecialTrigger(const Char_t *trgclust, Int_t runMin = 0, Int_t runMax = 999999999);
 182     void SetDebugStreaming() {SetBit(kTreeStream);};
 183     void SetWeightHist() {SetBit(kWeightHist);};
 184     Bool_t CheckTRDTriggerESD(AliESDEvent *ev);
 185     Bool_t CheckTRDTrigger(AliVEvent *ev);
 186     void DrawTRDTrigger(AliESDEvent *ev);
 187     void DrawTRDTriggerAnalysis(AliVEvent *ev);
 188
 189   private:
 190     enum{
 191       kHasMCdata = BIT(19),
 192       kAODanalysis = BIT(20),
 193       kBackgroundInitialized = BIT(21),
 194       kTreeStream = BIT(22),
 195       kWeightHist = BIT(23)
 196     };
 197
 198     Bool_t FillProductionVertex(const AliVParticle * const track) const;
 199     void MakeParticleContainer();
 200     void MakeEventContainer();
 201     void InitHistoITScluster();
 202     void InitHistoRadius();
 203     void InitContaminationQA();
 204     const Char_t *GetSpecialTrigger(Int_t run);
 205     void ProcessMC();
 206     void ProcessESD();
 207     void ProcessAOD();
 208     Int_t GetITSMultiplicity(AliVEvent *ev);
 209     Bool_t IsMCFakeTrack(const AliVTrack * const trk) const;
 210     Bool_t PreSelectTrack(AliESDtrack *track) const;
 211     Bool_t ProcessMCtrack(AliVParticle *track);
 212     Bool_t ProcessCutStep(Int_t cutStep, AliVParticle *track);
 213     AliAODMCHeader *fAODMCHeader;         // ! MC info AOD
 214     TClonesArray *fAODArrayMCInfo;        // ! MC info particle AOD
 215     ULong_t fQAlevel;                     // QA level
 216     UShort_t fPlugins;                    // Enabled Plugins
 217     TBits fCollisionSystem;              // Collision System;
 218     Bool_t fFillSignalOnly;               // Fill container only with MC Signal Tracks
 219     Bool_t fRejectMCFakeTracks;           // Reject fake tracks in MC using the sign of the Label
 220     Bool_t fFillNoCuts;                   // Fill container before any cut
 221     Bool_t fBackGroundFactorApply;        // Apply Background Function Subtraction,   MF: To be removed when transition to OADB container is finished
 222     Bool_t fRemovePileUp;                 // Remove Pile Up
 223     Bool_t fIdentifiedAsPileUp;           // Identified as pile-up
 224     Bool_t fIdentifiedAsOutInz;           // Out Of Range in z
 225     Bool_t fPassTheEventCut;              // Pass The Event Cut
 226     Bool_t fRejectKinkMother;             // Reject Kink Mother
 227     Bool_t fisppMultiBin;                 // pp Multiplicity Bin analysis
 228     Bool_t fPbPbUserCentralityBinning;    // PbPb user centrality binning
 229     Bool_t fRemoveFirstEvent;             // Remove first event from chunk
 230     Bool_t fisNonHFEsystematics;          // Non-HFE background systematics analysis
 231     AliOADBContainer *fSpecialTrigger;    // Special trigger selection
 232     Int_t   fCentralityF;                 // Centrality bin
 233     Float_t fCentralityPercent;           // Centrality percentile
 234     TString fCentralityEstimator;         // Centrality Estimator
 235     Float_t fContributors;                // Contributors
 236     Double_t fWeightBackGround;            // weight background function
 237     Double_t fVz;                         // z position of the primary vertex
 238     const TF1  *fkBackGroundFactorArray[12];   // Array of BackGround factors for each centrality bin, bin0 = min bias
 239     Double_t fElecBackgroundFactor[kBgLevels][kCentBins][kElecBgSpecies][kBgPtBins];     // Electron background factors
 240     Double_t fBinLimit[kBgPtBins+1];      // Electron pt bin edges
 241     Float_t fCentralityLimits[12];        // Limits for centrality bins
 242     AliHFEcontainer *fContainer;          //! The HFE container
 243     AliHFEvarManager *fVarManager;        // The var manager as the backbone of the analysis
 244     AliHFEsignalCuts *fSignalCuts;        //! MC true signal (electron coming from certain source)
 245     AliCFManager *fCFM;                   //! Correction Framework Manager
 246     AliTriggerAnalysis *fTriggerAnalysis; //! Trigger Analysis for Normalisation
 247     AliHFEpid *fPID;                      // PID
 248     AliHFEpidQAmanager *fPIDqa;           // PID QA
 249     AliTRDTriggerAnalysis *fTRDTriggerAnalysismb; //! TRD Trigger Analysis for mb analysis
 250     AliTRDTriggerAnalysis *fTRDTriggerAnalysistrg; //! TRD Trigger Analysis for trg sample analysis
 251     AliHFEpid *fPIDpreselect;             // PID oject for pre-selected tracks (without QA)
 252     AliHFEcuts *fCuts;                    // Cut Collection
 253     AliHFEcuts *fTaggedTrackCuts;         // Cut Collection for V0 tagged tracks
 254     Bool_t fCleanTaggedTrack;             // Loose cleaning of the V0 tagged tracks electron
 255     Bool_t fVariablesTRDTaggedTrack;      // Take the variables at the TRD for the V0 tagged tracks electron
 256     AliAnalysisUtils *fAnalysisUtils;     // Utility object to remove the first event of a chunk from the analysis
 257     AliESDtrackCuts *fCutspreselect;      // Cut Collection for pre-selected tracks
 258     AliHFEsecVtx *fSecVtx;                //! Secondary Vertex Analysis
 259     AliHFEelecbackground *fElecBackGround;//! Background analysis
 260     AliHFEmcQA *fMCQA;                    //! MC QA
 261     AliHFEtaggedTrackAnalysis *fTaggedTrackAnalysis;     //!Analyse V0-tagged tracks
 262     AliHFEextraCuts *fExtraCuts;          //! temporary implementation for IP QA
 263     AliHFENonPhotonicElectron *fBackgroundSubtraction; // Background subtraction
 264     Bool_t fTRDTrigger;                   // Check if event is TRD triggered event
 265     Int_t  fWhichTRDTrigger;               // Select type of TRD trigger
 266
 267     AliHFEV0taginfo *fV0Tagger;           // Tags v0 tracks per Event
 268
 269     //-----------QA and output---------------
 270     TList *fQA;                           //! QA histos for the cuts
 271     TList *fOutput;                       //! Container for Task Output
 272     TList *fHistMCQA;                     //! Output container for MC QA histograms
 273     TList *fHistSECVTX;                   //! Output container for sec. vertexing results
 274     TList *fHistELECBACKGROUND;           //! Output container for electron background analysis
 275     AliHFEcollection *fQACollection;      //! Tasks own QA collection
 276     //---------------------------------------
 277
 278     ClassDef(AliAnalysisTaskHFE, 2)       // The electron Analysis Task
 279 };
 280 #endif
 281