CaloCellClusterWeights.h

Go to the documentation of this file.

// -*- c++ -*-
/* Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration */
 
#ifndef CALOEVENT_CALOCELLCLUSTERWEIGHTS_H
#define CALOEVENT_CALOCELLCLUSTERWEIGHTS_H
 
#include "AthenaKernel/CLASS_DEF.h"
 
#include <string>
#include <vector>
#include <tuple>
 
class CaloCell;
 
class CaloCellClusterWeights
{
public:
 
  typedef std::vector<double>                 weight_t;        
  typedef std::tuple<bool,weight_t> value_t;         
  typedef std::vector<value_t>                store_t;         
  typedef store_t::const_iterator             const_iterator;  
  typedef store_t::iterator                   iterator;        
 
  CaloCellClusterWeights();
  CaloCellClusterWeights(size_t size);
  CaloCellClusterWeights(const CaloCellClusterWeights& cellClusterWeights);
  virtual ~CaloCellClusterWeights();
 
  const weight_t& operator[](size_t hash) const; 
  const weight_t& at(size_t hash) const;
  const weight_t& at(const CaloCell* pCell) const;
  bool check(size_t hash) const;
  bool check(const CaloCell* pCell) const;
  bool fastCheck(size_t hash) const;
  bool fastCheck(const CaloCell* pCell) const;
 
  void set(size_t hash,double value);
  void set(const CaloCell* pCell,double value);
  void reset();                       
  void clear();
  void clear(size_t hash);
 
  size_t size() const;     
  size_t reserve() const;  
 
  const_iterator begin() const; 
  const_iterator end() const;   
  iterator begin();             
  iterator end();               
 
  const store_t& store() const; 
  store_t& store();             
 
  static std::string key(const std::string& pref);
 
private:
 
  store_t  m_hashTable;                      
  weight_t m_defaultValue { weight_t() };    
};
 
//CLASS_DEF( CaloCellClusterWeights, 249044352, 1 )
 
inline CaloCellClusterWeights::const_iterator CaloCellClusterWeights::begin() const { return m_hashTable.begin(); }
inline CaloCellClusterWeights::iterator       CaloCellClusterWeights::begin()       { return m_hashTable.begin(); }
 
inline CaloCellClusterWeights::const_iterator CaloCellClusterWeights::end() const { return m_hashTable.end(); }
inline CaloCellClusterWeights::iterator       CaloCellClusterWeights::end()       { return m_hashTable.end(); }
 
inline size_t CaloCellClusterWeights::size()    const { return m_hashTable.size(); }
inline size_t CaloCellClusterWeights::reserve() const { return m_hashTable.capacity(); }
 
inline const CaloCellClusterWeights::store_t& CaloCellClusterWeights::store() const { return m_hashTable; } 
inline       CaloCellClusterWeights::store_t& CaloCellClusterWeights::store()       { return m_hashTable; } 
 
inline std::string CaloCellClusterWeights::key(const std::string& pref) { return pref+std::string("_CCW"); } 
#endif