#pragma link C++ class AliAODRecoDecayHF3Prong+;
#pragma link C++ class AliAODRecoDecayHF4Prong+;
#pragma link C++ class AliAODRecoCascadeHF+;
+#pragma link C++ class AliRDHFCuts+;
+#pragma link C++ class AliRDHFCutsD0toKpi+;
#pragma link C++ class AliAnalysisVertexingHF+;
#pragma link C++ class AliAnalysisTaskSEVertexingHF+;
#pragma link C++ class AliAnalysisTaskMEVertexingHF+;
vertexingHF/AliAODRecoDecayHF2Prong.cxx vertexingHF/AliAODRecoDecayHF3Prong.cxx \
vertexingHF/AliAODRecoDecayHF4Prong.cxx \
vertexingHF/AliAODRecoCascadeHF.cxx \
+ vertexingHF/AliRDHFCuts.cxx \
+ vertexingHF/AliRDHFCutsD0toKpi.cxx \
vertexingHF/AliAnalysisVertexingHF.cxx \
vertexingHF/AliAnalysisTaskSEVertexingHF.cxx \
vertexingHF/AliAnalysisTaskMEVertexingHF.cxx \
--- /dev/null
+
+/**************************************************************************
+ * 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 "AliAODVertex.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),
+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)
+{
+ //
+ // Default Constructor
+ //
+}
+//--------------------------------------------------------------------------
+AliRDHFCuts::AliRDHFCuts(const AliRDHFCuts &source) :
+ AliAnalysisCuts(source),
+ fMinVtxType(source.fMinVtxType),
+ fMinVtxContr(source.fMinVtxContr),
+ fMaxVtxRedChi2(source.fMaxVtxRedChi2),
+ 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)
+{
+ //
+ // Copy constructor
+ //
+ cout<<"Copy constructor"<<endl;
+ if(source.GetTrackCuts()) AddTrackCuts(source.GetTrackCuts());
+ /*
+ if(source.GetPtBinLimits()) SetPtBins(source.fnPtBinLimits,source.GetPtBinLimits());
+ if(source.GetVarNames()) SetVarNames(source.fnVars,source.GetVarNames(),source.GetIsUpperCut());
+ */
+ 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();
+ /*
+ if (source.fCutsRD){
+ fCutsRD = new Float_t*[fnVars];
+
+ for(Int_t iv=0; iv<fnVars; iv++) {
+
+ fCutsRD[iv] = new Float_t[fnPtBins];
+
+ for(Int_t ib=0; ib<fnPtBins; ib++) {
+
+ fCutsRD[iv][ib] = source.fCutsRD[iv][ib];
+ }
+ }
+ }
+ */
+ /*
+ Float_t** cutsRD=0;
+
+ cutsRD=new Float_t*[source.fnVars];
+ for (Int_t iv=0;iv<source.fnVars;iv++){
+ cutsRD[iv]=new Float_t[source.fnPtBins];
+ }
+
+ source.GetCuts(source.fnVars,source.fnPtBins,cutsRD);
+
+ //if(source.GetCuts())SetCuts(source.fnVars,source.fnPtBins,source.GetCuts());
+
+ for(Int_t iv=0; iv<source.fnVars; iv++) {
+
+ for(Int_t ib=0; ib<source.fnPtBins; ib++) {
+ cout<<"fCutsRD["<<iv<<"]["<<ib<<"] = "<<fCutsRD[iv][ib]<<endl;
+ //cutsRD[iv][ib] = fCutsRD[iv][ib];
+ //cout<<"cutsRD["<<iv<<"]["<<ib<<"] = "<<cutsRD[iv][ib]<<endl;
+ }
+ }
+
+ if(cutsRD) SetCuts(source.fnVars,source.fnPtBins,cutsRD);
+ */
+ //if(source.GetVarsForOpt()) SetVarsForOpt(source.fnVars,source.GetVarsForOpt());
+
+}
+//--------------------------------------------------------------------------
+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;
+ fMinSPDMultiplicity=source.fMinSPDMultiplicity;
+ fTriggerMask=source.fTriggerMask;
+ fnPtBins=source.fnPtBins;
+ fnVars=source.fnVars;
+ fGlobalIndex=source.fGlobalIndex;
+ fnVarsForOpt=source.fnVarsForOpt;
+
+ 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();
+
+ /*
+ if(source.GetTrackCuts()) AddTrackCuts(source.GetTrackCuts());
+
+ if(source.GetPtBinLimits()) SetPtBins(source.fnPtBinLimits,source.GetPtBinLimits());
+ if(source.GetVarNames()) SetVarNames(source.fnVars,source.GetVarNames(),source.GetIsUpperCut());
+ */
+/*
+ Float_t** cutsRD;
+ cutsRD=new Float_t*[source.fnVars];
+ for (Int_t iv=0;iv<source.fnVars;iv++){
+ cutsRD[iv]=new Float_t[source.fnPtBins];
+ }
+ source.GetCuts(source.fnVars,source.fnPtBins,cutsRD);
+
+ if(cutsRD) SetCuts(source.fnVars,source.fnPtBins,cutsRD);
+*/
+ //if(source.GetCuts()) SetCuts(source.fnVars,source.fnPtBins,source.GetCuts());
+ //if(source.GetVarsForOpt()) SetVarsForOpt(source.fnVars,source.GetVarsForOpt());
+
+ 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;}
+
+}
+//---------------------------------------------------------------------------
+Bool_t AliRDHFCuts::IsEventSelected(AliVEvent *event) const {
+ //
+ // Event selection
+ //
+ if(fTriggerMask && event->GetTriggerMask()!=fTriggerMask) return kFALSE;
+
+ // 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;
+
+ return kTRUE;
+}
+//---------------------------------------------------------------------------
+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::SetCuts(Int_t nVars,Int_t nPtBins,Float_t **cutsRD) {
+ // set 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];
+
+ Int_t iGlobal=0;
+ for(Int_t iv=0; iv<fnVars; iv++) {
+
+ for(Int_t ib=0; ib<fnPtBins; ib++) {
+
+ fCutsRD[iGlobal] = cutsRD[iv][ib];
+ //cout<<"fCutsRD["<<iGlobal<<"] = "<<fCutsRD[iGlobal]<<endl;
+ iGlobal++;
+ //check
+ if(iGlobal>fGlobalIndex) {
+ cout<<"Overflow, exit..."<<endl;
+ return;
+ }
+ }
+ }
+ //check
+ if(iGlobal != fGlobalIndex) {
+ cout<<"Total number of entries of cut matrix "<<iGlobal<<" not expected! Check please..."<<endl;
+ return;
+ }
+
+ cout<<"done"<<endl;
+ return;
+}
+//---------------------------------------------------------------------------
+void AliRDHFCuts::SetCuts(Int_t glIndex,Float_t* cutsRDGlob){
+ 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];
+ }
+ cout<<"done"<<endl;
+ return;
+
+}
+
+
+//---------------------------------------------------------------------------
+void AliRDHFCuts::PrintAll() const{
+ 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;
+ }
+}
+
+
+//---------------------------------------------------------------------------
+void AliRDHFCuts::GetCuts(Float_t**& cutsRD) const{
+ // get the cuts
+
+// if(nVars!=fnVars){
+// cout<<"Number of variables doesn't match or not defined yet"<<endl;
+// return;
+// }
+
+// if(nPtBins!=fnPtBins){
+// cout<<"Number of pt bins doesn't match or not defined yet"<<endl;
+// return;
+// }
+ cout<<"Give back a "<<fnVars<<"x"<<fnPtBins<<" matrix."<<endl;
+ //cutsRD=fCutsRD;
+
+ if(!cutsRD) {
+ cout<<"Initialization..."<<endl;
+ cutsRD=new Float_t*[fnVars];
+ for(Int_t iv=0; iv<fnVars; iv++) {
+ cutsRD[iv] = new Float_t[fnPtBins];
+ }
+ }
+
+ cout<<"Ptr cuts rd "<<cutsRD<<endl;
+ Int_t iGlobal=0;
+ for(Int_t iv=0; iv<fnVars; iv++) {
+ for(Int_t ib=0; ib<fnPtBins; ib++) {
+ //cout<<"fCutsRD["<<iv<<"]["<<ib<<"] = "<<fCutsRD[iv][ib]<<endl;
+ cutsRD[iv][ib] = fCutsRD[iGlobal];
+ //cout<<"cutsRD["<<iv<<"]["<<ib<<"] = "<<cutsRD[iv][ib]<<endl;
+ iGlobal++;
+ }
+ }
+
+}
+
+//---------------------------------------------------------------------------
+Int_t AliRDHFCuts::GetGlobalIndex(Int_t iVar,Int_t iPtBin) const{
+ 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;
+
+}
+
+//---------------------------------------------------------------------------
+Int_t AliRDHFCuts::PtBin(Double_t pt) const {
+
+ //give the pt bin where the pt lies.
+
+ Int_t ptbin=0;
+ for (Int_t i=0;i<fnPtBins;i++){
+ if(pt<fPtBinLimits[i+1]) {
+ ptbin=i;
+ break;
+ }
+ }
+ return ptbin;
+}
--- /dev/null
+#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 "AliVEvent.h"
+
+class AliAODRecoDecayHF;
+
+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);
+
+ 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 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;}
+
+ 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;}
+ const Float_t *GetCuts() const {return fCutsRD;}
+ void GetCuts(Float_t**& cutsRD) const;
+ 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;
+ Float_t GetMassCut(Int_t iPtBin=0) const { return (fCutsRD ? fCutsRD[GetGlobalIndex(0,iPtBin)] : 1.e6);}
+
+ 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) const;
+ virtual Int_t IsSelected(TObject* obj,Int_t selectionLevel) = 0;
+
+ Int_t PtBin(Double_t pt) const;
+ void PrintAll()const;
+
+ enum{kAll,kTracks,kCandidate};
+
+ 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
+ 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
+
+ ClassDef(AliRDHFCuts,1); // base class for cuts on AOD reconstructed
+ // heavy-flavour decays
+};
+
+#endif
--- /dev/null
+/**************************************************************************
+ * 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. *
+ **************************************************************************/
+
+/////////////////////////////////////////////////////////////
+//
+// Class for cuts on AOD reconstructed D0->Kpi
+//
+// Author: A.Dainese, andrea.dainese@pd.infn.it
+/////////////////////////////////////////////////////////////
+
+#include <TDatabasePDG.h>
+#include <Riostream.h>
+
+#include "AliRDHFCutsD0toKpi.h"
+#include "AliAODRecoDecayHF2Prong.h"
+#include "AliAODTrack.h"
+#include "AliESDtrack.h"
+
+ClassImp(AliRDHFCutsD0toKpi)
+
+//--------------------------------------------------------------------------
+AliRDHFCutsD0toKpi::AliRDHFCutsD0toKpi() :
+AliRDHFCuts()
+{
+ //
+ // Default Constructor
+ //
+ Int_t nvars=9;
+ SetNVars(nvars);
+ TString varNames[9]={"inv. mass [GeV]",
+ "dca [cm]",
+ "cosThetaStar",
+ "pTK [GeV/c]",
+ "pTPi [GeV/c]",
+ "d0K [cm]",
+ "d0Pi [cm]",
+ "d0d0 [cm^2]",
+ "cosThetaPoint"};
+ Bool_t isUpperCut[9]={kTRUE,
+ kTRUE,
+ kTRUE,
+ kFALSE,
+ kFALSE,
+ kTRUE,
+ kTRUE,
+ kTRUE,
+ kFALSE};
+ SetVarNames(nvars,varNames,isUpperCut);
+ Bool_t forOpt[9]={kFALSE,
+ kTRUE,
+ kTRUE,
+ kFALSE,
+ kFALSE,
+ kFALSE,
+ kFALSE,
+ kTRUE,
+ kTRUE};
+ SetVarsForOpt(4,forOpt);
+ Float_t limits[2]={0,999999999.};
+ SetPtBins(2,limits);
+}
+//--------------------------------------------------------------------------
+AliRDHFCutsD0toKpi::AliRDHFCutsD0toKpi(const AliRDHFCutsD0toKpi &source) :
+ AliRDHFCuts(source)
+{
+ //
+ // Copy constructor
+ //
+
+}
+//--------------------------------------------------------------------------
+AliRDHFCutsD0toKpi &AliRDHFCutsD0toKpi::operator=(const AliRDHFCutsD0toKpi &source)
+{
+ //
+ // assignment operator
+ //
+ if(&source == this) return *this;
+
+ AliRDHFCuts::operator=(source);
+
+ return *this;
+}
+
+
+//---------------------------------------------------------------------------
+void AliRDHFCutsD0toKpi::GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters) {
+ //
+ // Fills in vars the values of the variables
+ //
+
+ cout<<"Ingetvarforopt"<<endl;
+ //PrintAll();
+
+ if(nvars!=fnVarsForOpt) {
+ printf("AliRDHFCutsD0toKpi::GetCutsVarsForOpt: wrong number of variables\n");
+ return;
+ }
+
+ AliAODRecoDecayHF2Prong *dd = (AliAODRecoDecayHF2Prong*)d;
+ /*
+ vars[0] = dd->GetDCA();
+ if(TMath::Abs(pdgdaughters[0])==211) {
+ vars[1] = dd->CosThetaStarD0();
+ } else {
+ vars[1] = dd->CosThetaStarD0bar();
+ }
+ vars[2] = dd->Prodd0d0();
+ vars[3] = dd->CosPointingAngle();
+
+ return;
+*/
+
+ //possibile generalizzazione
+ Int_t iter=-1;
+ if(fVarsForOpt[0]){
+ iter++;
+ if(TMath::Abs(pdgdaughters[0])==211) {
+ vars[iter]=dd->InvMassD0();
+ } else {
+ vars[iter]=dd->InvMassD0bar();
+ }
+ }
+ if(fVarsForOpt[1]){
+ iter++;
+ vars[iter]=dd->GetDCA();
+ }
+ if(fVarsForOpt[2]){
+ iter++;
+ if(TMath::Abs(pdgdaughters[0])==211) {
+ vars[iter] = dd->CosThetaStarD0();
+ } else {
+ vars[iter] = dd->CosThetaStarD0bar();
+ }
+ }
+ if(fVarsForOpt[3]){
+ iter++;
+ if(TMath::Abs(pdgdaughters[0])==321) {
+ vars[iter]=dd->PtProng(0);
+ }
+ else{
+ vars[iter]=dd->PtProng(1);
+ }
+ }
+ if(fVarsForOpt[4]){
+ iter++;
+ if(TMath::Abs(pdgdaughters[0])==211) {
+ vars[iter]=dd->PtProng(0);
+ }
+ else{
+ vars[iter]=dd->PtProng(1);
+ }
+ }
+ if(fVarsForOpt[5]){
+ iter++;
+ if(TMath::Abs(pdgdaughters[0])==321) {
+ vars[iter]=dd->Getd0Prong(0);
+ }
+ else{
+ vars[iter]=dd->Getd0Prong(1);
+ }
+ }
+ if(fVarsForOpt[6]){
+ iter++;
+ if(TMath::Abs(pdgdaughters[0])==211) {
+ vars[iter]=dd->Getd0Prong(0);
+ }
+ else{
+ vars[iter]=dd->Getd0Prong(1);
+ }
+ }
+ if(fVarsForOpt[7]){
+ iter++;
+ vars[iter]= dd->Prodd0d0();
+ }
+ if(fVarsForOpt[8]){
+ iter++;
+ vars[iter]=dd->CosPointingAngle();
+ }
+
+ return;
+}
+//---------------------------------------------------------------------------
+Int_t AliRDHFCutsD0toKpi::IsSelected(TObject* obj,Int_t selectionLevel) {
+ //
+ // Apply selection
+ //
+
+ if(!fCutsRD){
+ cout<<"Cut matrice not inizialized. Exit..."<<endl;
+ return -1;
+ }
+ //PrintAll();
+ AliAODRecoDecayHF2Prong* d=(AliAODRecoDecayHF2Prong*)obj; // ????
+
+ Int_t returnvalue=1;
+ if(!d){
+ cout<<"AliAODRecoDecayHF2Prong null"<<endl;
+ return 0;
+ }
+
+ // selection on daughter tracks
+ if(selectionLevel==AliRDHFCuts::kAll ||
+ selectionLevel==AliRDHFCuts::kTracks) {
+ Int_t ndaughters = d->GetNDaughters();
+ //cout<<"loop on "<<ndaughters<<"daughters"<<endl;
+ for(Int_t idg=0; idg<ndaughters; idg++) {
+ AliAODTrack *dgTrack = (AliAODTrack*)d->GetDaughter(idg);
+ if(!dgTrack) returnvalue=0;
+ //printf("charge %d\n",dgTrack->Charge());
+ if(dgTrack->Charge()==0) continue; // it's not a track, but a V0
+ // convert to ESD track here
+ AliESDtrack* esdTrack=new AliESDtrack(dgTrack);
+
+ if(!fTrackCuts->IsSelected(esdTrack)) returnvalue=0;//kFALSE;
+ }
+ if(!returnvalue) return 0;
+ }
+
+
+
+ //cout<<"cand sel? "<<selectionLevel<<" = "<<AliRDHFCuts::kAll<<" or "<<AliRDHFCuts::kCandidate<<endl;
+
+ // selection on candidate
+ if(selectionLevel==AliRDHFCuts::kAll ||
+ selectionLevel==AliRDHFCuts::kCandidate) {
+
+ Double_t pt=d->Pt();
+
+ Int_t okD0=0,okD0bar=0;
+
+ Int_t ptbin=PtBin(pt);
+
+ Double_t mD0,mD0bar,ctsD0,ctsD0bar;
+ okD0=1; okD0bar=1;
+
+ Double_t mD0PDG = TDatabasePDG::Instance()->GetParticle(421)->Mass();
+
+ if(d->PtProng(1) < fCutsRD[GetGlobalIndex(3,ptbin)] || d->PtProng(0) < fCutsRD[GetGlobalIndex(4,ptbin)]) okD0 = 0;
+ if(d->PtProng(0) < fCutsRD[GetGlobalIndex(3,ptbin)] || d->PtProng(1) < fCutsRD[GetGlobalIndex(4,ptbin)]) okD0bar = 0;
+
+ if(!okD0 && !okD0bar) returnvalue=0;
+
+ if(TMath::Abs(d->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(5,ptbin)] ||
+ TMath::Abs(d->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(6,ptbin)]) okD0 = 0;
+ if(TMath::Abs(d->Getd0Prong(0)) > fCutsRD[GetGlobalIndex(6,ptbin)] ||
+ TMath::Abs(d->Getd0Prong(1)) > fCutsRD[GetGlobalIndex(5,ptbin)]) okD0bar = 0;
+ if(!okD0 && !okD0bar) returnvalue=0;
+
+ if(d->GetDCA() > fCutsRD[GetGlobalIndex(1,ptbin)]) { okD0 = okD0bar = 0; returnvalue=0;
+ }
+
+ d->InvMassD0(mD0,mD0bar);
+ if(TMath::Abs(mD0-mD0PDG) > fCutsRD[GetGlobalIndex(0,ptbin)]) okD0 = 0;
+ if(TMath::Abs(mD0bar-mD0PDG) > fCutsRD[GetGlobalIndex(0,ptbin)]) okD0bar = 0;
+ if(!okD0 && !okD0bar) returnvalue=0;
+
+ d->CosThetaStarD0(ctsD0,ctsD0bar);
+ if(TMath::Abs(ctsD0) > fCutsRD[GetGlobalIndex(2,ptbin)]) okD0 = 0;
+ if(TMath::Abs(ctsD0bar) > fCutsRD[GetGlobalIndex(2,ptbin)]) okD0bar = 0;
+ if(!okD0 && !okD0bar) returnvalue=0;
+
+ if(d->Prodd0d0() > fCutsRD[GetGlobalIndex(7,ptbin)]) { okD0 = okD0bar = 0; returnvalue=0; }
+
+ if(d->CosPointingAngle() < fCutsRD[GetGlobalIndex(8,ptbin)]) { okD0 = okD0bar = 0; returnvalue=0; }
+
+
+
+ if (okD0) returnvalue=1; //cuts passed as D0
+ if (okD0bar) returnvalue=2; //cuts passed as D0bar
+ if (okD0 && okD0bar) returnvalue=3; //cuts passed as D0 and D0bar
+ }
+
+
+ return returnvalue;
+
+}
+//---------------------------------------------------------------------------
--- /dev/null
+#ifndef ALIRDHFCUTSD0TOKPI_H
+#define ALIRDHFCUTSD0TOKPI_H
+/* Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+//***********************************************************
+// Class AliRDHFCutsD0toKpi
+// class for cuts on AOD reconstructed D0->Kpi
+// Author: A.Dainese, andrea.dainese@pd.infn.it
+//***********************************************************
+
+#include "AliRDHFCuts.h"
+
+class AliRDHFCutsD0toKpi : public AliRDHFCuts
+{
+ public:
+
+ AliRDHFCutsD0toKpi();
+
+ virtual ~AliRDHFCutsD0toKpi(){}
+
+ AliRDHFCutsD0toKpi(const AliRDHFCutsD0toKpi& source);
+ AliRDHFCutsD0toKpi& operator=(const AliRDHFCutsD0toKpi& source);
+
+ virtual void GetCutVarsForOpt(AliAODRecoDecayHF *d,Float_t *vars,Int_t nvars,Int_t *pdgdaughters);
+
+ using AliRDHFCuts::IsSelected;
+ virtual Int_t IsSelected(TObject* obj,Int_t selectionLevel);
+
+ protected:
+
+
+ ClassDef(AliRDHFCutsD0toKpi,1); // class for cuts on AOD reconstructed
+ // D0->Kpi
+};
+
+#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff