CaloSamplingData.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOEVENT_CALOSAMPLINGDATA_H
#define CALOEVENT_CALOSAMPLINGDATA_H
 
#include "CaloGeoHelpers/CaloSampling.h"
#include "CaloEvent/CaloVariableType.h" 
#include "CxxUtils/copy_bounded.h"
 
#include <vector>
#include <algorithm>
 
class CaloSamplingData
{
 public: 
 
  typedef CaloSampling::CaloSample                sampling_key_type;
  typedef CaloVariableType::VariableType          variable_key_type;
 
  typedef double                                  value_type;    
  typedef std::vector<value_type>                 variable_store_type;
 
  typedef std::vector<value_type>                 const_vector_type;
  typedef std::vector<value_type>                 vector_type;
 
  CaloSamplingData();
  CaloSamplingData(unsigned int varTypePattern);
  explicit CaloSamplingData(const CaloSamplingData& rData);
  explicit CaloSamplingData(const CaloSamplingData* pData);
  CaloSamplingData& operator= (const CaloSamplingData&);
  virtual ~CaloSamplingData();
 
  void swap (CaloSamplingData& other);
 
 
  size_t getNumberOfSamplings() const;
  size_t getNumberOfSamplings(variable_key_type theVariable) const; 
 
  size_t getNumberOfVariableTypes() const;
 
  value_type retrieveData(variable_key_type theVariable,
                          sampling_key_type theSampling) const;
  value_type& retrieveData(variable_key_type theVariable,
               sampling_key_type theSampling);
  bool retrieveData(variable_key_type theVariable,
            vector_type& theData) const;
 
  bool removeVariable(variable_key_type theVariable, 
              sampling_key_type theSampling);
  bool removeVariable(variable_key_type theVariable);
  bool removeVariable(sampling_key_type theSampling);
  /*{! \brief Clear the store */
  bool removeVariable(); 
  bool clearStore();
  bool storeData(variable_key_type theVariable,
         sampling_key_type theSampling,
         value_type theData);
  bool storeData(variable_key_type theVariable,
         const vector_type& theData);
  template <class Iterator>
  bool storeData(variable_key_type theVariable, Iterator beg, Iterator end);
 
  bool contains(variable_key_type theVariable) const;
 
 protected: 
 
  class IsValidData
  {
  public:    
    bool operator()(value_type theData)
    { return theData != value_type(); }
  };
 
 private:
  friend class CaloSamplingDataCnv_p1;
  friend class CaloSamplingDataContainerCnv_p1;
  friend class CaloClusterContainerCnv_p4;
  friend class CaloClusterContainerCnv_p5;
  friend class CaloClusterContainerCnv_p6;
  friend class CaloClusterContainerCnv_p7;
  friend class CaloClusterContainerCnvTest_p6;
  friend class CaloClusterContainerCnvTest_p7;
 
  variable_store_type m_dataStore;
 
  unsigned int  m_varTypePattern;
 
  bool setupStores();
 
  unsigned int getBitPattern(variable_key_type theVariable) const;
 
  bool checkBitPattern(variable_key_type theVariable);
  bool testBitPattern(variable_key_type theVariable) const;
  bool clearBitPattern(variable_key_type theVariable);
  bool clearBitPattern();
  bool testConstPattern() const;
 
  size_t index (size_t theVariable, size_t theSampling) const;
  size_t fastNsamp() const;
}; 
 
// Retrieve Data Helpers //
 
inline size_t CaloSamplingData::getNumberOfSamplings() const
{ return size_t(CaloSampling::getNumberOfSamplings()); }
 
inline size_t CaloSamplingData::getNumberOfVariableTypes() const
{ return size_t(CaloVariableType::getNumberOfVariables()); }
 
inline CaloSamplingData::value_type&
CaloSamplingData::retrieveData(variable_key_type theVariable,
                   sampling_key_type theSampling)
{ 
  m_varTypePattern = m_varTypePattern | this->getBitPattern(theVariable);
  return m_dataStore[index(theVariable, theSampling)];
}
 
inline CaloSamplingData::value_type
CaloSamplingData::retrieveData(variable_key_type theVariable,
                   sampling_key_type theSampling) const
{
  return m_dataStore[index(theVariable, theSampling)];
}
 
// Store And Erase Data Helper //
 
 
inline bool
CaloSamplingData::removeVariable(variable_key_type theVariable,
                 sampling_key_type theSampling)
{
  m_dataStore[index(theVariable,theSampling)] = value_type();
  return true;
}
inline bool
CaloSamplingData::removeVariable(sampling_key_type theSampling)
{
  variable_store_type::iterator beg =
    m_dataStore.begin() + index (0, theSampling);
  variable_store_type::iterator end = m_dataStore.end();
  int nsamp = fastNsamp();
  for (; beg < end; beg += nsamp)
    *beg = value_type();
  return true;
}
inline bool
CaloSamplingData::removeVariable(variable_key_type theVariable)
{
  size_t idx = index (theVariable, 0);
  std::fill_n (m_dataStore.begin() + idx, fastNsamp(), value_type());
  return true;
}
inline bool
CaloSamplingData::removeVariable()
{
  std::fill (m_dataStore.begin(), m_dataStore.end(), value_type());
  return this->clearBitPattern();
}
inline bool CaloSamplingData::clearStore() { return this->removeVariable(); }
inline bool
CaloSamplingData::contains(variable_key_type theVariable) const
{ return this->testBitPattern(theVariable); }
 
inline unsigned int
CaloSamplingData::getBitPattern(variable_key_type theVariable) const
{ return CaloVariableType::getVariableBit(theVariable); }
 
inline bool
CaloSamplingData::testBitPattern(variable_key_type theVariable) const
{
  unsigned int testBit(this->getBitPattern(theVariable));
  if (testBit == 0) return false;
  return ( m_varTypePattern & testBit ) == testBit;
}
 
inline bool CaloSamplingData::testConstPattern() const
{ return CaloVariableType::checkConst(m_varTypePattern); }
 
inline
size_t CaloSamplingData::index (size_t theVariable, size_t theSampling) const
{
  return theVariable * fastNsamp() + theSampling;
}
 
inline
size_t CaloSamplingData::fastNsamp() const
{
  return (size_t)(CaloSampling::Unknown);
}
 
 
template <class Iterator>
bool CaloSamplingData::storeData (variable_key_type theVariable,
                                  Iterator beg, Iterator end)
{
  //Check const bit and set m_varTypePattern 
  if (!this->checkBitPattern (theVariable))
    return false;
  if (beg == end)
    return false;
  variable_store_type::iterator output =
    m_dataStore.begin() + index(theVariable, 0);
  CxxUtils::copy_bounded (beg, end, output, output + fastNsamp());
  return true;
  
}
 
#endif