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