Garfield::AvalancheGrid Class Reference

#include <AvalancheGrid.hh>

Public Member Functions
	AvalancheGrid ()
	Constructor.
	~AvalancheGrid ()
	Destructor.
void	SetSensor (Sensor *sensor)
	Set the sensor.
void	SetAvalancheMicroscopic (AvalancheMicroscopic *avmc)
	Set the AvalancheMicroscopic.
void	StartGridAvalanche ()
void	SetElectronVelocity (const double vx, const double vy, const double vz)
	Set the electron drift velocity (in cm / ns).
void	SetElectronTownsend (const double town)
	Set the electron Townsend coefficient (in 1 / cm).
void	SetElectronAttachment (const double att)
	Set the electron attachment coefficient (in 1 / cm).
void	SetMaxAvalancheSize (const double size)
	Set the maximum avalanche size (1e7 by default).
void	EnableDiffusion (const double diffSigma)
void	CreateAvalanche (const double x, const double y, const double z, const double t=0, const int n=1)
void	GetElectronsFromAvalancheMicroscopic ()
	Import electron data from AvalancheMicroscopic class.
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)
	Import electron data from AvalancheMicroscopic class.
int	GetAmountOfStartingElectrons ()
void	EnableDebugging ()
void	Reset ()

Detailed Description

Calculate avalanches in a uniform electric field using avalanche statistics.

Definition at line 17 of file AvalancheGrid.hh.

Constructor & Destructor Documentation

AvalancheGrid()

Garfield::AvalancheGrid::AvalancheGrid ( )

inline

Constructor.

Definition at line 20 of file AvalancheGrid.hh.

{}

~AvalancheGrid()

Garfield::AvalancheGrid::~AvalancheGrid ( )

inline

Destructor.

Definition at line 22 of file AvalancheGrid.hh.

{}

Member Function Documentation

CreateAvalanche()

void Garfield::AvalancheGrid::CreateAvalanche	(	const double	x,
		const double	y,
		const double	z,
		const double	t = 0,
		const int	n = 1
	)

Setting the starting point of an electron that .

Parameters

z	z-coordinate of initial electron.
x	x-coordinate of initial electron.
v	speed of initial electron.
t	starting time of avalanche.

Definition at line 483 of file AvalancheGrid.cc.

                                                 {
  m_driftAvalanche = true;
 
  if (m_avgrid.time == 0 && m_avgrid.time != t && m_debug)
    std::cerr << m_className
              << "::CreateAvalanche::Overwriting start time of avalanche for t "
                 "= 0 to "
              << t << ".\n";
  m_avgrid.time = t;
 
  if (SnapToGrid(m_avgrid, x, y, z, 0, n) && m_debug)
    std::cerr << m_className
              << "::CreateAvalanche::Electron added at (t,x,y,z) =  (" << t
              << "," << x << "," << y << "," << z << ").\n";
 
  // std::cerr<< m_className<< "::CreateAvalanche::expected contribution is "<<
  // exp((m_Townsend-m_Attachment)*z) << ".\n";
}

EnableDebugging()

void Garfield::AvalancheGrid::EnableDebugging ( )

inline

Definition at line 76 of file AvalancheGrid.hh.

{ m_debug = true; }

EnableDiffusion()

void Garfield::AvalancheGrid::EnableDiffusion ( const double  diffSigma )

inline

Enable transverse diffusion of electrons with transverse diffusion coefficients (in √cm).

Definition at line 54 of file AvalancheGrid.hh.

                                               {
    m_diffusion = true;
    m_DiffSigma = diffSigma;
  }

GetAmountOfStartingElectrons()

int Garfield::AvalancheGrid::GetAmountOfStartingElectrons ( )

inline

Definition at line 74 of file AvalancheGrid.hh.

{ return m_nestart; }

GetElectronsFromAvalancheMicroscopic()

void Garfield::AvalancheGrid::GetElectronsFromAvalancheMicroscopic

(

)

Import electron data from AvalancheMicroscopic class.

Definition at line 503 of file AvalancheGrid.cc.

                                                         {
  // Get the information of the electrons from the AvalancheMicroscopic class.
  if (!m_avmc) return;
 
  if (!m_importAvalanche) m_importAvalanche = true;
 
  int np = m_avmc->GetNumberOfElectronEndpoints();
 
  if (np == 0) return;
 
  // Get initial positions of electrons
  double x1, y1, z1, t1;
  double x2, y2, z2, t2;
  double e1, e2;
  int status;
 
  double vel = 0.;
 
  for (int i = 0; i < np; ++i) {
    m_avmc->GetElectronEndpoint(i, x1, y1, z1, t1, e1, x2, y2, z2, t2, e2,
                                status);
 
    vel = (z2 - z1) / (t2 - t1);
 
    m_avgrid.time = t2;
 
    if (SnapToGrid(m_avgrid, x2, y2, z2, vel) && m_debug)
      std::cerr << m_className
                << "::GetElectronsFromAvalancheMicroscopic::Electron added at "
                   "(x,y,z) =  ("
                << x2 << "," << y2 << "," << z2 << ").\n";
  }
}

Referenced by StartGridAvalanche().

Reset()

void Garfield::AvalancheGrid::Reset

(

)

Definition at line 588 of file AvalancheGrid.cc.

                          {
  std::cerr << m_className << "::Reset::Resetting AvalancheGrid.\n";
 
  m_avgrid.n.clear();
  m_avgrid.transverseDiffusion.clear();
  m_avgrid.time = 0;
  m_avgrid.N = 0;
  m_avgrid.run = true;
 
  m_Saturated = false;
  m_SaturationTime = -1;
 
  m_driftAvalanche = false;
 
  std::vector<int> nhx(m_avgrid.xsteps, 0);
  std::vector<std::vector<int>> nhy(m_avgrid.ysteps, nhx);
  std::vector<std::vector<std::vector<int>>> nhz(m_avgrid.zsteps, nhy);
  m_avgrid.n = nhz;
 
  for (int i = 0; i < 3; i++) {
    m_avgrid.gridPosition[i].clear();
  }
 
  // Get the diffusion factors for neighboring points on the grid.
  DiffusionFactors(m_avgrid);
}

SetAvalancheMicroscopic()

void Garfield::AvalancheGrid::SetAvalancheMicroscopic ( AvalancheMicroscopic *  avmc )

inline

Set the AvalancheMicroscopic.

Definition at line 26 of file AvalancheGrid.hh.

{ m_avmc = avmc; }

SetElectronAttachment()

void Garfield::AvalancheGrid::SetElectronAttachment ( const double  att )

inline

Set the electron attachment coefficient (in 1 / cm).

Definition at line 49 of file AvalancheGrid.hh.

{ m_Attachment = att; }

SetElectronTownsend()

void Garfield::AvalancheGrid::SetElectronTownsend ( const double  town )

inline

Set the electron Townsend coefficient (in 1 / cm).

Definition at line 47 of file AvalancheGrid.hh.

{ m_Townsend = town; }

SetElectronVelocity()

void Garfield::AvalancheGrid::SetElectronVelocity ( const double  vx, const double  vy, const double  vz  )

inline

Set the electron drift velocity (in cm / ns).

Definition at line 37 of file AvalancheGrid.hh.

                                                                              {
    double vel = 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);
  }

SetGrid()

void Garfield::AvalancheGrid::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
	)

Import electron data from AvalancheMicroscopic class.

Definition at line 58 of file AvalancheGrid.cc.

                                              {
  m_avgrid.gridset = true;
 
  if (zmin >= zmax || zsteps <= 0 || xmin > xmax || xsteps <= 0 ||
      ymin > ymax || ysteps <= 0) {
    std::cerr << m_className
              << "::SetGrid:Error: Grid is not properly defined.\n";
    return;
  }
 
  // Setting grid
 
  SetZGrid(m_avgrid, zmax, zmin, zsteps);
  SetYGrid(m_avgrid, ymax, ymin, ysteps);
  SetXGrid(m_avgrid, xmax, xmin, xsteps);
 
  if (m_sensor) GetParametersFromSensor();
}

SetMaxAvalancheSize()

void Garfield::AvalancheGrid::SetMaxAvalancheSize ( const double  size )

inline

Set the maximum avalanche size (1e7 by default).

Definition at line 51 of file AvalancheGrid.hh.

{ m_MaxSize = size; }

SetSensor()

void Garfield::AvalancheGrid::SetSensor ( Sensor *  sensor )

inline

Set the sensor.

Definition at line 24 of file AvalancheGrid.hh.

{ m_sensor = sensor; }

StartGridAvalanche()

void Garfield::AvalancheGrid::StartGridAvalanche

(

)

Start grid based avalanche simulation.

Parameters

zmin,zmax	z-coordinate range of grid [cm].
zsteps	amount of z-coordinate points in grid.
xmin,xmax	x-coordinate range of grid [cm].
xsteps	amount of x-coordinate points in grid.

Definition at line 381 of file AvalancheGrid.cc.

                                       {
  // Start the AvalancheGrid algorithm.
  if ((!m_avmc && !m_driftAvalanche) || !m_sensor) return;
 
  if (!m_importAvalanche && m_avmc) GetElectronsFromAvalancheMicroscopic();
 
  std::cerr << m_className
            << "::StartGridAvalanche::Starting grid based simulation with "
            << m_avgrid.N << " initial electrons.\n";
  if (m_avgrid.N <= 0) {
    std::cerr << m_className << "::StartGridAvalanche::Cancelled.\n";
    return;
  }
 
  m_nestart = m_avgrid.N;
 
  // The vector containing the indexes of the z-coordinate grid points of the
  // initial electrons needs to be ordered from small to large values. All
  // duplicate values need to be removed.
 
  GetParametersFromSensor();
 
  SortPositionVector();
 
  if (m_debug) {
    std::cerr << m_className
              << "::StartGridAvalanche::m_avgrid.gridPosition at iz = ";
    for (size_t i = 0; i < m_avgrid.gridPosition[0].size(); i++) {
      std::cerr << m_avgrid.gridPosition[0][i] << ",";
    }
    std::cerr << ".\n";
  }
 
  // Set velocity if given.
  m_avgrid.velocity = m_Velocity;
  // Main loop.
  while (m_avgrid.run == true) {
    NextAvalancheGridPoint(m_avgrid);
  }
 
  if (m_Saturated)
    std::cerr << m_className
              << "::StartGridAvalanche::Avalanche maximum size of " << m_MaxSize
              << " electrons reached at " << m_SaturationTime << " ns.\n";
 
  std::cerr << m_className
            << "::StartGridAvalanche::Final avalanche size = " << m_avgrid.N
            << " at t = " << m_avgrid.time << " ns.\n";
 
  return;
}

---

The documentation for this class was generated from the following files:

• AvalancheGrid.hh
• AvalancheGrid.cc