SimpleL1MuGMTCand.cc

Go to the documentation of this file.

// This class header:
#include "FastSimDataFormats/L1GlobalMuonTrigger/interface/SimpleL1MuGMTCand.h"

// Fast Simulation headers
#include "SimDataFormats/Track/interface/SimTrack.h"

// The muon scales

//CMSSW headers

// STL headers
#include <iomanip>

SimpleL1MuGMTCand::SimpleL1MuGMTCand()
    : m_name("FastL1MuCand"),
      m_empty(true),
      m_phi(0),
      m_eta(31),
      m_pt(0),
      m_charge(0),
      m_quality(0),
      m_rank(0),
      m_smearedPt(0) {}

SimpleL1MuGMTCand::SimpleL1MuGMTCand(const SimpleL1MuGMTCand& mu)
    : L1MuGMTExtendedCand::L1MuGMTExtendedCand(mu),
      m_name(mu.m_name),
      m_empty(mu.m_empty),
      m_phi(mu.m_phi),
      m_eta(mu.m_eta),
      m_pt(mu.m_pt),
      m_charge(mu.m_charge),
      m_quality(mu.m_quality),
      m_rank(mu.m_rank),
      m_smearedPt(mu.m_smearedPt) {
  setMomentum(mu.getMomentum());
  setQuality(m_quality & 7);
  setEtaPacked(m_eta & 63);
  setPhiPacked(m_phi & 255);
  setCharge(m_charge);
  setPtPacked(m_pt & 31);
}

SimpleL1MuGMTCand::SimpleL1MuGMTCand(const SimpleL1MuGMTCand* mu)
    : m_name(mu->m_name),
      m_empty(mu->m_empty),
      m_phi(mu->m_phi),
      m_eta(mu->m_eta),
      m_pt(mu->m_pt),
      m_charge(mu->m_charge),
      m_quality(mu->m_quality),
      m_rank(mu->m_rank),
      m_smearedPt(mu->m_smearedPt) {
  setMomentum(mu->getMomentum());
  setQuality(m_quality & 7);
  setEtaPacked(m_eta & 63);
  setPhiPacked(m_phi & 255);
  setCharge(m_charge);
  setPtPacked(m_pt & 31);
}

SimpleL1MuGMTCand::SimpleL1MuGMTCand(const SimTrack* p) {
  //  setMomentum(p->momentum());
  LorentzVector toBeRemoved(p->momentum().x(), p->momentum().y(), p->momentum().z(), p->momentum().t());
  setMomentum(toBeRemoved);
  m_name = "FastL1MuCand";
  m_empty = false;
  m_quality = 7;
  setQuality(m_quality);
  m_rank = 0;
  setEta(myMomentum.Eta());
  setPhi(myMomentum.Phi());
  setCharge(int(p->charge()));
  setPt(myMomentum.Pt());
  setBx(0);
  if (fabs(myMomentum.eta()) > 1.04)
    setFwdBit(1);
  else
    setFwdBit(0);
  setRPCBit(0);
}

SimpleL1MuGMTCand::SimpleL1MuGMTCand(const SimTrack* p,
                                     unsigned etaIndex,
                                     unsigned phiIndex,
                                     unsigned pTIndex,
                                     float etaValue,
                                     float phiValue,
                                     float pTValue) {
  //  setMomentum(p->momentum());
  LorentzVector toBeRemoved(p->momentum().x(), p->momentum().y(), p->momentum().z(), p->momentum().t());
  setMomentum(toBeRemoved);
  m_name = "FastL1MuCand";
  m_empty = false;
  m_quality = 7;
  setQuality(m_quality);
  m_rank = 0;
  m_phi = phiIndex;
  setPhiPacked(phiIndex);
  setPhiValue(phiValue);
  m_eta = etaIndex;
  setEtaPacked(etaIndex);
  setEtaValue(etaValue);
  setCharge(int(p->charge()));
  m_pt = pTIndex;
  setPtPacked(pTIndex);
  setPtValue(pTValue);
  m_smearedPt = myMomentum.Pt();
  setBx(0);
  if (fabs(etaValue) > 1.04)
    setFwdBit(1);
  else
    setFwdBit(0);
  setRPCBit(0);
}

SimpleL1MuGMTCand::~SimpleL1MuGMTCand() { reset(); }

//
void SimpleL1MuGMTCand::reset() {
  m_empty = true;
  m_phi = 0;
  m_eta = 31;
  m_pt = 0;
  m_charge = 0;
  m_quality = 0;
  m_rank = 0;
  m_smearedPt = 0;
}

//
// set phi-value of muon candidate
//
void SimpleL1MuGMTCand::setPhi(float phi) {
  int index = 0;
  float mindiff = 1000.0;

  if (phi < 0.) {
    phi = 2 * M_PI + phi;
  }
  for (int i = 0; i < 144; i++) {
    float diff = fabs(SimpleL1MuGMTCand::phiScale[i] - phi);
    if (diff <= mindiff) {
      mindiff = diff;
      index = i;
    }
  }

  m_phi = index;
  setPhiPacked(m_phi & 255);
  setPhiValue(phiScale[m_phi]);
}

//
// set eta-value of muon candidate
//
void SimpleL1MuGMTCand::setEta(float eta) {
  int index = 0;
  float mindiff = 1000.0;

  for (int i = 0; i < 63; i++) {
    float diff = fabs(SimpleL1MuGMTCand::etaScale[i] - eta);
    if (diff <= mindiff) {
      mindiff = diff;
      index = i;
    }
  }

  m_eta = index;
  setEtaPacked(m_eta & 63);
  setEtaValue(etaScale[m_eta]);
}

//
// set pt (value!!) of muon candidate
//
void SimpleL1MuGMTCand::setPt(float pt) {
  int index = 0;
  m_smearedPt = pt;

  float mindiff = 1000.0;

  for (int i = 0; i < 32; i++) {
    float diff = fabs(SimpleL1MuGMTCand::ptScale[i] - pt);
    if (diff <= mindiff) {
      mindiff = diff;
      index = i;
    }
  }

  m_pt = index;
  setPtPacked(m_pt & 31);
  setPtValue(ptScale[m_pt]);
}

//
// set charge and packed code of muon candidate
//
void SimpleL1MuGMTCand::setCharge(int charge) {
  m_charge = charge;
  setChargePacked(charge == 1 ? 0 : 1);
}

//
// set generator particle of muon candidate
//
/*
void SimpleL1MuGMTCand::setGenPart(const HepMC::GenParticle * rhp) {

   myGenParticle = rhp;
}
*/

//
// Assignment operator
//
SimpleL1MuGMTCand& SimpleL1MuGMTCand::operator=(const SimpleL1MuGMTCand& cand) {
  if (this != &cand) {
    m_empty = cand.m_empty;
    m_phi = cand.m_phi;
    m_eta = cand.m_eta;
    m_pt = cand.m_pt;
    m_charge = cand.m_charge;
    m_quality = cand.m_quality;
    m_rank = cand.m_rank;
    m_smearedPt = cand.m_smearedPt;
  }
  return *this;
}

//
// Assignment operator for SimTrack's
//
SimpleL1MuGMTCand* SimpleL1MuGMTCand::operator=(const SimTrack* p) {
  m_empty = false;
  setEta(p->momentum().eta());
  setPhi(p->momentum().phi());
  setCharge(int(p->charge()));
  setPt(std::sqrt(p->momentum().perp2()));

  return this;
}

//
// Equal operator
//
bool SimpleL1MuGMTCand::operator==(const SimpleL1MuGMTCand& cand) const {
  if (m_empty != cand.m_empty)
    return false;
  if (m_phi != cand.m_phi)
    return false;
  if (m_eta != cand.m_eta)
    return false;
  if (m_pt != cand.m_pt)
    return false;
  if (m_charge != cand.m_charge)
    return false;
  if (m_quality != cand.m_quality)
    return false;
  if (m_rank != cand.m_rank)
    return false;
  return true;
}

//
// Unequal operator
//
bool SimpleL1MuGMTCand::operator!=(const SimpleL1MuGMTCand& cand) const {
  if (m_empty != cand.m_empty)
    return true;
  if (m_phi != cand.m_phi)
    return true;
  if (m_eta != cand.m_eta)
    return true;
  if (m_pt != cand.m_pt)
    return true;
  if (m_charge != cand.m_charge)
    return true;
  if (m_quality != cand.m_quality)
    return true;
  if (m_rank != cand.m_rank)
    return true;
  return false;
}

//
// print parameters of track candidate
//
void SimpleL1MuGMTCand::print() const {
  using namespace std;

  if (!empty()) {
    cout.setf(ios::showpoint);
    cout.setf(ios::right, ios::adjustfield);
    cout << setiosflags(ios::showpoint | ios::fixed) << "pt = " << setw(5) << setprecision(1) << ptValue() << " GeV  "
         << "charge = " << setw(2) << charge() << " "
         << "eta = " << setw(5) << setprecision(2) << etaValue() << "  "
         << "phi = " << setw(5) << setprecision(3) << phiValue() << " rad  "
         << "rank = " << setw(6) << rank() << endl;
  }
}

//
// output stream operator for track candidate
//
std::ostream& operator<<(std::ostream& s, const SimpleL1MuGMTCand& id) {
  using namespace std;

  if (!id.empty()) {
    s << setiosflags(ios::showpoint | ios::fixed) << "pt = " << setw(5) << setprecision(1) << id.ptValue() << " GeV  "
      << "charge = " << setw(2) << id.charge() << " "
      << "eta = " << setw(5) << setprecision(2) << id.etaValue() << "  "
      << "phi = " << setw(5) << setprecision(3) << id.phiValue() << " rad  ";
  }
  return s;
}

//static

// pt scale in GeV
// low edges of pt bins
const float SimpleL1MuGMTCand::ptScale[32] = {0.0,  0.0,  1.5,  2.0,  2.5,  3.0,  3.5,  4.0,   4.5,   5.0,  6.0,
                                              7.0,  8.0,  10.0, 12.0, 14.0, 16.0, 18.0, 20.0,  25.0,  30.0, 35.0,
                                              40.0, 45.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, 120.0, 140.0};

// eta scale
const float SimpleL1MuGMTCand::etaScale[63] = {
    -2.40, -2.35, -2.30, -2.25, -2.20, -2.15, -2.10, -2.05, -2.00, -1.95, -1.90, -1.85, -1.80, -1.75, -1.70, -1.60,
    -1.50, -1.40, -1.30, -1.20, -1.10, -1.00, -0.90, -0.80, -0.70, -0.60, -0.50, -0.40, -0.30, -0.20, -0.10, 0.00,
    0.10,  0.20,  0.30,  0.40,  0.50,  0.60,  0.70,  0.80,  0.90,  1.00,  1.10,  1.20,  1.30,  1.40,  1.50,  1.60,
    1.70,  1.75,  1.80,  1.85,  1.90,  1.95,  2.00,  2.05,  2.10,  2.15,  2.20,  2.25,  2.30,  2.35,  2.40};

// phi scale
const float SimpleL1MuGMTCand::phiScale[144] = {
    0.0000, 0.0436, 0.0873, 0.1309, 0.1745, 0.2182, 0.2618, 0.3054, 0.3491, 0.3927, 0.4363, 0.4800, 0.5236, 0.5672,
    0.6109, 0.6545, 0.6981, 0.7418, 0.7854, 0.8290, 0.8727, 0.9163, 0.9599, 1.0036, 1.0472, 1.0908, 1.1345, 1.1781,
    1.2217, 1.2654, 1.3090, 1.3526, 1.3963, 1.4399, 1.4835, 1.5272, 1.5708, 1.6144, 1.6581, 1.7017, 1.7453, 1.7890,
    1.8326, 1.8762, 1.9199, 1.9635, 2.0071, 2.0508, 2.0944, 2.1380, 2.1817, 2.2253, 2.2689, 2.3126, 2.3562, 2.3998,
    2.4435, 2.4871, 2.5307, 2.5744, 2.6180, 2.6616, 2.7053, 2.7489, 2.7925, 2.8362, 2.8798, 2.9234, 2.9671, 3.0107,
    3.0543, 3.0980, 3.1416, 3.1852, 3.2289, 3.2725, 3.3161, 3.3598, 3.4034, 3.4470, 3.4907, 3.5343, 3.5779, 3.6216,
    3.6652, 3.7088, 3.7525, 3.7961, 3.8397, 3.8834, 3.9270, 3.9706, 4.0143, 4.0579, 4.1015, 4.1452, 4.1888, 4.2324,
    4.2761, 4.3197, 4.3633, 4.4070, 4.4506, 4.4942, 4.5379, 4.5815, 4.6251, 4.6688, 4.7124, 4.7560, 4.7997, 4.8433,
    4.8869, 4.9306, 4.9742, 5.0178, 5.0615, 5.1051, 5.1487, 5.1924, 5.2360, 5.2796, 5.3233, 5.3669, 5.4105, 5.4542,
    5.4978, 5.5414, 5.5851, 5.6287, 5.6723, 5.7160, 5.7596, 5.8032, 5.8469, 5.8905, 5.9341, 5.9778, 6.0214, 6.0650,
    6.1087, 6.1523, 6.1959, 6.2396};