LVL1TGC::BigWheelCoincidenceLUT Class Reference

#include <BigWheelCoincidenceLUT.h>

Collaboration diagram for LVL1TGC::BigWheelCoincidenceLUT:

Public Member Functions
	BigWheelCoincidenceLUT (LVL1TGCTrigger::TGCArguments *, const SG::ReadCondHandleKey< TGCTriggerLUTs > &readKey, const std::string &version)
virtual	~BigWheelCoincidenceLUT ()
	BigWheelCoincidenceLUT (const BigWheelCoincidenceLUT &right)=default
BigWheelCoincidenceLUT &	operator= (const BigWheelCoincidenceLUT &right)=delete
bool	readMap ()
int8_t	test (int sideId, int octantId, int moduleId, int subsector, int type, int dr, int dphi) const
int	getMapType (int hlwire, int hlstrip) const
const std::string &	getVersion () const
const LVL1TGCTrigger::TGCArguments *	tgcArgs () const

Protected Member Functions
int	getTYPE (int lDR, int hDR, int lDPhi, int hDPhi) const

Protected Attributes
std::map< char, int8_t >	m_pTdef

Static Protected Attributes
static constexpr uint32_t	N_COIN_TYPE = 4

Private Member Functions
	BigWheelCoincidenceLUT ()=delete

Private Attributes
std::unordered_map< uint32_t, char >	m_lut
std::string	m_verName
bool	m_fullCW {false}
LVL1TGCTrigger::TGCArguments *	m_tgcArgs
const SG::ReadCondHandleKey< TGCTriggerLUTs > &	m_readCondKey

Detailed Description

Contents of Run-3 BW-CW LUT

std::unordered_map<GLOBALADDR, PTCHAR> where GLOBALADDR | 27 bits | uint32_t | side, octant, type, phimod2, module, roi, | DR(0...0x1f for -15...15), DPhi(0...0xf for -7...7) PTCHAR | 5 bits | char | pT (4 bits) and charge

for GLOBALADDR | 29 |28|27|26|25|24|23| 22 |21|..|18|17|...|10| 9| 8| 7| 6| 5| 4| 3| 2| 1| 0| |side| octant | 0|type |phimod2| module | RoI | 0| delta R | delta Phi | where side = 0x0 (A-side), 0x1 (C-side). octant = 0x(0...7) type = 0x0(HH), 0x1(HL), 0x2(LH), 0x3(LL): HL means 3-sta.-wire and 2-sta.-strip.

Definition at line 35 of file BigWheelCoincidenceLUT.h.

Constructor & Destructor Documentation

BigWheelCoincidenceLUT() [1/3]

LVL1TGC::BigWheelCoincidenceLUT::BigWheelCoincidenceLUT	(	LVL1TGCTrigger::TGCArguments *	tgcargs,
		const SG::ReadCondHandleKey< TGCTriggerLUTs > &	readKey,
		const std::string &	version
	)

Definition at line 64 of file BigWheelCoincidenceLUT.cxx.

: m_verName(version),
  m_tgcArgs(tgcargs),
  m_readCondKey(readKey) {
 
  MsgStream log(Athena::getMessageSvc(), "LVL1TGC::BigWheelCoincidenceLUT");
  log << MSG::INFO
      << " BigWheel LUT version of " << m_verName << " is selected." << endmsg;
 
  if (!tgcArgs()->USE_CONDDB()) {
    // read LUT contents from local files
    this->readMap();
  } 
}

~BigWheelCoincidenceLUT()

LVL1TGC::BigWheelCoincidenceLUT::~BigWheelCoincidenceLUT ( )

virtual

Definition at line 81 of file BigWheelCoincidenceLUT.cxx.

                                                {
}

BigWheelCoincidenceLUT() [2/3]

LVL1TGC::BigWheelCoincidenceLUT::BigWheelCoincidenceLUT ( const BigWheelCoincidenceLUT &  right )

default

BigWheelCoincidenceLUT() [3/3]

LVL1TGC::BigWheelCoincidenceLUT::BigWheelCoincidenceLUT ( )

privatedelete

Member Function Documentation

getMapType()

int LVL1TGC::BigWheelCoincidenceLUT::getMapType ( int  hlwire, int  hlstrip  ) const

inline

Definition at line 99 of file BigWheelCoincidenceLUT.h.

                                                                           {
  return (TGCTriggerLUTs::COIN_LL - 2*hlwire - hlstrip);
}

getTYPE()

int LVL1TGC::BigWheelCoincidenceLUT::getTYPE ( int  lDR, int  hDR, int  lDPhi, int  hDPhi  ) const

inlineprotected

Definition at line 88 of file BigWheelCoincidenceLUT.h.

                                                                                       {
  if((lDR == -TGCTriggerLUTs::DR_HIGH_RANGE) && (hDR == TGCTriggerLUTs::DR_HIGH_RANGE)) {
    if     ((lDPhi == -TGCTriggerLUTs::DPHI_HIGH_RANGE) && (hDPhi == TGCTriggerLUTs::DPHI_HIGH_RANGE)) return TGCTriggerLUTs::COIN_HH;
    else if((lDPhi == -TGCTriggerLUTs::DPHI_LOW_RANGE) && (hDPhi == TGCTriggerLUTs::DPHI_LOW_RANGE))   return TGCTriggerLUTs::COIN_HL;
  } else if((lDR == -TGCTriggerLUTs::DR_LOW_RANGE) && (hDR == TGCTriggerLUTs::DR_LOW_RANGE)) {
    if     ((lDPhi == -TGCTriggerLUTs::DPHI_HIGH_RANGE) && (hDPhi == TGCTriggerLUTs::DPHI_HIGH_RANGE)) return TGCTriggerLUTs::COIN_LH;
    else if((lDPhi == -TGCTriggerLUTs::DPHI_LOW_RANGE) && (hDPhi == TGCTriggerLUTs::DPHI_LOW_RANGE))   return TGCTriggerLUTs::COIN_LL;
  }
  return -1;
}

getVersion()

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

inline

Definition at line 84 of file BigWheelCoincidenceLUT.h.

                                                                 {
  return m_verName;
}

operator=()

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

delete

readMap()

bool LVL1TGC::BigWheelCoincidenceLUT::readMap

(

)

Definition at line 84 of file BigWheelCoincidenceLUT.cxx.

{
  const uint8_t kNMODULETYPE = 12;
  const uint8_t modulenumber[kNMODULETYPE] = {0, 1, 2, 2, 3, 4, 5, 5, 6, 7, 8, 8};
  const std::string modulename[kNMODULETYPE] = {"0a","1a","2a","2b","3a","4a","5a","5b","6a","7a","8a","8b"};
  const std::string sidename[TGCSide::kNSide] = {"a","c"};
  const std::string capitalsidename[TGCSide::kNSide] = {"A", "C"};
 
  const std::string octantName[kNOctant] =
    {  "0", "1", "2", "3", "4", "5", "6", "7"};
  const std::string coincidenceTypeName[N_COIN_TYPE] = {"HH", "HL", "LH", "LL"};
 
  MsgStream log(Athena::getMessageSvc(), "LVL1TGC::BigWheelCoincidenceLUT");
 
  // Automatic identification of octant-symmetry or full-CW from version
  std::string tryname = PathResolver::FindCalibDirectory("dev")+"/TrigT1TGC/BW/cm_a0aHH_Octant_" + m_verName + ".db";
  std::ifstream tryfile(tryname.c_str(), std::ios::in);
  if (tryfile) {
    m_fullCW = false;
    tryfile.close();
  } else {
    tryname = PathResolver::FindCalibDirectory("dev")+"/TrigT1TGC/BW/cm_mod0aHH_A0_" + m_verName + ".db";
    tryfile = std::ifstream(tryname.c_str(), std::ios::in);
    if (tryfile) {
      m_fullCW = true;
      tryfile.close();
    } else {
      log << MSG::ERROR << "Could not found the expected file!" << endmsg;
    }
  }
 
  const uint8_t num_sides = (m_fullCW) ? TGCSide::kNSide : 1;
  const uint8_t num_octants = (m_fullCW) ? kNOctant : 1;
 
  for (uint8_t iside=0; iside < num_sides; iside++) {
    for (uint8_t ioctant=0; ioctant < num_octants; ioctant++) {
      uint32_t octaddr = (iside<<TGCTriggerLUTs::SIDE_SHIFT) +
                         ((ioctant & TGCTriggerLUTs::OCTANT_MASK)<<TGCTriggerLUTs::OCTANT_SHIFT);
 
      // loop over all files...
      for (int iModule=0; iModule < kNMODULETYPE; iModule+=1) {
        uint32_t phimod2 = (modulename[iModule].find("b") != std::string::npos) ? 1 : 0;
 
        if (m_fullCW && iModule%4 > 1) {   // only forward sectors
          if ((ioctant%2 == 0 && uint32_t(iModule/4)%2 != phimod2) ||   // A0, A2, A4, ...
              (ioctant%2 == 1 && uint32_t(iModule/4)%2 == phimod2)) {   // A1, A3, A5, ...
            continue;   // only one of phimod2 sectors should be used
          }
        }
        uint32_t modaddr = ((modulenumber[iModule] & TGCTriggerLUTs::MODULE_MASK)<<TGCTriggerLUTs::MODULE_SHIFT) +
                           ((phimod2 & TGCTriggerLUTs::PHIMOD2_MASK)<<TGCTriggerLUTs::PHIMOD2_SHIFT);
 
        for (int iCoinType=0; iCoinType != N_COIN_TYPE; iCoinType++) {
          std::string fn = "/BW/cm_";
          if (m_fullCW) {
            fn += "mod" + modulename[iModule] + coincidenceTypeName[iCoinType] + "_" + capitalsidename[iside] + octantName[ioctant] + "_";
          } else {
            fn += sidename[iside] + modulename[iModule] + coincidenceTypeName[iCoinType] + "_Octant_";
          }
          fn += m_verName + ".db";
 
          int type = -1;
          int lDR, hDR, lDPhi, hDPhi;
          std::string fullName = PathResolver::FindCalibDirectory("dev")+"/TrigT1TGC"+fn;
          if( fullName.length() == 0 ) {
            log << MSG::ERROR << " Could not found " << fn.c_str() << endmsg;
            continue;
          }
 
          std::ifstream file(fullName.c_str(),std::ios::in);
          if(!file){
            log << MSG::ERROR << " Could not found " << fullName.c_str() << endmsg;
            continue;
          }
 
          std::string buf, tag;
          char delimiter = '\n';
          while (getline(file,buf,delimiter)){
            std::istringstream header(buf);
            header>>tag;
 
            if (tag == "#") {    // read header part
              int roi;
              header >> roi >> lDR >> hDR >> lDPhi >> hDPhi;
              type = getTYPE(lDR, hDR, lDPhi, hDPhi);
              // check moduleNumber and ptLevel
              if(type < 0) {
                log << MSG::WARNING
                    << " illegal parameter in database header : " << header.str() << " in file " << fn << endmsg;
                break;
              }
 
              uint32_t cwaddr = ((uint8_t(type) & TGCTriggerLUTs::TYPE_MASK)<<TGCTriggerLUTs::TYPE_SHIFT) +
                                ((roi & TGCTriggerLUTs::ROI_MASK)<<TGCTriggerLUTs::ROI_SHIFT);
 
              for(uint8_t ir=lDR+TGCTriggerLUTs::DR_HIGH_RANGE; ir <= hDR+TGCTriggerLUTs::DR_HIGH_RANGE; ir++) {
                uint32_t draddr = (ir & TGCTriggerLUTs::DR_MASK)<<TGCTriggerLUTs::DR_SHIFT;
 
                // get window data
                getline(file, buf, delimiter);
 
                for(uint8_t iphi=lDPhi+TGCTriggerLUTs::DPHI_HIGH_RANGE; iphi <= hDPhi+TGCTriggerLUTs::DPHI_HIGH_RANGE; iphi++) {
                  uint32_t theaddr = octaddr + modaddr + cwaddr + draddr + iphi;
                  char pt = buf[iphi-lDPhi-TGCTriggerLUTs::DPHI_HIGH_RANGE];
                  if (pt == 'X') continue;   // not opened
          if(m_lut.count(theaddr)==0){
            m_lut[theaddr] = pt;
          }else{
            log << MSG::ERROR
            << " Problem with loading TGC BW Trigger LUT: duplicated entry at address=" << theaddr << " with pt=" << pt << endmsg;
          }
                }
              }
            }   // if (tag == "#")
          }   // while (getline(...))
        }   // for (int iCoinType)
      }   // for (int iModule)
    }   // for (uint8_t ioctant)
  }   // for (uint8_t iside)
 
  return true;
}

test()

int8_t LVL1TGC::BigWheelCoincidenceLUT::test	(	int	sideId,
		int	octantId,
		int	moduleId,
		int	subsector,
		int	type,
		int	dr,
		int	dphi
	)		const

Definition at line 22 of file BigWheelCoincidenceLUT.cxx.

                                                                      {
  if (type < TGCTriggerLUTs::COIN_HH || type > TGCTriggerLUTs::COIN_LL) return 0;  // no candidate
 
  int phimod2 = 0;
  if (moduleId == 2 || moduleId == 5 || moduleId == 8) {   // forward sectors
    int sector = (moduleId-2) / 3 + octantId * 3;   // sector number assuming the forward sector
    phimod2 = (sector%2 == 1) ? 1 : 0;
  }
 
  uint32_t addr = ((type & TGCTriggerLUTs::TYPE_MASK)<<TGCTriggerLUTs::TYPE_SHIFT) +
                  ((phimod2 & TGCTriggerLUTs::PHIMOD2_MASK)<<TGCTriggerLUTs::PHIMOD2_SHIFT) +
                  ((moduleId & TGCTriggerLUTs::MODULE_MASK)<<TGCTriggerLUTs::MODULE_SHIFT) +
                  ((subsector & TGCTriggerLUTs::ROI_MASK)<<TGCTriggerLUTs::ROI_SHIFT) +
                  (((dr+TGCTriggerLUTs::DR_HIGH_RANGE) & TGCTriggerLUTs::DR_MASK)<<TGCTriggerLUTs::DR_SHIFT) +
                  (((dphi+TGCTriggerLUTs::DPHI_HIGH_RANGE) & TGCTriggerLUTs::DPHI_MASK)<<TGCTriggerLUTs::DPHI_SHIFT);
 
  int8_t content = 0x0;   // outside from defined window, i.e. pT=0
 
  if(tgcArgs()->USE_CONDDB()) {
    SG::ReadCondHandle<TGCTriggerLUTs> readHandle{m_readCondKey};
    const TGCTriggerLUTs* readCdo{*readHandle};
    bool fullCW = (readCdo->getType(TGCTriggerLUTs::CW_BW) == "full");
    if(fullCW) addr += (sideId<<TGCTriggerLUTs::SIDE_SHIFT) +
                       ((octantId & TGCTriggerLUTs::OCTANT_MASK)<<TGCTriggerLUTs::OCTANT_SHIFT);
 
    content = readCdo->getBigWheelPt(addr);
  } else {
    if(m_fullCW) addr += (sideId<<TGCTriggerLUTs::SIDE_SHIFT) +
                         ((octantId & TGCTriggerLUTs::OCTANT_MASK)<<TGCTriggerLUTs::OCTANT_SHIFT);
 
    std::unordered_map<uint32_t, char>::const_iterator it = m_lut.find(addr);
    if(it != m_lut.end()) {
      char pt_char = it->second;
      content = m_pTdef.find(pt_char)->second;
    }
  }
 
  return content;
}

tgcArgs()

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

inline

Definition at line 80 of file BigWheelCoincidenceLUT.h.

                                                                               {
  return m_tgcArgs;
}

Member Data Documentation

m_fullCW

bool LVL1TGC::BigWheelCoincidenceLUT::m_fullCW {false}

private

Definition at line 73 of file BigWheelCoincidenceLUT.h.

m_lut

std::unordered_map<uint32_t, char> LVL1TGC::BigWheelCoincidenceLUT::m_lut

private

Definition at line 70 of file BigWheelCoincidenceLUT.h.

m_pTdef

std::map<char, int8_t> LVL1TGC::BigWheelCoincidenceLUT::m_pTdef

protected

Initial value:

={{'X',0},
              {'A',1},{'B',2},{'C',3},{'D',4},{'E',5},{'F',6},{'G',7},{'H',8},{'I',9},{'J',10},{'K',11},{'L',12},{'M',13},{'N',14},{'O',15},
              {'a',-1},{'b',-2},{'c',-3},{'d',-4},{'e',-5},{'f',-6},{'g',-7},{'h',-8},{'i',-9},{'j',-10},{'k',-11},{'l',-12},{'m',-13},{'n',-14},{'o',-15} }

Definition at line 65 of file BigWheelCoincidenceLUT.h.

m_readCondKey

const SG::ReadCondHandleKey<TGCTriggerLUTs>& LVL1TGC::BigWheelCoincidenceLUT::m_readCondKey

private

Definition at line 77 of file BigWheelCoincidenceLUT.h.

m_tgcArgs

LVL1TGCTrigger::TGCArguments* LVL1TGC::BigWheelCoincidenceLUT::m_tgcArgs

private

Definition at line 75 of file BigWheelCoincidenceLUT.h.

m_verName

std::string LVL1TGC::BigWheelCoincidenceLUT::m_verName

private

Definition at line 72 of file BigWheelCoincidenceLUT.h.

N_COIN_TYPE

constexpr uint32_t LVL1TGC::BigWheelCoincidenceLUT::N_COIN_TYPE = 4

staticconstexprprotected

Definition at line 62 of file BigWheelCoincidenceLUT.h.

---

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

• BigWheelCoincidenceLUT.h
• BigWheelCoincidenceLUT.cxx