CaloClusterCellLink.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
//Dear emacs, this is -*-c++-*-
#ifndef CALOEVENT_CALOCLUSTERCELLLINK_H
#define CALOEVENT_CALOCLUSTERCELLLINK_H
 
#include "AthLinks/DataLink.h"
#include "CaloEvent/CaloCellContainer.h"
#include <map> 
#include <iterator>
 
class CaloClusterCellLink {
 
 public:
  typedef double weight_t;
 
 private:
  //Typedef std::map<unsigned,weight_t> linkAndWeightCollType;
  typedef std::vector<std::pair<unsigned, weight_t> > linkAndWeightCollType;
 
 public:
  CaloClusterCellLink();
 
  CaloClusterCellLink(const CaloCellContainer* cellCont);
 
  CaloClusterCellLink(const DataLink<CaloCellContainer>& cellCont);
 
  
  ~CaloClusterCellLink(); 
 
  class const_iterator
  {
  public:
    using iterator_category = std::bidirectional_iterator_tag;
    using value_type = const CaloCell*;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type*;
    using reference = value_type&;
 
    const_iterator() = delete; //C++11 
 
    const_iterator(const CaloCellContainer* cellCont, linkAndWeightCollType::const_iterator it) :
      m_ccc(cellCont), m_it(it) {};
 
    const CaloCell* operator*() const {return (*m_ccc)[m_it->first];}
    const CaloCell* operator->() const {return (*m_ccc)[m_it->first];}
 
    weight_t weight() const {return m_it->second;}
 
    unsigned index() const {return m_it->first;}
 
    const_iterator operator++() {++m_it; return *this;}
    const_iterator operator--() {--m_it; return *this;}
    const_iterator operator++(int) {++m_it; return *this;}
    const_iterator operator--(int) {--m_it; return *this;}
    bool operator==(const const_iterator& b) const { return m_it==b.m_it;}
    bool operator!=(const const_iterator& b) const { return m_it!=b.m_it;}
    
  private:
    const CaloCellContainer* m_ccc;
    linkAndWeightCollType::const_iterator m_it;
  };//end class CaloClusterCellLink::const_iterator
 
 
  const static CaloClusterCellLink::const_iterator dummyIt;
 
  const_iterator begin() const {return const_iterator(m_cellCont, m_indicesAndWeights.begin());} 
 
  const_iterator end() const {return const_iterator(m_cellCont, m_indicesAndWeights.end());} 
 
  size_t size() const {return m_indicesAndWeights.size();}
 
  //Non-const interface:
 
  class iterator
  {
    friend class CaloClusterCellLink;
  public:
    using iterator_category = std::bidirectional_iterator_tag;
    using value_type = const CaloCell*;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type*;
    using reference = value_type&;
 
    iterator() = delete;
 
  iterator(const CaloCellContainer* ccc, linkAndWeightCollType::iterator it) :
    m_ccc(ccc), m_it(it) {};
    const CaloCell* operator*() const {return (*m_ccc)[m_it->first];}
    const CaloCell* operator->() const {return (*m_ccc)[m_it->first];}
    weight_t weight() const {return m_it->second;}
 
    unsigned index() const {return m_it->first;}
 
    iterator operator++() {++m_it; return *this;}
    iterator operator--() {--m_it; return *this;}
    iterator operator++(int) {++m_it; return *this;}
    iterator operator--(int) {--m_it; return *this;}
    bool operator==(const iterator& b) const { return m_it==b.m_it;}
    bool operator!=(const iterator& b) const { return m_it!=b.m_it;}
 
    //Non-const manipulations:
    void reweight(const weight_t newWeight) {m_it->second=newWeight;}
 
    void reindex(const unsigned newIndex) {m_it->first=newIndex;}
 
    
  private:
    const CaloCellContainer* m_ccc;
    linkAndWeightCollType::iterator m_it;
  };//end class CaloClusterCellLink::iterator
 
  iterator begin() {return iterator(m_cellCont, m_indicesAndWeights.begin());} 
 
  iterator end() {return iterator(m_cellCont, m_indicesAndWeights.end());} 
 
 
  bool addCell(const unsigned cellIdx, const weight_t weight=1.0);
 
  CaloClusterCellLink::iterator removeCell(iterator cellItr);
  
 
  bool removeCell(const CaloCell* ptr);
  
 
  const CaloCellContainer* getCellContainer() const { return m_cellCont.cptr();}
  const DataLink<CaloCellContainer>& getCellContainerLink() const { return m_cellCont;}
 
  void reserve(const size_t s) { m_indicesAndWeights.reserve(s);}
 
 
  void clear() {m_indicesAndWeights.clear();}
 
  void toPersistent(); 
 
 private:
  DataLink<CaloCellContainer> m_cellCont;
  linkAndWeightCollType m_indicesAndWeights;
 
  const static linkAndWeightCollType m_dummyIndicesAndWeights; //0-size vector for dummy iterator
 
};
 
inline bool CaloClusterCellLink::addCell(const unsigned cellIdx, const weight_t weight) {
 
  /* map version - with uniqueness check
  std::pair<linkAndWeightCollType::iterator,bool> tryInsert=
    m_indicesAndWeights.insert(std::make_pair(cellIdx,weight));
  if (!tryInsert.second) {
    //Cell existed before, need to overwrite
    tryInsert.first->second=weight;
  }
  return !tryInsert.second;
  */
  m_indicesAndWeights.emplace_back(cellIdx,weight);
  return true;
 
}
 
#endif