-/**************************************************************************
- * Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Author: The ALICE Off-line Project. *
- * Contributors are mentioned in the code where appropriate. *
- * *
- * Permission to use, copy, modify and distribute this software and its *
- * documentation strictly for non-commercial purposes is hereby granted *
- * without fee, provided that the above copyright notice appears in all *
- * copies and that both the copyright notice and this permission notice *
- * appear in the supporting documentation. The authors make no claims *
- * about the suitability of this software for any purpose. It is *
- * provided "as is" without express or implied warranty. *
- **************************************************************************/
-
-/////////////////////////////////////////////////////////////
-//
-// Base class for cuts on AOD reconstructed heavy-flavour decay
-//
-// Author: A.Dainese, andrea.dainese@pd.infn.it
-/////////////////////////////////////////////////////////////
-#include <Riostream.h>
-
-#include "AliVEvent.h"
-#include "AliESDEvent.h"
-#include "AliAODEvent.h"
-#include "AliVVertex.h"
-#include "AliESDVertex.h"
-#include "AliLog.h"
-#include "AliAODVertex.h"
-#include "AliESDtrack.h"
-#include "AliAODTrack.h"
-#include "AliESDtrackCuts.h"
-#include "AliAODRecoDecayHF.h"
-#include "AliRDHFCuts.h"
-
-ClassImp(AliRDHFCuts)
-
-//--------------------------------------------------------------------------
-AliRDHFCuts::AliRDHFCuts(const Char_t* name, const Char_t* title) :
-AliAnalysisCuts(name,title),
-fMinVtxType(3),
-fMinVtxContr(1),
-fMaxVtxRedChi2(1e6),
-fMaxVtxZ(1e6),
-fMinSPDMultiplicity(0),
-fTriggerMask(0),
-fTrackCuts(0),
-fnPtBins(1),
-fnPtBinLimits(1),
-fPtBinLimits(0),
-fnVars(1),
-fVarNames(0),
-fnVarsForOpt(0),
-fVarsForOpt(0),
-fGlobalIndex(1),
-fCutsRD(0),
-fIsUpperCut(0),
-fUsePID(kFALSE),
-fPidHF(0),
-fWhyRejection(0),
-fRemoveDaughtersFromPrimary(kFALSE),
-fOptPileup(0),
-fMinContrPileup(3),
-fMinDzPileup(0.6),
-fUseCentrality(0),
-fMinCentrality(0.),
-fMaxCentrality(100.)
-
-{
- //
- // Default Constructor
- //
-}
-//--------------------------------------------------------------------------
-AliRDHFCuts::AliRDHFCuts(const AliRDHFCuts &source) :
- AliAnalysisCuts(source),
- fMinVtxType(source.fMinVtxType),
- fMinVtxContr(source.fMinVtxContr),
- fMaxVtxRedChi2(source.fMaxVtxRedChi2),
- fMaxVtxZ(source.fMaxVtxZ),
- fMinSPDMultiplicity(source.fMinSPDMultiplicity),
- fTriggerMask(source.fTriggerMask),
- fTrackCuts(0),
- fnPtBins(source.fnPtBins),
- fnPtBinLimits(source.fnPtBinLimits),
- fPtBinLimits(0),
- fnVars(source.fnVars),
- fVarNames(0),
- fnVarsForOpt(source.fnVarsForOpt),
- fVarsForOpt(0),
- fGlobalIndex(source.fGlobalIndex),
- fCutsRD(0),
- fIsUpperCut(0),
- fUsePID(source.fUsePID),
- fPidHF(0),
- fWhyRejection(source.fWhyRejection),
- fRemoveDaughtersFromPrimary(source.fRemoveDaughtersFromPrimary),
- fOptPileup(source.fOptPileup),
- fMinContrPileup(source.fMinContrPileup),
- fMinDzPileup(source.fMinDzPileup),
- fUseCentrality(source.fUseCentrality),
- fMinCentrality(source.fMinCentrality),
- fMaxCentrality(source.fMaxCentrality)
-
-
-{
- //
- // Copy constructor
- //
- cout<<"Copy constructor"<<endl;
- if(source.GetTrackCuts()) AddTrackCuts(source.GetTrackCuts());
- if(source.fPtBinLimits) SetPtBins(source.fnPtBinLimits,source.fPtBinLimits);
- if(source.fVarNames) SetVarNames(source.fnVars,source.fVarNames,source.fIsUpperCut);
- if(source.fCutsRD) SetCuts(source.fGlobalIndex,source.fCutsRD);
- if(source.fVarsForOpt) SetVarsForOpt(source.fnVarsForOpt,source.fVarsForOpt);
- if(source.fPidHF) SetPidHF(source.fPidHF);
- PrintAll();
-
-}
-//--------------------------------------------------------------------------
-AliRDHFCuts &AliRDHFCuts::operator=(const AliRDHFCuts &source)
-{
- //
- // assignment operator
- //
- if(&source == this) return *this;
-
- AliAnalysisCuts::operator=(source);
-
- fMinVtxType=source.fMinVtxType;
- fMinVtxContr=source.fMinVtxContr;
- fMaxVtxRedChi2=source.fMaxVtxRedChi2;
- fMaxVtxZ=source.fMaxVtxZ;
- fMinSPDMultiplicity=source.fMinSPDMultiplicity;
- fTriggerMask=source.fTriggerMask;
- fnPtBins=source.fnPtBins;
- fnVars=source.fnVars;
- fGlobalIndex=source.fGlobalIndex;
- fnVarsForOpt=source.fnVarsForOpt;
- fUsePID=source.fUsePID;
- SetPidHF(source.GetPidHF());
- fWhyRejection=source.fWhyRejection;
- fRemoveDaughtersFromPrimary=source.fRemoveDaughtersFromPrimary;
- fOptPileup=source.fOptPileup;
- fMinContrPileup=source.fMinContrPileup;
- fMinDzPileup=source.fMinDzPileup;
- fUseCentrality=source.fUseCentrality;
- fMinCentrality=source.fMinCentrality;
- fMaxCentrality=source.fMaxCentrality;
-
- if(source.GetTrackCuts()) AddTrackCuts(source.GetTrackCuts());
- if(source.fPtBinLimits) SetPtBins(source.fnPtBinLimits,source.fPtBinLimits);
- if(source.fVarNames) SetVarNames(source.fnVars,source.fVarNames,source.fIsUpperCut);
- if(source.fCutsRD) SetCuts(source.fGlobalIndex,source.fCutsRD);
- if(source.fVarsForOpt) SetVarsForOpt(source.fnVarsForOpt,source.fVarsForOpt);
- PrintAll();
-
- return *this;
-}
-//--------------------------------------------------------------------------
-AliRDHFCuts::~AliRDHFCuts() {
- //
- // Default Destructor
- //
- if(fPtBinLimits) {delete [] fPtBinLimits; fPtBinLimits=0;}
- if(fVarNames) {delete [] fVarNames; fVarNames=0;}
- if(fVarsForOpt) {delete [] fVarsForOpt; fVarsForOpt=0;}
- if(fCutsRD) {
- delete [] fCutsRD;
- fCutsRD=0;
- }
- if(fIsUpperCut) {delete [] fIsUpperCut; fIsUpperCut=0;}
- if(fPidHF){
- delete fPidHF;
- fPidHF=0;
- }
-}
-//---------------------------------------------------------------------------
-Bool_t AliRDHFCuts::IsEventSelected(AliVEvent *event) {
- //
- // Event selection
- //
- //if(fTriggerMask && event->GetTriggerMask()!=fTriggerMask) return kFALSE;
-
- fWhyRejection=0;
-
- // multiplicity cuts no implemented yet
-
- const AliVVertex *vertex = event->GetPrimaryVertex();
-
- if(!vertex) return kFALSE;
-
- TString title=vertex->GetTitle();
- if(title.Contains("Z") && fMinVtxType>1) return kFALSE;
- if(title.Contains("3D") && fMinVtxType>2) return kFALSE;
-
- if(vertex->GetNContributors()<fMinVtxContr) return kFALSE;
-
- if(TMath::Abs(vertex->GetZ())>fMaxVtxZ) return kFALSE;
-
- // switch to settings for 1-pad cls in TPC
- if(fPidHF) {
- if(event->GetRunNumber()>121693 && event->GetRunNumber()<136851)
- fPidHF->SetOnePad(kTRUE);
- if(event->GetRunNumber()>=136851 && event->GetRunNumber()<=139517)
- fPidHF->SetPbPb(kTRUE);
- }
-
- if(fOptPileup==kRejectPileupEvent){
- Int_t cutc=(Int_t)fMinContrPileup;
- Double_t cutz=(Double_t)fMinDzPileup;
- if(event->IsPileupFromSPD(cutc,cutz,3.,2.,10.)) {
- fWhyRejection=1;
- return kFALSE;
- }
- }
-
- //centrality selection
- if (!(fUseCentrality==kCentOff)){
-
- AliAODHeader *header=((AliAODEvent*)event)->GetHeader();
- AliCentrality *centrality=header->GetCentralityP();
- if(centrality){
- Float_t cent=-999.;
- if (fUseCentrality==kCentV0M) cent=(Float_t)(centrality->GetCentralityPercentile("V0M"));
- else {
- if (fUseCentrality==kCentTRK) cent=(Float_t)(centrality->GetCentralityPercentile("TRK"));
- else{
- if (fUseCentrality==kCentTKL) cent=(Float_t)(centrality->GetCentralityPercentile("TKL"));
- else{
- if (fUseCentrality==kCentCL1) cent=(Float_t)(centrality->GetCentralityPercentile("CL1"));
- else {
- fWhyRejection=3;
- return kFALSE;
- }
- }
- }
- }
-
-
- if (cent<fMinCentrality || cent>fMaxCentrality){
- fWhyRejection=2;
- return kFALSE;
- }
- }
- }
-
-
- return kTRUE;
-}
-//---------------------------------------------------------------------------
-Bool_t AliRDHFCuts::AreDaughtersSelected(AliAODRecoDecayHF *d) const {
- //
- // Daughter tracks selection
- //
- if(!fTrackCuts) return kTRUE;
-
- Int_t ndaughters = d->GetNDaughters();
- AliAODVertex *vAOD = d->GetPrimaryVtx();
- Double_t pos[3],cov[6];
- vAOD->GetXYZ(pos);
- vAOD->GetCovarianceMatrix(cov);
- const AliESDVertex vESD(pos,cov,100.,100);
-
- Bool_t retval=kTRUE;
-
- for(Int_t idg=0; idg<ndaughters; idg++) {
- AliAODTrack *dgTrack = (AliAODTrack*)d->GetDaughter(idg);
- if(!dgTrack) retval = kFALSE;
- //printf("charge %d\n",dgTrack->Charge());
- if(dgTrack->Charge()==0) continue; // it's not a track, but a V0
-
- if(!IsDaughterSelected(dgTrack,&vESD,fTrackCuts)) retval = kFALSE;
- }
-
- return retval;
-}
-//---------------------------------------------------------------------------
-Bool_t AliRDHFCuts::IsDaughterSelected(AliAODTrack *track,const AliESDVertex *primary,AliESDtrackCuts *cuts) const {
- //
- // Convert to ESDtrack, relate to vertex and check cuts
- //
- if(!cuts) return kTRUE;
-
- Bool_t retval=kTRUE;
-
- // convert to ESD track here
- AliESDtrack esdTrack(track);
- // needed to calculate the impact parameters
- esdTrack.RelateToVertex(primary,0.,3.);
- if(!cuts->IsSelected(&esdTrack)) retval = kFALSE;
-
- if(fOptPileup==kRejectTracksFromPileupVertex){
- // to be implemented
- // we need either to have here the AOD Event,
- // or to have the pileup vertex object
- }
- return retval;
-}
-//---------------------------------------------------------------------------
-void AliRDHFCuts::SetPtBins(Int_t nPtBinLimits,Float_t *ptBinLimits) {
- // Set the pt bins
-
- if(fPtBinLimits) {
- delete [] fPtBinLimits;
- fPtBinLimits = NULL;
- printf("Changing the pt bins\n");
- }
-
- if(nPtBinLimits != fnPtBins+1){
- cout<<"Warning: ptBinLimits dimention "<<nPtBinLimits<<" != nPtBins+1 ("<<fnPtBins+1<<")\nSetting nPtBins to "<<nPtBinLimits-1<<endl;
- SetNPtBins(nPtBinLimits-1);
- }
-
- fnPtBinLimits = nPtBinLimits;
- SetGlobalIndex();
- //cout<<"Changing also Global Index -> "<<fGlobalIndex<<endl;
- fPtBinLimits = new Float_t[fnPtBinLimits];
- for(Int_t ib=0; ib<nPtBinLimits; ib++) fPtBinLimits[ib]=ptBinLimits[ib];
-
- return;
-}
-//---------------------------------------------------------------------------
-void AliRDHFCuts::SetVarNames(Int_t nVars,TString *varNames,Bool_t *isUpperCut){
- // Set the variable names
-
- if(fVarNames) {
- delete [] fVarNames;
- fVarNames = NULL;
- //printf("Changing the variable names\n");
- }
- if(nVars!=fnVars){
- printf("Wrong number of variables: it has to be %d\n",fnVars);
- return;
- }
- //fnVars=nVars;
- fVarNames = new TString[nVars];
- fIsUpperCut = new Bool_t[nVars];
- for(Int_t iv=0; iv<nVars; iv++) {
- fVarNames[iv] = varNames[iv];
- fIsUpperCut[iv] = isUpperCut[iv];
- }
-
- return;
-}
-//---------------------------------------------------------------------------
-void AliRDHFCuts::SetVarsForOpt(Int_t nVars,Bool_t *forOpt) {
- // Set the variables to be used for cuts optimization
-
- if(fVarsForOpt) {
- delete [] fVarsForOpt;
- fVarsForOpt = NULL;
- //printf("Changing the variables for cut optimization\n");
- }
-
- if(nVars==0){//!=fnVars) {
- printf("%d not accepted as number of variables: it has to be %d\n",nVars,fnVars);
- return;
- }
-
- fnVarsForOpt = 0;
- fVarsForOpt = new Bool_t[fnVars];
- for(Int_t iv=0; iv<fnVars; iv++) {
- fVarsForOpt[iv]=forOpt[iv];
- if(fVarsForOpt[iv]) fnVarsForOpt++;
- }
-
- return;
-}
-
-//---------------------------------------------------------------------------
-
-void AliRDHFCuts::SetUseCentrality(Int_t flag) {
- //
- // enable centrality selection
- //
- fUseCentrality=flag;
- if(fUseCentrality>=kCentInvalid) AliWarning("Centrality estimator not valid");
-
- return;
-}
-
-
-//---------------------------------------------------------------------------
-void AliRDHFCuts::SetCuts(Int_t nVars,Int_t nPtBins,Float_t **cutsRD) {
- //
- // store the cuts
- //
- if(nVars!=fnVars) {
- printf("Wrong number of variables: it has to be %d\n",fnVars);
- return;
- }
- if(nPtBins!=fnPtBins) {
- printf("Wrong number of pt bins: it has to be %d\n",fnPtBins);
- return;
- }
-
- if(!fCutsRD) fCutsRD = new Float_t[fGlobalIndex];
-
-
- for(Int_t iv=0; iv<fnVars; iv++) {
-
- for(Int_t ib=0; ib<fnPtBins; ib++) {
-
- //check
- if(GetGlobalIndex(iv,ib)>=fGlobalIndex) {
- cout<<"Overflow, exit..."<<endl;
- return;
- }
-
- fCutsRD[GetGlobalIndex(iv,ib)] = cutsRD[iv][ib];
-
- }
- }
- return;
-}
-//---------------------------------------------------------------------------
-void AliRDHFCuts::SetCuts(Int_t glIndex,Float_t* cutsRDGlob){
- //
- // store the cuts
- //
- if(glIndex != fGlobalIndex){
- cout<<"Wrong array size: it has to be "<<fGlobalIndex<<endl;
- return;
- }
- if(!fCutsRD) fCutsRD = new Float_t[fGlobalIndex];
-
- for(Int_t iGl=0;iGl<fGlobalIndex;iGl++){
- fCutsRD[iGl] = cutsRDGlob[iGl];
- }
- return;
-}
-//---------------------------------------------------------------------------
-void AliRDHFCuts::PrintAll() const {
- //
- // print all cuts values
- //
-
- printf("Minimum vtx type %d\n",fMinVtxType);
- printf("Minimum vtx contr %d\n",fMinVtxContr);
- printf("Max vtx red chi2 %f\n",fMaxVtxRedChi2);
- printf("Min SPD mult %d\n",fMinSPDMultiplicity);
- printf("Use PID %d\n",(Int_t)fUsePID);
- printf("Remove daughters from vtx %d\n",(Int_t)fRemoveDaughtersFromPrimary);
-
- if(fVarNames){
- cout<<"Array of variables"<<endl;
- for(Int_t iv=0;iv<fnVars;iv++){
- cout<<fVarNames[iv]<<"\t";
- }
- cout<<endl;
- }
- if(fVarsForOpt){
- cout<<"Array of optimization"<<endl;
- for(Int_t iv=0;iv<fnVars;iv++){
- cout<<fVarsForOpt[iv]<<"\t";
- }
- cout<<endl;
- }
- if(fIsUpperCut){
- cout<<"Array of upper/lower cut"<<endl;
- for(Int_t iv=0;iv<fnVars;iv++){
- cout<<fIsUpperCut[iv]<<"\t";
- }
- cout<<endl;
- }
- if(fPtBinLimits){
- cout<<"Array of ptbin limits"<<endl;
- for(Int_t ib=0;ib<fnPtBinLimits;ib++){
- cout<<fPtBinLimits[ib]<<"\t";
- }
- cout<<endl;
- }
- if(fCutsRD){
- cout<<"Matrix of cuts"<<endl;
- for(Int_t iv=0;iv<fnVars;iv++){
- for(Int_t ib=0;ib<fnPtBins;ib++){
- cout<<"fCutsRD["<<iv<<"]["<<ib<<"] = "<<fCutsRD[GetGlobalIndex(iv,ib)]<<"\t";
- }
- cout<<endl;
- }
- cout<<endl;
- }
- return;
-}
-//---------------------------------------------------------------------------
-void AliRDHFCuts::GetCuts(Float_t**& cutsRD) const{
- //
- // get the cuts
- //
-
- //cout<<"Give back a "<<fnVars<<"x"<<fnPtBins<<" matrix."<<endl;
-
-
- Int_t iv,ib;
- if(!cutsRD) {
- //cout<<"Initialization..."<<endl;
- cutsRD=new Float_t*[fnVars];
- for(iv=0; iv<fnVars; iv++) {
- cutsRD[iv] = new Float_t[fnPtBins];
- }
- }
-
- for(Int_t iGlobal=0; iGlobal<fGlobalIndex; iGlobal++) {
- GetVarPtIndex(iGlobal,iv,ib);
- cutsRD[iv][ib] = fCutsRD[iGlobal];
- }
-
- return;
-}
-
-//---------------------------------------------------------------------------
-Int_t AliRDHFCuts::GetGlobalIndex(Int_t iVar,Int_t iPtBin) const{
- //
- // give the global index from variable and pt bin
- //
- return iPtBin*fnVars+iVar;
-}
-
-//---------------------------------------------------------------------------
-void AliRDHFCuts::GetVarPtIndex(Int_t iGlob, Int_t& iVar, Int_t& iPtBin) const {
- //
- //give the index of the variable and of the pt bin from the global index
- //
- iPtBin=(Int_t)iGlob/fnVars;
- iVar=iGlob%fnVars;
-
- return;
-}
-
-//---------------------------------------------------------------------------
-Int_t AliRDHFCuts::PtBin(Double_t pt) const {
- //
- //give the pt bin where the pt lies.
- //
- Int_t ptbin=-1;
- for (Int_t i=0;i<fnPtBins;i++){
- if(pt<fPtBinLimits[i+1]) {
- ptbin=i;
- break;
- }
- }
- return ptbin;
-}
-//-------------------------------------------------------------------
-Float_t AliRDHFCuts::GetCutValue(Int_t iVar,Int_t iPtBin) const {
- //
- // Give the value of cut set for the variable iVar and the pt bin iPtBin
- //
- if(!fCutsRD){
- cout<<"Cuts not iniziaisez yet"<<endl;
- return 0;
- }
- return fCutsRD[GetGlobalIndex(iVar,iPtBin)];
-}
-//-------------------------------------------------------------------
-Float_t AliRDHFCuts::GetCentrality(AliAODEvent* aodEvent) {
- //
- // centrality percentile
- //
- AliAODHeader *header=aodEvent->GetHeader();
- AliCentrality *centrality=header->GetCentralityP();
- Float_t cent=-999.;
- if(centrality){
- if (fUseCentrality==kCentV0M) cent=(Float_t)(centrality->GetCentralityPercentile("V0M"));
- else {
- if (fUseCentrality==kCentTRK) cent=(Float_t)(centrality->GetCentralityPercentile("TRK"));
- else{
- if (fUseCentrality==kCentTKL) cent=(Float_t)(centrality->GetCentralityPercentile("TKL"));
- else{
- if (fUseCentrality==kCentCL1) cent=(Float_t)(centrality->GetCentralityPercentile("CL1"));
- else {
- AliWarning("Centrality estimator not valid");
- return kFALSE;
- }
- }
- }
- }
- }
- return cent;
-}
-//-------------------------------------------------------------------
-Bool_t AliRDHFCuts::CompareCuts(const AliRDHFCuts *obj) const {
- //
- // Compare two cuts objects
- //
-
- Bool_t areEqual=kTRUE;
-
- if(fMinVtxType!=obj->fMinVtxType) { printf("Minimum vtx type %d %d\n",fMinVtxType,obj->fMinVtxType); areEqual=kFALSE;}
-
- if(fMinVtxContr!=obj->fMinVtxContr) { printf("Minimum vtx contr %d %d\n",fMinVtxContr,obj->fMinVtxContr); areEqual=kFALSE;}
-
- if(TMath::Abs(fMaxVtxRedChi2-obj->fMaxVtxRedChi2)>1.e-10) { printf("Max vtx red chi2 %f %f\n",fMaxVtxRedChi2,obj->fMaxVtxRedChi2);areEqual=kFALSE;}
-
- if(fMinSPDMultiplicity!=obj->fMinSPDMultiplicity) { printf("Min SPD mult %d\n %d",fMinSPDMultiplicity,obj->fMinSPDMultiplicity);areEqual=kFALSE;}
-
- if(fUsePID!=obj->fUsePID) { printf("Use PID %d %d\n",(Int_t)fUsePID,(Int_t)obj->fUsePID); areEqual=kFALSE;}
-
- if(fRemoveDaughtersFromPrimary!=obj->fRemoveDaughtersFromPrimary) {printf("Remove daughters from vtx %d %d\n",(Int_t)fRemoveDaughtersFromPrimary,(Int_t)obj->fRemoveDaughtersFromPrimary); areEqual=kFALSE;}
- if(fTrackCuts){
- if(fTrackCuts->GetMinNClusterTPC()!=obj->fTrackCuts->GetMinNClusterTPC()) {printf("MinNClsTPC %d %d\n",fTrackCuts->GetMinNClusterTPC(),obj->fTrackCuts->GetMinNClusterTPC()); areEqual=kFALSE;}
-
- if(fTrackCuts->GetMinNClustersITS()!=obj->fTrackCuts->GetMinNClustersITS()) {printf("MinNClsITS %d %d\n",fTrackCuts->GetMinNClustersITS(),obj->fTrackCuts->GetMinNClustersITS()); areEqual=kFALSE;}
-
- if(TMath::Abs(fTrackCuts->GetMaxChi2PerClusterTPC()-obj->fTrackCuts->GetMaxChi2PerClusterTPC())>1.e-10) {printf("MaxChi2ClsTPC %f %f\n",fTrackCuts->GetMaxChi2PerClusterTPC(),obj->fTrackCuts->GetMaxChi2PerClusterTPC()); areEqual=kFALSE;}
-
- 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;}
- }
-
- if(fCutsRD) {
- for(Int_t iv=0;iv<fnVars;iv++) {
- for(Int_t ib=0;ib<fnPtBins;ib++) {
- if(TMath::Abs(fCutsRD[GetGlobalIndex(iv,ib)]-obj->fCutsRD[GetGlobalIndex(iv,ib)])>1.e-10) {
- cout<<"fCutsRD["<<iv<<"]["<<ib<<"] = "<<fCutsRD[GetGlobalIndex(iv,ib)]<<" "<<obj->fCutsRD[GetGlobalIndex(iv,ib)]<<"\n";
- areEqual=kFALSE;
- }
- }
- }
- }
-
- return areEqual;
-}
-//---------------------------------------------------------------------------
-void AliRDHFCuts::MakeTable() const {
- //
- // print cuts values in table format
- //
-
- TString ptString = "pT range";
- if(fVarNames && fPtBinLimits && fCutsRD){
- TString firstLine(Form("* %-15s",ptString.Data()));
- for (Int_t ivar=0; ivar<fnVars; ivar++){
- firstLine+=Form("* %-15s ",fVarNames[ivar].Data());
- if (ivar == fnVars){
- firstLine+="*\n";
- }
- }
- Printf("%s",firstLine.Data());
-
- for (Int_t ipt=0; ipt<fnPtBins; ipt++){
- TString line;
- if (ipt==fnPtBins-1){
- line=Form("* %5.1f < pt < inf ",fPtBinLimits[ipt]);
- }
- else{
- line=Form("* %5.1f < pt < %4.1f ",fPtBinLimits[ipt],fPtBinLimits[ipt+1]);
- }
- for (Int_t ivar=0; ivar<fnVars; ivar++){
- line+=Form("* %-15f ",fCutsRD[GetGlobalIndex(ivar,ipt)]);
- }
- Printf("%s",line.Data());
- }
-
- }
-
-
- return;
-}
+/**************************************************************************\r
+ * Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *\r
+ * *\r
+ * Author: The ALICE Off-line Project. *\r
+ * Contributors are mentioned in the code where appropriate. *\r
+ * *\r
+ * Permission to use, copy, modify and distribute this software and its *\r
+ * documentation strictly for non-commercial purposes is hereby granted *\r
+ * without fee, provided that the above copyright notice appears in all *\r
+ * copies and that both the copyright notice and this permission notice *\r
+ * appear in the supporting documentation. The authors make no claims *\r
+ * about the suitability of this software for any purpose. It is *\r
+ * provided "as is" without express or implied warranty. *\r
+ **************************************************************************/\r
+\r
+/////////////////////////////////////////////////////////////\r
+//\r
+// Base class for cuts on AOD reconstructed heavy-flavour decay\r
+//\r
+// Author: A.Dainese, andrea.dainese@pd.infn.it\r
+/////////////////////////////////////////////////////////////\r
+#include <Riostream.h>\r
+\r
+#include "AliVEvent.h"\r
+#include "AliESDEvent.h"\r
+#include "AliAODEvent.h"\r
+#include "AliVVertex.h"\r
+#include "AliESDVertex.h"\r
+#include "AliLog.h"\r
+#include "AliAODVertex.h"\r
+#include "AliESDtrack.h"\r
+#include "AliAODTrack.h"\r
+#include "AliESDtrackCuts.h"\r
+#include "AliAODRecoDecayHF.h"\r
+#include "AliRDHFCuts.h"\r
+\r
+ClassImp(AliRDHFCuts)\r
+\r
+//--------------------------------------------------------------------------\r
+AliRDHFCuts::AliRDHFCuts(const Char_t* name, const Char_t* title) : \r
+AliAnalysisCuts(name,title),\r
+fMinVtxType(3),\r
+fMinVtxContr(1),\r
+fMaxVtxRedChi2(1e6),\r
+fMaxVtxZ(1e6),\r
+fMinSPDMultiplicity(0),\r
+fTriggerMask(0),\r
+fTrackCuts(0),\r
+fnPtBins(1),\r
+fnPtBinLimits(1),\r
+fPtBinLimits(0),\r
+fnVars(1),\r
+fVarNames(0),\r
+fnVarsForOpt(0),\r
+fVarsForOpt(0),\r
+fGlobalIndex(1),\r
+fCutsRD(0),\r
+fIsUpperCut(0),\r
+fUsePID(kFALSE),\r
+fPidHF(0),\r
+fWhyRejection(0),\r
+fRemoveDaughtersFromPrimary(kFALSE),\r
+fOptPileup(0),\r
+fMinContrPileup(3),\r
+fMinDzPileup(0.6),\r
+fUseCentrality(0),\r
+fMinCentrality(0.),\r
+fMaxCentrality(100.)\r
+\r
+{\r
+ //\r
+ // Default Constructor\r
+ //\r
+}\r
+//--------------------------------------------------------------------------\r
+AliRDHFCuts::AliRDHFCuts(const AliRDHFCuts &source) :\r
+ AliAnalysisCuts(source),\r
+ fMinVtxType(source.fMinVtxType),\r
+ fMinVtxContr(source.fMinVtxContr),\r
+ fMaxVtxRedChi2(source.fMaxVtxRedChi2),\r
+ fMaxVtxZ(source.fMaxVtxZ),\r
+ fMinSPDMultiplicity(source.fMinSPDMultiplicity),\r
+ fTriggerMask(source.fTriggerMask),\r
+ fTrackCuts(0),\r
+ fnPtBins(source.fnPtBins),\r
+ fnPtBinLimits(source.fnPtBinLimits),\r
+ fPtBinLimits(0),\r
+ fnVars(source.fnVars),\r
+ fVarNames(0),\r
+ fnVarsForOpt(source.fnVarsForOpt),\r
+ fVarsForOpt(0),\r
+ fGlobalIndex(source.fGlobalIndex),\r
+ fCutsRD(0),\r
+ fIsUpperCut(0),\r
+ fUsePID(source.fUsePID),\r
+ fPidHF(0),\r
+ fWhyRejection(source.fWhyRejection),\r
+ fRemoveDaughtersFromPrimary(source.fRemoveDaughtersFromPrimary),\r
+ fOptPileup(source.fOptPileup),\r
+ fMinContrPileup(source.fMinContrPileup),\r
+ fMinDzPileup(source.fMinDzPileup),\r
+ fUseCentrality(source.fUseCentrality),\r
+ fMinCentrality(source.fMinCentrality),\r
+ fMaxCentrality(source.fMaxCentrality)\r
+\r
+\r
+{\r
+ //\r
+ // Copy constructor\r
+ //\r
+ cout<<"Copy constructor"<<endl;\r
+ if(source.GetTrackCuts()) AddTrackCuts(source.GetTrackCuts());\r
+ if(source.fPtBinLimits) SetPtBins(source.fnPtBinLimits,source.fPtBinLimits);\r
+ if(source.fVarNames) SetVarNames(source.fnVars,source.fVarNames,source.fIsUpperCut);\r
+ if(source.fCutsRD) SetCuts(source.fGlobalIndex,source.fCutsRD);\r
+ if(source.fVarsForOpt) SetVarsForOpt(source.fnVarsForOpt,source.fVarsForOpt);\r
+ if(source.fPidHF) SetPidHF(source.fPidHF);\r
+ PrintAll();\r
+\r
+}\r
+//--------------------------------------------------------------------------\r
+AliRDHFCuts &AliRDHFCuts::operator=(const AliRDHFCuts &source)\r
+{\r
+ //\r
+ // assignment operator\r
+ //\r
+ if(&source == this) return *this;\r
+\r
+ AliAnalysisCuts::operator=(source);\r
+\r
+ fMinVtxType=source.fMinVtxType;\r
+ fMinVtxContr=source.fMinVtxContr;\r
+ fMaxVtxRedChi2=source.fMaxVtxRedChi2;\r
+ fMaxVtxZ=source.fMaxVtxZ;\r
+ fMinSPDMultiplicity=source.fMinSPDMultiplicity;\r
+ fTriggerMask=source.fTriggerMask;\r
+ fnPtBins=source.fnPtBins;\r
+ fnVars=source.fnVars;\r
+ fGlobalIndex=source.fGlobalIndex;\r
+ fnVarsForOpt=source.fnVarsForOpt;\r
+ fUsePID=source.fUsePID;\r
+ SetPidHF(source.GetPidHF());\r
+ fWhyRejection=source.fWhyRejection;\r
+ fRemoveDaughtersFromPrimary=source.fRemoveDaughtersFromPrimary;\r
+ fOptPileup=source.fOptPileup;\r
+ fMinContrPileup=source.fMinContrPileup;\r
+ fMinDzPileup=source.fMinDzPileup;\r
+ fUseCentrality=source.fUseCentrality;\r
+ fMinCentrality=source.fMinCentrality;\r
+ fMaxCentrality=source.fMaxCentrality;\r
+\r
+ if(source.GetTrackCuts()) AddTrackCuts(source.GetTrackCuts());\r
+ if(source.fPtBinLimits) SetPtBins(source.fnPtBinLimits,source.fPtBinLimits);\r
+ if(source.fVarNames) SetVarNames(source.fnVars,source.fVarNames,source.fIsUpperCut);\r
+ if(source.fCutsRD) SetCuts(source.fGlobalIndex,source.fCutsRD);\r
+ if(source.fVarsForOpt) SetVarsForOpt(source.fnVarsForOpt,source.fVarsForOpt);\r
+ PrintAll();\r
+\r
+ return *this;\r
+}\r
+//--------------------------------------------------------------------------\r
+AliRDHFCuts::~AliRDHFCuts() {\r
+ // \r
+ // Default Destructor\r
+ //\r
+ if(fPtBinLimits) {delete [] fPtBinLimits; fPtBinLimits=0;}\r
+ if(fVarNames) {delete [] fVarNames; fVarNames=0;}\r
+ if(fVarsForOpt) {delete [] fVarsForOpt; fVarsForOpt=0;}\r
+ if(fCutsRD) {\r
+ delete [] fCutsRD;\r
+ fCutsRD=0;\r
+ }\r
+ if(fIsUpperCut) {delete [] fIsUpperCut; fIsUpperCut=0;}\r
+ if(fPidHF){ \r
+ delete fPidHF;\r
+ fPidHF=0;\r
+ }\r
+}\r
+//---------------------------------------------------------------------------\r
+Bool_t AliRDHFCuts::IsEventSelected(AliVEvent *event) {\r
+ //\r
+ // Event selection\r
+ // \r
+ //if(fTriggerMask && event->GetTriggerMask()!=fTriggerMask) return kFALSE;\r
+\r
+ fWhyRejection=0;\r
+\r
+ // multiplicity cuts no implemented yet\r
+ \r
+ const AliVVertex *vertex = event->GetPrimaryVertex();\r
+\r
+ if(!vertex) return kFALSE;\r
+\r
+ TString title=vertex->GetTitle();\r
+ if(title.Contains("Z") && fMinVtxType>1) return kFALSE; \r
+ if(title.Contains("3D") && fMinVtxType>2) return kFALSE; \r
+\r
+ if(vertex->GetNContributors()<fMinVtxContr) return kFALSE; \r
+\r
+ if(TMath::Abs(vertex->GetZ())>fMaxVtxZ) return kFALSE;\r
+\r
+ // switch to settings for 1-pad cls in TPC\r
+ if(fPidHF) {\r
+ if(event->GetRunNumber()>121693 && event->GetRunNumber()<136851) \r
+ fPidHF->SetOnePad(kTRUE);\r
+ if(event->GetRunNumber()>=136851 && event->GetRunNumber()<=139517) \r
+ fPidHF->SetPbPb(kTRUE);\r
+ }\r
+\r
+ if(fOptPileup==kRejectPileupEvent){\r
+ Int_t cutc=(Int_t)fMinContrPileup;\r
+ Double_t cutz=(Double_t)fMinDzPileup;\r
+ if(event->IsPileupFromSPD(cutc,cutz,3.,2.,10.)) {\r
+ fWhyRejection=1;\r
+ return kFALSE;\r
+ }\r
+ }\r
+\r
+ //centrality selection\r
+ if (!(fUseCentrality==kCentOff)){ \r
+ if(fUseCentrality<kCentOff||fUseCentrality>=kCentInvalid){\r
+ AliWarning("Centrality estimator not valid");\r
+ fWhyRejection=3;\r
+ return kFALSE;\r
+ }else{\r
+ Float_t centvalue=GetCentrality((AliAODEvent*)event);\r
+ if (centvalue<0.){\r
+ if (fWhyRejection==3) return kFALSE;\r
+ else return kTRUE;\r
+ }\r
+ else{\r
+ \r
+ if (centvalue<fMinCentrality || centvalue>fMaxCentrality){\r
+ fWhyRejection=2; \r
+ return kFALSE; \r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+\r
+ return kTRUE;\r
+}\r
+//---------------------------------------------------------------------------\r
+Bool_t AliRDHFCuts::AreDaughtersSelected(AliAODRecoDecayHF *d) const {\r
+ //\r
+ // Daughter tracks selection\r
+ // \r
+ if(!fTrackCuts) return kTRUE;\r
+\r
+ Int_t ndaughters = d->GetNDaughters();\r
+ AliAODVertex *vAOD = d->GetPrimaryVtx();\r
+ Double_t pos[3],cov[6];\r
+ vAOD->GetXYZ(pos);\r
+ vAOD->GetCovarianceMatrix(cov);\r
+ const AliESDVertex vESD(pos,cov,100.,100);\r
+\r
+ Bool_t retval=kTRUE;\r
+\r
+ for(Int_t idg=0; idg<ndaughters; idg++) {\r
+ AliAODTrack *dgTrack = (AliAODTrack*)d->GetDaughter(idg);\r
+ if(!dgTrack) retval = kFALSE;\r
+ //printf("charge %d\n",dgTrack->Charge());\r
+ if(dgTrack->Charge()==0) continue; // it's not a track, but a V0\r
+\r
+ if(!IsDaughterSelected(dgTrack,&vESD,fTrackCuts)) retval = kFALSE;\r
+ }\r
+\r
+ return retval;\r
+}\r
+//---------------------------------------------------------------------------\r
+Bool_t AliRDHFCuts::IsDaughterSelected(AliAODTrack *track,const AliESDVertex *primary,AliESDtrackCuts *cuts) const {\r
+ //\r
+ // Convert to ESDtrack, relate to vertex and check cuts\r
+ //\r
+ if(!cuts) return kTRUE;\r
+\r
+ Bool_t retval=kTRUE;\r
+\r
+ // convert to ESD track here\r
+ AliESDtrack esdTrack(track);\r
+ // needed to calculate the impact parameters\r
+ esdTrack.RelateToVertex(primary,0.,3.); \r
+ if(!cuts->IsSelected(&esdTrack)) retval = kFALSE;\r
+ \r
+ if(fOptPileup==kRejectTracksFromPileupVertex){\r
+ // to be implemented\r
+ // we need either to have here the AOD Event, \r
+ // or to have the pileup vertex object\r
+ }\r
+ return retval; \r
+}\r
+//---------------------------------------------------------------------------\r
+void AliRDHFCuts::SetPtBins(Int_t nPtBinLimits,Float_t *ptBinLimits) {\r
+ // Set the pt bins\r
+\r
+ if(fPtBinLimits) {\r
+ delete [] fPtBinLimits;\r
+ fPtBinLimits = NULL;\r
+ printf("Changing the pt bins\n");\r
+ }\r
+\r
+ if(nPtBinLimits != fnPtBins+1){\r
+ cout<<"Warning: ptBinLimits dimention "<<nPtBinLimits<<" != nPtBins+1 ("<<fnPtBins+1<<")\nSetting nPtBins to "<<nPtBinLimits-1<<endl;\r
+ SetNPtBins(nPtBinLimits-1);\r
+ }\r
+\r
+ fnPtBinLimits = nPtBinLimits;\r
+ SetGlobalIndex();\r
+ //cout<<"Changing also Global Index -> "<<fGlobalIndex<<endl;\r
+ fPtBinLimits = new Float_t[fnPtBinLimits];\r
+ for(Int_t ib=0; ib<nPtBinLimits; ib++) fPtBinLimits[ib]=ptBinLimits[ib];\r
+\r
+ return;\r
+}\r
+//---------------------------------------------------------------------------\r
+void AliRDHFCuts::SetVarNames(Int_t nVars,TString *varNames,Bool_t *isUpperCut){\r
+ // Set the variable names\r
+\r
+ if(fVarNames) {\r
+ delete [] fVarNames;\r
+ fVarNames = NULL;\r
+ //printf("Changing the variable names\n");\r
+ }\r
+ if(nVars!=fnVars){\r
+ printf("Wrong number of variables: it has to be %d\n",fnVars);\r
+ return;\r
+ }\r
+ //fnVars=nVars;\r
+ fVarNames = new TString[nVars];\r
+ fIsUpperCut = new Bool_t[nVars];\r
+ for(Int_t iv=0; iv<nVars; iv++) {\r
+ fVarNames[iv] = varNames[iv];\r
+ fIsUpperCut[iv] = isUpperCut[iv];\r
+ }\r
+\r
+ return;\r
+}\r
+//---------------------------------------------------------------------------\r
+void AliRDHFCuts::SetVarsForOpt(Int_t nVars,Bool_t *forOpt) {\r
+ // Set the variables to be used for cuts optimization\r
+\r
+ if(fVarsForOpt) {\r
+ delete [] fVarsForOpt;\r
+ fVarsForOpt = NULL;\r
+ //printf("Changing the variables for cut optimization\n");\r
+ }\r
+ \r
+ if(nVars==0){//!=fnVars) {\r
+ printf("%d not accepted as number of variables: it has to be %d\n",nVars,fnVars);\r
+ return;\r
+ } \r
+ \r
+ fnVarsForOpt = 0;\r
+ fVarsForOpt = new Bool_t[fnVars];\r
+ for(Int_t iv=0; iv<fnVars; iv++) {\r
+ fVarsForOpt[iv]=forOpt[iv];\r
+ if(fVarsForOpt[iv]) fnVarsForOpt++;\r
+ }\r
+\r
+ return;\r
+}\r
+\r
+//---------------------------------------------------------------------------\r
+void AliRDHFCuts::SetUseCentrality(Int_t flag) {\r
+ //\r
+ // set centrality estimator\r
+ //\r
+ fUseCentrality=flag;\r
+ if (fUseCentrality<kCentOff||fUseCentrality>=kCentInvalid) AliWarning("Centrality estimator not valid");\r
+ \r
+ return;\r
+}\r
+\r
+\r
+//---------------------------------------------------------------------------\r
+void AliRDHFCuts::SetCuts(Int_t nVars,Int_t nPtBins,Float_t **cutsRD) {\r
+ //\r
+ // store the cuts\r
+ //\r
+ if(nVars!=fnVars) {\r
+ printf("Wrong number of variables: it has to be %d\n",fnVars);\r
+ return;\r
+ } \r
+ if(nPtBins!=fnPtBins) {\r
+ printf("Wrong number of pt bins: it has to be %d\n",fnPtBins);\r
+ return;\r
+ } \r
+\r
+ if(!fCutsRD) fCutsRD = new Float_t[fGlobalIndex];\r
+ \r
+\r
+ for(Int_t iv=0; iv<fnVars; iv++) {\r
+\r
+ for(Int_t ib=0; ib<fnPtBins; ib++) {\r
+\r
+ //check\r
+ if(GetGlobalIndex(iv,ib)>=fGlobalIndex) {\r
+ cout<<"Overflow, exit..."<<endl;\r
+ return;\r
+ }\r
+\r
+ fCutsRD[GetGlobalIndex(iv,ib)] = cutsRD[iv][ib];\r
+\r
+ }\r
+ }\r
+ return;\r
+}\r
+//---------------------------------------------------------------------------\r
+void AliRDHFCuts::SetCuts(Int_t glIndex,Float_t* cutsRDGlob){\r
+ //\r
+ // store the cuts\r
+ //\r
+ if(glIndex != fGlobalIndex){\r
+ cout<<"Wrong array size: it has to be "<<fGlobalIndex<<endl;\r
+ return;\r
+ }\r
+ if(!fCutsRD) fCutsRD = new Float_t[fGlobalIndex];\r
+\r
+ for(Int_t iGl=0;iGl<fGlobalIndex;iGl++){\r
+ fCutsRD[iGl] = cutsRDGlob[iGl];\r
+ }\r
+ return;\r
+}\r
+//---------------------------------------------------------------------------\r
+void AliRDHFCuts::PrintAll() const {\r
+ //\r
+ // print all cuts values\r
+ // \r
+\r
+ printf("Minimum vtx type %d\n",fMinVtxType);\r
+ printf("Minimum vtx contr %d\n",fMinVtxContr);\r
+ printf("Max vtx red chi2 %f\n",fMaxVtxRedChi2);\r
+ printf("Min SPD mult %d\n",fMinSPDMultiplicity);\r
+ printf("Use PID %d\n",(Int_t)fUsePID);\r
+ printf("Remove daughters from vtx %d\n",(Int_t)fRemoveDaughtersFromPrimary);\r
+\r
+ if(fVarNames){\r
+ cout<<"Array of variables"<<endl;\r
+ for(Int_t iv=0;iv<fnVars;iv++){\r
+ cout<<fVarNames[iv]<<"\t";\r
+ }\r
+ cout<<endl;\r
+ }\r
+ if(fVarsForOpt){\r
+ cout<<"Array of optimization"<<endl;\r
+ for(Int_t iv=0;iv<fnVars;iv++){\r
+ cout<<fVarsForOpt[iv]<<"\t";\r
+ }\r
+ cout<<endl;\r
+ }\r
+ if(fIsUpperCut){\r
+ cout<<"Array of upper/lower cut"<<endl;\r
+ for(Int_t iv=0;iv<fnVars;iv++){\r
+ cout<<fIsUpperCut[iv]<<"\t";\r
+ }\r
+ cout<<endl;\r
+ }\r
+ if(fPtBinLimits){\r
+ cout<<"Array of ptbin limits"<<endl;\r
+ for(Int_t ib=0;ib<fnPtBinLimits;ib++){\r
+ cout<<fPtBinLimits[ib]<<"\t";\r
+ }\r
+ cout<<endl;\r
+ }\r
+ if(fCutsRD){\r
+ cout<<"Matrix of cuts"<<endl;\r
+ for(Int_t iv=0;iv<fnVars;iv++){\r
+ for(Int_t ib=0;ib<fnPtBins;ib++){\r
+ cout<<"fCutsRD["<<iv<<"]["<<ib<<"] = "<<fCutsRD[GetGlobalIndex(iv,ib)]<<"\t";\r
+ }\r
+ cout<<endl;\r
+ }\r
+ cout<<endl;\r
+ }\r
+ return;\r
+}\r
+//---------------------------------------------------------------------------\r
+void AliRDHFCuts::GetCuts(Float_t**& cutsRD) const{\r
+ //\r
+ // get the cuts\r
+ //\r
+\r
+ //cout<<"Give back a "<<fnVars<<"x"<<fnPtBins<<" matrix."<<endl;\r
+\r
+\r
+ Int_t iv,ib;\r
+ if(!cutsRD) {\r
+ //cout<<"Initialization..."<<endl;\r
+ cutsRD=new Float_t*[fnVars];\r
+ for(iv=0; iv<fnVars; iv++) {\r
+ cutsRD[iv] = new Float_t[fnPtBins];\r
+ }\r
+ }\r
+ \r
+ for(Int_t iGlobal=0; iGlobal<fGlobalIndex; iGlobal++) {\r
+ GetVarPtIndex(iGlobal,iv,ib);\r
+ cutsRD[iv][ib] = fCutsRD[iGlobal];\r
+ }\r
+\r
+ return;\r
+}\r
+\r
+//---------------------------------------------------------------------------\r
+Int_t AliRDHFCuts::GetGlobalIndex(Int_t iVar,Int_t iPtBin) const{\r
+ //\r
+ // give the global index from variable and pt bin\r
+ //\r
+ return iPtBin*fnVars+iVar;\r
+}\r
+\r
+//---------------------------------------------------------------------------\r
+void AliRDHFCuts::GetVarPtIndex(Int_t iGlob, Int_t& iVar, Int_t& iPtBin) const {\r
+ //\r
+ //give the index of the variable and of the pt bin from the global index\r
+ //\r
+ iPtBin=(Int_t)iGlob/fnVars;\r
+ iVar=iGlob%fnVars;\r
+\r
+ return;\r
+}\r
+\r
+//---------------------------------------------------------------------------\r
+Int_t AliRDHFCuts::PtBin(Double_t pt) const {\r
+ //\r
+ //give the pt bin where the pt lies.\r
+ //\r
+ Int_t ptbin=-1;\r
+ for (Int_t i=0;i<fnPtBins;i++){\r
+ if(pt<fPtBinLimits[i+1]) {\r
+ ptbin=i;\r
+ break;\r
+ }\r
+ }\r
+ return ptbin;\r
+}\r
+//-------------------------------------------------------------------\r
+Float_t AliRDHFCuts::GetCutValue(Int_t iVar,Int_t iPtBin) const {\r
+ // \r
+ // Give the value of cut set for the variable iVar and the pt bin iPtBin\r
+ //\r
+ if(!fCutsRD){\r
+ cout<<"Cuts not iniziaisez yet"<<endl;\r
+ return 0;\r
+ }\r
+ return fCutsRD[GetGlobalIndex(iVar,iPtBin)];\r
+}\r
+//-------------------------------------------------------------------\r
+Float_t AliRDHFCuts::GetCentrality(AliAODEvent* aodEvent) const {\r
+ //\r
+ // Get centrality percentile\r
+ //\r
+ AliAODHeader *header=aodEvent->GetHeader();\r
+ AliCentrality *centrality=header->GetCentralityP();\r
+ Float_t cent=-999.;\r
+ if(!centrality) return cent;\r
+ else{\r
+ if (fUseCentrality==kCentV0M) cent=(Float_t)(centrality->GetCentralityPercentile("V0M"));\r
+ else {\r
+ if (fUseCentrality==kCentTRK) cent=(Float_t)(centrality->GetCentralityPercentile("TRK"));\r
+ else{\r
+ if (fUseCentrality==kCentTKL) cent=(Float_t)(centrality->GetCentralityPercentile("TKL"));\r
+ else{\r
+ if (fUseCentrality==kCentCL1) cent=(Float_t)(centrality->GetCentralityPercentile("CL1"));\r
+ else {\r
+ AliWarning("Centrality estimator not valid");\r
+ }\r
+ }\r
+ }\r
+ } \r
+ }\r
+ return cent;\r
+}\r
+//-------------------------------------------------------------------\r
+Bool_t AliRDHFCuts::CompareCuts(const AliRDHFCuts *obj) const {\r
+ //\r
+ // Compare two cuts objects\r
+ //\r
+\r
+ Bool_t areEqual=kTRUE;\r
+\r
+ if(fMinVtxType!=obj->fMinVtxType) { printf("Minimum vtx type %d %d\n",fMinVtxType,obj->fMinVtxType); areEqual=kFALSE;}\r
+\r
+ if(fMinVtxContr!=obj->fMinVtxContr) { printf("Minimum vtx contr %d %d\n",fMinVtxContr,obj->fMinVtxContr); areEqual=kFALSE;}\r
+\r
+ if(TMath::Abs(fMaxVtxRedChi2-obj->fMaxVtxRedChi2)>1.e-10) { printf("Max vtx red chi2 %f %f\n",fMaxVtxRedChi2,obj->fMaxVtxRedChi2);areEqual=kFALSE;}\r
+\r
+ if(fMinSPDMultiplicity!=obj->fMinSPDMultiplicity) { printf("Min SPD mult %d\n %d",fMinSPDMultiplicity,obj->fMinSPDMultiplicity);areEqual=kFALSE;}\r
+\r
+ if(fUsePID!=obj->fUsePID) { printf("Use PID %d %d\n",(Int_t)fUsePID,(Int_t)obj->fUsePID); areEqual=kFALSE;}\r
+\r
+ if(fRemoveDaughtersFromPrimary!=obj->fRemoveDaughtersFromPrimary) {printf("Remove daughters from vtx %d %d\n",(Int_t)fRemoveDaughtersFromPrimary,(Int_t)obj->fRemoveDaughtersFromPrimary); areEqual=kFALSE;}\r
+ if(fTrackCuts){\r
+ if(fTrackCuts->GetMinNClusterTPC()!=obj->fTrackCuts->GetMinNClusterTPC()) {printf("MinNClsTPC %d %d\n",fTrackCuts->GetMinNClusterTPC(),obj->fTrackCuts->GetMinNClusterTPC()); areEqual=kFALSE;}\r
+\r
+ if(fTrackCuts->GetMinNClustersITS()!=obj->fTrackCuts->GetMinNClustersITS()) {printf("MinNClsITS %d %d\n",fTrackCuts->GetMinNClustersITS(),obj->fTrackCuts->GetMinNClustersITS()); areEqual=kFALSE;}\r
+\r
+ if(TMath::Abs(fTrackCuts->GetMaxChi2PerClusterTPC()-obj->fTrackCuts->GetMaxChi2PerClusterTPC())>1.e-10) {printf("MaxChi2ClsTPC %f %f\n",fTrackCuts->GetMaxChi2PerClusterTPC(),obj->fTrackCuts->GetMaxChi2PerClusterTPC()); areEqual=kFALSE;}\r
+\r
+ 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;}\r
+ }\r
+\r
+ if(fCutsRD) {\r
+ for(Int_t iv=0;iv<fnVars;iv++) {\r
+ for(Int_t ib=0;ib<fnPtBins;ib++) {\r
+ if(TMath::Abs(fCutsRD[GetGlobalIndex(iv,ib)]-obj->fCutsRD[GetGlobalIndex(iv,ib)])>1.e-10) {\r
+ cout<<"fCutsRD["<<iv<<"]["<<ib<<"] = "<<fCutsRD[GetGlobalIndex(iv,ib)]<<" "<<obj->fCutsRD[GetGlobalIndex(iv,ib)]<<"\n";\r
+ areEqual=kFALSE;\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ return areEqual;\r
+}\r
+//---------------------------------------------------------------------------\r
+void AliRDHFCuts::MakeTable() const {\r
+ //\r
+ // print cuts values in table format\r
+ // \r
+\r
+ TString ptString = "pT range";\r
+ if(fVarNames && fPtBinLimits && fCutsRD){\r
+ TString firstLine(Form("* %-15s",ptString.Data()));\r
+ for (Int_t ivar=0; ivar<fnVars; ivar++){\r
+ firstLine+=Form("* %-15s ",fVarNames[ivar].Data());\r
+ if (ivar == fnVars){\r
+ firstLine+="*\n";\r
+ }\r
+ }\r
+ Printf("%s",firstLine.Data());\r
+ \r
+ for (Int_t ipt=0; ipt<fnPtBins; ipt++){\r
+ TString line;\r
+ if (ipt==fnPtBins-1){\r
+ line=Form("* %5.1f < pt < inf ",fPtBinLimits[ipt]);\r
+ }\r
+ else{\r
+ line=Form("* %5.1f < pt < %4.1f ",fPtBinLimits[ipt],fPtBinLimits[ipt+1]);\r
+ }\r
+ for (Int_t ivar=0; ivar<fnVars; ivar++){\r
+ line+=Form("* %-15f ",fCutsRD[GetGlobalIndex(ivar,ipt)]);\r
+ }\r
+ Printf("%s",line.Data());\r
+ }\r
+\r
+ }\r
+\r
+\r
+ return;\r
+}\r
-#ifndef ALIRDHFCUTS_H
-#define ALIRDHFCUTS_H
-/* Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice */
-
-//***********************************************************
-// Class AliRDHFCuts
-// base class for cuts on AOD reconstructed heavy-flavour decays
-// Author: A.Dainese, andrea.dainese@pd.infn.it
-//***********************************************************
-
-#include "AliAnalysisCuts.h"
-#include "AliESDtrackCuts.h"
-#include "AliAODPidHF.h"
-#include "AliAODEvent.h"
-#include "AliVEvent.h"
-
-class AliAODTrack;
-class AliAODRecoDecayHF;
-class AliESDVertex;
-
-class AliRDHFCuts : public AliAnalysisCuts
-{
- public:
-
- AliRDHFCuts(const Char_t* name="RDHFCuts", const Char_t* title="");
-
- virtual ~AliRDHFCuts();
-
- AliRDHFCuts(const AliRDHFCuts& source);
- AliRDHFCuts& operator=(const AliRDHFCuts& source);
-
- virtual void SetStandardCutsPP2010() {return;}
- virtual void SetStandardCutsPbPb2010() {return;}
-
-
- void SetMinCentrality(Float_t minCentrality=0.) {fMinCentrality=minCentrality;}
- void SetMaxCentrality(Float_t maxCentrality=100.) {fMinCentrality=maxCentrality;}
- void SetMinVtxType(Int_t type=3) {fMinVtxType=type;}
- void SetMinVtxContr(Int_t contr=1) {fMinVtxContr=contr;}
- void SetMaxVtxRdChi2(Float_t chi2=1e6) {fMaxVtxRedChi2=chi2;}
- void SetMaxVtxZ(Float_t z=1e6) {fMaxVtxZ=z;}
- void SetMinSPDMultiplicity(Int_t mult=0) {fMinSPDMultiplicity=mult;}
- void SetTriggerMask(ULong64_t mask=0) {fTriggerMask=mask;}
- void SetVarsForOpt(Int_t nVars,Bool_t *forOpt);
- void SetGlobalIndex(){fGlobalIndex=fnVars*fnPtBins;}
- void SetGlobalIndex(Int_t nVars,Int_t nptBins){fnVars=nVars; fnPtBins=nptBins; SetGlobalIndex();}
- void SetVarNames(Int_t nVars,TString *varNames,Bool_t *isUpperCut);
- void SetPtBins(Int_t nPtBinLimits,Float_t *ptBinLimits);
- void SetCuts(Int_t nVars,Int_t nPtBins,Float_t** cutsRD);
- void SetCuts(Int_t glIndex, Float_t* cutsRDGlob);
- void AddTrackCuts(const AliESDtrackCuts *cuts)
- {fTrackCuts=new AliESDtrackCuts(*cuts); return;}
- void SetUsePID(Bool_t flag=kTRUE) {fUsePID=flag; return;}
- void SetUseCentrality(Int_t flag=1); // see enum below
- void SetPidHF(AliAODPidHF* pidObj) {
- if(fPidHF) delete fPidHF;
- fPidHF=new AliAODPidHF(*pidObj);
- }
- void SetRemoveDaughtersFromPrim(Bool_t removeDaughtersPrim) {fRemoveDaughtersFromPrimary=removeDaughtersPrim;}
- void SetOptPileup(Int_t opt=0){
- // see enum below
- fOptPileup=opt;
- }
- void ConfigurePileupCuts(Int_t minContrib=3, Float_t minDz=0.6){
- fMinContrPileup=minContrib;
- fMinDzPileup=minDz;
- }
-
-
- AliAODPidHF* GetPidHF() const {return fPidHF;}
- Float_t *GetPtBinLimits() const {return fPtBinLimits;}
- Int_t GetNPtBins() const {return fnPtBins;}
- Int_t GetNVars() const {return fnVars;}
- TString *GetVarNames() const {return fVarNames;}
- Bool_t *GetVarsForOpt() const {return fVarsForOpt;}
- Int_t GetNVarsForOpt() const {return fnVarsForOpt;}
- const Float_t *GetCuts() const {return fCutsRD;}
- void GetCuts(Float_t**& cutsRD) const;
- Float_t GetCutValue(Int_t iVar,Int_t iPtBin) const;
- Float_t GetCentrality(AliAODEvent* aodEvent);
- Bool_t *GetIsUpperCut() const {return fIsUpperCut;}
- AliESDtrackCuts *GetTrackCuts() const {return fTrackCuts;}
- virtual void GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters) = 0;
- Int_t GetGlobalIndex(Int_t iVar,Int_t iPtBin) const;
- void GetVarPtIndex(Int_t iGlob, Int_t& iVar, Int_t& iPtBin) const;
- Bool_t GetIsUsePID() const {return fUsePID;}
- Bool_t GetIsPrimaryWithoutDaughters() const {return fRemoveDaughtersFromPrimary;}
- Bool_t GetOptPileUp() const {return fOptPileup;}
- Int_t GetUseCentrality() const {return fUseCentrality;}
- Float_t GetMinCentrality() const {return fMinCentrality;}
- Float_t GetMaxCentrality() const {return fMaxCentrality;}
- Bool_t IsSelected(TObject *obj) {return IsSelected(obj,AliRDHFCuts::kAll);}
- Bool_t IsSelected(TList *list) {if(!list) return kTRUE; return kFALSE;}
- Bool_t IsEventSelected(AliVEvent *event);
- Bool_t AreDaughtersSelected(AliAODRecoDecayHF *rd) const;
- Bool_t IsDaughterSelected(AliAODTrack *track,const AliESDVertex *primary,AliESDtrackCuts *cuts) const;
- virtual Int_t IsSelectedPID(AliAODRecoDecayHF * /*rd*/) {return 1;}
-
- virtual Int_t IsSelected(TObject* obj,Int_t selectionLevel) = 0;
- virtual Int_t IsSelected(TObject* obj,Int_t selectionLevel,AliAODEvent* /*aod*/)
- {return IsSelected(obj,selectionLevel);}
- Int_t PtBin(Double_t pt) const;
- void PrintAll()const;
-
- virtual Bool_t IsInFiducialAcceptance(Double_t /*pt*/,Double_t /*y*/) const {return kTRUE;}
-
- void SetWhyRejection(Int_t why) {fWhyRejection=why; return;}
- Int_t GetWhyRejection() const {return fWhyRejection;}
-
- Bool_t CompareCuts(const AliRDHFCuts *obj) const;
- void MakeTable()const;
-
- enum{kAll,kTracks,kPID,kCandidate};
- enum{kNoPileupSelection,kRejectPileupEvent,kRejectTracksFromPileupVertex};
- enum{kCentOff,kCentV0M,kCentTRK,kCentTKL,kCentCL1,kCentInvalid};
-
- protected:
-
- void SetNPtBins(Int_t nptBins){fnPtBins=nptBins;}
- void SetNVars(Int_t nVars){fnVars=nVars;}
-
- // cuts on the event
- Int_t fMinVtxType; // 0: not cut; 1: SPDZ; 2: SPD3D; 3: Tracks
- Int_t fMinVtxContr; // minimum vertex contributors
- Float_t fMaxVtxRedChi2; // maximum chi2/ndf
- Float_t fMaxVtxZ; // maximum |z| of primary vertex
- Int_t fMinSPDMultiplicity; // SPD multiplicity
- ULong64_t fTriggerMask; // trigger mask
- // quality cuts on the daughter tracks
- AliESDtrackCuts *fTrackCuts; // tracks for daughter tracks (AOD converted to ESD on the flight!)
- // cuts on the candidate
- Int_t fnPtBins; // number of pt bins for cuts
- Int_t fnPtBinLimits; // "number of limits", that is fnPtBins+1
- Float_t* fPtBinLimits; //[fnPtBinLimits] pt bins
- Int_t fnVars; // number of cut vars for candidates
- TString *fVarNames; //[fnVars] names of the variables
- Int_t fnVarsForOpt; // number of cut vars to be optimized for candidates
- Bool_t *fVarsForOpt; //[fnVars] kTRUE for vars to be used in optimization
- Int_t fGlobalIndex; // fnVars*fnPtBins
- Float_t *fCutsRD; //[fGlobalIndex] the cuts values
- Bool_t *fIsUpperCut; //[fnVars] use > or < to select
- Bool_t fUsePID; // enable PID usage (off by default)
- AliAODPidHF *fPidHF; // PID for heavy flavours manager
- Int_t fWhyRejection; // used to code the step at which candidate was rejected
- Bool_t fRemoveDaughtersFromPrimary; // flag to switch on the removal of duaghters from the primary vertex computation
- Int_t fOptPileup; // option for pielup selection
- Int_t fMinContrPileup; // min. n. of tracklets in pileup vertex
- Float_t fMinDzPileup; // min deltaz between main and pileup vertices
- Int_t fUseCentrality; // off =0 (default)
- // 1 = V0
- // 2 = Tracks
- // 3 = Tracklets
- // 4 = SPD clusters outer
- Float_t fMinCentrality; // minimum centrality for selected events
- Float_t fMaxCentrality; // maximum centrality for selected events
-
- ClassDef(AliRDHFCuts,8); // base class for cuts on AOD reconstructed heavy-flavour decays
-};
-
-#endif
+#ifndef ALIRDHFCUTS_H\r
+#define ALIRDHFCUTS_H\r
+/* Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *\r
+ * See cxx source for full Copyright notice */\r
+\r
+//***********************************************************\r
+// Class AliRDHFCuts\r
+// base class for cuts on AOD reconstructed heavy-flavour decays\r
+// Author: A.Dainese, andrea.dainese@pd.infn.it\r
+//***********************************************************\r
+\r
+#include "AliAnalysisCuts.h"\r
+#include "AliESDtrackCuts.h"\r
+#include "AliAODPidHF.h"\r
+#include "AliAODEvent.h"\r
+#include "AliVEvent.h"\r
+\r
+class AliAODTrack;\r
+class AliAODRecoDecayHF;\r
+class AliESDVertex;\r
+\r
+class AliRDHFCuts : public AliAnalysisCuts \r
+{\r
+ public:\r
+\r
+ AliRDHFCuts(const Char_t* name="RDHFCuts", const Char_t* title="");\r
+ \r
+ virtual ~AliRDHFCuts();\r
+ \r
+ AliRDHFCuts(const AliRDHFCuts& source);\r
+ AliRDHFCuts& operator=(const AliRDHFCuts& source); \r
+\r
+ virtual void SetStandardCutsPP2010() {return;} \r
+ virtual void SetStandardCutsPbPb2010() {return;} \r
+\r
+\r
+ void SetMinCentrality(Float_t minCentrality=0.) {fMinCentrality=minCentrality;} \r
+ void SetMaxCentrality(Float_t maxCentrality=100.) {fMinCentrality=maxCentrality;} \r
+ void SetMinVtxType(Int_t type=3) {fMinVtxType=type;} \r
+ void SetMinVtxContr(Int_t contr=1) {fMinVtxContr=contr;} \r
+ void SetMaxVtxRdChi2(Float_t chi2=1e6) {fMaxVtxRedChi2=chi2;} \r
+ void SetMaxVtxZ(Float_t z=1e6) {fMaxVtxZ=z;} \r
+ void SetMinSPDMultiplicity(Int_t mult=0) {fMinSPDMultiplicity=mult;} \r
+ void SetTriggerMask(ULong64_t mask=0) {fTriggerMask=mask;} \r
+ void SetVarsForOpt(Int_t nVars,Bool_t *forOpt);\r
+ void SetGlobalIndex(){fGlobalIndex=fnVars*fnPtBins;}\r
+ void SetGlobalIndex(Int_t nVars,Int_t nptBins){fnVars=nVars; fnPtBins=nptBins; SetGlobalIndex();}\r
+ void SetVarNames(Int_t nVars,TString *varNames,Bool_t *isUpperCut); \r
+ void SetPtBins(Int_t nPtBinLimits,Float_t *ptBinLimits);\r
+ void SetCuts(Int_t nVars,Int_t nPtBins,Float_t** cutsRD);\r
+ void SetCuts(Int_t glIndex, Float_t* cutsRDGlob);\r
+ void AddTrackCuts(const AliESDtrackCuts *cuts) \r
+ {fTrackCuts=new AliESDtrackCuts(*cuts); return;}\r
+ void SetUsePID(Bool_t flag=kTRUE) {fUsePID=flag; return;}\r
+ void SetUseCentrality(Int_t flag=1); // see enum below\r
+ void SetPidHF(AliAODPidHF* pidObj) {\r
+ if(fPidHF) delete fPidHF;\r
+ fPidHF=new AliAODPidHF(*pidObj);\r
+ }\r
+ void SetRemoveDaughtersFromPrim(Bool_t removeDaughtersPrim) {fRemoveDaughtersFromPrimary=removeDaughtersPrim;}\r
+ void SetOptPileup(Int_t opt=0){\r
+ // see enum below\r
+ fOptPileup=opt;\r
+ }\r
+ void ConfigurePileupCuts(Int_t minContrib=3, Float_t minDz=0.6){\r
+ fMinContrPileup=minContrib;\r
+ fMinDzPileup=minDz;\r
+ }\r
+\r
+\r
+ AliAODPidHF* GetPidHF() const {return fPidHF;}\r
+ Float_t *GetPtBinLimits() const {return fPtBinLimits;}\r
+ Int_t GetNPtBins() const {return fnPtBins;}\r
+ Int_t GetNVars() const {return fnVars;} \r
+ TString *GetVarNames() const {return fVarNames;} \r
+ Bool_t *GetVarsForOpt() const {return fVarsForOpt;} \r
+ Int_t GetNVarsForOpt() const {return fnVarsForOpt;}\r
+ const Float_t *GetCuts() const {return fCutsRD;} \r
+ void GetCuts(Float_t**& cutsRD) const;\r
+ Float_t GetCutValue(Int_t iVar,Int_t iPtBin) const;\r
+ Float_t GetCentrality(AliAODEvent* aodEvent) const;\r
+ Bool_t *GetIsUpperCut() const {return fIsUpperCut;}\r
+ AliESDtrackCuts *GetTrackCuts() const {return fTrackCuts;}\r
+ virtual void GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters) = 0;\r
+ Int_t GetGlobalIndex(Int_t iVar,Int_t iPtBin) const;\r
+ void GetVarPtIndex(Int_t iGlob, Int_t& iVar, Int_t& iPtBin) const;\r
+ Bool_t GetIsUsePID() const {return fUsePID;}\r
+ Bool_t GetIsPrimaryWithoutDaughters() const {return fRemoveDaughtersFromPrimary;}\r
+ Bool_t GetOptPileUp() const {return fOptPileup;}\r
+ Int_t GetUseCentrality() const {return fUseCentrality;}\r
+ Float_t GetMinCentrality() const {return fMinCentrality;}\r
+ Float_t GetMaxCentrality() const {return fMaxCentrality;}\r
+ Bool_t IsSelected(TObject *obj) {return IsSelected(obj,AliRDHFCuts::kAll);}\r
+ Bool_t IsSelected(TList *list) {if(!list) return kTRUE; return kFALSE;}\r
+ Bool_t IsEventSelected(AliVEvent *event);\r
+ Bool_t AreDaughtersSelected(AliAODRecoDecayHF *rd) const;\r
+ Bool_t IsDaughterSelected(AliAODTrack *track,const AliESDVertex *primary,AliESDtrackCuts *cuts) const;\r
+ virtual Int_t IsSelectedPID(AliAODRecoDecayHF * /*rd*/) {return 1;}\r
+\r
+ virtual Int_t IsSelected(TObject* obj,Int_t selectionLevel) = 0;\r
+ virtual Int_t IsSelected(TObject* obj,Int_t selectionLevel,AliAODEvent* /*aod*/)\r
+ {return IsSelected(obj,selectionLevel);}\r
+ Int_t PtBin(Double_t pt) const;\r
+ void PrintAll()const;\r
+\r
+ virtual Bool_t IsInFiducialAcceptance(Double_t /*pt*/,Double_t /*y*/) const {return kTRUE;}\r
+\r
+ void SetWhyRejection(Int_t why) {fWhyRejection=why; return;}\r
+ Int_t GetWhyRejection() const {return fWhyRejection;}\r
+\r
+ Bool_t CompareCuts(const AliRDHFCuts *obj) const;\r
+ void MakeTable()const;\r
+\r
+ enum{kAll,kTracks,kPID,kCandidate};\r
+ enum{kNoPileupSelection,kRejectPileupEvent,kRejectTracksFromPileupVertex};\r
+ enum{kCentOff,kCentV0M,kCentTRK,kCentTKL,kCentCL1,kCentInvalid};\r
+\r
+ protected:\r
+\r
+ void SetNPtBins(Int_t nptBins){fnPtBins=nptBins;}\r
+ void SetNVars(Int_t nVars){fnVars=nVars;}\r
+\r
+ // cuts on the event\r
+ Int_t fMinVtxType; // 0: not cut; 1: SPDZ; 2: SPD3D; 3: Tracks\r
+ Int_t fMinVtxContr; // minimum vertex contributors\r
+ Float_t fMaxVtxRedChi2; // maximum chi2/ndf\r
+ Float_t fMaxVtxZ; // maximum |z| of primary vertex\r
+ Int_t fMinSPDMultiplicity; // SPD multiplicity\r
+ ULong64_t fTriggerMask; // trigger mask\r
+ // quality cuts on the daughter tracks\r
+ AliESDtrackCuts *fTrackCuts; // tracks for daughter tracks (AOD converted to ESD on the flight!)\r
+ // cuts on the candidate\r
+ Int_t fnPtBins; // number of pt bins for cuts\r
+ Int_t fnPtBinLimits; // "number of limits", that is fnPtBins+1\r
+ Float_t* fPtBinLimits; //[fnPtBinLimits] pt bins\r
+ Int_t fnVars; // number of cut vars for candidates\r
+ TString *fVarNames; //[fnVars] names of the variables\r
+ Int_t fnVarsForOpt; // number of cut vars to be optimized for candidates\r
+ Bool_t *fVarsForOpt; //[fnVars] kTRUE for vars to be used in optimization\r
+ Int_t fGlobalIndex; // fnVars*fnPtBins\r
+ Float_t *fCutsRD; //[fGlobalIndex] the cuts values\r
+ Bool_t *fIsUpperCut; //[fnVars] use > or < to select\r
+ Bool_t fUsePID; // enable PID usage (off by default)\r
+ AliAODPidHF *fPidHF; // PID for heavy flavours manager\r
+ Int_t fWhyRejection; // used to code the step at which candidate was rejected\r
+ Bool_t fRemoveDaughtersFromPrimary; // flag to switch on the removal of duaghters from the primary vertex computation\r
+ Int_t fOptPileup; // option for pielup selection\r
+ Int_t fMinContrPileup; // min. n. of tracklets in pileup vertex\r
+ Float_t fMinDzPileup; // min deltaz between main and pileup vertices\r
+ Int_t fUseCentrality; // off =0 (default)\r
+ // 1 = V0 \r
+ // 2 = Tracks\r
+ // 3 = Tracklets\r
+ // 4 = SPD clusters outer \r
+ Float_t fMinCentrality; // minimum centrality for selected events\r
+ Float_t fMaxCentrality; // maximum centrality for selected events\r
+\r
+ ClassDef(AliRDHFCuts,8); // base class for cuts on AOD reconstructed heavy-flavour decays\r
+};\r
+\r
+#endif\r
+\r
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff