#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, GEMInternalCluster &best) const

void	bestClusterLoc (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, GEMInternalCluster &best) const

int	calculateGEMCSCBending (const CSCCLCTDigi &clct, const GEMInternalCluster &cluster) 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

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

void	matchingClustersLoc (const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, GEMInternalClusters &output, bool ignoreALCTGEMmatch) const

void	matchingClustersLoc (const CSCALCTDigi &alct, const CSCCLCTDigi &clct, const GEMInternalClusters &clusters, GEMInternalClusters &output) const

void	setESLookupTables (const CSCL1TPLookupTableME11ILT *conf)

void	setESLookupTables (const CSCL1TPLookupTableME21ILT *conf)

Private Member Functions
int	CSCGEMSlopeCorrector (const bool isME1a, const int cscSlope, bool isLayer2) const

uint16_t	mitigatedSlopeByConsistency (const CSCCLCTDigi &clct) const

Private Attributes
bool	assign_gem_csc_bending_

unsigned	chamber_

bool	enable_match_gem_me1a_

bool	enable_match_gem_me1b_

unsigned	endcap_

bool	isEven_

const CSCL1TPLookupTableME11ILT *	lookupTableME11ILT_

const CSCL1TPLookupTableME21ILT *	lookupTableME21ILT_

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 37 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,
		GEMInternalCluster &	best
	)		const

Definition at line 52 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);
 
   // 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,
		GEMInternalCluster &	best
	)		const

Definition at line 68 of file CSCGEMMatcher.cc.

References bsc_activity_cfg::clusters, GEMInternalCluster::isCoincidence(), GEMInternalCluster::isMatchingLayer1(), GEMInternalCluster::isMatchingLayer2(), CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), matchingClustersLoc(), or, and GEMInternalCluster::set_coincidence().

                                                                    {
   if (!alct.isValid() or !clct.isValid() or clusters.empty())
     return;
 
   // match spatially
   GEMInternalClusters clustersLoc;
   matchingClustersLoc(alct, clct, clusters, 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

Definition at line 422 of file CSCGEMMatcher.cc.

                                                                                                           {
   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);
   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

private

Definition at line 364 of file CSCGEMMatcher.cc.

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

Definition at line 231 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) : clct.getSlope();
 
     int clctSlope = pow(-1, clct.getBend()) * baseSlope;
 
     SlopeShift = CSCGEMSlopeCorrector(isME1a, clctSlope, isLayer2);
     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, convertSQLitetoXML_cfg::output, 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

Definition at line 138 of file CSCGEMMatcher.cc.

References funct::abs(), haddnano::cl, GetRecoTauVFromDQM_MC_cff::cl2, bsc_activity_cfg::clusters, enable_match_gem_me1a_, enable_match_gem_me1b_, CSCCLCTDigi::getKeyStrip(), isEven_, CSCCLCTDigi::isValid(), matchedClusterDistES(), CSCConstants::MAX_HALF_STRIP_ME1B, maxDeltaHsEven_, maxDeltaHsOdd_, or, convertSQLitetoXML_cfg::output, jetsAK4_CHS_cff::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));
         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));
         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, 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));
           unsigned cl2_distanceES = abs(matchedClusterDistES(clct, cl2, cl2_isLayer2, false));
           return cl1_distanceES < cl2_distanceES;
         } else
           return false;
       });
 }

◆ matchingClustersLoc() [3/3]

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

Definition at line 211 of file CSCGEMMatcher.cc.

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

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

◆ mitigatedSlopeByConsistency()

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

private

Definition at line 260 of file CSCGEMMatcher.cc.

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