MuCTPIPhase1ByteStreamAlgo Class Reference

this is done in the original (run2) tool; trying to replace this with an include above. More...

#include <MuCTPIPhase1ByteStreamAlgo.h>

Inheritance diagram for MuCTPIPhase1ByteStreamAlgo:

Collaboration diagram for MuCTPIPhase1ByteStreamAlgo:

Public Member Functions
	MuCTPIPhase1ByteStreamAlgo (const std::string &name, ISvcLocator *svcLoc)
	Default constructor.
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &eventContext) const override
virtual StatusCode	finalize () override
StatusCode	convert (const IROBDataProviderSvc::ROBF *rob, SG::WriteHandle< MuCTPI_Phase1_RDO > &outputHandle) const
	Convert ROBFragment to MuCTPI_RDO.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, 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	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
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< uint32_t >	m_robId {this, "ROBID", 0x760000, "MuCTPI DAQ readout ROB ID"}
	Object storing the various IDs of the MuCTPI fragment.
ServiceHandle< IROBDataProviderSvc >	m_robDataProviderSvc { this, "ROBDataProviderSvc", "ROBDataProviderSvc", "ROB data provider"}
	ROBDataProvider service handle.
SG::WriteHandleKey< MuCTPI_Phase1_RDO >	m_MuCTPI_Phase1_RDOKey { this, "MuCTPI_Phase1_RDOKey", "MUCTPI_Phase1_RDO" }
std::vector< uint32_t >	m_muctpi_Nbits = {3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1}
Gaudi::Property< std::string >	m_alias_db {this,"TriggerDBAlias","TRIGGERDB_RUN3","Alias to the TriggerDB to download CTP configuration from"}
Gaudi::Property< bool >	m_doTopo
	Other properties.
const std::string	m_barrelRoIFile = "TrigConfMuctpi/Data_ROI_Mapping_Barrel_040422.txt"
const std::string	m_ecfRoIFile = "TrigConfMuctpi/Data_RoI_Mapping_EF_040422.txt"
const std::string	m_side0LUTFile = "TrigConfMuctpi/lookup_0_040422.json"
const std::string	m_side1LUTFile = "TrigConfMuctpi/lookup_1_040422.json"
LVL1MUCTPIPHASE1::L1TopoLUT	m_l1topoLUT
	Helper members.
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
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

this is done in the original (run2) tool; trying to replace this with an include above.

Algo doing the ROB -> MuCTPI_Phase1_RDO ByteStream conversion

Definition at line 34 of file MuCTPIPhase1ByteStreamAlgo.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MuCTPIPhase1ByteStreamAlgo()

MuCTPIPhase1ByteStreamAlgo::MuCTPIPhase1ByteStreamAlgo	(	const std::string &	name,
		ISvcLocator *	svcLoc )

Default constructor.

The constructor takes care of correctly constructing the base class and declaring the tool's interface to the framework.

Definition at line 22 of file MuCTPIPhase1ByteStreamAlgo.cxx.

    : AthReentrantAlgorithm( name, svcLoc) {}

Member Function Documentation

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

convert()

StatusCode MuCTPIPhase1ByteStreamAlgo::convert	(	const IROBDataProviderSvc::ROBF *	rob,
		SG::WriteHandle< MuCTPI_Phase1_RDO > &	outputHandle ) const

Convert ROBFragment to MuCTPI_RDO.

Conversion from eformat::ROBFragment to RDO.

This is called from the MuCTPIByteStreamCnv::createObj method.

Definition at line 135 of file MuCTPIPhase1ByteStreamAlgo.cxx.

                                                                                                                                          {
 
  ATH_MSG_DEBUG("executing convert() from ROBFragment to RDO");
  // check ROD source ID
  const uint32_t rodId = rob->rod_source_id();
  // check BC ID
  const uint32_t bcId = rob->rod_bc_id();
 
  ATH_MSG_DEBUG(" expected ROD sub-detector ID: " << std::hex << m_robId << " ID found: " << std::hex << rodId << std::dec);  
 
  if( rodId != m_robId ) {
    ATH_MSG_ERROR("Wrong ROD ID found in the MuCTPI ROB fragment!");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_VERBOSE(" ROD Header BCID " << bcId << ", dumping MuCTPI words:");
 
  const uint32_t* it_data;
  rob->rod_data( it_data );
  const uint32_t ndata = rob->rod_ndata();
  ATH_MSG_DEBUG("MUCTPI DQ DEBUG: number of ROB data words: " << std::dec << ndata);
 
  //slices
  std::vector< LVL1::MuCTPIBits::Slice > slices;
  LVL1::MuCTPIBits::Slice slice;
  bool firstSlice=true;
  std::vector<size_t> errorBits;    
  uint64_t sliceMultiplicity=0;//grouping the 3 multiplicity words, to be processed at the end of the slice
 
  for( uint32_t iWord = 0; iWord < ndata; ++iWord, ++it_data ) {
 
      //for each word, get it, find type, and add in Slice struct.
      uint32_t word =  static_cast< uint32_t >( *it_data );
      ATH_MSG_DEBUG("MUCTPI raw word " << iWord << ": 0x" << std::hex << word << std::dec);
      LVL1::MuCTPIBits::WordType wordType = LVL1::MuCTPIBits::getWordType(word);
 
      switch (wordType) {
      case LVL1::MuCTPIBits::WordType::Timeslice: {
 
          ATH_MSG_DEBUG(" MUCTPI DQ DEBUG: Timeslice found: "<< std::hex << word);
 
          //add previous slice if any
          if(!firstSlice)
          {
              ATH_MSG_DEBUG(" MUCTPI DQ DEBUG: new timeslice found (pushing)");
              slices.push_back(slice);
          }
          else
              firstSlice=false;
 
          //make new slice (to be improved, since "new" will give pointer)
          slice =  LVL1::MuCTPIBits::Slice();
 
          const auto header = LVL1::MuCTPIBits::timesliceHeader(word);
          ATH_MSG_DEBUG("This is a timeslice header word with BCID=" << header.bcid
                        << ", NTOB=" << header.tobCount << ", NCAND=" << header.candCount);
          slice.bcid  = header.bcid;
          slice.nCand = header.candCount;
          slice.nTOB  = header.tobCount;
          break;
      }
      case LVL1::MuCTPIBits::WordType::Multiplicity: {
          uint32_t tmNum = LVL1::MuCTPIBits::multiplicityWordNumber(word);
          ATH_MSG_DEBUG("This is a multiplicity word #" << tmNum);
 
          if(m_muctpi_Nbits.size()==32)
          {
              //fill mult word into temp container until 3rd word is found
              if(tmNum==1)
                  sliceMultiplicity |= ( (uint64_t)LVL1::MuCTPIBits::maskedWord(word,LVL1::MuCTPIBits::RUN3_MULTIPLICITY_PART1_SHIFT, LVL1::MuCTPIBits::RUN3_MULTIPLICITY_PART1_MASK) ) << LVL1::MuCTPIBits::RUN3_MULTIPLICITY_ENC_PART1_SHIFT;
              else if(tmNum==2)
                  sliceMultiplicity |= ( (uint64_t)LVL1::MuCTPIBits::maskedWord(word,LVL1::MuCTPIBits::RUN3_MULTIPLICITY_PART2_SHIFT, LVL1::MuCTPIBits::RUN3_MULTIPLICITY_PART2_MASK) ) << LVL1::MuCTPIBits::RUN3_MULTIPLICITY_ENC_PART2_SHIFT;
              else if(tmNum==3)
                  sliceMultiplicity |= ( (uint64_t)LVL1::MuCTPIBits::maskedWord(word,LVL1::MuCTPIBits::RUN3_MULTIPLICITY_PART3_SHIFT, LVL1::MuCTPIBits::RUN3_MULTIPLICITY_PART3_MASK) ) << LVL1::MuCTPIBits::RUN3_MULTIPLICITY_ENC_PART3_SHIFT;
 
              //flags from third word
              //AND: process multiplicity for the slice!!!
              if(tmNum==3)
              {
                  slice.mlt.nswMon       = LVL1::MuCTPIBits::maskedWord(word,LVL1::MuCTPIBits::RUN3_NSW_MONITORING_TRIGGER_SHIFT, LVL1::MuCTPIBits::RUN3_NSW_MONITORING_TRIGGER_MASK);
                  slice.mlt.candOverflow = LVL1::MuCTPIBits::maskedWord(word,LVL1::MuCTPIBits::RUN3_MULTIPLICITY_OVERFLOW_SHIFT,  LVL1::MuCTPIBits::RUN3_MULTIPLICITY_OVERFLOW_MASK);
                  slice.mlt.bits         = sliceMultiplicity;
 
                  //process the long mult word into 32 mlt thr counters
                  for(uint iThr=0;iThr<m_muctpi_Nbits.size();iThr++)
                  {
                      uint thismask=0;
                      if(m_muctpi_Nbits[iThr]==1)
                          thismask=0x1;
                      else if(m_muctpi_Nbits[iThr]==2)
                          thismask=0x3;
                      else if(m_muctpi_Nbits[iThr]==3)
                          thismask=0x7;
 
                      //keep only the part of the 64bit word corresponding to the nbits value
                      slice.mlt.cnt.push_back( sliceMultiplicity & thismask);
                      //"throw away" the part of the 64bit word that we just used
                      sliceMultiplicity >>= m_muctpi_Nbits[iThr];
                  }
 
                  sliceMultiplicity=0;//cleaning just in case..
              }
 
          }
          else
          {
              //if nbits size !=32, then it's not set
              //for now, ignore, and can fill the histos with the Mult bits, as they come
              //without decoding
              //=>suppress this warning
              //ATH_MSG_WARNING("MUCTPI DQ DEBUG: skipping Mult processing, no nbits defined");
 
              //todo: add code + histos for Mult bits
          }
 
          break;
      }
      case LVL1::MuCTPIBits::WordType::Candidate: {
        ATH_MSG_DEBUG("This is a RoI candidate word");
 
        LVL1::MuCTPIBits::Candidate thiscand(word);
 
        // We calculate eta/phi coordinates for each candidate with the 
        // full resolution available.
        if(thiscand.type == LVL1::MuCTPIBits::SubsysID::Barrel)
        {
            thiscand.eta = m_l1topoLUT.getCoordinates(thiscand.side, thiscand.subsystem, thiscand.num, thiscand.roi).eta;
            thiscand.phi = m_l1topoLUT.getCoordinates(thiscand.side, thiscand.subsystem, thiscand.num, thiscand.roi).phi;
            //ATH_MSG_INFO("Candidate Pt " << thiscand.pt);
            thiscand.mappedPt = LVL1::MuCTPIBits::RPCtoTGC_pt_map[thiscand.pt];
            //ATH_MSG_INFO("Candidate mapped Pt " << thiscand.mappedPt);
        }
        else if(thiscand.type == LVL1::MuCTPIBits::SubsysID::Endcap)
        {
            thiscand.eta = m_l1topoLUT.getCoordinates(thiscand.side, thiscand.subsystem, thiscand.num, thiscand.roi).eta;
            thiscand.phi = m_l1topoLUT.getCoordinates(thiscand.side, thiscand.subsystem, thiscand.num, thiscand.roi).phi;
        }
        else if(thiscand.type == LVL1::MuCTPIBits::SubsysID::Forward)
        {
            thiscand.eta = m_l1topoLUT.getCoordinates(thiscand.side, thiscand.subsystem, thiscand.num, thiscand.roi).eta;
            thiscand.phi = m_l1topoLUT.getCoordinates(thiscand.side, thiscand.subsystem, thiscand.num, thiscand.roi).phi;
        }
        slice.cand.push_back(thiscand);
        break;
      }
      case LVL1::MuCTPIBits::WordType::Topo: {
        ATH_MSG_DEBUG("This is a Topo TOB word "<< std::hex << word);
        LVL1::MuCTPIBits::TopoTOB thistob(word);
 
        if(thistob.det == 0) // BA
        {
          try
          {
            thistob.roi = m_l1topoLUT.getBarrelROI(thistob.side, thistob.sec, thistob.barrel_eta_lookup, thistob.barrel_phi_lookup);
          }
          catch (const std::out_of_range& e) // Occurs when getBarrelROI fails to find entry in the map
          { 
            ++barrelROIFailCounter;
            ATH_MSG_WARNING("TopoTOB word not found in LUT!"
                            << " (" << e.what() << " exception)"
                            << " Word info: det = " << thistob.det
                            << ", subsystem = " << thistob.subsystem
                            << ", side = " << thistob.side
                            << ", sector = " << thistob.sec
                            << ", ieta = " << thistob.barrel_eta_lookup
                            << ", iphi = " << thistob.barrel_phi_lookup);
            break;
          }
          thistob.etaDecoded = m_l1topoLUT.getCoordinates(thistob.side, thistob.subsystem, thistob.sec, thistob.roi).eta;
          thistob.phiDecoded = m_l1topoLUT.getCoordinates(thistob.side, thistob.subsystem, thistob.sec, thistob.roi).phi;
        }
        else // FW or EC
        {
          // FW and EC have the ROI initialized in the constructor of the Topo word, because it is encoded in eta_raw and phi_raw 
          thistob.etaDecoded = m_l1topoLUT.getCoordinates(thistob.side, thistob.subsystem, thistob.sec, thistob.roi).eta;
          thistob.phiDecoded = m_l1topoLUT.getCoordinates(thistob.side, thistob.subsystem, thistob.sec, thistob.roi).phi;
        }        
        slice.tob.push_back(thistob);
        break;
      }
      case LVL1::MuCTPIBits::WordType::Status: {
        ATH_MSG_DEBUG("This is a status word"<< std::hex << word);
        errorBits = LVL1::MuCTPIBits::getDataStatusWordErrors(word);
        if (!errorBits.empty()) {
          ATH_MSG_DEBUG("MUCTPI ROD data flagged with errors. The data status word is 0x" << std::hex << word << std::dec);
          for (size_t bit : errorBits) {
            ATH_MSG_DEBUG("Error bit " << bit << ": " << LVL1::MuCTPIBits::DataStatusWordErrors.at(bit));
          }
        }
        break;
      }
      default: {
        ATH_MSG_ERROR("The MUCTPI word 0x" << std::hex << word << std::dec << " does not match any known word type");
        return StatusCode::FAILURE;
      }//default
      }//switch
  }//for each word
 
  //add last timeslice in vector, since there is no end-slice flag
  ATH_MSG_DEBUG(" MUCTPI DQ DEBUG: out of words (pushing last slice)");
  slices.push_back( std::move(slice) );
 
  // Check that the number of exceptions is below a limit based on the number of slices.
  // Exceptions can occur if word is present in multiple timeslices for same event.
  // This allows for cases where we have one or two bad words per event, but not where lots of map errors arise. 
  if (barrelROIFailCounter == slices.size() + 2 )
  {
    ATH_MSG_ERROR("TopoTOB word exception count exceeded limit!");
    return StatusCode::FAILURE;
  }
 
  // create MuCTPI RDO
  ATH_CHECK(outputHandle.record(
      std::make_unique<MuCTPI_Phase1_RDO>(std::move(slices), std::move(errorBits))
  ));
  return StatusCode::SUCCESS;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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; }

execute()

StatusCode MuCTPIPhase1ByteStreamAlgo::execute ( const EventContext & eventContext ) const

overridevirtual

Definition at line 110 of file MuCTPIPhase1ByteStreamAlgo.cxx.

                                                                                     {
    ATH_MSG_DEBUG("Executing " << name());
 
    // Retrieve the BS data for all tools in one request to parallelise DCM->ROS network requests
    IROBDataProviderSvc::VROBFRAG vrobf;
    std::vector<uint32_t> robID = { m_robId };// Source ID of MIROD
    //get rob fragment(s)
    m_robDataProviderSvc->getROBData(eventContext, robID, vrobf, name());
    //should only receive exactly 1 fragment; make sure:
    if(vrobf.size()!=1)
    {
        ATH_MSG_ERROR("Wrong number of MUCTPI fragment in event: vrobf.size()="<<vrobf.size());
        return StatusCode::FAILURE;
    }
 
    //make the conversion, i.e. make the RDO, record it
    SG::WriteHandle<MuCTPI_Phase1_RDO> outputHandle{m_MuCTPI_Phase1_RDOKey, eventContext};
    ATH_CHECK(convert(vrobf[0],outputHandle));
    return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode MuCTPIPhase1ByteStreamAlgo::finalize ( )

overridevirtual

Definition at line 353 of file MuCTPIPhase1ByteStreamAlgo.cxx.

{
    if (barrelROIFailCounter != 0) ATH_MSG_WARNING(barrelROIFailCounter << " TopoTOB words could not retrieve RoIs in the barrel");
    return StatusCode::SUCCESS;
}

initialize()

StatusCode MuCTPIPhase1ByteStreamAlgo::initialize ( )

overridevirtual

fetch nbits vector from l1menu (todo: fix) bool success=false; TrigConf::L1CTPFiles ctpfiles; SG::ReadHandleKey<TrigConf::L1Menu> L1MenuKey{this, "L1TriggerMenu", "DetectorStore+L1TriggerMenu", "L1 Menu"};

ATH_CHECK(L1MenuKey.initialize()); if(L1MenuKey.initialize()) { SG::ReadHandle<TrigConf::L1Menu> l1Menu = SG::makeHandle(L1MenuKey);

if (!l1Menu.isValid()) { ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES L1 menu INvalid! Cannot read nbits for mlt word"); } else { ATH_MSG_DEBUG("MUCTPI DQ DEBUG: CTPFILES L1 menu valid"); uint smk = l1Menu->smk(); TrigConf::TrigDBCTPFilesLoader db_loader(m_alias_db); options below added according to TrigConf::L1CTPFiles header file ATH_MSG_DEBUG("MUCTPI DQ DEBUG: CTPFILES L1 menu load files with smk="<<smk); try{success = db_loader.loadHardwareFiles(smk, ctpfiles,0x08);} catch(std::exception& e){ ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES loadHardwareFiles exception: "<<e.what()); } catch(...){ ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES loadHardwareFiles: Unknown exception"); }

ATH_MSG_DEBUG("MUCTPI DQ DEBUG: CTPFILES success="<<success); } if(!ctpfiles.hasCompleteMuctpiData()) { ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES Incomplete MUCTPI data from TriggerDB"); } else if(success) { ATH_MSG_DEBUG("MUCTPI DQ DEBUG: CTPFILES L1 menu load files success!"); try { m_muctpi_Nbits = (std::vector<uint32_t>) ctpfiles.muctpi_Nbits(); if(m_muctpi_Nbits.size()!=32) ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES MUCTPI data from TriggerDB - nbits wrong size: "<<std::dec << m_muctpi_Nbits.size()); else ATH_MSG_WARNING("MUCTPI DQ DEBUG: CTPFILES MUCTPI data from TriggerDB - nbits GOOD SIZE!");

ATH_MSG_DEBUG("MUCTPI DQ DEBUG: CTPFILES L1 menu GOT muctpi nbits");

} catch(std::exception& e){ ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES exception: "<<e.what()); } catch(...){ ATH_MSG_ERROR("MUCTPI DQ DEBUG: CTPFILES: Unknown exception"); } }

} return StatusCode::SUCCESS;

Definition at line 25 of file MuCTPIPhase1ByteStreamAlgo.cxx.

{
    ATH_MSG_DEBUG("Initialising " << name());
 
    ATH_CHECK( m_MuCTPI_Phase1_RDOKey.initialize(/*m_processMuctpi=*/true) );
 
    //needed to enable the decoding of eta and phi
    ATH_MSG_INFO("--- ENABLING THE DECODING");
    const std::string barrelFileName   = PathResolverFindCalibFile( m_barrelRoIFile );
    ATH_MSG_INFO("--- - CHECK BARREL FILE NAME" << barrelFileName);
    const std::string ecfFileName      = PathResolverFindCalibFile( m_ecfRoIFile );
    ATH_MSG_INFO("--- - CHECK ECF FILE NAME" << ecfFileName);
    const std::string side0LUTFileName = PathResolverFindCalibFile( m_side0LUTFile );
    ATH_MSG_INFO("--- - CHECK SIDE0 LUT FILE NAME" << side0LUTFileName);
    const std::string side1LUTFileName = PathResolverFindCalibFile( m_side1LUTFile );
    ATH_MSG_INFO("--- - INFO SIDE1 LUT FILE NAME" << side1LUTFileName);
 
    CHECK( m_l1topoLUT.initializeLUT(barrelFileName,
                                     ecfFileName,
                                     side0LUTFileName,
                                     side1LUTFileName) );
 
    //return here while looking for fix for this
    return StatusCode::SUCCESS;
    
    //this didn't work yet locally (offline). Waiting for feedback and should cleanup or reinclude soon.
    //not critical; can run without it.
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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.

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::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< Gaudi::Algorithm > >::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_alias_db

Gaudi::Property<std::string> MuCTPIPhase1ByteStreamAlgo::m_alias_db {this,"TriggerDBAlias","TRIGGERDB_RUN3","Alias to the TriggerDB to download CTP configuration from"}

private

Definition at line 59 of file MuCTPIPhase1ByteStreamAlgo.h.

{this,"TriggerDBAlias","TRIGGERDB_RUN3","Alias to the TriggerDB to download CTP configuration from"};

m_barrelRoIFile

const std::string MuCTPIPhase1ByteStreamAlgo::m_barrelRoIFile = "TrigConfMuctpi/Data_ROI_Mapping_Barrel_040422.txt"

private

Definition at line 65 of file MuCTPIPhase1ByteStreamAlgo.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doTopo

Gaudi::Property<bool> MuCTPIPhase1ByteStreamAlgo::m_doTopo

private

Initial value:

{
    this, "DoTopo", false, "Enable decoding/encoding MUCTPI Topo TOBs"}

Other properties.

Definition at line 62 of file MuCTPIPhase1ByteStreamAlgo.h.

                               {
    this, "DoTopo", false, "Enable decoding/encoding MUCTPI Topo TOBs"};

m_ecfRoIFile

const std::string MuCTPIPhase1ByteStreamAlgo::m_ecfRoIFile = "TrigConfMuctpi/Data_RoI_Mapping_EF_040422.txt"

private

Definition at line 66 of file MuCTPIPhase1ByteStreamAlgo.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_l1topoLUT

LVL1MUCTPIPHASE1::L1TopoLUT MuCTPIPhase1ByteStreamAlgo::m_l1topoLUT

private

Helper members.

Definition at line 71 of file MuCTPIPhase1ByteStreamAlgo.h.

m_muctpi_Nbits

std::vector<uint32_t> MuCTPIPhase1ByteStreamAlgo::m_muctpi_Nbits = {3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1}

private

Definition at line 58 of file MuCTPIPhase1ByteStreamAlgo.h.

{3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1}; //default value, used for DQ mon

m_MuCTPI_Phase1_RDOKey

SG::WriteHandleKey<MuCTPI_Phase1_RDO> MuCTPIPhase1ByteStreamAlgo::m_MuCTPI_Phase1_RDOKey { this, "MuCTPI_Phase1_RDOKey", "MUCTPI_Phase1_RDO" }

private

Definition at line 56 of file MuCTPIPhase1ByteStreamAlgo.h.

{ this, "MuCTPI_Phase1_RDOKey", "MUCTPI_Phase1_RDO" };

m_robDataProviderSvc

ServiceHandle<IROBDataProviderSvc> MuCTPIPhase1ByteStreamAlgo::m_robDataProviderSvc { this, "ROBDataProviderSvc", "ROBDataProviderSvc", "ROB data provider"}

private

ROBDataProvider service handle.

Definition at line 54 of file MuCTPIPhase1ByteStreamAlgo.h.

{ this, "ROBDataProviderSvc", "ROBDataProviderSvc", "ROB data provider"};

m_robId

Gaudi::Property<uint32_t> MuCTPIPhase1ByteStreamAlgo::m_robId {this, "ROBID", 0x760000, "MuCTPI DAQ readout ROB ID"}

private

Object storing the various IDs of the MuCTPI fragment.

Definition at line 51 of file MuCTPIPhase1ByteStreamAlgo.h.

{this, "ROBID", 0x760000, "MuCTPI DAQ readout ROB ID"};

m_side0LUTFile

const std::string MuCTPIPhase1ByteStreamAlgo::m_side0LUTFile = "TrigConfMuctpi/lookup_0_040422.json"

private

Definition at line 67 of file MuCTPIPhase1ByteStreamAlgo.h.

m_side1LUTFile

const std::string MuCTPIPhase1ByteStreamAlgo::m_side1LUTFile = "TrigConfMuctpi/lookup_1_040422.json"

private

Definition at line 68 of file MuCTPIPhase1ByteStreamAlgo.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• MuCTPIPhase1ByteStreamAlgo.h
• MuCTPIPhase1ByteStreamAlgo.cxx