[u/mrichter/AliRoot.git] / PWGHF / correlationHF / AliHFAssociatedTrackCuts.h

#ifndef AliHFAssociatedTrackCuts_H
#define AliHFAssociatedTrackCuts_H
/**************************************************************************
 * 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.                  *
 **************************************************************************/

/* $Id$ */

////////////////////////////////////////////////////////////////////////
//
// Base class for cuts on Associated tracks for HF Correlation analysis
//
// Author: S.Bjelogrlic (Utrecht) sandro.bjelogrlic@cern.ch
////////////////////////////////////////////////////////////////////////

#include <TString.h>
#include "AliAnalysisCuts.h"
#include "AliESDtrackCuts.h"
#include "AliAODPidHF.h"
#include "AliAODEvent.h"
#include "AliAODRecoDecayHF2Prong.h"
#include <TClonesArray.h>

class AliAODTrack;
class AliAODEvent;


//
class AliHFAssociatedTrackCuts : public AliAnalysisCuts
{
	public:	
	AliHFAssociatedTrackCuts();
	AliHFAssociatedTrackCuts(const char* name, const char* title);
	
	
	AliHFAssociatedTrackCuts(const AliHFAssociatedTrackCuts& source);
	AliHFAssociatedTrackCuts& operator=(const AliHFAssociatedTrackCuts& source);
	
	virtual ~AliHFAssociatedTrackCuts(); // destructor
	Bool_t IsSelected(TList*  list) {if(list) return kTRUE; return kFALSE;};
	Bool_t IsSelected(TObject*  obj) {if(obj) return kTRUE; return kFALSE;};
	Bool_t IsInAcceptance();
	Bool_t IsHadronSelected(AliAODTrack * track);
	Bool_t CheckHadronKinematic(Double_t pt, Double_t d0); 
	Bool_t Charge(Short_t charge, AliAODTrack* track);
	Bool_t CheckKaonCompatibility(AliAODTrack * track, Bool_t useMc, TClonesArray* mcArray, Int_t method=1);
	Bool_t IsKZeroSelected(AliAODv0 *vzero, AliAODVertex *vtx1);
	Int_t IsMCpartFromHF(Int_t label, TClonesArray*mcArray);
	Bool_t InvMassDstarRejection(AliAODRecoDecayHF2Prong* d, AliAODTrack *track, Int_t hypD0) const;	
	
	//getters
	Int_t GetMaxNEventsInPool() {return fPoolMaxNEvents;}
	Int_t GetMinNTracksInPool() {return fPoolMinNTracks;}
	Int_t GetMinEventsToMix(){return fMinEventsToMix;}
	Int_t GetNZvtxPoolBins() {return fNzVtxBins;}
	Double_t *GetZvtxPoolBins(){return fZvtxBins;}
	Int_t GetNCentPoolBins() {return fNCentBins;}
	Double_t *GetCentPoolBins(){return fCentBins;}
	
	
	void AddTrackCuts(const AliESDtrackCuts *cuts) {
		delete fESDTrackCuts; 
		fESDTrackCuts=new AliESDtrackCuts(*cuts); 
		return;
	}
	//setters
	//event pool settings
	void SetMaxNEventsInPool(Int_t events){fPoolMaxNEvents=events;}
	void SetMinNTracksInPool(Int_t tracks){fPoolMinNTracks=tracks;}
	void SetMinEventsToMix(Int_t events){fMinEventsToMix=events;}
	
	void SetNofPoolBins(Int_t Nzvtxbins, Int_t Ncentbins){
		fNzVtxBins=Nzvtxbins;
		fNzVtxBinsDim=Nzvtxbins+1;
		
	    fNCentBins=Ncentbins;
		fNCentBinsDim=Ncentbins+1;
	}
	
	void SetPoolBins(Double_t *ZvtxBins, Double_t* CentBins){
		fZvtxBins=ZvtxBins; 
		fCentBins=CentBins;
	}
	//cut settings
	void SetAODTrackCuts(Float_t *cutsarray);
	void SetTrackCutsNames(/*TString *namearray*/);
	void SetAODvZeroCuts(Float_t *cutsarray);
	void SetvZeroCutsNames(/*TString *namearray*/);
	void SetPidHF(AliAODPidHF* pid) {fPidObj = pid; return;}
	void SetCharge(Short_t charge) {fCharge = charge;}
	void SetFilterBit(Int_t bit) {fBit = bit;}
	virtual void PrintAll();
	virtual void PrintPoolParameters();
	Int_t GetNVarsTrack(){return fNTrackCuts;}
	
	
	void SetNVarsTrack(Int_t nVars){fNTrackCuts=nVars;}
	void SetNVarsVzero(Int_t nVars){fNvZeroCuts=nVars;}
	
private:
	//AliESDtrackCuts *fTrackCuts;
	AliESDtrackCuts *fESDTrackCuts; // track cut object
	AliAODPidHF * fPidObj;     /// PID object
	
	Int_t fPoolMaxNEvents; // set maximum number of events in the pool
	Int_t fPoolMinNTracks; // se minimum number of tracks in the pool
	Int_t fMinEventsToMix; // set the minimum number of events you wanna mix
	
	Int_t fNzVtxBins; // number of z vrtx bins
	Int_t fNzVtxBinsDim; // number of z vrtx bins +1 : necessary to initialize correctly the array
	Double_t* fZvtxBins; // [fNzVtxBinsDim]
	
	
	Int_t fNCentBins; //number of centrality bins
	Int_t fNCentBinsDim; //number of centrality bins bins +1 : necessary to initialize correctly the array
	Double_t* fCentBins; // [fNCentBinsDim]
	
	Int_t fNTrackCuts;     // array dimension
	Float_t* fAODTrackCuts;//[fNTrackCuts]
	TString * fTrackCutsNames;//[fNTrackCuts]
	Int_t fNvZeroCuts;// array dimension
	Float_t *fAODvZeroCuts;//[fNvZeroCuts]
	TString * fvZeroCutsNames;//[fNvZeroCuts]
	Int_t fBit; // filterBit
	Short_t fCharge; // charge (+1 or -1)
	
	
	ClassDef(AliHFAssociatedTrackCuts,3);
};


#endif
Commit	Line	Data
14c8fedd	1	#ifndef AliHFAssociatedTrackCuts_H
	2	#define AliHFAssociatedTrackCuts_H
	3	/**************************************************************************
	4	* Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
	5	* *
	6	* Author: The ALICE Off-line Project. *
	7	* Contributors are mentioned in the code where appropriate. *
	8	* *
	9	* Permission to use, copy, modify and distribute this software and its *
	10	* documentation strictly for non-commercial purposes is hereby granted *
	11	* without fee, provided that the above copyright notice appears in all *
	12	* copies and that both the copyright notice and this permission notice *
	13	* appear in the supporting documentation. The authors make no claims *
	14	* about the suitability of this software for any purpose. It is *
	15	* provided "as is" without express or implied warranty. *
	16	**************************************************************************/
	17
	18	/* $Id$ */
	19
	20	////////////////////////////////////////////////////////////////////////
	21	//
	22	// Base class for cuts on Associated tracks for HF Correlation analysis
	23	//
	24	// Author: S.Bjelogrlic (Utrecht) sandro.bjelogrlic@cern.ch
	25	////////////////////////////////////////////////////////////////////////
	26
	27	#include <TString.h>
	28	#include "AliAnalysisCuts.h"
	29	#include "AliESDtrackCuts.h"
	30	#include "AliAODPidHF.h"
	31	#include "AliAODEvent.h"
	32	#include "AliAODRecoDecayHF2Prong.h"
	33	#include <TClonesArray.h>
	34
	35	class AliAODTrack;
	36	class AliAODEvent;
	37
	38
	39	//
	40	class AliHFAssociatedTrackCuts : public AliAnalysisCuts
	41	{
	42	public:
	43	AliHFAssociatedTrackCuts();
	44	AliHFAssociatedTrackCuts(const char* name, const char* title);
	45
	46
	47	AliHFAssociatedTrackCuts(const AliHFAssociatedTrackCuts& source);
	48	AliHFAssociatedTrackCuts& operator=(const AliHFAssociatedTrackCuts& source);
	49
	50	virtual ~AliHFAssociatedTrackCuts(); // destructor
	51	Bool_t IsSelected(TList* list) {if(list) return kTRUE; return kFALSE;};
	52	Bool_t IsSelected(TObject* obj) {if(obj) return kTRUE; return kFALSE;};
	53	Bool_t IsInAcceptance();
bce70c96	54	Bool_t IsHadronSelected(AliAODTrack * track);
bce70c96	55	Bool_t CheckHadronKinematic(Double_t pt, Double_t d0);
c84dbedf	56	Bool_t Charge(Short_t charge, AliAODTrack* track);
14c8fedd	57	Bool_t CheckKaonCompatibility(AliAODTrack * track, Bool_t useMc, TClonesArray* mcArray, Int_t method=1);
	58	Bool_t IsKZeroSelected(AliAODv0 vzero, AliAODVertex vtx1);
	59	Int_t IsMCpartFromHF(Int_t label, TClonesArray*mcArray);
	60	Bool_t InvMassDstarRejection(AliAODRecoDecayHF2Prong* d, AliAODTrack *track, Int_t hypD0) const;
	61
bce70c96	62	//getters
	63	Int_t GetMaxNEventsInPool() {return fPoolMaxNEvents;}
	64	Int_t GetMinNTracksInPool() {return fPoolMinNTracks;}
	65	Int_t GetMinEventsToMix(){return fMinEventsToMix;}
	66	Int_t GetNZvtxPoolBins() {return fNzVtxBins;}
	67	Double_t *GetZvtxPoolBins(){return fZvtxBins;}
	68	Int_t GetNCentPoolBins() {return fNCentBins;}
	69	Double_t *GetCentPoolBins(){return fCentBins;}
	70
	71
14c8fedd	72
	73	void AddTrackCuts(const AliESDtrackCuts *cuts) {
	74	delete fESDTrackCuts;
	75	fESDTrackCuts=new AliESDtrackCuts(*cuts);
	76	return;
	77	}
bce70c96	78	//setters
	79	//event pool settings
	80	void SetMaxNEventsInPool(Int_t events){fPoolMaxNEvents=events;}
	81	void SetMinNTracksInPool(Int_t tracks){fPoolMinNTracks=tracks;}
	82	void SetMinEventsToMix(Int_t events){fMinEventsToMix=events;}
14c8fedd	83
bce70c96	84	void SetNofPoolBins(Int_t Nzvtxbins, Int_t Ncentbins){
	85	fNzVtxBins=Nzvtxbins;
	86	fNzVtxBinsDim=Nzvtxbins+1;
	87
	88	fNCentBins=Ncentbins;
	89	fNCentBinsDim=Ncentbins+1;
	90	}
	91
	92	void SetPoolBins(Double_t ZvtxBins, Double_t CentBins){
	93	fZvtxBins=ZvtxBins;
	94	fCentBins=CentBins;
	95	}
	96	//cut settings
14c8fedd	97	void SetAODTrackCuts(Float_t *cutsarray);
	98	void SetTrackCutsNames(/TString namearray*/);
	99	void SetAODvZeroCuts(Float_t *cutsarray);
	100	void SetvZeroCutsNames(/TString namearray*/);
	101	void SetPidHF(AliAODPidHF* pid) {fPidObj = pid; return;}
c84dbedf	102	void SetCharge(Short_t charge) {fCharge = charge;}
c84dbedf	103	void SetFilterBit(Int_t bit) {fBit = bit;}
14c8fedd	104	virtual void PrintAll();
bce70c96	105	virtual void PrintPoolParameters();
14c8fedd	106	Int_t GetNVarsTrack(){return fNTrackCuts;}
	107
	108
	109
	110	void SetNVarsTrack(Int_t nVars){fNTrackCuts=nVars;}
	111	void SetNVarsVzero(Int_t nVars){fNvZeroCuts=nVars;}
	112
	113	private:
	114	//AliESDtrackCuts *fTrackCuts;
	115	AliESDtrackCuts *fESDTrackCuts; // track cut object
	116	AliAODPidHF * fPidObj; /// PID object
bce70c96	117
	118	Int_t fPoolMaxNEvents; // set maximum number of events in the pool
	119	Int_t fPoolMinNTracks; // se minimum number of tracks in the pool
	120	Int_t fMinEventsToMix; // set the minimum number of events you wanna mix
	121
	122	Int_t fNzVtxBins; // number of z vrtx bins
	123	Int_t fNzVtxBinsDim; // number of z vrtx bins +1 : necessary to initialize correctly the array
	124	Double_t* fZvtxBins; // [fNzVtxBinsDim]
	125
	126
	127	Int_t fNCentBins; //number of centrality bins
	128	Int_t fNCentBinsDim; //number of centrality bins bins +1 : necessary to initialize correctly the array
	129	Double_t* fCentBins; // [fNCentBinsDim]
	130
14c8fedd	131	Int_t fNTrackCuts; // array dimension
	132	Float_t* fAODTrackCuts;//[fNTrackCuts]
	133	TString * fTrackCutsNames;//[fNTrackCuts]
	134	Int_t fNvZeroCuts;// array dimension
	135	Float_t *fAODvZeroCuts;//[fNvZeroCuts]
	136	TString * fvZeroCutsNames;//[fNvZeroCuts]
c84dbedf	137	Int_t fBit; // filterBit
c84dbedf	138	Short_t fCharge; // charge (+1 or -1)
14c8fedd	139
14c8fedd	140
c84dbedf	141	ClassDef(AliHFAssociatedTrackCuts,3);
14c8fedd	142	};
	143
	144
	145	#endif