#include <CSCTriggerPrimitivesBuilder.h>

Public Types
enum	trig_cscs { MAX_ENDCAPS = 2, MAX_STATIONS = 4, MAX_SECTORS = 6, MAX_SUBSECTORS = 2, MAX_CHAMBERS = 9 }

Public Member Functions
void	build (const CSCBadChambers badChambers, const CSCWireDigiCollection wiredc, const CSCComparatorDigiCollection compdc, const GEMPadDigiCollection gemPads, const GEMPadDigiClusterCollection *gemPadClusters, CSCALCTDigiCollection &oc_alct, CSCCLCTDigiCollection &oc_clct, CSCCLCTPreTriggerDigiCollection &oc_clctpretrigger, CSCCLCTPreTriggerCollection &oc_pretrig, CSCCorrelatedLCTDigiCollection &oc_lct, CSCCorrelatedLCTDigiCollection &oc_sorted_lct, GEMCoPadDigiCollection &oc_gemcopad)

	CSCTriggerPrimitivesBuilder (const edm::ParameterSet &)

void	setConfigParameters (const CSCDBL1TPParameters *conf)

void	setCSCGeometry (const CSCGeometry *g)
	set CSC and GEM geometries for the matching needs More...

void	setGEMGeometry (const GEMGeometry *g)

	~CSCTriggerPrimitivesBuilder ()

Private Member Functions
template<class T , class S >
void	put (const T &, S &, const CSCDetId &, std::string comment)

Private Attributes
bool	checkBadChambers_
	a flag whether to skip chambers from the bad chambers map More...

const CSCGeometry *	csc_g

bool	disableME1a_

bool	disableME42_

const GEMGeometry *	gem_g

int	infoV

bool	isSLHC_

int	m_maxBX_

int	m_minBX_

std::unique_ptr< CSCMuonPortCard >	m_muonportcard

bool	runME11ILT_

bool	runME11Up_

bool	runME21ILT_

bool	runME21Up_

bool	runME31Up_

bool	runME41Up_

std::unique_ptr< CSCMotherboard >	tmb_ [MAX_ENDCAPS][MAX_STATIONS][MAX_SECTORS][MAX_SUBSECTORS][MAX_CHAMBERS]

bool	useClusters_

Static Private Attributes
static const int	max_chamber = CSCTriggerNumbering::maxTriggerCscId()

static const int	max_endcap = CSCDetId::maxEndcapId()

static const int	max_sector = CSCTriggerNumbering::maxTriggerSectorId()

static const int	max_station = CSCDetId::maxStationId()

static const int	max_subsector = CSCTriggerNumbering::maxTriggerSubSectorId()

static const int	min_chamber = CSCTriggerNumbering::minTriggerCscId()

static const int	min_endcap = CSCDetId::minEndcapId()

static const int	min_sector = CSCTriggerNumbering::minTriggerSectorId()

static const int	min_station = CSCDetId::minStationId()

static const int	min_subsector = CSCTriggerNumbering::minTriggerSubSectorId()

Detailed Description

Definition at line 40 of file CSCTriggerPrimitivesBuilder.h.

Member Enumeration Documentation

enum CSCTriggerPrimitivesBuilder::trig_cscs

Max values of trigger labels for all CSCs; used to construct TMB processors.

Enumerator
MAX_ENDCAPS
MAX_STATIONS
MAX_SECTORS
MAX_SUBSECTORS
MAX_CHAMBERS

Definition at line 83 of file CSCTriggerPrimitivesBuilder.h.

83 {MAX_ENDCAPS = 2, MAX_STATIONS = 4, MAX_SECTORS = 6,

84 MAX_SUBSECTORS = 2, MAX_CHAMBERS = 9};

CSCTriggerPrimitivesBuilder::MAX_ENDCAPS

Definition: CSCTriggerPrimitivesBuilder.h:83

CSCTriggerPrimitivesBuilder::MAX_STATIONS

Definition: CSCTriggerPrimitivesBuilder.h:83

CSCTriggerPrimitivesBuilder::MAX_CHAMBERS

Definition: CSCTriggerPrimitivesBuilder.h:84

CSCTriggerPrimitivesBuilder::MAX_SECTORS

Definition: CSCTriggerPrimitivesBuilder.h:83

CSCTriggerPrimitivesBuilder::MAX_SUBSECTORS

Definition: CSCTriggerPrimitivesBuilder.h:84

Constructor & Destructor Documentation

CSCTriggerPrimitivesBuilder::CSCTriggerPrimitivesBuilder ( const edm::ParameterSet & conf )

explicit

Configure the algorithm via constructor. Receives ParameterSet percolated down from EDProducer which owns this Builder.

Definition at line 20 of file CSCTriggerPrimitivesBuilder.cc.

References relativeConstraints::cham, checkBadChambers_, disableME1a_, disableME42_, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), infoV, isSLHC_, m_maxBX_, m_minBX_, m_muonportcard, max_chamber, MAX_CHAMBERS, max_endcap, MAX_ENDCAPS, max_sector, MAX_SECTORS, max_station, MAX_STATIONS, max_subsector, MAX_SUBSECTORS, min_chamber, min_endcap, min_sector, min_station, min_subsector, relativeConstraints::ring, CSCTriggerNumbering::ringFromTriggerLabels(), runME11ILT_, runME11Up_, runME21ILT_, runME21Up_, runME31Up_, runME41Up_, tmb_, and useClusters_.

 {
   // special configuration parameters for ME11 treatment
   edm::ParameterSet commonParams = conf.getParameter<edm::ParameterSet>("commonParam");
   isSLHC_ = commonParams.getParameter<bool>("isSLHC");
   infoV = commonParams.getParameter<int>("verbosity");
   disableME1a_ = commonParams.getParameter<bool>("disableME1a");
   disableME42_ = commonParams.getParameter<bool>("disableME42");
 
   checkBadChambers_ = conf.getParameter<bool>("checkBadChambers");
 
   runME11Up_ = commonParams.existsAs<bool>("runME11Up")?commonParams.getParameter<bool>("runME11Up"):false;
   runME21Up_ = commonParams.existsAs<bool>("runME21Up")?commonParams.getParameter<bool>("runME21Up"):false;
   runME31Up_ = commonParams.existsAs<bool>("runME31Up")?commonParams.getParameter<bool>("runME31Up"):false;
   runME41Up_ = commonParams.existsAs<bool>("runME41Up")?commonParams.getParameter<bool>("runME41Up"):false;
 
   runME11ILT_ = commonParams.existsAs<bool>("runME11ILT")?commonParams.getParameter<bool>("runME11ILT"):false;
   runME21ILT_ = commonParams.existsAs<bool>("runME21ILT")?commonParams.getParameter<bool>("runME21ILT"):false;
 
   useClusters_ = commonParams.existsAs<bool>("useClusters")?commonParams.getParameter<bool>("useClusters"):false;
 
   // Initializing boards.
   for (int endc = min_endcap; endc <= max_endcap; endc++)
   {
     for (int stat = min_station; stat <= max_station; stat++)
     {
       int numsubs = ((stat == 1) ? max_subsector : 1);
       for (int sect = min_sector; sect <= max_sector; sect++)
       {
         for (int subs = min_subsector; subs <= numsubs; subs++)
         {
           for (int cham = min_chamber; cham <= max_chamber; cham++)
           {
             if ((endc <= 0 || endc > MAX_ENDCAPS)    ||
                 (stat <= 0 || stat > MAX_STATIONS)   ||
                 (sect <= 0 || sect > MAX_SECTORS)    ||
                 (subs <= 0 || subs > MAX_SUBSECTORS) ||
                 (cham <= 0 || cham > MAX_CHAMBERS))
             {
               edm::LogError("CSCTriggerPrimitivesBuilder|SetupError")
                 << "+++ trying to instantiate TMB of illegal CSC id ["
                 << " endcap = "  << endc << " station = "   << stat
                 << " sector = "  << sect << " subsector = " << subs
                 << " chamber = " << cham << "]; skipping it... +++\n";
               continue;
             }
             int ring = CSCTriggerNumbering::ringFromTriggerLabels(stat, cham);
             // When the motherboard is instantiated, it instantiates ALCT
             // and CLCT processors.
 
             // go through all possible cases
             if (isSLHC_ and ring == 1 and stat==1 and runME11Up_ and !runME11ILT_)
               tmb_[endc-1][stat-1][sect-1][subs-1][cham-1].reset( new CSCMotherboardME11(endc, stat, sect, subs, cham, conf) );
             else if (isSLHC_ and ring == 1 and stat==1 and runME11Up_ and runME11ILT_)
               tmb_[endc-1][stat-1][sect-1][subs-1][cham-1].reset( new CSCGEMMotherboardME11(endc, stat, sect, subs, cham, conf) );
             else if (isSLHC_ and ring == 1 and stat==2 and runME21Up_ and !runME21ILT_)
               tmb_[endc-1][stat-1][sect-1][subs-1][cham-1].reset( new CSCUpgradeMotherboard(endc, stat, sect, subs, cham, conf) );
             else if (isSLHC_ and ring == 1 and stat==2 and runME21Up_ and runME21ILT_)
               tmb_[endc-1][stat-1][sect-1][subs-1][cham-1].reset( new CSCGEMMotherboardME21(endc, stat, sect, subs, cham, conf) );
             else if (isSLHC_ and ring == 1 and ((stat==3 and runME31Up_) || (stat==4 and runME41Up_)))
               tmb_[endc-1][stat-1][sect-1][subs-1][cham-1].reset( new CSCUpgradeMotherboard(endc, stat, sect, subs, cham, conf) );
             else
               tmb_[endc-1][stat-1][sect-1][subs-1][cham-1].reset( new CSCMotherboard(endc, stat, sect, subs, cham, conf) );
           }
         }
       }
     }
   }
 
   // Get min and max BX to sort LCTs in MPC.
   m_minBX_ = conf.getParameter<int>("MinBX");
   m_maxBX_ = conf.getParameter<int>("MaxBX");
 
   // Init MPC
   m_muonportcard.reset( new CSCMuonPortCard(conf) );
 }

CSCTriggerPrimitivesBuilder::~CSCTriggerPrimitivesBuilder ( )

Definition at line 100 of file CSCTriggerPrimitivesBuilder.cc.

101 {

102 }

Member Function Documentation

void CSCTriggerPrimitivesBuilder::build	(	const CSCBadChambers *	badChambers,
		const CSCWireDigiCollection *	wiredc,
		const CSCComparatorDigiCollection *	compdc,
		const GEMPadDigiCollection *	gemPads,
		const GEMPadDigiClusterCollection *	gemPadClusters,
		CSCALCTDigiCollection &	oc_alct,
		CSCCLCTDigiCollection &	oc_clct,
		CSCCLCTPreTriggerDigiCollection &	oc_clctpretrigger,
		CSCCLCTPreTriggerCollection &	oc_pretrig,
		CSCCorrelatedLCTDigiCollection &	oc_lct,
		CSCCorrelatedLCTDigiCollection &	oc_sorted_lct,
		GEMCoPadDigiCollection &	oc_gemcopad
	)

Definition at line 127 of file CSCTriggerPrimitivesBuilder.cc.

References CSCMotherboard::alctProc, relativeConstraints::cham, relativeConstraints::chamber, CSCGeometry::chamber(), CSCTriggerNumbering::chamberFromTriggerLabels(), checkBadChambers_, CSCMotherboard::clctProc, CSCGEMMotherboard::coPadProcessor, csc_g, disableME1a_, disableME42_, MillePedeFileConverter_cfg::e, gem_g, CSCBaseboard::getCSCName(), infoV, CSCBadChambers::isInBadChamber(), isSLHC_, LogDebug, LogTrace, m_maxBX_, m_minBX_, m_muonportcard, max_chamber, max_endcap, max_sector, max_station, max_subsector, min_chamber, min_endcap, min_sector, min_station, min_subsector, or, put(), CSCGEMMotherboardME21::readoutLCTs(), CSCMotherboard::readoutLCTs(), CSCUpgradeMotherboard::readoutLCTs(), CSCGEMMotherboardME11::readoutLCTs1a(), CSCMotherboardME11::readoutLCTs1a(), CSCGEMMotherboardME11::readoutLCTs1b(), CSCMotherboardME11::readoutLCTs1b(), mps_fire::result, relativeConstraints::ring, CSCTriggerNumbering::ringFromTriggerLabels(), CSCGEMMotherboardME21::run(), CSCGEMMotherboardME11::run(), CSCMotherboardME11::run(), CSCMotherboard::run(), CSCUpgradeMotherboard::run(), runME11ILT_, runME21ILT_, CSCBaseboard::setCSCGeometry(), CSCGEMMotherboard::setGEMGeometry(), tmb_, and CSCDetId::zendcap().

Referenced by setGEMGeometry().

 {
   // CSC geometry.
   for (int endc = min_endcap; endc <= max_endcap; endc++)
   {
     for (int stat = min_station; stat <= max_station; stat++)
     {
       int numsubs = ((stat == 1) ? max_subsector : 1);
       for (int sect = min_sector; sect <= max_sector; sect++)
       {
         for (int subs = min_subsector; subs <= numsubs; subs++)
         {
           for (int cham = min_chamber; cham <= max_chamber; cham++)
           {
             // extract the ring number
             int ring = CSCTriggerNumbering::ringFromTriggerLabels(stat, cham);
 
             // case when you want to ignore ME42
             if (disableME42_ && stat==4 && ring==2) continue;
 
             CSCMotherboard* tmb = tmb_[endc-1][stat-1][sect-1][subs-1][cham-1].get();
 
             tmb->setCSCGeometry(csc_g);
 
             // actual chamber number =/= trigger chamber number
             int chid = CSCTriggerNumbering::chamberFromTriggerLabels(sect, subs, stat, cham);
 
             // 0th layer means whole chamber.
             CSCDetId detid(endc, stat, ring, chid, 0);
 
             // Run processors only if chamber exists in geometry.
             if (tmb == nullptr || csc_g->chamber(detid) == nullptr) continue;
 
             // Skip chambers marked as bad (usually includes most of ME4/2 chambers;
             // also, there's no ME1/a-1/b separation, it's whole ME1/1)
             if (checkBadChambers_ && badChambers->isInBadChamber(detid)) continue;
 
 
             // running upgraded ME1/1 TMBs
             if (stat==1 && ring==1 && isSLHC_ && !runME11ILT_)
             {
               // run the TMB
               CSCMotherboardME11* tmb11 = static_cast<CSCMotherboardME11*>(tmb);
               if (infoV > 1)
                 LogTrace("CSCTriggerPrimitivesBuilder")<<"CSCTriggerPrimitivesBuilder::build in E:"<<endc<<" S:"<<stat<<" R:"<<ring;
               tmb11->run(wiredc,compdc);
 
               // get all collections
               // all ALCTs, CLCTs, LCTs are written with detid ring = 1, as data did
               // but CLCTs and LCTs are written sperately in ME1a and ME1b, considering whether ME1a is disabled or not
               const std::vector<CSCCorrelatedLCTDigi>& lctV = tmb11->readoutLCTs1b();
               const std::vector<CSCCorrelatedLCTDigi>& lctV1a = tmb11->readoutLCTs1a();
               const std::vector<CSCALCTDigi>& alctV = tmb11->alctProc->readoutALCTs();
               const std::vector<CSCCLCTDigi>& clctV = tmb11->clctProc->readoutCLCTsME1b();
               const std::vector<int> preTriggerBXs = tmb11->clctProc->preTriggerBXs();
               const std::vector<CSCCLCTPreTriggerDigi>& pretriggerV = tmb11->clctProc->preTriggerDigisME1b();
               const std::vector<CSCCLCTDigi>& clctV1a = tmb11->clctProc->readoutCLCTsME1a();
               const std::vector<CSCCLCTPreTriggerDigi>& pretriggerV1a = tmb11->clctProc->preTriggerDigisME1a();
 
               if (infoV > 1)
                   LogTrace("CSCTriggerPrimitivesBuilder")<<"CSCTriggerPrimitivesBuilder:: a="<<alctV.size()<<" c="<<clctV.size()<<" l="<<lctV.size()
                                                      <<" c="<<clctV1a.size()<<" l="<<lctV1a.size();
 
               // ME1/b
 
               if (!(lctV.empty()&&alctV.empty()&&clctV.empty()) and infoV > 1) {
                 LogTrace("L1CSCTrigger")
                   << "CSCTriggerPrimitivesBuilder results in " <<detid;
               }
 
               // put collections in event
               put(lctV, oc_lct, detid, " ME1b LCT digi");
               put(alctV, oc_alct, detid, " ME1b ALCT digi");
               put(clctV, oc_clct, detid, " ME1b CLCT digi");
               put(pretriggerV, oc_pretrigger, detid, " ME1b CLCT pre-trigger digi");
               put(preTriggerBXs, oc_pretrig, detid, " ME1b CLCT pre-trigger BX");
 
               // ME1/a
 
               if (disableME1a_) continue;
 
               CSCDetId detid1a(endc, stat, 4, chid, 0);
 
               if (!(lctV1a.empty() && clctV1a.empty()) and infoV > 1){
                 LogTrace("L1CSCTrigger") << "CSCTriggerPrimitivesBuilder results in " <<detid1a;
               }
 
               // put collections in event, still use detid ring =1
               put(lctV1a, oc_lct, detid, " ME1a LCT digi");
               put(clctV1a, oc_clct, detid, " ME1a CLCT digi");
               put(pretriggerV1a, oc_pretrigger, detid, " ME1a CLCT pre-trigger digi");
             } // upgraded TMB
 
             // running upgraded ME1/1 TMBs with GEMs
             else if (stat==1 && ring==1 && isSLHC_ && runME11ILT_)
             {
               // run the TMB
               CSCGEMMotherboardME11* tmb11GEM = static_cast<CSCGEMMotherboardME11*>(tmb);
               tmb11GEM->setCSCGeometry(csc_g);
               tmb11GEM->setGEMGeometry(gem_g);
               if (infoV > 1)
                   LogTrace("CSCTriggerPrimitivesBuilder")<<"CSCTriggerPrimitivesBuilder::build in E:"<<endc<<" S:"<<stat<<" R:"<<ring;
               tmb11GEM->run(wiredc, compdc, gemPads);
 
               // 0th layer means whole chamber.
               GEMDetId gemId(detid.zendcap(), 1, 1, 0, chid, 0);
 
               // get the collections
               const std::vector<CSCCorrelatedLCTDigi>& lctV = tmb11GEM->readoutLCTs1b();
               const std::vector<CSCCorrelatedLCTDigi>& lctV1a = tmb11GEM->readoutLCTs1a();
               const std::vector<CSCALCTDigi>& alctV = tmb11GEM->alctProc->readoutALCTs();
               const std::vector<CSCCLCTDigi>& clctV = tmb11GEM->clctProc->readoutCLCTsME1b();
               const std::vector<int>& preTriggerBXs = tmb11GEM->clctProc->preTriggerBXs();
               const std::vector<CSCCLCTPreTriggerDigi>& pretriggerV = tmb11GEM->clctProc->preTriggerDigisME1b();
               const std::vector<CSCCLCTDigi>& clctV1a = tmb11GEM->clctProc->readoutCLCTsME1a();
               const std::vector<CSCCLCTPreTriggerDigi>& pretriggerV1a = tmb11GEM->clctProc->preTriggerDigisME1a();
               const std::vector<GEMCoPadDigi>& copads = tmb11GEM->coPadProcessor->readoutCoPads();
 
               // ME1/b
               if (!(lctV.empty()&&alctV.empty()&&clctV.empty()) and infoV > 1) {
                 LogTrace("L1CSCTrigger")
                   << "CSCTriggerPrimitivesBuilder results in " <<detid;
               }
 
               // put collections in event
               put(lctV, oc_lct, detid, " ME1b LCT digi");
               put(alctV, oc_alct, detid, " ME1b ALCT digi");
               put(clctV, oc_clct, detid, " ME1b CLCT digi");
               put(pretriggerV, oc_pretrigger, detid, " ME1b CLCT pre-trigger digi");
               put(preTriggerBXs, oc_pretrig, detid, " ME1b CLCT pre-trigger BX");
               put(copads, oc_gemcopad, gemId, " GEM coincidence pad");
 
               // ME1/a
               if (disableME1a_) continue;
 
               CSCDetId detid1a(endc, stat, 4, chid, 0);
 
               if (!(lctV1a.empty() && clctV1a.empty()) and infoV > 1){
                 LogTrace("L1CSCTrigger") << "CSCTriggerPrimitivesBuilder results in " <<detid1a;
               }
 
               // put collections in event, still use detid ring =1
               put(lctV1a, oc_lct, detid, " ME1a LCT digi");
               put(clctV1a, oc_clct, detid, " ME1a CLCT digi");
               put(pretriggerV1a, oc_pretrigger, detid, " ME1a CLCT pre-trigger digi");
             }
 
             // running upgraded ME2/1 TMBs
             else if (stat==2 && ring==1 && isSLHC_ && runME21ILT_)
             {
               // run the TMB
               CSCGEMMotherboardME21* tmb21GEM = static_cast<CSCGEMMotherboardME21*>(tmb);
               tmb21GEM->setCSCGeometry(csc_g);
               tmb21GEM->setGEMGeometry(gem_g);
               tmb21GEM->run(wiredc, compdc, gemPads);
 
               // 0th layer means whole chamber.
               GEMDetId gemId(detid.zendcap(), 1, 2, 0, chid, 0);
 
               // get the collections
               const std::vector<CSCCorrelatedLCTDigi>& lctV = tmb21GEM->readoutLCTs();
               const std::vector<CSCALCTDigi>& alctV = tmb21GEM->alctProc->readoutALCTs();
               const std::vector<CSCCLCTDigi>& clctV = tmb21GEM->clctProc->readoutCLCTs();
               const std::vector<int>& preTriggerBXs = tmb21GEM->clctProc->preTriggerBXs();
               const std::vector<CSCCLCTPreTriggerDigi>& pretriggerV = tmb21GEM->clctProc->preTriggerDigis();
               const std::vector<GEMCoPadDigi>& copads = tmb21GEM->coPadProcessor->readoutCoPads();
 
               if (!(alctV.empty() && clctV.empty() && lctV.empty()) and infoV > 1) {
                 LogTrace("L1CSCTrigger")
                   << "CSCTriggerPrimitivesBuilder got results in " <<detid;
               }
 
               // put collections in event
               put(lctV, oc_lct, detid, " ME21 LCT digi");
               put(alctV, oc_alct, detid, " ME21 ALCT digi");
               put(clctV, oc_clct, detid, " ME21 CLCT digi");
               put(pretriggerV, oc_pretrigger, detid, " ME21 CLCT pre-trigger digi");
               put(preTriggerBXs, oc_pretrig, detid, " ME21 CLCT pre-trigger BX");
               put(copads, oc_gemcopad, gemId, " GEM coincidence pad");
             }
             // running upgraded ME2/1-ME3/1-ME4/1 TMBs (without GEMs or RPCs)
             else if ((stat==2 or stat==3 or stat==4) && ring==1 && isSLHC_)
             {
               // run the TMB
               CSCUpgradeMotherboard* utmb = static_cast<CSCUpgradeMotherboard*>(tmb);
               utmb->setCSCGeometry(csc_g);
               utmb->run(wiredc, compdc);
 
               // get the collections
               const std::vector<CSCCorrelatedLCTDigi>& lctV = utmb->readoutLCTs();
               const std::vector<CSCALCTDigi>& alctV = utmb->alctProc->readoutALCTs();
               const std::vector<CSCCLCTDigi>& clctV = utmb->clctProc->readoutCLCTs();
               const std::vector<int>& preTriggerBXs = utmb->clctProc->preTriggerBXs();
               const std::vector<CSCCLCTPreTriggerDigi>& pretriggerV = utmb->clctProc->preTriggerDigis();
 
               if (!(alctV.empty() && clctV.empty() && lctV.empty()) and infoV > 1) {
                 LogTrace("L1CSCTrigger")
                   << "CSCTriggerPrimitivesBuilder got results in " <<detid;
               }
 
               // put collections in event
               put(lctV, oc_lct, detid, " LCT digi");
               put(alctV, oc_alct, detid, " ALCT digi");
               put(clctV, oc_clct, detid, " CLCT digi");
               put(pretriggerV, oc_pretrigger, detid, " CLCT pre-trigger digi");
               put(preTriggerBXs, oc_pretrig, detid, " CLCT pre-trigger BX");
             }
 
             // running non-upgraded TMB
             else
             {
               // run the TMB
               tmb->run(wiredc,compdc);
 
               // get the collections
               const std::vector<CSCCorrelatedLCTDigi>& lctV = tmb->readoutLCTs();
               const std::vector<CSCALCTDigi>& alctV = tmb->alctProc->readoutALCTs();
               const std::vector<CSCCLCTDigi>& clctV = tmb->clctProc->readoutCLCTs();
               const std::vector<int>& preTriggerBXs = tmb->clctProc->preTriggerBXs();
               const std::vector<CSCCLCTPreTriggerDigi>& pretriggerV = tmb->clctProc->preTriggerDigis();
 
               if (!(alctV.empty() && clctV.empty() && lctV.empty()) and infoV > 1) {
                 LogTrace("L1CSCTrigger")
                   << "CSCTriggerPrimitivesBuilder got results in " <<detid;
               }
 
               // put collections in event
               put(lctV, oc_lct, detid, tmb->getCSCName() + " LCT digi");
               put(alctV, oc_alct, detid, tmb->getCSCName() + " ALCT digi");
               put(clctV, oc_clct, detid, tmb->getCSCName() + " CLCT digi");
               put(pretriggerV, oc_pretrigger, detid, tmb->getCSCName() + " CLCT pre-trigger digi");
               put(preTriggerBXs, oc_pretrig, detid, tmb->getCSCName() + " CLCT pre-trigger BX");
             } // non-upgraded TMB
           }
         }
       }
     }
   }
 
   // run MPC simulation
   m_muonportcard->loadDigis(oc_lct);
 
   // sort the LCTs per sector
   // insert them into the result vector
   std::vector<csctf::TrackStub> result;
   for(int bx = m_minBX_; bx <= m_maxBX_; ++bx)
     for(int e = min_endcap; e <= max_endcap; ++e)
       for(int st = min_station; st <= max_station; ++st)
         for(int se = min_sector; se <= max_sector; ++se)
         {
           if(st == 1)
           {
             std::vector<csctf::TrackStub> subs1, subs2;
             subs1 = m_muonportcard->sort(e, st, se, 1, bx);
             subs2 = m_muonportcard->sort(e, st, se, 2, bx);
             result.insert(result.end(), subs1.begin(), subs1.end());
             result.insert(result.end(), subs2.begin(), subs2.end());
           }
           else
           {
             std::vector<csctf::TrackStub> sector;
             sector = m_muonportcard->sort(e, st, se, 0, bx);
             result.insert(result.end(), sector.begin(), sector.end());
           }
         }
 
   // now convert csctf::TrackStub back into CSCCorrelatedLCTDigi
   // put MPC stubs into the event
   std::vector<csctf::TrackStub>::const_iterator itr = result.begin();
   for (; itr != result.end(); itr++)
   {
     oc_sorted_lct.insertDigi(CSCDetId(itr->getDetId().rawId()), *(itr->getDigi()));
     if (infoV > 1)
       LogDebug("L1CSCTrigger")
         << "MPC " << *(itr->getDigi()) << " found in ME"
         << ((itr->endcap() == 1) ? "+" : "-") << itr->station() << "/"
         << CSCDetId(itr->getDetId().rawId()).ring() << "/"
         << CSCDetId(itr->getDetId().rawId()).chamber()
         << " (sector " << itr->sector()
         << " trig id. " << itr->cscid() << ")" << "\n";
   }
 }

template<class T , class S >

void CSCTriggerPrimitivesBuilder::put	(	const T &	t,
		S &	s,
		const CSCDetId &	detid,
		std::string	comment
	)

private

template function to put data in the output helps to reduce the large amount of code duplication!

Definition at line 150 of file CSCTriggerPrimitivesBuilder.h.

References LogTrace.

Referenced by build().

 {
   if (!t.empty()) {
     LogTrace("L1CSCTrigger")
       << "Put " << t.size() << comment
       << ((t.size() > 1) ? "s " : " ") << "in collection\n";
     s.put(std::make_pair(t.begin(),t.end()), detid);
   }
 }

void CSCTriggerPrimitivesBuilder::setConfigParameters ( const CSCDBL1TPParameters * conf )

Sets configuration parameters obtained via EventSetup mechanism.

Definition at line 104 of file CSCTriggerPrimitivesBuilder.cc.

References relativeConstraints::cham, max_chamber, max_endcap, max_sector, max_station, max_subsector, min_chamber, min_endcap, min_sector, min_station, min_subsector, and tmb_.

 {
   // Receives CSCDBL1TPParameters percolated down from ESProducer.
 
   for (int endc = min_endcap; endc <= max_endcap; endc++)
   {
     for (int stat = min_station; stat <= max_station; stat++)
     {
       int numsubs = ((stat == 1) ? max_subsector : 1);
       for (int sect = min_sector; sect <= max_sector; sect++)
       {
         for (int subs = min_subsector; subs <= numsubs; subs++)
         {
           for (int cham = min_chamber; cham <= max_chamber; cham++)
           {
             tmb_[endc-1][stat-1][sect-1][subs-1][cham-1]->setConfigParameters(conf);
           }
         }
       }
     }
   }
 }

void CSCTriggerPrimitivesBuilder::setCSCGeometry ( const CSCGeometry * g )

inline

set CSC and GEM geometries for the matching needs

Definition at line 56 of file CSCTriggerPrimitivesBuilder.h.

References csc_g, and g.

56 { csc_g = g; }

g

The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g

Definition: Activities.doc:4

CSCTriggerPrimitivesBuilder::csc_g

const CSCGeometry * csc_g

Definition: CSCTriggerPrimitivesBuilder.h:142

void CSCTriggerPrimitivesBuilder::setGEMGeometry ( const GEMGeometry * g )

inline

Definition at line 57 of file CSCTriggerPrimitivesBuilder.h.

References build(), g, and gem_g.

57 { gem_g = g; }

g

The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g

Definition: Activities.doc:4

CSCTriggerPrimitivesBuilder::gem_g

const GEMGeometry * gem_g

Definition: CSCTriggerPrimitivesBuilder.h:143