TMBMuon.hpp

Go to the documentation of this file.

#ifndef TMBMuon_H
#define TMBMuon_H

//                                                                      //
// TMBTree Muon class                                                   //
//                                                                      //

// Constants for smearing
#define    I_par_A_TMBMuon  0
#define    I_par_B_TMBMuon  4
#define    I_par_Bpt_TMBMuon  8
#define    I_scale_TMBMuon  12
#define    I_smt_ncft_cut_TMBMuon 16 
#define    I_smt_eta_cut_TMBMuon  17
#define    I_smt_eta_cft_cut_TMBMuon  18
#define    I_nosmt_ncft_cut_TMBMuon 19 
#define    I_nosmt_eta_cut_TMBMuon  20
#define    I_nosmt_eta_cft_cut_TMBMuon  21
#define    npar_TMBMuon  22

#include "tmb_tree/TMBLorentzVector.hpp"
#include "tmb_tree/TMBMuonType.hpp"
#include "tmb_tree/TMBTrack.hpp"
#include <string>

#ifndef ROOT_TRef
#include "TRef.h"
#endif
#ifndef ROOT_TRefArray
#include "TRefArray.h"
#endif

class TMBTrack;
class TMBVertex;

class TMBMuon : public TMBLorentzVector {

public:

  enum Type {
    kLocalCorr   = 0,
    kCentralCorr = 1,
    kSmearedMC   = 2
  };

private:

  // different muon types
  TMBMuonType _local;      
  TMBMuonType _localcorr;  
  TMBMuonType _central;    
  TMBMuonType _centralcorr;
  TMBMuonType _global;     
  TMBMuonType _smearedMC;  
  Type _best; 
 
  // muon system info:
  Int_t        _nhit;      
  Int_t        _ndeck;     
  Int_t        _region;    
  Int_t        _octant;    
  Float_t      _chisqloc;  
  Float_t      _sctimeA;   
  Float_t      _sctimeB;   
  Float_t      _sctimeC;   
  Float_t      _xA;        
  Float_t      _yA;        
  Float_t      _zA;        
  Float_t      _bdl;       

  // matching info:
  Int_t        _nseg;        
  Int_t        _ndof;        
  Float_t      _deltaPhi;    
  Float_t      _deltaEta;    
  Float_t      _deltaDrift;  
  Float_t      _chisq;       
  Float_t      _zAtPca;      
  Float_t      _impPar;      
  Float_t      _impParSig;   
  Float_t      _err_impPar;  
  Float_t      _err_zAtPca;  
  Float_t      _dca;         
  Float_t      _deteta;      
  TRef         _chptr;       
  TRef         _vtxref;      

  // MTC info:
  Int_t        _calnLayer;   
  Int_t        _nmtc;        
  Float_t      _etrack_best; 
  Float_t      _caleSig;     
  Float_t      _calEta;      
  Float_t      _calPhi;      
  Float_t      _eloss;       

  // isolation variables
  Int_t        _nTrk5;     
  Float_t      _EInCone1;  
  Float_t      _EInCone15; 
  Float_t      _EInCone2;  
  Float_t      _EInCone4;  
  Float_t      _EInCone6;  
  Float_t      _drJet5;    
  Float_t      _etTrkCone5;
  Float_t      _etHalo;    

  // Flags
  Int_t _isLoose;     
  Int_t _isMedium;    
  Int_t _isTight;     
  Int_t _hasLocal;    
  Int_t _hasCentral;  
  Int_t _hasCal;      
  Int_t _isMuonEventOK;
  Int_t _isCosmic;     
  Int_t _isCosmicT;    
  
  // Expected number of hits
  Int_t _expWhitsA;  
  Int_t _expWhitsBC; 
  Int_t _expShitsA;  
  Int_t _expShitsBC; 

  Float_t _rand; 

public:
  
  TMBMuon();

  TMBMuon(Double_t pT, Double_t eta, Double_t phi, Type best,
          const TMBMuonType& local,   const TMBMuonType& localcorr, 
          const TMBMuonType& central, const TMBMuonType& centralcorr, 
          const TMBMuonType& global,  const TMBMuonType& smearedMC);
                        
  void SetLocalInfo(Int_t nhit, Int_t ndeck, Int_t region, Int_t octant,
                Float_t chisqloc, Float_t sctimeA, Float_t sctimeB, Float_t sctimeC,
                Float_t xA, Float_t yA, Float_t zA, Float_t bdl);

  void SetMatchingInfo(Int_t nseg, Int_t ndof, 
                Float_t deltaPhi, Float_t deltaEta, Float_t deltaDrift,
                Float_t chisq, Float_t zAtPca, Float_t impPar, Float_t impParSig, 
                Float_t err_zAtPca, Float_t err_impPar, Float_t dca,
                TRef chptr, TRef vtxref);

  void SetDetEta(Float_t deteta);

  void SetMTCInfo(Int_t nmtc, Int_t calnLayer, Float_t etrack_best,
                Float_t caleSig, Float_t calEta, Float_t calPhi, Float_t eloss);

  void SetIsolationInfo(Int_t nTrk5, Float_t EInCone1, Float_t EInCone15, Float_t EInCone2, 
                Float_t EInCone4, Float_t EInCone6,
                Float_t drJet5, Float_t etTrkCone5, Float_t etHalo);

  void SetFlags(Int_t isLoose, Int_t isMedium, Int_t isTight, 
                Int_t hasLocal, Int_t hasCentral, Int_t hasCal,
                Int_t isMuonEventOK, Int_t isCosmic, Int_t isCosmicT);  

  void SetExpectedHits(Int_t expWhitsA, Int_t expWhitsBC, Int_t expShitsA, Int_t expShitsBC);

  void SetMCsmearingRand(Float_t rand);

  void CorrectPt(double dca);


 void ActAsSmeared(Float_t * par, bool zjpsiparams=1);

  void ActAsSmeared_pre();
  void ActAsSmeared_post();
  ~TMBMuon() {;}

  // different muon types
  const TMBMuonType& Local()                    const{return _local;}
  const TMBMuonType& LocalCorr()                const{return _localcorr;}
  const TMBMuonType& Central()                  const{return _central;}
  const TMBMuonType& CentralCorr()              const{return _centralcorr;}
  const TMBMuonType& Global()                   const{return _global;}
  const TMBMuonType& SmearedMC()                const{return _smearedMC;}

  // general methods, those of TMBMuonType (additionnal those of TMBLorentzVector)
  Int_t       charge()  const;
  Double_t    tlm()     const;
  Double_t    err_phi() const;
  Double_t    err_eta() const;
  Double_t    err_pT()  const;

  // muon system info:
  Int_t       nhit()                    const {return _nhit;}
  Int_t       ndeck()                   const {return _ndeck;}
  Int_t       region()                  const {return _region;}
  Int_t       octant()                  const {return _octant;}
  Float_t     chisqloc()                const {return _chisqloc ;} 
  Float_t     sctimeA()                 const {return _sctimeA ;} 
  Float_t     sctimeB()                 const {return _sctimeB ;}
  Float_t     sctimeC()                 const {return _sctimeC ;} 
  Float_t     xA()                      const {return _xA ;} 
  Float_t     yA()                      const {return _yA ;} 
  Float_t     zA()                      const {return _zA;} 
  Float_t     bdl()                     const {return _bdl;}

  Int_t  wireHitsA() const;
  Int_t  wireHitsB() const;
  Int_t  wireHitsC() const;
  Int_t  wireHitsBC() const;
  Int_t  scintHitsA() const;
  Int_t  scintHitsB() const;
  Int_t  scintHitsC() const;
  Int_t  scintHitsBC() const;
  // return muon detector eta at R=rdet (mainly for rdet = A, B or C layer)
  Double_t GetEtaDetector(Double_t eta, Double_t z, Double_t rdet) const;
  Double_t GetEtaDetector(Int_t solpol=0) const;

  bool isInHole(Int_t solpol=0) const;
  Double_t det_eta(double theta, double phi, double z0) const;

  // matching info:
  Int_t       nseg()                    const {return _nseg;}
  Int_t       ndof()                    const {return _ndof;}
  Float_t     deltaPhi()                const {return _deltaPhi;}
  Float_t     deltaEta()                const {return _deltaEta;}
  Float_t     deltaDrift()              const {return _deltaDrift;}
  Float_t     chisq()                   const {return _chisq;}
  Float_t     zAtPca()                  const {return _zAtPca ;} 
  Float_t     impPar()                  const {return _impPar ;} 
  Float_t     impParSig()               const {return _impParSig ;} 
  Float_t     err_impPar()              const {return _err_impPar;} 
  Float_t     err_zAtPca()              const {return _err_zAtPca ;}
  Float_t     dca()                     const {return _dca;} 
  Float_t     detectorEta()             const {return _deteta;}
  TMBTrack*   GetChargedTrack()         const {return _chptr.IsValid() ? (TMBTrack*)_chptr.GetObject() : 0;}
  const TRef& GetChargedTrackRef()      const {return _chptr;}
  TMBVertex*  GetVertex()               const {return _vtxref.IsValid() ? (TMBVertex*)_vtxref.GetObject() : 0;}
  const TRef& GetVertexRef()            const {return _vtxref;}
  Double_t chisqProb() const;

  // MTC info:
  Int_t       calnLayer()               const {return _calnLayer;}
  Int_t       nmtc()                    const {return _nmtc;}
  Float_t     etrack_best()             const {return _etrack_best;} 
  Float_t     caleSig()                 const {return _caleSig;}
  Float_t     calEta()                  const {return _calEta;}
  Float_t     calPhi()                  const {return _calPhi;}
  Float_t     eloss()                   const {return _eloss;}
 
  // Isolation info:
  Int_t       nTrk5()                   const {return _nTrk5;}
  Float_t     EInCone1()                const {return _EInCone1;}
  Float_t     EInCone15()               const {return _EInCone15;}
  Float_t     EInCone2()                const {return _EInCone2;}
  Float_t     EInCone4()                const {return _EInCone4;}
  Float_t     EInCone6()                const {return _EInCone6;}
  Float_t     drJet5()                  const {return _drJet5;}
  Float_t     etTrkCone5()              const {return _etTrkCone5;}
  Float_t     etHalo()                  const {return _etHalo;}

  // Flags:
  Int_t       isLoose()                 const { return _isLoose;}
  Int_t       isMedium()                const { return _isMedium;}
  Int_t       isTight()                 const {return _isTight;}
  Int_t       hasLocal()                const {return _hasLocal;}
  Int_t       hasCentral()              const {return _hasCentral;}
  Int_t       hasCal()                  const {return _hasCal;}
  Int_t       isMuonEventOK()           const {return _isMuonEventOK;}
  Int_t       isCosmic()                const {return _isCosmic;}
  Int_t       isCosmicT()               const {return _isCosmicT;}

  // Expected number of hits:
  Int_t expWhitsA()      const {return _expWhitsA;}
  Int_t expWhitsBC()     const {return _expWhitsBC;}
  Int_t expShitsA()      const { return _expShitsA;}
  Int_t expShitsBC()     const { return _expShitsBC;}

  Float_t MCsmearingRand() const { return _rand;}
 
  void  FixMuonPt();

  ClassDef(TMBMuon, 5)   // TMBTree Muon class
};

#endif

---