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