CaloCellContainer.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOEVENT_CALOCELLCONTAINER_H
#define CALOEVENT_CALOCELLCONTAINER_H
 
/********************************************************************
 
NAME:     CaloCellContainer.h
PACKAGE:  offline/Calorimeter/CaloRec
 
AUTHORS:  S. Rajagopalan
CREATED:  April 2001
 
PURPOSE:  Container for CaloCell - stored as DataObject in TDS.
MODIFIED: David Rousseau: heavy modification to allow storing all 
          calorimeter cells in one single container
********************************************************************/
 
#include "AthContainers/DataVector.h"
#include "AthenaKernel/CLASS_DEF.h"
#include "CaloEvent/CaloCell.h"
 
#include "CaloIdentifier/CaloCell_ID.h"
#include "Identifier/IdentifierHash.h"
#include "CxxUtils/PackedArray.h"
#include "CxxUtils/CachedValue.h"
#include "AthLinks/tools/findInContainer.h"
 
 
class CaloCellContainer : public DataVector<CaloCell>
{
 
// only class allowed to use private functions
// this is because CaloCellContainer need to be told by 
// someone the maximum hash size. Cannot do it by 
// itself to avoid dependencies
 
 friend class CaloConstCellContainer;
 friend class CaloCellContainerFinalizerTool;
 friend class CaloCompactCellTool; 
 friend class FullCaloCellContMaker;
 friend class EmptyCellBuilderTool;
 friend class CaloCellContCopyTool;
 public:
 
 
  typedef std::vector<const CaloCell*> CellVector;
  
  typedef std::vector<CaloCell*> MutableCellVector;
  
  CaloCellContainer(SG::OwnershipPolicy ownPolicy=SG::OWN_ELEMENTS ) ;
 
  
  CaloCellContainer(size_t n, SG::OwnershipPolicy ownPolicy=SG::OWN_ELEMENTS );
 
 
  virtual ~CaloCellContainer() { };
 
 
  void push_back(CaloCell *);
 
  void push_back(std::unique_ptr<CaloCell>);
 
 
  void push_back_fast(CaloCell *);  
 
  void push_back_fast(std::unique_ptr<CaloCell> theCell);
 
 
  static void print() ;
 
  CaloCellContainer::const_iterator beginConstCalo(CaloCell_ID::SUBCALO caloNum) const, endConstCalo(CaloCell_ID::SUBCALO caloNum) const;
 
  CaloCellContainer::iterator beginCalo(CaloCell_ID::SUBCALO caloNum), endCalo(CaloCell_ID::SUBCALO caloNum);
 
 
  bool checkOrderedAndComplete() const ;
 
  void setIsOrderedAndComplete(const bool ordered);
 
  bool isOrderedAndComplete() const ;
 
  bool checkOrdered() const ;
 
  void setIsOrdered(const bool ordered);
 
  bool isOrdered() const ;
 
  bool hasTotalSize() const ;
 
 
  bool hasCalo(const CaloCell_ID::SUBCALO caloNum) const ;
 
 
  int indexFirstCellCalo(const CaloCell_ID::SUBCALO caloNum) const ;
 
  int indexLastCellCalo(const CaloCell_ID::SUBCALO caloNum) const ;
 
  int nCellsCalo(const CaloCell_ID::SUBCALO caloNum) const ;
 
  void setHasCalo(const CaloCell_ID::SUBCALO caloNum);
 
  void updateCaloIterators();
  
  void updateCaloBeginIterators(int ic, int ind);
  
  void updateCaloEndIterators(int ic,int ind);
 
  const CaloCell * findCell(const IdentifierHash   theHash) const;
 
  CaloCell * findCell(const IdentifierHash   theHash);
 
  int findIndex(const IdentifierHash   theHash) const;
 
  void findCellVector(const std::vector<IdentifierHash> & theVectorHash,CellVector & theCellVector) const;
 
  void findCellVector(const std::vector<IdentifierHash> & theVectorHash,MutableCellVector & theCellVector);
 
  
 
  void initializeLookUpTable();
 
  void resetLookUpTable();
 
  void order();
 
  class orderWithCaloHash
    {
    public:
      bool operator() ( const CaloCell * a ,const CaloCell * b ) const;
      // implement in .cxx so that CaloDetDescrElement.h does not need to be included
      // {return a->caloDDE()->calo_hash() < b->caloDDE()->calo_hash(); }
    bool operator() ( const CaloCell & a ,const CaloCell & b ) const ;
    // { return a.caloDDE()->calo_hash() < b.caloDDE()->calo_hash(); }
    };
 
 
 private:
  IMessageSvc* msgSvc() const;
 
  void setHasTotalSize(const bool);
 
 
  void updateCaloIteratorsOrdered (CaloCellContainer::iterator beg,
                                   CaloCellContainer::iterator end);
  
 
  void orderWhenIncomplete();
  void orderWhenComplete();
 
 
  template <class CONT, class VECT>
  static void findCellVectorT(CONT& cont,
                              const std::vector<IdentifierHash> & theVectorHash,
                              VECT& theCellVector);
 
  const CxxUtils::PackedArray& getLookUpTable() const;
 
  CxxUtils::CachedValue<CxxUtils::PackedArray> m_lookUpTable;
 
  bool m_hasTotalSize ;
 
 
  bool m_isOrdered ;
 
  bool m_isOrderedAndComplete ;
 
  std::vector<bool> m_hasCalo;
 
  std::vector<int> m_indexFirstCellCalo;
 
  std::vector<int> m_indexLastCellCalo;
 
  std::vector< CaloCellContainer::const_iterator > m_beginConstCalo,m_endConstCalo ;
  std::vector< CaloCellContainer::iterator > m_beginCalo,m_endCalo;
};
 
inline bool CaloCellContainer::hasTotalSize() const {
  return m_hasTotalSize ;
}
 
inline bool CaloCellContainer::isOrdered() const {
  return m_isOrdered ;
}
 
 
inline bool CaloCellContainer::isOrderedAndComplete() const {
  return m_isOrderedAndComplete ;
}
 
 
CLASS_DEF(CaloCellContainer, 2802, 1)
SG_BASE(CaloCellContainer, DataVector<CaloCell> );
 
namespace SG {
 
 
// Specialize this for CaloCellContainer.
// We'll implement it using findIndex.
template <>
bool
findInContainer (const CaloCellContainer& data,
                 CaloCell const * const & element,
                 CaloCellContainer::size_type& index);
 
 
} // namespace SG
 
 
#endif