CaloCalibrationHit.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// CaloCalibrationHit
// 26-Jan-2004 William Seligman
 
// This class defines a "calibration" hit associated with the Calo
// simulation.
 
#ifndef CaloSimEvent_CaloCalibrationHit_h
#define CaloSimEvent_CaloCalibrationHit_h
 
#include "GeneratorObjects/HepMcParticleLink.h"
#include "Identifier/Identifier.h"
#include "TruthUtils/MagicNumbers.h"
 
class CaloCalibrationHit
 
{
 public:
  CaloCalibrationHit(Identifier id, double energyEM, double energyNonEM,
                     double energyInvisible, double energyEscaped)
      : m_ID(id),
        m_energy0(energyEM),
        m_energy1(energyNonEM),
        m_energy2(energyInvisible),
        m_energy3(energyEscaped) {}

  CaloCalibrationHit(Identifier id, double energyEM, double energyNonEM,
                     double energyInvisible, double energyEscaped, int barcode,
                     int uniqueID = HepMC::INVALID_PARTICLE_ID)
      : m_ID(id),
        m_energy0(energyEM),
        m_energy1(energyNonEM),
        m_energy2(energyInvisible),
        m_energy3(energyEscaped),
        m_barcode(barcode),
        m_uniqueID(uniqueID) {
    if (m_barcode == HepMC::UNDEFINED_ID) {
      m_uniqueID = HepMC::UNDEFINED_ID;
    }  // No link to a truth particle
    else if (m_uniqueID == HepMC::INVALID_PARTICLE_ID &&
             m_barcode != HepMC::INVALID_PARTICLE_ID) {
      m_partLink = std::make_unique<HepMcParticleLink>(
          m_barcode, 0, HepMcParticleLink::IS_POSITION,
          HepMcParticleLink::IS_BARCODE);  // FIXME is barcode-based
    }
  }

  CaloCalibrationHit() : m_ID(Identifier()) {}

  CaloCalibrationHit(const CaloCalibrationHit& cchSource)
      : m_ID(cchSource.m_ID),
        m_energy0(cchSource.m_energy0),
        m_energy1(cchSource.m_energy1),
        m_energy2(cchSource.m_energy2),
        m_energy3(cchSource.m_energy3),
        m_barcode(cchSource.m_barcode),
        m_uniqueID(cchSource.m_uniqueID) {
    if (m_barcode == HepMC::UNDEFINED_ID) {
      m_uniqueID = HepMC::UNDEFINED_ID;
    }  // No link to a truth particle
    else if (m_uniqueID == HepMC::INVALID_PARTICLE_ID &&
             m_barcode != HepMC::INVALID_PARTICLE_ID) {
      m_uniqueID =
          cchSource.particleUID();  // Try a look-up via HepMcParticleLink
    }
  }

  CaloCalibrationHit& operator=(const CaloCalibrationHit& cchSource) {
    if (this == &cchSource)
      return *this;
    m_ID = cchSource.m_ID;
    m_energy0 = cchSource.m_energy0;
    m_energy1 = cchSource.m_energy1;
    m_energy2 = cchSource.m_energy2;
    m_energy3 = cchSource.m_energy3;
    m_barcode = cchSource.m_barcode;
    m_uniqueID = cchSource.m_uniqueID;
    if (m_barcode == HepMC::UNDEFINED_ID) {
      m_uniqueID = HepMC::UNDEFINED_ID;
    }  // No link to a truth particle
    else if (m_uniqueID == HepMC::INVALID_PARTICLE_ID &&
             m_barcode != HepMC::INVALID_PARTICLE_ID) {
      m_uniqueID =
          cchSource.particleUID();  // Try a look-up via HepMcParticleLink
    }
    return *this;
  }

  virtual ~CaloCalibrationHit() {}

  Identifier cellID() const { return m_ID; }

  double energyEM() const { return m_energy0; }

  double energyNonEM() const { return m_energy1; }

  double energyInvisible() const { return m_energy2; }

  double energyEscaped() const { return m_energy3; }

  double energyTotal() const {
    return m_energy0 + m_energy1 + m_energy2 + m_energy3;
  }

  double energy(unsigned int i) const {
    switch (i) {
      case 0:
        return m_energy0;
      case 1:
        return m_energy1;
      case 2:
        return m_energy2;
      case 3:
        return m_energy3;
      default:
        return 0.;
    }
  }

  int particleID() const { return m_barcode; }

  int barcode() const { return particleID(); }

  int particleUID() const {
    if (m_uniqueID == HepMC::INVALID_PARTICLE_ID && m_partLink) {
      return m_partLink->id();
    } else {
      return m_uniqueID;
    }
  }

  double operator()(unsigned int i) const { return energy(i); }

  bool Less(const CaloCalibrationHit* h) const {
    if (m_ID != h->m_ID) {
      return m_ID < h->m_ID;
    } else {
      if (particleID() == HepMC::INVALID_PARTICLE_ID ||
          h->particleUID() == HepMC::INVALID_PARTICLE_ID) {
        return m_barcode < h->m_barcode;
      } else {
        return particleUID() < h->particleUID();
      }
    }
  }

  bool Equals(const CaloCalibrationHit& h) const {
    bool equal = (m_ID == h.m_ID);
    const bool validBarcode(particleID() != HepMC::INVALID_PARTICLE_ID &&
                            h.particleID() != HepMC::INVALID_PARTICLE_ID);
    const bool validUID(particleUID() != HepMC::INVALID_PARTICLE_ID &&
                        h.particleUID() != HepMC::INVALID_PARTICLE_ID);
    equal &= (validBarcode || validUID);
    if (validBarcode) {
      equal &= (m_barcode == h.m_barcode);
    }
    // Corrected bug: was comparing m_barcode instead of m_uniqueID
    if (validUID) {
      equal &= (particleUID() == h.particleUID());
    }
    return equal;
  };

  bool Equals(const CaloCalibrationHit* h) const { return Equals(*h); }

  void Add(const CaloCalibrationHit* h) {
    m_energy0 += h->m_energy0;
    m_energy1 += h->m_energy1;
    m_energy2 += h->m_energy2;
    m_energy3 += h->m_energy3;
  }
 
 private:
  Identifier m_ID;

  double m_energy0{0.};
  double m_energy1{0.};
  double m_energy2{0.};
  double m_energy3{0.};

  int m_barcode{HepMC::UNDEFINED_ID};
  int m_uniqueID{HepMC::UNDEFINED_ID};
  std::unique_ptr<HepMcParticleLink>
      m_partLink{};  // nullptr unless object was produced by reading
                     // TrackRecord_p1.
};
 
#endif  // CaloSimEvent_CaloCalibrationHit_h