LVL1BS::JepByteStreamV2Tool Class Reference

Tool to perform ROB fragments to jet elements, jet hits and energy sums, and JEP container to raw data conversions. More...

#include <JepByteStreamV2Tool.h>

Inheritance diagram for LVL1BS::JepByteStreamV2Tool:

Collaboration diagram for LVL1BS::JepByteStreamV2Tool:

Classes
struct	LocalData
struct	JepByteStreamToolData
struct	JetElementData
struct	EnergySumsData
struct	CmxTobData
struct	CmxHitsData
struct	CmxSumsData

Public Member Functions
	JepByteStreamV2Tool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~JepByteStreamV2Tool ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
StatusCode	convert (const EventContext &ctx, const std::string &name, DataVector< LVL1::JetElement > *jeCollection) const
	Convert ROB fragments to jet elements.
StatusCode	convert (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::JetElement > *jeCollection) const
StatusCode	convert (const EventContext &ctx, const std::string &name, DataVector< LVL1::JEMEtSums > *etCollection) const
	Convert ROB fragments to energy sums.
StatusCode	convert (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::JEMEtSums > *etCollection) const
StatusCode	convert (const EventContext &ctx, const std::string &name, DataVector< LVL1::CMXJetTob > *tobCollection) const
	Convert ROB fragments to CMX TOBs.
StatusCode	convert (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::CMXJetTob > *tobCollection) const
StatusCode	convert (const EventContext &ctx, const std::string &name, DataVector< LVL1::CMXJetHits > *hitCollection) const
	Convert ROB fragments to CMX jet hits.
StatusCode	convert (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::CMXJetHits > *hitCollection) const
StatusCode	convert (const EventContext &ctx, const std::string &name, DataVector< LVL1::CMXEtSums > *etCollection) const
	Convert ROB fragments to CMX energy sums.
StatusCode	convert (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, DataVector< LVL1::CMXEtSums > *etCollection) const
StatusCode	convert (const LVL1::JEPBSCollectionV2 *jep) const
	Convert JEP Container to bytestream.
const std::vector< uint32_t > &	sourceIDs () 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
enum	CollectionType {   JET_ELEMENTS , ENERGY_SUMS , CMX_TOBS , CMX_HITS ,   CMX_SUMS }
typedef DataVector< LVL1::JetElement >	JetElementCollection
typedef DataVector< LVL1::JEMEtSums >	EnergySumsCollection
typedef DataVector< LVL1::CMXJetTob >	CmxTobCollection
typedef DataVector< LVL1::CMXJetHits >	CmxHitsCollection
typedef DataVector< LVL1::CMXEtSums >	CmxSumsCollection
typedef std::map< unsigned int, LVL1::JetElement * >	JetElementMap
typedef std::map< unsigned int, const LVL1::JetElement * >	ConstJetElementMap
typedef std::map< int, LVL1::JEMEtSums * >	EnergySumsMap
typedef std::map< int, const LVL1::JEMEtSums * >	ConstEnergySumsMap
typedef std::map< int, LVL1::CMXJetTob * >	CmxTobMap
typedef std::map< int, const LVL1::CMXJetTob * >	ConstCmxTobMap
typedef std::map< int, LVL1::CMXJetHits * >	CmxHitsMap
typedef std::map< int, const LVL1::CMXJetHits * >	ConstCmxHitsMap
typedef std::map< int, LVL1::CMXEtSums * >	CmxSumsMap
typedef std::map< int, const LVL1::CMXEtSums * >	ConstCmxSumsMap
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
StatusCode	convertBs (const std::string &sgKey, const IROBDataProviderSvc::VROBFRAG &robFrags, JepByteStreamToolData &data) const
	Convert bytestream to given container type.
void	decodeCmxEnergy (CmxEnergySubBlock *subBlock, int trigJem, CmxSumsData &data, LocalData &ld) const
	Unpack CMX-Energy sub-block.
void	decodeCmxJet (CmxJetSubBlock *subBlock, int trigJem, JepByteStreamToolData &data, LocalData &ld) const
	Unpack CMX-Jet sub-block.
void	decodeJem (JemSubBlockV2 *subBlock, int trigJem, JepByteStreamToolData &data, LocalData &ld) const
	Unpack JEM sub-block.
int	tobKey (int crate, int jem, int frame, int loc) const
	Find TOB map key for given crate, jem, frame, loc.
const LVL1::JetElement *	findJetElement (double eta, double phi, const ConstJetElementMap &jeMap, LVL1::JetElementKey &elementKey) const
	Find a jet element given eta, phi.
LVL1::JetElement *	findJetElement (const JetElementData &data, double eta, double phi, LVL1::JetElementKey &elementKey) const
const LVL1::JEMEtSums *	findEnergySums (int crate, int module, const ConstEnergySumsMap &etMap) const
	Find energy sums for given crate, module.
LVL1::JEMEtSums *	findEnergySums (const EnergySumsData &data, int crate, int module) const
const LVL1::CMXJetTob *	findCmxTob (int key, const ConstCmxTobMap &cmxTobMap) const
	Find CMX TOB for given key.
LVL1::CMXJetTob *	findCmxTob (const CmxTobData &data, int key) const
const LVL1::CMXJetHits *	findCmxHits (int crate, int source, const ConstCmxHitsMap &cmxHitsMap) const
	Find CMX hits for given crate, source.
LVL1::CMXJetHits *	findCmxHits (const CmxHitsData &data, int crate, int source) const
const LVL1::CMXEtSums *	findCmxSums (int crate, int source, const ConstCmxSumsMap &cmxEtMap) const
	Find CMX energy sums for given crate, source.
LVL1::CMXEtSums *	findCmxSums (const CmxSumsData &data, int crate, int source) const
std::vector< uint32_t >	makeSourceIDs () const
void	setupJeMap (const JetElementCollection *jeCollection, ConstJetElementMap &jeMap, LVL1::JetElementKey &elementKey) const
	Set up jet element map.
void	setupEtMap (const EnergySumsCollection *enCollection, ConstEnergySumsMap &etMap) const
	Set up energy sums map.
void	setupCmxTobMap (const CmxTobCollection *tobCollection, ConstCmxTobMap &cmxTobMap) const
	Set up CMX TOB map.
void	setupCmxHitsMap (const CmxHitsCollection *hitCollection, ConstCmxHitsMap &cmxHitsMap) const
	Set up CMX hits map.
void	setupCmxEtMap (const CmxSumsCollection *enCollection, ConstCmxSumsMap &cmxEtMap) const
	Set up CMX energy sums map.
bool	slinkSlices (int crate, int module, int modulesPerSlink, int &timeslices, int &trigJem, const ConstJetElementMap &jeMap, const ConstEnergySumsMap &etMap, const ConstCmxTobMap &cmxTobMap, const ConstCmxHitsMap &cmxHitsMap, const ConstCmxSumsMap &cmxEtMap, LVL1::JetElementKey &elementKey) const
	Get number of slices and triggered slice offset for next slink.
void	energySubBlockTypes (int source, CmxEnergySubBlock::SourceType &srcType, CmxEnergySubBlock::SumType &sumType, CmxEnergySubBlock::HitsType &hitType) const
	Get energy subBlock types from CMXEtSums source type.
int	jetSubBlockSourceId (int source) const
	Get jet hits subBlock source ID from CMXJetHits source type.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< bool >	m_enableEncoding
SmartIF< IByteStreamCnvSvc >	m_byteStreamCnvSvc
ServiceHandle< IROBDataProviderSvc >	m_robDataProvider
ToolHandle< LVL1::IL1CaloMappingTool >	m_jemMaps
	Property: Channel mapping tool.
ToolHandle< LVL1BS::L1CaloErrorByteStreamTool >	m_errorTool
	Property:Error collection tool.
int	m_crateOffsetHw
	Property:Hardware crate number offset.
int	m_crateOffsetSw
	Property:Software crate number offset.
int	m_version
	Property:Sub_block header version.
int	m_dataFormat
	Property:Data compression format.
const int	m_channels
	Number of channels per module.
const int	m_crates
	Number of crates.
const int	m_modules
	Number of JEM modules per crate.
const int	m_frames
	Number of RoI frames.
const int	m_locations
	Number of RoI locations.
const int	m_maxTobs
	Maximum number of TOBs per module.
int	m_slinks
	Property: Number of slinks per crate when writing out bytestream.
int	m_dfltSlices
	Property: Default number of slices in simulation.
int	m_forceSlices
	Property: Force number of 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.
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.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Tool to perform ROB fragments to jet elements, jet hits and energy sums, and JEP container to raw data conversions.

Based on ROD document version X_xxx. <<== CHECK

Author

Peter Faulkner

Definition at line 58 of file JepByteStreamV2Tool.h.

Member Typedef Documentation

CmxHitsCollection

typedef DataVector<LVL1::CMXJetHits> LVL1BS::JepByteStreamV2Tool::CmxHitsCollection

private

Definition at line 148 of file JepByteStreamV2Tool.h.

CmxHitsMap

typedef std::map<int, LVL1::CMXJetHits*> LVL1BS::JepByteStreamV2Tool::CmxHitsMap

private

Definition at line 156 of file JepByteStreamV2Tool.h.

CmxSumsCollection

typedef DataVector<LVL1::CMXEtSums> LVL1BS::JepByteStreamV2Tool::CmxSumsCollection

private

Definition at line 149 of file JepByteStreamV2Tool.h.

CmxSumsMap

typedef std::map<int, LVL1::CMXEtSums*> LVL1BS::JepByteStreamV2Tool::CmxSumsMap

private

Definition at line 158 of file JepByteStreamV2Tool.h.

CmxTobCollection

typedef DataVector<LVL1::CMXJetTob> LVL1BS::JepByteStreamV2Tool::CmxTobCollection

private

Definition at line 147 of file JepByteStreamV2Tool.h.

CmxTobMap

typedef std::map<int, LVL1::CMXJetTob*> LVL1BS::JepByteStreamV2Tool::CmxTobMap

private

Definition at line 154 of file JepByteStreamV2Tool.h.

ConstCmxHitsMap

typedef std::map<int, const LVL1::CMXJetHits*> LVL1BS::JepByteStreamV2Tool::ConstCmxHitsMap

private

Definition at line 157 of file JepByteStreamV2Tool.h.

ConstCmxSumsMap

typedef std::map<int, const LVL1::CMXEtSums*> LVL1BS::JepByteStreamV2Tool::ConstCmxSumsMap

private

Definition at line 159 of file JepByteStreamV2Tool.h.

ConstCmxTobMap

typedef std::map<int, const LVL1::CMXJetTob*> LVL1BS::JepByteStreamV2Tool::ConstCmxTobMap

private

Definition at line 155 of file JepByteStreamV2Tool.h.

ConstEnergySumsMap

typedef std::map<int, const LVL1::JEMEtSums*> LVL1BS::JepByteStreamV2Tool::ConstEnergySumsMap

private

Definition at line 153 of file JepByteStreamV2Tool.h.

ConstJetElementMap

typedef std::map<unsigned int, const LVL1::JetElement*> LVL1BS::JepByteStreamV2Tool::ConstJetElementMap

private

Definition at line 151 of file JepByteStreamV2Tool.h.

EnergySumsCollection

typedef DataVector<LVL1::JEMEtSums> LVL1BS::JepByteStreamV2Tool::EnergySumsCollection

private

Definition at line 146 of file JepByteStreamV2Tool.h.

EnergySumsMap

typedef std::map<int, LVL1::JEMEtSums*> LVL1BS::JepByteStreamV2Tool::EnergySumsMap

private

Definition at line 152 of file JepByteStreamV2Tool.h.

JetElementCollection

typedef DataVector<LVL1::JetElement> LVL1BS::JepByteStreamV2Tool::JetElementCollection

private

Definition at line 145 of file JepByteStreamV2Tool.h.

JetElementMap

typedef std::map<unsigned int, LVL1::JetElement*> LVL1BS::JepByteStreamV2Tool::JetElementMap

private

Definition at line 150 of file JepByteStreamV2Tool.h.

ROBIterator

typedef IROBDataProviderSvc::VROBFRAG::const_iterator LVL1BS::JepByteStreamV2Tool::ROBIterator

private

Definition at line 161 of file JepByteStreamV2Tool.h.

ROBPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::JepByteStreamV2Tool::ROBPointer

private

Definition at line 162 of file JepByteStreamV2Tool.h.

RODPointer

typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType LVL1BS::JepByteStreamV2Tool::RODPointer

private

Definition at line 163 of file JepByteStreamV2Tool.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::JepByteStreamV2Tool::CollectionType

private

Enumerator
JET_ELEMENTS
ENERGY_SUMS
CMX_TOBS
CMX_HITS
CMX_SUMS

Definition at line 142 of file JepByteStreamV2Tool.h.

                      { JET_ELEMENTS, ENERGY_SUMS, CMX_TOBS,
                                       CMX_HITS, CMX_SUMS };

Constructor & Destructor Documentation

JepByteStreamV2Tool()

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

Definition at line 53 of file JepByteStreamV2Tool.cxx.

  : AthAlgTool(type, name, parent),
    m_robDataProvider("ROBDataProviderSvc", name),
    m_jemMaps("LVL1::JemMappingTool/JemMappingTool"),
    m_errorTool("LVL1BS::L1CaloErrorByteStreamTool/L1CaloErrorByteStreamTool"),
    m_channels(44), m_crates(2), m_modules(16), m_frames(8), m_locations(4),
    m_maxTobs(4), 
    m_subDetector(eformat::TDAQ_CALO_JET_PROC_DAQ)
{
  declareInterface<JepByteStreamV2Tool>(this);
 
  declareProperty("JemMappingTool", m_jemMaps,
                  "Crate/Module/Channel to Eta/Phi/Layer mapping tool");
  declareProperty("ErrorTool", m_errorTool,
                  "Tool to collect errors for monitoring");
 
  declareProperty("CrateOffsetHw",  m_crateOffsetHw = 12,
                  "Offset of JEP crate numbers in bytestream");
  declareProperty("CrateOffsetSw",  m_crateOffsetSw = 0,
                  "Offset of JEP crate numbers in RDOs");
  declareProperty("SlinksPerCrate", m_slinks        = 4,
                  "The number of S-Links per crate");
 
  // 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("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");
 
}

~JepByteStreamV2Tool()

LVL1BS::JepByteStreamV2Tool::~JepByteStreamV2Tool ( )

virtual

Definition at line 100 of file JepByteStreamV2Tool.cxx.

{
}

Member Function Documentation

convert() [1/11]

StatusCode LVL1BS::JepByteStreamV2Tool::convert	(	const EventContext &	ctx,
		const std::string &	name,
		DataVector< LVL1::CMXEtSums > *	etCollection ) const

Convert ROB fragments to CMX energy sums.

Definition at line 223 of file JepByteStreamV2Tool.cxx.

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

convert() [2/11]

StatusCode LVL1BS::JepByteStreamV2Tool::convert	(	const EventContext &	ctx,
		const std::string &	name,
		DataVector< LVL1::CMXJetHits > *	hitCollection ) const

Convert ROB fragments to CMX jet hits.

Definition at line 199 of file JepByteStreamV2Tool.cxx.

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

convert() [3/11]

StatusCode LVL1BS::JepByteStreamV2Tool::convert	(	const EventContext &	ctx,
		const std::string &	name,
		DataVector< LVL1::CMXJetTob > *	tobCollection ) const

Convert ROB fragments to CMX TOBs.

Definition at line 176 of file JepByteStreamV2Tool.cxx.

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

convert() [4/11]

StatusCode LVL1BS::JepByteStreamV2Tool::convert	(	const EventContext &	ctx,
		const std::string &	name,
		DataVector< LVL1::JEMEtSums > *	etCollection ) const

Convert ROB fragments to energy sums.

Definition at line 153 of file JepByteStreamV2Tool.cxx.

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

convert() [5/11]

StatusCode LVL1BS::JepByteStreamV2Tool::convert	(	const EventContext &	ctx,
		const std::string &	name,
		DataVector< LVL1::JetElement > *	jeCollection ) const

Convert ROB fragments to jet elements.

Definition at line 130 of file JepByteStreamV2Tool.cxx.

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

convert() [6/11]

StatusCode LVL1BS::JepByteStreamV2Tool::convert

(

const LVL1::JEPBSCollectionV2 *

jep

)

const

Convert JEP Container to bytestream.

CMX energy sums map

Definition at line 247 of file JepByteStreamV2Tool.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,
                                                        "JepByteStreamV2") );
  const uint16_t minorVersion = m_srcIdMap.minorVersion();
  fea->setRodMinorVersion(minorVersion);
 
  // Pointer to ROD data vector
 
  FullEventAssembler<L1CaloSrcIdMap>::RODDATA* theROD = 0;
 
  // Jet element key provider
  LVL1::JetElementKey elementKey;
 
  // Set up the container maps
 
  // Jet element map
  ConstJetElementMap jeMap;
  setupJeMap(jep->JetElements(), jeMap, elementKey);
 
  // Energy sums map
  ConstEnergySumsMap etMap;
  setupEtMap(jep->EnergySums(), etMap);
 
  // CMX TOB map
  ConstCmxTobMap cmxTobMap;
  setupCmxTobMap(jep->CmxTobs(), cmxTobMap);
 
  // CMX hits map
  ConstCmxHitsMap cmxHitsMap;
  setupCmxHitsMap(jep->CmxHits(), cmxHitsMap);

  ConstCmxSumsMap cmxEtMap;
  setupCmxEtMap(jep->CmxSums(), cmxEtMap);
 
  // Loop over data
 
  const bool neutralFormat = m_dataFormat == L1CaloSubBlock::NEUTRAL;
  const int modulesPerSlink = m_modules / m_slinks;
  int timeslices       = 1;
  int trigJem          = 0;
  int timeslicesNew    = 1;
  int trigJemNew       = 0;
  for (int crate = m_crateMin; crate <= m_crateMax; ++crate) {
    const int hwCrate = crate + m_crateOffsetHw;
 
    for (int module=0; module < m_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 " << hwCrate
                << " slink " << slink << endmsg;
        }
    // Get number of JEM slices and triggered slice offset
    // for this slink
    if ( ! slinkSlices(crate, module, modulesPerSlink,
                           timeslices, trigJem,
                           jeMap,
                           etMap,
                           cmxTobMap,
                           cmxHitsMap,
                           cmxEtMap,
                           elementKey))
        {
      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;
    trigJemNew    = ModifySlices::peak(trigJem, timeslices, timeslicesNew);
        if (debug) {
      msg() << "Data Version/Format: " << m_version
            << " " << m_dataFormat << endmsg
                << "Slices/offset: " << timeslices << " " << trigJem;
      if (timeslices != timeslicesNew) {
        msg() << " modified to " << timeslicesNew << " " << trigJemNew;
          }
      msg() << endmsg;
        }
        L1CaloUserHeader userHeader;
        userHeader.setJem(trigJemNew);
    const uint32_t rodIdJem = m_srcIdMap.getRodID(hwCrate, slink, daqOrRoi,
                                                            m_subDetector);
    theROD = fea->getRodData(rodIdJem);
    theROD->push_back(userHeader.header());
      }
      if (debug) msg() << "Module " << module << endmsg;
 
      // Create a sub-block for each slice (except Neutral format)
 
      // Vector for current JEM sub-blocks
      DataVector<JemSubBlockV2> jemBlocks;
      for (int slice = 0; slice < timeslicesNew; ++slice) {
        JemSubBlockV2* const subBlock = new JemSubBlockV2();
    subBlock->setJemHeader(m_version, m_dataFormat, slice,
                           hwCrate, module, timeslicesNew);
        jemBlocks.push_back(subBlock);
    if (neutralFormat) break;
      }
 
      // Find jet elements 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_jemMaps->mapping(crate, module, chan, eta, phi, layer)) {
          const LVL1::JetElement* const je = findJetElement(eta, phi, jeMap,
                                                            elementKey);
      if (je ) {
        std::vector<int> emData;
        std::vector<int> hadData;
        std::vector<int> emErrors;
        std::vector<int> hadErrors;
        ModifySlices::data(je->emEnergyVec(),  emData,    timeslicesNew);
        ModifySlices::data(je->hadEnergyVec(), hadData,   timeslicesNew);
        ModifySlices::data(je->emErrorVec(),   emErrors,  timeslicesNew);
        ModifySlices::data(je->hadErrorVec(),  hadErrors, timeslicesNew);
            for (int slice = 0; slice < timeslicesNew; ++slice) {
          const LVL1::DataError emErrBits(emErrors[slice]);
          const LVL1::DataError hadErrBits(hadErrors[slice]);
          const int index = ( neutralFormat ) ? 0 : slice;
              JemSubBlockV2* const subBlock = jemBlocks[index];
          const JemJetElement jetEle(chan, emData[slice], hadData[slice],
                      emErrBits.get(LVL1::DataError::Parity),
                      hadErrBits.get(LVL1::DataError::Parity),
              emErrBits.get(LVL1::DataError::LinkDown) +
             (hadErrBits.get(LVL1::DataError::LinkDown) << 1));
              subBlock->fillJetElement(slice, jetEle);
          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);
          }
        }
          }
        }
      }
 
      // Add energy subsums
 
      const LVL1::JEMEtSums* const et = findEnergySums(crate, module, etMap);
      if (et) {
        std::vector<unsigned int> exVec;
        std::vector<unsigned int> eyVec;
        std::vector<unsigned int> etVec;
    ModifySlices::data(et->ExVec(), exVec, timeslicesNew);
    ModifySlices::data(et->EyVec(), eyVec, timeslicesNew);
    ModifySlices::data(et->EtVec(), etVec, timeslicesNew);
    for (int slice = 0; slice < timeslicesNew; ++slice) {
      const int index = ( neutralFormat ) ? 0 : slice;
      JemSubBlockV2* const subBlock = jemBlocks[index];
      subBlock->setEnergySubsums(slice, exVec[slice], eyVec[slice],
                                                      etVec[slice]);
        }
      }
      
      // Pack and write the sub-blocks
 
      DataVector<JemSubBlockV2>::iterator pos;
      for (pos = jemBlocks.begin(); pos != jemBlocks.end(); ++pos) {
        JemSubBlockV2* const subBlock = *pos;
    if ( !subBlock->pack()) {
      msg(MSG::ERROR) << "JEM sub-block packing failed" << endmsg;
      return StatusCode::FAILURE;
    }
    if (debug) {
      msg() << "JEM sub-block data words: "
            << subBlock->dataWords() << endmsg;
    }
    subBlock->write(theROD);
      }
    }
 
    // Append CMXs to last S-Link of the crate
 
    // Create a sub-block for each slice (except Neutral format)
 
    // Vector for current CMX-Energy sub-blocks
    DataVector<CmxEnergySubBlock> cmxEnergyBlocks;
    // Vector for current CMX-Jet sub-blocks
    DataVector<CmxJetSubBlock> cmxJetBlocks;
 
    const int summing = (crate == m_crates - 1) ? CmxSubBlock::SYSTEM
                                                : CmxSubBlock::CRATE;
    for (int slice = 0; slice < timeslicesNew; ++slice) {
      CmxEnergySubBlock* const enBlock = new CmxEnergySubBlock();
      const int cmxEnergyVersion = 3;                             // <<== CHECK  Make jo property for each sub-block?
      enBlock->setCmxHeader(cmxEnergyVersion, m_dataFormat, slice, hwCrate,
                            summing, CmxSubBlock::CMX_ENERGY,
                CmxSubBlock::LEFT, timeslicesNew);
      cmxEnergyBlocks.push_back(enBlock);
      CmxJetSubBlock* const jetBlock = new CmxJetSubBlock();
      jetBlock->setCmxHeader(m_version, m_dataFormat, slice, hwCrate,
                             summing, CmxSubBlock::CMX_JET,
                 CmxSubBlock::RIGHT, timeslicesNew);
      cmxJetBlocks.push_back(jetBlock);
      if (neutralFormat) break;
    }
 
    // CMX-Energy
 
    int maxSource = static_cast<int>(LVL1::CMXEtSums::MAX_SOURCE);
    for (int source = 0; source < maxSource; ++source) {
      if (source >= m_modules) {
        if (summing == CmxSubBlock::CRATE && 
        source != LVL1::CMXEtSums::LOCAL_STANDARD &&
        source != LVL1::CMXEtSums::LOCAL_RESTRICTED) continue;
      }
      const LVL1::CMXEtSums* const sums = findCmxSums(crate, source, cmxEtMap);
      if ( sums ) {
        std::vector<unsigned int> ex;
        std::vector<unsigned int> ey;
        std::vector<unsigned int> et;
        std::vector<int> exErr;
        std::vector<int> eyErr;
        std::vector<int> etErr;
    ModifySlices::data(sums->ExVec(), ex, timeslicesNew);
    ModifySlices::data(sums->EyVec(), ey, timeslicesNew);
    ModifySlices::data(sums->EtVec(), et, timeslicesNew);
    ModifySlices::data(sums->ExErrorVec(), exErr, timeslicesNew);
    ModifySlices::data(sums->EyErrorVec(), eyErr, timeslicesNew);
    ModifySlices::data(sums->EtErrorVec(), etErr, timeslicesNew);
    for (int slice = 0; slice < timeslicesNew; ++slice) {
      const LVL1::DataError exErrBits(exErr[slice]);
      const LVL1::DataError eyErrBits(eyErr[slice]);
      const LVL1::DataError etErrBits(etErr[slice]);
      int exError = exErrBits.get(LVL1::DataError::Parity) << 1;
      int eyError = eyErrBits.get(LVL1::DataError::Parity) << 1;
      int etError = etErrBits.get(LVL1::DataError::Parity) << 1;
      if (source >= m_modules) {
        exError += exErrBits.get(LVL1::DataError::Overflow);
        eyError += eyErrBits.get(LVL1::DataError::Overflow);
        etError += etErrBits.get(LVL1::DataError::Overflow);
      }
      const int index = ( neutralFormat ) ? 0 : slice;
      CmxEnergySubBlock* const subBlock = cmxEnergyBlocks[index];
      if (source < m_modules) {
        subBlock->setSubsums(slice, source,
                             ex[slice], ey[slice], et[slice],
                 exError, eyError, etError);
          } else {
        CmxEnergySubBlock::SourceType srcType = CmxEnergySubBlock::MAX_SOURCE_TYPE;
        CmxEnergySubBlock::SumType    sumType = CmxEnergySubBlock::MAX_SUM_TYPE;
        CmxEnergySubBlock::HitsType   hitType = CmxEnergySubBlock::MAX_HITS_TYPE;
        energySubBlockTypes(source, srcType, sumType, hitType);
        if (srcType != CmxEnergySubBlock::MAX_SOURCE_TYPE) {
          subBlock->setSubsums(slice, srcType, sumType,
                               ex[slice], ey[slice], et[slice],
                   exError, eyError, etError);
            } else if (hitType != CmxEnergySubBlock::MAX_HITS_TYPE) {
          subBlock->setEtHits(slice, hitType, sumType, et[slice]);
            }
          }
        }
      }
    }
    DataVector<CmxEnergySubBlock>::iterator pos;
    pos = cmxEnergyBlocks.begin();
    for (; pos != cmxEnergyBlocks.end(); ++pos) {
      CmxEnergySubBlock* const subBlock = *pos;
      if ( !subBlock->pack()) {
        msg(MSG::ERROR) << "CMX-Energy sub-block packing failed" << endmsg;
    return StatusCode::FAILURE;
      }
      if (debug) {
    msg() << "CMX-Energy sub-block data words: "
          << subBlock->dataWords() << endmsg;
      }
      subBlock->write(theROD);
    }
 
    // CMX-Jet TOBs
 
    for (int jem = 0; jem < m_modules; ++jem) {
      for (int frame = 0; frame < m_frames; ++frame) {
        for (int loc = 0; loc < m_locations; ++loc) {
      const int key = tobKey(crate, jem, frame, loc);
          const LVL1::CMXJetTob* const ct = findCmxTob(key, cmxTobMap);
          if ( ct ) {
            std::vector<int> energyLarge;
            std::vector<int> energySmall;
            std::vector<int> error;
            std::vector<unsigned int> presence;
            ModifySlices::data(ct->energyLgVec(),    energyLarge, timeslicesNew);
            ModifySlices::data(ct->energySmVec(),    energySmall, 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 err0 = errBits.get(LVL1::DataError::Parity);
              int err1 = errBits.get(LVL1::DataError::ParityPhase0);
              err1 |= (errBits.get(LVL1::DataError::ParityPhase1))<<1;
              err1 |= (errBits.get(LVL1::DataError::ParityPhase2))<<2;
              err1 |= (errBits.get(LVL1::DataError::ParityPhase3))<<3;
              const int index = ( neutralFormat ) ? 0 : slice;
              CmxJetSubBlock* const subBlock = cmxJetBlocks[index];
              subBlock->setTob(slice, jem, frame, loc, energyLarge[slice],
                                                  energySmall[slice], err0);
          subBlock->setParityBits(slice, jem, err1); // for neutral format
              subBlock->setPresenceMap(slice, jem, presence[slice]);
            }
          }
        }
      }
    }
 
    // CMX-Jet Hits
 
    maxSource = static_cast<int>(LVL1::CMXJetHits::MAX_SOURCE);
    for (int source = 0; source < maxSource; ++source) {
      if (summing == CmxSubBlock::CRATE && 
          (source == LVL1::CMXJetHits::REMOTE_MAIN    ||
       source == LVL1::CMXJetHits::TOTAL_MAIN     ||
       source == LVL1::CMXJetHits::REMOTE_FORWARD ||
       source == LVL1::CMXJetHits::TOTAL_FORWARD)) continue;
      int sourceId = jetSubBlockSourceId(source);
      if (sourceId == CmxJetSubBlock::MAX_SOURCE_ID) continue;
      const LVL1::CMXJetHits* const ch = findCmxHits(crate, source, cmxHitsMap);
      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) {
      int error = 0;
      if (source != LVL1::CMXJetHits::TOPO_CHECKSUM &&
          source != LVL1::CMXJetHits::TOPO_OCCUPANCY_MAP &&
          source != LVL1::CMXJetHits::TOPO_OCCUPANCY_COUNTS) {
        const LVL1::DataError errBits0(err0[slice]);
        const LVL1::DataError errBits1(err1[slice]);
        error = (errBits0.get(LVL1::DataError::Overflow) |
                 errBits1.get(LVL1::DataError::Overflow)) << 2;
        if (source == LVL1::CMXJetHits::REMOTE_MAIN ||
            source == LVL1::CMXJetHits::REMOTE_FORWARD) {
          error += (errBits0.get(LVL1::DataError::Parity) +
                   (errBits1.get(LVL1::DataError::Parity) << 1));
        }
      }
      const int index = ( neutralFormat ) ? 0 : slice;
      CmxJetSubBlock* const subBlock = cmxJetBlocks[index];
      subBlock->setHits(slice, sourceId, 0, hits0[slice], error);
      if (source != LVL1::CMXJetHits::TOPO_CHECKSUM &&
          source != LVL1::CMXJetHits::TOPO_OCCUPANCY_MAP) {
        subBlock->setHits(slice, sourceId, 1, hits1[slice], error);
          }
        }
      }
    }
    DataVector<CmxJetSubBlock>::iterator jos;
    jos = cmxJetBlocks.begin();
    for (; jos != cmxJetBlocks.end(); ++jos) {
      CmxJetSubBlock* const subBlock = *jos;
      if ( !subBlock->pack()) {
        msg(MSG::ERROR) << "CMX-Jet sub-block packing failed" << endmsg;
    return StatusCode::FAILURE;
      }
      if (debug) {
    msg() << "CMX-Jet sub-block data words: "
          << subBlock->dataWords() << endmsg;
      }
      subBlock->write(theROD);
    }
  }
 
  return StatusCode::SUCCESS;
}

convert() [7/11]

StatusCode LVL1BS::JepByteStreamV2Tool::convert	(	const std::string &	sgKey,
		const IROBDataProviderSvc::VROBFRAG &	robFrags,
		DataVector< LVL1::CMXEtSums > *	etCollection ) const

Definition at line 236 of file JepByteStreamV2Tool.cxx.

{
  CmxSumsData data (etCollection);
  return convertBs(sgKey, robFrags, data);
}

convert() [8/11]

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

Definition at line 212 of file JepByteStreamV2Tool.cxx.

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

convert() [9/11]

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

Definition at line 189 of file JepByteStreamV2Tool.cxx.

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

convert() [10/11]

StatusCode LVL1BS::JepByteStreamV2Tool::convert	(	const std::string &	sgKey,
		const IROBDataProviderSvc::VROBFRAG &	robFrags,
		DataVector< LVL1::JEMEtSums > *	etCollection ) const

Definition at line 166 of file JepByteStreamV2Tool.cxx.

{
  EnergySumsData data (etCollection);
  return convertBs(sgKey, robFrags, data);
}

convert() [11/11]

StatusCode LVL1BS::JepByteStreamV2Tool::convert	(	const std::string &	sgKey,
		const IROBDataProviderSvc::VROBFRAG &	robFrags,
		DataVector< LVL1::JetElement > *	jeCollection ) const

Definition at line 143 of file JepByteStreamV2Tool.cxx.

{
  JetElementData data (jeCollection);
  return convertBs(sgKey, robFrags, data);
}

convertBs()

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

private

Convert bytestream to given container type.

Definition at line 679 of file JepByteStreamV2Tool.cxx.

{
  LocalData ld;
 
  // Check if overlap jet element channels wanted
  const std::string flag("Overlap");
  const std::string::size_type pos = sgKey.find(flag);
  ld.coreOverlap =
   (pos == std::string::npos || pos != sgKey.length() - flag.length()) ? 0 : 1;
 
  const bool debug = msgLvl(MSG::DEBUG);
  if (debug) msg(MSG::DEBUG);
 
  // JemSubBlock for unpacking
  JemSubBlockV2 jemSubBlock;
  // CmxEnergySubBlock for unpacking
  CmxEnergySubBlock cmxEnergySubBlock;
  // CmxJetSubBlock for unpacking
  CmxJetSubBlock cmxJetSubBlock;
 
  // Loop over ROB fragments
 
  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)    <  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 offsets
    int trigJem = userHeader.jem();
    if (debug) {
      msg() << "Minor format version number: " << MSG::hex
            << minorVersion << MSG::dec << endmsg
            << "JEM triggered slice offset: " << trigJem << 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;
      }
      if (CmxSubBlock::cmxBlock(*payload)) {
        // CMXs
    if (CmxSubBlock::cmxType(*payload) == CmxSubBlock::CMX_JET) {
      cmxJetSubBlock.clear();
          payload = cmxJetSubBlock.read(payload, payloadEnd);
      if (cmxJetSubBlock.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_HITS || data.m_collection == CMX_TOBS) {
        decodeCmxJet(&cmxJetSubBlock, trigJem, data, ld);
        if (ld.rodErr != L1CaloSubBlock::ERROR_NONE) {
          if (debug) msg() << "decodeCmxJet failed" << endmsg;
          break;
        }
          }
        } else if (CmxSubBlock::cmxType(*payload) == CmxSubBlock::CMX_ENERGY) {
      cmxEnergySubBlock.clear();
      payload = cmxEnergySubBlock.read(payload, payloadEnd);
      if (cmxEnergySubBlock.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_SUMS) {
        decodeCmxEnergy(&cmxEnergySubBlock, trigJem, static_cast<CmxSumsData&>(data), ld);
        if (ld.rodErr != L1CaloSubBlock::ERROR_NONE) {
          if (debug) msg() << "decodeCmxEnergy failed" << endmsg;
          break;
        }
          }
    } else {
      if (debug) msg() << "Invalid CMX type in module field" << endmsg;
      ld.rodErr = L1CaloSubBlock::ERROR_MODULE_NUMBER;
      break;
        }
      } else {
        // JEM
    jemSubBlock.clear();
        payload = jemSubBlock.read(payload, payloadEnd);
    if (jemSubBlock.crate() != rodCrate) {
      if (debug) msg() << "Inconsistent crate number in ROD source ID"
                       << endmsg;
      ld.rodErr = L1CaloSubBlock::ERROR_CRATE_NUMBER;
      break;
        }
    if (data.m_collection == JET_ELEMENTS || data.m_collection == ENERGY_SUMS) {
      decodeJem(&jemSubBlock, trigJem, data, ld);
      if (ld.rodErr != L1CaloSubBlock::ERROR_NONE) {
        if (debug) msg() << "decodeJem failed" << endmsg;
        break;
      }
        }
      }
    }
    if (ld.rodErr != L1CaloSubBlock::ERROR_NONE)
                                       m_errorTool->rodError(robid, ld.rodErr);
  }
 
  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());
  }

decodeCmxEnergy()

void LVL1BS::JepByteStreamV2Tool::decodeCmxEnergy ( CmxEnergySubBlock * subBlock, int trigJem, CmxSumsData & data, LocalData & ld ) const

private

Unpack CMX-Energy sub-block.

Definition at line 879 of file JepByteStreamV2Tool.cxx.

{
  const bool debug = msgLvl(MSG::DEBUG);
  if (debug) msg(MSG::DEBUG);
 
  const int hwCrate    = subBlock->crate();
  const int module     = 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-Energy: Crate " << hwCrate
          << "  Module "          << module
      << "  Firmware "        << firmware
      << "  Summing "         << summing
          << "  Total slices "    << timeslices
          << "  Slice "           << sliceNum    << endmsg;
  }
  if (timeslices <= trigJem) {
    if (debug) msg() << "Triggered CMX slice from header "
                     << "inconsistent with number of slices: "
                     << trigJem << ", " << 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-Energy sub-block unpacking failed: " << errMsg << endmsg;
    }
    ld.rodErr = subBlock->unpackErrorCode();
    return;
  }
 
  // Retrieve required data
 
  const bool neutralFormat = subBlock->format() == L1CaloSubBlock::NEUTRAL;
  const int crate     = hwCrate - m_crateOffsetHw;
  const int swCrate   = crate   + m_crateOffsetSw;
  const int maxSource = static_cast<int>(LVL1::CMXEtSums::MAX_SOURCE);
  std::vector<unsigned int>& exVec(ld.uintVec0);
  std::vector<unsigned int>& eyVec(ld.uintVec1);
  std::vector<unsigned int>& etVec(ld.uintVec2);
  std::vector<int>& exErrVec(ld.intVec0);
  std::vector<int>& eyErrVec(ld.intVec1);
  std::vector<int>& etErrVec(ld.intVec2);
  LVL1::DataError derr;
  derr.set(LVL1::DataError::SubStatusWord, subBlock->subStatus());
  const int ssError = derr.error();
  const int sliceBeg = ( neutralFormat ) ? 0          : sliceNum;
  const int sliceEnd = ( neutralFormat ) ? timeslices : sliceNum + 1;
  for (int slice = sliceBeg; slice < sliceEnd; ++slice) {
 
    // Energy sums
 
    for (int source = 0; source < maxSource; ++source) {
      if (source >= m_modules && summing == CmxSubBlock::CRATE && 
      source != LVL1::CMXEtSums::LOCAL_STANDARD &&
      source != LVL1::CMXEtSums::LOCAL_RESTRICTED) continue;
      unsigned int ex = 0;
      unsigned int ey = 0;
      unsigned int et = 0;
      int exErr = 0;
      int eyErr = 0;
      int etErr = 0;
      LVL1::DataError exErrBits(ssError);
      LVL1::DataError eyErrBits(ssError);
      LVL1::DataError etErrBits(ssError);
      if (source < m_modules) {
        ex = subBlock->energy(slice, source, CmxEnergySubBlock::ENERGY_EX);
        ey = subBlock->energy(slice, source, CmxEnergySubBlock::ENERGY_EY);
        et = subBlock->energy(slice, source, CmxEnergySubBlock::ENERGY_ET);
        exErr = subBlock->error(slice, source, CmxEnergySubBlock::ENERGY_EX);
        eyErr = subBlock->error(slice, source, CmxEnergySubBlock::ENERGY_EY);
        etErr = subBlock->error(slice, source, CmxEnergySubBlock::ENERGY_ET);
    exErrBits.set(LVL1::DataError::Parity, exErr >> 1);
    eyErrBits.set(LVL1::DataError::Parity, eyErr >> 1);
    etErrBits.set(LVL1::DataError::Parity, etErr >> 1);
      } else {
    CmxEnergySubBlock::SourceType srcType = CmxEnergySubBlock::MAX_SOURCE_TYPE;
    CmxEnergySubBlock::SumType    sumType = CmxEnergySubBlock::MAX_SUM_TYPE;
    CmxEnergySubBlock::HitsType   hitType = CmxEnergySubBlock::MAX_HITS_TYPE;
    energySubBlockTypes(source, srcType, sumType, hitType);
    if (srcType != CmxEnergySubBlock::MAX_SOURCE_TYPE) {
      ex = subBlock->energy(slice, srcType, sumType, CmxEnergySubBlock::ENERGY_EX);
      ey = subBlock->energy(slice, srcType, sumType, CmxEnergySubBlock::ENERGY_EY);
      et = subBlock->energy(slice, srcType, sumType, CmxEnergySubBlock::ENERGY_ET);
      exErr = subBlock->error(slice, srcType, sumType, CmxEnergySubBlock::ENERGY_EX);
      eyErr = subBlock->error(slice, srcType, sumType, CmxEnergySubBlock::ENERGY_EY);
      etErr = subBlock->error(slice, srcType, sumType, CmxEnergySubBlock::ENERGY_ET);
      exErrBits.set(LVL1::DataError::Overflow, exErr);
      eyErrBits.set(LVL1::DataError::Overflow, eyErr);
      etErrBits.set(LVL1::DataError::Overflow, etErr);
      if (srcType == CmxEnergySubBlock::REMOTE) {
        exErrBits.set(LVL1::DataError::Parity, exErr >> 1);
        eyErrBits.set(LVL1::DataError::Parity, eyErr >> 1);
        etErrBits.set(LVL1::DataError::Parity, etErr >> 1);
          }
        } else if (hitType != CmxEnergySubBlock::MAX_HITS_TYPE) {
      ex = subBlock->hits(slice, hitType, sumType);
      ey = ex;
      et = ex;
        }
      }
      exErr = exErrBits.error();
      eyErr = eyErrBits.error();
      etErr = etErrBits.error();
      if (ex || ey || et || exErr || eyErr || etErr) {
        LVL1::CMXEtSums* sums = findCmxSums(data, crate, source);
    if ( ! sums ) {   // create new CMX energy sums
      exVec.assign(timeslices, 0);
      eyVec.assign(timeslices, 0);
      etVec.assign(timeslices, 0);
      exErrVec.assign(timeslices, 0);
      eyErrVec.assign(timeslices, 0);
      etErrVec.assign(timeslices, 0);
      exVec[slice] = ex;
      eyVec[slice] = ey;
      etVec[slice] = et;
      exErrVec[slice] = exErr;
      eyErrVec[slice] = eyErr;
      etErrVec[slice] = etErr;
      auto sumsp =
            std::make_unique<LVL1::CMXEtSums>(swCrate, source, etVec, exVec, eyVec,
                                              etErrVec, exErrVec, eyErrVec, trigJem);
          const int key = crate*100 + source;
      data.m_cmxEtMap.insert(std::make_pair(key, sumsp.get()));
      data.m_cmxEtCollection->push_back(std::move(sumsp));
        } else {
      exVec = sums->ExVec();
      eyVec = sums->EyVec();
      etVec = sums->EtVec();
      exErrVec = sums->ExErrorVec();
      eyErrVec = sums->EyErrorVec();
      etErrVec = sums->EtErrorVec();
      const int nsl = exVec.size();
      if (timeslices != nsl) {
        if (debug) msg() << "Inconsistent number of slices in sub-blocks"
                         << endmsg;
            ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
        return;
          }
      if (exVec[slice] != 0 || eyVec[slice] != 0 || etVec[slice] != 0 ||
          exErrVec[slice] != 0 || eyErrVec[slice] != 0 ||
              etErrVec[slice] != 0) {
            if (debug) msg() << "Duplicate data for slice " << slice << endmsg;
        ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
        return;
          }
      exVec[slice] = ex;
      eyVec[slice] = ey;
      etVec[slice] = et;
      exErrVec[slice] = exErr;
      eyErrVec[slice] = eyErr;
      etErrVec[slice] = etErr;
      sums->addEx(exVec, exErrVec);
      sums->addEy(eyVec, eyErrVec);
      sums->addEt(etVec, etErrVec);
        }
      }
    }
  }
  
  return;
}

decodeCmxJet()

void LVL1BS::JepByteStreamV2Tool::decodeCmxJet ( CmxJetSubBlock * subBlock, int trigJem, JepByteStreamToolData & data, LocalData & ld ) const

private

Unpack CMX-Jet sub-block.

Definition at line 1058 of file JepByteStreamV2Tool.cxx.

{
  const bool debug = msgLvl(MSG::DEBUG);
  if (debug) msg(MSG::DEBUG);
 
  const int hwCrate    = subBlock->crate();
  const int module     = 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-Jet: Crate " << hwCrate
          << "  Module "       << module
      << "  Firmware "     << firmware
      << "  Summing "      << summing
          << "  Total slices " << timeslices
          << "  Slice "        << sliceNum    << endmsg;
  }
  if (timeslices <= trigJem) {
    if (debug) msg() << "Triggered CMX slice from header "
                     << "inconsistent with number of slices: "
                     << trigJem << ", " << 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-Jet sub-block unpacking failed: " << errMsg << endmsg;
    }
    ld.rodErr = subBlock->unpackErrorCode();
    return;
  }
 
  // Retrieve required data
 
  const bool neutralFormat = subBlock->format() == L1CaloSubBlock::NEUTRAL;
  const int crate     = hwCrate - m_crateOffsetHw;
  const int swCrate   = crate   + m_crateOffsetSw;
  const int maxSource = static_cast<int>(LVL1::CMXJetHits::MAX_SOURCE);
  std::vector<int>& energyLgVec(ld.intVec0);
  std::vector<int>& energySmVec(ld.intVec1);
  std::vector<int>& errorVec(ld.intVec2);
  std::vector<unsigned int>& presenceMapVec(ld.uintVec0);
  std::vector<unsigned int>& hit0Vec(ld.uintVec0);
  std::vector<unsigned int>& hit1Vec(ld.uintVec1);
  std::vector<int>& err0Vec(ld.intVec0);
  std::vector<int>& err1Vec(ld.intVec1);
  LVL1::DataError derr;
  derr.set(LVL1::DataError::SubStatusWord, subBlock->subStatus());
  const int ssError = derr.error();
  const int sliceBeg = ( neutralFormat ) ? 0          : sliceNum;
  const int sliceEnd = ( neutralFormat ) ? timeslices : sliceNum + 1;
  for (int slice = sliceBeg; slice < sliceEnd; ++slice) {
 
    // Jet TOBs
 
    if (data.m_collection == CMX_TOBS) {
      CmxTobData& tdata = static_cast<CmxTobData&> (data);
 
      for (int jem = 0; jem < m_modules; ++jem) {
        const unsigned int presenceMap = subBlock->presenceMap(slice, jem);
        for (int tob = 0; tob < m_maxTobs; ++tob) {
      const int energyLarge = subBlock->energyLarge(slice, jem, tob);
      const int energySmall = subBlock->energySmall(slice, jem, tob);
      int error = subBlock->tobError(slice, jem, tob);
      if (energyLarge == 0 && energySmall == 0 && error == 0) break;
      const int loc = subBlock->localCoord(slice, jem, tob);
      const int frame = subBlock->frame(slice, jem, tob);
      LVL1::DataError errBits(ssError);
      if (error) {
        errBits.set(LVL1::DataError::Parity, error);
            if (neutralFormat) {
          const int parity = subBlock->parityBits(slice, jem);
          errBits.set(LVL1::DataError::ParityPhase0, parity);
          errBits.set(LVL1::DataError::ParityPhase1, (parity>>1));
          errBits.set(LVL1::DataError::ParityPhase2, (parity>>2));
          errBits.set(LVL1::DataError::ParityPhase3, (parity>>3));
        }
          }
      error = errBits.error();
      const int key = tobKey(crate, jem, frame, loc);
      LVL1::CMXJetTob* tb = findCmxTob(tdata, key);
      if ( ! tb ) { // create new CMX TOB
        energyLgVec.assign(timeslices, 0);
        energySmVec.assign(timeslices, 0);
        errorVec.assign(timeslices, 0);
        presenceMapVec.assign(timeslices, 0);
        energyLgVec[slice] = energyLarge;
        energySmVec[slice] = energySmall;
        errorVec[slice]    = error;
        presenceMapVec[slice] = presenceMap;
        auto tbp =
              std::make_unique<LVL1::CMXJetTob>(swCrate, jem, frame, loc,
                                                energyLgVec, energySmVec, errorVec,
                                                presenceMapVec, trigJem);
        tdata.m_cmxTobMap.insert(std::make_pair(key, tbp.get()));
        tdata.m_cmxTobCollection->push_back(std::move(tbp));
          } else {
        energyLgVec = tb->energyLgVec();
        energySmVec = tb->energySmVec();
        errorVec    = tb->errorVec();
        presenceMapVec = tb->presenceMapVec();
        const int nsl = energyLgVec.size();
        if (timeslices != nsl) {
          if (debug) msg() << "Inconsistent number of slices in sub-blocks"
                           << endmsg;
              ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
          return;
            }
        if (energyLgVec[slice] != 0 || energySmVec[slice] != 0 ||
            errorVec[slice]  != 0 || presenceMapVec[slice] != 0) {
              if (debug) msg() << "Duplicate data for slice " << slice << endmsg;
          ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
          return;
            }
        energyLgVec[slice] = energyLarge;
        energySmVec[slice] = energySmall;
        errorVec[slice]    = error;
        presenceMapVec[slice] = presenceMap;
        tb->addTob(energyLgVec, energySmVec, errorVec, presenceMapVec);
          }
        }
      }
    }
 
    // Jet hit counts and topo info
 
    else if (data.m_collection == CMX_HITS) {
      CmxHitsData& hdata = static_cast<CmxHitsData&> (data);
 
      for (int source = 0; source < maxSource; ++source) {
        if (summing == CmxSubBlock::CRATE && 
            (source == LVL1::CMXJetHits::REMOTE_MAIN    ||
         source == LVL1::CMXJetHits::TOTAL_MAIN     ||
         source == LVL1::CMXJetHits::REMOTE_FORWARD ||
         source == LVL1::CMXJetHits::TOTAL_FORWARD)) continue;
        int sourceId = jetSubBlockSourceId(source);
        if (sourceId == CmxJetSubBlock::MAX_SOURCE_ID) continue;
    const unsigned int hit0 = subBlock->hits(slice, sourceId, 0);
    const unsigned int hit1 = subBlock->hits(slice, sourceId, 1);
    int err0 = subBlock->hitsError(slice, sourceId, 0);
    int err1 = subBlock->hitsError(slice, sourceId, 1);
    LVL1::DataError err0Bits(ssError);
    LVL1::DataError err1Bits(ssError);
    err0Bits.set(LVL1::DataError::Parity, err0);
    err1Bits.set(LVL1::DataError::Parity, err1>>1);
    err0Bits.set(LVL1::DataError::Overflow, err0>>2);
    err1Bits.set(LVL1::DataError::Overflow, err1>>2);
    err0 = err0Bits.error();
    err1 = err1Bits.error();
    if (hit0 || hit1 || err0 || err1) {
          LVL1::CMXJetHits* jh = findCmxHits(hdata, crate, source);
      if ( ! jh ) {   // create new CMX hits
        hit0Vec.assign(timeslices, 0);
        hit1Vec.assign(timeslices, 0);
        err0Vec.assign(timeslices, 0);
        err1Vec.assign(timeslices, 0);
        hit0Vec[slice] = hit0;
        hit1Vec[slice] = hit1;
        err0Vec[slice] = err0;
        err1Vec[slice] = err1;
        auto jhp =
              std::make_unique<LVL1::CMXJetHits>(swCrate, source, hit0Vec, hit1Vec,
                                                 err0Vec, err1Vec, trigJem);
            const int key = crate*100 + source;
        hdata.m_cmxHitsMap.insert(std::make_pair(key, jhp.get()));
        hdata.m_cmxHitCollection->push_back(std::move(jhp));
          } else {
        hit0Vec = jh->hitsVec0();
        hit1Vec = jh->hitsVec1();
        err0Vec = jh->errorVec0();
        err1Vec = jh->errorVec1();
        const int nsl = hit0Vec.size();
        if (timeslices != nsl) {
          if (debug) msg() << "Inconsistent number of slices in sub-blocks"
                           << endmsg;
              ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
          return;
            }
        if (hit0Vec[slice] != 0 || hit1Vec[slice] != 0 ||
            err0Vec[slice] != 0 || err1Vec[slice] != 0) {
          if (debug) msg() << "Duplicate data for slice " << slice << endmsg;
          ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
          return;
            }
        hit0Vec[slice] = hit0;
        hit1Vec[slice] = hit1;
        err0Vec[slice] = err0;
        err1Vec[slice] = err1;
        jh->addHits(hit0Vec, hit1Vec, err0Vec, err1Vec);
          }
        }
      }
    }
  }
  
  return;
}

decodeJem()

void LVL1BS::JepByteStreamV2Tool::decodeJem ( JemSubBlockV2 * subBlock, int trigJem, JepByteStreamToolData & data, LocalData & ld ) const

private

Unpack JEM sub-block.

Definition at line 1270 of file JepByteStreamV2Tool.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() << "JEM: Crate "     << hwCrate
          << "  Module "       << module
          << "  Total slices " << timeslices
          << "  Slice "        << sliceNum    << endmsg;
  }
  if (timeslices <= trigJem) {
    if (debug) msg() << "Triggered JEM slice from header "
                     << "inconsistent with number of slices: "
                     << trigJem << ", " << 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() << "JEM sub-block unpacking failed: " << errMsg << endmsg;
    }
    ld.rodErr = subBlock->unpackErrorCode();
    return;
  }
 
  // Retrieve required data
 
  const bool neutralFormat = subBlock->format() == L1CaloSubBlock::NEUTRAL;
  const int crate    = hwCrate - m_crateOffsetHw;
  const int swCrate  = crate   + m_crateOffsetSw;
  std::vector<unsigned int>& exVec(ld.uintVec0);
  std::vector<unsigned int>& eyVec(ld.uintVec1);
  std::vector<unsigned int>& etVec(ld.uintVec2);
  LVL1::DataError derr;
  derr.set(LVL1::DataError::SubStatusWord, subBlock->subStatus());
  const int ssError = derr.error();
  std::vector<int> dummy(timeslices);
  const int sliceBeg = ( neutralFormat ) ? 0          : sliceNum;
  const int sliceEnd = ( neutralFormat ) ? timeslices : sliceNum + 1;
  for (int slice = sliceBeg; slice < sliceEnd; ++slice) {
 
    if (data.m_collection == JET_ELEMENTS) {
      JetElementData& jedata = static_cast<JetElementData&> (data);
 
      // Loop over jet element channels and fill jet elements
 
      for (int chan = 0; chan < m_channels; ++chan) {
        const JemJetElement jetEle(subBlock->jetElement(slice, chan));
        if (jetEle.data() || ssError) {
      double eta = 0.;
      double phi = 0.;
      int layer = 0;
      if (m_jemMaps->mapping(crate, module, chan, eta, phi, layer)) {
        if (layer == ld.coreOverlap) {
          LVL1::JetElement* je = findJetElement(jedata, eta, phi,
                                                    ld.elementKey);
          if ( ! je ) {   // create new jet element
            const unsigned int key = ld.elementKey.jeKey(phi, eta);
                auto jep =
                  std::make_unique<LVL1::JetElement>(phi, eta, dummy, dummy, key,
                                                     dummy, dummy, dummy, trigJem);
                je = jep.get();
            jedata.m_jeMap.insert(std::make_pair(key, jep.get()));
            jedata.m_jeCollection->push_back(std::move(jep));
              } else {
            const std::vector<int>& emEnergy(je->emEnergyVec());
        const std::vector<int>& hadEnergy(je->hadEnergyVec());
        const std::vector<int>& emError(je->emErrorVec());
        const std::vector<int>& hadError(je->hadErrorVec());
        const int nsl = emEnergy.size();
        if (timeslices != nsl) {
          if (debug) {
            msg() << "Inconsistent number of slices in sub-blocks"
                  << endmsg;
                  }
          ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
          return;
                }
        if (emEnergy[slice] != 0 || hadEnergy[slice] != 0 ||
            emError[slice]  != 0 || hadError[slice]  != 0) {
                  if (debug) msg() << "Duplicate data for slice "
                           << slice << endmsg;
                  ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
          return;
                }
              }
          LVL1::DataError emErrBits(ssError);
          LVL1::DataError hadErrBits(ssError);
          const int linkError = jetEle.linkError();
          emErrBits.set(LVL1::DataError::Parity, jetEle.emParity());
          emErrBits.set(LVL1::DataError::LinkDown, linkError);
          hadErrBits.set(LVL1::DataError::Parity, jetEle.hadParity());
          hadErrBits.set(LVL1::DataError::LinkDown, linkError >> 1);
          je->addSlice(slice, jetEle.emData(), jetEle.hadData(),
                              emErrBits.error(), hadErrBits.error(),
                          linkError);
        }
          } else if (verbose && jetEle.data()) {
        msg(MSG::VERBOSE) << "Non-zero data but no channel mapping for channel "
                          << chan << endmsg;
        msg(MSG::DEBUG);
          }
        } else if (verbose) {
      msg(MSG::VERBOSE) << "No jet element data for channel "
                        << chan << " slice " << slice << endmsg;
      msg(MSG::DEBUG);
        }
      }
    } else if (data.m_collection == ENERGY_SUMS) {
      EnergySumsData& sumdata = static_cast<EnergySumsData&> (data);
 
      // Get energy subsums
 
      const unsigned int ex = subBlock->ex(slice);
      const unsigned int ey = subBlock->ey(slice);
      const unsigned int et = subBlock->et(slice);
      if (ex | ey | et) {
    LVL1::JEMEtSums* sums = findEnergySums(sumdata, crate, module);
    if ( ! sums ) {   // create new energy sums
      exVec.assign(timeslices, 0);
      eyVec.assign(timeslices, 0);
      etVec.assign(timeslices, 0);
      exVec[slice] = ex;
      eyVec[slice] = ey;
      etVec[slice] = et;
      auto sumsp =
            std::make_unique<LVL1::JEMEtSums>(swCrate, module, etVec, exVec, eyVec,
                                              trigJem);
          sumdata.m_etMap.insert(std::make_pair(crate*m_modules+module, sumsp.get()));
      sumdata.m_etCollection->push_back(std::move(sumsp));
        } else {
      exVec = sums->ExVec();
      eyVec = sums->EyVec();
      etVec = sums->EtVec();
      const int nsl = exVec.size();
      if (timeslices != nsl) {
        if (debug) {
          msg() << "Inconsistent number of slices in sub-blocks"
                << endmsg;
        }
            ld.rodErr = L1CaloSubBlock::ERROR_SLICES;
        return;
          }
      if (exVec[slice] != 0 || eyVec[slice] != 0 || etVec[slice] != 0) {
        if (debug) msg() << "Duplicate data for slice "
                         << slice << endmsg;
            ld.rodErr = L1CaloSubBlock::ERROR_DUPLICATE_DATA;
        return;
          }
      exVec[slice] = ex;
      eyVec[slice] = ey;
      etVec[slice] = et;
      sums->addEx(exVec);
      sums->addEy(eyVec);
      sums->addEt(etVec);
        }
      } else if (verbose) {
        msg(MSG::VERBOSE) << "No energy sums data for crate/module/slice "
                          << hwCrate << "/" << module << "/" << 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; }

energySubBlockTypes()

void LVL1BS::JepByteStreamV2Tool::energySubBlockTypes ( int source, CmxEnergySubBlock::SourceType & srcType, CmxEnergySubBlock::SumType & sumType, CmxEnergySubBlock::HitsType & hitType ) const

private

Get energy subBlock types from CMXEtSums source type.

Definition at line 1846 of file JepByteStreamV2Tool.cxx.

{
  switch (source) {
    case LVL1::CMXEtSums::REMOTE_STANDARD:
      srcType = CmxEnergySubBlock::REMOTE;
      sumType = CmxEnergySubBlock::STANDARD;
      break;
    case LVL1::CMXEtSums::REMOTE_RESTRICTED:
      srcType = CmxEnergySubBlock::REMOTE;
      sumType = CmxEnergySubBlock::RESTRICTED_WEIGHTED;
      break;
    case LVL1::CMXEtSums::LOCAL_STANDARD:
      srcType = CmxEnergySubBlock::LOCAL;
      sumType = CmxEnergySubBlock::STANDARD;
      break;
    case LVL1::CMXEtSums::LOCAL_RESTRICTED:
      srcType = CmxEnergySubBlock::LOCAL;
      sumType = CmxEnergySubBlock::RESTRICTED_WEIGHTED;
      break;
    case LVL1::CMXEtSums::TOTAL_STANDARD:
      srcType = CmxEnergySubBlock::TOTAL;
      sumType = CmxEnergySubBlock::STANDARD;
      break;
    case LVL1::CMXEtSums::TOTAL_RESTRICTED:
      srcType = CmxEnergySubBlock::TOTAL;
      sumType = CmxEnergySubBlock::RESTRICTED_WEIGHTED;
      break;
    case LVL1::CMXEtSums::SUM_ET_STANDARD:
      hitType = CmxEnergySubBlock::SUM_ET;
      sumType = CmxEnergySubBlock::STANDARD;
      break;
    case LVL1::CMXEtSums::SUM_ET_RESTRICTED:
      hitType = CmxEnergySubBlock::SUM_ET;
      sumType = CmxEnergySubBlock::RESTRICTED_WEIGHTED;
      break;
    case LVL1::CMXEtSums::MISSING_ET_STANDARD:
      hitType = CmxEnergySubBlock::MISSING_ET;
      sumType = CmxEnergySubBlock::STANDARD;
      break;
    case LVL1::CMXEtSums::MISSING_ET_RESTRICTED:
      hitType = CmxEnergySubBlock::MISSING_ET;
      sumType = CmxEnergySubBlock::RESTRICTED_WEIGHTED;
      break;
    case LVL1::CMXEtSums::MISSING_ET_SIG_STANDARD:
      hitType = CmxEnergySubBlock::MISSING_ET_SIG;
      sumType = CmxEnergySubBlock::STANDARD;
      break;
    default:
      break;
  }
}

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::JepByteStreamV2Tool::finalize ( )

overridevirtual

Definition at line 123 of file JepByteStreamV2Tool.cxx.

{
  return StatusCode::SUCCESS;
}

findCmxHits() [1/2]

LVL1::CMXJetHits * LVL1BS::JepByteStreamV2Tool::findCmxHits ( const CmxHitsData & data, int crate, int source ) const

private

Definition at line 1538 of file JepByteStreamV2Tool.cxx.

{
  CmxHitsMap::const_iterator mapIter = data.m_cmxHitsMap.find(crate*100 + source);
  if (mapIter != data.m_cmxHitsMap.end()) return mapIter->second;
  return nullptr;
}

findCmxHits() [2/2]

const LVL1::CMXJetHits * LVL1BS::JepByteStreamV2Tool::findCmxHits ( int crate, int source, const ConstCmxHitsMap & cmxHitsMap ) const

private

Find CMX hits for given crate, source.

Definition at line 1529 of file JepByteStreamV2Tool.cxx.

{
  ConstCmxHitsMap::const_iterator mapIter = cmxHitsMap.find(crate*100 + source);
  if (mapIter != cmxHitsMap.end()) return mapIter->second;
  return nullptr;
}

findCmxSums() [1/2]

LVL1::CMXEtSums * LVL1BS::JepByteStreamV2Tool::findCmxSums ( const CmxSumsData & data, int crate, int source ) const

private

Definition at line 1559 of file JepByteStreamV2Tool.cxx.

{
  CmxSumsMap::const_iterator mapIter = data.m_cmxEtMap.find(crate*100 + source);
  if (mapIter != data.m_cmxEtMap.end()) return mapIter->second;
  return nullptr;
}

findCmxSums() [2/2]

const LVL1::CMXEtSums * LVL1BS::JepByteStreamV2Tool::findCmxSums ( int crate, int source, const ConstCmxSumsMap & cmxEtMap ) const

private

Find CMX energy sums for given crate, source.

Definition at line 1550 of file JepByteStreamV2Tool.cxx.

{
  ConstCmxSumsMap::const_iterator mapIter = cmxEtMap.find(crate*100 + source);
  if (mapIter != cmxEtMap.end()) return mapIter->second;
  return nullptr;
}

findCmxTob() [1/2]

LVL1::CMXJetTob * LVL1BS::JepByteStreamV2Tool::findCmxTob ( const CmxTobData & data, int key ) const

private

Definition at line 1518 of file JepByteStreamV2Tool.cxx.

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

findCmxTob() [2/2]

const LVL1::CMXJetTob * LVL1BS::JepByteStreamV2Tool::findCmxTob ( int key, const ConstCmxTobMap & cmxTobMap ) const

private

Find CMX TOB for given key.

Definition at line 1510 of file JepByteStreamV2Tool.cxx.

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

findEnergySums() [1/2]

LVL1::JEMEtSums * LVL1BS::JepByteStreamV2Tool::findEnergySums ( const EnergySumsData & data, int crate, int module ) const

private

Definition at line 1498 of file JepByteStreamV2Tool.cxx.

{
  EnergySumsMap::const_iterator mapIter = data.m_etMap.find(crate*m_modules + module);
  if (mapIter != data.m_etMap.end()) return mapIter->second;
  return nullptr;
}

findEnergySums() [2/2]

const LVL1::JEMEtSums * LVL1BS::JepByteStreamV2Tool::findEnergySums ( int crate, int module, const ConstEnergySumsMap & etMap ) const

private

Find energy sums for given crate, module.

Definition at line 1489 of file JepByteStreamV2Tool.cxx.

{
  ConstEnergySumsMap::const_iterator mapIter = etMap.find(crate*m_modules + module);
  if (mapIter != etMap.end()) return mapIter->second;
  return nullptr;
}

findJetElement() [1/2]

LVL1::JetElement * LVL1BS::JepByteStreamV2Tool::findJetElement ( const JetElementData & data, double eta, double phi, LVL1::JetElementKey & elementKey ) const

private

Definition at line 1475 of file JepByteStreamV2Tool.cxx.

{
  const unsigned int key = elementKey.jeKey(phi, eta);
  JetElementMap::const_iterator mapIter = data.m_jeMap.find(key);
  if (mapIter != data.m_jeMap.end()) return mapIter->second;
  return nullptr;
}

findJetElement() [2/2]

const LVL1::JetElement * LVL1BS::JepByteStreamV2Tool::findJetElement ( double eta, double phi, const ConstJetElementMap & jeMap, LVL1::JetElementKey & elementKey ) const

private

Find a jet element given eta, phi.

Definition at line 1464 of file JepByteStreamV2Tool.cxx.

{
  const unsigned int key = elementKey.jeKey(phi, eta);
  ConstJetElementMap::const_iterator mapIter = jeMap.find(key);
  if (mapIter != jeMap.end()) return mapIter->second;
  return nullptr;
}

initialize()

StatusCode LVL1BS::JepByteStreamV2Tool::initialize ( )

overridevirtual

Definition at line 107 of file JepByteStreamV2Tool.cxx.

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

static

AlgTool InterfaceID.

Definition at line 46 of file JepByteStreamV2Tool.cxx.

{
  return IID_IJepByteStreamV2Tool;
}

jetSubBlockSourceId()

int LVL1BS::JepByteStreamV2Tool::jetSubBlockSourceId ( int source ) const

private

Get jet hits subBlock source ID from CMXJetHits source type.

Definition at line 1903 of file JepByteStreamV2Tool.cxx.

{
  int sourceId = CmxJetSubBlock::MAX_SOURCE_ID;
  switch (source) {
    case LVL1::CMXJetHits::REMOTE_MAIN:
      sourceId = CmxJetSubBlock::REMOTE_MAIN;
      break;
    case LVL1::CMXJetHits::LOCAL_MAIN:
      sourceId = CmxJetSubBlock::LOCAL_MAIN;
      break;
    case LVL1::CMXJetHits::TOTAL_MAIN:
      sourceId = CmxJetSubBlock::TOTAL_MAIN;
      break;
    case LVL1::CMXJetHits::REMOTE_FORWARD:
      sourceId = CmxJetSubBlock::REMOTE_FORWARD;
      break;
    case LVL1::CMXJetHits::LOCAL_FORWARD:
      sourceId = CmxJetSubBlock::LOCAL_FORWARD;
      break;
    case LVL1::CMXJetHits::TOTAL_FORWARD:
      sourceId = CmxJetSubBlock::TOTAL_FORWARD;
      break;
    case LVL1::CMXJetHits::TOPO_CHECKSUM:
      sourceId = CmxJetSubBlock::TOPO_CHECKSUM;
      break;
    case LVL1::CMXJetHits::TOPO_OCCUPANCY_MAP:
      sourceId = CmxJetSubBlock::TOPO_OCCUPANCY_MAP;
      break;
    case LVL1::CMXJetHits::TOPO_OCCUPANCY_COUNTS:
      sourceId = CmxJetSubBlock::TOPO_OCCUPANCY_COUNTS;
      break;
    default:
      break;
  }
  return sourceId;
}

makeSourceIDs()

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

private

Definition at line 646 of file JepByteStreamV2Tool.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()

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.

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

setupCmxEtMap()

void LVL1BS::JepByteStreamV2Tool::setupCmxEtMap ( const CmxSumsCollection * enCollection, ConstCmxSumsMap & cmxEtMap ) const

private

Set up CMX energy sums map.

Definition at line 1649 of file JepByteStreamV2Tool.cxx.

{
  cmxEtMap.clear();
  if (etCollection) {
    CmxSumsCollection::const_iterator pos  = etCollection->begin();
    CmxSumsCollection::const_iterator pose = etCollection->end();
    for (; pos != pose; ++pos) {
      const LVL1::CMXEtSums* const sums = *pos;
      const int crate = sums->crate() - m_crateOffsetSw;
      const int key   = crate*100 + sums->source();
      cmxEtMap.insert(std::make_pair(key, sums));
    }
  }
}

setupCmxHitsMap()

void LVL1BS::JepByteStreamV2Tool::setupCmxHitsMap ( const CmxHitsCollection * hitCollection, ConstCmxHitsMap & cmxHitsMap ) const

private

Set up CMX hits map.

Definition at line 1630 of file JepByteStreamV2Tool.cxx.

{
  cmxHitsMap.clear();
  if (hitCollection) {
    CmxHitsCollection::const_iterator pos  = hitCollection->begin();
    CmxHitsCollection::const_iterator pose = hitCollection->end();
    for (; pos != pose; ++pos) {
      const LVL1::CMXJetHits* const hits = *pos;
      const int crate = hits->crate() - m_crateOffsetSw;
      const int key   = crate*100 + hits->source();
      cmxHitsMap.insert(std::make_pair(key, hits));
    }
  }
}

setupCmxTobMap()

void LVL1BS::JepByteStreamV2Tool::setupCmxTobMap ( const CmxTobCollection * tobCollection, ConstCmxTobMap & cmxTobMap ) const

private

Set up CMX TOB map.

Definition at line 1608 of file JepByteStreamV2Tool.cxx.

{
  cmxTobMap.clear();
  if (tobCollection) {
    CmxTobCollection::const_iterator pos  = tobCollection->begin();
    CmxTobCollection::const_iterator pose = tobCollection->end();
    for (; pos != pose; ++pos) {
      const LVL1::CMXJetTob* const tob = *pos;
      const int crate = tob->crate() - m_crateOffsetSw;
      const int jem   = tob->jem();
      const int frame = tob->frame();
      const int loc   = tob->location();
      const int key   = tobKey(crate, jem, frame, loc);
      cmxTobMap.insert(std::make_pair(key, tob));
    }
  }
}

setupEtMap()

void LVL1BS::JepByteStreamV2Tool::setupEtMap ( const EnergySumsCollection * enCollection, ConstEnergySumsMap & etMap ) const

private

Set up energy sums map.

Definition at line 1589 of file JepByteStreamV2Tool.cxx.

{
  etMap.clear();
  if (etCollection) {
    EnergySumsCollection::const_iterator pos  = etCollection->begin();
    EnergySumsCollection::const_iterator pose = etCollection->end();
    for (; pos != pose; ++pos) {
      const LVL1::JEMEtSums* const sums = *pos;
      const int crate = sums->crate() - m_crateOffsetSw;
      const int key   = m_modules * crate + sums->module();
      etMap.insert(std::make_pair(key, sums));
    }
  }
}

setupJeMap()

void LVL1BS::JepByteStreamV2Tool::setupJeMap ( const JetElementCollection * jeCollection, ConstJetElementMap & jeMap, LVL1::JetElementKey & elementKey ) const

private

Set up jet element map.

Definition at line 1570 of file JepByteStreamV2Tool.cxx.

{
  jeMap.clear();
  if (jeCollection) {
    JetElementCollection::const_iterator pos  = jeCollection->begin();
    JetElementCollection::const_iterator pose = jeCollection->end();
    for (; pos != pose; ++pos) {
      const LVL1::JetElement* const je = *pos;
      const unsigned int key = elementKey.jeKey(je->phi(), je->eta());
      jeMap.insert(std::make_pair(key, je));
    }
  }
}

slinkSlices()

bool LVL1BS::JepByteStreamV2Tool::slinkSlices ( int crate, int module, int modulesPerSlink, int & timeslices, int & trigJem, const ConstJetElementMap & jeMap, const ConstEnergySumsMap & etMap, const ConstCmxTobMap & cmxTobMap, const ConstCmxHitsMap & cmxHitsMap, const ConstCmxSumsMap & cmxEtMap, LVL1::JetElementKey & elementKey ) const

private

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

Definition at line 1668 of file JepByteStreamV2Tool.cxx.

{
  int slices = -1;
  int trigJ  = 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_jemMaps->mapping(crate, mod, chan, eta, phi, layer)) continue;
      const LVL1::JetElement* const je = findJetElement(eta, phi, jeMap,
                                                        elementKey);
      if ( !je ) continue;
      const int numdat = 5;
      std::vector<int> sums(numdat);
      std::vector<int> sizes(numdat);
      sums[0] = std::accumulate((je->emEnergyVec()).begin(),
                                (je->emEnergyVec()).end(), 0);
      sums[1] = std::accumulate((je->hadEnergyVec()).begin(),
                                (je->hadEnergyVec()).end(), 0);
      sums[2] = std::accumulate((je->emErrorVec()).begin(),
                                (je->emErrorVec()).end(), 0);
      sums[3] = std::accumulate((je->hadErrorVec()).begin(),
                                (je->hadErrorVec()).end(), 0);
      sums[4] = std::accumulate((je->linkErrorVec()).begin(),
                                (je->linkErrorVec()).end(), 0);
      sizes[0] = (je->emEnergyVec()).size();
      sizes[1] = (je->hadEnergyVec()).size();
      sizes[2] = (je->emErrorVec()).size();
      sizes[3] = (je->hadErrorVec()).size();
      sizes[4] = (je->linkErrorVec()).size();
      const int peak = je->peak();
      for (int i = 0; i < numdat; ++i) {
        if (sums[i] == 0) continue;
        if (slices < 0) {
      slices = sizes[i];
      trigJ  = peak;
    } else if (slices != sizes[i] || trigJ != peak) return false;
      }
    }
    const LVL1::JEMEtSums* const et = findEnergySums(crate, mod, etMap);
    if (et) {
      const int numdat = 3;
      std::vector<unsigned int> sums(numdat);
      std::vector<int> sizes(numdat);
      sums[0] = std::accumulate((et->ExVec()).begin(),
                                (et->ExVec()).end(), 0);
      sums[1] = std::accumulate((et->EyVec()).begin(),
                                (et->EyVec()).end(), 0);
      sums[2] = std::accumulate((et->EtVec()).begin(),
                                (et->EtVec()).end(), 0);
      sizes[0] = (et->ExVec()).size();
      sizes[1] = (et->EyVec()).size();
      sizes[2] = (et->EtVec()).size();
      const int peak = et->peak();
      for (int i = 0; i < numdat; ++i) {
        if (sums[i] == 0) continue;
    if (slices < 0) {
      slices = sizes[i];
      trigJ  = peak;
        } else if (slices != sizes[i] || trigJ != peak) return false;
      }
    }
  }
  // CMX last slink of crate
  if (module/modulesPerSlink == m_slinks - 1) {
    for (int jem = module; jem < module + modulesPerSlink; ++jem) {
      for (int frame = 0; frame < m_frames; ++frame) {
        for (int loc = 0; loc < m_locations; ++loc) {
      const int key = tobKey(crate, jem, frame, loc);
      const LVL1::CMXJetTob* tob = findCmxTob(key, cmxTobMap);
      if (tob) {
        const int numdat = 4;
            std::vector<int> sums(numdat);
            std::vector<int> sizes(numdat);
        sums[0] = std::accumulate((tob->energyLgVec()).begin(),
                                  (tob->energyLgVec()).end(), 0);
        sums[1] = std::accumulate((tob->energySmVec()).begin(),
                                  (tob->energySmVec()).end(), 0);
        sums[2] = std::accumulate((tob->errorVec()).begin(),
                                  (tob->errorVec()).end(), 0);
        sums[3] = std::accumulate((tob->presenceMapVec()).begin(),
                                  (tob->presenceMapVec()).end(), 0);
            sizes[0] = (tob->energyLgVec()).size();
            sizes[1] = (tob->energySmVec()).size();
            sizes[2] = (tob->errorVec()).size();
            sizes[3] = (tob->presenceMapVec()).size();
        const int peak = tob->peak();
        for (int i = 0; i < numdat; ++i) {
          if (sums[i] == 0) continue;
              if (slices < 0) {
            slices = sizes[i];
            trigJ  = peak;
              } else if (slices != sizes[i] || trigJ != peak) return false;
        }
          }
        }
      }
    }
    const int maxDataID1 = LVL1::CMXJetHits::MAX_SOURCE;
    const int maxDataID2 = LVL1::CMXEtSums::MAX_SOURCE;
    const int maxDataID  = (maxDataID1 > maxDataID2) ? maxDataID1 : maxDataID2;
    for (int source = 0; source < maxDataID; ++source) {
      const int numdat = 6;
      std::vector<unsigned int> sums(numdat);
      std::vector<int> sizes(numdat);
      const LVL1::CMXJetHits* hits = 0;
      if (source < maxDataID1) hits = findCmxHits(crate, source, cmxHitsMap);
      if (hits) {
        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 < 4; ++i) {
          if (sums[i] == 0) continue;
          if (slices < 0) {
        slices = sizes[i];
        trigJ  = peak;
          } else if (slices != sizes[i] || trigJ != peak) return false;
        }
      }
      const LVL1::CMXEtSums* et = 0;      if (source < maxDataID2) et = findCmxSums(crate, source, cmxEtMap);
      if (et) {
        sums[0] = std::accumulate((et->ExVec()).begin(),
                  (et->ExVec()).end(), 0);
        sums[1] = std::accumulate((et->EyVec()).begin(),
                                  (et->EyVec()).end(), 0);
        sums[2] = std::accumulate((et->EtVec()).begin(),
                                  (et->EtVec()).end(), 0);
        sums[3] = std::accumulate((et->ExErrorVec()).begin(),
                                  (et->ExErrorVec()).end(), 0);
        sums[4] = std::accumulate((et->EyErrorVec()).begin(),
                                  (et->EyErrorVec()).end(), 0);
        sums[5] = std::accumulate((et->EtErrorVec()).begin(),
                                  (et->EtErrorVec()).end(), 0);
        sizes[0] = (et->ExVec()).size();
        sizes[1] = (et->EyVec()).size();
        sizes[2] = (et->EtVec()).size();
        sizes[3] = (et->ExErrorVec()).size();
        sizes[4] = (et->EyErrorVec()).size();
        sizes[5] = (et->EtErrorVec()).size();
        const int peak = et->peak();
        for (int i = 0; i < numdat; ++i) {
          if (sums[i] == 0) continue;
      if (slices < 0) {
        slices = sizes[i];
        trigJ  = peak;
          } else if (slices != sizes[i] || trigJ != peak) return false;
        }
      }
    }
  }
  if (slices < 0) slices = m_dfltSlices;
  timeslices = slices;
  trigJem    = trigJ;
  return true;
}

sourceIDs()

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

(

)

const

Return reference to vector with all possible Source Identifiers.

Definition at line 671 of file JepByteStreamV2Tool.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 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.

tobKey()

int LVL1BS::JepByteStreamV2Tool::tobKey ( int crate, int jem, int frame, int loc ) const

private

Find TOB map key for given crate, jem, frame, loc.

Definition at line 1455 of file JepByteStreamV2Tool.cxx.

{
  return ((((((crate<<4)+jem)<<3)+frame)<<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<IByteStreamCnvSvc> LVL1BS::JepByteStreamV2Tool::m_byteStreamCnvSvc

private

Definition at line 118 of file JepByteStreamV2Tool.h.

m_channels

const int LVL1BS::JepByteStreamV2Tool::m_channels

private

Number of channels per module.

Definition at line 299 of file JepByteStreamV2Tool.h.

m_crateMax

int LVL1BS::JepByteStreamV2Tool::m_crateMax

private

Property: Maximum crate number when writing out bytestream.

Definition at line 319 of file JepByteStreamV2Tool.h.

m_crateMin

int LVL1BS::JepByteStreamV2Tool::m_crateMin

private

Property: Minimum crate number when writing out bytestream.

Definition at line 317 of file JepByteStreamV2Tool.h.

m_crateOffsetHw

int LVL1BS::JepByteStreamV2Tool::m_crateOffsetHw

private

Property:Hardware crate number offset.

Definition at line 291 of file JepByteStreamV2Tool.h.

m_crateOffsetSw

int LVL1BS::JepByteStreamV2Tool::m_crateOffsetSw

private

Property:Software crate number offset.

Definition at line 293 of file JepByteStreamV2Tool.h.

m_crates

const int LVL1BS::JepByteStreamV2Tool::m_crates

private

Number of crates.

Definition at line 301 of file JepByteStreamV2Tool.h.

m_dataFormat

int LVL1BS::JepByteStreamV2Tool::m_dataFormat

private

Property:Data compression format.

Definition at line 297 of file JepByteStreamV2Tool.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::JepByteStreamV2Tool::m_dfltSlices

private

Property: Default number of slices in simulation.

Definition at line 313 of file JepByteStreamV2Tool.h.

m_enableEncoding

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

private

Initial value:

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

Definition at line 116 of file JepByteStreamV2Tool.h.

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

m_errorTool

ToolHandle<LVL1BS::L1CaloErrorByteStreamTool> LVL1BS::JepByteStreamV2Tool::m_errorTool

private

Property:Error collection tool.

Definition at line 288 of file JepByteStreamV2Tool.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::JepByteStreamV2Tool::m_forceSlices

private

Property: Force number of slices in bytestream.

Definition at line 315 of file JepByteStreamV2Tool.h.

m_frames

const int LVL1BS::JepByteStreamV2Tool::m_frames

private

Number of RoI frames.

Definition at line 305 of file JepByteStreamV2Tool.h.

m_jemMaps

ToolHandle<LVL1::IL1CaloMappingTool> LVL1BS::JepByteStreamV2Tool::m_jemMaps

private

Property: Channel mapping tool.

Definition at line 286 of file JepByteStreamV2Tool.h.

m_locations

const int LVL1BS::JepByteStreamV2Tool::m_locations

private

Number of RoI locations.

Definition at line 307 of file JepByteStreamV2Tool.h.

m_maxTobs

const int LVL1BS::JepByteStreamV2Tool::m_maxTobs

private

Maximum number of TOBs per module.

Definition at line 309 of file JepByteStreamV2Tool.h.

m_modules

const int LVL1BS::JepByteStreamV2Tool::m_modules

private

Number of JEM modules per crate.

Definition at line 303 of file JepByteStreamV2Tool.h.

m_robDataProvider

ServiceHandle<IROBDataProviderSvc> LVL1BS::JepByteStreamV2Tool::m_robDataProvider

private

Definition at line 284 of file JepByteStreamV2Tool.h.

m_slinks

int LVL1BS::JepByteStreamV2Tool::m_slinks

private

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

Definition at line 311 of file JepByteStreamV2Tool.h.

m_sourceIDsProp

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

private

Property:ROB source IDs.

Definition at line 321 of file JepByteStreamV2Tool.h.

m_srcIdMap

const L1CaloSrcIdMap LVL1BS::JepByteStreamV2Tool::m_srcIdMap

private

Source ID converter.

Definition at line 325 of file JepByteStreamV2Tool.h.

m_subDetector

const eformat::SubDetector LVL1BS::JepByteStreamV2Tool::m_subDetector

private

Sub-detector type.

Definition at line 323 of file JepByteStreamV2Tool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_version

int LVL1BS::JepByteStreamV2Tool::m_version

private

Property:Sub_block header version.

Definition at line 295 of file JepByteStreamV2Tool.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:

• JepByteStreamV2Tool.h
• JepByteStreamV2Tool.cxx