L1MuBMTrack.cc

Go to the documentation of this file.

//-------------------------------------------------
//
//   Class: L1MuBMTrack
//
//   Description: Muon Track Candidate
//
//
//
//   Author :
//   N. Neumeister            CERN EP
//   J. Troconiz              UAM Madrid
//
//--------------------------------------------------
 
//-----------------------
// This Class's Header --
//-----------------------
 
#include "DataFormats/L1TMuon/interface/L1MuBMTrack.h"
 
//---------------
// C++ Headers --
//---------------
 
#include <iostream>
#include <iomanip>
 
//-------------------------------
// Collaborating Class Headers --
//-------------------------------
 
#include "DataFormats/L1TMuon/interface/BMTF/L1MuBMSecProcId.h"
#include "DataFormats/L1TMuon/interface/L1MuBMTrackSegPhi.h"
#include "DataFormats/L1TMuon/interface/L1MuBMTrackSegEta.h"
//#include "CondFormats/L1TObjects/interface/L1MuTriggerPtScale.h"
//#include "CondFormats/DataRecord/interface/L1MuTriggerPtScaleRcd.h"
//#include "CondFormats/L1TObjects/interface/L1MuPacking.h"
 
using namespace std;
 
// --------------------------------
//       class L1MuBMTrack
//---------------------------------
 
//----------------
// Constructors --
//----------------
L1MuBMTrack::L1MuBMTrack()
    :  //L1MuRegionalCand(0,0),-->
      l1t::RegionalMuonCand(),
      m_spid(L1MuBMSecProcId()),
      m_name("L1MuBMTrack"),
      m_empty(true),
      m_tc(UNDEF),
      m_addArray(),
      m_tsphiList(),
      m_tsetaList() {
  m_tsphiList.reserve(4);
  m_tsetaList.reserve(3);
 
  //setType(0);
  //setChargeValid(true);
  setHwSignValid(1);
}
 
L1MuBMTrack::L1MuBMTrack(const L1MuBMSecProcId& spid)
    :  //L1MuRegionalCand(0,0),-->
      l1t::RegionalMuonCand(),
      m_spid(spid),
      m_name("L1MuBMTrack"),
      m_empty(true),
      m_tc(UNDEF),
      m_addArray(),
      m_tsphiList(),
      m_tsetaList() {
  m_tsphiList.reserve(4);
  m_tsetaList.reserve(3);
  //setType(0);
  //setChargeValid(true);
  setHwSignValid(1);
}
 
L1MuBMTrack::L1MuBMTrack(const L1MuBMTrack& id)
    :  //L1MuRegionalCand(id),-->
      l1t::RegionalMuonCand(id),
      m_spid(id.m_spid),
      m_name(id.m_name),
      m_empty(id.m_empty),
      m_tc(id.m_tc),
      m_addArray(id.m_addArray),
      m_tsphiList(id.m_tsphiList),
      m_tsetaList(id.m_tsetaList) {}
 
//--------------
// Destructor --
//--------------
L1MuBMTrack::~L1MuBMTrack() {}
 
//--------------
// Operations --
//--------------
 
//
// reset Muon Track Candidate
//
void L1MuBMTrack::reset() {
  //L1MuRegionalCand::reset();
  m_empty = true;
  m_tc = UNDEF;
  m_addArray.reset();
  m_tsphiList.clear();
  m_tsetaList.clear();
}
 
//
// set (packed) eta-code of muon candidate
//
void L1MuBMTrack::setEta(int eta) {
  // eta is a signed integer [-115,118],
  setHwHF(false);
  setHwEta(eta);
}
 
//
// return start phi track segment
//
const L1MuBMTrackSegPhi& L1MuBMTrack::getStartTSphi() const { return m_tsphiList.front(); }
 
//
// return end phi track segment
//
const L1MuBMTrackSegPhi& L1MuBMTrack::getEndTSphi() const { return m_tsphiList.back(); }
 
//
// return start eta track segment
//
const L1MuBMTrackSegEta& L1MuBMTrack::getStartTSeta() const { return m_tsetaList.front(); }
 
//
// return end eta track segment
//
const L1MuBMTrackSegEta& L1MuBMTrack::getEndTSeta() const { return m_tsetaList.back(); }
 
//
// set phi track segments used to form the muon candidate
//
void L1MuBMTrack::setTSphi(const vector<const L1MuBMTrackSegPhi*>& tsList) {
  if (!tsList.empty()) {
    vector<const L1MuBMTrackSegPhi*>::const_iterator iter;
    for (iter = tsList.begin(); iter != tsList.end(); iter++) {
      if (*iter)
        m_tsphiList.push_back(**iter);
    }
  }
}
 
//
// set eta track segments used to form the muon candidate
//
void L1MuBMTrack::setTSeta(const vector<const L1MuBMTrackSegEta*>& tsList) {
  if (!tsList.empty()) {
    vector<const L1MuBMTrackSegEta*>::const_iterator iter;
    for (iter = tsList.begin(); iter != tsList.end(); iter++) {
      if (*iter)
        m_tsetaList.push_back(**iter);
    }
  }
}
 
//
// convert pt value in GeV to pt code
//
unsigned int L1MuBMTrack::triggerScale(float value, const edm::EventSetup& c) const {
  /*const float eps = 1.e-5; // add an epsilon so that setting works with low edge value
 
  edm::ESHandle< L1MuTriggerPtScale > theTriggerScales;
  c.get< L1MuTriggerPtScaleRcd >().get( theTriggerScales );
  unsigned int t_Scale = theTriggerScales->getPtScale()->getPacked( value + eps );
 
  return t_Scale;*/
  return (unsigned int)0.5;
}
 
//
// Assignment operator
//
L1MuBMTrack& L1MuBMTrack::operator=(const L1MuBMTrack& track) {
  if (this != &track) {
    this->setBx(track.bx());
    //this->setDataWord(track.getDataWord());
    m_spid = track.m_spid;
    m_empty = track.m_empty;
    m_name = track.m_name;
    m_tc = track.m_tc;
    m_addArray = track.m_addArray;
    m_tsphiList = track.m_tsphiList;
    m_tsetaList = track.m_tsetaList;
  }
  return *this;
}
 
//
// Equal operator
//
bool L1MuBMTrack::operator==(const L1MuBMTrack& track) const {
  if (m_spid != track.m_spid)
    return false;
  if (m_empty != track.m_empty)
    return false;
  if (m_tc != track.m_tc)
    return false;
  if (bx() != track.bx())
    return false;
  if (phi() != track.phi())
    return false;
  if (eta() != track.eta())
    return false;
  if (fineEtaBit() != track.fineEtaBit())
    return false;
  if (pt() != track.pt())
    return false;
  if (charge() != track.charge())
    return false;
  if (quality() != track.quality())
    return false;
  if (m_addArray != track.m_addArray)
    return false;
  return true;
}
 
//
// Unequal operator
//
bool L1MuBMTrack::operator!=(const L1MuBMTrack& track) const {
  if (m_spid != track.m_spid)
    return true;
  if (m_empty != track.m_empty)
    return true;
  if (m_tc != track.m_tc)
    return true;
  if (bx() != track.bx())
    return true;
  if (phi() != track.phi())
    return true;
  if (eta() != track.eta())
    return true;
  if (fineEtaBit() != track.fineEtaBit())
    return true;
  if (pt() != track.pt())
    return true;
  if (charge() != track.charge())
    return true;
  if (quality() != track.quality())
    return true;
  if (m_addArray != track.m_addArray)
    return true;
  return false;
}
 
//
// print parameters of track candidate
//
void L1MuBMTrack::print() const {
  if (!empty()) {
    cout.setf(ios::showpoint);
    cout.setf(ios::right, ios::adjustfield);
    cout << setiosflags(ios::showpoint | ios::fixed);
    cout << "MUON : "
         << "pt = " << setw(3) << hwPt() << "  "
         << "charge = " << setw(2) << hwSign() << "  "
         << "eta = " << setw(2)
         << hwEta()
         //<< " ("         << setw(1) << finehalo_packed() << ")  "
         << "phi = " << setw(3) << hwPhi() << "  "
         << "quality = " << setw(1) << hwQual() << '\t' << "class = " << tc() << "  "
         << "bx = " << setw(2) << bx() << endl;
    cout << "       found in " << m_spid << " with phi track segments :" << endl;
    vector<L1MuBMTrackSegPhi>::const_iterator iter;
    for (iter = m_tsphiList.begin(); iter != m_tsphiList.end(); iter++) {
      cout << "       " << (*iter) << endl;
    }
  }
}
 
//
// output stream operator for track candidate
//
ostream& operator<<(ostream& s, const L1MuBMTrack& id) {
  if (!id.empty()) {
    s << setiosflags(ios::showpoint | ios::fixed) << "pt = " << setw(3) << id.hwPt() << "  "
      << "charge = " << setw(2) << id.hwSign() << "  "
      << "eta = " << setw(2)
      << id.hwEta()
      //<< " ("         << setw(1) << id.finehalo_packed() << ")  "
      << "phi = " << setw(3) << id.hwPhi() << "  "
      << "quality = " << setw(1) << id.hwQual() << '\t' << "bx = " << setw(2) << id.bx();
  }
  return s;
}