CaloCompactCellContainer.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOEVENT_CALOCOMPACTCELLCONTAINER_H
#define CALOEVENT_CALOCOMPACTCELLCONTAINER_H

 
#include "AthenaKernel/CLASS_DEF.h"
#include "CaloEvent/CaloCompactCell.h"
#include <vector>
 
class CaloCompactCellContainer
{
 
 public:

  typedef int   value_type;
 
 private:

  std::vector<value_type> m_compactData;
 public:
  CaloCompactCellContainer()
  {
    m_compactData.resize(0);
  };

  CaloCompactCellContainer(const std::vector<value_type> & theCompactData) :
    m_compactData(theCompactData)
  { };
 
  virtual ~CaloCompactCellContainer() { };

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

  CaloCompactCell getCompactCell(const int & iCell,
                 const int & nBytesPerCell) const;

  inline const std::vector<value_type> & getData() const {
    return m_compactData;
  };

  inline std::vector<value_type> & getData() {
    return m_compactData;
  };

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

  void resize (const unsigned int & totalSize);

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

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

  class compact_input_iterator
  {
  public:
    compact_input_iterator (std::vector<value_type>::const_iterator it);
 

    CaloCompactCell::value_type next();
 

    std::vector<value_type>::const_iterator base() const;
 
 
  private:
    std::vector<value_type>::const_iterator m_it;

    value_type m_word;

    int m_count;
  };
 

  compact_input_iterator compact_begin_input() const;

  compact_input_iterator compact_begin_input_from (int) const;

  class compact_output_iterator
  {
  public:
    compact_output_iterator ();
 

    compact_output_iterator (std::vector<value_type>::iterator it);
 

    void set (CaloCompactCell::value_type x);
 

    compact_output_iterator& operator++ ();
 

    int used () const;
 
 
  private:
    std::vector<value_type>::iterator m_it;

    int m_count;
  };
 

  compact_output_iterator compact_begin_output(int headerLength);
};
 
inline  void CaloCompactCellContainer::getCompactCellDataTime(const int & iCell,  CaloCompactCell::value_type & dataTime) const{
    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);
    }
 
inline void CaloCompactCellContainer::setCompactCellDataTime(CaloCompactCell::value_type &theCompactCell, const int & iCell,const int & headerLength) {
 
  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);
 
}
 
 
inline
CaloCompactCellContainer::compact_input_iterator::compact_input_iterator
   (std::vector<value_type>::const_iterator it)
  : m_it (it),
    m_word(0),
    m_count (0)
{
}
 
 
inline
CaloCompactCell::value_type
CaloCompactCellContainer::compact_input_iterator::next()
{
  // Constants.
  const int mask = static_cast<CaloCompactCell::value_type>(-1);
  const int shift = 8*sizeof (CaloCompactCell::value_type);
  const int ratio =
    sizeof(value_type) / sizeof(CaloCompactCell::value_type);
 
  // Fetch the next @c value_type, if needed.
  if (m_count % ratio == 0)
    m_word = *m_it;
 
  // Mask off the current value.
  CaloCompactCell::value_type ret = m_word & mask;
 
  // Bump the count.
  if (((++m_count)%ratio) == 0) {
    // We wrapped to a new @c value_type.  Bump the underlying iterator.
    ++m_it;
  }
  else {
    // Same @c value_type --- shift the word over.
    m_word >>= shift;
  }
 
  return ret;
}
 
 
inline
std::vector<CaloCompactCellContainer::value_type>::const_iterator
CaloCompactCellContainer::compact_input_iterator::base() const
{
  return m_it;
}
 
 
inline
CaloCompactCellContainer::compact_input_iterator
CaloCompactCellContainer::compact_begin_input() const
{
  return compact_input_iterator (m_compactData.begin() + m_compactData[0]);
}
 
inline
CaloCompactCellContainer::compact_input_iterator
CaloCompactCellContainer::compact_begin_input_from(int pos) const{
    return compact_input_iterator (m_compactData.end() - pos);
}
 
inline
CaloCompactCellContainer::compact_output_iterator::compact_output_iterator ()
{
}
 
 
inline
CaloCompactCellContainer::compact_output_iterator::compact_output_iterator
    (std::vector<value_type>::iterator it)
  : m_it (it),
    m_count (0)
{
}
 
inline
void CaloCompactCellContainer::compact_output_iterator::set
  (CaloCompactCell::value_type x)
{
  // Constants.
  const int mask = static_cast<CaloCompactCell::value_type>(-1);
  const int ratio =
    sizeof(value_type) / sizeof(CaloCompactCell::value_type);
  const int shift = 8*sizeof (CaloCompactCell::value_type) * (m_count%ratio);
 
  // Mask the value into the current word.
  *m_it = (*m_it & ~(mask<<shift)) | (x << shift);
 
  // Advance the iterator.
  if (((++m_count)%ratio) == 0)
    ++m_it;
}
 
 
inline
CaloCompactCellContainer::compact_output_iterator&
CaloCompactCellContainer::compact_output_iterator::operator++ ()
{
  const int ratio =
    sizeof(value_type) / sizeof(CaloCompactCell::value_type);
  if (((++m_count)%ratio) == 0)
    ++m_it;
  return *this;
}
 
 
inline
int CaloCompactCellContainer::compact_output_iterator::used () const
{
  const int ratio =
    sizeof(value_type) / sizeof(CaloCompactCell::value_type);
  return (m_count + ratio - 1) / ratio;
}
 
 
inline
CaloCompactCellContainer::compact_output_iterator
CaloCompactCellContainer::compact_begin_output (int headerLength)
{
  return compact_output_iterator (m_compactData.begin() + headerLength);
}
 
 
CLASS_DEF(CaloCompactCellContainer, 1106685019, 1)
 
#endif