]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG3/vertexingHF/AliRDHFCuts.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Analysis code for D0->4prong (Fabio)
[u/mrichter/AliRoot.git] / PWG3 / vertexingHF / AliRDHFCuts.cxx
CommitLineData
7a1c0c33 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
27de2dfb 16/* $Id$ */
17
7a1c0c33 18/////////////////////////////////////////////////////////////
19//
20// Base class for cuts on AOD reconstructed heavy-flavour decay
21//
22// Author: A.Dainese, andrea.dainese@pd.infn.it
23/////////////////////////////////////////////////////////////
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"
77c65905 38#include "AliAnalysisVertexingHF.h"
7a1c0c33 39#include "AliRDHFCuts.h"
40
41ClassImp(AliRDHFCuts)
42
43//--------------------------------------------------------------------------
44AliRDHFCuts::AliRDHFCuts(const Char_t* name, const Char_t* title) :
45AliAnalysisCuts(name,title),
46fMinVtxType(3),
47fMinVtxContr(1),
48fMaxVtxRedChi2(1e6),
49fMaxVtxZ(1e6),
50fMinSPDMultiplicity(0),
51fTriggerMask(0),
cd995490 52fTriggerClass("CINT1"),
7a1c0c33 53fTrackCuts(0),
54fnPtBins(1),
55fnPtBinLimits(1),
56fPtBinLimits(0),
57fnVars(1),
58fVarNames(0),
59fnVarsForOpt(0),
60fVarsForOpt(0),
61fGlobalIndex(1),
62fCutsRD(0),
63fIsUpperCut(0),
64fUsePID(kFALSE),
65fPidHF(0),
66fWhyRejection(0),
67fRemoveDaughtersFromPrimary(kFALSE),
68fOptPileup(0),
69fMinContrPileup(3),
70fMinDzPileup(0.6),
71fUseCentrality(0),
72fMinCentrality(0.),
77c65905 73fMaxCentrality(100.),
892e16af 74fFixRefs(kFALSE),
75fIsSelectedCuts(0),
47aa3d55 76fIsSelectedPID(0),
77fMinPtCand(-1.),
78fMaxPtCand(100000.)
7a1c0c33 79{
80 //
81 // Default Constructor
82 //
83}
84//--------------------------------------------------------------------------
85AliRDHFCuts::AliRDHFCuts(const AliRDHFCuts &source) :
86 AliAnalysisCuts(source),
87 fMinVtxType(source.fMinVtxType),
88 fMinVtxContr(source.fMinVtxContr),
89 fMaxVtxRedChi2(source.fMaxVtxRedChi2),
90 fMaxVtxZ(source.fMaxVtxZ),
91 fMinSPDMultiplicity(source.fMinSPDMultiplicity),
92 fTriggerMask(source.fTriggerMask),
cd995490 93 fTriggerClass(source.fTriggerClass),
7a1c0c33 94 fTrackCuts(0),
95 fnPtBins(source.fnPtBins),
96 fnPtBinLimits(source.fnPtBinLimits),
97 fPtBinLimits(0),
98 fnVars(source.fnVars),
99 fVarNames(0),
100 fnVarsForOpt(source.fnVarsForOpt),
101 fVarsForOpt(0),
102 fGlobalIndex(source.fGlobalIndex),
103 fCutsRD(0),
104 fIsUpperCut(0),
105 fUsePID(source.fUsePID),
106 fPidHF(0),
107 fWhyRejection(source.fWhyRejection),
108 fRemoveDaughtersFromPrimary(source.fRemoveDaughtersFromPrimary),
109 fOptPileup(source.fOptPileup),
110 fMinContrPileup(source.fMinContrPileup),
111 fMinDzPileup(source.fMinDzPileup),
112 fUseCentrality(source.fUseCentrality),
113 fMinCentrality(source.fMinCentrality),
77c65905 114 fMaxCentrality(source.fMaxCentrality),
892e16af 115 fFixRefs(source.fFixRefs),
116 fIsSelectedCuts(source.fIsSelectedCuts),
47aa3d55 117 fIsSelectedPID(source.fIsSelectedPID),
118 fMinPtCand(source.fMinPtCand),
119 fMaxPtCand(source.fMaxPtCand)
7a1c0c33 120{
121 //
122 // Copy constructor
123 //
124 cout<<"Copy constructor"<<endl;
125 if(source.GetTrackCuts()) AddTrackCuts(source.GetTrackCuts());
126 if(source.fPtBinLimits) SetPtBins(source.fnPtBinLimits,source.fPtBinLimits);
127 if(source.fVarNames) SetVarNames(source.fnVars,source.fVarNames,source.fIsUpperCut);
128 if(source.fCutsRD) SetCuts(source.fGlobalIndex,source.fCutsRD);
129 if(source.fVarsForOpt) SetVarsForOpt(source.fnVarsForOpt,source.fVarsForOpt);
130 if(source.fPidHF) SetPidHF(source.fPidHF);
131 PrintAll();
132
133}
134//--------------------------------------------------------------------------
135AliRDHFCuts &AliRDHFCuts::operator=(const AliRDHFCuts &source)
136{
137 //
138 // assignment operator
139 //
140 if(&source == this) return *this;
141
142 AliAnalysisCuts::operator=(source);
143
144 fMinVtxType=source.fMinVtxType;
145 fMinVtxContr=source.fMinVtxContr;
146 fMaxVtxRedChi2=source.fMaxVtxRedChi2;
147 fMaxVtxZ=source.fMaxVtxZ;
148 fMinSPDMultiplicity=source.fMinSPDMultiplicity;
149 fTriggerMask=source.fTriggerMask;
cd995490 150 fTriggerClass=source.fTriggerClass;
7a1c0c33 151 fnPtBins=source.fnPtBins;
152 fnVars=source.fnVars;
153 fGlobalIndex=source.fGlobalIndex;
154 fnVarsForOpt=source.fnVarsForOpt;
155 fUsePID=source.fUsePID;
156 SetPidHF(source.GetPidHF());
157 fWhyRejection=source.fWhyRejection;
158 fRemoveDaughtersFromPrimary=source.fRemoveDaughtersFromPrimary;
159 fOptPileup=source.fOptPileup;
160 fMinContrPileup=source.fMinContrPileup;
161 fMinDzPileup=source.fMinDzPileup;
162 fUseCentrality=source.fUseCentrality;
163 fMinCentrality=source.fMinCentrality;
164 fMaxCentrality=source.fMaxCentrality;
77c65905 165 fFixRefs=source.fFixRefs;
892e16af 166 fIsSelectedCuts=source.fIsSelectedCuts;
167 fIsSelectedPID=source.fIsSelectedPID;
47aa3d55 168 fMinPtCand=source.fMinPtCand;
169 fMaxPtCand=source.fMaxPtCand;
7a1c0c33 170
171 if(source.GetTrackCuts()) AddTrackCuts(source.GetTrackCuts());
172 if(source.fPtBinLimits) SetPtBins(source.fnPtBinLimits,source.fPtBinLimits);
173 if(source.fVarNames) SetVarNames(source.fnVars,source.fVarNames,source.fIsUpperCut);
174 if(source.fCutsRD) SetCuts(source.fGlobalIndex,source.fCutsRD);
175 if(source.fVarsForOpt) SetVarsForOpt(source.fnVarsForOpt,source.fVarsForOpt);
176 PrintAll();
177
178 return *this;
179}
180//--------------------------------------------------------------------------
181AliRDHFCuts::~AliRDHFCuts() {
182 //
183 // Default Destructor
184 //
185 if(fPtBinLimits) {delete [] fPtBinLimits; fPtBinLimits=0;}
186 if(fVarNames) {delete [] fVarNames; fVarNames=0;}
187 if(fVarsForOpt) {delete [] fVarsForOpt; fVarsForOpt=0;}
188 if(fCutsRD) {
189 delete [] fCutsRD;
190 fCutsRD=0;
191 }
192 if(fIsUpperCut) {delete [] fIsUpperCut; fIsUpperCut=0;}
193 if(fPidHF){
194 delete fPidHF;
195 fPidHF=0;
196 }
197}
198//---------------------------------------------------------------------------
892e16af 199Int_t AliRDHFCuts::IsEventSelectedInCentrality(AliVEvent *event) {
200 //
201 // Centrality selection
202 //
203
204 if(fUseCentrality<kCentOff||fUseCentrality>=kCentInvalid){
205 AliWarning("Centrality estimator not valid");
206 return 3;
207 }else{
208 Float_t centvalue=GetCentrality((AliAODEvent*)event);
fa3a368e 209 if (centvalue<-998.){//-999 if no centralityP
892e16af 210 return 0;
211 }else{
212 if (centvalue<fMinCentrality || centvalue>fMaxCentrality){
213 return 2;
214 }
215 }
216 }
217 return 0;
218}
219//---------------------------------------------------------------------------
7a1c0c33 220Bool_t AliRDHFCuts::IsEventSelected(AliVEvent *event) {
221 //
222 // Event selection
223 //
224 //if(fTriggerMask && event->GetTriggerMask()!=fTriggerMask) return kFALSE;
225
cd995490 226 fWhyRejection=0;
227
228 // trigger class
229 TString firedTriggerClasses=((AliAODEvent*)event)->GetFiredTriggerClasses();
230 // don't do for PbPb 2010 data
231 if(event->GetRunNumber()<136851 || event->GetRunNumber()>139517) {
232 if(!firedTriggerClasses.Contains(fTriggerClass.Data())) {
233 fWhyRejection=5;
234 return kFALSE;
235 }
236 }
237
77c65905 238 // TEMPORARY FIX FOR REFERENCES
239 // Fix references to daughter tracks
240 if(fFixRefs) {
241 AliAnalysisVertexingHF *fixer = new AliAnalysisVertexingHF();
242 fixer->FixReferences((AliAODEvent*)event);
243 delete fixer;
244 }
245 //
246
247
7a1c0c33 248
249 // multiplicity cuts no implemented yet
250
251 const AliVVertex *vertex = event->GetPrimaryVertex();
252
253 if(!vertex) return kFALSE;
254
255 TString title=vertex->GetTitle();
256 if(title.Contains("Z") && fMinVtxType>1) return kFALSE;
257 if(title.Contains("3D") && fMinVtxType>2) return kFALSE;
258
259 if(vertex->GetNContributors()<fMinVtxContr) return kFALSE;
260
601736df 261 if(TMath::Abs(vertex->GetZ())>fMaxVtxZ) {
262 fWhyRejection=6;
263 return kFALSE;
264 }
7a1c0c33 265
266 // switch to settings for 1-pad cls in TPC
267 if(fPidHF) {
601736df 268 if((event->GetRunNumber()>121693 && event->GetRunNumber()<136851) ||
269 event->GetRunNumber()>139517)
7a1c0c33 270 fPidHF->SetOnePad(kTRUE);
271 if(event->GetRunNumber()>=136851 && event->GetRunNumber()<=139517)
272 fPidHF->SetPbPb(kTRUE);
273 }
274
275 if(fOptPileup==kRejectPileupEvent){
276 Int_t cutc=(Int_t)fMinContrPileup;
277 Double_t cutz=(Double_t)fMinDzPileup;
278 if(event->IsPileupFromSPD(cutc,cutz,3.,2.,10.)) {
279 fWhyRejection=1;
280 return kFALSE;
281 }
282 }
283
284 //centrality selection
892e16af 285 if (fUseCentrality!=kCentOff) {
286 Int_t rejection=IsEventSelectedInCentrality(event);
287 if(rejection>1){
288 fWhyRejection=rejection;
289 return kFALSE;
7a1c0c33 290 }
291 }
292
7a1c0c33 293 return kTRUE;
294}
295//---------------------------------------------------------------------------
296Bool_t AliRDHFCuts::AreDaughtersSelected(AliAODRecoDecayHF *d) const {
297 //
298 // Daughter tracks selection
299 //
300 if(!fTrackCuts) return kTRUE;
dc222f77 301
7a1c0c33 302 Int_t ndaughters = d->GetNDaughters();
303 AliAODVertex *vAOD = d->GetPrimaryVtx();
304 Double_t pos[3],cov[6];
305 vAOD->GetXYZ(pos);
306 vAOD->GetCovarianceMatrix(cov);
307 const AliESDVertex vESD(pos,cov,100.,100);
dc222f77 308
7a1c0c33 309 Bool_t retval=kTRUE;
dc222f77 310
7a1c0c33 311 for(Int_t idg=0; idg<ndaughters; idg++) {
312 AliAODTrack *dgTrack = (AliAODTrack*)d->GetDaughter(idg);
fd20854c 313 if(!dgTrack) {retval = kFALSE; continue;}
7a1c0c33 314 //printf("charge %d\n",dgTrack->Charge());
315 if(dgTrack->Charge()==0) continue; // it's not a track, but a V0
316
317 if(!IsDaughterSelected(dgTrack,&vESD,fTrackCuts)) retval = kFALSE;
318 }
dc222f77 319
7a1c0c33 320 return retval;
321}
322//---------------------------------------------------------------------------
323Bool_t AliRDHFCuts::IsDaughterSelected(AliAODTrack *track,const AliESDVertex *primary,AliESDtrackCuts *cuts) const {
324 //
325 // Convert to ESDtrack, relate to vertex and check cuts
326 //
327 if(!cuts) return kTRUE;
328
329 Bool_t retval=kTRUE;
330
331 // convert to ESD track here
332 AliESDtrack esdTrack(track);
84d5345b 333 // set the TPC cluster info
334 esdTrack.SetTPCClusterMap(track->GetTPCClusterMap());
335 esdTrack.SetTPCSharedMap(track->GetTPCSharedMap());
336 esdTrack.SetTPCPointsF(track->GetTPCNclsF());
7a1c0c33 337 // needed to calculate the impact parameters
338 esdTrack.RelateToVertex(primary,0.,3.);
84d5345b 339
7a1c0c33 340 if(!cuts->IsSelected(&esdTrack)) retval = kFALSE;
341
342 if(fOptPileup==kRejectTracksFromPileupVertex){
343 // to be implemented
344 // we need either to have here the AOD Event,
345 // or to have the pileup vertex object
346 }
347 return retval;
348}
349//---------------------------------------------------------------------------
350void AliRDHFCuts::SetPtBins(Int_t nPtBinLimits,Float_t *ptBinLimits) {
351 // Set the pt bins
352
353 if(fPtBinLimits) {
354 delete [] fPtBinLimits;
355 fPtBinLimits = NULL;
356 printf("Changing the pt bins\n");
357 }
358
359 if(nPtBinLimits != fnPtBins+1){
360 cout<<"Warning: ptBinLimits dimention "<<nPtBinLimits<<" != nPtBins+1 ("<<fnPtBins+1<<")\nSetting nPtBins to "<<nPtBinLimits-1<<endl;
361 SetNPtBins(nPtBinLimits-1);
362 }
363
364 fnPtBinLimits = nPtBinLimits;
365 SetGlobalIndex();
366 //cout<<"Changing also Global Index -> "<<fGlobalIndex<<endl;
367 fPtBinLimits = new Float_t[fnPtBinLimits];
368 for(Int_t ib=0; ib<nPtBinLimits; ib++) fPtBinLimits[ib]=ptBinLimits[ib];
369
370 return;
371}
372//---------------------------------------------------------------------------
373void AliRDHFCuts::SetVarNames(Int_t nVars,TString *varNames,Bool_t *isUpperCut){
374 // Set the variable names
375
376 if(fVarNames) {
377 delete [] fVarNames;
378 fVarNames = NULL;
379 //printf("Changing the variable names\n");
380 }
381 if(nVars!=fnVars){
382 printf("Wrong number of variables: it has to be %d\n",fnVars);
383 return;
384 }
385 //fnVars=nVars;
386 fVarNames = new TString[nVars];
387 fIsUpperCut = new Bool_t[nVars];
388 for(Int_t iv=0; iv<nVars; iv++) {
389 fVarNames[iv] = varNames[iv];
390 fIsUpperCut[iv] = isUpperCut[iv];
391 }
392
393 return;
394}
395//---------------------------------------------------------------------------
396void AliRDHFCuts::SetVarsForOpt(Int_t nVars,Bool_t *forOpt) {
397 // Set the variables to be used for cuts optimization
398
399 if(fVarsForOpt) {
400 delete [] fVarsForOpt;
401 fVarsForOpt = NULL;
402 //printf("Changing the variables for cut optimization\n");
403 }
404
405 if(nVars==0){//!=fnVars) {
406 printf("%d not accepted as number of variables: it has to be %d\n",nVars,fnVars);
407 return;
408 }
409
410 fnVarsForOpt = 0;
411 fVarsForOpt = new Bool_t[fnVars];
412 for(Int_t iv=0; iv<fnVars; iv++) {
413 fVarsForOpt[iv]=forOpt[iv];
414 if(fVarsForOpt[iv]) fnVarsForOpt++;
415 }
416
417 return;
418}
419
420//---------------------------------------------------------------------------
421void AliRDHFCuts::SetUseCentrality(Int_t flag) {
422 //
423 // set centrality estimator
424 //
425 fUseCentrality=flag;
426 if(fUseCentrality<kCentOff||fUseCentrality>=kCentInvalid) AliWarning("Centrality estimator not valid");
427
428 return;
429}
430
431
432//---------------------------------------------------------------------------
433void AliRDHFCuts::SetCuts(Int_t nVars,Int_t nPtBins,Float_t **cutsRD) {
434 //
435 // store the cuts
436 //
437 if(nVars!=fnVars) {
438 printf("Wrong number of variables: it has to be %d\n",fnVars);
439 return;
440 }
441 if(nPtBins!=fnPtBins) {
442 printf("Wrong number of pt bins: it has to be %d\n",fnPtBins);
443 return;
444 }
445
446 if(!fCutsRD) fCutsRD = new Float_t[fGlobalIndex];
447
448
449 for(Int_t iv=0; iv<fnVars; iv++) {
450
451 for(Int_t ib=0; ib<fnPtBins; ib++) {
452
453 //check
454 if(GetGlobalIndex(iv,ib)>=fGlobalIndex) {
455 cout<<"Overflow, exit..."<<endl;
456 return;
457 }
458
459 fCutsRD[GetGlobalIndex(iv,ib)] = cutsRD[iv][ib];
460
461 }
462 }
463 return;
464}
465//---------------------------------------------------------------------------
466void AliRDHFCuts::SetCuts(Int_t glIndex,Float_t* cutsRDGlob){
467 //
468 // store the cuts
469 //
470 if(glIndex != fGlobalIndex){
471 cout<<"Wrong array size: it has to be "<<fGlobalIndex<<endl;
472 return;
473 }
474 if(!fCutsRD) fCutsRD = new Float_t[fGlobalIndex];
475
476 for(Int_t iGl=0;iGl<fGlobalIndex;iGl++){
477 fCutsRD[iGl] = cutsRDGlob[iGl];
478 }
479 return;
480}
481//---------------------------------------------------------------------------
482void AliRDHFCuts::PrintAll() const {
483 //
484 // print all cuts values
485 //
486
487 printf("Minimum vtx type %d\n",fMinVtxType);
488 printf("Minimum vtx contr %d\n",fMinVtxContr);
489 printf("Max vtx red chi2 %f\n",fMaxVtxRedChi2);
490 printf("Min SPD mult %d\n",fMinSPDMultiplicity);
491 printf("Use PID %d\n",(Int_t)fUsePID);
492 printf("Remove daughters from vtx %d\n",(Int_t)fRemoveDaughtersFromPrimary);
493 printf("Pileup rejection: %s\n",(fOptPileup > 0) ? "Yes" : "No");
494 if(fOptPileup==1) printf(" -- Reject pileup event");
495 if(fOptPileup==2) printf(" -- Reject tracks from pileup vtx");
496 if(fUseCentrality>0) {
497 TString estimator="";
498 if(fUseCentrality==1) estimator = "V0";
499 if(fUseCentrality==2) estimator = "Tracks";
500 if(fUseCentrality==3) estimator = "Tracklets";
501 if(fUseCentrality==4) estimator = "SPD clusters outer";
502 printf("Centrality class considered: %.1f-%.1f, estimated with %s",fMinCentrality,fMaxCentrality,estimator.Data());
503 }
504
505 if(fVarNames){
506 cout<<"Array of variables"<<endl;
507 for(Int_t iv=0;iv<fnVars;iv++){
508 cout<<fVarNames[iv]<<"\t";
509 }
510 cout<<endl;
511 }
512 if(fVarsForOpt){
513 cout<<"Array of optimization"<<endl;
514 for(Int_t iv=0;iv<fnVars;iv++){
515 cout<<fVarsForOpt[iv]<<"\t";
516 }
517 cout<<endl;
518 }
519 if(fIsUpperCut){
520 cout<<"Array of upper/lower cut"<<endl;
521 for(Int_t iv=0;iv<fnVars;iv++){
522 cout<<fIsUpperCut[iv]<<"\t";
523 }
524 cout<<endl;
525 }
526 if(fPtBinLimits){
527 cout<<"Array of ptbin limits"<<endl;
528 for(Int_t ib=0;ib<fnPtBinLimits;ib++){
529 cout<<fPtBinLimits[ib]<<"\t";
530 }
531 cout<<endl;
532 }
533 if(fCutsRD){
534 cout<<"Matrix of cuts"<<endl;
535 for(Int_t iv=0;iv<fnVars;iv++){
536 for(Int_t ib=0;ib<fnPtBins;ib++){
537 cout<<"fCutsRD["<<iv<<"]["<<ib<<"] = "<<fCutsRD[GetGlobalIndex(iv,ib)]<<"\t";
77c65905 538 }
7a1c0c33 539 cout<<endl;
540 }
541 cout<<endl;
542 }
543 return;
544}
545//---------------------------------------------------------------------------
546void AliRDHFCuts::GetCuts(Float_t**& cutsRD) const{
547 //
548 // get the cuts
549 //
550
551 //cout<<"Give back a "<<fnVars<<"x"<<fnPtBins<<" matrix."<<endl;
552
553
554 Int_t iv,ib;
555 if(!cutsRD) {
556 //cout<<"Initialization..."<<endl;
557 cutsRD=new Float_t*[fnVars];
558 for(iv=0; iv<fnVars; iv++) {
559 cutsRD[iv] = new Float_t[fnPtBins];
560 }
561 }
562
563 for(Int_t iGlobal=0; iGlobal<fGlobalIndex; iGlobal++) {
564 GetVarPtIndex(iGlobal,iv,ib);
565 cutsRD[iv][ib] = fCutsRD[iGlobal];
566 }
567
568 return;
569}
570
571//---------------------------------------------------------------------------
572Int_t AliRDHFCuts::GetGlobalIndex(Int_t iVar,Int_t iPtBin) const{
573 //
574 // give the global index from variable and pt bin
575 //
576 return iPtBin*fnVars+iVar;
577}
578
579//---------------------------------------------------------------------------
580void AliRDHFCuts::GetVarPtIndex(Int_t iGlob, Int_t& iVar, Int_t& iPtBin) const {
581 //
582 //give the index of the variable and of the pt bin from the global index
583 //
584 iPtBin=(Int_t)iGlob/fnVars;
585 iVar=iGlob%fnVars;
586
587 return;
588}
589
590//---------------------------------------------------------------------------
591Int_t AliRDHFCuts::PtBin(Double_t pt) const {
592 //
593 //give the pt bin where the pt lies.
594 //
595 Int_t ptbin=-1;
5639e412 596 if(pt<fPtBinLimits[0])return ptbin;
7a1c0c33 597 for (Int_t i=0;i<fnPtBins;i++){
598 if(pt<fPtBinLimits[i+1]) {
599 ptbin=i;
600 break;
601 }
602 }
603 return ptbin;
604}
605//-------------------------------------------------------------------
606Float_t AliRDHFCuts::GetCutValue(Int_t iVar,Int_t iPtBin) const {
607 //
608 // Give the value of cut set for the variable iVar and the pt bin iPtBin
609 //
610 if(!fCutsRD){
611 cout<<"Cuts not iniziaisez yet"<<endl;
612 return 0;
613 }
614 return fCutsRD[GetGlobalIndex(iVar,iPtBin)];
615}
616//-------------------------------------------------------------------
617Float_t AliRDHFCuts::GetCentrality(AliAODEvent* aodEvent,AliRDHFCuts::ECentrality estimator) const {
618 //
619 // Get centrality percentile
620 //
621 AliAODHeader *header=aodEvent->GetHeader();
622 AliCentrality *centrality=header->GetCentralityP();
623 Float_t cent=-999.;
5fc4893f 624 Bool_t isSelRun=kFALSE;
625 Int_t selRun[5]={138364, 138826, 138828, 138836, 138871};
7a1c0c33 626 if(!centrality) return cent;
627 else{
5fc4893f 628 if (estimator==kCentV0M){
629 cent=(Float_t)(centrality->GetCentralityPercentile("V0M"));
630 if(cent<0){
631 Int_t quality = centrality->GetQuality();
632 if(quality<=1){
633 cent=(Float_t)centrality->GetCentralityPercentileUnchecked("V0M");
634 }else{
635 Int_t runnum=aodEvent->GetRunNumber();
636 for(Int_t ir=0;ir<5;ir++){
637 if(runnum==selRun[ir]){
638 isSelRun=kTRUE;
639 break;
640 }
641 }
642 if((quality==8||quality==9)&&isSelRun)cent=(Float_t)centrality->GetCentralityPercentileUnchecked("V0M");
643 }
644 }
645 }
7a1c0c33 646 else {
5fc4893f 647 if (estimator==kCentTRK) {
648 cent=(Float_t)(centrality->GetCentralityPercentile("TRK"));
649 if(cent<0){
650 Int_t quality = centrality->GetQuality();
651 if(quality<=1){
652 cent=(Float_t)centrality->GetCentralityPercentileUnchecked("TRK");
653 }else{
654 Int_t runnum=aodEvent->GetRunNumber();
655 for(Int_t ir=0;ir<5;ir++){
656 if(runnum==selRun[ir]){
657 isSelRun=kTRUE;
658 break;
659 }
660 }
661 if((quality==8||quality==9)&&isSelRun)cent=(Float_t)centrality->GetCentralityPercentileUnchecked("TRK");
662 }
663 }
664 }
7a1c0c33 665 else{
5fc4893f 666 if (estimator==kCentTKL){
667 cent=(Float_t)(centrality->GetCentralityPercentile("TKL"));
668 if(cent<0){
669 Int_t quality = centrality->GetQuality();
670 if(quality<=1){
671 cent=(Float_t)centrality->GetCentralityPercentileUnchecked("TKL");
672 }else{
673 Int_t runnum=aodEvent->GetRunNumber();
674 for(Int_t ir=0;ir<5;ir++){
675 if(runnum==selRun[ir]){
676 isSelRun=kTRUE;
677 break;
678 }
679 }
680 if((quality==8||quality==9)&&isSelRun)cent=(Float_t)centrality->GetCentralityPercentileUnchecked("TKL");
681 }
682 }
683 }
7a1c0c33 684 else{
5fc4893f 685 if (estimator==kCentCL1){
686 cent=(Float_t)(centrality->GetCentralityPercentile("CL1"));
687 if(cent<0){
688 Int_t quality = centrality->GetQuality();
689 if(quality<=1){
690 cent=(Float_t)centrality->GetCentralityPercentileUnchecked("CL1");
691 }else{
692 Int_t runnum=aodEvent->GetRunNumber();
693 for(Int_t ir=0;ir<5;ir++){
694 if(runnum==selRun[ir]){
695 isSelRun=kTRUE;
696 break;
697 }
698 }
699 if((quality==8||quality==9)&&isSelRun)cent=(Float_t)centrality->GetCentralityPercentileUnchecked("CL1");
700 }
701 }
702 }
7a1c0c33 703 else {
704 AliWarning("Centrality estimator not valid");
5fc4893f 705
7a1c0c33 706 }
707 }
708 }
709 }
710 }
711 return cent;
712}
713//-------------------------------------------------------------------
714Bool_t AliRDHFCuts::CompareCuts(const AliRDHFCuts *obj) const {
715 //
716 // Compare two cuts objects
717 //
718
719 Bool_t areEqual=kTRUE;
720
721 if(fMinVtxType!=obj->fMinVtxType) { printf("Minimum vtx type %d %d\n",fMinVtxType,obj->fMinVtxType); areEqual=kFALSE;}
722
723 if(fMinVtxContr!=obj->fMinVtxContr) { printf("Minimum vtx contr %d %d\n",fMinVtxContr,obj->fMinVtxContr); areEqual=kFALSE;}
724
725 if(TMath::Abs(fMaxVtxRedChi2-obj->fMaxVtxRedChi2)>1.e-10) { printf("Max vtx red chi2 %f %f\n",fMaxVtxRedChi2,obj->fMaxVtxRedChi2);areEqual=kFALSE;}
726
727 if(fMinSPDMultiplicity!=obj->fMinSPDMultiplicity) { printf("Min SPD mult %d\n %d",fMinSPDMultiplicity,obj->fMinSPDMultiplicity);areEqual=kFALSE;}
728
729 if(fUsePID!=obj->fUsePID) { printf("Use PID %d %d\n",(Int_t)fUsePID,(Int_t)obj->fUsePID); areEqual=kFALSE;}
730
731 if(fRemoveDaughtersFromPrimary!=obj->fRemoveDaughtersFromPrimary) {printf("Remove daughters from vtx %d %d\n",(Int_t)fRemoveDaughtersFromPrimary,(Int_t)obj->fRemoveDaughtersFromPrimary); areEqual=kFALSE;}
732 if(fTrackCuts){
733 if(fTrackCuts->GetMinNClusterTPC()!=obj->fTrackCuts->GetMinNClusterTPC()) {printf("MinNClsTPC %d %d\n",fTrackCuts->GetMinNClusterTPC(),obj->fTrackCuts->GetMinNClusterTPC()); areEqual=kFALSE;}
734
735 if(fTrackCuts->GetMinNClustersITS()!=obj->fTrackCuts->GetMinNClustersITS()) {printf("MinNClsITS %d %d\n",fTrackCuts->GetMinNClustersITS(),obj->fTrackCuts->GetMinNClustersITS()); areEqual=kFALSE;}
736
737 if(TMath::Abs(fTrackCuts->GetMaxChi2PerClusterTPC()-obj->fTrackCuts->GetMaxChi2PerClusterTPC())>1.e-10) {printf("MaxChi2ClsTPC %f %f\n",fTrackCuts->GetMaxChi2PerClusterTPC(),obj->fTrackCuts->GetMaxChi2PerClusterTPC()); areEqual=kFALSE;}
738
739 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;}
740 }
741
742 if(fCutsRD) {
743 for(Int_t iv=0;iv<fnVars;iv++) {
744 for(Int_t ib=0;ib<fnPtBins;ib++) {
745 if(TMath::Abs(fCutsRD[GetGlobalIndex(iv,ib)]-obj->fCutsRD[GetGlobalIndex(iv,ib)])>1.e-10) {
746 cout<<"fCutsRD["<<iv<<"]["<<ib<<"] = "<<fCutsRD[GetGlobalIndex(iv,ib)]<<" "<<obj->fCutsRD[GetGlobalIndex(iv,ib)]<<"\n";
747 areEqual=kFALSE;
748 }
749 }
750 }
751 }
752
753 return areEqual;
754}
755//---------------------------------------------------------------------------
756void AliRDHFCuts::MakeTable() const {
757 //
758 // print cuts values in table format
759 //
760
761 TString ptString = "pT range";
762 if(fVarNames && fPtBinLimits && fCutsRD){
763 TString firstLine(Form("* %-15s",ptString.Data()));
764 for (Int_t ivar=0; ivar<fnVars; ivar++){
765 firstLine+=Form("* %-15s ",fVarNames[ivar].Data());
766 if (ivar == fnVars){
767 firstLine+="*\n";
768 }
769 }
770 Printf("%s",firstLine.Data());
771
772 for (Int_t ipt=0; ipt<fnPtBins; ipt++){
773 TString line;
774 if (ipt==fnPtBins-1){
775 line=Form("* %5.1f < pt < inf ",fPtBinLimits[ipt]);
776 }
777 else{
778 line=Form("* %5.1f < pt < %4.1f ",fPtBinLimits[ipt],fPtBinLimits[ipt+1]);
779 }
780 for (Int_t ivar=0; ivar<fnVars; ivar++){
781 line+=Form("* %-15f ",fCutsRD[GetGlobalIndex(ivar,ipt)]);
782 }
783 Printf("%s",line.Data());
784 }
785
786 }
787
788
789 return;
790}
eb497c14 791//--------------------------------------------------------------------------
792Bool_t AliRDHFCuts::RecalcOwnPrimaryVtx(AliAODRecoDecayHF *d,AliAODEvent *aod,
793 AliAODVertex *origownvtx,AliAODVertex *recvtx) const
794{
795 //
796 // Recalculate primary vertex without daughters
797 //
798
799 if(!aod) {
800 AliError("Can not remove daughters from vertex without AOD event");
801 return kFALSE;
802 }
803 if(d->GetOwnPrimaryVtx()) origownvtx=new AliAODVertex(*d->GetOwnPrimaryVtx());
804 recvtx=d->RemoveDaughtersFromPrimaryVtx(aod);
805 if(!recvtx){
806 AliDebug(2,"Removal of daughter tracks failed");
807 if(origownvtx){
808 delete origownvtx;
809 origownvtx=NULL;
810 }
811 return kFALSE;
812 }
813 //set recalculed primary vertex
814 d->SetOwnPrimaryVtx(recvtx);
815 delete recvtx; recvtx=NULL;
816
817 return kTRUE;
818}
819//--------------------------------------------------------------------------
820void AliRDHFCuts::CleanOwnPrimaryVtx(AliAODRecoDecayHF *d,AliAODVertex *origownvtx) const
821{
822 //
823 // Clean-up own primary vertex if needed
824 //
825
826 if(origownvtx) {
827 d->SetOwnPrimaryVtx(origownvtx);
828 delete origownvtx;
829 origownvtx=NULL;
830 } else if(fRemoveDaughtersFromPrimary) {
831 d->UnsetOwnPrimaryVtx();
832 AliDebug(3,"delete new vertex\n");
833 }
834
835 return;
836}
837
838
839