LVL1BS::PpmByteStreamV1Tool Class Reference

Tool to perform ROB fragments to trigger towers and trigger towers to raw data conversions. More...

#include <PpmByteStreamV1Tool.h>

Inheritance diagram for LVL1BS::PpmByteStreamV1Tool:

Collaboration diagram for LVL1BS::PpmByteStreamV1Tool:

Classes
struct	SlotData

Public Member Functions
	PpmByteStreamV1Tool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~PpmByteStreamV1Tool ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
StatusCode	convert (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::TriggerTower > *ttCollection) const
	Convert ROB fragments to trigger towers.
StatusCode	convert (const DataVector< LVL1::TriggerTower > *ttCollection, RawEventWrite *re) const
	Convert trigger towers to bytestream.
const std::vector< uint32_t > &	sourceIDs (const std::string &sgKey) const
	Return reference to vector with all possible Source Identifiers.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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

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 DataVector< LVL1::TriggerTower >	TriggerTowerCollection
typedef std::vector< LVL1::TriggerTower * >	TriggerTowerVector
typedef std::map< unsigned int, int >	TriggerTowerMap
typedef std::map< unsigned int, const LVL1::TriggerTower * >	TriggerTowerMapConst
typedef std::vector< uint32_t >	ChannelBitVector
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
void	addCompStats (const std::vector< uint32_t > &stats) const
	Add compression stats to totals.
void	printCompStats () const
	Print compression stats.
const LVL1::TriggerTower *	findLayerTriggerTower (double eta, double phi, int layer, const TriggerTowerMapConst &ttEmMap, const TriggerTowerMapConst &ttHadMap, LVL1::TriggerTowerKey &towerKey) const
	Find a trigger tower using separate layer maps.
void	setupTTMaps (const TriggerTowerCollection *ttCollection, TriggerTowerMapConst &ttEmMap, TriggerTowerMapConst &ttHadMap, LVL1::TriggerTowerKey &towerKey) const
	Set up separate Em and Had trigger tower maps.
bool	slinkSlices (int crate, int module, int modulesPerSlink, int &slicesLut, int &slicesFadc, int &trigLut, int &trigFadc, const TriggerTowerMapConst &ttEmMap, const TriggerTowerMapConst &ttHadMap, LVL1::TriggerTowerKey &towerKey) const
	Get number of slices and triggered slice offsets for next slink.
std::vector< uint32_t >	makeSourceIDs (bool spareChannels, bool muonChannels) const
void	printVec (const std::vector< int > &vec) const
	Print a vector.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::SlotSpecificObj< SlotData > m_slotData	ATLAS_THREAD_SAFE
ToolHandle< LVL1::IL1CaloMappingTool >	m_ppmMaps
	Property: Channel mapping tool.
ToolHandle< LVL1BS::L1CaloErrorByteStreamTool >	m_errorTool
	Property: Error collection tool.
ServiceHandle< SegMemSvc >	m_sms
	Memory pool service.
const int	m_version
	Sub_block header version.
int	m_dataFormat
	Property: Data compression format.
const int	m_compVers
	Compression version.
int	m_printCompStats
	Property: Compression statistics print flag.
int	m_slinks
	Property: Number of slinks per crate when writing out bytestream.
int	m_dfltSlicesLut
	Property: Default number of LUT slices in simulation.
int	m_dfltSlicesFadc
	Property: Default number of FADC slices in simulation.
int	m_forceSlicesLut
	Property: Force number of LUT slices in bytestream.
int	m_forceSlicesFadc
	Property: Force number of FADC slices in bytestream.
int	m_crateMin
	Property: Minimum crate number when writing out bytestream.
int	m_crateMax
	Property: Maximum crate number when writing out bytestream.
int	m_pedestal
	Property: Pedestal value.
int	m_fadcBaseline
	Property: FADC baseline lower bound.
int	m_fadcThreshold
	Property: FADC threshold for super-compressed format.
int	m_zeroSuppress
	Property: Zero suppression on input.
std::vector< uint32_t >	m_sourceIDsProp
	Property: ROB source IDs.
const eformat::SubDetector	m_subDetector
	Sub-detector type.
const L1CaloSrcIdMap	m_srcIdMap
	Source ID converter.
std::atomic< uint32_t >	m_compStats [MAXFORMATS]
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

Static Private Attributes
static constexpr unsigned int	MAXFORMATS = 10
	Vector for compression statistics.
static const int	s_crates = 8
static const int	s_modules = 16
static const int	s_channels = 64
static const int	s_dataSize = 3584

Detailed Description

Tool to perform ROB fragments to trigger towers and trigger towers to raw data conversions.

Based on ROD document version 1_09h.

Author

Peter Faulkner

Definition at line 56 of file PpmByteStreamV1Tool.h.

Member Typedef Documentation

ChannelBitVector

typedef std::vector<uint32_t> LVL1BS::PpmByteStreamV1Tool::ChannelBitVector

private

Definition at line 88 of file PpmByteStreamV1Tool.h.

ROBIterator

typedef IROBDataProviderSvc::VROBFRAG::const_iterator LVL1BS::PpmByteStreamV1Tool::ROBIterator

private

Definition at line 89 of file PpmByteStreamV1Tool.h.

ROBPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::PpmByteStreamV1Tool::ROBPointer

private

Definition at line 90 of file PpmByteStreamV1Tool.h.

RODPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::PpmByteStreamV1Tool::RODPointer

private

Definition at line 91 of file PpmByteStreamV1Tool.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

TriggerTowerCollection

typedef DataVector<LVL1::TriggerTower> LVL1BS::PpmByteStreamV1Tool::TriggerTowerCollection

private

Definition at line 83 of file PpmByteStreamV1Tool.h.

TriggerTowerMap

typedef std::map<unsigned int, int> LVL1BS::PpmByteStreamV1Tool::TriggerTowerMap

private

Definition at line 85 of file PpmByteStreamV1Tool.h.

TriggerTowerMapConst

typedef std::map<unsigned int, const LVL1::TriggerTower*> LVL1BS::PpmByteStreamV1Tool::TriggerTowerMapConst

private

Definition at line 87 of file PpmByteStreamV1Tool.h.

TriggerTowerVector

typedef std::vector<LVL1::TriggerTower*> LVL1BS::PpmByteStreamV1Tool::TriggerTowerVector

private

Definition at line 84 of file PpmByteStreamV1Tool.h.

Constructor & Destructor Documentation

PpmByteStreamV1Tool()

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

Definition at line 52 of file PpmByteStreamV1Tool.cxx.

    : AthAlgTool(type, name, parent),
      m_ppmMaps("LVL1::PpmMappingTool/PpmMappingTool"),
      m_errorTool("LVL1BS::L1CaloErrorByteStreamTool/L1CaloErrorByteStreamTool"),
      m_sms("SegMemSvc/SegMemSvc", name),
      m_version(1), m_compVers(4),
      m_subDetector(eformat::TDAQ_CALO_PREPROC)
{
    declareInterface<PpmByteStreamV1Tool>(this);
 
    declareProperty("PpmMappingTool", m_ppmMaps,
                    "Crate/Module/Channel to Eta/Phi/Layer mapping tool");
    declareProperty("ErrorTool", m_errorTool,
                    "Tool to collect errors for monitoring");
 
    declareProperty("PrintCompStats",     m_printCompStats  = 0,
                    "Print compressed format statistics");
    declareProperty("SlinksPerCrate",     m_slinks          = 4,
                    "The number of S-Links per crate");
 
    // Properties for reading bytestream only
    declareProperty("ZeroSuppress",       m_zeroSuppress    = 0,
                    "Only make trigger towers with non-zero EM or Had energy");
    declareProperty("ROBSourceIDs",       m_sourceIDsProp,
                    "ROB fragment source identifiers");
    declareProperty("PedestalValue",      m_pedestal        = 10,
                    "Pedestal value - needed for compressed formats 0,1 only");
 
    // Properties for writing bytestream only
    declareProperty("DataFormat",         m_dataFormat      = 1,
                    "Format identifier (0-3) in sub-block header");
    declareProperty("FADCBaseline",       m_fadcBaseline    = 0,
                    "FADC baseline lower bound for compressed formats");
    declareProperty("FADCThreshold",      m_fadcThreshold   = 1,
                    "FADC threshold for super-compressed format");
    declareProperty("SimulSlicesLUT",     m_dfltSlicesLut   = 1,
                    "The number of LUT slices in the simulation");
    declareProperty("SimulSlicesFADC",    m_dfltSlicesFadc  = 7,
                    "The number of FADC slices in the simulation");
    declareProperty("ForceSlicesLUT",     m_forceSlicesLut  = 0,
                    "If >0, the number of LUT slices in bytestream");
    declareProperty("ForceSlicesFADC",    m_forceSlicesFadc = 0,
                    "If >0, the number of FADC slices in bytestream");
    declareProperty("CrateMin",       m_crateMin = 0,
                    "Minimum crate number, allows partial output");
    declareProperty("CrateMax",       m_crateMax = s_crates - 1,
                    "Maximum crate number, allows partial output");
 
}

~PpmByteStreamV1Tool()

LVL1BS::PpmByteStreamV1Tool::~PpmByteStreamV1Tool ( )

virtual

Definition at line 106 of file PpmByteStreamV1Tool.cxx.

{
}

Member Function Documentation

addCompStats()

void LVL1BS::PpmByteStreamV1Tool::addCompStats ( const std::vector< uint32_t > & stats ) const

private

Add compression stats to totals.

Definition at line 1058 of file PpmByteStreamV1Tool.cxx.

{
    if (stats.empty()) return;
    const int n = std::min (stats.size(), static_cast<size_t>(MAXFORMATS));
    for (int i = 0; i < n; ++i) {
      std::atomic<uint32_t>& stat ATLAS_THREAD_SAFE =
        const_cast<std::atomic<uint32_t>&> (m_compStats[i]);
      stat += stats[i];
    }
}

convert() [1/2]

StatusCode LVL1BS::PpmByteStreamV1Tool::convert	(	const DataVector< LVL1::TriggerTower > *	ttCollection,
		RawEventWrite *	re ) const

Convert trigger towers to bytestream.

Definition at line 787 of file PpmByteStreamV1Tool.cxx.

{
    const bool debug = msgLvl(MSG::DEBUG);
    if (debug) msg(MSG::DEBUG);
 
    // Clear the event assembler
    FullEventAssembler<L1CaloSrcIdMap> fea;
    fea.clear();
    const uint16_t minorVersion = m_srcIdMap.minorVersionPreLS1();
    fea.setRodMinorVersion(minorVersion);
 
    // Pointer to ROD data vector
 
    FullEventAssembler<L1CaloSrcIdMap>::RODDATA *theROD = 0;
 
    LVL1::TriggerTowerKey towerKey;
 
    // Set up trigger tower maps
 
    // Trigger tower map for conversion EM to bytestream
    TriggerTowerMapConst ttEmMap;
    // Trigger tower map for conversion Had to bytestream
    TriggerTowerMapConst ttHadMap;
    setupTTMaps(ttCollection, ttEmMap, ttHadMap, towerKey);
 
    // Create the sub-blocks to do the packing
 
    PpmSubBlockV1 subBlock;
    const int chanPerSubBlock = subBlock.channelsPerSubBlock(m_version,
                                m_dataFormat);
    if (chanPerSubBlock == 0)
    {
        msg(MSG::ERROR) << "Unsupported version/data format: "
                        << m_version << "/" << m_dataFormat << endmsg;
        return StatusCode::FAILURE;
    }
    PpmSubBlockV1 errorBlock;
 
    int slicesLut  = 1;
    int slicesFadc = 1;
    int trigLut    = 0;
    int trigFadc   = 0;
    int slicesLutNew  = 1;
    int slicesFadcNew = 1;
    int trigLutNew    = 0;
    int trigFadcNew   = 0;
    const int modulesPerSlink = s_modules / m_slinks;
    for (int crate = m_crateMin; crate <= m_crateMax; ++crate)
    {
        for (int module = 0; module < s_modules; ++module)
        {
 
            // Pack required number of modules per slink
 
            if (module % modulesPerSlink == 0)
            {
                const int daqOrRoi = 0;
                const int slink = module / modulesPerSlink;
                if (debug)
                {
                    msg() << "Treating crate " << crate << " slink " << slink << endmsg;
                }
                // Get number of slices and triggered slice offsets
                // for this slink
                if ( ! slinkSlices(crate, module, modulesPerSlink,
                                   slicesLut, slicesFadc, trigLut, trigFadc,
                                   ttEmMap, ttHadMap,
                                   towerKey))
                {
                    msg(MSG::ERROR) << "Inconsistent number of slices or "
                                    << "triggered slice offsets in data for crate "
                                    << crate << " slink " << slink << endmsg;
                    return StatusCode::FAILURE;
                }
                slicesLutNew  = (m_forceSlicesLut)  ? m_forceSlicesLut  : slicesLut;
                slicesFadcNew = (m_forceSlicesFadc) ? m_forceSlicesFadc : slicesFadc;
                trigLutNew    = ModifySlices::peak(trigLut,  slicesLut,  slicesLutNew);
                trigFadcNew   = ModifySlices::peak(trigFadc, slicesFadc, slicesFadcNew);
                if (debug)
                {
                    msg() << "Data Version/Format: " << m_version
                          << " " << m_dataFormat << endmsg
                          << "LUT slices/offset: " << slicesLut << " " << trigLut;
                    if (slicesLut != slicesLutNew)
                    {
                        msg() << " modified to " << slicesLutNew << " " << trigLutNew;
                    }
                    msg() << endmsg
                          << "FADC slices/offset: " << slicesFadc << " " << trigFadc;
                    if (slicesFadc != slicesFadcNew)
                    {
                        msg() << " modified to " << slicesFadcNew << " " << trigFadcNew;
                    }
                    msg() << endmsg;
                }
                L1CaloUserHeader userHeader;
                userHeader.setPpmLut(trigLutNew);
                userHeader.setPpmFadc(trigFadcNew);
                userHeader.setLowerBound(m_fadcBaseline);
                const uint32_t rodIdPpm = m_srcIdMap.getRodID(crate, slink, daqOrRoi,
                                          m_subDetector);
                theROD = fea.getRodData(rodIdPpm);
                theROD->push_back(userHeader.header());
            }
            if (debug) msg() << "Module " << module << endmsg;
 
            // Find trigger towers corresponding to each eta/phi pair and fill
            // sub-blocks
 
            bool upstreamError = false;
            for (int channel = 0; channel < s_channels; ++channel)
            {
                const int chan = channel % chanPerSubBlock;
                if (channel == 0 && m_dataFormat == L1CaloSubBlock::UNCOMPRESSED)
                {
                    errorBlock.clear();
                    errorBlock.setPpmErrorHeader(m_version, m_dataFormat, crate,
                                                 module, slicesFadcNew, slicesLutNew);
                }
                if (chan == 0)
                {
                    subBlock.clear();
                    if (m_dataFormat >= L1CaloSubBlock::COMPRESSED)
                    {
                        subBlock.setPpmHeader(m_version, m_dataFormat, m_compVers, crate,
                                              module, slicesFadcNew, slicesLutNew);
                    }
                    else
                    {
                        subBlock.setPpmHeader(m_version, m_dataFormat, channel, crate,
                                              module, slicesFadcNew, slicesLutNew);
                    }
                    subBlock.setLutOffset(trigLutNew);
                    subBlock.setFadcOffset(trigFadcNew);
                    subBlock.setFadcBaseline(m_fadcBaseline);
                    subBlock.setFadcThreshold(m_fadcThreshold);
                }
                const LVL1::TriggerTower *tt = 0;
                double eta = 0.;
                double phi = 0.;
                int layer = 0;
                if (m_ppmMaps->mapping(crate, module, channel, eta, phi, layer))
                {
                  tt = findLayerTriggerTower(eta, phi, layer, ttEmMap, ttHadMap, towerKey);
                }
                if (tt )
                {
                    int err = 0;
                    std::vector<int> lut;
                    std::vector<int> fadc;
                    std::vector<int> bcidLut;
                    std::vector<int> bcidFadc;
                    if (layer == 0)    // em
                    {
                        ModifySlices::data(tt->emLUT(),     lut,      slicesLutNew);
                        ModifySlices::data(tt->emADC(),     fadc,     slicesFadcNew);
                        ModifySlices::data(tt->emBCIDvec(), bcidLut,  slicesLutNew);
                        ModifySlices::data(tt->emBCIDext(), bcidFadc, slicesFadcNew);
                        err = tt->emError();
                    }
                    else               // had
                    {
                        ModifySlices::data(tt->hadLUT(),     lut,      slicesLutNew);
                        ModifySlices::data(tt->hadADC(),     fadc,     slicesFadcNew);
                        ModifySlices::data(tt->hadBCIDvec(), bcidLut,  slicesLutNew);
                        ModifySlices::data(tt->hadBCIDext(), bcidFadc, slicesFadcNew);
                        err = tt->hadError();
                    }
                    subBlock.fillPpmData(channel, lut, fadc, bcidLut, bcidFadc);
                    if (err)
                    {
                        const LVL1::DataError errorBits(err);
                        const int errpp = errorBits.get(LVL1::DataError::PPMErrorWord);
                        if (m_dataFormat == L1CaloSubBlock::UNCOMPRESSED)
                        {
                            errorBlock.fillPpmError(channel, errpp);
                        }
                        else subBlock.fillPpmError(channel, errpp);
                        if (errpp >> 2) upstreamError = true;
                    }
                }
                if (chan == chanPerSubBlock - 1)
                {
                    // output the packed sub-block
                    if ( !subBlock.pack())
                    {
                        msg(MSG::ERROR) << "PPM sub-block packing failed" << endmsg;
                        return StatusCode::FAILURE;
                    }
                    if (m_printCompStats) addCompStats(subBlock.compStats());
                    if (channel != s_channels - 1)
                    {
                        // Only put errors in last sub-block
                        subBlock.setStatus(0, false, false, false, false,
                                           false, false, false);
                        if (debug)
                        {
                            msg() << "PPM sub-block data words: "
                                  << subBlock.dataWords() << endmsg;
                        }
                        subBlock.write(theROD);
                    }
                    else
                    {
                        // Last sub-block - write error block
                        bool glinkTimeout = false;
                        bool daqOverflow  = false;
                        bool bcnMismatch  = false;
                        bool glinkParity  = false;
                        if (m_dataFormat == L1CaloSubBlock::UNCOMPRESSED)
                        {
                            glinkTimeout = errorBlock.mcmAbsent() ||
                                           errorBlock.timeout();
                            daqOverflow  = errorBlock.asicFull() ||
                                           errorBlock.fpgaCorrupt();
                            bcnMismatch  = errorBlock.eventMismatch() ||
                                           errorBlock.bunchMismatch();
                            glinkParity  = errorBlock.glinkPinParity();
                        }
                        else
                        {
                            glinkTimeout = subBlock.mcmAbsent() ||
                                           subBlock.timeout();
                            daqOverflow  = subBlock.asicFull() ||
                                           subBlock.fpgaCorrupt();
                            bcnMismatch  = subBlock.eventMismatch() ||
                                           subBlock.bunchMismatch();
                            glinkParity  = subBlock.glinkPinParity();
                        }
                        subBlock.setStatus(0, glinkTimeout, false, upstreamError,
                                           daqOverflow, bcnMismatch, false, glinkParity);
                        if (debug)
                        {
                            msg() << "PPM sub-block data words: "
                                  << subBlock.dataWords() << endmsg;
                        }
                        subBlock.write(theROD);
                        // Only uncompressed format has a separate error block
                        if (m_dataFormat == L1CaloSubBlock::UNCOMPRESSED)
                        {
                            if ( ! errorBlock.pack())
                            {
                                msg(MSG::ERROR) << "PPM error block packing failed" << endmsg;
                                return StatusCode::FAILURE;
                            }
                            errorBlock.setStatus(0, glinkTimeout, false, upstreamError,
                                                 daqOverflow, bcnMismatch, false, glinkParity);
                            errorBlock.write(theROD);
                            if (debug)
                            {
                                msg() << "PPM error block data words: "
                                      << errorBlock.dataWords() << endmsg;
                            }
                        }
                    }
                }
            }
        }
    }
 
    // Fill the raw event
 
    fea.fill(re, msg());
 
    return StatusCode::SUCCESS;
}

convert() [2/2]

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

Convert ROB fragments to trigger towers.

Definition at line 139 of file PpmByteStreamV1Tool.cxx.

{
    const bool debug   = msgLvl(MSG::DEBUG);
    const bool verbose = msgLvl(MSG::VERBOSE);
    if (debug) msg(MSG::DEBUG);
 
    const std::string flag("Spare");
    const std::string::size_type pos = sgKey.find(flag);
    bool spareChannels =
        (pos != std::string::npos && pos == (sgKey.length() - flag.length()));
    const std::string flag2("Muon");
    const std::string::size_type pos2 = sgKey.find(flag2);
    bool muonChannels =
        (pos2 != std::string::npos && pos2 == (sgKey.length() - flag2.length()));
    bool dataChannels = (!spareChannels && !muonChannels);
 
    // Set up TriggerTower pool and mappings
    // (NB. This assumes mappings won't change during the course of a job)
    const int maxChannels = s_crates * s_modules * s_channels;
    const int chanBitVecSize = maxChannels / 32;
 
    SlotData& sd = *m_slotData;
    std::lock_guard guard (sd.m_mutex);
    
    if (sd.m_ttData.empty())
    {
        const int spareSize = maxChannels - 2 * s_dataSize;
        const int muonSize = 2 * s_channels;
        const int modBitVecSize = (s_crates * s_modules) / 32;
        sd.m_ttData.reserve(s_dataSize);
        sd.m_ttSpare.reserve(spareSize);
        sd.m_ttMuon.reserve(muonSize);
        sd.m_ttPos.resize(maxChannels);
        sd.m_chanLayer.resize(chanBitVecSize);
        sd.m_dataChan.resize(chanBitVecSize);
        sd.m_spareChan.resize(chanBitVecSize);
        sd.m_muonChan.resize(chanBitVecSize);
        sd.m_dataMod.resize(modBitVecSize);
        sd.m_spareMod.resize(modBitVecSize);
        sd.m_muonMod.resize(modBitVecSize);
        TriggerTowerMap ttMap;
        TriggerTowerMap::iterator itt;
        std::vector<int> dummyS;
        std::vector<int> dummyL(1);
        std::vector<int> dummyF(5);
        int dataCount  = 0;
        int spareCount = 0;
        for (int crate = 0; crate < s_crates; ++crate)
        {
            for (int module = 0; module < s_modules; ++module)
            {
                const int index2 = (crate << 4) + module;
                const int word2  = index2 / 32;
                const int bit2   = index2 % 32;
                for (int channel = 0; channel < s_channels; ++channel)
                {
                    const int index = (crate << 10) + (module << 6) + channel;
                    const int word  = index / 32;
                    const int bit   = index % 32;
                    double eta = 0.;
                    double phi = 0.;
                    int layer = 0;
                    unsigned int key = 0;
                    if (m_ppmMaps->mapping(crate, module, channel, eta, phi, layer))
                    {
                        // Data channels
                        key = sd.m_towerKey.ttKey(phi, eta);
                        itt = ttMap.find(key);
                        if (itt == ttMap.end())
                        {
                            LVL1::TriggerTower *tt =
                                new (m_sms->allocate<LVL1::TriggerTower>(SegMemSvc::JOB))
                            LVL1::TriggerTower(phi, eta, key,
                                               dummyF, dummyL, dummyF, dummyL, 0, 0, 0,
                                               dummyF, dummyL, dummyF, dummyL, 0, 0, 0);
                            sd.m_ttData.push_back(tt);
                            const int count = dataCount++;
                            sd.m_ttPos[index] = count;
                            ttMap.insert(std::make_pair(key, count));
                        }
                        else
                        {
                            sd.m_ttPos[index] = itt->second;
                        }
                        sd.m_chanLayer[word] |= (layer << bit);
                        sd.m_dataChan[word]  |= (1 << bit);
                        sd.m_dataMod[word2]  |= (1 << bit2);
                    }
                    else
                    {
                        // Spare channels
                        const int pin  = channel % 16;
                        const int asic = channel / 16;
                        eta = 16 * crate + module;
                        phi = 4 * pin + asic;
                        layer = 0;
                        const int type = 1;
                        key = (crate << 24) | (type << 20) | (module << 16) | (pin << 8) | asic; // CoolID
                        LVL1::TriggerTower *tt =
                            new (m_sms->allocate<LVL1::TriggerTower>(SegMemSvc::JOB))
                        LVL1::TriggerTower(phi, eta, key,
                                           dummyF, dummyL, dummyF, dummyL, 0, 0, 0,
                                           dummyS, dummyS, dummyS, dummyS, 0, 0, 0);
                        sd.m_ttSpare.push_back(tt);
                        sd.m_ttPos[index] = spareCount++;
                        sd.m_chanLayer[word] |= (layer << bit);
                        sd.m_spareChan[word] |= (1 << bit);
                        sd.m_spareMod[word2] |= (1 << bit2);
                        if ((crate == 2 || crate == 3) && (module == 0))
                        {
                            sd.m_ttMuon.push_back(tt);
                            sd.m_muonChan[word] |= (1 << bit);
                            sd.m_muonMod[word2] |= (1 << bit2);
                        }
                    }
                }
            }
        }
    }
 
    // Set up according to the collection we want
 
    TriggerTowerVector &ttCol(dataChannels ? sd.m_ttData
                              : spareChannels
                              ? sd.m_ttSpare
                              : sd.m_ttMuon);
    TriggerTowerVector &ttColRef(dataChannels ? sd.m_ttData
                                 : sd.m_ttSpare);
    const ChannelBitVector &colChan(dataChannels ? sd.m_dataChan
                                    : spareChannels
                                    ? sd.m_spareChan
                                    : sd.m_muonChan);
    const ChannelBitVector &colMod(dataChannels ? sd.m_dataMod
                                   : spareChannels
                                   ? sd.m_spareMod
                                   : sd.m_muonMod);
    const int colSize = dataChannels ? 2 * ttCol.size()
                        : ttCol.size();
    sd.m_foundChan.assign(chanBitVecSize, 0);
    int ttCount = 0;
 
    // Vectors to unpack into
    std::vector<int> lut;
    std::vector<int> fadc;
    std::vector<int> bcidLut;
    std::vector<int> bcidFadc;
 
    // Loop over ROB fragments
 
    int fadcBaseline = m_fadcBaseline;
 
    int robCount = 0;
    std::set<uint32_t> dupCheck;
    ROBIterator rob    = robFrags.begin();
    ROBIterator robEnd = robFrags.end();
    for (; rob != robEnd; ++rob)
    {
 
        if (debug)
        {
            ++robCount;
            msg() << "Treating ROB fragment " << robCount << endmsg;
        }
 
        // Skip fragments with ROB status errors
 
        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)    >= m_slinks      ||
                m_srcIdMap.crate(sourceID)    >= s_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 post-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 offsets
        const int trigLut  = userHeader.ppmLut();
        const int trigFadc = userHeader.ppmFadc();
        // FADC baseline lower bound
        fadcBaseline = userHeader.lowerBound();
        if (debug)
        {
            msg() << "Minor format version number: "
                  << MSG::hex << minorVersion << MSG::dec              << endmsg
                  << "LUT triggered slice offset:  " << trigLut        << endmsg
                  << "FADC triggered slice offset: " << trigFadc       << endmsg
                  << "FADC baseline lower bound:   " << fadcBaseline << endmsg;
        }
        const int runNumber = (*rob)->rod_run_no() & 0xffffff;
 
        // Find the number of channels per sub-block
 
        int chanPerSubBlock = 0;
        bool firstBlock = false;
        uint32_t firstWord = 0;
        RODPointer payloadFirst;
        if (payload != payloadEnd)
        {
            if (L1CaloSubBlock::wordType(*payload) != L1CaloSubBlock::HEADER
                    || CmmSubBlock::cmmBlock(*payload))
            {
                m_errorTool->rodError(robid, L1CaloSubBlock::ERROR_MISSING_HEADER);
                if (debug) msg() << "Missing Sub-block header" << endmsg;
                continue;
            }
            firstBlock = true;
            firstWord = *payload;
            if (sd.m_ppmBlocks.empty())
            {
                sd.m_ppmBlocks.push_back(new PpmSubBlockV1());
            }
            PpmSubBlockV1 *const subBlock = sd.m_ppmBlocks[0];
            subBlock->clear();
            payloadFirst = subBlock->read(payload, payloadEnd);
            chanPerSubBlock = subBlock->channelsPerSubBlock();
            if (chanPerSubBlock == 0)
            {
                m_errorTool->rodError(robid, subBlock->unpackErrorCode());
                if (debug) msg() << "Unsupported version/data format: "
                                     << subBlock->version() << "/"
                                     << subBlock->format()  << endmsg;
                continue;
            }
            if (debug) msg() << "Channels per sub-block: "
                                 << chanPerSubBlock << endmsg;
        }
        else
        {
            if (debug) msg() << "ROB fragment contains user header only" << endmsg;
            continue;
        }
        const int numSubBlocks = s_channels / chanPerSubBlock;
        const int size = sd.m_ppmBlocks.size();
        if (numSubBlocks > size)
        {
            for (int i = size; i < numSubBlocks; ++i)
            {
                sd.m_ppmBlocks.push_back(new PpmSubBlockV1());
            }
        }
 
        // Loop over PPMs
 
        payload = payloadBeg;
        for (int i = 0; i < headerWords; ++i) ++payload;
        unsigned int rodErr = L1CaloSubBlock::ERROR_NONE;
        while (payload != payloadEnd)
        {
 
            // Get all sub-blocks for one PPM (first already read in above)
 
            int crate = 0;
            int module = 0;
            int nPpmBlocks = 0;
            for (int block = 0; block < numSubBlocks; ++block)
            {
                const uint32_t word = (firstBlock) ? firstWord : *payload;
                if (L1CaloSubBlock::wordType(word) != L1CaloSubBlock::HEADER
                        || CmmSubBlock::cmmBlock(word)
                        || PpmSubBlockV1::errorBlock(word))
                {
                    if (debug) msg() << "Unexpected data sequence" << endmsg;
                    rodErr = L1CaloSubBlock::ERROR_MISSING_HEADER;
                    break;
                }
                if (chanPerSubBlock != s_channels &&
                        L1CaloSubBlock::seqno(word) != block * chanPerSubBlock)
                {
                    if (debug)
                    {
                        msg() << "Unexpected channel sequence number: "
                              << L1CaloSubBlock::seqno(word) << " expected "
                              << block *chanPerSubBlock << endmsg;
                    }
                    rodErr = L1CaloSubBlock::ERROR_MISSING_SUBBLOCK;
                    break;
                }
                PpmSubBlockV1 *const subBlock = sd.m_ppmBlocks[block];
                nPpmBlocks++;
                if (firstBlock)
                {
                    payload = payloadFirst;
                    firstBlock = false;
                }
                else
                {
                    subBlock->clear();
                    payload = subBlock->read(payload, payloadEnd);
                }
                if (block == 0)
                {
                    crate = subBlock->crate();
                    module = subBlock->module();
                    if (debug)
                    {
                        msg() << "Crate " << crate << "  Module " << module << endmsg;
                    }
                    if (crate != rodCrate)
                    {
                        if (debug)
                        {
                            msg() << "Inconsistent crate number in ROD source ID" << endmsg;
                        }
                        rodErr = L1CaloSubBlock::ERROR_CRATE_NUMBER;
                        break;
                    }
                }
                else
                {
                    if (subBlock->crate() != crate)
                    {
                        if (debug) msg() << "Inconsistent crate number in sub-blocks"
                                             << endmsg;
                        rodErr = L1CaloSubBlock::ERROR_CRATE_NUMBER;
                        break;
                    }
                    if (subBlock->module() != module)
                    {
                        if (debug) msg() << "Inconsistent module number in sub-blocks"
                                             << endmsg;
                        rodErr = L1CaloSubBlock::ERROR_MODULE_NUMBER;
                        break;
                    }
                }
                if (payload == payloadEnd && block != numSubBlocks - 1)
                {
                    if (debug) msg() << "Premature end of data" << endmsg;
                    rodErr = L1CaloSubBlock::ERROR_MISSING_SUBBLOCK;
                    break;
                }
            }
            if (rodErr != L1CaloSubBlock::ERROR_NONE) break;
 
            // Is there an error block?
 
            bool isErrBlock = false;
            if (payload != payloadEnd)
            {
                if (L1CaloSubBlock::wordType(*payload) == L1CaloSubBlock::HEADER
                        && !CmmSubBlock::cmmBlock(*payload)
                        && PpmSubBlockV1::errorBlock(*payload))
                {
                    if (debug) msg() << "Error block found" << endmsg;
                    sd.m_errorBlock.clear();
                    isErrBlock = true;
                    payload = sd.m_errorBlock.read(payload, payloadEnd);
                    if (sd.m_errorBlock.crate() != crate)
                    {
                        if (debug) msg() << "Inconsistent crate number in error block"
                                             << endmsg;
                        rodErr = L1CaloSubBlock::ERROR_CRATE_NUMBER;
                        break;
                    }
                    if (sd.m_errorBlock.module() != module)
                    {
                        if (debug) msg() << "Inconsistent module number in error block"
                                             << endmsg;
                        rodErr = L1CaloSubBlock::ERROR_MODULE_NUMBER;
                        break;
                    }
                    if (sd.m_errorBlock.dataWords() && !sd.m_errorBlock.unpack())
                    {
                        if (debug)
                        {
                            std::string errMsg(sd.m_errorBlock.unpackErrorMsg());
                            msg() << "Unpacking error block failed: " << errMsg << endmsg;
                        }
                        rodErr = sd.m_errorBlock.unpackErrorCode();
                        break;
                    }
                }
            }
 
            // Don't bother unpacking modules that aren't used for required collection
 
            const int index2 = (crate << 4) + module;
            const int word2  = index2 / 32;
            const int bit2   = index2 % 32;
            if (!((colMod[word2] >> bit2) & 1)) continue;
 
            // Loop over sub-blocks and fill trigger towers
 
            for (int block = 0; block < nPpmBlocks; ++block)
            {
                PpmSubBlockV1 *const subBlock = sd.m_ppmBlocks[block];
                subBlock->setLutOffset(trigLut);
                subBlock->setFadcOffset(trigFadc);
                subBlock->setPedestal(m_pedestal);
                subBlock->setFadcBaseline(fadcBaseline);
                subBlock->setRunNumber(runNumber);
                if (debug)
                {
                    msg() << "Unpacking sub-block version/format/seqno: "
                          << subBlock->version() << "/" << subBlock->format() << "/"
                          << subBlock->seqno() << endmsg;
                }
                if (subBlock->dataWords() && !subBlock->unpack())
                {
                    if (debug)
                    {
                        std::string errMsg(subBlock->unpackErrorMsg());
                        msg() << "Unpacking PPM sub-block failed: " << errMsg << endmsg;
                    }
                    rodErr = subBlock->unpackErrorCode();
                    break;
                }
                if (m_printCompStats) addCompStats(subBlock->compStats());
                for (int chan = 0; chan < chanPerSubBlock; ++chan)
                {
                    const int channel = block * chanPerSubBlock + chan;
                    const int index = (crate << 10) + (module << 6) + channel;
                    const int word  = index / 32;
                    const int bit   = index % 32;
                    if (!((colChan[word] >> bit) & 1)) continue; // skip unwanted channels
                    if (((sd.m_foundChan[word] >> bit) & 1))
                    {
                        if (debug) msg() << "Duplicate data for crate/module/channel: "
                                             << crate << "/" << module << "/" << channel
                                             << endmsg;
                        rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
                        break;
                    }
                    lut.clear();
                    fadc.clear();
                    bcidLut.clear();
                    bcidFadc.clear();
                    subBlock->ppmData(channel, lut, fadc, bcidLut, bcidFadc);
                    if (lut.size() < size_t(trigLut + 1))
                    {
                        if (debug)
                        {
                            msg() << "Triggered LUT slice from header "
                                  << "inconsistent with number of slices: "
                                  << trigLut << ", " << lut.size() << endmsg;
                        }
                        rodErr = L1CaloSubBlock::ERROR_SLICES;
                        break;
                    }
                    if (fadc.size() < size_t(trigFadc + 1))
                    {
                        if (debug)
                        {
                            msg() << "Triggered FADC slice from header "
                                  << "inconsistent with number of slices: "
                                  << trigFadc << ", " << fadc.size() << endmsg;
                        }
                        rodErr = L1CaloSubBlock::ERROR_SLICES;
                        break;
                    }
                    LVL1::DataError errorBits(0);
                    if (isErrBlock)
                    {
                        errorBits.set(LVL1::DataError::PPMErrorWord,
                                      sd.m_errorBlock.ppmError(channel));
                        errorBits.set(LVL1::DataError::SubStatusWord,
                                      sd.m_errorBlock.subStatus());
                    }
                    else
                    {
                        errorBits.set(LVL1::DataError::PPMErrorWord,
                                      subBlock->ppmError(channel));
                        const PpmSubBlockV1 *const lastBlock =
                            sd.m_ppmBlocks[nPpmBlocks - 1];
                        errorBits.set(LVL1::DataError::SubStatusWord,
                                      lastBlock->subStatus());
                    }
                    // Wrong bit set for compressed formats 1.01 to 1.03
                    if (subBlock->format() > 1 && subBlock->seqno() < 4)
                    {
                        errorBits.set(LVL1::DataError::ModuleError,
                                      (errorBits.error() >> (LVL1::DataError::ModuleError + 1)) & 0x1);
                    }
                    const int error = errorBits.error();
 
                    // Save to TriggerTower
 
                    if (verbose)
                    {
                        msg(MSG::VERBOSE) << "channel/LUT/FADC/bcidLUT/bcidFADC/error: "
                                          << channel << "/";
                        printVec(lut);
                        printVec(fadc);
                        printVec(bcidLut);
                        printVec(bcidFadc);
                        msg() << MSG::hex << error << MSG::dec << "/";
                    }
                    sd.m_foundChan[word] |= (1 << bit);
                    ++ttCount;
                    LVL1::TriggerTower *tt = ttColRef[sd.m_ttPos[index]];
                    const int layer = ((sd.m_chanLayer[word] >> bit) & 1);
                    if (layer == 0)    // EM
                    {
                        tt->addEM(fadc, lut, bcidFadc, bcidLut, error, trigLut, trigFadc);
                    }
                    else               // Had
                    {
                        tt->addHad(fadc, lut, bcidFadc, bcidLut, error, trigLut, trigFadc);
                    }
                }
                if (rodErr != L1CaloSubBlock::ERROR_NONE) break;
            }
            if (rodErr != L1CaloSubBlock::ERROR_NONE) break;
        }
        if (rodErr != L1CaloSubBlock::ERROR_NONE)
            m_errorTool->rodError(robid, rodErr);
    }
 
    // Reset any missing channels (should be rare)
 
    if (ttCount != colSize)
    {
        if (debug)
        {
            msg() << "Found " << ttCount << " channels, expected " << colSize << endmsg;
        }
        std::vector<int> dummy(1);
        for (int word = 0; word < chanBitVecSize; ++word)
        {
            if (sd.m_foundChan[word] != colChan[word])
            {
                for (int bit = 0; bit < 32; ++bit)
                {
                    if (((sd.m_foundChan[word] >> bit) & 1) != ((colChan[word] >> bit) & 1))
                    {
                        const int index = word * 32 + bit;
                        LVL1::TriggerTower *tt = ttColRef[sd.m_ttPos[index]];
                        const int layer = ((sd.m_chanLayer[word] >> bit) & 1);
                        if (layer == 0)              // EM
                        {
                            tt->addEM(dummy, dummy, dummy, dummy, 0, 0, 0);
                        }
                        else if (dataChannels)     // Had
                        {
                            tt->addHad(dummy, dummy, dummy, dummy, 0, 0, 0);
                        }
                    }
                }
            }
        }
    }
 
    // And copy into output collection
 
    if (m_zeroSuppress)
    {
        TriggerTowerVector::iterator itr  = ttCol.begin();
        TriggerTowerVector::iterator itrE = ttCol.end();
        for (; itr != itrE; ++itr)
        {
            if ((*itr)->emEnergy() || (dataChannels && (*itr)->hadEnergy()))
            {
                ttCollection->push_back(*itr);
            }
        }
    }
    else
    {
        ttCollection->assign(ttCol.begin(), ttCol.end());
    }
 
    return StatusCode::SUCCESS;
}

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

finalize()

StatusCode LVL1BS::PpmByteStreamV1Tool::finalize ( )

overridevirtual

Definition at line 126 of file PpmByteStreamV1Tool.cxx.

{
    if (m_printCompStats && msgLvl(MSG::INFO))
    {
        msg(MSG::INFO);
        printCompStats();
    }
    return StatusCode::SUCCESS;
}

findLayerTriggerTower()

const LVL1::TriggerTower * LVL1BS::PpmByteStreamV1Tool::findLayerTriggerTower ( double eta, double phi, int layer, const TriggerTowerMapConst & ttEmMap, const TriggerTowerMapConst & ttHadMap, LVL1::TriggerTowerKey & towerKey ) const

private

Find a trigger tower using separate layer maps.

Definition at line 1083 of file PpmByteStreamV1Tool.cxx.

{
    const LVL1::TriggerTower *tt = 0;
    const unsigned int key = towerKey.ttKey(phi, eta);
    TriggerTowerMapConst::const_iterator mapIter;
    if (layer == 0)
    {
        mapIter = ttEmMap.find(key);
        if (mapIter != ttEmMap.end()) tt = mapIter->second;
    }
    else
    {
        mapIter = ttHadMap.find(key);
        if (mapIter != ttHadMap.end()) tt = mapIter->second;
    }
    return tt;
}

initialize()

StatusCode LVL1BS::PpmByteStreamV1Tool::initialize ( )

overridevirtual

Definition at line 113 of file PpmByteStreamV1Tool.cxx.

{
    ATH_MSG_INFO ( "Initializing " << name() );
 
    ATH_CHECK( m_ppmMaps.retrieve() );
    ATH_CHECK( m_errorTool.retrieve() );
    ATH_CHECK( m_sms.retrieve() );
 
    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::PpmByteStreamV1Tool::interfaceID ( )

static

AlgTool InterfaceID.

Definition at line 45 of file PpmByteStreamV1Tool.cxx.

{
    return IID_IPpmByteStreamV1Tool;
}

makeSourceIDs()

std::vector< uint32_t > LVL1BS::PpmByteStreamV1Tool::makeSourceIDs ( bool spareChannels, bool muonChannels ) const

private

Definition at line 1222 of file PpmByteStreamV1Tool.cxx.

{
  std::vector<uint32_t> robIds;
 
  if (!spareChannels && !muonChannels) {
    robIds = m_sourceIDsProp;
  }
 
  if (robIds.empty()) {
    const int maxlinks = m_srcIdMap.maxSlinks();
    for (int crate = 0; crate < s_crates; ++crate)
    {
      for (int slink = 0; slink < maxlinks; ++slink)
      {
        const int daqOrRoi = 0;
        const uint32_t rodId = m_srcIdMap.getRodID(crate, slink, daqOrRoi,
                                                    m_subDetector);
        const uint32_t robId = m_srcIdMap.getRobID(rodId);
 
        if (spareChannels && !(crate > 1 && crate < 6)) {
          continue;
        }
 
        if (muonChannels && !(crate > 1 && crate < 4 && slink == 0)) {
          continue;
        }
 
        robIds.push_back (robId);
      }
    }
  }
  return robIds;
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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.

printCompStats()

void LVL1BS::PpmByteStreamV1Tool::printCompStats ( ) const

private

Print compression stats.

Definition at line 1071 of file PpmByteStreamV1Tool.cxx.

{
    msg() << "Compression stats format/count: ";
    for (unsigned int i = 0; i < MAXFORMATS; ++i)
    {
        msg() << " " << i << "/" << m_compStats[i];
    }
    msg() << endmsg;
}

printVec()

void LVL1BS::PpmByteStreamV1Tool::printVec ( const std::vector< int > & vec ) const

private

Print a vector.

Definition at line 1289 of file PpmByteStreamV1Tool.cxx.

{
    std::vector<int>::const_iterator pos;
    for (pos = vec.begin(); pos != vec.end(); ++pos)
    {
        if (pos != vec.begin()) msg() << ",";
        msg() << *pos;
    }
    msg() << "/";
}

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

setupTTMaps()

void LVL1BS::PpmByteStreamV1Tool::setupTTMaps ( const TriggerTowerCollection * ttCollection, TriggerTowerMapConst & ttEmMap, TriggerTowerMapConst & ttHadMap, LVL1::TriggerTowerKey & towerKey ) const

private

Set up separate Em and Had trigger tower maps.

Definition at line 1107 of file PpmByteStreamV1Tool.cxx.

{
    using std::accumulate;
 
    ttEmMap.clear();
    ttHadMap.clear();
    TriggerTowerCollection::const_iterator pos  = ttCollection->begin();
    TriggerTowerCollection::const_iterator pose = ttCollection->end();
    for (; pos != pose; ++pos)
    {
        const LVL1::TriggerTower *tt = *pos;
        const unsigned int key = towerKey.ttKey(tt->phi(), tt->eta());
        // Ignore any with zero data
        // EM
        if (accumulate((tt->emLUT()).begin(),     (tt->emLUT()).end(),     0) ||
                accumulate((tt->emADC()).begin(),     (tt->emADC()).end(),     0) ||
                accumulate((tt->emBCIDvec()).begin(), (tt->emBCIDvec()).end(), 0) ||
                accumulate((tt->emBCIDext()).begin(), (tt->emBCIDext()).end(), 0) ||
                tt->emError())
        {
            ttEmMap.insert(std::make_pair(key, tt));
        }
        // Had
        if (accumulate((tt->hadLUT()).begin(),     (tt->hadLUT()).end(),     0) ||
                accumulate((tt->hadADC()).begin(),     (tt->hadADC()).end(),     0) ||
                accumulate((tt->hadBCIDvec()).begin(), (tt->hadBCIDvec()).end(), 0) ||
                accumulate((tt->hadBCIDext()).begin(), (tt->hadBCIDext()).end(), 0) ||
                tt->hadError())
        {
            ttHadMap.insert(std::make_pair(key, tt));
        }
    }
}

slinkSlices()

bool LVL1BS::PpmByteStreamV1Tool::slinkSlices ( int crate, int module, int modulesPerSlink, int & slicesLut, int & slicesFadc, int & trigLut, int & trigFadc, const TriggerTowerMapConst & ttEmMap, const TriggerTowerMapConst & ttHadMap, LVL1::TriggerTowerKey & towerKey ) const

private

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

Definition at line 1147 of file PpmByteStreamV1Tool.cxx.

{
    int sliceL = -1;
    int sliceF =  m_dfltSlicesFadc;
    int trigL  =  m_dfltSlicesLut / 2;
    int trigF  =  m_dfltSlicesFadc / 2;
    for (int mod = module; mod < module + modulesPerSlink; ++mod)
    {
        for (int chan = 0; chan < s_channels; ++chan)
        {
            double eta = 0.;
            double phi = 0.;
            int layer = 0;
            if (!m_ppmMaps->mapping(crate, mod, chan,
                                    eta, phi, layer)) continue;
            const LVL1::TriggerTower *const tt = findLayerTriggerTower(
                    eta, phi, layer, ttEmMap, ttHadMap,
                    towerKey);
            if ( !tt ) continue;
            if (layer == 0)
            {
                if (sliceL < 0)   // initialise
                {
                    sliceL = (tt->emLUT()).size();
                    sliceF = (tt->emADC()).size();
                    trigL  = tt->emPeak();
                    trigF  = tt->emADCPeak();
                }
                else     // check consistent
                {
                    if ((tt->emLUT()).size() != size_t(sliceL) ||
                            (tt->emADC()).size() != size_t(sliceF) ||
                            tt->emPeak() != trigL || tt->emADCPeak() != trigF)
                    {
                        return false;
                    }
                }
            }
            else
            {
                if (sliceL < 0)
                {
                    sliceL = (tt->hadLUT()).size();
                    sliceF = (tt->hadADC()).size();
                    trigL  = tt->hadPeak();
                    trigF  = tt->hadADCPeak();
                }
                else
                {
                    if ((tt->hadLUT()).size() != size_t(sliceL) ||
                            (tt->hadADC()).size() != size_t(sliceF) ||
                            tt->hadPeak() != trigL || tt->hadADCPeak() != trigF)
                    {
                        return false;
                    }
                }
            }
        }
    }
    if (sliceL < 0) sliceL = m_dfltSlicesLut;
    slicesLut  = sliceL;
    slicesFadc = sliceF;
    trigLut    = trigL;
    trigFadc   = trigF;
    return true;
}

sourceIDs()

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

(

const std::string &

sgKey

)

const

Return reference to vector with all possible Source Identifiers.

Definition at line 1256 of file PpmByteStreamV1Tool.cxx.

{
    // Check if spare channels wanted
    const std::string flag("Spare");
    const std::string::size_type pos = sgKey.find(flag);
    bool spareChannels =
        (pos != std::string::npos && pos == (sgKey.length() - flag.length()));
    // Check if Tile Muon channels wanted
    const std::string flag2("Muon");
    const std::string::size_type pos2 = sgKey.find(flag2);
    bool muonChannels =
        (pos2 != std::string::npos && pos2 == (sgKey.length() - flag2.length()));
 
    if (spareChannels) {
      static const std::vector<uint32_t> sourceIDsSpare =
        makeSourceIDs (true, false);
      return sourceIDsSpare;
    }
 
    if (muonChannels) {
      static const std::vector<uint32_t> sourceIDsMuon =
        makeSourceIDs (false, true);
      return sourceIDsMuon;
    }
 
    static const std::vector<uint32_t> sourceIDs =
      makeSourceIDs (false, false);
    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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

ATLAS_THREAD_SAFE

SG::SlotSpecificObj<SlotData> m_slotData LVL1BS::PpmByteStreamV1Tool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 147 of file PpmByteStreamV1Tool.h.

m_compStats

std::atomic<uint32_t> LVL1BS::PpmByteStreamV1Tool::m_compStats[MAXFORMATS]

private

Definition at line 195 of file PpmByteStreamV1Tool.h.

m_compVers

const int LVL1BS::PpmByteStreamV1Tool::m_compVers

private

Compression version.

Definition at line 162 of file PpmByteStreamV1Tool.h.

m_crateMax

int LVL1BS::PpmByteStreamV1Tool::m_crateMax

private

Property: Maximum crate number when writing out bytestream.

Definition at line 178 of file PpmByteStreamV1Tool.h.

m_crateMin

int LVL1BS::PpmByteStreamV1Tool::m_crateMin

private

Property: Minimum crate number when writing out bytestream.

Definition at line 176 of file PpmByteStreamV1Tool.h.

m_dataFormat

int LVL1BS::PpmByteStreamV1Tool::m_dataFormat

private

Property: Data compression format.

Definition at line 160 of file PpmByteStreamV1Tool.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_dfltSlicesFadc

int LVL1BS::PpmByteStreamV1Tool::m_dfltSlicesFadc

private

Property: Default number of FADC slices in simulation.

Definition at line 170 of file PpmByteStreamV1Tool.h.

m_dfltSlicesLut

int LVL1BS::PpmByteStreamV1Tool::m_dfltSlicesLut

private

Property: Default number of LUT slices in simulation.

Definition at line 168 of file PpmByteStreamV1Tool.h.

m_errorTool

ToolHandle<LVL1BS::L1CaloErrorByteStreamTool> LVL1BS::PpmByteStreamV1Tool::m_errorTool

private

Property: Error collection tool.

Definition at line 153 of file PpmByteStreamV1Tool.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_fadcBaseline

int LVL1BS::PpmByteStreamV1Tool::m_fadcBaseline

private

Property: FADC baseline lower bound.

Definition at line 182 of file PpmByteStreamV1Tool.h.

m_fadcThreshold

int LVL1BS::PpmByteStreamV1Tool::m_fadcThreshold

private

Property: FADC threshold for super-compressed format.

Definition at line 184 of file PpmByteStreamV1Tool.h.

m_forceSlicesFadc

int LVL1BS::PpmByteStreamV1Tool::m_forceSlicesFadc

private

Property: Force number of FADC slices in bytestream.

Definition at line 174 of file PpmByteStreamV1Tool.h.

m_forceSlicesLut

int LVL1BS::PpmByteStreamV1Tool::m_forceSlicesLut

private

Property: Force number of LUT slices in bytestream.

Definition at line 172 of file PpmByteStreamV1Tool.h.

m_pedestal

int LVL1BS::PpmByteStreamV1Tool::m_pedestal

private

Property: Pedestal value.

Definition at line 180 of file PpmByteStreamV1Tool.h.

m_ppmMaps

ToolHandle<LVL1::IL1CaloMappingTool> LVL1BS::PpmByteStreamV1Tool::m_ppmMaps

private

Property: Channel mapping tool.

Definition at line 151 of file PpmByteStreamV1Tool.h.

m_printCompStats

int LVL1BS::PpmByteStreamV1Tool::m_printCompStats

private

Property: Compression statistics print flag.

Definition at line 164 of file PpmByteStreamV1Tool.h.

m_slinks

int LVL1BS::PpmByteStreamV1Tool::m_slinks

private

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

Definition at line 166 of file PpmByteStreamV1Tool.h.

m_sms

ServiceHandle<SegMemSvc> LVL1BS::PpmByteStreamV1Tool::m_sms

private

Memory pool service.

Definition at line 155 of file PpmByteStreamV1Tool.h.

m_sourceIDsProp

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

private

Property: ROB source IDs.

Definition at line 188 of file PpmByteStreamV1Tool.h.

m_srcIdMap

const L1CaloSrcIdMap LVL1BS::PpmByteStreamV1Tool::m_srcIdMap

private

Source ID converter.

Definition at line 192 of file PpmByteStreamV1Tool.h.

m_subDetector

const eformat::SubDetector LVL1BS::PpmByteStreamV1Tool::m_subDetector

private

Sub-detector type.

Definition at line 190 of file PpmByteStreamV1Tool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_version

const int LVL1BS::PpmByteStreamV1Tool::m_version

private

Sub_block header version.

Definition at line 158 of file PpmByteStreamV1Tool.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_zeroSuppress

int LVL1BS::PpmByteStreamV1Tool::m_zeroSuppress

private

Property: Zero suppression on input.

Definition at line 186 of file PpmByteStreamV1Tool.h.

MAXFORMATS

unsigned int LVL1BS::PpmByteStreamV1Tool::MAXFORMATS = 10

staticconstexprprivate

Vector for compression statistics.

Definition at line 194 of file PpmByteStreamV1Tool.h.

s_channels

const int LVL1BS::PpmByteStreamV1Tool::s_channels = 64

staticprivate

Definition at line 199 of file PpmByteStreamV1Tool.h.

s_crates

const int LVL1BS::PpmByteStreamV1Tool::s_crates = 8

staticprivate

Definition at line 197 of file PpmByteStreamV1Tool.h.

s_dataSize

const int LVL1BS::PpmByteStreamV1Tool::s_dataSize = 3584

staticprivate

Definition at line 200 of file PpmByteStreamV1Tool.h.

s_modules

const int LVL1BS::PpmByteStreamV1Tool::s_modules = 16

staticprivate

Definition at line 198 of file PpmByteStreamV1Tool.h.

---

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

• PpmByteStreamV1Tool.h
• PpmByteStreamV1Tool.cxx