TMBTau.hpp

Go to the documentation of this file.

#ifndef TMBTau_H
#define TMBTau_H

//                                                                      //
// File:  TMBTau.hpp
//                                                                      //

#include "tmb_tree/TMBLorentzVector.hpp"

//#ifndef ROOT_TObject
//#include "TObject.h"
//#endif
#ifndef ROOT_TRef
#include "TRef.h"
#endif
#ifndef ROOT_TRefArray
#include "TRefArray.h"
#endif

class TMBTrack;
class TMBCps;
class TMBFps;
class TMBVertex;

//class TauQuality;

class TMBTau : public TMBLorentzVector {

private:
   TRefArray      _cpsptr;
   TRefArray      _fpsptr;
   TRefArray      _tracks;
   TRef           _vtxref;

   Float_t        _rms;
   Float_t        _profile;
   Float_t        _emf;         
   Float_t        _icdf;        
   Float_t        _chf;         
   Float_t        _hot;         
   Float_t        _nnout; // NN jet-tau
  Float_t        _nnelec; // NN electron-tau (-1.0 for types 1 and 3)
  Int_t          _flag;

    //  quality quantities
  // Int_t          _iq[3]; // replaced by
  Int_t _nclus;
  // Float_t        _fq[34]; // replaced by
  Float_t _ett1; 
  Float_t _ett2; 
  Float_t _ett3; 
  Float_t _mtrk; 
  Float_t _ettr; 
  Float_t _empt; 
  Float_t _emm; 
  Float_t _emeta; 
  Float_t _emphi; 
  Float_t _tzDCA; 
  Float_t _teta;  
  Float_t _tphi;  
  Float_t _tphiPS; 
  Float_t _tphiEM3; 
  Float_t _emcl_eta1; 
  Float_t _emcl_eta2; 
  Float_t _emcl_phi1; 
  Float_t _emcl_phi2; 
  Float_t _emcl_et1; 
  Float_t _emcl_et2; 
  Float_t _pseta; 
  Float_t _psphi; 
  Float_t _e1e2;  
  Float_t _dalpha;

  Float_t _emcl_f12; 
  Float_t _emcl_f3; 
  Float_t _emcl_f4; 

   Float_t        _et_7;
   Float_t        _et_3;
   Float_t        _EM12_Et;
   Float_t        _EM12_Et_core;
   Float_t        _EM3_Et;
   Float_t        _EM3_Et_core;
   Float_t        _EM4_Et;
   Float_t        _EM4_Et_core;
   Int_t        _typ;
  Float_t _nnreco;  // nnout from d0reco
  Float_t _nnL3; // nnL3 from d0reco
  Float_t _Ecorrection;

public:
  TMBTau():_nnreco(-1.0),_nnL3(-1.0),_nnout(-1.0),_nnelec(-1.0),_Ecorrection(1.0){;}
   TMBTau(Float_t px, Float_t py, Float_t pz, Float_t E, 
          TRefArray* cpsptr, TRefArray* fpsptr,
          TRefArray* tracks, TRef& vtxref,
          Float_t rms, Float_t profile, Float_t emf,
          Float_t icdf, Float_t chf, Float_t hot,
          Int_t flag, Int_t* iq, Float_t* fq,
          Float_t et_7, Float_t et_3, 
          Float_t EM12_Et, Float_t EM12_Et_core,
          Float_t EM3_Et, Float_t EM3_Et_core, Float_t  EM4_Et,
          Float_t EM4_Et_core, Int_t typ);

   void Set(Float_t px, Float_t py, Float_t pz, Float_t E,
          TRefArray* cpsptr, TRefArray* fpsptr, 
         TRefArray* tracks, TRef& vtxref,
         Float_t rms, Float_t profile, Float_t emf,
         Float_t icdf, Float_t chf, Float_t hot,
         Int_t flag, Int_t* iq, Float_t* fq,
         Float_t et_7, Float_t et_3,
         Float_t EM12_Et, Float_t EM12_Et_core,
         Float_t EM3_Et, Float_t EM3_Et_core, Float_t  EM4_Et,
         Float_t EM4_Et_core, Int_t typ);
  void SetNNreco(Float_t nnreco){_nnreco=nnreco;}
  void SetNNL3(Float_t nnL3){_nnL3=nnL3;}
  void SetNN(Float_t nn){ _nnout=nn;}
  void SetNNe(Float_t nne){ _nnelec=nne;}
  void SetEcorrection(Float_t Ecorrection){_Ecorrection=Ecorrection;}

  Float_t Ecorrection() const {return _Ecorrection;} 
  Float_t   ET()      const {return Perp();}

   Float_t   rms()     const {return _rms;}
   Float_t   profile() const {return _profile;}
   Float_t   emf()     const {return _emf;}
   Float_t   icdf()    const {return _icdf;}
   Float_t   chf()          const {return _chf;}
   Float_t   hot()          const {return _hot;}

   Int_t     flag()         const {return _flag;}
   Float_t   Et_iso()       const {return _et_7;}
   Float_t   Et()           const {return _et_3;}
   Float_t   EM12_Et_iso()  const {return _EM12_Et;}
   Float_t   EM12_Et()      const {return _EM12_Et_core;}
   Float_t   EM3_Et_iso()   const {return _EM3_Et;}
   Float_t   EM3_Et()       const {return _EM3_Et_core;}
   Float_t   EM4_Et_iso()   const {return _EM4_Et;}
   Float_t   EM4_Et()       const {return _EM4_Et_core;}
   Int_t   type()         const {return _typ;}

   Int_t     nclus()        const {return _nclus;}
   Float_t   ett1()         const {return _ett1;}
   Float_t   ett2()         const {return _ett2;}
   Float_t   ett3()         const {return _ett3;}
   Float_t   mtrk()         const {return _mtrk;}
   Float_t   ettr()         const {return _ettr;}
  Float_t   empt()         const {return _empt;}
   Float_t   emm()          const {return _emm;}
   Float_t   emeta()        const {return _emeta;}
   Float_t   emphi()        const {return _emphi;}
   Float_t   tzDCA()        const {return _tzDCA;}
   Float_t   teta()         const {return _teta;}
   Float_t   tphi()         const {return _tphi;}
  Float_t   tphiPS()       const {return _tphiPS-_tphi;} // phi of track 1 at PS
  Float_t   tphiEM3()      const {return _tphiEM3-_tphi;} // phi of track 1 at EM3
   Float_t   emcl_eta1()    const {return _emcl_eta1;}
   Float_t   emcl_eta2()    const {return _emcl_eta2;}
   Float_t   emcl_phi1()    const {return _emcl_phi1;}
   Float_t   emcl_phi2()    const {return _emcl_phi2;}
   Float_t   emcl_et1()     const {return _emcl_et1;}
   Float_t   emcl_et2()     const {return _emcl_et2;}
   Float_t   pseta()        const {return _pseta;}
   Float_t   psphi()        const {return _psphi;}
   Float_t   e1e2()         const {return _e1e2;}
   Float_t   dalpha()       const {return _dalpha;}

   Float_t   emcl_f12()     const {return _emcl_f12;}
   Float_t   emcl_f3()      const {return _emcl_f3;}
   Float_t   emcl_f4()      const {return _emcl_f4;}
  Float_t nnout() const{return _nnout;}
  Float_t nnelec() const{return _nnelec;}
  Float_t nnreco() const{return _nnreco;}
  Float_t nnL3() const{return _nnL3;}
  Int_t  ntrk() const {return _tracks.GetLast()+1;}
  const TMBTrack*  GetChargedTrack(Int_t itrk) const {return (const TMBTrack*)_tracks.At(itrk);}
  const TMBVertex*  GetVertex()                 const {return _vtxref.IsValid() ? (const TMBVertex*)_vtxref.GetObject() : 0;}
  const TRef& GetVertexRef() const {return _vtxref;}
  Int_t ncps() const{return _cpsptr.GetLast()+1;}
  const TMBCps*   GetCps(Int_t icps)          const {return (const TMBCps*)_cpsptr.At(icps);}
  Int_t nfps() const{return _fpsptr.GetLast()+1;}
  const TMBFps*   GetFps(Int_t ifps)          const {return (const TMBFps*)_fpsptr.At(ifps);}

   Float_t   EM12isof() const {return _et_7 >= 0.001 ? _EM12_Et/_et_7      : _EM12_Et/0.001 ;}
   Float_t   EM12f()  const {return _et_3 >= 0.001 ? _EM12_Et_core/_et_3 : _EM12_Et_core/0.001;}
   Float_t   EM3isof() const {return _et_7 >= 0.001 ? _EM3_Et/_et_7       : _EM3_Et/0.001;}
   Float_t   EM3f()    const {return _et_3 >= 0.001 ? _EM3_Et_core/_et_3  : _EM3_Et_core/0.001;}
   Float_t   EM4isof() const {return _et_7 >= 0.001 ? _EM4_Et/_et_7       : _EM4_Et/0.001;}
   Float_t   EM4f()    const {return _et_3 >= 0.001 ? _EM4_Et_core/_et_3  : _EM4_Et_core/0.001;}
   Float_t   iso()     const {return _et_3 >= 0.001 ? (_et_7 - _et_3)/_et_3 : (_et_7 - _et_3)/0.001;}
  Float_t charge() const;
  Float_t vz() const;
  Float_t det_eta(float z, float pz, float pT) const;
  Float_t etad() const;

   ~TMBTau() {;}

template <class T>
int give_sign (T x) const
//
// Purpose: Return the sign of X.
//
// Inputs:
//   x -           The value to test.
//
// Returns:
//   One of +1, -1, or 0, depending on the sign of X.
//
{
  if (x > 0)
    return 1;
  else if (x < 0)
    return -1;
  else
    return 0;
}


    ClassDef(TMBTau, 7)   // TMBTree Taus class
};

#endif

---