L1MuKBMTrack.cc

Go to the documentation of this file.

#include "DataFormats/L1TMuon/interface/L1MuKBMTrack.h"
 
L1MuKBMTrack::L1MuKBMTrack() : reco::LeafCandidate(-1, reco::LeafCandidate::PolarLorentzVector(0.1, 0.0, 0.0, 0.105)) {}
 
L1MuKBMTrack::~L1MuKBMTrack() {}
 
L1MuKBMTrack::L1MuKBMTrack(const L1MuKBMTCombinedStubRef& seed, int phi, int phiB)
    : reco::LeafCandidate(-1, reco::LeafCandidate::PolarLorentzVector(0.1, 0.0, 0.0, 0.105)),
      covariance_(std::vector<double>(6, 0.0)),
      curvVertex_(0),
      phiVertex_(0),
      dxy_(0),
      curvMuon_(0),
      phiMuon_(0),
      phiBMuon_(0),
      curv_(0),
      phi_(phi),
      phiB_(phiB),
      coarseEta_(0),
      approxChi2_(0),
      trackCompatibility_(0),
      hitPattern_(0),
      step_(seed->stNum()),
      sector_(seed->scNum()),
      wheel_(seed->whNum()),
      quality_(seed->quality()),
      hasFineEta_(false),
      bx_(seed->bxNum()),
      rank_(seed->bxNum()),
      ptUnconstrained_(0.0) {
  stubs_.push_back(seed);
  residuals_.push_back(0);
  residuals_.push_back(0);
  residuals_.push_back(0);
}
 
int L1MuKBMTrack::curvatureAtMuon() const { return curvMuon_; }
int L1MuKBMTrack::phiAtMuon() const { return phiMuon_; }
int L1MuKBMTrack::phiBAtMuon() const { return phiBMuon_; }
 
int L1MuKBMTrack::curvatureAtVertex() const { return curvVertex_; }
 
int L1MuKBMTrack::phiAtVertex() const { return phiVertex_; }
 
int L1MuKBMTrack::dxy() const { return dxy_; }
 
int L1MuKBMTrack::curvature() const { return curv_; }
 
int L1MuKBMTrack::positionAngle() const { return phi_; }
 
int L1MuKBMTrack::bendingAngle() const { return phiB_; }
 
int L1MuKBMTrack::coarseEta() const { return coarseEta_; }
 
int L1MuKBMTrack::approxChi2() const { return approxChi2_; }
int L1MuKBMTrack::trackCompatibility() const { return trackCompatibility_; }
 
int L1MuKBMTrack::hitPattern() const { return hitPattern_; }
 
int L1MuKBMTrack::step() const { return step_; }
int L1MuKBMTrack::sector() const { return sector_; }
int L1MuKBMTrack::wheel() const { return wheel_; }
 
int L1MuKBMTrack::quality() const { return quality_; }
 
float L1MuKBMTrack::ptUnconstrained() const { return ptUnconstrained_; }
 
int L1MuKBMTrack::fineEta() const { return fineEta_; }
 
bool L1MuKBMTrack::hasFineEta() const { return hasFineEta_; }
 
int L1MuKBMTrack::bx() const { return bx_; }
 
int L1MuKBMTrack::rank() const { return rank_; }
 
const L1MuKBMTCombinedStubRefVector& L1MuKBMTrack::stubs() const { return stubs_; }
 
int L1MuKBMTrack::residual(uint i) const { return residuals_[i]; }
 
void L1MuKBMTrack::setCoordinates(int step, int curv, int phi, int phiB) {
  step_ = step;
  curv_ = curv;
  phiB_ = phiB;
  phi_ = phi;
}
 
void L1MuKBMTrack::setCoordinatesAtVertex(int curv, int phi, int dxy) {
  curvVertex_ = curv;
  phiVertex_ = phi;
  dxy_ = dxy;
}
 
void L1MuKBMTrack::setCoordinatesAtMuon(int curv, int phi, int phiB) {
  curvMuon_ = curv;
  phiMuon_ = phi;
  phiBMuon_ = phiB;
}
 
void L1MuKBMTrack::setCoarseEta(int eta) { coarseEta_ = eta; }
 
void L1MuKBMTrack::setHitPattern(int pattern) { hitPattern_ = pattern; }
 
void L1MuKBMTrack::setApproxChi2(int chi) { approxChi2_ = chi; }
void L1MuKBMTrack::setTrackCompatibility(int chi) { trackCompatibility_ = chi; }
 
void L1MuKBMTrack::setPtEtaPhi(double pt, double eta, double phi) {
  PolarLorentzVector v(pt, eta, phi, 0.105);
  setP4(v);
}
void L1MuKBMTrack::setPtUnconstrained(float pt) { ptUnconstrained_ = pt; }
 
void L1MuKBMTrack::addStub(const L1MuKBMTCombinedStubRef& stub) {
  if (stub->quality() < quality_)
    quality_ = stub->quality();
  stubs_.push_back(stub);
}
 
void L1MuKBMTrack::setFineEta(int eta) {
  fineEta_ = eta;
  hasFineEta_ = true;
}
 
void L1MuKBMTrack::setRank(int rank) { rank_ = rank; }
 
void L1MuKBMTrack::setKalmanGain(
    unsigned int step, unsigned int K, float a1, float a2, float a3, float a4, float a5, float a6) {
  switch (step) {
    case 3:
      kalmanGain3_.push_back(K);
      kalmanGain3_.push_back(a1);
      kalmanGain3_.push_back(a2);
      kalmanGain3_.push_back(a3);
      kalmanGain3_.push_back(a4);
      kalmanGain3_.push_back(a5);
      kalmanGain3_.push_back(a6);
      break;
    case 2:
      kalmanGain2_.push_back(K);
      kalmanGain2_.push_back(a1);
      kalmanGain2_.push_back(a2);
      kalmanGain2_.push_back(a3);
      kalmanGain2_.push_back(a4);
      kalmanGain2_.push_back(a5);
      kalmanGain2_.push_back(a6);
      break;
    case 1:
      kalmanGain1_.push_back(K);
      kalmanGain1_.push_back(a1);
      kalmanGain1_.push_back(a2);
      kalmanGain1_.push_back(a3);
      kalmanGain1_.push_back(a4);
      kalmanGain1_.push_back(a5);
      kalmanGain1_.push_back(a6);
      break;
    case 0:
      kalmanGain0_.push_back(K);
      kalmanGain0_.push_back(a1);
      kalmanGain0_.push_back(a2);
      kalmanGain0_.push_back(a3);
      break;
 
    default:
      printf("Critical ERROR on setting the Klamn gain\n");
  }
}
 
void L1MuKBMTrack::setResidual(uint i, int val) { residuals_[i] = val; }
 
const std::vector<float>& L1MuKBMTrack::kalmanGain(unsigned int step) const {
  switch (step) {
    case 3:
      return kalmanGain3_;
    case 2:
      return kalmanGain2_;
    case 1:
      return kalmanGain1_;
    case 0:
      return kalmanGain0_;
  }
  return kalmanGain0_;
}
 
const std::vector<double>& L1MuKBMTrack::covariance() const { return covariance_; }
 
bool L1MuKBMTrack::overlapTrack(const L1MuKBMTrack& other) const {
  for (const auto& s1 : stubs_) {
    for (const auto& s2 : other.stubs()) {
      if (s1->scNum() == s2->scNum() && s1->whNum() == s2->whNum() && s1->stNum() == s2->stNum() &&
          s1->tag() == s2->tag())
        return true;
    }
  }
  return false;
}
 
void L1MuKBMTrack::setCovariance(const CovarianceMatrix& c) {
  covariance_[0] = c(0, 0);
  covariance_[1] = c(0, 1);
  covariance_[2] = c(1, 1);
  covariance_[3] = c(0, 2);
  covariance_[4] = c(1, 2);
  covariance_[5] = c(2, 2);
}