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 "common/DefaultValues.h"
#include "dataobjects/Momentum.h"
#include "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;

  float EDep() const { return _eDep; }
  void SetEDep(float eDep) { _eDep = eDep; }

  const Point &EntrancePoint() const { return _entrancePoint; }
  void SetEntrancePoint(Point entrancePoint) { _entrancePoint = std::move(entrancePoint); }

  const Point &ExitPoint() const { return _exitPoint; }
  void SetExitPoint(Point exitPoint) { _exitPoint = std::move(exitPoint); }

  const Momentum &EntranceMomentum() const { return _entranceMomentum; }
  void SetEntranceMomentum(Momentum entranceMomentum) { _entranceMomentum = std::move(entranceMomentum); }

  float EntranceEnergy() const { return _entranceEnergy; }
  void SetEntranceEnergy(float entranceEnergy) { _entranceEnergy = entranceEnergy; }

  int ParticlePDG() const { return _particlePdg; }
  void SetParticlePDG(int particlePdg) { _particlePdg = particlePdg; }

  int TrackID() const { return _trackID; }

  void SetTrackID(int trackID) { _trackID = trackID; }

  int ParentTrackID() const { return _parentTrackID; }

  void SetParentTrackID(int parentTrackID) { _parentTrackID = parentTrackID; }

  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_ */