PWGGA/GammaConv/AliConvEventCuts.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Authors: Svein Lindal, Daniel Lohner                                   *
   5  * Version 1.0                                                            *
   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 //---------------------------------------------
  18 // Class handling all kinds of selection cuts for
  19 // Gamma Conversion analysis
  20 //---------------------------------------------
  21 ////////////////////////////////////////////////
  22
  23 #include "AliConvEventCuts.h"
  24
  25 #include "AliAODTrack.h"
  26 #include "AliESDtrack.h"
  27 #include "AliAnalysisManager.h"
  28 #include "AliInputEventHandler.h"
  29 #include "AliMCEventHandler.h"
  30 #include "AliAODHandler.h"
  31 #include "TH1.h"
  32 #include "TH2.h"
  33 #include "TF1.h"
  34 #include "AliStack.h"
  35 #include "TObjString.h"
  36 #include "AliAODEvent.h"
  37 #include "AliESDEvent.h"
  38 #include "AliCentrality.h"
  39 #include "TList.h"
  40 #include "TFile.h"
  41 #include "AliLog.h"
  42 #include "AliGenCocktailEventHeader.h"
  43 #include "AliGenDPMjetEventHeader.h"
  44 #include "AliGenPythiaEventHeader.h"
  45 #include "AliGenHijingEventHeader.h"
  46 #include "AliTriggerAnalysis.h"
  47 #include "AliV0ReaderV1.h"
  48 #include "AliVCaloCells.h"
  49 #include "AliAODMCParticle.h"
  50 #include "AliAODMCHeader.h"
  51
  52 class iostream;
  53
  54 using namespace std;
  55
  56 ClassImp(AliConvEventCuts)
  57
  58
  59 const char* AliConvEventCuts::fgkCutNames[AliConvEventCuts::kNCuts] = {
  60    "HeavyIon",                                          //0
  61    "CentralityMin",                                     //1
  62    "CentralityMax",                                     //2
  63    "SelectSpecialTrigger",                      //3
  64    "SelectSpecialSubTriggerClass",      //4
  65    "RemovePileUp",                                      //5
  66    "RejectExtraSignals",                        //6
  67 };
  68
  69
  70 //________________________________________________________________________
  71 AliConvEventCuts::AliConvEventCuts(const char *name,const char *title) :
  72         AliAnalysisCuts(name,title),
  73         fHistograms(NULL),
  74         fHeaderList(NULL),
  75         fEventQuality(-1),
  76         fIsHeavyIon(0),
  77         fDetectorCentrality(0),
  78         fModCentralityClass(0),
  79         fMaxVertexZ(10),
  80         fCentralityMin(0),
  81         fCentralityMax(0),
  82         fMultiplicityMethod(0),
  83         fSpecialTrigger(0),
  84         fSpecialSubTrigger(0),
  85         fRemovePileUp(kFALSE),
  86         fRejectExtraSignals(0),
  87         fOfflineTriggerMask(0),
  88         fHasV0AND(kTRUE),
  89         fIsSDDFired(kTRUE),
  90         fRandom(0),
  91         fnHeaders(0),
  92         fNotRejectedStart(NULL),
  93         fNotRejectedEnd(NULL),
  94         fGeneratorNames(NULL),
  95         fCutString(NULL),
  96         fUtils(NULL),
  97         fEtaShift(0.0),
  98         fDoEtaShift(kFALSE),
  99         fDoReweightHistoMCPi0(kFALSE),
 100         fDoReweightHistoMCEta(kFALSE),
 101         fDoReweightHistoMCK0s(kFALSE),
 102         fPathTrFReweighting(""),
 103         fNameHistoReweightingPi0(""),
 104         fNameHistoReweightingEta(""),
 105         fNameHistoReweightingK0s(""),
 106         fNameFitDataPi0(""),
 107         fNameFitDataEta(""),
 108         fNameFitDataK0s(""),
 109         fHistoEventCuts(NULL),
 110         hCentrality(NULL),
 111         hCentralityVsNumberOfPrimaryTracks(NULL),
 112         hVertexZ(NULL),
 113         hTriggerClass(NULL),
 114         hTriggerClassSelected(NULL),
 115         hReweightMCHistPi0(NULL),
 116         hReweightMCHistEta(NULL),
 117         hReweightMCHistK0s(NULL),
 118         fFitDataPi0(NULL),
 119         fFitDataEta(NULL),
 120         fFitDataK0s(NULL),
 121         fAddedSignalPDGCode(0),
 122         fPreSelCut(kFALSE),
 123         fTriggerSelectedManually(kFALSE),
 124         fSpecialTriggerName(""),
 125         fSpecialSubTriggerName(""),
 126         fNSpecialSubTriggerOptions(0),
 127         fV0ReaderName(""),
 128         fCaloTriggers(NULL),
 129         fTriggerPatchInfo(NULL),
 130         fMainTriggerPatchEMCAL(NULL),
 131         fCaloTriggersName(""),
 132         fCaloTriggerPatchInfoName(""),
 133         fTriggersEMCAL(0),
 134         fTriggersEMCALSelected(-1),
 135         fEMCALTrigInitialized(kFALSE),
 136         fSecProdBoundary(1.0)
 137 {
 138    for(Int_t jj=0;jj<kNCuts;jj++){fCuts[jj]=0;}
 139    fCutString=new TObjString((GetCutNumber()).Data());
 140
 141    fUtils = new AliAnalysisUtils();
 142    //if you do not want to apply the cut on the distance between the SPD and TRK vertex:
 143    //fUtils->SetCutOnZVertexSPD(kFALSE);
 144
 145
 146 }
 147
 148 //________________________________________________________________________
 149 AliConvEventCuts::AliConvEventCuts(const AliConvEventCuts &ref) :
 150         AliAnalysisCuts(ref),
 151         fHistograms(NULL),
 152         fHeaderList(ref.fHeaderList),
 153         fEventQuality(ref.fEventQuality),
 154         fIsHeavyIon(ref.fIsHeavyIon),
 155         fDetectorCentrality(ref.fDetectorCentrality),
 156         fModCentralityClass(ref.fModCentralityClass),
 157         fMaxVertexZ(ref.fMaxVertexZ),
 158         fCentralityMin(ref.fCentralityMin),
 159         fCentralityMax(ref.fCentralityMax),
 160         fMultiplicityMethod(ref.fMultiplicityMethod),
 161         fSpecialTrigger(ref.fSpecialTrigger),
 162         fSpecialSubTrigger(ref.fSpecialSubTrigger),
 163         fRemovePileUp(ref.fRemovePileUp),
 164         fRejectExtraSignals(ref.fRejectExtraSignals),
 165         fOfflineTriggerMask(ref.fOfflineTriggerMask),
 166         fHasV0AND(ref.fHasV0AND),
 167         fIsSDDFired(ref.fIsSDDFired),
 168         fRandom(ref.fRandom),
 169         fnHeaders(ref.fnHeaders),
 170         fNotRejectedStart(NULL),
 171         fNotRejectedEnd(NULL),
 172         fGeneratorNames(ref.fGeneratorNames),
 173         fCutString(NULL),
 174         fUtils(NULL),
 175         fEtaShift(ref.fEtaShift),
 176         fDoEtaShift(ref.fDoEtaShift),
 177         fDoReweightHistoMCPi0(ref.fDoReweightHistoMCPi0),
 178         fDoReweightHistoMCEta(ref.fDoReweightHistoMCEta),
 179         fDoReweightHistoMCK0s(ref.fDoReweightHistoMCK0s),
 180         fPathTrFReweighting(ref.fPathTrFReweighting),
 181         fNameHistoReweightingPi0(ref.fNameHistoReweightingPi0),
 182         fNameHistoReweightingEta(ref.fNameHistoReweightingEta),
 183         fNameHistoReweightingK0s(ref.fNameHistoReweightingK0s),
 184         fNameFitDataPi0(ref.fNameFitDataPi0),
 185         fNameFitDataEta(ref.fNameFitDataEta),
 186         fNameFitDataK0s(ref.fNameFitDataK0s),
 187         fHistoEventCuts(NULL),
 188         hCentrality(NULL),
 189         hCentralityVsNumberOfPrimaryTracks(NULL),
 190         hVertexZ(NULL),
 191         hTriggerClass(NULL),
 192         hTriggerClassSelected(NULL),
 193         hReweightMCHistPi0(ref.hReweightMCHistPi0),
 194         hReweightMCHistEta(ref.hReweightMCHistEta),
 195         hReweightMCHistK0s(ref.hReweightMCHistK0s),
 196         fFitDataPi0(ref.fFitDataPi0),
 197         fFitDataEta(ref.fFitDataEta),
 198         fFitDataK0s(ref.fFitDataK0s),
 199         fAddedSignalPDGCode(ref.fAddedSignalPDGCode),
 200         fPreSelCut(ref.fPreSelCut),
 201         fTriggerSelectedManually(ref.fTriggerSelectedManually),
 202         fSpecialTriggerName(ref.fSpecialTriggerName),
 203         fSpecialSubTriggerName(ref.fSpecialSubTriggerName),
 204         fNSpecialSubTriggerOptions(ref.fNSpecialSubTriggerOptions),
 205         fV0ReaderName(ref.fV0ReaderName),
 206         fCaloTriggers(NULL),
 207         fTriggerPatchInfo(NULL),
 208         fMainTriggerPatchEMCAL(NULL),
 209         fCaloTriggersName(ref.fCaloTriggersName),
 210         fCaloTriggerPatchInfoName(ref.fCaloTriggerPatchInfoName),
 211         fTriggersEMCAL(ref.fTriggersEMCAL),
 212         fTriggersEMCALSelected(ref.fTriggersEMCALSelected),
 213         fEMCALTrigInitialized(kFALSE),
 214         fSecProdBoundary(ref.fSecProdBoundary)
 215 {
 216    // Copy Constructor
 217    for(Int_t jj=0;jj<kNCuts;jj++){fCuts[jj]=ref.fCuts[jj];}
 218    fCutString=new TObjString((GetCutNumber()).Data());
 219    fUtils = new AliAnalysisUtils();
 220    // dont copy histograms (if you like histograms, call InitCutHistograms())
 221
 222 }
 223
 224
 225 //________________________________________________________________________
 226 AliConvEventCuts::~AliConvEventCuts() {
 227    // Destructor
 228    //Deleting fHistograms leads to seg fault it it's added to output collection of a task
 229    // if(fHistograms)
 230    //    delete fHistograms;
 231    // fHistograms = NULL;
 232    if(fCutString != NULL){
 233       delete fCutString;
 234       fCutString = NULL;
 235    }
 236    if(fNotRejectedStart){
 237       delete[] fNotRejectedStart;
 238       fNotRejectedStart = NULL;
 239    }
 240    if(fNotRejectedEnd){
 241       delete[] fNotRejectedEnd;
 242       fNotRejectedEnd = NULL;
 243    }
 244    if(fGeneratorNames){
 245       delete[] fGeneratorNames;
 246       fGeneratorNames = NULL;
 247    }
 248    if(fUtils){
 249      delete fUtils;
 250      fUtils = NULL;
 251    }
 252
 253 }
 254
 255 //________________________________________________________________________
 256 void AliConvEventCuts::InitCutHistograms(TString name, Bool_t preCut){
 257
 258    // Initialize Cut Histograms for QA (only initialized and filled if function is called)
 259    TH1::AddDirectory(kFALSE);
 260
 261    if(fHistograms != NULL){
 262       delete fHistograms;
 263       fHistograms=NULL;
 264    }
 265    if(fHistograms==NULL){
 266       fHistograms=new TList();
 267       fHistograms->SetOwner(kTRUE);
 268       if(name=="")fHistograms->SetName(Form("ConvEventCuts_%s",GetCutNumber().Data()));
 269       else fHistograms->SetName(Form("%s_%s",name.Data(),GetCutNumber().Data()));
 270    }
 271
 272    if (hReweightMCHistPi0){
 273       hReweightMCHistPi0->SetName("MCInputForWeightingPi0");
 274       fHistograms->Add(hReweightMCHistPi0);
 275    }
 276    if (hReweightMCHistEta){
 277       hReweightMCHistEta->SetName("MCInputForWeightingEta");
 278       fHistograms->Add(hReweightMCHistEta);
 279    }
 280    if (hReweightMCHistK0s){
 281       hReweightMCHistK0s->SetName("MCInputForWeightingK0s");
 282       fHistograms->Add(hReweightMCHistK0s);
 283    }
 284
 285    hCentrality=new TH1F(Form("Centrality %s",GetCutNumber().Data()),"Centrality",100,0,100);
 286    fHistograms->Add(hCentrality);
 287    hCentralityVsNumberOfPrimaryTracks=new TH2F(Form("Centrality vs Primary Tracks %s",GetCutNumber().Data()),"Centrality vs Primary Tracks ",100,0,100,4000,0,4000);
 288    fHistograms->Add(hCentralityVsNumberOfPrimaryTracks);
 289
 290    // Event Cuts and Info
 291    if(preCut){
 292       fHistoEventCuts=new TH1F(Form("ESD_EventCuts %s",GetCutNumber().Data()),"Event Cuts",7,-0.5,6.5);
 293       fHistoEventCuts->GetXaxis()->SetBinLabel(1,"in");
 294       fHistoEventCuts->GetXaxis()->SetBinLabel(2,"OfflineTrigger");
 295       fHistoEventCuts->GetXaxis()->SetBinLabel(3,"nvtxcontr");
 296       fHistoEventCuts->GetXaxis()->SetBinLabel(4,"VertexZ");
 297       fHistoEventCuts->GetXaxis()->SetBinLabel(5,"pileup");
 298       fHistoEventCuts->GetXaxis()->SetBinLabel(6,"centrsel");
 299       fHistoEventCuts->GetXaxis()->SetBinLabel(7,"out");
 300       fHistograms->Add(fHistoEventCuts);
 301
 302       hVertexZ=new TH1F(Form("VertexZ %s",GetCutNumber().Data()),"VertexZ",1000,-50,50);
 303       fHistograms->Add(hVertexZ);
 304
 305       hTriggerClass= new TH1F(Form("OfflineTrigger %s",GetCutNumber().Data()),"OfflineTrigger",35,-0.5,34.5);
 306       hTriggerClass->GetXaxis()->SetBinLabel( 1,"kMB");
 307       hTriggerClass->GetXaxis()->SetBinLabel( 2,"kINT7");
 308       hTriggerClass->GetXaxis()->SetBinLabel( 3,"kMUON");
 309       hTriggerClass->GetXaxis()->SetBinLabel( 4,"kHighMult");
 310       hTriggerClass->GetXaxis()->SetBinLabel( 5,"kKEMC1");
 311       hTriggerClass->GetXaxis()->SetBinLabel( 6,"kCINT5");
 312       hTriggerClass->GetXaxis()->SetBinLabel( 7,"kCMUS5/kMUSPB");
 313       hTriggerClass->GetXaxis()->SetBinLabel( 8,"kMUSH7/kMUSHPB");
 314       hTriggerClass->GetXaxis()->SetBinLabel( 9,"kMUL7/kMuonLikePB");
 315       hTriggerClass->GetXaxis()->SetBinLabel(10,"kMUU7/kMuonUnlikePB");
 316       hTriggerClass->GetXaxis()->SetBinLabel(11,"kEMC7/kEMC8");
 317       hTriggerClass->GetXaxis()->SetBinLabel(12,"kMUS7");
 318       hTriggerClass->GetXaxis()->SetBinLabel(13,"kPHI1");
 319       hTriggerClass->GetXaxis()->SetBinLabel(14,"kPHI7/kPHI8/kPHOSPb");
 320       hTriggerClass->GetXaxis()->SetBinLabel(15,"kEMCEJE");
 321       hTriggerClass->GetXaxis()->SetBinLabel(16,"kEMCEGA");
 322       hTriggerClass->GetXaxis()->SetBinLabel(17,"kCentral");
 323       hTriggerClass->GetXaxis()->SetBinLabel(18,"kSemiCentral");
 324       hTriggerClass->GetXaxis()->SetBinLabel(19,"kDG5");
 325       hTriggerClass->GetXaxis()->SetBinLabel(20,"kZED");
 326       hTriggerClass->GetXaxis()->SetBinLabel(21,"kSPI7/kSPI");
 327       hTriggerClass->GetXaxis()->SetBinLabel(22,"kINT8");
 328       hTriggerClass->GetXaxis()->SetBinLabel(23,"kMuonSingleLowPt8");
 329       hTriggerClass->GetXaxis()->SetBinLabel(24,"kMuonSingleHighPt8");
 330       hTriggerClass->GetXaxis()->SetBinLabel(25,"kMuonLikeLowPt8");
 331       hTriggerClass->GetXaxis()->SetBinLabel(26,"kMuonUnlikeLowPt8");
 332       hTriggerClass->GetXaxis()->SetBinLabel(27,"kMuonUnlikeLowPt0");
 333       hTriggerClass->GetXaxis()->SetBinLabel(28,"kUserDefined");
 334       hTriggerClass->GetXaxis()->SetBinLabel(29,"kTRD");
 335       hTriggerClass->GetXaxis()->SetBinLabel(30,"kFastOnly");
 336       hTriggerClass->GetXaxis()->SetBinLabel(31,"kAnyINT");
 337       hTriggerClass->GetXaxis()->SetBinLabel(32,"kAny");
 338       hTriggerClass->GetXaxis()->SetBinLabel(33,"V0AND");
 339       hTriggerClass->GetXaxis()->SetBinLabel(34,"NOT kFastOnly");
 340       hTriggerClass->GetXaxis()->SetBinLabel(35,"failed Physics Selection");
 341       fHistograms->Add(hTriggerClass);
 342    }
 343    if(!preCut){
 344       hTriggerClassSelected= new TH1F(Form("OfflineTriggerSelected %s",GetCutNumber().Data()),"OfflineTriggerSelected",34,-0.5,33.5);
 345       hTriggerClassSelected->GetXaxis()->SetBinLabel( 1,"kMB");
 346       hTriggerClassSelected->GetXaxis()->SetBinLabel( 2,"kINT7");
 347       hTriggerClassSelected->GetXaxis()->SetBinLabel( 3,"kMUON");
 348       hTriggerClassSelected->GetXaxis()->SetBinLabel( 4,"kHighMult");
 349       hTriggerClassSelected->GetXaxis()->SetBinLabel( 5,"kKEMC1");
 350       hTriggerClassSelected->GetXaxis()->SetBinLabel( 6,"kCINT5");
 351       hTriggerClassSelected->GetXaxis()->SetBinLabel( 7,"kCMUS5/kMUSPB");
 352       hTriggerClassSelected->GetXaxis()->SetBinLabel( 8,"kMUSH7/kMUSHPB");
 353       hTriggerClassSelected->GetXaxis()->SetBinLabel( 9,"kMUL7/kMuonLikePB");
 354       hTriggerClassSelected->GetXaxis()->SetBinLabel(10,"kMUU7/kMuonUnlikePB");
 355       hTriggerClassSelected->GetXaxis()->SetBinLabel(11,"kEMC7/kEMC8");
 356       hTriggerClassSelected->GetXaxis()->SetBinLabel(12,"kMUS7");
 357       hTriggerClassSelected->GetXaxis()->SetBinLabel(13,"kPHI1");
 358       hTriggerClassSelected->GetXaxis()->SetBinLabel(14,"kPHI7/kPHI8/kPHOSPb");
 359       hTriggerClassSelected->GetXaxis()->SetBinLabel(15,"kEMCEJE");
 360       hTriggerClassSelected->GetXaxis()->SetBinLabel(16,"kEMCEGA");
 361       hTriggerClassSelected->GetXaxis()->SetBinLabel(17,"kCentral");
 362       hTriggerClassSelected->GetXaxis()->SetBinLabel(18,"kSemiCentral");
 363       hTriggerClassSelected->GetXaxis()->SetBinLabel(19,"kDG5");
 364       hTriggerClassSelected->GetXaxis()->SetBinLabel(20,"kZED");
 365       hTriggerClassSelected->GetXaxis()->SetBinLabel(21,"kSPI7/kSPI");
 366       hTriggerClassSelected->GetXaxis()->SetBinLabel(22,"kINT8");
 367       hTriggerClassSelected->GetXaxis()->SetBinLabel(23,"kMuonSingleLowPt8");
 368       hTriggerClassSelected->GetXaxis()->SetBinLabel(24,"kMuonSingleHighPt8");
 369       hTriggerClassSelected->GetXaxis()->SetBinLabel(25,"kMuonLikeLowPt8");
 370       hTriggerClassSelected->GetXaxis()->SetBinLabel(26,"kMuonUnlikeLowPt8");
 371       hTriggerClassSelected->GetXaxis()->SetBinLabel(27,"kMuonUnlikeLowPt0");
 372       hTriggerClassSelected->GetXaxis()->SetBinLabel(28,"kUserDefined");
 373       hTriggerClassSelected->GetXaxis()->SetBinLabel(29,"kTRD");
 374       hTriggerClassSelected->GetXaxis()->SetBinLabel(30,"kFastOnly");
 375       hTriggerClassSelected->GetXaxis()->SetBinLabel(31,"kAnyINT");
 376       hTriggerClassSelected->GetXaxis()->SetBinLabel(32,"kAny");
 377       hTriggerClassSelected->GetXaxis()->SetBinLabel(33,"V0AND");
 378       hTriggerClassSelected->GetXaxis()->SetBinLabel(34,"NOT kFastOnly");
 379       fHistograms->Add(hTriggerClassSelected);
 380
 381    }
 382    TH1::AddDirectory(kTRUE);
 383 }
 384
 385 ///________________________________________________________________________
 386 Bool_t AliConvEventCuts::EventIsSelected(AliVEvent *fInputEvent, AliVEvent *fMCEvent){
 387    // Process Event Selection
 388
 389    Int_t cutindex=0;
 390    if(fHistoEventCuts)fHistoEventCuts->Fill(cutindex);
 391    cutindex++;
 392
 393    // Check for MC event
 394    Bool_t isMC = kFALSE;
 395    if(fMCEvent && fInputEvent->IsA()==AliESDEvent::Class()){
 396       // Check if MC event is correctly loaded
 397       AliMCEventHandler* mcHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
 398       if (!mcHandler){
 399          fEventQuality = 2;
 400          return kFALSE;
 401       }
 402       if (!mcHandler->InitOk() ){
 403          fEventQuality = 2;
 404          return kFALSE;
 405       }
 406       if (!mcHandler->TreeK() ){
 407          fEventQuality = 2;
 408          return kFALSE;
 409       }
 410       if (!mcHandler->TreeTR() ) {
 411          fEventQuality = 2;
 412          return kFALSE;
 413       }
 414       isMC = kTRUE;
 415    }
 416
 417
 418
 419    // Event Trigger
 420 //    cout << "before event trigger" << endl;
 421    if(!IsTriggerSelected(fInputEvent, isMC )){
 422       if(fHistoEventCuts)fHistoEventCuts->Fill(cutindex);
 423       fEventQuality = 3;
 424       return kFALSE;
 425    }
 426    cutindex++;
 427
 428    if(fInputEvent->IsA()==AliESDEvent::Class()){
 429       AliTriggerAnalysis fTriggerAnalysis;// = new AliTriggerAnalysis;
 430       fHasV0AND = fTriggerAnalysis.IsOfflineTriggerFired((AliESDEvent*)fInputEvent, AliTriggerAnalysis::kV0AND);
 431       if(fHasV0AND&&hTriggerClass)hTriggerClass->Fill(32);
 432    }
 433 //   cout << "event number " << ((AliESDEvent*)fInputEvent)->GetEventNumberInFile() << " entered"<< endl;
 434
 435
 436    // Number of Contributors Cut
 437    if(GetNumberOfContributorsVtx(fInputEvent)<=0) {
 438       if(fHistoEventCuts)fHistoEventCuts->Fill(cutindex);
 439       fEventQuality = 5;
 440       return kFALSE;
 441    }
 442    cutindex++;
 443
 444    // Z Vertex Position Cut
 445    if(!VertexZCut(fInputEvent)){
 446       if(fHistoEventCuts)fHistoEventCuts->Fill(cutindex);
 447       fEventQuality = 4;
 448       return kFALSE;
 449    }
 450    cutindex++;
 451
 452    // Pile Up Rejection
 453
 454    if(fRemovePileUp){
 455       if(fInputEvent->IsPileupFromSPD(3,0.8,3.,2.,5.)){
 456          if(fHistoEventCuts)fHistoEventCuts->Fill(cutindex);
 457          fEventQuality = 6;
 458          return kFALSE;
 459       }
 460    }
 461    cutindex++;
 462
 463    // Centrality Selection
 464    if(!IsCentralitySelected(fInputEvent,fMCEvent)){
 465       if(fHistoEventCuts)fHistoEventCuts->Fill(cutindex);
 466       fEventQuality = 1;
 467       return kFALSE;
 468    }
 469    cutindex++;
 470
 471    // Fill Event Histograms
 472    if(fHistoEventCuts)fHistoEventCuts->Fill(cutindex);
 473    if(hVertexZ)hVertexZ->Fill(fInputEvent->GetPrimaryVertex()->GetZ());
 474    if(hCentrality)hCentrality->Fill(GetCentrality(fInputEvent));
 475    if(hCentralityVsNumberOfPrimaryTracks)
 476       hCentralityVsNumberOfPrimaryTracks->Fill(GetCentrality(fInputEvent),
 477                                                ((AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()
 478                                                 ->GetTask(fV0ReaderName.Data()))->GetNumberOfPrimaryTracks());
 479    fEventQuality = 0;
 480    return kTRUE;
 481 }
 482
 483 ///________________________________________________________________________
 484 Bool_t AliConvEventCuts::UpdateCutString() {
 485         ///Update the cut string (if it has been created yet)
 486
 487         if(fCutString && fCutString->GetString().Length() == kNCuts) {
 488                 fCutString->SetString(GetCutNumber());
 489         } else {
 490                 return kFALSE;
 491         }
 492         return kTRUE;
 493 }
 494
 495 ///________________________________________________________________________
 496 void AliConvEventCuts::LoadReweightingHistosMCFromFile() {
 497
 498         AliInfo("Entering loading of histograms for weighting");
 499         TFile *f = TFile::Open(fPathTrFReweighting.Data());
 500         if(!f){
 501                 AliError(Form("file for weighting %s not found",fPathTrFReweighting.Data()));
 502                 return;
 503         }
 504         if (fNameHistoReweightingPi0.CompareTo("") != 0 && fDoReweightHistoMCPi0 ){
 505                 cout << "I have to find: " <<  fNameHistoReweightingPi0.Data() << endl;
 506                 TH1D *hReweightMCHistPi0temp = (TH1D*)f->Get(fNameHistoReweightingPi0.Data());
 507                 hReweightMCHistPi0 = new TH1D(*hReweightMCHistPi0temp);
 508                 if (hReweightMCHistPi0) AliInfo(Form("%s has been loaded from %s", fNameHistoReweightingPi0.Data(),fPathTrFReweighting.Data() ));
 509                 else AliWarning(Form("%s not found in %s", fNameHistoReweightingPi0.Data() ,fPathTrFReweighting.Data()));
 510                 hReweightMCHistPi0->SetDirectory(0);
 511         }
 512         if (fNameFitDataPi0.CompareTo("") != 0 && fDoReweightHistoMCPi0 ){
 513                 cout << "I have to find: " <<  fNameFitDataPi0.Data() << endl;
 514                 TF1 *fFitDataPi0temp = (TF1*)f->Get(fNameFitDataPi0.Data());
 515                 fFitDataPi0 = new TF1(*fFitDataPi0temp);
 516                 if (fFitDataPi0) AliInfo(Form("%s has been loaded from %s", fNameFitDataPi0.Data(),fPathTrFReweighting.Data() ));
 517                 else AliWarning(Form("%s not found in %s",fPathTrFReweighting.Data(), fNameFitDataPi0.Data() ));
 518         }
 519
 520         if (fNameHistoReweightingEta.CompareTo("") != 0 && fDoReweightHistoMCEta){
 521                 cout << "I have to find: " <<  fNameHistoReweightingEta.Data() << endl;
 522                 TH1D *hReweightMCHistEtatemp = (TH1D*)f->Get(fNameHistoReweightingEta.Data());
 523                 hReweightMCHistEta = new TH1D(*hReweightMCHistEtatemp);
 524                 if (hReweightMCHistEta) AliInfo(Form("%s has been loaded from %s", fNameHistoReweightingEta.Data(),fPathTrFReweighting.Data() ));
 525                 else AliWarning(Form("%s not found in %s", fNameHistoReweightingEta.Data(),fPathTrFReweighting.Data() ));
 526                 hReweightMCHistEta->SetDirectory(0);
 527         }
 528
 529         if (fNameFitDataEta.CompareTo("") != 0 && fDoReweightHistoMCEta){
 530                 cout << "I have to find: " <<  fNameFitDataEta.Data() << endl;
 531                 TF1 *fFitDataEtatemp = (TF1*)f->Get(fNameFitDataEta.Data());
 532                 fFitDataEta = new TF1(*fFitDataEtatemp);
 533                 if (fFitDataEta) AliInfo(Form("%s has been loaded from %s", fNameFitDataEta.Data(),fPathTrFReweighting.Data() ));
 534                 else AliWarning(Form("%s not found in %s", fNameFitDataEta.Data(),fPathTrFReweighting.Data() ));
 535
 536         }
 537         if (fNameHistoReweightingK0s.CompareTo("") != 0 && fDoReweightHistoMCK0s){
 538                 cout << "I have to find: " <<  fNameHistoReweightingK0s.Data() << endl;
 539                 TH1D *hReweightMCHistK0stemp = (TH1D*)f->Get(fNameHistoReweightingK0s.Data());
 540                 hReweightMCHistK0s = new TH1D(*hReweightMCHistK0stemp);
 541                 if (hReweightMCHistK0s) AliInfo(Form("%s has been loaded from %s", fNameHistoReweightingK0s.Data(),fPathTrFReweighting.Data() ));
 542                 else AliWarning(Form("%s not found in %s", fNameHistoReweightingK0s.Data(),fPathTrFReweighting.Data() ));
 543                 hReweightMCHistK0s->SetDirectory(0);
 544         }
 545
 546         if (fNameFitDataK0s.CompareTo("") != 0 && fDoReweightHistoMCK0s){
 547                 cout << "I have to find: " <<  fNameFitDataK0s.Data() << endl;
 548                 TF1 *fFitDataK0stemp = (TF1*)f->Get(fNameFitDataK0s.Data());
 549                 fFitDataK0s = new TF1(*fFitDataK0stemp);
 550                 if (fFitDataK0s) AliInfo(Form("%s has been loaded from %s", fNameFitDataK0s.Data(),fPathTrFReweighting.Data() ));
 551                 else AliWarning(Form("%s not found in %s", fNameFitDataK0s.Data(),fPathTrFReweighting.Data() ));
 552         }
 553         f->Close();
 554         delete f;
 555 }
 556
 557
 558 ///________________________________________________________________________
 559 Bool_t AliConvEventCuts::InitializeCutsFromCutString(const TString analysisCutSelection ) {
 560         // Initialize Cuts from a given Cut string
 561         if(fDoReweightHistoMCPi0 || fDoReweightHistoMCEta || fDoReweightHistoMCK0s) {
 562                 AliInfo("Weighting was enabled");
 563                 LoadReweightingHistosMCFromFile();
 564         }
 565
 566         AliInfo(Form("Set Event Cut Number: %s",analysisCutSelection.Data()));
 567         if(analysisCutSelection.Length()!=kNCuts) {
 568                 AliError(Form("Cut selection has the wrong length! size is %d, number of cuts is %d", analysisCutSelection.Length(), kNCuts));
 569                 return kFALSE;
 570         }
 571         if(!analysisCutSelection.IsDigit()){
 572                 AliError("Cut selection contains characters");
 573                 return kFALSE;
 574         }
 575
 576         if (fV0ReaderName.CompareTo("") == 0){
 577                 fV0ReaderName = "V0ReaderV1";
 578         }
 579         const char *cutSelection = analysisCutSelection.Data();
 580         #define ASSIGNARRAY(i)  fCuts[i] = cutSelection[i] - '0'
 581         for(Int_t ii=0;ii<kNCuts;ii++){
 582                 ASSIGNARRAY(ii);
 583         }
 584
 585         // Set Individual Cuts
 586         for(Int_t ii=0;ii<kNCuts;ii++){
 587                 if(!SetCut(cutIds(ii),fCuts[ii]))return kFALSE;
 588         }
 589
 590         PrintCutsWithValues();
 591
 592         return kTRUE;
 593 }
 594
 595 ///________________________________________________________________________
 596 Bool_t AliConvEventCuts::SetCut(cutIds cutID, const Int_t value) {
 597         ///Set individual cut ID
 598
 599         switch (cutID) {
 600         case kremovePileUp:
 601                 if( SetRemovePileUp(value)) {
 602                         fCuts[kremovePileUp] = value;
 603                         UpdateCutString();
 604                         return kTRUE;
 605                 } else return kFALSE;
 606         case kSelectSpecialTriggerAlias:
 607                 if( SetSelectSpecialTrigger(value)) {
 608                         fCuts[kSelectSpecialTriggerAlias] = value;
 609                         UpdateCutString();
 610                         return kTRUE;
 611                 } else return kFALSE;
 612         case kSelectSubTriggerClass:
 613                 if( SetSelectSubTriggerClass(value)) {
 614                         fCuts[kSelectSubTriggerClass] = value;
 615                         UpdateCutString();
 616                         return kTRUE;
 617                 } else return kFALSE;
 618         case kisHeavyIon:
 619                 if( SetIsHeavyIon(value)) {
 620                         fCuts[kisHeavyIon] = value;
 621                         UpdateCutString();
 622                         return kTRUE;
 623                 } else return kFALSE;
 624         case kCentralityMin:
 625                 if( SetCentralityMin(value)) {
 626                         fCuts[kCentralityMin] = value;
 627                         UpdateCutString();
 628                         return kTRUE;
 629                 } else return kFALSE;
 630         case kCentralityMax:
 631                 if( SetCentralityMax(value)) {
 632                         fCuts[kCentralityMax] = value;
 633                         UpdateCutString();
 634                         return kTRUE;
 635                 } else return kFALSE;
 636         case kExtraSignals:
 637                 if( SetRejectExtraSignalsCut(value)) {
 638                         fCuts[kExtraSignals] = value;
 639                         UpdateCutString();
 640                         return kTRUE;
 641                 } else return kFALSE;
 642         case kNCuts:
 643                 AliError("Cut id out of range");
 644                 return kFALSE;
 645         }
 646
 647         AliError("Cut id %d not recognized");
 648         return kFALSE;
 649 }
 650
 651 ///________________________________________________________________________
 652 void AliConvEventCuts::PrintCuts() {
 653         // Print out current Cut Selection
 654         for(Int_t ic = 0; ic < kNCuts; ic++) {
 655                 printf("%-30s : %d \n", fgkCutNames[ic], fCuts[ic]);
 656         }
 657 }
 658
 659 void AliConvEventCuts::PrintCutsWithValues() {
 660    // Print out current Cut Selection with value
 661         printf("\nEvent cutnumber \n");
 662         for(Int_t ic = 0; ic < kNCuts; ic++) {
 663                 printf("%d",fCuts[ic]);
 664         }
 665         printf("\n\n");
 666
 667         if (fIsHeavyIon == 0) {
 668                 printf("Running in pp mode \n");
 669                 if (fSpecialTrigger == 0){
 670                         if (fSpecialSubTrigger == 0){
 671                                 printf("\t only events triggered by V0OR will be analysed \n");
 672                         } else if (fSpecialSubTrigger == 1){
 673                                 printf("\t only events where SDD was present will be analysed \n");
 674                         }
 675                 } else if (fSpecialTrigger == 1){
 676                         if (fSpecialSubTrigger == 0){
 677                                 printf("\t only events triggered by V0AND will be analysed \n");
 678                         } else if(fSpecialSubTrigger == 1){
 679                                 printf("\t only events where SDD was present will be analysed and triggered by VOAND\n");
 680                         }
 681                 } else if (fSpecialTrigger > 1){
 682                         printf("\t only events triggered by %s %s\n", fSpecialTriggerName.Data(), fSpecialSubTriggerName.Data());
 683                 }
 684         } else if (fIsHeavyIon == 1){
 685                 printf("Running in PbPb mode \n");
 686                 if (fDetectorCentrality == 0){
 687                         printf("\t centrality selection based on V0M \n");
 688                 } else if (fDetectorCentrality == 1){
 689                         printf("\t centrality selection based on Cl1 \n");
 690                 }
 691                 if (fModCentralityClass == 0){
 692                         printf("\t %d - %d \n", fCentralityMin*10, fCentralityMax*10);
 693                 } else if ( fModCentralityClass == 1){
 694                         printf("\t %d - %d \n", fCentralityMin*5, fCentralityMax*5);
 695                 } else if ( fModCentralityClass == 2){
 696                         printf("\t %d - %d \n", fCentralityMin*5+45, fCentralityMax*5+45);
 697                 } else if (fModCentralityClass == 3){
 698                         printf("\t %d - %d, with Track mult in MC as data \n", fCentralityMin*10, fCentralityMax*10);
 699                 } else if ( fModCentralityClass == 4){
 700                         printf("\t %d - %d, with Track mult in MC as data \n", fCentralityMin*5, fCentralityMax*5);
 701                 } else if ( fModCentralityClass == 5){
 702                         printf("\t %d - %d, with Track mult in MC as data \n", fCentralityMin*5+45, fCentralityMax*5+45);
 703                 }
 704                 if (fSpecialTrigger == 0){
 705                         printf("\t only events triggered by kMB, kCentral, kSemiCentral will be analysed \n");
 706                 } else if (fSpecialTrigger > 1){
 707                         printf("\t only events triggered by %s %s\n", fSpecialTriggerName.Data(), fSpecialSubTriggerName.Data());
 708                         printf("\n\t        SpecialTrigger is:  %s\n", fSpecialTriggerName.Data());
 709                         printf("\t        SpecialSubTrigger is: %s\n\n", fSpecialSubTriggerName.Data());
 710                 }
 711         } else if (fIsHeavyIon == 2){
 712                 printf("Running in pPb mode \n");
 713                 if (fDetectorCentrality == 0){
 714                         printf("\t centrality selection based on V0A \n");
 715                 } else if (fDetectorCentrality == 1){
 716                         printf("\t centrality selection based on Cl1 \n");
 717                 }
 718                 if (fModCentralityClass == 0){
 719                         printf("\t %d - %d \n", fCentralityMin*10, fCentralityMax*10);
 720                 }
 721                 if (fSpecialTrigger == 0){
 722                         printf("\t only events triggered by kINT7 will be analysed \n");
 723                 } else if (fSpecialTrigger > 1){
 724                         printf("\t only events triggered by %s %s\n", fSpecialTriggerName.Data(), fSpecialSubTriggerName.Data());
 725                 }
 726         }
 727         printf("MC event cuts: \n");
 728         if (fRejectExtraSignals == 0) printf("\t no rejection was applied \n");
 729                 else if (fRejectExtraSignals == 1) printf("\t only MB header will be inspected \n");
 730                 else if (fRejectExtraSignals > 1) printf("\t special header have been selected \n");
 731 }
 732
 733 ///________________________________________________________________________
 734 Bool_t AliConvEventCuts::SetIsHeavyIon(Int_t isHeavyIon)
 735 {   // Set Cut
 736         switch(isHeavyIon){
 737         case 0:
 738                 fIsHeavyIon=0;
 739                 break;
 740         case 1:
 741                 fIsHeavyIon=1;
 742                 fDetectorCentrality=0;
 743                 break;
 744         case 2:
 745                 fIsHeavyIon=1;
 746                 fDetectorCentrality=1;
 747                 break;
 748         case 3: //allows to select centrality 0-45% in steps of 5% for V0 Multiplicity
 749                 fIsHeavyIon=1;
 750                 fDetectorCentrality=0;
 751                 fModCentralityClass=1;
 752                 break;
 753         case 4: //allows to select centrality 45-90% in steps of 5% for V0 Multiplicity
 754                 fIsHeavyIon=1;
 755                 fDetectorCentrality=0;
 756                 fModCentralityClass=2;
 757                 break;
 758         case 5: //strict cut on v0 tracks for MC
 759                 fIsHeavyIon=1;
 760                 fDetectorCentrality=0;
 761                 fModCentralityClass=3;
 762                 break;
 763         case 6: //allows to select centrality 0-45% in steps of 5% for track mult
 764                 //strict cut on v0 tracks for MC
 765                 fIsHeavyIon=1;
 766                 fDetectorCentrality=0;
 767                 fModCentralityClass=4;
 768                 break;
 769         case 7: //allows to select centrality 45-90% in steps of 5% for V0 Multiplicity
 770                 //strict cut on v0 tracks for MC
 771                 fIsHeavyIon=1;
 772                 fDetectorCentrality=0;
 773                 fModCentralityClass=5;
 774                 break;
 775         case 8:
 776                 fIsHeavyIon=2;
 777                 fDetectorCentrality=0;
 778                 break;
 779         case 9:
 780                 fIsHeavyIon=2;
 781                 fDetectorCentrality=1;
 782                 break;
 783         default:
 784                 AliError(Form("SetHeavyIon not defined %d",isHeavyIon));
 785                 return kFALSE;
 786         }
 787         return kTRUE;
 788 }
 789
 790 //___________________________________________________________________
 791 Bool_t AliConvEventCuts::SetCentralityMin(Int_t minCentrality)
 792 {
 793         // Set Cut
 794         if(minCentrality<0||minCentrality>9){
 795                 AliError(Form("minCentrality not defined %d",minCentrality));
 796                 return kFALSE;
 797         }
 798
 799         fCentralityMin=minCentrality;
 800         return kTRUE;
 801 }
 802
 803 //___________________________________________________________________
 804 Bool_t AliConvEventCuts::SetCentralityMax(Int_t maxCentrality)
 805 {
 806         // Set Cut
 807         if(maxCentrality<0||maxCentrality>9){
 808                 AliError(Form("maxCentrality not defined %d",maxCentrality));
 809                 return kFALSE;
 810         }
 811         fCentralityMax=maxCentrality;
 812         return kTRUE;
 813 }
 814
 815 ///________________________________________________________________________
 816 Bool_t AliConvEventCuts::SetSelectSpecialTrigger(Int_t selectSpecialTrigger)
 817 {// Set Cut
 818
 819         switch(selectSpecialTrigger){
 820         case 0:
 821                 fSpecialTrigger=0; // V0OR
 822                 break;
 823         case 1:
 824                 fSpecialTrigger=1; // V0AND
 825                 break;
 826 //      case 2:
 827 //              fSpecialTrigger=2; //
 828 //              break;
 829         case 3:
 830                 fSpecialTrigger=3; //specific centrality trigger selection
 831                 fSpecialTriggerName="AliVEvent::kCentral/kSemiCentral/kMB";
 832                 break;
 833         case 4:
 834                 fSpecialTrigger=4; // trigger alias kTRD
 835                 fOfflineTriggerMask=AliVEvent::kTRD;
 836                 fTriggerSelectedManually = kTRUE;
 837                 fSpecialTriggerName="AliVEvent::kTRD";
 838                 break;
 839         case 5:
 840                 fSpecialTrigger=5; // trigger alias kEMC
 841                 fOfflineTriggerMask=AliVEvent::kEMC7 | AliVEvent::kEMC8 | AliVEvent::kEMC1 ;
 842                 fTriggerSelectedManually = kTRUE;
 843                 fTriggersEMCALSelected= 0;
 844                 SETBIT(fTriggersEMCALSelected, kL0);
 845                 fSpecialTriggerName="AliVEvent::kEMC7/kEMC8/kEMC1";
 846                 break;
 847         case 6:
 848                 fSpecialTrigger=6; // trigger alias kPHI
 849                 fOfflineTriggerMask=AliVEvent::kPHI7 | AliVEvent::kPHI1 | AliVEvent::kPHI8 | AliVEvent::kPHOSPb;
 850                 fTriggerSelectedManually = kTRUE;
 851                 fSpecialTriggerName="AliVEvent::kPHI7/kPHI1/kPHI8/kPHOSPb";
 852                 break;
 853         case 7:
 854                 fSpecialTrigger=7; // trigger alias kHighMult
 855                 fOfflineTriggerMask=AliVEvent::kHighMult;
 856                 fTriggerSelectedManually = kTRUE;
 857                 fSpecialTriggerName="AliVEvent::kHighMult";
 858                 break;
 859                 case 8:
 860                 fSpecialTrigger=8; // trigger alias kEMCEGA
 861                 fOfflineTriggerMask=AliVEvent::kEMCEGA;
 862                 fTriggerSelectedManually = kTRUE;
 863                 fTriggersEMCALSelected= 0;
 864                 SETBIT(fTriggersEMCALSelected, kG2);
 865                 fSpecialTriggerName="AliVEvent::kEMCEGA";
 866                 break;
 867                 case 9:
 868                 fSpecialTrigger=9; // trigger alias kEMCEJE
 869                 fOfflineTriggerMask=AliVEvent::kEMCEJE;
 870                 fTriggerSelectedManually = kTRUE;
 871                 fTriggersEMCALSelected= 0;
 872                 SETBIT(fTriggersEMCALSelected, kJ2);
 873                 fSpecialTriggerName="AliVEvent::kEMCEJE";
 874                 break;
 875         default:
 876                 AliError("Warning: Special Trigger Not known");
 877                 return 0;
 878         }
 879         return 1;
 880 }
 881
 882 ///________________________________________________________________________
 883 Bool_t AliConvEventCuts::SetSelectSubTriggerClass(Int_t selectSpecialSubTriggerClass)
 884 {// Set Cut
 885
 886         if (fSpecialTrigger == 0){ //OR
 887                 switch(selectSpecialSubTriggerClass){
 888                 case 0://with VZERO
 889                         fSpecialTrigger=0;
 890                         fSpecialSubTrigger=0;
 891 //                      AliInfo("Info: Nothing to be done");
 892                         break;
 893                 case 3: //V0OR with SDD requested (will only work with LHC11a dataset)
 894                         fSpecialSubTrigger=1;
 895                         cout << "V0OR with SDD requested" << endl;
 896                         break;
 897                 default:
 898                         AliError("Warning: Special Subtrigger Class Not known");
 899                         return 0;
 900                 }
 901         } else if (fSpecialTrigger == 1){ //AND with different detectors
 902                 switch(selectSpecialSubTriggerClass){
 903                 case 0: //with VZERO general implementation of V0AND (periods LHC11c onwards)
 904                         fSpecialTrigger=0;
 905                         fSpecialSubTrigger=0;
 906                         fOfflineTriggerMask=AliVEvent::kINT7;
 907                         fTriggerSelectedManually = kTRUE;
 908                         fSpecialTriggerName="AliVEvent::kINT7";
 909                 break;
 910                 case 1: //with TZERO
 911                         fSpecialTrigger=0;
 912                         fSpecialSubTrigger=0;
 913                         fOfflineTriggerMask=AliVEvent::kINT8;
 914                         fTriggerSelectedManually = kTRUE;
 915                         fSpecialTriggerName="AliVEvent::kINT8";
 916                         break;
 917                 case 2: //with VZERO (will only work with LHC11a dataset)
 918                         fSpecialTrigger=1;
 919                         fSpecialSubTrigger=0;
 920 //                      AliInfo("Info: Nothing to be done");
 921                         break;
 922                 case 3: //V0AND with SDD requested (will only work with LHC11a dataset)
 923                         fSpecialTrigger=1;
 924                         fSpecialSubTrigger=1;
 925                         break;
 926                 default:
 927                         AliError("Warning: Special Subtrigger Class Not known");
 928                         return 0;
 929                 }
 930         } else if (fSpecialTrigger == 3){ // Selecting kCentral and kSemiCentral from trigger classes, not aliases
 931                 switch(selectSpecialSubTriggerClass){
 932                 case 0: // all together
 933                         fSpecialSubTrigger=0;
 934                         fSpecialSubTriggerName="";
 935 //                      AliInfo("Info: Nothing to be done");
 936                         break;
 937                 case 1: // kCentral - no vertex restriction
 938                         fSpecialSubTrigger=1;
 939                         fNSpecialSubTriggerOptions=1;
 940                         fSpecialSubTriggerName="CVHN";
 941                         cout << "kCentralOpen" << endl;
 942                         break;
 943                 case 2: // kCentral - T00 +- 10 cm
 944                         fSpecialSubTrigger=1;
 945                         fNSpecialSubTriggerOptions=1;
 946                         fSpecialSubTriggerName="CCENT";
 947                         cout << "kCentralVertex" << endl;
 948                         break;
 949                 case 3: // kCentral - both
 950                         fSpecialSubTrigger=1;
 951                         fNSpecialSubTriggerOptions=1;
 952                         fSpecialSubTriggerName="CVHN|CCENT";
 953                         cout << "kCentral both" << endl;
 954                         break;
 955                 case 4: // kSemiCentral - no vertex restriction
 956                         fSpecialSubTrigger=1;
 957                         fNSpecialSubTriggerOptions=1;
 958                         fSpecialSubTriggerName="CVLN";
 959                         cout << "kSemiCentralOpen" << endl;
 960                         break;
 961                 case 5: // kSemiCentral - T00 +- 10 cm
 962                         fSpecialSubTrigger=1;
 963                         fNSpecialSubTriggerOptions=1;
 964                         fSpecialSubTriggerName="CSEMI";
 965                         cout << "kSemiCentralVertex" << endl;
 966                         break;
 967                 case 6: // kSemiCentral - both
 968                         fSpecialSubTrigger=1;
 969                         fNSpecialSubTriggerOptions=1;
 970                         fSpecialSubTriggerName="CSEMI%CVLN";
 971                         cout << "kSemiCentral both" << endl;
 972                         break;
 973                 case 7: // kMB
 974                         fSpecialSubTrigger=1;
 975                         fNSpecialSubTriggerOptions=1;
 976                         fSpecialSubTriggerName="CPBI1_|CPBI1-";
 977                         cout << "kMB 1" << endl;
 978                         break;
 979                 case 8: // kMB
 980                         fSpecialSubTrigger=1;
 981                         fNSpecialSubTriggerOptions=1;
 982                         fSpecialSubTriggerName="CPBI2_|CPBI2-";
 983                         cout << "kMB 2" << endl;
 984                         break;
 985                 default:
 986                         AliError("Warning: Special Subtrigger Class Not known");
 987                         return 0;
 988                 }
 989         } else if (fSpecialTrigger == 4){ // Subdivision of TRD trigger classes
 990                 switch(selectSpecialSubTriggerClass){
 991                 case 0: // all together
 992                         fSpecialSubTrigger=0;
 993                         fSpecialSubTriggerName="";
 994 //                      AliInfo("Info: Nothing to be done");
 995                         break;
 996                 case 1: // 7WUHSH - V0AND with single electron in TRD & EMCAL
 997                         fSpecialSubTrigger=1;
 998                         fNSpecialSubTriggerOptions=1;
 999                         fSpecialSubTriggerName="7WUHEE";
1000                         break;
1001                 case 2: // 8WUHSH - T0AND with single electron in TRD & EMCAL
1002                         fSpecialSubTrigger=1;
1003                         fNSpecialSubTriggerOptions=1;
1004                         fSpecialSubTriggerName="8WUHEE";
1005                         break;
1006                 case 3: // 7WUHSE - V0AND with single high pt electron in TRD
1007                         fSpecialSubTrigger=1;
1008                         fNSpecialSubTriggerOptions=1;
1009                         fSpecialSubTriggerName="7WUHSE";
1010                         break;
1011                 case 4: // 8WUHSE - T0AND with single high pt electron in TRD
1012                         fSpecialSubTrigger=1;
1013                         fNSpecialSubTriggerOptions=1;
1014                         fSpecialSubTriggerName="8WUHSE";
1015                         break;
1016                 case 5: // 7WUHJE - V0AND with jet in TRD
1017                         fSpecialSubTrigger=1;
1018                         fNSpecialSubTriggerOptions=1;
1019                         fSpecialSubTriggerName="7WUHJT";
1020                         break;
1021                 case 6: // 8WUHJE - T0AND with jet in TRD
1022                         fSpecialSubTrigger=1;
1023                         fNSpecialSubTriggerOptions=1;
1024                         fSpecialSubTriggerName="8WUHJT";
1025                         break;
1026                 case 7: // 7WUHQU - V0AND with dielectron pair in TRD
1027                         fSpecialSubTrigger=1;
1028                         fNSpecialSubTriggerOptions=1;
1029                         fSpecialSubTriggerName="7WUHQU";
1030                         break;
1031                 case 8: // 8WUHQU - T0AND with dielectron pair in TRD
1032                         fSpecialSubTrigger=1;
1033                         fNSpecialSubTriggerOptions=1;
1034                         fSpecialSubTriggerName="8WUHQU";
1035                         break;
1036                 default:
1037                         AliError("Warning: Special Subtrigger Class Not known");
1038                         return 0;
1039                 }
1040         } else if (fSpecialTrigger == 5){ // Subdivision of kEMC trigger classes
1041                 switch(selectSpecialSubTriggerClass){
1042                 case 0: // all together
1043                         fSpecialSubTrigger=0;
1044                         fSpecialSubTriggerName="";
1045 //                      AliInfo("Info: Nothing to be done");
1046                         break;
1047                 case 1: // CEMC1 - V0OR and EMCAL fired
1048                         fOfflineTriggerMask=AliVEvent::kEMC1;
1049                         fSpecialTriggerName="AliVEvent::kEMC1";
1050                         fSpecialSubTrigger=1;
1051                         fNSpecialSubTriggerOptions=1;
1052                         fSpecialSubTriggerName="CEMC1";
1053                         break;
1054                 case 2: // CEMC7 - V0AND and EMCAL fired
1055                         fSpecialSubTrigger=1;
1056                         fOfflineTriggerMask=AliVEvent::kEMC7;
1057                         fSpecialTriggerName="AliVEvent::kEMC7";
1058                         fNSpecialSubTriggerOptions=1;
1059                         fSpecialSubTriggerName="CEMC7";
1060                         break;
1061                 case 3: // CEMC8  - T0OR and EMCAL fired
1062                         fOfflineTriggerMask=AliVEvent::kEMC8;
1063                         fSpecialTriggerName="AliVEvent::kEMC8";
1064                         fSpecialSubTrigger=1;
1065                         fNSpecialSubTriggerOptions=1;
1066                         fSpecialSubTriggerName="CEMC8";
1067                         break;
1068                 default:
1069                         AliError("Warning: Special Subtrigger Class Not known");
1070                         return 0;
1071                 }
1072         }  else if (fSpecialTrigger == 6){ // Subdivision of kPHI trigger classes
1073                 switch(selectSpecialSubTriggerClass){
1074                 case 0: // all together
1075                         fSpecialSubTrigger=0;
1076                         fSpecialSubTriggerName="";
1077 //                      AliInfo("Info: Nothing to be done");
1078                         break;
1079                 case 1: // CEMC1 - V0OR and EMCAL fired
1080                         fOfflineTriggerMask=AliVEvent::kPHI1;
1081                         fSpecialTriggerName="AliVEvent::kPHI1";
1082                         fSpecialSubTrigger=1;
1083                         fNSpecialSubTriggerOptions=1;
1084                         fSpecialSubTriggerName="CPHI1";
1085                         break;
1086                 case 2: // CEMC7 - V0AND and EMCAL fired
1087                         fSpecialSubTrigger=1;
1088                         fOfflineTriggerMask=AliVEvent::kPHI7;
1089                         fSpecialTriggerName="AliVEvent::kPHI7";
1090                         fNSpecialSubTriggerOptions=1;
1091                         fSpecialSubTriggerName="CPHI7";
1092                         break;
1093                 case 3: // CEMC8  - T0OR and EMCAL fired
1094                         fOfflineTriggerMask=AliVEvent::kPHI8;
1095                         fSpecialTriggerName="AliVEvent::kPHI8";
1096                         fSpecialSubTrigger=1;
1097                         fNSpecialSubTriggerOptions=1;
1098                         fSpecialSubTriggerName="CPHI8";
1099                         break;
1100                 default:
1101                         AliError("Warning: Special Subtrigger Class Not known");
1102                         return 0;
1103                 }
1104         } else if (fSpecialTrigger == 7){ // Subdivision of kHighMult trigger classes
1105                 switch(selectSpecialSubTriggerClass){
1106                 case 0: // all together
1107                         fSpecialSubTrigger=0;
1108                         fSpecialSubTriggerName="";
1109 //                      AliInfo("Info: Nothing to be done");
1110                         break;
1111                 case 1: // CSHM1 - V0OR and high mult fired
1112                         fSpecialSubTrigger=1;
1113                         fNSpecialSubTriggerOptions=1;
1114                         fSpecialSubTriggerName="CSHM1";
1115                         break;
1116                 case 2: // CSHM7 - V0AND and high mult fired
1117                         fSpecialSubTrigger=1;
1118                         fNSpecialSubTriggerOptions=1;
1119                         fSpecialSubTriggerName="CSHM7";
1120                         break;
1121                 case 3: // CSHM8  - T0OR and high mult fired
1122                         fSpecialSubTrigger=1;
1123                         fNSpecialSubTriggerOptions=1;
1124                         fSpecialSubTriggerName="CSHM8";
1125                         break;
1126                 default:
1127                         AliError("Warning: Special Subtrigger Class Not known");
1128                         return 0;
1129                 }
1130         }  else if (fSpecialTrigger == 8){ // Subdivision of kEMCEGA trigger classes
1131                 switch(selectSpecialSubTriggerClass){
1132                 case 0: // all together
1133                         fSpecialSubTrigger=0;
1134                         fSpecialSubTriggerName="";
1135 //                      AliInfo("Info: Nothing to be done");
1136                         break;
1137                 case 1: // 7EGA - CINT7 EGA
1138                         fSpecialSubTrigger=1;
1139                         fNSpecialSubTriggerOptions=1;
1140                         fSpecialSubTriggerName="7EGA";
1141                         fTriggersEMCALSelected= 0;
1142                         SETBIT(fTriggersEMCALSelected, kG2);
1143                         break;
1144                 case 2: // 8EGA - CINT8 EGA
1145                         fSpecialSubTrigger=1;
1146                         fNSpecialSubTriggerOptions=1;
1147                         fSpecialSubTriggerName="8EGA";
1148                         fTriggersEMCALSelected= 0;
1149                         SETBIT(fTriggersEMCALSelected, kG2);
1150                         break;
1151                 case 3: // 7EG1 - CINT7 EG1
1152                         fSpecialSubTrigger=1;
1153                         fNSpecialSubTriggerOptions=1;
1154                         fSpecialSubTriggerName="7EG1";
1155                         fTriggersEMCALSelected= 0;
1156                         SETBIT(fTriggersEMCALSelected, kG1);
1157                         break;
1158                 case 4: // 8EG1 - CINT8 EG1
1159                         fSpecialSubTrigger=1;
1160                         fNSpecialSubTriggerOptions=1;
1161                         fSpecialSubTriggerName="8EG1";
1162                         fTriggersEMCALSelected= 0;
1163                         SETBIT(fTriggersEMCALSelected, kG1);
1164                         break;
1165                 case 5: // 7EG2 - CINT7 EG2
1166                         fSpecialSubTrigger=1;
1167                         fNSpecialSubTriggerOptions=1;
1168                         fSpecialSubTriggerName="7EG2";
1169                         fTriggersEMCALSelected= 0;
1170                         SETBIT(fTriggersEMCALSelected, kG2);
1171                         break;
1172                 case 6: // 8EG2 - CINT8 EG2
1173                         fSpecialSubTrigger=1;
1174                         fNSpecialSubTriggerOptions=1;
1175                         fSpecialSubTriggerName="8EG2";
1176                         fTriggersEMCALSelected= 0;
1177                         SETBIT(fTriggersEMCALSelected, kG2);
1178                         break;
1179                 default:
1180                         AliError("Warning: Special Subtrigger Class Not known");
1181                         return 0;
1182                 }
1183         } else if (fSpecialTrigger == 9){ // Subdivision of kEMCEGA trigger classes
1184                 switch(selectSpecialSubTriggerClass){
1185                 case 0: // all together
1186                         fSpecialSubTrigger=0;
1187                         fSpecialSubTriggerName="";
1188 //                      AliInfo("Info: Nothing to be done");
1189                         break;
1190                 case 1: // 7EJE - CINT7 EJE
1191                         fSpecialSubTrigger=1;
1192                         fNSpecialSubTriggerOptions=1;
1193                         fSpecialSubTriggerName="7EJE";
1194                         fTriggersEMCALSelected= 0;
1195                         SETBIT(fTriggersEMCALSelected, kJ2);
1196                         break;
1197                 case 2: // 8EJE - CINT8 EJE
1198                         fSpecialSubTrigger=1;
1199                         fNSpecialSubTriggerOptions=1;
1200                         fSpecialSubTriggerName="8EJE";
1201                         fTriggersEMCALSelected= 0;
1202                         SETBIT(fTriggersEMCALSelected, kJ2);
1203                         break;
1204                 case 3: // 7EJ1 - CINT7 EJ1
1205                         fSpecialSubTrigger=1;
1206                         fNSpecialSubTriggerOptions=1;
1207                         fSpecialSubTriggerName="7EJ1";
1208                         fTriggersEMCALSelected= 0;
1209                         SETBIT(fTriggersEMCALSelected, kJ1);
1210                         break;
1211                 case 4: // 8EJ1 - CINT8 EJ1
1212                         fSpecialSubTrigger=1;
1213                         fNSpecialSubTriggerOptions=1;
1214                         fSpecialSubTriggerName="8EJ1";
1215                         fTriggersEMCALSelected= 0;
1216                         SETBIT(fTriggersEMCALSelected, kJ1);
1217                         break;
1218                 case 5: // 7EJ2 - CINT7 EJ2
1219                         fSpecialSubTrigger=1;
1220                         fNSpecialSubTriggerOptions=1;
1221                         fSpecialSubTriggerName="7EJ2";
1222                         fTriggersEMCALSelected= 0;
1223                         SETBIT(fTriggersEMCALSelected, kJ2);
1224                         break;
1225                 case 6: // 8EJ2 - CINT8 EJ2
1226                         fSpecialSubTrigger=1;
1227                         fNSpecialSubTriggerOptions=1;
1228                         fSpecialSubTriggerName="8EJ2";
1229                         fTriggersEMCALSelected= 0;
1230                         SETBIT(fTriggersEMCALSelected, kJ2);
1231                         break;
1232                 default:
1233                         AliError("Warning: Special Subtrigger Class Not known");
1234                         return 0;
1235                 }
1236         }
1237         return 1;
1238 }
1239
1240 ///________________________________________________________________________
1241 Bool_t AliConvEventCuts::SetMultiplicityMethod(Int_t multiplicityMethod)
1242 {
1243         // Set Cut
1244         fMultiplicityMethod=multiplicityMethod;
1245
1246         // 0 Photon Multiplicity
1247         // 1 TPC Track multiplicity
1248         // 2 V0 Mult
1249         // 3 SPD Mult
1250
1251         return kTRUE;
1252 }
1253
1254 ///________________________________________________________________________
1255 Bool_t AliConvEventCuts::SetRemovePileUp(Int_t removePileUp)
1256 {// Set Cut
1257         switch(removePileUp){
1258         case 0:
1259                 fRemovePileUp=kFALSE;
1260                 break;
1261         case 1:
1262                 fRemovePileUp=kTRUE;
1263                 break;
1264         default:
1265                 AliError("RemovePileUpCut not defined");
1266                 return kFALSE;
1267         }
1268         return kTRUE;
1269 }
1270
1271 ///________________________________________________________________________
1272 Bool_t AliConvEventCuts::SetRejectExtraSignalsCut(Int_t extraSignal) {
1273
1274         switch(extraSignal){
1275         case 0:
1276                 fRejectExtraSignals = 0;
1277                 break; // No Rejection
1278         case 1:
1279                 fRejectExtraSignals = 1;
1280                 break; // MinBias Header
1281         case 2:
1282                 fRejectExtraSignals = 2;
1283                 break; // User String Array
1284         case 3:
1285                 fRejectExtraSignals = 3;
1286                 break; // Rejection for Gamma Correction only
1287         default:
1288                 AliError(Form("Extra Signal Rejection not defined %d",extraSignal));
1289                 return kFALSE;
1290         }
1291         return kTRUE;
1292 }
1293
1294 //-------------------------------------------------------------
1295 Double_t AliConvEventCuts::GetCentrality(AliVEvent *event)
1296 {   // Get Event Centrality
1297
1298         AliESDEvent *esdEvent=dynamic_cast<AliESDEvent*>(event);
1299         if(esdEvent){
1300                 AliCentrality *fESDCentrality=(AliCentrality*)esdEvent->GetCentrality();
1301                 if(fDetectorCentrality==0){
1302                         if (fIsHeavyIon==2){
1303                                 return fESDCentrality->GetCentralityPercentile("V0A"); // default for pPb
1304                         } else{
1305                                 return fESDCentrality->GetCentralityPercentile("V0M"); // default
1306                         }
1307                 }
1308                 if(fDetectorCentrality==1){
1309                         return fESDCentrality->GetCentralityPercentile("CL1");
1310                 }
1311         }
1312
1313         AliAODEvent *aodEvent=dynamic_cast<AliAODEvent*>(event);
1314         if(aodEvent){
1315           if(aodEvent->GetHeader()){return ((AliVAODHeader*)aodEvent->GetHeader())->GetCentrality();}
1316         }
1317
1318         return -1;
1319 }
1320
1321 //_____________________________________________________________________________________
1322 Bool_t AliConvEventCuts::IsCentralitySelected(AliVEvent *event, AliVEvent *fMCEvent)
1323 {   // Centrality Selection
1324         if(!fIsHeavyIon)return kTRUE;
1325
1326         if(fCentralityMin == fCentralityMax ) return kTRUE;//0-100%
1327         else if ( fCentralityMax==0) fCentralityMax=10; //CentralityRange = fCentralityMin-10*multfactor
1328         Double_t centrality=GetCentrality(event);
1329         if(centrality<0)return kFALSE;
1330
1331         Int_t centralityC=0;
1332         if (fModCentralityClass == 0){
1333                 centralityC= Int_t(centrality/10);
1334                 if(centralityC >= fCentralityMin && centralityC < fCentralityMax)
1335                         return kTRUE;
1336                 else return kFALSE;
1337         }
1338         else if (fModCentralityClass ==1){
1339                 centralityC= Int_t(centrality);
1340                 if(centralityC >= fCentralityMin*5 && centralityC < fCentralityMax*5){
1341                         return kTRUE;
1342                 } else return kFALSE;
1343         }
1344         else if (fModCentralityClass ==2){
1345                 centralityC= Int_t(centrality);
1346                 if(centralityC >= ((fCentralityMin*5)+45) && centralityC < ((fCentralityMax*5)+45))
1347                         return kTRUE;
1348                 else return kFALSE;
1349         }
1350
1351         Int_t nprimaryTracks = ((AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask(fV0ReaderName.Data()))->GetNumberOfPrimaryTracks();
1352         Int_t PrimaryTracks10[11][2] =
1353                 {
1354                         {9999,9999}, //  0
1355                         {1210, 928}, // 10
1356                         { 817, 658}, // 20
1357                         { 536, 435}, // 30
1358                         { 337, 276}, // 40
1359                         { 197, 162}, // 50
1360                         { 106, 100}, // 60
1361                         {  51,  44}, // 70
1362                         {  21,  18}, // 80
1363                         {   0,   0},  // 90
1364                         {   0,   0}  // 100 // only max accessible
1365                 };
1366         Int_t PrimaryTracks5a[11][2] =
1367                 {
1368                         {9999,9999}, // 0
1369                         {1485,1168}, // 5
1370                         {1210, 928}, // 10
1371                         { 995, 795}, // 15
1372                         { 817, 658}, // 20
1373                         { 666, 538}, // 25
1374                         { 536, 435}, // 30
1375                         { 428, 350}, // 35
1376                         { 337, 276}, // 40
1377                         { 260, 214},  // 45
1378                         { 0, 162}  // 50 only max accessible
1379                 };
1380         Int_t PrimaryTracks5b[11][2] =
1381                 {
1382                         { 260, 214}, // 45
1383                         { 197, 162}, // 50
1384                         { 147, 125}, // 55
1385                         { 106, 100}, // 60
1386                         {  75,  63}, // 65
1387                         {  51,  44}, // 70
1388                         {  34,  29}, // 75
1389                         {  21,  18}, // 80
1390                         {  13,  11}, // 85
1391                         {   0,   0},  // 90
1392                         {   0,   0}  // 100 only max accessible
1393                 };
1394         Int_t column = 0;
1395         if(event->IsA()==AliESDEvent::Class()) column = 0;
1396         if(event->IsA()==AliAODEvent::Class()) column = 1;
1397
1398         if (fModCentralityClass == 3){
1399                 if(fMCEvent){
1400                         if(nprimaryTracks > PrimaryTracks10[fCentralityMax][column] && nprimaryTracks <= PrimaryTracks10[fCentralityMin][column])
1401                                 return kTRUE;
1402                         else return kFALSE;
1403                 }
1404                 else{
1405                         centralityC= Int_t(centrality/10);
1406                         if(centralityC >= fCentralityMin && centralityC < fCentralityMax)
1407                                 return kTRUE;
1408                         else return kFALSE;
1409                 }
1410         }
1411         else if (fModCentralityClass ==4){
1412                 if(fMCEvent){
1413                         if(nprimaryTracks > PrimaryTracks5a[fCentralityMax][column] && nprimaryTracks <= PrimaryTracks5a[fCentralityMin][column])
1414                                 return kTRUE;
1415                         else return kFALSE;
1416                 }
1417                 else{
1418                         centralityC= Int_t(centrality);
1419                         if(centralityC >= fCentralityMin*5 && centralityC < fCentralityMax*5){
1420                                 return kTRUE;
1421                         } else return kFALSE;
1422                 }
1423         }
1424         else if (fModCentralityClass ==5){
1425                 if(fMCEvent){
1426                         if(nprimaryTracks > PrimaryTracks5b[fCentralityMax][column] && nprimaryTracks <= PrimaryTracks5b[fCentralityMin][column])
1427                                 return kTRUE;
1428                         else return kFALSE;
1429                 }
1430                 else{
1431                         centralityC= Int_t(centrality);
1432                         if(centralityC >= ((fCentralityMin*5)+45) && centralityC < ((fCentralityMax*5)+45))
1433                                 return kTRUE;
1434                         else return kFALSE;
1435                 }
1436         }
1437
1438         return kFALSE;
1439 }
1440
1441 ///________________________________________________________________________
1442 Bool_t AliConvEventCuts::VertexZCut(AliVEvent *event){
1443         // Cut on z position of primary vertex
1444         Double_t fVertexZ=event->GetPrimaryVertex()->GetZ();
1445         Double_t fVertexZSPD = 0;
1446         AliESDEvent *fESDEvent=dynamic_cast<AliESDEvent*>(event);
1447         if(fESDEvent){
1448                 fVertexZSPD = fESDEvent->GetPrimaryVertexSPD()->GetZ();
1449         }
1450         AliAODEvent *fAODEvent=dynamic_cast<AliAODEvent*>(event);
1451         if(fAODEvent){
1452                 fVertexZSPD = fAODEvent->GetPrimaryVertexSPD()->GetZ();
1453         }
1454
1455         if(abs(fVertexZ)>fMaxVertexZ)return kFALSE;
1456
1457         TString periodName = ((AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()
1458                                                                                                         ->GetTask(fV0ReaderName.Data()))->GetPeriodName();
1459         if (periodName.CompareTo("LHC11h")==0){
1460                 if (abs(fVertexZ-fVertexZSPD) > 0.1) return kFALSE;
1461         }
1462         if (fIsHeavyIon == 2){
1463                 if(fUtils->IsFirstEventInChunk(event)) return kFALSE;
1464                 if(!fUtils->IsVertexSelected2013pA(event)) return kFALSE;
1465                 if(fUtils->IsPileUpEvent(event)) return kFALSE;
1466         }
1467
1468         return kTRUE;
1469 }
1470
1471 ///________________________________________________________________________
1472 Int_t AliConvEventCuts::GetNumberOfContributorsVtx(AliVEvent *event){
1473         // returns number of contributors to the vertex
1474
1475         AliESDEvent *fESDEvent=dynamic_cast<AliESDEvent*>(event);
1476         if(fESDEvent){
1477                 if (fESDEvent->GetPrimaryVertex() != NULL){
1478                         if(fESDEvent->GetPrimaryVertex()->GetNContributors()>0) {
1479         //     cout << "accepted global" << fESDEvent->GetEventNumberInFile() << " with NCont: " << fESDEvent->GetPrimaryVertex()->GetNContributors() << endl;
1480                                 return fESDEvent->GetPrimaryVertex()->GetNContributors();
1481                         }
1482                 }
1483
1484                 if(fESDEvent->GetPrimaryVertexSPD() !=NULL){
1485                         if(fESDEvent->GetPrimaryVertexSPD()->GetNContributors()>0) {
1486         //     cout << "accepted SPD" << fESDEvent->GetEventNumberInFile() << " with NCont: " << fESDEvent->GetPrimaryVertexSPD()->GetNContributors() << endl;
1487                                 return fESDEvent->GetPrimaryVertexSPD()->GetNContributors();
1488                         }  else {
1489                                 AliWarning(Form("Number of contributors from bad vertex type:: %s",fESDEvent->GetPrimaryVertex()->GetName()));
1490         //            cout << "rejected " << fESDEvent->GetEventNumberInFile() << endl;
1491                                 return 0;
1492                         }
1493                 }
1494         }
1495
1496         AliAODEvent *fAODEvent=dynamic_cast<AliAODEvent*>(event);
1497         if(fAODEvent){
1498                 if (fAODEvent->GetPrimaryVertex() != NULL){
1499                         if(fAODEvent->GetPrimaryVertex()->GetNContributors()>0) {
1500                                 return fAODEvent->GetPrimaryVertex()->GetNContributors();
1501                         }
1502                 }
1503                 if(fAODEvent->GetPrimaryVertexSPD() !=NULL){
1504                         if(fAODEvent->GetPrimaryVertexSPD()->GetNContributors()>0) {
1505                                 return fAODEvent->GetPrimaryVertexSPD()->GetNContributors();
1506                         } else {
1507                                 AliWarning(Form("Number of contributors from bad vertex type:: %s",fAODEvent->GetPrimaryVertex()->GetName()));
1508                                 return 0;
1509                         }
1510                 }
1511         }
1512         // cout << "rejected " << fESDEvent->GetEventNumberInFile() << endl;
1513         return 0;
1514 }
1515
1516
1517 ///________________________________________________________________________
1518 Bool_t AliConvEventCuts::IsTriggerSelected(AliVEvent *fInputEvent, Bool_t isMC)
1519 {
1520
1521         AliInputEventHandler *fInputHandler=(AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
1522
1523
1524         UInt_t isSelected = AliVEvent::kAny;
1525         TString periodName = ((AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask(fV0ReaderName.Data()))->GetPeriodName();
1526         //    cout <<   periodName.Data() << endl;
1527
1528         if (fInputHandler==NULL) return kFALSE;
1529         if( fInputHandler->GetEventSelection() || fInputEvent->IsA()==AliAODEvent::Class()) {
1530
1531                 TString firedTrigClass = fInputEvent->GetFiredTriggerClasses();
1532                 if (!fTriggerSelectedManually){
1533                         if (fPreSelCut) fOfflineTriggerMask = AliVEvent::kAny;
1534                         else {
1535                                 if (fIsHeavyIon == 1) fOfflineTriggerMask = AliVEvent::kMB | AliVEvent::kCentral | AliVEvent::kSemiCentral;
1536                                 else if (fIsHeavyIon == 2) fOfflineTriggerMask = AliVEvent::kINT7;
1537                                 else if (periodName.CompareTo("LHC11c") == 0 || periodName.CompareTo("LHC11d") == 0 || periodName.CompareTo("LHC11e") == 0 || periodName.CompareTo("LHC11f") == 0 || periodName.CompareTo("LHC11g") == 0  || periodName.CompareTo("LHC12a") == 0 || periodName.CompareTo("LHC12b") == 0 || periodName.CompareTo("LHC12c") == 0 || periodName.CompareTo("LHC12d") == 0 || periodName.CompareTo("LHC12f") == 0  || periodName.CompareTo("LHC12g") == 0  || periodName.CompareTo("LHC12h") == 0  || periodName.CompareTo("LHC12i") == 0  ||periodName.CompareTo("LHC13g") == 0 ) {
1538                                         fOfflineTriggerMask = AliVEvent::kINT7;
1539         //                              cout << "will take kINT7 as trigger mask" << endl;
1540                                 }
1541                                 else fOfflineTriggerMask = AliVEvent::kMB;
1542                         }
1543                 }
1544                 // Get the actual offline trigger mask for the event and AND it with the
1545                 // requested mask. If no mask requested select by default the event.
1546         //       if (fPreSelCut) cout << "Trigger selected from outside: "<< fTriggerSelectedManually <<"\t Offline Trigger mask for Precut: " << fOfflineTriggerMask << endl;
1547         //       else cout << "Trigger selected from outside: "<< fTriggerSelectedManually <<"\t Offline Trigger mask: " << fOfflineTriggerMask << endl;
1548
1549                 if (isMC) fOfflineTriggerMask = AliVEvent::kAny;
1550
1551                 if (fOfflineTriggerMask){
1552                         isSelected = fOfflineTriggerMask & fInputHandler->IsEventSelected();
1553
1554                         if (isSelected && !fPreSelCut){
1555 //                              cout << "Special trigger: "<< fSpecialTrigger << " initialized " << fEMCALTrigInitialized << endl;
1556                                 if (fSpecialTrigger == 5 || fSpecialTrigger == 8 || fSpecialTrigger == 9){ // EMCAL triggers
1557                                         if (!fEMCALTrigInitialized ) InitializeEMCALTrigger(fInputEvent);
1558                                         fTriggersEMCAL= GetTriggerList();
1559                                 }
1560                                 if (fSpecialSubTrigger>0 && !isMC){
1561                                         if (!firedTrigClass.Contains(fSpecialSubTriggerName.Data())) isSelected = 0;
1562                                 } else if (isMC){
1563                                         if (fSpecialTrigger == 5 || fSpecialTrigger == 8 || fSpecialTrigger == 9){ // EMCAL triggers
1564                                                 isSelected = 0;
1565 //                                              if (fTriggersEMCAL > 0)cout << "Special Trigger " << fSpecialTrigger << " triggers: " << fTriggersEMCAL << "    selected triggers: " << fTriggersEMCALSelected << " run number: " <<fInputEvent->GetRunNumber()<<endl;
1566                                                 if (fTriggersEMCAL&fTriggersEMCALSelected){
1567 //                                                      cout << "accepted ++++++++++++++++++++" << endl;
1568                                                         isSelected = 1;
1569                                                 }
1570                                         }
1571                                 }
1572                                 //if for specif centrality trigger selection
1573                                 if(fSpecialSubTrigger == 1){
1574                                         if(fSpecialSubTriggerName.Contains("|")){
1575                                                 TObjArray *ClassesList = fSpecialSubTriggerName.Tokenize("|");
1576                                                 for (Int_t i=0; i<ClassesList->GetEntriesFast();++i){
1577                                                         TObjString *NameClass = (TObjString*)ClassesList->At(i);
1578                                                         if (firedTrigClass.Contains(NameClass->GetString())) isSelected = 1;
1579 //                                                      cout << "|||||||| \t" << NameClass->GetString() << "\t ||||||||" << endl;
1580                                                 }
1581                                         } else if(fSpecialSubTriggerName.Contains("%")){
1582                                                 TObjArray *ClassesList = fSpecialSubTriggerName.Tokenize("%");
1583                                                 for (Int_t i=0; i<ClassesList->GetEntriesFast();++i){
1584                                                         TObjString *NameClass = (TObjString*)ClassesList->At(i);
1585                                                         if (firedTrigClass.Contains(NameClass->GetString())) isSelected = 1;
1586 //                                                      cout << "|||||||| \t" << NameClass->GetString() << "\t ||||||||" << endl;
1587                                                 }
1588                                         } else if(fSpecialSubTriggerName.Contains("&")){
1589                                                 TObjArray *ClassesList = fSpecialSubTriggerName.Tokenize("&");
1590                                                 TString CheckClass = "";
1591                                                 for (Int_t i=0; i<ClassesList->GetEntriesFast(); i++){
1592                                                         TObjString *NameClass = (TObjString*)ClassesList->At(i);
1593                                                         if (firedTrigClass.Contains(NameClass->GetString())) CheckClass+="1";
1594                                                         else CheckClass+="0";
1595                                                 }
1596                                                 if(CheckClass.Contains("0")) isSelected = 0;
1597 //                                              cout << "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << endl;
1598                                         }
1599                                         else if(firedTrigClass.Contains(fSpecialSubTriggerName.Data())) isSelected = 1;
1600                                 }
1601                         }
1602                 }
1603         }
1604         fIsSDDFired = !(fInputHandler->IsEventSelected() & AliVEvent::kFastOnly);
1605
1606         // Fill Histogram
1607         if(hTriggerClass){
1608                 if (fIsSDDFired) hTriggerClass->Fill(33);
1609                 if (fInputHandler->IsEventSelected() & AliVEvent::kMB)hTriggerClass->Fill(0);
1610                 if (fInputHandler->IsEventSelected() & AliVEvent::kINT7)hTriggerClass->Fill(1);
1611                 if (fInputHandler->IsEventSelected() & AliVEvent::kMUON)hTriggerClass->Fill(2);
1612                 if (fInputHandler->IsEventSelected() & AliVEvent::kHighMult)hTriggerClass->Fill(3);
1613                 if (fInputHandler->IsEventSelected() & AliVEvent::kEMC1)hTriggerClass->Fill(4);
1614                 if (fInputHandler->IsEventSelected() & AliVEvent::kCINT5)hTriggerClass->Fill(5);
1615                 if (fInputHandler->IsEventSelected() & AliVEvent::kCMUS5)hTriggerClass->Fill(6);
1616         //       if (fInputHandler->IsEventSelected() & AliVEvent::kMUSPB)hTriggerClass->Fill(6);
1617                 if (fInputHandler->IsEventSelected() & AliVEvent::kMUSH7)hTriggerClass->Fill(7);
1618         //       if (fInputHandler->IsEventSelected() & AliVEvent::kMUSHPB)hTriggerClass->Fill(7);
1619                 if (fInputHandler->IsEventSelected() & AliVEvent::kMUL7)hTriggerClass->Fill(8);
1620         //       if (fInputHandler->IsEventSelected() & AliVEvent::kMuonLikePB)hTriggerClass->Fill(8);
1621                 if (fInputHandler->IsEventSelected() & AliVEvent::kMUU7)hTriggerClass->Fill(9);
1622         //       if (fInputHandler->IsEventSelected() & AliVEvent::kMuonUnlikePB)hTriggerClass->Fill(9);
1623                 if (fInputHandler->IsEventSelected() & AliVEvent::kEMC7)hTriggerClass->Fill(10);
1624         //       if (fInputHandler->IsEventSelected() & AliVEvent::kEMC8)hTriggerClass->Fill(10);
1625                 if (fInputHandler->IsEventSelected() & AliVEvent::kMUS7)hTriggerClass->Fill(11);
1626                 if (fInputHandler->IsEventSelected() & AliVEvent::kPHI1)hTriggerClass->Fill(12);
1627                 if (fInputHandler->IsEventSelected() & AliVEvent::kPHI7)hTriggerClass->Fill(13);
1628         //       if (fInputHandler->IsEventSelected() & AliVEvent::kPHI8)hTriggerClass->Fill(13);
1629         //       if (fInputHandler->IsEventSelected() & AliVEvent::kPHOSPb)hTriggerClass->Fill(13);
1630                 if (fInputHandler->IsEventSelected() & AliVEvent::kEMCEJE)hTriggerClass->Fill(14);
1631                 if (fInputHandler->IsEventSelected() & AliVEvent::kEMCEGA)hTriggerClass->Fill(15);
1632                 if (fInputHandler->IsEventSelected() & AliVEvent::kCentral)hTriggerClass->Fill(16);
1633                 if (fInputHandler->IsEventSelected() & AliVEvent::kSemiCentral)hTriggerClass->Fill(17);
1634                 if (fInputHandler->IsEventSelected() & AliVEvent::kDG5)hTriggerClass->Fill(18);
1635                 if (fInputHandler->IsEventSelected() & AliVEvent::kZED)hTriggerClass->Fill(19);
1636                 if (fInputHandler->IsEventSelected() & AliVEvent::kSPI7)hTriggerClass->Fill(20);
1637         //       if (fInputHandler->IsEventSelected() & AliVEvent::kSPI)hTriggerClass->Fill(20);
1638                 if (fInputHandler->IsEventSelected() & AliVEvent::kINT8)hTriggerClass->Fill(21);
1639                 if (fInputHandler->IsEventSelected() & AliVEvent::kMuonSingleLowPt8)hTriggerClass->Fill(22);
1640                 if (fInputHandler->IsEventSelected() & AliVEvent::kMuonSingleHighPt8)hTriggerClass->Fill(23);
1641                 if (fInputHandler->IsEventSelected() & AliVEvent::kMuonLikeLowPt8)hTriggerClass->Fill(24);
1642                 if (fInputHandler->IsEventSelected() & AliVEvent::kMuonUnlikeLowPt8)hTriggerClass->Fill(25);
1643                 if (fInputHandler->IsEventSelected() & AliVEvent::kMuonUnlikeLowPt0)hTriggerClass->Fill(26);
1644                 if (fInputHandler->IsEventSelected() & AliVEvent::kUserDefined)hTriggerClass->Fill(27);
1645                 if (fInputHandler->IsEventSelected() & AliVEvent::kTRD)hTriggerClass->Fill(28);
1646                 if (fInputHandler->IsEventSelected() & AliVEvent::kFastOnly)hTriggerClass->Fill(29);
1647                 if (fInputHandler->IsEventSelected() & AliVEvent::kAnyINT)hTriggerClass->Fill(30);
1648                 if (fInputHandler->IsEventSelected() & AliVEvent::kAny)hTriggerClass->Fill(31);
1649                 if (!fInputHandler->IsEventSelected()) hTriggerClass->Fill(34);
1650         }
1651
1652         if(hTriggerClassSelected && isSelected){
1653                 if (!fIsSDDFired) hTriggerClassSelected->Fill(33);
1654                 if (fInputHandler->IsEventSelected() & AliVEvent::kMB)hTriggerClassSelected->Fill(0);
1655                 if (fInputHandler->IsEventSelected() & AliVEvent::kINT7)hTriggerClassSelected->Fill(1);
1656                 if (fInputHandler->IsEventSelected() & AliVEvent::kMUON)hTriggerClassSelected->Fill(2);
1657                 if (fInputHandler->IsEventSelected() & AliVEvent::kHighMult)hTriggerClassSelected->Fill(3);
1658                 if (fInputHandler->IsEventSelected() & AliVEvent::kEMC1)hTriggerClassSelected->Fill(4);
1659                 if (fInputHandler->IsEventSelected() & AliVEvent::kCINT5)hTriggerClassSelected->Fill(5);
1660                 if (fInputHandler->IsEventSelected() & AliVEvent::kCMUS5)hTriggerClassSelected->Fill(6);
1661         //       if (fInputHandler->IsEventSelected() & AliVEvent::kMUSPB)hTriggerClassSelected->Fill(6);
1662                 if (fInputHandler->IsEventSelected() & AliVEvent::kMUSH7)hTriggerClassSelected->Fill(7);
1663         //       if (fInputHandler->IsEventSelected() & AliVEvent::kMUSHPB)hTriggerClassSelected->Fill(7);
1664                 if (fInputHandler->IsEventSelected() & AliVEvent::kMUL7)hTriggerClassSelected->Fill(8);
1665         //       if (fInputHandler->IsEventSelected() & AliVEvent::kMuonLikePB)hTriggerClassSelected->Fill(8);
1666                 if (fInputHandler->IsEventSelected() & AliVEvent::kMUU7)hTriggerClassSelected->Fill(9);
1667         //       if (fInputHandler->IsEventSelected() & AliVEvent::kMuonUnlikePB)hTriggerClassSelected->Fill(9);
1668                 if (fInputHandler->IsEventSelected() & AliVEvent::kEMC7)hTriggerClassSelected->Fill(10);
1669         //       if (fInputHandler->IsEventSelected() & AliVEvent::kEMC8)hTriggerClassSelected->Fill(10);
1670                 if (fInputHandler->IsEventSelected() & AliVEvent::kMUS7)hTriggerClassSelected->Fill(11);
1671                 if (fInputHandler->IsEventSelected() & AliVEvent::kPHI1)hTriggerClassSelected->Fill(12);
1672                 if (fInputHandler->IsEventSelected() & AliVEvent::kPHI7)hTriggerClassSelected->Fill(13);
1673         //       if (fInputHandler->IsEventSelected() & AliVEvent::kPHI8)hTriggerClassSelected->Fill(13);
1674         //       if (fInputHandler->IsEventSelected() & AliVEvent::kPHOSPb)hTriggerClassSelected->Fill(13);
1675                 if (fInputHandler->IsEventSelected() & AliVEvent::kEMCEJE)hTriggerClassSelected->Fill(14);
1676                 if (fInputHandler->IsEventSelected() & AliVEvent::kEMCEGA)hTriggerClassSelected->Fill(15);
1677                 if (fInputHandler->IsEventSelected() & AliVEvent::kCentral)hTriggerClassSelected->Fill(16);
1678                 if (fInputHandler->IsEventSelected() & AliVEvent::kSemiCentral)hTriggerClassSelected->Fill(17);
1679                 if (fInputHandler->IsEventSelected() & AliVEvent::kDG5)hTriggerClassSelected->Fill(18);
1680                 if (fInputHandler->IsEventSelected() & AliVEvent::kZED)hTriggerClassSelected->Fill(19);
1681                 if (fInputHandler->IsEventSelected() & AliVEvent::kSPI7)hTriggerClassSelected->Fill(20);
1682         //       if (fInputHandler->IsEventSelected() & AliVEvent::kSPI)hTriggerClassSelected->Fill(20);
1683                 if (fInputHandler->IsEventSelected() & AliVEvent::kINT8)hTriggerClassSelected->Fill(21);
1684                 if (fInputHandler->IsEventSelected() & AliVEvent::kMuonSingleLowPt8)hTriggerClassSelected->Fill(22);
1685                 if (fInputHandler->IsEventSelected() & AliVEvent::kMuonSingleHighPt8)hTriggerClassSelected->Fill(23);
1686                 if (fInputHandler->IsEventSelected() & AliVEvent::kMuonLikeLowPt8)hTriggerClassSelected->Fill(24);
1687                 if (fInputHandler->IsEventSelected() & AliVEvent::kMuonUnlikeLowPt8)hTriggerClassSelected->Fill(25);
1688                 if (fInputHandler->IsEventSelected() & AliVEvent::kMuonUnlikeLowPt0)hTriggerClassSelected->Fill(26);
1689                 if (fInputHandler->IsEventSelected() & AliVEvent::kUserDefined)hTriggerClassSelected->Fill(27);
1690                 if (fInputHandler->IsEventSelected() & AliVEvent::kTRD)hTriggerClassSelected->Fill(28);
1691                 if (fInputHandler->IsEventSelected() & AliVEvent::kFastOnly)hTriggerClassSelected->Fill(29);
1692                 if (fInputHandler->IsEventSelected() & AliVEvent::kAnyINT)hTriggerClassSelected->Fill(30);
1693                 if (fInputHandler->IsEventSelected() & AliVEvent::kAny)hTriggerClassSelected->Fill(31);
1694         }
1695
1696         if(!isSelected)return kFALSE;
1697         return kTRUE;
1698
1699 }
1700
1701 ///________________________________________________________________________
1702 TString AliConvEventCuts::GetCutNumber(){
1703    // returns TString with current cut number
1704    TString a(kNCuts);
1705    for(Int_t ii=0;ii<kNCuts;ii++){
1706       a.Append(Form("%d",fCuts[ii]));
1707    }
1708    return a;
1709 }
1710
1711 ///________________________________________________________________________
1712 void AliConvEventCuts::GetNotRejectedParticles(Int_t rejection, TList *HeaderList, AliVEvent *MCEvent){
1713
1714         TString periodName = ((AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()->GetTask(fV0ReaderName.Data()))->GetPeriodName();
1715
1716         if(fNotRejectedStart){
1717                 delete[] fNotRejectedStart;
1718                 fNotRejectedStart = NULL;
1719         }
1720         if(fNotRejectedEnd){
1721                 delete[] fNotRejectedEnd;
1722                 fNotRejectedEnd = NULL;
1723         }
1724         if(fGeneratorNames){
1725                 delete[] fGeneratorNames;
1726                 fGeneratorNames = NULL;
1727         }
1728
1729         if(rejection == 0) return; // No Rejection
1730
1731         AliGenCocktailEventHeader *cHeader = 0x0;
1732         AliAODMCHeader *cHeaderAOD = 0x0;
1733         Bool_t headerFound = kFALSE;
1734         AliStack *fMCStack = 0x0;
1735         TClonesArray *fMCStackAOD = 0x0;
1736         if(MCEvent->IsA()==AliMCEvent::Class()){
1737                 if(dynamic_cast<AliMCEvent*>(MCEvent)){
1738                         cHeader = dynamic_cast<AliGenCocktailEventHeader*>(dynamic_cast<AliMCEvent*>(MCEvent)->GenEventHeader());
1739                         if(cHeader) headerFound = kTRUE;
1740                         fMCStack = dynamic_cast<AliStack*>(dynamic_cast<AliMCEvent*>(MCEvent)->Stack());
1741                 }
1742         }
1743         if(MCEvent->IsA()==AliAODEvent::Class()){ // MCEvent is a AODEvent in case of AOD
1744                 cHeaderAOD = dynamic_cast<AliAODMCHeader*>(MCEvent->FindListObject(AliAODMCHeader::StdBranchName()));
1745                 fMCStackAOD = dynamic_cast<TClonesArray*>(MCEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1746                 if(cHeaderAOD) headerFound = kTRUE;
1747         }
1748
1749 //      cout << "event starts here" << endl;
1750         if(headerFound){
1751                 TList *genHeaders = 0x0;
1752                 if(cHeader) genHeaders = cHeader->GetHeaders();
1753                 if(cHeaderAOD){
1754                         genHeaders = cHeaderAOD->GetCocktailHeaders();
1755                         if(genHeaders->GetEntries()==1){
1756                                 SetRejectExtraSignalsCut(0);
1757                                 return;
1758                         }
1759                 }
1760                 AliGenEventHeader* gh = 0;
1761                 fnHeaders = 0;
1762                 Int_t firstindexA = 0;
1763                 Int_t lastindexA =  -1;
1764                 if(rejection == 1 || rejection == 3) fnHeaders = 1; // MinBiasHeader
1765                 if(rejection == 2){ // TList of Headers Names
1766                         for(Int_t i = 0; i<genHeaders->GetEntries();i++){
1767                                 gh = (AliGenEventHeader*)genHeaders->At(i);
1768                                 TString GeneratorName = gh->GetName();
1769                                 lastindexA = lastindexA + gh->NProduced();
1770 //                              cout << i << "\t" << GeneratorName.Data() << endl;
1771                                 for(Int_t j = 0; j<HeaderList->GetEntries();j++){
1772                                         TString GeneratorInList = ((TObjString*)HeaderList->At(j))->GetString();
1773 //                                      cout << GeneratorInList.Data() << endl;
1774                                         if(GeneratorName.CompareTo(GeneratorInList) == 0){
1775 //                                              cout << "accepted" << endl;
1776                                                 if (GeneratorInList.CompareTo("PARAM") == 0 || GeneratorInList.CompareTo("BOX") == 0 ){
1777                                                         if(fMCStack){
1778                                                                 if (periodName.CompareTo("LHC14a1b")==0 || periodName.CompareTo("LHC14a1c")==0 ){
1779                                                                         if (fMCStack->Particle(firstindexA)->GetPdgCode() == fAddedSignalPDGCode ) {
1780                                                                                 if (gh->NProduced() > 10 && fMCStack->Particle(firstindexA+10)->GetPdgCode() == fAddedSignalPDGCode ){
1781 //                                                                                      cout << "cond 1: "<< fnHeaders << endl;
1782                                                                                         fnHeaders++;
1783                                                                                         continue;
1784                                                                                 }
1785                                                                                 continue;
1786                                                                         }
1787                                                                 } else {
1788 //                                                                      cout << "cond 2: " << fnHeaders << endl;
1789                                                                         fnHeaders++;
1790                                                                         continue;
1791
1792                                                                 }
1793                                                         }
1794                                                         if ( fMCStackAOD){
1795                                                                 AliAODMCParticle *aodMCParticle = static_cast<AliAODMCParticle*>(fMCStackAOD->At(firstindexA));
1796                                                                 if (periodName.CompareTo("LHC14a1b")==0 || periodName.CompareTo("LHC14a1c")==0 ){
1797                                                                         if (  aodMCParticle->GetPdgCode() == fAddedSignalPDGCode ){
1798                                                                                 if (gh->NProduced() > 10){
1799                                                                                         AliAODMCParticle *aodMCParticle2 = static_cast<AliAODMCParticle*>(fMCStackAOD->At(firstindexA+10));
1800                                                                                         if (  aodMCParticle2->GetPdgCode() == fAddedSignalPDGCode ){
1801 //                                                                                              cout << "cond 1: " << fnHeaders << endl;
1802                                                                                                 fnHeaders++;
1803                                                                                                 continue;
1804                                                                                         }
1805                                                                                 }
1806                                                                                 continue;
1807                                                                         }
1808                                                                 } else {
1809 //                                                                      cout << "cond 2: " << fnHeaders << endl;
1810                                                                         fnHeaders++;
1811                                                                         continue;
1812                                                                 }
1813                                                         }
1814                                                         continue;
1815                                                 }
1816 //                                              cout << "cond 3: "<< fnHeaders << endl;
1817                                                 fnHeaders++;
1818                                                 continue;
1819                                         }
1820                                 }
1821                                 firstindexA = firstindexA + gh->NProduced();
1822                         }
1823                 }
1824 //              cout << "number of headers: " <<fnHeaders << endl;
1825
1826                 fNotRejectedStart = new Int_t[fnHeaders];
1827                 fNotRejectedEnd = new Int_t[fnHeaders];
1828                 fGeneratorNames = new TString[fnHeaders];
1829
1830                 if(rejection == 1 || rejection == 3){
1831                         fNotRejectedStart[0] = 0;
1832                         fNotRejectedEnd[0] = ((AliGenEventHeader*)genHeaders->At(0))->NProduced()-1;
1833                         fGeneratorNames[0] = ((AliGenEventHeader*)genHeaders->At(0))->GetName();
1834                         return;
1835                 }
1836
1837                 Int_t firstindex = 0;
1838                 Int_t lastindex =  -1;
1839                 Int_t number = 0;
1840
1841                 for(Int_t i = 0; i<genHeaders->GetEntries();i++){
1842                         gh = (AliGenEventHeader*)genHeaders->At(i);
1843                         TString GeneratorName = gh->GetName();
1844                         lastindex = lastindex + gh->NProduced();
1845                         for(Int_t j = 0; j<HeaderList->GetEntries();j++){
1846                                 TString GeneratorInList = ((TObjString*)HeaderList->At(j))->GetString();
1847 //                              cout << i << "\t" << GeneratorName.Data() << endl;
1848                                 if(GeneratorName.CompareTo(GeneratorInList) == 0){
1849                                         if (GeneratorInList.CompareTo("PARAM") == 0 || GeneratorInList.CompareTo("BOX") == 0 ){
1850                                                 if(fMCStack){
1851                                                         if (periodName.CompareTo("LHC14a1b")==0 || periodName.CompareTo("LHC14a1c")==0 ){
1852                                                                 if (fMCStack->Particle(firstindex)->GetPdgCode() == fAddedSignalPDGCode ) {
1853                                                                         cout << "produced " << gh->NProduced() << " with box generator" << endl;
1854                                                                         if (gh->NProduced() > 10 && fMCStack->Particle(firstindex+10)->GetPdgCode() == fAddedSignalPDGCode){
1855 //                                                                              cout << "one of them was a pi0 or eta" <<  endl;
1856                                                                                 fNotRejectedStart[number] = firstindex;
1857                                                                                 fNotRejectedEnd[number] = lastindex;
1858                                                                                 fGeneratorNames[number] = GeneratorName;
1859                                                                                 number++;
1860 //                                                                              cout << "Number of particles produced for: " << i << "\t" << GeneratorName.Data() << "\t" << lastindex-firstindex+1 << endl;
1861                                                                                 continue;
1862                                                                         }
1863                                                                 }
1864                                                         } else {
1865                                                                 fNotRejectedStart[number] = firstindex;
1866                                                                 fNotRejectedEnd[number] = lastindex;
1867                                                                 fGeneratorNames[number] = GeneratorName;
1868                                                                 number++;
1869                                                                 continue;
1870                                                         }
1871                                                 }
1872                                                 if ( fMCStackAOD){
1873                                                         AliAODMCParticle *aodMCParticle = static_cast<AliAODMCParticle*>(fMCStackAOD->At(firstindex));
1874                                                         if (periodName.CompareTo("LHC14a1b")==0 || periodName.CompareTo("LHC14a1c")==0 ){
1875                                                                 if (  aodMCParticle->GetPdgCode() == fAddedSignalPDGCode ){
1876                                                                         if (gh->NProduced() > 10) {
1877                                                                                 AliAODMCParticle *aodMCParticle2 = static_cast<AliAODMCParticle*>(fMCStackAOD->At(firstindex+10));
1878                                                                                 if ( aodMCParticle2->GetPdgCode() == fAddedSignalPDGCode ){
1879                                                                                         fNotRejectedEnd[number] = lastindex;
1880                                                                                         fNotRejectedStart[number] = firstindex;
1881                                                                                         fGeneratorNames[number] = GeneratorName;
1882                                                                                         number++;
1883                                                                                 }
1884                                                                                 continue;
1885                                                                         }
1886                                                                 }
1887                                                         } else {
1888                                                                 fNotRejectedStart[number] = firstindex;
1889                                                                 fNotRejectedEnd[number] = lastindex;
1890                                                                 fGeneratorNames[number] = GeneratorName;
1891                                                                 number++;
1892                                                                 continue;
1893                                                         }
1894                                                 }
1895                                                 continue;
1896                                         } else {
1897                                                 fNotRejectedStart[number] = firstindex;
1898                                                 fNotRejectedEnd[number] = lastindex;
1899                                                 fGeneratorNames[number] = GeneratorName;
1900 //                                              cout << "Number of particles produced for: " << i << "\t" << GeneratorName.Data() << "\t" << lastindex-firstindex+1 << endl;
1901                                                 number++;
1902                                                 continue;
1903                                         }
1904
1905                                 }
1906                         }
1907                         firstindex = firstindex + gh->NProduced();
1908                 }
1909 //              for (Int_t i = 0; i < number; i++){
1910 //                      cout << i << "\t" <<fGeneratorNames[i] << "\t" << fNotRejectedStart[i] << "\t" <<fNotRejectedEnd[i] << endl;
1911 //              }
1912
1913         } else { // No Cocktail Header Found
1914                 fNotRejectedStart = new Int_t[1];
1915                 fNotRejectedEnd = new Int_t[1];
1916
1917                 fnHeaders = 1;
1918                 fNotRejectedStart[0] = 0;
1919                 fNotRejectedEnd[0] = static_cast<AliMCEvent*>(MCEvent)->Stack()->GetNprimary()-1;
1920                 fGeneratorNames = new TString[1];
1921                 fGeneratorNames[0] = "NoCocktailGeneratorFound";
1922                 SetRejectExtraSignalsCut(0);
1923         }
1924
1925 }
1926
1927 //_________________________________________________________________________
1928 Int_t AliConvEventCuts::IsParticleFromBGEvent(Int_t index, AliStack *MCStack, AliVEvent *InputEvent){
1929
1930         if(index < 0) return 0; // No Particle
1931
1932         Int_t accepted = 0;
1933         if(!InputEvent || InputEvent->IsA()==AliESDEvent::Class()){
1934                 if( index >= MCStack->GetNprimary()){ // Secondary Particle
1935                         if( ((TParticle*)MCStack->Particle(index))->GetMother(0) < 0) return 1; // Secondary Particle without Mother??
1936                         return IsParticleFromBGEvent(((TParticle*)MCStack->Particle(index))->GetMother(0),MCStack,InputEvent);
1937                 }
1938                 for(Int_t i = 0;i<fnHeaders;i++){
1939                         if(index >= fNotRejectedStart[i] && index <= fNotRejectedEnd[i]){
1940                                 accepted = 1;
1941                                 if(i == 0) accepted = 2; // MB Header
1942                         }
1943                 }
1944         }
1945         else if(InputEvent->IsA()==AliAODEvent::Class()){
1946                 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(InputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
1947                 if (AODMCTrackArray){
1948                         AliAODMCParticle *aodMCParticle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(index));
1949                         if(!aodMCParticle) return 1; // Photon Without a Mother ? --> Accepted
1950                         if(!aodMCParticle->IsPrimary()){
1951                                 if( aodMCParticle->GetMother() < 0) return 1;// Secondary Particle without Mother??
1952                                 return IsParticleFromBGEvent(aodMCParticle->GetMother(),MCStack,InputEvent);
1953                         }
1954                         index = abs(static_cast<AliAODMCParticle*>(AODMCTrackArray->At(index))->GetLabel());
1955                         for(Int_t i = 0;i<fnHeaders;i++){
1956                                 if(index >= fNotRejectedStart[i] && index <= fNotRejectedEnd[i]){
1957                                         accepted = 1;
1958                                         if(i == 0) accepted = 2; // MB Header
1959                                 }
1960                         }
1961                 }
1962         }
1963
1964         return accepted;
1965 }
1966
1967 //_________________________________________________________________________
1968 Int_t AliConvEventCuts::IsEventAcceptedByCut(AliConvEventCuts *ReaderCuts, AliVEvent *InputEvent, AliMCEvent *MCEvent, Int_t isHeavyIon, Bool_t isEMCALAnalysis){
1969
1970         Bool_t isMC = kFALSE;
1971         if (MCEvent){isMC = kTRUE;}
1972
1973         if ( !IsTriggerSelected(InputEvent, isMC) )
1974                 return 3;
1975
1976         if(isHeavyIon != 0 && !(IsCentralitySelected(InputEvent,MCEvent)))
1977                 return 1; // Check Centrality --> Not Accepted => eventQuality = 1
1978
1979         if(isHeavyIon == 0 && GetIsFromPileup()){
1980                 if(InputEvent->IsPileupFromSPD(3,0.8,3.,2.,5.)){
1981                         return 6; // Check Pileup --> Not Accepted => eventQuality = 6
1982                 }
1983         }
1984
1985         Bool_t hasV0And = ReaderCuts->HasV0AND();
1986         Bool_t isSDDFired = ReaderCuts->IsSDDFired();
1987
1988         if( ( (IsSpecialTrigger() == 0 && IsSpecialSubTrigger() == 1) || (IsSpecialTrigger() == 1 && IsSpecialSubTrigger() == 1) ) && !isSDDFired && !MCEvent)
1989         //if V0OR with SDD requested or V0AND with SDD request but the SDD has not fired
1990         return 7; // V0 with SDD requested but no fired
1991
1992         if( ( (IsSpecialTrigger() == 1 && IsSpecialSubTrigger() == 0) || (IsSpecialTrigger() == 1 && IsSpecialSubTrigger() == 1) ) && !hasV0And)
1993         //if V0AND (only) or V0AND with SDD requested but V0AND requested but no fired
1994         return 8; // V0AND requested but no fired
1995
1996
1997         if( (IsSpecialTrigger() == 2 || IsSpecialTrigger() == 3) && !isSDDFired && !MCEvent)
1998                 return 7; // With SDD requested but no fired
1999
2000         if( (IsSpecialTrigger() == 1 || IsSpecialTrigger() == 3) && !hasV0And)
2001                 return 8; // V0AND requested but no fired
2002
2003         // Special EMCAL checks due to hardware issues in LHC11a
2004         if (isEMCALAnalysis || IsSpecialTrigger() == 5 || IsSpecialTrigger() == 8 || IsSpecialTrigger() == 9 ){
2005                 Int_t runnumber = InputEvent->GetRunNumber();
2006                 if ((runnumber>=144871) && (runnumber<=146860)) {
2007
2008                         AliVCaloCells *cells   = InputEvent->GetEMCALCells();
2009                         const Short_t nCells   = cells->GetNumberOfCells();
2010
2011                         if (InputEvent->IsA()==AliESDEvent::Class()) AliAnalysisManager::GetAnalysisManager()->LoadBranch("EMCALCells.");
2012
2013                         AliInputEventHandler *fInputHandler=(AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
2014                         if (!fInputHandler) return 3;
2015
2016                         // count cells above threshold
2017                         Int_t nCellCount[12] = {0,0,0,0,0,0,0,0,0,0,0,0};
2018                         for(Int_t iCell=0; iCell<nCells; ++iCell) {
2019                                 Short_t cellId = cells->GetCellNumber(iCell);
2020                                 Double_t cellE = cells->GetCellAmplitude(cellId);
2021                                 Int_t sm       = cellId / (24*48);
2022                                 if (cellE>0.1) ++nCellCount[sm];
2023                         }
2024
2025                         Bool_t fIsLedEvent = kFALSE;
2026                         if (nCellCount[4] > 100) {
2027                                 fIsLedEvent = kTRUE;
2028                         } else {
2029                                 if ((runnumber>=146858) && (runnumber<=146860)) {
2030                                         if ((fInputHandler->IsEventSelected() & AliVEvent::kMB) && (nCellCount[3]>=21))
2031                                                 fIsLedEvent = kTRUE;
2032                                         else if ((fInputHandler->IsEventSelected() & AliVEvent::kEMC1) && (nCellCount[3]>=35))
2033                                                 fIsLedEvent = kTRUE;
2034                                 }
2035                         }
2036                         if (fIsLedEvent) {
2037                                 return 9;
2038                         }
2039                 }
2040         }
2041
2042         if(hCentrality)hCentrality->Fill(GetCentrality(InputEvent));
2043         if(hCentralityVsNumberOfPrimaryTracks)
2044                 hCentralityVsNumberOfPrimaryTracks->Fill(GetCentrality(InputEvent),
2045                                                                                                 ((AliV0ReaderV1*)AliAnalysisManager::GetAnalysisManager()
2046                                                                                                 ->GetTask(fV0ReaderName.Data()))->GetNumberOfPrimaryTracks());
2047
2048         return 0;
2049 }
2050
2051 //_________________________________________________________________________
2052 Float_t AliConvEventCuts::GetWeightForMeson(TString period, Int_t index, AliStack *MCStack, AliVEvent *InputEvent){
2053         if (!( period.Contains("LHC13d2")                       || period.Contains("LHC14a1")                                   || period.CompareTo("LHC13e7") == 0             || period.Contains("LHC13b2_efix")              ||
2054                    period.CompareTo("LHC14b2") == 0     || period.Contains("LHC14e2")                                   || period.CompareTo("LHC12f1a") == 0            || period.CompareTo("LHC12f1b") == 0    ||
2055                    period.CompareTo("LHC12i3") == 0)) return 1.;
2056         Int_t kCaseGen = 0;
2057         for (Int_t i = 0; i < fnHeaders; i++){
2058                 if (index >= fNotRejectedStart[i] && index < fNotRejectedEnd[i]+1){
2059                         if (period.Contains("LHC13d2")          || period.CompareTo("LHC13e7") == 0                     || period.Contains("LHC13b2_efix")              || period.Contains("LHC14a1")                   ||
2060                                 period.CompareTo("LHC14b2") == 0 || period.Contains("LHC14e2")                                  || period.CompareTo("LHC12f1a") == 0            || period.CompareTo("LHC12f1b") == 0    ||
2061                                 period.CompareTo("LHC12i3") == 0){
2062                                 kCaseGen = 1;
2063                         }
2064                 }
2065         }
2066         if (kCaseGen == 0) return 1;
2067
2068         Double_t mesonPt = 0;
2069         Double_t mesonMass = 0;
2070         Int_t PDGCode = 0;
2071         if(!InputEvent || InputEvent->IsA()==AliESDEvent::Class()){
2072                 mesonPt = ((TParticle*)MCStack->Particle(index))->Pt();
2073                 mesonMass = ((TParticle*)MCStack->Particle(index))->GetCalcMass();
2074                 PDGCode = ((TParticle*)MCStack->Particle(index))->GetPdgCode();
2075         } else if(InputEvent->IsA()==AliAODEvent::Class()){
2076                 TClonesArray *AODMCTrackArray = dynamic_cast<TClonesArray*>(InputEvent->FindListObject(AliAODMCParticle::StdBranchName()));
2077                 if (AODMCTrackArray){
2078                         AliAODMCParticle *aodMCParticle = static_cast<AliAODMCParticle*>(AODMCTrackArray->At(index));
2079                         mesonPt = aodMCParticle->Pt();
2080                         mesonMass = aodMCParticle->GetCalcMass();
2081                         PDGCode = aodMCParticle->GetPdgCode();
2082                 } else {
2083                         return 1;
2084                 }
2085         }
2086
2087         Float_t functionResultMC = 1.;
2088         if ( PDGCode ==  111 && fDoReweightHistoMCPi0 && hReweightMCHistPi0!= 0x0){
2089                 functionResultMC = hReweightMCHistPi0->Interpolate(mesonPt);
2090         }
2091         if ( PDGCode ==  221 && fDoReweightHistoMCEta && hReweightMCHistEta!= 0x0){
2092                 functionResultMC = hReweightMCHistEta->Interpolate(mesonPt);
2093         }
2094         if ( PDGCode ==  310 && fDoReweightHistoMCK0s && hReweightMCHistK0s!= 0x0){
2095                 functionResultMC = hReweightMCHistK0s->Interpolate(mesonPt);
2096         }
2097
2098         Float_t functionResultData = 1;
2099         if ( PDGCode ==  111 && fDoReweightHistoMCPi0 && fFitDataPi0!= 0x0){
2100                 functionResultData = fFitDataPi0->Eval(mesonPt);
2101         }
2102         if ( PDGCode ==  221 && fDoReweightHistoMCEta && fFitDataEta!= 0x0){
2103                 functionResultData = fFitDataEta->Eval(mesonPt);
2104         }
2105         if ( PDGCode ==  310 && fDoReweightHistoMCK0s && fFitDataK0s!= 0x0){
2106                 functionResultData = fFitDataK0s->Eval(mesonPt);
2107         }
2108
2109         Double_t weight = 1;
2110         if (PDGCode ==  111 || PDGCode ==  221){
2111                 if (functionResultData != 0. && functionResultMC != 0. && isfinite(functionResultData) && isfinite(functionResultMC)){
2112                         weight = functionResultData/functionResultMC;
2113                         if ( kCaseGen == 3){
2114                                 if (PDGCode ==  111){
2115                                 if (!(fDoReweightHistoMCPi0 && hReweightMCHistPi0!= 0x0 && PDGCode ==  111)){
2116                                         weight = 1.;
2117                                 }
2118                                 }
2119                                 if (PDGCode ==  221){
2120                                 if (!(fDoReweightHistoMCEta && hReweightMCHistEta!= 0x0 && PDGCode ==  221)){
2121                                         weight = 1.;
2122                                 }
2123                                 }
2124                         }
2125                         if (!isfinite(functionResultData)) weight = 1.;
2126                         if (!isfinite(weight)) weight = 1.;
2127                 }
2128         } else if (PDGCode ==  310 && functionResultMC != 0 && isfinite(functionResultMC)){
2129                 weight = functionResultMC;
2130         }
2131         return weight;
2132 }
2133
2134
2135 ///________________________________________________________________________
2136 void AliConvEventCuts::GetCorrectEtaShiftFromPeriod(TString periodName){
2137
2138    if(periodName.CompareTo("LHC12g") == 0 || //pilot run 2012
2139       periodName.CompareTo("LHC13b") == 0 || //mainly minimum bias
2140       periodName.CompareTo("LHC13c") == 0 || //mainly minimum bias
2141       periodName.CompareTo("LHC13d") == 0 || //mainly triggered
2142       periodName.CompareTo("LHC13e") == 0 || //mainly triggered
2143       periodName.CompareTo("LHC13c3") == 0 || //MC Starlight, anchor LHC13d+e
2144       periodName.CompareTo("LHC13c2") == 0 || //MC Starlight, coherent J/Psi, UPC muon anchor LHC13d+e
2145       periodName.CompareTo("LHC13b4") == 0 || //MC Pythia 6 (Jet-Jet), anchor LHC13b
2146       periodName.CompareTo("LHC13b2_fix_1") == 0 || //MC DPMJET, anchr LHC13b+c
2147       periodName.CompareTo("LHC13b2_efix_p1") == 0 || //MC DPMJET, anchr LHC13b+c
2148       periodName.CompareTo("LHC13b2_efix_p2") == 0 || //MC DPMJET, anchr LHC13b+c
2149       periodName.CompareTo("LHC13b2_efix_p3") == 0 || //MC DPMJET, anchr LHC13b+c
2150       periodName.CompareTo("LHC13b2_efix_p4") == 0 || //MC DPMJET, anchr LHC13b+c
2151       periodName.CompareTo("LHC13e7") == 0 || //MC DPMJET, anchr LHC13b+c
2152       periodName.CompareTo("LHC13b3") == 0 || //MC HIJING, weighted to number of events per run, anchor LHC13b
2153       periodName.CompareTo("LHC13b2") == 0 ||  // MC DPMJET, wrong energy, anchor LHC13b
2154       periodName.CompareTo("LHC13b2_plus") == 0 || // MC DPMJET, weighted to number event per run, anchor LHC13b
2155       periodName.CompareTo("LHC13c1_bis") == 0 || // MC AMPT fast generation, pT hardbin, anchor ?
2156       periodName.CompareTo("LHC13c1") == 0 || // MC AMPT fast generation, anchor ?
2157       periodName.CompareTo("LHC13b1") == 0 || // MC DPMJET, fragments, with fixed label 0, anchor LHC12g
2158       periodName.CompareTo("LHC12g4b_fix") == 0 || // MC DPMJET, with fixed label 0, anchor LHC12g
2159       periodName.CompareTo("LHC12g1_fix") == 0 || // MC ?, with fixed label 0, anchor LHC12g
2160       periodName.CompareTo("LHC12g4c") == 0 || // MC DPMJET, shifted vertex runs, anchor LHC12g
2161       periodName.CompareTo("LHC12h6") == 0 || // MC muon cocktail, anchor LHC12g
2162       periodName.CompareTo("LHC12g4b") == 0 || // MC DPMJET 3rd iteration, anchor LHC12g
2163       periodName.CompareTo("LHC12g4a") == 0 || // MC DPMJET improved, anchor LHC12g
2164       periodName.CompareTo("LHC12g4") == 0 || // MC DPMJET, anchor LHC12g
2165       periodName.CompareTo("LHC12g5") == 0 || // MC PHOJET, anchor LHC12g
2166       periodName.CompareTo("LHC12g2") == 0 || // MC Starlight background, anchor LHC12g
2167       periodName.CompareTo("LHC12g1") == 0 ) // MC ?, anchor LHC12g
2168       {
2169          printf(" Gamma Conversion Cuts %s :: pPb Run doing Eta Shift of %f \n\n",(GetCutNumber()).Data(),-0.465);
2170          SetEtaShift(-0.465);
2171       }
2172    else if(periodName.CompareTo("LHC13f") == 0 ||
2173            periodName.CompareTo("LHC13c6b") == 0 ||// MC Jpsi -> mumu, anchor LHC13f
2174            periodName.CompareTo("LHC13c5") == 0 || //MC Starlight, gamma gamma UPC muon, anchor LHC13f
2175            periodName.CompareTo("LHC13c4") == 0 )//MC Starlight, coherent JPsi, UPC muon, anchor LHC13f
2176       {
2177          printf(" Gamma Conversion Cuts %s :: Pbp Run doing Eta Shift of %f \n\n",(GetCutNumber()).Data(),0.465);
2178          SetEtaShift(+0.465);
2179       }
2180    else printf(" Gamma Conversion Cuts %s :: Automatic Eta Shift requested but Period is not known -> No Shift \n\n",(GetCutNumber()).Data());
2181 }
2182
2183 //________________________________________________________________________
2184 AliEmcalTriggerPatchInfo* AliConvEventCuts::GetMainTriggerPatch()
2185 {
2186   //get main trigger match; if not known yet, look for it and cache
2187
2188   if (fMainTriggerPatchEMCAL)
2189     return fMainTriggerPatchEMCAL;
2190
2191   if (!fTriggerPatchInfo) {
2192     AliError(Form("%s: fTriggerPatchInfo not available",GetName()));
2193     return 0;
2194   }
2195
2196   //number of patches in event
2197   Int_t nPatch = fTriggerPatchInfo->GetEntries();
2198
2199   //extract main trigger patch
2200   AliEmcalTriggerPatchInfo *patch;
2201   for (Int_t iPatch = 0; iPatch < nPatch; iPatch++) {
2202     patch = (AliEmcalTriggerPatchInfo*)fTriggerPatchInfo->At( iPatch );
2203     if (patch->IsMainTrigger()) {
2204       fMainTriggerPatchEMCAL = patch;
2205       break;
2206     }
2207   }
2208
2209   return fMainTriggerPatchEMCAL;
2210 }
2211
2212
2213 //________________________________________________________________________
2214 void AliConvEventCuts::InitializeEMCALTrigger(AliVEvent *fInputEvent)
2215 {
2216 //      cout << "entered EMCAL trigger initialization" << endl;
2217
2218         // Init the analysis.
2219         if (fCaloTriggersName.IsNull()){
2220                 if (fInputEvent->IsA()==AliESDEvent::Class()){
2221                         fCaloTriggersName = "EMCALTrigger";
2222                 } else {
2223                         fCaloTriggersName = "emcalTrigger";
2224                 }
2225         }
2226
2227         if (!fCaloTriggersName.IsNull() && !fCaloTriggers) {
2228                 fCaloTriggers =  dynamic_cast<AliVCaloTrigger*>(fInputEvent->FindListObject(fCaloTriggersName));
2229                 if (!fCaloTriggers) {
2230                         AliError(Form("%s: Could not retrieve calo triggers %s!", GetName(), fCaloTriggersName.Data()));
2231                 return;
2232                 }
2233         }
2234
2235         if (fCaloTriggerPatchInfoName.IsNull()){
2236                 if (fInputEvent->IsA()==AliESDEvent::Class()){
2237                         fCaloTriggerPatchInfoName = "EmcalTriggers";
2238                 } else {
2239                         fCaloTriggerPatchInfoName = "EmcalTriggers";
2240                 }
2241         }
2242
2243         if (!fCaloTriggerPatchInfoName.IsNull() && !fTriggerPatchInfo) {
2244                 fTriggerPatchInfo = GetArrayFromEvent(fInputEvent, fCaloTriggerPatchInfoName.Data(), "AliEmcalTriggerPatchInfo");
2245                 if (!fTriggerPatchInfo) {
2246                         AliError(Form("%s: Could not retrieve calo trigger patch info %s!", GetName(), fCaloTriggerPatchInfoName.Data()));
2247                 return;
2248                 }
2249
2250         }
2251
2252         fEMCALTrigInitialized = kTRUE;
2253 }
2254
2255 //________________________________________________________________________
2256 ULong_t AliConvEventCuts::GetTriggerList(){
2257         if (!fTriggerPatchInfo)
2258         return 0;
2259         //number of patches in event
2260         Int_t nPatch = fTriggerPatchInfo->GetEntries();
2261
2262         //loop over patches to define trigger type of event
2263         Int_t nG1 = 0;
2264         Int_t nG2 = 0;
2265         Int_t nJ1 = 0;
2266         Int_t nJ2 = 0;
2267         Int_t nL0 = 0;
2268         AliEmcalTriggerPatchInfo *patch;
2269 //      if (nPatch> 0) {cout << "NEW Triggers in this event*********************************" << endl;}
2270         for (Int_t iPatch = 0; iPatch < nPatch; iPatch++) {
2271                 patch = (AliEmcalTriggerPatchInfo*)fTriggerPatchInfo->At( iPatch );
2272 //              cout << "Patch energy: "<<patch->GetPatchE() << "\t ADC counts: " << patch->GetADCAmp() << endl;
2273 //              cout << "Phi: " << patch->GetPhiMin() << " - " << patch->GetPhiMax() << " delta phi: " <<abs(patch->GetPhiMin()-patch->GetPhiMax())<< endl;
2274 //              cout << "Eta: " << patch->GetEtaMin() << " - " << patch->GetEtaMax() << " delta eta: " <<abs(patch->GetEtaMin()-patch->GetEtaMax())<< endl;
2275                 if (patch->IsGammaHigh()){
2276 //                      cout << "fired L1GA high" << endl;
2277                         nG1++;
2278                 }
2279                 if (patch->IsGammaLow()){
2280 //                      cout << "fired L1GA low" << endl;
2281                         nG2++;
2282                 }
2283                 if (patch->IsJetHigh()){
2284 //                      cout << "fired L1JE high" << endl;
2285                         nJ1++;
2286                 }
2287                 if (patch->IsJetLow()){
2288 //                      cout << "fired L1JE low" << endl;
2289                         nJ2++;
2290                 }
2291                 if (patch->IsLevel0()){
2292 //                      cout << "fired L0" << endl;
2293                         nL0++;
2294                 }
2295 //              cout << patch->GetPatchE()      << "\t" << patch->GetADCAmp()   << "\t" << patch->IsGammaHigh() << "\t" << patch->IsGammaLow()
2296 //                   << "\t" << patch->IsJetHigh()      << "\t" << patch->IsJetLow()    << "\t" << patch->IsLevel0()
2297 //                       << "\t" << patch->GetPhiMin()  << "\t" << patch->GetPhiMax()   << "\t" << abs(patch->GetPhiMin()-patch->GetPhiMax())
2298 //                       << "\t" << patch->GetEtaMin()  << "\t" << patch->GetEtaMax()   << "\t" << abs(patch->GetEtaMin()-patch->GetEtaMax()) << endl;
2299         }
2300
2301         if (nPatch > 0){
2302                 AliDebug(2, "Patch summary: ");
2303                 AliDebug(2, Form("Number of patches: %d", nPatch));
2304                 AliDebug(2, Form("Level0: [%d]" ,nL0));
2305                 AliDebug(2, Form("Jet:    low[%d], high[%d]" ,nJ2, nJ1));
2306                 AliDebug(2, Form("Gamma:  low[%d], high[%d]" ,nG2, nG1));
2307         }
2308
2309 //      if (nPatch > 0){
2310 //              cout <<           Form("Number of patches: %d", nPatch) << endl;
2311 //              cout <<           Form("Level0: [%d]" ,nL0) << endl;
2312 //              cout <<           Form("Jet:    low[%d], high[%d]" ,nJ2, nJ1) << endl;
2313 //              cout <<           Form("Gamma:  low[%d], high[%d]" ,nG2, nG1) << endl;
2314 //      }
2315
2316         ULong_t triggers(0);
2317         if (nG1>0)
2318                 SETBIT(triggers, kG1);
2319         if (nG2>0)
2320                 SETBIT(triggers, kG2);
2321         if (nJ1>0)
2322                 SETBIT(triggers, kJ1);
2323         if (nJ2>0)
2324                 SETBIT(triggers, kJ2);
2325         if (nL0>0)
2326                 SETBIT(triggers, kL0);
2327         return triggers;
2328 }
2329
2330 //________________________________________________________________________
2331 Bool_t AliConvEventCuts::HasTriggerType(TriggerTypeEMCAL t){
2332         // Check if event has a given trigger type
2333         if(t == kND){
2334                 return fTriggersEMCAL == 0;
2335         }
2336         return TESTBIT(fTriggersEMCAL, int(t));
2337 }
2338
2339
2340 //________________________________________________________________________
2341 TClonesArray *AliConvEventCuts::GetArrayFromEvent(AliVEvent* fInputEvent, const char *name, const char *clname)
2342 {
2343         // Get array from event.
2344
2345         TClonesArray *arr = 0;
2346         TString sname(name);
2347         if (!sname.IsNull()) {
2348                 arr = dynamic_cast<TClonesArray*>(fInputEvent->FindListObject(sname));
2349                 if (!arr) {
2350                 AliWarning(Form("%s: Could not retrieve array with name %s!", GetName(), name));
2351                 return 0;
2352                 }
2353         } else {
2354                 return 0;
2355         }
2356
2357         if (!clname)
2358                 return arr;
2359
2360         TString objname(arr->GetClass()->GetName());
2361         TClass cls(objname);
2362         if (!cls.InheritsFrom(clname)) {
2363                 AliWarning(Form("%s: Objects of type %s in %s are not inherited from %s!",
2364                                                 GetName(), cls.GetName(), name, clname));
2365                 return 0;
2366         }
2367         return arr;
2368 }
2369
2370 //_________________________________________________________________________
2371 Bool_t AliConvEventCuts::IsConversionPrimaryESD( AliStack *MCStack, Int_t stackpos, Double_t prodVtxX, Double_t prodVtxY, Double_t prodVtxZ){
2372
2373         TParticle* particle = (TParticle *)MCStack->Particle(stackpos);
2374         if (!particle) return kFALSE;
2375         if (particle->GetMother(0) != -1){
2376                 Double_t deltaX = particle->Vx() - prodVtxX;
2377                 Double_t deltaY = particle->Vy() - prodVtxY;
2378                 Double_t deltaZ = particle->Vz() - prodVtxZ;
2379
2380                 Double_t realRadius2D = TMath::Sqrt(deltaX*deltaX+deltaY*deltaY);
2381                 Double_t realRadius3D = TMath::Sqrt(deltaX*deltaX+deltaY*deltaY+deltaZ*deltaZ);
2382
2383
2384                 Bool_t dalitzCand = kFALSE;
2385
2386                 TParticle* firstmother = (TParticle *)MCStack->Particle(particle->GetMother(0));
2387                 Int_t pdgCodeFirstMother                = firstmother->GetPdgCode();
2388                 Bool_t intDecay = kFALSE;
2389                 if ( pdgCodeFirstMother == 111 || pdgCodeFirstMother == 221 ) intDecay = kTRUE;
2390                 if ( intDecay && abs(particle->GetPdgCode()) == 11 ){
2391                         dalitzCand = kTRUE;
2392 //                      cout << "dalitz candidate found" << endl;
2393                 }
2394
2395                 Int_t source = particle->GetMother(0);
2396                 Bool_t foundExcludedPart = kFALSE;
2397                 Bool_t foundShower = kFALSE;
2398                 Int_t pdgCodeMotherPrev = 0;
2399                 Int_t pdgCodeMotherPPrevMother = 0;
2400                 Int_t depth = 0;
2401                 if (dalitzCand || realRadius3D < fSecProdBoundary ){
2402 //                      if (particle->GetPdgCode() == 22){
2403 //                              cout << endl << endl << "new particle: " << stackpos <<endl;
2404 //                              cout << particle->GetPdgCode() << "\t" << particle->R() << "\t" << realRadius2D << "\t" << realRadius3D << endl;
2405 //                      }
2406                         while (depth < 20){
2407                                 TParticle* mother       = (TParticle *)MCStack->Particle(source);
2408                                 source                          = mother->GetMother(0);
2409 //                              if (particle->GetPdgCode() == 22)cout << "Stackposition: "<< source << endl;
2410                                 Int_t pdgCodeMother             = mother->GetPdgCode();
2411 //                              if (particle->GetPdgCode() == 22)cout << "Previous mothers: " << pdgCodeMother << "\t"<< pdgCodeMotherPrev<< "\t" << pdgCodeMotherPPrevMother << endl;
2412                                 if (pdgCodeMother == pdgCodeMotherPrev && pdgCodeMother == pdgCodeMotherPPrevMother) depth = 20;
2413                                 if (abs(pdgCodeMother) == 11 && abs(pdgCodeMotherPrev) == 22 && abs(pdgCodeMotherPPrevMother) == 11 ){
2414                                         foundShower = kTRUE;
2415                                         depth =20;
2416                                 }
2417                                 if (abs(pdgCodeMother) == 22 && abs(pdgCodeMotherPrev) == 11 && abs(pdgCodeMotherPPrevMother) == 22 ){
2418                                         foundShower = kTRUE;
2419                                         depth =20;
2420                                 }
2421
2422                                 // particles to be excluded:
2423                                 // K0s          - 310
2424                                 // K0l          - 130
2425                                 // K+/-         - 321
2426                                 // Lambda       - 3122
2427                                 // Sigma0       - 3212
2428                                 // Sigma+/-     - 3222, 3112
2429                                 // Cascades     - 3322, 3312
2430                                 if (abs(pdgCodeMother) == 310   || abs(pdgCodeMother) == 130    || abs(pdgCodeMother) == 321  ||
2431                                         abs(pdgCodeMother) == 3122      || abs(pdgCodeMother) == 3212   || abs(pdgCodeMother) == 3222 ||
2432                                         abs(pdgCodeMother) == 3112      || abs(pdgCodeMother) == 3322   || abs(pdgCodeMother) == 3312
2433                                 ) {
2434                                         foundExcludedPart = kTRUE;
2435                                 }
2436 //                              if (particle->GetPdgCode() == 22)cout << mother->GetPdgCode() << "\t" <<  source << "\t" << foundExcludedPart<< endl;
2437                                 pdgCodeMotherPPrevMother = pdgCodeMotherPrev;
2438                                 pdgCodeMotherPrev = pdgCodeMother;
2439                                 if (source == -1) depth = 20;
2440
2441 //                              if (particle->GetPdgCode() == 22)cout << depth << endl;
2442                                 depth++;
2443                         }
2444                 }
2445                 if (foundExcludedPart){
2446 //                      if (particle->GetPdgCode() == 22)cout << "This is definitely a secondary, manually excluded" << endl;
2447                         return kFALSE;
2448                 } else if (dalitzCand){
2449 //                      if (particle->GetPdgCode() == 22)cout << "This was a decay via a virtual photon" << endl;
2450                         return kTRUE;
2451                 } else if (foundShower){
2452 //                      if (particle->GetPdgCode() == 22)cout << "This is a shower" << endl;
2453                         return kFALSE;
2454                 } else if (realRadius3D > fSecProdBoundary){
2455 //                      cout << "This is a secondary, to large production radius" << endl;
2456                         return kFALSE;
2457                 }
2458         }
2459
2460         return kTRUE;
2461 }
2462