CaloEnergyCluster.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOEVENT_CALOENERGYCLUSTER_H
#define CALOEVENT_CALOENERGYCLUSTER_H
 
 
#include "Navigation/Navigable.h"
 
#include "EventKernel/INavigable4Momentum.h"
 
#include "FourMom/P4EEtaPhiM.h"
 
#include "CaloEvent/CaloRecoStatus.h"
 
#include "CaloEvent/CaloCellContainer.h"
 
class CaloCell;
 
class CaloEnergyCluster : public Navigable<CaloCellContainer,double>,
              public P4EEtaPhiM,
              virtual public INavigable4Momentum
{
 public:

  typedef CaloCellContainer::const_reference                   const_cell_ptr;
  typedef Navigable<CaloCellContainer,double>::external_index_type index_type;
  typedef Navigable<CaloCellContainer,double>::object_iter      cell_iterator;

  virtual ~CaloEnergyCluster();

  virtual double energy() const { return P4EEtaPhiM::e(); }

  virtual double getBasicEnergy() const { return this->energy(); } 

  virtual void setBasicEnergy(double theEnergy) { this->setE(theEnergy); }

  void addCell(const CaloCellContainer* theContainer,
               const CaloCell*          theCell,
               double                   weight);
  void addCell(const CaloCellContainer* theContainer,
               index_type theIndex,
               double weight);
  
  virtual void addUniqueCell(const CaloCellContainer* theContainer,
                             index_type theIndex,
                             double weight,
                             size_t size_hint = 0);
                             
  void addUniqueCellNoKine(const CaloCellContainer* theContainer,
                           index_type theIndex,
                           double weight,
                           size_t size_hint = 0);
 

  void addUniqueCellNoKine(const CaloCellContainer* theContainer,
                           index_type theIndex,
                           IProxyDict* sg,
                           double weight,
                           size_t size_hint = 0);
 

  void addUniqueCellNoKine(const ElementLink<CaloCellContainer>& theContainer,
                           index_type theIndex,
                           double weight,
                           size_t size_hint = 0);
 

  void reweightCell(const CaloCell* theCell,double weight);
  void reweightCell(const CaloCellContainer* theContainer,
                    index_type& theIndex,
                    double weight);
  void reweightCell(cell_iterator& iterCell,
                    double weight);
  void removeCell(const CaloCell* theCell); 
  void removeCell(const CaloCellContainer* theContainer,
                  index_type& theIndex);

  void removeCells();

  double getCellWeight(const CaloCell* theCell) const; 
  double getCellWeight(const CaloCellContainer* theContainer,
                       index_type& theIndex) const; 
  double getCellWeight(cell_iterator& iterCell) const; 
  const CaloCellContainer* 
    getCellContainer(const CaloCell* theCell) const;

  bool getCellIndex(const CaloCell* theCell, 
                    index_type& theIndex) const;

  cell_iterator cell_begin() const; 
  cell_iterator cell_end()   const;

  unsigned int getNumberOfCells() const;

  void setRecoStatus(CaloRecoStatus::StatusIndicator recStatus);

  const CaloRecoStatus& getRecoStatus() const;
 
 protected:

  CaloEnergyCluster();

  CaloRecoStatus m_status;

  virtual void updateKine(const CaloCell* theCell, double weight) = 0;
 
};

#endif