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