#include <CSCALCTCrossCLCT.h>

Public Member Functions
void	calculateLCTCodes (const CSCALCTDigi &a1, const CSCCLCTDigi &c1, const CSCALCTDigi &a2, const CSCCLCTDigi &c2, unsigned &bestLCTCode, unsigned &secondLCTCode) const

	CSCALCTCrossCLCT (unsigned endcap, unsigned station, unsigned ring, bool ignoreAlctCrossClct, const edm::ParameterSet &conf)

bool	doesALCTCrossCLCT (const CSCALCTDigi &a, const CSCCLCTDigi &c) const

Private Member Functions
bool	doesWiregroupCrossHalfStrip (int wg, int keystrip) const

Private Attributes
std::unique_ptr< CSCLUTReader >	code_to_best_lct_

std::unique_ptr< CSCLUTReader >	code_to_second_lct_

unsigned	endcap_

bool	gangedME1a_

bool	ignoreAlctCrossClct_

std::vector< std::string >	lctCombinationCodeFiles_

unsigned	ring_

unsigned	station_

std::unique_ptr< CSCLUTReader >	wg_cross_max_hs_ME1a_

std::unique_ptr< CSCLUTReader >	wg_cross_max_hs_ME1a_ganged_

std::unique_ptr< CSCLUTReader >	wg_cross_max_hs_ME1b_

std::unique_ptr< CSCLUTReader >	wg_cross_min_hs_ME1a_

std::unique_ptr< CSCLUTReader >	wg_cross_min_hs_ME1a_ganged_

std::unique_ptr< CSCLUTReader >	wg_cross_min_hs_ME1b_

std::vector< std::string >	wgCrossHsME1aFiles_

std::vector< std::string >	wgCrossHsME1aGangedFiles_

std::vector< std::string >	wgCrossHsME1bFiles_

Detailed Description

Helper class to check if an ALCT crosses with a CLCT in ME1/1. This check was originally introduced by Vadim Khotilovich in 2010 to improve the quality of the ME1/1 LCTs that are sent to the endcap muon track finder. However, it is the policy of the EMTF group that they would like to receive all LCT information, even if an ME1/1 LCT has no physical crossing half-strips and wiregroups. The EMTF disassembles LCTs into ALCT and CLCT anyway and thus for normal trigger operations this class should not be used. However, in the event that multiple high-quality LCTs are present in ME1/1, this class could be used to trim the unphysical ones. As of writing (April 2021) no plans are in place to implement this feature into the CSC trigger firmware

Author: Sven Dildick (Rice University)

Definition at line 33 of file CSCALCTCrossCLCT.h.

Constructor & Destructor Documentation

◆ CSCALCTCrossCLCT()

CSCALCTCrossCLCT::CSCALCTCrossCLCT	(	unsigned	endcap,
		unsigned	station,
		unsigned	ring,
		bool	ignoreAlctCrossClct,
		const edm::ParameterSet &	conf
	)

Definition at line 8 of file CSCALCTCrossCLCT.cc.

     : endcap_(endcap), station_(station), ring_(ring) {
   const auto& commonParams = conf.getParameter<edm::ParameterSet>("commonParam");
   gangedME1a_ = commonParams.getParameter<bool>("gangedME1a");
   ignoreAlctCrossClct_ = ignoreAlctCrossClct;
  
   if (!ignoreAlctCrossClct_) {
     const edm::ParameterSet me11luts(conf.getParameter<edm::ParameterSet>("wgCrossHsME11Params"));
     wgCrossHsME1aFiles_ = me11luts.getParameter<std::vector<std::string>>("wgCrossHsME1aFiles");
     wgCrossHsME1aGangedFiles_ = me11luts.getParameter<std::vector<std::string>>("wgCrossHsME1aGangedFiles");
     wgCrossHsME1bFiles_ = me11luts.getParameter<std::vector<std::string>>("wgCrossHsME1bFiles");
     wg_cross_min_hs_ME1a_ = std::make_unique<CSCLUTReader>(wgCrossHsME1aFiles_[0]);
     wg_cross_max_hs_ME1a_ = std::make_unique<CSCLUTReader>(wgCrossHsME1aFiles_[1]);
     wg_cross_min_hs_ME1a_ganged_ = std::make_unique<CSCLUTReader>(wgCrossHsME1aGangedFiles_[0]);
     wg_cross_max_hs_ME1a_ganged_ = std::make_unique<CSCLUTReader>(wgCrossHsME1aGangedFiles_[1]);
     wg_cross_min_hs_ME1b_ = std::make_unique<CSCLUTReader>(wgCrossHsME1bFiles_[0]);
     wg_cross_max_hs_ME1b_ = std::make_unique<CSCLUTReader>(wgCrossHsME1bFiles_[1]);
   }
 }

References gangedME1a_, edm::ParameterSet::getParameter(), tmbParams::ignoreAlctCrossClct, ignoreAlctCrossClct_, wg_cross_max_hs_ME1a_, wg_cross_max_hs_ME1a_ganged_, wg_cross_max_hs_ME1b_, wg_cross_min_hs_ME1a_, wg_cross_min_hs_ME1a_ganged_, wg_cross_min_hs_ME1b_, wgCrossHsME1aFiles_, wgCrossHsME1aGangedFiles_, and wgCrossHsME1bFiles_.

Member Function Documentation

◆ calculateLCTCodes()

void CSCALCTCrossCLCT::calculateLCTCodes	(	const CSCALCTDigi &	a1,
		const CSCCLCTDigi &	c1,
		const CSCALCTDigi &	a2,
		const CSCCLCTDigi &	c2,
		unsigned &	bestLCTCode,
		unsigned &	secondLCTCode
	)		const

Definition at line 29 of file CSCALCTCrossCLCT.cc.

                                                                         {
   // Each of these calls should return "1" when the ALCT and CLCT are valid.
   const bool ok11 = doesALCTCrossCLCT(bestALCT, bestCLCT);
   const bool ok12 = doesALCTCrossCLCT(bestALCT, secondCLCT);
   const bool ok21 = doesALCTCrossCLCT(secondALCT, bestCLCT);
   const bool ok22 = doesALCTCrossCLCT(secondALCT, secondCLCT);
  
   /*
     With these okxx, we now calculate a 4-bit code that determines
     the best and second LCT combinations.
   */
  
   const unsigned code = (ok11 << 3) | (ok12 << 2) | (ok21 << 1) | (ok22);
  
   bestLCTCode = code_to_best_lct_->lookup(code);
   secondLCTCode = code_to_second_lct_->lookup(code);
  
   edm::LogInfo("CSCALCTCrossCLCT") << "Calculate LCT combination code" << std::endl
                                    << "ALCT1: " << bestALCT << std::endl
                                    << "ALCT2: " << secondALCT << std::endl
                                    << "CLCT1: " << bestCLCT << std::endl
                                    << "CLCT2: " << secondCLCT << std::endl
                                    << "LCT combination code: " << code << std::endl
                                    << "LCT1: " << bestLCTCode << std::endl
                                    << "LCT1: " << secondLCTCode << std::endl;
 }

References code_to_best_lct_, code_to_second_lct_, and doesALCTCrossCLCT().

◆ doesALCTCrossCLCT()

bool CSCALCTCrossCLCT::doesALCTCrossCLCT	(	const CSCALCTDigi &	a,
		const CSCCLCTDigi &	c
	)		const

Definition at line 61 of file CSCALCTCrossCLCT.cc.

                                                                                          {
   // both need to valid
   if (!c.isValid() || !a.isValid()) {
     return false;
   }
  
   // when non-overlapping half-strips and wiregroups don't matter
   if (ignoreAlctCrossClct_)
     return true;
  
   // overlap only needs to be considered for ME1/1
   if (station_ == 1 and ring_ == 1) {
     return doesWiregroupCrossHalfStrip(a.getKeyWG(), c.getKeyStrip());
   } else
     return true;
 }

References a, c, doesWiregroupCrossHalfStrip(), ignoreAlctCrossClct_, ring_, and station_.

Referenced by calculateLCTCodes().

◆ doesWiregroupCrossHalfStrip()

bool CSCALCTCrossCLCT::doesWiregroupCrossHalfStrip	(	int	wg,
		int	keystrip
	)		const

private

Definition at line 78 of file CSCALCTCrossCLCT.cc.

                                                                                      {
   const int min_hs_ME1a = wg_cross_min_hs_ME1a_->lookup(wiregroup);
   const int max_hs_ME1a = wg_cross_max_hs_ME1a_->lookup(wiregroup);
   const int min_hs_ME1a_ganged = wg_cross_min_hs_ME1a_ganged_->lookup(wiregroup);
   const int max_hs_ME1a_ganged = wg_cross_max_hs_ME1a_ganged_->lookup(wiregroup);
   const int min_hs_ME1b = wg_cross_min_hs_ME1b_->lookup(wiregroup);
   const int max_hs_ME1b = wg_cross_max_hs_ME1b_->lookup(wiregroup);
  
   // ME1/a half-strip starts at 128
   if (halfstrip > CSCConstants::MAX_HALF_STRIP_ME1B) {
     if (!gangedME1a_) {
       // wrap around ME11 HS number for -z endcap
       if (endcap_ == 2) {
         // first subtract 128
         halfstrip -= 1 + CSCConstants::MAX_HALF_STRIP_ME1B;
         // flip the HS
         halfstrip = CSCConstants::MAX_HALF_STRIP_ME1A_UNGANGED - halfstrip;
         // then add 128 again
         halfstrip += 1 + CSCConstants::MAX_HALF_STRIP_ME1B;
       }
       return halfstrip >= min_hs_ME1a && halfstrip <= max_hs_ME1a;
     }
  
     else {
       // wrap around ME11 HS number for -z endcap
       if (endcap_ == 2) {
         // first subtract 128
         halfstrip -= 1 + CSCConstants::MAX_HALF_STRIP_ME1B;
         // flip the HS
         halfstrip = CSCConstants::MAX_HALF_STRIP_ME1A_GANGED - halfstrip;
         // then add 128 again
         halfstrip += 1 + CSCConstants::MAX_HALF_STRIP_ME1B;
       }
       return halfstrip >= min_hs_ME1a_ganged && halfstrip <= max_hs_ME1a_ganged;
     }
   }
   // ME1/b half-strip ends at 127
   else if (halfstrip <= CSCConstants::MAX_HALF_STRIP_ME1B) {
     if (endcap_ == 2) {
       halfstrip = CSCConstants::MAX_HALF_STRIP_ME1B - halfstrip;
     }
     return halfstrip >= min_hs_ME1b && halfstrip <= max_hs_ME1b;
   }
   // all other cases, return true
   else
     return true;
 }