CSCComparatorDigiFitter.cc

Go to the documentation of this file.

#include "L1Trigger/CSCTriggerPrimitives/interface/CSCComparatorDigiFitter.h"
#include "L1Trigger/CSCCommonTrigger/interface/CSCConstants.h"
#include "DataFormats/Math/interface/normalizedPhi.h"
 
namespace {
  // CSC LCT patterns
  // the number quotes the distance to the center
 
  // pid=0: no pattern found
  const std::vector<std::vector<int> > pat0delta(CSCConstants::NUM_LAYERS);
 
  // pid=1: layer-OR trigger
  const std::vector<std::vector<int> > pat1delta{{-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5},
                                                 {-2, -1, 0, 1, 2},
                                                 {0},
                                                 {-2, -1, 0, 1, 2},
                                                 {-4, -3, -2, -1, 0, 1, 2, 3, 4},
                                                 {-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5}};
 
  // pid=2: right-bending (large)
  const std::vector<std::vector<int> > pat2delta{{3, 4, 5}, {1, 2}, {0}, {-2, -1, 0}, {-4, -3, -2}, {-5, -4, -3}};
 
  // pid=3: left-bending (large)
  const std::vector<std::vector<int> > pat3delta{{-5, -4, -3}, {-2, -1}, {0}, {0, 1, 2}, {2, 3, 4}, {3, 4, 5}};
 
  // pid=4: right-bending (medium)
  const std::vector<std::vector<int> > pat4delta{{2, 3, 4}, {1, 2}, {0}, {-2, -1}, {-4, -3, -2}, {-4, -3, -2}
 
  };
 
  // pid=5: left-bending (medium)
  const std::vector<std::vector<int> > pat5delta{{-4, -3, -2}, {-2, -1}, {0}, {1, 2}, {2, 3, 4}, {2, 3, 4}
 
  };
 
  // pid=6: right-bending (medium)
  const std::vector<std::vector<int> > pat6delta{{1, 2, 3}, {0, 1}, {0}, {-1, 0}, {-2, -1}, {-3, -2, -1}};
 
  // pid=7: left-bending (medium)
  const std::vector<std::vector<int> > pat7delta{{-3, -2, -1}, {-1, 0}, {0}, {0, 1}, {1, 2}, {1, 2, 3}};
 
  // pid=8: right-bending (small)
  const std::vector<std::vector<int> > pat8delta{{0, 1, 2}, {0, 1}, {0}, {-1, 0}, {-2, -1, 0}, {-2, -1, 0}};
 
  // pid=9: left-bending (small)
  const std::vector<std::vector<int> > pat9delta{{-2, -1, 0}, {-1, 0}, {0}, {0, 1}, {0, 1, 2}, {0, 1, 2}};
 
  // pid=A: straight-through
  const std::vector<std::vector<int> > patAdelta{{-1, 0, 1}, {0}, {0}, {0}, {-1, 0, 1}, {-1, 0, 1}};
 
  const std::vector<std::vector<std::vector<int> > > patIndexToPatternDelta{pat0delta,
                                                                            pat1delta,
                                                                            pat2delta,
                                                                            pat3delta,
                                                                            pat4delta,
                                                                            pat5delta,
                                                                            pat6delta,
                                                                            pat7delta,
                                                                            pat8delta,
                                                                            pat9delta,
                                                                            patAdelta};
}  // namespace
 
void CSCComparatorDigiFitter::matchingComparatorDigisLCT(const CSCDetId& ch_id,
                                                         const CSCCorrelatedLCTDigi& stub,
                                                         const CSCComparatorDigiCollection& hCSCComparators) {
  // fetch the CSC comparator digis in this chamber
  for (int iLayer = 1; iLayer <= CSCConstants::NUM_LAYERS; ++iLayer) {
    const CSCDetId layerId(ch_id.endcap(), ch_id.station(), ch_id.ring(), ch_id.chamber(), iLayer);
 
    // get the digis per layer
    const auto& compRange = hCSCComparators.get(layerId);
    CSCComparatorDigiContainer compDigis;
 
    for (auto compDigiItr = compRange.first; compDigiItr != compRange.second; compDigiItr++) {
      const auto& compDigi = *compDigiItr;
 
      //if (stub.getTimeBin() < 4 or stub.getTimeBin() > 8) continue;
      const int stubHalfStrip(compDigi.getHalfStrip());
 
      // these comparator digis never fit the pattern anyway!
      if (std::abs(stubHalfStrip - stub.getStrip()) > 5)
        continue;
 
      // check if this comparator digi fits the pattern
      if (comparatorInLCTPattern(stub.getStrip(), stub.getPattern(), iLayer, stubHalfStrip)) {
        compDigis.push_back(compDigi);
      }
    }
    compDigisIds_.emplace_back(layerId, compDigis);
  }
}
 
void CSCComparatorDigiFitter::getComparatorDigiCoordinates(const CSCDetId& ch_id, const CSCCorrelatedLCTDigi& stub) {
  const auto& cscChamber = cscGeometry_->chamber(ch_id);
 
  // get the z and phi positions of the comparator digis
  float radius_ = 0.0;
 
  // loop on all matching digis
  for (const auto& p : compDigisIds_) {
    const auto& detId = p.first;
 
    float phi_tmp = 0.0;
    float radius_tmp = 0.0;
    float z_tmp = 0.0;
 
    // ignore layers with no digis
    if (p.second.empty())
      continue;
 
    // loop on all matching digis in this layer
    for (const auto& hit : p.second) {
      const float fractional_strip = hit.getFractionalStrip();
      const auto& layer_geo = cscChamber->layer(detId.layer())->geometry();
      const float wire = layer_geo->middleWireOfGroup(stub.getKeyWG() + 1);
 
      // get the phi of each comparator digi
      const LocalPoint& csc_intersect = layer_geo->intersectionOfStripAndWire(fractional_strip, wire);
      const GlobalPoint& csc_gp = cscGeometry_->idToDet(detId)->surface().toGlobal(csc_intersect);
      const float gpphi = csc_gp.phi();
 
      // normalize phi values according to first one
      if (!phis_.empty() and gpphi > 0 and phis_[0] < 0 and (gpphi - phis_[0]) > M_PI)
        phi_tmp += (gpphi - 2 * M_PI);
      else if (!phis_.empty() and gpphi < 0 and phis_[0] > 0 and (gpphi - phis_[0]) < -M_PI)
        phi_tmp += (gpphi + 2 * M_PI);
      else
        phi_tmp += (csc_gp.phi());
 
      z_tmp = csc_gp.z();
      radius_tmp += csc_gp.perp();
    }
 
    //in case there are more than one comparator digis in one layer
    radius_tmp = radius_tmp / (p.second).size();
    radius_ += radius_tmp;
 
    zs_.push_back(z_tmp);
    ezs_.push_back(0);
 
    phi_tmp = phi_tmp / (p.second).size();
    phis_.push_back(phi_tmp);
    // assume that the charge is flat distributed across the half-strip
    // this is only approximately valid, but good enough for now
    ephis_.push_back(cscHalfStripWidth(detId) / sqrt(12));
  }
}
 
void CSCComparatorDigiFitter::fit(const CSCDetId& ch_id,
                                  const CSCCorrelatedLCTDigi& stub,
                                  const CSCComparatorDigiCollection& hCSCComparators,
                                  std::vector<float>& fit_phi_layers,
                                  std::vector<float>& fit_z_layers,
                                  float& keyRadius) {
  // clear fit results
  fit_phi_layers.clear();
  fit_z_layers.clear();
  keyRadius = 0;
 
  // first, match the comparator digis to the LCT
  matchingComparatorDigisLCT(ch_id, stub, hCSCComparators);
 
  // second, get the coordinates
  getComparatorDigiCoordinates(ch_id, stub);
 
  // get radius of the stub from key layer
  const CSCDetId key_id(ch_id.endcap(), ch_id.station(), ch_id.ring(), ch_id.chamber(), CSCConstants::KEY_CLCT_LAYER);
  const float fractional_strip = stub.getFractionalStrip();
 
  const auto& cscChamber = cscGeometry_->chamber(ch_id);
  const auto& layer_geo = cscChamber->layer(CSCConstants::KEY_CLCT_LAYER)->geometry();
 
  // LCT::getKeyWG() also starts from 0
  const float wire = layer_geo->middleWireOfGroup(stub.getKeyWG() + 1);
  const LocalPoint& csc_intersect = layer_geo->intersectionOfStripAndWire(fractional_strip, wire);
  const GlobalPoint& csc_gp = cscGeometry_->idToDet(key_id)->surface().toGlobal(csc_intersect);
 
  // get radius from key layer
  if (useKeyRadius_)
    radius_ = radius_ / phis_.size();
  else
    radius_ = csc_gp.perp();
 
  float alpha = -99., beta = 0.;
  // do a fit to the comparator digis
  calculateSlopeIntercept(alpha, beta);
  if (phis_.size() <= 2 or std::abs(alpha) >= 99) {
    alpha = csc_gp.phi();
    beta = 0.0;
  }
 
  // determine the pitch of the chamber
  // option to discretize the pitch
  float stripPhiPitch = layer_geo->stripPhiPitch();
  if (nStripBits_)
    stripPhiPitch = stripPhiPitch / nStripBits_;
 
  // get the fit results
  // option to discretize the fitted phi value
  keyRadius = radius_;
 
  for (int i = 0; i < CSCConstants::NUM_LAYERS; i++) {
    const float fit_z = cscChamber->layer(i + 1)->centerOfStrip(20).z();
    const float fit_phi = normalizedPhi(alpha + beta * fit_z);
    fit_z_layers.push_back(fit_z);
    fit_phi_layers.push_back(fit_phi);
    if (nStripBits_)
      fit_phi_layers.push_back((std::floor(fit_phi / stripPhiPitch) + 0.5) * stripPhiPitch);
  }
}
 
void CSCComparatorDigiFitter::calculateSlopeIntercept(float& alpha, float& beta) {
  // if there are at least 3 hits in the chamber, do a linear fit to the
  // comparator digi positions with the chi2 method
  if (phis_.size() >= 3) {
    float Sxx = 0, Sxy = 0, Sx = 0, Sy = 0, S = 0;
    for (unsigned i = 0; i < phis_.size(); ++i) {
      float sigma2_inv = 1. / ephis_[i] * ephis_[i];
      Sxx += zs_[i] * zs_[i] * sigma2_inv;
      Sxy += zs_[i] * phis_[i] * sigma2_inv;
      Sx += zs_[i] * zs_[i] * sigma2_inv;
      Sy += phis_[i] * sigma2_inv;
      S += sigma2_inv;
    }
    float delta = S * Sxx - Sx * Sx;
    alpha = (Sxx * Sy - Sx * Sxy) / delta;
    beta = (S * Sxy - Sx * Sy) / delta;
  } else {
    alpha = -99;
    beta = 0.0;
  }
}
 
float CSCComparatorDigiFitter::cscHalfStripWidth(const CSCDetId& id) const {
  // what is the chamber type?
  int index = id.iChamberType() - 1;
 
  // calculate the half strip width of this chamber
  return degrees_[index] * M_PI / 180. / (2. * strips_[index]);
}
 
bool CSCComparatorDigiFitter::comparatorInLCTPattern(int keyStrip, int pattern, int layer, int halfStrip) const {
  // get the (sub)pattern
  const std::vector<int>& subpat = patIndexToPatternDelta[pattern].at(layer - 1);
 
  // due to comparator digi time extension in the CLCT processor we need to
  // search a bigger region around the key HS. +/-1, 0 should be sufficient
  const int halfStripDelta = halfStrip - keyStrip;
  return (std::find(subpat.begin(), subpat.end(), halfStripDelta + 1) != subpat.end() or
          std::find(subpat.begin(), subpat.end(), halfStripDelta) != subpat.end() or
          std::find(subpat.begin(), subpat.end(), halfStripDelta - 1) != subpat.end());
}