PWG/FLOW/Tasks/AliFlowEventCuts.cxx

   1  /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   2  *                                                                        *
   3  * Author: The ALICE Off-line Project.                                    *
   4  * Contributors are mentioned in the code where appropriate.              *
   5  *                                                                        *
   6  * Permission to use, copy, modify and distribute this software and its   *
   7  * documentation strictly for non-commercial purposes is hereby granted   *
   8  * without fee, provided that the above copyright notice appears in all   *
   9  * copies and that both the copyright notice and this permission notice   *
  10  * appear in the supporting documentation. The authors make no claims     *
  11  * about the suitability of this software for any purpose. It is          *
  12  * provided "as is" without express or implied warranty.                  *
  13  **************************************************************************/
  14
  15 /* $Id$ */
  16
  17 // AliFlowEventCuts:
  18 // An event cut class for the flow framework
  19 //
  20 // origin: Mikolaj Krzewicki (mikolaj.krzewicki@cern.ch)
  21
  22 #include <limits.h>
  23 #include <float.h>
  24 #include <TList.h>
  25 #include <TH1F.h>
  26 #include <TH2F.h>
  27 #include <TBrowser.h>
  28 #include "TMath.h"
  29 #include "TNamed.h"
  30 #include "AliVVertex.h"
  31 #include "AliVEvent.h"
  32 #include "AliESDEvent.h"
  33 #include "AliAODEvent.h"
  34 #include "AliAODHeader.h"
  35 #include "AliCentrality.h"
  36 #include "AliESDVZERO.h"
  37 #include "AliMultiplicity.h"
  38 #include "AliMCEvent.h"
  39 #include "AliFlowEventCuts.h"
  40 #include "AliFlowTrackCuts.h"
  41 #include "AliTriggerAnalysis.h"
  42 #include "AliCollisionGeometry.h"
  43 #include "AliGenEventHeader.h"
  44 #include <iostream>
  45 using namespace std;
  46
  47 ClassImp(AliFlowEventCuts)
  48
  49 //-----------------------------------------------------------------------
  50 AliFlowEventCuts::AliFlowEventCuts():
  51   TNamed(),
  52   fQA(NULL),
  53   fCutNumberOfTracks(kFALSE),
  54   fNumberOfTracksMax(INT_MAX),
  55   fNumberOfTracksMin(INT_MIN),
  56   fCutRefMult(kFALSE),
  57   fRefMultMethod(kTPConly),
  58   fUseAliESDtrackCutsRefMult(kFALSE),
  59   fRefMultMethodAliESDtrackCuts(AliESDtrackCuts::kTrackletsITSTPC),
  60   fRefMultMax(INT_MAX),
  61   fRefMultMin(INT_MIN),
  62   fRefMultCuts(NULL),
  63   fMeanPtCuts(NULL),
  64   fStandardTPCcuts(NULL),
  65   fStandardGlobalCuts(NULL),
  66   fCutPrimaryVertexX(kFALSE),
  67   fPrimaryVertexXmax(INT_MAX),
  68   fPrimaryVertexXmin(INT_MIN),
  69   fCutPrimaryVertexY(kFALSE),
  70   fPrimaryVertexYmax(INT_MAX),
  71   fPrimaryVertexYmin(INT_MIN),
  72   fCutPrimaryVertexZ(kFALSE),
  73   fPrimaryVertexZmax(INT_MAX),
  74   fPrimaryVertexZmin(INT_MIN),
  75   fCutNContributors(kFALSE),
  76   fNContributorsMax(INT_MAX),
  77   fNContributorsMin(INT_MIN),
  78   fCutMeanPt(kFALSE),
  79   fMeanPtMax(-DBL_MAX),
  80   fMeanPtMin(DBL_MAX),
  81   fCutSPDvertexerAnomaly(kFALSE),
  82   fCutSPDTRKVtxZ(kFALSE),
  83   fCutTPCmultiplicityOutliers(kFALSE),
  84   fCutCentralityPercentile(kFALSE),
  85   fUseCentralityUnchecked(kFALSE),
  86   fCentralityPercentileMethod(kTPConly),
  87   fCentralityPercentileMax(100.),
  88   fCentralityPercentileMin(0.),
  89   fCutZDCtiming(kFALSE),
  90   fTrigAna(),
  91   fCutImpactParameter(kFALSE),
  92   fImpactParameterMin(0.0),
  93   fImpactParameterMax(100.0),
  94   fhistTPCvsGlobalMult(0),
  95   fData2011(kFALSE)
  96 {
  97   //constructor
  98 }
  99
 100 //-----------------------------------------------------------------------
 101 AliFlowEventCuts::AliFlowEventCuts(const char* name, const char* title):
 102   TNamed(name, title),
 103   fQA(NULL),
 104   fCutNumberOfTracks(kFALSE),
 105   fNumberOfTracksMax(INT_MAX),
 106   fNumberOfTracksMin(INT_MIN),
 107   fCutRefMult(kFALSE),
 108   fRefMultMethod(kTPConly),
 109   fUseAliESDtrackCutsRefMult(kFALSE),
 110   fRefMultMethodAliESDtrackCuts(AliESDtrackCuts::kTrackletsITSTPC),
 111   fRefMultMax(INT_MAX),
 112   fRefMultMin(INT_MIN),
 113   fRefMultCuts(NULL),
 114   fMeanPtCuts(NULL),
 115   fStandardTPCcuts(AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts2010()),
 116   fStandardGlobalCuts(AliFlowTrackCuts::GetStandardGlobalTrackCuts2010()),
 117   fCutPrimaryVertexX(kFALSE),
 118   fPrimaryVertexXmax(INT_MAX),
 119   fPrimaryVertexXmin(INT_MIN),
 120   fCutPrimaryVertexY(kFALSE),
 121   fPrimaryVertexYmax(INT_MAX),
 122   fPrimaryVertexYmin(INT_MIN),
 123   fCutPrimaryVertexZ(kFALSE),
 124   fPrimaryVertexZmax(INT_MAX),
 125   fPrimaryVertexZmin(INT_MIN),
 126   fCutNContributors(kFALSE),
 127   fNContributorsMax(INT_MAX),
 128   fNContributorsMin(INT_MIN),
 129   fCutMeanPt(kFALSE),
 130   fMeanPtMax(-DBL_MAX),
 131   fMeanPtMin(DBL_MAX),
 132   fCutSPDvertexerAnomaly(kFALSE),
 133   fCutSPDTRKVtxZ(kFALSE),
 134   fCutTPCmultiplicityOutliers(kFALSE),
 135   fCutCentralityPercentile(kFALSE),
 136   fUseCentralityUnchecked(kFALSE),
 137   fCentralityPercentileMethod(kTPConly),
 138   fCentralityPercentileMax(100.),
 139   fCentralityPercentileMin(0.),
 140   fCutZDCtiming(kFALSE),
 141   fTrigAna(),
 142   fCutImpactParameter(kFALSE),
 143   fImpactParameterMin(0.0),
 144   fImpactParameterMax(100.0),
 145   fhistTPCvsGlobalMult(0),
 146   fData2011(kFALSE)
 147 {
 148   //constructor
 149 }
 150
 151 ////-----------------------------------------------------------------------
 152 AliFlowEventCuts::AliFlowEventCuts(const AliFlowEventCuts& that):
 153   TNamed(that),
 154   fQA(NULL),
 155   fCutNumberOfTracks(that.fCutNumberOfTracks),
 156   fNumberOfTracksMax(that.fNumberOfTracksMax),
 157   fNumberOfTracksMin(that.fNumberOfTracksMin),
 158   fCutRefMult(that.fCutRefMult),
 159   fRefMultMethod(that.fRefMultMethod),
 160   fUseAliESDtrackCutsRefMult(that.fUseAliESDtrackCutsRefMult),
 161   fRefMultMethodAliESDtrackCuts(that.fRefMultMethodAliESDtrackCuts),
 162   fRefMultMax(that.fRefMultMax),
 163   fRefMultMin(that.fRefMultMin),
 164   fRefMultCuts(NULL),
 165   fMeanPtCuts(NULL),
 166   fStandardTPCcuts(NULL),
 167   fStandardGlobalCuts(NULL),
 168   fCutPrimaryVertexX(that.fCutPrimaryVertexX),
 169   fPrimaryVertexXmax(that.fPrimaryVertexXmax),
 170   fPrimaryVertexXmin(that.fPrimaryVertexXmin),
 171   fCutPrimaryVertexY(that.fCutPrimaryVertexX),
 172   fPrimaryVertexYmax(that.fPrimaryVertexYmax),
 173   fPrimaryVertexYmin(that.fPrimaryVertexYmin),
 174   fCutPrimaryVertexZ(that.fCutPrimaryVertexX),
 175   fPrimaryVertexZmax(that.fPrimaryVertexZmax),
 176   fPrimaryVertexZmin(that.fPrimaryVertexZmin),
 177   fCutNContributors(that.fCutNContributors),
 178   fNContributorsMax(that.fNContributorsMax),
 179   fNContributorsMin(that.fNContributorsMin),
 180   fCutMeanPt(that.fCutMeanPt),
 181   fMeanPtMax(that.fMeanPtMax),
 182   fMeanPtMin(that.fMeanPtMin),
 183   fCutSPDvertexerAnomaly(that.fCutSPDvertexerAnomaly),
 184   fCutSPDTRKVtxZ(that.fCutSPDTRKVtxZ),
 185   fCutTPCmultiplicityOutliers(that.fCutTPCmultiplicityOutliers),
 186   fCutCentralityPercentile(that.fCutCentralityPercentile),
 187   fUseCentralityUnchecked(that.fUseCentralityUnchecked),
 188   fCentralityPercentileMethod(that.fCentralityPercentileMethod),
 189   fCentralityPercentileMax(that.fCentralityPercentileMax),
 190   fCentralityPercentileMin(that.fCentralityPercentileMin),
 191   fCutZDCtiming(that.fCutZDCtiming),
 192   fTrigAna(),
 193   fhistTPCvsGlobalMult(that.fhistTPCvsGlobalMult),
 194   fData2011(that.fData2011),
 195   fCutImpactParameter(that.fCutImpactParameter),
 196   fImpactParameterMin(that.fImpactParameterMin),
 197   fImpactParameterMax(that.fImpactParameterMax)
 198 {
 199   if (that.fQA) DefineHistograms();
 200   //copy constructor
 201   if (that.fRefMultCuts)
 202     fRefMultCuts = new AliFlowTrackCuts(*(that.fRefMultCuts));
 203   if (that.fMeanPtCuts)
 204     fMeanPtCuts = new AliFlowTrackCuts(*(that.fMeanPtCuts));
 205   fStandardTPCcuts = AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts2010();
 206   fStandardGlobalCuts = AliFlowTrackCuts::GetStandardGlobalTrackCuts2010();
 207 }
 208
 209 ////-----------------------------------------------------------------------
 210 AliFlowEventCuts::~AliFlowEventCuts()
 211 {
 212   //dtor
 213   delete fMeanPtCuts;
 214   delete fRefMultCuts;
 215   delete fStandardGlobalCuts;
 216   delete fStandardTPCcuts;
 217   if (fQA) { fQA->SetOwner(); fQA->Delete(); delete fQA; }
 218 }
 219
 220 ////-----------------------------------------------------------------------
 221 AliFlowEventCuts& AliFlowEventCuts::operator=(const AliFlowEventCuts& that)
 222 {
 223   //assignment
 224   if (this==&that) return *this;
 225
 226   if (that.fQA)
 227   {
 228     if (fQA)
 229     {
 230       fQA->Delete();
 231       delete fQA;
 232     }
 233     fQA = static_cast<TList*>(that.fQA->Clone());
 234   }
 235   else
 236   {
 237     fQA->Delete();
 238     delete fQA;
 239     fQA=NULL;
 240   }
 241
 242   fCutNumberOfTracks=that.fCutNumberOfTracks;
 243   fNumberOfTracksMax=that.fNumberOfTracksMax;
 244   fNumberOfTracksMin=that.fNumberOfTracksMin;
 245   fCutRefMult=that.fCutRefMult;
 246   fRefMultMethod=that.fRefMultMethod;
 247   fUseAliESDtrackCutsRefMult=that.fUseAliESDtrackCutsRefMult;
 248   fRefMultMethodAliESDtrackCuts=that.fRefMultMethodAliESDtrackCuts;
 249   fRefMultMax=that.fRefMultMax;
 250   fRefMultMin=that.fRefMultMin;
 251   if (that.fRefMultCuts) *fRefMultCuts=*(that.fRefMultCuts);
 252   if (that.fMeanPtCuts) *fMeanPtCuts=*(that.fMeanPtCuts);
 253   fStandardTPCcuts = AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts2010();
 254   fStandardGlobalCuts = AliFlowTrackCuts::GetStandardGlobalTrackCuts2010();
 255   fCutPrimaryVertexX=that.fCutPrimaryVertexX;
 256   fPrimaryVertexXmax=that.fPrimaryVertexXmax;
 257   fPrimaryVertexXmin=that.fPrimaryVertexXmin;
 258   fCutPrimaryVertexY=that.fCutPrimaryVertexY;
 259   fPrimaryVertexYmax=that.fPrimaryVertexYmax;
 260   fPrimaryVertexYmin=that.fPrimaryVertexYmin;
 261   fCutPrimaryVertexZ=that.fCutPrimaryVertexZ;
 262   fPrimaryVertexZmax=that.fPrimaryVertexZmax;
 263   fPrimaryVertexZmin=that.fPrimaryVertexZmin;
 264   fCutNContributors=that.fCutNContributors;
 265   fNContributorsMax=that.fNContributorsMax;
 266   fNContributorsMin=that.fNContributorsMin;
 267   fCutMeanPt=that.fCutMeanPt;
 268   fMeanPtMax=that.fMeanPtMax;
 269   fMeanPtMin=that.fMeanPtMin;
 270   fCutSPDvertexerAnomaly=that.fCutSPDvertexerAnomaly;
 271   fCutSPDTRKVtxZ=that.fCutSPDTRKVtxZ;
 272   fCutTPCmultiplicityOutliers=that.fCutTPCmultiplicityOutliers;
 273   fCutCentralityPercentile=that.fCutCentralityPercentile;
 274   fUseCentralityUnchecked=that.fUseCentralityUnchecked;
 275   fCentralityPercentileMethod=that.fCentralityPercentileMethod;
 276   fCentralityPercentileMax=that.fCentralityPercentileMax;
 277   fCentralityPercentileMin=that.fCentralityPercentileMin;
 278   fCutZDCtiming=that.fCutZDCtiming;
 279   fhistTPCvsGlobalMult=that.fhistTPCvsGlobalMult;
 280   fData2011=that.fData2011;
 281   return *this;
 282 }
 283
 284 //-----------------------------------------------------------------------
 285 Bool_t AliFlowEventCuts::IsSelected(TObject* obj, TObject* objmc)
 286 {
 287   //check cuts
 288   AliVEvent* vevent = dynamic_cast<AliVEvent*>(obj);
 289   AliMCEvent* mcevent = dynamic_cast<AliMCEvent*>(objmc);
 290   if (vevent) return PassesCuts(vevent,mcevent);;
 291   return kFALSE;  //when passed wrong type of object
 292 }
 293 //-----------------------------------------------------------------------
 294 Bool_t AliFlowEventCuts::PassesCuts(AliVEvent *event, AliMCEvent *mcevent)
 295 {
 296   ///check if event passes cuts
 297   const AliVVertex* pvtx=event->GetPrimaryVertex();
 298   Double_t pvtxx = pvtx->GetX();
 299   Double_t pvtxy = pvtx->GetY();
 300   Double_t pvtxz = pvtx->GetZ();
 301   Int_t ncontrib = pvtx->GetNContributors();
 302   Bool_t pass=kTRUE;
 303   AliESDEvent* esdevent = dynamic_cast<AliESDEvent*>(event);
 304   AliAODEvent* aodevent = dynamic_cast<AliAODEvent*>(event);
 305   Int_t multTPC = 0;
 306   Int_t multGlobal = 0;
 307   multTPC = fStandardTPCcuts->Count(event);
 308   multGlobal = fStandardGlobalCuts->Count(event);
 309   if (fQA)
 310   {
 311     QAbefore(0)->Fill(pvtxz);
 312     QAbefore(1)->Fill(multGlobal,multTPC);
 313   }
 314   if (  (fCutTPCmultiplicityOutliers && esdevent) ||  (fCutTPCmultiplicityOutliers && aodevent)  )
 315   {
 316     //this is pretty slow as we check the event track by track twice
 317     //this cut will work for 2010 PbPb data and is dependent on
 318     //TPC and ITS reco efficiency (e.g. geometry, calibration etc)
 319     if(esdevent){
 320       if (multTPC > ( 23+1.216*multGlobal)) {pass=kFALSE;}
 321       if (multTPC < (-20+1.087*multGlobal)) {pass=kFALSE;}
 322     }
 323
 324     if(aodevent && fData2011){
 325         if (multTPC > ( 62.87+1.78*multGlobal)) {pass=kFALSE;}
 326         if (multTPC < (-36.73+1.48*multGlobal)) {pass=kFALSE;}
 327       }
 328     if(aodevent && ~fData2011){
 329         if (multTPC > ( 32.1+1.59*multGlobal)) {pass=kFALSE;}
 330         if (multTPC < (-40.3+1.22*multGlobal)) {pass=kFALSE;}
 331       }
 332   }
 333   if (fCutNContributors)
 334   {
 335     if (ncontrib < fNContributorsMin || ncontrib >= fNContributorsMax) pass=kFALSE;
 336   }
 337   if (fCutPrimaryVertexX)
 338   {
 339     if (pvtxx < fPrimaryVertexXmin || pvtxx >= fPrimaryVertexXmax) pass=kFALSE;
 340   }
 341   if (fCutPrimaryVertexY)
 342   {
 343     if (pvtxy < fPrimaryVertexYmin || pvtxy >= fPrimaryVertexYmax) pass=kFALSE;
 344   }
 345   if (fCutPrimaryVertexZ)
 346   {
 347     if (pvtxz < fPrimaryVertexZmin || pvtxz >= fPrimaryVertexZmax)
 348       pass=kFALSE;
 349   }
 350   if (fCutCentralityPercentile&&esdevent)
 351   {
 352     AliCentrality* centr = esdevent->GetCentrality();
 353     if (fUseCentralityUnchecked)
 354     {
 355       if (!centr->IsEventInCentralityClassUnchecked( fCentralityPercentileMin,
 356                                                      fCentralityPercentileMax,
 357                                                      CentrMethName(fCentralityPercentileMethod) ))
 358       {
 359         pass=kFALSE;
 360       }
 361     }
 362     else
 363     {
 364       if (!centr->IsEventInCentralityClass( fCentralityPercentileMin,
 365                                             fCentralityPercentileMax,
 366                                             CentrMethName(fCentralityPercentileMethod) ))
 367       {
 368         pass=kFALSE;
 369       }
 370     }
 371   }
 372   if (fCutSPDvertexerAnomaly&&esdevent)
 373   {
 374     const AliESDVertex* sdpvertex = esdevent->GetPrimaryVertexSPD();
 375     if (sdpvertex->GetNContributors()<1) pass=kFALSE;
 376     if (sdpvertex->GetDispersion()>0.04) pass=kFALSE;
 377     if (sdpvertex->GetZRes()>0.25) pass=kFALSE;
 378     const AliESDVertex* tpcvertex = esdevent->GetPrimaryVertexTPC();
 379     if (tpcvertex->GetNContributors()<1) pass=kFALSE;
 380     const AliMultiplicity* tracklets = esdevent->GetMultiplicity();
 381     if (tpcvertex->GetNContributors()<(-10.0+0.25*tracklets->GetNumberOfITSClusters(0)))
 382     {
 383       pass=kFALSE;
 384     }
 385   }
 386   if (fCutZDCtiming&&esdevent)
 387   {
 388     if (!fTrigAna.ZDCTimeTrigger(esdevent))
 389     {
 390       pass=kFALSE;
 391     }
 392   }
 393   if(fCutNumberOfTracks) {if ( event->GetNumberOfTracks() < fNumberOfTracksMin ||
 394                                event->GetNumberOfTracks() >= fNumberOfTracksMax ) pass=kFALSE;}
 395   if((fCutRefMult&&mcevent)||(fCutRefMult&&esdevent))
 396   {
 397     //reference multiplicity still to be defined
 398     Double_t refMult = RefMult(event,mcevent);
 399     if (refMult < fRefMultMin || refMult >= fRefMultMax )
 400     {
 401       pass=kFALSE;
 402     }
 403   }
 404
 405   // Handles AOD event
 406   if(aodevent) {
 407     if(fCutSPDTRKVtxZ) {
 408       Double_t tVtxZ = aodevent->GetPrimaryVertex()->GetZ();
 409       Double_t tSPDVtxZ = aodevent->GetPrimaryVertexSPD()->GetZ();
 410       if( TMath::Abs(tVtxZ-tSPDVtxZ) > 0.5 ) pass = kFALSE;
 411     }
 412     AliCentrality* centr = aodevent->GetHeader()->GetCentralityP();
 413     if(fCutTPCmultiplicityOutliers){
 414       Double_t v0Centr  = centr->GetCentralityPercentile("V0M");
 415       Double_t trkCentr = centr->GetCentralityPercentile("TRK");
 416       if(TMath::Abs(v0Centr-trkCentr) > 5) pass = kFALSE;
 417     }
 418     if (fCutCentralityPercentile) {
 419       if (fUseCentralityUnchecked) {
 420         if (!centr->IsEventInCentralityClassUnchecked( fCentralityPercentileMin,
 421                                                        fCentralityPercentileMax,
 422                                                        CentrMethName(fCentralityPercentileMethod) )) {
 423           pass = kFALSE;
 424         }
 425       } else {
 426         if (!centr->IsEventInCentralityClass( fCentralityPercentileMin,
 427                                               fCentralityPercentileMax,
 428                                               CentrMethName(fCentralityPercentileMethod) )) {
 429           pass = kFALSE;
 430         }
 431       }
 432     }
 433   }
 434
 435   if (fCutMeanPt)
 436   {
 437     Float_t meanpt=0.0;
 438     Int_t ntracks=event->GetNumberOfTracks();
 439     Int_t nselected=0;
 440     for (Int_t i=0; i<ntracks; i++)
 441     {
 442       AliVParticle* track = event->GetTrack(i);
 443       if (!track) continue;
 444       Bool_t localpass=kTRUE;
 445       if (fMeanPtCuts) localpass=fMeanPtCuts->IsSelected(track);
 446       if (localpass)
 447       {
 448         meanpt += track->Pt();
 449         nselected++;
 450       }
 451     }
 452     if (nselected) meanpt=meanpt/nselected;
 453     if (meanpt<fMeanPtMin || meanpt >= fMeanPtMax) pass=kFALSE;
 454   }
 455
 456   //impact parameter cut
 457   if(fCutImpactParameter) {
 458     Double_t gImpactParameter = 0.;
 459     if(mcevent) {
 460       AliCollisionGeometry* headerH = dynamic_cast<AliCollisionGeometry*>(dynamic_cast<AliMCEvent*>(mcevent)->GenEventHeader());
 461       if(headerH)
 462         gImpactParameter = headerH->ImpactParameter();
 463     }
 464     if ((gImpactParameter < fImpactParameterMin) || (gImpactParameter >= fImpactParameterMax ))
 465       pass=kFALSE;
 466   }
 467
 468   if (fQA&&pass)
 469   {
 470     QAafter(1)->Fill(multGlobal,multTPC);
 471     QAafter(0)->Fill(pvtxz);
 472   }
 473   return pass;
 474 }
 475
 476 //-----------------------------------------------------------------------
 477 const char* AliFlowEventCuts::CentrMethName(refMultMethod method) const
 478 {
 479   //get the string for refmultmethod, for use with AliCentrality in
 480   //the cut on centrality percentile
 481   switch (method)
 482   {
 483     case kSPDtracklets:
 484       return "TKL";
 485     case kSPD1clusters:
 486       return "CL1";
 487     case kTPConly:
 488       return "TRK";
 489     case kV0:
 490       return "V0M";
 491     default:
 492       return "";
 493   }
 494 }
 495 //-----------------------------------------------------------------------
 496 AliFlowEventCuts* AliFlowEventCuts::StandardCuts()
 497 {
 498   //make a set of standard event cuts, caller becomes owner
 499   AliFlowEventCuts* cuts = new AliFlowEventCuts();
 500   return cuts;
 501 }
 502
 503 //-----------------------------------------------------------------------
 504 Int_t AliFlowEventCuts::RefMult(AliVEvent* event, AliMCEvent *mcEvent)
 505 {
 506   //calculate the reference multiplicity, if all fails return 0
 507   AliESDVZERO* vzero = NULL;
 508   AliESDEvent* esdevent = dynamic_cast<AliESDEvent*>(event);
 509
 510   if (fUseAliESDtrackCutsRefMult && esdevent)
 511   {
 512     //use the standard ALICE reference multiplicity with the default eta range
 513     return AliESDtrackCuts::GetReferenceMultiplicity(esdevent, fRefMultMethodAliESDtrackCuts);
 514   }
 515
 516   if (fRefMultMethod==kTPConly && !fRefMultCuts)
 517   {
 518     fRefMultCuts = AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts();
 519     fRefMultCuts->SetEtaRange(-0.8,0.8);
 520     fRefMultCuts->SetPtMin(0.15);
 521   }
 522   else if (fRefMultMethod==kSPDtracklets && !fRefMultCuts)
 523   {
 524     fRefMultCuts = new AliFlowTrackCuts("tracklet refmult cuts");
 525     fRefMultCuts->SetParamType(AliFlowTrackCuts::kSPDtracklet);
 526     fRefMultCuts->SetEtaRange(-0.8,0.8);
 527   }
 528   else if (fRefMultMethod==kV0)
 529   {
 530     if (!esdevent) return 0;
 531     vzero=esdevent->GetVZEROData();
 532     if (!vzero) return 0;
 533     return TMath::Nint(vzero->GetMTotV0A()+vzero->GetMTotV0C());
 534   }
 535   else if (fRefMultMethod==kSPD1clusters)
 536   {
 537     if (!esdevent) return 0;
 538     const AliMultiplicity* mult = esdevent->GetMultiplicity();
 539     if (!mult) return 0;
 540     return mult->GetNumberOfITSClusters(1);
 541   }
 542
 543   Int_t refmult=0;
 544   fRefMultCuts->SetEvent(event,mcEvent);
 545   Int_t numberOfInputObjects = fRefMultCuts->GetNumberOfInputObjects();
 546   for (Int_t i=0; i<numberOfInputObjects; i++) {
 547     if (fRefMultCuts->IsSelected(fRefMultCuts->GetInputObject(i),i))
 548       refmult++;
 549   }
 550   return refmult;
 551 }
 552 //_____________________________________________________________________________
 553 void AliFlowEventCuts::DefineHistograms()
 554 {
 555   //define QA histos
 556   if (fQA) return;
 557
 558   Bool_t adddirstatus = TH1::AddDirectoryStatus();
 559   TH1::AddDirectory(kFALSE);
 560   fQA = new TList(); fQA->SetOwner();
 561   fQA->SetName(Form("%s QA",GetName()));
 562   TList* before = new TList(); before->SetOwner();
 563   before->SetName("before");
 564   TList* after = new TList(); after->SetOwner();
 565   after->SetName("after");
 566   fQA->Add(before);
 567   fQA->Add(after);
 568   before->Add(new TH1F("zvertex",";z;event cout",500,-15.,15.)); //0
 569   after->Add(new TH1F("zvertex",";z;event cout",500,-15.,15.)); //0
 570   before->Add(new TH2F("fTPCvsGlobalMult","TPC only vs Global track multiplicity;global;TPC only",500,0,2500,500,0,3500));//1
 571   after->Add(new TH2F("fTPCvsGlobalMult","TPC only vs Global track multiplicity;global;TPC only",500,0,2500,500,0,3500));//1
 572   TH1::AddDirectory(adddirstatus);
 573 }
 574
 575 //---------------------------------------------------------------//
 576 void AliFlowEventCuts::Browse(TBrowser* b)
 577 {
 578   //some browsing capabilities
 579   if (fQA) b->Add(fQA);
 580 }
 581
 582 //---------------------------------------------------------------//
 583 Long64_t AliFlowEventCuts::Merge(TCollection* list)
 584 {
 585   //merge
 586   Int_t number=0;
 587   AliFlowEventCuts* obj;
 588   if (!list) return 0;
 589   if (list->GetEntries()<1) return 0;
 590   TIter next(list);
 591   while ( (obj = dynamic_cast<AliFlowEventCuts*>(next())) )
 592   {
 593     if (obj==this) continue;
 594     TList listwrapper;
 595     listwrapper.Add(obj->GetQA());
 596     fQA->Merge(&listwrapper);
 597     number++;
 598   }
 599   return number;
 600 }
 601
 602