CSCMotherboard Class Reference

#include <CSCMotherboard.h>

Inheritance diagram for CSCMotherboard:

Classes
struct	RunContext

Public Member Functions
	CSCMotherboard (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, CSCBaseboard::Parameters &conf)
virtual std::vector< CSCCorrelatedLCTDigi >	readoutLCTs () const
std::vector< CSCShowerDigi >	readoutShower () const
void	run (const CSCWireDigiCollection *wiredc, const CSCComparatorDigiCollection *compdc, const RunContext &)
void	selectLCTs ()
	~CSCMotherboard () override=default
Public Member Functions inherited from CSCBaseboard
	CSCBaseboard (unsigned endcap, unsigned station, unsigned sector, unsigned subsector, unsigned chamber, Parameters &conf)
	CSCBaseboard ()
std::string	getCSCName () const
CSCDetId	id () const
virtual	~CSCBaseboard ()=default

Public Attributes
std::unique_ptr< CSCAnodeLCTProcessor >	alctProc
std::unique_ptr< CSCCathodeLCTProcessor >	clctProc

Protected Member Functions
bool	doesALCTCrossCLCT (const CSCALCTDigi &, const CSCCLCTDigi &) const
unsigned int	encodePattern (const int clctPattern) const
CSCALCTDigi	getBXShiftedALCT (const CSCALCTDigi &) const
CSCCLCTDigi	getBXShiftedCLCT (const CSCCLCTDigi &) const
unsigned int	match_trig_enable () const
unsigned int	match_trig_window_size () const
int	preferred_bx_match (unsigned int index) const
std::tuple< std::vector< CSCALCTDigi >, std::vector< CSCCLCTDigi > >	runCommon (const CSCWireDigiCollection *wiredc, const CSCComparatorDigiCollection *compdc, const RunContext &context)
bool	sort_clct_bx () const
void	sortCLCTByQualBend (int alct_bx, std::vector< unsigned > &clctBxVector)
Protected Member Functions inherited from CSCBaseboard
void	checkConfigParameters (unsigned int &var, const unsigned int var_max, const unsigned int var_def, const std::string &var_str)
const CSCChamber *	cscChamber (CSCGeometry const &) const

Protected Attributes
LCTContainer	allLCTs_
std::unique_ptr< LCTQualityAssignment >	qualityAssignment_
Protected Attributes inherited from CSCBaseboard
CSCDetId	cscId_
bool	disableME1a_
bool	enableAlctPhase2_
bool	gangedME1a_
int	infoV
bool	isME11_
bool	isME12_
bool	isME13_
bool	isME21_
bool	isME22_
bool	isME31_
bool	isME32_
bool	isME41_
bool	isME42_
bool	run3_
bool	runCCLUT_
bool	runCCLUT_OTMB_
bool	runCCLUT_TMB_
bool	runME11ILT_
bool	runME11Up_
bool	runME21ILT_
bool	runME21Up_
bool	runME31Up_
bool	runME41Up_
bool	runPhase2_
unsigned	theChamber
std::string	theCSCName_
const unsigned	theEndcap
int	theRegion
unsigned	theRing
const unsigned	theSector
const unsigned	theStation
const unsigned	theSubsector
const unsigned	theTrigChamber

Private Member Functions
void	checkConfigParameters ()
void	clear ()
void	constructLCTs (const CSCALCTDigi &aLCT, const CSCCLCTDigi &cLCT, int type, int trknmb, CSCCorrelatedLCTDigi &lct) const
void	copyValidToInValidALCT (CSCALCTDigi &, CSCALCTDigi &) const
void	copyValidToInValidCLCT (CSCCLCTDigi &, CSCCLCTDigi &) const
void	correlateLCTs (const CSCALCTDigi &bestALCT, const CSCALCTDigi &secondALCT, const CSCCLCTDigi &bestCLCT, const CSCCLCTDigi &secondCLCT, CSCCorrelatedLCTDigi &bLCT, CSCCorrelatedLCTDigi &sLCT, int type) const
void	dumpConfigParams () const
void	encodeHighMultiplicityBits ()
void	matchALCTCLCT ()
void	matchShowers (CSCShowerDigi *anode_showers, CSCShowerDigi *cathode_showers, bool andlogic)
void	setConfigParameters (const CSCDBL1TPParameters *conf)

Private Attributes
unsigned int	alct_trig_enable_
unsigned int	clct_trig_enable_
std::unique_ptr< CSCALCTCrossCLCT >	cscOverlap_
bool	drop_used_clcts
int	early_tbins
bool	ignoreAlctCrossClct_
std::vector< CSCCorrelatedLCTDigi >	lctV
bool	match_earliest_clct_only_
unsigned int	match_trig_enable_
unsigned int	match_trig_window_size_
unsigned	maxbx_readout_
unsigned	minbx_readout_
unsigned int	mpc_block_me1a_
std::vector< int >	preferred_bx_match_
std::unique_ptr< LCTQualityControl >	qualityControl_
bool	readout_earliest_2
CSCShowerDigi	showers_ [CSCConstants::MAX_LCT_TBINS]
std::vector< unsigned >	showerSource_
bool	sort_clct_bx_
unsigned	thisShowerSource_
unsigned int	tmb_l1a_window_size_

Static Private Attributes
static const unsigned int	def_alct_trig_enable = 0
static const unsigned int	def_clct_trig_enable = 0
static const unsigned int	def_match_trig_enable = 1
static const unsigned int	def_match_trig_window_size = 7
static const unsigned int	def_mpc_block_me1a = 1
static const unsigned int	def_tmb_l1a_window_size = 7

Detailed Description

Correlates anode and cathode LCTs from the same chamber.

When the Trigger MotherBoard (TMB) is instantiated it instantiates an ALCT and CLCT board. The MotherBoard takes up to two LCTs from each anode and cathode LCT card and combines them into a single Correlated LCT. The output is up to two Correlated LCTs.

It can be run in either a test mode, where the arguments are a collection of wire times and arrays of halfstrip times, or for general use, with wire digi and comparator digi collections as arguments. In the latter mode, the wire & strip info is passed on the LCTProcessors, where it is decoded and converted into a convenient form. After running the anode and cathode LCTProcessors, TMB correlates the anode and cathode LCTs. At present, it simply matches the best CLCT with the best ALCT; perhaps a better algorithm will be determined in the future. The MotherBoard then determines a few more numbers (such as quality and pattern) from the ALCT and CLCT information, and constructs two correlated LCT "digis".

Author

Benn Tannenbaum 28 August 1999 benn@.nosp@m.phys.nosp@m.ics.u.nosp@m.cla..nosp@m.edu

Based on code by Nick Wisniewski (nw@it.nosp@m.s.ca.nosp@m.ltech.nosp@m..edu) and a framework by Darin Acosta (acost.nosp@m.a@ph.nosp@m.ys.uf.nosp@m.l.ed.nosp@m.u).

Numerous later improvements by Jason Mumford and Slava Valuev (see cvs in ORCA). Porting from ORCA by S. Valuev (Slava.nosp@m..Val.nosp@m.uev@c.nosp@m.ern..nosp@m.ch), May 2006.

Extended for Run-3 and Phase-2 by Vadim Khotilovich, Tao Huang, Sven Dildick and Giovanni Mocellin

Definition at line 50 of file CSCMotherboard.h.

Constructor & Destructor Documentation

CSCMotherboard()

CSCMotherboard::CSCMotherboard	(	unsigned	endcap,
		unsigned	station,
		unsigned	sector,
		unsigned	subsector,
		unsigned	chamber,
		CSCBaseboard::Parameters &	conf
	)

Normal constructor.

Definition at line 13 of file CSCMotherboard.cc.

References alct_trig_enable_, alctProc, allLCTs_, cms::cuda::assert(), relativeConstraints::chamber, checkConfigParameters(), clct_trig_enable_, clctProc, CSCBaseboard::Parameters::conf(), cscOverlap_, drop_used_clcts, dumpConfigParams(), early_tbins, CSCBaseboard::enableAlctPhase2_, makeMuonMisalignmentScenario::endcap, edm::ParameterSet::getParameter(), CSCDetId::iChamberType(), ignoreAlctCrossClct_, CSCBaseboard::infoV, CSCConstants::LCT_CENTRAL_BX, match_earliest_clct_only_, match_trig_enable_, match_trig_window_size_, maxbx_readout_, minbx_readout_, mpc_block_me1a_, preferred_bx_match_, qualityAssignment_, qualityControl_, readout_earliest_2, CSCBaseboard::runPhase2_, nano_mu_digi_cff::sector, LCTContainer::setMatchTrigWindowSize(), CSCBaseboard::Parameters::showerParams(), showerSource_, sort_clct_bx_, relativeConstraints::station, nano_mu_digi_cff::subsector, CSCBaseboard::theRing, CSCBaseboard::theStation, thisShowerSource_, tmb_l1a_window_size_, and CSCBaseboard::Parameters::tmbParams().

    : CSCBaseboard(endcap, station, sector, subsector, chamber, conf) {
  // Normal constructor.  -JM
  // Pass ALCT, CLCT, and common parameters on to ALCT and CLCT processors.
  static std::atomic<bool> config_dumped{false};

  mpc_block_me1a_ = conf.tmbParams().getParameter<unsigned int>("mpcBlockMe1a");
  alct_trig_enable_ = conf.tmbParams().getParameter<unsigned int>("alctTrigEnable");
  clct_trig_enable_ = conf.tmbParams().getParameter<unsigned int>("clctTrigEnable");
  match_trig_enable_ = conf.tmbParams().getParameter<unsigned int>("matchTrigEnable");
  match_trig_window_size_ = conf.tmbParams().getParameter<unsigned int>("matchTrigWindowSize");
  tmb_l1a_window_size_ =  // Common to CLCT and TMB
      conf.tmbParams().getParameter<unsigned int>("tmbL1aWindowSize");

  // configuration handle for number of early time bins
  early_tbins = conf.tmbParams().getParameter<int>("tmbEarlyTbins");

  // whether to not reuse CLCTs that were used by previous matching ALCTs
  drop_used_clcts = conf.tmbParams().getParameter<bool>("tmbDropUsedClcts");

  // whether to readout only the earliest two LCTs in readout window
  readout_earliest_2 = conf.tmbParams().getParameter<bool>("tmbReadoutEarliest2");

  match_earliest_clct_only_ = conf.tmbParams().getParameter<bool>("matchEarliestClctOnly");

  infoV = conf.tmbParams().getParameter<int>("verbosity");

  alctProc = std::make_unique<CSCAnodeLCTProcessor>(endcap, station, sector, subsector, chamber, conf);
  clctProc = std::make_unique<CSCCathodeLCTProcessor>(endcap, station, sector, subsector, chamber, conf);

  // Check and print configuration parameters.
  checkConfigParameters();
  if (infoV > 0 && !config_dumped) {
    dumpConfigParams();
    config_dumped = true;
  }

  allLCTs_.setMatchTrigWindowSize(match_trig_window_size_);

  // get the preferred CLCT BX match array
  preferred_bx_match_ = conf.tmbParams().getParameter<std::vector<int>>("preferredBxMatch");

  // sort CLCT only by bx or by quality+bending for  ALCT-CLCT match
  sort_clct_bx_ = conf.tmbParams().getParameter<bool>("sortClctBx");

  // quality assignment
  qualityAssignment_ = std::make_unique<LCTQualityAssignment>(endcap, station, sector, subsector, chamber, conf);

  // quality control of stubs
  qualityControl_ = std::make_unique<LCTQualityControl>(endcap, station, sector, subsector, chamber, conf);

  // shower-trigger source
  showerSource_ = conf.showerParams().getParameter<std::vector<unsigned>>("source");

  unsigned csc_idx = CSCDetId::iChamberType(theStation, theRing) - 2;
  thisShowerSource_ = showerSource_[csc_idx];

  // shower readout window
  minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size_ / 2;
  maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size_ / 2;
  assert(tmb_l1a_window_size_ / 2 <= CSCConstants::LCT_CENTRAL_BX);

  // enable the upgrade processors for ring 1 stations
  if (runPhase2_ and theRing == 1) {
    clctProc = std::make_unique<CSCUpgradeCathodeLCTProcessor>(endcap, station, sector, subsector, chamber, conf);
    if (enableAlctPhase2_) {
      alctProc = std::make_unique<CSCUpgradeAnodeLCTProcessor>(endcap, station, sector, subsector, chamber, conf);
    }
  }

  // set up helper class to check if ALCT and CLCT cross
  ignoreAlctCrossClct_ = conf.tmbParams().getParameter<bool>("ignoreAlctCrossClct");
  if (!ignoreAlctCrossClct_) {
    cscOverlap_ = std::make_unique<CSCALCTCrossCLCT>(endcap, station, theRing, ignoreAlctCrossClct_, conf.conf());
  }
}

~CSCMotherboard()

CSCMotherboard::~CSCMotherboard ( )

overridedefault

Default destructor.

Member Function Documentation

checkConfigParameters()

void CSCMotherboard::checkConfigParameters ( )

private

Make sure that the parameter values are within the allowed range.

Definition at line 610 of file CSCMotherboard.cc.

References alct_trig_enable_, cms::cuda::assert(), CSCBaseboard::checkConfigParameters(), clct_trig_enable_, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), def_alct_trig_enable, def_clct_trig_enable, def_match_trig_enable, def_match_trig_window_size, def_mpc_block_me1a, def_tmb_l1a_window_size, CSCConstants::LCT_CENTRAL_BX, match_trig_enable_, match_trig_window_size_, mpc_block_me1a_, and tmb_l1a_window_size_.

Referenced by CSCMotherboard(), and setConfigParameters().

                                           {
  // Make sure that the parameter values are within the allowed range.

  // Max expected values.
  static constexpr unsigned int max_mpc_block_me1a = 1 << 1;
  static constexpr unsigned int max_alct_trig_enable = 1 << 1;
  static constexpr unsigned int max_clct_trig_enable = 1 << 1;
  static constexpr unsigned int max_match_trig_enable = 1 << 1;
  static constexpr unsigned int max_match_trig_window_size = 1 << 4;
  static constexpr unsigned int max_tmb_l1a_window_size = 1 << 4;

  // Checks.
  CSCBaseboard::checkConfigParameters(mpc_block_me1a_, max_mpc_block_me1a, def_mpc_block_me1a, "mpc_block_me1a");
  CSCBaseboard::checkConfigParameters(
      alct_trig_enable_, max_alct_trig_enable, def_alct_trig_enable, "alct_trig_enable");
  CSCBaseboard::checkConfigParameters(
      clct_trig_enable_, max_clct_trig_enable, def_clct_trig_enable, "clct_trig_enable");
  CSCBaseboard::checkConfigParameters(
      match_trig_enable_, max_match_trig_enable, def_match_trig_enable, "match_trig_enable");
  CSCBaseboard::checkConfigParameters(
      match_trig_window_size_, max_match_trig_window_size, def_match_trig_window_size, "match_trig_window_size");
  CSCBaseboard::checkConfigParameters(
      tmb_l1a_window_size_, max_tmb_l1a_window_size, def_tmb_l1a_window_size, "tmb_l1a_window_size");
  assert(tmb_l1a_window_size_ / 2 <= CSCConstants::LCT_CENTRAL_BX);
}

clear()

void CSCMotherboard::clear ( void  )

private

Clears correlated LCT and passes clear signal on to cathode and anode LCT processors.

Definition at line 95 of file CSCMotherboard.cc.

References alctProc, allLCTs_, nano_mu_digi_cff::bx, clctProc, CSCShowerDigi::clear(), LCTContainer::clear(), lctV, CSCConstants::MAX_LCT_TBINS, and showers_.

Referenced by runCommon().

                           {
  // clear the processors
  if (alctProc)
    alctProc->clear();
  if (clctProc)
    clctProc->clear();

  lctV.clear();

  allLCTs_.clear();

  for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
    showers_[bx].clear();
  }
}

constructLCTs()

void CSCMotherboard::constructLCTs ( const CSCALCTDigi &  aLCT, const CSCCLCTDigi &  cLCT, int  type, int  trknmb, CSCCorrelatedLCTDigi &  lct  ) const

private

Definition at line 503 of file CSCMotherboard.cc.

References nano_mu_digi_cff::bx, encodePattern(), CSCCLCTDigi::getBend(), CSCALCTDigi::getBX(), CSCCLCTDigi::getBX(), getBXShiftedALCT(), getBXShiftedCLCT(), CSCCLCTDigi::getEighthStripBit(), CSCCLCTDigi::getKeyStrip(), CSCALCTDigi::getKeyWG(), CSCCLCTDigi::getPattern(), CSCCLCTDigi::getQuartStripBit(), CSCCLCTDigi::getRun3Pattern(), CSCCLCTDigi::getSlope(), CSCALCTDigi::isValid(), qualityAssignment_, CSCBaseboard::runCCLUT_, CSCCorrelatedLCTDigi::setALCT(), CSCCorrelatedLCTDigi::setBend(), CSCCorrelatedLCTDigi::setBX(), CSCCorrelatedLCTDigi::setBX0(), CSCCorrelatedLCTDigi::setCLCT(), CSCCorrelatedLCTDigi::setCSCID(), CSCCorrelatedLCTDigi::setEighthStripBit(), CSCCorrelatedLCTDigi::setMPCLink(), CSCCorrelatedLCTDigi::setPattern(), CSCCorrelatedLCTDigi::setQuality(), CSCCorrelatedLCTDigi::setQuartStripBit(), CSCCorrelatedLCTDigi::setRun3(), CSCCorrelatedLCTDigi::setRun3Pattern(), CSCCorrelatedLCTDigi::setSlope(), CSCCorrelatedLCTDigi::setStrip(), CSCCorrelatedLCTDigi::setSyncErr(), CSCCorrelatedLCTDigi::setTrknmb(), CSCCorrelatedLCTDigi::setType(), CSCCorrelatedLCTDigi::setValid(), CSCCorrelatedLCTDigi::setWireGroup(), and CSCBaseboard::theTrigChamber.

Referenced by correlateLCTs().

                                                                                                                 {
  thisLCT.setValid(true);
  thisLCT.setType(type);
  // make sure to shift the ALCT BX from 8 to 3 and the CLCT BX from 8 to 7!
  thisLCT.setALCT(getBXShiftedALCT(aLCT));
  thisLCT.setCLCT(getBXShiftedCLCT(cLCT));
  thisLCT.setPattern(encodePattern(cLCT.getPattern()));
  thisLCT.setMPCLink(0);
  thisLCT.setBX0(0);
  thisLCT.setSyncErr(0);
  thisLCT.setCSCID(theTrigChamber);
  thisLCT.setTrknmb(trknmb);
  thisLCT.setWireGroup(aLCT.getKeyWG());
  thisLCT.setStrip(cLCT.getKeyStrip());
  thisLCT.setBend(cLCT.getBend());
  // Bunch crossing: get it from cathode LCT if anode LCT is not there.
  int bx = aLCT.isValid() ? aLCT.getBX() : cLCT.getBX();
  thisLCT.setBX(bx);
  thisLCT.setQuality(qualityAssignment_->findQuality(aLCT, cLCT));
  if (runCCLUT_) {
    thisLCT.setRun3(true);
    // 4-bit slope value derived with the CCLUT algorithm
    thisLCT.setSlope(cLCT.getSlope());
    thisLCT.setQuartStripBit(cLCT.getQuartStripBit());
    thisLCT.setEighthStripBit(cLCT.getEighthStripBit());
    thisLCT.setRun3Pattern(cLCT.getRun3Pattern());
  }
}

copyValidToInValidALCT()

void CSCMotherboard::copyValidToInValidALCT ( CSCALCTDigi &  bestALCT, CSCALCTDigi &  secondALCT  ) const

private

Definition at line 483 of file CSCMotherboard.cc.

References CSCALCTDigi::isValid().

Referenced by correlateLCTs().

                                                                                                {
  if (bestALCT.isValid() and !secondALCT.isValid())
    secondALCT = bestALCT;
}

copyValidToInValidCLCT()

void CSCMotherboard::copyValidToInValidCLCT ( CSCCLCTDigi &  bestCLCT, CSCCLCTDigi &  secondCLCT  ) const

private

Definition at line 489 of file CSCMotherboard.cc.

References CSCCLCTDigi::isValid().

Referenced by correlateLCTs().

                                                                                                {
  if (bestCLCT.isValid() and !secondCLCT.isValid())
    secondCLCT = bestCLCT;
}

correlateLCTs()

void CSCMotherboard::correlateLCTs ( const CSCALCTDigi &  bestALCT, const CSCALCTDigi &  secondALCT, const CSCCLCTDigi &  bestCLCT, const CSCCLCTDigi &  secondCLCT, CSCCorrelatedLCTDigi &  bLCT, CSCCorrelatedLCTDigi &  sLCT, int  type  ) const

private

Definition at line 413 of file CSCMotherboard.cc.

References alct_trig_enable_, clct_trig_enable_, CSCCLCTDigi::clear(), constructLCTs(), copyValidToInValidALCT(), copyValidToInValidCLCT(), doesALCTCrossCLCT(), CSCCLCTDigi::getQuality(), CSCALCTDigi::isValid(), CSCCLCTDigi::isValid(), match_trig_enable_, and or.

Referenced by matchALCTCLCT().

                                                   {
  CSCALCTDigi bestALCT = bALCT;
  CSCALCTDigi secondALCT = sALCT;
  CSCCLCTDigi bestCLCT = bCLCT;
  CSCCLCTDigi secondCLCT = sCLCT;

  // extra check to make sure that both CLCTs have at least 4 layers
  // for regular ALCT-CLCT type LCTs. A check was already done on the
  // best CLCT, but not yet on the second best CLCT. The check on best
  // CLCT is repeated for completeness
  if (bestCLCT.getQuality() <= 3)
    bestCLCT.clear();
  if (secondCLCT.getQuality() <= 3)
    secondCLCT.clear();

  // if the best ALCT/CLCT is valid, but the second ALCT/CLCT is not,
  // the information is copied over
  copyValidToInValidALCT(bestALCT, secondALCT);
  copyValidToInValidCLCT(bestCLCT, secondCLCT);

  // ALCT-only LCTs
  const bool bestCase1(alct_trig_enable_ and bestALCT.isValid());
  // CLCT-only LCTs
  const bool bestCase2(clct_trig_enable_ and bestCLCT.isValid());
  /*
    Normal case: ALCT-CLCT matched LCTs. We require ALCT and CLCT to be valid.
    Optionally, we can check if the ALCT cross the CLCT. This check will always return true
    for a valid ALCT-CLCT pair in non-ME1/1 chambers. For ME1/1 chambers, it returns true,
    only when the ALCT-CLCT pair crosses and when the parameter "checkAlctCrossClct" is set to True.
    It is recommended to keep "checkAlctCrossClct" set to False, so that the EMTF receives
    all information, even if it's unphysical.
  */
  const bool bestCase3(match_trig_enable_ and bestALCT.isValid() and bestCLCT.isValid() and
                       doesALCTCrossCLCT(bestALCT, bestCLCT));

  // at least one of the cases must be valid
  if (bestCase1 or bestCase2 or bestCase3) {
    constructLCTs(bestALCT, bestCLCT, type, 1, bLCT);
  }

  // ALCT-only LCTs
  const bool secondCase1(alct_trig_enable_ and secondALCT.isValid());
  // CLCT-only LCTs
  const bool secondCase2(clct_trig_enable_ and secondCLCT.isValid());
  /*
    Normal case: ALCT-CLCT matched LCTs. We require ALCT and CLCT to be valid.
    Optionally, we can check if the ALCT cross the CLCT. This check will always return true
    for a valid ALCT-CLCT pair in non-ME1/1 chambers. For ME1/1 chambers, it returns true,
    only when the ALCT-CLCT pair crosses and when the parameter "checkAlctCrossClct" is set to True.
    It is recommended to keep "checkAlctCrossClct" set to False, so that the EMTF receives
    all information, even if it's unphysical.
  */
  const bool secondCase3(match_trig_enable_ and secondALCT.isValid() and secondCLCT.isValid() and
                         doesALCTCrossCLCT(secondALCT, secondCLCT));

  // at least one component must be different in order to consider the secondLCT
  if ((secondALCT != bestALCT) or (secondCLCT != bestCLCT)) {
    // at least one of the cases must be valid
    if (secondCase1 or secondCase2 or secondCase3)
      constructLCTs(secondALCT, secondCLCT, type, 2, sLCT);
  }
}

doesALCTCrossCLCT()

bool CSCMotherboard::doesALCTCrossCLCT ( const CSCALCTDigi &  alct, const CSCCLCTDigi &  clct  ) const

protected

Definition at line 494 of file CSCMotherboard.cc.

References cscOverlap_, and ignoreAlctCrossClct_.

Referenced by correlateLCTs(), and CSCGEMMotherboard::correlateLCTsGEM().

                                                                                             {
  if (ignoreAlctCrossClct_)
    return true;
  else
    return cscOverlap_->doesALCTCrossCLCT(alct, clct);
}

dumpConfigParams()

void CSCMotherboard::dumpConfigParams ( ) const

private

Dump TMB/MPC configuration parameters.

Definition at line 636 of file CSCMotherboard.cc.

References alct_trig_enable_, clct_trig_enable_, LogDebug, match_trig_enable_, match_trig_window_size_, mpc_block_me1a_, and tmb_l1a_window_size_.

Referenced by CSCMotherboard(), and setConfigParameters().

                                            {
  std::ostringstream strm;
  strm << "\n";
  strm << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
  strm << "+                   TMB configuration parameters:                  +\n";
  strm << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
  strm << " mpc_block_me1a [block/not block triggers which come from ME1/A] = " << mpc_block_me1a_ << "\n";
  strm << " alct_trig_enable [allow ALCT-only triggers] = " << alct_trig_enable_ << "\n";
  strm << " clct_trig_enable [allow CLCT-only triggers] = " << clct_trig_enable_ << "\n";
  strm << " match_trig_enable [allow matched ALCT-CLCT triggers] = " << match_trig_enable_ << "\n";
  strm << " match_trig_window_size [ALCT-CLCT match window width, in 25 ns] = " << match_trig_window_size_ << "\n";
  strm << " tmb_l1a_window_size [L1Accept window width, in 25 ns bins] = " << tmb_l1a_window_size_ << "\n";
  strm << "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
  LogDebug("CSCMotherboard") << strm.str();
}

encodeHighMultiplicityBits()

void CSCMotherboard::encodeHighMultiplicityBits ( )

private

Definition at line 713 of file CSCMotherboard.cc.

References alctProc, clctProc, filterCSVwithJSON::copy, matchShowers(), CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, showers_, and thisShowerSource_.

Referenced by runCommon().

                                                {
  // get the high multiplicity
  // for anode this reflects what is already in the anode CSCShowerDigi object
  CSCShowerDigi cathode_showers[CSCConstants::MAX_CLCT_TBINS];
  CSCShowerDigi anode_showers[CSCConstants::MAX_ALCT_TBINS];
  auto cshowers_v = clctProc->getAllShower();
  auto ashowers_v = alctProc->getAllShower();

  std::copy(cshowers_v.begin(), cshowers_v.end(), cathode_showers);
  std::copy(ashowers_v.begin(), ashowers_v.end(), anode_showers);

  // set the value according to source
  switch (thisShowerSource_) {
    case 0:
      std::copy(std::begin(cathode_showers), std::end(cathode_showers), std::begin(showers_));
      break;
    case 1:
      std::copy(std::begin(anode_showers), std::end(anode_showers), std::begin(showers_));
      break;
    case 2:
      matchShowers(anode_showers, cathode_showers, false);
      break;
    case 3:
      matchShowers(anode_showers, cathode_showers, true);
      break;
    default:
      std::copy(std::begin(anode_showers), std::end(anode_showers), std::begin(showers_));
      break;
  };
}

encodePattern()

unsigned int CSCMotherboard::encodePattern ( const int  clctPattern ) const

protected

Definition at line 534 of file CSCMotherboard.cc.

References funct::abs(), and topSingleLeptonDQM_PU_cfi::pattern.

Referenced by constructLCTs(), and CSCGEMMotherboard::constructLCTsGEM().

                                                              {
  const int kPatternBitWidth = 4;

  // In the TMB07 firmware, LCT pattern is just a 4-bit CLCT pattern.
  unsigned int pattern = (abs(ptn) & ((1 << kPatternBitWidth) - 1));

  return pattern;
}

getBXShiftedALCT()

CSCALCTDigi CSCMotherboard::getBXShiftedALCT ( const CSCALCTDigi &  aLCT ) const

protected

Definition at line 652 of file CSCMotherboard.cc.

References CSCConstants::ALCT_CENTRAL_BX, CSCALCTDigi::getBX(), CSCConstants::LCT_CENTRAL_BX, and CSCALCTDigi::setBX().

Referenced by constructLCTs(), and CSCGEMMotherboard::constructLCTsGEM().

                                                                          {
  CSCALCTDigi aLCT_shifted = aLCT;
  aLCT_shifted.setBX(aLCT_shifted.getBX() - (CSCConstants::LCT_CENTRAL_BX - CSCConstants::ALCT_CENTRAL_BX));
  return aLCT_shifted;
}

getBXShiftedCLCT()

CSCCLCTDigi CSCMotherboard::getBXShiftedCLCT ( const CSCCLCTDigi &  cLCT ) const

protected

Definition at line 658 of file CSCMotherboard.cc.

References CSCConstants::ALCT_CLCT_OFFSET, CSCCLCTDigi::getBX(), and CSCCLCTDigi::setBX().

Referenced by constructLCTs(), and CSCGEMMotherboard::constructLCTsGEM().

                                                                          {
  CSCCLCTDigi cLCT_shifted = cLCT;
  cLCT_shifted.setBX(cLCT_shifted.getBX() - CSCConstants::ALCT_CLCT_OFFSET);
  return cLCT_shifted;
}

match_trig_enable()

unsigned int CSCMotherboard::match_trig_enable ( ) const

inlineprotected

Definition at line 121 of file CSCMotherboard.h.

References match_trig_enable_.

Referenced by CSCGEMMotherboard::correlateLCTsGEM().

{ return match_trig_enable_; }

match_trig_window_size()

unsigned int CSCMotherboard::match_trig_window_size ( ) const

inlineprotected

Configuration parameters.

Definition at line 120 of file CSCMotherboard.h.

References match_trig_window_size_.

Referenced by CSCGEMMotherboard::matchALCTCLCTGEM().

{ return match_trig_window_size_; }

matchALCTCLCT()

void CSCMotherboard::matchALCTCLCT ( )

private

Definition at line 182 of file CSCMotherboard.cc.

References CSCConstants::ALCT_CLCT_OFFSET, alct_trig_enable_, CSCCorrelatedLCTDigi::ALCTCLCT, CSCCorrelatedLCTDigi::ALCTONLY, alctProc, allLCTs_, clct_trig_enable_, CSCCorrelatedLCTDigi::CLCTONLY, clctProc, correlateLCTs(), drop_used_clcts, CSCBaseboard::infoV, LogTrace, match_earliest_clct_only_, match_trig_window_size_, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, or, preferred_bx_match_, sort_clct_bx_, and sortCLCTByQualBend().

Referenced by run().

                                   {
  // array to mask CLCTs
  bool used_clct_mask[CSCConstants::MAX_CLCT_TBINS] = {false};

  // Step 3: ALCT-centric ALCT-to-CLCT matching
  int bx_clct_matched = 0;  // bx of last matched CLCT
  for (int bx_alct = 0; bx_alct < CSCConstants::MAX_ALCT_TBINS; bx_alct++) {
    // There should be at least one valid CLCT or ALCT for a
    // correlated LCT to be formed.  Decision on whether to reject
    // non-complete LCTs (and if yes of which type) is made further
    // upstream.
    if (alctProc->getBestALCT(bx_alct).isValid()) {
      // Look for CLCTs within the match-time window.  The window is
      // centered at the ALCT bx; therefore, we make an assumption
      // that anode and cathode hits are perfectly synchronized.  This
      // is always true for MC, but only an approximation when the
      // data is analyzed (which works fairly good as long as wide
      // windows are used).  To get rid of this assumption, one would
      // need to access "full BX" words, which are not readily
      // available.
      bool is_matched = false;
      // we can use single value to best CLCT but here use vector to keep the
      // the future option to do multiple ALCT-CLCT matches wiht CLCT from different bx
      std::vector<unsigned> clctBx_qualbend_match;
      sortCLCTByQualBend(bx_alct, clctBx_qualbend_match);

      bool hasLocalShower = false;
      for (unsigned ibx = 1; ibx <= match_trig_window_size_ / 2; ibx++)
        hasLocalShower =
            (hasLocalShower or clctProc->getLocalShowerFlag(bx_alct - CSCConstants::ALCT_CLCT_OFFSET - ibx));

      // loop on the preferred "delta BX" array
      for (unsigned mbx = 0; mbx < match_trig_window_size_; mbx++) {
        // evaluate the preffered CLCT BX, taking into account that there is an offset in the simulation
        //bx_clct_run2 would be overflow when bx_alct is small but it is okay
        unsigned bx_clct_run2 = bx_alct + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET;
        unsigned bx_clct_qualbend = clctBx_qualbend_match[mbx];
        unsigned bx_clct = (sort_clct_bx_ or not(hasLocalShower)) ? bx_clct_run2 : bx_clct_qualbend;
        // check that the CLCT BX is valid
        if (bx_clct >= CSCConstants::MAX_CLCT_TBINS)
          continue;
        // do not consider previously matched CLCTs
        if (drop_used_clcts && used_clct_mask[bx_clct])
          continue;
        // only consider >=4 layer CLCTs for ALCT-CLCT type LCTs
        // this condition is lowered to >=3 layers for CLCTs in the
        // matchALCTCLCTGEM function
        if (clctProc->getBestCLCT(bx_clct).getQuality() <= 3)
          continue;
        // a valid CLCT with sufficient layers!
        if (clctProc->getBestCLCT(bx_clct).isValid()) {
          if (infoV > 1)
            LogTrace("CSCMotherboard") << "Successful ALCT-CLCT match: bx_alct = " << bx_alct
                                       << "; bx_clct = " << bx_clct << "; mbx = " << mbx;
          // now correlate the ALCT and CLCT into LCT.
          // smaller mbx means more preferred!
          correlateLCTs(alctProc->getBestALCT(bx_alct),
                        alctProc->getSecondALCT(bx_alct),
                        clctProc->getBestCLCT(bx_clct),
                        clctProc->getSecondCLCT(bx_clct),
                        allLCTs_(bx_alct, mbx, 0),
                        allLCTs_(bx_alct, mbx, 1),
                        CSCCorrelatedLCTDigi::ALCTCLCT);
          // when the first LCT is valid, you can mask the matched CLCT and/or
          // move on to the next ALCT if match_earliest_clct_only_ is set to true
          if (allLCTs_(bx_alct, mbx, 0).isValid()) {
            is_matched = true;
            used_clct_mask[bx_clct] = true;
            bx_clct_matched = bx_clct;
            if (match_earliest_clct_only_)
              break;
          }
        }
      }
      // No CLCT within the match time interval found: report ALCT-only LCT
      // (use dummy CLCTs).
      if (!is_matched) {
        if (infoV > 1)
          LogTrace("CSCMotherboard") << "Unsuccessful ALCT-CLCT match (ALCT only): bx_alct = " << bx_alct
                                     << " first ALCT " << alctProc->getBestALCT(bx_alct);
        if (alct_trig_enable_)
          correlateLCTs(alctProc->getBestALCT(bx_alct),
                        alctProc->getSecondALCT(bx_alct),
                        clctProc->getBestCLCT(bx_alct),
                        clctProc->getSecondCLCT(bx_alct),
                        allLCTs_(bx_alct, 0, 0),
                        allLCTs_(bx_alct, 0, 1),
                        CSCCorrelatedLCTDigi::ALCTONLY);
      }
    }
    // No valid ALCTs; attempt to make CLCT-only LCT.  Use only CLCTs
    // which have zeroth chance to be matched at later cathode times.
    // (I am not entirely sure this perfectly matches the firmware logic.)
    // Use dummy ALCTs.
    else {
      int bx_clct = bx_alct - match_trig_window_size_ / 2;
      if (bx_clct >= 0 && bx_clct > bx_clct_matched) {
        if (clctProc->getBestCLCT(bx_clct).isValid() and clct_trig_enable_) {
          if (infoV > 1)
            LogTrace("CSCMotherboard") << "Unsuccessful ALCT-CLCT match (CLCT only): bx_clct = " << bx_clct;
          correlateLCTs(alctProc->getBestALCT(bx_alct),
                        alctProc->getSecondALCT(bx_alct),
                        clctProc->getBestCLCT(bx_clct),
                        clctProc->getSecondCLCT(bx_clct),
                        allLCTs_(bx_clct, 0, 0),
                        allLCTs_(bx_clct, 0, 1),
                        CSCCorrelatedLCTDigi::CLCTONLY);
        }
      }
    }
  }
}

matchShowers()

void CSCMotherboard::matchShowers ( CSCShowerDigi *  anode_showers, CSCShowerDigi *  cathode_showers, bool  andlogic  )

private

Definition at line 664 of file CSCMotherboard.cc.

References CSCConstants::ALCT_CLCT_OFFSET, nano_mu_digi_cff::bx, CSCShowerDigi::getComparatorNHits(), CSCShowerDigi::getCSCID(), CSCShowerDigi::getWireNHits(), CSCShowerDigi::isLooseInTime(), CSCShowerDigi::isNominalInTime(), CSCShowerDigi::isTightInTime(), CSCShowerDigi::isValid(), sistrip::SpyUtilities::isValid(), match_trig_window_size_, CSCConstants::MAX_ALCT_TBINS, CSCConstants::MAX_CLCT_TBINS, or, preferred_bx_match_, and showers_.

Referenced by encodeHighMultiplicityBits().

                                                                                                             {
  CSCShowerDigi ashower, cshower;
  bool used_cshower_mask[CSCConstants::MAX_CLCT_TBINS] = {false};
  for (unsigned bx = 0; bx < CSCConstants::MAX_ALCT_TBINS; bx++) {
    ashower = anode_showers[bx];
    cshower = CSCShowerDigi();  //use empty shower digi to initialize cshower
    if (ashower.isValid()) {
      for (unsigned mbx = 0; mbx < match_trig_window_size_; mbx++) {
        int cbx = bx + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET;
        //check bx range [0, CSCConstants::MAX_LCT_TBINS]
        if (cbx < 0 || cbx >= CSCConstants::MAX_CLCT_TBINS)
          continue;
        if (cathode_showers[cbx].isValid() and not used_cshower_mask[cbx]) {
          cshower = cathode_showers[cbx];
          used_cshower_mask[cbx] = true;
          break;
        }
      }
    } else
      cshower = cathode_showers[bx];  //if anode shower is not valid, use the cshower from this bx

    //matched HMT, with and/or logic
    unsigned matchHMT = 0;
    if (andlogic) {
      if (ashower.isTightInTime() and cshower.isTightInTime())
        matchHMT = 3;
      else if (ashower.isNominalInTime() and cshower.isNominalInTime())
        matchHMT = 2;
      else if (ashower.isLooseInTime() and cshower.isLooseInTime())
        matchHMT = 1;
    } else {
      if (ashower.isTightInTime() or cshower.isTightInTime())
        matchHMT = 3;
      else if (ashower.isNominalInTime() or cshower.isNominalInTime())
        matchHMT = 2;
      else if (ashower.isLooseInTime() or cshower.isLooseInTime())
        matchHMT = 1;
    }
    //LCTShower with showerType = 3
    showers_[bx] = CSCShowerDigi(matchHMT & 3,
                                 false,
                                 ashower.getCSCID(),
                                 bx,
                                 CSCShowerDigi::ShowerType::kLCTShower,
                                 ashower.getWireNHits(),
                                 cshower.getComparatorNHits());
  }
}

preferred_bx_match()

int CSCMotherboard::preferred_bx_match ( unsigned int  index ) const

inlineprotected

Definition at line 123 of file CSCMotherboard.h.

References preferred_bx_match_.

Referenced by CSCGEMMotherboard::matchALCTCLCTGEM().

{ return preferred_bx_match_[index]; }

readoutLCTs()

std::vector< CSCCorrelatedLCTDigi > CSCMotherboard::readoutLCTs ( ) const

virtual

Definition at line 298 of file CSCMotherboard.cc.

References nano_mu_digi_cff::bx, CSCBaseboard::infoV, CSCBaseboard::isME11_, CSCConstants::LCT_CENTRAL_BX, lctV, LogDebug, CSCConstants::MAX_HALF_STRIP_ME1B, CSCConstants::MAX_LCT_TBINS, mpc_block_me1a_, qualityControl_, readout_earliest_2, and tmb_l1a_window_size_.

Referenced by CSCTriggerPrimitivesBuilder::build().

                                                                  {
  // temporary container for further selection
  std::vector<CSCCorrelatedLCTDigi> tmpV;

  /*
    LCTs in the BX window [early_tbin,...,late_tbin] are considered good for physics
    The central LCT BX is time bin 8.
    For tmb_l1a_window_size set to 7 (Run-1, Run-2), the window is [5, 6, 7, 8, 9, 10, 11]
    For tmb_l1a_window_size set to 5 (Run-3), the window is [6, 7, 8, 9, 10]
    For tmb_l1a_window_size set to 3 (Run-4?), the window is [ 7, 8, 9]
  */
  const unsigned delta_tbin = tmb_l1a_window_size_ / 2;
  int early_tbin = CSCConstants::LCT_CENTRAL_BX - delta_tbin;
  int late_tbin = CSCConstants::LCT_CENTRAL_BX + delta_tbin;
  /*
     Special case for an even-numbered time-window,
     For instance tmb_l1a_window_size set to 6: [5, 6, 7, 8, 9, 10]
  */
  if (tmb_l1a_window_size_ % 2 == 0)
    late_tbin = CSCConstants::LCT_CENTRAL_BX + delta_tbin - 1;
  const int max_late_tbin = CSCConstants::MAX_LCT_TBINS - 1;

  // debugging messages when early_tbin or late_tbin has a suspicious value
  if (early_tbin < 0) {
    edm::LogWarning("CSCMotherboard|SuspiciousParameters")
        << "Early time bin (early_tbin) smaller than minimum allowed, which is 0. set early_tbin to 0.";
    early_tbin = 0;
  }
  if (late_tbin > max_late_tbin) {
    edm::LogWarning("CSCMotherboard|SuspiciousParameters")
        << "Late time bin (late_tbin) larger than maximum allowed, which is " << max_late_tbin
        << ". set early_tbin to max allowed";
    late_tbin = CSCConstants::MAX_LCT_TBINS - 1;
  }

  // Start from the vector of all found correlated LCTs and select
  // those within the LCT*L1A coincidence window.
  int bx_readout = -1;
  for (const auto& lct : lctV) {
    // extra check on invalid LCTs
    if (!lct.isValid()) {
      continue;
    }

    const int bx = lct.getBX();
    // Skip LCTs found too early relative to L1Accept.
    if (bx < early_tbin) {
      if (infoV > 1)
        LogDebug("CSCMotherboard") << " Do not report correlated LCT on key halfstrip " << lct.getStrip()
                                   << " and key wire " << lct.getKeyWG() << ": found at bx " << bx
                                   << ", whereas the earliest allowed bx is " << early_tbin;
      continue;
    }

    // Skip LCTs found too late relative to L1Accept.
    if (bx > late_tbin) {
      if (infoV > 1)
        LogDebug("CSCMotherboard") << " Do not report correlated LCT on key halfstrip " << lct.getStrip()
                                   << " and key wire " << lct.getKeyWG() << ": found at bx " << bx
                                   << ", whereas the latest allowed bx is " << late_tbin;
      continue;
    }

    // Do not report LCTs found in ME1/A if mpc_block_me1a is set.
    if (mpc_block_me1a_ and isME11_ and lct.getStrip() > CSCConstants::MAX_HALF_STRIP_ME1B) {
      continue;
    }

    // If (readout_earliest_2) take only LCTs in the earliest bx in the read-out window:
    // in digi->raw step, LCTs have to be packed into the TMB header, and
    // currently there is room just for two.
    if (readout_earliest_2) {
      if (bx_readout == -1 || bx == bx_readout) {
        tmpV.push_back(lct);
        if (bx_readout == -1)
          bx_readout = bx;
      }
    }
    // if readout_earliest_2 == false, save all LCTs
    else {
      tmpV.push_back(lct);
    }
  }

  // do a final check on the LCTs in readout
  qualityControl_->checkMultiplicityBX(tmpV);
  for (const auto& lct : tmpV) {
    qualityControl_->checkValid(lct);
    /*std::cout << "\n########################################## Emu LCT ##########################################\n" << std::endl;
    std::cout << "Emu LCT: " << lct << std::endl;
    std::cout << "\n########################################## THE END ##########################################\n" << std::endl;*/
  }

  return tmpV;
}

readoutShower()

std::vector< CSCShowerDigi > CSCMotherboard::readoutShower

(

)

const

Returns shower bits

Definition at line 394 of file CSCMotherboard.cc.

References nano_mu_digi_cff::bx, sistrip::SpyUtilities::isValid(), CSCConstants::LCT_CENTRAL_BX, maxbx_readout_, hltL1TEGammaFilteredCollectionProducer_cfi::minBX, minbx_readout_, showers_, and tmb_l1a_window_size_.

Referenced by CSCTriggerPrimitivesBuilder::build().

                                                             {
  unsigned minBXdiff = 2 * tmb_l1a_window_size_;  //impossible value
  unsigned minBX = 0;
  std::vector<CSCShowerDigi> showerOut;
  for (unsigned bx = minbx_readout_; bx < maxbx_readout_; bx++) {
    unsigned bx_diff = (bx > bx - CSCConstants::LCT_CENTRAL_BX) ? bx - CSCConstants::LCT_CENTRAL_BX
                                                                : CSCConstants::LCT_CENTRAL_BX - bx;
    if (showers_[bx].isValid() and bx_diff < minBXdiff) {
      minBXdiff = bx_diff;
      minBX = bx;
    }
  }

  for (unsigned bx = minbx_readout_; bx < maxbx_readout_; bx++)
    if (bx == minBX)
      showerOut.push_back(showers_[bx]);
  return showerOut;
}

run()

void CSCMotherboard::run	(	const CSCWireDigiCollection *	wiredc,
		const CSCComparatorDigiCollection *	compdc,
		const RunContext &	context
	)

Run function for normal usage. Runs cathode and anode LCT processors, takes results and correlates into CorrelatedLCT.

Definition at line 167 of file CSCMotherboard.cc.

References visDQMUpload::context, matchALCTCLCT(), runCommon(), and selectLCTs().

Referenced by CSCTriggerPrimitivesBuilder::build().

                                                    {
  auto [alctV, clctV] = runCommon(wiredc, compdc, context);
  // if there are no ALCTs and no CLCTs, it does not make sense to run this TMB
  if (alctV.empty() and clctV.empty())
    return;

  // step 3: match the ALCTs to the CLCTs
  matchALCTCLCT();

  // Step 4: Select at most 2 LCTs per BX
  selectLCTs();
}

runCommon()

std::tuple< std::vector< CSCALCTDigi >, std::vector< CSCCLCTDigi > > CSCMotherboard::runCommon ( const CSCWireDigiCollection *  wiredc, const CSCComparatorDigiCollection *  compdc, const RunContext &  context  )

protected

Definition at line 140 of file CSCMotherboard.cc.

References alctProc, cms::cuda::assert(), relativeConstraints::chamber, clctProc, clear(), visDQMUpload::context, CSCBaseboard::cscChamber(), encodeHighMultiplicityBits(), and setConfigParameters().

Referenced by CSCGEMMotherboard::run(), and run().

                                                                                                               {
  // Step 1: Setup
  clear();

  setConfigParameters(context.parameters_);

  std::tuple<std::vector<CSCALCTDigi>, std::vector<CSCCLCTDigi>> retValue;

  // Check for existing processors
  if (!(alctProc && clctProc)) {
    edm::LogError("CSCMotherboard|SetupError") << "+++ run() called for non-existing ALCT/CLCT processor! +++ \n";
    return retValue;
  }

  assert(context.cscGeometry_);
  auto chamber = cscChamber(*context.cscGeometry_);
  // Step 2: Run the processors
  // run anodeLCT and cathodeLCT
  retValue = std::make_tuple(alctProc->run(wiredc, chamber), clctProc->run(compdc, chamber, context.lookupTableCCLUT_));

  // Step 2b: encode high multiplicity bits (independent of LCT construction)
  encodeHighMultiplicityBits();

  return retValue;
}

selectLCTs()

void CSCMotherboard::selectLCTs

(

)

Definition at line 543 of file CSCMotherboard.cc.

References allLCTs_, nano_mu_digi_cff::bx, mps_fire::i, CSCBaseboard::infoV, sistrip::SpyUtilities::isValid(), lctV, LogDebug, match_trig_window_size_, CSCConstants::MAX_LCT_TBINS, and CSCConstants::MAX_LCTS_PER_CSC.

Referenced by CSCGEMMotherboard::run(), and run().

                                {
  // in each of the LCT time bins
  for (int bx = 0; bx < CSCConstants::MAX_LCT_TBINS; bx++) {
    unsigned nLCTs = 0;

    std::vector<CSCCorrelatedLCTDigi> tempV;
    // check each of the preferred combinations
    for (unsigned int mbx = 0; mbx < match_trig_window_size_; mbx++) {
      // select at most 2
      for (int i = 0; i < CSCConstants::MAX_LCTS_PER_CSC; i++) {
        if (allLCTs_(bx, mbx, i).isValid() and nLCTs < 2) {
          tempV.push_back(allLCTs_(bx, mbx, i));
          ++nLCTs;
        }
      }
    }
    // store the best 2
    for (const auto& lct : tempV) {
      lctV.push_back(lct);
    }
  }

  // Show the pre-selected LCTs. They're not final yet. Some selection is done in the readoutLCTs function
  if (infoV > 0) {
    for (const auto& lct : lctV) {
      LogDebug("CSCMotherboard") << "Selected LCT" << lct;
    }
  }
}

setConfigParameters()

void CSCMotherboard::setConfigParameters ( const CSCDBL1TPParameters *  conf )

private

Definition at line 112 of file CSCMotherboard.cc.

References alct_trig_enable_, alctProc, checkConfigParameters(), clct_trig_enable_, clctProc, dumpConfigParams(), CSCConstants::LCT_CENTRAL_BX, match_trig_enable_, match_trig_window_size_, maxbx_readout_, minbx_readout_, mpc_block_me1a_, tmb_l1a_window_size_, CSCDBL1TPParameters::tmbAlctTrigEnable(), CSCDBL1TPParameters::tmbClctTrigEnable(), CSCDBL1TPParameters::tmbMatchTrigEnable(), CSCDBL1TPParameters::tmbMatchTrigWindowSize(), CSCDBL1TPParameters::tmbMpcBlockMe1a(), and CSCDBL1TPParameters::tmbTmbL1aWindowSize().

Referenced by runCommon().

                                                                        {
  if (nullptr == conf) {
    return;
  }
  static std::atomic<bool> config_dumped{false};

  // Config. parameters for the TMB itself.
  mpc_block_me1a_ = conf->tmbMpcBlockMe1a();
  alct_trig_enable_ = conf->tmbAlctTrigEnable();
  clct_trig_enable_ = conf->tmbClctTrigEnable();
  match_trig_enable_ = conf->tmbMatchTrigEnable();
  match_trig_window_size_ = conf->tmbMatchTrigWindowSize();
  tmb_l1a_window_size_ = conf->tmbTmbL1aWindowSize();

  // Config. paramteres for ALCT and CLCT processors.
  alctProc->setConfigParameters(conf);
  clctProc->setConfigParameters(conf);

  // Check and print configuration parameters.
  checkConfigParameters();
  if (!config_dumped) {
    dumpConfigParams();
    config_dumped = true;
  }
  minbx_readout_ = CSCConstants::LCT_CENTRAL_BX - tmb_l1a_window_size_ / 2;
  maxbx_readout_ = CSCConstants::LCT_CENTRAL_BX + tmb_l1a_window_size_ / 2;
}

sort_clct_bx()

bool CSCMotherboard::sort_clct_bx ( ) const

inlineprotected

Definition at line 124 of file CSCMotherboard.h.

References sort_clct_bx_.

Referenced by CSCGEMMotherboard::matchALCTCLCTGEM().

{ return sort_clct_bx_; }

sortCLCTByQualBend()

void CSCMotherboard::sortCLCTByQualBend ( int  alct_bx, std::vector< unsigned > &  clctBxVector  )

protected

Definition at line 573 of file CSCMotherboard.cc.

References CSCConstants::ALCT_CLCT_OFFSET, nano_mu_digi_cff::bx, clctProc, CSCCLCTDigi::getPattern(), CSCCLCTDigi::getQuality(), CSCCLCTDigi::getSlope(), CSCCLCTDigi::isRun3(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, match_trig_window_size_, CSCConstants::MAX_CLCT_TBINS, and preferred_bx_match_.

Referenced by matchALCTCLCT(), and CSCGEMMotherboard::matchALCTCLCTGEM().

                                                                                      {
  //find clct bx range in [centerbx-window_size/2, center_bx+window_size/2]
  //Then sort CLCT based quality+bend within the match window
  //if two CLCTs from different BX has same qual+bend, the in-time one has higher priority
  clctBxVector.clear();
  int clctQualBendArray[CSCConstants::MAX_CLCT_TBINS + 1] = {0};
  for (unsigned mbx = 0; mbx < match_trig_window_size_; mbx++) {
    unsigned bx_clct = bx_alct + preferred_bx_match_[mbx] - CSCConstants::ALCT_CLCT_OFFSET;
    int tempQualBend = 0;
    if (bx_clct >= CSCConstants::MAX_CLCT_TBINS)
      continue;
    if (!clctProc->getBestCLCT(bx_clct).isValid()) {
      clctQualBendArray[bx_clct] = tempQualBend;
      continue;
    }
    CSCCLCTDigi bestCLCT = clctProc->getBestCLCT(bx_clct);
    //for run2 pattern, ignore direction and use &0xe
    //for run3, slope=0 is straighest pattern
    int clctBend = bestCLCT.isRun3() ? (16 - bestCLCT.getSlope()) : (bestCLCT.getPattern() & 0xe);
    //shift quality to left for 4 bits
    int clctQualBend = clctBend | (bestCLCT.getQuality() << 5);
    clctQualBendArray[bx_clct] = clctQualBend;
    if (clctBxVector.empty())
      clctBxVector.push_back(bx_clct);
    else {
      for (auto it = clctBxVector.begin(); it != clctBxVector.end(); it++)
        if (clctQualBend > clctQualBendArray[*it]) {  //insert the Bx with better clct
          clctBxVector.insert(it, bx_clct);
          break;
        }
    }
  }
  //fill rest of vector with MAX_CLCT_TBINS
  for (unsigned bx = clctBxVector.size(); bx < match_trig_window_size_; bx++)
    clctBxVector.push_back(CSCConstants::MAX_CLCT_TBINS);
}

Member Data Documentation

alct_trig_enable_

unsigned int CSCMotherboard::alct_trig_enable_

private

Definition at line 230 of file CSCMotherboard.h.

Referenced by checkConfigParameters(), correlateLCTs(), CSCMotherboard(), dumpConfigParams(), matchALCTCLCT(), and setConfigParameters().

alctProc

std::unique_ptr<CSCAnodeLCTProcessor> CSCMotherboard::alctProc

Anode LCT processor.

Definition at line 104 of file CSCMotherboard.h.

Referenced by CSCTriggerPrimitivesBuilder::build(), clear(), CSCMotherboard(), encodeHighMultiplicityBits(), matchALCTCLCT(), CSCGEMMotherboard::matchALCTCLCTGEM(), runCommon(), and setConfigParameters().

allLCTs_

LCTContainer CSCMotherboard::allLCTs_

protected

Container with all LCTs prior to sorting and selecting.

Definition at line 137 of file CSCMotherboard.h.

Referenced by clear(), CSCMotherboard(), matchALCTCLCT(), CSCGEMMotherboard::matchALCTCLCTGEM(), and selectLCTs().

clct_trig_enable_

unsigned int CSCMotherboard::clct_trig_enable_

private

Definition at line 230 of file CSCMotherboard.h.

Referenced by checkConfigParameters(), correlateLCTs(), CSCMotherboard(), dumpConfigParams(), matchALCTCLCT(), and setConfigParameters().

clctProc

std::unique_ptr<CSCCathodeLCTProcessor> CSCMotherboard::clctProc

Cathode LCT processor.

Definition at line 107 of file CSCMotherboard.h.

Referenced by CSCTriggerPrimitivesBuilder::build(), clear(), CSCMotherboard(), encodeHighMultiplicityBits(), matchALCTCLCT(), CSCGEMMotherboard::matchALCTCLCTGEM(), runCommon(), setConfigParameters(), and sortCLCTByQualBend().

cscOverlap_

std::unique_ptr<CSCALCTCrossCLCT> CSCMotherboard::cscOverlap_

private

Definition at line 225 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and doesALCTCrossCLCT().

def_alct_trig_enable

const unsigned int CSCMotherboard::def_alct_trig_enable = 0

staticprivate

Definition at line 258 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

def_clct_trig_enable

const unsigned int CSCMotherboard::def_clct_trig_enable = 0

staticprivate

Definition at line 258 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

def_match_trig_enable

const unsigned int CSCMotherboard::def_match_trig_enable = 1

staticprivate

Definition at line 259 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

def_match_trig_window_size

const unsigned int CSCMotherboard::def_match_trig_window_size = 7

staticprivate

Definition at line 259 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

def_mpc_block_me1a

const unsigned int CSCMotherboard::def_mpc_block_me1a = 1

staticprivate

Default values of configuration parameters.

Definition at line 257 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

def_tmb_l1a_window_size

const unsigned int CSCMotherboard::def_tmb_l1a_window_size = 7

staticprivate

Definition at line 260 of file CSCMotherboard.h.

Referenced by checkConfigParameters().

drop_used_clcts

bool CSCMotherboard::drop_used_clcts

private

Phase2: whether to not reuse CLCTs that were used by previous matching ALCTs

Definition at line 243 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and matchALCTCLCT().

early_tbins

int CSCMotherboard::early_tbins

private

Phase2: separate handle for early time bins

Definition at line 234 of file CSCMotherboard.h.

Referenced by CSCMotherboard().

ignoreAlctCrossClct_

bool CSCMotherboard::ignoreAlctCrossClct_

private

Definition at line 251 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and doesALCTCrossCLCT().

lctV

std::vector<CSCCorrelatedLCTDigi> CSCMotherboard::lctV

private

Definition at line 205 of file CSCMotherboard.h.

Referenced by clear(), readoutLCTs(), and selectLCTs().

match_earliest_clct_only_

bool CSCMotherboard::match_earliest_clct_only_

private

Definition at line 249 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and matchALCTCLCT().

match_trig_enable_

unsigned int CSCMotherboard::match_trig_enable_

private

Definition at line 230 of file CSCMotherboard.h.

Referenced by checkConfigParameters(), correlateLCTs(), CSCMotherboard(), dumpConfigParams(), match_trig_enable(), and setConfigParameters().

match_trig_window_size_

unsigned int CSCMotherboard::match_trig_window_size_

private

Definition at line 231 of file CSCMotherboard.h.

Referenced by checkConfigParameters(), CSCMotherboard(), dumpConfigParams(), match_trig_window_size(), matchALCTCLCT(), matchShowers(), selectLCTs(), setConfigParameters(), and sortCLCTByQualBend().

maxbx_readout_

unsigned CSCMotherboard::maxbx_readout_

private

Definition at line 240 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), readoutShower(), and setConfigParameters().

minbx_readout_

unsigned CSCMotherboard::minbx_readout_

private

Definition at line 239 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), readoutShower(), and setConfigParameters().

mpc_block_me1a_

unsigned int CSCMotherboard::mpc_block_me1a_

private

Definition at line 229 of file CSCMotherboard.h.

Referenced by checkConfigParameters(), CSCMotherboard(), dumpConfigParams(), readoutLCTs(), and setConfigParameters().

preferred_bx_match_

std::vector<int> CSCMotherboard::preferred_bx_match_

private

Definition at line 212 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), matchALCTCLCT(), matchShowers(), preferred_bx_match(), and sortCLCTByQualBend().

qualityAssignment_

std::unique_ptr<LCTQualityAssignment> CSCMotherboard::qualityAssignment_

protected

Definition at line 140 of file CSCMotherboard.h.

Referenced by constructLCTs(), CSCGEMMotherboard::constructLCTsGEM(), CSCGEMMotherboard::CSCGEMMotherboard(), and CSCMotherboard().

qualityControl_

std::unique_ptr<LCTQualityControl> CSCMotherboard::qualityControl_

private

Definition at line 217 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and readoutLCTs().

readout_earliest_2

bool CSCMotherboard::readout_earliest_2

private

Phase2: whether to readout only the earliest two LCTs in readout window

Definition at line 246 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and readoutLCTs().

showers_

CSCShowerDigi CSCMotherboard::showers_[CSCConstants::MAX_LCT_TBINS]

private

Definition at line 227 of file CSCMotherboard.h.

Referenced by clear(), encodeHighMultiplicityBits(), matchShowers(), and readoutShower().

showerSource_

std::vector<unsigned> CSCMotherboard::showerSource_

private

Definition at line 214 of file CSCMotherboard.h.

Referenced by CSCMotherboard().

sort_clct_bx_

bool CSCMotherboard::sort_clct_bx_

private

Definition at line 254 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), matchALCTCLCT(), and sort_clct_bx().

thisShowerSource_

unsigned CSCMotherboard::thisShowerSource_

private

Definition at line 237 of file CSCMotherboard.h.

Referenced by CSCMotherboard(), and encodeHighMultiplicityBits().

tmb_l1a_window_size_

unsigned int CSCMotherboard::tmb_l1a_window_size_

private

Definition at line 231 of file CSCMotherboard.h.

Referenced by checkConfigParameters(), CSCMotherboard(), dumpConfigParams(), readoutLCTs(), readoutShower(), and setConfigParameters().