L1MuDTTrack.cc

Go to the documentation of this file.

//-------------------------------------------------
//
//   Class: L1MuDTTrack
//
//   Description: Muon Track Candidate
//
//
//   $Date: 2008/02/18 17:38:04 $
//   $Revision: 1.5 $
//
//   Author :
//   N. Neumeister            CERN EP
//   J. Troconiz              UAM Madrid
//
//--------------------------------------------------

//-----------------------
// This Class's Header --
//-----------------------

#include "L1Trigger/DTTrackFinder/interface/L1MuDTTrack.h"

//---------------
// C++ Headers --
//---------------

#include <iostream>
#include <iomanip>

//-------------------------------
// Collaborating Class Headers --
//-------------------------------

#include "L1Trigger/DTTrackFinder/src/L1MuDTSecProcId.h"
#include "L1Trigger/DTTrackFinder/src/L1MuDTTrackSegPhi.h"
#include "L1Trigger/DTTrackFinder/src/L1MuDTTrackSegEta.h"
#include "CondFormats/L1TObjects/interface/L1MuTriggerPtScale.h"
#include "CondFormats/DataRecord/interface/L1MuTriggerPtScaleRcd.h"
#include "CondFormats/L1TObjects/interface/L1MuPacking.h"

using namespace std;

// --------------------------------
//       class L1MuDTTrack
//---------------------------------

//----------------
// Constructors --
//----------------
L1MuDTTrack::L1MuDTTrack() :
               L1MuRegionalCand(0,0),
               m_spid(L1MuDTSecProcId()), m_name("L1MuDTTrack"), m_empty(true),
               m_tc(UNDEF),
               m_addArray(), m_tsphiList(), m_tsetaList() {

  m_tsphiList.reserve(4);
  m_tsetaList.reserve(3);
  
  setType(0);
  setChargeValid(true);

}


L1MuDTTrack::L1MuDTTrack(const L1MuDTSecProcId& spid) :
               L1MuRegionalCand(0,0),
               m_spid(spid), m_name("L1MuDTTrack"), m_empty(true), 
               m_tc(UNDEF),
               m_addArray(), m_tsphiList(), m_tsetaList() {

  m_tsphiList.reserve(4);
  m_tsetaList.reserve(3);
  
  setType(0);
  setChargeValid(true);

}


L1MuDTTrack::L1MuDTTrack(const L1MuDTTrack& id) :
               L1MuRegionalCand(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 --
//--------------
L1MuDTTrack::~L1MuDTTrack() {}


//--------------
// Operations --
//--------------

//
// reset Muon Track Candidate
//
void L1MuDTTrack::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 L1MuDTTrack::setEta(int eta) {

  // eta is a signed integer [-32,31], 
  // representing 64 bins in an interval [-1.2,+1.2] 
  // first convert eta into an unsigned integer
  L1MuSignedPacking<6> pEta;
  setEtaPacked(pEta.packedFromIdx(eta));

}


//
// return start phi track segment
//
const L1MuDTTrackSegPhi& L1MuDTTrack::getStartTSphi() const { 

  return m_tsphiList.front();

}


//
// return end phi track segment
//
const L1MuDTTrackSegPhi& L1MuDTTrack::getEndTSphi() const { 

  return m_tsphiList.back(); 

}


//
// return start eta track segment
//
const L1MuDTTrackSegEta& L1MuDTTrack::getStartTSeta() const {

  return m_tsetaList.front(); 

}


//
// return end eta track segment
//
const L1MuDTTrackSegEta& L1MuDTTrack::getEndTSeta() const {

  return m_tsetaList.back();

}


//
// set phi track segments used to form the muon candidate
//
void L1MuDTTrack::setTSphi(const vector<const L1MuDTTrackSegPhi*>& tsList) {

  if ( !tsList.empty() ) {
    vector<const L1MuDTTrackSegPhi*>::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 L1MuDTTrack::setTSeta(const vector<const L1MuDTTrackSegEta*>& tsList) {

  if ( !tsList.empty() ) {
    vector<const L1MuDTTrackSegEta*>::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 L1MuDTTrack::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;
}


//
// Assignment operator
//
L1MuDTTrack& L1MuDTTrack::operator=(const L1MuDTTrack& 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 L1MuDTTrack::operator==(const L1MuDTTrack& 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 L1MuDTTrack::operator!=(const L1MuDTTrack& 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 L1MuDTTrack::print() const {

  if ( !empty() ) {
    cout.setf(ios::showpoint);
    cout.setf(ios::right,ios::adjustfield);  
    cout << setiosflags(ios::showpoint | ios::fixed);
    cout << "MUON : "
         << "pt = "      << setw(2) << pt_packed() << "  "
         << "charge = "  << setw(2) << charge_packed() << "  "
         << "eta = "     << setw(2) << eta_packed()
         << " ("         << setw(1) << finehalo_packed() << ")  "  
         << "phi = "     << setw(3) << phi_packed() << "  "
         << "quality = " << setw(1) << quality_packed() << '\t'
         << "class = "   << tc() << "  "
         << "bx = "      << setw(2) << bx() << endl;
    cout << "       found in " << m_spid << " with phi track segments :" << endl;
    vector<L1MuDTTrackSegPhi>::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 L1MuDTTrack& id) {

  if ( !id.empty() ) {
    s << setiosflags(ios::showpoint | ios::fixed) 
      << "pt = "      << setw(2) << id.pt_packed() << "  "
      << "charge = "  << setw(2) << id.charge_packed() << "  "
      << "eta = "     << setw(2) << id.eta_packed()
      << " ("         << setw(1) << id.finehalo_packed() << ")  "  
      << "phi = "     << setw(3) << id.phi_packed() << "  "
      << "quality = " << setw(1) << id.quality_packed() << '\t'
      << "bx = "      << setw(2) << id.bx();
  }
  return s;

}