[u/mrichter/AliRoot.git] / FASTSIM / AliFastMuonTriggerEff.h

#ifndef ALIFASTMUONTRIGGEREFF_H
#define ALIFASTMUONTRIGGEREFF_H
/*  Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */
// Class for the fast simulation of the muon trigger efficiency
// The trigger parametrization is computed for background levels 0., 0.5 and 1.
// In order to set a background level different from 0 it is necessary to 
// explicitly force it with:
// ForceBkgLevel(BkgLevel).
// For intermediate background levels, the trigger response is linearly 
// interpolated between these values.
// There is increased granularity in the pT region below 3 GeV. Although
// it does not seem to be necessary it is also possible to interpolate
// between pT bins using SetInt().
// Author: Pietro Cortese (Universita' del Piemonte Orientale - Alessandria 
// and INFN of Torino)

#include <AliFastResponse.h>
#include <TString.h>

class TH3F;
class TAxis;

// Debugging flag
//#define MYTRIGDEBUG

enum CutTupe {kLow, kHigh, kAny};

class AliFastMuonTriggerEff : public AliFastResponse {
    
 public:
    AliFastMuonTriggerEff();
    AliFastMuonTriggerEff(const char* /*Name*/, const char* /*Title*/);
    AliFastMuonTriggerEff(const AliFastMuonTriggerEff& eff);
    virtual ~AliFastMuonTriggerEff(){;}
    virtual void    Init();
    virtual void    Evaluate(Float_t charge, Float_t pt, Float_t theta, Float_t phi,
			     Float_t& effLow, Float_t& effHigh, Float_t& effAny);
    virtual void    Evaluate(Float_t pt, Float_t theta, Float_t phi,
			     Float_t& effLow, Float_t& effHigh, Float_t& effAny)
	{Evaluate(1., pt, theta, phi, effLow, effHigh, effAny);}
    virtual Float_t Evaluate(Float_t charge, Float_t pt, Float_t theta, Float_t phi);
    
    virtual void    SetCut(Int_t cut = kLow);
    virtual Float_t Cut() const {return fCut;}
    virtual Int_t   SetBkgLevel(Float_t Bkg=0.);
    virtual Int_t   ForceBkgLevel(Float_t Bkg=0.);
    virtual Float_t GetBkgLevel() const {return fBkg;}
    Int_t LoadTables(Char_t *namet);  // Load trigger response tables
    void SetInt() {fInt=1;}
    void UnsetInt() {fInt=0;}
    Int_t GetInt() const {return fInt;}
    // Copy
    AliFastMuonTriggerEff& operator=(const AliFastMuonTriggerEff& rhs);
  protected:
    Double_t fPtMin;               // Minimun pt
    Double_t fPtMax;               // Maximum pt
    Double_t fDpt;                 // Delta_pt
    Int_t    fnptb;                // Number of bins
    Double_t fPhiMin;              // Lower limit for phi 
    Double_t fPhiMax;              // Upper limit for phi
    Double_t fDphi;                // Delta_phi
    Int_t    fnphib;               // Number of bins   
    Double_t fThetaMin;            // lower limit for theta
    Double_t fThetaMax;            // upper limit for theta
    Double_t fDtheta;              // Delta_theta
    Int_t    fnthetab;             // Number of bins 
    Int_t   fCut;                  // Cut type (low/high)
    Int_t   fZones;                // Total number of zones
    TH3F*   fhEffAPt;              // Trig. prob. for Any Pt
    TH3F*   fhEffLPt;              // Trig. prob. for Low Pt
    TH3F*   fhEffHPt;              // Trig. prob. for High Pt
    TAxis*  fhLX;                  // x-axis 
    TAxis*  fhLY;                  // y-axis
    TAxis*  fhLZ;                  // z-axis
    Float_t fBkg;                  // Background level
    TString fTableTitle;           // Title of the LUT
    TString fDescription;          // Description of the table content
    Int_t fInt;                    // Interpolation flag (1 to interpolate)
  private:
    Int_t fibx;                    // index x 
    Int_t fiby;                    // index y
    Int_t fibz;                    // index z
    ClassDef(AliFastMuonTriggerEff,1)    // Fast Muon Trigger response
};

#endif
Commit	Line	Data
	1	#ifndef ALIFASTMUONTRIGGEREFF_H
	2	#define ALIFASTMUONTRIGGEREFF_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7	// Class for the fast simulation of the muon trigger efficiency
	8	// The trigger parametrization is computed for background levels 0., 0.5 and 1.
	9	// In order to set a background level different from 0 it is necessary to
	10	// explicitly force it with:
	11	// ForceBkgLevel(BkgLevel).
	12	// For intermediate background levels, the trigger response is linearly
	13	// interpolated between these values.
	14	// There is increased granularity in the pT region below 3 GeV. Although
	15	// it does not seem to be necessary it is also possible to interpolate
	16	// between pT bins using SetInt().
	17	// Author: Pietro Cortese (Universita' del Piemonte Orientale - Alessandria
	18	// and INFN of Torino)
	19
	20	#include <AliFastResponse.h>
	21	#include <TString.h>
	22
	23	class TH3F;
	24	class TAxis;
	25
	26	// Debugging flag
	27	//#define MYTRIGDEBUG
	28
	29	enum CutTupe {kLow, kHigh, kAny};
	30
	31	class AliFastMuonTriggerEff : public AliFastResponse {
	32
	33	public:
	34	AliFastMuonTriggerEff();
	35	AliFastMuonTriggerEff(const char* /Name/, const char* /Title/);
	36	AliFastMuonTriggerEff(const AliFastMuonTriggerEff& eff);
	37	virtual ~AliFastMuonTriggerEff(){;}
	38	virtual void Init();
	39	virtual void Evaluate(Float_t charge, Float_t pt, Float_t theta, Float_t phi,
	40	Float_t& effLow, Float_t& effHigh, Float_t& effAny);
	41	virtual void Evaluate(Float_t pt, Float_t theta, Float_t phi,
	42	Float_t& effLow, Float_t& effHigh, Float_t& effAny)
	43	{Evaluate(1., pt, theta, phi, effLow, effHigh, effAny);}
	44	virtual Float_t Evaluate(Float_t charge, Float_t pt, Float_t theta, Float_t phi);
	45
	46	virtual void SetCut(Int_t cut = kLow);
	47	virtual Float_t Cut() const {return fCut;}
	48	virtual Int_t SetBkgLevel(Float_t Bkg=0.);
	49	virtual Int_t ForceBkgLevel(Float_t Bkg=0.);
	50	virtual Float_t GetBkgLevel() const {return fBkg;}
	51	Int_t LoadTables(Char_t *namet); // Load trigger response tables
	52	void SetInt() {fInt=1;}
	53	void UnsetInt() {fInt=0;}
	54	Int_t GetInt() const {return fInt;}
	55	// Copy
	56	AliFastMuonTriggerEff& operator=(const AliFastMuonTriggerEff& rhs);
	57	protected:
	58	Double_t fPtMin; // Minimun pt
	59	Double_t fPtMax; // Maximum pt
	60	Double_t fDpt; // Delta_pt
	61	Int_t fnptb; // Number of bins
	62	Double_t fPhiMin; // Lower limit for phi
	63	Double_t fPhiMax; // Upper limit for phi
	64	Double_t fDphi; // Delta_phi
	65	Int_t fnphib; // Number of bins
	66	Double_t fThetaMin; // lower limit for theta
	67	Double_t fThetaMax; // upper limit for theta
	68	Double_t fDtheta; // Delta_theta
	69	Int_t fnthetab; // Number of bins
	70	Int_t fCut; // Cut type (low/high)
	71	Int_t fZones; // Total number of zones
	72	TH3F* fhEffAPt; // Trig. prob. for Any Pt
	73	TH3F* fhEffLPt; // Trig. prob. for Low Pt
	74	TH3F* fhEffHPt; // Trig. prob. for High Pt
	75	TAxis* fhLX; // x-axis
	76	TAxis* fhLY; // y-axis
	77	TAxis* fhLZ; // z-axis
	78	Float_t fBkg; // Background level
	79	TString fTableTitle; // Title of the LUT
	80	TString fDescription; // Description of the table content
	81	Int_t fInt; // Interpolation flag (1 to interpolate)
	82	private:
	83	Int_t fibx; // index x
	84	Int_t fiby; // index y
	85	Int_t fibz; // index z
	86	ClassDef(AliFastMuonTriggerEff,1) // Fast Muon Trigger response
	87	};
	88
	89	#endif
	90
	91
	92