Calorimeter/CaloEvent/CaloEvent/CaloCluster.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
//Dear emacs, this is -*-c++-*-
 
#ifndef CALOEVENT_CALOCLUSTER_H  
#define CALOEVENT_CALOCLUSTER_H
/***************************************************************************
  CaloCluster class
  base class for calorimeter classes
   
Update: Jan 10 2001 HMA
          order of static/virtual/const 
 
Update:  Redesign.  May 21, 2001 
         Concrete base class for Calorimeter cluster
     Using CaloSampling for sampling information. 
 
Update:  Redesign.  Nov 12, 2001  efrank
         Inherit from Navigable to plug into navigation code.
     Modify addcell() to update token.  I realize now that CaloCluster
     and NavClusterToken may need to be extend so that a weight can
     be stored with added cells.
 
Update:  Redesign. Mar 06, 2003 P Loch
         New navigation system.
 
Update:  Redesign. Feb 17, 2004 P Loch
         Complete overhaul. Now inherits from CaloEnergyCluster (navigable
         4-vector object with constituents). Non-backward compatible change
         of interfaces.
 
Update:  Jul 18, 2005 P Loch
         Add basic signal data word and access methods
 
Update:  Sep 18, 2005 P Loch
         Completely new EDM with external data objects storing the cell links
         and cluster data.
***************************************************************************/
#include "EventKernel/INavigable4Momentum.h"
#include "EventKernel/ISignalState.h"
#include "Navigation/AthenaBarCodeBase.h"
 
#include "CaloEvent/CaloClusterLinkTemplate.h"
#include "CaloEvent/CaloSamplingHelper.h"
 
#include "CaloEvent/CaloClusterMoment.h"
#include "CaloEvent/CaloClusterMomentStore.h"
 
#include "CaloEvent/CaloVariableType.h"
#include "CaloEvent/CaloShower.h"
#include "CaloEvent/CaloShowerContainer.h"
 
#include "CaloEvent/CaloCompositeKineBase.h"
#include "CaloEvent/CaloCompositeCellBase.h"
#include "CaloEvent/CaloClusterNavigable.h"
 
#include "CaloEvent/CaloClusterBadChannelData.h"
 
#include <vector>
 
#include "GeoPrimitives/GeoPrimitives.h"
#include "CxxUtils/checker_macros.h"
 
 
class CaloCell ; 
 
class CaloCluster;
 
struct CaloClusterSignalState;
 
 
class CaloCluster :  public CaloCompositeKineBase,
                            public CaloCompositeCellBase<CaloClusterNavigable>,
                                virtual public INavigable4Momentum,
                            public ISignalState,
                            public AthenaBarCodeBase
{
 
 public:

  enum ClusterSize {
    // electrons
    SW_55ele   = 1,
    SW_35ele   = 2,
    SW_37ele   = 3,
    // photons
    SW_55gam   = 4,
    SW_35gam   = 5,
    SW_37gam   = 6,
    // early converted photons
    SW_55Econv = 7,
    SW_35Econv = 8,
    SW_37Econv = 9,
    // soft electrons
    SW_softe   = 10,
    // topological clusters
    Topo_420   = 11,
    Topo_633   = 12,
    // transient cluster for AODCellContainer
    SW_7_11   = 13,
    Unknown    = 99
  };
 

  // Public Types //

  typedef CaloCompositeCellBase<CaloClusterNavigable>::cell_iterator 
    cell_iterator;

  typedef CaloSampling::CaloSample                sampling_type;

  typedef CaloVariableType::VariableType          variable_type;

  typedef double                                  value_type;
 

  typedef CaloClusterMomentStore                  moment_store;
  typedef moment_store::moment_type               moment_type;
  typedef moment_store::moment_value              moment_value;
  typedef moment_store::moment_iterator           moment_iterator_i;
 
  // xAOD compatibility.
  typedef moment_type MomentType;
 
  typedef double (CaloCluster::*GET_VALUE)()   const;
  typedef void   (CaloCluster::*SET_VALUE)(double v);
 
  typedef P4SignalState              statename_t;
  typedef P4SignalState::State     signalstate_t;

  // MomentStore Iterator //
 
  class MomentStoreIter
  {
  public:

    MomentStoreIter();
    MomentStoreIter(const moment_iterator_i& iter,
            const moment_store* firstStore, 
            const moment_store* secndStore=0) ;
    ~MomentStoreIter();

    MomentStoreIter next();

    MomentStoreIter prev() ;
     
    MomentStoreIter operator++();
    MomentStoreIter operator++(int);    
    MomentStoreIter operator--(); 
    MomentStoreIter operator--(int);

    bool operator==(const MomentStoreIter& anOther) const;
    bool operator!=(const MomentStoreIter& anOther) const;

    const CaloClusterMoment& operator*() const;
    const CaloClusterMoment& getMoment() const;
    moment_type getMomentType() const;
 
  private: 
     
    moment_iterator_i m_iter;
    const moment_store*     m_firstStore;
    const moment_store*     m_secndStore;
  };

  typedef MomentStoreIter          moment_iterator; 

  // Constructors & Destructors //

  CaloCluster(double eta0 = 0, double phi0 = 0,
          unsigned int varTypePattern = 0x00000000, 
          unsigned int clusterSize=CaloCluster::SW_55ele);
  virtual ~CaloCluster();
  CaloCluster(const CaloCluster* pCluster);
  CaloCluster(const CaloCluster& rCluster);

  // General Set and Get for all Variables //
     
  double 
  getVariable(const variable_type& varType,
          const sampling_type& samType,
          bool                  useLink = true) const;
  
  bool
  getVariable(const variable_type& varType,
          std::vector<double>& varList,
          bool                 useLink = true) const;
          
  bool
  setVariable(const variable_type& varType, 
          const sampling_type& samType,
          const double&        varData,
          bool                 useLink = false);
  bool
  setVariable(const variable_type&       varType, 
          const std::vector<double>& varList,
          bool                       useLink = false);
 

  bool
  lockVariable(const variable_type& varType);

  bool
  unlockVariable(const variable_type& varType);

  bool isLocked(const variable_type& varType) const;
  bool isLocked(const unsigned int& bitPattern) const;

  bool allLocked() const;

  // Kinematics //

  virtual  CLHEP::HepLorentzVector hlv() const {return CaloCompositeKineBase::hlv();} 

  virtual  CLHEP::HepLorentzVector hlv(signalstate_t s) const;

  virtual double e() const;
  virtual double eta() const;
  virtual double phi() const;
  virtual double m() const;

  double e(signalstate_t s) const;
  double eta(signalstate_t s) const;
  double phi(signalstate_t s) const;
  double m(signalstate_t s) const;

  virtual void setE(double e);
  virtual void setEta(double eta);
  virtual void setPhi(double phi);
  virtual void setM(double m);

  virtual void set4Mom(const I4Momentum* const pMom);
  virtual void set4Mom(const I4Momentum& rMom);
  virtual void set4Mom(const CLHEP::HepLorentzVector& rVec);

  unsigned int nSamples() const;
  double eSample(sampling_type sampling) const;
  double etaSample(sampling_type sampling) const;
  double phiSample(sampling_type sampling) const;

  void getEInSamples(std::vector<double>& theEnergies) const;
  void getEtaInSamples( std::vector<double>& theEtas)  const;
  void getPhiInSamples( std::vector<double>& thePhis)  const;

  void setEInSamples(const std::vector<double>& theEnergies);
  void setEtaInSamples(const std::vector<double>& theEtas);
  void setPhiInSamples(const std::vector<double>& thePhis);
  virtual double getBasicEnergy() const;
  virtual void setBasicEnergy(double theEnergy);  
  double getTime() const;
  void setTime(double theTime);

  void setClusterSize(unsigned int theClusterSize);

  unsigned int getClusterSize() const;
 
  /* \brief Get eta/phi size from cluster size */
  unsigned int getClusterEtaSize() const;
  unsigned int getClusterPhiSize() const;

  void setenergy(sampling_type sampling, double e);
  void seteta   (sampling_type sampling, double eta);
  void setphi   (sampling_type sampling, double phi);

  // Cluster Moments //

  void insertMoment(const moment_type& momType,
                    const moment_value& momValue,
                    bool                useLink=true);
  moment_iterator beginMoment(bool useLink=true) const;
  moment_iterator endMoment(bool useLink=true) const;
  bool retrieveMoment(const moment_type& momType,
                      moment_value& momValue,
                      bool useLink=true) const;
  bool retrieveMoment(const moment_type& momType,
                      double&       momData,
                      bool          useLink=true) const; 
  moment_value getMoment(const moment_type& momType,
                         bool useLink=true) const;
  moment_value getMoment(const moment_iterator& momIter) const;

  double getMomentValue(const moment_type& momType,
                        bool useLink=true) const;
  double getMomentValue(const moment_iterator& momIter) const;

  moment_type getMomentType(const moment_iterator& momIter) const;

  // Special Variables //

  bool is_valid_sampling(const sampling_type& sampling) const;  
  bool isEMSampling(const sampling_type& theSampling) const;
  bool hasSampling(const sampling_type& theSampling) const; 
  unsigned int samplingPattern() const;

  double eta0() const;
  double phi0() const;

  double etasize(sampling_type sampling) const;
  double phisize(sampling_type sampling) const;
  void setetasize(sampling_type sampling, double size);
  void setphisize(sampling_type sampling, double size) ;

  double energy_max(sampling_type sampling) const;
  double etamax(sampling_type sampling) const;
  double phimax(sampling_type sampling) const;
  void setenergymax(sampling_type sampling, double m) ;
  void setetamax(sampling_type sampling, double m);
  void setphimax(sampling_type sampling, double m) ;

  double etaBE(int sampling) const;
  double phiBE(int sampling) const;
  double energyBE(int sampling) const;

  bool inBarrel() const;
  bool inEndcap() const;
  void setBarrel(bool barrel);
  void setEndcap(bool endcap);

  void addBadChannel(const CaloClusterBadChannelData& badChannel);
  void resetBadChannel();

  typedef std::vector<CaloClusterBadChannelData> badChannelList;
  const badChannelList* getBadChannel() const;

  bool containsBadCells() const;

  void calculateKine(const bool useweight=true, const bool updateLayers=true );
 
 protected:
 
  friend class CaloClusterStoreHelper;
  friend struct CaloClusterSignalState;
 
  typedef 
  CaloClusterLinkTemplate<CaloShowerContainer>::link_type data_link_type;

  static const double m_errorValue;

  CaloSamplingData                    m_dataStore;   
  CaloClusterMomentStore              m_momentStore; 

  //  CaloShower* m_dataStorePointer;
  bool m_ownDataStore;

  data_link_type m_dataLink;  

  CaloShower* m_shower;

  double m_basicSignal;

  double m_time;

  unsigned int m_samplingPattern;

  virtual void updateKine(const CaloCell* theCell, double weight);
 
  double variableBE(const variable_type& theVariable,
                    const int& samplingIndex) const;
 
  CaloSamplingData* getDataStore(const variable_type& theVariable,
                                 bool useLink=true);
  const CaloSamplingData* getDataStore(const variable_type&
                                       theVariable,
                                       bool useLink=false) const;
 
  CaloClusterMomentStore* 
  getMomentStore(bool useLink=true);
  const CaloClusterMomentStore* 
  getMomentStore(bool useLink=false) const;
  const CaloClusterMomentStore* 
  getMomentStore(const moment_type& theMoment, bool useLink=false) const;
  CaloClusterMomentStore*
  getMomentStore(const moment_type& theMoment, bool useLink=true);
  bool
  getMomentStorePtrs(const CaloClusterMomentStore*& pFirstStore,
             const CaloClusterMomentStore*& pSecndStore,
             bool useLink) const;
    //DEBUG          const std::string& mode) const;

  bool setDataLink(CaloShowerContainer* pDataLink);

  bool setStores(CaloShower* pData,CaloCellLink* pLink,bool ownStores=true);

  bool setDataStore(CaloShower* pData,bool ownStores=true);
 
 private:

  template <class InputIterator>
  void
  maybeSetVariable(variable_type varType, 
                   InputIterator beg,
                   InputIterator end);
 
  bool m_barrel; 
  bool m_endcap;

  unsigned int m_clusterSize;
 
  // ... RAW eta,phi of cluster seed 
  double m_eta0; 
  double m_phi0;   

  double m_timeNorm;

  double m_posNorm;

  std::vector<double> m_posSamNorm;

  int m_nBarrel;
  int m_nEndcap;
  unsigned int m_lockPattern;
 
  badChannelList m_badChannelData;

  // Signal States //
  
 public:
  
  signalstate_t signalState() const;
  signalstate_t defaultSignalState() const;
  
  virtual bool hasSignalState(signalstate_t s) const;
  virtual bool isAtSignalState(signalstate_t s) const;
 
 protected:

  virtual bool setSignalState(signalstate_t s);

  virtual void resetSignalState();
  
  bool setDefaultSignalState(signalstate_t s);
 
 private:

  double getRawE()   const;
  double getRawEta() const;
  double getRawPhi() const;
  double getRawM()   const;

  double getCalE()   const;
  double getCalEta() const;
  double getCalPhi() const;
  double getCalM()   const;

  double getAltE()   const;
  double getAltEta() const;
  double getAltPhi() const;
  double getAltM()   const;

  void setRawE(double e);
  void setRawEta(double eta);
  void setRawPhi(double phi);
  void setRawM(double m);

  void setCalE(double e);
  void setCalEta(double eta);
  void setCalPhi(double phi);
  void setCalM(double m);

  void setAltE(double e);
  void setAltEta(double eta);
  void setAltPhi(double phi);
  void setAltM(double m);
 
  // Cint has trouble with the types of these members.
  // Just hide them from reflex for now.
#ifndef __REFLEX__
  GET_VALUE m_getE{};
  GET_VALUE m_getEta{};
  GET_VALUE m_getPhi{};
  GET_VALUE m_getM{};

  SET_VALUE m_setE{};
  SET_VALUE m_setEta{};
  SET_VALUE m_setPhi{};
  SET_VALUE m_setM{};
#endif

  signalstate_t m_signalState;
  signalstate_t m_defSigState;

  double m_rawE;
  double m_rawEta;
  double m_rawPhi;
  double m_rawM;

  double m_altE;
  double m_altEta;
  double m_altPhi;
  double m_altM;

  bool setStateRaw();

  bool setStateCal();

  bool setStateAlt();
 
public:
  // For interactive debugging from python --- 
  // should not be used from client code.
  data_link_type getMomentStoreLink () const
  { return m_dataLink; }
 
private:
  CaloCluster& operator= (const CaloCluster&);
 
  friend class CaloClusterContainerCnv_p1;
  friend class CaloClusterContainerCnv_p2;
  friend class CaloClusterContainerCnv_p3;
  friend class CaloClusterContainerCnv_p4;
  friend class CaloClusterContainerCnv_p5;
  friend class CaloClusterContainerCnv_p6;
  friend class CaloClusterContainerCnv_p7;
  friend class CaloClusterContainerCnvTest_p6;
  friend class CaloClusterContainerCnvTest_p7;
 
};

//                           Inline Funtions                                 //

// Kinematics //
 
#ifndef __REFLEX__
inline double CaloCluster::e()   const 
{ return (this->*m_getE)(); }
inline double CaloCluster::eta() const
{
  return (this->*m_getEta)(); 
}
inline double CaloCluster::phi() const
{
  return (this->*m_getPhi)(); 
}
 
inline double CaloCluster::m()   const
{ return (this->*m_getM)(); }
 
inline void CaloCluster::setE(double e) 
{ (this->*m_setE)(e); }
inline void CaloCluster::setEta(double eta)
{ (this->*m_setEta)(eta); }
inline void CaloCluster::setPhi(double phi)
{ (this->*m_setPhi)(phi); }
inline void CaloCluster::setM(double m)
{ (this->*m_setM)(m); }  
#endif
 
inline double CaloCluster::e(signalstate_t s)   const 
{
  if (!hasSignalState(s)) return m_errorValue;
  switch (s) {
  case statename_t::CALIBRATED:
    return P4EEtaPhiM::e();
  case statename_t::UNCALIBRATED:
    return m_rawE;
  case statename_t::ALTCALIBRATED:
    return m_altE;
  default:
    return m_errorValue;
  }
}
 
 
inline double CaloCluster::eta(signalstate_t s) const
{
  if (!hasSignalState(s)) return m_errorValue;
  switch (s) {
  case statename_t::CALIBRATED:
    return P4EEtaPhiM::eta();
  case statename_t::UNCALIBRATED:
    return m_rawEta;
  case statename_t::ALTCALIBRATED:
    return m_altEta;
  default:
    return m_errorValue;
  }
}
 
 
inline double CaloCluster::phi(signalstate_t s) const
{
  if (!hasSignalState(s)) return m_errorValue;
  switch (s) {
  case statename_t::CALIBRATED:
    return P4EEtaPhiM::phi();
  case statename_t::UNCALIBRATED:
    return m_rawPhi;
  case statename_t::ALTCALIBRATED:
    return m_altPhi;
  default:
    return m_errorValue;
  }
}
 
 
inline double CaloCluster::m(signalstate_t s)   const
{
  if (!hasSignalState(s)) return m_errorValue;
  switch (s) {
  case statename_t::CALIBRATED:
    return P4EEtaPhiM::m();
  case statename_t::UNCALIBRATED:
    return m_rawM;
  case statename_t::ALTCALIBRATED:
    return m_altM;
  default:
    return m_errorValue;
  }
}
 
 
inline void CaloCluster::set4Mom(const I4Momentum* const pMom)
{
  this->setE(pMom->e());
  this->setEta(pMom->eta());
  this->setPhi(pMom->phi());
  this->setM(pMom->m());
}
 
inline void CaloCluster::set4Mom(const I4Momentum& rMom)
{ this->set4Mom(&rMom); }
 
inline void CaloCluster::set4Mom(const CLHEP::HepLorentzVector& rVec)
{
  this->setE(rVec.e());
  this->setEta(rVec.eta());
  this->setPhi(rVec.phi());
  this->setM(rVec.m());
}
 
inline CaloCluster::signalstate_t CaloCluster::signalState() const
{ return m_signalState; }
inline CaloCluster::signalstate_t CaloCluster::defaultSignalState() const
{ return m_defSigState; }
 
inline bool CaloCluster::setDefaultSignalState(signalstate_t s) 
{
  m_defSigState = s;
  return this->setSignalState(s);
}

// Basic Signal and Time //
 
inline double 
CaloCluster::getBasicEnergy() const { return m_basicSignal; }
inline void 
CaloCluster::setBasicEnergy(double theEnergy) { m_basicSignal = theEnergy; }
 
inline double
CaloCluster::getTime() const { return m_time; }
 
inline void
CaloCluster::setTime(double theTime) { m_time = theTime; }
 
inline void
CaloCluster::setClusterSize(unsigned int theClusterSize) { m_clusterSize = theClusterSize; }
 
inline unsigned int
CaloCluster::getClusterSize() const { return m_clusterSize; }

// Configuration //
 
inline bool
CaloCluster::setStores(CaloShower* pData, CaloCellLink* pLink, bool ownStores)
{
  return ( this->setDataStore(pData,ownStores) &&  
       this->setLinkStore(pLink,ownStores) );
}
 
inline bool
CaloCluster::setDataStore(CaloShower* pData,bool ownStores) 
{ 
  //  m_dataStorePointer = pData;
  m_ownDataStore = ownStores;
  m_dataLink.setElement(pData);
  m_shower = pData;
  return m_dataLink.isValid(); 
} 

// Tags //

inline bool CaloCluster::inBarrel() const { return m_barrel; }
inline bool CaloCluster::inEndcap() const { return m_endcap; }
inline void CaloCluster::setBarrel(bool barrel) { m_barrel = barrel; }
inline void CaloCluster::setEndcap(bool endcap) { m_endcap = endcap; }
inline bool 
CaloCluster::is_valid_sampling(const sampling_type& sampling) const
{ return this->isEMSampling(sampling); }
 
inline bool CaloCluster::isEMSampling(const sampling_type& theSampling) const
{ return CaloSamplingHelper::isEMSampling(theSampling); }
 
inline bool CaloCluster::hasSampling(const sampling_type& theSampling) const
{
  unsigned int bitPattern = CaloSamplingHelper::getSamplingBit(theSampling);
  return (m_samplingPattern & bitPattern) == bitPattern;
}

// Get Energy/Eta/Phi in Samplings //

inline unsigned int CaloCluster::nSamples() const 
{ return CaloSampling::getNumberOfSamplings(); }

inline double CaloCluster::eSample(sampling_type theSampling) const
{ return this->getVariable(CaloVariableType::ENERGY,theSampling,true); }

inline void CaloCluster::getEInSamples(std::vector<double>& theEnergies) const
{ this->getVariable(CaloVariableType::ENERGY,theEnergies,true); }

inline double CaloCluster::etaSample(sampling_type theSampling) const
{ return this->getVariable(CaloVariableType::ETA,theSampling,true); }

inline void CaloCluster::getEtaInSamples(std::vector<double>& theEtas) const
{ this->getVariable(CaloVariableType::ETA,theEtas,true); }

inline double CaloCluster::phiSample(sampling_type theSampling) const
{ return this->getVariable(CaloVariableType::PHI,theSampling,true); }

inline void CaloCluster::getPhiInSamples(std::vector<double>& thePhis) const
{ this->getVariable(CaloVariableType::PHI,thePhis,true); }

// Set Methods for Sampling Kinematic //

inline void CaloCluster::setenergy(sampling_type theSampling, double theEnergy)
{ this->setVariable(CaloVariableType::ENERGY,theSampling,theEnergy,true); }

inline void CaloCluster::setEInSamples(const std::vector<double>& theEnergies)
{ this->setVariable(CaloVariableType::ENERGY,theEnergies,true); }

inline void CaloCluster::seteta(sampling_type sampling, double eta) 
{ this->setVariable(CaloVariableType::ETA,sampling,eta,true); }

inline void CaloCluster::setEtaInSamples(const std::vector<double>& theEtas)
{ this->setVariable(CaloVariableType::ETA,theEtas,true); }

inline void CaloCluster::setphi(sampling_type sampling, double phi) 
{ this->setVariable(CaloVariableType::PHI,sampling,phi,true); }

inline void CaloCluster::setPhiInSamples(const std::vector<double>& thePhis)
{ this->setVariable(CaloVariableType::PHI,thePhis,true); }

// Energy/eta/phi of Maximum Signal Cell //
 
inline double CaloCluster::energy_max(sampling_type sampling) const
{
  return this->isEMSampling(sampling)
    ? this->getVariable(CaloVariableType::MAX_ENERGY,sampling,true)
    : double(0);
}
 
inline double CaloCluster::etamax(sampling_type sampling) const
{
  return this->isEMSampling(sampling)
    ? this->getVariable(CaloVariableType::MAX_ETA,sampling,true)
    : double(0);
}
 
inline double CaloCluster::phimax(sampling_type sampling) const
{
  return this->isEMSampling(sampling)
    ? this->getVariable(CaloVariableType::MAX_PHI,sampling,true)
    : double(0);
}

// Cluster Sizes in Samplings //
 
inline double CaloCluster::etasize(sampling_type sampling) const
{
  return this->isEMSampling(sampling)
    ? this->getVariable(CaloVariableType::DELTA_ETA,sampling,true)
    : double(0);
}
 
inline double CaloCluster::phisize(sampling_type sampling) const
{
  return this->isEMSampling(sampling)
    ? this->getVariable(CaloVariableType::DELTA_PHI,sampling,true)
    : double(0);
}

// Seeds //

inline double CaloCluster::eta0() const { return m_eta0; }

inline double CaloCluster::phi0() const { return m_phi0; }

// Kinematics in Barrel/EndCap EM //
 
inline double CaloCluster::etaBE(int sam) const
{ return this->variableBE(CaloVariableType::ETA,sam); }
 
inline double CaloCluster::phiBE(int sam) const
{ return this->variableBE(CaloVariableType::PHI,sam); }
 
inline double CaloCluster::energyBE(int sam) const
{ return this->variableBE(CaloVariableType::ENERGY,sam); }

// Moments //
 
inline CaloClusterMoment 
CaloCluster::getMoment(const moment_type& momType,bool useLink) const {  
  CaloClusterMoment value(0.0);
  if (!this->retrieveMoment(momType,value,useLink))
    value = 0; // Make coverity happy.
  return value;
}
 
 
inline CaloClusterMoment
CaloCluster::getMoment(const moment_iterator& rMomIter) const
{ return rMomIter.getMoment(); }
 
inline double
CaloCluster::getMomentValue(const moment_type& momType,bool useLink) const {
  double value(0.0);
  if (!this->retrieveMoment(momType,value,useLink))
    value = 0; // Make coverity happy.
  return value;
}
 
 
 
inline double
CaloCluster::getMomentValue(const moment_iterator& momIter) const
{ return (momIter.getMoment()).getValue(); }
 
inline CaloClusterMoment::MomentType
CaloCluster::getMomentType(const moment_iterator& rMomIter) const
{ return rMomIter.getMomentType(); }

// Internal Stores //
 
// set data link store
inline bool CaloCluster::setDataLink(CaloShowerContainer* pDataLink)
{
  if (!pDataLink) 
    return false;
  CaloShower* pData = m_shower;
  m_ownDataStore = !pDataLink->ownElements();
  return CaloClusterLinkTemplate<CaloShowerContainer>::setLink(pDataLink,
                                   pData,
                                   m_dataLink);
}

// Variable Locking //
 
// check if variable is locked
inline bool CaloCluster::isLocked(const variable_type& varType) const
{
  unsigned int bitPattern(CaloVariableType::getVariableBit(varType));
  return this->isLocked(bitPattern); 
}
inline bool CaloCluster::isLocked(const unsigned int& bitPattern) const
{
  return ( m_lockPattern & bitPattern ) == bitPattern;
}
 
// check if all variables are locked
inline bool CaloCluster::allLocked() const
{
  return 
    ( m_lockPattern & CaloVariableType::getAllVariableBits() ) ==
    CaloVariableType::getAllVariableBits();
}

//  containsBadCell
 
inline bool CaloCluster::containsBadCells() const {
  return !(this->getBadChannel()->empty());
}
 
// internal functions
 
 
// Override the default hash function for NavigationToken so that
// we'll get reproducible ordering.
inline
std::size_t navigationHash (const CaloCluster* p)
{
  return static_cast<std::size_t> (static_cast<long long>(p->energy_nonvirt()));
}
 
 
template <class InputIterator>
void CaloCluster::maybeSetVariable (variable_type varType,
                                    InputIterator beg,
                                    InputIterator end)
{
  if (this->isLocked (varType)) return;
  CaloSamplingData* p = this->getDataStore (varType, true);
  if (p)
    p->storeData (varType, beg, end);
}
 
 
 
// check if variable is locked

#endif // CALOCLUSTER_H