Hit.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
#ifndef ALICEO2_FOCAL_HIT_H
#define ALICEO2_FOCAL_HIT_H
 
#include <iosfwd>
#include "SimulationDataFormat/BaseHits.h"
#include "CommonUtils/ShmAllocator.h"
#include <boost/container_hash/hash.hpp>
 
namespace o2::focal
{
 
class Hit : public o2::BasicXYZEHit<float>
{
 public:
  enum class Subsystem_t {
    EPADS,   
    EPIXELS, 
    HCAL,    
    UNKNOWN  
  };
 
  struct HitID {
    int mParentID;   
    uint8_t mRow;    
    uint8_t mColumn; 
    uint8_t mLayer;  
 
    bool operator==(const HitID& other) const
    {
      return mParentID == other.mParentID && mRow == other.mRow && mColumn == other.mColumn && mLayer == other.mLayer;
    }
    friend std::ostream& operator<<(std::ostream& stream, const Hit::HitID& channel);
  };
 
  struct HitIDHasher {
 
    size_t operator()(const HitID& s) const
    {
      std::size_t seed = 0;
      boost::hash_combine(seed, s.mParentID);
      boost::hash_combine(seed, s.mRow);
      boost::hash_combine(seed, s.mColumn);
      boost::hash_combine(seed, s.mLayer);
      return seed;
    }
  };
 
  Hit() = default;
 
  Hit(int primary, int trackID, int detID, Subsystem_t subsystem, double initialEnergy, const math_utils::Point3D<float>& pos,
      double tof, double eLoss);
 
  ~Hit() = default;
 
  bool operator==(const Hit& other) const;
 
  bool operator<(const Hit& other) const;
 
  Hit& operator+=(const Hit& other);
 
  Subsystem_t getSubsystem() const { return mSubSystem; }
 
  bool isPixelHit() const { return mSubSystem == Subsystem_t::EPIXELS; }
 
  bool isPadHit() const { return mSubSystem == Subsystem_t::EPADS; }
 
  bool isHCALHit() const { return mSubSystem == Subsystem_t::HCAL; }
 
  int getPrimary() const { return mPrimary; }
 
  double getInitialEnergy() const { return mInitialEnergy; }
 
  void setInitialEnergy(double energy) { mInitialEnergy = energy; }
 
  void setPrimary(int primary) { mPrimary = primary; }
 
  void printStream(std::ostream& stream) const;
 
 private:
  Subsystem_t mSubSystem = Subsystem_t::UNKNOWN; 
  int mPrimary = -1;                             
  double mInitialEnergy = 0.;                    
 
  ClassDefNV(Hit, 1);
};
 
Hit operator+(const Hit& lhs, const Hit& rhs);
 
std::ostream& operator<<(std::ostream& stream, const Hit& point);
} // namespace o2::focal
 
#ifdef USESHM
namespace std
{
template <>
class allocator<o2::focal::Hit> : public o2::utils::ShmAllocator<o2::focal::Hit>
{
};
} // namespace std
#endif
#endif