CaloCell.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOEVENT_CALOCELL_H
#define CALOEVENT_CALOCELL_H

 
//  Update:
//    Jan 10 2001 HMA
//          ordor of static/virtual/const
//    Nov 12 2001 EDF
//          Inherit from Navigible.  Now CaloCell has a pure virtual method
//          and can not be instantiated directly.
//    June 13 2003 DR delegate to CaloDetDescrElement
//    Feb  25 2004 DR CaloGain data member
//    Apr  01 2004 PL new navigation and clean-up
//
 
#include "EventKernel/INavigable4Momentum.h"
 
#include "Navigation/NavigableTerminalNode.h"
 
#include "Identifier/Identifier.h"
#include "CaloIdentifier/CaloGain.h"
#include "FourMom/P4EEtaPhiMBase.h"
#include <math.h>
#include <iostream>
#include <functional>
#include <memory>
 
//class CaloDetDescrElement;
#include "CaloDetDescr/CaloDetDescrElement.h"
#include "GeoPrimitives/GeoPrimitives.h"
 
 
class CaloCell: virtual public P4EEtaPhiMBase,
        virtual public INavigable4Momentum,
        public NavigableTerminalNode
{
public:

  CaloCell();

  CaloCell(const CaloDetDescrElement* caloDDE,
           float energy,
           float time,
           double quality,
           CaloGain::CaloGain gain);

  CaloCell(const CaloDetDescrElement* caloDDE,
           float energy,
           float time,
           uint16_t quality,
           uint16_t provenance,
           CaloGain::CaloGain gain);
 

  CaloCell(const CaloDetDescrElement* caloDDE,
           const Identifier & ID,
           float energy,
           float time,
           double quality,
           CaloGain::CaloGain gain);

  CaloCell(const CaloDetDescrElement* caloDDE,
           const Identifier & ID,
           float energy,
           float time,
           uint16_t quality,
           uint16_t provenance,
           CaloGain::CaloGain gain);
 
  CaloCell(const CaloCell&) = default;
  CaloCell(CaloCell&&) = default;
 
  CaloCell& operator= (const CaloCell&) = default;
  CaloCell& operator= (CaloCell&&) = default;
 

  virtual ~CaloCell ();

  void assign (const CaloDetDescrElement* caloDDE,
               const Identifier & ID,
               float energy,
               float time,
               uint16_t quality,
               uint16_t provenance,
               CaloGain::CaloGain gain);

  double energy () const;


  virtual double phi    () const override final;
  virtual double eta    () const override final;
  virtual double sinTh  () const override final;
  virtual double cosTh  () const override final;
  virtual double sinPhi  () const override final;
  virtual double cosPhi  () const override final;
  virtual double cotTh  () const override final;
  virtual double m      () const override final;
  virtual double e      () const override final;
  virtual double et     () const override final;


  float x      () const;
  float y      () const;
  float z      () const;

  Identifier    ID     () const ;

  float        time   () const;
  uint16_t     quality() const;
  uint16_t     provenance() const;
  CaloGain::CaloGain  gain()  const;

  const CaloDetDescrElement* caloDDE() const;
  void setCaloDDE (const CaloDetDescrElement* caloDDE);
  void addEnergy (float energy);
  void addTime (float delta);
  void setProvenance (uint16_t prov);
  void setGain(CaloGain::CaloGain gain=CaloGain::INVALIDGAIN);
  void setQuality (uint16_t quality);
  void setQuality (double quality);


  virtual bool badcell() const;
  virtual void setEnergy (float energy);
  virtual void scaleEnergy (float scale);
  virtual void setTime (float time);

  virtual void set4Mom (const I4Momentum * const theI4Mom ) override final;

  virtual void set4Mom (const I4Momentum & theI4Mom) override final;

  virtual void set4Mom (const CLHEP::HepLorentzVector & theHlv ) override final;
 

  virtual std::unique_ptr<CaloCell> clone() const;

  void set (const CaloDetDescrElement* caloDDE,
            const Identifier& ID);

  void set (float energy,
            float time,
            uint16_t quality,
            uint16_t provenance,
            CaloGain::CaloGain gain);
 

  void set (float energy,
            float time,
            double quality,
            CaloGain::CaloGain gain);
 
 
protected:

  float      m_energy  ;
  float      m_time    ;
 
  // Reflex doesn't handle unions completely correctly.
  // If you have a union as a data member, it will print a warning
  // at runtime.  So, hide the union from reflex.  (Only m_quality is used
  // in inlined code.)
#ifdef __REFLEX__
    int  m_quality ;
#   define m_qualProv ((uint16_t*)&m_quality)
#   define m_tileQual ((uint8_t*)&m_quality)
#else
  union {
    int  m_quality = 0 ;
    uint16_t m_qualProv[2];
    uint8_t m_tileQual[4];
  };
#endif
  Identifier  m_ID      ;
  CaloGain::CaloGain m_gain ;
  const CaloDetDescrElement* m_caloDDE  ;
 
};
 
 
// inlines
 
inline CaloCell::CaloCell()
    :
    m_energy(0),
    m_time(0),
    m_quality(0),
    m_gain(CaloGain::UNKNOWNGAIN),
    m_caloDDE(0)
{}
 
 
#ifndef __REFLEX__
inline
void CaloCell::assign(const CaloDetDescrElement* caloDDE,
                        const Identifier & ID,
                        float   energy,
                        float   time,
                        uint16_t   quality,
                        uint16_t   provenance,
                        CaloGain::CaloGain gain)
{
  m_energy = energy;
  m_time = time;
  m_ID = ID;
  m_gain = gain;
  m_caloDDE = caloDDE;
  m_qualProv[0]=quality;
  m_qualProv[1]=provenance;
}
#endif
 
 
 
inline Identifier CaloCell::ID() const {
  return m_ID;
}
 

struct CaloCellIDFcn {
  std::size_t operator() (const CaloCell* p) const
  {
    return p->ID().get_identifier32().get_compact();
  }
};
 
 
// Make this the default hash function for NavigationToken.
inline
std::size_t navigationHash (const CaloCell* p)
{
  return p->ID().get_identifier32().get_compact();
}
 
inline
const CaloDetDescrElement* CaloCell::caloDDE() const{
   return m_caloDDE;
}
 
 
inline
double CaloCell::energy() const
{
  return m_energy;
}
 
inline
double CaloCell::e() const
{
  return m_energy;
}
 
 
inline
double CaloCell::m() const
{
  // zero mass by convention
  return 0.;
}
 
 
inline
uint16_t CaloCell::quality() const
{
  return m_qualProv[0];
}
 
inline
uint16_t CaloCell::provenance() const
{
  // cppcheck-suppress objectIndex
  return m_qualProv[1];
}
 
inline
CaloGain::CaloGain CaloCell::gain() const
{
  return m_gain;
}
 
 
inline
float CaloCell::time() const
{
  return m_time;
}
 
 
inline
double CaloCell::phi() const
{
  return m_caloDDE->phi();
}
 
 
inline
double CaloCell::eta() const
{
  return m_caloDDE->eta();
}
 
 
inline
double CaloCell::sinTh() const
{
  return m_caloDDE->sinTh();
}
 
 
inline
double CaloCell::cosTh() const
{
  return m_caloDDE->cosTh();
}
 
 
inline
double CaloCell::cotTh() const
{
  return m_caloDDE->cotTh();
}
 
 
inline
double CaloCell::sinPhi() const
{
  return m_caloDDE->sinPhi();
}
 
 
inline
double CaloCell::cosPhi() const
{
  return m_caloDDE->cosPhi();
}
 
inline double
CaloCell::et() const
{
  return this->e() * this->sinTh();
}
 
inline
float CaloCell::x() const
{
  return m_caloDDE->x();
}
 
 
inline
float CaloCell::y() const
{
  return m_caloDDE->y();
}
 
 
inline
float CaloCell::z() const
{
  return m_caloDDE->z();
}
 
inline
void CaloCell::addEnergy(float energy) {
  m_energy += energy;
}
 
inline
void CaloCell::addTime (float delta)
{
  m_time += delta;
}
 
inline
void CaloCell::setQuality (uint16_t quality)
{
  m_qualProv[0] = quality;
}
 
inline
void CaloCell::setQuality (double quality)
{
  m_quality = (int)(quality);
}
 
inline
void CaloCell::setEnergy (float energy)
{
  m_energy = energy ;
}
 
inline
void CaloCell::scaleEnergy (float scale)
{
  m_energy *= scale ;
}
 
inline
void CaloCell::setTime (float time)
{
  m_time = time;
}
 
inline
void CaloCell::setProvenance (uint16_t prov)
{
  // cppcheck-suppress objectIndex
  m_qualProv[1] = prov;
}
 
inline
void CaloCell::setGain(CaloGain::CaloGain gain)
{
  m_gain = gain;
}
 
inline
void CaloCell::setCaloDDE(const CaloDetDescrElement* caloDDE) {
  m_caloDDE = caloDDE;
  if (m_caloDDE) {
    m_ID = m_caloDDE->identify();
  }
}
 
inline
void CaloCell::set(const CaloDetDescrElement* caloDDE,
                   const Identifier& ID) {
  m_ID = ID;
  m_caloDDE = caloDDE;
}
 
#endif