TMBMuon.cpp

Go to the documentation of this file.

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

#include "tmb_tree/TMBMuon.hpp"
#include "TError.h"
#include "TMath.h"
#include "tmb_tree/TMBTrack.hpp"

namespace {
  Double_t MuonMass = 0.1057;
}

ClassImp(TMBMuon)

//_____________________________________________________________________________
TMBMuon::TMBMuon()
    :  TMBLorentzVector(0,0,0,MuonMass, kPtEtaPhiM),
       _best(kCentralCorr)
{
}

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)
    : TMBLorentzVector(pT,eta,phi,MuonMass,kPtEtaPhiM),
      _local(local),
      _localcorr(localcorr),
      _central(central),
      _centralcorr(centralcorr),
      _global(global),
      _smearedMC(smearedMC),
      _best(best)
{
}

void TMBMuon::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) 
{
  _nhit     = nhit;
  _ndeck    = ndeck;
  _region   = region;
  _octant   = octant;
  _chisqloc = chisqloc;
  _sctimeA  = sctimeA;
  _sctimeB  = sctimeB;
  _sctimeC  = sctimeC;
  _xA       = xA;
  _yA       = yA;
  _zA       = zA;
  _bdl      = bdl;
}

void TMBMuon::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, Float_t deteta,
                TRef chptr, TRef vtxref)
{
  _nseg       = nseg;
  _ndof       = ndof;
  _deltaPhi   = deltaPhi;
  _deltaEta   = deltaEta;
  _deltaDrift = deltaDrift;
  _chisq      = chisq;
  _zAtPca     = zAtPca;
  _impPar     = impPar;
  _impParSig  = impParSig;
  _err_zAtPca = err_zAtPca;
  _err_impPar = err_impPar;
  _dca        = dca;
  _deteta     = deteta;
  _chptr      = chptr;
  _vtxref     = vtxref;
}
 
void TMBMuon::SetMTCInfo(Int_t nmtc, Int_t calnLayer, Float_t etrack_best,
                Float_t caleSig, Float_t calEta, Float_t calPhi, Float_t eloss)
{
  _nmtc        = nmtc;
  _calnLayer   = calnLayer;
  _etrack_best = etrack_best;
  _caleSig     = caleSig;
  _calEta      = calEta;
  _calPhi      = calPhi;
  _eloss       = eloss;
}

void TMBMuon::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)
{
  _nTrk5      = nTrk5;
  _EInCone1   = EInCone1;
  _EInCone15  = EInCone15;
  _EInCone2   = EInCone2;
  _EInCone4   = EInCone4;
  _EInCone6   = EInCone6;
  _drJet5     = drJet5;
  _etTrkCone5 = etTrkCone5;
  _etHalo     = etHalo;
}
 
void TMBMuon::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)
{
  _isLoose       = isLoose;
  _isMedium      = isMedium;
  _isTight       = isTight;
  _hasLocal      = hasLocal;
  _hasCentral    = hasCentral;
  _hasCal        = hasCal;
  _isMuonEventOK = isMuonEventOK;
  _isCosmic      = isCosmic;
  _isCosmicT     = isCosmicT;
}

void TMBMuon::SetExpectedHits(Int_t expWhitsA, Int_t expWhitsBC, 
                              Int_t expShitsA, Int_t expShitsBC)
{
  _expWhitsA      = expWhitsA;
  _expWhitsBC     = expWhitsBC;
  _expShitsA      = expShitsA;
  _expShitsBC     = expShitsBC;
}

void TMBMuon::SetMCsmearingRand(Float_t rand)
{
  _rand = rand;
}

void TMBMuon::CorrectPt(double dca)
{
  //If muo does not have track do not try to correct
  if(!_hasCentral) return;
  const TMBTrack* trk = GetChargedTrack();
  if(trk) {
    double err_rqpt = trk->trerrs(4, 0);
    double err_rr = trk->trerrs(0, 0);
    float qopt = trk->qpt();
    qopt -= dca * err_rqpt / err_rr;
    double pTcorr = 1 / qopt;
    int q = 1;
    if(pTcorr<0) {
      pTcorr *= -1;
      q = -1;
    }
    double scale = pTcorr / trk->Pt();
    double corrpx = scale * trk->Px();
    double corrpy = scale * trk->Py();
    double corrpz = scale * trk->Pz();
    double corrE = scale * trk->E();
    
    //change TMBMuon 4-vector
    SetPxPyPzE(corrpx,corrpy,corrpz,corrE);
    //change _centralcorr 4-vector & charge
    TMBMuonType new_centralcorr(pTcorr,Eta(),Phi(),err_pT(),err_eta(),err_phi(),q);
    _centralcorr = new_centralcorr;
    //Set best muon info to CentralCorr
    _best = TMBMuon::kCentralCorr; 
  }

}

Int_t TMBMuon::charge() const
{
  switch(_best) {
    case kLocalCorr: return _localcorr.charge();
    case kCentralCorr: return _centralcorr.charge();
    case kSmearedMC: return _smearedMC.charge();
    default: Error("TMBMuon::charge","bad best muon type");
  }
  return 0;
}

Double_t TMBMuon::tlm() const
{
  switch(_best) {
    case kLocalCorr: return _localcorr.tlm();
    case kCentralCorr: return _centralcorr.tlm();
    case kSmearedMC: return _smearedMC.tlm();
    default: Error("TMBMuon::tlm","bad best muon type");
  }
  return 0;
}

Double_t TMBMuon::err_phi() const
{
  switch(_best) {
    case kLocalCorr: return _localcorr.err_phi();
    case kCentralCorr: return _centralcorr.err_phi();
    case kSmearedMC: return _smearedMC.err_phi();
    default: Error("TMBMuon::err_phi","bad best muon type");
  }
  return 0;
}

Double_t TMBMuon::err_eta() const
{
  switch(_best) {
    case kLocalCorr: return _localcorr.err_eta();
    case kCentralCorr: return _centralcorr.err_eta();
    case kSmearedMC: return _smearedMC.err_eta();
    default: Error("TMBMuon::err_eta","bad best muon type");
  }
  return 0;
}

Double_t TMBMuon::err_pT() const
{
  switch(_best) {
    case kLocalCorr: return _localcorr.err_pT();
    case kCentralCorr: return _centralcorr.err_pT();
    case kSmearedMC: return _smearedMC.err_pT();
    default: Error("TMBMuon::err_pT","bad best muon type");
  }
  return 0;
}

Int_t TMBMuon::wireHitsA() const
{
  return (_nhit % 10);
}

Int_t TMBMuon::wireHitsB() const
{
  return (_nhit / 10)%10;
}

Int_t TMBMuon::wireHitsC() const
{
  return (_nhit / 100)%10;
}

Int_t TMBMuon::wireHitsBC() const
{
  return (wireHitsB() + wireHitsC());
}

int TMBMuon::scintHitsA() const {
  return (_nhit / 1000)%10;
}

int TMBMuon::scintHitsBC() const {
  return scintHitsB() + scintHitsC();
}

int TMBMuon::scintHitsB() const {
  return (_nhit/10000)%10;
}

int TMBMuon::scintHitsC() const {
  return (_nhit/100000)%10;
}

Double_t TMBMuon::GetEtaDetector(Double_t eta, Double_t z, Double_t rdet) const
{
  float z0 = z + rdet*sinh(eta);
  float temp = z0/rdet + sqrt(z0*z0/rdet/rdet + 1.);
  return (temp>0?log(temp):eta);
}

Double_t TMBMuon::chisqProb() const
{
  return TMath::Prob(_chisq,_ndof);
}

//______________________________________________________________________________

---