TGCTriggerBWCWReader Class Reference

#include <TGCTriggerBWCWReader.h>

Inheritance diagram for TGCTriggerBWCWReader:

Collaboration diagram for TGCTriggerBWCWReader:

Public Member Functions
	TGCTriggerBWCWReader (int lutType)
	~TGCTriggerBWCWReader ()=default
bool	readLUT (TGCTriggerLUTs *writeCdo) override
bool	loadParameters (TGCTriggerLUTs *writeCdo, const CondAttrListCollection *readKey) override
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Protected Attributes
int	m_lutType {0}

Private Types
enum	{   TMap_HH =0 , TMap_HL , TMap_LH , TMap_LL ,   N_TMap }

Private Member Functions
int	getType (int lDR, int hDR, int lDPhi, int hDPhi) const
int	subSectorAdd (int ssid, int modid, int phimod2, int type) const
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Definition at line 14 of file TGCTriggerBWCWReader.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
TMap_HH
TMap_HL
TMap_LH
TMap_LL
N_TMap

Definition at line 24 of file TGCTriggerBWCWReader.h.

{TMap_HH=0, TMap_HL, TMap_LH, TMap_LL, N_TMap};

Constructor & Destructor Documentation

TGCTriggerBWCWReader()

TGCTriggerBWCWReader::TGCTriggerBWCWReader

(

int

lutType

)

Definition at line 10 of file TGCTriggerBWCWReader.cxx.

                                                     :
  TGCTriggerLUTReader(lutType),
  AthMessaging("TGCTriggerBWCWReader")
{
}

~TGCTriggerBWCWReader()

TGCTriggerBWCWReader::~TGCTriggerBWCWReader ( )

default

Member Function Documentation

getType()

int TGCTriggerBWCWReader::getType ( int lDR, int hDR, int lDPhi, int hDPhi ) const

private

Definition at line 149 of file TGCTriggerBWCWReader.cxx.

                                                                               {
  int type = -1;
  if ( (lDR==-15) && (hDR==15) && (lDPhi==-7) && (hDPhi==7))      type = TGCTriggerBWCWReader::TMap_HH;
  else if ( (lDR==-15) && (hDR==15) && (lDPhi==-3) && (hDPhi==3)) type = TGCTriggerBWCWReader::TMap_HL;
  else if ( (lDR==-7) && (hDR==7) && (lDPhi==-7) && (hDPhi==7))   type = TGCTriggerBWCWReader::TMap_LH;
  else if ( (lDR==-7) && (hDR==7) && (lDPhi==-3) && (hDPhi==3))   type = TGCTriggerBWCWReader::TMap_LL;
  return type;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

loadParameters()

bool TGCTriggerBWCWReader::loadParameters ( TGCTriggerLUTs * writeCdo, const CondAttrListCollection * readKey )

overridevirtual

Implements TGCTriggerLUTReader.

Definition at line 18 of file TGCTriggerBWCWReader.cxx.

                                                                                 {
 
  CondAttrListCollection::const_iterator itr = readCdo->begin();
  CondAttrListCollection::const_iterator itr_e = readCdo->end();
 
  for(; itr!=itr_e; ++itr) {
    const unsigned int channel = (*itr).first;
    const coral::AttributeList& atr = (*itr).second;
 
    ATH_MSG_DEBUG("channel: " << channel);
    std::string file    = *(static_cast<const std::string*>((atr["file"]).addressOfData()));
    std::string data    = *(static_cast<const std::string*>((atr["data"]).addressOfData()));
    std::string version = *(static_cast<const std::string*>((atr["version"]).addressOfData()));
    std::string type    = *(static_cast<const std::string*>((atr["type"]).addressOfData()));
 
    writeCdo->m_datamap[m_lutType][file] = data;
    writeCdo->m_data[m_lutType].push_back(data);
    writeCdo->m_file[m_lutType].push_back(file);
    writeCdo->m_version[m_lutType].push_back(std::move(version));
    writeCdo->m_type[m_lutType].push_back(std::move(type));
 
    ATH_MSG_INFO("file: " <<file);
    ATH_MSG_DEBUG("data: " << data);
 
  }
  return true;
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

readLUT()

bool TGCTriggerBWCWReader::readLUT ( TGCTriggerLUTs * writeCdo )

overridevirtual

Implements TGCTriggerLUTReader.

Definition at line 54 of file TGCTriggerBWCWReader.cxx.

                                                          {
 
  const int numberOfCoincidenceType = 4;
 
  const int moduleNumber[TGCTriggerLUTs::N_MODULETYPE]  =
    {  0,  1,   2,   2,  3,  4,   5,   5,  6,  7,   8,  8 };
  const std::string moduleName[TGCTriggerLUTs::N_MODULETYPE]=
    {"0a","1a","2a","2b","3a","4a","5a","5b","6a","7a","8a","8b"};
  const std::string sideName[TGCTriggerLUTs::N_SIDE] = {"a","c"};
  const std::string octantName[TGCTriggerLUTs::N_OCTANT] =
    {  "0", "1", "2", "3", "4", "5", "6", "7"};
  const std::string coincidenceTypeName[numberOfCoincidenceType] = {"HH","HL","LH","LL"};
 
 
  // initialize
  bool fullCW = (writeCdo->getType(TGCTriggerLUTs::CW_BW) == "full" );
  // loop over all files...
  for(int iSide = 0; iSide<TGCTriggerLUTs::N_SIDE; iSide++){
    for(int iOctant = 0; iOctant < TGCTriggerLUTs::N_OCTANT; iOctant++) {
 
      uint32_t octaddr = ((iSide & TGCTriggerLUTs::SIDE_MASK)<<TGCTriggerLUTs::SIDE_SHIFT) +
                         ((iOctant & TGCTriggerLUTs::OCTANT_MASK)<<TGCTriggerLUTs::OCTANT_SHIFT);
 
      for(int iModule=0; iModule<TGCTriggerLUTs::N_MODULETYPE; iModule+=1) {
 
        uint32_t phimod2 = moduleName[iModule].find('b') != std::string::npos ? 1 : 0;
        uint32_t modaddr = ((moduleNumber[iModule] & TGCTriggerLUTs::MODULE_MASK)<<TGCTriggerLUTs::MODULE_SHIFT) +
                           ((phimod2 & TGCTriggerLUTs::PHIMOD2_MASK)<<TGCTriggerLUTs::PHIMOD2_SHIFT);
 
        for(int iCoinType=0; iCoinType!=numberOfCoincidenceType; iCoinType++){
 
          std::string fn;
          if (fullCW) {
            fn = "RPhiCoincidenceMapRun3_" + sideName[iSide] + octantName[iOctant]
               + moduleName[iModule] + coincidenceTypeName[iCoinType] + ".db";
          } else{
            fn = "RPhiCoincidenceMapRun3_" + moduleName[iModule] + coincidenceTypeName[iCoinType] + ".db";
          }
 
          bool Forward_type1=(moduleName[iModule]=="2b"||moduleName[iModule]=="5a"||moduleName[iModule]=="8b");
          bool Forward_type2=(moduleName[iModule]=="2a"||moduleName[iModule]=="5b"||moduleName[iModule]=="8a");
 
          if(iOctant%2==0 && Forward_type1){continue;}
          if(iOctant%2==1 && Forward_type2){continue;}
          int type = -1;
          int lDR, hDR, lDPhi, hDPhi;
 
          std::string data = writeCdo->getData(TGCTriggerLUTs::CW_BW, std::move(fn));
          std::istringstream stream(data);
 
          std::string buf,tag;
          char delimiter = '\n';
          int roi;
 
          while(getline(stream,buf,delimiter)){
            std::istringstream header(buf);
            header>>tag;
            if(tag=="#") { // read header part.     
              header >> roi >> lDR >> hDR >> lDPhi >> hDPhi;
              type = getType( lDR, hDR, lDPhi, hDPhi );
              if( type<0 ) {
                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++) {   // 0...31 or 7...23
                uint32_t draddr = (ir & TGCTriggerLUTs::DR_MASK) << TGCTriggerLUTs::DR_SHIFT;
 
                // get window data
                getline(stream, 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
                  writeCdo->m_ptmap_bw[theaddr] = pt;
                }
              }
 
            }
          }
 
        }// coincidence type
      }// module
    }// octant
  }// side
 
  return true;
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

subSectorAdd()

int TGCTriggerBWCWReader::subSectorAdd ( int ssid, int modid, int phimod2, int type ) const

private

Definition at line 158 of file TGCTriggerBWCWReader.cxx.

                                                                                       { 
  return (ssid+(modid<<8)+(phimod2<<12) + (type<<16) ); 
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lutType

int TGCTriggerLUTReader::m_lutType {0}

protectedinherited

Definition at line 23 of file TGCTriggerLUTReader.h.

{0};

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

---

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

• TGCTriggerBWCWReader.h
• TGCTriggerBWCWReader.cxx