TrackHeed.hh

Go to the documentation of this file.

#ifndef G_TRACK_HEED_H
#define G_TRACK_HEED_H
 
#include <memory>
#include <vector>
 
#include "Garfield/Track.hh"
 
namespace Heed {
class gparticle;
class particle_def;
class HeedParticle;
class HeedCondElectron;
class HeedMatterDef;
class GasDef;
class MatterDef;
class EnergyMesh;
class EnTransfCS;
class ElElasticScat;
class ElElasticScatLowSigma;
class PairProd;
class HeedDeltaElectronCS;
class HeedPhoton;
}  // namespace Heed
 
namespace Garfield {
 
class HeedChamber;
class HeedFieldMap;
class Medium;

 
class TrackHeed : public Track {
 public:
  struct Electron {
    double x = 0.;
    double y = 0.;
    double z = 0.;
    double t = 0.;
    double e = 0.;
    double dx = 0.;
    double dy = 0.;
    double dz = 0.;
  };
 
  struct Photon {
    double x = 0.;
    double y = 0.;
    double z = 0.;
    double t = 0.;
    double e = 0.;
    double dx = 0.;
    double dy = 0.;
    double dz = 0.;
  };
 
  struct Cluster {
    double x, y, z, t;
    double energy;
    double extra;
    std::vector<Photon> photons;
    std::vector<Electron> electrons;
    std::vector<Electron> ions;
  };

  TrackHeed() : TrackHeed(nullptr) {}
  TrackHeed(Sensor* sensor);
  virtual ~TrackHeed();
 
  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);
  bool GetCluster(double& xc, double& yc, double& zc, double& tc, int& ne,
                  int& ni, double& ec, double& extra);
  bool GetCluster(double& xc, double& yc, double& zc, double& tc, int& ne,
                  int& ni, int& np, double& ec, double& extra);
  bool GetElectron(const unsigned int i, double& x, double& y, double& z,
                   double& t, double& e, double& dx, double& dy, double& dz);
  bool GetIon(const unsigned int i, double& x, double& y, double& z,
              double& t) const;

  bool GetPhoton(const unsigned int i, double& x, double& y, double& z,
                 double& t, double& e, double& dx, double& dy,
                 double& dz) const;
 
  double GetClusterDensity() override;
  double GetStoppingPower() override;
  double GetW() const;
  double GetFanoFactor() const;
  double GetPhotoAbsorptionCrossSection(const double e) const;

  bool Initialise(Medium* medium, const bool verbose = false);

  Cluster TransportDeltaElectron(const double x0, const double y0,
                                 const double z0, const double t0,
                                 const double e0, const double dx0,
                                 const double dy0, const double dz0);

  void TransportDeltaElectron(const double x0, const double y0, const double z0,
                              const double t0, const double e0,
                              const double dx0, const double dy0,
                              const double dz0, int& ne, int& ni);
  void TransportDeltaElectron(const double x0, const double y0, const double z0,
                              const double t0, const double e0,
                              const double dx0, const double dy0,
                              const double dz0, int& ne);

  Cluster TransportPhoton(const double x0, const double y0, const double z0,
                          const double t0, const double e0, const double dx0,
                          const double dy0, const double dz0);

  void TransportPhoton(const double x0, const double y0, const double z0,
                       const double t0, const double e0, const double dx0,
                       const double dy0, const double dz0, int& ne, int& ni,
                       int& np);

  void TransportPhoton(const double x0, const double y0, const double z0,
                       const double t0, const double e0, const double dx0,
                       const double dy0, const double dz0, int& ne, int& ni);
  void TransportPhoton(const double x0, const double y0, const double z0,
                       const double t0, const double e0, const double dx0,
                       const double dy0, const double dz0, int& ne);

  void EnableElectricField();
  void DisableElectricField();
  void EnableMagneticField();
  void DisableMagneticField();

  void SetSteppingLimits(const double maxStep, const double radStraight,
                         const double stepAngleStraight,
                         const double stepAngleCurved) {
    m_maxStep = maxStep;
    m_radStraight = radStraight;
    m_stepAngleStraight = stepAngleStraight;
    m_stepAngleCurved = stepAngleCurved;
  }
  void GetSteppingLimits(double& maxStep, double& radStraight,
                         double& stepAngleStraight, double& stepAngleCurved) {
    maxStep = m_maxStep;
    radStraight = m_radStraight;
    stepAngleStraight = m_stepAngleStraight;
    stepAngleCurved = m_stepAngleCurved;
  }
 
  void CrossInactiveMedia(const bool on = true) { m_crossInactiveMedia = on; }
  void EnableCoulombScattering(const bool on = true) {
    m_coulombScattering = on;
  }

  void EnableDeltaElectronTransport() { m_doDeltaTransport = true; }
  void DisableDeltaElectronTransport() { m_doDeltaTransport = false; }

  void EnablePhotonReabsorption(const bool on = true) {
    m_doPhotonReabsorption = on;
  }

  void EnablePhotoAbsorptionCrossSectionOutput(const bool on) {
    m_usePacsOutput = on;
  }

  void SetEnergyMesh(const double e0, const double e1, const int nsteps);

  void SetParticleUser(const double m, const double z);
 
  void EnableOneStepFly(const bool on) { m_oneStepFly = on; }
 
 private:
  // Prevent usage of copy constructor and assignment operator
  TrackHeed(const TrackHeed& heed);
  TrackHeed& operator=(const TrackHeed& heed);
 
  bool m_oneStepFly = false;
 
  bool m_ready = false;
  bool m_hasActiveTrack = false;
 
  double m_mediumDensity = -1.;
  std::string m_mediumName = "";
 
  bool m_usePacsOutput = false;
 
  bool m_doPhotonReabsorption = true;
  bool m_crossInactiveMedia = false;
  bool m_coulombScattering = false;
  bool m_useBfieldAuto = true;
  bool m_doDeltaTransport = true;
 
  std::vector<Cluster> m_clusters;
  size_t m_cluster = 0;
 
  // Particle properties
  std::unique_ptr<Heed::particle_def> m_particle_def;
  // Material properties
  std::unique_ptr<Heed::HeedMatterDef> m_matter;
  std::unique_ptr<Heed::GasDef> m_gas;
  std::unique_ptr<Heed::MatterDef> m_material;
 
  // Energy mesh
  double m_emin = 2.e-6;
  double m_emax = 2.e-1;
  unsigned int m_nEnergyIntervals = 200;
  std::unique_ptr<Heed::EnergyMesh> m_energyMesh;
 
  // Cross-sections
  std::unique_ptr<Heed::EnTransfCS> m_transferCs;
  std::unique_ptr<Heed::ElElasticScat> m_elScat;
  std::unique_ptr<Heed::ElElasticScatLowSigma> m_lowSigma;
  std::unique_ptr<Heed::PairProd> m_pairProd;
  std::unique_ptr<Heed::HeedDeltaElectronCS> m_deltaCs;
 
  // Interface classes
  std::unique_ptr<HeedChamber> m_chamber;
  std::unique_ptr<HeedFieldMap> m_fieldMap;
 
  // Bounding box
  double m_lX = 0., m_lY = 0., m_lZ = 0.;
  double m_cX = 0., m_cY = 0., m_cZ = 0.;
 
  // Stepping parameters.
  double m_maxStep = 100.;
  double m_radStraight = 1000.;
  double m_stepAngleStraight = 0.1;
  double m_stepAngleCurved = 0.2;
 
  bool SetupGas(Medium* medium);
  bool SetupMaterial(Medium* medium);
  bool SetupDelta(const std::string& databasePath);
  bool AddCluster(Heed::HeedPhoton* virtualPhoton,
                  std::vector<Cluster>& clusters);
  void AddElectrons(
      const std::vector<Heed::HeedCondElectron>& conductionElectrons,
      std::vector<Electron>& electrons);
  bool IsInside(const double x, const double y, const double z);
  bool UpdateBoundingBox(bool& update);
};
}  // namespace Garfield
 
#endif