LVL1TGC::TGCTileMuCoincidenceLUT Class Reference

This class stores the LUT for Tile-Muon coincidence of the Run-3 L1Muon Endcap trigger. More...

#include <TGCTileMuCoincidenceLUT.h>

Collaboration diagram for LVL1TGC::TGCTileMuCoincidenceLUT:

Public Types
enum	TileMuMask {   TM_NA = 0, TM_D6_L = 1, TM_D6_H = 5, TM_D56_L = 3,   TM_D56_H = 7 }
enum	{ N_Input_TileMuModule =4 }

Public Member Functions
	TGCTileMuCoincidenceLUT (LVL1TGCTrigger::TGCArguments *, const SG::ReadCondHandleKey< TGCTriggerData > &readCondKey, const std::string &version="NA")
virtual	~TGCTileMuCoincidenceLUT ()
	TGCTileMuCoincidenceLUT (const TGCTileMuCoincidenceLUT &right)=default
TGCTileMuCoincidenceLUT &	operator= (const TGCTileMuCoincidenceLUT &right)=delete
uint16_t	getAddr (int16_t side, int16_t sec, int16_t ssc) const
int	getFlagPT (const int pt, const int16_t ssc, const int16_t sec, const int16_t side) const
int	getFlagROI (const int roi, const int16_t ssc, const int16_t sec, const int16_t side) const
int	getTrigMask (const int module, const int16_t ssc, const int16_t sec, const int16_t side) const
const std::string &	getVersion () const
bool	readMap ()
LVL1TGCTrigger::TGCArguments *	tgcArgs ()
const LVL1TGCTrigger::TGCArguments *	tgcArgs () const

Private Attributes
std::unordered_map< uint16_t, uint8_t >	m_flagpt
std::unordered_map< uint16_t, uint8_t >	m_flagroi
std::unordered_map< uint16_t, uint16_t >	m_trigbit
std::string	m_verName
LVL1TGCTrigger::TGCArguments *	m_tgcArgs
const SG::ReadCondHandleKey< TGCTriggerData > &	m_readCondKey

Detailed Description

This class stores the LUT for Tile-Muon coincidence of the Run-3 L1Muon Endcap trigger.

The contents are read from the Condition database, and are kept in the XXXX object. When the coincidence map is read from the text file, the contents is kept in member variables of this class. Note that the structure is temporary same as Run-2's one.

Contents of Run-3 Tile-Muon LUT

consists of three look-up tables a) Applied pT in SSC (m_flagpt) std::unordered_map<ADDR, PTMASK> where ADDR | 12 bits | uint16_t | side, trigger sector, and SSC PTMASK | 3 bits | uint8_t | bit mask for applied pT for SSC

b)Applied RoI in SSC (m_flagroi) std::unordered_map<ADDR, ROIMASK> where ADDR | 12 bits | uint16_t | side, trigger sector, and SSC ROIMASK | 8 bits | uint8_t | bit mask for applied RoI in SSC

c) Trigger bit for each input (m_trigbit) std::unordered_map<ADDR, TRIGBIT> where TRIGBIT is: | Module D (Tile=3) || Module C (Tile=2) || Module B (Tile=1) || Module A (Tile=0) | | 15 | 14 | 13 | 12 || 11 | 10 | 9 | 8 || 7 | 6 | 5 | 4 || 3 | 2 | 1 | 0 | | 0 | LH | D56| D6 || 0 | LH | D56| D6 || 0 | LH | D56 | D6 || 0 | LH | D56 | D6 | for each Module: [1:0] hit with cell information: D6=0x1, D56=0x3 [2] Low/High threshold: 1 = H, 0=L e.g.) 0x7 = D5+D6 energy exceeds the high threshold

for ADDR, | 11 |10| 9| 8| 7| 6| 5| 4| 3| 2| 1| 0| |side| Trig. Sector | SSC | where side = 0x0 (A-side), 0x1 (C-side). trig. sector = 0x(0...2f) SSC = 0x(0...12)

Definition at line 61 of file TGCTileMuCoincidenceLUT.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
N_Input_TileMuModule

Definition at line 89 of file TGCTileMuCoincidenceLUT.h.

{N_Input_TileMuModule=4};

TileMuMask

enum LVL1TGC::TGCTileMuCoincidenceLUT::TileMuMask

Enumerator
TM_NA
TM_D6_L
TM_D6_H
TM_D56_L
TM_D56_H

Definition at line 81 of file TGCTileMuCoincidenceLUT.h.

                  {
    TM_NA    =  0,
    TM_D6_L  =  1,
    TM_D6_H  =  5,
    TM_D56_L =  3,
    TM_D56_H =  7
  };

Constructor & Destructor Documentation

TGCTileMuCoincidenceLUT() [1/2]

LVL1TGC::TGCTileMuCoincidenceLUT::TGCTileMuCoincidenceLUT	(	LVL1TGCTrigger::TGCArguments *	tgcargs,
		const SG::ReadCondHandleKey< TGCTriggerData > &	readCondKey,
		const std::string &	version = "NA"
	)

Definition at line 14 of file TGCTileMuCoincidenceLUT.cxx.

 : m_verName(version),
   m_tgcArgs(tgcargs),
   m_readCondKey(readCondKey)
{
  if (!tgcArgs()->TILE_MU()) return;
  if (tgcArgs()->USE_CONDDB()) return;
 
  MsgStream log(Athena::getMessageSvc(), "LVL1TGC::TGCTileMuCoincidenceLUT");
 
  // read Inner Coincidence Map 
  if (this->readMap()) {
    log << MSG::INFO 
      << " TGC TileMu CW version of " << m_verName << " is selected " << endmsg;
  } else {
    log << MSG::INFO  
    << " NOT use TileMu " << endmsg;
    m_flagpt.clear();
    m_flagroi.clear();
    m_trigbit.clear();
  }
}

~TGCTileMuCoincidenceLUT()

LVL1TGC::TGCTileMuCoincidenceLUT::~TGCTileMuCoincidenceLUT ( )

virtual

Definition at line 40 of file TGCTileMuCoincidenceLUT.cxx.

{
}

TGCTileMuCoincidenceLUT() [2/2]

LVL1TGC::TGCTileMuCoincidenceLUT::TGCTileMuCoincidenceLUT ( const TGCTileMuCoincidenceLUT &  right )

default

Member Function Documentation

getAddr()

uint16_t LVL1TGC::TGCTileMuCoincidenceLUT::getAddr	(	int16_t	side,
		int16_t	sec,
		int16_t	ssc
	)		const

Definition at line 190 of file TGCTileMuCoincidenceLUT.cxx.

{
  return ((side & TGCTriggerData::SIDE_MASK)<<TGCTriggerData::ADDR_SIDE_SHIFT) +
         ((sec & TGCTriggerData::SECTOR_MASK)<<TGCTriggerData::ADDR_SECTOR_SHIFT) +
         (ssc & TGCTriggerData::SSC_MASK);
}

getFlagPT()

int LVL1TGC::TGCTileMuCoincidenceLUT::getFlagPT	(	const int	pt,
		const int16_t	ssc,
		const int16_t	sec,
		const int16_t	side
	)		const

Definition at line 150 of file TGCTileMuCoincidenceLUT.cxx.

{
  if ((pt<=0)||(pt>TGCTriggerData::N_PT_THRESH)) return -1;
 
  uint8_t ptmask = 0x0;
  if  (tgcArgs()->USE_CONDDB()) {
    SG::ReadCondHandle<TGCTriggerData> readHandle{m_readCondKey};
    const TGCTriggerData* readCdo{*readHandle};
    ptmask = readCdo->getFlagPtTile(ssc, sec, side);
  } else {
    uint16_t addr = this->getAddr(side, sec, ssc);
    std::unordered_map<uint16_t, uint8_t>::const_iterator it = m_flagpt.find(addr);
    if(it != m_flagpt.end()) ptmask = it->second;
  }
  return (ptmask>>(pt-1)) & 0x1;  /* only 1st bit needed (0x1) */
}

getFlagROI()

int LVL1TGC::TGCTileMuCoincidenceLUT::getFlagROI	(	const int	roi,
		const int16_t	ssc,
		const int16_t	sec,
		const int16_t	side
	)		const

Definition at line 170 of file TGCTileMuCoincidenceLUT.cxx.

{
  if ((roi<0)||(roi>=TGCTriggerData::N_ROI_IN_SSC)) return -1;
 
  uint8_t roimask = 0x0;
  if  (tgcArgs()->USE_CONDDB()) {
    SG::ReadCondHandle<TGCTriggerData> readHandle{m_readCondKey};
    const TGCTriggerData* readCdo{*readHandle};
    roimask = readCdo->getFlagRoiTile(ssc, sec, side);
  } else {
    uint16_t addr = this->getAddr(side, sec, ssc);
    std::unordered_map<uint16_t, uint8_t>::const_iterator it = m_flagroi.find(addr);
    if(it != m_flagroi.end()) roimask = it->second;
  }
  return (roimask >> roi) & 0x1;  /* only 1st bit needed (0x1) */
}

getTrigMask()

int LVL1TGC::TGCTileMuCoincidenceLUT::getTrigMask	(	const int	module,
		const int16_t	ssc,
		const int16_t	sec,
		const int16_t	side
	)		const

Definition at line 129 of file TGCTileMuCoincidenceLUT.cxx.

{
  if ((module<0)||(module>=TGCTriggerData::N_TILE_INPUT)) return TM_NA;
 
  uint16_t mask = 0x0;
  if  (tgcArgs()->USE_CONDDB()) {
    SG::ReadCondHandle<TGCTriggerData> readHandle{m_readCondKey};
    const TGCTriggerData* readCdo{*readHandle};
    mask = readCdo->getTrigMaskTile(ssc, sec, side);
  } else {
    uint16_t addr = this->getAddr(side, sec, ssc);
    std::unordered_map<uint16_t, uint16_t>::const_iterator it = m_trigbit.find(addr);
    if(it != m_trigbit.end()) mask = it->second;
  }
 
  return mask>>(module*4) & 0x7;
}

getVersion()

const std::string& LVL1TGC::TGCTileMuCoincidenceLUT::getVersion ( ) const

inline

Definition at line 78 of file TGCTileMuCoincidenceLUT.h.

{ return m_verName; }

operator=()

TGCTileMuCoincidenceLUT& LVL1TGC::TGCTileMuCoincidenceLUT::operator= ( const TGCTileMuCoincidenceLUT &  right )

delete

readMap()

bool LVL1TGC::TGCTileMuCoincidenceLUT::readMap

(

)

Definition at line 44 of file TGCTileMuCoincidenceLUT.cxx.

{
  MsgStream log(Athena::getMessageSvc(), "LVL1TGC::TGCTileMuCoincidenceLUT");
 
  // select right database according to a set of thresholds
  std::string dbname="";
  dbname = "TileMuCoincidenceMap." + m_verName + "._12.db";
 
  //----- 
  
  std::string fullName;
  fullName = PathResolver::FindCalibDirectory("dev")+"/TrigT1TGC/TILE/"+dbname;
  bool isFound =( fullName.length() > 0 );
  if( !isFound) {
    log << MSG::WARNING 
    << " Could not found " << dbname << endmsg;
    return false ;  
  } 
 
  std::ifstream file(fullName.c_str(),std::ios::in);    
 
  static constexpr unsigned int BufferSize = 256;
  char buf[BufferSize];
 
  while (file.getline(buf, BufferSize)) {
 
    int16_t sideId = -1;
    int16_t sectorId = -1;
    int16_t sscId    = -1;
 
    std::istringstream header(buf);
    std::string tag;
    header >> tag;
    if(tag == "#") {
      header >> sideId >> sectorId >> sscId;
    }
 
    // check Id
    if(sideId < 0   || sideId>=TGCTriggerData::N_SIDE ||
       sectorId < 0 || sectorId>=TGCTriggerData::N_ENDCAP_SECTOR ||
       sscId < 0    || sscId>=TGCTriggerData::N_ENDCAP_SSC ) {
      log << MSG::WARNING
          << " illegal parameter in database header : " << header.str()
          << " in file " << dbname
          << endmsg;
      file.close();
      return false;
    }
 
    uint16_t addr = this->getAddr(sideId, sectorId, sscId);
 
    uint8_t flagpt = 0;
    for (size_t pt = 0; pt < TGCTriggerData::N_PT_THRESH; pt++){
      uint8_t use;
      header >> use;
      flagpt |= (use&0x1)<<pt;
    }
    m_flagpt[addr] = flagpt;
 
    uint8_t roi = 0;
    for (size_t pos=0; pos< TGCTriggerData::N_ROI_IN_SSC; pos++){
      uint8_t use;
      header >> use;
      roi |= (use&0x1)<<pos;
    }
    m_flagroi[addr] = roi;
 
    // get trigger word
    file.getline(buf,BufferSize);
    std::istringstream cont(buf);
    uint16_t trigbit = 0x0;
    for(size_t pos=0; pos < TGCTriggerData::N_TILE_INPUT; pos++){
        uint16_t word;
        cont >> word;
        trigbit |= (word & 0xf)<<(pos*4);
    }
    m_trigbit[addr] = trigbit;
 
  }
  file.close();   
 
  return true;
}

tgcArgs() [1/2]

LVL1TGCTrigger::TGCArguments* LVL1TGC::TGCTileMuCoincidenceLUT::tgcArgs ( )

inline

Definition at line 91 of file TGCTileMuCoincidenceLUT.h.

{ return m_tgcArgs; }

tgcArgs() [2/2]

const LVL1TGCTrigger::TGCArguments* LVL1TGC::TGCTileMuCoincidenceLUT::tgcArgs ( ) const

inline

Definition at line 92 of file TGCTileMuCoincidenceLUT.h.

{ return m_tgcArgs; }

Member Data Documentation

m_flagpt

std::unordered_map<uint16_t, uint8_t> LVL1TGC::TGCTileMuCoincidenceLUT::m_flagpt

private

Definition at line 95 of file TGCTileMuCoincidenceLUT.h.

m_flagroi

std::unordered_map<uint16_t, uint8_t> LVL1TGC::TGCTileMuCoincidenceLUT::m_flagroi

private

Definition at line 96 of file TGCTileMuCoincidenceLUT.h.

m_readCondKey

const SG::ReadCondHandleKey<TGCTriggerData>& LVL1TGC::TGCTileMuCoincidenceLUT::m_readCondKey

private

Definition at line 101 of file TGCTileMuCoincidenceLUT.h.

m_tgcArgs

LVL1TGCTrigger::TGCArguments* LVL1TGC::TGCTileMuCoincidenceLUT::m_tgcArgs

private

Definition at line 100 of file TGCTileMuCoincidenceLUT.h.

m_trigbit

std::unordered_map<uint16_t, uint16_t> LVL1TGC::TGCTileMuCoincidenceLUT::m_trigbit

private

Definition at line 97 of file TGCTileMuCoincidenceLUT.h.

m_verName

std::string LVL1TGC::TGCTileMuCoincidenceLUT::m_verName

private

Definition at line 99 of file TGCTileMuCoincidenceLUT.h.

---

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

• TGCTileMuCoincidenceLUT.h
• TGCTileMuCoincidenceLUT.cxx