TileROD_Decoder Class Reference

Decodes the different TileCal ROD subfragment types in bytestream data and fills TileDigitsContainer, TileRawChannelContainer or TileL2Container. More...

#include <TileROD_Decoder.h>

Inheritance diagram for TileROD_Decoder:

Classes
struct	D0CellsHLT

Public Types
enum	TileFragStatus {   ALL_OK =0 , CRC_ERR =1 , ALL_FF =0x10 , ALL_00 =0x20 ,   NO_FRAG =0x40 , NO_ROB =0x80 }
typedef eformat::ROBFragment< const uint32_t * >	ROBData
	convert ROD Data words into either TileCell or TileRawChannel.

Public Member Functions
	TileROD_Decoder (const std::string &type, const std::string &name, const IInterface *parent)
	constructor
virtual	~TileROD_Decoder ()
	destructor
virtual StatusCode	initialize ()
virtual StatusCode	finalize ()
template<class COLLECTION>
void	fillCollection (const ROBData *rob, COLLECTION &v, typename TileROD_Helper::ContainerForCollection< COLLECTION >::type *container=nullptr) const
	This method calls the unpacking methods to decode the ROD data and fills the TileDigitsContainer and/or the TileRawChannelContainer.
uint32_t	fillCollectionHLT (const ROBData *rob, TileCellCollection &v, D0CellsHLT &d0cells, TileCellCollection *MBTS, const TileHid2RESrcID *hid2reHLT) const
void	fillCollectionL2 (const ROBData *rob, TileL2Container &v) const
void	fillCollectionL2ROS (const ROBData *rob, TileL2Container &v) const
void	fillTileLaserObj (const ROBData *rob, TileLaserObject &v) const
void	fillCollection_TileMuRcv_RawChannel (const ROBData *rob, TileRawChannelCollection &v) const
void	fillCollection_TileMuRcv_Digi (const ROBData *rob, TileDigitsCollection &v) const
void	fillContainer_TileMuRcv_Decision (const ROBData *rob, TileMuonReceiverContainer &v) const
void	fillCollection_FELIX_Digi (const ROBData *rob, TileDigitsCollection &v) const
void	setLaserVersion (TileLaserObject &laserObject) const
void	loadRw2Cell (const int section, const std::vector< int > &vec)
void	loadMBTS (std::map< unsigned int, unsigned int > &mapMBTS, int MBTS_channel)
const TileHWID *	getTileHWID () const
const TileFragHash *	hashFunc () const
StatusCode	convert (const RawEvent *re, TileL2Container *L2Cnt) const
StatusCode	convertLaser (const RawEvent *re, TileLaserObject *TileLaserObj) const
StatusCode	convertTMDBDecision (const RawEvent *re, TileMuonReceiverContainer *tileMuRcv) const
void	mergeD0cellsHLT (const D0CellsHLT &d0cells, TileCellCollection &) const
void	loadRw2Pmt (const int section, const std::vector< int > &vec)
void	printErrorCounter (bool printIfNoError)
int	getErrorCounter ()
void	printWarningCounter (bool printIfNoWarning)
int	getWarningCounter ()
const TileHid2RESrcID *	getHid2reHLT ()
const TileHid2RESrcID *	getHid2re ()
void	setUseFrag0 (bool f)
void	setUseFrag1 (bool f)
void	setUseFrag4 (bool f)
void	setUseFrag5Raw (bool f)
void	setUseFrag5Reco (bool f)
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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

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

Private Types
typedef std::vector< TileCell * >	pCellVec
typedef std::vector< TileDigits * >	pDigiVec
typedef std::vector< TileBeamElem * >	pBeamVec
typedef std::vector< TileRawChannel * >	pRwChVec
typedef std::vector< TileFastRawChannel >	FRwChVec
typedef std::vector< std::vector< uint32_t > >	DigitsMetaData_t
typedef std::vector< std::vector< uint32_t > >	RawChannelMetaData_t
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
const uint32_t *	getOFW (int fragId, int unit) const
	getOFW returns Optimal Filtering Weights for Frag5 decoder loaded from COOL for correspondent units.
void	unpack_frag0 (uint32_t version, uint32_t sizeOverhead, DigitsMetaData_t &digitsMetaData, const uint32_t *p, pDigiVec &pDigits, int fragID, int demoType) const
	unpack_frag0 decodes tile subfragment type 0x0.
void	unpack_frag1 (uint32_t version, uint32_t sizeOverhead, DigitsMetaData_t &digitsMetaData, const uint32_t *p, pDigiVec &pDigits, int fragID, int demoType) const
	unpack_frag1 decodes tile subfragment type 0x1.
void	unpack_frag2 (uint32_t version, uint32_t sizeOverhead, const uint32_t *p, pRwChVec &pChannel, int fragID, int demoType) const
	unpack_frag2 decodes tile subfragment type 0x2.
void	unpack_frag3 (uint32_t version, uint32_t sizeOverhead, const uint32_t *p, pRwChVec &pChannel, int fragID, int demoType) const
	unpack_frag3 decodes tile subfragment type 0x3.
void	unpack_frag4 (uint32_t version, uint32_t sizeOverhead, unsigned int unit, RawChannelMetaData_t &rawchannelMetaData, const uint32_t *p, pRwChVec &pChannel, int fragID, int demoType) const
	unpack_frag4 decodes tile subfragment type 0x4.
void	unpack_frag5 (uint32_t version, uint32_t sizeOverhead, unsigned int unit, DigitsMetaData_t &digitsMetaData, const uint32_t *p, pDigiVec &pDigits, pRwChVec &pChannel, int fragID, int demoType) const
	unpack_frag5 decodes tile subfragment type 0x4.
void	unpack_frag6 (uint32_t version, uint32_t sizeOverhead, DigitsMetaData_t &digitsMetaData, const uint32_t *p, pDigiVec &pDigits, int fragID, int demoType) const
	unpack_frag6 decodes tile subfragment type 0x6.
void	unpack_frag3HLT (uint32_t version, uint32_t sizeOverhead, const uint32_t *p, FRwChVec &pChannel, int fragID, int demoType) const
	unpack_frag3HLT decodes tile subfragment type 0x3 for the high level trigger (HLT).
void	unpack_frag2HLT (uint32_t version, uint32_t sizeOverhead, const uint32_t *p, FRwChVec &pChannel, int fragID, int demoType) const
	unpack_frag2HLT decodes tile subfragment type 0x2 for the high level trigger (HLT).
void	unpack_frag4HLT (uint32_t version, uint32_t sizeOverhead, unsigned int unit, const uint32_t *p, FRwChVec &pChannel, int fragID, int demoType) const
	unpack_frag4HLT decodes tile subfragment type 0x4 for the high level trigger (HLT).
void	unpack_frag5HLT (uint32_t version, uint32_t sizeOverhead, unsigned int unit, const uint32_t *p, FRwChVec &pChannel, int fragID, int demoType) const
	unpack_frag5HLT decodes tile subfragment type 0x5 for the high level trigger (HLT).
void	unpack_fragA (uint32_t version, RawChannelMetaData_t &rawchannelMetaData, const uint32_t *p, pRwChVec &pChannel, int fragID, int demoType) const
	unpack_fragA decodes tile subfragment type 0XA.
void	unpack_fragAHLT (uint32_t version, const uint32_t *p, uint16_t rob_bcid, uint16_t &mask, int fragID, int demoType) const
	unpack_fragAHLT decodes tile subfragment type 0XA.
void	unpack_frag10 (uint32_t version, const uint32_t *p, TileL2Container &v, int fragID, int demoType) const
	unpack_frag10 decodes tile subfragment type 0x10.
void	unpack_frag11 (uint32_t version, const uint32_t *p, TileL2Container &v, int fragID, int demoType) const
	unpack_frag11 decodes tile subfragment type 0x11.
void	unpack_frag12 (uint32_t version, const uint32_t *p, TileL2Container &v, int fragID, int demoType) const
	unpack_frag12 decodes tile subfragment type 0x12.
void	unpack_frag13 (uint32_t version, const uint32_t *p, TileL2Container &v, int fragID, int demoType) const
	unpack_frag13 decodes tile subfragment type 0x13.
void	unpack_frag14 (uint32_t version, const uint32_t *p, TileL2Container &v, int fragID, int demoType) const
	unpack_frag14 decodes tile subfragment type 0x14.
void	unpack_frag15 (uint32_t version, const uint32_t *p, TileL2Container &v, int fragID, int demoType) const
	unpack_frag15 decodes tile subfragment type 0x15.
bool	unpack_frag4L2 (uint32_t version, uint32_t sizeOverhead, const uint32_t *p, TileL2Container &v, int fragID, int demoType) const
	unpack_frag4L2 decodes tile subfragment type 0x4 and extract transverse energy from this fragment
bool	unpack_frag5L2 (uint32_t version, const uint32_t *p, TileL2Container &v, int fragID, int demoType) const
	unpack_frag5L2 decodes tile subfragment type 0x5 and extract transverse energy from this fragment
void	unpack_frag16 (uint32_t version, const uint32_t *p, TileLaserObject &v) const
	unpack_frag16 decodes tile subfragment type 0x16 or 0x20.
void	unpack_frag17 (uint32_t version, uint32_t sizeOverhead, const uint32_t *p, TileLaserObject &v) const
	unpack_frag17 decodes tile subfragment type 0x17 or 0x20.
void	unpack_brod (uint32_t version, uint32_t sizeOverhead, const uint32_t *p, pBeamVec &pBeam, int fragID) const
	unpack_brod decodes all ancillary tile subfragments coming from beam ROD at the testbeam or LASTROD in normal ATLAS configuration
void	unpack_frag40 (uint32_t collid, uint32_t version, const uint32_t *p, int size, TileDigitsCollection &coll) const
	unpacking methods dedicated to the TMDB ROD format sub-fragments 0x40 0x41 0x42
void	unpack_frag41 (uint32_t collid, uint32_t version, const uint32_t *p, int size, TileRawChannelCollection &coll) const
void	unpack_frag42 (uint32_t sourceid, uint32_t version, const uint32_t *p, int size, TileMuonReceiverContainer &v) const
void	make_copy (uint32_t bsflags, TileFragHash::TYPE rChType, TileRawChannelUnit::UNIT rChUnit, DigitsMetaData_t &digitsMetaData, RawChannelMetaData_t &rawchannelMetaData, const ROBData *rob, pDigiVec &pDigits, pRwChVec &pChannel, TileBeamElemCollection &v, TileBeamElemContainer *container) const
void	make_copy (uint32_t bsflags, TileFragHash::TYPE rChType, TileRawChannelUnit::UNIT rChUnit, DigitsMetaData_t &digitsMetaData, RawChannelMetaData_t &rawchannelMetaData, const ROBData *rob, pDigiVec &pDigits, pRwChVec &pChannel, TileDigitsCollection &v, TileDigitsContainer *container) const
void	make_copy (uint32_t bsflags, TileFragHash::TYPE rChType, TileRawChannelUnit::UNIT rChUnit, DigitsMetaData_t &digitsMetaData, RawChannelMetaData_t &rawchannelMetaData, const ROBData *rob, pDigiVec &pDigits, pRwChVec &pChannel, TileRawChannelCollection &v, TileRawChannelContainer *container) const
uint32_t	make_copyHLT (bool of2, TileRawChannelUnit::UNIT rChUnit, bool correctAmplitude, const FRwChVec &pChannel, TileCellCollection &v, const uint16_t DQuality, D0CellsHLT &d0cells, TileCellCollection *MBTS) const
std::vector< uint32_t >	get_correct_data (const uint32_t *p) const
void	make_copy (const ROBData *rob, pBeamVec &pBeam, TileBeamElemCollection &v) const
void	make_copy (const ROBData *rob, pBeamVec &pBeam, TileDigitsCollection &v) const
void	make_copy (const ROBData *rob, pBeamVec &pBeam, TileRawChannelCollection &v) const
void	make_copy (const ROBData *rob, pBeamVec &pBeam, TileCellCollection &v) const
template<typename ELEMENT>
void	delete_vec (std::vector< ELEMENT * > &v) const
template<typename ELEMENT, class COLLECTION>
void	copy_vec (std::vector< ELEMENT * > &v, COLLECTION &coll) const
bool	checkBit (const uint32_t *p, int chan) const
	check the bitmap for a channel
void	updateAmpThreshold (int run=-1)
void	initHid2re ()
void	initHid2reHLT ()
const uint32_t *	get_data (const ROBData *rob) const
uint32_t	data_size (const ROBData *rob, uint32_t &error) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
TileRawChannel2Bytes5	m_rc2bytes5
TileRawChannel2Bytes4	m_rc2bytes4
TileRawChannel2Bytes2	m_rc2bytes2
TileRawChannel2Bytes	m_rc2bytes
TileDigits2Bytes	m_d2Bytes
const TileHWID *	m_tileHWID = nullptr
Gaudi::Property< bool >	m_useFrag0 {this, "useFrag0", true, "Use frag0"}
Gaudi::Property< bool >	m_useFrag1 {this, "useFrag1", true, "Use frag1"}
Gaudi::Property< bool >	m_useFrag4 {this, "useFrag4", true, "User frag4"}
Gaudi::Property< bool >	m_useFrag5Raw {this, "useFrag5Raw", false, "Use frag5 raw"}
Gaudi::Property< bool >	m_useFrag5Reco {this, "useFrag5Reco", false, "Use frag5 reco"}
Gaudi::Property< bool >	m_ignoreFrag4HLT {this, "ignoreFrag4HLT", false, "Ignore frag4 HLT"}
Gaudi::Property< float >	m_allowedTimeMin
Gaudi::Property< float >	m_allowedTimeMax
Gaudi::Property< float >	m_ampMinThresh
Gaudi::Property< float >	m_timeMinThresh
Gaudi::Property< float >	m_timeMaxThresh
Gaudi::Property< unsigned int >	m_fullTileRODs
Gaudi::Property< std::vector< int > >	m_demoFragIDs
Gaudi::Property< bool >	m_verbose {this, "VerboseOutput", false, "Print extra information"}
Gaudi::Property< bool >	m_calibrateEnergy {this, "calibrateEnergy", true, "Convert ADC counts to pCb for RawChannels"}
Gaudi::Property< bool >	m_suppressDummyFragments {this, "suppressDummyFragments", false, "Suppress dummy fragments"}
Gaudi::Property< bool >	m_maskBadDigits
Gaudi::Property< int >	m_maxWarningPrint {this, "MaxWarningPrint", 1000, "Maximum warning messages to print"}
Gaudi::Property< int >	m_maxErrorPrint {this, "MaxErrorPrint", 1000, "Maximum error messages to print"}
SG::ReadCondHandleKey< TileHid2RESrcID >	m_hid2RESrcIDKey
ToolHandle< TileCondToolTiming >	m_tileToolTiming
ToolHandle< TileCondToolOfcCool >	m_tileCondToolOfcCool
ToolHandle< TileCondToolEmscale >	m_tileToolEmscale
ToolHandle< ITileBadChanTool >	m_tileBadChanTool
ToolHandle< TileL2Builder >	m_L2Builder
ServiceHandle< TileCablingSvc >	m_cablingSvc
float	m_ampMinThresh_pC
	correct amplitude if it's above amplitude threshold (in pC)
float	m_ampMinThresh_MeV
	correct amplitude if it's above amplitude threshold (in MeV)
std::vector< uint32_t > m_OFWeights[4 *TileCalibUtils::MAX_DRAWERIDX]	ATLAS_THREAD_SAFE
std::atomic< const uint32_t * > m_OFPtrs[4 *TileCalibUtils::MAX_DRAWERIDX]	ATLAS_THREAD_SAFE
std::mutex	m_OFWeightMutex
std::mutex	m_HidMutex
std::vector< int >	m_Rw2Cell [4]
std::vector< int >	m_Rw2Pmt [4]
TileFragHash	m_hashFunc
bool	m_of2Default
std::map< unsigned int, unsigned int >	m_mapMBTS
int	m_MBTS_channel = 0
std::atomic< int >	m_WarningCounter
std::atomic< int >	m_ErrorCounter
TileHid2RESrcID *	m_hid2re
TileHid2RESrcID *	m_hid2reHLT
std::vector< int >	m_list_of_masked_drawers
unsigned int	m_maxChannels
bool	m_checkMaskedDrawers
int	m_runPeriod
std::vector< int >	m_demoChanLB
std::vector< int >	m_demoChanEB
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

Friends
class	TileHid2RESrcID

Detailed Description

Decodes the different TileCal ROD subfragment types in bytestream data and fills TileDigitsContainer, TileRawChannelContainer or TileL2Container.

Author

A. Solodkov

Version

0-0-1 , Oct 17, 2002

Modified, Dec 20, 2002 Create either TileRawChannel or TileCell.

Modified, Jan 15, 2003 Moved Encoding part to TileROD_Encoder.

Modified, Sep 7, 2003 Decoding of Testbeam data added

Definition at line 119 of file TileROD_Decoder.h.

Member Typedef Documentation

DigitsMetaData_t

typedef std::vector<std::vector<uint32_t> > TileROD_Decoder::DigitsMetaData_t

private

Definition at line 242 of file TileROD_Decoder.h.

FRwChVec

typedef std::vector<TileFastRawChannel> TileROD_Decoder::FRwChVec

private

Definition at line 235 of file TileROD_Decoder.h.

pBeamVec

typedef std::vector<TileBeamElem *> TileROD_Decoder::pBeamVec

private

Definition at line 233 of file TileROD_Decoder.h.

pCellVec

typedef std::vector<TileCell *> TileROD_Decoder::pCellVec

private

Definition at line 231 of file TileROD_Decoder.h.

pDigiVec

typedef std::vector<TileDigits *> TileROD_Decoder::pDigiVec

private

Definition at line 232 of file TileROD_Decoder.h.

pRwChVec

typedef std::vector<TileRawChannel *> TileROD_Decoder::pRwChVec

private

Definition at line 234 of file TileROD_Decoder.h.

RawChannelMetaData_t

typedef std::vector<std::vector<uint32_t> > TileROD_Decoder::RawChannelMetaData_t

private

Definition at line 244 of file TileROD_Decoder.h.

ROBData

typedef eformat::ROBFragment<const uint32_t*> TileROD_Decoder::ROBData

convert ROD Data words into either TileCell or TileRawChannel.

Definition at line 153 of file TileROD_Decoder.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

TileFragStatus

enum TileROD_Decoder::TileFragStatus

Enumerator
ALL_OK
CRC_ERR
ALL_FF
ALL_00
NO_FRAG
NO_ROB

Definition at line 226 of file TileROD_Decoder.h.

{ALL_OK=0, CRC_ERR=1, ALL_FF=0x10, ALL_00=0x20, NO_FRAG=0x40, NO_ROB=0x80};

Constructor & Destructor Documentation

TileROD_Decoder()

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

constructor

Definition at line 39 of file TileROD_Decoder.cxx.

  : AthAlgTool(type, name, parent)
  , m_ampMinThresh_pC(-1.)
  , m_ampMinThresh_MeV(-1.)
  , m_of2Default(true)
  , m_WarningCounter (0)
  , m_ErrorCounter (0)
  , m_hid2re(nullptr)
  , m_hid2reHLT(nullptr)
  , m_maxChannels(TileCalibUtils::MAX_CHAN)
  , m_checkMaskedDrawers(false)
  , m_runPeriod(0){
 
  declareInterface<TileROD_Decoder>(this);
 
  for (std::atomic<const uint32_t*>& p : m_OFPtrs) {
    p = nullptr;
  }
}

~TileROD_Decoder()

TileROD_Decoder::~TileROD_Decoder ( )

virtual

destructor

Definition at line 78 of file TileROD_Decoder.cxx.

                                  {
  if (m_hid2re) delete m_hid2re;
  if (m_hid2reHLT) delete m_hid2reHLT;
}

Member Function Documentation

checkBit()

bool TileROD_Decoder::checkBit ( const uint32_t * p, int chan ) const

private

check the bitmap for a channel

Definition at line 232 of file TileROD_Decoder.cxx.

                                                                {
  // chan = (0,47)
  int a = chan / 32;
  int r = chan % 32;
  // a = (0,1), r = ( 0, 31 )
  return *(p + a) & (1 << r);
  
}

convert()

StatusCode TileROD_Decoder::convert	(	const RawEvent *	re,
		TileL2Container *	L2Cnt ) const

Definition at line 3027 of file TileROD_Decoder.cxx.

                                                                                    {
  
  ATH_MSG_DEBUG( "Reading L2 data from ByteStream" );
  
  if (!re) {
    ATH_MSG_FATAL( "RawEvent passed to 'convert'-function is a null pointer!" );
    return StatusCode::FAILURE;
  }
  
  //bool eValid = re->check_tree();
  //if (! eValid) return StatusCode::FAILURE;
  
  //  const VDETF& vdetf = re->compounds(); //Get subdetector fragements from the raw event.
  uint32_t total_sub = re->nchildren();
  
  if (msgLvl(MSG::VERBOSE)) {
    msg(MSG::VERBOSE) << "Full Event: " << endmsg;
    msg(MSG::VERBOSE) << MSG::hex << "Full source ID: " << re->source_id()
    << MSG::dec << endmsg;
    msg(MSG::VERBOSE) << "Fragment size in words: " << re->fragment_size_word() << endmsg;
    msg(MSG::VERBOSE)<< "# of rob frags: " << total_sub << endmsg;
  }
  
  for (uint32_t i_rob = 0; i_rob < total_sub; ++i_rob) {
    const uint32_t* p_rob;
    re->child(p_rob, i_rob);
    const eformat::ROBFragment<const uint32_t*> robFrag(p_rob);
    
    eformat::helper::SourceIdentifier id = eformat::helper::SourceIdentifier(robFrag.source_id());
    unsigned int subDetId = id.subdetector_id();
    
    if (subDetId >= 0x50 && subDetId < 0x60) { //Select Tile-Subdetectors
      fillCollectionL2(&robFrag, *L2Cnt);
    }
  }
  
  // Debug
  
  if (msgLvl(MSG::VERBOSE)) {
    msg(MSG::VERBOSE) << "convertL2: " << L2Cnt->size()
    << " TileL2 objects created" << endmsg;
    TileL2Container::const_iterator ind = L2Cnt->begin();
    TileL2Container::const_iterator last = L2Cnt->end();
    
    int num = 0;
    for (; ind != last; ++ind) {
      msg(MSG::VERBOSE) << "Ind " << num++ << " " << (std::string) (*(*ind)) << endmsg;
    }
  }
  
  return StatusCode::SUCCESS;
}

convertLaser()

StatusCode TileROD_Decoder::convertLaser	(	const RawEvent *	re,
		TileLaserObject *	TileLaserObj ) const

Definition at line 3261 of file TileROD_Decoder.cxx.

                                                                                               {
  
  ATH_MSG_DEBUG( "Reading TileLaser data from ByteStream" );
  
  setLaserVersion(*laserObject);
 
  if (!re) {
    ATH_MSG_FATAL( "RawEvent passed to 'convert'-function is a null pointer!" );
    return StatusCode::FAILURE;
  }
  
  //bool eValid = re->check_tree();
  //if (! eValid) return StatusCode::FAILURE;
  
  //  const VDETF& vdetf = re->compounds(); //Get subdetector fragments from the raw event.
  uint32_t total_sub = re->nchildren();
  
  if (msgLvl(MSG::VERBOSE)) {
    msg(MSG::VERBOSE) << "Full Event: " << endmsg;
    msg(MSG::VERBOSE) << MSG::hex << "Full source ID: " << re->source_id() << MSG::dec << endmsg;
    msg(MSG::VERBOSE) << "Fragment size in words: " << re->fragment_size_word() << endmsg;
    msg(MSG::VERBOSE) << "# of rob frags: " << total_sub << endmsg;
  }
  
  for (uint32_t i_rob = 0; i_rob < total_sub; ++i_rob) {
    const uint32_t* p_rob;
    re->child(p_rob, i_rob);
    const eformat::ROBFragment<const uint32_t*> robFrag(p_rob);
    
    eformat::helper::SourceIdentifier id = eformat::helper::SourceIdentifier(
                                                                             robFrag.rod_source_id());
    unsigned int subDetId = id.subdetector_id();
    
    if (subDetId >= 0x50 && subDetId < 0x60) { //Select Tile-Subdetectors
      fillTileLaserObj(&robFrag, *laserObject);
    }
  }
  
  return StatusCode::SUCCESS;
} // end of convertLaser()

convertTMDBDecision()

StatusCode TileROD_Decoder::convertTMDBDecision	(	const RawEvent *	re,
		TileMuonReceiverContainer *	tileMuRcv ) const

Definition at line 4593 of file TileROD_Decoder.cxx.

{
 
  ATH_MSG_DEBUG( " TileROD_Decoder::convertTMDBDecision " );
 
  if (!re) {
    ATH_MSG_FATAL( "RawEvent passed to 'convert'-function is a null pointer!" );
    return StatusCode::FAILURE;
  }
 
  uint32_t total_sub = re->nchildren();
 
  for (uint32_t i_rob = 0; i_rob < total_sub; ++i_rob) {
    const uint32_t* p_rob;
    re->child(p_rob, i_rob);
    const eformat::ROBFragment<const uint32_t*> robFrag(p_rob);
 
    //eformat::helper::SourceIdentifier id = eformat::helper::SourceIdentifier(robFrag.source_id());
    uint32_t sourceid = robFrag.source_id();
    uint32_t modid = sourceid >> 16;
    //ATH_MSG_VERBOSE( MSG::hex<<" sourceId: 0x"<< robFrag.source_id() <<MSG::dec );
 
    if ((modid == 0x51 || modid == 0x52 || modid == 0x53 || modid == 0x54) && (sourceid & 0xf00)) {
      fillContainer_TileMuRcv_Decision(&robFrag, *tileMuRcv);
    }
  }
 
  return StatusCode::SUCCESS;
}

copy_vec()

template<typename ELEMENT, class COLLECTION>

void TileROD_Decoder::copy_vec ( std::vector< ELEMENT * > & v, COLLECTION & coll ) const

inlineprivate

Definition at line 696 of file TileROD_Decoder.h.

                                                                                       {
  typedef typename std::vector<ELEMENT *>::const_iterator ELEMENT_const_iterator;
 
  ELEMENT_const_iterator iCh = v.begin();
  ELEMENT_const_iterator iEnd = v.end();
  for (; iCh != iEnd; ++iCh) coll.push_back(*iCh);
}

data_size()

uint32_t TileROD_Decoder::data_size ( const ROBData * rob, uint32_t & error ) const

inlineprivate

Definition at line 620 of file TileROD_Decoder.h.

                                                                   {
      uint32_t size = rob->rod_ndata();
      uint32_t max_allowed_size = rob->rod_fragment_size_word();
      uint32_t delta = rob->rod_header_size_word() + rob->rod_trailer_size_word();
      if (max_allowed_size > delta)
        max_allowed_size -= delta;
      else
        max_allowed_size = 0;
      if (size < 3 && size > 0) {
        if (rob->rod_source_id() > 0x50ffff) error |= 0x10000; // indicate error in frag size, but ignore error in laser ROD
        if (m_WarningCounter++ < m_maxWarningPrint) {
          ATH_MSG_WARNING("ROB " << MSG::hex << rob->source_id()
              << " ROD " << rob->rod_source_id() << MSG::dec
              << " has unexpected data size: " << size << " - assuming zero size " );
        }
        return 0;
      } else if (rob->rod_header_size_word() >= rob->rod_fragment_size_word()) {
        if (rob->rod_source_id() > 0x50ffff) error |= 0x10000; // indicate error in frag size, but ignore error in laser ROD
        if (m_WarningCounter++ < m_maxWarningPrint) {
          ATH_MSG_WARNING("ROB " << MSG::hex << rob->source_id()
              << " ROD " << rob->rod_source_id() << MSG::dec
              << " has unexpected header size: " << rob->rod_header_size_word()
              << " bigger than full size " << rob->rod_fragment_size_word()
              << " - assuming no data " );
        }
        return 0;
      } else if (size > max_allowed_size) {
        if (rob->rod_source_id() > 0x50ffff) error |= 0x10000; // indicate error in frag size, but ignore error in laser ROD
 
        if (size - rob->rod_trailer_size_word() < max_allowed_size) {
          if ((m_WarningCounter++) < m_maxWarningPrint) {
            ATH_MSG_WARNING("ROB " << MSG::hex << rob->source_id()
                            << " ROD " << rob->rod_source_id() << MSG::dec
                            << " data size " << size << " is longer than allowed size " << max_allowed_size
                            << " - assuming that ROD trailer is shorter: "
                            << rob->rod_trailer_size_word()-(size-max_allowed_size)
                            << " words instead of " << rob->rod_trailer_size_word());
          }
          max_allowed_size = size;
        } else if (size - rob->rod_trailer_size_word() == max_allowed_size) {
          if ((m_WarningCounter++) < m_maxWarningPrint) {
            ATH_MSG_WARNING("ROB " << MSG::hex << rob->source_id()
                            << " ROD " << rob->rod_source_id() << MSG::dec
                            << " data size " << size << " is longer than allowed size " << max_allowed_size
                            << " - assuming that ROD trailer ("
                            << rob->rod_trailer_size_word()
                            << " words) is absent");
          }
          max_allowed_size = size;
        } else {
          max_allowed_size += rob->rod_trailer_size_word();
          if ((m_WarningCounter++) < m_maxWarningPrint) {
            ATH_MSG_WARNING("ROB " << MSG::hex << rob->source_id()
                            << " ROD " << rob->rod_source_id() << MSG::dec
                            << " has unexpected data size: " << size
                            << " - assuming data size = " << max_allowed_size << " words and no ROD trailer at all" );
          }
        }
        return max_allowed_size;
      } else {
        return size;
      }
    }

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

delete_vec()

template<typename ELEMENT>

void TileROD_Decoder::delete_vec ( std::vector< ELEMENT * > & v ) const

inlineprivate

Definition at line 686 of file TileROD_Decoder.h.

                                                                      {
  typedef typename std::vector<ELEMENT *>::const_iterator ELEMENT_const_iterator;
 
  ELEMENT_const_iterator iCh = v.begin();
  ELEMENT_const_iterator iEnd = v.end();
  for (; iCh != iEnd; ++iCh)  delete (*iCh);
  v.clear();
}

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

fillCollection()

template<class COLLECTION>

void TileROD_Decoder::fillCollection	(	const ROBData *	rob,
		COLLECTION &	v,
		typename TileROD_Helper::ContainerForCollection< COLLECTION >::type *	container = nullptr ) const

This method calls the unpacking methods to decode the ROD data and fills the TileDigitsContainer and/or the TileRawChannelContainer.

fill either TileDigitsCollection or TileRawChannelCollection or TileCellCollection or TileBeamElemCollection from a BLOCK of integers

Definition at line 904 of file TileROD_Decoder.h.

{
  //
  // get info from ROD header
  //
  //  if (msgLvl(MSG::VERBOSE)) {
  //    msg(MSG::VERBOSE) << "ROD header info: " << endmsg
  //    msg(MSG::VERBOSE) << " Format Vers.  " << MSG::hex << "0x" << rob->rod_version() << MSG::dec << endmsg;
  //    msg(MSG::VERBOSE) << " Source ID     " << MSG::hex << "0x" << rob->rod_source_id() << MSG::dec << endmsg;
  //    msg(MSG::VERBOSE) << " Source ID str " << eformat::helper::SourceIdentifier(rob->source_id()).human().c_str() << endmsg;
  //    msg(MSG::VERBOSE) << " Run number    " << (int) rob->rod_run_no() << endmsg;
  //    msg(MSG::VERBOSE) << " Level1 ID     " << rob->rod_lvl1_id() << endmsg;
  //    msg(MSG::VERBOSE) << " BCID          " << rob->rod_bc_id() << endmsg;
  //    msg(MSG::VERBOSE) << " Lvl1 TrigType " << rob->rod_lvl1_trigger_type() << endmsg;
  //    msg(MSG::VERBOSE) << " Event Type    " << rob->rod_detev_type() << endmsg;
  //    msg(MSG::VERBOSE) << " Fragment size " << rob->rod_fragment_size_word() << endmsg;
  //    msg(MSG::VERBOSE) << " Header   size " << rob->rod_header_size_word() << endmsg;
  //    msg(MSG::VERBOSE) << " Trailer  size " << rob->rod_trailer_size_word() << endmsg;
  //    msg(MSG::VERBOSE) << " N data        " << rob->rod_ndata() << endmsg;
  //    msg(MSG::VERBOSE) << " N status      " << rob->rod_nstatus() << endmsg;
  //    msg(MSG::VERBOSE) << " Status pos    " << rob->rod_status_position() << endmsg;
  //  }
 
  uint32_t version = rob->rod_version() & 0xFFFF;
 
  bool isBeamROD = false;
  // figure out which fragment we want to unpack
  TileRawChannelCollection::ID frag_id = v.identify();
  SG::ReadCondHandle<TileHid2RESrcID> hid2re{m_hid2RESrcIDKey};
  const std::vector<uint32_t> & drawer_info = hid2re->getDrawerInfo(frag_id);
  int bs_frag_id = drawer_info.size()>1 ? static_cast<int>(drawer_info[1]) : frag_id;
  int drawer_type = drawer_info.size()>2 ? static_cast<int>(drawer_info[2]) : -1;
 
  uint32_t mask = 0xFFFF;
 
  // special conversion for sub-fragments in beam ROD
  if (frag_id < 0x100) {
    isBeamROD = true;
    mask = 0xFF; // this is needed for TB 2003, when beam frag_id >= 0x400
  }
 
  // find all fragments with given Fragment ID
  // and possibly with different types
  std::vector<const uint32_t *> pFrag;
  pFrag.reserve(5);
 
  uint32_t error = 0;
  uint32_t wc = 0;
  uint32_t size = data_size(rob, error);
  const uint32_t * p = get_data(rob);
 
  // 2 extra words in every frag by default (frag id + frag size)
  // but for all data after 2005 it is set to 3 later in the code
  uint32_t sizeOverhead = 2;
 
  // bool skipWords = ( ! isBeamROD && version == 0x1 );
  // std::cout << " *(p) = 0x" << std::hex << (*(p)) << std::dec << std::endl;
  if (size) {
    bool V3format = (*(p) == 0xff1234ff); // additional frag marker since Sep 2005
    V3format |= (*(p) == 0x00123400); // additional frag marker since Sep 2005 (can appear in buggy ROD frags)
    if (!V3format && version>0xff) {
      V3format = true;
      if ((m_WarningCounter++) < m_maxWarningPrint)
        ATH_MSG_WARNING("fillCollection: corrupted frag separator 0x" << MSG::hex << (*p) << " instead of 0xff1234ff in ROB 0x" << rob->rod_source_id() << MSG::dec );
    }
    if (V3format) {
      ++p; // skip frag marker
      sizeOverhead = 3;
    } else {
      sizeOverhead = 2;
    }
  }
 
  //std::cout << std::hex << " frag_id " << frag_id << " mask " << mask
  //          << " version " << version << " sizeOverhead " << sizeOverhead
  //          << " skipWords " << skipWords << " V3format " << V3format
  //          << std::dec << std::endl;
  //std::cout << " size is "<< size << std::endl;
 
  while (wc < size) { // iterator over all words in a ROD
 
    // first word is frag size
    uint32_t count = *(p);
    // second word is frag ID (16 bits) frag type (8 bits) and additional flags
    uint32_t idAndType = *(p + 1);
    int frag = (idAndType & mask);
    int type = (idAndType & 0xF00000) >> 16; // note special mask, we ignore one digit, keep only 0x10, 0x20, 0x30, ...
 
    if (count < sizeOverhead || count > size - wc) {
      int cnt = 0;
      for (; wc < size; ++wc, ++cnt, ++p) {
        if ((*p) == 0xff1234ff) {
          ++cnt;
          ++wc;
          ++p;
          break;
        }
      }
      if ((m_ErrorCounter++) < m_maxErrorPrint) {
        msg(MSG::WARNING) << "Frag 0x" << MSG::hex << frag << MSG::dec
                        << " has unexpected size: " << count;
        if (wc < size) {
          msg(MSG::WARNING) << "  skipping " << cnt << " words to the next frag" << endmsg;
        } else {
          msg(MSG::WARNING) << " ignoring " << cnt << " words till the end of ROD frag" << endmsg;
        }
      }
      continue;
    }
 
    if (type != 0x10 && frag == bs_frag_id) pFrag.push_back(p);
 
    p += count;
    wc += count;
 
    //std::cout << " frag ="<<frag<<" type = "<<type<<" count="<<count<<std::endl;
 
    // this is not needed anymore, since we can't read very old BS files anyhow.
    //if ( skipWords && type == 0 && wc < size ) { // special treatment of preROD output with digits
    //  wc+=7; p+=7; // skip extra header
    //}
  }
 
  if (wc != size) {
    // check word count
    if ((m_ErrorCounter++) < m_maxErrorPrint) {
      ATH_MSG_WARNING( "Incorrect ROD size: " << wc << " words instead of " << size );
    }
    assert(0);
    // return;
  }
 
  static const bool unpackDigits = std::is_same_v<COLLECTION, TileDigitsCollection>;
  static const bool unpackChannels = std::is_same_v<COLLECTION, TileRawChannelCollection>;
 
  if (isBeamROD) {
 
    pBeamVec pBeam;
    pBeam.reserve(16);
 
    std::vector<const uint32_t *>::const_iterator it = pFrag.begin();
    std::vector<const uint32_t *>::const_iterator itEnd = pFrag.end();
 
    for (; it != itEnd; ++it) {
 
      p = (*it);
 
      unpack_brod(version, sizeOverhead, p, pBeam, frag_id);
    }
 
    make_copy(rob, pBeam, v);
 
  } else {
 
    pDigiVec pDigits;
    pRwChVec pChannel;
    pChannel.reserve(48);
 
    // initialize meta data storage
    DigitsMetaData_t digitsMetaData (7);
    RawChannelMetaData_t rawchannelMetaData (7);
    for (unsigned int i = 0; i < 7; ++i) {
      digitsMetaData[i].reserve(16);
      rawchannelMetaData[i].reserve(2);
    }
 
    // now unpack all channels in all fragments
    // and fill temporary array of TileDigits and/or TileRawChannels
 
    std::vector<const uint32_t *>::const_iterator it = pFrag.begin();
    std::vector<const uint32_t *>::const_iterator itEnd = pFrag.end();
 
    uint32_t bsflags = 0;
    TileFragHash::TYPE rChType = TileFragHash::Digitizer;
    TileRawChannelUnit::UNIT rChUnit = TileRawChannelUnit::ADCcounts;
 
    for (; it != itEnd; ++it) {
 
      p = (*it);
      // first word is frag size
      // uint32_t count = *(p);
      // second word is frag ID (16 bits) frag type (8 bits) and additional flags
      uint32_t idAndType = *(p + 1);
      int type = (idAndType & 0x00FF0000) >> 16;
 
      ATH_MSG_VERBOSE( "Unpacking frag: 0x" << MSG::hex << (idAndType & 0xFFFF)
                      << " type " << type << MSG::dec );
 
      switch (type) {
        case 0:
          if (unpackDigits && m_useFrag0) unpack_frag0(version, sizeOverhead, digitsMetaData, p, pDigits, frag_id, drawer_type);
          break;
        case 1:
          if (unpackDigits && m_useFrag1) unpack_frag1(version, sizeOverhead, digitsMetaData, p, pDigits, frag_id, drawer_type);
          break;
        case 2:
          if (unpackChannels && m_useFrag4) unpack_frag2(version, sizeOverhead, p, pChannel, frag_id, drawer_type);
          break;
        case 3:
          if (unpackChannels && m_useFrag4) unpack_frag3(version, sizeOverhead, p, pChannel, frag_id, drawer_type);
          break;
        case 4:
          if (unpackChannels && m_useFrag4) {
            bsflags = idAndType & 0xFFFF0000; // ignore frag num, keep all the rest
            int unit = (idAndType & 0xC0000000) >> 30;
 
            int DataType = (idAndType & 0x30000000) >> 28;
 
            if (DataType < 3) { // real data
 
              // only one bit for type and next 2 bits for number of iterations
              //int AlgoType = (idAndType & 0x4000000) >> 26;
              //if (AlgoType == 0)      rChType = TileFragHash::OF1Filter;
              //else                    rChType = TileFragHash::OF2Filter;
              // always set special type, which means now that OF is done inside DSP
              rChType = TileFragHash::OptFilterDsp;
 
              // Attention! Switching to Online Units for release 14.2.0
              rChUnit = (TileRawChannelUnit::UNIT) (unit + TileRawChannelUnit::OnlineOffset); // Online units in real data
              // rChUnit = (TileRawChannelUnit::UNIT) ( unit );
 
            } else { // simulated data
 
              // all 3 bits for type
              int AlgoType = (idAndType & 0x7000000) >> 24;
              rChType = (TileFragHash::TYPE) AlgoType;
 
              rChUnit = (TileRawChannelUnit::UNIT) (unit); // Offline units in simulated data
 
              if (!m_demoFragIDs.empty()) {
                const_cast<Gaudi::Property<std::vector<int>> &> ( m_demoFragIDs ) = {}; // No demonstator cabling in MC
                ATH_MSG_INFO("Disable channel remapping for demonstrator in MC");
              }
            }
 
            unpack_frag4(version, sizeOverhead, unit, rawchannelMetaData, p, pChannel, frag_id, drawer_type);
          }
          break;
 
        case 5:
          if (m_useFrag5Raw || m_useFrag5Reco) {
            bsflags = idAndType & 0xFFFF0000; // ignore frag num, keep all the rest
            int unit = (idAndType & 0xC0000000) >> 30;
 
            // always set special type, which means now that OF is done inside DSP
            rChType = TileFragHash::OptFilterDspCompressed;
 
            rChUnit = (TileRawChannelUnit::UNIT) (unit + TileRawChannelUnit::OnlineOffset);
            unpack_frag5(version, sizeOverhead, unit,
                         digitsMetaData,
                         p, pDigits, pChannel, frag_id, drawer_type);
          }
          break;
 
        case 6:
          break;
 
        case 0xA:
          if (unpackChannels) unpack_fragA(version, rawchannelMetaData, p, pChannel, frag_id, drawer_type);
          break;
 
        default:
          int frag = idAndType & 0xFFFF;
          ATH_MSG_WARNING( "Unknown frag type=" << type << " for frag=" << frag );
          assert(0);
          break;
      }
    } // end of all frags
 
    make_copy(bsflags, rChType, rChUnit, digitsMetaData, rawchannelMetaData,
              rob, pDigits, pChannel, v, container);
  }
 
  return;
}

fillCollection_FELIX_Digi()

void TileROD_Decoder::fillCollection_FELIX_Digi	(	const ROBData *	rob,
		TileDigitsCollection &	v ) const

Definition at line 4528 of file TileROD_Decoder.cxx.

                                                                                                     {
 
  ATH_MSG_DEBUG( "TileROD_Decoder::fillCollection_FELIX_Digi" );
 
  uint32_t version  = rob->rod_version() & 0xFFFF;
  uint32_t sizeOverhead = 3; // Sub fragment marker, size, and (id + type)
 
  SG::ReadCondHandle<TileHid2RESrcID> hid2re{m_hid2RESrcIDKey};
 
  // initialize meta data storage
  DigitsMetaData_t digitsMetaData(9);
  RawChannelMetaData_t rawchannelMetaData;
 
  pDigiVec pDigits;
  pRwChVec pChannel;
 
  uint32_t  error = 0; 
  uint32_t size = data_size(rob, error);
  const uint32_t* data = get_data(rob);
  const uint32_t* const end_data = data + size;
 
  int frag_id = coll.identify();
  const std::vector<uint32_t> & drawer_info = hid2re->getDrawerInfo(frag_id);
  int bs_frag_id = drawer_info.size()>1 ? static_cast<int>(drawer_info[1]) : frag_id;
  int drawer_type = drawer_info.size()>2 ? static_cast<int>(drawer_info[2]) : -1;
 
  while (data < end_data) { // iterator over all words for a robid
    // first word is the start of the tile subfragment in v3format it is 0xff1234ff
    if ((*data) == 0xff1234ff) {
      uint32_t count = *(data + 1); // first word is frag size
      uint32_t idAndType = *(data + 2); // second word is frag ID and frag type
      int frag = (idAndType &  0x0FFF); // remove the offset
      int type = (idAndType>>16)& 0xFF; // note special mask, we ignore one digit, keep only 0x10, 0x20, 0x30, ...
      if (type == 0x06 &&  (frag == bs_frag_id)) {
        ++data;
        ATH_MSG_DEBUG( MSG::hex << "Found FELIX sub-fragment ID=0x" << frag
                                <<" type=0x" << type << MSG::dec
                                << " size=" << count );
        std::vector<uint32_t> correct_data = get_correct_data(data);
        unpack_frag6(version, sizeOverhead, digitsMetaData, correct_data.data(), pDigits, frag_id, drawer_type);
        // store metadata for this collection
        // size, fragID, BCID
        digitsMetaData[0].push_back(count);
        digitsMetaData[0].push_back(frag);
        digitsMetaData[0].push_back(0);
        break;
      } else {
        // carry on looping to search for 0x60
        data += count;
      }
    }
    ++data;
  }
 
  uint32_t bsflags = 0;
  TileFragHash::TYPE rChType = TileFragHash::Digitizer;
  TileRawChannelUnit::UNIT rChUnit = TileRawChannelUnit::ADCcounts;
 
  make_copy(bsflags, rChType, rChUnit, digitsMetaData, rawchannelMetaData,
            rob, pDigits, pChannel, coll, nullptr);
 
}

fillCollection_TileMuRcv_Digi()

void TileROD_Decoder::fillCollection_TileMuRcv_Digi	(	const ROBData *	rob,
		TileDigitsCollection &	v ) const

Definition at line 4398 of file TileROD_Decoder.cxx.

                                                                                                         {
 
  ATH_MSG_DEBUG( " TileROD_Decoder::fillCollection_TileMuRcv_Digi " );
 
  int  wc         = 0;
  bool b_sof      = false;
  bool b_digiTmdb = false;
 
  uint32_t version  = rob->rod_version() & 0xFFFF;
  uint32_t sourceid = rob->rod_source_id();
  int size          = rob->rod_ndata();
 
  uint32_t sfrag_version = 0x0;
  uint32_t sfrag_type    = 0x0;
  int sfrag_size         = 0;
 
  const uint32_t *p = get_data(rob);
 
  ATH_MSG_DEBUG( " Trying DECODER over source ID: "<<MSG::hex<<" 0x"<<sourceid<<MSG::dec<<" size of full fragment: "<<size );
 
  while ( wc < size ) { // iterator over all words for a robid   
    // first word is the start of the tile subfragment in v3format it is 0xff1234ff
    if ((*p) == 0xff1234ff) b_sof=true;
 
    ATH_MSG_DEBUG( " Start of sub-fragment word: "<<MSG::hex<<(*p)<<MSG::dec<<" false/true: "<<b_sof );
 
    if (b_sof) {
      // second word is frag size
      sfrag_size   = *(p+1);
      // third word is frag version (16-bits) + type (16-bits)
      sfrag_version = *(p+2) & 0xFFFF;
      sfrag_type    = *(p+2) >> 16;
      b_sof = false;
    }
 
    if (sfrag_type==0x40) {
      b_digiTmdb   = true;
      ATH_MSG_DEBUG( MSG::hex<<" DECODER sub-fragment VERSION= 0x"<<sfrag_version<<" TYPE= 0x"<<sfrag_type<< MSG::dec<<" SIZE="<<sfrag_size<<" FOUND! " );
      // type and version are identified and we move to the end of the loop
      wc += size-wc;
      p  += 3;
    } else {
      // carry on looping to search for 0x40
      wc++;
      p++;
    }
  }
 
  if ( b_digiTmdb ) {
    // the TMDB raw channel 0x40
    uint32_t collID = coll.identify();
    unpack_frag40( collID, version,  p, sfrag_size-3, coll);
  }
 
  //delete_vec(digi);
 
  return;
 
}

fillCollection_TileMuRcv_RawChannel()

void TileROD_Decoder::fillCollection_TileMuRcv_RawChannel	(	const ROBData *	rob,
		TileRawChannelCollection &	v ) const

Definition at line 4458 of file TileROD_Decoder.cxx.

                                                                                                                   {
 
  ATH_MSG_DEBUG( " TileROD_Decoder::fillCollection_TileMuRcv_RawChannel " );
 
  int wc        = 0;
  bool b_sof    = false;
  bool b_rcTmdb = false;
 
  uint32_t version  = rob->rod_version() & 0xFFFF;
  uint32_t sourceid = rob->rod_source_id();
  int size          = rob->rod_ndata();
  int offset = 0;
 
  uint32_t sfrag_version = 0x0;
  uint32_t sfrag_type    = 0x0;
  int sfrag_size = 0;
 
  const uint32_t *p = get_data(rob);
 
  ATH_MSG_DEBUG( " Trying DECODER over source ID: "<<MSG::hex<<" 0x"<<sourceid<<MSG::dec<<" size of full fragment: "<<size );
 
  while ( wc < size ) { // iterator over all words in a robid
    // first word is the start of the tile subfragment in v3format it is 0xff1234ff
    if ((*p) == 0xff1234ff) b_sof=true;
    ATH_MSG_DEBUG( " Start of sub-fragment word : "<<MSG::hex<< (*p)<<MSG::dec<<" false/true : "<<b_sof );
    // if at the start of the fragment than we should find more information about this (sub-)fragment in the following two words 
    if (b_sof) {
      // second word is frag size
      sfrag_size    = *(p+1);
      // third word is frag version (16-bits) + type (16-bits)
      sfrag_version = *(p+2) & 0xFFFF;
      sfrag_type    = *(p+2) >> 16;
      b_sof=false;
    }
    // for tmdb we will start to have a fragment with three sub-fragments ordered as 0x40 0x41 0x42
    // we investigate if there are any of type 0x40 before going on 0x41
    // like this the loop is faster since we can access the size of this sub-fragment
    //         
    if (sfrag_type==0x40) {
      ATH_MSG_DEBUG(MSG::hex<<" DECODER sub-fragment VERSION= 0x"<<sfrag_version<<" TYPE= 0x"<<sfrag_type<<MSG::dec<<" SIZE="<<sfrag_size<<" FOUND! Keep on looking for 0x41.");
      offset = sfrag_size;
      wc += offset;
      p  += offset;
    } else if (sfrag_type==0x41) {
      b_rcTmdb   = true;
      ATH_MSG_DEBUG(MSG::hex<<" DECODER sub-fragment VERSION= 0x"<<sfrag_version<<" TYPE= 0x"<<sfrag_type<<MSG::dec<<" SIZE="<<sfrag_size<<" FOUND!");
      // type and version are identified and we move to the end of the loop
      wc += size-wc;
      p+=3;
    } else {
      ATH_MSG_DEBUG(MSG::hex<<" DECODER sub-fragment VERSION= 0x"<<sfrag_version<<" TYPE= 0x"<<sfrag_type<<MSG::dec<<" SIZE="<<sfrag_size<<" FOUND!");
      // carry on looping to search for 0x41
      wc++;
      p++;
    }
  }
 
  if ( b_rcTmdb ) {
    // the TMDB raw channel 0x41
    //
    uint32_t collID = coll.identify();
    unpack_frag41( collID, version,  p, sfrag_size-3, coll);
  }
 
  //delete_vec(rc);
 
return;
}

fillCollectionHLT()

uint32_t TileROD_Decoder::fillCollectionHLT	(	const ROBData *	rob,
		TileCellCollection &	v,
		D0CellsHLT &	d0cells,
		TileCellCollection *	MBTS,
		const TileHid2RESrcID *	hid2reHLT ) const

Definition at line 3410 of file TileROD_Decoder.cxx.

{
  uint32_t version = rob->rod_version() & 0xFFFF;
  // Resets error flag
  uint32_t error = 0x0;
  
  // figure out which fragment we want to unpack
  TileRawChannelCollection::ID frag_id = v.identify();
  const std::vector<uint32_t> & drawer_info = hid2reHLT->getDrawerInfo(frag_id);
  int bs_frag_id = drawer_info.size()>1 ? static_cast<int>(drawer_info[1]) : frag_id;
  int drawer_type = drawer_info.size()>2 ? static_cast<int>(drawer_info[2]) : -1;
 
  /*
   if (frag_id < 0x100) { // BEAM ROD frag - nothing to do
   m_error|=0x10000;
   return;
   }
   */
  
  uint32_t wc = 0;
  uint32_t size = data_size(rob, error);
  const uint32_t * p = get_data(rob);
  // prepare bcid with one extra bit set for comparison with bcid in DQ fragment
  uint16_t rob_bcid = ((rob->rod_bc_id() & 0x7FFF) | 0x8000);
  
  uint32_t sizeOverhead = 2;
  if (size) {
    bool V3format = (*(p) == 0xff1234ff); // additional frag marker since Sep 2005
    if (!V3format && version>0xff) {
      V3format = true;
      if ((m_WarningCounter++) < m_maxWarningPrint)
        ATH_MSG_WARNING("fillCollectionHLT: corrupted frag separator 0x" << MSG::hex << (*p) << " instead of 0xff1234ff in ROB 0x" << rob->rod_source_id() << MSG::dec );
    }
    if (V3format) {
      ++p; // skip frag marker
      sizeOverhead = 3;
    } else {
      sizeOverhead = 2;
    }
  }
  bool of2 = m_of2Default;
  bool correctAmplitude = false;
  TileRawChannelUnit::UNIT rChUnit = TileRawChannelUnit::ADCcounts;
  uint16_t DQuality = 0x0;
  bool fragFound = false;
  bool DQfragMissing = true;
  
  FRwChVec pChannel;
  pChannel.reserve (m_maxChannels);
 
  while (wc < size) { // iterator over all words in a ROD
    
    // first word is frag size
    uint32_t count = *(p);
    // second word is frag ID (16 bits) frag type (8 bits) and additional flags
    uint32_t idAndType = *(p + 1);
    int frag = (idAndType & 0xFFFF);
    int type = (idAndType & 0xFF0000) >> 16;
    
    if (count < sizeOverhead || count > size - wc) {
      int cnt = 0;
      for (; wc < size; ++wc, ++cnt, ++p) {
        if ((*p) == 0xff1234ff) {
          ++cnt;
          ++wc;
          ++p;
          break;
        }
      }
      if ((m_ErrorCounter++) < m_maxErrorPrint) {
        msg(MSG::WARNING) << "Frag: " << MSG::hex << "0x" << frag << MSG::dec
        << " has unexpected size: " << count;
        if (wc < size) {
          msg(MSG::WARNING) << "  skipping " << cnt << " words to the next frag" << endmsg;
        } else {
          msg(MSG::WARNING) << " ignoring " << cnt << " words till the end of ROD frag" << endmsg;
        }
      }
      error |= 0x10000;
      continue;
    }
    
    //if (frag == frag_id && ((type > 1 && type < 6) || type==0xa)) { // proper fragment found - unpack it
    if (frag == bs_frag_id) { // proper fragment found - unpack it
      
      switch (type) {
        case 2:
          fragFound = true;
          DQfragMissing = false;
          correctAmplitude = false;
          unpack_frag2HLT(version, sizeOverhead, p, pChannel, frag_id, drawer_type);
          break;
        case 3:
          fragFound = true;
          DQfragMissing = false;
          correctAmplitude = false;
          unpack_frag3HLT(version, sizeOverhead, p, pChannel, frag_id, drawer_type);
          break;
        case 4:
          if (!m_ignoreFrag4HLT && !fragFound) {
            fragFound = true;
            int unit = (idAndType & 0xC0000000) >> 30;
            
            int DataType = (idAndType & 0x30000000) >> 28;
            
            if (DataType < 3) { // real data
              
              of2 = ((idAndType & 0x4000000) != 0);
              int nIter = (idAndType & 0x3000000) >> 24;
              correctAmplitude = (!nIter); // automatic detection of nIter
              rChUnit = (TileRawChannelUnit::UNIT) (unit + TileRawChannelUnit::OnlineOffset); // Online units in real data
              
            } else { // simulated data
              
              DQfragMissing = false;
              correctAmplitude = false;
              rChUnit = (TileRawChannelUnit::UNIT) (unit); // Offline units in simulated data
              if (!m_demoFragIDs.empty()) {
                const_cast<Gaudi::Property<std::vector<int>> &> ( m_demoFragIDs ) = {}; // No demonstator cabling in MC
                ATH_MSG_INFO("Disable channel remapping for demonstrator in MC");
              }
            }
            
            unpack_frag4HLT(version, sizeOverhead, unit, p, pChannel, frag_id, drawer_type);
          }
          break;
          
        case 5:
          if (!fragFound) {
            fragFound = true;
            int unit = (idAndType & 0xC0000000) >> 30;
            
            of2 = ((idAndType & 0x4000000) != 0);
            correctAmplitude = true; // fragment 5 will appear only if there is no iterations, so correction required
            rChUnit = (TileRawChannelUnit::UNIT) (unit + TileRawChannelUnit::OnlineOffset);
            
            unpack_frag5HLT(version, sizeOverhead, unit, p, pChannel, frag_id, drawer_type);
          }
          break;
          
        case 0xa:
          DQfragMissing = false;
          unpack_fragAHLT(version, p, rob_bcid, DQuality, frag_id, drawer_type);
          break;
          
        default:
          // Just ignore it
          break;
      }
    }
    p += count;
    wc += count;
  }
 
  bool masked_drawer = m_checkMaskedDrawers ? m_tileBadChanTool->isDrawerMasked(frag_id) : false;
 
  if (DQfragMissing && !masked_drawer) error |= 0x40000;
  
  if (fragFound) {
    if (masked_drawer) DQuality = 0x0;
    error |= make_copyHLT(of2, rChUnit, correctAmplitude,
                          pChannel, v, DQuality, d0cells, MBTS);
  } else if (!masked_drawer) error |= 0x20000;
  
  return error;
}

fillCollectionL2()

void TileROD_Decoder::fillCollectionL2	(	const ROBData *	rob,
		TileL2Container &	v ) const

Definition at line 3080 of file TileROD_Decoder.cxx.

                                                                                     {
  uint32_t version = rob->rod_version() & 0xFFFF;
 
  uint32_t error = 0;
  uint32_t wc = 0;
  uint32_t size = data_size(rob, error);
  const uint32_t * p = get_data(rob);
  int fragmin = 0xFFF, fragmax = -1;
  
  int counter = 0;
  
  uint32_t sizeOverhead = 2;
  if (size) {
    bool V3format = (*(p) == 0xff1234ff); // additional frag marker since Sep 2005
    if (!V3format && version>0xff) {
      V3format = true;
      if ((m_WarningCounter++) < m_maxWarningPrint)
        ATH_MSG_WARNING("fillCollectionL2( corrupted frag separator 0x" << MSG::hex << (*p) << " instead of 0xff1234ff in ROB 0x" << rob->rod_source_id() << MSG::dec );
    }
    if (V3format) {
      ++p; // skip frag marker
      sizeOverhead = 3;
    } else {
      sizeOverhead = 2;
    }
  }
 
  SG::ReadCondHandle<TileHid2RESrcID> hid2re{m_hid2RESrcIDKey};
 
  int DataType = 0;
  while (wc < size) { // iterator over all words in a ROD
    
    // first word is frag size
    uint32_t count = *(p);
    // second word is frag ID and frag type
    uint32_t idAndType = *(p + 1);
    uint32_t bs_frag_id = idAndType & 0xFFFF;
    int frag = hid2re->getOfflineFragID(bs_frag_id);
    if (frag<0) frag = bs_frag_id;
    const std::vector<uint32_t> & drawer_info = hid2re->getDrawerInfo(frag);
    int drawer_type = drawer_info.size()>2 ? static_cast<int>(drawer_info[2]) : -1;
    if (frag < fragmin) fragmin = frag;
    if (frag > fragmax) fragmax = frag;
    DataType = (idAndType & 0x30000000) >> 28;
 
    int type = (*(p + 1) >> 16) & 0xFF;
    
    if (count < sizeOverhead || count > size - wc) {
      int cnt = 0;
      for (; wc < size; ++wc, ++cnt, ++p) {
        if ((*p) == 0xff1234ff) {
          ++cnt;
          ++wc;
          ++p;
          break;
        }
      }
      if ((m_ErrorCounter++) < m_maxErrorPrint) {
        msg(MSG::WARNING) << "Frag " << MSG::hex << "0x" << frag
        << MSG::dec << " has unexpected size: " << count;
        if (wc < size) {
          msg(MSG::WARNING) << "  skipping " << cnt << " words to the next frag" << endmsg;
        } else {
          msg(MSG::WARNING) << " ignoring " << cnt << " words till the end of ROD frag" << endmsg;
        }
      }
      continue;
    }
    
    if (type == 4) { // frag4 which contains sum Et at the end
      
      if (unpack_frag4L2(version, sizeOverhead, p, v, frag, drawer_type)) {
        counter++;
      }
      
    } else if (type == 5 && m_useFrag5Reco) { // new fragment which contains sum Et
      
      if (unpack_frag5L2(version, p, v, frag, drawer_type)) {
        counter++;
      }
      
    } else if ((type >> 4) == 1) { // all frags 0x10-0x15 are MET or MTag frags
      
      counter++;
      
      switch (type) {
          
        case 0x10:
          unpack_frag10(version, p, v, frag, drawer_type);
          break;
        case 0x11:
          unpack_frag11(version, p, v, frag, drawer_type);
          break;
        case 0x12:
          unpack_frag12(version, p, v, frag, drawer_type);
          break;
        case 0x13:
          unpack_frag13(version, p, v, frag, drawer_type);
          break;
        case 0x14:
          unpack_frag14(version, p, v, frag, drawer_type);
          break;
        case 0x15:
          unpack_frag15(version, p, v, frag, drawer_type);
          break;
          
        default:
          int frag = *(p + 1) & 0xFFFF;
          ATH_MSG_WARNING( "Unknown frag type=" << type << " for frag=" << frag  << " bs_frag=" << bs_frag_id);
          assert(0);
          break;
      }
    }
    
    p += count;
    wc += count;
  }
  
  if (wc != size) {
    // check word count
    if ((m_ErrorCounter++) < m_maxErrorPrint) {
      ATH_MSG_WARNING( "Incorrect ROD size: " << wc << " words instead of " << size );
    }
    assert(0);
    // return;
  }
  
  if (DataType >= 3 && counter == 0 && !m_L2Builder.empty()) {
    if (m_L2Builder->process(fragmin, fragmax, &v).isFailure()) {
      ATH_MSG_ERROR( "Failure in " << m_L2Builder );
      return;
    }
  }
  
  return;
}

fillCollectionL2ROS()

void TileROD_Decoder::fillCollectionL2ROS	(	const ROBData *	rob,
		TileL2Container &	v ) const

Definition at line 3217 of file TileROD_Decoder.cxx.

                                                                                        {
  uint32_t error = 0;
  uint32_t size = data_size(rob, error);
  const uint32_t * p = get_data(rob);
  const uint32_t ROB_to_decode = ((*p) & 0xFFFF); // Multiply by two
  const uint32_t virtualROBJump = ((*p) >> 16) >> 2; // Divide by four (four drawer-1ROB)
  if (size < ROB_to_decode * virtualROBJump + 1) {
    ATH_MSG_ERROR( "Declared size =" << size
                  << "; virtualROBJump=" << virtualROBJump
                  << "; ROB_to_decode=" << ROB_to_decode );
    return;
  }
  p++; // Jump first word
 
  SG::ReadCondHandle<TileHid2RESrcID> hid2re{m_hid2RESrcIDKey};
 
  std::vector<float> sumE(3, 0.0);
  uint32_t idAndType, bs_frag_id;
  int frag, hash, unit;
  
  for (size_t irob = 0; irob < ROB_to_decode; ++irob) {
    for (size_t drawInRob = 0; drawInRob < virtualROBJump; ++drawInRob) {
      
      idAndType = *(p++);
      bs_frag_id = idAndType & 0xFFF;
      frag = hid2re->getOfflineFragID(bs_frag_id);
      if (frag<0) frag = bs_frag_id;
 
      hash = m_hashFunc(frag);
      if (hash > -1) {
        unit = (idAndType >> (32 - 2)) & 0x3;
        sumE[0] = Frag5_unpack_bin2sum(unit, (int)(*(p++)));
        sumE[1] = Frag5_unpack_bin2sum(unit, (int)(*(p++)));
        sumE[2] = Frag5_unpack_bin2sum(unit, (int)(*(p++)));
        
        (v[hash])->setEt(std::vector<float>(sumE)); //copy since looping
      } else {
        p += 3;
      }
    } // End of drawInRob loop
  } // End of rob loop
  
}

fillContainer_TileMuRcv_Decision()

void TileROD_Decoder::fillContainer_TileMuRcv_Decision	(	const ROBData *	rob,
		TileMuonReceiverContainer &	v ) const

Definition at line 4623 of file TileROD_Decoder.cxx.

                                                                                                                {
 
  ATH_MSG_DEBUG( "TileROD_Decoder::fillContainer_TileMuRcv_Decision" );
 
  int wc          = 0;
  bool b_sof      = false;
  bool b_deciTmdb = false;
 
  uint32_t version  = rob->rod_version() & 0xFFFF;
  uint32_t sourceid = rob->rod_source_id();
  int size          = rob->rod_ndata();
  int offset        = 0;
 
  uint32_t sfrag_version = 0x0;
  uint32_t sfrag_type    = 0x0;
  int sfrag_size         = 0;
 
  const uint32_t *p = get_data(rob);
  std::vector<const uint32_t *> pFragTmdb;
 
  ATH_MSG_DEBUG( " Trying DECODER over source ID: " << MSG::hex
                << " 0x" << sourceid << MSG::dec
                << " full fragment size " << size );
 
  while ( wc < size ) { // iterator over all words in a ROD
    // first word is the start of the tile subfragment in v3format it is 0xff1234ff
    if ((*p) == 0xff1234ff)  b_sof=true;
 
    ATH_MSG_DEBUG( " start of sub-fragment word : " << MSG::hex << (*p) << MSG::dec << " false/true : " << b_sof );
 
    if (b_sof) {
      // second word is frag size
      sfrag_size = *(p + 1);
      // third word is frag version [31-16] and type [15-0]
      sfrag_version = *(p + 2) & 0xFFFF;
      sfrag_type = *(p + 2) >> 16;
      b_sof = false;
    }
    // for tmdb we will start to have three sub-fragments ordered as 0x40 0x41 0x42
    // we investigate if there are any of type 0x40,0x41 before going on 0x42
    // like this the loop is faster since we can access the size of this two sub-fragments
    if (sfrag_type == 0x40) {
      ATH_MSG_DEBUG( MSG::hex << " DECODER sub-fragment VERSION=" << sfrag_version
                    << " TYPE=" << sfrag_type << MSG::dec
                    << " SIZE=" << sfrag_size
                    << " FOUND! Keep on looking for 0x42.");
      offset = sfrag_size;
      wc += offset;
      p += offset;
    } else if (sfrag_type == 0x41) {
      ATH_MSG_DEBUG( MSG::hex << " DECODER sub-fragment VERSION=" << sfrag_version
                    << " TYPE=" << sfrag_type << MSG::dec
                    <<" SIZE=" << sfrag_size
                    << " FOUND! Keep on looking for 0x42.");
      offset = sfrag_size;
      wc += offset;
      p += offset;
    } else if (sfrag_type == 0x42) {
      b_deciTmdb = true;
      ATH_MSG_DEBUG( MSG::hex << " DECODER sub-fragment VERSION=" << sfrag_version
                    << " TYPE=" << sfrag_type << MSG::dec
                    << " SIZE=" <<sfrag_size << " FOUND!");
      wc += size - wc;
      p += 3;
    } else {
      ++p;
      ++wc;
    }
  }
  // the TMDB result    0x42
  //
  if (b_deciTmdb) unpack_frag42( sourceid, version, p, sfrag_size-3, cont);
 
return;
}

fillTileLaserObj()

void TileROD_Decoder::fillTileLaserObj	(	const ROBData *	rob,
		TileLaserObject &	v ) const

Definition at line 3302 of file TileROD_Decoder.cxx.

                                                                                     {
  // v.setBCID(-999);  // TileLaserObject default tag -> Laser only if BCID != -999
  
  uint32_t version = rob->rod_version() & 0xFFFF;
 
  uint32_t error = 0;
  uint32_t wc = 0;
  uint32_t size = data_size(rob, error);
  const uint32_t * p = get_data(rob);
  
  ATH_MSG_DEBUG(" Version = " << version <<
                " wc = "      << wc      <<
                " size = "    << size    <<
                " pointer = " << p );
 
  if (!size) {
    ATH_MSG_DEBUG(" Nothing to unpack");
    return;
  }
  
  uint32_t sizeOverhead = 2;
  bool V3format = (*(p) == 0xff1234ff); // additional frag marker since Sep 2005
  if (!V3format && version>0) {
    V3format = true;
    if ((m_WarningCounter++) < m_maxWarningPrint)
      ATH_MSG_WARNING("fillTileLaserObj: corrupted frag separator 0x" << MSG::hex << (*p) << " instead of 0xff1234ff in ROB 0x" << rob->rod_source_id() << MSG::dec );
  }
  if (V3format) {
    ++p; // skip frag marker
    sizeOverhead = 3;
  } else {
    sizeOverhead = 2;
  }
  
  if(V3format) ATH_MSG_DEBUG("tile flag found! size overhead = " << sizeOverhead);
  else         ATH_MSG_DEBUG("tile flag not found! size overhead = " << sizeOverhead);
  
  while (wc < size) { // iterator over all words in a ROD
    // first word is frag size
    uint32_t count = *(p);
    // second word is frag ID and frag type
    int frag = *(p + 1) & 0xFFFF;
    int type = *(p + 1) >> 16;
    
    ATH_MSG_DEBUG( wc << " / " << size << " HEX = 0x" << MSG::hex << count << " DEC = " << MSG::dec << count << " ( FRAG , TYPE ) = " << frag << " , " << type );
    
    if (count < sizeOverhead || count > size - wc) {
      int cnt = 0;
      for (; wc < size; ++wc, ++cnt, ++p) {
        if ((*p) == 0xff1234ff) {
          ATH_MSG_DEBUG( "DATA POINTER: HEX = " << MSG::hex << (*p) << " DEC = " << MSG::dec << (*p) );
          ++cnt;
          ++wc;
          ++p;
          break;
        }
      }
      if ((m_ErrorCounter++) < m_maxErrorPrint) {
        msg(MSG::WARNING) << "Frag: " << MSG::hex << "0x" << frag << MSG::dec
        << " has unexpected size: " << count;
        if (wc < size) {
          msg(MSG::WARNING) << "  skiping " << cnt << " words to the next frag" << endmsg;
        } else {
          msg(MSG::WARNING) << " ignoring " << cnt << " words till the end of ROD frag" << endmsg;
        }
      }
      continue;
    }
    
    ATH_MSG_DEBUG( "DECODER" << " " << "FRAG=" << frag << " TYPE=" << type << " SIZE=" << size << " FOUND!" );
    
    if (frag == 0x16 && type == 0x20){
      
      const int LASTROD_BCID = rob->rod_bc_id();
      v.setBCID(LASTROD_BCID);
      
      if (size>29){
        ATH_MSG_DEBUG("UNPACKING FRAG16");
        unpack_frag16(version, p, v);
      } else if (size>24) {
        ATH_MSG_DEBUG("UNPACKING NEW FRAG16");
        unpack_frag17(version, sizeOverhead, p, v);
      }
    }
    
    if (frag == 0x17 && type == 0x20){
      
      const int LASTROD_BCID = rob->rod_bc_id();
      v.setBCID(LASTROD_BCID);
      
      ATH_MSG_DEBUG("UNPACKING FRAG17");
      unpack_frag17(version, sizeOverhead, p, v);
    } // IF
    
    p += count;
    wc += count;
  }
  
  if (wc != size) {
    // check word count
    if ((m_ErrorCounter++) < m_maxErrorPrint) {
      ATH_MSG_WARNING("Incorrect ROD size: " << wc << " words instead of " << size );
    }
    assert(0);
    // return;
  }
} //end of FillLaserObj

finalize()

StatusCode TileROD_Decoder::finalize ( )

virtual

Definition at line 220 of file TileROD_Decoder.cxx.

                                     {
  for (unsigned int i = 0; i < 4; ++i) {
    m_Rw2Cell[i].clear();
    m_Rw2Pmt[i].clear();
  }
  m_list_of_masked_drawers.clear();
  if (m_WarningCounter != 0) printWarningCounter(1);
  if (m_ErrorCounter != 0) printErrorCounter(1);
  return StatusCode::SUCCESS;
}

get_correct_data()

std::vector< uint32_t > TileROD_Decoder::get_correct_data ( const uint32_t * p ) const

private

Definition at line 1083 of file TileROD_Decoder.cxx.

                                                                             {
 
  uint32_t size = (*p) - 1; // The size of fragment - start of the Tile subfragment (in v3format it is 0xff1234ff)
 
  std::vector<uint32_t> data;
  data.reserve(size);
  const uint32_t* data_end = p + size;
 
  // The first 2 words (size and fragmentID with type) are correct (just copy)
  data.push_back(*p);
  data.push_back(*(++p));
 
  ++p;
  while (p < data_end) {
    uint32_t ppr_size = (*p) - 2; // The size of PPr packet
    // The first 2 words (FELIX header) of each MD fragment are correct (just copy)
    data.push_back(*(p));
    data.push_back(*(++p));
 
    ++p;
    std::for_each(p, p + ppr_size, [&data] (uint32_t v) {
      data.push_back((ntohs(v >> 16) << 16) | (ntohs(v & 0xFFFF)));
    });
 
    p += ppr_size;
  }
 
  return data;
}

get_data()

const uint32_t * TileROD_Decoder::get_data ( const ROBData * rob ) const

inlineprivate

Definition at line 609 of file TileROD_Decoder.h.

                                                         {
      const uint32_t * p;
      if (rob->rod_status_position()==0 && 
          rob->rod_nstatus() + rob->rod_header_size_word() + rob->rod_trailer_size_word() >= rob->rod_fragment_size_word()) {
        rob->rod_status(p);
      } else {
        rob->rod_data(p);
      }
      return p;
    }

getErrorCounter()

int TileROD_Decoder::getErrorCounter

(

)

Definition at line 103 of file TileROD_Decoder.cxx.

                                     {
  return m_ErrorCounter;
}

getHid2re()

const TileHid2RESrcID * TileROD_Decoder::getHid2re ( )

inline

Definition at line 214 of file TileROD_Decoder.h.

                                        {
      std::lock_guard<std::mutex> lock (m_HidMutex);
      if (!m_hid2re) initHid2re();
      return m_hid2re;
    }

getHid2reHLT()

const TileHid2RESrcID * TileROD_Decoder::getHid2reHLT ( )

inline

Definition at line 210 of file TileROD_Decoder.h.

                                           {
      return m_hid2reHLT;
    }

getOFW()

const uint32_t * TileROD_Decoder::getOFW ( int fragId, int unit ) const

private

getOFW returns Optimal Filtering Weights for Frag5 decoder loaded from COOL for correspondent units.

Coefficients automatically stored in memory, thus for next calls nothing loaded again. Once loaded in memory coefficients will be kept there and freed only by destructor method.

Definition at line 4322 of file TileROD_Decoder.cxx.

{
  if (unit >> 2) {
    ATH_MSG_WARNING( "Wrong online reconstruction units for getOFW: unit=" << unit
                    << " => assume unit=" << (unit & 3) );
    unit &= 3;
  }
  
  uint32_t drawerIdx = TileCalibUtils::getDrawerIdxFromFragId(fragId);
  size_t id = (drawerIdx << 2 | unit);
  const uint32_t* ofptr = m_OFPtrs[id];
  if (ofptr) {
    return ofptr;
  }
 
  std::lock_guard<std::mutex> lock (m_OFWeightMutex);
  ofptr = m_OFPtrs[id];
  if (ofptr) {
    return ofptr;
  }
 
  const EventContext &ctx = Gaudi::Hive::currentContext();
 
  std::vector<uint32_t>& ofw = m_OFWeights[id];
  
  ATH_MSG_DEBUG("getOFC fragId: 0x" << MSG::hex << fragId << MSG::dec << " Unit: " << unit);
  TileRawChannelUnit::UNIT chan_unit = (TileRawChannelUnit::UNIT) (unit
                                                                   + TileRawChannelUnit::OnlineOffset);
    
  bool of2 = true;
  std::vector<double> a(7), b(7), c(7), g(7), dg(7);
    
  for (int ch = 0; ch < 48; ++ch) {
    for (int gain = 0; gain < 2; ++gain) {
      float phase = -m_tileToolTiming->getSignalPhase(drawerIdx, ch, gain);
      TileOfcWeightsStruct weights;
      if (m_tileCondToolOfcCool->getOfcWeights(drawerIdx, ch, gain, phase, of2, weights, ctx).isFailure())
      {
        ATH_MSG_ERROR( "getOfcWeights fails" );
        return nullptr;
      }
        
      double calib = m_tileToolEmscale->channelCalibOnl(drawerIdx, ch, gain, 1.0, chan_unit);
        
      if (unit != 0 && gain) calib *= 64.0;
        
      for (int i = 0; i < 7; ++i) {
        a[i] = weights.w_a[i];
        b[i] = weights.w_b[i];
        c[i] = weights.w_c[i];
        g[i] = weights.g[i];
        dg[i] = weights.dg[i];
      }
      Format6(a, b, c, g, dg
              , ch // channel
              , 0 // phase = 0 poskol'ku ne ponyal kak okruglyat'
              , calib // calibration
              , ofw
              , false // verbose
              );
    } // gain
  } // ch
 
  ofptr = m_OFPtrs[id] = ofw.data();
  
  return ofptr;
}

getTileHWID()

const TileHWID * TileROD_Decoder::getTileHWID ( ) const

inline

Definition at line 187 of file TileROD_Decoder.h.

{ return m_tileHWID;}

getWarningCounter()

int TileROD_Decoder::getWarningCounter

(

)

Definition at line 99 of file TileROD_Decoder.cxx.

                                       {
  return m_WarningCounter;
}

hashFunc()

const TileFragHash * TileROD_Decoder::hashFunc ( ) const

inline

Definition at line 188 of file TileROD_Decoder.h.

{ return &m_hashFunc; }

initHid2re()

void TileROD_Decoder::initHid2re ( )

private

Definition at line 4267 of file TileROD_Decoder.cxx.

                                 {
  if (m_hid2re) return;
  
  ATH_MSG_DEBUG( "initHid2re() for run " << m_fullTileRODs );
 
  m_hid2re = new TileHid2RESrcID(m_tileHWID,m_fullTileRODs); // setting normal frag2RODmap and map dedicated to TMDB
  
  // Check whether we want to overwrite default ROB IDs
  
  SmartIF<IProperty> propertyServer{service("ByteStreamCnvSvc")};
  if (propertyServer) {
    
    std::vector<std::string> vecProp;
    StringArrayProperty vecProperty("ROD2ROBmap", vecProp);
    
    if (propertyServer->getProperty(&vecProperty).isSuccess()) {
      
      if (vecProperty.value().size() % 2 == 1) {
        ATH_MSG_DEBUG( "Length of ROD2ROBmap is and odd value, "
                       << " means that we'll scan event for all fragments to create proper map" );
        
        SmartIF<IROBDataProviderSvc> robSvc{service("ROBDataProviderSvc")};
        if (robSvc) {
          const eformat::FullEventFragment<const uint32_t*> * event = robSvc->getEvent(Gaudi::Hive::currentContext());
          try {
            event->check_tree();
            m_hid2re->setROD2ROBmap(event, m_of2Default, msg());
          } catch (...) {
            ATH_MSG_DEBUG( "Bad event, mapping might be incomplete! " );
            // bad event, but process anyhow (well, till next bug report )
            m_hid2re->setROD2ROBmap(event, m_of2Default, msg());
          }
        }
      } else if (vecProperty.value().size() == 0) {
        ATH_MSG_DEBUG( "Length of ROD2ROBmap vector is zero, "
                       << " means that predefined mapping for run " << m_fullTileRODs << " will be used " );
      } else {
        ATH_MSG_DEBUG( "Apply additional remapping for " << vecProperty.value().size()/2 << " fragments from jobOptions ");
        m_hid2re->setROD2ROBmap(vecProperty.value(), msg());
      }
    }
  }
 
  m_hid2re->printSpecial(msg());
}

initHid2reHLT()

void TileROD_Decoder::initHid2reHLT ( )

private

Definition at line 4313 of file TileROD_Decoder.cxx.

                                    {
  if (m_hid2reHLT) return;
 
  ATH_MSG_DEBUG( "initHid2reHLT() for run " << m_fullTileRODs );
 
  m_hid2reHLT = new TileHid2RESrcID(m_tileHWID,m_fullTileRODs); // setting a frag2RODmap and map dedicated to TMDB
}

initialize()

StatusCode TileROD_Decoder::initialize ( )

virtual

Definition at line 107 of file TileROD_Decoder.cxx.

                                       {
  
  m_rc2bytes5.setVerbose(m_verbose);
  m_rc2bytes2.setVerbose(m_verbose);
  m_rc2bytes.setVerbose(m_verbose);
  m_d2Bytes.setVerbose(m_verbose);
  
  // retrieve TileHWID helper from det store
  ATH_CHECK( detStore()->retrieve(m_tileHWID, "TileHWID") );
  ATH_CHECK( m_hid2RESrcIDKey.initialize() );
  
  if (m_useFrag5Raw || m_useFrag5Reco) {
    //=== get TileCondToolOfcCool
    ATH_CHECK( m_tileCondToolOfcCool.retrieve() );
    
    //=== get TileToolTiming
    ATH_CHECK( m_tileToolTiming.retrieve() );
  }
  else {
    m_tileCondToolOfcCool.disable();
    m_tileToolTiming.disable();
  }
  
  //=== get TileCondToolEmscale
  ATH_CHECK( m_tileToolEmscale.retrieve(DisableTool{m_tileToolEmscale.empty()}) );
 
  //=== get TileBadChanTool
  if ( m_tileBadChanTool.empty() ) {
    m_tileBadChanTool.disable();
  } else {
    ATH_CHECK( m_tileBadChanTool.retrieve() );
  }
 
  // Tile cabling service
  ATH_CHECK( m_cablingSvc.retrieve() );
  const TileCablingService *cablingService = m_cablingSvc->cablingService();
  m_maxChannels    = cablingService->getMaxChannels();
  m_runPeriod      = cablingService->runPeriod();
  std::ostringstream os;
  if (m_runPeriod==3) {
    if ( m_demoFragIDs.empty() ) {
      std::vector<int> v = { 0x10d }; // LBA14 is demonstrator in RUN3
      m_demoFragIDs = v;
    }
    os << " in RUN3";
  }
 
  if ( !m_demoFragIDs.empty() ) {
    std::sort(m_demoFragIDs.begin(),m_demoFragIDs.end());
    os << " (frag IDs):";
    for (int fragID : m_demoFragIDs) {
      if (fragID>0)
        os << " 0x" << std::hex << fragID << std::dec;
      else
        os << " " << fragID;
    }
    ATH_MSG_INFO("Enable channel remapping for demonstrator modules" << os.str());
  }
 
  m_Rw2Cell[0].reserve(m_maxChannels);
  m_Rw2Cell[1].reserve(m_maxChannels);
  m_Rw2Cell[2].reserve(m_maxChannels * TileCalibUtils::MAX_DRAWER);
  m_Rw2Cell[3].reserve(m_maxChannels * TileCalibUtils::MAX_DRAWER);
  m_Rw2Pmt[0].reserve(m_maxChannels);
  m_Rw2Pmt[1].reserve(m_maxChannels);
  m_Rw2Pmt[2].reserve(m_maxChannels * TileCalibUtils::MAX_DRAWER);
  m_Rw2Pmt[3].reserve(m_maxChannels * TileCalibUtils::MAX_DRAWER);
  
 
  ATH_CHECK( m_L2Builder.retrieve(DisableTool{m_L2Builder.empty()}) );
 
  updateAmpThreshold();
 
  // Initialize
  this->m_hashFunc.initialize(m_tileHWID);
  
  this->initHid2reHLT();
 
  // prepare remapping from channel numbers in demonstrator to channel numbers in legacy drawers
  if (!m_demoFragIDs.empty()) {
    for (int i=0; i<24; ++i) {
      m_demoChanLB.push_back(i);
      m_demoChanEB.push_back(i);
    }
    for (int i=24; i<48; i+=3) {
      m_demoChanLB.push_back(i+2);
      m_demoChanLB.push_back(i+1);
      m_demoChanLB.push_back(i);
    }
    m_demoChanEB.push_back(31);
    m_demoChanEB.push_back(32);
    m_demoChanEB.push_back(30);
    m_demoChanEB.push_back(35);
    m_demoChanEB.push_back(33);
    m_demoChanEB.push_back(34);
    m_demoChanEB.push_back(38);
    m_demoChanEB.push_back(37);
    m_demoChanEB.push_back(41);
    m_demoChanEB.push_back(40);
    m_demoChanEB.push_back(39);
    m_demoChanEB.push_back(36);
    for (int i=24; i<30; ++i) {
      m_demoChanEB.push_back(i);
    }
    for (int i=42; i<48; ++i) {
      m_demoChanEB.push_back(i);
    }
  }
 
  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 & TileROD_Decoder::interfaceID ( )

static

AlgTool InterfaceID.

Definition at line 83 of file TileROD_Decoder.cxx.

                                                {
  return IID_ITileROD_Decoder;
}

loadMBTS()

void TileROD_Decoder::loadMBTS	(	std::map< unsigned int, unsigned int > &	mapMBTS,
		int	MBTS_channel )

Definition at line 4261 of file TileROD_Decoder.cxx.

                                                                                            {
  m_mapMBTS = mapMBTS;
  m_MBTS_channel = MBTS_channel;
  return;
}

loadRw2Cell()

void TileROD_Decoder::loadRw2Cell ( const int section, const std::vector< int > & vec )

inline

Definition at line 179 of file TileROD_Decoder.h.

                                                                   {
      //    std::cout << vec.size() << std::endl;
      for (unsigned int i = 0; i < vec.size(); ++i) {
        //  std::cout << vec[i] << std::endl;
        m_Rw2Cell[section].push_back(vec[i]);
      }
    }

loadRw2Pmt()

void TileROD_Decoder::loadRw2Pmt ( const int section, const std::vector< int > & vec )

inline

Definition at line 196 of file TileROD_Decoder.h.

                                                                  {
      for (unsigned int i = 0; i < vec.size(); ++i) {
        //  std::cout << vec[i] << std::endl;
        m_Rw2Pmt[section].push_back(vec[i]);
      }
    }

make_copy() [1/7]

void TileROD_Decoder::make_copy ( const ROBData * rob, pBeamVec & pBeam, TileBeamElemCollection & v ) const

inlineprivate

Definition at line 865 of file TileROD_Decoder.h.

                                      {
  copy_vec(pBeam, v);
 
  v.setLvl1Id(rob->rod_lvl1_id());
  v.setLvl1Type(rob->rod_lvl1_trigger_type());
  v.setDetEvType(rob->rod_detev_type());
  v.setRODBCID(rob->rod_bc_id());
}

make_copy() [2/7]

void TileROD_Decoder::make_copy ( const ROBData * rob, pBeamVec & pBeam, TileCellCollection & v ) const

inlineprivate

Definition at line 890 of file TileROD_Decoder.h.

                                {
  // do nothing
  delete_vec(pBeam);
}

make_copy() [3/7]

void TileROD_Decoder::make_copy ( const ROBData * rob, pBeamVec & pBeam, TileDigitsCollection & v ) const

inlineprivate

Definition at line 876 of file TileROD_Decoder.h.

                                  {
  // do nothing
  delete_vec(pBeam);
}

make_copy() [4/7]

void TileROD_Decoder::make_copy ( const ROBData * rob, pBeamVec & pBeam, TileRawChannelCollection & v ) const

inlineprivate

Definition at line 883 of file TileROD_Decoder.h.

                                      {
  // do nothing
  delete_vec(pBeam);
}

make_copy() [5/7]

void TileROD_Decoder::make_copy ( uint32_t bsflags, TileFragHash::TYPE rChType, TileRawChannelUnit::UNIT rChUnit, DigitsMetaData_t & digitsMetaData, RawChannelMetaData_t & rawchannelMetaData, const ROBData * rob, pDigiVec & pDigits, pRwChVec & pChannel, TileBeamElemCollection & v, TileBeamElemContainer * container ) const

inlineprivate

Definition at line 850 of file TileROD_Decoder.h.

{
  // do nothing
  delete_vec(pDigits);
  delete_vec(pChannel);
}

make_copy() [6/7]

void TileROD_Decoder::make_copy ( uint32_t bsflags, TileFragHash::TYPE rChType, TileRawChannelUnit::UNIT rChUnit, DigitsMetaData_t & digitsMetaData, RawChannelMetaData_t & rawchannelMetaData, const ROBData * rob, pDigiVec & pDigits, pRwChVec & pChannel, TileDigitsCollection & v, TileDigitsContainer * container ) const

inlineprivate

Definition at line 705 of file TileROD_Decoder.h.

{
  copy_vec(pDigits, v); // Digits stored
 
  if (pChannel.size() > 0) { // RawChannels deleted
    delete_vec(pChannel);
  }
 
  v.setLvl1Id(rob->rod_lvl1_id());
  v.setLvl1Type(rob->rod_lvl1_trigger_type());
  v.setDetEvType(rob->rod_detev_type());
  v.setRODBCID(rob->rod_bc_id());
 
  uint32_t status = TileFragStatus::ALL_OK;
  for (size_t j=0; j<digitsMetaData[6].size(); ++j) {
    status |= digitsMetaData[6][j];
  }
 
  if (v.size() > 0) {
    // Set meta data
    v.setFragSize(digitsMetaData[0][0]);
    v.setFragBCID(digitsMetaData[0][2] | (status<<16));
 
    v.setFragExtraWords(digitsMetaData[1]);
 
    v.setFragChipHeaderWords(digitsMetaData[2]);
    v.setFragChipCRCWords(digitsMetaData[3]);
 
    if (v.isCalibMode()) {
      v.setFragChipHeaderWordsHigh(digitsMetaData[4]);
      v.setFragChipCRCWordsHigh(digitsMetaData[5]);
    }
    if (m_verbose) v.printExtra();
  } else if ( digitsMetaData[0].size() == 0 ) {
    // no useful digi fragment or no data inside fragment
    status |= TileFragStatus::NO_FRAG;
    v.setFragBCID(0xDEAD | (status<<16));
    v.setFragSize(0);
  }
 
  if (status!=TileFragStatus::ALL_OK)
    ATH_MSG_DEBUG( "Status for drawer 0x" << MSG::hex << v.identify() << " in Digi frag is 0x" << status << MSG::dec);
}

make_copy() [7/7]

void TileROD_Decoder::make_copy ( uint32_t bsflags, TileFragHash::TYPE rChType, TileRawChannelUnit::UNIT rChUnit, DigitsMetaData_t & digitsMetaData, RawChannelMetaData_t & rawchannelMetaData, const ROBData * rob, pDigiVec & pDigits, pRwChVec & pChannel, TileRawChannelCollection & v, TileRawChannelContainer * container ) const

inlineprivate

Definition at line 759 of file TileROD_Decoder.h.

{
  if (pChannel.size() > 0) { // take available raw channels
                             // and store in collection
    if (container) {
      ATH_MSG_VERBOSE( "RawChannel unit is " << rChUnit
                      << "  - setting unit in TileRawChannelContainer " );
      container->set_unit(rChUnit);
      container->set_type(rChType);
      container->set_bsflags(bsflags);
    } else {
      ATH_MSG_ERROR( "Can't set unit=" << rChUnit << " in TileRawChannelContainer" );
    }
 
    copy_vec(pChannel, v);
 
    if (pDigits.size() > 0) delete_vec(pDigits); // Digits deleted
 
  } else {
 
    if (pDigits.size() > 0) { // convert digits to raw channels
                              // and store directly in collection
      ATH_MSG_VERBOSE( " No reco frag in BS " );
      //m_RCBuilder->build(pDigits.begin(),pDigits.end(),(&v));
 
      delete_vec(pDigits); // Digits deleted
 
    } else {
      ATH_MSG_DEBUG( "data for drawer 0x" << MSG::hex << v.identify() << MSG::dec << " not found in BS" );
    }
    rawchannelMetaData[6].push_back(TileFragStatus::NO_FRAG);
    HWIdentifier drawerID = m_tileHWID->drawer_id(v.identify());
    for (unsigned int ch = 0; ch < m_maxChannels; ++ch) {
      HWIdentifier adcID = m_tileHWID->adc_id(drawerID, ch, 0);
      v.push_back(new TileRawChannel(adcID, 0.0, -100.0, 31));
    }
 
  }
 
  v.setLvl1Id(rob->rod_lvl1_id());
  v.setLvl1Type(rob->rod_lvl1_trigger_type());
  v.setDetEvType(rob->rod_detev_type());
  v.setRODBCID(rob->rod_bc_id());
 
  if (rChUnit < TileRawChannelUnit::OnlineOffset && rChType > TileFragHash::OptFilterDsp) { // set good status for BS from MC
    rawchannelMetaData[0].push_back(0);
    rawchannelMetaData[0].push_back(0xDEAD);
    rawchannelMetaData[5].push_back(0xFFFF);
    rawchannelMetaData[5].push_back(0xFFFF);
  }
 
  for (unsigned int i = 0; i < 6; ++i) {
    for (size_t j=rawchannelMetaData[i].size(); j<2; ++j) {
      rawchannelMetaData[i].push_back(0);
    }
  }
 
  uint32_t status = (rawchannelMetaData[0][0] & 0x1) ? TileFragStatus::CRC_ERR : TileFragStatus::ALL_OK ;
  for (size_t j=0; j<rawchannelMetaData[6].size(); ++j) {
    status |= rawchannelMetaData[6][j];
  }
  if (status>TileFragStatus::CRC_ERR)
    ATH_MSG_DEBUG( "Status for drawer 0x" << MSG::hex << v.identify() << " is 0x" << status << MSG::dec);
 
  v.setFragGlobalCRC(status);
  v.setFragDSPBCID(rawchannelMetaData[0][1]);
  v.setFragBCID(rawchannelMetaData[1][0]);
  v.setFragMemoryPar(rawchannelMetaData[1][1]);
  v.setFragSstrobe(rawchannelMetaData[2][0]);
  v.setFragDstrobe(rawchannelMetaData[2][1]);
  v.setFragHeaderBit(rawchannelMetaData[3][0]);
  v.setFragHeaderPar(rawchannelMetaData[3][1]);
  v.setFragSampleBit(rawchannelMetaData[4][0]);
  v.setFragSamplePar(rawchannelMetaData[4][1]);
  v.setFragFEChipMask(rawchannelMetaData[5][0]);
  if (std::binary_search(m_demoFragIDs.begin(), m_demoFragIDs.end(), v.identify()))
    v.setFragRODChipMask(rawchannelMetaData[5][0]);
  else
    v.setFragRODChipMask(rawchannelMetaData[5][1]);
}

make_copyHLT()

uint32_t TileROD_Decoder::make_copyHLT ( bool of2, TileRawChannelUnit::UNIT rChUnit, bool correctAmplitude, const FRwChVec & pChannel, TileCellCollection & v, const uint16_t DQuality, D0CellsHLT & d0cells, TileCellCollection * MBTS ) const

private

Definition at line 3581 of file TileROD_Decoder.cxx.

{
  typedef FRwChVec::const_iterator ITERATOR;
  // int gain = 0;
  float ener, time, qual = 0;
  TileCell* pCell;
  std::vector<TileCell*> cell2Double;
  cell2Double.reserve(23);
 
  uint32_t error = 0;
 
  if (DQuality == 0xffff) error |= 0x80000;
  
  TileRawChannelCollection::ID frag_id = (v.identify() & 0x0FFF);
  int ros = (frag_id >> 8);
  int drawer = (frag_id & 0x3F);
  int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
  unsigned int channelIdx;
  unsigned int adcIdx;
  bool recalibrate = (rChUnit != TileRawChannelUnit::OnlineMegaElectronVolts && rChUnit != TileRawChannelUnit::MegaElectronVolts);
  
  int sec = ros - 1; // 0-3 for barrel +/- and EB +/-
  
  if (pChannel.size() > 0) { // convert raw channels to cells
    
    // Zero all cell energies
    /*
    for (unsigned int cell = 0; cell < v.size(); ++cell) {
      ((TileCell*) v[cell])->setEnergy_nonvirt(0.0F, 0.0F, 0, CaloGain::INVALIDGAIN);
      ((TileCell*) v[cell])->setTime_nonvirt(-100.0F); // Just to mark a non-initialized cell
      ((TileCell*) v[cell])->setQuality_nonvirt(static_cast<unsigned char>(255), 0, 0);
      ((TileCell*) v[cell])->setQuality_nonvirt(static_cast<unsigned char>(255), 0, 1);
    }
    */
 
    for (TileCell* cell : v) {
      cell->setEnergy_nonvirt(0.0F, 0.0F, 0, CaloGain::INVALIDGAIN);
      cell->setTime_nonvirt(-100.0F); // Just to mark a non-initialized cell
      cell->setQuality_nonvirt(static_cast<unsigned char>(255), 0, 0);
      cell->setQuality_nonvirt(static_cast<unsigned char>(255), 0, 1);
    }
 
 
    int idxraw = drawer * m_maxChannels;
    
    ITERATOR rawItr = pChannel.begin();
    ITERATOR end = pChannel.end();
    
    if (sec < 2) { // special treatment of first PMT in pos/neg barrel which belongs to D0 cell
      idxraw = 0;
      channelIdx = rawItr->channel();
      bool no_dmu_mask = true;
      if (DQuality) {
        if (DQuality >> (channelIdx / 3) & 0x1) no_dmu_mask = false;
      }
      
      adcIdx = rawItr->adc();
      qual = rawItr->quality();
      bool do_mask = false;
      if ((qual < QUALITY_THRESHOLD) && no_dmu_mask) {
        ener = rawItr->amplitude();
        time = rawItr->time();
        // FIXME:: To speed up HLT processing we keep OnlineMegaElectronVolts
        // but this means that we can end up with different units (online or offline)
        if (recalibrate && ener!=0.0F) {
          ener = m_tileToolEmscale->channelCalib(drawerIdx, channelIdx, adcIdx, ener, rChUnit,
                                                 TileRawChannelUnit::MegaElectronVolts);
        }
        // parabolic correction for good but slightly out-of-time signals
        if (correctAmplitude) {
          if (time<m_allowedTimeMin || time>m_allowedTimeMax) {
            ener = 0.0F;
            time = 0.0F;
          } else if (ener > m_ampMinThresh_MeV
                     && time > m_timeMinThresh
                     && time < m_timeMaxThresh) {
            ener *= TileRawChannelBuilder::correctAmp(time,of2);
          }
        }
      } else {
        // ignore energy from bad channel
        ener = 0.0F;
        time = 0.0F;
        do_mask = true;
      }
      
      if (sec > 0) { // sec=1 - negative
        d0cells.m_D0channeg[drawer].set(channelIdx, adcIdx, ener, time, qual);
        d0cells.m_D0Existneg[drawer] = true;
        d0cells.m_D0Maskneg[drawer] = do_mask;
      } else { // sec=0 - positive
        d0cells.m_D0chanpos[drawer].set(channelIdx, adcIdx, ener, time, qual);
        d0cells.m_D0Existpos[drawer] = true;
        d0cells.m_D0Maskpos[drawer] = do_mask;
      }
      ++rawItr; // done with first channel in barrel, go to second
      ++idxraw;
    }
    
    int MBTS_chan=((ros>2)?-1:43);
    
    for (; rawItr != end; ++rawItr) {
      const TileFastRawChannel* rawPtr = &*rawItr;
      const int rw2cell = m_Rw2Cell[sec][idxraw];
      if (rw2cell != -1) {
        // Get Variables
        pCell = v[rw2cell];
        channelIdx = rawPtr->channel();
        bool no_dmu_mask = true;
        if (DQuality) {
          if (DQuality >> (channelIdx / 3) & 0x1) no_dmu_mask = false;
        }
        adcIdx = rawPtr->adc();
        qual = rawPtr->quality();
        time = 0.0F;
        if (no_dmu_mask && (qual < QUALITY_THRESHOLD)) {
          // gain = adcIdx;
          ener = rawPtr->amplitude();
          time = rawPtr->time();
          // FIXME:: To speed up HLT processing we keep OnlineMegaElectronVolts
          // but this means that we can end up with different units (online or offline)
          if (recalibrate && ener!=0.0F) {
            ener = m_tileToolEmscale->channelCalib(drawerIdx, channelIdx, adcIdx, ener, rChUnit,
                                                   TileRawChannelUnit::MegaElectronVolts);
          }
          // parabolic correction for good but slightly out-of-time signals
          if (correctAmplitude) {
            if (time<m_allowedTimeMin || time>m_allowedTimeMax) {
              ener = 0.0F;
              time = 0.0F;
            } else if (ener > m_ampMinThresh_MeV
                       && time > m_timeMinThresh
                       && time < m_timeMaxThresh) {
              ener *= TileRawChannelBuilder::correctAmp(time,of2);
            }
          }
          unsigned char qbit = qbitfun(time,m_allowedTimeMin,m_allowedTimeMax);
          if (pCell->time() != -100.0F) pCell->setTime(time, m_Rw2Pmt[sec][idxraw]);
          else pCell->setTime_nonvirt(time);
          
          pCell->setQuality_nonvirt(std::min(255, abs((int) qual)), qbit, m_Rw2Pmt[sec][idxraw]);
          pCell->addEnergy(ener, m_Rw2Pmt[sec][idxraw], adcIdx);
          
          if (pCell->caloDDE()->onl2() == TileHWID::NOT_VALID_HASH)
            pCell->setQuality_nonvirt(0, 0, 1);
          
        } else if (pCell->caloDDE()->onl2() != TileHWID::NOT_VALID_HASH) {
          pCell->addEnergy(0.0F, m_Rw2Pmt[sec][idxraw], 0U);
          pCell->setQuality_nonvirt((unsigned char) 255, 0, m_Rw2Pmt[sec][idxraw]);
          cell2Double.push_back(pCell); // have to double later
        } else { // Mask it here for Gap
          // (pCell)->setEnergy_nonvirt(0.0F, 0.0F, 0, CaloGain::INVALIDGAIN);
          pCell->setTime_nonvirt(0.0F);
          pCell->setQuality_nonvirt(static_cast<unsigned char>(qual), 0, 1);
        }
      } else if (MBTS_chan<0) MBTS_chan=rawPtr->channel();// end of if
      ++idxraw;
      //if ( DQuality ) idxraw1++;
    } // End of for TileRawChannel
    
    if (MBTS_chan==4) { // assign zero energy and high gain  to second PMT in special C10
      pCell = v[m_Rw2Cell[sec][5]]; // find cell with channel 5 connected
      pCell->addEnergy(0., 1-m_Rw2Pmt[sec][5], 1);
    }
 
    if (MBTS && MBTS_chan >= 0) {
      auto it = m_mapMBTS.find (frag_id);
      unsigned int idx = it != m_mapMBTS.end() ? it->second : 0u;
      if (idx < (*MBTS).size()) { // MBTS present (always last channel)
        TileCell* pCell = (*MBTS)[idx];
        const TileFastRawChannel& rawCh = pChannel[MBTS_chan];
        channelIdx = rawCh.channel();
        adcIdx = rawCh.adc();
        float ener = rawCh.amplitude();
        float time = rawCh.time();
        float qual = rawCh.quality();
        if (qual < QUALITY_THRESHOLD) {
          if (rChUnit==TileRawChannelUnit::MegaElectronVolts) { // go back to pC - not standard configuration
            ener /= m_tileToolEmscale->channelCalib(drawerIdx, channelIdx, adcIdx, 1.0, // calibrate to PicoCoulombs
                                                    TileRawChannelUnit::PicoCoulombs, rChUnit);
          } else {
            ener = m_tileToolEmscale->channelCalib(drawerIdx, channelIdx, adcIdx, ener, // calibrate to PicoCoulombs
                                                   rChUnit, TileRawChannelUnit::PicoCoulombs);
          }
          // parabolic correction for good but slightly out-of-time signals
          if (correctAmplitude) {
            if (time<m_allowedTimeMin || time>m_allowedTimeMax) {
              ener = 0.0F;
              time = 0.0F;
            } else if (ener > m_ampMinThresh_pC
                       && time > m_timeMinThresh
                       && time < m_timeMaxThresh) {
              ener *= TileRawChannelBuilder::correctAmp(time,of2);
            }
          }
        } else {
          // ignore energy from bad channel
          ener = 0.0F;
          time = -100.0F;
        }
        pCell->setEnergy(ener, 0.0F);
        pCell->setTime_nonvirt(time);
        unsigned char qbit = qbitfun(time,m_allowedTimeMin,m_allowedTimeMax);
        pCell->setQuality_nonvirt(std::min(255, abs((int) qual)), qbit, 0);
      } // End of if idx
      
    } // End of if MBTS
    
  } // end of if vec<TileRawChannel>::size > 0)
  
  for (std::vector<TileCell*>::const_iterator d_it = cell2Double.begin();
       d_it != cell2Double.end(); ++d_it) {
    
    //    int gain = 0;
    //    if ((*d_it)->gain1() == 1 || (*d_it)->gain2() == 1) gain = 1;
    int gain = (*d_it)->gain1() | (*d_it)->gain2();
    unsigned char qual = (*d_it)->qual1() & (*d_it)->qual2();
 
    float ener = (*d_it)->e();
    float time = (*d_it)->time();
    unsigned char qbit = qbitfun(time,m_allowedTimeMin,m_allowedTimeMax);
    
    (*d_it)->setEnergy_nonvirt(ener, ener, gain, gain);
    (*d_it)->setQuality_nonvirt(qual, qbit, 0);
    (*d_it)->setQuality_nonvirt(qual, qbit, 1);
    if (time == -100.0F) (*d_it)->setTime_nonvirt(0.0F);
  }
 
  return error;
}

mergeD0cellsHLT()

void TileROD_Decoder::mergeD0cellsHLT	(	const D0CellsHLT &	d0cells,
		TileCellCollection &	v ) const

Definition at line 4192 of file TileROD_Decoder.cxx.

{
  TileRawChannelCollection::ID frag_id = (v.identify() & 0x0FFF);
  int ros = (frag_id >> 8);
  bool barrel ( (ros==1) || (ros==2) );
  if ( !barrel ) return; // Only in barrel
  int drawer = (frag_id & 0xFF);
  TileCell* pCell  = d0cells.m_cells[drawer];
  if ( !pCell ) return;
 
  if (d0cells.m_D0Maskpos[drawer] && d0cells.m_D0Maskneg[drawer]) {
 
    // both channels are bad - mask whole cell
    (pCell)->setEnergy_nonvirt(0.0F, 0.0F, 0, 0);
    (pCell)->setTime_nonvirt(0.0F);
    (pCell)->setQuality_nonvirt(static_cast<unsigned char>(255), 0, 0);
    (pCell)->setQuality_nonvirt(static_cast<unsigned char>(255), 0, 1);
 
  } else if (d0cells.m_D0Maskpos[drawer]) {
 
    // first(positive) channel is bad, second(negative) is good
    float amp2 = d0cells.m_D0channeg[drawer].amplitude();
    float time2 = d0cells.m_D0channeg[drawer].time();
    int gain2 = d0cells.m_D0channeg[drawer].adc();
    unsigned char qual2 = d0cells.m_D0channeg[drawer].quality();
    unsigned char qbit2 = qbitfun(time2,m_allowedTimeMin,m_allowedTimeMax);
 
    (pCell)->setEnergy(amp2, amp2, gain2, gain2);
    (pCell)->setTime(time2);
    (pCell)->setQuality(qual2, qbit2, 0);
    (pCell)->setQuality(qual2, qbit2, 1);
 
  } else {
 
    // first(positive) channel is good
    float amp1 = d0cells.m_D0chanpos[drawer].amplitude();
    float time1 = d0cells.m_D0chanpos[drawer].time();
    int gain1 = d0cells.m_D0chanpos[drawer].adc();
    unsigned char qual1 = d0cells.m_D0chanpos[drawer].quality();
    unsigned char qbit1 = qbitfun(time1,m_allowedTimeMin,m_allowedTimeMax);
 
    if (d0cells.m_D0Maskneg[drawer]) {
 
      // second channel is bad, first is good
      (pCell)->setEnergy(amp1, amp1, gain1, gain1);
      (pCell)->setTime(time1);
      (pCell)->setQuality(qual1, qbit1, 0);
      (pCell)->setQuality(qual1, qbit1, 1);
 
    } else {
 
      // second(negative) channel is good
      float amp2 = d0cells.m_D0channeg[drawer].amplitude();
      float time2 = d0cells.m_D0channeg[drawer].time();
      int gain2 = d0cells.m_D0channeg[drawer].adc();
      unsigned char qual2 = d0cells.m_D0channeg[drawer].quality();
      unsigned char qbit2 = qbitfun(time2,m_allowedTimeMin,m_allowedTimeMax);
 
      // both channels are good
      (pCell)->setEnergy(amp1, amp2, gain1, gain2);
      (pCell)->setTime(time1);
      (pCell)->setTime(time2, 1);
      (pCell)->setQuality(qual1, qbit1, 0);
      (pCell)->setQuality(qual2, qbit2, 1);
    }
  }
}

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.

printErrorCounter()

void TileROD_Decoder::printErrorCounter

(

bool

printIfNoError

)

Definition at line 93 of file TileROD_Decoder.cxx.

                                                           {
  if (printIfNoError || m_ErrorCounter > 0) {
    ATH_MSG_WARNING( "Found " << m_ErrorCounter << " errors in decoding words");
  }
}

printWarningCounter()

void TileROD_Decoder::printWarningCounter

(

bool

printIfNoWarning

)

Definition at line 87 of file TileROD_Decoder.cxx.

                                                               {
  if (printIfNoWarning || m_WarningCounter > 0) {
    ATH_MSG_WARNING( "Found " << m_WarningCounter << " warnings in decoding words");
  }
}

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

setLaserVersion()

void TileROD_Decoder::setLaserVersion ( TileLaserObject & laserObject ) const

inline

Definition at line 175 of file TileROD_Decoder.h.

                                                              {
      laserObject.setVersion((m_runPeriod >= 2) ? -2 : -1);
    }

setUseFrag0()

void TileROD_Decoder::setUseFrag0 ( bool f )

inline

Definition at line 220 of file TileROD_Decoder.h.

{ m_useFrag0 = f; }

setUseFrag1()

void TileROD_Decoder::setUseFrag1 ( bool f )

inline

Definition at line 221 of file TileROD_Decoder.h.

{ m_useFrag1 = f; }

setUseFrag4()

void TileROD_Decoder::setUseFrag4 ( bool f )

inline

Definition at line 222 of file TileROD_Decoder.h.

{ m_useFrag4 = f; }

setUseFrag5Raw()

void TileROD_Decoder::setUseFrag5Raw ( bool f )

inline

Definition at line 223 of file TileROD_Decoder.h.

{ m_useFrag5Raw = f; }

setUseFrag5Reco()

void TileROD_Decoder::setUseFrag5Reco ( bool f )

inline

Definition at line 224 of file TileROD_Decoder.h.

{ m_useFrag5Reco = f; }

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.

unpack_brod()

void TileROD_Decoder::unpack_brod ( uint32_t version, uint32_t sizeOverhead, const uint32_t * p, pBeamVec & pBeam, int fragID ) const

private

unpack_brod decodes all ancillary tile subfragments coming from beam ROD at the testbeam or LASTROD in normal ATLAS configuration

Definition at line 2788 of file TileROD_Decoder.cxx.

{
  // first word is frag size
  int count = *(p);
  // second word is frag ID and frag type
  uint32_t idAndType = *(p + 1);
  int bs_frag = idAndType & 0xFFFF;
  bool is16ChannelType = (idAndType >> 16) & 1; // V775N, V792N
  bool is32ChannelType = (idAndType >> 17) & 1; // V775, V792
  
  p += 2; // 2 words so far
  int datasize = count - sizeOverhead; // can be 2 or 3 words less
  
  if (msgLvl(MSG::VERBOSE)) {
    msg(MSG::VERBOSE) << "Unpacking Beam Elements, ID=0x" << MSG::hex << frag_id << " BS frag=0x" << bs_frag
    << ", size=" << MSG::dec << datasize;
    for (int ch = 0; ch < datasize; ++ch) {
      if (0 == ch % 8) msg(MSG::VERBOSE) << endmsg;
      msg(MSG::VERBOSE) << p[ch] << " ";
    }
    msg(MSG::VERBOSE) << endmsg;
  }
  
  if (datasize <= 0) return;
  
  int frag = (frag_id>=0) ? frag_id : bs_frag;
  frag &= 0xff; // reset upper byte, because it's different in 2003 and 2004
  HWIdentifier drawerID = m_tileHWID->drawer_id(frag);
  TileBeamElem* rc;
  
  switch (bs_frag) {
      
      /* ************************************************************************************* */
      /*    LeCroy 1176 16bit 1ns TDC FRAG in Tile Beam crate or in Common Beam crate          */
    case BEAM_TDC_FRAG:
    case COMMON_TDC1_FRAG:
    case COMMON_TDC2_FRAG: {
      if (!(is16ChannelType || is32ChannelType)) {
        uint32_t prev = 0xFF;
        std::vector<uint32_t> adc;
        for (int c = 0; c < datasize; ++c) {
          uint32_t time = *p & 0xFFFF;
          uint32_t flag = *p >> 16;
          uint32_t chan = (flag >> 1) & 0x0F;
          uint32_t bad = (flag >> 5) & 0x01;
          if (!bad) {
            if (prev != 0xFF) {
              HWIdentifier adcID = m_tileHWID->adc_id(drawerID, prev, 0);
              rc = new TileBeamElem(adcID, adc);
              pBeam.push_back(rc);
              adc.clear();
            }
            prev = chan;
          }
          adc.push_back(time);
          ++p;
        }
        if (prev != 0xFF) {
          HWIdentifier adcID = m_tileHWID->adc_id(drawerID, prev, 0);
          rc = new TileBeamElem(adcID, adc);
          pBeam.push_back(rc);
        }
        break;
      }
      // Fall through to default
      [[fallthrough]]; // silent the warning on fall through
    }
 
      /* ************************************************************************************* */
      /*           CAEN V775 or V775N 12 bit TDC  (1count=35psec) in common beam crate           */
    case COMMON_TOF_FRAG: {
      
      uint32_t prev = 0xFF;
      std::vector<uint32_t> adc;
      for (int c = 0; c < datasize; ++c) {
        uint32_t chan = is16ChannelType ? (*p >> 17) & 0x3FF  // take 10 bits, but 6 upper bits should be 0
                                        : (*p >> 16) & 0x7FF; // take 11 bits, but 6 upper bits should be 0
        if (chan > 31) {
          continue; // skip header or end of block
        }
        uint32_t time = *p & 0x1FFF; // uppermost bit is overflow flag
        if (prev != chan && ((is16ChannelType && chan < 16) || (is32ChannelType && chan < 32))) {
          if (prev != 0xFF) {           // channel >= 32 can be only in corrupted data
            HWIdentifier adcID = m_tileHWID->adc_id(drawerID, prev, 0);
            rc = new TileBeamElem(adcID, adc);
            pBeam.push_back(rc);
            adc.clear();
          }
          prev = chan;
        }
        adc.push_back(time);
        ++p;
      }
      if ((is16ChannelType && prev < 16) || (is32ChannelType && prev < 32)) {
        HWIdentifier adcID = m_tileHWID->adc_id(drawerID, prev, 0);
        rc = new TileBeamElem(adcID, adc);
        pBeam.push_back(rc);
      }
    }
      break;
      
      /* ************************************************************************************* */
      /*                                      ADDERS FRAG                    */
    case ADD_FADC_FRAG: {
 
      uint32_t val, channel[16][16];
      int nmodule = 4, nchan, nsamp, ch;
 
      nchan = nmodule * 4;
      nsamp = datasize / nmodule;
 
      ATH_MSG_VERBOSE(" Adders: nmod=" << nmodule << ", nchan=" << nchan
                                       << ", nsamp=" << nsamp);
 
      if (nmodule * nsamp == datasize) {
        /* Unpack DATA */
        for (int m = 0; m < nmodule; ++m) {
          /* extract all samples for 4 channels in the module */
          for (int s = 0; s < nsamp; ++s) {
            val = *p;
            for (int c = 0; c < 4; ++c) {
              ch = m * 4 + c;
              if (ch < nchan)
                channel[ch][s] = val & 0xFF;
              val >>= 8;
            }
            ++p;
          }
        }
        /* ***** */
        for (ch = 0; ch < nchan; ++ch) {
          HWIdentifier adcID = m_tileHWID->adc_id(drawerID, ch, 0);
          std::vector<uint32_t> adc;
          adc.reserve(nsamp);
          for (int s = 0; s < nsamp; ++s) {
            adc.push_back(channel[ch][s]);
          }
          rc = new TileBeamElem(adcID, adc);
          pBeam.push_back(rc);
        }
      } else {
        ATH_MSG_WARNING("unpack_brod => Unexpected Adders size: " << MSG::dec
                                                                  << datasize);
        return;
      }
    } break;
 
#ifndef LASER_OBJ_FRAG
#define LASER_OBJ_FRAG   0x016
#endif
#ifndef LASER2_OBJ_FRAG
#define LASER2_OBJ_FRAG   0x017
#endif
      
    case LASER_OBJ_FRAG:
    case LASER2_OBJ_FRAG: {
      
      std::vector<uint32_t> digits;
      for (int ch = 0; ch < datasize; ++ch) {
        digits.push_back((*p));
        ++p;
      }
      HWIdentifier adcID = m_tileHWID->adc_id(drawerID, 0, 0);
      rc = new TileBeamElem(adcID, digits);
      pBeam.push_back(rc);
    }
      break;
 
    /* ************************************************************************************* */
    /*           CAEN V792 or V792N 12 bit ADC in common beam crate                      */
    case COMMON_ADC1_FRAG:
    case COMMON_ADC2_FRAG: {
 
      if (is16ChannelType || is32ChannelType) {
        uint32_t prev = 0xFF;
        std::vector<uint32_t> adc;
        for (int c = 0; c < datasize; ++c) {
          uint32_t chan = is16ChannelType ? (*p >> 17) & 0x3FF  // take 10 bits, but 6 upper bits should be 0
                                          : (*p >> 16) & 0x7FF; // take 11 bits, but 6 upper bits should be 0
 
          if (chan > 31) {
            continue; // skip header or end of block
          }
          uint32_t amplitude = *p & 0x1FFF; // uppermost bit is overflow flag
          if (prev != chan && ((is16ChannelType && chan < 16) || (is32ChannelType && chan < 32))) {
            if (prev != 0xFF) {         // channel >= 32 can be only in corrupted data
              HWIdentifier adcID = m_tileHWID->adc_id(drawerID, prev, 0);
              rc = new TileBeamElem(adcID, adc);
              pBeam.push_back(rc);
              adc.clear();
            }
            prev = chan;
          }
          adc.push_back(amplitude);
          ++p;
        }
        if ((is16ChannelType && prev < 16) || (is32ChannelType && prev < 32)) {
          HWIdentifier adcID = m_tileHWID->adc_id(drawerID, prev, 0);
          rc = new TileBeamElem(adcID, adc);
          pBeam.push_back(rc);
        }
        break;
      }
      // Fall through to default
      [[fallthrough]]; // silent the warning on fall through
    }
 
      /* ************************************************************************************* */
      /*                                   OTHER FRAGS: ONE WORD = ONE CHANNEL               */
    default: {
      
      int chmax = (datasize > 16) ? 15 : datasize;
      for (int ch = 0; ch < chmax; ++ch) {
        HWIdentifier adcID = m_tileHWID->adc_id(drawerID, ch, 0);
        rc = new TileBeamElem(adcID, (*p));
        pBeam.push_back(rc);
        ++p;
      }
      if (chmax != datasize) {
        std::vector<uint32_t> digits;
        for (int ch = chmax; ch < datasize; ++ch) {
          digits.push_back((*p));
          ++p;
        }
        HWIdentifier adcID = m_tileHWID->adc_id(drawerID, chmax, 0);
        rc = new TileBeamElem(adcID, digits);
        pBeam.push_back(rc);
      }
    }
      break;
  }
  
  return;
}

unpack_frag0()

void TileROD_Decoder::unpack_frag0 ( uint32_t version, uint32_t sizeOverhead, DigitsMetaData_t & digitsMetaData, const uint32_t * p, pDigiVec & pDigits, int frag_id, int drawer_type ) const

private

unpack_frag0 decodes tile subfragment type 0x0.

Unpack TileDigits stored in ROD.

This subfragment contains the tile raw digits from the 48 read-out channels of a tilecal module.

Assume that mode (calib/normal) is the same for every invocation.

Definition at line 246 of file TileROD_Decoder.cxx.

                                                                       {
  int gain = 0;
  int n;
  
  // pointer to current data word
  const uint32_t *data;
  // current chip #
  int chip;
  // channel #
  int channel;
  
  // first word is full frag size, first two words are not data
  int size = *(p) - sizeOverhead;
  // second word is frag ID (0x100-0x4ff) and frag type
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
  bool remap = (drawer_type > 0) || std::binary_search(m_demoFragIDs.begin(), m_demoFragIDs.end(), frag);
  const std::vector<int> & chmap = (frag<0x300) ? m_demoChanLB : m_demoChanEB;
  
  // Position of first data word, ignore 2 frag header words
  data = p + 2;
  
  uint32_t all00 = TileFragStatus::ALL_00;
  uint32_t allFF = TileFragStatus::ALL_FF;
 
  for (int i = 0; i < size; ++i) {
    uint32_t w = data[i];
    if (allFF && w!=0xFFFFFFFF) {
      allFF = TileFragStatus::ALL_OK;
      if (all00 == TileFragStatus::ALL_OK) break;
    }
    if (all00 && w != 0) {
      all00 = TileFragStatus::ALL_OK;
      if (allFF == TileFragStatus::ALL_OK) break;
    }
  }
 
  uint32_t status = (all00 | allFF);
  digitsMetaData[6].push_back( status );
 
  // check that fragment is not dummy
  if (m_suppressDummyFragments && status != TileFragStatus::ALL_OK) {
    return; // nothing reasonable found
  }
  
  // if (msgLvl(MSG::VERBOSE))
  //   msg(MSG::VERBOSE) << "version=" << version << " size: " << (*p) << " " << size;
  if (sizeOverhead == 2 && (version == 0x2 || version == 0x1)) { /* can not guess number of samples from size */
    if (size > 178 && size < 205)
      size = 179; /* we expect this number (9+2)*16+2 */
    else if (size > 274 && size < 405) size = 275; /* we expect this number (7*2+3)*16+2 */
    ++data; // ignore first word coming from drawer
  }
  
  // if (msgLvl(MSG::VERBOSE))
  //   msg(MSG::VERBOSE) << size << endmsg;
  
  // number of chips in the data, only 16 is expected
  int chipCount = 16;
  // one chip contains 3 channels
  int channelCount = chipCount * 3;
  // size of 'block'. In normal mode one block is header and chipCount words with samples and CRC word
  // In calib mode one block is header word, <chipCount> low gain samples, header, <chipCount> high gain and CRC word
  int blockSize = size / chipCount;
  // deplacement of high gain samples in calib mode
  int gainOffset = 0;
  // calculate number of words per chip including header and excluding CRC
  int wordsPerChip = 0;
  // number of data words per chip, excluding header and CRC
  int dataWordsPerChip = 0;
  // real number of channels and chips
  // int channelCountReal,chipCountReal;
  
  // Digitizer mode doesn't change between events
  static std::atomic<int> savedDigiMode = -1;
 
  int digiMode = savedDigiMode;
  
  if (digiMode < 0 && size > 0) { // try to find digi mode until good mode is found
    digiMode = m_d2Bytes.getDigiMode(data, chipCount, blockSize);
    savedDigiMode = digiMode;
  }
  
  if (digiMode > 0 || (digiMode < 0 && blockSize == 17)) {
    // calibration mode
    // 2X number of chips
    // chipCount <<= 1;
    // channelCount = chipCount*3;
    
    // lengt with header and without CRC
    wordsPerChip = (blockSize - 1) / 2;
    // lengt without header and CRC
    dataWordsPerChip = wordsPerChip - 1;
    
    //channelCountReal = channelCount/2;
    //chipCountReal = chipCount/2;
    
    gainOffset = wordsPerChip;
  } else {
    // assume normal mode
    // block contains one CRC word
    wordsPerChip = blockSize - 1;
    // one header word
    dataWordsPerChip = wordsPerChip - 1;
    
    // channelCountReal = channelCount;
    // chipCountReal = chipCount;
  }
  
  if (msgLvl(MSG::VERBOSE)) {
    msg(MSG::VERBOSE) << "Unpacking TileDigits, ID=0x" << MSG::hex << frag
    << ", size=" << MSG::dec << size << endmsg;
    
    msg(MSG::VERBOSE) << " chips=" << chipCount << endmsg;
    msg(MSG::VERBOSE) << " channels=" << channelCount << endmsg;
    msg(MSG::VERBOSE) << " block size=" << blockSize << endmsg;
    msg(MSG::VERBOSE) << " words/chip=" << wordsPerChip << endmsg;
    msg(MSG::VERBOSE) << " data/chip=" << dataWordsPerChip << endmsg;
    msg(MSG::VERBOSE) << " gain offs=" << gainOffset << endmsg;
    msg(MSG::VERBOSE) << " mode=" << digiMode << endmsg;
  }
  
  if (size == 0) {
    ATH_MSG_VERBOSE( "Size is 0, no digits extracted" );
    return;
  }
  
  TileDigits *td;
  HWIdentifier drawerID = m_tileHWID->drawer_id(frag);
  HWIdentifier adcID;
  std::array< std::vector<float>, 3 > digiVec;
  
  // take BCID from chip header with good parity
  uint32_t bcid = m_d2Bytes.getBCID(data, chipCount, blockSize);
  
  if (gainOffset > 0) {
    // calibration mode
    pDigits.reserve(96);
    std::vector<uint32_t>& chipHeaderLow = digitsMetaData[2];
    std::vector<uint32_t>& chipCRCLow = digitsMetaData[3];
    std::vector<uint32_t>& chipHeaderHigh = digitsMetaData[4];
    std::vector<uint32_t>& chipCRCHigh = digitsMetaData[5];
    
    // loop through all chips
    for (chip = 0; chip < chipCount; ++chip) {
      ATH_MSG_VERBOSE( "Unpacking calib data for chip " << chip );
      
      // Extract low gain digits for fragment
      digiVec = m_d2Bytes.getDigits(data + 1, dataWordsPerChip);
      
      for (n = 0; n < 3; ++n) {
        // calc channel #
        channel = chip * 3 + n;
        if (remap) channel = chmap[channel];
        // create ID
        adcID = m_tileHWID->adc_id(drawerID, channel, TileHWID::LOWGAIN);
        
        td = new TileDigits(adcID, digiVec[n]);
        pDigits.push_back(td);
        
      }
      if (remap) std::sort(pDigits.end()-3,pDigits.end(),chan_order);
      
      // Extract high gain digits for fragment
      digiVec = m_d2Bytes.getDigits(data + 1 + gainOffset, dataWordsPerChip);
      
      for (n = 0; n < 3; ++n) {
        // calc channel #
        channel = chip * 3 + n;
        if (remap) channel = chmap[channel];
        // create ID
        adcID = m_tileHWID->adc_id(drawerID, channel, TileHWID::HIGHGAIN);
        
        td = new TileDigits(adcID, digiVec[n]);
        pDigits.push_back(td);
        
      }
      if (remap) std::sort(pDigits.end()-3,pDigits.end(),chan_order);
      
      // store metadata
      chipHeaderLow.push_back(*data);
      chipCRCLow.push_back(*(data + gainOffset - 1));
      chipHeaderHigh.push_back(*(data + gainOffset));
      chipCRCHigh.push_back(*(data + blockSize - 1));
      
      // next block
      data += blockSize;
    }
  } else {
    // Normal mode
    pDigits.reserve(pDigits.size() + 48);
    std::vector<uint32_t>& chipHeader = digitsMetaData[2];
    std::vector<uint32_t>& chipCRC = digitsMetaData[3];
    
    // loop through all chips
    for (chip = 0; chip < chipCount; ++chip) {
      // Extract digits for fragment
      digiVec = m_d2Bytes.getDigits(data + 1, dataWordsPerChip);
      
      ATH_MSG_VERBOSE( "Header $"  << MSG::hex << (*data)
                      << " CRC $" << *(data + blockSize - 1) );
      
      for (n = 0; n < 3; ++n) {
        // calc channel #
        channel = chip * 3 + n;
        if (remap) channel = chmap[channel];
        // get gain from chip header
        gain = m_d2Bytes.getGain(data, n);
        // create ID
        adcID = m_tileHWID->adc_id(drawerID, channel, gain);
        td = new TileDigits(adcID, digiVec[n]);
        
        ATH_MSG_VERBOSE( "Frag: $" << MSG::hex << frag << MSG::dec
                        << " G:" << gain
                        << " C:" << channel
                        << " BCID: " << MSG::hex << m_d2Bytes.getBCID(data, chipCount, blockSize) << MSG::dec
                        << " Data={" << (int) digiVec[n][0]
                        << "," << (int) digiVec[n][1]
                        << "," << (int) digiVec[n][2]
                        << "," << (int) digiVec[n][3]
                        << "," << (int) digiVec[n][4]
                        << "," << (int) digiVec[n][5]
                        << "," << (int) digiVec[n][6] << "}" );
        
        
        pDigits.push_back(td);
        
      }
      
      // store some metadata, first word in chip is header, last is CRC
      chipHeader.push_back(*data);
      chipCRC.push_back(*(data + blockSize - 1));
      
      // go to next block
      data += blockSize;
    }
    if (remap) std::sort(pDigits.end()-channelCount,pDigits.end(),chan_order);
  }
  
  int extra = size - (data - p) + 2;
  
  // check size of fragment - we expect 2 extra words (DMU mask and CRC) or more!
  if (extra < 2) {
    if ((m_ErrorCounter++) < m_maxErrorPrint) {
      ATH_MSG_WARNING( "Too short fragment ! Expected at least " << MSG::dec << (data - p)
                      << " data words, while size from header is " << size
                      << " data words (plus " << sizeOverhead << " words overhead)" );
    }
  }
  
  if (msgLvl(MSG::VERBOSE)) {
    msg(MSG::VERBOSE) << "Trailer 0x" << MSG::hex
    << data[0] << " 0x" << data[1];
    for (int i = 2; i < extra; ++i) {
      msg(MSG::VERBOSE) << " 0x" << data[i];
    }
    msg(MSG::VERBOSE) << MSG::dec << endmsg;
    
    // check frag trailer
    if (extra > 0) {
      if ((data[0] & 0xffff) != (data[0] >> 16)) {
        msg(MSG::VERBOSE) << MSG::hex << "Trailer numbers do not match: "
        << data[0] << MSG::dec << endmsg;
      } else {
        if ((data[0] & 0xffff) == 0xffff)
          msg(MSG::VERBOSE) << "Found barrel trailer" << endmsg;
        else if ((data[0] & 0xffff) == 0xfff)
          msg(MSG::VERBOSE) << "Found extended barrel trailer" << endmsg;
        else
          msg(MSG::VERBOSE) << MSG::hex << "Unexpected trailer number: "
          << (data[0] & 0xffff) << MSG::dec << endmsg;
      }
    }
    
    // check CRC trailer
    if (extra > 1) {
      if ((data[1] & 0xffff) != (data[1] >> 16)) {
        msg(MSG::VERBOSE) << "Trailer CRC numbers do not match" << endmsg;
      } else {
        msg(MSG::VERBOSE) << MSG::hex << "Found CRC 0x" << (data[1] & 0xffff)
        << MSG::dec << endmsg;
      }
    }
  }
  
  // store metadata for this collection
  // size, fragID, BCID,  DMU Mask, CRC and other extra words
  digitsMetaData[0].push_back(size);
  digitsMetaData[0].push_back(frag);
  digitsMetaData[0].push_back(bcid);
  for (int i = 0; i < extra; ++i) {
    digitsMetaData[1].push_back(data[i]);
  }
  if (sizeOverhead == 2 && (version == 0x2 || version == 0x1)) { // keep also first skipped word
    digitsMetaData[1].push_back(p[2]);
  }
  
  if (dataWordsPerChip > 15) { // can not be true !!!
    savedDigiMode = -1; // check again digiMode in next fragment
  }
}

unpack_frag1()

void TileROD_Decoder::unpack_frag1 ( uint32_t version, uint32_t sizeOverhead, DigitsMetaData_t & digitsMetaData, const uint32_t * p, pDigiVec & pDigits, int fragID, int demoType ) const

private

unpack_frag1 decodes tile subfragment type 0x1.

This subfragment contains the tile raw digits ONLY from the existing channels of a tilecal module.

(not implemented yet).

Definition at line 551 of file TileROD_Decoder.cxx.

                                                                       {
  // first word is full frag size, first two words are not data
  int size = *(p) - sizeOverhead;
  // second word is frag ID (0x100-0x4ff) and frag1 type (old and new version).
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
  bool remap = (drawer_type > 0) || std::binary_search(m_demoFragIDs.begin(), m_demoFragIDs.end(), frag);
  const std::vector<int> & chmap = (frag<0x300) ? m_demoChanLB : m_demoChanEB;
  int frag1version = (*(p + 1) >> 31) & 0x1;
  int nbchanformat1 = ((*(p + 1)) >> 24) & 0x3F;
  
  // store metadata for this collection
  // size, fragID, BCID
  digitsMetaData[0].push_back(size);
  digitsMetaData[0].push_back(frag);
  digitsMetaData[0].push_back(0);
  
  if (frag1version == 0) { //Old version
    p += 2; // 2 words so far
    
    int nsamp = (*(p) >> 8) & 0x0F; // find number of samples in first data word
    int words_per_chan = nsamp + 1; // one extra 16bit word with channel number
    int nchan = 2 * size / words_per_chan;
    
    if (2 * size != nchan * words_per_chan || nchan <= 0 || nchan > 48) {
      if ((m_ErrorCounter++) < m_maxErrorPrint) {
        ATH_MSG_WARNING( "Digi frag type=1 fragId=0x" << MSG::hex << frag << MSG::dec
                         << " Nsamp=" << nsamp
                         << " Nchan=" << nchan
                         << " Wrong Size=" << size );
      }
      return;
    }
    
    HWIdentifier drawerID = m_tileHWID->drawer_id(frag);
    std::vector<float> digiVec(nsamp);
    pDigits.reserve(nchan);
    
    const uint16_t* p16 = reinterpret_cast<const uint16_t *>(p);
    
    for (int ch = 0; ch < nchan; ++ch) {
      
      int channel = (*p16) & 0xFF;
      if (remap) channel = chmap[channel];
      int nsamp1 = (*(p16) >> 8) & 0x0F;
      int gain = (*p16) >> 15;
      ++p16;
      
      for (int samp = 0; samp < nsamp; ++samp) {
        digiVec[samp] = *p16++;
      }
      
      if (channel < 48 && nsamp1 == nsamp) {
        HWIdentifier adcID = m_tileHWID->adc_id(drawerID, channel, gain);
        TileDigits * td = new TileDigits(adcID, digiVec);
        pDigits.push_back(td);
      } else {
        if ((m_ErrorCounter++) < m_maxErrorPrint) {
          ATH_MSG_WARNING( "Digi frag type=1 fragId=0x" << MSG::hex << frag << MSG::dec
                           << " CHind=" << ch
                           << " channel=" << channel
                           << " nsamp=" << nsamp1 << "/" << nsamp );
        }
      }
      
      if (msgLvl(MSG::VERBOSE)) {
        msg(MSG::VERBOSE) << MSG::hex << "Frag: $" << frag << MSG::dec
        << " G:" << gain
        << " C:" << channel
        << " Data={";
        for (int samp = 0; samp < nsamp; ++samp) {
          msg(MSG::VERBOSE) << " " << (int) digiVec[samp];
        }
        msg(MSG::VERBOSE) << "}  " << MSG::hex;
        for (int samp = 0; samp < nsamp / 2 + 1; ++samp) {
          msg(MSG::VERBOSE) << (int) *p++ << " ";
        }
        msg(MSG::VERBOSE) << MSG::dec << endmsg;
      }
    }
  } //End of old version
  
  else if (frag1version == 1) { //New version
    p += 2; // 2 words so far
    
    int nsamp = 7; // New frag1 only for 7 samples
    int SizeOfFrag1 = size * 2; // Number of 16 bit words
    int nbchanformat2 = (SizeOfFrag1 - (3 * nbchanformat1)) / 5;
    
    int nchan = nbchanformat1 + nbchanformat2;
    
    if ((nchan) > 48 || ((nbchanformat1 * 3) + (nbchanformat2 * 5) > SizeOfFrag1)) {
      if ((m_ErrorCounter++) < m_maxErrorPrint) {
        ATH_MSG_WARNING( "Digi frag type=1 fragId=0x" << MSG::hex << frag << MSG::dec
                         << " frag1Version=" << frag1version
                         << " Nsamp=" << nsamp
                         << " NchanFormat1=" << nbchanformat1
                         << " NchanFormat2=" << nbchanformat2
                         << " Wrong Size=" << size);
      }
      return;
    }
    
    HWIdentifier drawerID = m_tileHWID->drawer_id(frag);
    std::vector<float> digiVec(nsamp);
    pDigits.reserve(nchan);
    pDigiVec sDigits(48);
    
    int ptr16index = 1;
    int channel = 0;
    uint16_t word1 = 0;
    uint16_t word2 = 0;
    uint16_t word3 = 0;
    uint16_t word4 = 0;
    uint16_t word5 = 0;
    
    for (int chf1 = 0; chf1 < nbchanformat1; ++chf1) {
      if (ptr16index == 1)
        channel = ((*p >> 26) & 0x3F);
      else
        channel = ((*p >> 10) & 0x3F);
      if (remap) channel = chmap[channel];
      
      int gain = 1;
      
      if (ptr16index == 1) {
        word1 = (uint16_t) ((*p >> 16) & 0xFFFF);
        word2 = (uint16_t) (*p & 0xFFFF);
        word3 = (uint16_t) ((*(p + 1) >> 16) & 0xFFFF);
        ptr16index = 0;
      }
      
      else if (ptr16index == 0) {
        word1 = (uint16_t) (*p & 0xFFFF);
        word2 = (uint16_t) ((*(p + 1) >> 16) & 0xFFFF);
        word3 = (uint16_t) (*(p + 1) & 0xFFFF);
        ptr16index = 1;
      }
      
      uint16_t Smin = (word1 & 0x3FF);
      
      digiVec[0] = ((word3 >> 4) & 0xF) + Smin;
      digiVec[1] = ((word3 >> 0) & 0xF) + Smin;
      digiVec[2] = ((word3 >> 8) & 0xF) + Smin;
      digiVec[3] = ((word3 >> 12) & 0xF) + Smin;
      digiVec[4] = ((word2 >> 4) & 0xF) + Smin;
      digiVec[5] = ((word2 >> 0) & 0xF) + Smin;
      digiVec[6] = ((word2 >> 8) & 0xF) + Smin;
      
      HWIdentifier adcID = m_tileHWID->adc_id(drawerID, channel, gain);
      TileDigits * td = new TileDigits(adcID, digiVec);
      sDigits.at(channel) = td;
      p += 1 + ptr16index;
      
      if (msgLvl(MSG::VERBOSE)) {
        msg(MSG::VERBOSE) << MSG::hex << "Frag: $" << frag << MSG::dec
        << " G:" << gain
        << " C:" << channel
        << " Data={";
        for (int samp = 0; samp < 7; ++samp) {
          msg(MSG::VERBOSE) << " " << (int) digiVec[samp];
        }
        msg(MSG::VERBOSE) << "}  " << MSG::hex
        << " WORD1: " << word1
        << " WORD2: " << word2
        << " WORD3: " << word3 << MSG::dec << endmsg;
      }
    }
    
    for (int chf2 = 0; chf2 < nbchanformat2; ++chf2) {
      if (ptr16index == 1)
        channel = ((*p) & 0x3F);
      else
        channel = ((*(p + 1) >> 16) & 0x3F);
      if (remap) channel = chmap[channel];
      
      if (ptr16index == 1) {
        word1 = (uint16_t) ((*p >> 16) & 0xFFFF);
        word2 = (uint16_t) ((*p) & 0xFFFF);
        word3 = (uint16_t) ((*(p + 1) >> 16) & 0xFFFF);
        word4 = (uint16_t) (*(p + 1) & 0xFFFF);
        word5 = (uint16_t) ((*(p + 2) >> 16) & 0xFFFF);
        ptr16index = 0;
      } else if (ptr16index == 0) {
        word1 = (uint16_t) ((*p) & 0xFFFF);
        word2 = (uint16_t) ((*(p + 1) >> 16) & 0xFFFF);
        word3 = (uint16_t) (*(p + 1) & 0xFFFF);
        word4 = (uint16_t) ((*(p + 2) >> 16) & 0xFFFF);
        word5 = (uint16_t) (*(p + 2) & 0xFFFF);
        ptr16index = 1;
      }
      
      int gain = ((word2 >> 6) & 0x1);
      
      digiVec[0] = ((word1 << 9) & 0x200) + ((word2 >> 7) & 0x1FF);
      digiVec[1] = (word1 >> 1) & 0x3FF;
      digiVec[2] = (word4 << 5 & 0x3E0) + ((word1 >> 11) & 0x1F);
      digiVec[3] = (word4 >> 5) & 0x3FF;
      digiVec[4] = ((word3 << 1) & 0x3FE) + ((word4 >> 15) & 0x1);
      digiVec[5] = ((word5 << 7) & 0x380) + ((word3 >> 9) & 0x7F);
      digiVec[6] = (word5 >> 3) & 0x3FF;
      
      HWIdentifier adcID = m_tileHWID->adc_id(drawerID, channel, gain);
      TileDigits * td = new TileDigits(adcID, digiVec);
      sDigits.at(channel) = td;
      p += (2 + ptr16index);
      
      if (msgLvl(MSG::VERBOSE)) {
        msg(MSG::VERBOSE) << MSG::hex << "Frag: $" << frag << MSG::dec
        << " G:" << gain
        << " C:" << channel
        << " Data={";
        for (int samp = 0; samp < nsamp; ++samp) {
          msg(MSG::VERBOSE) << " " << (int) digiVec[samp];
        }
        msg(MSG::VERBOSE) << "}  " << MSG::hex
        << " WORD1: " << word1
        << " WORD2: " << word2
        << " WORD3: " << word3
        << " WORD4: " << word4
        << " WORD5: " << word5 << MSG::dec << endmsg;
      }
      
    }
    for (uint i = 0; i < sDigits.size(); i++) {
      TileDigits * td = sDigits.at(i);
      if (td) pDigits.push_back(td);
    }
  } //End of new version
  
}

unpack_frag10()

void TileROD_Decoder::unpack_frag10 ( uint32_t version, const uint32_t * p, TileL2Container & v, int fragID, int demoType ) const

private

unpack_frag10 decodes tile subfragment type 0x10.

This subfragment contains the result of the MTag algorithm and the transverse energy calculation for two tilecal modules.

The MTag algorithm identifies low transverse momentum muons with eta projective pattern that traverse the tile calorimeter and calculates the energy deposited in the corresponding eta projective tower.

The total transverse energy is calculated for each of the two tilecal modules in the subfragment.

Definition at line 1490 of file TileROD_Decoder.cxx.

                                                              {
  // MTag-MET fragment 0x10 (staging mode)
  
  // second word is frag ID and frag type
  int size = *(p);
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
  
  int nDrawer[2];
  nDrawer[0] = frag & 0x3F;
  nDrawer[1] = (frag & 0xFC0) >> 6;
  
  p += 2; // 2 words so far
  
  uint32_t w;
  uint32_t Mu_energy0;
  uint32_t Mu_energy1;
  uint32_t Mu_energy2;
  uint32_t Mu_pattern;
  uint32_t Mu_drawer;
  uint32_t Mu_quality;
  
  std::vector<float> sumE[2];
  std::vector<unsigned int> word[2];
  std::vector<float> eta[2];
  std::vector<float> energy0[2];
  std::vector<float> energy1[2];
  std::vector<float> energy2[2];
  std::vector<unsigned int> quality[2];
 
  
  constexpr float eta_LB[9] = {
    ((0.00f + 2 * 0.05f) / 3),  // D0, BC1, A1
    ((0.20f + 2 * 0.15f) / 3),  // D1, BC2, A2
    ((0.20f + 2 * 0.25f) / 3),  // D1, BC3, A3
    ((0.40f + 2 * 0.35f) / 3),  // D2, BC4, A4
    ((0.40f + 2 * 0.45f) / 3),  // D2, BC5, A5
    ((0.40f + 2 * 0.55f) / 3),  // D2, BC6, A6
    ((0.60f + 2 * 0.55f) / 3),  // D3, BC6, A6
    ((0.60f + 2 * 0.65f) / 3),  // D3, BC7, A7
    ((0.60f + 2 * 0.75f) / 3)   // D3, BC8, A8
  };
  
  constexpr float eta_EB[17] = {
    ((1.00f + 1.05f + 1.15f) / 3), // D5, B11, A12
    ((1.00f + 1.15f + 1.15f) / 3), // D5, B12, A12
    ((1.00f + 1.15f + 1.25f) / 3), // D5, B12, A13
    ((1.00f + 1.25f + 1.15f) / 3), // D5, B13, A12
    ((1.00f + 1.25f + 1.25f) / 3), // D5, B13, A13
    ((1.00f + 1.25f + 1.35f) / 3), // D5, B13, A14
    ((1.20f + 1.05f + 1.15f) / 3), // D6, B11, A12
    ((1.20f + 1.15f + 1.15f) / 3), // D6, B12, A12
    ((1.20f + 1.15f + 1.25f) / 3), // D6, B12, A13
    ((1.20f + 1.25f + 1.15f) / 3), // D6, B13, A12
    ((1.20f + 1.25f + 1.25f) / 3), // D6, B13, A13
    ((1.20f + 1.25f + 1.35f) / 3), // D6, B13, A14
    ((1.20f + 1.35f + 1.25f) / 3), // D6, B14, A13
    ((1.20f + 1.35f + 1.35f) / 3), // D6, B14, A14
    ((1.20f + 1.35f + 1.45f) / 3), // D6, B14, A15
    ((1.20f + 1.45f + 1.35f) / 3), // D6, B15, A14
    ((1.20f + 1.45f + 1.45f) / 3)  // D6, B15, A15
  };
  
  // Transverse energy - 2 words
  sumE[0].push_back((float) ((int32_t) (*p++) - 9000));
  sumE[1].push_back((float) ((int32_t) (*p++) - 9000));
  
  // Muon tagging
  
  int NMuons = (int) (size - 5) / 2;
  
  for (int mu = 0; mu < NMuons; ++mu) {
    
    w = (*p);
    
    Mu_energy2 = w & 0x1FFFFFF; // 25 bits
    Mu_pattern = (w >> 25) & 0x1F; // 5 bits
    Mu_drawer = (w >> 30) & 1; // 1 bit
    Mu_quality = w >> 31; // 1 bit
    
    word[Mu_drawer].push_back(w);
    
    w = *(p + 1);
    
    Mu_energy0 = w & 0xFFFF;    // 16 bits
    Mu_energy1 = w >> 16;       // 16 bits
    
    word[Mu_drawer].push_back(w);
    
    // Muon eta coordinate
    switch (frag >> 12) {
      case 1:
        eta[Mu_drawer].push_back(eta_LB[Mu_pattern]);
        break;
      case 2:
        eta[Mu_drawer].push_back(-eta_LB[Mu_pattern]);
        break;
      case 3:
        eta[Mu_drawer].push_back(eta_EB[Mu_pattern]);
        break;
      case 4:
        eta[Mu_drawer].push_back(-eta_EB[Mu_pattern]);
        break;
      default:
        ATH_MSG_WARNING("Unknown fragment: " << (frag >> 8));
        break;
    }
    
    // Energy deposited in TileCal by the muon (MeV)
    energy0[Mu_drawer].push_back(Mu_energy0 / 2.);
    energy1[Mu_drawer].push_back(Mu_energy1 / 2.);
    energy2[Mu_drawer].push_back(Mu_energy2 / 2.);
    
    // Muon quality factor
    quality[Mu_drawer].push_back(Mu_quality);
    
    p += 2;
  }
  
  for (unsigned int i = 0; i < 2; ++i) {
    
    // frag ID
    int fragId = (((frag & 0xF000) >> 4) | nDrawer[i]);
    
    // store sumEt
    (*pL2[m_hashFunc(fragId)]).setEt(std::move(sumE[i]));
    
    // store Muon data
    (*pL2[m_hashFunc(fragId)]).setMu(std::move(eta[i]), std::move(energy0[i]), std::move(energy1[i]), std::move(energy2[i]),
                                     std::move(quality[i]), std::move(word[i]));
  }
  
  return;
}

unpack_frag11()

void TileROD_Decoder::unpack_frag11 ( uint32_t version, const uint32_t * p, TileL2Container & v, int fragID, int demoType ) const

private

unpack_frag11 decodes tile subfragment type 0x11.

This subfragment contains the result of the MTag algorithm and the transverse energy calculation ONLY for one tilecal module.

The MTag algorithm identifies low transverse momentum muons with eta projective pattern that traverse the tile calorimeter and calculates the energy deposited in the corresponding eta projective tower.

The total transverse energy is calculated for a tilecal module.

Definition at line 1626 of file TileROD_Decoder.cxx.

                                                              {
  // MTag-MET fragment 0x11 (full mode)
  
  // second word is frag ID and frag type
  int size = *(p);
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
  
  p += 2; // 2 words so far
  
  uint32_t w;
  uint32_t Mu_energy0;
  uint32_t Mu_energy1;
  uint32_t Mu_energy2;
  uint32_t Mu_pattern;
  //uint32_t Mu_drawer;
  uint32_t Mu_quality;
  
  std::vector<unsigned int> word;
  std::vector<float> eta;
  std::vector<float> energy0;
  std::vector<float> energy1;
  std::vector<float> energy2;
  std::vector<unsigned int> quality;
  
  constexpr float eta_LB[9] = {
    ((0.00f + 2 * 0.05f) / 3),  // D0, BC1, A1
    ((0.20f + 2 * 0.15f) / 3),  // D1, BC2, A2
    ((0.20f + 2 * 0.25f) / 3),  // D1, BC3, A3
    ((0.40f + 2 * 0.35f) / 3),  // D2, BC4, A4
    ((0.40f + 2 * 0.45f) / 3),  // D2, BC5, A5
    ((0.40f + 2 * 0.55f) / 3),  // D2, BC6, A6
    ((0.60f + 2 * 0.55f) / 3),  // D3, BC6, A6
    ((0.60f + 2 * 0.65f) / 3),  // D3, BC7, A7
    ((0.60f + 2 * 0.75f) / 3)   // D3, BC8, A8
  };
  
  constexpr float eta_EB[17] = {
    ((1.00f + 1.05f + 1.15f) / 3), // D5, B11, A12
    ((1.00f + 1.15f + 1.15f) / 3), // D5, B12, A12
    ((1.00f + 1.15f + 1.25f) / 3), // D5, B12, A13
    ((1.00f + 1.25f + 1.15f) / 3), // D5, B13, A12
    ((1.00f + 1.25f + 1.25f) / 3), // D5, B13, A13
    ((1.00f + 1.25f + 1.35f) / 3), // D5, B13, A14
    ((1.20f + 1.05f + 1.15f) / 3), // D6, B11, A12
    ((1.20f + 1.15f + 1.15f) / 3), // D6, B12, A12
    ((1.20f + 1.15f + 1.25f) / 3), // D6, B12, A13
    ((1.20f + 1.25f + 1.15f) / 3), // D6, B13, A12
    ((1.20f + 1.25f + 1.25f) / 3), // D6, B13, A13
    ((1.20f + 1.25f + 1.35f) / 3), // D6, B13, A14
    ((1.20f + 1.35f + 1.25f) / 3), // D6, B14, A13
    ((1.20f + 1.35f + 1.35f) / 3), // D6, B14, A14
    ((1.20f + 1.35f + 1.45f) / 3), // D6, B14, A15
    ((1.20f + 1.45f + 1.35f) / 3), // D6, B15, A14
    ((1.20f + 1.45f + 1.45f) / 3)  // D6, B15, A15
  };
  
  // Transverse energy
  std::vector<float> sumE(1, (float) ((int32_t) (*p++) - 9000));
  (*pL2[m_hashFunc(frag)]).setEt(std::move(sumE));
  
  // Muon tagging
  
  int NMuons = (int) (size - 4) / 2;
  
  for (int mu = 0; mu < NMuons; ++mu) {
    
    w = (*p);
    
    Mu_energy2 = w & 0x1FFFFFF; // 25 bits
    Mu_pattern = (w >> 25) & 0x1F; // 5 bits
    //Mu_drawer = (w >> 30) & 1; // 1 bit
    Mu_quality = w >> 31; // 1 bit
    
    word.push_back(w);
    
    w = *(p + 1);
    
    Mu_energy0 = w & 0xFFFF;    // 16 bits
    Mu_energy1 = w >> 16;       // 16 bits
    
    word.push_back(w);
    
    // Muon eta coordinate
    switch (frag >> 8) {
      case 1:
        eta.push_back(eta_LB[Mu_pattern]);
        break;
      case 2:
        eta.push_back(-eta_LB[Mu_pattern]);
        break;
      case 3:
        eta.push_back(eta_EB[Mu_pattern]);
        break;
      case 4:
        eta.push_back(-eta_EB[Mu_pattern]);
        break;
      default:
        ATH_MSG_WARNING("Unknown fragment: " << (frag >> 8));
        break;
    }
    
    // Energy deposited in TileCal by the muon (MeV)
    energy0.push_back(Mu_energy0 / 2.);
    energy1.push_back(Mu_energy1 / 2.);
    energy2.push_back(Mu_energy2 / 2.);
    
    // Muon quality factor
    quality.push_back(Mu_quality);
    
    p += 2;
  }
  
  (*pL2[m_hashFunc(frag)]).setMu(std::move(eta), std::move(energy0),
           std::move(energy1), std::move(energy2), std::move(quality), std::move(word));
  
  return;
}

unpack_frag12()

void TileROD_Decoder::unpack_frag12 ( uint32_t version, const uint32_t * p, TileL2Container & v, int fragID, int demoType ) const

private

unpack_frag12 decodes tile subfragment type 0x12.

This subfragment contains the result of the MTag algorithm for two tilecal modules.

The MTag algorithm identifies low transverse momentum muons with eta projective pattern that traverse the tile calorimeter and calculates the energy deposited in the corresponding eta projective tower.

Definition at line 1746 of file TileROD_Decoder.cxx.

                                                              {
  // MTag fragment 0x12 (staging mode)
  
  // second word is frag ID and frag type
  int size = *(p);
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
  
  int nDrawer[2];
  nDrawer[0] = frag & 0x3F;
  nDrawer[1] = (frag & 0xFC0) >> 6;
  
  p += 2; // 2 words so far
  
  uint32_t w;
  uint32_t Mu_energy0;
  uint32_t Mu_energy1;
  uint32_t Mu_energy2;
  uint32_t Mu_pattern;
  uint32_t Mu_drawer;
  uint32_t Mu_quality;
  
  std::vector<unsigned int> word[2];
  std::vector<float> eta[2];
  std::vector<float> energy0[2];
  std::vector<float> energy1[2];
  std::vector<float> energy2[2];
  std::vector<unsigned int> quality[2];
  
  constexpr float eta_LB[9] = {
    ((0.00f + 2 * 0.05f) / 3),  // D0, BC1, A1
    ((0.20f + 2 * 0.15f) / 3),  // D1, BC2, A2
    ((0.20f + 2 * 0.25f) / 3),  // D1, BC3, A3
    ((0.40f + 2 * 0.35f) / 3),  // D2, BC4, A4
    ((0.40f + 2 * 0.45f) / 3),  // D2, BC5, A5
    ((0.40f + 2 * 0.55f) / 3),  // D2, BC6, A6
    ((0.60f + 2 * 0.55f) / 3),  // D3, BC6, A6
    ((0.60f + 2 * 0.65f) / 3),  // D3, BC7, A7
    ((0.60f + 2 * 0.75f) / 3)   // D3, BC8, A8
  };
  
  constexpr float eta_EB[17] = {
    ((1.00f + 1.05f + 1.15f) / 3), // D5, B11, A12
    ((1.00f + 1.15f + 1.15f) / 3), // D5, B12, A12
    ((1.00f + 1.15f + 1.25f) / 3), // D5, B12, A13
    ((1.00f + 1.25f + 1.15f) / 3), // D5, B13, A12
    ((1.00f + 1.25f + 1.25f) / 3), // D5, B13, A13
    ((1.00f + 1.25f + 1.35f) / 3), // D5, B13, A14
    ((1.20f + 1.05f + 1.15f) / 3), // D6, B11, A12
    ((1.20f + 1.15f + 1.15f) / 3), // D6, B12, A12
    ((1.20f + 1.15f + 1.25f) / 3), // D6, B12, A13
    ((1.20f + 1.25f + 1.15f) / 3), // D6, B13, A12
    ((1.20f + 1.25f + 1.25f) / 3), // D6, B13, A13
    ((1.20f + 1.25f + 1.35f) / 3), // D6, B13, A14
    ((1.20f + 1.35f + 1.25f) / 3), // D6, B14, A13
    ((1.20f + 1.35f + 1.35f) / 3), // D6, B14, A14
    ((1.20f + 1.35f + 1.45f) / 3), // D6, B14, A15
    ((1.20f + 1.45f + 1.35f) / 3), // D6, B15, A14
    ((1.20f + 1.45f + 1.45f) / 3)  // D6, B15, A15
  };
  
  int NMuons = (int) (size - 3) / 2;
  
  for (int mu = 0; mu < NMuons; ++mu) {
    
    w = (*p);
    
    Mu_energy2 = w & 0x1FFFFFF; // 25 bits
    Mu_pattern = (w >> 25) & 0x1F; // 5 bits
    Mu_drawer = (w >> 30) & 1; // 1 bit
    Mu_quality = w >> 31; // 1 bit
    
    word[Mu_drawer].push_back(w);
    
    w = *(p + 1);
    
    Mu_energy0 = w & 0xFFFF;    // 16 bits
    Mu_energy1 = w >> 16;       // 16 bits
    
    word[Mu_drawer].push_back(w);
    
    // Muon eta coordinate
    switch (frag >> 12) {
      case 1:
        eta[Mu_drawer].push_back(eta_LB[Mu_pattern]);
        break;
      case 2:
        eta[Mu_drawer].push_back(-eta_LB[Mu_pattern]);
        break;
      case 3:
        eta[Mu_drawer].push_back(eta_EB[Mu_pattern]);
        break;
      case 4:
        eta[Mu_drawer].push_back(-eta_EB[Mu_pattern]);
        break;
      default:
        ATH_MSG_WARNING("Unknown fragment: " << (frag >> 8));
        break;
    }
    
    // Energy deposited in TileCal by the muon (MeV)
    energy0[Mu_drawer].push_back(Mu_energy0 / 2.);
    energy1[Mu_drawer].push_back(Mu_energy1 / 2.);
    energy2[Mu_drawer].push_back(Mu_energy2 / 2.);
    
    // Muon quality factor
    quality[Mu_drawer].push_back(Mu_quality);
    
    p += 2;
  }
  
  for (unsigned int i = 0; i < 2; ++i) {
    
    // frag ID
    int fragId = (((frag & 0xF000) >> 4) | nDrawer[i]);
    
    (*pL2[m_hashFunc(fragId)]).setMu(std::move(eta[i]), std::move(energy0[i]), std::move(energy1[i]), std::move(energy2[i]),
                                     std::move(quality[i]), std::move(word[i]));
 
  }
  
  return;
}

unpack_frag13()

void TileROD_Decoder::unpack_frag13 ( uint32_t version, const uint32_t * p, TileL2Container & v, int fragID, int demoType ) const

private

unpack_frag13 decodes tile subfragment type 0x13.

This subfragment contains the result of the MTag algorithm ONLY for one tilecal module.

The MTag algorithm identifies low transverse momentum muons with eta projective pattern that traverse the tile calorimeter and calculates the energy deposited in the corresponding eta projective tower.

Definition at line 1871 of file TileROD_Decoder.cxx.

                                                              {
  // MTag fragment 0x13 (full mode)
  
  // second word is frag ID and frag type
  int size = *(p);
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
  
  p += 2; // 2 words so far
  
  uint32_t w;
  uint32_t Mu_energy0;
  uint32_t Mu_energy1;
  uint32_t Mu_energy2;
  uint32_t Mu_pattern;
  //uint32_t Mu_drawer;
  uint32_t Mu_quality;
  
  std::vector<unsigned int> word;
  std::vector<float> eta;
  std::vector<float> energy0;
  std::vector<float> energy1;
  std::vector<float> energy2;
  std::vector<unsigned int> quality;
  
  constexpr float eta_LB[9] = {
    ((0.00f + 2 * 0.05f) / 3),  // D0, BC1, A1
    ((0.20f + 2 * 0.15f) / 3),  // D1, BC2, A2
    ((0.20f + 2 * 0.25f) / 3),  // D1, BC3, A3
    ((0.40f + 2 * 0.35f) / 3),  // D2, BC4, A4
    ((0.40f + 2 * 0.45f) / 3),  // D2, BC5, A5
    ((0.40f + 2 * 0.55f) / 3),  // D2, BC6, A6
    ((0.60f + 2 * 0.55f) / 3),  // D3, BC6, A6
    ((0.60f + 2 * 0.65f) / 3),  // D3, BC7, A7
    ((0.60f + 2 * 0.75f) / 3)   // D3, BC8, A8
  };
  
  constexpr float eta_EB[17] = {
    ((1.00f + 1.05f + 1.15f) / 3), // D5, B11, A12
    ((1.00f + 1.15f + 1.15f) / 3), // D5, B12, A12
    ((1.00f + 1.15f + 1.25f) / 3), // D5, B12, A13
    ((1.00f + 1.25f + 1.15f) / 3), // D5, B13, A12
    ((1.00f + 1.25f + 1.25f) / 3), // D5, B13, A13
    ((1.00f + 1.25f + 1.35f) / 3), // D5, B13, A14
    ((1.20f + 1.05f + 1.15f) / 3), // D6, B11, A12
    ((1.20f + 1.15f + 1.15f) / 3), // D6, B12, A12
    ((1.20f + 1.15f + 1.25f) / 3), // D6, B12, A13
    ((1.20f + 1.25f + 1.15f) / 3), // D6, B13, A12
    ((1.20f + 1.25f + 1.25f) / 3), // D6, B13, A13
    ((1.20f + 1.25f + 1.35f) / 3), // D6, B13, A14
    ((1.20f + 1.35f + 1.25f) / 3), // D6, B14, A13
    ((1.20f + 1.35f + 1.35f) / 3), // D6, B14, A14
    ((1.20f + 1.35f + 1.45f) / 3), // D6, B14, A15
    ((1.20f + 1.45f + 1.35f) / 3), // D6, B15, A14
    ((1.20f + 1.45f + 1.45f) / 3)  // D6, B15, A15
  };
  
  int NMuons = (int) (size - 3) / 2;
  
  for (int mu = 0; mu < NMuons; ++mu) {
    
    w = (*p);
    
    Mu_energy2 = w & 0x1FFFFFF; // 25 bits
    Mu_pattern = (w >> 25) & 0x1F; // 5 bits
    //Mu_drawer = (w >> 30) & 1; // 1 bit
    Mu_quality = w >> 31; // 1 bit
    
    word.push_back(w);
    
    w = *(p + 1);
    
    Mu_energy0 = w & 0xFFFF;    // 16 bits
    Mu_energy1 = w >> 16;       // 16 bits
    
    word.push_back(w);
    
    // Muon eta coordinate
    switch (frag >> 8) {
      case 1:
        eta.push_back(eta_LB[Mu_pattern]);
        break;
      case 2:
        eta.push_back(-eta_LB[Mu_pattern]);
        break;
      case 3:
        eta.push_back(eta_EB[Mu_pattern]);
        break;
      case 4:
        eta.push_back(-eta_EB[Mu_pattern]);
        break;
      default:
        ATH_MSG_WARNING("Unknown fragment: " << (frag >> 8));
        break;
    }
    
    // Energy deposited in TileCal by the muon (MeV)
    energy0.push_back(Mu_energy0 / 2.);
    energy1.push_back(Mu_energy1 / 2.);
    energy2.push_back(Mu_energy2 / 2.);
    
    // Muon quality factor
    quality.push_back(Mu_quality);
    
    p += 2;
  }
  
  (*pL2[m_hashFunc(frag)]).setMu(std::move(eta), std::move(energy0),
        std::move(energy1), std::move(energy2), std::move(quality), std::move(word));
  
  return;
}

unpack_frag14()

void TileROD_Decoder::unpack_frag14 ( uint32_t version, const uint32_t * p, TileL2Container & v, int fragID, int demoType ) const

private

unpack_frag14 decodes tile subfragment type 0x14.

This subfragment contains the transverse energy calculation for tilecal module.

Definition at line 1985 of file TileROD_Decoder.cxx.

                                                              {
  // Met fragment 0x14 (staging mode) - obsolete, now sumEt is part of frag4/frag5
  
  // second word is frag ID and frag type
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
  
  int nDrawer[2];
  nDrawer[0] = frag & 0x3F;
  nDrawer[1] = (frag & 0xFC0) >> 6;
  
  p += 2; // 2 words somethingm far
  
  for (unsigned int i = 0; i < 2; ++i) {
    
    int fragId = (((frag & 0xF000) >> 4) | nDrawer[i]);
    
    float sumE = (float) ((int32_t) (*p) - 9000);
    (*pL2[m_hashFunc(fragId)]).setEt(std::vector<float>{sumE});
    
    ++p;
  }
  
  return;
}

unpack_frag15()

void TileROD_Decoder::unpack_frag15 ( uint32_t version, const uint32_t * p, TileL2Container & v, int fragID, int demoType ) const

private

unpack_frag15 decodes tile subfragment type 0x15.

This subfragment contains the transverse energy calculation ONLY for one tilecal module.

Definition at line 2012 of file TileROD_Decoder.cxx.

                                                              {
  // Met fragment 0x15 (full mode) - obsolete, now sumEt is part of frag4/frag5
  
  // second word is frag ID and frag type
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
  
  p += 2; // 2 words so far
  
  std::vector<float> sumE(1);
  
  sumE[0] = (float) ((int32_t) (*p) - 9000);
  (*pL2[m_hashFunc(frag)]).setEt(std::move(sumE));
  
  return;
}

unpack_frag16()

void TileROD_Decoder::unpack_frag16 ( uint32_t version, const uint32_t * p, TileLaserObject & v ) const

private

unpack_frag16 decodes tile subfragment type 0x16 or 0x20.

This subfragment contains informations coming from the Laser box [calibration run]

Definition at line 2030 of file TileROD_Decoder.cxx.

                                                                         {
  
  //frag ID
  
  //int frag = *(p+1) & 0xFFFF;
  //int type = *(p+1) >>16;
  
  // pointer to current data word
  const uint32_t *pData;
  
  //position of first data word, skip the first two words of the header fragment
  
  pData = p + 2;
  
  int counter = 0;
  
  counter = *pData;
  
  ++pData;
  
  int reqAmp = 0;
  int filt = 0;
  //int rawfilt=0;
  //int status=0;
  bool errorFlag = false;
  
  if ((*pData & 0xFF000000) == 0x20000000) {
    
    if (version == 1) {
      
      reqAmp = *pData & 0xFFFF;
      
    } else {
      
      reqAmp = *pData & 0xFFFF;
      
      //     rawfilt = (*pData >>16) & 0xF;
      
      if (version == 2) {
        filt = (((*pData >> 16) & 7) ^ 7) + 2;
      } else {
        filt = 9 - (((*pData >> 17) & 1) * 4 + ((*pData >> 18) & 1) * 2 + ((*pData >> 19) & 1));
      }
      
      if (((*pData >> 16) & 1) == 1) filt = 0; // Filter wheel moving
      
      if (filt > 8) filt -= 8;
    }
    //status = (*pData >>20) & 0xF;
    
  } else {
    errorFlag = true;
    if (m_ErrorCounter <= m_maxErrorPrint)
      ATH_MSG_WARNING( "In decoding word 20" );
  }
  
  ++pData;
  
  //int delay=0;
  int measAmp = 0;
  
  if ((*pData & 0xFF000000) == 0x21000000) {
    
    measAmp = *pData & 0xFFF;
    //delay = (*pData >>12) & 0xFFF;
    
  } else {
    errorFlag = true;
    if (m_ErrorCounter <= m_maxErrorPrint)
      ATH_MSG_WARNING( "In decoding word 21" );
  }
  
  ++pData;
  
  //int status1=0;
  int tdc1 = 0;
  int tdc2 = 0;
  
  if ((*pData & 0xFF000000) == 0x22000000) {
    
    if (version == 1) {
      
      tdc1 = (*pData >> 16) & 0xF;
      tdc2 = (*pData >> 20) & 0xF;
    } else {
      
      tdc1 = *pData & 0xFFFF;
      
    }
    
  } else {
    errorFlag = true;
    if (m_ErrorCounter <= m_maxErrorPrint)
      ATH_MSG_WARNING( "In decoding word 22" );
    
  }
  
  ++pData;
  
  //int status2=0;
  //int tdc2=0;
  
  if ((*pData & 0xFF000000) == 0x23000000) {
    
    if (version == 1) {
      
      tdc2 = (*pData >> 12) & 0xFFF;
      tdc1 = *pData & 0xFFF;
      
    } else {
      
      tdc2 = *pData & 0xFFFF;
      
      //status2 = (*pData >>16) & 0xFF;
    }
    
  } else {
    errorFlag = true;
    if (m_ErrorCounter <= m_maxErrorPrint)
      ATH_MSG_WARNING( "In decoding word 23" );
  }
  
  ++pData;
  
  int chan0 = 0;
  int chan1 = 0;
  
  if ((*pData & 0xFF000000) == 0x44000000) {
    
    chan0 = 4095 - (*pData & 0xFFF);
    chan1 = 4095 - ((*pData >> 12) & 0xFFF);
    
  } else {
    errorFlag = true;
    if (m_ErrorCounter <= m_maxErrorPrint)
      ATH_MSG_WARNING( "In decoding word 24" );
  }
  
  ++pData;
  
  int chan2 = 0;
  int chan3 = 0;
  
  if ((*pData & 0xFF000000) == 0x45000000) {
    
    chan2 = 4095 - (*pData & 0xFFF);
    chan3 = 4095 - ((*pData >> 12) & 0xFFF);
    
  } else {
    errorFlag = true;
    if (m_ErrorCounter <= m_maxErrorPrint)
      ATH_MSG_WARNING( "In decoding word 25" );
  }
  
  ++pData;
  
  int chan4 = 0;
  int chan5 = 0;
  
  if ((*pData & 0xFF000000) == 0x46000000) {
    
    chan4 = 4095 - (*pData & 0xFFF);
    chan5 = 4095 - ((*pData >> 12) & 0xFFF);
    
  } else {
    errorFlag = true;
    if (m_ErrorCounter <= m_maxErrorPrint)
      ATH_MSG_WARNING( "In decoding word 26" );
  }
  
  ++pData;
  
  //int chan6=0;
  //int chan7=0;
  
  if ((*pData & 0xFF000000) == 0x47000000) {
    
    //chan6 = 4095 - (*pData & 0xFFF);
    //chan7 = 4095 - ((*pData >>12) & 0xFFF);
    
  } else {
    errorFlag = true;
    if (m_ErrorCounter <= m_maxErrorPrint)
      ATH_MSG_WARNING( "In decoding word 27" );
  }
  
  ++pData;
  
  int meanPed_diode1 = 0;
  int rmsPed_diode1 = 0;
  
  double MeanPed_diode1 = 0;
  double RmsPed_diode1 = 0;
  
  rmsPed_diode1 = *pData & 0xFFFF;
  meanPed_diode1 = (*pData >> 16) & 0xFFFF;
  
  MeanPed_diode1 = static_cast<double>(meanPed_diode1) * 0.1;
  
  RmsPed_diode1 = static_cast<double>(rmsPed_diode1) * 0.01;
  
  ++pData;
  
  int meanPed_diode2 = 0;
  int rmsPed_diode2 = 0;
  
  double MeanPed_diode2 = 0;
  double RmsPed_diode2 = 0;
  
  rmsPed_diode2 = *pData & 0xFFFF;
  meanPed_diode2 = (*pData >> 16) & 0xFFFF;
  
  MeanPed_diode2 = static_cast<double>(meanPed_diode2) * 0.1;
  
  RmsPed_diode2 = static_cast<double>(rmsPed_diode2) * 0.01;
  
  ++pData;
  
  int meanPed_diode3 = 0;
  int rmsPed_diode3 = 0;
  
  double MeanPed_diode3 = 0;
  double RmsPed_diode3 = 0;
  
  rmsPed_diode3 = *pData & 0xFFFF;
  meanPed_diode3 = (*pData >> 16) & 0xFFFF;
  
  MeanPed_diode3 = static_cast<double>(meanPed_diode3) * 0.1;
  
  RmsPed_diode3 = static_cast<double>(rmsPed_diode3) * 0.01;
  
  ++pData;
  
  int meanPed_diode4 = 0;
  int rmsPed_diode4 = 0;
  
  double MeanPed_diode4 = 0;
  double RmsPed_diode4 = 0;
  
  rmsPed_diode4 = *pData & 0xFFFF;
  meanPed_diode4 = (*pData >> 16) & 0xFFFF;
  
  MeanPed_diode4 = static_cast<double>(meanPed_diode4) * 0.1;
  
  RmsPed_diode4 = static_cast<double>(rmsPed_diode4) * 0.01;
  
  ++pData;
  
  int meanPed_pmt1 = 0;
  int rmsPed_pmt1 = 0;
  
  double MeanPed_pmt1 = 0;
  double RmsPed_pmt1 = 0;
  
  rmsPed_pmt1 = *pData & 0xFFFF;
  meanPed_pmt1 = (*pData >> 16) & 0xFFFF;
  
  MeanPed_pmt1 = static_cast<double>(meanPed_pmt1) * 0.1;
  
  RmsPed_pmt1 = static_cast<double>(rmsPed_pmt1) * 0.01;
  
  ++pData;
  
  int meanPed_pmt2 = 0;
  int rmsPed_pmt2 = 0;
  
  double MeanPed_pmt2 = 0;
  double RmsPed_pmt2 = 0;
  
  rmsPed_pmt2 = *pData & 0xFFFF;
  meanPed_pmt2 = (*pData >> 16) & 0xFFFF;
  
  MeanPed_pmt2 = static_cast<double>(meanPed_pmt2) * 0.1;
  
  RmsPed_pmt2 = static_cast<double>(rmsPed_pmt2) * 0.01;
  
  ++pData;
  
  time_t lastPedMeas = *pData;
  //struct tm *time = localtime(&lastPedMeas);
  //printf("Date is %d/%02d/%02d\n", time->tm_year+1900, time->tm_mon+1, time->tm_mday);
  //printf("Time is %02d:%02d\n", time->tm_hour, time->tm_min);
  
  ++pData;
  
  int meanAlpha_diode1 = 0;
  int rmsAlpha_diode1 = 0;
  
  double MeanAlpha_diode1 = 0;
  double RmsAlpha_diode1 = 0;
  
  rmsAlpha_diode1 = *pData & 0xFFFF;
  meanAlpha_diode1 = (*pData >> 16) & 0xFFFF;
  
  MeanAlpha_diode1 = static_cast<double>(meanAlpha_diode1) * 0.1;
  
  RmsAlpha_diode1 = static_cast<double>(rmsAlpha_diode1) * 0.01;
  
  ++pData;
  
  int meanAlpha_diode2 = 0;
  int rmsAlpha_diode2 = 0;
  
  double MeanAlpha_diode2 = 0;
  double RmsAlpha_diode2 = 0;
  
  rmsAlpha_diode2 = *pData & 0xFFFF;
  meanAlpha_diode2 = (*pData >> 16) & 0xFFFF;
  
  MeanAlpha_diode2 = static_cast<float>(meanAlpha_diode2) * 0.1;
  
  RmsAlpha_diode2 = static_cast<float>(rmsAlpha_diode2) * 0.01;
  
  ++pData;
  
  //  ATH_MSG_VERBOSE( "Diode 2 value is " << MeanAlpha_diode2 );
  
  int meanAlpha_diode3 = 0;
  int rmsAlpha_diode3 = 0;
  
  double MeanAlpha_diode3 = 0;
  double RmsAlpha_diode3 = 0;
  
  rmsAlpha_diode3 = *pData & 0xFFFF;
  meanAlpha_diode3 = (*pData >> 16) & 0xFFFF;
  
  MeanAlpha_diode3 = static_cast<double>(meanAlpha_diode3) * 0.1;
  
  RmsAlpha_diode3 = static_cast<double>(rmsAlpha_diode3) * 0.01;
  
  ++pData;
  
  int meanAlpha_diode4 = 0;
  int rmsAlpha_diode4 = 0;
  
  double MeanAlpha_diode4 = 0;
  double RmsAlpha_diode4 = 0;
  
  rmsAlpha_diode4 = *pData & 0xFFFF;
  meanAlpha_diode4 = (*pData >> 16) & 0xFFFF;
  
  MeanAlpha_diode4 = static_cast<double>(meanAlpha_diode4) * 0.1;
  
  RmsAlpha_diode4 = static_cast<double>(rmsAlpha_diode4) * 0.01;
  
  ++pData;
  
  time_t lastAlphaMeas = *pData;
  //tm *Time = localtime(&lastAlphaMeas);
  //printf("Date is %d/%02d/%02d\n", Time->tm_year+1900, Time->tm_mon+1, Time->tm_mday);
  //printf("Time is %02d:%02d\n", Time->tm_hour, Time->tm_min);
  
  ++pData;
  
  if (version > 1) {
    
    //int pedAlpha_diode1=0;
    //int pedRMSAlpha_diode1=0;
    
    //double PedAlpha_diode1=0;
    //double PedRMSAlpha_diode1=0;
    
    //pedRMSAlpha_diode1 = *pData & 0xFFFF ;
    //pedAlpha_diode1 = (*pData >> 16) & 0xFFFF;
    
    //PedAlpha_diode1 = static_cast<double>(pedAlpha_diode1)/10;
    
    //PedRMSAlpha_diode1 = static_cast<double>(pedRMSAlpha_diode1)/100;
    
    ++pData;
    
    //int pedAlpha_diode2=0;
    //int pedRMSAlpha_diode2=0;
    
    //double PedAlpha_diode2=0;
    //double PedRMSAlpha_diode2=0;
    
    //pedRMSAlpha_diode2 = *pData & 0xFFFF ;
    //pedAlpha_diode2 = (*pData >> 16) & 0xFFFF;
    
    //PedAlpha_diode2 = static_cast<double>(pedAlpha_diode2)/10;
    
    //PedRMSAlpha_diode2 = static_cast<double>(pedRMSAlpha_diode2)/100;
    
    ++pData;
    
    //int pedAlpha_diode3=0;
    //int pedRMSAlpha_diode3=0;
    
    //double PedAlpha_diode3=0;
    //double PedRMSAlpha_diode3=0;
    
    //pedRMSAlpha_diode3 = *pData & 0xFFFF ;
    //pedAlpha_diode3 = (*pData >> 16) & 0xFFFF;
    
    //PedAlpha_diode3 = static_cast<double>(pedAlpha_diode3)/10;
    
    //PedRMSAlpha_diode3 = static_cast<double>(pedRMSAlpha_diode3)/100;
    
    ++pData;
    
    //int pedAlpha_diode4=0;
    //int pedRMSAlpha_diode4=0;
    
    //double PedAlpha_diode4=0;
    //double PedRMSAlpha_diode4=0;
    
    //pedRMSAlpha_diode4 = *pData & 0xFFFF ;
    //pedAlpha_diode4 = (*pData >> 16) & 0xFFFF;
    
    //PedAlpha_diode4 = static_cast<double>(pedAlpha_diode4)/10;
    
    //PedRMSAlpha_diode4 = static_cast<double>(pedRMSAlpha_diode4)/100;
    
    ++pData;
    
    //time_t lastAlphaPedMeas = *pData;
    
    ++pData;
  }
  
  int diodeTemp = 0;
  int seconds1 = 0;
  
  double DiodeTemp = 0;
  
  diodeTemp = *pData & 0xFFF;
  seconds1 = (*pData >> 12) & 0xFFFFF;
  
  DiodeTemp = static_cast<double>(diodeTemp) * 0.1;
  
  ++pData;
  
  int boxTemp = 0;
  int seconds2 = 0;
  
  double BoxTemp = 0;
  
  boxTemp = *pData & 0xFFF;
  seconds2 = (*pData >> 12) & 0xFFFFF;
  
  BoxTemp = static_cast<double>(boxTemp) * 0.1;
  
  ++pData;
  
  int hum = 0;
  int seconds3 = 0;
  
  double Hum = 0;
  
  hum = *pData & 0xFFF;
  seconds3 = (*pData >> 12) & 0xFFFFF;
  
  Hum = static_cast<double>(hum) * 0.1;
  
  ++pData;
  
  int gasFlow = 0;
  int seconds4 = 0;
  
  double GasFlow = 0;
  
  gasFlow = *pData & 0xFFF;
  seconds4 = (*pData >> 12) & 0xFFFFF;
  
  GasFlow = static_cast<double>(gasFlow) * 0.1;
  
  ++pData;
  
  int PLCstatus = 0;
  //int seconds5 =0;
  
  PLCstatus = *pData & 0xFFF;
  //seconds5 = (*pData >> 12) & 0xFFFFF;
  int alphaPos = PLCstatus & 0x7;
  int LVdiodes = (PLCstatus >> 0x3) & 0x1;
  int HVpmts = (PLCstatus >> 0x4) & 0x3;
  int shutter = (PLCstatus >> 0x6) & 0x3;
  int interLock = (PLCstatus >> 0x8) & 0x1;
  int alarm = (PLCstatus >> 0x9) & 0x7;
  
  laserObject.setPmt(0, chan4, tdc1, MeanPed_pmt1, RmsPed_pmt1, 0);
  
  laserObject.setPmt(1, chan5, tdc2, MeanPed_pmt2, RmsPed_pmt2, 0);
  
  laserObject.setDiode(0, chan0, MeanPed_diode1, RmsPed_diode1, MeanAlpha_diode1, RmsAlpha_diode1, 0, 0, 0);
  
  laserObject.setDiode(1, chan1, MeanPed_diode2, RmsPed_diode2, MeanAlpha_diode2, RmsAlpha_diode2, 0, 0, 0);
  
  laserObject.setDiode(2, chan2, MeanPed_diode3, RmsPed_diode3, MeanAlpha_diode3, RmsAlpha_diode3, 0, 0, 0);
  
  laserObject.setDiode(3, chan3, MeanPed_diode4, RmsPed_diode4, MeanAlpha_diode4, RmsAlpha_diode4, 0, 0, 0);
  
  laserObject.setControl(DiodeTemp, seconds1, BoxTemp, seconds2, GasFlow, seconds4, Hum, seconds3, lastPedMeas, lastAlphaMeas);
  
  laserObject.setLaser(counter, reqAmp, measAmp, filt, 0, 1);
  
  laserObject.setPLC(alphaPos, LVdiodes, HVpmts, shutter, interLock, alarm);
  
  if (errorFlag) m_ErrorCounter++;
} // unpack_frag16

unpack_frag17()

void TileROD_Decoder::unpack_frag17 ( uint32_t version, uint32_t sizeOverhead, const uint32_t * p, TileLaserObject & v ) const

private

unpack_frag17 decodes tile subfragment type 0x17 or 0x20.

This subfragment contains informations coming from the Laser box [calibration run]

Definition at line 2533 of file TileROD_Decoder.cxx.

{
  // first word is full frag size, first two words are not data
  int size = *(p);
  // second word is frag ID and frag type
  //int frag = *(p + 1) & 0xFFFF;
  //position of first data word, skip the first two words of the header fragment
  //const uint32_t *pData = p+2;
  
  bool debug = msgLvl(MSG::DEBUG);
  
  if (true) {
    int maxn=size+2-sizeOverhead;
    for(int n=0; n<maxn; ++n){
      ATH_MSG_DEBUG("WORD " << n << " (" << n+11 << ") : (DEC) " << p[n] << "  (HEX) 0x" << MSG::hex << p[n] << MSG::dec );
    }
  }
  
  // p[2]    00 00 00 tt    Daq Type
  // p[3]    nn nn nn nn    Laser Count
  // p[4]    rr rr mm mm    rrrr = Requested Intensity    mmmm = measured intensity
  // p[5]    t0 0f dd dd    t= timeout (bit 31 and 30) f = filter    dddd = Delay Slama
  // [[6]    00 00 ll ll    Linearity DAC Value
  
  ATH_MSG_DEBUG("SETTING DAQ TYPE IN DECODER = " << MSG::hex << "0x" << int(p[2]) << "  " << MSG::dec << int(p[2]));
  
  int countr = p[3];
  int idiode = (p[4]>>16);
  int intensity = (p[4]&0xFFFF);
  int filter = (p[5]>>16) & 0x000F;
  bool qdctimeout = !((p[5]>>31) & 0x1);
  bool tdctimeout = !((p[5]>>30) & 0x1);
 
  int timing = (p[5] & 0xFFFF);
  int daqtyp = p[2];
 
  laserObject.setLaser(countr, idiode, intensity, filter, timing, 2);
  laserObject.setControl(-99,-99,-99,-99,-99,-99,-99,-99,-99,-99);
  laserObject.setPLC(-99,-99,-99,-99,-99,-99);
  laserObject.setDaqType(daqtyp);
  laserObject.setTimeouts(qdctimeout, tdctimeout);
 
  
  if(laserObject.isLASERII()) ATH_MSG_DEBUG("LASERII VERSION IS " << laserObject.getVersion());
  else                        ATH_MSG_DEBUG("LASERI VERSION IS "  << laserObject.getVersion());
  
  ATH_MSG_DEBUG("laserObject.setLaser: " << MSG::dec << "COUNTER=" << countr << " | "
                << "I_DIODE=" << idiode << " | "
                << "FILTERN=" << filter << " | "
                << "TIMINGD=" << timing << " | "
                << "DAQTYPE=" << daqtyp );
  
  int las[32];
  double ped[32];
  double std[32];
  
  // ATTENTION: note that HG has even index (0,2,4,...) in las[], ped[], std[] arrays
  static const int HG=0;
  static const int LG=1;
  
  const uint32_t *word = p+7; // move to 7th word
  int adc=0;
  // decode 32 ADC half-words (16 low & high channels)
  while (adc<31) {
    // ll ll hh hh    ADC Channel 1 & 0 (Low & High Gain)
    las[adc++] = 8500 - ((*word) & 0xFFFF);
    las[adc++] = 8500 - ((*word) >> 16);
    ++word;
  }
  // TDC word immediately after ADC words
  // aa aa bb bb    aaaa = TDC N1    bbbb = TDC N0
  int TDC0 = (*word) & 0xFFFF;
  int TDC1 = (*word) >> 16;
  
  if (size>130) {
    
    uint32_t sum[32];
    uint64_t ssq[32];
    
    // p[128] Nb event
    double nevt = double(p[128]);
    if(p[128]==0 || (p[128]==3072 && p[32]<21504000) ) {
      nevt=1024.; // HAS TO BE REMOVED!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
      ATH_MSG_DEBUG("Nevents= " << p[128] << " => assuming 1024");
    }
    
    if (nevt>0) {
      
      word = p+32; // jump to 32th word
      
      // decode sums for 16 channels (6 words per channel)
      for(int channel=0;channel<16;++channel) {
        
        // Sum Xi  channel 0
        // Sum Xi  channel 1
        // Sum Xi2  LSB channel 0
        // Sum Xi2  MSB channel 0
        // Sum Xi2  LSB channel 1
        // Sum Xi2  MSB channel 1
        
        sum[channel*2+HG] = *(word++);
        sum[channel*2+LG] = *(word++);
        
        uint32_t lsb0 = *(word++);
        uint32_t msb0 = *(word++);
        uint32_t lsb1 = *(word++);
        uint32_t msb1 = *(word++);
        uint64_t MSB0 = (uint64_t) msb0 << 32;
        uint64_t MSB1 = (uint64_t) msb1 << 32;
        uint64_t SSQ0 = MSB0 | lsb0;
        uint64_t SSQ1 = MSB1 | lsb1;
        
        ssq[channel*2+HG] = SSQ0;
        ssq[channel*2+LG] = SSQ1;
        
        // COMPUTE MEAN AND STANDARD DEVIATION
        ped[channel*2+HG] = double(sum[channel*2+HG])/nevt;
        ped[channel*2+LG] = double(sum[channel*2+LG])/nevt;
        
        std[channel*2+HG] = double(ssq[channel*2+HG])/nevt - ped[channel*2+HG]*ped[channel*2+HG];
        std[channel*2+LG] = double(ssq[channel*2+LG])/nevt - ped[channel*2+LG]*ped[channel*2+LG];
        if (std[channel*2+HG]>0.0) std[channel*2+HG] = sqrt(std[channel*2+HG]);
        if (std[channel*2+LG]>0.0) std[channel*2+LG] = sqrt(std[channel*2+LG]);
        
        // PLEASE NOTE THAT   LG EQUALS 1  WHEN  TILEID::LOWGAIN  EQUALS 0
        //                    HG EQUALS 0  WHEN  TILEID::HIGHGAIN EQUALS 1
        // THIS CONFUSING INDEXING IS TAKEN CARE OF IN THE FOLLOWING TWO LINES AND WILL *NOT*
        // BE PROPAGATED FURTHER DOWN THE CHAIN. THIS MEANS THAT AFTER THIS LG=0 AND HG=1
    laserObject.setCalibType(int(p[31]));
        laserObject.setCalib(channel,int(p[31]), double(sum[channel*2+LG]), double(ssq[channel*2+LG]), nevt, TileID::LOWGAIN);
        laserObject.setCalib(channel,int(p[31]), double(sum[channel*2+HG]), double(ssq[channel*2+HG]), nevt, TileID::HIGHGAIN);
        
        // DEBUGGING OUTPUT
        if(debug){
          ATH_MSG_DEBUG("PED CHAN=" << channel << " GAIN=LG" << " TYPE=" << laserObject.getType(channel,TileID::LOWGAIN,0) << " MEAN=" << laserObject.getMean(channel,TileID::LOWGAIN,0) << " SIGMA=" << laserObject.getSigma(channel,TileID::LOWGAIN,0) << " N=" << laserObject.getN(channel,TileID::LOWGAIN,0) << " isSet?=" << laserObject.isSet(channel,TileID::LOWGAIN,0) );
          ATH_MSG_DEBUG("PED CHAN=" << channel << " GAIN=HG" << " TYPE=" << laserObject.getType(channel,TileID::HIGHGAIN,0) << " MEAN=" << laserObject.getMean(channel,TileID::HIGHGAIN,0) << " SIGMA=" << laserObject.getSigma(channel,TileID::HIGHGAIN,0) << " N=" << laserObject.getN(channel,TileID::HIGHGAIN,0) << " isSet?=" << laserObject.isSet(channel,TileID::HIGHGAIN,0) );
          
          ATH_MSG_DEBUG("PED CHAN=" << channel << " GAIN=LG" << " TYPE=" << laserObject.getType(channel,TileID::LOWGAIN,1) << " MEAN=" << laserObject.getMean(channel,TileID::LOWGAIN,1) << " SIGMA=" << laserObject.getSigma(channel,TileID::LOWGAIN,1) << " N=" << laserObject.getN(channel,TileID::LOWGAIN,1) << " isSet?=" << laserObject.isSet(channel,TileID::LOWGAIN,1) );
          ATH_MSG_DEBUG("PED CHAN=" << channel << " GAIN=HG" << " TYPE=" << laserObject.getType(channel,TileID::HIGHGAIN,1) << " MEAN=" << laserObject.getMean(channel,TileID::HIGHGAIN,1) << " SIGMA=" << laserObject.getSigma(channel,TileID::HIGHGAIN,1) << " N=" << laserObject.getN(channel,TileID::HIGHGAIN,1) << " isSet?=" << laserObject.isSet(channel,TileID::HIGHGAIN,1) );
          
          ATH_MSG_DEBUG("LED CHAN=" << channel << " GAIN=LG" << " TYPE=" << laserObject.getType(channel,TileID::LOWGAIN,2) << " MEAN=" << laserObject.getMean(channel,TileID::LOWGAIN,2) << " SIGMA=" << laserObject.getSigma(channel,TileID::LOWGAIN,2) << " N=" << laserObject.getN(channel,TileID::LOWGAIN,2) << " isSet?=" << laserObject.isSet(channel,TileID::LOWGAIN,2) );
          ATH_MSG_DEBUG("LED CHAN=" << channel << " GAIN=HG" << " TYPE=" << laserObject.getType(channel,TileID::HIGHGAIN,2) << " MEAN=" << laserObject.getMean(channel,TileID::HIGHGAIN,2) << " SIGMA=" << laserObject.getSigma(channel,TileID::HIGHGAIN,2) << " N=" << laserObject.getN(channel,TileID::HIGHGAIN,2) << " isSet?=" << laserObject.isSet(channel,TileID::HIGHGAIN,2) );
          
          ATH_MSG_DEBUG("ALP CHAN=" << channel << " GAIN=LG" << " TYPE=" << laserObject.getType(channel,TileID::LOWGAIN,3) << " MEAN=" << laserObject.getMean(channel,TileID::LOWGAIN,3) << " SIGMA=" << laserObject.getSigma(channel,TileID::LOWGAIN,3) << " N=" << laserObject.getN(channel,TileID::LOWGAIN,3) << " isSet?=" << laserObject.isSet(channel,TileID::LOWGAIN,3) );
          ATH_MSG_DEBUG("ALP CHAN=" << channel << " GAIN=HG" << " TYPE=" << laserObject.getType(channel,TileID::HIGHGAIN,3) << " MEAN=" << laserObject.getMean(channel,TileID::HIGHGAIN,3) << " SIGMA=" << laserObject.getSigma(channel,TileID::HIGHGAIN,3) << " N=" << laserObject.getN(channel,TileID::HIGHGAIN,3) << " isSet?=" << laserObject.isSet(channel,TileID::HIGHGAIN,3) );
          
          ATH_MSG_DEBUG(MSG::hex << msb0 << " + " << lsb0 << " => " << SSQ0 <<
                        MSG::dec << "  >>>  D" << channel << "(HG)"
                        << " SUMX/N="
                        << sum[channel*2+HG]
                        << " / " << nevt
                        << " = "
                        << ped[channel*2+HG]
                        << " SUMX2/N="
                        << ssq[channel*2+HG]
                        << " / " << nevt
                        << " => STD="
                        << std[channel*2+0]);
          ATH_MSG_DEBUG(MSG::hex << msb1 << " + " << lsb1 << " => " << SSQ1 <<
                        MSG::dec << "  >>>  D" << channel << "(LG)"
                        << " SUMX/N="
                        << sum[channel*2+LG]
                        << " / " << nevt
                        << " = "
                        << ped[channel*2+LG]
                        << " SUMX2/N="
                        << ssq[channel*2+LG]
                        << " / " << nevt
                        << " => STD="
                        << std[channel*2+LG]);
        } // IF
        
        ped[channel*2+0] = 8500. - ped[channel*2+0];
        ped[channel*2+1] = 8500. - ped[channel*2+1];
      }
      
    } else { // nevt == 0
      ATH_MSG_DEBUG("WARNING NEVT=0");
      memset(ped,0,sizeof(ped));
      memset(std,0,sizeof(std));
    }
    
    if (debug) {
      for(int channel=0;channel<16;++channel){
        ATH_MSG_DEBUG("HG  CHANNEL " << channel << ":  sig=" << las[HG+channel*2] << " ped=" << ped[HG+channel*2] << "+/-" << std[HG+channel*2]);
        ATH_MSG_DEBUG("LG  CHANNEL " << channel << ":  sig=" << las[LG+channel*2] << " ped=" << ped[LG+channel*2] << "+/-" << std[LG+channel*2]);
      }
    }
    
  } else { // short fragment
    ATH_MSG_DEBUG("SHORT FRAGMENT, size=" << p[0] << " type=0x" << MSG::hex << p[1] << MSG::dec);
    memset(ped,0,sizeof(ped));
    memset(std,0,sizeof(std));
  }
  
  // ATTENTION: note that HG has even index (0,2,4,...) in las[], ped[], std[] arrays
  
  // STORE PMT INFORMATION
  //PMT1
  laserObject.setPmt(0,las[HG+10*2],TDC0,laserObject.getMean(10,TileID::HIGHGAIN,0),laserObject.getSigma(10,TileID::HIGHGAIN,0),TileID::HIGHGAIN);
  laserObject.setPmt(0,las[LG+10*2],TDC0,laserObject.getMean(10,TileID::LOWGAIN,0), laserObject.getSigma(10,TileID::LOWGAIN,0), TileID::LOWGAIN);
  //PMT2
  laserObject.setPmt(1,las[HG+14*2],TDC1,laserObject.getMean(14,TileID::HIGHGAIN,0),laserObject.getSigma(14,TileID::HIGHGAIN,0),TileID::HIGHGAIN);
  laserObject.setPmt(1,las[LG+14*2],TDC1,laserObject.getMean(14,TileID::LOWGAIN,0), laserObject.getSigma(14,TileID::LOWGAIN,0), TileID::LOWGAIN);
  
  // STORE DIODE INFORMATION
  for(int diode=0;diode<10;++diode){
    laserObject.setDiode(diode,las[HG+diode*2],laserObject.getMean( diode,TileID::HIGHGAIN,0),
                                               laserObject.getSigma(diode,TileID::HIGHGAIN,0),
                                               laserObject.getMean( diode,TileID::HIGHGAIN,3),
                                               laserObject.getSigma(diode,TileID::HIGHGAIN,3),0.,0.,TileID::HIGHGAIN);
    laserObject.setDiode(diode,las[LG+diode*2],laserObject.getMean( diode,TileID::LOWGAIN,0),
                                               laserObject.getSigma(diode,TileID::LOWGAIN,0),
                                               laserObject.getMean( diode,TileID::LOWGAIN,3),
                                               laserObject.getSigma(diode,TileID::LOWGAIN,3),0.,0.,TileID::LOWGAIN);
  } // FOR
  laserObject.setDiode(10,las[HG+22],laserObject.getMean( 11,TileID::HIGHGAIN,0),
                                     laserObject.getSigma(11,TileID::HIGHGAIN,0),
                                     laserObject.getMean( 11,TileID::HIGHGAIN,3),
                                     laserObject.getSigma(11,TileID::HIGHGAIN,3),0.,0.,TileID::HIGHGAIN); // EXTERNAL CIS 0 HG
  laserObject.setDiode(10,las[LG+22],laserObject.getMean( 11,TileID::LOWGAIN,0),
                                     laserObject.getSigma(11,TileID::LOWGAIN,0),
                                     laserObject.getMean( 11,TileID::LOWGAIN,3),
                                     laserObject.getSigma(11,TileID::LOWGAIN,3),0.,0.,TileID::LOWGAIN);  // EXTERNAL CIS 0 LG
  laserObject.setDiode(11,las[HG+24],laserObject.getMean( 12,TileID::HIGHGAIN,0),
                                     laserObject.getSigma(12,TileID::HIGHGAIN,0),
                                     laserObject.getMean( 12,TileID::HIGHGAIN,3),
                                     laserObject.getSigma(12,TileID::HIGHGAIN,3),0.,0.,TileID::HIGHGAIN); // INTERNAL CIS HG
  laserObject.setDiode(11,las[LG+24],laserObject.getMean( 12,TileID::LOWGAIN,0),
                                     laserObject.getSigma(12,TileID::LOWGAIN,0),
                                     laserObject.getMean( 12,TileID::LOWGAIN,3),
                                     laserObject.getSigma(12,TileID::LOWGAIN,3),0.,0.,TileID::LOWGAIN);  // INTERNAL CIS LG
  laserObject.setDiode(12,las[HG+26],laserObject.getMean( 13,TileID::HIGHGAIN,0),
                                     laserObject.getSigma(13,TileID::HIGHGAIN,0),
                                     laserObject.getMean( 13,TileID::HIGHGAIN,3),
                                     laserObject.getSigma(13,TileID::HIGHGAIN,3),0.,0.,TileID::HIGHGAIN); // PHOTODIODE PHOCAL HG
  laserObject.setDiode(12,las[LG+26],laserObject.getMean( 13,TileID::LOWGAIN,0),
                                     laserObject.getSigma(13,TileID::LOWGAIN,0),
                                     laserObject.getMean( 13,TileID::LOWGAIN,3),
                                     laserObject.getSigma(13,TileID::LOWGAIN,3),0.,0.,TileID::LOWGAIN);  // PHOTODIODE PHOCAL LG
  laserObject.setDiode(13,las[HG+30],laserObject.getMean( 15,TileID::HIGHGAIN,0),
                                     laserObject.getSigma(15,TileID::HIGHGAIN,0),
                                     laserObject.getMean( 15,TileID::HIGHGAIN,3),
                                     laserObject.getSigma(15,TileID::HIGHGAIN,3),0.,0.,TileID::HIGHGAIN); // EXTERNAL CIS HG
  laserObject.setDiode(13,las[LG+30],laserObject.getMean( 15,TileID::LOWGAIN,0),
                                     laserObject.getSigma(15,TileID::LOWGAIN,0),
                                     laserObject.getMean( 15,TileID::LOWGAIN,3),
                                     laserObject.getSigma(15,TileID::LOWGAIN,3),0.,0.,TileID::LOWGAIN);  // EXTERNAL CIS LG
  
} // unpack_frag17

unpack_frag2()

void TileROD_Decoder::unpack_frag2 ( uint32_t version, uint32_t sizeOverhead, const uint32_t * p, pRwChVec & pChannel, int fragID, int demoType ) const

private

unpack_frag2 decodes tile subfragment type 0x2.

This subfragment contains the reconstructed amplitude and phase from the tilecal digitized pulse and a quality factor of the reconstruction.

The amplitude is not calibrated and is encoded in ADC counts.

The phase is encoded in ns.

The subfragment type 0x2 contains the reconstructed parameters from the 48 read-out channels of a tilecal module.

Definition at line 787 of file TileROD_Decoder.cxx.

                                                             {
  // first word is frag size
  int count = *(p);
  // second word is frag ID and frag type
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
  
  //  ATH_MSG_VERBOSE( "Unpacking TileRawChannels, ID=" << frag << " size=" << count );
  
  //  ATH_MSG_VERBOSE( "first 2 words " << MSG::hex
  //                  << "  0x" << *p
  //                  << "  0x" << *(p+1)
  //                  << MSG::dec );
  
  p += 2; // 2 words so far
  int wc = sizeOverhead; // can be 2 or 3 words
  
  HWIdentifier drawerID = m_tileHWID->drawer_id(frag);
  TileRawChannel* rc;
  
  for (unsigned int ch = 0; ch < m_maxChannels; ++ch) {
    unsigned int w = (*p);
    
    int gain = m_rc2bytes2.gain(w);
    HWIdentifier adcID = m_tileHWID->adc_id(drawerID, ch, gain);
    
    if (w != 0) { // skip invalid channels
      rc = new TileRawChannel(adcID, m_rc2bytes2.amplitude(w), m_rc2bytes2.time(w),
                              m_rc2bytes2.quality(w));
    } else {
      rc = new TileRawChannel(adcID, 0.0, -100.0, 31);
    }
    
    pChannel.push_back(rc);
    
    //      ATH_MSG_VERBOSE(" frag 0x" << MSG::hex << frag
    //                      << MSG::dec << " ch " << ch
    //                      << " " << MSG::hex << w << MSG::dec
    //                      << " " << gain
    //                      << " " << m_rc2bytes2.amplitude(w)
    //                      << " " << m_rc2bytes2.time(w)
    //                      << " " << m_rc2bytes2.quality(w) );
    
    ++wc;
    ++p;
  }
  
  if (wc != count) {
    // check word count
    if ((m_ErrorCounter++) < m_maxErrorPrint) {
      ATH_MSG_WARNING( "unpack_frag2 => Incorrect word count: "
                       << wc << " != " << count );
    }
    assert(0);
    // return;
  }
  
  return;
}

unpack_frag2HLT()

void TileROD_Decoder::unpack_frag2HLT ( uint32_t version, uint32_t sizeOverhead, const uint32_t * p, FRwChVec & pChannel, int fragID, int demoType ) const

private

unpack_frag2HLT decodes tile subfragment type 0x2 for the high level trigger (HLT).

This subfragment contains the reconstructed amplitude and phase from the tilecal digitized pulse and a quality factor of the reconstruction.

The amplitude is not calibrated and is encoded in ADC counts.

The phase is encoded in ns.

The subfragment type 0x2 contains the reconstructed parameters from the 48 read-out channels of a tilecal module.

Definition at line 3819 of file TileROD_Decoder.cxx.

{
  // first word is frag size
  int count = *(p);
  
  p += 2; // 2 words so far
  int wc = sizeOverhead; // can be 2 or 3 words
  
  for (unsigned int ch = 0; ch < m_maxChannels; ++ch) {
    unsigned int w = (*p);
    
    if (w != 0) { // skip invalid channels
      
      pChannel.emplace_back(ch
                            , m_rc2bytes2.gain(w)
                            , m_rc2bytes2.amplitude(w)
                            , m_rc2bytes2.time(w)
                            , m_rc2bytes2.quality(w));
      
    } else {
      pChannel.emplace_back(ch, 1U, 0.0F, 0.0F, 0.0F);
    }
    ++wc;
    ++p;
  }
  
  if (wc != count) {
    // check word count
    if ((m_ErrorCounter++) < m_maxErrorPrint) {
      ATH_MSG_WARNING("Incorrect word count: " << wc << " != " << count );
    }
    assert(0);
    // return;
  }
  
  return;
}

unpack_frag3()

void TileROD_Decoder::unpack_frag3 ( uint32_t version, uint32_t sizeOverhead, const uint32_t * p, pRwChVec & pChannel, int fragID, int demoType ) const

private

unpack_frag3 decodes tile subfragment type 0x3.

This subfragment contains the reconstructed amplitude and phase from the tilecal digitized pulse and a quality factor of the reconstruction.

The amplitude is not calibrated and it is encoded in ADC counts.

The phase is encoded in ns.

The subfragment type 0x3 contains the reconstructed parameters ONLY from the existing channels of a tilecal module.

Definition at line 850 of file TileROD_Decoder.cxx.

                                                             {
  // first word is frag size
  int count = *(p);
  // second word is frag ID and frag type
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
 
  //  ATH_MSG_VERBOSE( "first 4 words " << MSG::hex
  //                  << "  0x" << *p
  //                  << "  0x" << *(p+1)
  //                  << "  0x" << *(p+2)
  //                  << "  0x" << *(p+3) << MSG::dec );
  
  // followed by 2 map words
  const uint32_t* pMap = p + 2;
  
  const short* p16 = reinterpret_cast<const short *>(p);
  
  p16 = p16 + 8; // 8 16bit words so far
  short wc16 = 4 + sizeOverhead * 2; // can be 8 or 10 (if overhead is 3 words)
  
  HWIdentifier drawerID = m_tileHWID->drawer_id(frag);
  TileRawChannel* rc;
  
  for (unsigned int ch = 0; ch < m_maxChannels; ++ch) {
    if (checkBit(pMap, ch)) {
      int gain = m_rc2bytes.gain(*p16);
      HWIdentifier adcID = m_tileHWID->adc_id(drawerID, ch, gain);
      
      rc = new TileRawChannel(adcID
                              , m_rc2bytes.amplitude(*p16)
                              , m_rc2bytes.time(*(p16 + 1))
                              , m_rc2bytes.quality(*(p16 + 2)));
      pChannel.push_back(rc);
      
      ATH_MSG_VERBOSE( " frag 0x" << MSG::hex << frag << MSG::dec
                      << " ch " << ch << " " << MSG::hex
                      << "0x" << *p16 << *(p16+1) << *(p16+2) << MSG::dec
                      << " " << gain
                      << " " << m_rc2bytes.amplitude(*p16)
                      << " " << m_rc2bytes.time(*(p16+1))
                      << " " << m_rc2bytes.quality(*(p16+2)) );
      
      wc16 = wc16 + 3;
      p16 = p16 + 3;
    } // channel present
  } // all bits, done with this frag
  
  if (wc16 % 2 == 1) {
    ++wc16; // align
    ++p16;
  }
  if (wc16 != 2 * count) {
    // check word count
    if ((m_ErrorCounter++) < m_maxErrorPrint) {
      ATH_MSG_WARNING( "unpack_frag3 => Incorrect word count: "
                       << wc16 << " != 2*" << count );
    }
    assert(0);
    // return;
  }
  
  return;
}

unpack_frag3HLT()

void TileROD_Decoder::unpack_frag3HLT ( uint32_t version, uint32_t sizeOverhead, const uint32_t * p, FRwChVec & pChannel, int fragID, int demoType ) const

private

unpack_frag3HLT decodes tile subfragment type 0x3 for the high level trigger (HLT).

This subfragment contains the reconstructed amplitude and phase from the tilecal digitized pulse and a quality factor of the reconstruction.

The amplitude is not calibrated and it is encoded in ADC counts.

The phase is encoded in ns.

The subfragment type 0x3 contains the reconstructed parameters ONLY from the existing channels of a tilecal module.

Definition at line 3861 of file TileROD_Decoder.cxx.

{
  // first word is frag size
  int count = *(p);
  // second word is frag ID and frag type
  
  //  ATH_MSG_VERBOSE( "first 4 words " << MSG::hex
  //                  << "  0x" << *p
  //                  << "  0x" << *(p+1)
  //                  << "  0x" << *(p+2)
  //                  << "  0x" << *(p+3) << MSG::dec );
  
  // followed by 2 map words
  const uint32_t* pMap = p + 2;
  
  const short* p16 = reinterpret_cast<const short *>(p);
  
  p16 = p16 + 8; // 8 16bit words so far
  short wc16 = 4 + sizeOverhead * 2; // can be 8 or 10 (if overhead is 3 words)
  
  for (unsigned int ch = 0U; ch < 48U; ++ch) {
    if (checkBit(pMap, ch)) {
      
      pChannel.emplace_back(ch
                            , m_rc2bytes.gain(*p16)
                            , m_rc2bytes.amplitude(*p16)
                            , m_rc2bytes.time(*(p16 + 1))
                            , m_rc2bytes.quality(*(p16 + 2)));
      
      //      ATH_MSG_VERBOSE(" frag 0x" << MSG::hex  << frag << MSG::dec
      //                      << " ch " << ch
      //                      << " " << MSG::hex << "0x" << *p16 << *(p16+1) << *(p16+2) << MSG::dec
      //                      << " " << gain
      //                      << " " << m_rc2bytes.amplitude(*p16)
      //                      << " " << m_rc2bytes.time(*(p16+1))
      //                      << " " << m_rc2bytes.quality(*(p16+2)) );
      
      wc16 = wc16 + 3;
      p16 = p16 + 3;
    } // channel present
    else {
      pChannel.emplace_back(ch, 1U, 0.0F, 0.0F, 0.0F);
    }
  } // all bits, done with this frag
  
  if (wc16 % 2 == 1) {
    ++wc16; // align
    ++p16;
  }
  if (wc16 != 2 * count) {
    // check word count
    if ((m_ErrorCounter++) < m_maxErrorPrint) {
      ATH_MSG_WARNING( "unpack_frag3HLT => Incorrect wordcount: "
                       << wc16 << " != 2*" << count );
    }
    assert(0);
    // return;
  }
  
  return;
}

unpack_frag4()

void TileROD_Decoder::unpack_frag4 ( uint32_t version, uint32_t sizeOverhead, unsigned int unit, RawChannelMetaData_t & rawchannelMetaData, const uint32_t * p, pRwChVec & pChannel, int fragID, int demoType ) const

private

unpack_frag4 decodes tile subfragment type 0x4.

This subfragment contains the reconstructed amplitude and phase from the tilecal digitized pulse and a quality factor of the reconstruction.

The amplitude is calibrated to the online units that can be:

• TileRawChannelUnit::OnlineADCcounts
• TileRawChannelUnit::OnlinePicoCoulombs
• TileRawChannelUnit::OnlineCesiumPicoCoulombs
• TileRawChannelUnit::OnlineMegaElectronVolts

The phase is encoded in ns.

The subfragment type 0x4 contains the reconstructed parameters from the 48 read-out channels of a tilecal module.

Definition at line 918 of file TileROD_Decoder.cxx.

{
  // first word is frag size
  int count = *(p);
  // second word is frag ID and frag type
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
  bool remap = (drawer_type > 0) || std::binary_search(m_demoFragIDs.begin(), m_demoFragIDs.end(), frag);
  const std::vector<int> & chmap = (frag<0x300) ? m_demoChanLB : m_demoChanEB;
  
  //  ATH_MSG_VERBOSE( "Unpacking TileRawChannels, ID=" << frag << " size=" << count <<s);
  
  //  ATH_MSG_VERBOSE( "first 2 words " << MSG::hex
  //                  << "  0x" << *p
  //                  << "  0x" << *(p+1) << MSG::dec );
  
  p += 2; // 2 words so far
  int wc = sizeOverhead; // can be 2 or 3 words
  
  HWIdentifier drawerID = m_tileHWID->drawer_id(frag);
  TileRawChannel* rc;
  uint32_t all00 = TileFragStatus::ALL_00;
  uint32_t allFF = TileFragStatus::ALL_FF;
 
  for (unsigned int ch = 0; ch < m_maxChannels; ++ch) {
    unsigned int w = (*p);
    
    int gain = m_rc2bytes4.gain(w);
    int ch1 = (remap) ? chmap[ch] : ch;
    HWIdentifier adcID = m_tileHWID->adc_id(drawerID, ch1, gain);
    
    if (allFF && w!=0xFFFFFFFF) allFF = TileFragStatus::ALL_OK;
    if (w != 0) { // skip invalid channels
      if (all00) all00 = TileFragStatus::ALL_OK;
      rc = new TileRawChannel(adcID
                              , m_rc2bytes4.amplitude(w, unit)
                              , m_rc2bytes4.time(w)
                              , m_rc2bytes4.quality(w));
    } else {
      rc = new TileRawChannel(adcID, 0.0, -100., 31);
    }
    
    pChannel.push_back(rc);
    
    //      ATH_MSG_VERBOSE(  MSG::hex << " frag 0x" << frag << MSG::dec
    //                      << " ch " << ch
    //                      << " 0x" << MSG::hex << w << MSG::dec
    //                      << " " << gain
    //                      << " " << m_rc2bytes4.amplitude(w)
    //                      << " " << m_rc2bytes4.time(w)
    //                      << " " << m_rc2bytes4.quality(w) );
    
    ++wc;
    ++p;
  }
  if (remap) std::sort(pChannel.end()-m_maxChannels,pChannel.end(),chan_order);
  
  rawchannelMetaData[6].push_back( all00 | allFF );
 
  if (wc > count) {
    // check word count
    if ((m_ErrorCounter++) < m_maxErrorPrint) {
      ATH_MSG_WARNING( "unpack_frag4 => Incorrect word count: "
                       << wc << " != " << count );
    }
    assert(0);
    // return;
    //  } else if (wc < count) {
    //    ATH_MSG_VERBOSE("unpack_frag4 => extra " << count-wc << " words in frag" );
  }
  
  return;
}

unpack_frag40()

void TileROD_Decoder::unpack_frag40 ( uint32_t collid, uint32_t version, const uint32_t * p, int size, TileDigitsCollection & coll ) const

private

unpacking methods dedicated to the TMDB ROD format sub-fragments 0x40 0x41 0x42

Definition at line 4699 of file TileROD_Decoder.cxx.

                                      {
 
  int ros = (collid >> 8);
  int drawer = collid & 0xff;
  HWIdentifier drawerID = m_tileHWID->drawer_id(ros, drawer);
  int nsamp = 7; // assume fixed number of samples for the moment
  int nmod = (ros > 2) ? 8 : 4; // we have 8 modules per fragment in ext.barrel, 4 modules in barrel
  int nchan = 4 * datasize / nmod / nsamp; // factor 4 because in one 32-bit word we have 4 samples
 
  int nsamp1 = nsamp - 1;
 
  std::vector<float> digits(nsamp);
 
  // Each 32 bit word is made of four 8-bit words each a ADC of a sample like
  //
  //     32nd bit -> |   37/D6R  |   38/D6L  |  16/D5R  |  17/D5L  | <- 1st bit
  // 
  // First come 8 words (M0->M7) with sample 0 and so forth i.e. the digits for the first module are placed by words: {0,8,16,24,32,40,48}.
  // Note that order of samples is inversed with respect to time line, 
  // i.e. first sample from data should go to the last sample in TileDigits vector
 
  int wpos = (collid % nmod) * nchan; // location of first sample for given channel in given module
  int jump = nchan * nmod; // distance between samples for one channel in number of bytes
  const unsigned char * adc = reinterpret_cast<const unsigned char *>(p);
 
  for (int i = 0; i < nchan; ++i) {
    for (int j = 0; j < nsamp; ++j) {
      digits[nsamp1 - j] = adc[wpos + jump * j];
    }
    ++wpos;
    HWIdentifier adcID = m_tileHWID->adc_id(drawerID, i, TileID::LOWGAIN);
    TileDigits *digitmp = new TileDigits(adcID, digits);
    coll.push_back(digitmp);
  }
 
  if (msgLvl(MSG::DEBUG)) {
    msg(MSG::DEBUG) << "TileROD_Decoder::unpack_frag40  frag: 0x" << MSG::hex << collid << MSG::dec
                    << " version: " << version << endmsg;
 
    int pos = coll.size() - nchan;
    const char * strchannel[13] = { " d5L ", " d5R ", " d6L ", " d6R ",
                                    " xxx ", " d0x ", " d1L ", " d1R ", " d2L ", " d2R ", " d3L ", " d3R ", " xxx " };
    int nchmax = (ros > 2) ? 4 : 8;
    for (int i = 0; i < nchan; ++i) {
      const std::vector<float> & sample = coll.at(pos + i)->samples();
      std::stringstream ss;
      for (const auto & val : sample) {
        ss << std::setw(5) << int(val);
      }
      msg(MSG::DEBUG) << " ros:" << ros
                      << " drawer:" << drawer
                      << " ch:" << i << strchannel[std::min(i, nchmax)+nchmax-4] << ss.str() << endmsg;
    }
  }
 
  return;
}

unpack_frag41()

void TileROD_Decoder::unpack_frag41 ( uint32_t collid, uint32_t version, const uint32_t * p, int size, TileRawChannelCollection & coll ) const

private

Definition at line 4758 of file TileROD_Decoder.cxx.

                                                                                                                                              {
 
  int ros=(collid>>8);
  int drawer=collid&0xff;
  HWIdentifier drawerID = m_tileHWID->drawer_id(ros,drawer);
  float calFactorADC2MeV = 1.0;
 
  int nmod = (ros>2)?8:4; // we have 8 modules per fragment in ext.barrel, 4 modules in barrel
  int nchan = datasize / nmod;
 
  int wpos = (collid % nmod) * nchan;
 
  if (version == 0) {
 
    // Each 32 bit word is an energy of a channel pmt
    //
    //    32nd bit -> |                     17/D5L                  | <- 1st bit
    //    32nd bit -> |                     16/D5R                  | <- 1st bit
    //    32nd bit -> |                     37/D6L                  | <- 1st bit
    //    32nd bit -> |                     38/D6R                  | <- 1st bit
    //
    // Each 4 words respect a module. 
 
    const int32_t * pp = reinterpret_cast<const int32_t *>(p);
    pp += wpos;
    for (int i = 0; i < nchan; ++i) {
      HWIdentifier adcID = m_tileHWID->adc_id(drawerID, i, TileID::LOWGAIN);
      TileRawChannel *rctmp = new TileRawChannel(adcID, (*pp) * calFactorADC2MeV, 0., 0.);
      coll.push_back(rctmp);
      ++pp;
    }
 
  } else {
 
    // Each 32 bit word is made of two 16-bit words each a energy of a channel pmt
    //
    //    32nd bit -> |         16/D5R        |        17/D5L       | <- 1st bit
    //    32nd bit -> |         38/D6R        |        37/D6L       | <- 1st bit
    //
    // Each 2 words respect a module. 
      
    nchan *= 2; // change number of channels calculated before assuming 16 bits for channel
    const int16_t * pp = reinterpret_cast<const int16_t *>(p);
    pp += wpos;
    for (int i = 0; i < nchan; ++i) {
      HWIdentifier adcID = m_tileHWID->adc_id(drawerID, i, TileID::LOWGAIN);
      TileRawChannel *rctmp = new TileRawChannel(adcID, (*pp) * calFactorADC2MeV, 0., 0.);
      coll.push_back(rctmp);
      ++pp;
    }
  }
  
  if (msgLvl(MSG::DEBUG)) {
    msg(MSG::DEBUG) << " TileROD_Decoder::unpack_frag41  frag: 0x" << MSG::hex << collid << MSG::dec
                    << " version: " << version << endmsg;
 
    int nbits = (version == 0) ? 32 : 16;
    msg(MSG::DEBUG) << " position of " << nbits << "-bit word inside sub-fragment 0x41: " << wpos << endmsg;
    int pos = coll.size() - nchan;
    const char * strchannel[13] = { " d5L ", " d5R ", " d6L ", " d6R ",
                                    " xxx ", " d0x ", " d1L ", " d1R ", " d2L ", " d2R ", " d3L ", " d3R ", " xxx " };
    int nchmax = (ros > 2) ? 4 : 8;
    for (int i = 0; i < nchan; ++i) {
      msg(MSG::DEBUG) << " ros:" << ros
                      << " drawer:" << drawer
                      << " ch:" << i << strchannel[std::min(i, nchmax)+nchmax-4] << coll.at(pos + i)->amplitude() << endmsg;
    }
  }
 
  return;
}

unpack_frag42()

void TileROD_Decoder::unpack_frag42 ( uint32_t sourceid, uint32_t version, const uint32_t * p, int size, TileMuonReceiverContainer & v ) const

private

Definition at line 4830 of file TileROD_Decoder.cxx.

                                                                                                                                              {
 
  // == RUN 2 ==
  // results are hold in 3 16-bit words.
  //
  //    32nd bit -> |        results2       ||        results1       | <- 1st bit
  //                |          0x0          ||        results3       |
  //
  //    32nd bit -> | m-5 | m-4 | m-3 | m-2 || m-2 | m-1 | m-0 | 0x0 | <- 1st bit
  //                |          0x0          || 0x0 | m-7 | m-6 | m-5 |
  //
  // each 4 bit word is
  //                   0      1      2     3    <-- in Obj
  //                | d56h | d56l | d6h | d6l |
  //                  bit3   bit2  bit1  bit0 
  //
  // bit-3 -> result.at(0)
  // bit-2        .
  // bit-1        .
  // bit-0 -> result.at(3)
  //
  // == RUN 3 ==
  // results are hold in 3 16-bit words.
  //
  //               32nd bit -> |         results2 [16:31]            ||           results1 [0:15]           | <- 1st bit
  //               32nd bit -> |            0x0   [16:31]            ||           results3 [0:15]           | <- 1st bit
  //
  //               32nd bit -> | bcid1 [12:15] | m-5 | m-4 | m-3 | m-2 || bcid0 [12:15] | m-3 | m-2 | m-1 | m-0 | <- 1st bit
  //                           |          0x0 [16:31]                  || bcid2 [12:15] | m-7 | m-6 | m-5 | m-4 |
  //
  // For each module m-X there is a 3-bit word with the results for a threshold
  //
  //                    |  d5+d6  |  d6   |  d5  |
  //                    |   bit2  |  bit1 | bit0 |
  //
 
  int nbit=0;
  int nmod=0;
  uint32_t word=0x0;
  uint32_t bcid=0x0;
 
  int drawer = (sourceid & 0xf0000) >> 8; // get ROS number from source ID
  if (drawer<0x300) { // barrel
    nbit = 4;
    nmod = 4;
    drawer |= ((sourceid & 0x0000f) << 2);
    word = (datasize > 0) ? p[0] : 0; // just use first word, although expect all zeros for the moment
  } else { // extended barrel
    nbit = 4;
    nmod = 8;
    drawer |= ((sourceid & 0x0000f) << 3);
    if (datasize > 1) {
      if (m_runPeriod<=2) {
        word = (p[1] << 20) | ((p[0] >> 8) & 0xff000) | ((p[0] >> 4) & 0xfff);
      } else {
        word = ((p[1] & 0xfff) << 12) | (p[0] & 0xfff);
        // keeping all 12 bits of information (just for cross check) |bcid2|bcid1|bcid0|
        bcid = ((p[1] >> 4) & 0xf00) | ((p[0] >> 24) & 0xf0) | ((p[0] >> 12) & 0xf);
      }
    }
  }
 
  drawer |= (bcid<<16) ;
 
  std::vector<bool> result(nbit);
  for (int j = 0; j < nmod; ++j) { // loop over modules
    for (int k = nbit-1; k >= 0; --k) { // loop over bits of one module in inversed order
      if (m_runPeriod<=2) {
          result[k] = (word & 1);
      word >>= 1;
      } else {
          if (k==0) {
         result[k]=0;
      } else {
         result[k] = (word & 1);
         word >>= 1;
      }
      }
    }
    TileMuonReceiverObj * obj = new TileMuonReceiverObj(drawer, result);
    v.push_back(obj);
    ++drawer;
  }
 
  if (msgLvl(MSG::DEBUG)) {
    if (m_runPeriod<=2) msg(MSG::DEBUG) << "TMDB version for RUN2 simulation (2014)" <<endmsg;
    else msg(MSG::DEBUG) << "TMDB version for RUN3 simulation (2020)" <<endmsg;
 
    msg(MSG::DEBUG) << " TileROD_Decoder::unpack_frag42  source ID: 0x" << MSG::hex << sourceid << MSG::dec
                    << " version: " << version << " bcid | drawer " << MSG::hex << drawer << endmsg;
 
    for (size_t j = v.size() - nmod; j < v.size(); ++j) {
      const std::vector<bool> & r = v[j]->GetDecision();
      std::stringstream ss;
      for (const bool val : r) {
        ss << std::setw(2) << val;
      }
      msg(MSG::DEBUG) << MSG::hex << "0x" << v[j]->GetID() << MSG::dec << ss.str() << endmsg;
    }
  }
 
  return;
}

unpack_frag4HLT()

void TileROD_Decoder::unpack_frag4HLT ( uint32_t version, uint32_t sizeOverhead, unsigned int unit, const uint32_t * p, FRwChVec & pChannel, int fragID, int demoType ) const

private

unpack_frag4HLT decodes tile subfragment type 0x4 for the high level trigger (HLT).

This subfragment contains the reconstructed amplitude and phase from the tilecal digitized pulse and a quality factor of the reconstruction.

The amplitude is calibrated to the online units that can be:

• TileRawChannelUnit::OnlineADCcounts
• TileRawChannelUnit::OnlinePicoCoulombs
• TileRawChannelUnit::OnlineCesiumPicoCoulombs
• TileRawChannelUnit::OnlineMegaElectronVolts

The phase is encoded in ns.

The subfragment type 0x4 contains the reconstructed parameters from the 48 read-out channels of a tilecal module.

Definition at line 3927 of file TileROD_Decoder.cxx.

{
  // first word is frag size
  int count = *(p);
  // second word is frag ID and frag type
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
  bool remap = (drawer_type > 0) || std::binary_search(m_demoFragIDs.begin(), m_demoFragIDs.end(), frag);
  const std::vector<int> & chmap = (frag<0x300) ? m_demoChanLB : m_demoChanEB;
  
  p += 2; // 2 words so far
  int wc = sizeOverhead; // can be 2 or 3 words
  for (unsigned int ch = 0U; ch < m_maxChannels; ++ch) {
    unsigned int ch1 = (remap) ? chmap[ch] : ch;
    unsigned int w = (*p);
    if (w != 0) { // skip invalid channels
      pChannel.emplace_back(ch1
                            , m_rc2bytes4.gain(w)
                            , m_rc2bytes4.amplitude(w, unit)
                            , m_rc2bytes4.time(w)
                            , m_rc2bytes4.quality(w));
      
    } else {
      pChannel.emplace_back(ch1, 1U, 0.0F, 0.0F, 0.0F);
    }
    ++wc;
    ++p;
  }
  if (remap) std::sort(pChannel.end()-m_maxChannels,pChannel.end(),chan_order1);
  
  if (wc > count) {
    // check word count
    if ((m_ErrorCounter++) < m_maxErrorPrint) {
      ATH_MSG_WARNING( "unpack_frag4HLT => Incorrect word count: "
                       << wc << " != " << count );
    }
    assert(0);
    // return;
  }
  
  return;
}

unpack_frag4L2()

bool TileROD_Decoder::unpack_frag4L2 ( uint32_t version, uint32_t sizeOverhead, const uint32_t * p, TileL2Container & v, int fragID, int demoType ) const

private

unpack_frag4L2 decodes tile subfragment type 0x4 and extract transverse energy from this fragment

Definition at line 4037 of file TileROD_Decoder.cxx.

                                                               {
  // first word is frag size
  int size = *(p);
  // second word is frag ID and frag type
  uint32_t idAndType = *(p + 1);
  int frag = (frag_id>0) ? frag_id : idAndType & 0xFFFF;
  int unit = (idAndType >> (32 - 2)) & 0x3;
  
#ifdef DO_NOT_USE_MUON_TAG
  
  p += 50; // offset 50: 2 words in header and 48 channels after
  
#else
  
  // this part should be very similar to unpack_frag4HLT - it reads amplitude from DSP
  // and then uses vector of 48 amplitudes to calculate Muon tags
  // but since nobody is using Tile Muon tags in L2 trigger
  // this part is not implemented
  
  p+=50;// offset 50: 2 words in header and 48 channels after
  
#endif
  
  int size_L2 = size - sizeOverhead - 48;
  if (size_L2 > 0) {
    
    std::vector<float> sumE;
    sumE.reserve(size_L2);
    while (size_L2--) {
      sumE.push_back(Frag5_unpack_bin2sum(unit, (int)(*(p++))));
    }
    (*pL2[m_hashFunc(frag)]).setEt(std::move(sumE));
    
    return true;
    
  } else {
    
    return false; // indicate that there is no sumEt info in the fragment
  }
}

unpack_frag5()

void TileROD_Decoder::unpack_frag5 ( uint32_t version, uint32_t sizeOverhead, unsigned int unit, DigitsMetaData_t & digitsMetaData, const uint32_t * p, pDigiVec & pDigits, pRwChVec & pChannel, int fragID, int demoType ) const

private

unpack_frag5 decodes tile subfragment type 0x4.

This subfragment contains the reconstructed amplitude and phase from the tilecal digitized pulse and a quality factor of the reconstruction.

The amplitude is calibrated to the online units that can be:

• TileRawChannelUnit::OnlineADCcounts
• TileRawChannelUnit::OnlinePicoCoulombs
• TileRawChannelUnit::OnlineCesiumPicoCoulombs
• TileRawChannelUnit::OnlineMegaElectronVolts

The phase is encoded in ns.

The subfragment type 0x5 contains the reconstructed parameters and residuals from the 48 read-out channels of a tilecal module.

Definition at line 997 of file TileROD_Decoder.cxx.

{
  // first word is frag size
  int count = *(p);
  // second word is frag ID and frag type
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
  bool remap = (drawer_type > 0) || std::binary_search(m_demoFragIDs.begin(), m_demoFragIDs.end(), frag);
  const std::vector<int> & chmap = (frag<0x300) ? m_demoChanLB : m_demoChanEB;
  int size_L2 = (*(p + 1) >> (32 - 2 - 3)) & 0x7;
  
  // store metadata for this collection
  // size, fragID, BCID
  digitsMetaData[0].push_back(count);
  digitsMetaData[0].push_back(frag);
  digitsMetaData[0].push_back(0);
  
  TileRawChannel2Bytes5::TileChanData ChanData[48];
  const uint32_t* ptrFrag = reinterpret_cast<const uint32_t*> (p - 1); // begin of fragment
  const uint32_t* ptrOFW = getOFW(frag, unit); // get OF Weights
  m_rc2bytes5.unpack(ptrOFW, ptrFrag, ChanData);
  
  int wc = sizeOverhead; // can be 2 or 3 words
  int bc = (size_L2 * 32 + 48) / 8; // size_L2 + BadBits
  
  HWIdentifier drawerID = m_tileHWID->drawer_id(frag);
  
  std::vector<float> digiVec(7);
  if (m_useFrag5Raw) pDigits.reserve(pDigits.size() + 48);
  if (m_useFrag5Reco) pChannel.reserve(pChannel.size() + 48);
  
  for (int ch = 0; ch < 48; ++ch) {
    int size = m_rc2bytes5.get_size_code(ChanData[ch].code);
    int gain = ChanData[ch].gain;
    int ch1 = (remap) ? chmap[ch] : ch;
    HWIdentifier adcID = m_tileHWID->adc_id(drawerID, ch1, gain);
    
    if (m_useFrag5Raw) {
      for (int i = 0; i < 7; ++i) digiVec[i] = ChanData[ch].s[i];
      TileDigits* td = new TileDigits(adcID, digiVec);
      pDigits.push_back(td);
    }
    
    if (m_useFrag5Reco) {
      int format = m_rc2bytes5.get_format(ChanData[ch].code);
      int quality = m_rc2bytes5.get_quality(ChanData[ch].bad, format);
      float ene = ChanData[ch].ene;
      float time = ChanData[ch].time;
      
      TileRawChannel* rc = new TileRawChannel(adcID, ene, time, quality);
      pChannel.push_back(rc);
    }
    bc += size;
  }
  if (remap) {
    std::sort(pDigits.end()-m_maxChannels,pDigits.end(),chan_order);
    std::sort(pChannel.end()-m_maxChannels,pChannel.end(),chan_order);
  }
  
  wc += (bc + 3) / 4;
  if (wc > count) {
    // check word count
    if ((m_ErrorCounter++) < m_maxErrorPrint) {
      ATH_MSG_WARNING( " unpack_frag5 => Incorrect word count: "
                       << wc << " != " << count );
    }
    assert(0);
    // return;
  } else if (wc < count) {
    if ((m_ErrorCounter++) < m_maxErrorPrint) {
      ATH_MSG_WARNING( "unpack_frag5 => extra " << count - wc
                      << " words in frag" );
      ATH_MSG_WARNING( " count = " << count
                      << " wc = " << wc
                      << " bc = " << bc
                      << " words in frag" );
    }
  }
  return;
}

unpack_frag5HLT()

void TileROD_Decoder::unpack_frag5HLT ( uint32_t version, uint32_t sizeOverhead, unsigned int unit, const uint32_t * p, FRwChVec & pChannel, int fragID, int demoType ) const

private

unpack_frag5HLT decodes tile subfragment type 0x5 for the high level trigger (HLT).

This subfragment contains the reconstructed amplitude and phase from the tilecal digitized pulse

The amplitude is calibrated to the online units that can be:

• TileRawChannelUnit::OnlineADCcounts
• TileRawChannelUnit::OnlinePicoCoulombs
• TileRawChannelUnit::OnlineCesiumPicoCoulombs
• TileRawChannelUnit::OnlineMegaElectronVolts

The phase is encoded in ns.

The subfragment type 0x5 contains the reconstructed parameters and residuals from the 48 read-out channels of a tilecal module.

Definition at line 3974 of file TileROD_Decoder.cxx.

{
  // first word is frag size
  int count = *(p);
  // second word is frag ID and frag type
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF;
  bool remap = (drawer_type > 0) || std::binary_search(m_demoFragIDs.begin(), m_demoFragIDs.end(), frag);
  const std::vector<int> & chmap = (frag<0x300) ? m_demoChanLB : m_demoChanEB;
  int size_L2 = (*(p + 1) >> (32 - 2 - 3)) & 0x7;
  
  p += 2; // 2 words so far
  int wc = sizeOverhead; // can be 2 or 3 words
  const uint16_t* ptr_bad = reinterpret_cast<const uint16_t*> (p + 48 + size_L2); // Reco + Size_L2
  uint16_t bad_bits[3] = { ptr_bad[1], ptr_bad[0], ptr_bad[3] };
  
  uint32_t code;
  int fmt, bad, gain(0), ene_bin(0), time_bin(0), quality;
  unsigned int w;
  float ene(0.0), time(0.0);
  
  unsigned int ch = 0U;
  for (unsigned int i = 0U; i < 3U; ++i) {
    uint16_t bad16 = ~bad_bits[i]; // note inversion here
    for (unsigned int j = 0U; j < 16U; ++j) {
      w = (*p);
      
      code = w >> 24;
      fmt = m_rc2bytes5.m_FormatLookup[code];
      Frag5_unpack_reco_bin(w, code, gain, ene_bin, time_bin);
      Frag5_unpack_bin2reco(unit, gain, ene_bin, ene, time_bin, time);
      //m_rc2bytes5.unpack_reco(w, fmt, gain, ene, time);
      
      bad = (bad16 & 0x1);
      bad16 >>= 1;
      quality = m_rc2bytes5.get_quality(bad, fmt);
      unsigned int ch1 = (remap) ? chmap[ch] : ch;
      pChannel.emplace_back(ch1, gain, ene, time, quality);
      
      ++ch;
      ++wc;
      ++p;
    }
  }
  if (remap) std::sort(pChannel.end()-m_maxChannels,pChannel.end(),chan_order1);
  
  if (wc > count) {
    // check word count
    if ((m_ErrorCounter++) < m_maxErrorPrint) {
      ATH_MSG_WARNING( "unpack_frag5HLT => Incorrect word count: "
                       << wc << " != " << count );
    }
    assert(0);
    // return;
  }
  
  return;
}

unpack_frag5L2()

bool TileROD_Decoder::unpack_frag5L2 ( uint32_t version, const uint32_t * p, TileL2Container & v, int fragID, int demoType ) const

private

unpack_frag5L2 decodes tile subfragment type 0x5 and extract transverse energy from this fragment

Definition at line 4082 of file TileROD_Decoder.cxx.

                                                               {
  // second word is frag ID and frag type
  uint32_t idAndType = *(p + 1);
  int frag = (frag_id>0) ? frag_id : idAndType & 0xFFFF;
  int unit = (idAndType >> (32 - 2)) & 0x3;
  int size_L2 = (idAndType >> (32 - 2 - 3)) & 0x7;
  
#ifdef DO_NOT_USE_MUON_TAG
  
  p += 50; // offset 50: 2 words in header and 48 channels after
  
#else
  
  // this part is very similar to unpack_frag5HLT - it reads amplitude from DSP
  // and then uses vector of 48 amplitudes to calculate Muon tags
  // all this is written only for tests and will not be used actually,
  // since nobody is using Tile Muon tags in L2 trigger
  
  p+=2;// 2 words so far
  
  int drawer = (frag & 0x3F);
  int ros = (frag >> 8);
  int drawerIdx = TileCalibUtils::getDrawerIdx(ros,drawer);
  TileRawChannelUnit::UNIT onlUnit = (TileRawChannelUnit::UNIT) ( unit + TileRawChannelUnit::OnlineOffset );
  bool recalibrate = (onlUnit != TileRawChannelUnit::OnlineMegaElectronVolts);
  float E_MeV[48];
  int Gain[48];
  bool bad[48];
  
  uint16_t* ptr_bad = (uint16_t*)(p + 48 + size_L2);// Reco + Size_L2
  uint16_t bad_bits[3] = {ptr_bad[1], ptr_bad[0], ptr_bad[3]};
  
  uint32_t code;
  int fmt, gain(0), ene_bin(0), time_bin(0);
  unsigned int w;
  float ene(0.0), time(0.0);
  
  int ch = 0;
  for (int i = 0; i < 3; ++i) {
    uint16_t bad16 = ~bad_bits[i]; // note inversion here
    for (int j = 0; j < 16; ++j) {
      w = (*p);
      
      code = w >> 24;
      fmt = m_rc2bytes5.m_FormatLookup[code];
      Frag5_unpack_reco_bin(w, code, gain, ene_bin, time_bin);
      Frag5_unpack_bin2reco(unit, gain, ene_bin, ene, time_bin, time);
      //m_rc2bytes5.unpack_reco(w, fmt, gain, ene, time);
      
      bad[ch] = (bad16 & 0x1); bad16 >>= 1;
      Gain[ch] = gain;
      if (recalibrate)
        E_MeV[ch] = m_tileToolEmscale->channelCalib(drawerIdx, ch, gain, ene, onlUnit, TileRawChannelUnit::MegaElectronVolts);
      else
        E_MeV[ch] = ene;
      
      ++ch;
      ++p;
    }
  }
  
  std::vector<double> EtaMuons;
  std::vector<double> EMuons0;
  std::vector<double> EMuons1;
  std::vector<double> EMuons2;
  std::vector<unsigned int> qf;
  std::vector<unsigned int> word;
  
  switch (ros) {
    case TileHWID::BARREL_POS: m_L2Builder->MTagLB(ros,drawer,E_MeV,Gain,bad,EtaMuons,EMuons0,EMuons1,EMuons2,qf,word); break;
    case TileHWID::BARREL_NEG: m_L2Builder->MTagLB(ros,drawer,E_MeV,Gain,bad,EtaMuons,EMuons0,EMuons1,EMuons2,qf,word); break;
    case TileHWID::EXTBAR_POS: m_L2Builder->MTagEB(ros,drawer,E_MeV,Gain,bad,EtaMuons,EMuons0,EMuons1,EMuons2,qf,word); break;
    case TileHWID::EXTBAR_NEG: m_L2Builder->MTagEB(ros,drawer,E_MeV,Gain,bad,EtaMuons,EMuons0,EMuons1,EMuons2,qf,word); break;
    default: ATH_MSG_WARNING( "unpack_frag5L2: incorrect ros value: " << ros );
  }
  
  (*pL2[m_hashFunc(frag)]).setMu(std::move(EtaMuons), std::move(EMuons0),
           std::move(EMuons1), std::move(EMuons2), std::move(qf), std::move(word));
  
#endif
  
  if (size_L2 > 0) {
    
    std::vector<float> sumE;
    sumE.reserve(size_L2);
    while (size_L2--) {
      sumE.push_back(Frag5_unpack_bin2sum(unit, (int)(*(p++))));
    }
    (*pL2[m_hashFunc(frag)]).setEt(std::move(sumE));
    
    return true;
    
  } else {
    
    return false; // indicate that there is no sumEt info in the fragment
  }
}

unpack_frag6()

void TileROD_Decoder::unpack_frag6 ( uint32_t version, uint32_t sizeOverhead, DigitsMetaData_t & digitsMetaData, const uint32_t * p, pDigiVec & pDigits, int fragID, int demoType ) const

private

unpack_frag6 decodes tile subfragment type 0x6.

This subfragment contains the tile raw digits with 16 samples and 2 gains from the 48 read-out channels of a tilecal module.

Definition at line 1113 of file TileROD_Decoder.cxx.

{
  int size = *(p)- sizeOverhead;
  const uint32_t* data = p+2; // pointer to current data word  Position of first data word,
   // second word is frag ID (0x100-0x4ff) and frag type
  int frag = (frag_id>0) ? frag_id : *(p + 1) & 0xFFFF; /* (*(data +3)>>16) & 0xFF;*/
  bool remap = (drawer_type > 0) || std::binary_search(m_demoFragIDs.begin(), m_demoFragIDs.end(), frag);
  const std::vector<int> & chmap = (frag<0x300) ? m_demoChanLB : m_demoChanEB;
 
  HWIdentifier adcID;
  HWIdentifier drawerID = m_tileHWID->drawer_id(frag);
 
  uint32_t all00 = TileFragStatus::ALL_00;
  uint32_t allFF = TileFragStatus::ALL_FF;
 
  for (int i = 0; i < size; ++i) {
    uint32_t w = data[i];
    if (allFF && w!=0xFFFFFFFF) {
      allFF = TileFragStatus::ALL_OK;
      if (all00 == TileFragStatus::ALL_OK) break;
    }
    if (all00 && w != 0) {
      all00 = TileFragStatus::ALL_OK;
      if (allFF == TileFragStatus::ALL_OK) break;
    }
  }
 
  uint32_t status = (all00 | allFF);
  digitsMetaData[6].push_back( status );
 
  // check that fragment is not dummy
  if (m_suppressDummyFragments && status != TileFragStatus::ALL_OK){
    ATH_MSG_WARNING("FRAG6: Suppress dummy fragment!!!");
    return; // nothing reasonable found
  }
 
  using Tile = TileCalibUtils;
  unsigned int moduleID[Tile::MAX_MINIDRAWER] = {0};
  unsigned int runType[Tile::MAX_MINIDRAWER] = {0};
 
  unsigned int runNumber[Tile::MAX_MINIDRAWER] = {0};
 
  unsigned int pedestalHi[Tile::MAX_MINIDRAWER] = {0};
  unsigned int pedestalLo[Tile::MAX_MINIDRAWER] = {0};
 
  unsigned int chargeInjected[Tile::MAX_MINIDRAWER] = {0};
  unsigned int timeInjected[Tile::MAX_MINIDRAWER] = {0};
  unsigned int capacitor[Tile::MAX_MINIDRAWER] = {0};
 
  uint32_t bcid[Tile::MAX_MINIDRAWER] = {0};
  uint32_t l1id[Tile::MAX_MINIDRAWER] = {0};
 
  uint32_t ecr[Tile::MAX_MINIDRAWER] = {0};
  uint32_t bcr[Tile::MAX_MINIDRAWER] = {0};
 
  uint32_t fragmentID[Tile::MAX_MINIDRAWER] = {0};
  uint32_t packetVersion[Tile::MAX_MINIDRAWER] = {0};
 
  int version = 0;
 
  int mdFragmentSize = (*data) & 0xFFFF;
  int sampleNumber = mdFragmentSize / Tile::MAX_MINIDRAWER_CHAN;
 
  std::vector<std::vector<std::vector<float>>> samples(Tile::MAX_GAIN,
                                                       std::vector<std::vector<float>>(Tile::MAX_CHAN,
                                                                                       std::vector<float>(sampleNumber)));
 
  const uint32_t* const end_data = data + size; 
  while (data < end_data) {
    if (*data == 0x12345678 ) {
      mdFragmentSize = (*(data - 2)) & 0xFFFF;
 
      if ((++data < end_data)) {
 
        version = (((*data >> 16) & 0xFFFF) == 0) ? 1 : 0;
        int mdSizeOverhead = (version == 0) ? 10 : 11;
        int delta = mdFragmentSize - (sampleNumber * Tile::MAX_MINIDRAWER_CHAN + mdSizeOverhead);
        if (delta != 0) {
          ATH_MSG_WARNING( "FRAG6: Unexpected MD fragment size " << mdFragmentSize << " => "
                           << sampleNumber << " samples will be unpacked and last "
                           << delta << " words will be ignored ");
        }
 
        unsigned int miniDrawer = -1;
 
        // check trailer
        const uint32_t* trailer = data + mdFragmentSize - 4;
        if (trailer < end_data && *trailer == 0x87654321) {
 
          unsigned int paramsSize = 3;
          if (version == 0) {
            unsigned int fragSize   = *data & 0xFF;
            paramsSize = (*data >> 8 ) & 0xFF;
 
            miniDrawer = *(data + 4) & 0xFF;
 
            moduleID[miniDrawer]    = (*data >> 16) & 0xFF;
            runType[miniDrawer]     = (*data >> 24) & 0xFF;
            if (fragSize != sampleNumber * Tile::MAX_MINIDRAWER_CHAN) {
              ATH_MSG_WARNING("FRAG6: Minidrawer [" << miniDrawer
                              << "] has unexpected fragment size: " << fragSize
                              << " correct value for " << sampleNumber
                              << " samples is " << sampleNumber * Tile::MAX_MINIDRAWER_CHAN);
            }
 
            if (paramsSize == 3){
              runNumber[miniDrawer]  = *(++data);
 
              pedestalLo[miniDrawer] = *(++data)      & 0xFFF;
              pedestalHi[miniDrawer] = (*data >> 12 ) & 0xFFF;
 
              chargeInjected[miniDrawer] = *(++data)     & 0xFFF;
              timeInjected[miniDrawer]   = (*data >> 12) & 0xFF;
              capacitor[miniDrawer]      = (*data >> 20) & 0x1;
            } else {
 
              ATH_MSG_WARNING("FRAG6: Minidrawer [" << miniDrawer
                              << "] has unexpected number of parameter words: " << paramsSize
                              << " => ignore them !!!");
              data += paramsSize;
            }
 
            bcid[miniDrawer] = (*(++data) >> 16) & 0xFFFF;
            l1id[miniDrawer] = *(++data) & 0xFFFFFF;
            ecr[miniDrawer] = (*data >> 24) & 0xFF;
 
          } else {
 
            miniDrawer = *(data + 1) & 0xFF;
 
            packetVersion[miniDrawer] = (*data) & 0xFF;
            fragmentID[miniDrawer] = (*data >> 8) & 0xFF;
 
            bcid[miniDrawer] = (*(++data) >> 8) & 0xFFF;
            moduleID[miniDrawer] = (*data >> 20) & 0xFFF;
 
            l1id[miniDrawer] = *(++data) & 0xFFFFFF;
            ecr[miniDrawer] = (*data >> 24) & 0xFF;
 
            bcr[miniDrawer] = *(++data);
 
 
            if (packetVersion[miniDrawer] == 1) {
              pedestalLo[miniDrawer] = *(++data)      & 0xFFF;
              pedestalHi[miniDrawer] = (*data >> 12 ) & 0xFFF;
              runType[miniDrawer]    = (*data >> 24) & 0xFF;
 
              runNumber[miniDrawer]  = *(++data);
            } else {
              runNumber[miniDrawer]  = *(++data);
 
              pedestalLo[miniDrawer] = *(++data)      & 0xFFF;
              pedestalHi[miniDrawer] = (*data >> 12 ) & 0xFFF;
              runType[miniDrawer]    = (*data >> 24) & 0xFF;
            }
 
            chargeInjected[miniDrawer] = *(++data)     & 0xFFF;
            timeInjected[miniDrawer]   = (*data >> 12) & 0xFF;
            capacitor[miniDrawer]      = (*data >> 20) & 0x1;
          }
 
          if (msgLvl(MSG::VERBOSE)) {
            msg(MSG::VERBOSE) << "FRAG6: Found MD[" << miniDrawer << "] fragment"
                              << ", Run type: " << runType[miniDrawer]
                              << ", Module ID: " << moduleID[miniDrawer]
                              << ", BCID: " << bcid[miniDrawer]
                              << ", L1ID: " << l1id[miniDrawer]
                              << ", ECR: " << ecr[miniDrawer];
            if (version) {
              msg(MSG::VERBOSE) << ", BCR: " << bcr[miniDrawer]
                                << ", Packet version: " << packetVersion[miniDrawer]
                                << ", Fragment ID: " << fragmentID[miniDrawer];
            }
 
            msg(MSG::VERBOSE) << endmsg;
 
            if (paramsSize == 3) {
              msg(MSG::VERBOSE) << "FRAG6: MD[" << miniDrawer << "] Parameters:"
                                << " Run number: " << runNumber[miniDrawer]
                                << ", Ppedestal Lo: " << pedestalLo[miniDrawer]
                                << ", Ppedestal Hi: " << pedestalHi[miniDrawer]
                                << ", Charge injected: " << chargeInjected[miniDrawer]
                                << ", Time injected: " << timeInjected[miniDrawer]
                                << ", Capacitor: " << capacitor[miniDrawer] << endmsg;
            }
          }
 
          const uint16_t* sample = reinterpret_cast<const uint16_t *> (++data);
 
          for (int gain = 1; gain > -1; --gain) { // HG seems to be first
            int start_channel(miniDrawer * Tile::MAX_MINIDRAWER_CHAN);
            int end_channel(start_channel + Tile::MAX_MINIDRAWER_CHAN);
            for (int channel = start_channel; channel < end_channel; ++channel) {
 
              for (int samplesIdx = 0; samplesIdx<sampleNumber; ++samplesIdx) {
                samples[gain][channel][samplesIdx] = (*sample & 0x0FFF);
                ++sample;
              }
 
            }
          }
 
          data = ++trailer;
 
        } else {
          ATH_MSG_WARNING("FRAG6: Not found correct MD[" << miniDrawer << "] fragment trailer:  => skip it!!!");
        }
      }
    } else {
      ++data;
    }
  }
 
  pDigits.reserve(Tile::MAX_GAIN * Tile::MAX_CHAN);
 
  // always two gains
  for (unsigned int gain = 0; gain < Tile::MAX_GAIN; ++gain) {
    // always 48 channels
    for (unsigned int channel = 0; channel < Tile::MAX_CHAN; ++channel) {
      int ch1 = (remap) ? chmap[channel] : channel;
     
      adcID = m_tileHWID->adc_id(drawerID, ch1, gain);
      std::vector<float> digiVec(&samples[gain][channel][0], &samples[gain][channel][sampleNumber]);
      pDigits.push_back(new TileDigits(adcID, digiVec));
      
      ATH_MSG_VERBOSE("FRAG6: " << (std::string) *(pDigits.back()));
    }
    if (remap) std::sort(pDigits.end() - Tile::MAX_CHAN, pDigits.end(), chan_order);
  }
 
  digitsMetaData[1].insert(digitsMetaData[1].end(), &l1id[0], &l1id[Tile::MAX_MINIDRAWER]);
  digitsMetaData[1].insert(digitsMetaData[1].end(), &bcid[0], &bcid[Tile::MAX_MINIDRAWER]);
  digitsMetaData[1].insert(digitsMetaData[1].end(), &moduleID[0], &moduleID[Tile::MAX_MINIDRAWER]);
  digitsMetaData[1].insert(digitsMetaData[1].end(), &runType[0], &runType[Tile::MAX_MINIDRAWER]);
  digitsMetaData[1].insert(digitsMetaData[1].end(), &runNumber[0], &runNumber[Tile::MAX_MINIDRAWER]);
  digitsMetaData[1].insert(digitsMetaData[1].end(), &pedestalLo[0], &pedestalLo[Tile::MAX_MINIDRAWER]);
  digitsMetaData[1].insert(digitsMetaData[1].end(), &pedestalHi[0], &pedestalHi[Tile::MAX_MINIDRAWER]);
  digitsMetaData[1].insert(digitsMetaData[1].end(), &chargeInjected[0], &chargeInjected[Tile::MAX_MINIDRAWER]);
  digitsMetaData[1].insert(digitsMetaData[1].end(), &timeInjected[0], &timeInjected[Tile::MAX_MINIDRAWER]);
  digitsMetaData[1].insert(digitsMetaData[1].end(), &capacitor[0], &capacitor[Tile::MAX_MINIDRAWER]);
  digitsMetaData[1].insert(digitsMetaData[1].end(), &ecr[0], &ecr[Tile::MAX_MINIDRAWER]);
  if (version) {
    digitsMetaData[1].insert(digitsMetaData[1].end(), &bcr[0], &bcr[Tile::MAX_MINIDRAWER]);
    digitsMetaData[1].insert(digitsMetaData[1].end(), &packetVersion[0], &packetVersion[Tile::MAX_MINIDRAWER]);
    digitsMetaData[1].insert(digitsMetaData[1].end(), &fragmentID[0], &fragmentID[Tile::MAX_MINIDRAWER]);
  }
}

unpack_fragA()

void TileROD_Decoder::unpack_fragA ( uint32_t version, RawChannelMetaData_t & rawchannelMetaData, const uint32_t * p, pRwChVec & pChannel, int fragID, int demoType ) const

private

unpack_fragA decodes tile subfragment type 0XA.

This subfragment contains data quality checks.

Definition at line 1365 of file TileROD_Decoder.cxx.

                                                                 {
  // second word is frag ID and frag type
  int size = *(p); 
  p += 2; // 2 words so far
  
  unsigned int w;
  
  // Global CRC
  w = (*p);
  rawchannelMetaData[0].push_back(w & 0xFFFF);
  if (w >> 31 & 0x1) //most significant bit is 1. It means that it is a fragment containing the DSP BCID
    rawchannelMetaData[0].push_back((w >> 16) & 0x7FFF); //DSP BCID
  else
    rawchannelMetaData[0].push_back(0xDEAD); //0xDEAD if it is not filled
  ++p;
  
  if (drawer_type == 2) {
    ATH_MSG_WARNING("Demo->Legacy remapping for Ext.Barrel not yet implemented for DQ fragment");
  }
 
  for (int i = 0; i < (size - 4); ++i) {
    w = (*p);
    rawchannelMetaData[i + 1].push_back(w & 0xFFFF);
    rawchannelMetaData[i + 1].push_back(w >> 16);
    ++p;
  }
  
  return;
}

unpack_fragAHLT()

void TileROD_Decoder::unpack_fragAHLT ( uint32_t version, const uint32_t * p, uint16_t rob_bcid, uint16_t & mask, int fragID, int demoType ) const

private

unpack_fragAHLT decodes tile subfragment type 0XA.

This subfragment contains data quality checks.

Definition at line 1399 of file TileROD_Decoder.cxx.

                                                                                    {
  // first word is full frag size, including header
  int size = *(p);
  if (size < 9) return;
  
  // second word is frag ID (0x100-0x4ff) and frag type
  uint16_t frag = (*(++p)) & 0xfff;
  
  const uint16_t* w = reinterpret_cast<const uint16_t*> (++p); // Jump to first DQ word
  /* order of 16bit DQ words in DQ fragment
   ---------------------
   | Global CRC
   | DSP BCID
   | BCID checks
   | Mem parity err
   | Single strobe err
   | Double strobe err
   | Head format err
   | Head parity err
   | Sample format err
   | Sample parity err
   | FE chip mask err
   | ROD chip mask err
   ---------------------
   */
  if ((*w++) & 0x1) {
    mask = 0xffff;
    return;
  } // bad CRC
  mask = *w++; // BCID in DSP, can be zero (i.e. not set)
  if (mask != rob_bcid && mask > 0) {
    mask = 0xffff;
    return;
  } // BCIDs do not match - wrong event
  
  mask = *w++; // bcid checks, one bit per DMU
  if (mask & 0x0002) {
    mask = 0xffff;
    return;
  } // second DMU is bad - everything is bad
  
  if (drawer_type == 2) {
    ATH_MSG_WARNING("Demo->Legacy remapping for Ext.Barrel not yet implemented for DQ fragment");
  }
 
  if (mask & 0x00F0) { // at least one error in second motherboard, where we don't expect errors in ext.barrel
    uint16_t BCIDerr = mask;
    int n_badMB = 0;
    if (frag > 0x2FF) { // do not count non-existing DMUs in EB
      if ((frag == 0x30E) || frag == 0x411) {
        BCIDerr &= 0x3cff;
      } else {
        BCIDerr &= 0x3cfe;
      }
    }
    while (BCIDerr) {
      if (BCIDerr & 0xF) ++n_badMB;
      BCIDerr >>= 4;
    }
    if (n_badMB == 4) { // BCID errors in all 4 motherboards - assume that all DMUs are bad
      mask = 0xffff;
      return;
    }
  }
  
  mask |= *w++; // memory
  
  w += 2; // Ignore 2 guys - strobe
  uint16_t fe_mask = *w++; // head format
  fe_mask |= *w++; // head parity
  fe_mask |= *w++; // sample format
  fe_mask |= *w++; // sample parity
  
  if (fe_mask) { // something is wrong in data format - FE mask can not be used
    mask |= fe_mask;
    w++;
  } else { // real FE mask is valid only if there are no format or parity errors
    fe_mask = *w++;
    if ((frag > 0x2FF)) { // I am in extended barrel
      if ((frag == 0x30E) || frag == 0x411) fe_mask <<= 1; // shift by one DMU in EBA15 EBC18
      fe_mask = (fe_mask & 0xFF) | ((fe_mask & 0xF00) << 2); // shift upper half by two DMUs
    }
    mask |= ~fe_mask; // fe chip mask (inverted logic!)
  }
  
  mask |= ~(*w); // rod chip mask (inverted logic!)
  
  return;
}

updateAmpThreshold()

void TileROD_Decoder::updateAmpThreshold ( int run = -1 )

private

Definition at line 60 of file TileROD_Decoder.cxx.

                                                {
  if (m_ampMinThresh_MeV < 0 || m_ampMinThresh_pC < 0){
    if (run < 0) run = m_fullTileRODs;
    if (run >= 4444444) { // FIXME: should put correct run number here, once it is known
      m_ampMinThresh_pC  = m_ampMinThresh * (25.  / 4095.);
      m_ampMinThresh_MeV = m_ampMinThresh * (25.  / 4095. / 1.05 * 1000.);
    } else {
      m_ampMinThresh_pC  = m_ampMinThresh * (12.5 / 1023.);
      m_ampMinThresh_MeV = m_ampMinThresh * (12.5 / 1023. / 1.05 * 1000.);
    }
  }
  ATH_MSG_DEBUG("in TileROD_Decoder::updateAmpThreshold, m_ampMinThresh = " << m_ampMinThresh);
  ATH_MSG_DEBUG("in TileROD_Decoder::updateAmpThreshold, m_ampMinThresh_MeV = " << m_ampMinThresh_MeV);
  ATH_MSG_DEBUG("in TileROD_Decoder::updateAmpThreshold, m_ampMinThresh_pC = " << m_ampMinThresh_pC);
}

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

Friends And Related Symbol Documentation

TileHid2RESrcID

friend class TileHid2RESrcID

friend

Definition at line 229 of file TileROD_Decoder.h.

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

std::vector<uint32_t> m_OFWeights [4 * TileCalibUtils::MAX_DRAWERIDX] TileROD_Decoder::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 569 of file TileROD_Decoder.h.

ATLAS_THREAD_SAFE [2/2]

std::atomic<const uint32_t*> m_OFPtrs [4 * TileCalibUtils::MAX_DRAWERIDX] TileROD_Decoder::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 572 of file TileROD_Decoder.h.

m_allowedTimeMax

Gaudi::Property<float> TileROD_Decoder::m_allowedTimeMax

private

Initial value:

{this, "AllowedTimeMax", 50.0,
        "Set amplitude to zero if time is above allowed time maximum"}

Definition at line 516 of file TileROD_Decoder.h.

                                         {this, "AllowedTimeMax", 50.0,
        "Set amplitude to zero if time is above allowed time maximum"};

m_allowedTimeMin

Gaudi::Property<float> TileROD_Decoder::m_allowedTimeMin

private

Initial value:

{this, "AllowedTimeMin", -50.0,
        "Set amplitude to zero if time is below allowed time minimum"}

Definition at line 514 of file TileROD_Decoder.h.

                                         {this, "AllowedTimeMin", -50.0,
        "Set amplitude to zero if time is below allowed time minimum"};

m_ampMinThresh

Gaudi::Property<float> TileROD_Decoder::m_ampMinThresh

private

Initial value:

{this, "AmpMinForAmpCorrection", 15.0,
        "Correct amplitude if it's above amplitude threshold (in ADC counts)"}

Definition at line 520 of file TileROD_Decoder.h.

                                       {this, "AmpMinForAmpCorrection", 15.0,
        "Correct amplitude if it's above amplitude threshold (in ADC counts)"};

m_ampMinThresh_MeV

float TileROD_Decoder::m_ampMinThresh_MeV

private

correct amplitude if it's above amplitude threshold (in MeV)

Definition at line 564 of file TileROD_Decoder.h.

m_ampMinThresh_pC

float TileROD_Decoder::m_ampMinThresh_pC

private

correct amplitude if it's above amplitude threshold (in pC)

Definition at line 563 of file TileROD_Decoder.h.

m_cablingSvc

ServiceHandle<TileCablingSvc> TileROD_Decoder::m_cablingSvc

private

Initial value:

{ this,
        "TileCablingSvc", "TileCablingSvc", "The Tile cabling service"}

Definition at line 559 of file TileROD_Decoder.h.

                                              { this,
        "TileCablingSvc", "TileCablingSvc", "The Tile cabling service"};

m_calibrateEnergy

Gaudi::Property<bool> TileROD_Decoder::m_calibrateEnergy {this, "calibrateEnergy", true, "Convert ADC counts to pCb for RawChannels"}

private

Definition at line 534 of file TileROD_Decoder.h.

{this, "calibrateEnergy", true, "Convert ADC counts to pCb for RawChannels"};

m_checkMaskedDrawers

bool TileROD_Decoder::m_checkMaskedDrawers

private

Definition at line 603 of file TileROD_Decoder.h.

m_d2Bytes

TileDigits2Bytes TileROD_Decoder::m_d2Bytes

private

Definition at line 502 of file TileROD_Decoder.h.

m_demoChanEB

std::vector<int> TileROD_Decoder::m_demoChanEB

private

Definition at line 607 of file TileROD_Decoder.h.

m_demoChanLB

std::vector<int> TileROD_Decoder::m_demoChanLB

private

Definition at line 606 of file TileROD_Decoder.h.

m_demoFragIDs

Gaudi::Property<std::vector<int> > TileROD_Decoder::m_demoFragIDs

private

Initial value:

{this,
         "DemoFragIDs", {}, "List of Tile frag IDs with new electronics (demonstrator)"}

Definition at line 530 of file TileROD_Decoder.h.

                                              {this,
         "DemoFragIDs", {}, "List of Tile frag IDs with new electronics (demonstrator)"};

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_ErrorCounter

std::atomic<int> TileROD_Decoder::m_ErrorCounter

mutableprivate

Definition at line 593 of file TileROD_Decoder.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_fullTileRODs

Gaudi::Property<unsigned int> TileROD_Decoder::m_fullTileRODs

private

Initial value:

{this, "fullTileMode", 320000,
        "Run from which to take the cabling (for the moment, either 320000 - full 2017 mode (default) - or 0 - 2016 mode)"}

Definition at line 527 of file TileROD_Decoder.h.

                                              {this, "fullTileMode", 320000,
        "Run from which to take the cabling (for the moment, either 320000 - full 2017 mode (default) - or 0 - 2016 mode)"};

m_hashFunc

TileFragHash TileROD_Decoder::m_hashFunc

private

Definition at line 584 of file TileROD_Decoder.h.

m_hid2re

TileHid2RESrcID* TileROD_Decoder::m_hid2re

private

Definition at line 595 of file TileROD_Decoder.h.

m_hid2reHLT

TileHid2RESrcID* TileROD_Decoder::m_hid2reHLT

private

Definition at line 596 of file TileROD_Decoder.h.

m_hid2RESrcIDKey

SG::ReadCondHandleKey<TileHid2RESrcID> TileROD_Decoder::m_hid2RESrcIDKey

private

Initial value:

{this,
        "TileHid2RESrcID", "TileHid2RESrcID", "TileHid2RESrcID key"}

Definition at line 542 of file TileROD_Decoder.h.

                                                         {this,
        "TileHid2RESrcID", "TileHid2RESrcID", "TileHid2RESrcID key"};

m_HidMutex

std::mutex TileROD_Decoder::m_HidMutex

mutableprivate

Definition at line 578 of file TileROD_Decoder.h.

m_ignoreFrag4HLT

Gaudi::Property<bool> TileROD_Decoder::m_ignoreFrag4HLT {this, "ignoreFrag4HLT", false, "Ignore frag4 HLT"}

private

Definition at line 511 of file TileROD_Decoder.h.

{this, "ignoreFrag4HLT", false, "Ignore frag4 HLT"};

m_L2Builder

ToolHandle<TileL2Builder> TileROD_Decoder::m_L2Builder

private

Initial value:

{this,
        "TileL2Builder", "", "Tile L2 builder tool"}

Definition at line 553 of file TileROD_Decoder.h.

                                         {this,
        "TileL2Builder", "", "Tile L2 builder tool"};

m_list_of_masked_drawers

std::vector<int> TileROD_Decoder::m_list_of_masked_drawers

private

Definition at line 598 of file TileROD_Decoder.h.

m_mapMBTS

std::map<unsigned int, unsigned int> TileROD_Decoder::m_mapMBTS

private

Definition at line 588 of file TileROD_Decoder.h.

m_maskBadDigits

Gaudi::Property<bool> TileROD_Decoder::m_maskBadDigits

private

Initial value:

{this, "maskBadDigits", false,
        "Put -1 in digits vector for channels with bad BCID or CRC in unpack_frag0"}

Definition at line 536 of file TileROD_Decoder.h.

                                       {this, "maskBadDigits", false,
        "Put -1 in digits vector for channels with bad BCID or CRC in unpack_frag0"};

m_maxChannels

unsigned int TileROD_Decoder::m_maxChannels

private

Definition at line 602 of file TileROD_Decoder.h.

m_maxErrorPrint

Gaudi::Property<int> TileROD_Decoder::m_maxErrorPrint {this, "MaxErrorPrint", 1000, "Maximum error messages to print"}

private

Definition at line 540 of file TileROD_Decoder.h.

{this, "MaxErrorPrint", 1000, "Maximum error messages to print"};

m_maxWarningPrint

Gaudi::Property<int> TileROD_Decoder::m_maxWarningPrint {this, "MaxWarningPrint", 1000, "Maximum warning messages to print"}

private

Definition at line 539 of file TileROD_Decoder.h.

{this, "MaxWarningPrint", 1000, "Maximum warning messages to print"};

m_MBTS_channel

int TileROD_Decoder::m_MBTS_channel = 0

private

Definition at line 590 of file TileROD_Decoder.h.

m_of2Default

bool TileROD_Decoder::m_of2Default

private

Definition at line 585 of file TileROD_Decoder.h.

m_OFWeightMutex

std::mutex TileROD_Decoder::m_OFWeightMutex

mutableprivate

Definition at line 575 of file TileROD_Decoder.h.

m_rc2bytes

TileRawChannel2Bytes TileROD_Decoder::m_rc2bytes

private

Definition at line 501 of file TileROD_Decoder.h.

m_rc2bytes2

TileRawChannel2Bytes2 TileROD_Decoder::m_rc2bytes2

private

Definition at line 500 of file TileROD_Decoder.h.

m_rc2bytes4

TileRawChannel2Bytes4 TileROD_Decoder::m_rc2bytes4

private

Definition at line 499 of file TileROD_Decoder.h.

m_rc2bytes5

TileRawChannel2Bytes5 TileROD_Decoder::m_rc2bytes5

private

Definition at line 498 of file TileROD_Decoder.h.

m_runPeriod

int TileROD_Decoder::m_runPeriod

private

Definition at line 604 of file TileROD_Decoder.h.

m_Rw2Cell

std::vector<int> TileROD_Decoder::m_Rw2Cell[4]

private

Definition at line 581 of file TileROD_Decoder.h.

m_Rw2Pmt

std::vector<int> TileROD_Decoder::m_Rw2Pmt[4]

private

Definition at line 582 of file TileROD_Decoder.h.

m_suppressDummyFragments

Gaudi::Property<bool> TileROD_Decoder::m_suppressDummyFragments {this, "suppressDummyFragments", false, "Suppress dummy fragments"}

private

Definition at line 535 of file TileROD_Decoder.h.

{this, "suppressDummyFragments", false, "Suppress dummy fragments"};

m_tileBadChanTool

ToolHandle<ITileBadChanTool> TileROD_Decoder::m_tileBadChanTool

private

Initial value:

{this,
        "TileBadChanTool", "TileBadChanTool", "Tile bad channel tool"}

Definition at line 551 of file TileROD_Decoder.h.

                                                  {this,
        "TileBadChanTool", "TileBadChanTool", "Tile bad channel tool"};

m_tileCondToolOfcCool

ToolHandle<TileCondToolOfcCool> TileROD_Decoder::m_tileCondToolOfcCool

private

Initial value:

{this,
        "TileCondToolOfcCool", "TileCondToolOfcCool", "Tile OFC tool"}

Definition at line 547 of file TileROD_Decoder.h.

                                                         {this,
        "TileCondToolOfcCool", "TileCondToolOfcCool", "Tile OFC tool"};

m_tileHWID

const TileHWID* TileROD_Decoder::m_tileHWID = nullptr

private

Definition at line 504 of file TileROD_Decoder.h.

m_tileToolEmscale

ToolHandle<TileCondToolEmscale> TileROD_Decoder::m_tileToolEmscale

private

Initial value:

{this,
        "TileCondToolEmscale", "TileCondToolEmscale", "Tile EM scale calibration tool"}

Definition at line 549 of file TileROD_Decoder.h.

                                                     {this,
        "TileCondToolEmscale", "TileCondToolEmscale", "Tile EM scale calibration tool"};

m_tileToolTiming

ToolHandle<TileCondToolTiming> TileROD_Decoder::m_tileToolTiming

private

Initial value:

{this,
        "TileCondToolTiming", "TileCondToolTiming", "Tile timing tool"}

Definition at line 545 of file TileROD_Decoder.h.

                                                   {this,
        "TileCondToolTiming", "TileCondToolTiming", "Tile timing tool"};

m_timeMaxThresh

Gaudi::Property<float> TileROD_Decoder::m_timeMaxThresh

private

Initial value:

{this, "TimeMaxForAmpCorrection", 12.5,
        "Correct amplitude is time is below time maximum threshold"}

Definition at line 524 of file TileROD_Decoder.h.

                                        {this, "TimeMaxForAmpCorrection", 12.5,
        "Correct amplitude is time is below time maximum threshold"};

m_timeMinThresh

Gaudi::Property<float> TileROD_Decoder::m_timeMinThresh

private

Initial value:

{this, "TimeMinForAmpCorrection", -12.5,
        "Correct amplitude is time is above time minimum threshold"}

Definition at line 522 of file TileROD_Decoder.h.

                                        {this, "TimeMinForAmpCorrection", -12.5,
        "Correct amplitude is time is above time minimum threshold"};

m_useFrag0

Gaudi::Property<bool> TileROD_Decoder::m_useFrag0 {this, "useFrag0", true, "Use frag0"}

private

Definition at line 506 of file TileROD_Decoder.h.

{this, "useFrag0", true, "Use frag0"};

m_useFrag1

Gaudi::Property<bool> TileROD_Decoder::m_useFrag1 {this, "useFrag1", true, "Use frag1"}

private

Definition at line 507 of file TileROD_Decoder.h.

{this, "useFrag1", true, "Use frag1"};

m_useFrag4

Gaudi::Property<bool> TileROD_Decoder::m_useFrag4 {this, "useFrag4", true, "User frag4"}

private

Definition at line 508 of file TileROD_Decoder.h.

{this, "useFrag4", true, "User frag4"};

m_useFrag5Raw

Gaudi::Property<bool> TileROD_Decoder::m_useFrag5Raw {this, "useFrag5Raw", false, "Use frag5 raw"}

private

Definition at line 509 of file TileROD_Decoder.h.

{this, "useFrag5Raw", false, "Use frag5 raw"};

m_useFrag5Reco

Gaudi::Property<bool> TileROD_Decoder::m_useFrag5Reco {this, "useFrag5Reco", false, "Use frag5 reco"}

private

Definition at line 510 of file TileROD_Decoder.h.

{this, "useFrag5Reco", false, "Use frag5 reco"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_verbose

Gaudi::Property<bool> TileROD_Decoder::m_verbose {this, "VerboseOutput", false, "Print extra information"}

private

Definition at line 533 of file TileROD_Decoder.h.

{this, "VerboseOutput", false, "Print extra information"};

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_WarningCounter

std::atomic<int> TileROD_Decoder::m_WarningCounter

mutableprivate

Definition at line 592 of file TileROD_Decoder.h.

---

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

• TileROD_Decoder.h
• TileROD_Decoder.cxx