ParticleHit.h

Go to the documentation of this file.

/*
 * ParticleHit.h
 *
 *  Created on: 3 Dec 2018
 *      Author: Nicola Mori
 */
 
#ifndef HERD_PARTICLEHIT_H_
#define HERD_PARTICLEHIT_H_
 
// HerdSoftware headers
#include "herd/analysis/common/DefaultValues.h"
#include "herd/analysis/dataobjects/Momentum.h"
#include "herd/analysis/dataobjects/Point.h"
 
#ifdef HS_USE_ROOT
#include "Rtypes.h"
#endif
 
// c++ headers
#include <array>
 
namespace Herd {
 
class ParticleHit {
public:
  ParticleHit()
      : DEFAULT_INIT(_particlePdg), DEFAULT_INIT(_eDep), DEFAULT_INIT(_entranceEnergy), DEFAULT_INIT(_entrancePoint),
        DEFAULT_INIT(_exitPoint), DEFAULT_INIT(_trackID), DEFAULT_INIT(_parentTrackID), DEFAULT_INIT(_time) {}
 
  ParticleHit(int particlePDG, float eDep, float entranceEnergy, Point entrancePoint, Point exitPoint,
              Momentum entranceMomentum, int trackID, int parentTrackID, float time)
      : _particlePdg(particlePDG), _eDep(eDep), _entranceEnergy(entranceEnergy),
        _entrancePoint(std::move(entrancePoint)), _exitPoint(std::move(exitPoint)),
        _entranceMomentum(std::move(entranceMomentum)), _trackID{trackID}, _parentTrackID{parentTrackID}, _time{time} {}
 
  virtual ~ParticleHit() = default;
 
  [[nodiscard]] float EDep() const { return _eDep; }
  void SetEDep(float eDep) { _eDep = eDep; }
 
  [[nodiscard]] const Point &EntrancePoint() const { return _entrancePoint; }
  void SetEntrancePoint(Point entrancePoint) { _entrancePoint = std::move(entrancePoint); }
 
  [[nodiscard]] const Point &ExitPoint() const { return _exitPoint; }
  void SetExitPoint(Point exitPoint) { _exitPoint = std::move(exitPoint); }
 
  [[nodiscard]] const Momentum &EntranceMomentum() const { return _entranceMomentum; }
  void SetEntranceMomentum(Momentum entranceMomentum) { _entranceMomentum = std::move(entranceMomentum); }
 
  [[nodiscard]] float EntranceEnergy() const { return _entranceEnergy; }
  void SetEntranceEnergy(float entranceEnergy) { _entranceEnergy = entranceEnergy; }
 
  [[nodiscard]] int ParticlePDG() const { return _particlePdg; }
  void SetParticlePDG(int particlePdg) { _particlePdg = particlePdg; }
 
  [[nodiscard]] int TrackID() const { return _trackID; }
 
  void SetTrackID(int trackID) { _trackID = trackID; }
 
  [[nodiscard]] int ParentTrackID() const { return _parentTrackID; }
 
  void SetParentTrackID(int parentTrackID) { _parentTrackID = parentTrackID; }
 
  [[nodiscard]] float Time() const { return _time; }
 
  void SetTime(float time) { _time = time; }
 
  bool operator==(const ParticleHit &rhs) const {
    return _entrancePoint == rhs._entrancePoint && _exitPoint == rhs._exitPoint &&
           _entranceMomentum == rhs._entranceMomentum && _eDep == rhs._eDep && _entranceEnergy == rhs._entranceEnergy &&
           _particlePdg == rhs._particlePdg && _time == rhs._time;
  }
 
private:
  int _particlePdg;           
  float _eDep;                
  float _entranceEnergy;      
  Point _entrancePoint;       
  Point _exitPoint;           
  Momentum _entranceMomentum; 
  int _trackID;               
  int _parentTrackID;         
  float _time;                
 
#ifdef HS_USE_ROOT
  ClassDef(ParticleHit, 1)
#endif
};
 
} // namespace Herd
 
#endif /* HERD_PARTICLEHIT_H_ */