CSCGEMMatcher Class Reference

#include <CSCGEMMatcher.h>

Public Types
typedef std::vector < GEMInternalCluster >	GEMInternalClusters

Public Member Functions
void	bestClusterBXLoc (const CSCALCTDigi &alct, const GEMInternalClusters &clusters, GEMInternalCluster &best) const
void	bestClusterBXLoc (const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, GEMInternalCluster &best) const
void	bestClusterBXLoc (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, GEMInternalCluster &best) const
unsigned	calculateGEMCSCBending (const CSCCLCTDigi &clct, const GEMInternalCluster &cluster) const
	CSCGEMMatcher (int endcap, unsigned station, unsigned chamber, const edm::ParameterSet &tmbParams, const edm::ParameterSet &luts)
bool	matchedClusterLocES (const CSCCLCTDigi &clct, const GEMInternalCluster &cluster) const
bool	matchedClusterLocHS (const CSCCLCTDigi &clct, const GEMInternalCluster &cluster) const
void	matchingClustersBX (const CSCALCTDigi &alct, const GEMInternalClusters &clusters, GEMInternalClusters &selected) const
void	matchingClustersBX (const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, GEMInternalClusters &selected) const
void	matchingClustersBX (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, GEMInternalClusters &selected) const
void	matchingClustersBXLoc (const CSCALCTDigi &alct, const GEMInternalClusters &clusters, GEMInternalClusters &selected) const
void	matchingClustersBXLoc (const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, GEMInternalClusters &selected) const
void	matchingClustersBXLoc (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, GEMInternalClusters &selected) const
void	matchingClustersLoc (const CSCALCTDigi &alct, const GEMInternalClusters &clusters, GEMInternalClusters &selected) const
void	matchingClustersLoc (const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, GEMInternalClusters &selected) const
void	matchingClustersLoc (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, GEMInternalClusters &selected) const
void	setESLookupTables (const CSCL1TPLookupTableME11ILT *conf)
void	setESLookupTables (const CSCL1TPLookupTableME21ILT *conf)

Private Member Functions
int	CSCGEMSlopeCorrector (const bool isL1orCopad, const int cscSlope) const
uint16_t	mitigatedSlopeByConsistency (const CSCCLCTDigi &clct) const

Private Attributes
bool	assign_gem_csc_bending_
unsigned	chamber_
unsigned	endcap_
bool	isEven_
const CSCL1TPLookupTableME11ILT *	lookupTableME11ILT_
const CSCL1TPLookupTableME21ILT *	lookupTableME21ILT_
bool	matchWithHS_
unsigned	maxDeltaBXALCTGEM_
unsigned	maxDeltaBXCLCTGEM_
unsigned	maxDeltaHsEven_
unsigned	maxDeltaHsEvenME1a_
unsigned	maxDeltaHsOdd_
unsigned	maxDeltaHsOddME1a_
bool	mitigateSlopeByCosi_
unsigned	ring_
unsigned	station_

Detailed Description

Helper class to check if an ALCT or CLCT matches with a GEMInternalCluster

Author

Sven Dildick (Rice University)

Definition at line 24 of file CSCGEMMatcher.h.

Member Typedef Documentation

typedef std::vector<GEMInternalCluster> CSCGEMMatcher::GEMInternalClusters

Definition at line 26 of file CSCGEMMatcher.h.

Constructor & Destructor Documentation

CSCGEMMatcher::CSCGEMMatcher	(	int	endcap,
		unsigned	station,
		unsigned	chamber,
		const edm::ParameterSet &	tmbParams,
		const edm::ParameterSet &	luts
	)

Definition at line 11 of file CSCGEMMatcher.cc.

References assign_gem_csc_bending_, chamber_, edm::ParameterSet::getParameter(), isEven_, matchWithHS_, maxDeltaBXALCTGEM_, maxDeltaBXCLCTGEM_, maxDeltaHsEven_, maxDeltaHsEvenME1a_, maxDeltaHsOdd_, maxDeltaHsOddME1a_, mitigateSlopeByCosi_, and station_.

    : endcap_(endcap), station_(station), chamber_(chamber) {
  isEven_ = (chamber_ % 2 == 0);

  maxDeltaBXALCTGEM_ = tmbParams.getParameter<unsigned>("maxDeltaBXALCTGEM");
  maxDeltaBXCLCTGEM_ = tmbParams.getParameter<unsigned>("maxDeltaBXCLCTGEM");

  matchWithHS_ = tmbParams.getParameter<bool>("matchWithHS");

  maxDeltaHsEven_ = tmbParams.getParameter<unsigned>("maxDeltaHsEven");
  maxDeltaHsOdd_ = tmbParams.getParameter<unsigned>("maxDeltaHsOdd");

  if (station_ == 1) {
    maxDeltaHsEvenME1a_ = tmbParams.getParameter<unsigned>("maxDeltaHsEvenME1a");
    maxDeltaHsOddME1a_ = tmbParams.getParameter<unsigned>("maxDeltaHsOddME1a");
  }

  mitigateSlopeByCosi_ = tmbParams.getParameter<bool>("mitigateSlopeByCosi");
  assign_gem_csc_bending_ = tmbParams.getParameter<bool>("assignGEMCSCBending");
}

Member Function Documentation

void CSCGEMMatcher::bestClusterBXLoc	(	const CSCALCTDigi &	alct,
		const GEMInternalClusters &	clusters,
		GEMInternalCluster &	best
	)		const

Definition at line 324 of file CSCGEMMatcher.cc.

References CSCALCTDigi::isValid(), matchingClustersBXLoc(), and or.

                                                                     {
  if (!alct.isValid() or clusters.empty())
    return;

  GEMInternalClusters clustersBXLoc;
  matchingClustersBXLoc(alct, clusters, clustersBXLoc);

  // simply pick the first matching one
  if (!clustersBXLoc.empty())
    best = clustersBXLoc[0];
}

void CSCGEMMatcher::bestClusterBXLoc	(	const CSCCLCTDigi &	clct,
		const GEMInternalClusters &	clusters,
		GEMInternalCluster &	best
	)		const

Definition at line 338 of file CSCGEMMatcher.cc.

References CSCCLCTDigi::isValid(), matchingClustersBXLoc(), and or.

                                                                     {
  if (!clct.isValid() or clusters.empty())
    return;

  // match by BX
  GEMInternalClusters clustersBXLoc;
  matchingClustersBXLoc(clct, clusters, clustersBXLoc);

  // FIXME - for now: pick the first matching one
  if (!clustersBXLoc.empty())
    best = clustersBXLoc[0];
}

void CSCGEMMatcher::bestClusterBXLoc	(	const CSCALCTDigi &	alct,
		const CSCCLCTDigi &	clct,
		const GEMInternalClusters &	clusters,
		GEMInternalCluster &	best
	)		const

Definition at line 353 of file CSCGEMMatcher.cc.

References matchingClustersBXLoc().

                                                                     {
  // match by BX
  GEMInternalClusters clustersBXLoc;
  matchingClustersBXLoc(alct, clct, clusters, clustersBXLoc);

  // FIXME - for now: pick the first matching one
  if (!clustersBXLoc.empty())
    best = clustersBXLoc[0];
}

unsigned CSCGEMMatcher::calculateGEMCSCBending	(	const CSCCLCTDigi &	clct,
		const GEMInternalCluster &	cluster
	)		const

Definition at line 37 of file CSCGEMMatcher.cc.

References funct::abs(), change_name::diff, CSCL1TPLookupTableME11ILT::es_diff_slope_L1_ME1a_even(), CSCL1TPLookupTableME11ILT::es_diff_slope_L1_ME1a_odd(), CSCL1TPLookupTableME11ILT::es_diff_slope_L1_ME1b_even(), CSCL1TPLookupTableME11ILT::es_diff_slope_L1_ME1b_odd(), CSCL1TPLookupTableME21ILT::es_diff_slope_L1_ME21_even(), CSCL1TPLookupTableME21ILT::es_diff_slope_L1_ME21_odd(), CSCL1TPLookupTableME11ILT::es_diff_slope_L2_ME1a_even(), CSCL1TPLookupTableME11ILT::es_diff_slope_L2_ME1a_odd(), CSCL1TPLookupTableME11ILT::es_diff_slope_L2_ME1b_even(), CSCL1TPLookupTableME11ILT::es_diff_slope_L2_ME1b_odd(), CSCL1TPLookupTableME21ILT::es_diff_slope_L2_ME21_even(), CSCL1TPLookupTableME21ILT::es_diff_slope_L2_ME21_odd(), GEMInternalCluster::getKeyStrip(), CSCCLCTDigi::getKeyStrip(), GEMInternalCluster::id(), isEven_, GEMDetId::layer(), lookupTableME11ILT_, lookupTableME21ILT_, CSCConstants::MAX_HALF_STRIP_ME1B, slope, and station_.

                                                                                                               {
  // difference in 1/8-strip number
  const unsigned diff = std::abs(int(clct.getKeyStrip(8)) - int(cluster.getKeyStrip(8)));

  unsigned slope = 0;

  // need LUT to convert differences in 1/8-strips between GEM and CSC to slope
  if (station_ == 2) {
    if (isEven_) {
      if (cluster.id().layer() == 1)
        slope = lookupTableME21ILT_->es_diff_slope_L1_ME21_even(diff);
      else
        slope = lookupTableME21ILT_->es_diff_slope_L2_ME21_even(diff);
    } else {
      if (cluster.id().layer() == 1)
        slope = lookupTableME21ILT_->es_diff_slope_L1_ME21_odd(diff);
      else
        slope = lookupTableME21ILT_->es_diff_slope_L2_ME21_odd(diff);
    }
  } else if (station_ == 1) {
    if (clct.getKeyStrip() > CSCConstants::MAX_HALF_STRIP_ME1B) {  //is in ME1a
      if (isEven_) {
        if (cluster.id().layer() == 1)
          slope = lookupTableME11ILT_->es_diff_slope_L1_ME1a_even(diff);
        else
          slope = lookupTableME11ILT_->es_diff_slope_L2_ME1a_even(diff);
      } else {
        if (cluster.id().layer() == 1)
          slope = lookupTableME11ILT_->es_diff_slope_L1_ME1a_odd(diff);
        else
          slope = lookupTableME11ILT_->es_diff_slope_L2_ME1a_odd(diff);
      }
    } else {
      if (isEven_) {
        if (cluster.id().layer() == 1)
          slope = lookupTableME11ILT_->es_diff_slope_L1_ME1b_even(diff);
        else
          slope = lookupTableME11ILT_->es_diff_slope_L2_ME1b_even(diff);
      } else {
        if (cluster.id().layer() == 1)
          slope = lookupTableME11ILT_->es_diff_slope_L1_ME1b_odd(diff);
        else
          slope = lookupTableME11ILT_->es_diff_slope_L2_ME1b_odd(diff);
      }
    }
  }

  return slope;
}

int CSCGEMMatcher::CSCGEMSlopeCorrector ( const bool  isL1orCopad, const int  cscSlope  ) const

private

Definition at line 430 of file CSCGEMMatcher.cc.

References funct::abs(), chamber_, CSCL1TPLookupTableME11ILT::CSC_slope_corr_L1_ME11_even(), CSCL1TPLookupTableME11ILT::CSC_slope_corr_L1_ME11_odd(), CSCL1TPLookupTableME11ILT::CSC_slope_corr_L2_ME11_even(), CSCL1TPLookupTableME11ILT::CSC_slope_corr_L2_ME11_odd(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_corr_L1_ME11_even(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_corr_L1_ME11_odd(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_corr_L2_ME11_even(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_corr_L2_ME11_odd(), endcap_, lookupTableME11ILT_, and mitigateSlopeByCosi_.

Referenced by matchedClusterLocES().

                                                                                  {
  int SlopeShift = 0;
  int SlopeSign = cscSlope / std::abs(cscSlope);
  //account for slope mitigation by cosi, if opted-in
  if (mitigateSlopeByCosi_) {
    //determine cosi-based slope correction
    if (chamber_ % 2 == 0) {
      if (isL1orCoincidence)
        SlopeShift = lookupTableME11ILT_->CSC_slope_cosi_corr_L1_ME11_even(std::abs(cscSlope));
      else
        SlopeShift = lookupTableME11ILT_->CSC_slope_cosi_corr_L2_ME11_even(std::abs(cscSlope));
    } else {
      if (isL1orCoincidence)
        SlopeShift = lookupTableME11ILT_->CSC_slope_cosi_corr_L1_ME11_odd(std::abs(cscSlope));
      else
        SlopeShift = lookupTableME11ILT_->CSC_slope_cosi_corr_L2_ME11_odd(std::abs(cscSlope));
    }
  } else {
    //determine shift by slope correction
    if (chamber_ % 2 == 0) {
      if (isL1orCoincidence)
        SlopeShift = lookupTableME11ILT_->CSC_slope_corr_L1_ME11_even(std::abs(cscSlope));
      else
        SlopeShift = lookupTableME11ILT_->CSC_slope_corr_L2_ME11_even(std::abs(cscSlope));
    } else {
      if (isL1orCoincidence)
        SlopeShift = lookupTableME11ILT_->CSC_slope_corr_L1_ME11_odd(std::abs(cscSlope));
      else
        SlopeShift = lookupTableME11ILT_->CSC_slope_corr_L2_ME11_odd(std::abs(cscSlope));
    }
  }
  return std::round(SlopeShift * SlopeSign * endcap_);
}

bool CSCGEMMatcher::matchedClusterLocES	(	const CSCCLCTDigi &	clct,
		const GEMInternalCluster &	cluster
	)		const

Definition at line 211 of file CSCGEMMatcher.cc.

References funct::abs(), chamber_, CSCGEMSlopeCorrector(), CSCCLCTDigi::getBend(), CSCCLCTDigi::getKeyStrip(), CSCCLCTDigi::getSlope(), GEMInternalCluster::id(), GEMInternalCluster::isCoincidence(), GEMDetId::layer(), GEMInternalCluster::layer1_middle_es(), GEMInternalCluster::layer1_middle_es_me1a(), GEMInternalCluster::layer2_middle_es(), GEMInternalCluster::layer2_middle_es_me1a(), CSCConstants::MAX_HALF_STRIP_ME1B, mitigatedSlopeByConsistency(), mitigateSlopeByCosi_, or, funct::pow(), station_, and svgfig::window().

Referenced by matchingClustersLoc().

                                                                                                   {
  // key 1/8-strip
  int key_es = -1;

  //modification of DeltaStrip by CLCT slope
  int SlopeShift = 0;
  uint16_t baseSlope = 0;
  if (mitigateSlopeByCosi_)
    baseSlope = mitigatedSlopeByConsistency(clct);
  else
    baseSlope = clct.getSlope();
  int clctSlope = pow(-1, clct.getBend()) * baseSlope;

  // for coincidences or single clusters in L1
  if (cl.isCoincidence() or cl.id().layer() == 1) {
    key_es = cl.layer1_middle_es();
    if (station_ == 1 and clct.getKeyStrip() > CSCConstants::MAX_HALF_STRIP_ME1B)
      key_es = cl.layer1_middle_es_me1a();

    //set SlopeShift for L1 or Copad case
    SlopeShift =
        CSCGEMSlopeCorrector(true, clctSlope);  // fixed to facing detectors, must be determined at motherboard level
  }

  // for single clusters in L2
  else if (cl.id().layer() == 2) {
    key_es = cl.layer2_middle_es();
    if (station_ == 1 and clct.getKeyStrip() > CSCConstants::MAX_HALF_STRIP_ME1B)
      key_es = cl.layer2_middle_es_me1a();

    //set SlopeShift for L2 case
    SlopeShift =
        CSCGEMSlopeCorrector(false, clctSlope);  // fixed to facing detectors, must be determined at motherboard level

  }

  else
    edm::LogWarning("CSCGEMMatcher") << "cluster.id().layer =" << cl.id().layer() << " out of acceptable range 1-2!";

  // matching by 1/8-strip
  // determine matching window by chamber, assuming facing chambers only are processed
  int window = chamber_ % 2 == 0 ? 20 : 40;

  return std::abs(clct.getKeyStrip(8) - key_es + SlopeShift) < window;
}

bool CSCGEMMatcher::matchedClusterLocHS	(	const CSCCLCTDigi &	clct,
		const GEMInternalCluster &	cluster
	)		const

Definition at line 174 of file CSCGEMMatcher.cc.

References funct::abs(), GEMInternalCluster::getKeyStrip(), CSCCLCTDigi::getKeyStrip(), GEMInternalCluster::getKeyStripME1a(), isEven_, CSCConstants::MAX_HALF_STRIP_ME1B, maxDeltaHsEven_, maxDeltaHsEvenME1a_, maxDeltaHsOdd_, maxDeltaHsOddME1a_, and station_.

Referenced by matchingClustersLoc().

                                                                                                        {
  const bool isME1a(station_ == 1 and clct.getKeyStrip() > CSCConstants::MAX_HALF_STRIP_ME1B);

  unsigned halfStripDiff = std::abs(int(clct.getKeyStrip(2)) - int(cluster.getKeyStrip(2)));
  if (isME1a) {
    halfStripDiff = std::abs(int(clct.getKeyStrip(2)) - int(cluster.getKeyStripME1a(2)));
  }

  // 98% acceptance cuts
  unsigned halfStripCut;
  if (isEven_) {
    if (isME1a)
      halfStripCut = maxDeltaHsEvenME1a_;
    else
      halfStripCut = maxDeltaHsEven_;
  } else {
    if (isME1a)
      halfStripCut = maxDeltaHsOddME1a_;
    else
      halfStripCut = maxDeltaHsOdd_;
  }
  // 10 degree chamber is ~0.18 radian wide
  // 98% acceptance for clusters in odd/even chambers for muons with 5 GeV
  // {5, 0.02123785, 0.00928431}
  // This corresponds to 0.12 and 0.052 fractions of the chamber
  // or 16 and 7 half-strips

  // 20 degree chamber is ~0.35 radian wide
  // 98% acceptance for clusters in odd/even chambers for muons with 5 GeV
  // {5, 0.01095490, 0.00631625},
  // This corresponds to 0.031 and 0.018 fractions of the chamber
  // or 5 and 3 half-strips

  return halfStripDiff <= halfStripCut;
}

void CSCGEMMatcher::matchingClustersBX	(	const CSCALCTDigi &	alct,
		const GEMInternalClusters &	clusters,
		GEMInternalClusters &	selected
	)		const

Definition at line 88 of file CSCGEMMatcher.cc.

References funct::abs(), haddnano::cl, change_name::diff, CSCALCTDigi::getBX(), CSCALCTDigi::isValid(), maxDeltaBXALCTGEM_, and or.

Referenced by matchingClustersBX(), and matchingClustersBXLoc().

                                                                          {
  if (!alct.isValid() or clusters.empty())
    return;

  // select clusters matched in time
  for (const auto& cl : clusters) {
    const unsigned diff = std::abs(int(alct.getBX()) - cl.bx());
    if (diff <= maxDeltaBXALCTGEM_)
      output.push_back(cl);
  }
}

void CSCGEMMatcher::matchingClustersBX	(	const CSCCLCTDigi &	clct,
		const GEMInternalClusters &	clusters,
		GEMInternalClusters &	selected
	)		const

Definition at line 103 of file CSCGEMMatcher.cc.

References funct::abs(), haddnano::cl, change_name::diff, CSCCLCTDigi::getBX(), CSCCLCTDigi::isValid(), maxDeltaBXCLCTGEM_, and or.

                                                                          {
  if (!clct.isValid() or clusters.empty())
    return;

  // select clusters matched in time
  for (const auto& cl : clusters) {
    const unsigned diff = std::abs(int(clct.getBX()) - cl.bx());
    if (diff <= maxDeltaBXCLCTGEM_)
      output.push_back(cl);
  }
}

void CSCGEMMatcher::matchingClustersBX	(	const CSCALCTDigi &	alct,
		const CSCCLCTDigi &	clct,
		const GEMInternalClusters &	clusters,
		GEMInternalClusters &	selected
	)		const

Definition at line 118 of file CSCGEMMatcher.cc.

References CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), matchingClustersBX(), or, AlCaHLTBitMon_ParallelJobs::p, and submitPVResolutionJobs::q.

                                                                          {
  // both need to be valid
  if (!alct.isValid() or !clct.isValid() or clusters.empty())
    return;

  // get the single matches
  GEMInternalClusters alctClusters, clctClusters;
  matchingClustersBX(alct, clusters, alctClusters);
  matchingClustersBX(clct, clusters, clctClusters);

  // get the intersection
  for (const auto& p : alctClusters) {
    for (const auto& q : clctClusters) {
      if (p == q) {
        output.push_back(p);
      }
    }
  }
}

void CSCGEMMatcher::matchingClustersBXLoc	(	const CSCALCTDigi &	alct,
		const GEMInternalClusters &	clusters,
		GEMInternalClusters &	selected
	)		const

Definition at line 280 of file CSCGEMMatcher.cc.

References CSCALCTDigi::isValid(), matchingClustersBX(), matchingClustersLoc(), and or.

Referenced by bestClusterBXLoc().

                                                                             {
  if (!alct.isValid() or clusters.empty())
    return;

  // match by BX
  GEMInternalClusters clustersBX;
  matchingClustersBX(alct, clusters, clustersBX);

  // match spatially
  matchingClustersLoc(alct, clustersBX, output);
}

void CSCGEMMatcher::matchingClustersBXLoc	(	const CSCCLCTDigi &	clct,
		const GEMInternalClusters &	clusters,
		GEMInternalClusters &	selected
	)		const

Definition at line 294 of file CSCGEMMatcher.cc.

References CSCCLCTDigi::isValid(), matchingClustersBX(), matchingClustersLoc(), and or.

                                                                             {
  if (!clct.isValid() or clusters.empty())
    return;

  // match by BX
  GEMInternalClusters clustersBX;
  matchingClustersBX(clct, clusters, clustersBX);

  // match spatially
  matchingClustersLoc(clct, clustersBX, output);
}

void CSCGEMMatcher::matchingClustersBXLoc	(	const CSCALCTDigi &	alct,
		const CSCCLCTDigi &	clct,
		const GEMInternalClusters &	clusters,
		GEMInternalClusters &	selected
	)		const

Definition at line 308 of file CSCGEMMatcher.cc.

References CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), matchingClustersBX(), matchingClustersLoc(), and or.

                                                                               {
  // both need to be valid
  if (!alct.isValid() or !clct.isValid() or clusters.empty())
    return;

  // match by BX
  GEMInternalClusters clustersBX;
  matchingClustersBX(alct, clct, clusters, clustersBX);

  // match spatially
  matchingClustersLoc(alct, clct, clustersBX, selected);
}

void CSCGEMMatcher::matchingClustersLoc	(	const CSCALCTDigi &	alct,
		const GEMInternalClusters &	clusters,
		GEMInternalClusters &	selected
	)		const

Definition at line 141 of file CSCGEMMatcher.cc.

References haddnano::cl, CSCALCTDigi::getKeyWG(), CSCALCTDigi::isValid(), or, and station_.

Referenced by matchingClustersBXLoc(), and matchingClustersLoc().

                                                                           {
  if (!alct.isValid() or clusters.empty())
    return;

  // select clusters matched in wiregroup
  for (const auto& cl : clusters) {
    // for now add 10 wiregroups to make sure the matching can be done
    // this should be quite generous
    unsigned deltaWG(station_ == 1 ? 10 : 20);
    if (cl.min_wg() <= alct.getKeyWG() and alct.getKeyWG() <= cl.max_wg() + deltaWG) {
      output.push_back(cl);
    }
  }
}

void CSCGEMMatcher::matchingClustersLoc	(	const CSCCLCTDigi &	clct,
		const GEMInternalClusters &	clusters,
		GEMInternalClusters &	selected
	)		const

Definition at line 158 of file CSCGEMMatcher.cc.

References haddnano::cl, trackerHitRTTI::isMatched(), CSCCLCTDigi::isValid(), matchedClusterLocES(), matchedClusterLocHS(), matchWithHS_, and or.

                                                                           {
  if (!clct.isValid() or clusters.empty())
    return;

  // select clusters matched by 1/2-strip or 1/8-strip
  for (const auto& cl : clusters) {
    const bool isMatched(matchWithHS_ ? matchedClusterLocHS(clct, cl) : matchedClusterLocES(clct, cl));
    if (isMatched) {
      output.push_back(cl);
    }
  }
}

void CSCGEMMatcher::matchingClustersLoc	(	const CSCALCTDigi &	alct,
		const CSCCLCTDigi &	clct,
		const GEMInternalClusters &	clusters,
		GEMInternalClusters &	selected
	)		const

Definition at line 257 of file CSCGEMMatcher.cc.

References CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), matchingClustersLoc(), or, AlCaHLTBitMon_ParallelJobs::p, and submitPVResolutionJobs::q.

                                                                           {
  // both need to be valid
  if (!alct.isValid() or !clct.isValid() or clusters.empty())
    return;

  // get the single matches
  GEMInternalClusters alctClusters, clctClusters;
  matchingClustersLoc(alct, clusters, alctClusters);
  matchingClustersLoc(clct, clusters, clctClusters);

  // get the intersection
  for (const auto& p : alctClusters) {
    for (const auto& q : clctClusters) {
      if (p == q) {
        output.push_back(p);
      }
    }
  }
}

uint16_t CSCGEMMatcher::mitigatedSlopeByConsistency ( const CSCCLCTDigi &  clct ) const

private

Definition at line 366 of file CSCGEMMatcher.cc.

References funct::abs(), reco::ceil(), chamber_, CSCL1TPLookupTableME11ILT::CSC_slope_cosi_2to1_L1_ME11_even(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_2to1_L1_ME11_odd(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_3to1_L1_ME11_even(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_3to1_L1_ME11_odd(), CSCCLCTDigi::getHits(), CSCCLCTDigi::getSlope(), phase1PixelTopology::layer, lookupTableME11ILT_, position, and relativeConstraints::value.

Referenced by matchedClusterLocES().

                                                                                 {
  //extract hit values from CLCT hit matrix
  std::vector<std::vector<uint16_t>> CLCTHitMatrix = clct.getHits();
  int CLCTHits[6] = {-1, -1, -1, -1, -1, -1};

  for (unsigned layer = 0; layer < CLCTHitMatrix.size(); ++layer) {
    for (unsigned position = 0; position < CLCTHitMatrix.at(layer).size(); ++position) {
      const uint16_t value = CLCTHitMatrix.at(layer).at(position);
      if (value != 0 && value != 65535) {
        CLCTHits[layer] = (int)value;
        break;
      }
    }
  }

  //calculate slope consistency
  float MinMaxPairDifferences[2] = {999., -999.};
  for (unsigned First = 0; First < 5; ++First) {
    //skip empty layers
    if (CLCTHits[First] == -1)
      continue;
    for (unsigned Second = First + 1; Second < 6; ++Second) {
      //skip empty layers
      if (CLCTHits[Second] == -1)
        continue;
      float PairDifference = (CLCTHits[First] - CLCTHits[Second]) / (float)(Second - First);
      if (PairDifference < MinMaxPairDifferences[0])
        MinMaxPairDifferences[0] = PairDifference;
      if (PairDifference > MinMaxPairDifferences[1])
        MinMaxPairDifferences[1] = PairDifference;
    }
  }

  //calculate consistency of slope indicator: cosi
  uint16_t cosi = std::ceil(std::abs(MinMaxPairDifferences[1] - MinMaxPairDifferences[0]));

  //disambiguate cosi cases

  //extremely inconsistent track, deprecate slope
  if (cosi > 3)
    return 0;
  //consistent slope, do not change
  else if (cosi < 2)
    return clct.getSlope();
  //need to look up in table 2->1
  else if (cosi == 2) {
    if (chamber_ % 2 == 0)
      return lookupTableME11ILT_->CSC_slope_cosi_2to1_L1_ME11_even(clct.getSlope());
    else
      return lookupTableME11ILT_->CSC_slope_cosi_2to1_L1_ME11_odd(clct.getSlope());
  }
  //need to look up in table 3->1
  else if (cosi == 3) {
    if (chamber_ % 2 == 0)
      return lookupTableME11ILT_->CSC_slope_cosi_3to1_L1_ME11_even(clct.getSlope());
    else
      return lookupTableME11ILT_->CSC_slope_cosi_3to1_L1_ME11_odd(clct.getSlope());
  }
  //just to avoid compiler errors an error code
  else {
    return 999;
  }
}

void CSCGEMMatcher::setESLookupTables

(

const CSCL1TPLookupTableME11ILT *

conf

)

Definition at line 33 of file CSCGEMMatcher.cc.

References lookupTableME11ILT_.

{ lookupTableME11ILT_ = conf; }

void CSCGEMMatcher::setESLookupTables

(

const CSCL1TPLookupTableME21ILT *

conf

)

Definition at line 35 of file CSCGEMMatcher.cc.

References lookupTableME21ILT_.

{ lookupTableME21ILT_ = conf; }

Member Data Documentation

bool CSCGEMMatcher::assign_gem_csc_bending_

private

Definition at line 139 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher().

unsigned CSCGEMMatcher::chamber_

private

Definition at line 126 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), CSCGEMSlopeCorrector(), matchedClusterLocES(), and mitigatedSlopeByConsistency().

unsigned CSCGEMMatcher::endcap_

private

Definition at line 123 of file CSCGEMMatcher.h.

Referenced by CSCGEMSlopeCorrector().

bool CSCGEMMatcher::isEven_

private

Definition at line 127 of file CSCGEMMatcher.h.

Referenced by calculateGEMCSCBending(), CSCGEMMatcher(), and matchedClusterLocHS().

const CSCL1TPLookupTableME11ILT* CSCGEMMatcher::lookupTableME11ILT_

private

Definition at line 114 of file CSCGEMMatcher.h.

Referenced by calculateGEMCSCBending(), CSCGEMSlopeCorrector(), mitigatedSlopeByConsistency(), and setESLookupTables().

const CSCL1TPLookupTableME21ILT* CSCGEMMatcher::lookupTableME21ILT_

private

Definition at line 115 of file CSCGEMMatcher.h.

Referenced by calculateGEMCSCBending(), and setESLookupTables().

bool CSCGEMMatcher::matchWithHS_

private

Definition at line 132 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), and matchingClustersLoc().

unsigned CSCGEMMatcher::maxDeltaBXALCTGEM_

private

Definition at line 129 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), and matchingClustersBX().

unsigned CSCGEMMatcher::maxDeltaBXCLCTGEM_

private

Definition at line 130 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), and matchingClustersBX().

unsigned CSCGEMMatcher::maxDeltaHsEven_

private

Definition at line 134 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), and matchedClusterLocHS().

unsigned CSCGEMMatcher::maxDeltaHsEvenME1a_

private

Definition at line 136 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), and matchedClusterLocHS().

unsigned CSCGEMMatcher::maxDeltaHsOdd_

private

Definition at line 135 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), and matchedClusterLocHS().

unsigned CSCGEMMatcher::maxDeltaHsOddME1a_

private

Definition at line 137 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), and matchedClusterLocHS().

bool CSCGEMMatcher::mitigateSlopeByCosi_

private

Definition at line 140 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), CSCGEMSlopeCorrector(), and matchedClusterLocES().

unsigned CSCGEMMatcher::ring_

private

Definition at line 125 of file CSCGEMMatcher.h.

unsigned CSCGEMMatcher::station_

private

Definition at line 124 of file CSCGEMMatcher.h.

Referenced by calculateGEMCSCBending(), CSCGEMMatcher(), matchedClusterLocES(), matchedClusterLocHS(), and matchingClustersLoc().