AliPhysics  a88b1f0 (a88b1f0)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliRDHFCuts.cxx
Go to the documentation of this file.
1 /**************************************************************************
2  * Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
3  * *
4  * Author: The ALICE Off-line Project. *
5  * Contributors are mentioned in the code where appropriate. *
6  * *
7  * Permission to use, copy, modify and distribute this software and its *
8  * documentation strictly for non-commercial purposes is hereby granted *
9  * without fee, provided that the above copyright notice appears in all *
10  * copies and that both the copyright notice and this permission notice *
11  * appear in the supporting documentation. The authors make no claims *
12  * about the suitability of this software for any purpose. It is *
13  * provided "as is" without express or implied warranty. *
14  **************************************************************************/
15 
16 /* $Id$ */
17 
19 //
20 // Base class for cuts on AOD reconstructed heavy-flavour decay
21 //
22 // Author: A.Dainese, andrea.dainese@pd.infn.it
24 #include <Riostream.h>
25 
26 #include "AliVEvent.h"
27 #include "AliESDEvent.h"
28 #include "AliAODEvent.h"
29 #include "AliVVertex.h"
30 #include "AliESDVertex.h"
31 #include "AliLog.h"
32 #include "AliAODVertex.h"
33 #include "AliESDtrack.h"
34 #include "AliAODTrack.h"
35 #include "AliESDtrackCuts.h"
36 #include "AliCentrality.h"
37 #include "AliAODRecoDecayHF.h"
38 #include "AliAnalysisVertexingHF.h"
39 #include "AliAODMCHeader.h"
40 #include "AliAODMCParticle.h"
41 #include "AliVertexerTracks.h"
42 #include "AliRDHFCuts.h"
43 #include "AliAnalysisManager.h"
44 #include "AliAODHandler.h"
45 #include "AliInputEventHandler.h"
46 #include "AliPIDResponse.h"
47 #include "AliAnalysisUtils.h"
48 #include "AliMultSelection.h"
49 #include "AliAODVZERO.h"
50 #include "TRandom.h"
51 #include <TF1.h>
52 #include <TFile.h>
53 #include <TKey.h>
54 
55 using std::cout;
56 using std::endl;
57 
59 ClassImp(AliRDHFCuts);
61 
62 
63 //--------------------------------------------------------------------------
64 AliRDHFCuts::AliRDHFCuts(const Char_t* name, const Char_t* title) :
65 AliAnalysisCuts(name,title),
66 fMinVtxType(3),
67 fMinVtxContr(1),
68 fMaxVtxRedChi2(1e6),
69 fMaxVtxZ(10.),
70 fMinSPDMultiplicity(0),
71 fTriggerMask(AliVEvent::kAnyINT),
72 fUseOnlyOneTrigger(kFALSE),
73 fTrackCuts(0),
74 fnPtBins(1),
75 fnPtBinLimits(1),
76 fPtBinLimits(0),
77 fnVars(1),
78 fVarNames(0),
79 fnVarsForOpt(0),
80 fVarsForOpt(0),
81 fGlobalIndex(1),
82 fCutsRD(0),
83 fIsUpperCut(0),
84 fUsePID(kFALSE),
85 fUseAOD049(kFALSE),
86 fPidHF(0),
87 fWhyRejection(0),
88 fEvRejectionBits(0),
89 fRemoveDaughtersFromPrimary(kFALSE),
90 fUseMCVertex(kFALSE),
91 fUsePhysicsSelection(kTRUE),
92 fOptPileup(0),
93 fMinContrPileup(3),
94 fMinDzPileup(0.6),
95 fUseCentrality(0),
96 fMinCentrality(0.),
97 fMaxCentrality(100.),
98 fMultSelectionObjectName("MultSelection"),
99 fFixRefs(kFALSE),
100 fIsSelectedCuts(0),
101 fIsSelectedPID(0),
102 fMinPtCand(-1.),
103 fMaxPtCand(100000.),
104 fMaxRapidityCand(-999.),
105 fKeepSignalMC(kFALSE),
106 fIsCandTrackSPDFirst(kFALSE),
107 fMaxPtCandTrackSPDFirst(0.),
108 fApplySPDDeadPbPb2011(kFALSE),
109 fApplySPDMisalignedPP2012(kFALSE),
110 fMaxDiffTRKV0Centr(-1.),
111 fRemoveTrackletOutliers(kFALSE),
112 fCutOnzVertexSPD(0),
113 fKinkReject(kFALSE),
114 fUseTrackSelectionWithFilterBits(kTRUE),
115 fUseCentrFlatteningInMC(kFALSE),
116 fHistCentrDistr(0x0),
117 fCutRatioClsOverCrossRowsTPC(0),
118 fCutRatioSignalNOverCrossRowsTPC(0),
119 fCutMinCrossedRowsTPCPtDep(""),
120 f1CutMinNCrossedRowsTPCPtDep(0x0),
121 fUseCutGeoNcrNcl(kFALSE),
122 fDeadZoneWidth(3.),
123 fCutGeoNcrNclLength(130.),
124 fCutGeoNcrNclGeom1Pt(1.5),
125 fCutGeoNcrNclFractionNcr(0.85),
126 fCutGeoNcrNclFractionNcl(0.7),
127 fUseV0ANDSelectionOffline(kFALSE)
128 {
129  //
130  // Default Constructor
131  //
132  fTriggerClass[0]="CINT1"; fTriggerClass[1]="";
133 }
134 //--------------------------------------------------------------------------
135 AliRDHFCuts::AliRDHFCuts(const AliRDHFCuts &source) :
136  AliAnalysisCuts(source),
137  fMinVtxType(source.fMinVtxType),
138  fMinVtxContr(source.fMinVtxContr),
139  fMaxVtxRedChi2(source.fMaxVtxRedChi2),
140  fMaxVtxZ(source.fMaxVtxZ),
141  fMinSPDMultiplicity(source.fMinSPDMultiplicity),
142  fTriggerMask(source.fTriggerMask),
143  fUseOnlyOneTrigger(source.fUseOnlyOneTrigger),
144  fTriggerClass(),
145  fTrackCuts(0),
146  fnPtBins(source.fnPtBins),
147  fnPtBinLimits(source.fnPtBinLimits),
148  fPtBinLimits(0),
149  fnVars(source.fnVars),
150  fVarNames(0),
151  fnVarsForOpt(source.fnVarsForOpt),
152  fVarsForOpt(0),
153  fGlobalIndex(source.fGlobalIndex),
154  fCutsRD(0),
155  fIsUpperCut(0),
156  fUsePID(source.fUsePID),
157  fUseAOD049(source.fUseAOD049),
158  fPidHF(0),
159  fWhyRejection(source.fWhyRejection),
160  fEvRejectionBits(source.fEvRejectionBits),
161  fRemoveDaughtersFromPrimary(source.fRemoveDaughtersFromPrimary),
162  fUseMCVertex(source.fUseMCVertex),
163  fUsePhysicsSelection(source.fUsePhysicsSelection),
164  fOptPileup(source.fOptPileup),
165  fMinContrPileup(source.fMinContrPileup),
166  fMinDzPileup(source.fMinDzPileup),
167  fUseCentrality(source.fUseCentrality),
168  fMinCentrality(source.fMinCentrality),
169  fMaxCentrality(source.fMaxCentrality),
170  fMultSelectionObjectName(source.fMultSelectionObjectName),
171  fFixRefs(source.fFixRefs),
172  fIsSelectedCuts(source.fIsSelectedCuts),
173  fIsSelectedPID(source.fIsSelectedPID),
174  fMinPtCand(source.fMinPtCand),
175  fMaxPtCand(source.fMaxPtCand),
176  fMaxRapidityCand(source.fMaxRapidityCand),
177  fKeepSignalMC(source.fKeepSignalMC),
178  fIsCandTrackSPDFirst(source.fIsCandTrackSPDFirst),
179  fMaxPtCandTrackSPDFirst(source.fMaxPtCandTrackSPDFirst),
180  fApplySPDDeadPbPb2011(source.fApplySPDDeadPbPb2011),
181  fApplySPDMisalignedPP2012(source.fApplySPDMisalignedPP2012),
182  fMaxDiffTRKV0Centr(source.fMaxDiffTRKV0Centr),
183  fRemoveTrackletOutliers(source.fRemoveTrackletOutliers),
184  fCutOnzVertexSPD(source.fCutOnzVertexSPD),
185  fKinkReject(source.fKinkReject),
186  fUseTrackSelectionWithFilterBits(source.fUseTrackSelectionWithFilterBits),
187  fUseCentrFlatteningInMC(source.fUseCentrFlatteningInMC),
188  fHistCentrDistr(0x0),
189  fCutRatioClsOverCrossRowsTPC(source.fCutRatioClsOverCrossRowsTPC),
190  fCutRatioSignalNOverCrossRowsTPC(source.fCutRatioSignalNOverCrossRowsTPC),
191  fCutMinCrossedRowsTPCPtDep(""),
192  f1CutMinNCrossedRowsTPCPtDep(0x0),
193  fUseCutGeoNcrNcl(source.fUseCutGeoNcrNcl),
194  fDeadZoneWidth(source.fDeadZoneWidth),
195  fCutGeoNcrNclLength(source.fCutGeoNcrNclLength),
196  fCutGeoNcrNclGeom1Pt(source.fCutGeoNcrNclGeom1Pt),
197  fCutGeoNcrNclFractionNcr(source.fCutGeoNcrNclFractionNcr),
198  fCutGeoNcrNclFractionNcl(source.fCutGeoNcrNclFractionNcl),
199  fUseV0ANDSelectionOffline(source.fUseV0ANDSelectionOffline)
200 {
201  //
202  // Copy constructor
203  //
204  cout<<"Copy constructor"<<endl;
205  fTriggerClass[0] = source.fTriggerClass[0];
206  fTriggerClass[1] = source.fTriggerClass[1];
207  if(source.GetTrackCuts()) AddTrackCuts(source.GetTrackCuts());
208  if(source.fPtBinLimits) SetPtBins(source.fnPtBinLimits,source.fPtBinLimits);
209  if(source.fVarNames) SetVarNames(source.fnVars,source.fVarNames,source.fIsUpperCut);
210  if(source.fCutsRD) SetCuts(source.fGlobalIndex,source.fCutsRD);
211  if(source.fVarsForOpt) SetVarsForOpt(source.fnVarsForOpt,source.fVarsForOpt);
212  if(source.fPidHF) SetPidHF(source.fPidHF);
213  if(source.fHistCentrDistr) fHistCentrDistr=(TH1F*)(source.fHistCentrDistr->Clone());
214  if(source.fCutMinCrossedRowsTPCPtDep) fCutMinCrossedRowsTPCPtDep=source.fCutMinCrossedRowsTPCPtDep;
215  if(source.f1CutMinNCrossedRowsTPCPtDep) f1CutMinNCrossedRowsTPCPtDep=new TFormula(*(source.f1CutMinNCrossedRowsTPCPtDep));
216  PrintAll();
217 
218 }
219 //--------------------------------------------------------------------------
220 AliRDHFCuts &AliRDHFCuts::operator=(const AliRDHFCuts &source)
221 {
222  //
223  // assignment operator
224  //
225  if(&source == this) return *this;
226 
227  AliAnalysisCuts::operator=(source);
228 
229  fMinVtxType=source.fMinVtxType;
230  fMinVtxContr=source.fMinVtxContr;
231  fMaxVtxRedChi2=source.fMaxVtxRedChi2;
232  fMaxVtxZ=source.fMaxVtxZ;
233  fMinSPDMultiplicity=source.fMinSPDMultiplicity;
234  fTriggerMask=source.fTriggerMask;
235  fUseOnlyOneTrigger=source.fUseOnlyOneTrigger;
236  fTriggerClass[0]=source.fTriggerClass[0];
237  fTriggerClass[1]=source.fTriggerClass[1];
238  fnPtBins=source.fnPtBins;
239  fnPtBinLimits=source.fnPtBinLimits;
240  fnVars=source.fnVars;
241  fGlobalIndex=source.fGlobalIndex;
242  fnVarsForOpt=source.fnVarsForOpt;
243  fUsePID=source.fUsePID;
244  fUseAOD049=source.fUseAOD049;
245  if(fPidHF) delete fPidHF;
246  fPidHF=new AliAODPidHF(*(source.GetPidHF()));
247  fWhyRejection=source.fWhyRejection;
248  fEvRejectionBits=source.fEvRejectionBits;
249  fRemoveDaughtersFromPrimary=source.fRemoveDaughtersFromPrimary;
250  fUseMCVertex=source.fUseMCVertex;
251  fUsePhysicsSelection=source.fUsePhysicsSelection;
252  fOptPileup=source.fOptPileup;
253  fMinContrPileup=source.fMinContrPileup;
254  fMinDzPileup=source.fMinDzPileup;
255  fUseCentrality=source.fUseCentrality;
256  fMinCentrality=source.fMinCentrality;
257  fMaxCentrality=source.fMaxCentrality;
258  fMultSelectionObjectName=source.fMultSelectionObjectName;
259  fFixRefs=source.fFixRefs;
260  fIsSelectedCuts=source.fIsSelectedCuts;
261  fIsSelectedPID=source.fIsSelectedPID;
262  fMinPtCand=source.fMinPtCand;
263  fMaxPtCand=source.fMaxPtCand;
264  fMaxRapidityCand=source.fMaxRapidityCand;
265  fKeepSignalMC=source.fKeepSignalMC;
266  fIsCandTrackSPDFirst=source.fIsCandTrackSPDFirst;
267  fMaxPtCandTrackSPDFirst=source.fMaxPtCandTrackSPDFirst;
268  fApplySPDDeadPbPb2011=source.fApplySPDDeadPbPb2011;
269  fApplySPDMisalignedPP2012=source.fApplySPDMisalignedPP2012;
270  fMaxDiffTRKV0Centr=source.fMaxDiffTRKV0Centr;
271  fRemoveTrackletOutliers=source.fRemoveTrackletOutliers;
272  fCutOnzVertexSPD=source.fCutOnzVertexSPD;
273  fKinkReject=source.fKinkReject;
274  fUseTrackSelectionWithFilterBits=source.fUseTrackSelectionWithFilterBits;
275  if(fHistCentrDistr) delete fHistCentrDistr;
276  fUseCentrFlatteningInMC=source.fUseCentrFlatteningInMC;
277  if(source.fHistCentrDistr)fHistCentrDistr=(TH1F*)(source.fHistCentrDistr->Clone());
278 
279  if(source.GetTrackCuts()) {delete fTrackCuts; fTrackCuts=new AliESDtrackCuts(*(source.GetTrackCuts()));}
280  if(source.fPtBinLimits) SetPtBins(source.fnPtBinLimits,source.fPtBinLimits);
281  if(source.fVarNames) SetVarNames(source.fnVars,source.fVarNames,source.fIsUpperCut);
282  if(source.fCutsRD) SetCuts(source.fGlobalIndex,source.fCutsRD);
283  if(source.fVarsForOpt) SetVarsForOpt(source.fnVarsForOpt,source.fVarsForOpt);
284 
285  if(fCutMinCrossedRowsTPCPtDep) fCutMinCrossedRowsTPCPtDep=source.fCutMinCrossedRowsTPCPtDep;
286  if(f1CutMinNCrossedRowsTPCPtDep) delete f1CutMinNCrossedRowsTPCPtDep;
287  if(source.f1CutMinNCrossedRowsTPCPtDep) f1CutMinNCrossedRowsTPCPtDep=new TFormula(*(source.f1CutMinNCrossedRowsTPCPtDep));
288  fCutRatioClsOverCrossRowsTPC=source.fCutRatioClsOverCrossRowsTPC;
289  fCutRatioSignalNOverCrossRowsTPC=source.fCutRatioSignalNOverCrossRowsTPC;
290 
291  fUseCutGeoNcrNcl=source.fUseCutGeoNcrNcl;
292  fDeadZoneWidth=source.fDeadZoneWidth;
293  fCutGeoNcrNclLength=source.fCutGeoNcrNclLength;
294  fCutGeoNcrNclGeom1Pt=source.fCutGeoNcrNclGeom1Pt;
295  fCutGeoNcrNclFractionNcr=source.fCutGeoNcrNclFractionNcr;
296  fCutGeoNcrNclFractionNcl=source.fCutGeoNcrNclFractionNcl;
297  fUseV0ANDSelectionOffline=source.fUseV0ANDSelectionOffline;
298 
299  PrintAll();
300 
301  return *this;
302 }
303 //--------------------------------------------------------------------------
304 AliRDHFCuts::~AliRDHFCuts() {
305  //
306  // Default Destructor
307  //
308  if(fTrackCuts) { delete fTrackCuts; fTrackCuts=0; }
309  if(fPtBinLimits) {delete [] fPtBinLimits; fPtBinLimits=0;}
310  if(fVarNames) {delete [] fVarNames; fVarNames=0;}
311  if(fVarsForOpt) {delete [] fVarsForOpt; fVarsForOpt=0;}
312  if(fCutsRD) {
313  delete [] fCutsRD;
314  fCutsRD=0;
315  }
316  if(fIsUpperCut) {delete [] fIsUpperCut; fIsUpperCut=0;}
317  if(fPidHF){
318  delete fPidHF;
319  fPidHF=0;
320  }
321  if(fHistCentrDistr)delete fHistCentrDistr;
322 
323  if(f1CutMinNCrossedRowsTPCPtDep) {
324  delete f1CutMinNCrossedRowsTPCPtDep;
325  f1CutMinNCrossedRowsTPCPtDep = 0;
326  }
327 
328 }
329 //---------------------------------------------------------------------------
330 Int_t AliRDHFCuts::IsEventSelectedInCentrality(AliVEvent *event) {
331  //
332  // Centrality selection
333  //
334  if(fUseCentrality<kCentOff||fUseCentrality>=kCentInvalid){
335  AliWarning("Centrality estimator not valid");
336  return 3;
337  }else{
338  Float_t centvalue=GetCentrality((AliAODEvent*)event);
339  if (centvalue<-998.){//-999 if no centralityP
340  return 0;
341  }else if(fEvRejectionBits&(1<<kMismatchOldNewCentrality)){
342  return 0;
343  }else{
344  if (centvalue<fMinCentrality || centvalue>fMaxCentrality){
345  return 2;
346  }
347  // selection to flatten the centrality distribution
348  if(fHistCentrDistr){
349  if(!IsEventSelectedForCentrFlattening(centvalue))return 4;
350  }
351  }
352  }
353  return 0;
354 }
355 
356 
357 //-------------------------------------------------
358 void AliRDHFCuts::SetHistoForCentralityFlattening(TH1F *h,Double_t minCentr,Double_t maxCentr,Double_t centrRef,Int_t switchTRand){
359  // set the histo for centrality flattening
360  // the centrality is flatten in the range minCentr,maxCentr
361  // if centrRef is zero, the minimum in h within (minCentr,maxCentr) defines the reference
362  // positive, the value of h(centrRef) defines the reference (-> the centrality distribution might be not flat in the whole desired range)
363  // negative, h(bin with max in range)*centrRef is used to define the reference (-> defines the maximum loss of events, also in this case the distribution might be not flat)
364  // switchTRand is used to set the unerflow bin of the histo: if it is < -1 in the analysis the random event selection will be done on using TRandom
365 
366  if(maxCentr<minCentr){
367  AliWarning("AliRDHFCuts::Wrong centralities values while setting the histogram for centrality flattening");
368  }
369 
370  if(fHistCentrDistr)delete fHistCentrDistr;
371  fHistCentrDistr=(TH1F*)h->Clone("hCentralityFlat");
372  fHistCentrDistr->SetTitle("Reference histo for centrality flattening");
373  Int_t minbin=fHistCentrDistr->FindBin(minCentr*1.00001); // fast if fix bin width
374  Int_t maxbin=fHistCentrDistr->FindBin(maxCentr*0.9999);
375  fHistCentrDistr->GetXaxis()->SetRange(minbin,maxbin);
376  Double_t ref=0.,bincont=0.,binrefwidth=1.;
377  Int_t binref=0;
378  if(TMath::Abs(centrRef)<0.0001){
379  binref=fHistCentrDistr->GetMinimumBin();
380  binrefwidth=fHistCentrDistr->GetBinWidth(binref);
381  ref=fHistCentrDistr->GetBinContent(binref)/binrefwidth;
382  }
383  else if(centrRef>0.){
384  binref=h->FindBin(centrRef);
385  if(binref<1||binref>h->GetNbinsX()){
386  AliWarning("AliRDHFCuts::Wrong centrality reference value while setting the histogram for centrality flattening");
387  }
388  binrefwidth=fHistCentrDistr->GetBinWidth(binref);
389  ref=fHistCentrDistr->GetBinContent(binref)/binrefwidth;
390  }
391  else{
392  if(centrRef<-1) AliWarning("AliRDHFCuts: with this centrality reference no flattening will be applied");
393  binref=fHistCentrDistr->GetMaximumBin();
394  binrefwidth=fHistCentrDistr->GetBinWidth(binref);
395  ref=fHistCentrDistr->GetMaximum()*TMath::Abs(centrRef)/binrefwidth;
396  }
397 
398  for(Int_t j=1;j<=h->GetNbinsX();j++){// Now set the "probabilities"
399  if(h->GetBinLowEdge(j)*1.0001>=minCentr&&h->GetBinLowEdge(j+1)*0.9999<=maxCentr){
400  bincont=h->GetBinContent(j);
401  fHistCentrDistr->SetBinContent(j,ref/bincont*h->GetBinWidth(j));
402  fHistCentrDistr->SetBinError(j,h->GetBinError(j)*ref/bincont);
403  }
404  else{
405  h->SetBinContent(j,1.1);// prob > 1 to assure that events will not be rejected
406  }
407  }
408 
409  fHistCentrDistr->SetBinContent(0,switchTRand);
410  return;
411 
412 }
413 
414 //-------------------------------------------------
415 Bool_t AliRDHFCuts::IsEventSelectedForCentrFlattening(Float_t centvalue){
416  //
417  // Random event selection, based on fHistCentrDistr, to flatten the centrality distribution
418  // Can be faster if it was required that fHistCentrDistr covers
419  // exactly the desired centrality range (e.g. part of the lines below should be done during the
420  // setting of the histo) and TH1::SetMinimum called
421  //
422 
423  if(!fHistCentrDistr) return kTRUE;
424  // Int_t maxbin=fHistCentrDistr->FindBin(fMaxCentrality*0.9999);
425  // if(maxbin>fHistCentrDistr->GetNbinsX()){
426  // AliWarning("AliRDHFCuts: The maximum centrality exceeds the x-axis limit of the histogram for centrality flattening");
427  // }
428 
429  Int_t bin=fHistCentrDistr->FindBin(centvalue); // Fast if the histo has a fix bin
430  Double_t bincont=fHistCentrDistr->GetBinContent(bin);
431  Double_t centDigits=centvalue-(Int_t)(centvalue*100.)/100.;// this is to extract a random number between 0 and 0.01
432 
433  if(fHistCentrDistr->GetBinContent(0)<-0.9999){
434  if(gRandom->Uniform(1.)<bincont)return kTRUE;
435  return kFALSE;
436  }
437 
438  if(centDigits*100.<bincont)return kTRUE;
439  return kFALSE;
440 
441 }
442 //---------------------------------------------------------------------------
443 void AliRDHFCuts::SetupPID(AliVEvent *event) {
444  // Set the PID response object in the AliAODPidHF
445  // in case of old PID sets the TPC dE/dx BB parameterization
446 
447  if(fPidHF){
448  if(fPidHF->GetPidResponse()==0x0){
449  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
450  AliInputEventHandler *inputHandler=(AliInputEventHandler*)mgr->GetInputEventHandler();
451  AliPIDResponse *pidResp=inputHandler->GetPIDResponse();
452  fPidHF->SetPidResponse(pidResp);
453  }
454  if(fPidHF->GetUseCombined()) fPidHF->SetUpCombinedPID();
455  if(fPidHF->GetOldPid()) {
456 
457  Bool_t isMC=kFALSE;
458  TClonesArray *mcArray = (TClonesArray*)((AliAODEvent*)event)->GetList()->FindObject(AliAODMCParticle::StdBranchName());
459  if(mcArray) {isMC=kTRUE;fUseAOD049=kFALSE;}
460 
461  // pp, from LHC10d onwards
462  if((event->GetRunNumber()>121693 && event->GetRunNumber()<136851) ||
463  event->GetRunNumber()>139517) fPidHF->SetOnePad(kTRUE);
464  // pp, 2011 low energy run
465  if((event->GetRunNumber()>=146686 && event->GetRunNumber()<=146860)){
466  fPidHF->SetppLowEn2011(kTRUE);
467  fPidHF->SetOnePad(kFALSE);
468  }
469  // PbPb LHC10h
470  if(event->GetRunNumber()>=136851 && event->GetRunNumber()<=139517) fPidHF->SetPbPb(kTRUE);
471  // MC
472  if(isMC) fPidHF->SetMC(kTRUE);
473  if(isMC && (event->GetRunNumber()>=146686 && event->GetRunNumber()<=146860))
474  fPidHF->SetMClowenpp2011(kTRUE);
475  fPidHF->SetBetheBloch();
476  }else{
477  // check that AliPIDResponse object was properly set in case of using OADB
478  if(fPidHF->GetPidResponse()==0x0) AliFatal("AliPIDResponse object not set");
479  }
480  }
481 }
482 //---------------------------------------------------------------------------
483 Bool_t AliRDHFCuts::IsEventSelected(AliVEvent *event) {
484  //
485  // Event selection
486  //
487  //if(fTriggerMask && event->GetTriggerMask()!=fTriggerMask) return kFALSE;
488 
489 
490 
491  fWhyRejection=0;
492  fEvRejectionBits=0;
493  Bool_t accept=kTRUE;
494 
495 
496  // check if it's MC
497  Bool_t isMC=kFALSE;
498  TClonesArray *mcArray = (TClonesArray*)((AliAODEvent*)event)->GetList()->FindObject(AliAODMCParticle::StdBranchName());
499  if(mcArray) {isMC=kTRUE;fUseAOD049=kFALSE;}
500 
501 
502  SetupPID(event);
503 
504  // trigger class
505  TString firedTriggerClasses=((AliAODEvent*)event)->GetFiredTriggerClasses();
506  // don't do for MC and for PbPb 2010 data
507  if(!isMC && (event->GetRunNumber()<136851 || event->GetRunNumber()>139517)) {
508  if(!firedTriggerClasses.Contains(fTriggerClass[0].Data()) &&
509  (fTriggerClass[1].CompareTo("")==0 || !firedTriggerClasses.Contains(fTriggerClass[1].Data())) ) {
510  fWhyRejection=5;
511  fEvRejectionBits+=1<<kNotSelTrigger;
512  accept=kFALSE;
513  }
514  }
515 
516  // TEMPORARY FIX FOR GetEvent
517  Int_t nTracks=((AliAODEvent*)event)->GetNumberOfTracks();
518  for(Int_t itr=0; itr<nTracks; itr++){
519  AliAODTrack* tr=(AliAODTrack*)((AliAODEvent*)event)->GetTrack(itr);
520  tr->SetAODEvent((AliAODEvent*)event);
521  }
522 
523  // TEMPORARY FIX FOR REFERENCES
524  // Fix references to daughter tracks
525  // if(fFixRefs) {
526  // AliAnalysisVertexingHF *fixer = new AliAnalysisVertexingHF();
527  // fixer->FixReferences((AliAODEvent*)event);
528  // delete fixer;
529  // }
530  //
531 
532 
533  // physics selection requirements
534  if(fUsePhysicsSelection){
535  Bool_t isSelected = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & fTriggerMask);
536  if(!isSelected) {
537  if(accept) fWhyRejection=7;
538  fEvRejectionBits+=1<<kPhysicsSelection;
539  accept=kFALSE;
540  }else{
541  if(fUseOnlyOneTrigger){
542  if(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected()!=fTriggerMask){
543  if(accept) fWhyRejection=7;
544  fEvRejectionBits+=1<<kPhysicsSelection;
545  accept=kFALSE;
546  }
547  }
548  if(fUseV0ANDSelectionOffline){
549  AliAODVZERO* v0data=(AliAODVZERO*)((AliAODEvent*)event)->GetVZEROData();
550  Int_t tv0a=v0data->GetV0ADecision();
551  Int_t tv0c=v0data->GetV0CDecision();
552  if(!(tv0a==1 && tv0c==1)){
553  if(accept) fWhyRejection=7;
554  fEvRejectionBits+=1<<kPhysicsSelection;
555  accept=kFALSE;
556  }
557  }
558  }
559  }
560 
561  // vertex requirements
562 
563  const AliVVertex *vertex = event->GetPrimaryVertex();
564 
565  if(!vertex){
566  accept=kFALSE;
567  fEvRejectionBits+=1<<kNoVertex;
568  }else{
569  TString title=vertex->GetTitle();
570  if(title.Contains("Z") && fMinVtxType>1){
571  accept=kFALSE;
572  fEvRejectionBits+=1<<kNoVertex;
573  }
574  else if(title.Contains("3D") && fMinVtxType>2){
575  accept=kFALSE;
576  fEvRejectionBits+=1<<kNoVertex;
577  }
578  if(vertex->GetNContributors()<fMinVtxContr){
579  accept=kFALSE;
580  fEvRejectionBits+=1<<kTooFewVtxContrib;
581  }
582  if(TMath::Abs(vertex->GetZ())>fMaxVtxZ) {
583  fEvRejectionBits+=1<<kZVtxOutFid;
584  if(accept) fWhyRejection=6;
585  accept=kFALSE;
586  }
587  }
588 
589  if(fCutOnzVertexSPD>0){
590  const AliVVertex *vSPD = ((AliAODEvent*)event)->GetPrimaryVertexSPD();
591  if(!vSPD || (vSPD && vSPD->GetNContributors()<fMinVtxContr)){
592  accept=kFALSE;
593  fEvRejectionBits+=1<<kBadSPDVertex;
594  }else{
595  if(fCutOnzVertexSPD==1 && TMath::Abs(vSPD->GetZ())>12.) {
596  fEvRejectionBits+=1<<kZVtxSPDOutFid;
597  if(accept) fWhyRejection=6;
598  accept=kFALSE;
599  }
600  if(fCutOnzVertexSPD==2 && vertex){
601  if(TMath::Abs(vSPD->GetZ()-vertex->GetZ())>0.5) {
602  fEvRejectionBits+=1<<kZVtxSPDOutFid;
603  if(accept) fWhyRejection=6;
604  accept=kFALSE;
605  }
606  }
607  }
608  }
609 
610  // pile-up rejection
611  if(fOptPileup==kRejectPileupEvent){
612  Int_t cutc=(Int_t)fMinContrPileup;
613  Double_t cutz=(Double_t)fMinDzPileup;
614  if(event->IsPileupFromSPD(cutc,cutz,3.,2.,10.)) {
615  if(accept) fWhyRejection=1;
616  fEvRejectionBits+=1<<kPileup;
617  accept=kFALSE;
618  }
619  }
620  else if(fOptPileup==kRejectMVPileupEvent){
621  AliAnalysisUtils utils;
622  Bool_t isPUMV = utils.IsPileUpMV(event);
623  if(isPUMV) {
624  if(accept) fWhyRejection=1;
625  fEvRejectionBits+=1<<kPileup;
626  accept=kFALSE;
627  }
628  }
629 
630  // centrality selection
631  if (fUseCentrality!=kCentOff) {
632  Int_t rejection=IsEventSelectedInCentrality(event);
633  Bool_t okCent=kFALSE;
634  if(rejection==0) okCent=kTRUE;
635  if(isMC && rejection==4 && !fUseCentrFlatteningInMC) okCent=kTRUE;
636  if(!okCent){
637  if(accept) fWhyRejection=rejection;
638  if(fWhyRejection==4)fEvRejectionBits+=1<<kCentralityFlattening;
639  else fEvRejectionBits+=1<<kOutsideCentrality;
640  accept=kFALSE;
641  }
642 
643  }
644 
645  // PbPb2011 outliers in tracklets vs. VZERO and centTRK vs. centV0
646  if(event->GetRunNumber()>=167693 && event->GetRunNumber()<=170593){
647  if(fRemoveTrackletOutliers){
648  Double_t v0cent=GetCentrality((AliAODEvent*)event,kCentV0M);
649  Double_t ntracklets=((AliAODEvent*)event)->GetTracklets()->GetNumberOfTracklets();
650  Double_t cutval=60.-0.08*ntracklets+1./50000.*ntracklets*ntracklets;
651  if(ntracklets<1000. && v0cent<cutval){
652  if(accept) fWhyRejection=2;
653  fEvRejectionBits+=1<<kOutsideCentrality;
654  accept=kFALSE;
655  }
656  }
657  if(fMaxDiffTRKV0Centr>0.){
658  Double_t v0cent=GetCentrality((AliAODEvent*)event,kCentV0M);
659  Double_t trkcent=GetCentrality((AliAODEvent*)event,kCentTRK);
660  if(TMath::Abs(trkcent-v0cent)>fMaxDiffTRKV0Centr){
661  if(accept) fWhyRejection=1;
662  fEvRejectionBits+=1<<kBadTrackV0Correl;
663  accept=kFALSE;
664  }
665  }
666  }
667 
668  // Correcting PP2012 flag to remoce tracks crossing SPD misaligned staves for periods 12def
669  if(fApplySPDMisalignedPP2012 && !(event->GetRunNumber()>=195681 && event->GetRunNumber()<=197388)) fApplySPDMisalignedPP2012=false;
670 
671  return accept;
672 }
673 //---------------------------------------------------------------------------
674 Bool_t AliRDHFCuts::AreDaughtersSelected(AliAODRecoDecayHF *d, const AliAODEvent* aod) const{
675  //
676  // Daughter tracks selection
677  //
678  if(!fTrackCuts) return kTRUE;
679 
680  Int_t ndaughters = d->GetNDaughters();
681  AliAODVertex *vAOD = d->GetPrimaryVtx();
682  Double_t pos[3],cov[6];
683  vAOD->GetXYZ(pos);
684  vAOD->GetCovarianceMatrix(cov);
685  const AliESDVertex vESD(pos,cov,100.,100);
686 
687  Bool_t retval=kTRUE;
688 
689  for(Int_t idg=0; idg<ndaughters; idg++) {
690  AliAODTrack *dgTrack = (AliAODTrack*)d->GetDaughter(idg);
691  if(!dgTrack) {retval = kFALSE; continue;}
692  //printf("charge %d\n",dgTrack->Charge());
693  if(dgTrack->Charge()==0) continue; // it's not a track, but a V0
694 
695  if(fIsCandTrackSPDFirst && d->Pt()<fMaxPtCandTrackSPDFirst)
696  { if(!dgTrack->HasPointOnITSLayer(0)) { retval = kFALSE; continue; } }
697 
698  if(!IsDaughterSelected(dgTrack,&vESD,fTrackCuts,aod)) retval = kFALSE;
699  }
700 
701  return retval;
702 }
703 //---------------------------------------------------------------------------
704 Int_t AliRDHFCuts::CheckMatchingAODdeltaAODevents(){
705  //
706  // Check if AOD and deltaAOD files are composed of the same events:
707  // mismatches were observed in the merged AODs of LHC15o
708  //
709  // When AOD+deltaAOD are produced from ESD, mismatches can be found looking at:
710  // - the AOD trees in AliAOD.root and AliAOD.VertexingHF.root have different number of entries
711  // - the titles of the TProcessID objects do not match
712  // When deltaAOD are produced from AOD, mismatches can be found looking at:
713  // - the AOD trees in AliAOD.root and AliAOD.VertexingHF.root have different number of entries
714  //
715  // Return values:
716  // -1: AOD and deltaAOD trees have different number of entries
717  // 0: AOD and deltaAOD trees have same number of entries + the titles of the TProcessID objects do not match
718  // 1: AOD and deltaAOD trees have same number of entries + the titles of the TProcessID objects match
719  Bool_t okTProcessNames = kTRUE;
720  AliAODHandler* aodHandler = (AliAODHandler*)((AliAnalysisManager::GetAnalysisManager())->GetInputEventHandler());
721  TTree *treeAOD = aodHandler->GetTree();
722  TTree *treeDeltaAOD = treeAOD->GetFriend("aodTree");
723  if(!treeDeltaAOD || !treeAOD) return -1;
724  if(treeDeltaAOD && treeAOD){
725  if(treeAOD->GetEntries()!=treeDeltaAOD->GetEntries()){
726  printf("AliRDHFCuts::CheckMatchingAODdeltaAODevents: Difference in number of entries in main and friend tree, skipping event\n");
727  return -1;
728  }
729  TFile *mfile = treeAOD->GetCurrentFile();
730  TFile *dfile = treeDeltaAOD->GetCurrentFile();
731  TList* lm=mfile->GetListOfKeys();
732  TList* ld=dfile->GetListOfKeys();
733  Int_t nentm=lm->GetEntries();
734  Int_t nentd=ld->GetEntries();
735  for(Int_t jm=0; jm<nentm; jm++){
736  TKey* o=(TKey*)lm->At(jm);
737  TString clnam=o->GetClassName();
738  if(clnam=="TProcessID"){
739  TString pname=o->GetName();
740  TString ptit=o->GetTitle();
741  if(pname.Contains("ProcessID")){
742  TObject* od=(TObject*)ld->FindObject(pname.Data());
743  if(od){
744  TString ptit2=od->GetTitle();
745  if(ptit2!=ptit){
746  printf("AliRDHFCuts::CheckMatchingAODdeltaAODevents: mismatch in %s: AOD: %s -- deltaAOD: %s\n",pname.Data(),ptit.Data(),ptit2.Data());
747  okTProcessNames = kFALSE;
748  }
749  }
750  }
751  }
752  }
753  }
754 
755  if (okTProcessNames) return 1;
756  else return 0;
757 }
758 //---------------------------------------------------------------------------
759 Bool_t AliRDHFCuts::CheckPtDepCrossedRows(TString rows,Bool_t print) const {
760  //
761  // Check the correctness of the string syntax
762  //
763  Bool_t retval=kTRUE;
764 
765  if(!rows.Contains("pt")) {
766  if(print) AliError("string must contain \"pt\"");
767  retval= kFALSE;
768  }
769  return retval;
770 }
771 //---------------------------------------------------------------------------
772 void AliRDHFCuts::SetMinCrossedRowsTPCPtDep(const char *rows){
773  //
774  //Create the TFormula from TString for TPC crossed rows pT dependent cut
775  //
776 
777 
778  // setting data member that describes the TPC crossed rows pT dependent cut
779  fCutMinCrossedRowsTPCPtDep = rows;
780 
781  // creating TFormula from TString
782  if(f1CutMinNCrossedRowsTPCPtDep){
783  delete f1CutMinNCrossedRowsTPCPtDep;
784  // resetting TFormula
785  f1CutMinNCrossedRowsTPCPtDep = 0;
786  }
787  if(!CheckPtDepCrossedRows(rows,kTRUE))return;
788 
789  TString tmp(rows);
790  tmp.ReplaceAll("pt","x");
791  f1CutMinNCrossedRowsTPCPtDep = new TFormula("f1CutMinNCrossedRowsTPCPtDep",tmp.Data());
792 
793 
794 }
795 //---------------------------------------------------------------------------
796 Bool_t AliRDHFCuts::IsDaughterSelected(AliAODTrack *track,const AliESDVertex *primary,AliESDtrackCuts *cuts, const AliAODEvent* aod) const{
797  //
798  // Convert to ESDtrack, relate to vertex and check cuts
799  //
800  if(!cuts) return kTRUE;
801 
802  if(cuts->GetFlagCutTOFdistance()) cuts->SetFlagCutTOFdistance(kFALSE);
803 
804 
805  // convert to ESD track here
806  AliESDtrack esdTrack(track);
807  // set the TPC cluster info
808  esdTrack.SetTPCClusterMap(track->GetTPCClusterMap());
809  esdTrack.SetTPCSharedMap(track->GetTPCSharedMap());
810  esdTrack.SetTPCPointsF(track->GetTPCNclsF());
811  // needed to calculate the impact parameters
812  esdTrack.RelateToVertex(primary,0.,3.);
813 
814  //applying ESDtrackCut
815  if(!cuts->IsSelected(&esdTrack)) return kFALSE;
816 
817  //appliyng kink rejection
818  if(fKinkReject){
819  AliAODVertex *maybeKink=track->GetProdVertex();
820  if(maybeKink->GetType()==AliAODVertex::kKink) return kFALSE;
821  }
822 
823  //appliyng TPC crossed rows pT dependent cut
824  if(f1CutMinNCrossedRowsTPCPtDep){
825  Float_t nCrossedRowsTPC = esdTrack.GetTPCCrossedRows();
826  if(nCrossedRowsTPC<f1CutMinNCrossedRowsTPCPtDep->Eval(esdTrack.Pt())) return kFALSE;
827  }
828 
829  //appliyng NTPCcls/NTPCcrossedRows cut
830  if(fCutRatioClsOverCrossRowsTPC){
831  Float_t nCrossedRowsTPC = esdTrack.GetTPCCrossedRows();
832  Float_t nClustersTPC = esdTrack.GetTPCNcls();
833  if(nCrossedRowsTPC!=0){
834  Float_t ratio = nClustersTPC/nCrossedRowsTPC;
835  if(ratio<fCutRatioClsOverCrossRowsTPC) return kFALSE;
836  }
837  else return kFALSE;
838  }
839 
840  //appliyng TPCsignalN/NTPCcrossedRows cut
841  if(fCutRatioSignalNOverCrossRowsTPC){
842  Float_t nCrossedRowsTPC = esdTrack.GetTPCCrossedRows();
843  Float_t nTPCsignal = esdTrack.GetTPCsignalN();
844  if(nCrossedRowsTPC!=0){
845  Float_t ratio = nTPCsignal/nCrossedRowsTPC;
846  if(ratio<fCutRatioSignalNOverCrossRowsTPC) return kFALSE;
847  }
848  else return kFALSE;
849  }
850 
851  // geometrical cut (note uses track at vertex instead of at TPC inner wall)
852  if(fUseCutGeoNcrNcl && aod){
853  Float_t nCrossedRowsTPC = esdTrack.GetTPCCrossedRows();
854  Float_t lengthInActiveZoneTPC=esdTrack.GetLengthInActiveZone(0,fDeadZoneWidth,220.,aod->GetMagneticField());
855  Double_t cutGeoNcrNclLength=fCutGeoNcrNclLength-TMath::Power(TMath::Abs(esdTrack.GetSigned1Pt()),fCutGeoNcrNclGeom1Pt);
856  Bool_t isOK=kTRUE;
857  if (lengthInActiveZoneTPC<cutGeoNcrNclLength) isOK=kFALSE;
858  if (nCrossedRowsTPC<fCutGeoNcrNclFractionNcr*cutGeoNcrNclLength) isOK=kFALSE;
859  if (esdTrack.GetTPCncls()<fCutGeoNcrNclFractionNcl*cutGeoNcrNclLength) isOK=kFALSE;
860  if(!isOK) return kFALSE;
861  }
862 
863 
864  if(fOptPileup==kRejectTracksFromPileupVertex){
865  // to be implemented
866  // we need either to have here the AOD Event,
867  // or to have the pileup vertex object
868  }
869 
870  if(fApplySPDDeadPbPb2011){
871  Bool_t deadSPDLay1PbPb2011[20][4]={
872  {kTRUE,kTRUE,kTRUE,kTRUE},
873  {kTRUE,kTRUE,kTRUE,kTRUE},
874  {kTRUE,kTRUE,kTRUE,kTRUE},
875  {kTRUE,kTRUE,kTRUE,kTRUE},
876  {kTRUE,kTRUE,kTRUE,kTRUE},
877  {kFALSE,kFALSE,kTRUE,kTRUE},
878  {kTRUE,kTRUE,kFALSE,kFALSE},
879  {kTRUE,kTRUE,kTRUE,kTRUE},
880  {kFALSE,kFALSE,kTRUE,kTRUE},
881  {kTRUE,kTRUE,kTRUE,kTRUE},
882  {kTRUE,kTRUE,kFALSE,kFALSE},
883  {kTRUE,kTRUE,kTRUE,kTRUE},
884  {kFALSE,kFALSE,kFALSE,kFALSE},
885  {kFALSE,kFALSE,kTRUE,kTRUE},
886  {kFALSE,kFALSE,kFALSE,kFALSE},
887  {kFALSE,kFALSE,kFALSE,kFALSE},
888  {kTRUE,kTRUE,kTRUE,kTRUE},
889  {kTRUE,kTRUE,kFALSE,kFALSE},
890  {kFALSE,kFALSE,kFALSE,kFALSE},
891  {kFALSE,kFALSE,kFALSE,kFALSE}
892  };
893  Bool_t deadSPDLay2PbPb2011[40][4]={
894  {kTRUE,kTRUE,kTRUE,kTRUE},
895  {kTRUE,kTRUE,kTRUE,kTRUE},
896  {kTRUE,kTRUE,kTRUE,kTRUE},
897  {kTRUE,kTRUE,kTRUE,kTRUE},
898  {kTRUE,kTRUE,kTRUE,kTRUE},
899  {kTRUE,kTRUE,kTRUE,kTRUE},
900  {kTRUE,kTRUE,kTRUE,kTRUE},
901  {kTRUE,kTRUE,kTRUE,kTRUE},
902  {kTRUE,kTRUE,kTRUE,kTRUE},
903  {kTRUE,kTRUE,kTRUE,kTRUE},
904  {kTRUE,kTRUE,kTRUE,kTRUE},
905  {kTRUE,kTRUE,kTRUE,kTRUE},
906  {kFALSE,kFALSE,kFALSE,kFALSE},
907  {kFALSE,kFALSE,kTRUE,kTRUE},
908  {kTRUE,kTRUE,kTRUE,kTRUE},
909  {kTRUE,kTRUE,kTRUE,kTRUE},
910  {kTRUE,kTRUE,kFALSE,kFALSE},
911  {kTRUE,kTRUE,kTRUE,kTRUE},
912  {kTRUE,kTRUE,kTRUE,kTRUE},
913  {kTRUE,kTRUE,kTRUE,kTRUE},
914  {kFALSE,kFALSE,kFALSE,kFALSE},
915  {kFALSE,kFALSE,kFALSE,kFALSE},
916  {kTRUE,kTRUE,kTRUE,kTRUE},
917  {kTRUE,kTRUE,kTRUE,kTRUE},
918  {kFALSE,kFALSE,kFALSE,kFALSE},
919  {kFALSE,kFALSE,kFALSE,kFALSE},
920  {kTRUE,kTRUE,kTRUE,kTRUE},
921  {kTRUE,kTRUE,kTRUE,kTRUE},
922  {kFALSE,kFALSE,kFALSE,kFALSE},
923  {kFALSE,kFALSE,kFALSE,kFALSE},
924  {kFALSE,kFALSE,kFALSE,kFALSE},
925  {kFALSE,kFALSE,kFALSE,kFALSE},
926  {kTRUE,kTRUE,kTRUE,kTRUE},
927  {kTRUE,kTRUE,kTRUE,kTRUE},
928  {kTRUE,kTRUE,kFALSE,kFALSE},
929  {kTRUE,kTRUE,kTRUE,kTRUE},
930  {kFALSE,kFALSE,kFALSE,kFALSE},
931  {kFALSE,kFALSE,kFALSE,kFALSE},
932  {kFALSE,kFALSE,kFALSE,kFALSE},
933  {kFALSE,kFALSE,kFALSE,kFALSE}
934  };
935  Double_t xyz1[3],xyz2[3];
936  esdTrack.GetXYZAt(3.9,0.,xyz1);
937  esdTrack.GetXYZAt(7.6,0.,xyz2);
938  Double_t phi1=TMath::ATan2(xyz1[1],xyz1[0]);
939  if(phi1<0) phi1+=2*TMath::Pi();
940  Int_t lad1=(Int_t)(phi1/(2.*TMath::Pi()/20.));
941  Double_t phi2=TMath::ATan2(xyz2[1],xyz2[0]);
942  if(phi2<0) phi2+=2*TMath::Pi();
943  Int_t lad2=(Int_t)(phi2/(2.*TMath::Pi()/40.));
944  Int_t mod1=(Int_t)((xyz1[2]+14)/7.);
945  Int_t mod2=(Int_t)((xyz2[2]+14)/7.);
946  Bool_t lay1ok=kFALSE;
947  if(mod1>=0 && mod1<4 && lad1<20){
948  lay1ok=deadSPDLay1PbPb2011[lad1][mod1];
949  }
950  Bool_t lay2ok=kFALSE;
951  if(mod2>=0 && mod2<4 && lad2<40){
952  lay2ok=deadSPDLay2PbPb2011[lad2][mod2];
953  }
954  if(!lay1ok && !lay2ok) return kFALSE;
955  }
956 
957  if(fApplySPDMisalignedPP2012) {
958  // Cut tracks crossing the SPD at 5.6<phi<2pi
959  Double_t xyz1[3],xyz2[3];
960  esdTrack.GetXYZAt(3.9,0.,xyz1);
961  esdTrack.GetXYZAt(7.6,0.,xyz2);
962  Double_t phi1=TMath::ATan2(xyz1[1],xyz1[0]);
963  if(phi1<0) phi1+=2*TMath::Pi();
964  Double_t phi2=TMath::ATan2(xyz2[1],xyz2[0]);
965  if(phi2<0) phi2+=2*TMath::Pi();
966  Bool_t lay1ok=kTRUE;
967  if(phi1>5.6 && phi1<2.*TMath::Pi()) lay1ok=kFALSE;
968  Bool_t lay2ok=kTRUE;
969  if(phi2>5.6 && phi2<2.*TMath::Pi()) lay2ok=kFALSE;
970  if(!lay1ok || !lay2ok) return kFALSE;
971  }
972 
973  return kTRUE;
974 }
975 //---------------------------------------------------------------------------
976 void AliRDHFCuts::SetPtBins(Int_t nPtBinLimits,Float_t *ptBinLimits) {
977  // Set the pt bins
978 
979  if(fPtBinLimits) {
980  delete [] fPtBinLimits;
981  fPtBinLimits = NULL;
982  printf("Changing the pt bins\n");
983  }
984 
985  if(nPtBinLimits != fnPtBins+1){
986  cout<<"Warning: ptBinLimits dimention "<<nPtBinLimits<<" != nPtBins+1 ("<<fnPtBins+1<<")\nSetting nPtBins to "<<nPtBinLimits-1<<endl;
987  SetNPtBins(nPtBinLimits-1);
988  }
989 
990  fnPtBinLimits = nPtBinLimits;
991  SetGlobalIndex();
992  //cout<<"Changing also Global Index -> "<<fGlobalIndex<<endl;
993  fPtBinLimits = new Float_t[fnPtBinLimits];
994  for(Int_t ib=0; ib<nPtBinLimits; ib++) fPtBinLimits[ib]=ptBinLimits[ib];
995 
996  return;
997 }
998 //---------------------------------------------------------------------------
999 void AliRDHFCuts::SetVarNames(Int_t nVars,TString *varNames,Bool_t *isUpperCut){
1000  // Set the variable names
1001 
1002  if(fVarNames) {
1003  delete [] fVarNames;
1004  fVarNames = NULL;
1005  //printf("Changing the variable names\n");
1006  }
1007  if(nVars!=fnVars){
1008  printf("Wrong number of variables: it has to be %d\n",fnVars);
1009  return;
1010  }
1011  //fnVars=nVars;
1012  fVarNames = new TString[nVars];
1013  fIsUpperCut = new Bool_t[nVars];
1014  for(Int_t iv=0; iv<nVars; iv++) {
1015  fVarNames[iv] = varNames[iv];
1016  fIsUpperCut[iv] = isUpperCut[iv];
1017  }
1018 
1019  return;
1020 }
1021 //---------------------------------------------------------------------------
1022 void AliRDHFCuts::SetVarsForOpt(Int_t nVars,Bool_t *forOpt) {
1023  // Set the variables to be used for cuts optimization
1024 
1025  if(fVarsForOpt) {
1026  delete [] fVarsForOpt;
1027  fVarsForOpt = NULL;
1028  //printf("Changing the variables for cut optimization\n");
1029  }
1030 
1031  if(nVars==0){
1032  printf("%d not accepted as number of variables: it has to be %d\n",nVars,fnVars);
1033  return;
1034  }
1035 
1036  fnVarsForOpt = 0;
1037  fVarsForOpt = new Bool_t[fnVars];
1038  for(Int_t iv=0; iv<fnVars; iv++) {
1039  fVarsForOpt[iv]=forOpt[iv];
1040  if(fVarsForOpt[iv]) fnVarsForOpt++;
1041  }
1042 
1043  return;
1044 }
1045 
1046 //---------------------------------------------------------------------------
1047 void AliRDHFCuts::SetUseCentrality(Int_t flag) {
1048  //
1049  // set centrality estimator
1050  //
1051  fUseCentrality=flag;
1052  if(fUseCentrality<kCentOff||fUseCentrality>=kCentInvalid) AliWarning("Centrality estimator not valid");
1053 
1054  return;
1055 }
1056 
1057 
1058 //---------------------------------------------------------------------------
1059 void AliRDHFCuts::SetCuts(Int_t nVars,Int_t nPtBins,Float_t **cutsRD) {
1060  //
1061  // store the cuts
1062  //
1063  if(nVars!=fnVars) {
1064  printf("Wrong number of variables: it has to be %d\n",fnVars);
1065  AliFatal("exiting");
1066  }
1067  if(nPtBins!=fnPtBins) {
1068  printf("Wrong number of pt bins: it has to be %d\n",fnPtBins);
1069  AliFatal("exiting");
1070  }
1071 
1072  if(!fCutsRD) fCutsRD = new Float_t[fGlobalIndex];
1073 
1074 
1075  for(Int_t iv=0; iv<fnVars; iv++) {
1076 
1077  for(Int_t ib=0; ib<fnPtBins; ib++) {
1078 
1079  //check
1080  if(GetGlobalIndex(iv,ib)>=fGlobalIndex) {
1081  cout<<"Overflow, exit..."<<endl;
1082  return;
1083  }
1084 
1085  fCutsRD[GetGlobalIndex(iv,ib)] = cutsRD[iv][ib];
1086 
1087  }
1088  }
1089  return;
1090 }
1091 //---------------------------------------------------------------------------
1092 void AliRDHFCuts::SetCuts(Int_t glIndex,Float_t* cutsRDGlob){
1093  //
1094  // store the cuts
1095  //
1096  if(glIndex != fGlobalIndex){
1097  cout<<"Wrong array size: it has to be "<<fGlobalIndex<<endl;
1098  AliFatal("exiting");
1099  }
1100  if(!fCutsRD) fCutsRD = new Float_t[fGlobalIndex];
1101 
1102  for(Int_t iGl=0;iGl<fGlobalIndex;iGl++){
1103  fCutsRD[iGl] = cutsRDGlob[iGl];
1104  }
1105  return;
1106 }
1107 //---------------------------------------------------------------------------
1108 void AliRDHFCuts::PrintAll() const {
1109  //
1110  // print all cuts values
1111  //
1112 
1113  printf("Minimum vtx type %d\n",fMinVtxType);
1114  printf("Minimum vtx contr %d\n",fMinVtxContr);
1115  printf("Max vtx red chi2 %f\n",fMaxVtxRedChi2);
1116  printf("Min SPD mult %d\n",fMinSPDMultiplicity);
1117  printf("Use PID %d OldPid=%d\n",(Int_t)fUsePID,fPidHF ? fPidHF->GetOldPid() : -1);
1118  printf("Remove daughters from vtx %d\n",(Int_t)fRemoveDaughtersFromPrimary);
1119  printf("Physics selection: %s\n",fUsePhysicsSelection ? "Yes" : "No");
1120  printf("Pileup rejection: %s\n",(fOptPileup > 0) ? "Yes" : "No");
1121  if(fOptPileup==1) printf(" -- Reject pileup event");
1122  if(fOptPileup==2) printf(" -- Reject tracks from pileup vtx");
1123  if(fUseCentrality>0) {
1124  TString estimator="";
1125  if(fUseCentrality==1) estimator = "V0";
1126  if(fUseCentrality==2) estimator = "Tracks";
1127  if(fUseCentrality==3) estimator = "Tracklets";
1128  if(fUseCentrality==4) estimator = "SPD clusters outer";
1129  if(fUseCentrality==5) estimator = "ZNA";
1130  if(fUseCentrality==6) estimator = "ZPA";
1131  if(fUseCentrality==7) estimator = "V0A";
1132  printf("Centrality class considered: %.1f-%.1f, estimated with %s\n",fMinCentrality,fMaxCentrality,estimator.Data());
1133  }
1134  if(fIsCandTrackSPDFirst) printf("Check for candidates with pt < %2.2f, that daughters fullfill kFirst criteria\n",fMaxPtCandTrackSPDFirst);
1135 
1136  if(fCutRatioClsOverCrossRowsTPC) printf("N TPC Clusters > %f N TPC Crossed Rows\n", fCutRatioClsOverCrossRowsTPC);
1137  if(fCutRatioSignalNOverCrossRowsTPC) printf("N TPC Points for dE/dx > %f N TPC Crossed Rows\n", fCutRatioSignalNOverCrossRowsTPC);
1138  if(f1CutMinNCrossedRowsTPCPtDep) printf("N TPC Crossed Rows pT-dependent cut: %s\n", fCutMinCrossedRowsTPCPtDep.Data());
1139 
1140  if(fVarNames){
1141  cout<<"Array of variables"<<endl;
1142  for(Int_t iv=0;iv<fnVars;iv++){
1143  cout<<fVarNames[iv]<<"\t";
1144  }
1145  cout<<endl;
1146  }
1147  if(fVarsForOpt){
1148  cout<<"Array of optimization"<<endl;
1149  for(Int_t iv=0;iv<fnVars;iv++){
1150  cout<<fVarsForOpt[iv]<<"\t";
1151  }
1152  cout<<endl;
1153  }
1154  if(fIsUpperCut){
1155  cout<<"Array of upper/lower cut"<<endl;
1156  for(Int_t iv=0;iv<fnVars;iv++){
1157  cout<<fIsUpperCut[iv]<<"\t";
1158  }
1159  cout<<endl;
1160  }
1161  if(fPtBinLimits){
1162  cout<<"Array of ptbin limits"<<endl;
1163  for(Int_t ib=0;ib<fnPtBinLimits;ib++){
1164  cout<<fPtBinLimits[ib]<<"\t";
1165  }
1166  cout<<endl;
1167  }
1168  if(fCutsRD){
1169  cout<<"Matrix of cuts"<<endl;
1170  for(Int_t iv=0;iv<fnVars;iv++){
1171  for(Int_t ib=0;ib<fnPtBins;ib++){
1172  cout<<"fCutsRD["<<iv<<"]["<<ib<<"] = "<<fCutsRD[GetGlobalIndex(iv,ib)]<<"\t";
1173  }
1174  cout<<endl;
1175  }
1176  cout<<endl;
1177  }
1178  if(fPidHF) fPidHF->PrintAll();
1179  return;
1180 }
1181 
1182 //--------------------------------------------------------------------------
1183 void AliRDHFCuts::PrintTrigger() const{
1184  // print the trigger selection
1185 
1186  printf("Selected trigger classes: %s %s\n",fTriggerClass[0].Data(),fTriggerClass[1].Data());
1187 
1188  cout<<" Trigger selection pattern: ";
1189  if( fTriggerMask & AliVEvent::kAny ) cout<<" kAny ";
1190  if( fTriggerMask & AliVEvent::kAnyINT ) cout<<" kAnyINT ";
1191  if( fTriggerMask & AliVEvent::kINT7 ) cout<<" kINT7 ";
1192  if( fTriggerMask & AliVEvent::kMB ) cout<<" kMB ";
1193  if( fTriggerMask & AliVEvent::kCINT5 ) cout<<" kCINT5 ";
1194  if( fTriggerMask & AliVEvent::kCentral ) cout<<" kCentral ";
1195  if( fTriggerMask & AliVEvent::kSemiCentral ) cout<<" kSemiCentral ";
1196  if( fTriggerMask & AliVEvent::kEMCEGA ) cout<<" kEMCEGA ";
1197  if( fTriggerMask & AliVEvent::kHighMult ) cout<<" kHighMult ";
1198  if( fTriggerMask & AliVEvent::kFastOnly ) cout<<" kFastOnly ";
1199  cout << endl<< endl;
1200 
1201 }
1202 
1203 //---------------------------------------------------------------------------
1204 void AliRDHFCuts::GetCuts(Float_t**& cutsRD) const{
1205  //
1206  // get the cuts
1207  //
1208 
1209  //cout<<"Give back a "<<fnVars<<"x"<<fnPtBins<<" matrix."<<endl;
1210 
1211 
1212  Int_t iv,ib;
1213  if(!cutsRD) {
1214  //cout<<"Initialization..."<<endl;
1215  cutsRD=new Float_t*[fnVars];
1216  for(iv=0; iv<fnVars; iv++) {
1217  cutsRD[iv] = new Float_t[fnPtBins];
1218  }
1219  }
1220 
1221  for(Int_t iGlobal=0; iGlobal<fGlobalIndex; iGlobal++) {
1222  GetVarPtIndex(iGlobal,iv,ib);
1223  cutsRD[iv][ib] = fCutsRD[iGlobal];
1224  }
1225 
1226  return;
1227 }
1228 
1229 //---------------------------------------------------------------------------
1230 Int_t AliRDHFCuts::GetGlobalIndex(Int_t iVar,Int_t iPtBin) const{
1231  //
1232  // give the global index from variable and pt bin
1233  //
1234  return iPtBin*fnVars+iVar;
1235 }
1236 
1237 //---------------------------------------------------------------------------
1238 void AliRDHFCuts::GetVarPtIndex(Int_t iGlob, Int_t& iVar, Int_t& iPtBin) const {
1239  //
1240  //give the index of the variable and of the pt bin from the global index
1241  //
1242  iPtBin=(Int_t)iGlob/fnVars;
1243  iVar=iGlob%fnVars;
1244 
1245  return;
1246 }
1247 
1248 //---------------------------------------------------------------------------
1249 Int_t AliRDHFCuts::PtBin(Double_t pt) const {
1250  //
1251  //give the pt bin where the pt lies.
1252  //
1253  Int_t ptbin=-1;
1254  if(pt<fPtBinLimits[0])return ptbin;
1255  for (Int_t i=0;i<fnPtBins;i++){
1256  if(pt<fPtBinLimits[i+1]) {
1257  ptbin=i;
1258  break;
1259  }
1260  }
1261  return ptbin;
1262 }
1263 //-------------------------------------------------------------------
1264 Float_t AliRDHFCuts::GetCutValue(Int_t iVar,Int_t iPtBin) const {
1265  //
1266  // Give the value of cut set for the variable iVar and the pt bin iPtBin
1267  //
1268  if(!fCutsRD){
1269  cout<<"Cuts not iniziaisez yet"<<endl;
1270  return 0;
1271  }
1272  return fCutsRD[GetGlobalIndex(iVar,iPtBin)];
1273 }
1274 
1275 //-------------------------------------------------------------------
1276 Float_t AliRDHFCuts::GetCentrality(AliAODEvent* aodEvent,AliRDHFCuts::ECentrality estimator) {
1277 
1278  if(aodEvent->GetRunNumber()<244824)return GetCentralityOldFramework(aodEvent,estimator);
1279  Double_t cent=-999;
1280 
1281  AliMultSelection *multSelection = (AliMultSelection*)aodEvent->FindListObject(fMultSelectionObjectName);
1282  if(!multSelection){
1283  AliWarning("AliMultSelection could not be found in the aod event list of objects");
1284  return cent;
1285  }
1286 
1287  // Compare centrality with the centrality at AOD filtering and on-the-fly
1288  if( fMultSelectionObjectName.CompareTo("MultSelection")!=0 ){
1289  AliMultSelection *defaultmultSelection = (AliMultSelection*)aodEvent->FindListObject("MultSelection");
1290  if(!defaultmultSelection){
1291  AliWarning("AliMultSelection default method could not be found in the aod event list of objects");
1292  return cent;
1293  }
1294  Float_t defaultCent = defaultmultSelection->GetMultiplicityPercentile("V0M");
1295  Float_t newCent = multSelection->GetMultiplicityPercentile("V0M");
1296  if( defaultCent<20. && newCent>20.) fEvRejectionBits+=1<<kMismatchOldNewCentrality;
1297  else if (defaultCent>20. && newCent<20.) fEvRejectionBits+=1<<kMismatchOldNewCentrality;
1298  }
1299 
1300  if(estimator==kCentV0M){
1301  cent=multSelection->GetMultiplicityPercentile("V0M");
1302  Int_t qual = multSelection->GetEvSelCode();
1303  if(qual == 199 ) cent=-999;
1304  return cent;
1305  }
1306  else {
1307  AliWarning(Form("CENTRALITY ESTIMATE WITH ESTIMATEOR %d NOT YET IMPLEMENTED FOR NEW FRAMEWORK",(Int_t)estimator));
1308  return cent;
1309  }
1310 
1311 }
1312 //-------------------------------------------------------------------
1313 Float_t AliRDHFCuts::GetCentralityOldFramework(AliAODEvent* aodEvent,AliRDHFCuts::ECentrality estimator) {
1314  //
1315  // Get centrality percentile
1316  //
1317 
1318  TClonesArray *mcArray = (TClonesArray*)((AliAODEvent*)aodEvent)->GetList()->FindObject(AliAODMCParticle::StdBranchName());
1319  if(mcArray) {fUseAOD049=kFALSE;}
1320 
1321  AliAODHeader *header=dynamic_cast<AliAODHeader*>(aodEvent->GetHeader());
1322  if(!header) AliFatal("Not a standard AOD");
1323  AliCentrality *centrality=header->GetCentralityP();
1324  Float_t cent=-999.;
1325  Bool_t isSelRun=kFALSE;
1326  Int_t selRun[5]={138364, 138826, 138828, 138836, 138871};
1327  if(!centrality) return cent;
1328  else{
1329  if (estimator==kCentV0M){
1330  cent=(Float_t)(centrality->GetCentralityPercentile("V0M"));
1331  if(cent<0){
1332  Int_t quality = centrality->GetQuality();
1333  if(quality<=1){ // fQuality==1 means rejected by zVertex cut that we apply a part and we want to keep separate (Giacomo)
1334  cent=(Float_t)centrality->GetCentralityPercentileUnchecked("V0M");
1335  }else{
1336  Int_t runnum=aodEvent->GetRunNumber();
1337  for(Int_t ir=0;ir<5;ir++){
1338  if(runnum==selRun[ir]){
1339  isSelRun=kTRUE;
1340  break;
1341  }
1342  }
1343  if((quality==8||quality==9)&&isSelRun)cent=(Float_t)centrality->GetCentralityPercentileUnchecked("V0M");
1344  }
1345  }
1346 
1347  //temporary fix for AOD049 outliers
1348  if(fUseAOD049&&cent>=0){
1349  Float_t v0=0;
1350  AliAODVZERO* aodV0 = aodEvent->GetVZEROData();
1351  v0+=aodV0->GetMTotV0A();
1352  v0+=aodV0->GetMTotV0C();
1353  if(cent==0&&v0<19500)return -1;//filtering issue
1354  Float_t tkl = (Float_t)(aodEvent->GetTracklets()->GetNumberOfTracklets());
1355  Float_t val= 1.30552 + 0.147931 * v0;
1356  Float_t tklSigma[101]={176.644, 156.401, 153.789, 153.015, 142.476, 137.951, 136.127, 129.852, 127.436, 124.86, 120.788, 115.611, 113.172, 110.496, 109.127, 104.421, 102.479, 99.9766, 97.5152, 94.0654, 92.4602, 89.3364, 87.1342, 83.3497, 82.6216, 81.1084, 78.0793, 76.1234, 72.9434, 72.1334, 68.0056, 68.2755, 66.0376, 62.9666, 62.4274, 59.65, 58.3776, 56.6361, 54.5184, 53.4224, 51.932, 50.8922, 48.2848, 47.912, 46.5717, 43.4114, 43.2083, 41.3065, 40.1863, 38.5255, 37.2851, 37.5396, 34.4949, 33.8366, 31.8043, 31.7412, 30.8392, 30.0274, 28.8793, 27.6398, 26.6488, 25.0183, 25.1489, 24.4185, 22.9107, 21.2002, 21.6977, 20.1242, 20.4963, 19.0235, 19.298, 17.4103, 16.868, 15.2939, 15.2939, 16.0295, 14.186, 14.186, 15.2173, 12.9504, 12.9504, 12.9504, 15.264, 12.3674, 12.3674, 12.3674, 12.3674, 12.3674, 18.3811, 13.7544, 13.7544, 13.7544, 13.7544, 13.7544, 13.7544, 13.7544, 13.7544, 13.7544, 13.7544, 13.7544, 13.7544};
1357  if ( TMath::Abs(tkl-val) > 6.*tklSigma[(Int_t)cent] )return -1;//outlier
1358  }
1359  }
1360  else {
1361  if (estimator==kCentTRK) {
1362  cent=(Float_t)(centrality->GetCentralityPercentile("TRK"));
1363  if(cent<0){
1364  Int_t quality = centrality->GetQuality();
1365  if(quality<=1){
1366  cent=(Float_t)centrality->GetCentralityPercentileUnchecked("TRK");
1367  }else{
1368  Int_t runnum=aodEvent->GetRunNumber();
1369  for(Int_t ir=0;ir<5;ir++){
1370  if(runnum==selRun[ir]){
1371  isSelRun=kTRUE;
1372  break;
1373  }
1374  }
1375  if((quality==8||quality==9)&&isSelRun)cent=(Float_t)centrality->GetCentralityPercentileUnchecked("TRK");
1376  }
1377  }
1378  }
1379  else{
1380  if (estimator==kCentTKL){
1381  cent=(Float_t)(centrality->GetCentralityPercentile("TKL"));
1382  if(cent<0){
1383  Int_t quality = centrality->GetQuality();
1384  if(quality<=1){
1385  cent=(Float_t)centrality->GetCentralityPercentileUnchecked("TKL");
1386  }else{
1387  Int_t runnum=aodEvent->GetRunNumber();
1388  for(Int_t ir=0;ir<5;ir++){
1389  if(runnum==selRun[ir]){
1390  isSelRun=kTRUE;
1391  break;
1392  }
1393  }
1394  if((quality==8||quality==9)&&isSelRun)cent=(Float_t)centrality->GetCentralityPercentileUnchecked("TKL");
1395  }
1396  }
1397  }
1398  else{
1399  if (estimator==kCentCL1){
1400  cent=(Float_t)(centrality->GetCentralityPercentile("CL1"));
1401  if(cent<0){
1402  Int_t quality = centrality->GetQuality();
1403  if(quality<=1){
1404  cent=(Float_t)centrality->GetCentralityPercentileUnchecked("CL1");
1405  }else{
1406  Int_t runnum=aodEvent->GetRunNumber();
1407  for(Int_t ir=0;ir<5;ir++){
1408  if(runnum==selRun[ir]){
1409  isSelRun=kTRUE;
1410  break;
1411  }
1412  }
1413  if((quality==8||quality==9)&&isSelRun)cent=(Float_t)centrality->GetCentralityPercentileUnchecked("CL1");
1414  }
1415  }
1416  }
1417  else{
1418  if (estimator==kCentZNA){
1419  cent=(Float_t)(centrality->GetCentralityPercentile("ZNA"));
1420  if(cent<0){
1421  Int_t quality = centrality->GetQuality();
1422  if(quality<=1){
1423  cent=(Float_t)centrality->GetCentralityPercentileUnchecked("ZNA");
1424  }else{
1425  Int_t runnum=aodEvent->GetRunNumber();
1426  for(Int_t ir=0;ir<5;ir++){
1427  if(runnum==selRun[ir]){
1428  isSelRun=kTRUE;
1429  break;
1430  }
1431  }
1432  if((quality==8||quality==9)&&isSelRun)cent=(Float_t)centrality->GetCentralityPercentileUnchecked("ZNA");
1433  }
1434  }
1435  }
1436  else{
1437  if (estimator==kCentZPA){
1438  cent=(Float_t)(centrality->GetCentralityPercentile("ZPA"));
1439  if(cent<0){
1440  Int_t quality = centrality->GetQuality();
1441  if(quality<=1){
1442  cent=(Float_t)centrality->GetCentralityPercentileUnchecked("ZPA");
1443  }else{
1444  Int_t runnum=aodEvent->GetRunNumber();
1445  for(Int_t ir=0;ir<5;ir++){
1446  if(runnum==selRun[ir]){
1447  isSelRun=kTRUE;
1448  break;
1449  }
1450  }
1451  if((quality==8||quality==9)&&isSelRun)cent=(Float_t)centrality->GetCentralityPercentileUnchecked("ZPA");
1452  }
1453  }
1454  }
1455  else{
1456  if (estimator==kCentV0A){
1457  cent=(Float_t)(centrality->GetCentralityPercentile("V0A"));
1458  if(cent<0){
1459  Int_t quality = centrality->GetQuality();
1460  if(quality<=1){
1461  cent=(Float_t)centrality->GetCentralityPercentileUnchecked("V0A");
1462  }else{
1463  Int_t runnum=aodEvent->GetRunNumber();
1464  for(Int_t ir=0;ir<5;ir++){
1465  if(runnum==selRun[ir]){
1466  isSelRun=kTRUE;
1467  break;
1468  }
1469  }
1470  if((quality==8||quality==9)&&isSelRun)cent=(Float_t)centrality->GetCentralityPercentileUnchecked("V0A");
1471  }
1472  }
1473  }
1474  else {
1475  AliWarning("Centrality estimator not valid");
1476 
1477  }
1478  }
1479  }
1480  }
1481  }
1482  }
1483  }
1484  }
1485  return cent;
1486 }
1487 //-------------------------------------------------------------------
1488 Bool_t AliRDHFCuts::CompareCuts(const AliRDHFCuts *obj) const {
1489  //
1490  // Compare two cuts objects
1491  //
1492 
1493  Bool_t areEqual=kTRUE;
1494 
1495  if(fMinVtxType!=obj->fMinVtxType) { printf("Minimum vtx type %d %d\n",fMinVtxType,obj->fMinVtxType); areEqual=kFALSE;}
1496 
1497  if(fMinVtxContr!=obj->fMinVtxContr) { printf("Minimum vtx contr %d %d\n",fMinVtxContr,obj->fMinVtxContr); areEqual=kFALSE;}
1498 
1499  if(TMath::Abs(fMaxVtxRedChi2-obj->fMaxVtxRedChi2)>1.e-10) { printf("Max vtx red chi2 %f %f\n",fMaxVtxRedChi2,obj->fMaxVtxRedChi2);areEqual=kFALSE;}
1500 
1501  if(fMinSPDMultiplicity!=obj->fMinSPDMultiplicity) { printf("Min SPD mult %d\n %d",fMinSPDMultiplicity,obj->fMinSPDMultiplicity);areEqual=kFALSE;}
1502 
1503  if(fUsePID!=obj->fUsePID) { printf("Use PID %d %d\n",(Int_t)fUsePID,(Int_t)obj->fUsePID); areEqual=kFALSE;}
1504 
1505  if(fRemoveDaughtersFromPrimary!=obj->fRemoveDaughtersFromPrimary) {printf("Remove daughters from vtx %d %d\n",(Int_t)fRemoveDaughtersFromPrimary,(Int_t)obj->fRemoveDaughtersFromPrimary); areEqual=kFALSE;}
1506  if(fTrackCuts){
1507  if(fTrackCuts->GetMinNClusterTPC()!=obj->fTrackCuts->GetMinNClusterTPC()) {printf("MinNClsTPC %d %d\n",fTrackCuts->GetMinNClusterTPC(),obj->fTrackCuts->GetMinNClusterTPC()); areEqual=kFALSE;}
1508 
1509  if(fTrackCuts->GetMinNClustersITS()!=obj->fTrackCuts->GetMinNClustersITS()) {printf("MinNClsITS %d %d\n",fTrackCuts->GetMinNClustersITS(),obj->fTrackCuts->GetMinNClustersITS()); areEqual=kFALSE;}
1510 
1511  if(TMath::Abs(fTrackCuts->GetMaxChi2PerClusterTPC()-obj->fTrackCuts->GetMaxChi2PerClusterTPC())>1.e-10) {printf("MaxChi2ClsTPC %f %f\n",fTrackCuts->GetMaxChi2PerClusterTPC(),obj->fTrackCuts->GetMaxChi2PerClusterTPC()); areEqual=kFALSE;}
1512 
1513  if(fTrackCuts->GetClusterRequirementITS(AliESDtrackCuts::kSPD)!=obj->fTrackCuts->GetClusterRequirementITS(AliESDtrackCuts::kSPD)) {printf("ClusterReq SPD %d %d\n",fTrackCuts->GetClusterRequirementITS(AliESDtrackCuts::kSPD),obj->fTrackCuts->GetClusterRequirementITS(AliESDtrackCuts::kSPD)); areEqual=kFALSE;}
1514  }
1515 
1516  if(fCutsRD) {
1517  for(Int_t iv=0;iv<fnVars;iv++) {
1518  for(Int_t ib=0;ib<fnPtBins;ib++) {
1519  if(TMath::Abs(fCutsRD[GetGlobalIndex(iv,ib)]-obj->fCutsRD[GetGlobalIndex(iv,ib)])>1.e-10) {
1520  cout<<"fCutsRD["<<iv<<"]["<<ib<<"] = "<<fCutsRD[GetGlobalIndex(iv,ib)]<<" "<<obj->fCutsRD[GetGlobalIndex(iv,ib)]<<"\n";
1521  areEqual=kFALSE;
1522  }
1523  }
1524  }
1525  }
1526 
1527  return areEqual;
1528 }
1529 //---------------------------------------------------------------------------
1530 void AliRDHFCuts::MakeTable() const {
1531  //
1532  // print cuts values in table format
1533  //
1534 
1535  TString ptString = "pT range";
1536  if(fVarNames && fPtBinLimits && fCutsRD){
1537  TString firstLine(Form("* %-15s",ptString.Data()));
1538  for (Int_t ivar=0; ivar<fnVars; ivar++){
1539  firstLine+=Form("* %-15s ",fVarNames[ivar].Data());
1540  if (ivar == fnVars){
1541  firstLine+="*\n";
1542  }
1543  }
1544  Printf("%s",firstLine.Data());
1545 
1546  for (Int_t ipt=0; ipt<fnPtBins; ipt++){
1547  TString line;
1548  if (ipt==fnPtBins-1){
1549  line=Form("* %5.1f < pt < inf ",fPtBinLimits[ipt]);
1550  }
1551  else{
1552  line=Form("* %5.1f < pt < %4.1f ",fPtBinLimits[ipt],fPtBinLimits[ipt+1]);
1553  }
1554  for (Int_t ivar=0; ivar<fnVars; ivar++){
1555  line+=Form("* %-15f ",fCutsRD[GetGlobalIndex(ivar,ipt)]);
1556  }
1557  Printf("%s",line.Data());
1558  }
1559 
1560  }
1561 
1562 
1563  return;
1564 }
1565 //--------------------------------------------------------------------------
1566 Bool_t AliRDHFCuts::RecalcOwnPrimaryVtx(AliAODRecoDecayHF *d,
1567  AliAODEvent *aod) const
1568 {
1569  //
1570  // Recalculate primary vertex without daughters
1571  //
1572 
1573  if(!aod) {
1574  AliError("Can not remove daughters from vertex without AOD event");
1575  return 0;
1576  }
1577 
1578  AliAODVertex *recvtx=d->RemoveDaughtersFromPrimaryVtx(aod);
1579  if(!recvtx){
1580  AliDebug(2,"Removal of daughter tracks failed");
1581  return kFALSE;
1582  }
1583 
1584 
1585  //set recalculed primary vertex
1586  d->SetOwnPrimaryVtx(recvtx);
1587  delete recvtx;
1588 
1589  return kTRUE;
1590 }
1591 //--------------------------------------------------------------------------
1592 Bool_t AliRDHFCuts::SetMCPrimaryVtx(AliAODRecoDecayHF *d,AliAODEvent *aod) const
1593 {
1594  //
1595  // Recalculate primary vertex without daughters
1596  //
1597 
1598  if(!aod) {
1599  AliError("Can not get MC vertex without AOD event");
1600  return kFALSE;
1601  }
1602 
1603  // load MC header
1604  AliAODMCHeader *mcHeader =
1605  (AliAODMCHeader*)aod->GetList()->FindObject(AliAODMCHeader::StdBranchName());
1606  if(!mcHeader) {
1607  AliError("Can not get MC vertex without AODMCHeader event");
1608  return kFALSE;
1609  }
1610  Double_t pos[3];
1611  Double_t covmatrix[6]={0.,0.,0.,0.,0.,0.};
1612  mcHeader->GetVertex(pos);
1613  AliAODVertex *recvtx=new AliAODVertex(pos,covmatrix);
1614 
1615  if(!recvtx){
1616  AliDebug(2,"Removal of daughter tracks failed");
1617  return kFALSE;
1618  }
1619 
1620  //set recalculed primary vertex
1621  d->SetOwnPrimaryVtx(recvtx);
1622 
1623  d->RecalculateImpPars(recvtx,aod);
1624 
1625  delete recvtx;
1626 
1627  return kTRUE;
1628 }
1629 //--------------------------------------------------------------------------
1630 void AliRDHFCuts::CleanOwnPrimaryVtx(AliAODRecoDecayHF *d,
1631  AliAODEvent *aod,
1632  AliAODVertex *origownvtx) const
1633 {
1634  //
1635  // Clean-up own primary vertex if needed
1636  //
1637 
1638  if(fRemoveDaughtersFromPrimary || fUseMCVertex) {
1639  d->UnsetOwnPrimaryVtx();
1640  if(origownvtx) {
1641  d->SetOwnPrimaryVtx(origownvtx);
1642  delete origownvtx; origownvtx=NULL;
1643  }
1644  d->RecalculateImpPars(d->GetPrimaryVtx(),aod);
1645  } else {
1646  if(origownvtx) {
1647  delete origownvtx; origownvtx=NULL;
1648  }
1649  }
1650  return;
1651 }
1652 //--------------------------------------------------------------------------
1653 Bool_t AliRDHFCuts::IsSignalMC(AliAODRecoDecay *d,AliAODEvent *aod,Int_t pdg) const
1654 {
1655  //
1656  // Checks if this candidate is matched to MC signal
1657  //
1658 
1659  if(!aod) return kFALSE;
1660 
1661  // get the MC array
1662  TClonesArray *mcArray = (TClonesArray*)((AliAODEvent*)aod)->GetList()->FindObject(AliAODMCParticle::StdBranchName());
1663 
1664  if(!mcArray) return kFALSE;
1665 
1666  // try to match
1667  Int_t label = d->MatchToMC(pdg,mcArray);
1668 
1669  if(label>=0) {
1670  //printf("MATCH!\n");
1671  return kTRUE;
1672  }
1673 
1674  return kFALSE;
1675 }
1676 
1677 
1678 //--------------------------------------------------------------------------
1679 Bool_t AliRDHFCuts::RecomputePrimaryVertex(AliAODEvent* event) const{
1680  // recompute event primary vertex from AOD tracks
1681 
1682  AliVertexerTracks *vertexer = new AliVertexerTracks(event->GetMagneticField());
1683  vertexer->SetITSMode();
1684  vertexer->SetMinClusters(3);
1685 
1686  AliAODVertex* pvtx=event->GetPrimaryVertex();
1687  if(strstr(pvtx->GetTitle(),"VertexerTracksWithConstraint")) {
1688  Float_t diamondcovxy[3];
1689  event->GetDiamondCovXY(diamondcovxy);
1690  Double_t pos[3]={event->GetDiamondX(),event->GetDiamondY(),0.};
1691  Double_t cov[6]={diamondcovxy[0],diamondcovxy[1],diamondcovxy[2],0.,0.,10.*10.};
1692  AliESDVertex *diamond = new AliESDVertex(pos,cov,1.,1);
1693  vertexer->SetVtxStart(diamond);
1694  delete diamond; diamond=NULL;
1695  }
1696 
1697  AliESDVertex* vertexESD = (AliESDVertex*)vertexer->FindPrimaryVertex(event);
1698  if(!vertexESD) return kFALSE;
1699  if(vertexESD->GetNContributors()<=0) {
1700  //AliDebug(2,"vertexing failed");
1701  delete vertexESD; vertexESD=NULL;
1702  return kFALSE;
1703  }
1704  delete vertexer; vertexer=NULL;
1705 
1706  // convert to AliAODVertex
1707  Double_t pos[3],cov[6],chi2perNDF;
1708  vertexESD->GetXYZ(pos); // position
1709  vertexESD->GetCovMatrix(cov); //covariance matrix
1710  chi2perNDF = vertexESD->GetChi2toNDF();
1711  delete vertexESD; vertexESD=NULL;
1712 
1713  pvtx->SetPosition(pos[0],pos[1],pos[2]);
1714  pvtx->SetChi2perNDF(chi2perNDF);
1715  pvtx->SetCovMatrix(cov);
1716 
1717  return kTRUE;
1718 }
AliRDHFCuts::SetNPtBins
void SetNPtBins(Int_t nptBins)
Definition: AliRDHFCuts.h:375
AliRDHFCuts::fIsSelectedCuts
Int_t fIsSelectedCuts
fix the daughter track references
Definition: AliRDHFCuts.h:423
pdg
Int_t pdg
Definition: charmCutsOptimization.C:34
AliRDHFCuts::IsEventSelectedForCentrFlattening
Bool_t IsEventSelectedForCentrFlattening(Float_t centvalue)
Definition: AliRDHFCuts.cxx:415
AliRDHFCuts::fMinDzPileup
Float_t fMinDzPileup
min. n. of tracklets in pileup vertex
Definition: AliRDHFCuts.h:413
AliRDHFCuts::fMaxPtCandTrackSPDFirst
Double_t fMaxPtCandTrackSPDFirst
flag to select the track kFirst criteria for pt < ptlimit
Definition: AliRDHFCuts.h:430
AliRDHFCuts::fWhyRejection
Int_t fWhyRejection
PID for heavy flavours manager.
Definition: AliRDHFCuts.h:406
Double_t
double Double_t
Definition: External.C:58
AliRDHFCuts::fCutOnzVertexSPD
Int_t fCutOnzVertexSPD
flag to apply cut on tracklets vs. centrality for 2011 data
Definition: AliRDHFCuts.h:435
AliRDHFCuts::SetupPID
void SetupPID(AliVEvent *event)
Definition: AliRDHFCuts.cxx:443
AliRDHFCuts::IsSignalMC
Bool_t IsSignalMC(AliAODRecoDecay *d, AliAODEvent *aod, Int_t pdg) const
Definition: AliRDHFCuts.cxx:1653
title
const char * title
Definition: MakeQAPdf.C:26
AliRDHFCuts::fCutGeoNcrNclFractionNcr
Double_t fCutGeoNcrNclFractionNcr
3rd parameter of GeoNcrNcl cut
Definition: AliRDHFCuts.h:448
AliRDHFCuts::fUseMCVertex
Bool_t fUseMCVertex
flag to switch on the removal of duaghters from the primary vertex computation
Definition: AliRDHFCuts.h:409
AliRDHFCuts::fUseOnlyOneTrigger
Bool_t fUseOnlyOneTrigger
trigger mask
Definition: AliRDHFCuts.h:388
AliRDHFCuts::IsEventSelectedInCentrality
Int_t IsEventSelectedInCentrality(AliVEvent *event)
Definition: AliRDHFCuts.cxx:330
AliRDHFCuts::fIsUpperCut
Bool_t * fIsUpperCut
Definition: AliRDHFCuts.h:402
AliRDHFCuts::SetMCPrimaryVtx
Bool_t SetMCPrimaryVtx(AliAODRecoDecayHF *d, AliAODEvent *aod) const
Definition: AliRDHFCuts.cxx:1592
AliRDHFCuts::fRemoveDaughtersFromPrimary
Bool_t fRemoveDaughtersFromPrimary
Definition: AliRDHFCuts.h:408
AliRDHFCuts::SetHistoForCentralityFlattening
void SetHistoForCentralityFlattening(TH1F *h, Double_t minCentr, Double_t maxCentr, Double_t centrRef=0., Int_t switchTRand=0)
Definition: AliRDHFCuts.cxx:358
AliAODPidHF::GetUseCombined
Bool_t GetUseCombined()
Definition: AliAODPidHF.h:165
AliAnalysisVertexingHF.h
AliRDHFCuts::SetUseCentrality
void SetUseCentrality(Int_t flag=1)
Definition: AliRDHFCuts.cxx:1047
AliRDHFCuts::fPtBinLimits
Float_t * fPtBinLimits
"number of limits", that is fnPtBins+1
Definition: AliRDHFCuts.h:395
AliRDHFCuts::fMinVtxContr
Int_t fMinVtxContr
0: not cut; 1: SPDZ; 2: SPD3D; 3: Tracks
Definition: AliRDHFCuts.h:383
centrality
centrality
Definition: AverageDmesonRaa.C:71
Char_t
char Char_t
Definition: External.C:18
AliRDHFCuts::CheckMatchingAODdeltaAODevents
static Int_t CheckMatchingAODdeltaAODevents()
Definition: AliRDHFCuts.cxx:704
AliRDHFCuts::fMaxVtxRedChi2
Float_t fMaxVtxRedChi2
minimum vertex contributors
Definition: AliRDHFCuts.h:384
AliAODPidHF::SetMClowenpp2011
void SetMClowenpp2011(Bool_t mc)
Definition: AliAODPidHF.h:102
AliRDHFCuts::GetCuts
const Float_t * GetCuts() const
Definition: AliRDHFCuts.h:240
AliRDHFCuts::SetMinCrossedRowsTPCPtDep
void SetMinCrossedRowsTPCPtDep(const char *rows="")
Definition: AliRDHFCuts.cxx:772
AliRDHFCuts::fCutRatioClsOverCrossRowsTPC
Float_t fCutRatioClsOverCrossRowsTPC
histogram with reference centrality distribution for centrality distribution flattening ...
Definition: AliRDHFCuts.h:440
AliRDHFCuts::fDeadZoneWidth
Double_t fDeadZoneWidth
flag for enabling/disabling geometrical cut on TPC track
Definition: AliRDHFCuts.h:445
AliRDHFCuts::fMinVtxType
Int_t fMinVtxType
cuts on the event
Definition: AliRDHFCuts.h:382
AliAODPidHF::SetppLowEn2011
void SetppLowEn2011(Bool_t opt)
Definition: AliAODPidHF.h:104
AliRDHFCuts::fMaxRapidityCand
Double_t fMaxRapidityCand
minimum pt of the candidate
Definition: AliRDHFCuts.h:427
AliRDHFCuts::fCutGeoNcrNclFractionNcl
Double_t fCutGeoNcrNclFractionNcl
4th parameter of GeoNcrNcl cut
Definition: AliRDHFCuts.h:449
AliRDHFCuts::SetGlobalIndex
void SetGlobalIndex()
Definition: AliRDHFCuts.h:198
AliRDHFCuts::operator=
AliRDHFCuts & operator=(const AliRDHFCuts &source)
Definition: AliRDHFCuts.cxx:220
AliRDHFCuts::GetCutValue
Float_t GetCutValue(Int_t iVar, Int_t iPtBin) const
Definition: AliRDHFCuts.cxx:1264
AliRDHFCuts::fUseCentrality
Int_t fUseCentrality
min deltaz between main and pileup vertices
Definition: AliRDHFCuts.h:414
AliRDHFCuts::fUsePID
Bool_t fUsePID
Definition: AliRDHFCuts.h:403
gRandom
TRandom * gRandom
AliAODPidHF::PrintAll
void PrintAll() const
Definition: AliAODPidHF.cxx:1105
AliRDHFCuts::SetPidHF
void SetPidHF(AliAODPidHF *pidObj)
see enum below
Definition: AliRDHFCuts.h:212
AliAODPidHF::GetOldPid
Bool_t GetOldPid()
Definition: AliAODPidHF.h:157
GetList
TList * GetList(const TDirectory *d, const char *what)
Definition: ExtractData.C:172
AliRDHFCuts::GetPidHF
AliAODPidHF * GetPidHF() const
Definition: AliRDHFCuts.h:233
AliAODRecoDecayHF::RecalculateImpPars
void RecalculateImpPars(AliAODVertex *vtxAODNew, AliAODEvent *aod)
Definition: AliAODRecoDecayHF.cxx:329
AliRDHFCuts::fRemoveTrackletOutliers
Bool_t fRemoveTrackletOutliers
Max. difference between TRK and V0 centrality (remove TPC pileup for PbPb 2011)
Definition: AliRDHFCuts.h:434
AliRDHFCuts::fUseV0ANDSelectionOffline
Bool_t fUseV0ANDSelectionOffline
5th parameter of GeoNcrNcl cut
Definition: AliRDHFCuts.h:450
AliRDHFCuts::AliRDHFCuts
AliRDHFCuts(const Char_t *name="RDHFCuts", const Char_t *title="")
Definition: AliRDHFCuts.cxx:64
nPtBins
const Int_t nPtBins
Definition: ComputeDmesonYield.C:30
AliRDHFCuts::fTriggerMask
ULong64_t fTriggerMask
SPD multiplicity.
Definition: AliRDHFCuts.h:387
AliRDHFCuts::fUseCutGeoNcrNcl
Bool_t fUseCutGeoNcrNcl
pT-dep cut in TPC minimum n crossed rows
Definition: AliRDHFCuts.h:444
Int_t
int Int_t
Definition: External.C:63
AliRDHFCuts::fUseTrackSelectionWithFilterBits
Bool_t fUseTrackSelectionWithFilterBits
flag to reject kink daughters
Definition: AliRDHFCuts.h:437
AliRDHFCuts::SetCuts
void SetCuts(Int_t nVars, Int_t nPtBins, Float_t **cutsRD)
Definition: AliRDHFCuts.cxx:1059
AliRDHFCuts::fnVarsForOpt
Int_t fnVarsForOpt
Definition: AliRDHFCuts.h:398
AliRDHFCuts::fCutGeoNcrNclLength
Double_t fCutGeoNcrNclLength
1st parameter of GeoNcrNcl cut
Definition: AliRDHFCuts.h:446
Float_t
float Float_t
Definition: External.C:68
AliRDHFCuts::~AliRDHFCuts
virtual ~AliRDHFCuts()
Definition: AliRDHFCuts.cxx:304
AliAODPidHF::SetPbPb
void SetPbPb(Bool_t pbpb)
Definition: AliAODPidHF.h:105
AliRDHFCuts::fVarNames
TString * fVarNames
number of cut vars for candidates
Definition: AliRDHFCuts.h:397
AliRDHFCuts::fMaxPtCand
Double_t fMaxPtCand
minimum pt of the candidate
Definition: AliRDHFCuts.h:426
AliRDHFCuts.h
AliRDHFCuts::fTrackCuts
AliESDtrackCuts * fTrackCuts
quality cuts on the daughter tracks
Definition: AliRDHFCuts.h:391
AliRDHFCuts::MakeTable
void MakeTable() const
Definition: AliRDHFCuts.cxx:1530
AliRDHFCuts::fFixRefs
Bool_t fFixRefs
name of the AliMultSelection object to be considered
Definition: AliRDHFCuts.h:422
AliRDHFCuts::fKeepSignalMC
Bool_t fKeepSignalMC
max rapidity of candidate (if !=-999 overrides IsInFiducialAcceptance)
Definition: AliRDHFCuts.h:428
AliRDHFCuts::fOptPileup
Int_t fOptPileup
use Physics selection criteria
Definition: AliRDHFCuts.h:411
AliRDHFCuts::GetTrackCuts
AliESDtrackCuts * GetTrackCuts() const
Definition: AliRDHFCuts.h:248
AliRDHFCuts::PrintTrigger
void PrintTrigger() const
Definition: AliRDHFCuts.cxx:1183
AliRDHFCuts::fMaxVtxZ
Float_t fMaxVtxZ
maximum chi2/ndf
Definition: AliRDHFCuts.h:385
AliRDHFCuts::GetCentrality
Float_t GetCentrality(AliAODEvent *aodEvent)
Definition: AliRDHFCuts.h:244
AliRDHFCuts::fIsSelectedPID
Int_t fIsSelectedPID
outcome of cuts selection
Definition: AliRDHFCuts.h:424
AliRDHFCuts::fMinCentrality
Float_t fMinCentrality
Definition: AliRDHFCuts.h:419
AliAODRecoDecayHF::RemoveDaughtersFromPrimaryVtx
AliAODVertex * RemoveDaughtersFromPrimaryVtx(AliAODEvent *aod)
Definition: AliAODRecoDecayHF.cxx:255
AliAODPidHF::SetUpCombinedPID
void SetUpCombinedPID()
Definition: AliAODPidHF.cxx:1076
AliAODPidHF::GetPidResponse
AliPIDResponse * GetPidResponse() const
Definition: AliAODPidHF.h:160
AliRDHFCuts::fEvRejectionBits
UInt_t fEvRejectionBits
used to code the step at which candidate was rejected
Definition: AliRDHFCuts.h:407
AliRDHFCuts::fMaxDiffTRKV0Centr
Double_t fMaxDiffTRKV0Centr
flag to apply cut on tracks crossing SPD misaligned modules for PP2012 data
Definition: AliRDHFCuts.h:433
AliRDHFCuts::GetCentralityOldFramework
Float_t GetCentralityOldFramework(AliAODEvent *aodEvent, AliRDHFCuts::ECentrality estimator)
Definition: AliRDHFCuts.cxx:1313
AliRDHFCuts::fnPtBinLimits
Int_t fnPtBinLimits
number of pt bins for cuts
Definition: AliRDHFCuts.h:394
AliRDHFCuts::fCutsRD
Float_t * fCutsRD
fnVars*fnPtBins
Definition: AliRDHFCuts.h:401
AliRDHFCuts::CheckPtDepCrossedRows
Bool_t CheckPtDepCrossedRows(TString rows, Bool_t print=kFALSE) const
Definition: AliRDHFCuts.cxx:759
Data
Bool_t Data(TH1F *h, Double_t *rangefit, Bool_t writefit, Double_t &sgn, Double_t &errsgn, Double_t &bkg, Double_t &errbkg, Double_t &sgnf, Double_t &errsgnf, Double_t &sigmafit, Int_t &status)
Definition: charmCutsOptimization.C:371
AliAODRecoDecayHF::SetOwnPrimaryVtx
void SetOwnPrimaryVtx(const AliAODVertex *vtx)
Definition: AliAODRecoDecayHF.h:45
AliRDHFCuts::fUseCentrFlatteningInMC
Bool_t fUseCentrFlatteningInMC
flag to enable/disable the check on filter bits
Definition: AliRDHFCuts.h:438
AliRDHFCuts::SetVarsForOpt
void SetVarsForOpt(Int_t nVars, Bool_t *forOpt)
Definition: AliRDHFCuts.cxx:1022
AliRDHFCuts::SetVarNames
void SetVarNames(Int_t nVars, TString *varNames, Bool_t *isUpperCut)
Definition: AliRDHFCuts.cxx:999
AliRDHFCuts::GetVarPtIndex
void GetVarPtIndex(Int_t iGlob, Int_t &iVar, Int_t &iPtBin) const
Definition: AliRDHFCuts.cxx:1238
AliAODPidHF::SetBetheBloch
void SetBetheBloch()
Definition: AliAODPidHF.cxx:847
AliRDHFCuts::fVarsForOpt
Bool_t * fVarsForOpt
number of cut vars to be optimized for candidates
Definition: AliRDHFCuts.h:399
isMC
Bool_t isMC
Definition: ReadDvsMultiplicity.C:60
AliRDHFCuts::CompareCuts
Bool_t CompareCuts(const AliRDHFCuts *obj) const
Definition: AliRDHFCuts.cxx:1488
AliRDHFCuts::AreDaughtersSelected
Bool_t AreDaughtersSelected(AliAODRecoDecayHF *rd, const AliAODEvent *aod=0x0) const
Definition: AliRDHFCuts.cxx:674
AliRDHFCuts::fApplySPDMisalignedPP2012
Bool_t fApplySPDMisalignedPP2012
flag to apply SPD dead module map of PbPb2011
Definition: AliRDHFCuts.h:432
AliRDHFCuts::IsEventSelected
Bool_t IsEventSelected(AliVEvent *event)
Definition: AliRDHFCuts.cxx:483
AliRDHFCuts::fMinSPDMultiplicity
Int_t fMinSPDMultiplicity
maximum |z| of primary vertex
Definition: AliRDHFCuts.h:386
AliAODPidHF::SetMC
void SetMC(Bool_t mc)
Definition: AliAODPidHF.h:101
AliRDHFCuts::PrintAll
virtual void PrintAll() const
Definition: AliRDHFCuts.cxx:1108
AliRDHFCuts::fUseAOD049
Bool_t fUseAOD049
enable PID usage (off by default)
Definition: AliRDHFCuts.h:404
ClassImp
ClassImp(AliAnalysisTaskCRC) AliAnalysisTaskCRC
Definition: AliAnalysisTaskCRC.cxx:44
AliRDHFCuts::fApplySPDDeadPbPb2011
Bool_t fApplySPDDeadPbPb2011
maximum pt of the candidate for which to check if the daughters fulfill kFirst criteria ...
Definition: AliRDHFCuts.h:431
AliRDHFCuts::CleanOwnPrimaryVtx
void CleanOwnPrimaryVtx(AliAODRecoDecayHF *d, AliAODEvent *aod, AliAODVertex *origownvtx) const
Definition: AliRDHFCuts.cxx:1630
AliAODRecoDecayHF.h
AliRDHFCuts::fIsCandTrackSPDFirst
Bool_t fIsCandTrackSPDFirst
IsSelected returns always kTRUE for MC signal.
Definition: AliRDHFCuts.h:429
AliRDHFCuts::fHistCentrDistr
TH1F * fHistCentrDistr
flag for enabling/diabling centrality flattening in MC
Definition: AliRDHFCuts.h:439
AliRDHFCuts::SetPtBins
void SetPtBins(Int_t nPtBinLimits, Float_t *ptBinLimits)
Definition: AliRDHFCuts.cxx:976
AliRDHFCuts::fKinkReject
Bool_t fKinkReject
cut on zSPD vertex to remove outliers in centrality vs. tracklets (0=no cut, 1= cut at 12 cm...
Definition: AliRDHFCuts.h:436
AliRDHFCuts::fMultSelectionObjectName
TString fMultSelectionObjectName
maximum centrality for selected events
Definition: AliRDHFCuts.h:421
AliRDHFCuts::fMinContrPileup
Int_t fMinContrPileup
option for pielup selection
Definition: AliRDHFCuts.h:412
AliRDHFCuts::fUsePhysicsSelection
Bool_t fUsePhysicsSelection
use MC primary vertex
Definition: AliRDHFCuts.h:410
AliRDHFCuts::f1CutMinNCrossedRowsTPCPtDep
TFormula * f1CutMinNCrossedRowsTPCPtDep
pT-dep cut in TPC minimum n crossed rows
Definition: AliRDHFCuts.h:443
AliAODRecoDecayHF::GetPrimaryVtx
AliAODVertex * GetPrimaryVtx() const
Definition: AliAODRecoDecayHF.h:53
AliRDHFCuts::AddTrackCuts
void AddTrackCuts(const AliESDtrackCuts *cuts)
Definition: AliRDHFCuts.h:204
AliRDHFCuts::fTriggerClass
TString fTriggerClass[2]
flag to select one trigger only
Definition: AliRDHFCuts.h:389
Bool_t
bool Bool_t
Definition: External.C:53
AliRDHFCuts::fnPtBins
Int_t fnPtBins
cuts on the candidate
Definition: AliRDHFCuts.h:393
AliRDHFCuts::fCutGeoNcrNclGeom1Pt
Double_t fCutGeoNcrNclGeom1Pt
2nd parameter of GeoNcrNcl cut
Definition: AliRDHFCuts.h:447
AliRDHFCuts::fPidHF
AliAODPidHF * fPidHF
enable AOD049 centrality cleanup
Definition: AliRDHFCuts.h:405
AliRDHFCuts::fCutRatioSignalNOverCrossRowsTPC
Float_t fCutRatioSignalNOverCrossRowsTPC
min. value ratio NTPCClusters/NTPCCrossedRows, cut if !=0
Definition: AliRDHFCuts.h:441
AliRDHFCuts::fGlobalIndex
Int_t fGlobalIndex
Definition: AliRDHFCuts.h:400
AliRDHFCuts::RecalcOwnPrimaryVtx
Bool_t RecalcOwnPrimaryVtx(AliAODRecoDecayHF *d, AliAODEvent *aod) const
Definition: AliRDHFCuts.cxx:1566
AliRDHFCuts::PtBin
Int_t PtBin(Double_t pt) const
Definition: AliRDHFCuts.cxx:1249
AliRDHFCuts::GetGlobalIndex
Int_t GetGlobalIndex(Int_t iVar, Int_t iPtBin) const
Definition: AliRDHFCuts.cxx:1230
AliRDHFCuts::fCutMinCrossedRowsTPCPtDep
TString fCutMinCrossedRowsTPCPtDep
min. value ratio TPCPointsUsedForPID/NTPCCrossedRows, cut if !=0
Definition: AliRDHFCuts.h:442
AliRDHFCuts::fMinPtCand
Double_t fMinPtCand
outcome of PID selection
Definition: AliRDHFCuts.h:425
AliRDHFCuts::IsDaughterSelected
Bool_t IsDaughterSelected(AliAODTrack *track, const AliESDVertex *primary, AliESDtrackCuts *cuts, const AliAODEvent *aod=0x0) const
Definition: AliRDHFCuts.cxx:796
AliAODPidHF::SetOnePad
void SetOnePad(Bool_t onepad)
Definition: AliAODPidHF.h:103
AliRDHFCuts::fMaxCentrality
Float_t fMaxCentrality
minimum centrality for selected events
Definition: AliRDHFCuts.h:420
AliAODPidHF::SetPidResponse
void SetPidResponse(AliPIDResponse *pidResp)
Definition: AliAODPidHF.h:111
AliRDHFCuts::RecomputePrimaryVertex
Bool_t RecomputePrimaryVertex(AliAODEvent *event) const
Definition: AliRDHFCuts.cxx:1679
AliRDHFCuts::fnVars
Int_t fnVars
Definition: AliRDHFCuts.h:396