container class for CaloCompactCell objects More...

#include <CaloCompactCellContainer.h>

Collaboration diagram for CaloCompactCellContainer:

Classes
class	compact_input_iterator
	Simple iterator-like object for reading from the container. More...
class	compact_output_iterator
	Simple iterator-like object for writing to the container. More...

Public Types
typedef int	value_type
	value type for the internal data

Public Member Functions
	CaloCompactCellContainer ()
	default Constructor.
	CaloCompactCellContainer (const std::vector< value_type > &theCompactData)
	Constructor.
virtual	~CaloCompactCellContainer ()
void	getCompactCellDataTime (const int &iCell, CaloCompactCell::value_type &dataTime) const
	to speed things up ivuko.nosp@m.tic@.nosp@m.cern..nosp@m.ch added this inline function to be used instead of the two bellow.
CaloCompactCell	getCompactCell (const int &iCell, const int &nBytesPerCell) const
	returns the compactified `CaloCell` data
const std::vector< value_type > &	getData () const
	returns the entire compact cell container (includes header)
std::vector< value_type > &	getData ()
	returns the entire compact cell container (includes header)
const std::vector< value_type >	getHeader () const
	returns header portion of the compact cell container
void	resize (const unsigned int &totalSize)
	resize the data vector to totalSize (includes Header)
void	setHeader (const std::vector< value_type > &theHeader)
	replaces the current header (if there was one)
void	setCompactCell (const CaloCompactCell &theCompactCell, const int &iCell, const int &headerLength)
	store the compact cell with index iCell
void	setCompactCellDataTime (CaloCompactCell::value_type &theCompactCell, const int &iCell, const int &headerLength)
	to speed things up ivuko.nosp@m.tic@.nosp@m.cern..nosp@m.ch added this inline function to be used instead of the one above.
compact_input_iterator	compact_begin_input () const
	Return a new `compact_input_iterator` pointing at the start of the data.
compact_input_iterator	compact_begin_input_from (int) const
	Return a new `compact_input_iterator` pointing at position given as the parameter BUT from the end of the data.
compact_output_iterator	compact_begin_output (int headerLength)
	Return a new `compact_output_iterator` pointing at the start of the data.

Private Attributes
std::vector< value_type >	m_compactData
	vector containing header and compact cell data.

Detailed Description

container class for CaloCompactCell objects

Version: $Id: CaloCompactCellContainer.h,v 1.7 2008-11-20 21:35:56 ssnyder Exp $

Author: Sven Menke menke.nosp@m.@mpp.nosp@m.mu.mp.nosp@m.g.de

Date: 03-August-2004

Container class to contain compactified CaloCell objects from a complete CaloCellContainer. The completeness is required in the sense that for every Calorimeter present in the CaloCellContainer all possible cells have to be filled. This allows for not storing the Identifier for the cells. The compact cells (and instances of this class) are produced by the CaloCompactCellTool in CaloTools.

Definition at line 30 of file CaloCompactCellContainer.h.

Member Typedef Documentation

◆ value_type

typedef int CaloCompactCellContainer::value_type

value type for the internal data

The internal data format has a length of 32bit. Therefore this type must have the length of 32 bits.

Definition at line 40 of file CaloCompactCellContainer.h.

Constructor & Destructor Documentation

◆ CaloCompactCellContainer() [1/2]

CaloCompactCellContainer::CaloCompactCellContainer ( )

inline

default Constructor.

Definition at line 53 of file CaloCompactCellContainer.h.

  {
    m_compactData.resize(0);
  };

◆ CaloCompactCellContainer() [2/2]

CaloCompactCellContainer::CaloCompactCellContainer ( const std::vector< value_type > & theCompactData )

inline

Constructor.

Parameters

theCompactData The vector holding the header and CaloCompactCell data

Definition at line 63 of file CaloCompactCellContainer.h.

                                                                         :
    m_compactData(theCompactData)
  { };

◆ ~CaloCompactCellContainer()

virtual CaloCompactCellContainer::~CaloCompactCellContainer ( )

inlinevirtual

Definition at line 67 of file CaloCompactCellContainer.h.

67{ };

Member Function Documentation

◆ compact_begin_input()

CaloCompactCellContainer::compact_input_iterator CaloCompactCellContainer::compact_begin_input ( ) const

inline

Return a new compact_input_iterator pointing at the start of the data.

Definition at line 337 of file CaloCompactCellContainer.h.

{
  return compact_input_iterator (m_compactData.begin() + m_compactData[0]);
}

◆ compact_begin_input_from()

CaloCompactCellContainer::compact_input_iterator CaloCompactCellContainer::compact_begin_input_from ( int pos ) const

inline

Return a new compact_input_iterator pointing at position given as the parameter BUT from the end of the data.

Definition at line 344 of file CaloCompactCellContainer.h.

                                                               {
    return compact_input_iterator (m_compactData.end() - pos);
}

◆ compact_begin_output()

CaloCompactCellContainer::compact_output_iterator CaloCompactCellContainer::compact_begin_output ( int headerLength )

inline

Return a new compact_output_iterator pointing at the start of the data.

Parameters

headerLength The length of the header in front of the data.

Definition at line 404 of file CaloCompactCellContainer.h.

{
  return compact_output_iterator (m_compactData.begin() + headerLength);
}

◆ getCompactCell()

CaloCompactCell CaloCompactCellContainer::getCompactCell	(	const int &	iCell,
		const int &	nBytesPerCell ) const

returns the compactified CaloCell data

Parameters

iCell	the index of the cell in the `CaloCompactCellContainer`
nBytesPerCell	the size of each `CaloCompactCell` in bytes

Returns: a CaloCompactCell

returns the compactified CaloCell information in form of a CaloCompactCell which is needed to restore the original CaloCell object.

Definition at line 21 of file CaloCompactCellContainer.cxx.

{
  // the size of value_type must be an integral multiple
  // of the size of CaloCompactCell::value_type 
  const int nRatio = sizeof(value_type)/sizeof(CaloCompactCell::value_type);
 
  // the number of words (in terms of the CaloCompactCell::value_type) 
  // needed to store one compact cell
  const int nWords = nBytesPerCell/sizeof(CaloCompactCell::value_type);
  
  // the compace data for one cell
  std::vector<CaloCompactCell::value_type> cData(nWords);
 
  for (int iWord=0;iWord<nWords;iWord++) {
    // the vector element to use for this cell
    int iPos = m_compactData[0] + (int)((iCell*nWords+iWord)/nRatio);
    
    // the relative position inside the vector element to use for this cell
    int iMod = ((iCell*nWords+iWord)%nRatio)<<(8/nRatio);
 
    // shift the current vector element down and project out 16 bits
    cData[iWord] = (CaloCompactCell::value_type) (((m_compactData[iPos])>>iMod) 
                          & CaloCompactCell::WORDMASK);
    
  }
  
  CaloCompactCell cCell(cData);
  return cCell;
}

◆ getCompactCellDataTime()

void CaloCompactCellContainer::getCompactCellDataTime	(	const int &	iCell,
		CaloCompactCell::value_type &	dataTime ) const

inline

to speed things up ivuko.nosp@m.tic@.nosp@m.cern..nosp@m.ch added this inline function to be used instead of the two bellow.

It uses no vectors since it takes time to make them. nwords and a loop over them is removed since nwords is always=1 as nBytesPerCell is = sizeof(CaloCompactCell::value_type) Its inlined and calculation is simplifed

Definition at line 265 of file CaloCompactCellContainer.h.

                                                                                                                           {
    static const int nRatio = sizeof(value_type)/sizeof(CaloCompactCell::value_type);
    int iPos = m_compactData[0] + (int)(iCell/nRatio);
    int iMod = (iCell%nRatio)<<(8/nRatio);
    dataTime=(CaloCompactCell::value_type) (((m_compactData[iPos])>>iMod) & CaloCompactCell::WORDMASK);
    }

◆ getData() [1/2]

std::vector< value_type > & CaloCompactCellContainer::getData ( )

inline

returns the entire compact cell container (includes header)

Returns: a reference to the vector holding the compact data

Definition at line 105 of file CaloCompactCellContainer.h.

                                           {
    return m_compactData;
  };

◆ getData() [2/2]

const std::vector< value_type > & CaloCompactCellContainer::getData ( ) const

inline

returns the entire compact cell container (includes header)

Returns: a const reference to the vector holding the compact data

Definition at line 97 of file CaloCompactCellContainer.h.

                                                       {
    return m_compactData;
  };

◆ getHeader()

const std::vector< CaloCompactCellContainer::value_type > CaloCompactCellContainer::getHeader ( ) const

returns header portion of the compact cell container

Returns: a const vector holding the header data

Definition at line 53 of file CaloCompactCellContainer.cxx.

{
  std::vector<value_type> theHeader(m_compactData[0]);
  for(int i=0;i<m_compactData[0];i++)
    theHeader[i] = m_compactData[i];
  return theHeader;
}

◆ resize()

void CaloCompactCellContainer::resize ( const unsigned int & totalSize )

resize the data vector to totalSize (includes Header)

Parameters

totalSize the total size in unites of value_type

Definition at line 61 of file CaloCompactCellContainer.cxx.

{
  m_compactData.resize(totalSize);
}

◆ setCompactCell()

void CaloCompactCellContainer::setCompactCell	(	const CaloCompactCell &	theCompactCell,
		const int &	iCell,
		const int &	headerLength )

store the compact cell with index iCell

Parameters

theCompactCell	the compact `CaloCell` data
iCell	the index in the `CaloCompactCellContainer`
headerLength	the space reserved for the header information

Definition at line 73 of file CaloCompactCellContainer.cxx.

                           {
  
  // the size of value_type must be an integral multiple
  // of the size of CaloCompactCell::value_type 
  const int nRatio = sizeof(value_type)/sizeof(CaloCompactCell::value_type);
 
  // the compace data for one cell
  std::vector<CaloCompactCell::value_type> cData(theCompactCell.getData());
 
  // the number of words (in terms of the CaloCompactCell::value_type) 
  // needed to store one compact cell
  const int nWords = cData.size();
  
  for (int iWord=0;iWord<nWords;iWord++) {
    // the vector element to use for this cell
    int iPos = headerLength + (int)((iCell*nWords+iWord)/nRatio);
    
    // the relative position inside the vector element to use for this cell
    int iMod = ((iCell*nWords+iWord)%nRatio)<<(8/nRatio);
 
    if ( iMod == 0 ) 
      m_compactData[iPos] = 0;
    // shift the 16 bits to the correct position and put them into the
    // current vector element
    m_compactData[iPos] = m_compactData[iPos] | (cData[iWord]<<iMod);
  }
}

◆ setCompactCellDataTime()

void CaloCompactCellContainer::setCompactCellDataTime	(	CaloCompactCell::value_type &	theCompactCell,
		const int &	iCell,
		const int &	headerLength )

inline

to speed things up ivuko.nosp@m.tic@.nosp@m.cern..nosp@m.ch added this inline function to be used instead of the one above.

It uses no vectors since it takes time to make them. nwords and a loop over them is removed since nwords is always=1 as nBytesPerCell is = sizeof(CaloCompactCell::value_type) Its inlined and calculation is simplifed

Definition at line 272 of file CaloCompactCellContainer.h.

                                                                                                                                                  {
 
  static const int nRatio = sizeof(value_type)/sizeof(CaloCompactCell::value_type);
 
  // the compace data for one cell
  //CaloCompactCell::value_type cData(theCompactCell);
    int iPos = headerLength + (int)(iCell/nRatio);
    int iMod = (iCell%nRatio)<<(8/nRatio);
    if ( iMod == 0 ) m_compactData[iPos] = 0;
    m_compactData[iPos] = m_compactData[iPos] | (theCompactCell<<iMod);
 
}

◆ setHeader()

void CaloCompactCellContainer::setHeader ( const std::vector< value_type > & theHeader )

replaces the current header (if there was one)

Parameters

theHeader the new header

used by the compactifier tool on creation of the container

Definition at line 66 of file CaloCompactCellContainer.cxx.

{
  for(unsigned int i=0;i<theHeader.size();i++)
    m_compactData[i] = theHeader[i];
}

Member Data Documentation

◆ m_compactData

std::vector<value_type> CaloCompactCellContainer::m_compactData

private

vector containing header and compact cell data.

the first int in the vector must contain the header length (in number of 32bit ints) including the first int

Definition at line 50 of file CaloCompactCellContainer.h.

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

Classes

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ value_type

Constructor & Destructor Documentation

◆ CaloCompactCellContainer() [1/2]

◆ CaloCompactCellContainer() [2/2]

◆ ~CaloCompactCellContainer()

Member Function Documentation

◆ compact_begin_input()

◆ compact_begin_input_from()

◆ compact_begin_output()

◆ getCompactCell()

◆ getCompactCellDataTime()

◆ getData() [1/2]

◆ getData() [2/2]

◆ getHeader()

◆ resize()

◆ setCompactCell()

◆ setCompactCellDataTime()

◆ setHeader()

Member Data Documentation

◆ m_compactData