CSCGEMMatcher Class Reference

#include <CSCGEMMatcher.h>

Public Types
typedef std::vector< GEMInternalCluster >	GEMInternalClusters

Public Member Functions
void	bestClusterLoc (const CSCALCTDigi &alct, const GEMInternalClusters &clusters, GEMInternalCluster &best) const
void	bestClusterLoc (const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, const CSCL1TPLookupTableME11ILT *lookupTableME11ILT, const CSCL1TPLookupTableME21ILT *lookupTableME21ILT, GEMInternalCluster &best) const
void	bestClusterLoc (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, const CSCL1TPLookupTableME11ILT *lookupTableME11ILT, const CSCL1TPLookupTableME21ILT *lookupTableME21ILT, GEMInternalCluster &best) const
int	calculateGEMCSCBending (const CSCCLCTDigi &clct, const GEMInternalCluster &cluster, const CSCL1TPLookupTableME11ILT *lookupTableME11ILT, const CSCL1TPLookupTableME21ILT *lookupTableME21ILT) const
	CSCGEMMatcher (int endcap, unsigned station, unsigned chamber, const edm::ParameterSet &tmbParams, const edm::ParameterSet &luts)
int	matchedClusterDistES (const CSCCLCTDigi &clct, const GEMInternalCluster &cluster, const bool isLayer2, const bool ForceTotal, const CSCL1TPLookupTableME11ILT *lookupTableME11ILT, const CSCL1TPLookupTableME21ILT *lookupTableME21ILT) const
void	matchingClustersLoc (const CSCALCTDigi &alct, const GEMInternalClusters &clusters, GEMInternalClusters &output) const
void	matchingClustersLoc (const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, GEMInternalClusters &output, bool ignoreALCTGEMmatch, const CSCL1TPLookupTableME11ILT *lookupTableME11ILT, const CSCL1TPLookupTableME21ILT *lookupTableME21ILT) const
void	matchingClustersLoc (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, const CSCL1TPLookupTableME11ILT *lookupTableME11ILT, const CSCL1TPLookupTableME21ILT *lookupTableME21ILT, GEMInternalClusters &output) const

Private Member Functions
int	CSCGEMSlopeCorrector (const bool isME1a, const int cscSlope, bool isLayer2, const CSCL1TPLookupTableME11ILT *lookupTableME11ILT, const CSCL1TPLookupTableME21ILT *lookupTableME21ILT) const
uint16_t	mitigatedSlopeByConsistency (const CSCCLCTDigi &clct, const CSCL1TPLookupTableME11ILT *lookupTableME11ILT, const CSCL1TPLookupTableME21ILT *lookupTableME21ILT) const

Private Attributes
bool	assign_gem_csc_bending_
unsigned	chamber_
bool	enable_match_gem_me1a_
bool	enable_match_gem_me1b_
unsigned	endcap_
bool	isEven_
bool	matchCLCTpropagation_
unsigned	maxDeltaHsEven_
unsigned	maxDeltaHsOdd_
unsigned	maxDeltaWG_
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) by Giovanni Mocellin (UC Davis)

Definition at line 25 of file CSCGEMMatcher.h.

Member Typedef Documentation

GEMInternalClusters

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

Definition at line 27 of file CSCGEMMatcher.h.

Constructor & Destructor Documentation

CSCGEMMatcher()

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_, enable_match_gem_me1a_, enable_match_gem_me1b_, isEven_, matchCLCTpropagation_, maxDeltaHsEven_, maxDeltaHsOdd_, maxDeltaWG_, and mitigateSlopeByCosi_.

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

  enable_match_gem_me1a_ = tmbParams.getParameter<bool>("enableMatchGEMandME1a");
  enable_match_gem_me1b_ = tmbParams.getParameter<bool>("enableMatchGEMandME1b");

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

  matchCLCTpropagation_ = tmbParams.getParameter<bool>("matchCLCTpropagation");

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

Member Function Documentation

bestClusterLoc() [1/3]

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

Definition at line 33 of file CSCGEMMatcher.cc.

References bsc_activity_cfg::clusters, CSCALCTDigi::isValid(), matchingClustersLoc(), and or.

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

  // match spatially
  GEMInternalClusters clustersLoc;
  matchingClustersLoc(alct, clusters, clustersLoc);

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

bestClusterLoc() [2/3]

void CSCGEMMatcher::bestClusterLoc	(	const CSCCLCTDigi &	clct,
		const GEMInternalClusters &	clusters,
		const CSCL1TPLookupTableME11ILT *	lookupTableME11ILT,
		const CSCL1TPLookupTableME21ILT *	lookupTableME21ILT,
		GEMInternalCluster &	best
	)		const

Definition at line 48 of file CSCGEMMatcher.cc.

References bsc_activity_cfg::clusters, CSCCLCTDigi::isValid(), matchingClustersLoc(), and or.

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

  // match spatially
  bool ignoreALCTGEMmatch = true;
  GEMInternalClusters clustersLoc;
  matchingClustersLoc(clct, clusters, clustersLoc, ignoreALCTGEMmatch, lookupTableME11ILT, lookupTableME21ILT);

  // the first matching one is also the closest in phi distance (to expected position, if extrapolating), by ordered list in CLCT matching
  if (!clustersLoc.empty())
    best = clustersLoc[0];
}

bestClusterLoc() [3/3]

void CSCGEMMatcher::bestClusterLoc	(	const CSCALCTDigi &	alct,
		const CSCCLCTDigi &	clct,
		const GEMInternalClusters &	clusters,
		const CSCL1TPLookupTableME11ILT *	lookupTableME11ILT,
		const CSCL1TPLookupTableME21ILT *	lookupTableME21ILT,
		GEMInternalCluster &	best
	)		const

Definition at line 66 of file CSCGEMMatcher.cc.

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

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

  // match spatially
  GEMInternalClusters clustersLoc;
  matchingClustersLoc(alct, clct, clusters, lookupTableME11ILT, lookupTableME21ILT, clustersLoc);

  // the first matching one is also the closest in phi distance (to expected position, if extrapolating), by ordered list in CLCT matching
  if (!clustersLoc.empty()) {
    best = clustersLoc[0];
    if (best.isCoincidence() and !best.isMatchingLayer1() and best.isMatchingLayer2())
      best.set_coincidence(false);
    // std::cout << "\nGEM selected: " << best << "\n" << std::endl;
  }
}

calculateGEMCSCBending()

int CSCGEMMatcher::calculateGEMCSCBending	(	const CSCCLCTDigi &	clct,
		const GEMInternalCluster &	cluster,
		const CSCL1TPLookupTableME11ILT *	lookupTableME11ILT,
		const CSCL1TPLookupTableME21ILT *	lookupTableME21ILT
	)		const

Definition at line 442 of file CSCGEMMatcher.cc.

References funct::abs(), CSCL1TPLookupTableME11ILT::es_diff_slope_L1_ME11a_even(), CSCL1TPLookupTableME11ILT::es_diff_slope_L1_ME11a_odd(), CSCL1TPLookupTableME11ILT::es_diff_slope_L1_ME11b_even(), CSCL1TPLookupTableME11ILT::es_diff_slope_L1_ME11b_odd(), CSCL1TPLookupTableME21ILT::es_diff_slope_L1_ME21_even(), CSCL1TPLookupTableME21ILT::es_diff_slope_L1_ME21_odd(), CSCL1TPLookupTableME11ILT::es_diff_slope_L2_ME11a_even(), CSCL1TPLookupTableME11ILT::es_diff_slope_L2_ME11a_odd(), CSCL1TPLookupTableME11ILT::es_diff_slope_L2_ME11b_even(), CSCL1TPLookupTableME11ILT::es_diff_slope_L2_ME11b_odd(), CSCL1TPLookupTableME21ILT::es_diff_slope_L2_ME21_even(), CSCL1TPLookupTableME21ILT::es_diff_slope_L2_ME21_odd(), CSCCLCTDigi::getKeyStrip(), isEven_, GEMInternalCluster::isMatchingLayer1(), GEMInternalCluster::isMatchingLayer2(), matchedClusterDistES(), CSCConstants::MAX_HALF_STRIP_ME1B, funct::pow(), and station_.

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

  bool isLayer2 = false;
  if (!cluster.isMatchingLayer1() and cluster.isMatchingLayer2())
    isLayer2 = true;

  //ME1a necessitates a different treatment because of a different strip numbering scheme and strip width
  const int SignedEighthStripDiff =
      matchedClusterDistES(clct, cluster, isLayer2, true, lookupTableME11ILT, lookupTableME21ILT);
  const unsigned eighthStripDiff = abs(SignedEighthStripDiff);  //LUTs consider only absolute change

  //use LUTs to determine absolute slope, default 0
  int slopeShift = 0;
  if (station_ == 2) {
    if (!isLayer2) {
      if (isEven_)
        slopeShift = lookupTableME21ILT->es_diff_slope_L1_ME21_even(eighthStripDiff);
      else
        slopeShift = lookupTableME21ILT->es_diff_slope_L1_ME21_odd(eighthStripDiff);
    } else {
      if (isEven_)
        slopeShift = lookupTableME21ILT->es_diff_slope_L2_ME21_even(eighthStripDiff);
      else
        slopeShift = lookupTableME21ILT->es_diff_slope_L2_ME21_odd(eighthStripDiff);
    }
  } else if (station_ == 1) {
    if (isME1a) {  //is in ME1a
      if (!isLayer2) {
        if (isEven_)
          slopeShift = lookupTableME11ILT->es_diff_slope_L1_ME11a_even(eighthStripDiff);
        else
          slopeShift = lookupTableME11ILT->es_diff_slope_L1_ME11a_odd(eighthStripDiff);
      } else {
        if (isEven_)
          slopeShift = lookupTableME11ILT->es_diff_slope_L2_ME11a_even(eighthStripDiff);
        else
          slopeShift = lookupTableME11ILT->es_diff_slope_L2_ME11a_odd(eighthStripDiff);
      }
    } else {
      if (!isLayer2) {
        if (isEven_)
          slopeShift = lookupTableME11ILT->es_diff_slope_L1_ME11b_even(eighthStripDiff);
        else
          slopeShift = lookupTableME11ILT->es_diff_slope_L1_ME11b_odd(eighthStripDiff);
      } else {
        if (isEven_)
          slopeShift = lookupTableME11ILT->es_diff_slope_L2_ME11b_even(eighthStripDiff);
        else
          slopeShift = lookupTableME11ILT->es_diff_slope_L2_ME11b_odd(eighthStripDiff);
      }
    }
  }

  //account for the sign of the difference
  slopeShift *= pow(-1, std::signbit(SignedEighthStripDiff));

  return slopeShift;
}

CSCGEMSlopeCorrector()

int CSCGEMMatcher::CSCGEMSlopeCorrector ( const bool  isME1a, const int  cscSlope, bool  isLayer2, const CSCL1TPLookupTableME11ILT *  lookupTableME11ILT, const CSCL1TPLookupTableME21ILT *  lookupTableME21ILT  ) const

private

Definition at line 380 of file CSCGEMMatcher.cc.

References funct::abs(), chamber_, CSCL1TPLookupTableME11ILT::CSC_slope_corr_L1_ME11a_even(), CSCL1TPLookupTableME11ILT::CSC_slope_corr_L1_ME11a_odd(), CSCL1TPLookupTableME11ILT::CSC_slope_corr_L1_ME11b_even(), CSCL1TPLookupTableME11ILT::CSC_slope_corr_L1_ME11b_odd(), CSCL1TPLookupTableME21ILT::CSC_slope_corr_L1_ME21_even(), CSCL1TPLookupTableME21ILT::CSC_slope_corr_L1_ME21_odd(), CSCL1TPLookupTableME11ILT::CSC_slope_corr_L2_ME11a_even(), CSCL1TPLookupTableME11ILT::CSC_slope_corr_L2_ME11a_odd(), CSCL1TPLookupTableME11ILT::CSC_slope_corr_L2_ME11b_even(), CSCL1TPLookupTableME11ILT::CSC_slope_corr_L2_ME11b_odd(), CSCL1TPLookupTableME21ILT::CSC_slope_corr_L2_ME21_even(), CSCL1TPLookupTableME21ILT::CSC_slope_corr_L2_ME21_odd(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_corr_L1_ME11a_even(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_corr_L1_ME11a_odd(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_corr_L1_ME11b_even(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_corr_L1_ME11b_odd(), CSCL1TPLookupTableME21ILT::CSC_slope_cosi_corr_L1_ME21_even(), CSCL1TPLookupTableME21ILT::CSC_slope_cosi_corr_L1_ME21_odd(), mitigateSlopeByCosi_, funct::pow(), and station_.

Referenced by matchedClusterDistES().

                                                                                                   {
  int SlopeShift = 0;
  int SlopeSign = pow(-1, std::signbit(cscSlope));

  //account for slope mitigation by cosi, if opted-in
  if (mitigateSlopeByCosi_) {
    if (station_ == 1) {
      if (chamber_ % 2 == 0)
        SlopeShift = isME1a ? lookupTableME11ILT->CSC_slope_cosi_corr_L1_ME11a_even(std::abs(cscSlope))
                            : lookupTableME11ILT->CSC_slope_cosi_corr_L1_ME11b_even(std::abs(cscSlope));
      else
        SlopeShift = isME1a ? lookupTableME11ILT->CSC_slope_cosi_corr_L1_ME11a_odd(std::abs(cscSlope))
                            : lookupTableME11ILT->CSC_slope_cosi_corr_L1_ME11b_odd(std::abs(cscSlope));
    } else if (station_ == 2) {
      if (chamber_ % 2 == 0)
        SlopeShift = lookupTableME21ILT->CSC_slope_cosi_corr_L1_ME21_even(std::abs(cscSlope));
      else
        SlopeShift = lookupTableME21ILT->CSC_slope_cosi_corr_L1_ME21_odd(std::abs(cscSlope));
    }
  } else {  //account for slope without mitigation, if opted out
    if (station_ == 1) {
      if (!isLayer2) {
        if (chamber_ % 2 == 0)
          SlopeShift = isME1a ? lookupTableME11ILT->CSC_slope_corr_L1_ME11a_even(std::abs(cscSlope))
                              : lookupTableME11ILT->CSC_slope_corr_L1_ME11b_even(std::abs(cscSlope));
        else
          SlopeShift = isME1a ? lookupTableME11ILT->CSC_slope_corr_L1_ME11a_odd(std::abs(cscSlope))
                              : lookupTableME11ILT->CSC_slope_corr_L1_ME11b_odd(std::abs(cscSlope));
      } else {
        if (chamber_ % 2 == 0)
          SlopeShift = isME1a ? lookupTableME11ILT->CSC_slope_corr_L2_ME11a_even(std::abs(cscSlope))
                              : lookupTableME11ILT->CSC_slope_corr_L2_ME11b_even(std::abs(cscSlope));
        else
          SlopeShift = isME1a ? lookupTableME11ILT->CSC_slope_corr_L2_ME11a_odd(std::abs(cscSlope))
                              : lookupTableME11ILT->CSC_slope_corr_L2_ME11b_odd(std::abs(cscSlope));
      }
    } else if (station_ == 2) {
      if (!isLayer2) {
        if (chamber_ % 2 == 0)
          SlopeShift = lookupTableME21ILT->CSC_slope_corr_L1_ME21_even(std::abs(cscSlope));
        else
          SlopeShift = lookupTableME21ILT->CSC_slope_corr_L1_ME21_odd(std::abs(cscSlope));
      } else {
        if (chamber_ % 2 == 0)
          SlopeShift = lookupTableME21ILT->CSC_slope_corr_L2_ME21_even(std::abs(cscSlope));
        else
          SlopeShift = lookupTableME21ILT->CSC_slope_corr_L2_ME21_odd(std::abs(cscSlope));
      }
    }
  }
  return std::round(SlopeShift * SlopeSign);
}

matchedClusterDistES()

int CSCGEMMatcher::matchedClusterDistES	(	const CSCCLCTDigi &	clct,
		const GEMInternalCluster &	cluster,
		const bool	isLayer2,
		const bool	ForceTotal,
		const CSCL1TPLookupTableME11ILT *	lookupTableME11ILT,
		const CSCL1TPLookupTableME21ILT *	lookupTableME21ILT
	)		const

Definition at line 242 of file CSCGEMMatcher.cc.

References haddnano::cl, CSCGEMSlopeCorrector(), CSCCLCTDigi::getBend(), CSCCLCTDigi::getKeyStrip(), CSCCLCTDigi::getSlope(), matchCLCTpropagation_, CSCConstants::MAX_HALF_STRIP_ME1B, mitigatedSlopeByConsistency(), mitigateSlopeByCosi_, funct::pow(), and station_.

Referenced by calculateGEMCSCBending(), and matchingClustersLoc().

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

  int cl_es = isME1a ? cl.getKeyStripME1a(8, isLayer2) : cl.getKeyStrip(8, isLayer2);

  int eighthStripDiff = cl_es - clct.getKeyStrip(8);

  if (matchCLCTpropagation_ and !ForceTotal) {  //modification of DeltaStrip by CLCT slope
    int SlopeShift = 0;
    uint16_t baseSlope = -1;
    baseSlope = mitigateSlopeByCosi_ ? mitigatedSlopeByConsistency(clct, lookupTableME11ILT, lookupTableME21ILT)
                                     : clct.getSlope();

    int clctSlope = pow(-1, clct.getBend()) * baseSlope;

    SlopeShift = CSCGEMSlopeCorrector(isME1a, clctSlope, isLayer2, lookupTableME11ILT, lookupTableME21ILT);
    eighthStripDiff -= SlopeShift;
  }

  return eighthStripDiff;
}

matchingClustersLoc() [1/3]

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

Definition at line 93 of file CSCGEMMatcher.cc.

References haddnano::cl, bsc_activity_cfg::clusters, CSCALCTDigi::getKeyWG(), CSCALCTDigi::isValid(), SiStripPI::max, maxDeltaWG_, SiStripPI::min, CSCConstants::NUM_WIREGROUPS_ME11, CSCConstants::NUM_WIREGROUPS_ME21, or, and station_.

Referenced by bestClusterLoc(), and matchingClustersLoc().

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

  int number_of_wg = 0;
  if (station_ == 1)
    number_of_wg = CSCConstants::NUM_WIREGROUPS_ME11;
  else if (station_ == 2)
    number_of_wg = CSCConstants::NUM_WIREGROUPS_ME21;

  // select clusters matched in wiregroup

  for (const auto& cl : clusters) {
    // std::cout << "GEM cluster: " << cl << std::endl;
    bool isMatchedLayer1 = false;
    bool isMatchedLayer2 = false;

    if (cl.id1().layer() == 1) {  // cluster has valid layer 1
      int min_wg = std::max(0, int(cl.layer1_min_wg() - maxDeltaWG_));
      int max_wg = std::min(number_of_wg - 1, int(cl.layer1_max_wg() + maxDeltaWG_));
      if (min_wg <= alct.getKeyWG() and alct.getKeyWG() <= max_wg)
        isMatchedLayer1 = true;
    }
    if (cl.id2().layer() == 2) {  // cluster has valid layer 2
      int min_wg = std::max(0, int(cl.layer2_min_wg() - maxDeltaWG_));
      int max_wg = std::min(number_of_wg - 1, int(cl.layer2_max_wg() + maxDeltaWG_));
      if (min_wg <= alct.getKeyWG() and alct.getKeyWG() <= max_wg)
        isMatchedLayer2 = true;
    }

    // std::cout << "ALCT-GEM matching L1-L2: " << isMatchedLayer1 << " " << isMatchedLayer2 << std::endl;

    if (isMatchedLayer1 or isMatchedLayer2) {
      output.push_back(cl);
      if (isMatchedLayer1)
        output.back().set_matchingLayer1(true);
      if (isMatchedLayer2)
        output.back().set_matchingLayer2(true);
    }
  }
}

matchingClustersLoc() [2/3]

void CSCGEMMatcher::matchingClustersLoc	(	const CSCCLCTDigi &	clct,
		const GEMInternalClusters &	clusters,
		GEMInternalClusters &	output,
		bool	ignoreALCTGEMmatch,
		const CSCL1TPLookupTableME11ILT *	lookupTableME11ILT,
		const CSCL1TPLookupTableME21ILT *	lookupTableME21ILT
	)		const

Definition at line 138 of file CSCGEMMatcher.cc.

References funct::abs(), haddnano::cl, GetRecoTauVFromDQM_MC_cff::cl2, bsc_activity_cfg::clusters, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), enable_match_gem_me1a_, enable_match_gem_me1b_, CSCCLCTDigi::getKeyStrip(), isEven_, CSCCLCTDigi::isValid(), matchedClusterDistES(), CSCConstants::MAX_HALF_STRIP_ME1B, maxDeltaHsEven_, maxDeltaHsOdd_, or, jetUpdater_cfi::sort, and station_.

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

  if (station_ == 1 and !enable_match_gem_me1a_ and !enable_match_gem_me1b_)
    return;

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

  //determine window size
  unsigned eighthStripCut = isEven_ ? 4 * maxDeltaHsEven_ : 4 * maxDeltaHsOdd_;  // Cut in 1/8 = 4 * cut in 1/2

  for (const auto& cl : clusters) {
    // std::cout << "GEM cluster: " << cl << std::endl;
    // if (!ignoreALCTGEMmatch) std::cout << "IN CLCT-GEM => ALCT-GEM matching L1-L2: " << cl.isMatchingLayer1() << " " << cl.isMatchingLayer2() << std::endl;

    bool isMatchedLayer1 = false;
    bool isMatchedLayer2 = false;

    if (cl.id1().layer() == 1) {  // cluster has valid layer 1
      if ((station_ == 1 and enable_match_gem_me1a_ and
           ((isME1a and cl.roll1() == 8) or (!isME1a and cl.roll1() < 8))) or
          (station_ == 1 and !enable_match_gem_me1a_ and !isME1a) or (station_ == 2)) {
        constexpr bool isLayer2 = false;
        unsigned distanceES =
            abs(matchedClusterDistES(clct, cl, isLayer2, false, lookupTableME11ILT, lookupTableME21ILT));
        if (distanceES <= eighthStripCut)
          isMatchedLayer1 = true;
      }
    }
    if (cl.id2().layer() == 2) {  // cluster has valid layer 2
      if ((station_ == 1 and enable_match_gem_me1a_ and
           ((isME1a and cl.roll2() == 8) or (!isME1a and cl.roll2() < 8))) or
          (station_ == 1 and !enable_match_gem_me1a_ and !isME1a) or (station_ == 2)) {
        constexpr bool isLayer2 = true;
        unsigned distanceES =
            abs(matchedClusterDistES(clct, cl, isLayer2, false, lookupTableME11ILT, lookupTableME21ILT));
        if (distanceES <= eighthStripCut)
          isMatchedLayer2 = true;
      }
    }

    // std::cout << "CLCT-GEM matching L1-L2: " << isMatchedLayer1 << " " << isMatchedLayer2 << std::endl;

    if (((ignoreALCTGEMmatch or cl.isMatchingLayer1()) and isMatchedLayer1) or
        ((ignoreALCTGEMmatch or cl.isMatchingLayer2()) and isMatchedLayer2)) {
      output.push_back(cl);
      output.back().set_matchingLayer1(false);
      output.back().set_matchingLayer2(false);
      if ((ignoreALCTGEMmatch or cl.isMatchingLayer1()) and isMatchedLayer1)
        output.back().set_matchingLayer1(true);
      if ((ignoreALCTGEMmatch or cl.isMatchingLayer2()) and isMatchedLayer2)
        output.back().set_matchingLayer2(true);
    }
  }

  // Sorting of matching cluster prefers copads and ordering by smallest relative distance
  std::sort(
      output.begin(),
      output.end(),
      [clct, lookupTableME11ILT, lookupTableME21ILT, this](const GEMInternalCluster cl1,
                                                           const GEMInternalCluster cl2) -> bool {
        if (cl1.isCoincidence() and !cl2.isCoincidence())
          return cl1.isCoincidence();
        else if ((cl1.isCoincidence() and cl2.isCoincidence()) or (!cl1.isCoincidence() and !cl2.isCoincidence())) {
          bool cl1_isLayer2 = !cl1.isMatchingLayer1() and cl1.isMatchingLayer2();
          bool cl2_isLayer2 = !cl2.isMatchingLayer1() and cl2.isMatchingLayer2();
          unsigned cl1_distanceES =
              abs(matchedClusterDistES(clct, cl1, cl1_isLayer2, false, lookupTableME11ILT, lookupTableME21ILT));
          unsigned cl2_distanceES =
              abs(matchedClusterDistES(clct, cl2, cl2_isLayer2, false, lookupTableME11ILT, lookupTableME21ILT));
          return cl1_distanceES < cl2_distanceES;
        } else
          return false;
      });
}

matchingClustersLoc() [3/3]

void CSCGEMMatcher::matchingClustersLoc	(	const CSCALCTDigi &	alct,
		const CSCCLCTDigi &	clct,
		const GEMInternalClusters &	clusters,
		const CSCL1TPLookupTableME11ILT *	lookupTableME11ILT,
		const CSCL1TPLookupTableME21ILT *	lookupTableME21ILT,
		GEMInternalClusters &	output
	)		const

Definition at line 220 of file CSCGEMMatcher.cc.

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

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

  // get the single matches
  bool ignoreALCTGEMmatch = false;
  GEMInternalClusters alctClusters;
  matchingClustersLoc(alct, clusters, alctClusters);
  matchingClustersLoc(clct, alctClusters, output, ignoreALCTGEMmatch, lookupTableME11ILT, lookupTableME21ILT);
}

mitigatedSlopeByConsistency()

uint16_t CSCGEMMatcher::mitigatedSlopeByConsistency ( const CSCCLCTDigi &  clct, const CSCL1TPLookupTableME11ILT *  lookupTableME11ILT, const CSCL1TPLookupTableME21ILT *  lookupTableME21ILT  ) const

private

Definition at line 274 of file CSCGEMMatcher.cc.

References funct::abs(), reco::ceil(), chamber_, CSCL1TPLookupTableME11ILT::CSC_slope_cosi_2to1_L1_ME11a_even(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_2to1_L1_ME11a_odd(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_2to1_L1_ME11b_even(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_2to1_L1_ME11b_odd(), CSCL1TPLookupTableME21ILT::CSC_slope_cosi_2to1_L1_ME21_even(), CSCL1TPLookupTableME21ILT::CSC_slope_cosi_2to1_L1_ME21_odd(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_3to1_L1_ME11a_even(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_3to1_L1_ME11a_odd(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_3to1_L1_ME11b_even(), CSCL1TPLookupTableME11ILT::CSC_slope_cosi_3to1_L1_ME11b_odd(), CSCL1TPLookupTableME21ILT::CSC_slope_cosi_3to1_L1_ME21_even(), CSCL1TPLookupTableME21ILT::CSC_slope_cosi_3to1_L1_ME21_odd(), CSCCLCTDigi::getHits(), CSCCLCTDigi::getKeyStrip(), CSCCLCTDigi::getSlope(), createfilelist::int, nano_mu_digi_cff::layer, CSCConstants::MAX_HALF_STRIP_ME1B, position, and station_.

Referenced by matchedClusterDistES().

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

  // 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;
      }
    }
  }

  //Debugging
  //std::cout<<"CLCT Hits = "<<CLCTHits[0]<<", "<<CLCTHits[1]<<", "<<CLCTHits[2]<<", "<<CLCTHits[3]<<", "<<CLCTHits[4]<<", "<<CLCTHits[5]<<std::endl;

  //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]));
  //Debugging
  //std::cout<<"COSI = "<<cosi<<std::endl;

  //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 (station_ == 1) {
      if (isME1a) {
        if (chamber_ % 2 == 0)
          return lookupTableME11ILT->CSC_slope_cosi_2to1_L1_ME11a_even(clct.getSlope());
        else
          return lookupTableME11ILT->CSC_slope_cosi_2to1_L1_ME11a_odd(clct.getSlope());
      } else {
        if (chamber_ % 2 == 0)
          return lookupTableME11ILT->CSC_slope_cosi_2to1_L1_ME11b_even(clct.getSlope());
        else
          return lookupTableME11ILT->CSC_slope_cosi_2to1_L1_ME11b_odd(clct.getSlope());
      }
    } else {
      if (chamber_ % 2 == 0)
        return lookupTableME21ILT->CSC_slope_cosi_2to1_L1_ME21_even(clct.getSlope());
      else
        return lookupTableME21ILT->CSC_slope_cosi_2to1_L1_ME21_odd(clct.getSlope());
    }
  }
  //need to look up in table 3->1
  else if (cosi == 3) {
    if (station_ == 1) {
      if (isME1a) {
        if (chamber_ % 2 == 0)
          return lookupTableME11ILT->CSC_slope_cosi_3to1_L1_ME11a_even(clct.getSlope());
        else
          return lookupTableME11ILT->CSC_slope_cosi_3to1_L1_ME11a_odd(clct.getSlope());
      } else {
        if (chamber_ % 2 == 0)
          return lookupTableME11ILT->CSC_slope_cosi_3to1_L1_ME11b_even(clct.getSlope());
        else
          return lookupTableME11ILT->CSC_slope_cosi_3to1_L1_ME11b_odd(clct.getSlope());
      }
    } else {
      if (chamber_ % 2 == 0)
        return lookupTableME21ILT->CSC_slope_cosi_3to1_L1_ME21_even(clct.getSlope());
      else
        return lookupTableME21ILT->CSC_slope_cosi_3to1_L1_ME21_odd(clct.getSlope());
    }
  }
  //just to avoid compiler errors an error code
  else {
    return 999;
  }
}

Member Data Documentation

assign_gem_csc_bending_

bool CSCGEMMatcher::assign_gem_csc_bending_

private

Definition at line 123 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher().

chamber_

unsigned CSCGEMMatcher::chamber_

private

Definition at line 108 of file CSCGEMMatcher.h.

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

enable_match_gem_me1a_

bool CSCGEMMatcher::enable_match_gem_me1a_

private

Definition at line 112 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), and matchingClustersLoc().

enable_match_gem_me1b_

bool CSCGEMMatcher::enable_match_gem_me1b_

private

Definition at line 113 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), and matchingClustersLoc().

endcap_

unsigned CSCGEMMatcher::endcap_

private

Definition at line 105 of file CSCGEMMatcher.h.

isEven_

bool CSCGEMMatcher::isEven_

private

Definition at line 109 of file CSCGEMMatcher.h.

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

matchCLCTpropagation_

bool CSCGEMMatcher::matchCLCTpropagation_

private

Definition at line 116 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), and matchedClusterDistES().

maxDeltaHsEven_

unsigned CSCGEMMatcher::maxDeltaHsEven_

private

Definition at line 120 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), and matchingClustersLoc().

maxDeltaHsOdd_

unsigned CSCGEMMatcher::maxDeltaHsOdd_

private

Definition at line 121 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), and matchingClustersLoc().

maxDeltaWG_

unsigned CSCGEMMatcher::maxDeltaWG_

private

Definition at line 119 of file CSCGEMMatcher.h.

Referenced by CSCGEMMatcher(), and matchingClustersLoc().

mitigateSlopeByCosi_

bool CSCGEMMatcher::mitigateSlopeByCosi_

private

Definition at line 124 of file CSCGEMMatcher.h.

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

ring_

unsigned CSCGEMMatcher::ring_

private

Definition at line 107 of file CSCGEMMatcher.h.

station_

unsigned CSCGEMMatcher::station_

private

Definition at line 106 of file CSCGEMMatcher.h.

Referenced by calculateGEMCSCBending(), CSCGEMSlopeCorrector(), matchedClusterDistES(), matchingClustersLoc(), and mitigatedSlopeByConsistency().