LVL1BS::CpByteStreamV2Tool Class Reference

Tool to perform ROB fragments to CPM towers, CMX-CP TOBs and CMX-CP hits, and CP container to raw data conversions. More...

#include <CpByteStreamV2Tool.h>

Inheritance diagram for LVL1BS::CpByteStreamV2Tool:

Collaboration diagram for LVL1BS::CpByteStreamV2Tool:

Classes
struct	CmxCpHitsData
struct	CmxCpTobData
struct	CpByteStreamToolData
struct	CpmTowerData
struct	LocalData

Public Member Functions
	CpByteStreamV2Tool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~CpByteStreamV2Tool ()
virtual StatusCode	initialize () override
StatusCode	convert (const std::string &sgKey, DataVector< LVL1::CPMTower > *ttCollection) const
	Convert ROB fragments to CPM towers. More...
StatusCode	convert (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::CPMTower > *ttCollection) const
StatusCode	convert (const std::string &sgKey, DataVector< LVL1::CMXCPTob > *tobCollection) const
	Convert ROB fragments to CMX-CP TOBs. More...
StatusCode	convert (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::CMXCPTob > *tobCollection) const
StatusCode	convert (const std::string &sgKey, DataVector< LVL1::CMXCPHits > *hitCollection) const
	Convert ROB fragments to CMX-CP hits. More...
StatusCode	convert (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::CMXCPHits > *hitCollection) const
StatusCode	convert (const LVL1::CPBSCollectionV2 *cp) const
	Convert CP Container to bytestream. More...
const std::vector< uint32_t > &	sourceIDs () const
	Return reference to vector with all possible Source Identifiers. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	AlgTool InterfaceID. More...

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
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. More...

Private Types
enum	CollectionType { CPM_TOWERS, CMX_CP_TOBS, CMX_CP_HITS }
typedef DataVector< LVL1::CPMTower >	CpmTowerCollection
typedef DataVector< LVL1::CMXCPTob >	CmxCpTobCollection
typedef DataVector< LVL1::CMXCPHits >	CmxCpHitsCollection
typedef std::map< unsigned int, LVL1::CPMTower * >	CpmTowerMap
typedef std::map< unsigned int, const LVL1::CPMTower * >	ConstCpmTowerMap
typedef std::map< int, LVL1::CMXCPTob * >	CmxCpTobMap
typedef std::map< int, const LVL1::CMXCPTob * >	ConstCmxCpTobMap
typedef std::map< int, LVL1::CMXCPHits * >	CmxCpHitsMap
typedef std::map< int, const LVL1::CMXCPHits * >	ConstCmxCpHitsMap
typedef IROBDataProviderSvc::VROBFRAG::const_iterator	ROBIterator
typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType	ROBPointer
typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType	RODPointer
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::vector< uint32_t >	makeSourceIDs () const
	Create list of all source IDs. More...
StatusCode	convertBs (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, CpByteStreamToolData &data) const
	Convert bytestream to given container type. More...
void	decodeCmxCp (CmxCpSubBlock *subBlock, int trigCpm, CpByteStreamToolData &data, LocalData &ld) const
	Unpack CMX-CP sub-block. More...
void	decodeCpm (CpmSubBlockV2 *subBlock, int trigCpm, CpmTowerData &data, LocalData &ld) const
	Unpack CPM sub-block. More...
const LVL1::CPMTower *	findCpmTower (unsigned int key, const ConstCpmTowerMap &ttMap) const
	Find a CPM tower for given key. More...
LVL1::CPMTower *	findCpmTower (const CpmTowerData &data, unsigned int key) const
const LVL1::CMXCPTob *	findCmxCpTob (int key, const ConstCmxCpTobMap &tobMap) const
	Find CMX-CP TOB for given key. More...
LVL1::CMXCPTob *	findCmxCpTob (const CmxCpTobData &data, int key) const
const LVL1::CMXCPHits *	findCmxCpHits (int key, const ConstCmxCpHitsMap &hitsMap) const
	Find CMX-CP hits for given key. More...
LVL1::CMXCPHits *	findCmxCpHits (const CmxCpHitsData &data, int key) const
void	setupCpmTowerMap (const CpmTowerCollection *ttCollection, ConstCpmTowerMap &ttMap, LVL1::TriggerTowerKey &towerKey) const
	Set up CPM tower map. More...
void	setupCmxCpTobMap (const CmxCpTobCollection *tobCollection, ConstCmxCpTobMap &tobMap) const
	Set up CMX-CP TOB map. More...
void	setupCmxCpHitsMap (const CmxCpHitsCollection *hitCollection, ConstCmxCpHitsMap &hitsMap) const
	Set up CMX-CP hits map. More...
int	tobKey (int crate, int cmx, int cpm, int chip, int loc) const
	Key for TOBs. More...
int	hitsKey (int crate, int cmx, int source) const
	Key for Hits. More...
bool	slinkSlices (int crate, int module, int modulesPerSlink, int &timeslices, int &trigJem, const ConstCpmTowerMap &ttMap, const ConstCmxCpTobMap &tobMap, const ConstCmxCpHitsMap &hitsMap, LVL1::TriggerTowerKey &towerKey) const
	Get number of slices and triggered slice offset for next slink. More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
Gaudi::Property< bool >	m_enableEncoding
SmartIF< ByteStreamCnvSvc >	m_byteStreamCnvSvc
ToolHandle< LVL1::IL1CaloMappingTool >	m_cpmMaps
	Channel mapping tool. More...
ToolHandle< LVL1BS::L1CaloErrorByteStreamTool >	m_errorTool
	Error collection tool. More...
ServiceHandle< IROBDataProviderSvc >	m_robDataProvider
int	m_crateOffsetHw
	Property: Hardware crate number offset. More...
int	m_crateOffsetSw
	Property: Software crate number offset. More...
int	m_version
	Property: Sub_block header version. More...
int	m_dataFormat
	Property: Data compression format. More...
const int	m_channels
	Number of channels per module. More...
int	m_crates
	Property: Number of crates. More...
const int	m_modules
	Number of CPM modules per crate. More...
const int	m_cmxs
	Number of CMXs per crate. More...
const int	m_maxTobs
	Maximum number of TOBS per module. More...
const int	m_chips
	Number of chips. More...
const int	m_locs
	Number of Local coordinates. More...
int	m_slinks
	Property: Number of slinks per crate when writing out bytestream. More...
int	m_dfltSlices
	Property: Default number of slices in simulation. More...
int	m_forceSlices
	Property: Force number of slices in bytestream. More...
int	m_crateMin
	Property: Minimum crate number when writing out bytestream. More...
int	m_crateMax
	Property: Maximum crate number when writing out bytestream. More...
const eformat::SubDetector	m_subDetector
	Sub-detector type. More...
const L1CaloSrcIdMap	m_srcIdMap
	Source ID converter. More...
std::vector< uint32_t >	m_sourceIDsProp
	Property: ROB source IDs. More...
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Tool to perform ROB fragments to CPM towers, CMX-CP TOBs and CMX-CP hits, and CP container to raw data conversions.

Based on ROD document version X_xxx.

Author

Peter Faulkner

Definition at line 54 of file CpByteStreamV2Tool.h.

Member Typedef Documentation

CmxCpHitsCollection

typedef DataVector<LVL1::CMXCPHits> LVL1BS::CpByteStreamV2Tool::CmxCpHitsCollection

private

Definition at line 135 of file CpByteStreamV2Tool.h.

CmxCpHitsMap

typedef std::map<int, LVL1::CMXCPHits*> LVL1BS::CpByteStreamV2Tool::CmxCpHitsMap

private

Definition at line 140 of file CpByteStreamV2Tool.h.

CmxCpTobCollection

typedef DataVector<LVL1::CMXCPTob> LVL1BS::CpByteStreamV2Tool::CmxCpTobCollection

private

Definition at line 134 of file CpByteStreamV2Tool.h.

CmxCpTobMap

typedef std::map<int, LVL1::CMXCPTob*> LVL1BS::CpByteStreamV2Tool::CmxCpTobMap

private

Definition at line 138 of file CpByteStreamV2Tool.h.

ConstCmxCpHitsMap

typedef std::map<int, const LVL1::CMXCPHits*> LVL1BS::CpByteStreamV2Tool::ConstCmxCpHitsMap

private

Definition at line 141 of file CpByteStreamV2Tool.h.

ConstCmxCpTobMap

typedef std::map<int, const LVL1::CMXCPTob*> LVL1BS::CpByteStreamV2Tool::ConstCmxCpTobMap

private

Definition at line 139 of file CpByteStreamV2Tool.h.

ConstCpmTowerMap

typedef std::map<unsigned int, const LVL1::CPMTower*> LVL1BS::CpByteStreamV2Tool::ConstCpmTowerMap

private

Definition at line 137 of file CpByteStreamV2Tool.h.

CpmTowerCollection

typedef DataVector<LVL1::CPMTower> LVL1BS::CpByteStreamV2Tool::CpmTowerCollection

private

Definition at line 133 of file CpByteStreamV2Tool.h.

CpmTowerMap

typedef std::map<unsigned int, LVL1::CPMTower*> LVL1BS::CpByteStreamV2Tool::CpmTowerMap

private

Definition at line 136 of file CpByteStreamV2Tool.h.

ROBIterator

typedef IROBDataProviderSvc::VROBFRAG::const_iterator LVL1BS::CpByteStreamV2Tool::ROBIterator

private

Definition at line 142 of file CpByteStreamV2Tool.h.

ROBPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::CpByteStreamV2Tool::ROBPointer

private

Definition at line 143 of file CpByteStreamV2Tool.h.

RODPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::CpByteStreamV2Tool::RODPointer

private

Definition at line 144 of file CpByteStreamV2Tool.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

CollectionType

enum LVL1BS::CpByteStreamV2Tool::CollectionType

private

Enumerator
CPM_TOWERS
CMX_CP_TOBS
CMX_CP_HITS

Definition at line 131 of file CpByteStreamV2Tool.h.

{ CPM_TOWERS, CMX_CP_TOBS, CMX_CP_HITS };

Constructor & Destructor Documentation

CpByteStreamV2Tool()

LVL1BS::CpByteStreamV2Tool::CpByteStreamV2Tool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 51 of file CpByteStreamV2Tool.cxx.

    : AthAlgTool(type, name, parent),
      m_cpmMaps("LVL1::CpmMappingTool/CpmMappingTool"),
      m_errorTool("LVL1BS::L1CaloErrorByteStreamTool/L1CaloErrorByteStreamTool"),
      m_robDataProvider("ROBDataProviderSvc", name),
      m_channels(80), m_crates(4), m_modules(14), m_cmxs(2), m_maxTobs(5),
      m_chips(16), m_locs(4),
      m_subDetector(eformat::TDAQ_CALO_CLUSTER_PROC_DAQ)
{
    declareInterface<CpByteStreamV2Tool>(this);
 
    declareProperty("CpmMappingTool", m_cpmMaps,
                    "Crate/Module/Channel to Eta/Phi/Layer mapping tool");
    declareProperty("ErrorTool", m_errorTool,
                    "Tool to collect errors for monitoring");
 
    declareProperty("CrateOffsetHw",  m_crateOffsetHw  = 8,
                    "Offset of CP crate numbers in bytestream");
    declareProperty("CrateOffsetSw",  m_crateOffsetSw  = 0,
                    "Offset of CP crate numbers in RDOs");
 
    // Properties for reading bytestream only
    declareProperty("ROBSourceIDs",       m_sourceIDsProp,
                    "ROB fragment source identifiers");
 
    // Properties for writing bytestream only
    declareProperty("DataVersion",    m_version     = 2,                //  <<== CHECK
                    "Format version number in sub-block header");
    declareProperty("DataFormat",     m_dataFormat  = 1,
                    "Format identifier (0-1) in sub-block header");
    declareProperty("SlinksPerCrate", m_slinks      = 2,
                    "The number of S-Links per crate");
    declareProperty("SimulSlices",    m_dfltSlices  = 1,
                    "The number of slices in the simulation");
    declareProperty("ForceSlices",    m_forceSlices = 0,
                    "If >0, the number of slices in bytestream");
    declareProperty("CrateMin",       m_crateMin = 0,
                    "Minimum crate number, allows partial output");
    declareProperty("CrateMax",       m_crateMax = m_crates - 1,
                    "Maximum crate number, allows partial output");
 
}

~CpByteStreamV2Tool()

LVL1BS::CpByteStreamV2Tool::~CpByteStreamV2Tool ( )

virtual

Definition at line 98 of file CpByteStreamV2Tool.cxx.

{
}

Member Function Documentation

convert() [1/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert

(

const LVL1::CPBSCollectionV2 *

cp

)

const

Convert CP Container to bytestream.

Definition at line 188 of file CpByteStreamV2Tool.cxx.

{
    if (not m_enableEncoding.value()) {
        ATH_MSG_ERROR("Encoding method called while " << m_enableEncoding.name() << "=False");
        return StatusCode::FAILURE;
    }
 
    const bool debug = msgLvl(MSG::DEBUG);
    if (debug) msg(MSG::DEBUG);
 
    // Get the event assembler
    FullEventAssembler<L1CaloSrcIdMap>* fea = nullptr;
    ATH_CHECK( m_byteStreamCnvSvc->getFullEventAssembler (fea,
                                                          "CpByteStreamV2") );
    const uint16_t minorVersion = m_srcIdMap.minorVersion();
    fea->setRodMinorVersion(minorVersion);
 
    // Pointer to ROD data vector
 
    FullEventAssembler<L1CaloSrcIdMap>::RODDATA *theROD = 0;
 
    LVL1::TriggerTowerKey towerKey;
 
    // Set up the container maps
 
    // CPM tower map
    ConstCpmTowerMap  ttMap;
    setupCpmTowerMap(cp->towers(), ttMap, towerKey);
 
    // CMX-CP TOB map
    ConstCmxCpTobMap tobMap;
    setupCmxCpTobMap(cp->tobs(), tobMap);
 
    // CMX-CP hits map
    ConstCmxCpHitsMap hitsMap;
    setupCmxCpHitsMap(cp->hits(), hitsMap);
 
    // Loop over data
 
    const bool neutralFormat   = m_dataFormat == L1CaloSubBlock::NEUTRAL;
    const int  modulesPerSlink = m_modules / m_slinks;
    int timeslices    = 1;
    int trigCpm       = 0;
    int timeslicesNew = 1;
    int trigCpmNew    = 0;
    for (int crate = m_crateMin; crate <= m_crateMax; ++crate)
    {
        const int hwCrate = crate + m_crateOffsetHw;
 
        // CPM modules are numbered 1 to m_modules
        for (int module = 1; module <= m_modules; ++module)
        {
            const int mod = module - 1;
 
            // Pack required number of modules per slink
 
            if (mod % modulesPerSlink == 0)
            {
                const int daqOrRoi = 0;
                const int slink = (m_slinks == 2) ? 2 * (mod / modulesPerSlink)
                                  : mod / modulesPerSlink;
                if (debug)
                {
                    msg() << "Treating crate " << hwCrate
                          << " slink " << slink << endmsg;
                }
                // Get number of CPM slices and triggered slice offset
                // for this slink
                if ( ! slinkSlices(crate, module, modulesPerSlink,
                                   timeslices, trigCpm,
                                   ttMap,
                                   tobMap,
                                   hitsMap,
                                   towerKey))
                {
                    msg(MSG::ERROR) << "Inconsistent number of slices or "
                                    << "triggered slice offsets in data for crate "
                                    << hwCrate << " slink " << slink << endmsg;
                    return StatusCode::FAILURE;
                }
                timeslicesNew = (m_forceSlices) ? m_forceSlices : timeslices;
                trigCpmNew    = ModifySlices::peak(trigCpm, timeslices, timeslicesNew);
                if (debug)
                {
                    msg() << "Data Version/Format: " << m_version
                          << " " << m_dataFormat << endmsg
                          << "Slices/offset: " << timeslices << " " << trigCpm;
                    if (timeslices != timeslicesNew)
                    {
                        msg() << " modified to " << timeslicesNew << " " << trigCpmNew;
                    }
                    msg() << endmsg;
                }
                L1CaloUserHeader userHeader;
                userHeader.setCpm(trigCpmNew);
                const uint32_t rodIdCpm = m_srcIdMap.getRodID(hwCrate, slink, daqOrRoi,
                                          m_subDetector);
                theROD = fea->getRodData(rodIdCpm);
                theROD->push_back(userHeader.header());
            }
            if (debug) msg() << "Module " << module << endmsg;
 
            // Create a sub-block for each slice (except Neutral format)
 
            DataVector<CpmSubBlockV2> cpmBlocks;
            for (int slice = 0; slice < timeslicesNew; ++slice)
            {
                CpmSubBlockV2 *const subBlock = new CpmSubBlockV2();
                subBlock->setCpmHeader(m_version, m_dataFormat, slice,
                                       hwCrate, module, timeslicesNew);
                cpmBlocks.push_back(subBlock);
                if (neutralFormat) break;
            }
 
            // Find CPM towers corresponding to each eta/phi pair and fill
            // sub-blocks
 
            for (int chan = 0; chan < m_channels; ++chan)
            {
                double eta = 0.;
                double phi = 0.;
                int layer = 0;
                if (m_cpmMaps->mapping(crate, module, chan, eta, phi, layer))
                {
                    const unsigned int key = towerKey.ttKey(phi, eta);
                    const LVL1::CPMTower *const tt = findCpmTower(key, ttMap);
                    if (tt )
                    {
                        std::vector<int> emData;
                        std::vector<int> hadData;
                        std::vector<int> emError;
                        std::vector<int> hadError;
                        ModifySlices::data(tt->emEnergyVec(),  emData,   timeslicesNew);
                        ModifySlices::data(tt->hadEnergyVec(), hadData,  timeslicesNew);
                        ModifySlices::data(tt->emErrorVec(),   emError,  timeslicesNew);
                        ModifySlices::data(tt->hadErrorVec(),  hadError, timeslicesNew);
                        for (int slice = 0; slice < timeslicesNew; ++slice)
                        {
                            const LVL1::DataError emErrBits(emError[slice]);
                            const LVL1::DataError hadErrBits(hadError[slice]);
                            const int emErr  =
                                (emErrBits.get(LVL1::DataError::LinkDown) << 1) |
                                emErrBits.get(LVL1::DataError::Parity);
                            const int hadErr =
                                (hadErrBits.get(LVL1::DataError::LinkDown) << 1) |
                                hadErrBits.get(LVL1::DataError::Parity);
                            const int index  = ( neutralFormat ) ? 0 : slice;
                            CpmSubBlockV2 *const subBlock = cpmBlocks[index];
                            subBlock->fillTowerData(slice, chan, emData[slice],
                                                    hadData[slice], emErr, hadErr);
                            if ((emErrBits.error() >> LVL1::DataError::GLinkParity))
                            {
                                int gLinkParity   = emErrBits.get(LVL1::DataError::GLinkParity);
                                int gLinkProtocol = emErrBits.get(LVL1::DataError::GLinkProtocol);
                                int bCNMismatch   = emErrBits.get(LVL1::DataError::BCNMismatch);
                                int fIFOOverflow  = emErrBits.get(LVL1::DataError::FIFOOverflow);
                                int moduleError   = emErrBits.get(LVL1::DataError::ModuleError);
                                int gLinkDown     = emErrBits.get(LVL1::DataError::GLinkDown);
                                int gLinkTimeout  = emErrBits.get(LVL1::DataError::GLinkTimeout);
                                uint32_t failingBCN = emErrBits.get(LVL1::DataError::FailingBCN);
                                subBlock->setStatus(failingBCN, gLinkTimeout, gLinkDown,
                                                    moduleError, fIFOOverflow, bCNMismatch,
                                                    gLinkProtocol, gLinkParity);
                            }
                        }
                    }
                }
            }
 
            // Pack and write the sub-blocks
 
            DataVector<CpmSubBlockV2>::iterator pos;
            for (pos = cpmBlocks.begin(); pos != cpmBlocks.end(); ++pos)
            {
                CpmSubBlockV2 *const subBlock = *pos;
                if ( !subBlock->pack())
                {
                    msg(MSG::ERROR) << "CPM sub-block packing failed" << endmsg;
                    return StatusCode::FAILURE;
                }
                if (debug)
                {
                    msg() << "CPM sub-block data words: "
                          << subBlock->dataWords() << endmsg;
                }
                subBlock->write(theROD);
            }
        }
 
        // Append CMXs to last S-Link of the crate
 
        for (int cmx = 0; cmx < m_cmxs; ++cmx)
        {
 
            // Create a sub-block for each slice (except Neutral format)
 
            DataVector<CmxCpSubBlock> cmxBlocks;
            const int summing = (crate == m_crates - 1) ? CmxSubBlock::SYSTEM
                                : CmxSubBlock::CRATE;
            for (int slice = 0; slice < timeslicesNew; ++slice)
            {
                CmxCpSubBlock *const block = new CmxCpSubBlock();
                block->setCmxHeader(m_version, m_dataFormat, slice, hwCrate,
                                    summing, CmxSubBlock::CMX_CP, cmx, timeslicesNew);
                cmxBlocks.push_back(block);
                if (neutralFormat) break;
            }
 
            // CMX-CP Tobs
 
            for (int cpm = 1; cpm <= m_modules; ++cpm)
            {
                for (int chip = 0; chip < m_chips; ++chip)
                {
                    for (int loc = 0; loc < m_locs; ++loc)
                    {
                        const int key = tobKey(crate, cmx, cpm, chip, loc);
                        const LVL1::CMXCPTob *const ct = findCmxCpTob(key,
                                                                      tobMap);
                        if ( ct )
                        {
                            std::vector<int> energy;
                            std::vector<int> isolation;
                            std::vector<int> error;
                            std::vector<unsigned int> presence;
                            ModifySlices::data(ct->energyVec(),      energy,    timeslicesNew);
                            ModifySlices::data(ct->isolationVec(),   isolation, timeslicesNew);
                            ModifySlices::data(ct->errorVec(),       error,     timeslicesNew);
                            ModifySlices::data(ct->presenceMapVec(), presence,  timeslicesNew);
                            for (int slice = 0; slice < timeslicesNew; ++slice)
                            {
                                const LVL1::DataError errBits(error[slice]);
                                int err = errBits.get(LVL1::DataError::ParityMerge);
                                err |= (errBits.get(LVL1::DataError::ParityPhase0)) << 1;
                                err |= (errBits.get(LVL1::DataError::ParityPhase1)) << 2;
                                err |= (errBits.get(LVL1::DataError::ParityPhase2)) << 3;
                                err |= (errBits.get(LVL1::DataError::ParityPhase3)) << 4;
                                err |= (errBits.get(LVL1::DataError::Overflow)) << 5;
                                const int index = ( neutralFormat ) ? 0 : slice;
                                CmxCpSubBlock *const subBlock = cmxBlocks[index];
                                subBlock->setTob(slice, cpm, chip, loc, energy[slice],
                                                 isolation[slice], err);
                                subBlock->setPresenceMap(slice, cpm, presence[slice]);
                            }
                        }
                    }
                }
            }
 
            // CMX-CP Hits
 
            for (int source = 0; source < LVL1::CMXCPHits::MAXSOURCE; ++source)
            {
                const int key = hitsKey(crate, cmx, source);
                const LVL1::CMXCPHits *const ch = findCmxCpHits(key, hitsMap);
                if ( ch )
                {
                    std::vector<unsigned int> hits0;
                    std::vector<unsigned int> hits1;
                    std::vector<int> err0;
                    std::vector<int> err1;
                    ModifySlices::data(ch->hitsVec0(),  hits0, timeslicesNew);
                    ModifySlices::data(ch->hitsVec1(),  hits1, timeslicesNew);
                    ModifySlices::data(ch->errorVec0(), err0,  timeslicesNew);
                    ModifySlices::data(ch->errorVec1(), err1,  timeslicesNew);
                    for (int slice = 0; slice < timeslicesNew; ++slice)
                    {
                        const LVL1::DataError err0Bits(err0[slice]);
                        const LVL1::DataError err1Bits(err1[slice]);
                        const int index = ( neutralFormat ) ? 0 : slice;
                        CmxCpSubBlock *const subBlock = cmxBlocks[index];
                        subBlock->setHits(slice, source, 0, hits0[slice],                // Assuming CMXCPHits::source == CmxCpSubBlock::source
                                          err0Bits.get(LVL1::DataError::Parity));
                        subBlock->setHits(slice, source, 1, hits1[slice],
                                          err1Bits.get(LVL1::DataError::Parity));
                        if (neutralFormat)   // Neutral format wants RoI overflow bit
                        {
                            subBlock->setRoiOverflow(slice, source,
                                                     err0Bits.get(LVL1::DataError::Overflow));
                        }
                    }
                }
            }
            for (CmxCpSubBlock* subBlock : cmxBlocks)
            {
                if ( !subBlock->pack())
                {
                    msg(MSG::ERROR) << "CMX-Cp sub-block packing failed" << endmsg;
                    return StatusCode::FAILURE;
                }
                if (debug)
                {
                    msg() << "CMX-Cp sub-block data words: "
                          << subBlock->dataWords() << endmsg;
                }
                subBlock->write(theROD);
            }
        }
    }
 
    return StatusCode::SUCCESS;
}

convert() [2/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert	(	const std::string &	sgKey,
		const IROBDataProviderSvc::VROBFRAG &	robFrags,
		DataVector< LVL1::CMXCPHits > *	hitCollection
	)		const

Definition at line 177 of file CpByteStreamV2Tool.cxx.

{
    CmxCpHitsData data (hitCollection);
    return convertBs(sgKey, robFrags, data);
}

convert() [3/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert	(	const std::string &	sgKey,
		const IROBDataProviderSvc::VROBFRAG &	robFrags,
		DataVector< LVL1::CMXCPTob > *	tobCollection
	)		const

Definition at line 155 of file CpByteStreamV2Tool.cxx.

{
    CmxCpTobData data (tobCollection);
    return convertBs(sgKey, robFrags, data);
}

convert() [4/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert	(	const std::string &	sgKey,
		const IROBDataProviderSvc::VROBFRAG &	robFrags,
		DataVector< LVL1::CPMTower > *	ttCollection
	)		const

Definition at line 133 of file CpByteStreamV2Tool.cxx.

{
    CpmTowerData data (ttCollection);
    return convertBs(sgKey, robFrags, data);
}

convert() [5/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert	(	const std::string &	sgKey,
		DataVector< LVL1::CMXCPHits > *	hitCollection
	)		const

Convert ROB fragments to CMX-CP hits.

Definition at line 165 of file CpByteStreamV2Tool.cxx.

{
  const std::vector<uint32_t>& vID(sourceIDs());
  // // get ROB fragments
  IROBDataProviderSvc::VROBFRAG robFrags;
  m_robDataProvider->getROBData(vID, robFrags, "CpByteStreamV2Tool");
  ATH_MSG_DEBUG("Number of ROB fragments:" << robFrags.size());
  return convert(sgKey, robFrags, hitCollection);
}

convert() [6/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert	(	const std::string &	sgKey,
		DataVector< LVL1::CMXCPTob > *	tobCollection
	)		const

Convert ROB fragments to CMX-CP TOBs.

Definition at line 143 of file CpByteStreamV2Tool.cxx.

{
  const std::vector<uint32_t>& vID(sourceIDs());
  // // get ROB fragments
  IROBDataProviderSvc::VROBFRAG robFrags;
  m_robDataProvider->getROBData(vID, robFrags, "CpByteStreamV2Tool");
  ATH_MSG_DEBUG("Number of ROB fragments:" << robFrags.size());
  return convert(sgKey, robFrags, tobCollection);
}

convert() [7/7]

StatusCode LVL1BS::CpByteStreamV2Tool::convert	(	const std::string &	sgKey,
		DataVector< LVL1::CPMTower > *	ttCollection
	)		const

Convert ROB fragments to CPM towers.

Definition at line 121 of file CpByteStreamV2Tool.cxx.

{
  const std::vector<uint32_t>& vID(sourceIDs());
  // // get ROB fragments
  IROBDataProviderSvc::VROBFRAG robFrags;
  m_robDataProvider->getROBData(vID, robFrags, "CpByteStreamV2Tool");
  ATH_MSG_DEBUG("Number of ROB fragments:" << robFrags.size());
  return convert(sgKey, robFrags, ttCollection);
}

convertBs()

StatusCode LVL1BS::CpByteStreamV2Tool::convertBs ( const std::string &  sgKey, const IROBDataProviderSvc::VROBFRAG &  robFrags, CpByteStreamToolData &  data  ) const

private

Convert bytestream to given container type.

Definition at line 526 of file CpByteStreamV2Tool.cxx.

{
    LocalData ld;
 
    ld.coreOverlap =
      CxxUtils::ends_with (sgKey, "Overlap") || CxxUtils::ends_with (sgKey, "OverlapAux.");
 
    const bool debug = msgLvl(MSG::DEBUG);
    if (debug) msg(MSG::DEBUG);
 
    CmxCpSubBlock cmxCpSubBlock;
    CpmSubBlockV2 cpmSubBlock;
 
   // Loop over ROB fragments
 
    int robCount = 0;
    std::set<uint32_t> dupCheck;
    ROBIterator rob    = robFrags.begin();
    ROBIterator robEnd = robFrags.end();
    for (; rob != robEnd; ++rob)
    {
        ++robCount;
        ATH_MSG_DEBUG("Treating ROB fragment " << robCount << " source_id = " << std::hex << (*rob)->rob_source_id() << std::dec);
 
        // Skip fragments with ROB status errors
 
        const uint32_t robid = (*rob)->source_id();
        if ((*rob)->nstatus() > 0)
        {
            ROBPointer robData;
            (*rob)->status(robData);
            if (*robData != 0)
            {
                m_errorTool->robError(robid, *robData);
                if (debug) msg() << "ROB status error - skipping fragment" << endmsg;
                continue;
            }
        }
 
        // Skip duplicate fragments
 
        if (!dupCheck.insert(robid).second)
        {
            m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_DUPLICATE_ROB);
            if (debug) msg() << "Skipping duplicate ROB fragment" << endmsg;
            continue;
        }
 
        // Unpack ROD data (slinks)
 
        RODPointer payloadBeg;
        RODPointer payload;
        RODPointer payloadEnd;
        (*rob)->rod_data(payloadBeg);
        payloadEnd = payloadBeg + (*rob)->rod_ndata();
        payload = payloadBeg;
        if (payload == payloadEnd)
        {
            if (debug) msg() << "ROB fragment empty" << endmsg;
            continue;
        }
 
        // Check identifier
        const uint32_t sourceID = (*rob)->rod_source_id();
        if (m_srcIdMap.getRobID(sourceID) != robid           ||
                m_srcIdMap.subDet(sourceID)   != m_subDetector   ||
                m_srcIdMap.daqOrRoi(sourceID) != 0               ||
                (m_srcIdMap.slink(sourceID) != 0 && m_srcIdMap.slink(sourceID) != 2) ||
                m_srcIdMap.crate(sourceID)    <  m_crateOffsetHw ||
                m_srcIdMap.crate(sourceID)    >= m_crateOffsetHw + m_crates)
        {
            m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_ROD_ID);
            if (debug)
            {
                msg() << "Wrong source identifier in data: ROD "
                      << MSG::hex << sourceID << "  ROB " << robid
                      << MSG::dec << endmsg;
            }
            continue;
        }
 
        // Check minor version
        const int minorVersion = (*rob)->rod_version() & 0xffff;
 
        if (minorVersion <= m_srcIdMap.minorVersionPreLS1())
        {
            if (debug) msg() << "Skipping pre-LS1 data" << endmsg;
            continue;
        }
        const int rodCrate = m_srcIdMap.crate(sourceID);
        if (debug)
        {
            msg() << "Treating crate " << rodCrate
                  << " slink " << m_srcIdMap.slink(sourceID) << endmsg;
        }
 
        // First word should be User Header
        if ( !L1CaloUserHeader::isValid(*payload) )
        {
            m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_USER_HEADER);
            if (debug) msg() << "Invalid or missing user header" << endmsg;
            continue;
        }
        L1CaloUserHeader userHeader(*payload);
        userHeader.setVersion(minorVersion);
        const int headerWords = userHeader.words();
        if (headerWords != 1)
        {
            m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_USER_HEADER);
            if (debug) msg() << "Unexpected number of user header words: "
                                 << headerWords << endmsg;
            continue;
        }
        for (int i = 0; i < headerWords; ++i) ++payload;
        // triggered slice offset
        const int trigCpm = userHeader.cpm();
        if (debug)
        {
            msg() << "Minor format version number: " << MSG::hex
                  << minorVersion << MSG::dec << endmsg
                  << "Triggered slice offset: "  << trigCpm << endmsg;
        }
 
        // Loop over sub-blocks
 
        ld.rodErr = L1CaloSubBlock::ERROR_NONE;
        while (payload != payloadEnd)
        {
            if (L1CaloSubBlock::wordType(*payload) != L1CaloSubBlock::HEADER)
            {
                if (debug) msg() << "Unexpected data sequence" << endmsg;
                ld.rodErr = L1CaloSubBlock::ERROR_MISSING_HEADER;
                break;
            }
 
            // TODO: (sasha) Comment this check since firmware does not ready
            // Select right tool by ROD version
            // if (L1CaloSubBlock::version(*payload) == 1) {
            //   if (debug) msg() << "Skipping pre-LS1 data" << endmsg;
            //   break;
            // }
 
            if (CmxSubBlock::cmxBlock(*payload))
            {
                // CMX
                if (CmxSubBlock::cmxType(*payload) == CmxSubBlock::CMX_CP)
                {
                    cmxCpSubBlock.clear();
                    payload = cmxCpSubBlock.read(payload, payloadEnd);
                    if (cmxCpSubBlock.crate() != rodCrate)
                    {
                        if (debug) msg() << "Inconsistent crate number in ROD source ID"
                                             << endmsg;
                        ld.rodErr = L1CaloSubBlock::ERROR_CRATE_NUMBER;
                        break;
                    }
 
                    if (data.m_collection == CMX_CP_TOBS || data.m_collection == CMX_CP_HITS)
                    {
                        decodeCmxCp(&cmxCpSubBlock, trigCpm, data, ld);
                        if (ld.rodErr != L1CaloSubBlock::ERROR_NONE)
                        {
                            if (debug) msg() << "decodeCmxCp failed" << endmsg;
                            break;
                        }
                    }
                }
                else
                {
                    if (debug) msg() << "Invalid CMX type in module field" << endmsg;
                    ld.rodErr = L1CaloSubBlock::ERROR_MODULE_NUMBER;
                    break;
                }
            }
            else
            {
                // CPM
                cpmSubBlock.clear();
                payload = cpmSubBlock.read(payload, payloadEnd);
                if (cpmSubBlock.crate() != rodCrate)
                {
                    if (debug) msg() << "Inconsistent crate number in ROD source ID"
                                         << endmsg;
                    ld.rodErr = L1CaloSubBlock::ERROR_CRATE_NUMBER;
                    break;
                }
                if (data.m_collection == CPM_TOWERS)
                {
                    decodeCpm(&cpmSubBlock, trigCpm, static_cast<CpmTowerData&>(data), ld);
                    if (ld.rodErr != L1CaloSubBlock::ERROR_NONE)
                    {
                        if (debug) msg() << "decodeCpm failed" << endmsg;
                        break;
                    }
                }
            }
        }
        if (ld.rodErr != L1CaloSubBlock::ERROR_NONE)
        {
            m_errorTool->rodError(robid, ld.rodErr);
        }
    }
    return StatusCode::SUCCESS;
}

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

decodeCmxCp()

void LVL1BS::CpByteStreamV2Tool::decodeCmxCp ( CmxCpSubBlock *  subBlock, int  trigCpm, CpByteStreamToolData &  data, LocalData &  ld  ) const

private

Unpack CMX-CP sub-block.

Definition at line 736 of file CpByteStreamV2Tool.cxx.

{
    const bool debug = msgLvl(MSG::DEBUG);
    if (debug) msg(MSG::DEBUG);
 
    const int hwCrate    = subBlock->crate();
    const int cmx        = subBlock->cmxPosition();
    const int firmware   = subBlock->cmxFirmware();
    const int summing    = subBlock->cmxSumming();
    const int timeslices = subBlock->timeslices();
    const int sliceNum   = subBlock->slice();
    if (debug)
    {
        msg() << "CMX-CP: Crate "  << hwCrate
              << "  Position "     << cmx
              << "  Firmware "     << firmware
              << "  Summing "      << summing
              << "  Total slices " << timeslices
              << "  Slice "        << sliceNum
              << endmsg;
    }
    if (timeslices <= trigCpm)
    {
        if (debug) msg() << "Triggered slice from header "
                             << "inconsistent with number of slices: "
                             << trigCpm << ", " << timeslices << endmsg;
        ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
        return;
    }
    if (timeslices <= sliceNum)
    {
        if (debug) msg() << "Total slices inconsistent with slice number: "
                             << timeslices << ", " << sliceNum << endmsg;
        ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
        return;
    }
    // Unpack sub-block
    if (subBlock->dataWords() && !subBlock->unpack())
    {
        if (debug)
        {
            std::string errMsg(subBlock->unpackErrorMsg());
            msg() << "CMX-CP sub-block unpacking failed: " << errMsg << endmsg;
        }
        ld.rodErr = subBlock->unpackErrorCode();
        return;
    }
 
    // Retrieve required data
 
    const bool neutralFormat = subBlock->format() == L1CaloSubBlock::NEUTRAL;
    LVL1::DataError dErr;
    dErr.set(LVL1::DataError::SubStatusWord, subBlock->subStatus());
    const int subStatus = dErr.error();
    const int crate    = hwCrate - m_crateOffsetHw;
    const int swCrate  = crate   + m_crateOffsetSw;
    const int maxSid   = CmxCpSubBlock::MAX_SOURCE_ID;
    const int sliceBeg = ( neutralFormat ) ? 0          : sliceNum;
    const int sliceEnd = ( neutralFormat ) ? timeslices : sliceNum + 1;
    for (int slice = sliceBeg; slice < sliceEnd; ++slice)
    {
 
        if (data.m_collection == CMX_CP_TOBS)
        {
            CmxCpTobData& tdata = static_cast<CmxCpTobData&> (data);
 
            // TOBs
 
            for (int cpm = 1; cpm <= m_modules; ++cpm)
            {
                const unsigned int presenceMap = subBlock->presenceMap(slice, cpm);
                for (int tob = 0; tob < m_maxTobs; ++tob)
                {
                    const int energy = subBlock->energy(slice, cpm, tob);
                    const int isolation = subBlock->isolation(slice, cpm, tob);
                    int error = subBlock->tobError(slice, cpm, tob);
                    if (energy == 0 && isolation == 0 && error == 0) break;
                    const int loc = subBlock->localCoord(slice, cpm, tob);
                    const int chip = subBlock->chip(slice, cpm, tob);
                    LVL1::DataError errBits(subStatus);
                    if (error)
                    {
                        errBits.set(LVL1::DataError::ParityPhase0, error);
                        errBits.set(LVL1::DataError::ParityPhase1, (error >> 1));
                        errBits.set(LVL1::DataError::ParityPhase2, (error >> 2));
                        errBits.set(LVL1::DataError::ParityPhase3, (error >> 3));
                        errBits.set(LVL1::DataError::Overflow,     (error >> 4));
                        errBits.set(LVL1::DataError::ParityMerge, (error >> 5));
                        errBits.set(LVL1::DataError::Parity, (error & 0x2f) ? 1 : 0);
                    }
                    error = errBits.error();
                    const int key = tobKey(crate, cmx, cpm, chip, loc);
                    LVL1::CMXCPTob *tb = findCmxCpTob(tdata, key);
                    if ( ! tb )   // create new CMX TOB
                    {
                        ld.energyVec.assign(timeslices, 0);
                        ld.isolVec.assign(timeslices, 0);
                        ld.errorVec.assign(timeslices, 0);
                        ld.presenceMapVec.assign(timeslices, 0);
                        ld.energyVec[slice] = energy;
                        ld.isolVec[slice]   = isolation;
                        ld.errorVec[slice]  = error;
                        ld.presenceMapVec[slice] = presenceMap;
                        auto tbp =
                          std::make_unique<LVL1::CMXCPTob>(swCrate, cmx, cpm, chip, loc,
                                                           ld.energyVec, ld.isolVec, ld.errorVec,
                                                           ld.presenceMapVec, trigCpm);
                        tdata.m_tobMap.insert(std::make_pair(key, tbp.get()));
                        tdata.m_tobCollection->push_back(std::move(tbp));
                    }
                    else
                    {
                        ld.energyVec = tb->energyVec();
                        ld.isolVec   = tb->isolationVec();
                        ld.errorVec  = tb->errorVec();
                        ld.presenceMapVec = tb->presenceMapVec();
                        const int nsl = ld.energyVec.size();
                        if (timeslices != nsl)
                        {
                            if (debug) msg() << "Inconsistent number of slices in sub-blocks"
                                                 << endmsg;
                            ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
                            return;
                        }
                        if (ld.energyVec[slice] != 0 || ld.isolVec[slice] != 0 ||
                                ld.errorVec[slice]  != 0)
                        {
                            if (debug) msg() << "Duplicate data for slice " << slice << endmsg;
                            ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
                            return;
                        }
                        ld.energyVec[slice] = energy;
                        ld.isolVec[slice]   = isolation;
                        ld.errorVec[slice]  = error;
                        ld.presenceMapVec[slice] = presenceMap;
                        tb->addTob(ld.energyVec, ld.isolVec, ld.errorVec, ld.presenceMapVec);
                    }
                }
            }
 
        }
        else if (data.m_collection == CMX_CP_HITS)
        {
            CmxCpHitsData& hdata = static_cast<CmxCpHitsData&> (data);
 
            // Hit/Topo counts
 
            for (int source = 0; source < maxSid; ++source)
            {
                if (summing == CmxSubBlock::CRATE &&
                        (source == CmxCpSubBlock::REMOTE_0 ||
                         source == CmxCpSubBlock::REMOTE_1 ||
                         source == CmxCpSubBlock::REMOTE_2 ||
                         source == CmxCpSubBlock::TOTAL)) continue;
                const unsigned int hits0 = subBlock->hits(slice, source, 0); //low
                const unsigned int hits1 = subBlock->hits(slice, source, 1); //high
                int err0 = subBlock->hitsError(slice, source, 0);
                int err1 = subBlock->hitsError(slice, source, 1);
                int overflow = subBlock->roiOverflow(slice, source);
                LVL1::DataError err0Bits(subStatus);
                err0Bits.set(LVL1::DataError::Parity, err0);
                err0Bits.set(LVL1::DataError::Overflow, overflow);
                err0 = err0Bits.error();
                LVL1::DataError err1Bits(subStatus);
                err1Bits.set(LVL1::DataError::Parity, err1);
                err1Bits.set(LVL1::DataError::Overflow, overflow);
                err1 = err1Bits.error();
                if (hits0 || hits1 || err0 || err1)
                {
                    const int key = hitsKey(crate, cmx, source);
                    LVL1::CMXCPHits *ch = findCmxCpHits(hdata, key);
                    if ( ! ch )     // create new CMX hits
                    {
                        ld.hitsVec0.assign(timeslices, 0);
                        ld.hitsVec1.assign(timeslices, 0);
                        ld.errVec0.assign(timeslices, 0);
                        ld.errVec1.assign(timeslices, 0);
                        ld.hitsVec0[slice] = hits0;
                        ld.hitsVec1[slice] = hits1;
                        ld.errVec0[slice]  = err0;
                        ld.errVec1[slice]  = err1;
                        auto chp =
                          std::make_unique<LVL1::CMXCPHits>(swCrate, cmx, source,
                                                            ld.hitsVec0, ld.hitsVec1,
                                                            ld.errVec0, ld.errVec1, trigCpm);
                        hdata.m_hitsMap.insert(std::make_pair(key, chp.get()));
                        hdata.m_hitCollection->push_back(std::move(chp));
                    }
                    else
                    {
                        ld.hitsVec0 = ch->hitsVec0();
                        ld.hitsVec1 = ch->hitsVec1();
                        ld.errVec0  = ch->errorVec0();
                        ld.errVec1  = ch->errorVec1();
                        const int nsl = ld.hitsVec0.size();
                        if (timeslices != nsl)
                        {
                            if (debug) msg() << "Inconsistent number of slices in sub-blocks"
                                                 << endmsg;
                            ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
                            return;
                        }
                        if (ld.hitsVec0[slice] != 0 || ld.hitsVec1[slice] != 0 ||
                                ld.errVec0[slice]  != 0 || ld.errVec1[slice]  != 0)
                        {
                            if (debug) msg() << "Duplicate data for slice " << slice << endmsg;
                            ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
                            return;
                        }
                        ld.hitsVec0[slice] = hits0;
                        ld.hitsVec1[slice] = hits1;
                        ld.errVec0[slice]  = err0;
                        ld.errVec1[slice]  = err1;
                        ch->addHits(ld.hitsVec0, ld.hitsVec1, ld.errVec0, ld.errVec1);
                    }
                }
            }
        }
    }
 
    return;
}

decodeCpm()

void LVL1BS::CpByteStreamV2Tool::decodeCpm ( CpmSubBlockV2 *  subBlock, int  trigCpm, CpmTowerData &  data, LocalData &  ld  ) const

private

Unpack CPM sub-block.

Definition at line 963 of file CpByteStreamV2Tool.cxx.

{
    const bool debug   = msgLvl(MSG::DEBUG);
    const bool verbose = msgLvl(MSG::VERBOSE);
    if (debug) msg(MSG::DEBUG);
 
    const int hwCrate    = subBlock->crate();
    const int module     = subBlock->module();
    const int timeslices = subBlock->timeslices();
    const int sliceNum   = subBlock->slice();
    if (debug)
    {
        msg() << "CPM: Crate "     << hwCrate
              << "  Module "       << module
              << "  Total slices " << timeslices
              << "  Slice "        << sliceNum    << endmsg;
    }
    if (module < 1 || module > m_modules)
    {
        if (debug) msg() << "Unexpected module number: " << module << endmsg;
        ld.rodErr = L1CaloSubBlock::ERROR_MODULE_NUMBER;
        return;
    }
    if (timeslices <= trigCpm)
    {
        if (debug) msg() << "Triggered slice from header "
                             << "inconsistent with number of slices: "
                             << trigCpm << ", " << timeslices << endmsg;
        ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
        return;
    }
    if (timeslices <= sliceNum)
    {
        if (debug) msg() << "Total slices inconsistent with slice number: "
                             << timeslices << ", " << sliceNum << endmsg;
        ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
        return;
    }
    // Unpack sub-block
    if (subBlock->dataWords() && !subBlock->unpack())
    {
        if (debug)
        {
            std::string errMsg(subBlock->unpackErrorMsg());
            msg() << "CPM sub-block unpacking failed: " << errMsg << endmsg;
        }
        ld.rodErr = subBlock->unpackErrorCode();
        return;
    }
 
    // Retrieve required data
    const bool neutralFormat = subBlock->format() == L1CaloSubBlock::NEUTRAL;
    LVL1::DataError dErr;
    dErr.set(LVL1::DataError::SubStatusWord, subBlock->subStatus());
    const int subStatus = dErr.error();
    const int crate     = hwCrate - m_crateOffsetHw;
    const int sliceBeg  = ( neutralFormat ) ? 0          : sliceNum;
    const int sliceEnd  = ( neutralFormat ) ? timeslices : sliceNum + 1;
    for (int slice = sliceBeg; slice < sliceEnd; ++slice)
    {
 
        // Loop over tower channels and fill CPM towers
 
        for (int chan = 0; chan < m_channels; ++chan)
        {
            if (!subStatus && !subBlock->anyTowerData(chan)) continue;
            const int em     = subBlock->emData(slice, chan);
            const int had    = subBlock->hadData(slice, chan);
            const int emErr  = subBlock->emError(slice, chan);
            const int hadErr = subBlock->hadError(slice, chan);
            int emErr1 = subStatus;
            if (emErr)
            {
                LVL1::DataError emErrBits(emErr1);
                emErrBits.set(LVL1::DataError::Parity, emErr & 0x1);
                emErrBits.set(LVL1::DataError::LinkDown, (emErr >> 1) & 0x1);
                emErr1 = emErrBits.error();
            }
            int hadErr1 = subStatus;
            if (hadErr)
            {
                LVL1::DataError hadErrBits(hadErr1);
                hadErrBits.set(LVL1::DataError::Parity, hadErr & 0x1);
                hadErrBits.set(LVL1::DataError::LinkDown, (hadErr >> 1) & 0x1);
                hadErr1 = hadErrBits.error();
            }
            if (em || had || emErr1 || hadErr1)
            {
                double eta = 0.;
                double phi = 0.;
                int layer = 0;
                if (m_cpmMaps->mapping(crate, module, chan, eta, phi, layer))
                {
                    if (layer == ld.coreOverlap)
                    {
                        const unsigned int key = ld.towerKey.ttKey(phi, eta);
                        LVL1::CPMTower *tt = findCpmTower(data, key);
                        if ( ! tt )     // create new CPM tower
                        {
                            ld.emVec.assign(timeslices, 0);
                            ld.hadVec.assign(timeslices, 0);
                            ld.emErrVec.assign(timeslices, 0);
                            ld.hadErrVec.assign(timeslices, 0);
                            ld.emVec[slice]     = em;
                            ld.hadVec[slice]    = had;
                            ld.emErrVec[slice]  = emErr1;
                            ld.hadErrVec[slice] = hadErr1;
                            auto ttp =
                              std::make_unique<LVL1::CPMTower>(phi, eta, ld.emVec, ld.emErrVec,
                                                               ld.hadVec, ld.hadErrVec, trigCpm);
                            data.m_ttMap.insert(std::make_pair(key, ttp.get()));
                            data.m_ttCollection->push_back(std::move(ttp));
                        }
                        else
                        {
                            ld.emVec     = tt->emEnergyVec();
                            ld.hadVec    = tt->hadEnergyVec();
                            ld.emErrVec  = tt->emErrorVec();
                            ld.hadErrVec = tt->hadErrorVec();
                            const int nsl = ld.emVec.size();
                            if (timeslices != nsl)
                            {
                                if (debug)
                                {
                                    msg() << "Inconsistent number of slices in sub-blocks"
                                          << endmsg;
                                }
                                ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
                                return;
                            }
                            if (ld.emVec[slice]    != 0 || ld.hadVec[slice]    != 0 ||
                                    ld.emErrVec[slice] != 0 || ld.hadErrVec[slice] != 0)
                            {
                                if (debug) msg() << "Duplicate data for slice "
                                                     << slice << endmsg;
                                ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
                                return;
                            }
                            ld.emVec[slice]     = em;
                            ld.hadVec[slice]    = had;
                            ld.emErrVec[slice]  = emErr1;
                            ld.hadErrVec[slice] = hadErr1;
                            tt->fill(ld.emVec, ld.emErrVec, ld.hadVec, ld.hadErrVec, trigCpm);
                        }
                    }
                }
                else if (verbose && (em || had || emErr || hadErr))
                {
                    msg(MSG::VERBOSE) << "Non-zero data but no channel mapping for channel "
                                      << chan << endmsg;
                    msg(MSG::DEBUG);
                }
            }
            else if (verbose)
            {
                msg(MSG::VERBOSE) << "No CPM tower data for channel "
                                  << chan << " slice " << slice << endmsg;
                msg(MSG::DEBUG);
            }
        }
    }
    return;
}

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() [1/2]

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; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 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

findCmxCpHits() [1/2]

LVL1::CMXCPHits * LVL1BS::CpByteStreamV2Tool::findCmxCpHits ( const CmxCpHitsData &  data, int  key  ) const

private

Definition at line 1178 of file CpByteStreamV2Tool.cxx.

{
    CmxCpHitsMap::const_iterator mapIter = data.m_hitsMap.find(key);
    if (mapIter != data.m_hitsMap.end()) return mapIter->second;
    return nullptr;
}

findCmxCpHits() [2/2]

const LVL1::CMXCPHits * LVL1BS::CpByteStreamV2Tool::findCmxCpHits ( int  key, const ConstCmxCpHitsMap &  hitsMap  ) const

private

Find CMX-CP hits for given key.

Definition at line 1170 of file CpByteStreamV2Tool.cxx.

{
    ConstCmxCpHitsMap::const_iterator mapIter = hitsMap.find(key);
    if (mapIter != hitsMap.end()) return mapIter->second;
    return nullptr;
}

findCmxCpTob() [1/2]

LVL1::CMXCPTob * LVL1BS::CpByteStreamV2Tool::findCmxCpTob ( const CmxCpTobData &  data, int  key  ) const

private

Definition at line 1159 of file CpByteStreamV2Tool.cxx.

{
    CmxCpTobMap::const_iterator mapIter = data.m_tobMap.find(key);
    if (mapIter != data.m_tobMap.end()) return mapIter->second;
    return nullptr;
}

findCmxCpTob() [2/2]

const LVL1::CMXCPTob * LVL1BS::CpByteStreamV2Tool::findCmxCpTob ( int  key, const ConstCmxCpTobMap &  tobMap  ) const

private

Find CMX-CP TOB for given key.

Definition at line 1151 of file CpByteStreamV2Tool.cxx.

{
    ConstCmxCpTobMap::const_iterator mapIter = tobMap.find(key);
    if (mapIter != tobMap.end()) return mapIter->second;
    return nullptr;
}

findCpmTower() [1/2]

LVL1::CPMTower * LVL1BS::CpByteStreamV2Tool::findCpmTower ( const CpmTowerData &  data, unsigned int  key  ) const

private

Definition at line 1140 of file CpByteStreamV2Tool.cxx.

{
    CpmTowerMap::const_iterator mapIter = data.m_ttMap.find(key);
    if (mapIter != data.m_ttMap.end()) return mapIter->second;
    return nullptr;
}

findCpmTower() [2/2]

const LVL1::CPMTower * LVL1BS::CpByteStreamV2Tool::findCpmTower ( unsigned int  key, const ConstCpmTowerMap &  ttMap  ) const

private

Find a CPM tower for given key.

Definition at line 1132 of file CpByteStreamV2Tool.cxx.

{
    ConstCpmTowerMap::const_iterator mapIter = ttMap.find(key);
    if (mapIter != ttMap.end()) return mapIter->second;
    return nullptr;
}

hitsKey()

int LVL1BS::CpByteStreamV2Tool::hitsKey ( int  crate, int  cmx, int  source  ) const

private

Key for Hits.

Definition at line 1265 of file CpByteStreamV2Tool.cxx.

{
    return (((crate << 1) | cmx) << 3) | source;
}

initialize()

StatusCode LVL1BS::CpByteStreamV2Tool::initialize ( )

overridevirtual

Definition at line 105 of file CpByteStreamV2Tool.cxx.

{
    ATH_MSG_INFO( "Initializing " << name() );
 
    CHECK(m_cpmMaps.retrieve());
    CHECK(m_errorTool.retrieve());
    CHECK(m_robDataProvider.retrieve());
    if (m_enableEncoding.value()) {
        m_byteStreamCnvSvc = serviceLocator()->service("ByteStreamCnvSvc");
        ATH_CHECK(m_byteStreamCnvSvc.isValid());
    }
    
    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.

interfaceID()

const InterfaceID & LVL1BS::CpByteStreamV2Tool::interfaceID ( )

static

AlgTool InterfaceID.

Definition at line 44 of file CpByteStreamV2Tool.cxx.

{
    return IID_ICpByteStreamV2Tool;
}

makeSourceIDs()

std::vector< uint32_t > LVL1BS::CpByteStreamV2Tool::makeSourceIDs ( ) const

private

Create list of all source IDs.

Definition at line 493 of file CpByteStreamV2Tool.cxx.

{
  std::vector<uint32_t> sourceIDs;
 
  if (!m_sourceIDsProp.empty()) {
    sourceIDs = m_sourceIDsProp;
  }
  else {
    const int maxCrates = m_crates + m_crateOffsetHw;
    const int maxSlinks = m_srcIdMap.maxSlinks();
    for (int hwCrate = m_crateOffsetHw; hwCrate < maxCrates; ++hwCrate)
    {
      for (int slink = 0; slink < maxSlinks; ++slink)
      {
        const int daqOrRoi = 0;
        const uint32_t rodId = m_srcIdMap.getRodID(hwCrate, slink, daqOrRoi,
                                                   m_subDetector);
        const uint32_t robId = m_srcIdMap.getRobID(rodId);
        sourceIDs.push_back(robId);
      }
    }
  }
  return sourceIDs;
}

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< AlgTool >::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< 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();
  }

setupCmxCpHitsMap()

void LVL1BS::CpByteStreamV2Tool::setupCmxCpHitsMap ( const CmxCpHitsCollection *  hitCollection, ConstCmxCpHitsMap &  hitsMap  ) const

private

Set up CMX-CP hits map.

Definition at line 1234 of file CpByteStreamV2Tool.cxx.

{
    hitsMap.clear();
    if (hitCollection)
    {
        CmxCpHitsCollection::const_iterator pos  = hitCollection->begin();
        CmxCpHitsCollection::const_iterator pose = hitCollection->end();
        for (; pos != pose; ++pos)
        {
            const LVL1::CMXCPHits *const hits = *pos;
            const int crate = hits->crate() - m_crateOffsetSw;
            const int cmx = hits->cmx();
            const int source = hits->source();
            const int key = hitsKey(crate, cmx, source);
            hitsMap.insert(std::make_pair(key, hits));
        }
    }
}

setupCmxCpTobMap()

void LVL1BS::CpByteStreamV2Tool::setupCmxCpTobMap ( const CmxCpTobCollection *  tobCollection, ConstCmxCpTobMap &  tobMap  ) const

private

Set up CMX-CP TOB map.

Definition at line 1209 of file CpByteStreamV2Tool.cxx.

{
    tobMap.clear();
    if (tobCollection)
    {
        CmxCpTobCollection::const_iterator pos  = tobCollection->begin();
        CmxCpTobCollection::const_iterator pose = tobCollection->end();
        for (; pos != pose; ++pos)
        {
            const LVL1::CMXCPTob *const tob = *pos;
            const int crate = tob->crate() - m_crateOffsetSw;
            const int cmx = tob->cmx();
            const int cpm = tob->cpm();
            const int chip = tob->chip();
            const int loc = tob->location();
            const int key = tobKey(crate, cmx, cpm, chip, loc);
            tobMap.insert(std::make_pair(key, tob));
        }
    }
}

setupCpmTowerMap()

void LVL1BS::CpByteStreamV2Tool::setupCpmTowerMap ( const CpmTowerCollection *  ttCollection, ConstCpmTowerMap &  ttMap, LVL1::TriggerTowerKey &  towerKey  ) const

private

Set up CPM tower map.

Definition at line 1188 of file CpByteStreamV2Tool.cxx.

{
    ttMap.clear();
    if (ttCollection)
    {
        CpmTowerCollection::const_iterator pos  = ttCollection->begin();
        CpmTowerCollection::const_iterator pose = ttCollection->end();
        for (; pos != pose; ++pos)
        {
            const LVL1::CPMTower *const tt = *pos;
            const unsigned int key = towerKey.ttKey(tt->phi(), tt->eta());
            ttMap.insert(std::make_pair(key, tt));
        }
    }
}

slinkSlices()

bool LVL1BS::CpByteStreamV2Tool::slinkSlices ( int  crate, int  module, int  modulesPerSlink, int &  timeslices, int &  trigJem, const ConstCpmTowerMap &  ttMap, const ConstCmxCpTobMap &  tobMap, const ConstCmxCpHitsMap &  hitsMap, LVL1::TriggerTowerKey &  towerKey  ) const

private

Get number of slices and triggered slice offset for next slink.

Definition at line 1273 of file CpByteStreamV2Tool.cxx.

{
    int slices = -1;
    int trigC  = m_dfltSlices / 2;
    for (int mod = module; mod < module + modulesPerSlink; ++mod)
    {
        for (int chan = 0; chan < m_channels; ++chan)
        {
            double eta = 0.;
            double phi = 0.;
            int layer = 0;
            if ( !m_cpmMaps->mapping(crate, mod, chan, eta, phi, layer)) continue;
            const unsigned int key = towerKey.ttKey(phi, eta);
            const LVL1::CPMTower *const tt = findCpmTower(key, ttMap);
            if ( !tt ) continue;
            const int numdat = 4;
            std::vector<int> sums(numdat);
            std::vector<int> sizes(numdat);
            sums[0] = std::accumulate((tt->emEnergyVec()).begin(),
                                      (tt->emEnergyVec()).end(), 0);
            sums[1] = std::accumulate((tt->hadEnergyVec()).begin(),
                                      (tt->hadEnergyVec()).end(), 0);
            sums[2] = std::accumulate((tt->emErrorVec()).begin(),
                                      (tt->emErrorVec()).end(), 0);
            sums[3] = std::accumulate((tt->hadErrorVec()).begin(),
                                      (tt->hadErrorVec()).end(), 0);
            sizes[0] = (tt->emEnergyVec()).size();
            sizes[1] = (tt->hadEnergyVec()).size();
            sizes[2] = (tt->emErrorVec()).size();
            sizes[3] = (tt->hadErrorVec()).size();
            const int peak = tt->peak();
            for (int i = 0; i < numdat; ++i)
            {
                if (sums[i] == 0) continue;
                if (slices < 0)
                {
                    slices = sizes[i];
                    trigC  = peak;
                }
                else if (slices != sizes[i] || trigC != peak) return false;
            }
        }
    }
    // CMXs last slink of crate
    if (module / modulesPerSlink == m_slinks - 1)
    {
        for (int cmx = 0; cmx < m_cmxs; ++cmx)
        {
            for (int cpm = 1; cpm <= m_modules; ++ cpm)
            {
                for (int chip = 0; chip < m_chips; ++chip)
                {
                    for (int loc = 0; loc < m_locs; ++loc)
                    {
                        const int key = tobKey(crate, cmx, cpm, chip, loc);
                        const LVL1::CMXCPTob *const tob = findCmxCpTob(key,
                                                                       tobMap);
                        if (tob)
                        {
                            const int numdat = 3;
                            std::vector<int> sums(numdat);
                            std::vector<int> sizes(numdat);
                            sums[0] = std::accumulate((tob->energyVec()).begin(),
                                                      (tob->energyVec()).end(), 0);
                            sums[1] = std::accumulate((tob->isolationVec()).begin(),
                                                      (tob->isolationVec()).end(), 0);
                            sums[2] = std::accumulate((tob->errorVec()).begin(),
                                                      (tob->errorVec()).end(), 0);
                            sizes[0] = (tob->energyVec()).size();
                            sizes[1] = (tob->isolationVec()).size();
                            sizes[2] = (tob->errorVec()).size();
                            const int peak = tob->peak();
                            for (int i = 0; i < numdat; ++i)
                            {
                                if (sums[i] == 0) continue;
                                if (slices < 0)
                                {
                                    slices = sizes[i];
                                    trigC  = peak;
                                }
                                else if (slices != sizes[i] || trigC != peak) return false;
                            }
                        }
                    }
                }
            }
            for (int source = 0; source < LVL1::CMXCPHits::MAXSOURCE; ++source)
            {
                const int key = hitsKey(crate, cmx, source);
 
                const LVL1::CMXCPHits *const hits = findCmxCpHits(key,
                                                                  hitsMap);
                if (hits)
                {
                    const int numdat = 4;
                    std::vector<unsigned int> sums(numdat);
                    std::vector<int> sizes(numdat);
                    sums[0] = std::accumulate((hits->hitsVec0()).begin(),
                                              (hits->hitsVec0()).end(), 0);
                    sums[1] = std::accumulate((hits->hitsVec1()).begin(),
                                              (hits->hitsVec1()).end(), 0);
                    sums[2] = std::accumulate((hits->errorVec0()).begin(),
                                              (hits->errorVec0()).end(), 0);
                    sums[3] = std::accumulate((hits->errorVec1()).begin(),
                                              (hits->errorVec1()).end(), 0);
                    sizes[0] = (hits->hitsVec0()).size();
                    sizes[1] = (hits->hitsVec1()).size();
                    sizes[2] = (hits->errorVec0()).size();
                    sizes[3] = (hits->errorVec1()).size();
                    const int peak = hits->peak();
                    for (int i = 0; i < numdat; ++i)
                    {
                        if (sums[i] == 0) continue;
                        if (slices < 0)
                        {
                            slices = sizes[i];
                            trigC  = peak;
                        }
                        else if (slices != sizes[i] || trigC != peak) return false;
                    }
                }
            }
        }
    }
    if (slices < 0) slices = m_dfltSlices;
    timeslices = slices;
    trigCpm    = trigC;
    return true;
}

sourceIDs()

const std::vector< uint32_t > & LVL1BS::CpByteStreamV2Tool::sourceIDs

(

)

const

Return reference to vector with all possible Source Identifiers.

Definition at line 518 of file CpByteStreamV2Tool.cxx.

{
    static const std::vector<uint32_t> sourceIDs = makeSourceIDs();
    return sourceIDs;
}

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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

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.

tobKey()

int LVL1BS::CpByteStreamV2Tool::tobKey ( int  crate, int  cmx, int  cpm, int  chip, int  loc  ) const

private

Key for TOBs.

Definition at line 1257 of file CpByteStreamV2Tool.cxx.

{
    return (((((((crate << 1) | cmx) << 4) | cpm) << 4) | chip) << 2) | loc;
}

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_byteStreamCnvSvc

SmartIF<ByteStreamCnvSvc> LVL1BS::CpByteStreamV2Tool::m_byteStreamCnvSvc

private

Definition at line 95 of file CpByteStreamV2Tool.h.

m_channels

const int LVL1BS::CpByteStreamV2Tool::m_channels

private

Number of channels per module.

Definition at line 239 of file CpByteStreamV2Tool.h.

m_chips

const int LVL1BS::CpByteStreamV2Tool::m_chips

private

Number of chips.

Definition at line 249 of file CpByteStreamV2Tool.h.

m_cmxs

const int LVL1BS::CpByteStreamV2Tool::m_cmxs

private

Number of CMXs per crate.

Definition at line 245 of file CpByteStreamV2Tool.h.

m_cpmMaps

ToolHandle<LVL1::IL1CaloMappingTool> LVL1BS::CpByteStreamV2Tool::m_cpmMaps

private

Channel mapping tool.

Definition at line 226 of file CpByteStreamV2Tool.h.

m_crateMax

int LVL1BS::CpByteStreamV2Tool::m_crateMax

private

Property: Maximum crate number when writing out bytestream.

Definition at line 261 of file CpByteStreamV2Tool.h.

m_crateMin

int LVL1BS::CpByteStreamV2Tool::m_crateMin

private

Property: Minimum crate number when writing out bytestream.

Definition at line 259 of file CpByteStreamV2Tool.h.

m_crateOffsetHw

int LVL1BS::CpByteStreamV2Tool::m_crateOffsetHw

private

Property: Hardware crate number offset.

Definition at line 231 of file CpByteStreamV2Tool.h.

m_crateOffsetSw

int LVL1BS::CpByteStreamV2Tool::m_crateOffsetSw

private

Property: Software crate number offset.

Definition at line 233 of file CpByteStreamV2Tool.h.

m_crates

int LVL1BS::CpByteStreamV2Tool::m_crates

private

Property: Number of crates.

Definition at line 241 of file CpByteStreamV2Tool.h.

m_dataFormat

int LVL1BS::CpByteStreamV2Tool::m_dataFormat

private

Property: Data compression format.

Definition at line 237 of file CpByteStreamV2Tool.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_dfltSlices

int LVL1BS::CpByteStreamV2Tool::m_dfltSlices

private

Property: Default number of slices in simulation.

Definition at line 255 of file CpByteStreamV2Tool.h.

m_enableEncoding

Gaudi::Property<bool> LVL1BS::CpByteStreamV2Tool::m_enableEncoding

private

Initial value:

{
     this, "enableEncoding", true, "Enable conversion from RDO to ByteStream"}

Definition at line 93 of file CpByteStreamV2Tool.h.

m_errorTool

ToolHandle<LVL1BS::L1CaloErrorByteStreamTool> LVL1BS::CpByteStreamV2Tool::m_errorTool

private

Error collection tool.

Definition at line 228 of file CpByteStreamV2Tool.h.

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_forceSlices

int LVL1BS::CpByteStreamV2Tool::m_forceSlices

private

Property: Force number of slices in bytestream.

Definition at line 257 of file CpByteStreamV2Tool.h.

m_locs

const int LVL1BS::CpByteStreamV2Tool::m_locs

private

Number of Local coordinates.

Definition at line 251 of file CpByteStreamV2Tool.h.

m_maxTobs

const int LVL1BS::CpByteStreamV2Tool::m_maxTobs

private

Maximum number of TOBS per module.

Definition at line 247 of file CpByteStreamV2Tool.h.

m_modules

const int LVL1BS::CpByteStreamV2Tool::m_modules

private

Number of CPM modules per crate.

Definition at line 243 of file CpByteStreamV2Tool.h.

m_robDataProvider

ServiceHandle<IROBDataProviderSvc> LVL1BS::CpByteStreamV2Tool::m_robDataProvider

private

Definition at line 229 of file CpByteStreamV2Tool.h.

m_slinks

int LVL1BS::CpByteStreamV2Tool::m_slinks

private

Property: Number of slinks per crate when writing out bytestream.

Definition at line 253 of file CpByteStreamV2Tool.h.

m_sourceIDsProp

std::vector<uint32_t> LVL1BS::CpByteStreamV2Tool::m_sourceIDsProp

private

Property: ROB source IDs.

Definition at line 267 of file CpByteStreamV2Tool.h.

m_srcIdMap

const L1CaloSrcIdMap LVL1BS::CpByteStreamV2Tool::m_srcIdMap

private

Source ID converter.

Definition at line 265 of file CpByteStreamV2Tool.h.

m_subDetector

const eformat::SubDetector LVL1BS::CpByteStreamV2Tool::m_subDetector

private

Sub-detector type.

Definition at line 263 of file CpByteStreamV2Tool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_version

int LVL1BS::CpByteStreamV2Tool::m_version

private

Property: Sub_block header version.

Definition at line 235 of file CpByteStreamV2Tool.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• CpByteStreamV2Tool.h
• CpByteStreamV2Tool.cxx