PWGDQ/dielectron/AliDielectronEventCuts.cxx

   1 /*************************************************************************
   2 * Copyright(c) 1998-2009, 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 ///////////////////////////////////////////////////////////////////////////
  17 //                Dielectron EventCuts                                  //
  18 //                                                                       //
  19 //                                                                       //
  20 /*
  21 Detailed description
  22
  23
  24 */
  25 //                                                                       //
  26 ///////////////////////////////////////////////////////////////////////////
  27
  28
  29 #include <AliTriggerAnalysis.h>
  30 #include <AliESDVertex.h>
  31 #include <AliAODVertex.h>
  32 #include <AliESDEvent.h>
  33 #include <AliAODEvent.h>
  34 #include <AliMultiplicity.h>
  35 #include <AliCentrality.h>
  36 #include <AliESDVZERO.h>
  37 #include <AliAODVZERO.h>
  38
  39 #include "AliDielectronVarManager.h"
  40 #include "AliDielectronEventCuts.h"
  41
  42 ClassImp(AliDielectronEventCuts)
  43
  44 const char* AliDielectronEventCuts::fgkVtxNames[AliDielectronEventCuts::kVtxTracksOrSPD+1] = {"Tracks", "SPD", "TPC", "Any", "TracksOrSPD"};
  45
  46 AliDielectronEventCuts::AliDielectronEventCuts() :
  47   AliAnalysisCuts(),
  48   fRun(),
  49   fVtxZmin(0.),
  50   fVtxZmax(0.),
  51   fRequireVtx(kFALSE),
  52   fMinVtxContributors(0),
  53   fMultITSTPC(kFALSE),
  54   fCentMin(1.),
  55   fCentMax(0.),
  56   fVtxType(kVtxTracks),
  57   fRequire13sel(kFALSE),
  58   fUtils(),
  59   fRequireV0and(0),
  60   fTriggerAnalysis(0x0),
  61   fkVertex(0x0),
  62   fkVertexAOD(0x0),
  63   fparMean(0x0),
  64   fparSigma(0x0),
  65   fcutSigma(3.),
  66   fparMinVtxContributors(0x0),
  67   fparMaxVtxContributors(0x0)
  68 {
  69   //
  70   // Default Constructor
  71   //
  72
  73 }
  74
  75 //______________________________________________
  76 AliDielectronEventCuts::AliDielectronEventCuts(const char* name, const char* title) :
  77   AliAnalysisCuts(name, title),
  78   fRun(),
  79   fVtxZmin(0.),
  80   fVtxZmax(0.),
  81   fRequireVtx(kFALSE),
  82   fMinVtxContributors(0),
  83   fMultITSTPC(kFALSE),
  84   fCentMin(1.),
  85   fCentMax(0.),
  86   fVtxType(kVtxTracks),
  87   fRequire13sel(kFALSE),
  88   fUtils(),
  89   fRequireV0and(0),
  90   fTriggerAnalysis(0x0),
  91   fkVertex(0x0),
  92   fkVertexAOD(0x0),
  93   fparMean(0x0),
  94   fparSigma(0x0),
  95   fcutSigma(3.),
  96   fparMinVtxContributors(0x0),
  97   fparMaxVtxContributors(0x0)
  98 {
  99   //
 100   // Named Constructor
 101   //
 102 }
 103
 104 //______________________________________________
 105 AliDielectronEventCuts::~AliDielectronEventCuts()
 106 {
 107   //
 108   // Default Destructor
 109   //
 110   if (fTriggerAnalysis) delete fTriggerAnalysis;
 111 }
 112
 113 //______________________________________________
 114 Bool_t AliDielectronEventCuts::IsSelected(TObject* event)
 115 {
 116   //
 117   // check the cuts
 118   //
 119
 120   if(event->IsA() == AliESDEvent::Class()) return IsSelectedESD(event);
 121   else if(event->IsA() == AliAODEvent::Class()) return IsSelectedAOD(event);
 122   else return kFALSE;
 123 }
 124 //____________________________________________________________________
 125 Bool_t AliDielectronEventCuts::IsSelectedESD(TObject* event)
 126 {
 127   //
 128   // check the cuts
 129   //
 130
 131   AliESDEvent *ev=dynamic_cast<AliESDEvent*>(event);
 132   if (!ev) return kFALSE;
 133
 134   if (fCentMin<fCentMax){
 135     AliCentrality *centrality=ev->GetCentrality();
 136     Double_t centralityF=-1;
 137     if (centrality) centralityF = centrality->GetCentralityPercentile("V0M");
 138     if (centralityF<fCentMin || centralityF>=fCentMax) return kFALSE;
 139   }
 140
 141   fkVertex=0x0;
 142
 143   switch(fVtxType){
 144   case kVtxTracks:
 145   case kVtxTracksOrSPD:
 146     fkVertex=ev->GetPrimaryVertexTracks();
 147     break;
 148   case kVtxSPD:    fkVertex=ev->GetPrimaryVertexSPD(); break;
 149   case kVtxTPC:    fkVertex=ev->GetPrimaryVertexTPC(); break;
 150   case kVtxAny:    fkVertex=ev->GetPrimaryVertex(); break;
 151   }
 152
 153   if ((fRequireVtx||fVtxZmin<fVtxZmax||fMinVtxContributors>0)&&!fkVertex) return kFALSE;
 154
 155
 156   if (fMinVtxContributors>0){
 157     Int_t nCtrb = fkVertex->GetNContributors();
 158     if (nCtrb<fMinVtxContributors){
 159       if (fVtxType==kVtxTracksOrSPD){
 160         fkVertex=ev->GetPrimaryVertexSPD();
 161         nCtrb = fkVertex->GetNContributors();
 162         if (nCtrb<fMinVtxContributors) return kFALSE;
 163       } else {
 164         return kFALSE;
 165       }
 166     }
 167   }
 168
 169   if (fVtxZmin<fVtxZmax){
 170     Double_t zvtx=fkVertex->GetZv();
 171     if (zvtx<fVtxZmin||zvtx>fVtxZmax) return kFALSE;
 172   }
 173
 174   if(fRequire13sel){
 175     if(!fUtils.IsVertexSelected2013pA(ev)) return kFALSE;
 176     if(fUtils.IsFirstEventInChunk(ev)) return kFALSE;
 177   }
 178
 179   if (fRequireV0and){
 180     if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis;
 181     Bool_t v0AND = kFALSE;
 182     if (fRequireV0and==1){
 183       Bool_t v0A       = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0A);
 184       Bool_t v0C       = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0C);
 185       v0AND = v0A && v0C;
 186     }
 187
 188     if (fRequireV0and==2){
 189       Bool_t v0AHW     = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kASide, kTRUE) == AliTriggerAnalysis::kV0BB);
 190       Bool_t v0CHW     = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kCSide, kTRUE) == AliTriggerAnalysis::kV0BB);
 191       v0AND = v0AHW && v0CHW;
 192     }
 193
 194     if (!v0AND) return kFALSE;
 195   }
 196
 197   if (fMultITSTPC){
 198     const AliESDVertex *vtxESDTPC=ev->GetPrimaryVertexTPC();
 199     const AliMultiplicity *multESD = ev->GetMultiplicity();
 200     if ( vtxESDTPC && multESD && vtxESDTPC->GetNContributors() < (-10.+0.25*multESD->GetNumberOfITSClusters(0)) )
 201       return kFALSE;
 202   }
 203
 204   if(fparMean && fparSigma) {
 205     Double_t nTrks  = ev->GetNumberOfTracks();
 206     Double_t multV0 = 0.0;
 207     for(Int_t j=0; j<64; j++) multV0 += ev->GetVZEROData()->GetMultiplicity(j);
 208     Double_t mV0 = fparMean->Eval(nTrks);
 209     Double_t sV0 = fparSigma->Eval(nTrks);
 210     if(multV0 > mV0+fcutSigma*sV0 || multV0 < mV0-fcutSigma*sV0) return kFALSE;
 211   }
 212
 213   // cut on the number of vertex contributors using TPC versus global vertex
 214   if(fparMinVtxContributors && fparMaxVtxContributors) {
 215     const AliESDVertex *vtxTPC = ev->GetPrimaryVertexTPC();
 216     const AliESDVertex *vtxGbl = ev->GetPrimaryVertex();
 217     Double_t nContribTPC = (vtxTPC ? vtxTPC->GetNContributors() : 0);
 218     Double_t nContribGbl = (vtxGbl ? vtxGbl->GetNContributors() : 0);
 219     Double_t minCut = fparMinVtxContributors->Eval(nContribGbl);
 220     Double_t maxCut = fparMaxVtxContributors->Eval(nContribGbl);
 221     if(nContribTPC > maxCut || nContribTPC < minCut) return kFALSE;
 222   }
 223
 224
 225   return kTRUE;
 226 }
 227 //______________________________________________
 228 Bool_t AliDielectronEventCuts::IsSelectedAOD(TObject* event)
 229 {
 230   //
 231   // check the cuts
 232   //
 233
 234   AliAODEvent *ev=dynamic_cast<AliAODEvent*>(event);
 235   if (!ev) return kFALSE;
 236
 237   // run rejection
 238   Int_t run = ev->GetRunNumber();
 239   if(fRun.GetNrows()) {
 240     for(Int_t irun=0; irun<fRun.GetNrows(); irun++) {
 241       if(fRun(irun)==run) return kFALSE;
 242     }
 243   }
 244
 245   if (fCentMin<fCentMax){
 246     AliCentrality *centrality=ev->GetCentrality();
 247     Double_t centralityF=-1;
 248     if (centrality) centralityF = centrality->GetCentralityPercentile("V0M");
 249     if (centralityF<fCentMin || centralityF>=fCentMax) return kFALSE;
 250   }
 251
 252   fkVertexAOD=0x0;
 253
 254   switch(fVtxType){
 255   case kVtxTracks:         fkVertexAOD=0x0;                       break;
 256   case kVtxTPC:            fkVertexAOD=AliDielectronVarManager::GetVertex(ev, AliAODVertex::kMainTPC);   break;
 257   case kVtxSPD:
 258   case kVtxTracksOrSPD:    fkVertexAOD=ev->GetPrimaryVertexSPD(); break;
 259   case kVtxAny:            fkVertexAOD=ev->GetPrimaryVertex();    break;
 260   }
 261
 262   if ((fRequireVtx||fVtxZmin<fVtxZmax||fMinVtxContributors>0)&&!fkVertexAOD) return kFALSE;
 263
 264   if (fMinVtxContributors>0){
 265     Int_t nCtrb = fkVertexAOD->GetNContributors();
 266     if (nCtrb<fMinVtxContributors){
 267       // if (fVtxType==kVtxTracksOrSPD){
 268       //   fkVertexAOD=ev->GetVertex(AliAODVertex::kPrimary);
 269       //   nCtrb = fkVertexAOD->GetNContributors();
 270       //   if (nCtrb<fMinVtxContributors) return kFALSE;
 271       //      } else {
 272       return kFALSE;
 273       //}
 274     }
 275   }
 276
 277
 278   if (fVtxZmin<fVtxZmax){
 279     Double_t zvtx=fkVertexAOD->GetZ();
 280     if (zvtx<fVtxZmin||zvtx>fVtxZmax) return kFALSE;
 281   }
 282
 283   if(fRequire13sel){
 284     if(!fUtils.IsVertexSelected2013pA(ev)) return kFALSE;
 285 //     if(fUtils.IsFirstEventInChunk(ev)) return kFALSE;
 286   }
 287
 288   /*
 289   if (fRequireV0and){
 290     //    if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis;
 291     Bool_t v0AND = kFALSE;
 292     if (fRequireV0and==1){
 293       Bool_t v0A       = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0A);
 294       Bool_t v0A       = header->GetOfflineTrigger(); //TODO
 295       Bool_t v0C       = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0C);
 296       v0AND = v0A && v0C;
 297     }
 298
 299     if (fRequireV0and==2){
 300       Bool_t v0AHW     = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kASide, kTRUE) == AliTriggerAnalysis::kV0BB);
 301       Bool_t v0CHW     = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kCSide, kTRUE) == AliTriggerAnalysis::kV0BB);
 302       v0AND = v0AHW && v0CHW;
 303     }
 304
 305     if (!v0AND) return kFALSE;
 306   }
 307   */
 308   /*  if (fMultITSTPC){
 309     const AliESDVertex *vtxESDTPC=ev->GetPrimaryVertexTPC();
 310     const AliMultiplicity *multESD = ev->GetMultiplicity();
 311     if ( vtxESDTPC && multESD && vtxESDTPC->GetNContributors() < (-10.+0.25*multESD->GetNumberOfITSClusters(0)) )
 312       return kFALSE;
 313   }
 314   */
 315
 316   // correlation cut Ntrks vs. multV0
 317   if(fparMean && fparSigma) {
 318     Double_t nTrks  = ev->GetNumberOfTracks();
 319     Double_t multV0 = 0.0;
 320     for(Int_t j=0; j<64; j++) multV0 += ev->GetVZEROData()->GetMultiplicity(j);
 321     Double_t mV0 = fparMean->Eval(nTrks);
 322     Double_t sV0 = fparSigma->Eval(nTrks);
 323     if(multV0 > mV0+fcutSigma*sV0 || multV0 < mV0-fcutSigma*sV0) return kFALSE;
 324   }
 325
 326   // cut on the number of vertex contributors using TPC versus global vertex
 327   if(fparMinVtxContributors && fparMaxVtxContributors) {
 328     const AliAODVertex *vtxTPC = ev->GetVertex(AliAODVertex::kMainTPC);
 329     const AliAODVertex *vtxGbl = ev->GetPrimaryVertex();
 330     Double_t nContribTPC = (vtxTPC ? vtxTPC->GetNContributors() : 0);
 331     Double_t nContribGbl = (vtxGbl ? vtxGbl->GetNContributors() : 0);
 332     Double_t minCut = fparMinVtxContributors->Eval(nContribGbl);
 333     Double_t maxCut = fparMaxVtxContributors->Eval(nContribGbl);
 334     if(nContribTPC > maxCut || nContribTPC < minCut) return kFALSE;
 335   }
 336
 337   return kTRUE;
 338 }
 339
 340 //________________________________________________________________________
 341 void AliDielectronEventCuts::Print(const Option_t* /*option*/) const
 342 {
 343   //
 344   // Print cuts and the range
 345   //
 346   printf("cut ranges for '%s'\n",GetTitle());
 347   printf("All Cuts have to be fulfilled\n");
 348
 349   Int_t iCut=0;
 350   if(fRequireVtx) {
 351     printf("Cut %02d: vertex required \n",iCut);                                   iCut++; }
 352   printf("Cut %02d: vertex type: %s \n", iCut, fgkVtxNames[fVtxType]);             iCut++;
 353   if(fMinVtxContributors) {
 354     printf("Cut %02d: vertex contributors >= %d \n", iCut, fMinVtxContributors);   iCut++; }
 355   if(fVtxZmin<fVtxZmax) {
 356     printf("Cut %02d: %f < %s < %f\n",   iCut, fVtxZmin, "Zvtx", fVtxZmax);        iCut++; }
 357   if(fCentMin<fCentMax) {
 358     printf("Cut %02d: %f < %s < %f\n",   iCut, fCentMin, "V0centrality", fCentMax);iCut++; }
 359   if(fMultITSTPC) {
 360     printf("Cut %02d: cut on multiplcity ITS vs. TPC \n", iCut);                   iCut++; }
 361   if(fparMean&&fparSigma) {
 362     printf("Cut %02d: multplicity vs. #tracks correlation +-%.1f sigma inclusion \n", iCut, fcutSigma); iCut++; }
 363   if(fRequire13sel){
 364     printf("Cut %02d: vertex and event selection for 2013 pPb data taking required \n",iCut);   iCut++; }
 365   if(fRequireV0and) {
 366     printf("Cut %02d: require V0and type: %c \n", iCut, fRequireV0and);            iCut++; }
 367
 368 }
 369