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       printf("check run %.0f \n ",fRun(irun));
 242       if(fRun(irun)==run) return kFALSE;
 243     }
 244   }
 245
 246   if (fCentMin<fCentMax){
 247     AliCentrality *centrality=ev->GetCentrality();
 248     Double_t centralityF=-1;
 249     if (centrality) centralityF = centrality->GetCentralityPercentile("V0M");
 250     if (centralityF<fCentMin || centralityF>=fCentMax) return kFALSE;
 251   }
 252
 253   fkVertexAOD=0x0;
 254
 255   switch(fVtxType){
 256   case kVtxTracks:         fkVertexAOD=0x0;                       break;
 257   case kVtxTPC:            fkVertexAOD=AliDielectronVarManager::GetVertex(ev, AliAODVertex::kMainTPC);   break;
 258   case kVtxSPD:
 259   case kVtxTracksOrSPD:    fkVertexAOD=ev->GetPrimaryVertexSPD(); break;
 260   case kVtxAny:            fkVertexAOD=ev->GetPrimaryVertex();    break;
 261   }
 262
 263   if ((fRequireVtx||fVtxZmin<fVtxZmax||fMinVtxContributors>0)&&!fkVertexAOD) return kFALSE;
 264
 265   if (fMinVtxContributors>0){
 266     Int_t nCtrb = fkVertexAOD->GetNContributors();
 267     if (nCtrb<fMinVtxContributors){
 268       // if (fVtxType==kVtxTracksOrSPD){
 269       //   fkVertexAOD=ev->GetVertex(AliAODVertex::kPrimary);
 270       //   nCtrb = fkVertexAOD->GetNContributors();
 271       //   if (nCtrb<fMinVtxContributors) return kFALSE;
 272       //      } else {
 273       return kFALSE;
 274       //}
 275     }
 276   }
 277
 278
 279   if (fVtxZmin<fVtxZmax){
 280     Double_t zvtx=fkVertexAOD->GetZ();
 281     if (zvtx<fVtxZmin||zvtx>fVtxZmax) return kFALSE;
 282   }
 283
 284   if(fRequire13sel){
 285     if(!fUtils.IsVertexSelected2013pA(ev)) return kFALSE;
 286 //     if(fUtils.IsFirstEventInChunk(ev)) return kFALSE;
 287   }
 288
 289   /*
 290   if (fRequireV0and){
 291     //    if (!fTriggerAnalysis) fTriggerAnalysis=new AliTriggerAnalysis;
 292     Bool_t v0AND = kFALSE;
 293     if (fRequireV0and==1){
 294       Bool_t v0A       = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0A);
 295       Bool_t v0A       = header->GetOfflineTrigger(); //TODO
 296       Bool_t v0C       = fTriggerAnalysis->IsOfflineTriggerFired(ev, AliTriggerAnalysis::kV0C);
 297       v0AND = v0A && v0C;
 298     }
 299
 300     if (fRequireV0and==2){
 301       Bool_t v0AHW     = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kASide, kTRUE) == AliTriggerAnalysis::kV0BB);
 302       Bool_t v0CHW     = (fTriggerAnalysis->V0Trigger(ev, AliTriggerAnalysis::kCSide, kTRUE) == AliTriggerAnalysis::kV0BB);
 303       v0AND = v0AHW && v0CHW;
 304     }
 305
 306     if (!v0AND) return kFALSE;
 307   }
 308   */
 309   /*  if (fMultITSTPC){
 310     const AliESDVertex *vtxESDTPC=ev->GetPrimaryVertexTPC();
 311     const AliMultiplicity *multESD = ev->GetMultiplicity();
 312     if ( vtxESDTPC && multESD && vtxESDTPC->GetNContributors() < (-10.+0.25*multESD->GetNumberOfITSClusters(0)) )
 313       return kFALSE;
 314   }
 315   */
 316
 317   // correlation cut Ntrks vs. multV0
 318   if(fparMean && fparSigma) {
 319     Double_t nTrks  = ev->GetNumberOfTracks();
 320     Double_t multV0 = 0.0;
 321     for(Int_t j=0; j<64; j++) multV0 += ev->GetVZEROData()->GetMultiplicity(j);
 322     Double_t mV0 = fparMean->Eval(nTrks);
 323     Double_t sV0 = fparSigma->Eval(nTrks);
 324     if(multV0 > mV0+fcutSigma*sV0 || multV0 < mV0-fcutSigma*sV0) return kFALSE;
 325   }
 326
 327   // cut on the number of vertex contributors using TPC versus global vertex
 328   if(fparMinVtxContributors && fparMaxVtxContributors) {
 329     const AliAODVertex *vtxTPC = ev->GetVertex(AliAODVertex::kMainTPC);
 330     const AliAODVertex *vtxGbl = ev->GetPrimaryVertex();
 331     Double_t nContribTPC = (vtxTPC ? vtxTPC->GetNContributors() : 0);
 332     Double_t nContribGbl = (vtxGbl ? vtxGbl->GetNContributors() : 0);
 333     Double_t minCut = fparMinVtxContributors->Eval(nContribGbl);
 334     Double_t maxCut = fparMaxVtxContributors->Eval(nContribGbl);
 335     if(nContribTPC > maxCut || nContribTPC < minCut) return kFALSE;
 336   }
 337
 338   return kTRUE;
 339 }
 340
 341 //________________________________________________________________________
 342 void AliDielectronEventCuts::Print(const Option_t* /*option*/) const
 343 {
 344   //
 345   // Print cuts and the range
 346   //
 347   printf("cut ranges for '%s'\n",GetTitle());
 348   printf("All Cuts have to be fulfilled\n");
 349
 350   Int_t iCut=0;
 351   if(fRequireVtx) {
 352     printf("Cut %02d: vertex required \n",iCut);                                   iCut++; }
 353   printf("Cut %02d: vertex type: %s \n", iCut, fgkVtxNames[fVtxType]);             iCut++;
 354   if(fMinVtxContributors) {
 355     printf("Cut %02d: vertex contributors >= %d \n", iCut, fMinVtxContributors);   iCut++; }
 356   if(fVtxZmin<fVtxZmax) {
 357     printf("Cut %02d: %f < %s < %f\n",   iCut, fVtxZmin, "Zvtx", fVtxZmax);        iCut++; }
 358   if(fCentMin<fCentMax) {
 359     printf("Cut %02d: %f < %s < %f\n",   iCut, fCentMin, "V0centrality", fCentMax);iCut++; }
 360   if(fMultITSTPC) {
 361     printf("Cut %02d: cut on multiplcity ITS vs. TPC \n", iCut);                   iCut++; }
 362   if(fparMean&&fparSigma) {
 363     printf("Cut %02d: multplicity vs. #tracks correlation +-%.1f sigma inclusion \n", iCut, fcutSigma); iCut++; }
 364   if(fRequire13sel){
 365     printf("Cut %02d: vertex and event selection for 2013 pPb data taking required \n",iCut);   iCut++; }
 366   if(fRequireV0and) {
 367     printf("Cut %02d: require V0and type: %c \n", iCut, fRequireV0and);            iCut++; }
 368
 369 }
 370