AvalancheGrid.hh

Go to the documentation of this file.

#ifndef G_AVALANCHE_GRID_H
#define G_AVALANCHE_GRID_H
 
#include <array>
#include <cmath>
#include <string>
#include <vector>
 
namespace Garfield {
 
class Sensor;
class AvalancheMicroscopic;
class ComponentParallelPlate;

class AvalancheGrid {
 public:
  AvalancheGrid() : AvalancheGrid(nullptr) {}
  AvalancheGrid(Sensor *sensor);
  ~AvalancheGrid() = default;

  void SetSensor(Sensor *sensor) { m_sensor = sensor; }

  void StartGridAvalanche();
  void SetElectronVelocity(const double vx, const double vy, const double vz) {
    double vel = std::sqrt(vx * vx + vy * vy + vz * vz);
    if (vel != std::abs(vx) && vel != std::abs(vy) && vel != std::abs(vz))
      return;
    int nx = (int)vx / vel;
    int ny = (int)vy / vel;
    int nz = (int)vz / vel;
    m_velNormal = {nx, ny, nz};
    m_Velocity = -std::abs(vel);
  }

  void SetElectronTownsend(const double town) { m_Townsend = town; }
  void SetElectronAttachment(const double att) { m_Attachment = att; }
  void SetMaxAvalancheSize(const double size) { m_MaxSize = size; }

  void AddElectron(const double x, const double y, const double z,
                   const double t = 0, const int n = 1);
  void AddElectrons(AvalancheMicroscopic *avmc);

  void SetGrid(const double xmin, const double xmax, const int xsteps,
               const double ymin, const double ymax, const int ysteps,
               const double zmin, const double zmax, const int zsteps);

  int GetAmountOfStartingElectrons() { return m_nestart; }
  int GetAvalancheSize() { return m_nTotal; }
 
  void EnableDebugging() { m_debug = true; }
 
  void Reset();
 
 private:
  bool m_debug = false;
 
  double m_Townsend = -1;  // [1/cm]
 
  double m_Attachment = -1;  // [1/cm]
 
  double m_Velocity = 0.;  // [cm/ns]
 
  std::vector<int> m_velNormal = {0, 0, 0};
 
  double m_MaxSize = 1.6e7;  // Saturations size
  // Check if avalanche has reached maximum size
  bool m_Saturated = false;
  // Time when the avalanche has reached maximum size
  double m_SaturationTime = -1.;
 
  int m_nestart = 0.;
 
  std::vector<double> m_nLayer;
 
  std::string m_className = "AvalancheGrid";
 
  Sensor *m_sensor = nullptr;
 
  bool m_printPar = false;
 
  std::vector<double> m_zgrid;  
  double m_zStepSize = 0.;      
 
  std::vector<double> m_ygrid;  
  double m_yStepSize = 0.;      
 
  std::vector<double> m_xgrid;  
  double m_xStepSize = 0.;      
 
  bool m_gridset = false;  
  int m_nTotal = 0;        
  double m_time = 0;       
  bool m_run = true;  
 
  struct Path {
    std::vector<double> ts = {};
    std::vector<std::array<double, 3> > xs = {};
    std::vector<double> qs = {};
  };
 
  struct AvalancheNode {
    double ix = 0;
    double iy = 0;
    double iz = 0;
 
    int n = 1;
 
    int layer = 0;
 
    double townsend = 0;
    double attachment = 0;
    double velocity = 0;
 
    double stepSize = 0;
    std::vector<int> velNormal = {0, 0, 0};
 
    double time = 0.;  
    double dt = -1.;   
 
    bool active = true;
 
    Path path;
  };
 
  std::vector<AvalancheNode> m_activeNodes = {};
 
  // Assign electron to the closest grid point.
  bool SnapToGrid(const double x, const double y, const double z,
                  const double v, const int n = 1);
  // Go to next time step.
  void NextAvalancheGridPoint();
  // Obtain the Townsend coef., Attachment coef. and velocity vector from
  // sensor class.
  bool GetParameters(AvalancheNode &node);
 
  void DeactivateNode(AvalancheNode &node);
};
}  // namespace Garfield
 
#endif