TrigL2MuonSA::MuCalStreamerTool Class Reference

#include <MuCalStreamerTool.h>

Inheritance diagram for TrigL2MuonSA::MuCalStreamerTool:

Collaboration diagram for TrigL2MuonSA::MuCalStreamerTool:

Public Member Functions
	MuCalStreamerTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
const std::string &	instanceName () const
void	setInstanceName (const std::string &name)
void	setBufferName (const std::string &buffName)
StatusCode	openStream (int calBufferSize)
StatusCode	closeStream ()
bool	isStreamOpen ()
StatusCode	createRoiFragment (const xAOD::MuonRoI *roi, TrigL2MuonSA::TrackPattern &trackPattern, TrigL2MuonSA::MdtHits &mdtHits, TrigL2MuonSA::RpcHits &rpcHits, TrigL2MuonSA::TgcHits &tgcHits, std::vector< uint32_t > &localBuffer, bool doDataScouting, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	createMdtFragment (TrigL2MuonSA::MdtHits &mdtHits, LVL2_MUON_CALIBRATION::MdtCalibFragment &mdtFragment, float phi) const
StatusCode	createRpcFragment (const xAOD::MuonRoI *roi, LVL2_MUON_CALIBRATION::RpcCalibFragment &rpcFragment, const EventContext &ctx) const
StatusCode	createTgcFragment (std::vector< uint32_t > &tgcRobIdList, LVL2_MUON_CALIBRATION::TgcCalibFragment &tgcFragment, const EventContext &ctx) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< bool >	m_writeToFile { this, "WriteToFile", false, "" }
SG::ReadHandleKey< TgcRdoContainer >	m_tgcRdoKey {this, "TgcRdoContainer", "TGCRDO", "Tgc RDO Input"}
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey { this, "EventInfoKey", "EventInfo", "" }
SG::ReadHandleKey< RpcPadContainer >	m_rpcPadKey {this, "RpcPadContainerKey", "RPCPAD", "RpcPad container fro MuCalStreamerTool"}
std::string	m_calBufferName
std::string	m_algInstanceName
std::ofstream	m_outputFile
ToolHandle< IRegSelTool >	m_regSel_MDT {this, "RegSel_MDT", "RegSelTool/RegSelTool_MDT", "MDT Region Selector Tool"}
ToolHandle< IRegSelTool >	m_regSel_TGC {this, "RegSel_TGC", "RegSelTool/RegSelTool_TGC", "TGC Region Selector Tool"}
SG::ReadCondHandleKey< RpcCablingCondData >	m_readKey {this, "ReadKey", "RpcCablingCondData", "Key of RpcCablingCondData"}
TrigL2MuonSA::MuCalCircClient *	m_circ = nullptr
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 54 of file MuCalStreamerTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MuCalStreamerTool()

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

Definition at line 20 of file MuCalStreamerTool.cxx.

                                                     : 
   AthAlgTool(type,name,parent)
{
}

Member Function Documentation

closeStream()

StatusCode TrigL2MuonSA::MuCalStreamerTool::closeStream

(

)

Definition at line 80 of file MuCalStreamerTool.cxx.

{
 
  std::string name = m_calBufferName+"_"+m_algInstanceName;
  ATH_MSG_DEBUG("I'm going to close the stream "<<name);
 
  if (m_circ)
    {
      delete m_circ;
      m_circ = nullptr;
    }
 
  return StatusCode::SUCCESS;
 
}

createMdtFragment()

StatusCode TrigL2MuonSA::MuCalStreamerTool::createMdtFragment ( TrigL2MuonSA::MdtHits & mdtHits, LVL2_MUON_CALIBRATION::MdtCalibFragment & mdtFragment, float phi ) const

private

Definition at line 266 of file MuCalStreamerTool.cxx.

 {
 
   TrigL2MuonSA::MdtHits::const_iterator it = mdtHits.begin();
   for ( ; it != mdtHits.end() ; ++it ) {
 
     int stationName = (*it).name;
     int stationEta  = (*it).StationEta;
     int stationPhi  = (*it).StationPhi;
     int multilayer  = (*it).Multilayer;
     int layer       = (*it).TubeLayer;
     int tube        = (*it).Tube;
 
     uint32_t ID = LVL2_MUON_CALIBRATION::MdtIdIntoWord(stationName,
                               stationEta,stationPhi,multilayer,layer,tube);
 
     uint16_t  leadingCoarseTime  = (*it).LeadingCoarseTime;
     uint16_t  leadingFineTime    = (*it).LeadingFineTime;
     uint16_t  trailingCoarseTime = (*it).TrailingCoarseTime;
     uint16_t  trailingFineTime   = (*it).TrailingFineTime;
     uint16_t  adc                = (*it).Adc;
 
     LVL2_MUON_CALIBRATION::MdtCalibData mdt(ID,leadingCoarseTime,leadingFineTime,
                        trailingCoarseTime,trailingFineTime,adc
                        ,trackPhi);
 
     ATH_MSG_DEBUG("Dumping MDT Hit");
     ATH_MSG_DEBUG(mdt);
 
     mdtFragment << mdt;
   }
 
   return StatusCode::SUCCESS;
 }

createRoiFragment()

StatusCode TrigL2MuonSA::MuCalStreamerTool::createRoiFragment	(	const xAOD::MuonRoI *	roi,
		TrigL2MuonSA::TrackPattern &	trackPattern,
		TrigL2MuonSA::MdtHits &	mdtHits,
		TrigL2MuonSA::RpcHits &	rpcHits,
		TrigL2MuonSA::TgcHits &	tgcHits,
		std::vector< uint32_t > &	localBuffer,
		bool	doDataScouting,
		const EventContext &	ctx ) const

Definition at line 106 of file MuCalStreamerTool.cxx.

 {
 
   ATH_MSG_DEBUG("Data scouting is set to"<<doDataScouting);
 
   // skip the event if it's a noise burst
   unsigned int totalHits = mdtHits.size()+rpcHits.size()+tgcHits.size();
   if (  totalHits > 500 ) {
     ATH_MSG_DEBUG("Too many hits: skip the RoI");
     return StatusCode::SUCCESS;
   }
 
   // init roi pointer
   if ( !inputroi ) {
     ATH_MSG_ERROR("Roi not initialized");
     return StatusCode::FAILURE;
   }
 
   // pointer to the muon roi
   const xAOD::MuonRoI* roi {inputroi};
    
 
   // retrieve the event and trigger info
   SG::ReadHandle<xAOD::EventInfo> eventInfo (m_eventInfoKey, ctx);
   uint32_t runId  = ctx.eventID().run_number();
   uint32_t lvl1Id = eventInfo->extendedLevel1ID();
 
 
   // get track parameters
   float eta = (float) track.etaVtx;
   float phi = (float) track.phiVtx;
   float pt  = (float) track.pt;
 
   uint32_t mrods[4] = {0, 0, 0, 0};
   // prepare the header information
   std::vector<uint32_t> robIdList_MDT;
   double etaMin = roi->eta()-0.05;
   double etaMax = roi->eta()+0.05;
   double phi_roi = roi->phi();
   double phiMin = roi->phi()-0.05;
   double phiMax = roi->phi()+0.05;
   if( phi_roi < 0 ) phi_roi += 2*M_PI;
   if( phiMin < 0 ) phiMin += 2*M_PI;
   if( phiMax < 0 ) phiMax += 2*M_PI;
 
   TrigRoiDescriptor roiDescr( roi->eta(), etaMin, etaMax, phi_roi, phiMin, phiMax );
  
   const IRoiDescriptor* iroi = (IRoiDescriptor*) &roiDescr;
   m_regSel_MDT->lookup( ctx )->ROBIDList(*iroi,robIdList_MDT);
 
   // dump the list of robs for debugging 
   ATH_MSG_DEBUG("Size of the MDT rob list: " << robIdList_MDT.size());
   int isize = robIdList_MDT.size()<5 ? robIdList_MDT.size() : 4;
   for (int ii = 0 ; ii<isize ; ++ii ) {
     ATH_MSG_DEBUG("robId: 0x" << std::hex << robIdList_MDT.at(ii) << std::dec);
     mrods[ii] = robIdList_MDT.at(ii);
   }
 
   // get the list of TGC robs
   std::vector<uint32_t> robIdList_TGC;
   m_regSel_TGC->lookup(ctx)->ROBIDList(*iroi,robIdList_TGC);
   ATH_MSG_DEBUG("Size of the TGC rob list: " << robIdList_TGC.size());
 
 
   LVL2_MUON_CALIBRATION::CalibEvent  event(1,runId,lvl1Id,1,1,mrods,name().c_str(),eta,phi,pt);
   LVL2_MUON_CALIBRATION::MdtCalibFragment mdtFragment;
 
   // create the MDT fragment
   if ( mdtHits.size()>0 ) {
     ATH_CHECK( createMdtFragment(mdtHits,mdtFragment,phi) );
  
     // add the mdt fragment to the event
     event << mdtFragment;
   }
   else{
     // do not write the calib stream
     return StatusCode::SUCCESS;
   }
 
   // create the RPC fragment 
   if ( rpcHits.size() > 0 ) {    
     LVL2_MUON_CALIBRATION::RpcCalibFragment rpcFragment;
  
     if ( createRpcFragment(roi, rpcFragment, ctx) != StatusCode::SUCCESS ) {
       ATH_MSG_WARNING("Could not create the Rpc fragment of the calibration stream");
     }
     else {
       ATH_MSG_DEBUG("Adding the RPC fragment to the calibration stream");
       event << rpcFragment;
     }
   }
 
   if ( tgcHits.size() > 0 ) {    
     LVL2_MUON_CALIBRATION::TgcCalibFragment tgcFragment;
 
     if ( createTgcFragment(robIdList_TGC, tgcFragment, ctx) != StatusCode::SUCCESS ) {
       ATH_MSG_ERROR("Could not create the Tgc fragment of the calibration stream");
     }
     else {
       ATH_MSG_DEBUG("Adding the TGC fragment to the calibration stream");
       event << tgcFragment;
     }
   }
 
 
 
   ATH_MSG_DEBUG("Dumping the event stream");
   ATH_MSG_DEBUG(event);
  if (m_circ)
  {
    m_circ->dumpToCirc (event);
  }
 
  
  if (doDataScouting) {
    // Perform data scouting specific operations
    uint16_t eventSize_ds = event.size();
    if (eventSize_ds>1000) return StatusCode::SUCCESS;
 
    std::unique_ptr<uint8_t[]> buff_ds = std::make_unique<uint8_t[]>(eventSize_ds);
 
    // encode the event
    uint16_t eventSize8bits = eventSize_ds;
    uint16_t eventSize32bits = eventSize8bits/4;
    event.dumpWords(buff_ds.get(),eventSize_ds);
 
    // fill the local buffer 
    // dump the words also in the local buffer     
    // dump the encoded event to the screen
    ATH_MSG_DEBUG("Size of the DATASCOUTING buffer in 32 bits words: " << eventSize32bits);
    for ( uint16_t words = 0 ; words != eventSize32bits ; words++)  {                 
      uint32_t byte1 = buff_ds[words*4];
      uint32_t byte2 = buff_ds[words*4 + 1];
      uint32_t byte3 = buff_ds[words*4 + 2];
      uint32_t byte4 = buff_ds[words*4 + 3];
 
      // encoding in big-endian for now ( revert order for little-endian )
      uint32_t dataWord = (byte4 << 24) + (byte3 << 16) + (byte2 << 8) + byte1 ;
      //    std::cout << "Number of data words: " << words << std::endl;
      ATH_MSG_DEBUG("Data word " << words << " = " << std::hex << "0x" << dataWord << std::dec);
      
      localBuffer.push_back(dataWord);
    }
 
    ATH_MSG_DEBUG("Local buffer size = " << localBuffer.size());
 
  }
   return StatusCode::SUCCESS;
 }

createRpcFragment()

StatusCode TrigL2MuonSA::MuCalStreamerTool::createRpcFragment ( const xAOD::MuonRoI * roi, LVL2_MUON_CALIBRATION::RpcCalibFragment & rpcFragment, const EventContext & ctx ) const

private

Definition at line 308 of file MuCalStreamerTool.cxx.

{
 
  // exit if it's not in the barrel
  //if ( roi->sysID() != 0 ) return StatusCode::SUCCESS;
  if ( roi->getSource() != 0 ) return StatusCode::SUCCESS;
 
  // retrieve the padId from the RecMuonRoi
 
  //  decode  roIWord
  unsigned int side = roi->getHemisphere()==xAOD::MuonRoI::Hemisphere::Positive ? 1 : 0;
  unsigned int sector = roi->getSectorID();
  unsigned int roiNumber =  roi->getRoI();
 
  // retrieve the pad container
  SG::ReadHandle<RpcPadContainer> rh_rpcPad{m_rpcPadKey, ctx};
  const RpcPadContainer* rpcPadContainer=rh_rpcPad.cptr();
 
  SG::ReadCondHandle<RpcCablingCondData> readHandle{m_readKey,ctx};
  const RpcCablingCondData* readCdo{*readHandle};
  unsigned int padIdHash;
  if (readCdo->give_PAD_address( side, sector, roiNumber, padIdHash)) {
 
    auto itPad = rpcPadContainer->indexFindPtr(padIdHash);  
    if( itPad==nullptr ) {        
      ATH_MSG_WARNING("Failed to retrieve PAD hash Id " << padIdHash);  
      return StatusCode::FAILURE;                         
    }
    const RpcPad* rpcPad = itPad;
 
      uint16_t sector = rpcPad->sector();
      uint16_t sysId  = (sector<32)? 0x66 : 0x65;
      uint16_t secId  = sector%32;
      uint16_t padId  = rpcPad->onlineId();
      uint16_t status = rpcPad->status();
      uint16_t error  = rpcPad->errorCode();
      
      LVL2_MUON_CALIBRATION::RpcCalibFragment frag(sysId,secId,padId,status,error);
      rpcFragment = frag;
      RpcPad::const_iterator it3 = rpcPad->begin();
      for (; it3!=rpcPad->end() ; ++it3) {
    const RpcCoinMatrix * cma = (*it3);
    
    uint16_t cmaId  = cma->onlineId();
    uint16_t fel1Id = cma->fel1Id();
    uint16_t febcId = cma->febcId();
    uint16_t crc    = cma->crc();
    
    LVL2_MUON_CALIBRATION::RpcCalibData matrix(cmaId,fel1Id,febcId,crc);
    
    //for each cma for over fired channels
    RpcCoinMatrix::const_iterator it5 = (*it3)->begin();
    for (; it5 != (*it3)->end() ; ++it5) {
      const RpcFiredChannel * fChannel = (*it5);
      
      uint16_t bcid    = fChannel->bcid();
      uint16_t time    = fChannel->time();
      uint16_t ijk     = fChannel->ijk();
      uint16_t channel = fChannel->channel();
      uint16_t ovl     = fChannel->ovl();
      uint16_t thr     = fChannel->thr();
      
      if(ijk!=7) matrix.getHit(bcid,time,ijk,channel);
      else       matrix.getHit(bcid,time,ijk,ovl,thr);
      
    } // loop on the matrix hits
    
    rpcFragment << matrix;
      } // loop on the pad matrices
    
  }
  else {
    ATH_MSG_WARNING("Can't get the pad address from the RpcCablingCondData");
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

createTgcFragment()

StatusCode TrigL2MuonSA::MuCalStreamerTool::createTgcFragment ( std::vector< uint32_t > & tgcRobIdList, LVL2_MUON_CALIBRATION::TgcCalibFragment & tgcFragment, const EventContext & ctx ) const

private

Definition at line 393 of file MuCalStreamerTool.cxx.

{
 
 
  if ( robIdList_TGC.size()<1 ) {
    ATH_MSG_DEBUG("No TGC Rob found");
    return StatusCode::SUCCESS;
  }
 
  // system Id = 1 should correspond to the endcap
  uint16_t systemId = 1;
  // this is the subdetector Id
  uint16_t subSystemId = ( (robIdList_TGC.at(0) & 0xff0000) >> 16 );
  uint16_t rdoId = ( robIdList_TGC.at(0) & 0xff );
 
  uint16_t roiNumber = 0;
 
  tgcFragment = LVL2_MUON_CALIBRATION::TgcCalibFragment(systemId,subSystemId,rdoId,roiNumber);
 
  // retrieve the tgcrdo container
  SG::ReadHandle<TgcRdoContainer> rdoRH(m_tgcRdoKey, ctx);
  if (!rdoRH.isValid()) {
    ATH_MSG_ERROR( "No TGC RDO container found!"  );
    return StatusCode::FAILURE;
  }
  const TgcRdoContainer* tgcRdoContainer = rdoRH.cptr();
 
  // now get the list of ROB Ids and from the the subdetector ID ( that corresponds to the
  // subsystem ID
  
 
  LVL2_MUON_CALIBRATION::TgcCalibData tgc_payload;
  TgcRdoContainer::const_iterator it = tgcRdoContainer->begin();
  
  for ( ; it != tgcRdoContainer->end() ; ++it )  {
 
    ATH_MSG_DEBUG("Adding the hits from a new TGC chamber");
 
    // loop on the element of the TGC RDO
    ATH_MSG_DEBUG("Number of hits: " << (*it)->size());
 
    TgcRdo::const_iterator itRaw = (*it)->begin();
    for ( ; itRaw != (*it)->end() ; ++itRaw )  {
 
      const TgcRawData* raw = (*itRaw);
      LVL2_MUON_CALIBRATION::TGC_BYTESTREAM_READOUTHIT roh;
      LVL2_MUON_CALIBRATION::TGC_BYTESTREAM_READOUTTRIPLETSTRIP tps;
      LVL2_MUON_CALIBRATION::TGC_BYTESTREAM_READOUTTRACKLET rot;
      LVL2_MUON_CALIBRATION::TGC_BYTESTREAM_HIPT hpt;
      LVL2_MUON_CALIBRATION::TGC_BYTESTREAM_SL sl;
 
 
      switch (raw->type()) {
      case TgcRawData::TYPE_HIT:
    {
      roh.channel = raw->channel()-40;
      roh.sbId = raw->slbId();
      roh.sbType = raw->slbType();
      roh.adj = raw->isAdjacent();
      roh.ldbId = raw->sswId();
      roh.bcBitmap = bcBitmap(raw->bcTag());
      roh.tracklet = raw->tracklet();
      roh.ok = 1;
      
    }
    break;
      case TgcRawData::TYPE_TRACKLET:
    if (raw->slbType() == TgcRawData::SLB_TYPE_TRIPLET_STRIP)
      {
        tps.phi = raw->position();
        tps.seg = raw->segment();
        tps.sbId = raw->slbId();
        tps.ldbId = raw->sswId();
        tps.bcBitmap = bcBitmap(raw->bcTag());
        tps.slbType = TgcRawData::SLB_TYPE_TRIPLET_STRIP;
        tps.ok = 1;
      }
    else
      {
        rot.rphi = raw->position();
        rot.subm = raw->subMatrix();
        rot.seg = raw->segment();
        rot.delta = raw->delta();
        rot.sbId = raw->slbId();
        rot.ldbId = raw->sswId();
        rot.bcBitmap = bcBitmap(raw->bcTag());
        rot.slbType = raw->slbType();
        if (raw->slbType() == TgcRawData::SLB_TYPE_INNER_STRIP)
          rot.slbType = 4;
        rot.ok = 1;
      }
    break;
      case TgcRawData::TYPE_HIPT:
    {
      hpt.delta = raw->delta();
      hpt.hitId = raw->hitId();
      hpt.hipt = raw->isHipt();
      hpt.cand = raw->index();
      hpt.chip = raw->chip();
      hpt.sector = raw->sector();
      hpt.fwd = raw->isForward();
      hpt.strip = raw->isStrip();
      hpt.bcBitmap = bcBitmap(raw->bcTag());
    }
    break;
      case TgcRawData::TYPE_SL:
    {
      sl.roi = raw->roi();
      sl.overlap = raw->isOverlap();
      sl.threshold = raw->threshold();
      sl.sign = raw->isMuplus();
      sl.cand = raw->index();
      sl.sector = raw->sector();
      sl.fwd = raw->isForward();
      sl.bcBitmap = bcBitmap(raw->bcTag());
      sl.cand2plus = raw->cand3plus();
    }
    break;
      default:
    {
      ATH_MSG_ERROR("Invalid TgcRawData type: " << raw->type());
      return StatusCode::FAILURE;
    }
      }
      
      tgc_payload.getHit(roh,tps,rot,hpt,sl);
      
    }
  }
 
  tgcFragment << tgc_payload;
  
  return StatusCode::SUCCESS;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

initialize()

StatusCode TrigL2MuonSA::MuCalStreamerTool::initialize ( )

overridevirtual

Definition at line 30 of file MuCalStreamerTool.cxx.

{
   // locate the region selector
   ATH_CHECK( m_regSel_MDT.retrieve() );
   ATH_CHECK( m_regSel_TGC.retrieve() );
 
   ATH_CHECK(m_tgcRdoKey.initialize());
   ATH_CHECK(m_readKey.initialize());
   ATH_CHECK(m_eventInfoKey.initialize());
   ATH_CHECK(m_rpcPadKey.initialize());
 
   return StatusCode::SUCCESS;
 
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

instanceName()

const std::string & TrigL2MuonSA::MuCalStreamerTool::instanceName ( ) const

inline

Definition at line 64 of file MuCalStreamerTool.h.

{return m_algInstanceName;}

isStreamOpen()

bool TrigL2MuonSA::MuCalStreamerTool::isStreamOpen

(

)

Definition at line 100 of file MuCalStreamerTool.cxx.

{return m_circ!=nullptr;}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

openStream()

StatusCode TrigL2MuonSA::MuCalStreamerTool::openStream

(

int

calBufferSize

)

Definition at line 49 of file MuCalStreamerTool.cxx.

{
 
  std::string name = m_calBufferName;
  name += "_"+m_algInstanceName;
  
  if ( m_circ == nullptr ) { 
      try
    {
      m_circ = new TrigL2MuonSA::MuCalCircClient (0, name, calBufferSize);
    }
 
      catch (TrigL2MuonSA::Circexception &e)
    {
      ATH_MSG_WARNING("Could not open muon calibration buffer: name="
              << name << " buffer size=" << calBufferSize);
    }
 
      ATH_MSG_INFO("Opening muon calibration stream. Buffer name: " 
           << name << " buffer size: " << calBufferSize);
  }
 
  return StatusCode::SUCCESS;
}

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setBufferName()

void TrigL2MuonSA::MuCalStreamerTool::setBufferName ( const std::string & buffName )

inline

Definition at line 68 of file MuCalStreamerTool.h.

{m_calBufferName=buffName;}

setInstanceName()

void TrigL2MuonSA::MuCalStreamerTool::setInstanceName ( const std::string & name )

inline

Definition at line 65 of file MuCalStreamerTool.h.

{ m_algInstanceName = name; }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_algInstanceName

std::string TrigL2MuonSA::MuCalStreamerTool::m_algInstanceName

private

Definition at line 100 of file MuCalStreamerTool.h.

m_calBufferName

std::string TrigL2MuonSA::MuCalStreamerTool::m_calBufferName

private

Definition at line 99 of file MuCalStreamerTool.h.

m_circ

TrigL2MuonSA::MuCalCircClient* TrigL2MuonSA::MuCalStreamerTool::m_circ = nullptr

private

Definition at line 124 of file MuCalStreamerTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> TrigL2MuonSA::MuCalStreamerTool::m_eventInfoKey { this, "EventInfoKey", "EventInfo", "" }

private

Definition at line 94 of file MuCalStreamerTool.h.

{ this, "EventInfoKey", "EventInfo", "" };

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_outputFile

std::ofstream TrigL2MuonSA::MuCalStreamerTool::m_outputFile

private

Definition at line 103 of file MuCalStreamerTool.h.

m_readKey

SG::ReadCondHandleKey<RpcCablingCondData> TrigL2MuonSA::MuCalStreamerTool::m_readKey {this, "ReadKey", "RpcCablingCondData", "Key of RpcCablingCondData"}

private

Definition at line 110 of file MuCalStreamerTool.h.

{this, "ReadKey", "RpcCablingCondData", "Key of RpcCablingCondData"};

m_regSel_MDT

ToolHandle<IRegSelTool> TrigL2MuonSA::MuCalStreamerTool::m_regSel_MDT {this, "RegSel_MDT", "RegSelTool/RegSelTool_MDT", "MDT Region Selector Tool"}

private

Definition at line 107 of file MuCalStreamerTool.h.

{this, "RegSel_MDT", "RegSelTool/RegSelTool_MDT", "MDT Region Selector Tool"};

m_regSel_TGC

ToolHandle<IRegSelTool> TrigL2MuonSA::MuCalStreamerTool::m_regSel_TGC {this, "RegSel_TGC", "RegSelTool/RegSelTool_TGC", "TGC Region Selector Tool"}

private

Definition at line 108 of file MuCalStreamerTool.h.

{this, "RegSel_TGC", "RegSelTool/RegSelTool_TGC", "TGC Region Selector Tool"};

m_rpcPadKey

SG::ReadHandleKey<RpcPadContainer> TrigL2MuonSA::MuCalStreamerTool::m_rpcPadKey {this, "RpcPadContainerKey", "RPCPAD", "RpcPad container fro MuCalStreamerTool"}

private

Definition at line 95 of file MuCalStreamerTool.h.

{this, "RpcPadContainerKey", "RPCPAD", "RpcPad container fro MuCalStreamerTool"};

m_tgcRdoKey

SG::ReadHandleKey<TgcRdoContainer> TrigL2MuonSA::MuCalStreamerTool::m_tgcRdoKey {this, "TgcRdoContainer", "TGCRDO", "Tgc RDO Input"}

private

Definition at line 93 of file MuCalStreamerTool.h.

{this, "TgcRdoContainer", "TGCRDO", "Tgc RDO Input"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_writeToFile

Gaudi::Property< bool > TrigL2MuonSA::MuCalStreamerTool::m_writeToFile { this, "WriteToFile", false, "" }

private

Definition at line 92 of file MuCalStreamerTool.h.

{ this, "WriteToFile", false, "" };

---

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

• MuCalStreamerTool.h
• MuCalStreamerTool.cxx