PWGDQ/dielectron/AliAnalysisTaskMultiDielectronTG.h

   1 #ifndef ALIANALYSISTASKMULTIDIELECTRONTG_H
   2 #define ALIANALYSISTASKMULTIDIELECTRONTG_H
   3 /* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 //#####################################################
   7 //#                                                   #
   8 //#        Basic Analysis task for Dielectron         #
   9 //#          single event analysis                    #
  10 //#                                                   #
  11 //#  by WooJin J. Park, GSI / W.J.Park@gsi.de         #
  12 //#     Ionut C. Arsene, GSI / I.C.Arsene@gsi.de      #
  13 //#     Magnus Mager, CERN / Magnus.Mager@cern.ch     #
  14 //#     Jens Wiechula, Uni HD / Jens.Wiechula@cern.ch #
  15 //#                                                   #
  16 //#####################################################
  17
  18 #include "TList.h"
  19
  20 #include "AliAnalysisTaskSE.h"
  21
  22 #include <vector>
  23 #include <deque>
  24 #include <cstdlib>
  25
  26
  27 // #include "AliDielectronPID.h"
  28
  29 class AliDielectron;
  30 class TH1D;
  31 class AliAnalysisCuts;
  32 class AliTriggerAnalysis;
  33 class AliESDtrackCuts;
  34
  35 class AliDielectronSingleTG : public TObject
  36 {
  37  public:
  38   AliDielectronSingleTG():
  39     fCharge(0),
  40     fCentrality(0),
  41     fXv(0),
  42     fYv(0),
  43     fZv(0),
  44     fPx(0),
  45     fPy(0),
  46     fPz(0),
  47     fPt(0),
  48     fEta(0),
  49     fPhi(0),
  50     fTheta(0),
  51     fConv(0),
  52     fGst(0),
  53     Obj(0x0)
  54       {;
  55       }
  56
  57     AliDielectronSingleTG(Int_t charge, Double_t cent,
  58                           Double_t xv, Double_t yv, Double_t zv,
  59                           Double_t px, Double_t py, Double_t pz, Double_t pt,
  60                           Double_t eta, Double_t phi, Double_t theta,
  61                           Int_t conv, Int_t ghost, AliVTrack *trk)
  62       :
  63       fCharge(charge),
  64       fCentrality(cent),
  65       fXv(xv),
  66       fYv(yv),
  67       fZv(zv),
  68       fPx(px),
  69       fPy(py),
  70       fPz(pz),
  71       fPt(pt),
  72       fEta(eta),
  73       fPhi(phi),
  74       fTheta(theta),
  75       fConv(conv),
  76       fGst(ghost), Obj(0x0)
  77         {
  78           SetTrack(trk);
  79           ;
  80         }
  81
  82       ~AliDielectronSingleTG() {;}
  83
  84
  85       void SetTrack(AliVTrack *trk) { Obj = trk;}
  86       Int_t Charge(void){ return fCharge;}
  87       Double_t  Phi(void){ return fPhi;}
  88       Double_t  Theta(void){ return fTheta;}
  89       Double_t  Px(void){ return fPx;}
  90       Double_t  Py(void){ return fPy;}
  91       Double_t  Pz(void){ return fPz;}
  92       Double_t  Xv(void){ return fPx;}
  93       Double_t  Yv(void){ return fPy;}
  94       Double_t  Zv(void){ return fPz;}
  95       Double_t  Pt(void){ return fPt;}
  96       AliVTrack *GetTrack(void){ return Obj;}
  97       void SetConvFlag(Int_t val){ fConv = val;}
  98       void SetGstFlag(Int_t val){ fGst = val;}
  99       Int_t GetConvFlag(void){ return fConv;}
 100       Int_t GetGstFlag(void){ return fGst;}
 101
 102  protected:
 103       Int_t fCharge;
 104       Double_t fCentrality;
 105       Double_t fXv;
 106       Double_t fYv;
 107       Double_t fZv;
 108       Double_t fPx;
 109       Double_t fPy;
 110       Double_t fPz;
 111       Double_t fPt;
 112       Double_t fEta;
 113       Double_t fPhi;
 114       Double_t fTheta;
 115       Int_t fConv;
 116       Int_t fGst;
 117       AliVTrack *Obj;
 118
 119       ClassDef(AliDielectronSingleTG, 2) // Event pool class
 120
 121 };
 122
 123
 124
 125 class AliAnalysisTaskMultiDielectronTG : public AliAnalysisTaskSE {
 126
 127 public:
 128   AliAnalysisTaskMultiDielectronTG();
 129   AliAnalysisTaskMultiDielectronTG(const char *name);
 130   virtual ~AliAnalysisTaskMultiDielectronTG();
 131
 132   enum ETriggerLogig {kAny, kExact};
 133
 134   virtual void UserExec(Option_t *option);
 135   virtual void UserCreateOutputObjects();
 136   virtual void FinishTaskOutput();
 137   //temporary
 138 //   virtual void NotifyRun(){AliDielectronPID::SetCorrVal((Double_t)fCurrentRunNumber);}
 139
 140   void UsePhysicsSelection(Bool_t phy=kTRUE) {fSelectPhysics=phy;}
 141   void SetTriggerMask(ULong64_t mask) {fTriggerMask=mask;}
 142   UInt_t GetTriggerMask() const { return fTriggerMask; }
 143   void SetExcludeTriggerMask(ULong64_t mask) {fExcludeTriggerMask=mask;}
 144   UInt_t GetExcludeTriggerMask() const { return fExcludeTriggerMask; }
 145   void SetTriggerLogic(ETriggerLogig log) {fTriggerLogic=log;}
 146   ETriggerLogig GetTriggerLogic() const {return fTriggerLogic;}
 147
 148   void SetEventFilter(AliAnalysisCuts * const filter) {fEventFilter=filter;}
 149   void SetTriggerOnV0AND(Bool_t v0and=kTRUE)    { fTriggerOnV0AND=v0and;    }
 150   void SetRejectPileup(Bool_t pileup=kTRUE)     { fRejectPileup=pileup;     }
 151   void AddDielectron(AliDielectron * const die) { fListDielectron.Add(die); }
 152
 153
 154   void reject_conversion(double val){d_conv_phiv = val;}
 155   void enable_v0mixing(Bool_t val){d_v0_mixing = val;}
 156   void check_ghost_pairs(vector<AliDielectronSingleTG*> e1);
 157   void fill_pair(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2, int type, AliDielectron *die);
 158   bool PairTrackcut(double var1);
 159   void calc_vars(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2,
 160                  double &mass, double &phiv, double &px, double &py, double&pz,
 161                  double &pt, double &e, double &phi, double &eta, double &cos, double &psi);
 162   void calc_pair(vector<AliDielectronSingleTG*> e1, vector<AliDielectronSingleTG*> e2, AliDielectron *die, Int_t idie);
 163   void randomize_pool(vector<AliDielectronSingleTG*> e1, vector<AliDielectronSingleTG*> e2);
 164   void reshuffle_buffer(vector<AliDielectronSingleTG*> ve, deque<AliDielectronSingleTG*> pool);
 165
 166 protected:
 167   enum {kAllEvents=0, kSelectedEvents, kV0andEvents, kFilteredEvents, kPileupEvents, kNbinsEvent};
 168   TList fListDielectron;             // List of dielectron framework instances
 169   TList fListHistos;                 //! List of histogram manager lists in the framework classes
 170   TList fListCF;                     //! List with CF Managers
 171   TList *tQAElectron;                     //! List with CF Managers
 172
 173
 174   Bool_t fSelectPhysics;             // Whether to use physics selection
 175   UInt_t fTriggerMask;               // Event trigger mask
 176   UInt_t fExcludeTriggerMask;        // Triggers to exclude from the analysis
 177   Bool_t fTriggerOnV0AND;            // if to trigger on V0and
 178   Bool_t fRejectPileup;              // pileup rejection wanted
 179
 180   ETriggerLogig fTriggerLogic;       // trigger logic: any or all bits need to be matching
 181
 182   AliTriggerAnalysis *fTriggerAnalysis; //! trigger analysis class
 183
 184   AliAnalysisCuts *fEventFilter;     // event filter
 185
 186   AliESDtrackCuts *fCutsMother;
 187
 188   TH1D *fEventStat;                  //! Histogram with event statistics
 189   TH1D *fEvent;
 190   TH2D *fdEdXvsPt;
 191   TH2D *fdEdXnSigmaElecvsPt;
 192   TH2D *fdEdXvsPtTOF;
 193   TH2D *fdEdXnSigmaElecvsPtTOF;
 194   TH2D *fTOFbetavsPt;
 195   TH2D *fTOFnSigmaElecvsPt;
 196   TH2F *hNCrossedRowsTPC;
 197   TH2F *hChi2ClusTPC;
 198   TH2F *hRatioCrossClusTPC;
 199
 200   Double_t fgValues[AliDielectronVarManager::kNMaxValues];
 201   std::vector<AliDielectronSingleTG*>  vem;
 202   std::vector<AliDielectronSingleTG*>  vep;
 203   std::vector<AliDielectronSingleTG*>  vem_tmp;
 204   std::vector<AliDielectronSingleTG*>  vep_tmp;
 205   Double_t d_conv_phiv;
 206   Double_t bz;
 207   Bool_t d_v0_mixing;
 208
 209
 210   //Buffer for event mixing
 211   static const int NBUF=100; //depth of buffer
 212   static const int NMix=40; //# of events mixed (for +-)
 213   //static const int NMix=2; //# of events mixed (for +-)
 214
 215
 216   static const int NRPBIN=12;
 217   static const int NZBIN=10;
 218   static const int NCENT=10;
 219   static const int NDIE=10;
 220   int d_ibuf[NDIE][NZBIN][NCENT][NRPBIN];
 221   std::vector<AliDielectronSingleTG*> d_vep[NBUF][NDIE][NZBIN][NCENT][NRPBIN];
 222   std::vector<AliDielectronSingleTG*> d_vem[NBUF][NDIE][NZBIN][NCENT][NRPBIN];
 223
 224   static const unsigned int MAXPOOL=500;
 225   //static const unsigned int MAXPOOL=50;
 226   static const int MAX_TRY=3;
 227   std::deque<AliDielectronSingleTG*> d_poolp[NDIE][NZBIN][NCENT][NRPBIN];
 228   std::deque<AliDielectronSingleTG*> d_poolm[NDIE][NZBIN][NCENT][NRPBIN];
 229
 230   AliAnalysisTaskMultiDielectronTG(const AliAnalysisTaskMultiDielectronTG &c);
 231   AliAnalysisTaskMultiDielectronTG& operator= (const AliAnalysisTaskMultiDielectronTG &c);
 232
 233   ClassDef(AliAnalysisTaskMultiDielectronTG, 2); //Analysis Task handling multiple instances of AliDielectron
 234 };
 235 #endif