TrackSrim.hh

Go to the documentation of this file.

#ifndef G_TRACK_SRIM_H
#define G_TRACK_SRIM_H
 
#include <array>
#include <vector>
 
#include "Garfield/Track.hh"
 
namespace Garfield {
class Medium;
 
class TrackSrim : public Track {
 public:
  TrackSrim() : TrackSrim(nullptr) {}
  TrackSrim(Sensor* sensor);
  virtual ~TrackSrim() {}

  bool ReadFile(const std::string& file);
  void Print();
  void PlotEnergyLoss();
  void PlotRange();
  void PlotStraggling();

  void SetModel(const int m) { m_model = m; }
  int GetModel() const { return m_model; }

  void SetTargetClusterSize(const int n) { m_nsize = n; }
  int GetTargetClusterSize() const { return m_nsize; }

  void SetClustersMaximum(const int n) { m_maxclusters = n; }
  int GetClustersMaximum() const { return m_maxclusters; }

  void SetWorkFunction(const double w) { m_work = w; }
  double GetWorkFunction() const { return m_work; }
  void SetFanoFactor(const double f) {
    m_fano = f;
    m_fset = true;
  }

  void UnsetFanoFactor() { m_fset = false; }
  double GetFanoFactor() const { return m_fano; }
  void SetDensity(const double density) { m_rho = density; }
  double GetDensity() const { return m_rho; }
  void SetAtomicMassNumbers(const double a, const double z) {
    m_a = a;
    m_z = z;
  }

  void GetAtomicMassMumbers(double& a, double& z) const {
    a = m_a;
    z = m_z;
  }

  void EnableTransverseStraggling(const bool on = true) {
    m_useTransStraggle = on;
  }

  void EnableLongitudinalStraggling(const bool on = true) {
    m_useLongStraggle = on;
  }
 
  struct Cluster {
    double x, y, z, t;  
    double energy;      
    double kinetic;     
    int n;              
  };
 
  bool NewTrack(const double x0, const double y0, const double z0,
                const double t0, const double dx0, const double dy0,
                const double dz0) override;
  const std::vector<Cluster>& GetClusters() const { return m_clusters; }
  bool GetCluster(double& xc, double& yc, double& zc, double& tc, int& nc,
                  double& ec, double& extra);
 
 protected:
  bool m_useTransStraggle = true;
  bool m_useLongStraggle = false;

  bool m_chargeset = false;
  double m_qion = 1.;
  double m_mion = -1.;
  double m_rho = -1.;
  double m_work = -1.;
  bool m_fset = false;
  double m_fano = -1.;
  double m_a = -1.;
  double m_z = -1.;

  int m_maxclusters = -1;
  std::vector<double> m_ekin;
  std::vector<double> m_emloss;
  std::vector<double> m_hdloss;
  std::vector<double> m_range;
  std::vector<double> m_transstraggle;
  std::vector<double> m_longstraggle;

  size_t m_currcluster = 0;
  unsigned int m_model = 4;
  int m_nsize = -1;
  std::vector<Cluster> m_clusters;
 
  double Xi(const double x, const double beta2, const double edens) const;
  double DedxEM(const double e) const;
  double DedxHD(const double e) const;
  bool PreciseLoss(const double step, const double estart, double& deem,
                   double& dehd) const;
  bool EstimateRange(const double ekin, const double step,
                     double& stpmax) const;
  bool SmallestStep(const double ekin, const double edens, double de,
                    double step, double& stpmin);
  Medium* GetMedium(const std::array<double, 3>& x) const;
  double Terminate(const std::array<double, 3>& x0,
                   const std::array<double, 3>& v0, const double step0) const;
  double TerminateBfield(const std::array<double, 3>& x0,
                         const std::array<double, 3>& v0, const double dt0,
                         const double vmag) const;
  double RndmEnergyLoss(const double ekin, const double de, const double step,
                        const double edens) const;
};
}  // namespace Garfield
 
#endif