Line data    Source code

       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           0 :     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           0 :         {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           0 :     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           0 :     virtual Float_t GetBkgLevel() const {return fBkg;}
      51             :     Int_t LoadTables(const Char_t *namet);  // Load trigger response tables
      52           0 :     void SetInt() {fInt=1;}
      53           0 :     void UnsetInt() {fInt=0;}
      54           0 :     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          12 :     ClassDef(AliFastMuonTriggerEff,1)    // Fast Muon Trigger response
      87             : };
      88             : 
      89             : #endif 
      90             : 
      91             : 
      92             :