Emulates the GCT summing and packing of Hf Et sums and tower-over-threshold counts. More...

#include <L1GctGlobalHfSumAlgos.h>

Inheritance diagram for L1GctGlobalHfSumAlgos:

Public Types
typedef L1GctJetFinderBase::hfTowerSumsType	hfTowerSumsType

Public Member Functions
void	fetchInput () override
	get input data from sources; this is the standard way to provide input More...

const L1GctHfBitCountsLut *	getBCLut (const L1GctHfEtSumsLut::hfLutType type) const
	Get lut pointers. More...

const L1GctHfEtSumsLut *	getESLut (const L1GctHfEtSumsLut::hfLutType type) const

L1GctWheelJetFpga *	getMinusWheelJetFpga () const
	provide access to input pointer, Wheel Jet Fpga 0 More...

L1GctWheelJetFpga *	getPlusWheelJetFpga () const
	provide access to input pointer, Wheel Jet Fpga 1 More...

std::vector< double >	getThresholds (const L1GctHfEtSumsLut::hfLutType type) const
	Get thresholds. More...

std::vector< uint16_t >	hfSumsOutput (const L1GctHfEtSumsLut::hfLutType type) const
	Access to output quantities. More...

std::vector< unsigned >	hfSumsWord () const

	L1GctGlobalHfSumAlgos (const std::vector< L1GctWheelJetFpga * > &WheelJetFpga)
	Constructor needs the Wheel card Fpgas set up first. More...

void	process () override
	process the data, fill output buffers More...

void	setupLuts (const L1CaloEtScale *scale)
	Setup luts. More...

bool	setupOk () const
	check setup More...

	~L1GctGlobalHfSumAlgos () override
	Destructor. More...

Public Member Functions inherited from L1GctProcessor
	L1GctProcessor ()

void	reset ()
	complete reset of processor More...

void	setBxRange (const int firstBx, const int numberOfBx)
	define the bunch crossing range to process More...

void	setNextBx (const int bxnum)
	clear input data buffers and process a new bunch crossing More...

void	setTerse ()

bool	setupOk () const
	Method to check the setup for this processor. Returns true by default. More...

void	setVerbose ()
	control output messages More...

virtual	~L1GctProcessor ()

Protected Member Functions
void	resetPipelines () override

void	resetProcessor () override
	Separate reset methods for the processor itself and any data stored in pipelines. More...

void	setupObjects () override
	Initialise inputs with null objects for the correct bunch crossing if required. More...

Protected Member Functions inherited from L1GctProcessor
int	bxAbs () const

int	bxMax () const

int	bxMin () const
	Support for multiple beam crossing operation. More...

int	bxRel () const

int	numOfBx () const

Private Member Functions
void	storeBitCount (L1GctHfEtSumsLut::hfLutType type, uint16_t value)

void	storeEtSum (L1GctHfEtSumsLut::hfLutType type, uint16_t value)

Private Attributes
std::map < L1GctHfEtSumsLut::hfLutType, const L1GctHfBitCountsLut * >	m_bitCountLuts

std::map < L1GctHfEtSumsLut::hfLutType, const L1GctHfEtSumsLut * >	m_etSumLuts

hfTowerSumsType	m_hfInputSumsMinusWheel

hfTowerSumsType	m_hfInputSumsPlusWheel

std::map < L1GctHfEtSumsLut::hfLutType, Pipeline< uint16_t > >	m_hfOutputSumsPipe

L1GctWheelJetFpga *	m_minusWheelJetFpga

L1GctWheelJetFpga *	m_plusWheelJetFpga

bool	m_setupOk

Friends
std::ostream &	operator<< (std::ostream &os, const L1GctGlobalHfSumAlgos &fpga)
	Overload << operator. More...

Additional Inherited Members
Protected Attributes inherited from L1GctProcessor
bool	m_verbose
	Flag to control output messages. More...

Detailed Description

Emulates the GCT summing and packing of Hf Et sums and tower-over-threshold counts.

Gets the sums from the wheel cards and packs them into the output after compression using look-up tables

Author: Greg Heath

Date: 09/09/2008

Definition at line 27 of file L1GctGlobalHfSumAlgos.h.

Member Typedef Documentation

typedef L1GctJetFinderBase::hfTowerSumsType L1GctGlobalHfSumAlgos::hfTowerSumsType

Definition at line 29 of file L1GctGlobalHfSumAlgos.h.

Constructor & Destructor Documentation

L1GctGlobalHfSumAlgos::L1GctGlobalHfSumAlgos ( const std::vector< L1GctWheelJetFpga * > & WheelJetFpga )

Constructor needs the Wheel card Fpgas set up first.

Definition at line 11 of file L1GctGlobalHfSumAlgos.cc.

References m_minusWheelJetFpga, m_plusWheelJetFpga, m_setupOk, and L1GctProcessor::m_verbose.

     : L1GctProcessor(),
       m_plusWheelJetFpga(wheelJetFpga.at(1)),
       m_minusWheelJetFpga(wheelJetFpga.at(0)),
       m_bitCountLuts(),
       m_etSumLuts(),
       m_hfInputSumsPlusWheel(),
       m_hfInputSumsMinusWheel(),
       m_hfOutputSumsPipe(),
       m_setupOk(true) {
   if (wheelJetFpga.size() != 2) {
     m_setupOk = false;
     if (m_verbose) {
       edm::LogWarning("L1GctSetupError")
           << "L1GctGlobalHfSumAlgos::L1GctGlobalHfSumAlgos() : Global HfSum Algos has been incorrectly constructed!\n"
           << "This class needs two wheel jet fpga pointers. "
           << "Number of wheel jet fpga pointers present is " << wheelJetFpga.size() << ".\n";
     }
   }
 
   if (m_plusWheelJetFpga == nullptr) {
     m_setupOk = false;
     if (m_verbose) {
       edm::LogWarning("L1GctSetupError")
           << "L1GctGlobalHfSumAlgos::L1GctGlobalHfSumAlgos() has been incorrectly constructed!\n"
           << "Plus Wheel Jet Fpga pointer has not been set!\n";
     }
   }
   if (m_minusWheelJetFpga == nullptr) {
     m_setupOk = false;
     if (m_verbose) {
       edm::LogWarning("L1GctSetupError")
           << "L1GctGlobalHfSumAlgos::L1GctGlobalHfSumAlgos() has been incorrectly constructed!\n"
           << "Minus Wheel Jet Fpga pointer has not been set!\n";
     }
   }
 
   if (!m_setupOk && m_verbose) {
     edm::LogError("L1GctSetupError") << "L1GctGlobalEnergyAlgos has been incorrectly constructed";
   }
 }

L1GctGlobalHfSumAlgos::~L1GctGlobalHfSumAlgos ( )

override

Destructor.

Definition at line 53 of file L1GctGlobalHfSumAlgos.cc.

References m_bitCountLuts, and m_etSumLuts.

                                               {
   std::map<L1GctHfEtSumsLut::hfLutType, const L1GctHfBitCountsLut*>::const_iterator bclut = m_bitCountLuts.begin();
   while (bclut != m_bitCountLuts.end()) {
     delete bclut->second;
     bclut++;
   }
   std::map<L1GctHfEtSumsLut::hfLutType, const L1GctHfEtSumsLut*>::const_iterator eslut = m_etSumLuts.begin();
   while (eslut != m_etSumLuts.end()) {
     delete eslut->second;
     eslut++;
   }
 }

Member Function Documentation

void L1GctGlobalHfSumAlgos::fetchInput ( )

overridevirtual

get input data from sources; this is the standard way to provide input

Implements L1GctProcessor.

Definition at line 104 of file L1GctGlobalHfSumAlgos.cc.

References L1GctWheelJetFpga::getOutputHfSums(), m_hfInputSumsMinusWheel, m_hfInputSumsPlusWheel, m_minusWheelJetFpga, m_plusWheelJetFpga, and m_setupOk.

Referenced by L1GctGlobalEnergyAlgos::fetchInput().

                                        {
   if (m_setupOk) {
     m_hfInputSumsPlusWheel = m_plusWheelJetFpga->getOutputHfSums();
     m_hfInputSumsMinusWheel = m_minusWheelJetFpga->getOutputHfSums();
   }
 }

const L1GctHfBitCountsLut * L1GctGlobalHfSumAlgos::getBCLut ( const L1GctHfEtSumsLut::hfLutType type ) const

Get lut pointers.

Definition at line 244 of file L1GctGlobalHfSumAlgos.cc.

References m_bitCountLuts.

Referenced by L1GctPrintLuts::analyze().

                                                                                                      {
   std::map<L1GctHfEtSumsLut::hfLutType, const L1GctHfBitCountsLut*>::const_iterator bclut = m_bitCountLuts.find(type);
   if (bclut != m_bitCountLuts.end()) {
     return (bclut->second);
   } else {
     return nullptr;
   }
 }

const L1GctHfEtSumsLut * L1GctGlobalHfSumAlgos::getESLut ( const L1GctHfEtSumsLut::hfLutType type ) const

Definition at line 253 of file L1GctGlobalHfSumAlgos.cc.

References m_etSumLuts.

Referenced by L1GctPrintLuts::analyze(), and getThresholds().

                                                                                                   {
   std::map<L1GctHfEtSumsLut::hfLutType, const L1GctHfEtSumsLut*>::const_iterator eslut = m_etSumLuts.find(type);
   if (eslut != m_etSumLuts.end()) {
     return (eslut->second);
   } else {
     return nullptr;
   }
 }

L1GctWheelJetFpga* L1GctGlobalHfSumAlgos::getMinusWheelJetFpga ( ) const

inline

provide access to input pointer, Wheel Jet Fpga 0

Definition at line 62 of file L1GctGlobalHfSumAlgos.h.

References m_minusWheelJetFpga.

62 { return m_minusWheelJetFpga; }

L1GctGlobalHfSumAlgos::m_minusWheelJetFpga

L1GctWheelJetFpga * m_minusWheelJetFpga

Definition: L1GctGlobalHfSumAlgos.h:78

L1GctWheelJetFpga* L1GctGlobalHfSumAlgos::getPlusWheelJetFpga ( ) const

inline

provide access to input pointer, Wheel Jet Fpga 1

Definition at line 60 of file L1GctGlobalHfSumAlgos.h.

References m_plusWheelJetFpga.

60 { return m_plusWheelJetFpga; }

L1GctGlobalHfSumAlgos::m_plusWheelJetFpga

L1GctWheelJetFpga * m_plusWheelJetFpga

Definition: L1GctGlobalHfSumAlgos.h:77

std::vector< double > L1GctGlobalHfSumAlgos::getThresholds ( const L1GctHfEtSumsLut::hfLutType type ) const

Get thresholds.

Definition at line 263 of file L1GctGlobalHfSumAlgos.cc.

References getESLut(), L1CaloEtScale::getThresholds(), L1GctHfEtSumsLut::lutFunction(), and mps_fire::result.

                                                                                                  {
   std::vector<double> result;
   const L1GctHfEtSumsLut* ESLut = getESLut(type);
   if (ESLut != nullptr) {
     result = ESLut->lutFunction()->getThresholds();
   }
   return result;
 }

std::vector< uint16_t > L1GctGlobalHfSumAlgos::hfSumsOutput ( const L1GctHfEtSumsLut::hfLutType type ) const

Access to output quantities.

Definition at line 160 of file L1GctGlobalHfSumAlgos.cc.

References relmon_rootfiles_spy::contents, m_hfOutputSumsPipe, L1GctProcessor::numOfBx(), and mps_fire::result.

Referenced by hfSumsWord().

                                                                                                   {
   std::vector<uint16_t> result(numOfBx());
   std::map<L1GctHfEtSumsLut::hfLutType, Pipeline<uint16_t> >::const_iterator lut = m_hfOutputSumsPipe.find(type);
   if (lut != m_hfOutputSumsPipe.end()) {
     result = (lut->second).contents;
   }
 
   return result;
 }

std::vector< unsigned > L1GctGlobalHfSumAlgos::hfSumsWord ( ) const

Definition at line 170 of file L1GctGlobalHfSumAlgos.cc.

References L1GctHfEtSumsLut::bitCountNegEtaRing1, L1GctHfEtSumsLut::bitCountNegEtaRing2, L1GctHfEtSumsLut::bitCountPosEtaRing1, L1GctHfEtSumsLut::bitCountPosEtaRing2, makePileupJSON::bx, L1GctHfEtSumsLut::etSumNegEtaRing1, L1GctHfEtSumsLut::etSumNegEtaRing2, L1GctHfEtSumsLut::etSumPosEtaRing1, L1GctHfEtSumsLut::etSumPosEtaRing2, hfSumsOutput(), L1GctProcessor::numOfBx(), and mps_fire::result.

Referenced by operator<<().

                                                             {
   std::vector<unsigned> result(numOfBx(), 0x00001000);
   std::vector<uint16_t> outputBits;
 
   outputBits = hfSumsOutput(L1GctHfEtSumsLut::bitCountPosEtaRing1);
   for (unsigned bx = 0; bx < outputBits.size(); bx++) {
     result.at(bx) |= outputBits.at(bx);
   }
 
   outputBits = hfSumsOutput(L1GctHfEtSumsLut::bitCountNegEtaRing1);
   for (unsigned bx = 0; bx < outputBits.size(); bx++) {
     result.at(bx) |= outputBits.at(bx) << 3;
   }
 
   outputBits = hfSumsOutput(L1GctHfEtSumsLut::bitCountPosEtaRing2);
   for (unsigned bx = 0; bx < outputBits.size(); bx++) {
     result.at(bx) |= outputBits.at(bx) << 6;
   }
 
   outputBits = hfSumsOutput(L1GctHfEtSumsLut::bitCountNegEtaRing2);
   for (unsigned bx = 0; bx < outputBits.size(); bx++) {
     result.at(bx) |= outputBits.at(bx) << 9;
   }
 
   outputBits = hfSumsOutput(L1GctHfEtSumsLut::etSumPosEtaRing1);
   for (unsigned bx = 0; bx < outputBits.size(); bx++) {
     result.at(bx) |= outputBits.at(bx) << 12;
   }
 
   outputBits = hfSumsOutput(L1GctHfEtSumsLut::etSumNegEtaRing1);
   for (unsigned bx = 0; bx < outputBits.size(); bx++) {
     result.at(bx) |= outputBits.at(bx) << 16;
   }
 
   outputBits = hfSumsOutput(L1GctHfEtSumsLut::etSumPosEtaRing2);
   for (unsigned bx = 0; bx < outputBits.size(); bx++) {
     result.at(bx) |= outputBits.at(bx) << 19;
   }
 
   outputBits = hfSumsOutput(L1GctHfEtSumsLut::etSumNegEtaRing2);
   for (unsigned bx = 0; bx < outputBits.size(); bx++) {
     result.at(bx) |= outputBits.at(bx) << 22;
   }
 
   return result;
 }

void L1GctGlobalHfSumAlgos::process ( )

overridevirtual

process the data, fill output buffers

Implements L1GctProcessor.

Definition at line 112 of file L1GctGlobalHfSumAlgos.cc.

References L1GctHfEtSumsLut::bitCountNegEtaRing1, L1GctHfEtSumsLut::bitCountNegEtaRing2, L1GctHfEtSumsLut::bitCountPosEtaRing1, L1GctHfEtSumsLut::bitCountPosEtaRing2, L1GctJetFinderBase::hfTowerSumsType::etSum0, L1GctJetFinderBase::hfTowerSumsType::etSum1, L1GctHfEtSumsLut::etSumNegEtaRing1, L1GctHfEtSumsLut::etSumNegEtaRing2, L1GctHfEtSumsLut::etSumPosEtaRing1, L1GctHfEtSumsLut::etSumPosEtaRing2, m_hfInputSumsMinusWheel, m_hfInputSumsPlusWheel, m_setupOk, L1GctJetFinderBase::hfTowerSumsType::nOverThreshold0, L1GctJetFinderBase::hfTowerSumsType::nOverThreshold1, storeBitCount(), storeEtSum(), and L1GctUnsignedInt< nBits >::value().

Referenced by L1GctGlobalEnergyAlgos::process().

                                     {
   if (m_setupOk) {
     // step through the different types of Hf summed quantity
     // and store each one in turn into the relevant pipeline
 
     // bit count, positive eta, ring 1
     storeBitCount(L1GctHfEtSumsLut::bitCountPosEtaRing1, m_hfInputSumsPlusWheel.nOverThreshold0.value());
 
     // bit count, negative eta, ring 1
     storeBitCount(L1GctHfEtSumsLut::bitCountNegEtaRing1, m_hfInputSumsMinusWheel.nOverThreshold0.value());
 
     // bit count, positive eta, ring 2
     storeBitCount(L1GctHfEtSumsLut::bitCountPosEtaRing2, m_hfInputSumsPlusWheel.nOverThreshold1.value());
 
     // bit count, negative eta, ring 2
     storeBitCount(L1GctHfEtSumsLut::bitCountNegEtaRing2, m_hfInputSumsMinusWheel.nOverThreshold1.value());
 
     // et sum, positive eta, ring 1
     storeEtSum(L1GctHfEtSumsLut::etSumPosEtaRing1, m_hfInputSumsPlusWheel.etSum0.value());
 
     // et sum, negative eta, ring 1
     storeEtSum(L1GctHfEtSumsLut::etSumNegEtaRing1, m_hfInputSumsMinusWheel.etSum0.value());
 
     // et sum, positive eta, ring 2
     storeEtSum(L1GctHfEtSumsLut::etSumPosEtaRing2, m_hfInputSumsPlusWheel.etSum1.value());
 
     // et sum, negative eta, ring 2
     storeEtSum(L1GctHfEtSumsLut::etSumNegEtaRing2, m_hfInputSumsMinusWheel.etSum1.value());
   }
 }

void L1GctGlobalHfSumAlgos::resetPipelines ( )

overrideprotectedvirtual

Implements L1GctProcessor.

Definition at line 94 of file L1GctGlobalHfSumAlgos.cc.

References m_hfOutputSumsPipe, L1GctHfEtSumsLut::numberOfLutTypes, L1GctProcessor::numOfBx(), submitPVValidationJobs::t, and groupFilesInBlocks::temp.

                                            {
   m_hfOutputSumsPipe.clear();
   Pipeline<uint16_t> temp(numOfBx());
   // Make one copy of the empty pipeline for each type of Hf lut
   unsigned nTypes = (unsigned)L1GctHfEtSumsLut::numberOfLutTypes;
   for (unsigned t = 0; t < nTypes; ++t) {
     m_hfOutputSumsPipe[(L1GctHfEtSumsLut::hfLutType)t] = temp;
   }
 }

void L1GctGlobalHfSumAlgos::resetProcessor ( )

overrideprotectedvirtual

Separate reset methods for the processor itself and any data stored in pipelines.

Implements L1GctProcessor.

Definition at line 89 of file L1GctGlobalHfSumAlgos.cc.

References m_hfInputSumsMinusWheel, m_hfInputSumsPlusWheel, and L1GctJetFinderBase::hfTowerSumsType::reset().

                                            {
   m_hfInputSumsPlusWheel.reset();
   m_hfInputSumsMinusWheel.reset();
 }

void L1GctGlobalHfSumAlgos::setupLuts ( const L1CaloEtScale * scale )

Setup luts.

Definition at line 218 of file L1GctGlobalHfSumAlgos.cc.

References L1GctHfEtSumsLut::bitCountNegEtaRing1, L1GctHfEtSumsLut::bitCountNegEtaRing2, L1GctHfEtSumsLut::bitCountPosEtaRing1, L1GctHfEtSumsLut::bitCountPosEtaRing2, L1GctHfEtSumsLut::etSumNegEtaRing1, L1GctHfEtSumsLut::etSumNegEtaRing2, L1GctHfEtSumsLut::etSumPosEtaRing1, L1GctHfEtSumsLut::etSumPosEtaRing2, m_bitCountLuts, and m_etSumLuts.

Referenced by L1GlobalCaloTrigger::setupHfSumLuts().

                                                                 {
   // Replaces existing list of luts with a new one
   while (!m_bitCountLuts.empty()) {
     delete m_bitCountLuts.begin()->second;
     m_bitCountLuts.erase(m_bitCountLuts.begin());
   }
   m_bitCountLuts[L1GctHfEtSumsLut::bitCountPosEtaRing1] =
       new L1GctHfBitCountsLut(L1GctHfEtSumsLut::bitCountPosEtaRing1);
   m_bitCountLuts[L1GctHfEtSumsLut::bitCountPosEtaRing2] =
       new L1GctHfBitCountsLut(L1GctHfEtSumsLut::bitCountPosEtaRing2);
   m_bitCountLuts[L1GctHfEtSumsLut::bitCountNegEtaRing1] =
       new L1GctHfBitCountsLut(L1GctHfEtSumsLut::bitCountNegEtaRing1);
   m_bitCountLuts[L1GctHfEtSumsLut::bitCountNegEtaRing2] =
       new L1GctHfBitCountsLut(L1GctHfEtSumsLut::bitCountNegEtaRing2);
 
   while (!m_etSumLuts.empty()) {
     delete m_etSumLuts.begin()->second;
     m_etSumLuts.erase(m_etSumLuts.begin());
   }
   m_etSumLuts[L1GctHfEtSumsLut::etSumPosEtaRing1] = new L1GctHfEtSumsLut(L1GctHfEtSumsLut::etSumPosEtaRing1, scale);
   m_etSumLuts[L1GctHfEtSumsLut::etSumPosEtaRing2] = new L1GctHfEtSumsLut(L1GctHfEtSumsLut::etSumPosEtaRing2, scale);
   m_etSumLuts[L1GctHfEtSumsLut::etSumNegEtaRing1] = new L1GctHfEtSumsLut(L1GctHfEtSumsLut::etSumNegEtaRing1, scale);
   m_etSumLuts[L1GctHfEtSumsLut::etSumNegEtaRing2] = new L1GctHfEtSumsLut(L1GctHfEtSumsLut::etSumNegEtaRing2, scale);
 }

void L1GctGlobalHfSumAlgos::setupObjects ( )

inlineoverrideprotectedvirtual

Initialise inputs with null objects for the correct bunch crossing if required.

Implements L1GctProcessor.

Definition at line 73 of file L1GctGlobalHfSumAlgos.h.

73 {}

bool L1GctGlobalHfSumAlgos::setupOk ( ) const

inline

check setup

Definition at line 65 of file L1GctGlobalHfSumAlgos.h.

References m_setupOk.

Referenced by L1GctGlobalEnergyAlgos::L1GctGlobalEnergyAlgos(), and L1GctGlobalEnergyAlgos::setupOk().

65 { return m_setupOk; }

L1GctGlobalHfSumAlgos::m_setupOk

bool m_setupOk

Definition: L1GctGlobalHfSumAlgos.h:91

void L1GctGlobalHfSumAlgos::storeBitCount	(	L1GctHfEtSumsLut::hfLutType	type,
		uint16_t	value
	)

private

Definition at line 144 of file L1GctGlobalHfSumAlgos.cc.

References L1GctProcessor::bxRel(), m_bitCountLuts, and m_hfOutputSumsPipe.

Referenced by process().

                                                                                         {
   std::map<L1GctHfEtSumsLut::hfLutType, const L1GctHfBitCountsLut*>::const_iterator bclut = m_bitCountLuts.find(type);
   if (bclut != m_bitCountLuts.end()) {
     m_hfOutputSumsPipe[type].store((*bclut->second)[value], bxRel());
   }
 }

void L1GctGlobalHfSumAlgos::storeEtSum	(	L1GctHfEtSumsLut::hfLutType	type,
		uint16_t	value
	)

private

Definition at line 152 of file L1GctGlobalHfSumAlgos.cc.

References L1GctProcessor::bxRel(), m_etSumLuts, and m_hfOutputSumsPipe.

Referenced by process().

                                                                                      {
   std::map<L1GctHfEtSumsLut::hfLutType, const L1GctHfEtSumsLut*>::const_iterator eslut = m_etSumLuts.find(type);
   if (eslut != m_etSumLuts.end()) {
     m_hfOutputSumsPipe[type].store((*eslut->second)[value], bxRel());
   }
 }

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	os,
		const L1GctGlobalHfSumAlgos &	fpga
	)

friend

Overload << operator.

Definition at line 66 of file L1GctGlobalHfSumAlgos.cc.

                                                                           {
   os << "===L1GctGlobalHfSumAlgos===" << std::endl;
   os << "WheelJetFpga* plus  = " << fpga.m_plusWheelJetFpga << std::endl;
   os << "Plus wheel inputs:" << std::endl;
   os << "Bit counts ring 1: " << fpga.m_hfInputSumsPlusWheel.nOverThreshold0
      << ", ring 2: " << fpga.m_hfInputSumsPlusWheel.nOverThreshold1 << std::endl;
   os << "Et sums ring 1: " << fpga.m_hfInputSumsPlusWheel.etSum0 << ", ring 2: " << fpga.m_hfInputSumsPlusWheel.etSum1
      << std::endl;
   os << "WheelJetFpga* minus = " << fpga.m_minusWheelJetFpga << std::endl;
   os << "Minus wheel inputs:" << std::endl;
   os << "Bit counts ring 1: " << fpga.m_hfInputSumsMinusWheel.nOverThreshold0
      << ", ring 2: " << fpga.m_hfInputSumsMinusWheel.nOverThreshold1 << std::endl;
   os << "Et sums ring 1: " << fpga.m_hfInputSumsMinusWheel.etSum0 << ", ring 2: " << fpga.m_hfInputSumsMinusWheel.etSum1
      << std::endl;
 
   int bxZero = -fpga.bxMin();
   if (bxZero >= 0 && bxZero < fpga.numOfBx()) {
     os << "Output word " << std::hex << fpga.hfSumsWord().at(bxZero) << std::dec << std::endl;
   }
 
   return os;
 }