NSWL1::PadEmulatorTool Class Reference

#include <PadEmulatorTool.h>

Inheritance diagram for NSWL1::PadEmulatorTool:

Public Member Functions
	PadEmulatorTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~PadEmulatorTool () override=default
virtual StatusCode	initialize () override
StatusCode	loadPatterns (const std::string &pfile)
StatusCode	maskPads ()
StatusCode	maskPatterns ()
StatusCode	createRobIDs ()
virtual StatusCode	attachBranches (MuonVal::MuonTesterTree &tree) override
virtual StatusCode	emulate (const EventContext &ctx, Muon::NSW_PadTriggerDataContainer *out) const override
std::vector< uint32_t >	getForbiddenBandIDs (const std::vector< PadEmulatorTrigger > &triggers, const bool isLarge) const
std::vector< PadEmulatorTrigger >	filterPriorityEncoder (const std::vector< PadEmulatorTrigger > &input, const bool isLarge) const
std::vector< PadEmulatorTrigger >	filterLowBandIDs (const std::vector< PadEmulatorTrigger > &input) const
std::vector< PadEmulatorTrigger >	filterLastPhiOnly (const std::vector< PadEmulatorTrigger > &input) const
std::vector< PadEmulatorTrigger >	filterDuplicates (const std::vector< PadEmulatorTrigger > &input) const

Private Attributes
Gaudi::Property< bool >	m_isMC {this, "IsMC", true, "This is MC"}
Gaudi::Property< bool >	m_doNtuple {this, "DoNtuple", false, "Save trigger information into the analysis flat ntuple"}
Gaudi::Property< unsigned short >	m_stretch {this, "BCstretch", 2, "Number of BCIDs to stretch pad trigger hits"}
Gaudi::Property< bool >	m_ignoreBCIDs {this, "IgnoreBCIDs", false, "Ignore hit BCIDs"}
Gaudi::Property< bool >	m_lastPhiOnly {this, "LastPhiOnly", false, "Have phi bias in real data"}
Gaudi::Property< bool >	m_bandIDPriorityEncode {this, "bandIDPriorityEncode", true, "Have band ID bias"}
Gaudi::Property< bool >	m_noDuplicates {this, "noDuplicates", false, "Remove trigger candidate duplicates"}
Gaudi::Property< std::string >	m_triggerLogic {this, "triggerLogic", "specific5over8", "Other options: 3and1, 2and2, 4over8, specific4over8, 5over8, superspecific5over8, 6over8, 2x3over4, 8over8"}
Gaudi::Property< std::string >	m_pattername_L
Gaudi::Property< std::string >	m_pattername_S
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_detectorManagerKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of MuonDetectorManager condition data"}
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::ReadHandleKey< sTgcDigitContainer >	m_sTGCDigitContainerKey = {this, "sTGC_DigitContainerName", "sTGC_DIGITS_L1", "Name of the sTGC digit container"}
SG::ReadCondHandleKey< NswDcsDbData >	m_dcsKey {this, "DCSDataKey", "NswDcsDbData", "Read key for the NSW DCS data"}
std::vector< uint32_t >	m_robIDs
std::vector< PadPattern >	m_patterns_L
std::vector< PadPattern >	m_patterns_S
std::map< std::string, std::vector< std::tuple< uint32_t, uint32_t > > >	m_maskedPatterns
std::shared_ptr< MuonVal::VectorBranch< int > > m_padTrigger_digits_sector	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< int > > m_padTrigger_digits_eta	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< int > > m_padTrigger_digits_phi	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< int > > m_padTrigger_digits_multilayer	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< int > > m_padTrigger_digits_gasgap	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint32_t > > m_padTrigger_digits_source_id	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint32_t > > m_padTrigger_digits_pfeb	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint32_t > > m_padTrigger_digits_pad_channel	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint32_t > > m_padTrigger_digits_relbcid	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint8_t > > m_padTrigger_TP_R_id_init	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint8_t > > m_padTrigger_TP_phi_id_init	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint32_t > > m_padTrigger_TP_relbcid_init	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint8_t > > m_padTrigger_TP_R_id	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint8_t > > m_padTrigger_TP_phi_id	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint32_t > > m_padTrigger_TP_relbcid	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< char > > m_padTrigger_wheel	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint32_t > > m_padTrigger_sector	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint32_t > > m_padTrigger_hitmask	ATLAS_THREAD_SAFE {}
std::shared_ptr< MuonVal::VectorBranch< uint32_t > > m_padTrigger_efficiency	ATLAS_THREAD_SAFE {}

Detailed Description

Definition at line 42 of file PadEmulatorTool.h.

Constructor & Destructor Documentation

PadEmulatorTool()

PadEmulatorTool::PadEmulatorTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 8 of file PadEmulatorTool.cxx.

                                                                                                         :
  base_class(type,name,parent) {}

~PadEmulatorTool()

virtual NSWL1::PadEmulatorTool::~PadEmulatorTool ( )

overridevirtualdefault

Member Function Documentation

attachBranches()

StatusCode PadEmulatorTool::attachBranches ( MuonVal::MuonTesterTree & tree )

overridevirtual

Definition at line 48 of file PadEmulatorTool.cxx.

                                                                        {
    m_padTrigger_digits_sector = std::make_shared<MuonVal::VectorBranch<int> >(tree, "sTGC_PadTrigger_digits_sector");
    m_padTrigger_digits_eta = std::make_shared<MuonVal::VectorBranch<int> >(tree, "sTGC_PadTrigger_digits_eta");
    m_padTrigger_digits_phi = std::make_shared<MuonVal::VectorBranch<int> >(tree, "sTGC_PadTrigger_digits_phi");
    m_padTrigger_digits_multilayer = std::make_shared<MuonVal::VectorBranch<int> >(tree, "sTGC_PadTrigger_digits_multilayer");
    m_padTrigger_digits_gasgap = std::make_shared<MuonVal::VectorBranch<int> >(tree, "sTGC_PadTrigger_digits_gasgap");
    m_padTrigger_digits_source_id = std::make_shared<MuonVal::VectorBranch<uint32_t> >(tree, "sTGC_PadTrigger_digits_source_id");
    m_padTrigger_digits_pfeb = std::make_shared<MuonVal::VectorBranch<uint32_t> >(tree, "sTGC_PadTrigger_digits_pfeb");
    m_padTrigger_digits_pad_channel = std::make_shared<MuonVal::VectorBranch<uint32_t> >(tree, "sTGC_PadTrigger_digits_padchannel");
    m_padTrigger_digits_relbcid = std::make_shared<MuonVal::VectorBranch<uint32_t> >(tree, "sTGC_PadTrigger_digits_relbcid");
    m_padTrigger_TP_R_id_init = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "sTGC_PadTrigger_TP_R_id_init");
    m_padTrigger_TP_phi_id_init = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "sTGC_PadTrigger_TP_phi_id_init");
    m_padTrigger_TP_relbcid_init = std::make_shared<MuonVal::VectorBranch<uint32_t> >(tree, "sTGC_PadTrigger_TP_relbcid_init");
    m_padTrigger_TP_R_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "sTGC_PadTrigger_TP_R_id");
    m_padTrigger_TP_phi_id = std::make_shared<MuonVal::VectorBranch<uint8_t> >(tree, "sTGC_PadTrigger_TP_phi_id");
    m_padTrigger_TP_relbcid = std::make_shared<MuonVal::VectorBranch<uint32_t> >(tree, "sTGC_PadTrigger_TP_relbcid");
    m_padTrigger_wheel = std::make_shared<MuonVal::VectorBranch<char> >(tree, "sTGC_PadTrigger_wheel");
    m_padTrigger_sector = std::make_shared<MuonVal::VectorBranch<uint32_t> >(tree, "sTGC_PadTrigger_sector");
    m_padTrigger_hitmask  = std::make_shared<MuonVal::VectorBranch<uint32_t> >(tree, "sTGC_PadTrigger_hitmask");
    m_padTrigger_efficiency = std::make_shared<MuonVal::VectorBranch<uint32_t> >(tree, "sTGC_PadTrigger_efficiency");
 
    tree.addBranch(m_padTrigger_digits_sector);
    tree.addBranch(m_padTrigger_digits_eta);
    tree.addBranch(m_padTrigger_digits_phi);
    tree.addBranch(m_padTrigger_digits_multilayer);
    tree.addBranch(m_padTrigger_digits_gasgap);
    tree.addBranch(m_padTrigger_digits_source_id);
    tree.addBranch(m_padTrigger_digits_pfeb);
    tree.addBranch(m_padTrigger_digits_pad_channel);
    tree.addBranch(m_padTrigger_digits_relbcid);
    tree.addBranch(m_padTrigger_TP_R_id_init);
    tree.addBranch(m_padTrigger_TP_phi_id_init);
    tree.addBranch(m_padTrigger_TP_relbcid_init);
    tree.addBranch(m_padTrigger_TP_R_id);
    tree.addBranch(m_padTrigger_TP_phi_id);
    tree.addBranch(m_padTrigger_TP_relbcid);
    tree.addBranch(m_padTrigger_wheel);
    tree.addBranch(m_padTrigger_sector);
    tree.addBranch(m_padTrigger_hitmask);
    tree.addBranch(m_padTrigger_efficiency);
 
    return StatusCode::SUCCESS;
  }

createRobIDs()

StatusCode PadEmulatorTool::createRobIDs

(

)

Definition at line 558 of file PadEmulatorTool.cxx.

                                           {
    for(const auto& wheel : NSWL1::WHEELS) {
      for(const auto& sector: NSWL1::PAD::SECTORS) {
        m_robIDs.emplace_back(((wheel == "A" ? NSWL1::PAD::MUON_STGC_ENDCAP_A_SIDE : NSWL1::PAD::MUON_STGC_ENDCAP_C_SIDE) << 16) | NSWL1::PAD::PAD_TRIGGER_ROB | sector);
      }
    }
    return StatusCode::SUCCESS;
  }

emulate()

StatusCode PadEmulatorTool::emulate ( const EventContext & ctx, Muon::NSW_PadTriggerDataContainer * out ) const

overridevirtual

Definition at line 95 of file PadEmulatorTool.cxx.

                                                                                                         {
 
    SG::ReadCondHandle<MuonGM::MuonDetectorManager> detManager{m_detectorManagerKey, ctx};
    if(!detManager.isValid()){
      ATH_MSG_ERROR("Failed to retrieve the MuonDetectorManager conditions object");
      return StatusCode::FAILURE;
    }
 
    SG::ReadHandle<sTgcDigitContainer> sTGCdigits(m_sTGCDigitContainerKey, ctx);
    if(!sTGCdigits.isValid()) {
      ATH_MSG_ERROR("Failed to retrieve the sTGC Digit container");
      return StatusCode::FAILURE;
    }
 
    const NswDcsDbData* dcsData = nullptr;
    if(!m_isMC) {
      SG::ReadCondHandle<NswDcsDbData> dcsDataHandle{m_dcsKey, ctx};
      if(!dcsDataHandle.isValid()) {
        ATH_MSG_ERROR("Failed to retrieve DCS data while running on data");
        return StatusCode::FAILURE;
      }
      dcsData = dcsDataHandle.cptr();
    }
 
    const std::array<uint16_t, 8> bcWindow = {0, 1, 2, 3, 4, UINT16_MAX-1, UINT16_MAX-2, UINT16_MAX-3};
    for(const sTgcDigitCollection* digitCollection : *sTGCdigits) {
 
      std::vector<uint32_t> hits_sourceid{}, hits_pfeb{}, hits_padchan{}, hits_relbcid{};
      for(const sTgcDigit* digit : *digitCollection) {
        if(m_idHelperSvc->stgcIdHelper().channelType(digit->identify()) == sTgcIdHelper::sTgcChannelTypes::Pad) {
          if(std::find(bcWindow.begin(), bcWindow.end(), digit->bcTag()) != bcWindow.end()) {
            const Identifier Id = digit->identify();
            if(!m_isMC) {
              if(!dcsData->isConnectedChannel(Id) or !dcsData->isGood(ctx, Id) or !dcsData->isGoodHv(Id) or !dcsData->isGoodEltx(Id)) continue;
              bool disabled = false;
              if(!dcsData->isGoodTDaq(ctx,Id,disabled)) continue;
            }
 
            const int stEta = m_idHelperSvc->stationEta(Id);
            const int stPhi = m_idHelperSvc->stationPhi(Id);
            const int multilayer = m_idHelperSvc->stgcIdHelper().multilayer(Id);
            const int gasGap = m_idHelperSvc->stgcIdHelper().gasGap(Id);
            const int channel = m_idHelperSvc->stgcIdHelper().channel(Id);
            ATH_MSG_DEBUG("Digit: " << m_idHelperSvc->toString(Id) << " - BC: " << digit->bcTag());
 
            // Source ID retrieval: Pad Trigger logic needs sector number starting from 0
            int sector = m_idHelperSvc->sector(Id)-1;
            const char wheel = (stEta > 0) ? 'A' : 'C';
            auto sourceid = NSWL1::PAD::wheelSectorToSourceID(wheel, sector);
            hits_sourceid.emplace_back(sourceid);
 
            // pFEB retrieval
            auto pfeb = NSWL1::PAD::getpFEBAthena(gasGap, multilayer, stEta);
            hits_pfeb.emplace_back(pfeb);
 
            // padChannel retrieval: no check on the Type, as already done by selecting PAD digits only
            auto padchan = NSWL1::PAD::getPadchAthena(channel, pfeb, sector, gasGap);
            hits_padchan.emplace_back(padchan);
 
            // BC retrieval
            hits_relbcid.emplace_back(digit->bcTag());
 
            if(m_doNtuple) {
              m_padTrigger_digits_sector->push_back(sector);
              m_padTrigger_digits_eta->push_back(stEta);
              m_padTrigger_digits_phi->push_back(stPhi);
              m_padTrigger_digits_multilayer->push_back(multilayer);
              m_padTrigger_digits_gasgap->push_back(gasGap);
              m_padTrigger_digits_source_id->push_back(sourceid);
              m_padTrigger_digits_pfeb->push_back(pfeb);
              m_padTrigger_digits_pad_channel->push_back(padchan);
              m_padTrigger_digits_relbcid->push_back(digit->bcTag());
            }
          }
        }
      }
      ATH_MSG_DEBUG("Processed sTGC digit collection with size " << digitCollection->size() << ", finding a total of " << hits_sourceid.size() << " pad hits");
 
      for(const auto &rob : m_robIDs) {
        if(hits_sourceid.empty() or hits_pfeb.empty() or hits_padchan.empty() or hits_relbcid.empty()) continue;
 
        // Find robID
        std::vector<uint32_t> hits_indices{};
        for(size_t index{0}; index < hits_sourceid.size(); ++index) {
          if(hits_sourceid.at(index) == rob) hits_indices.emplace_back(index);
        }
 
        if(hits_indices.empty()) continue;
  
        // Preprocessing
        const auto& sourceid = hits_sourceid.at(hits_indices.front());
        const bool isLarge = (sourceid % 2 == 0);
        const bool isA = NSWL1::isA(sourceid);
        const char whl = isA ? 'A' : 'C';
        const auto sec = (sourceid & 0xf);  // last 4 bits of the sourceID are sector number (0-15)
        const auto& patterns = isLarge ? m_patterns_L : m_patterns_S;
        std::vector<uint32_t> masks(patterns.size() * NSWL1::PAD::PAD_TRIGGER_READOUT_NBC);
 
        // Loop over available hits
        for(const auto& index: hits_indices) {
          const auto& pfeb = hits_pfeb.at(index);
          const auto& chan = hits_padchan.at(index);
          const auto& bcid = m_ignoreBCIDs ? 0 : hits_relbcid.at(index);
          ATH_MSG_DEBUG("PadTrigger sector " << whl << sec+1 << std::dec << " -> Hit " << index << " pfeb " << pfeb << " padchan " << chan << " bcid " << bcid);
 
          /* What we are getting here:
           * producing a vector with size # of patterns * number of bunch crossings
           * so we have pattern A BCID 0, pattern B BCID 0,..., pattern A BCID 1, pattern B BCID 1
           * pattern A BCID 0 = 00000000 if no layers were hit, 00010101 if layers 0, 2, and 4 were hit
           * for each hit, find the patterns it belongs to
           * then for the corresponding bcid and the ones within stretch, mark the layer as hit
           */
          const auto layer = (pfeb % NSWL1::PAD::NPFEB_PER_RADIUS);
          for(size_t it{0}; it < patterns.size(); ++it) {
            if(patterns.at(it).getPfebs().at(layer) == pfeb and patterns.at(it).getPadChannels().at(layer) == chan) {
              for(uint32_t bc{bcid}; bc <= bcid + m_stretch; ++bc) {
                if(bc >= NSWL1::PAD::PAD_TRIGGER_READOUT_NBC) break;
                masks.at(it + bc*patterns.size()) |= (1 << layer);
              }
            }
          }
        }
 
        // Checking for problems/transitionregions/pads that are masked to 1
        std::string secstr = whl + std::to_string(sec+1);
        if(m_maskedPatterns.find(secstr) != m_maskedPatterns.end()) {
          for(const auto& [patind, tomask] : m_maskedPatterns.at(secstr)) {
            for(size_t bcid{0}; bcid < NSWL1::PAD::PAD_TRIGGER_READOUT_NBC; ++bcid) {
              masks.at(patind + bcid*patterns.size()) |= tomask;
            }
          }
        }
 
        // Check coincidences
        for(size_t relbcid{0}; relbcid < NSWL1::PAD::PAD_TRIGGER_READOUT_NBC; ++relbcid) {
          if(m_ignoreBCIDs and relbcid > 0) continue;
 
          bool isTrigger;
          std::vector<PadEmulatorTrigger> triggersBc{};
          for (size_t it{0}; it < patterns.size(); ++it) {
            const auto& pattern = patterns.at(it);
            const uint32_t hitmask = masks.at(it + relbcid*patterns.size());
            if(m_triggerLogic == "4over8") {
              isTrigger = trigger_4over8(hitmask & 0x01, hitmask & 0x02, hitmask & 0x04, hitmask & 0x08,
                                         hitmask & 0x10, hitmask & 0x20, hitmask & 0x40, hitmask & 0x80);
            }
            else if(m_triggerLogic == "3and1") {
              isTrigger = trigger_3and1(hitmask & 0x01, hitmask & 0x02, hitmask & 0x04, hitmask & 0x08,
                                        hitmask & 0x10, hitmask & 0x20, hitmask & 0x40, hitmask & 0x80);
            }
            else if(m_triggerLogic == "2and2") {
              isTrigger = trigger_2and2(hitmask & 0x01, hitmask & 0x02, hitmask & 0x04, hitmask & 0x08,
                                        hitmask & 0x10, hitmask & 0x20, hitmask & 0x40, hitmask & 0x80);
            }
            else if(m_triggerLogic == "specific4over8") {
              isTrigger = trigger_specific4over8(hitmask & 0x01, hitmask & 0x02, hitmask & 0x04, hitmask & 0x08,
                                                 hitmask & 0x10, hitmask & 0x20, hitmask & 0x40, hitmask & 0x80);
            }
            else if(m_triggerLogic == "5over8") {
              isTrigger = trigger_5over8(hitmask & 0x01, hitmask & 0x02, hitmask & 0x04, hitmask & 0x08,
                                         hitmask & 0x10, hitmask & 0x20, hitmask & 0x40, hitmask & 0x80);
            }
            else if(m_triggerLogic == "specific5over8") {
              isTrigger = trigger_specific5over8(hitmask & 0x01, hitmask & 0x02, hitmask & 0x04, hitmask & 0x08,
                                                 hitmask & 0x10, hitmask & 0x20, hitmask & 0x40, hitmask & 0x80);
            }
            else if(m_triggerLogic == "superspecific5over8") {
              isTrigger = trigger_superspecific5over8(hitmask & 0x01, hitmask & 0x02, hitmask & 0x04, hitmask & 0x08,
                                                      hitmask & 0x10, hitmask & 0x20, hitmask & 0x40, hitmask & 0x80);
            }
            else if(m_triggerLogic == "2x3over4") {
              isTrigger = trigger_2X_3over4(hitmask & 0x01, hitmask & 0x02, hitmask & 0x04, hitmask & 0x08,
                                            hitmask & 0x10, hitmask & 0x20, hitmask & 0x40, hitmask & 0x80);
            }
            else if(m_triggerLogic == "6over8") {
              isTrigger = trigger_6over8(hitmask & 0x01, hitmask & 0x02, hitmask & 0x04, hitmask & 0x08,
                                         hitmask & 0x10, hitmask & 0x20, hitmask & 0x40, hitmask & 0x80);
            }
            else if(m_triggerLogic == "8over8") {
              isTrigger = trigger_8over8(hitmask & 0x01, hitmask & 0x02, hitmask & 0x04, hitmask & 0x08,
                                         hitmask & 0x10, hitmask & 0x20, hitmask & 0x40, hitmask & 0x80);
            }
            else {
              ATH_MSG_ERROR("Unknown sTGC Pad Trigger logic!");
              return StatusCode::FAILURE;
            }
            if(not isTrigger) continue;
 
            // Save the output
            triggersBc.emplace_back(
                PadEmulatorTrigger(whl, sec, pattern.getBandid(), pattern.getPhiid(isA), relbcid, pattern, hitmask)
            );
          } // Closing loop on patterns
          if(m_doNtuple) {
            m_padTrigger_efficiency->push_back(triggersBc.size());
            for(const auto& trigger : triggersBc) {
              if(relbcid != trigger.getRelbcid()) continue;
              m_padTrigger_TP_R_id_init->push_back(trigger.getBandid());
              m_padTrigger_TP_phi_id_init->push_back(trigger.getPhiid());
              m_padTrigger_TP_relbcid_init->push_back(trigger.getRelbcid());
            }
          }
 
          // Filter output: eta bias
          triggersBc = (m_bandIDPriorityEncode) ? filterPriorityEncoder(triggersBc, isLarge) : filterLowBandIDs(triggersBc);
          if(m_doNtuple) m_padTrigger_efficiency->push_back(triggersBc.size());
 
          // Filter output: phi bias
          if(m_lastPhiOnly) triggersBc = filterLastPhiOnly(triggersBc);
          if(m_doNtuple) m_padTrigger_efficiency->push_back(triggersBc.size());
 
          // Filter output: duplicates of triggers with the same band and phi IDs in the same BC
          if(m_noDuplicates) triggersBc = filterDuplicates(triggersBc);
          if(m_doNtuple) m_padTrigger_efficiency->push_back(triggersBc.size());
 
          // Save the filtered output in the final container, for coincidence checks in the SL
          if(not triggersBc.empty()) {
            auto newCollection = new Muon::NSW_PadTriggerData(isA, sec, relbcid, 0);
            for(const auto& trigger : triggersBc) {
              if(relbcid != trigger.getRelbcid()) continue;
              newCollection->addTrigger(trigger.getBandid(), trigger.getPhiid(), 0);
              if(m_doNtuple) {
                m_padTrigger_TP_R_id->push_back(trigger.getBandid());
                m_padTrigger_TP_phi_id->push_back(trigger.getPhiid());
                m_padTrigger_TP_relbcid->push_back(trigger.getRelbcid());
                m_padTrigger_wheel->push_back(trigger.getWheel());
                m_padTrigger_sector->push_back(trigger.getSector());
                m_padTrigger_hitmask->push_back(trigger.getHitMask());
              }
            }
            if(out->addCollection(newCollection, out->numberOfCollections()).isFailure()) {
              ATH_MSG_ERROR("Failed while storing output in the Muon::NSW_PadTriggerDataContainer");
              return StatusCode::FAILURE;
            }
          }
        } // Closing loop on relative BCIDs
      } // Closing loop on ROBs
    } // Closing loop on digit collections
    return StatusCode::SUCCESS;
  }

filterDuplicates()

std::vector< PadEmulatorTrigger > PadEmulatorTool::filterDuplicates

(

const std::vector< PadEmulatorTrigger > &

input

)

const

Definition at line 407 of file PadEmulatorTool.cxx.

                                                                                                                  {
    if(input.empty()) return {};
 
    std::vector<PadEmulatorTrigger> output{};
    for(const auto& trigger : input) {
      if(std::any_of(output.cbegin(), output.cend(), [&](const auto& cmp) {
        return trigger.getBandid() == cmp.getBandid() and trigger.getPhiid() == cmp.getPhiid();
        })) continue;
      output.emplace_back(trigger);
    }
    return output;
  }

filterLastPhiOnly()

std::vector< PadEmulatorTrigger > PadEmulatorTool::filterLastPhiOnly

(

const std::vector< PadEmulatorTrigger > &

input

)

const

Definition at line 390 of file PadEmulatorTool.cxx.

                                                                                                                   {
    if(input.empty()) return {};
 
    std::map<uint32_t, std::vector<uint32_t> > phisPerBand{};
    for(const auto& trigger : input) {
      phisPerBand.try_emplace(trigger.getBandid(), std::vector<uint32_t>());
      phisPerBand.at(trigger.getBandid()).emplace_back(trigger.getPhiid());
    }
 
    std::vector<PadEmulatorTrigger> output{};
    for(const auto& trigger : input) {
      if(trigger.getPhiid() != phisPerBand.at(trigger.getBandid()).back()) continue;
      output.emplace_back(trigger);
    }
    return output;
  }

filterLowBandIDs()

std::vector< PadEmulatorTrigger > PadEmulatorTool::filterLowBandIDs

(

const std::vector< PadEmulatorTrigger > &

input

)

const

Definition at line 378 of file PadEmulatorTool.cxx.

                                                                                                                  {
    if(input.empty()) return {};
 
    std::vector<PadEmulatorTrigger> output{};
    const std::set<uint32_t> forbiddens{0, 1, 2, 3, 4, 5};
    for(const auto& trigger : input) {
      if(NSWL1::PAD::contains(forbiddens, trigger.getBandid())) continue;
      output.emplace_back(trigger);
    }
    return output;
  }

filterPriorityEncoder()

std::vector< PadEmulatorTrigger > PadEmulatorTool::filterPriorityEncoder	(	const std::vector< PadEmulatorTrigger > &	input,
		const bool	isLarge ) const

Definition at line 365 of file PadEmulatorTool.cxx.

                                                                                                   {
    if(input.empty()) return {};
 
    std::vector<PadEmulatorTrigger> output{};
    const auto& forbiddens = getForbiddenBandIDs(input, isLarge);
    for(const auto& trigger: input) {
      if(NSWL1::PAD::contains(forbiddens, trigger.getBandid())) continue;
      output.emplace_back(trigger);
    }
    return output;
  }

getForbiddenBandIDs()

std::vector< uint32_t > PadEmulatorTool::getForbiddenBandIDs	(	const std::vector< PadEmulatorTrigger > &	triggers,
		const bool	isLarge ) const

Definition at line 343 of file PadEmulatorTool.cxx.

                                                                                       {
    std::set<uint32_t> forbiddens{};
    const auto& encoder = isLarge ? NSWL1::PAD::priorityEncoderL : NSWL1::PAD::priorityEncoderS;
 
    std::set<uint32_t> bands{};
    for(const auto& trigger : triggers) bands.emplace(trigger.getBandid());
    auto bandids = std::vector<uint32_t>(bands.cbegin(), bands.cend());
 
    std::sort(bandids.rbegin(), bandids.rend());
    for(const auto& bandid : bandids) {
      if(NSWL1::PAD::contains(forbiddens, bandid)) continue;
 
      for(uint32_t forb{bandid-1}; forb >= encoder(bandid); --forb) forbiddens.emplace(forb);
    }
 
    // bandid less than 6 is forbidden
    for(const auto& bandid : {0, 1, 2, 3, 4, 5}) forbiddens.emplace(bandid);
 
    return std::vector<uint32_t>(forbiddens.cbegin(), forbiddens.cend());
  }

initialize()

StatusCode PadEmulatorTool::initialize ( )

overridevirtual

Definition at line 11 of file PadEmulatorTool.cxx.

                                         {
    ATH_MSG_INFO(           m_isMC.name()                  << " --> " << (m_isMC                  ? "[True]" : "[False]")
                 << ", " << m_doNtuple.name()              << " --> " << (m_doNtuple              ? "[True]" : "[False]")
                 << ", " << m_stretch.name()               << " --> " <<  m_stretch.value()
                 << ", " << m_ignoreBCIDs.name()           << " --> " << (m_ignoreBCIDs           ? "[True]" : "[False]")
                 << ", " << m_lastPhiOnly.name()           << " --> " << (m_lastPhiOnly           ? "[True]" : "[False]")
                 << ", " << m_bandIDPriorityEncode.name()  << " --> " << (m_bandIDPriorityEncode  ? "[True]" : "[False]")
                 << ", " << m_noDuplicates.name()          << " --> " << (m_noDuplicates          ? "[True]" : "[False]")
                 << ", " << m_triggerLogic.name()          << " --> " <<  m_triggerLogic.value()
                 << ", " << m_pattername_L.name()          << " --> " <<  m_pattername_L.value()
                 << ", " << m_pattername_S.name()          << " --> " <<  m_pattername_S.value()                        );
 
    ATH_CHECK(m_idHelperSvc.retrieve());
    ATH_CHECK(m_detectorManagerKey.initialize());
    ATH_CHECK(m_sTGCDigitContainerKey.initialize());
    ATH_CHECK(m_dcsKey.initialize(!m_isMC));
 
    // Read pattern file for large and small sectors
    ATH_CHECK(loadPatterns(m_pattername_L.value()));
    ATH_CHECK(loadPatterns(m_pattername_S.value()));
 
    // Mask specific patterns according to known issues
    ATH_CHECK(maskPatterns());
 
    // Create ROB IDs
    ATH_CHECK(createRobIDs());
 
    // Do not allow debug ntuple in multi-threaded mode
    if(m_doNtuple and Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents() > 1) {
      ATH_MSG_ERROR("DoNtuple is not possible in multi-threaded mode");
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_DEBUG("Successfully initialized " << name() );
    return StatusCode::SUCCESS;
  }

loadPatterns()

StatusCode PadEmulatorTool::loadPatterns

(

const std::string &

pfile

)

Definition at line 423 of file PadEmulatorTool.cxx.

                                                                 {
    if(pfile.empty()) {
      ATH_MSG_ERROR("Empty filename string for pad pattern file. No pattern will be loaded");
      return StatusCode::FAILURE;
    }
 
    std::ifstream ifs(pfile);
    std::string line;
    if(ifs) {
      bool isLarge = false;
      uint32_t bandid = NSWL1::PAD::DUMMY_BANDID;
      while (not ifs.eof()) {
        std::getline(ifs, line);
        const auto words = CxxUtils::tokenize(line, NSWL1::SPACE);
        ATH_MSG_DEBUG("Got words of size " << words.size());
 
        // check for EOF line
        if(NSWL1::PAD::contains(line, NSWL1::PAD::PATTERN_END)) break;
        ATH_MSG_DEBUG("Not pattern end line ");
 
        // find the current bandID
        if(NSWL1::PAD::contains(line, NSWL1::PAD::PATTERN_TAG)) {
          isLarge = NSWL1::PAD::contains(line, NSWL1::PAD::LARGE);
          bandid = NSWL1::PAD::parseLineForBandid(line);
          continue;
        }
        ATH_MSG_DEBUG("Parsed line for band ID " << bandid << " for large sector " << isLarge);
 
        // skip uninteresting lines
        if(bandid == NSWL1::PAD::DUMMY_BANDID) continue;
        if(NSWL1::PAD::contains(line, NSWL1::SEMICOLON)) continue;
        if(NSWL1::PAD::contains(words, NSWL1::VHDLCOMMENT)) continue;
        if(std::any_of(std::begin(line), std::end(line), [](char c){ return std::isalpha(c); })) continue;
        if(words.size() < NSWL1::NLAYERS) continue;
        ATH_MSG_DEBUG("Skipped uninteresting lines");
 
        // clean up the line
        line = NSWL1::PAD::replace(line, ",", ", ");
        line = NSWL1::PAD::replace(line, "(", " ");
        line = NSWL1::PAD::replace(line, ")", " ");
        line = NSWL1::PAD::replace(line, "0-1", "-1");
        line = NSWL1::PAD::replace(line, " ", "");
        const auto vals = CxxUtils::tokenize(line, NSWL1::COMMA);
        if(vals.size() != NSWL1::PAD::PATTERNLEN) {
          throw std::runtime_error("Can't unpack " + line);
        }
        ATH_MSG_DEBUG("Cleaned up lines");
 
        // unpack the line
        const auto pfeb0    = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PFEB0)));
        const auto pfeb1    = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PFEB1)));
        const auto pfeb2    = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PFEB2)));
        const auto pfeb3    = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PFEB3)));
        const auto pfeb4    = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PFEB4)));
        const auto pfeb5    = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PFEB5)));
        const auto pfeb6    = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PFEB6)));
        const auto pfeb7    = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PFEB7)));
 
        const auto padchan0 = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PADCHAN0)));
        const auto padchan1 = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PADCHAN1)));
        const auto padchan2 = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PADCHAN2)));
        const auto padchan3 = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PADCHAN3)));
        const auto padchan4 = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PADCHAN4)));
        const auto padchan5 = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PADCHAN5)));
        const auto padchan6 = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PADCHAN6)));
        const auto padchan7 = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PADCHAN7)));
        const auto phiid    = static_cast<uint32_t>(std::stoul(vals.at(NSWL1::PAD::I_PHIID)));
 
        // Store the retrieved information
        const std::array<uint32_t,8> pfebs = {pfeb0, pfeb1, pfeb2, pfeb3, pfeb4, pfeb5, pfeb6, pfeb7};
        const std::array<uint32_t,8> padchans = {padchan0, padchan1, padchan2, padchan3, padchan4, padchan5, padchan6, padchan7};
 
        // Save information in the private member of the class
        if(isLarge) m_patterns_L.emplace_back( PadPattern(bandid, phiid, pfebs, padchans, isLarge) );
        else m_patterns_S.emplace_back( PadPattern(bandid, phiid, pfebs, padchans, isLarge) );
        ATH_MSG_DEBUG("Unpacked lines and info stored");
      }
    }
    else {
      ATH_MSG_ERROR("Unable to read pad pattern file. No pattern will be loaded");
      return StatusCode::FAILURE;
    }
    ifs.close();
    ATH_MSG_DEBUG("Successfully loaded list of patterns from " << pfile << " with size (L/S): " << m_patterns_L.size() << " / " << m_patterns_S.size());
    return StatusCode::SUCCESS;
  }

maskPads()

StatusCode NSWL1::PadEmulatorTool::maskPads

(

)

maskPatterns()

StatusCode PadEmulatorTool::maskPatterns

(

)

Definition at line 513 of file PadEmulatorTool.cxx.

                                           {
    std::vector<char> sectorSizes = {'L', 'S'};
    for(const auto& secSize: sectorSizes) {
      const bool isLarge = (secSize == 'L');
      const std::vector<PadPattern> patterns = (isLarge) ? m_patterns_L : m_patterns_S;
      for(uint32_t patternitter{0}; patternitter < patterns.size(); ++patternitter) {
        const auto& pattern = patterns.at(patternitter);
        const auto pads = pattern.getPadChannels();
        uint32_t mask{0};
        bool ipfake = NSWL1::PAD::isDummyPad(pads.at(0));
        bool hofake = NSWL1::PAD::isDummyPad(pads.at(4));
        bool is4layer = (ipfake || hofake);
 
        std::map<std::string, uint32_t> problematicSectors{};
        if(is4layer) {
          int offset = (ipfake) ? 0 : 4;
          mask |= (1 << offset);
          if (m_triggerLogic != "specific4over8") mask |= (1 << (offset + 1));
          if (m_triggerLogic == "8over8" || m_triggerLogic == "2x3over4" || m_triggerLogic == "specific4over8") mask |= (1 << (offset + 2));
          if (m_triggerLogic == "8over8") mask |= (1 << (offset + 3));
          for (const auto& wheel: NSWL1::WHEELS) {
            for (const auto& sector: NSWL1::PAD::SECTORS) {
              if (isLarge != (sector%2 == 0)) continue;
              std::string secname = wheel + std::to_string(sector+1);
              problematicSectors.try_emplace(secname, mask);
            }
          }
        }
 
        if(problematicSectors.empty()) continue;
        for(const auto& sectoritr : problematicSectors) {
          const auto sector = sectoritr.first;
          m_maskedPatterns.try_emplace(sector, std::vector<std::tuple<uint32_t, uint32_t>>());
          m_maskedPatterns.at(sector).push_back(std::make_tuple(patternitter, sectoritr.second));
        }
      }
    }
 
    ATH_MSG_DEBUG("Found a total of " << m_maskedPatterns.size() << " patterns to be masked");
    return StatusCode::SUCCESS;
  }

Member Data Documentation

ATLAS_THREAD_SAFE [1/19]

std::shared_ptr<MuonVal::VectorBranch<int> > m_padTrigger_digits_sector NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 90 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [2/19]

std::shared_ptr<MuonVal::VectorBranch<int> > m_padTrigger_digits_eta NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 91 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [3/19]

std::shared_ptr<MuonVal::VectorBranch<int> > m_padTrigger_digits_phi NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 92 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [4/19]

std::shared_ptr<MuonVal::VectorBranch<int> > m_padTrigger_digits_multilayer NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 93 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [5/19]

std::shared_ptr<MuonVal::VectorBranch<int> > m_padTrigger_digits_gasgap NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 94 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [6/19]

std::shared_ptr<MuonVal::VectorBranch<uint32_t> > m_padTrigger_digits_source_id NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 95 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [7/19]

std::shared_ptr<MuonVal::VectorBranch<uint32_t> > m_padTrigger_digits_pfeb NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 96 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [8/19]

std::shared_ptr<MuonVal::VectorBranch<uint32_t> > m_padTrigger_digits_pad_channel NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 97 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [9/19]

std::shared_ptr<MuonVal::VectorBranch<uint32_t> > m_padTrigger_digits_relbcid NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 98 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [10/19]

std::shared_ptr<MuonVal::VectorBranch<uint8_t> > m_padTrigger_TP_R_id_init NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 99 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [11/19]

std::shared_ptr<MuonVal::VectorBranch<uint8_t> > m_padTrigger_TP_phi_id_init NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 100 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [12/19]

std::shared_ptr<MuonVal::VectorBranch<uint32_t> > m_padTrigger_TP_relbcid_init NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 101 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [13/19]

std::shared_ptr<MuonVal::VectorBranch<uint8_t> > m_padTrigger_TP_R_id NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 102 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [14/19]

std::shared_ptr<MuonVal::VectorBranch<uint8_t> > m_padTrigger_TP_phi_id NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 103 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [15/19]

std::shared_ptr<MuonVal::VectorBranch<uint32_t> > m_padTrigger_TP_relbcid NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 104 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [16/19]

std::shared_ptr<MuonVal::VectorBranch<char> > m_padTrigger_wheel NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 105 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [17/19]

std::shared_ptr<MuonVal::VectorBranch<uint32_t> > m_padTrigger_sector NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 106 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [18/19]

std::shared_ptr<MuonVal::VectorBranch<uint32_t> > m_padTrigger_hitmask NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 107 of file PadEmulatorTool.h.

{};

ATLAS_THREAD_SAFE [19/19]

std::shared_ptr<MuonVal::VectorBranch<uint32_t> > m_padTrigger_efficiency NSWL1::PadEmulatorTool::ATLAS_THREAD_SAFE {}

private

Definition at line 108 of file PadEmulatorTool.h.

{};

m_bandIDPriorityEncode

Gaudi::Property<bool> NSWL1::PadEmulatorTool::m_bandIDPriorityEncode {this, "bandIDPriorityEncode", true, "Have band ID bias"}

private

Definition at line 69 of file PadEmulatorTool.h.

{this, "bandIDPriorityEncode", true,        "Have band ID bias"};

m_dcsKey

SG::ReadCondHandleKey<NswDcsDbData> NSWL1::PadEmulatorTool::m_dcsKey {this, "DCSDataKey", "NswDcsDbData", "Read key for the NSW DCS data"}

private

Definition at line 81 of file PadEmulatorTool.h.

{this, "DCSDataKey", "NswDcsDbData", "Read key for the NSW DCS data"};

m_detectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> NSWL1::PadEmulatorTool::m_detectorManagerKey {this, "DetectorManagerKey", "MuonDetectorManager", "Key of MuonDetectorManager condition data"}

private

Definition at line 78 of file PadEmulatorTool.h.

{this, "DetectorManagerKey", "MuonDetectorManager", "Key of MuonDetectorManager condition data"};

m_doNtuple

Gaudi::Property<bool> NSWL1::PadEmulatorTool::m_doNtuple {this, "DoNtuple", false, "Save trigger information into the analysis flat ntuple"}

private

Definition at line 65 of file PadEmulatorTool.h.

{this, "DoNtuple",             false,       "Save trigger information into the analysis flat ntuple"};

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> NSWL1::PadEmulatorTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 79 of file PadEmulatorTool.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

m_ignoreBCIDs

Gaudi::Property<bool> NSWL1::PadEmulatorTool::m_ignoreBCIDs {this, "IgnoreBCIDs", false, "Ignore hit BCIDs"}

private

Definition at line 67 of file PadEmulatorTool.h.

{this, "IgnoreBCIDs",          false,       "Ignore hit BCIDs"};

m_isMC

Gaudi::Property<bool> NSWL1::PadEmulatorTool::m_isMC {this, "IsMC", true, "This is MC"}

private

Definition at line 64 of file PadEmulatorTool.h.

{this, "IsMC",                 true,        "This is MC"};

m_lastPhiOnly

Gaudi::Property<bool> NSWL1::PadEmulatorTool::m_lastPhiOnly {this, "LastPhiOnly", false, "Have phi bias in real data"}

private

Definition at line 68 of file PadEmulatorTool.h.

{this, "LastPhiOnly",          false,       "Have phi bias in real data"};

m_maskedPatterns

std::map<std::string, std::vector<std::tuple<uint32_t, uint32_t> > > NSWL1::PadEmulatorTool::m_maskedPatterns

private

Definition at line 85 of file PadEmulatorTool.h.

m_noDuplicates

Gaudi::Property<bool> NSWL1::PadEmulatorTool::m_noDuplicates {this, "noDuplicates", false, "Remove trigger candidate duplicates"}

private

Definition at line 70 of file PadEmulatorTool.h.

{this, "noDuplicates",         false,       "Remove trigger candidate duplicates"};

m_pattername_L

Gaudi::Property<std::string> NSWL1::PadEmulatorTool::m_pattername_L

private

Initial value:

{this, "PadPatternameL",
        PathResolver::find_calib_file("sTGCPadTriggerSim/patterns_corrected_large_19_12_2023_impr_07_03_2024_forFW.vhdl"), "Name of the vhdl file with pad patterns for LARGE sectors"}

Definition at line 73 of file PadEmulatorTool.h.

                                               {this, "PadPatternameL",
        PathResolver::find_calib_file("sTGCPadTriggerSim/patterns_corrected_large_19_12_2023_impr_07_03_2024_forFW.vhdl"), "Name of the vhdl file with pad patterns for LARGE sectors"};

m_pattername_S

Gaudi::Property<std::string> NSWL1::PadEmulatorTool::m_pattername_S

private

Initial value:

{this, "PadPatternameS",
        PathResolver::find_calib_file("sTGCPadTriggerSim/patterns_corrected_small_19_12_2023_impr_07_03_2024_forFW.vhdl"), "Name of the vhdl file with pad patterns for SMALL sectors"}

Definition at line 75 of file PadEmulatorTool.h.

                                               {this, "PadPatternameS",
        PathResolver::find_calib_file("sTGCPadTriggerSim/patterns_corrected_small_19_12_2023_impr_07_03_2024_forFW.vhdl"), "Name of the vhdl file with pad patterns for SMALL sectors"};

m_patterns_L

std::vector<PadPattern> NSWL1::PadEmulatorTool::m_patterns_L

private

Definition at line 84 of file PadEmulatorTool.h.

m_patterns_S

std::vector<PadPattern> NSWL1::PadEmulatorTool::m_patterns_S

private

Definition at line 84 of file PadEmulatorTool.h.

m_robIDs

std::vector<uint32_t> NSWL1::PadEmulatorTool::m_robIDs

private

Definition at line 83 of file PadEmulatorTool.h.

m_sTGCDigitContainerKey

SG::ReadHandleKey<sTgcDigitContainer> NSWL1::PadEmulatorTool::m_sTGCDigitContainerKey = {this, "sTGC_DigitContainerName", "sTGC_DIGITS_L1", "Name of the sTGC digit container"}

private

Definition at line 80 of file PadEmulatorTool.h.

{this, "sTGC_DigitContainerName", "sTGC_DIGITS_L1", "Name of the sTGC digit container"};

m_stretch

Gaudi::Property<unsigned short> NSWL1::PadEmulatorTool::m_stretch {this, "BCstretch", 2, "Number of BCIDs to stretch pad trigger hits"}

private

Definition at line 66 of file PadEmulatorTool.h.

{this, "BCstretch",            2,           "Number of BCIDs to stretch pad trigger hits"};

m_triggerLogic

Gaudi::Property<std::string> NSWL1::PadEmulatorTool::m_triggerLogic {this, "triggerLogic", "specific5over8", "Other options: 3and1, 2and2, 4over8, specific4over8, 5over8, superspecific5over8, 6over8, 2x3over4, 8over8"}

private

Definition at line 71 of file PadEmulatorTool.h.

{this, "triggerLogic",         "specific5over8",    "Other options: 3and1, 2and2, 4over8, specific4over8, 5over8, superspecific5over8, 6over8, 2x3over4, 8over8"};

---

The documentation for this class was generated from the following files:

• PadEmulatorTool.h
• PadEmulatorTool.cxx