Interpolation in a three-dimensional field map created by Sentaurus Device. More...

#include <ComponentTcad3d.hh>

Inheritance diagram for Garfield::ComponentTcad3d:

Public Member Functions
	ComponentTcad3d ()

	~ComponentTcad3d ()

void	ElectricField (const double x, const double y, const double z, double &ex, double &ey, double &ez, double &v, Medium *&m, int &status)

void	ElectricField (const double x, const double y, const double z, double &ex, double &ey, double &ez, Medium *&m, int &status)

Medium *	GetMedium (const double x, const double y, const double z)
	Get the medium at a given location (x, y, z).

bool	GetVoltageRange (double &vmin, double &vmax)
	Calculate the voltage range [V].

bool	GetBoundingBox (double &xmin, double &ymin, double &zmin, double &xmax, double &ymax, double &zmax)
	Get the bounding box coordinates.

bool	Initialise (const std::string &gridfilename, const std::string &datafilename)

void	PrintRegions ()

unsigned int	GetNumberOfRegions () const

void	GetRegion (const unsigned int ireg, std::string &name, bool &active) const

void	SetDriftRegion (const unsigned int ireg)

void	UnsetDriftRegion (const unsigned int ireg)

void	SetMedium (const unsigned int ireg, Medium *m)

bool	GetMedium (const unsigned int ireg, Medium *&m) const

int	GetNumberOfElements () const

bool	GetElement (const unsigned int i, double &vol, double &dmin, double &dmax, int &type) const

bool	GetElement (const unsigned int i, double &vol, double &dmin, double &dmax, int &type, int &node1, int &node2, int &node3, int &node4, int &node5, int &node6, int &node7, int &reg) const

unsigned int	GetNumberOfNodes () const

bool	GetNode (const unsigned int i, double &x, double &y, double &z, double &v, double &ex, double &ey, double &ez) const

Public Member Functions inherited from Garfield::ComponentBase
	ComponentBase ()
	Constructor.

virtual	~ComponentBase ()
	Destructor.

virtual void	SetGeometry (GeometryBase *geo)
	Define the geometry.

virtual void	Clear ()
	Reset.

virtual Medium *	GetMedium (const double x, const double y, const double z)
	Get the medium at a given location (x, y, z).

virtual void	ElectricField (const double x, const double y, const double z, double &ex, double &ey, double &ez, Medium *&m, int &status)=0

virtual void	ElectricField (const double x, const double y, const double z, double &ex, double &ey, double &ez, double &v, Medium *&m, int &status)=0

virtual bool	GetVoltageRange (double &vmin, double &vmax)=0
	Calculate the voltage range [V].

virtual void	WeightingField (const double x, const double y, const double z, double &wx, double &wy, double &wz, const std::string &label)

virtual double	WeightingPotential (const double x, const double y, const double z, const std::string &label)

virtual void	MagneticField (const double x, const double y, const double z, double &bx, double &by, double &bz, int &status)

void	SetMagneticField (const double bx, const double by, const double bz)
	Set a constant magnetic field.

virtual bool	IsReady ()
	Ready for use?

virtual bool	GetBoundingBox (double &xmin, double &ymin, double &zmin, double &xmax, double &ymax, double &zmax)
	Get the bounding box coordinates.

virtual bool	IsWireCrossed (const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, double &xc, double &yc, double &zc)

virtual bool	IsInTrapRadius (const double q0, const double x0, const double y0, const double z0, double &xw, double &yw, double &rw)

void	EnablePeriodicityX (const bool on=true)
	Enable simple periodicity in the direction.

void	DisablePeriodicityX ()

void	EnablePeriodicityY (const bool on=true)
	Enable simple periodicity in the direction.

void	DisablePeriodicityY ()

void	EnablePeriodicityZ (const bool on=true)
	Enable simple periodicity in the direction.

void	DisablePeriodicityZ ()

void	EnableMirrorPeriodicityX (const bool on=true)
	Enable mirror periodicity in the direction.

void	DisableMirrorPeriodicityX ()

void	EnableMirrorPeriodicityY (const bool on=true)
	Enable mirror periodicity in the direction.

void	DisableMirrorPeriodicityY ()

void	EnableMirrorPeriodicityZ (const bool on=true)
	Enable mirror periodicity in the direction.

void	DisableMirrorPeriodicityZ ()

void	EnableAxialPeriodicityX (const bool on=true)
	Enable axial periodicity in the direction.

void	DisableAxialPeriodicityX ()

void	EnableAxialPeriodicityY (const bool on=true)
	Enable axial periodicity in the direction.

void	DisableAxialPeriodicityY ()

void	EnableAxialPeriodicityZ (const bool on=true)
	Enable axial periodicity in the direction.

void	DisableAxialPeriodicityZ ()

void	EnableRotationSymmetryX (const bool on=true)
	Enable rotation symmetry around the axis.

void	DisableRotationSymmetryX ()

void	EnableRotationSymmetryY (const bool on=true)
	Enable rotation symmetry around the axis.

void	DisableRotationSymmetryY ()

void	EnableRotationSymmetryZ (const bool on=true)
	Enable rotation symmetry around the axis.

void	DisableRotationSymmetryZ ()

void	EnableDebugging ()
	Switch on debugging messages.

void	DisableDebugging ()
	Switch off debugging messages.

void	ActivateTraps ()
	Request trapping to be taken care of by the component (for TCAD).

void	DeactivateTraps ()

bool	IsTrapActive ()

void	ActivateVelocityMap ()
	Request velocity to be taken care of by the component (for TCAD).

void	DectivateVelocityMap ()

bool	IsVelocityActive ()

virtual bool	ElectronAttachment (const double, const double, const double, double &eta)
	Get the electron attachment coefficient.

virtual bool	HoleAttachment (const double, const double, const double, double &eta)
	Get the hole attachment coefficient.

virtual void	ElectronVelocity (const double, const double, const double, double &vx, double &vy, double &vz, Medium *&, int &status)
	Get the electron drift velocity.

virtual void	HoleVelocity (const double, const double, const double, double &vx, double &vy, double &vz, Medium *&, int &status)
	Get the hole drift velocity.

virtual bool	GetElectronLifetime (const double, const double, const double, double &etau)

virtual bool	GetHoleLifetime (const double, const double, const double, double &htau)

Additional Inherited Members
virtual void	Reset ()=0
	Geometry checks.

virtual void	UpdatePeriodicity ()=0
	Verify periodicities.

Protected Attributes inherited from Garfield::ComponentBase
std::string	m_className
	Class name.

GeometryBase *	m_geometry
	Pointer to the geometry.

bool	m_ready
	Ready for use?

bool	m_activeTraps
	Does the component have traps?

bool	m_hasVelocityMap
	Does the component have velocity maps?

bool	m_xPeriodic
	Simple periodicity in x.

bool	m_yPeriodic
	Simple periodicity in y.

bool	m_zPeriodic
	Simple periodicity in z.

bool	m_xMirrorPeriodic
	Mirror periodicity in x.

bool	m_yMirrorPeriodic
	Mirror periodicity in y.

bool	m_zMirrorPeriodic
	Mirror periodicity in z.

bool	m_xAxiallyPeriodic
	Axial periodicity in x.

bool	m_yAxiallyPeriodic
	Axial periodicity in y.

bool	m_zAxiallyPeriodic
	Axial periodicity in z.

bool	m_xRotationSymmetry
	Rotation symmetry around x-axis.

bool	m_yRotationSymmetry
	Rotation symmetry around y-axis.

bool	m_zRotationSymmetry
	Rotation symmetry around z-axis.

double	m_bx0

double	m_by0

double	m_bz0

bool	m_debug
	Switch on/off debugging messages.

Detailed Description

Interpolation in a three-dimensional field map created by Sentaurus Device.

Definition at line 10 of file ComponentTcad3d.hh.

Constructor & Destructor Documentation

◆ ComponentTcad3d()

Garfield::ComponentTcad3d::ComponentTcad3d ( )

Definition at line 22 of file ComponentTcad3d.cc.

                                 : ComponentBase(),
      m_pMin(0.), 
      m_pMax(0.),
      m_lastElement(0) {
 
  m_className = "ComponentTcad3d";
 
  m_regions.reserve(10);
  m_vertices.reserve(10000);
  m_elements.reserve(10000);
}

◆ ~ComponentTcad3d()

Garfield::ComponentTcad3d::~ComponentTcad3d ( )

inline

Definition at line 16 of file ComponentTcad3d.hh.

16{}

Member Function Documentation

◆ ElectricField() [1/2]

void Garfield::ComponentTcad3d::ElectricField	(	const double	x,
		const double	y,
		const double	z,
		double &	ex,
		double &	ey,
		double &	ez,
		double &	v,
		Medium *&	m,
		int &	status
	)

virtual

Implements Garfield::ComponentBase.

Definition at line 34 of file ComponentTcad3d.cc.

                                                 {
 
  ex = ey = ez = p = 0.;
  m = NULL;
  // Make sure the field map has been loaded.
  if (!m_ready) {
    std::cerr << m_className << "::ElectricField:\n"
              << "    Field map is not available for interpolation.\n";
    status = -10;
    return;
  }
 
  double x = xin, y = yin, z = zin;
  // In case of periodicity, reduce to the cell volume.
  bool xmirr = false, ymirr = false, zmirr = false;
  MapCoordinates(x, y, z, xmirr, ymirr, zmirr);
 
  // Check if the point is inside the bounding box.
  if (x < m_xMinBB || x > m_xMaxBB || y < m_yMinBB || y > m_yMaxBB || 
      z < m_zMinBB || z > m_zMaxBB) {
    status = -11;
    return;
  }
 
  // Assume this will work.
  status = 0;
  double w[nMaxVertices] = {0};
  if (m_lastElement >= 0) {
    // Check if the point is still located in the previously found element.
    const Element& last = m_elements[m_lastElement];
    if (x >= last.xmin && x <= last.xmax && 
        y >= last.ymin && y <= last.ymax &&
        z >= last.zmin && z <= last.zmax) {
      if (CheckElement(x, y, z, last, w)) {
        const unsigned int nVertices = last.type == 2 ? 3 : 4;
        for (unsigned int j = 0; j < nVertices; ++j) {
          const Vertex& vj = m_vertices[last.vertex[j]];
          ex += w[j] * vj.ex;
          ey += w[j] * vj.ey;
          ez += w[j] * vj.ez;
          p += w[j] * vj.p;
        }
        if (xmirr) ex = -ex;
        if (ymirr) ey = -ey;
        if (zmirr) ez = -ez;
        m = m_regions[last.region].medium;
        if (!m_regions[last.region].drift || !m) status = -5;
        return;
      }
    }
    // The point is not in the previous element.
    // Check the adjacent elements.
    const unsigned int nNeighbours = last.neighbours.size();
    for (unsigned int i = 0; i < nNeighbours; ++i) {
      const Element& element = m_elements[last.neighbours[i]];
      if (x < element.xmin || x > element.xmax ||
          y < element.ymin || y > element.ymax ||
          z < element.zmin || z > element.zmax) continue;
      if (!CheckElement(x, y, z, element, w)) continue;
      const unsigned int nVertices = element.type == 2 ? 3 : 4;
      for (unsigned int j = 0; j < nVertices; ++j) {
        const Vertex& vj = m_vertices[element.vertex[j]];
        ex += w[j] * vj.ex;
        ey += w[j] * vj.ey;
        ez += w[j] * vj.ez;
        p += w[j] * vj.p;
      }
      if (xmirr) ex = -ex;
      if (ymirr) ey = -ey;
      if (zmirr) ez = -ez;
      m = m_regions[element.region].medium;
      if (!m_regions[element.region].drift || !m) status = -5;
      m_lastElement = last.neighbours[i];
      return;
    }
  }
 
  // The point is not in the previous element.
  // We have to loop over all elements.
  const unsigned int nElements = m_elements.size();
  for (unsigned int i = 0; i < nElements; ++i) {
    const Element& element = m_elements[i];
    if (x < element.xmin || x > element.xmax ||
        y < element.ymin || y > element.ymax ||
        z < element.zmin || z > element.zmax) continue;
    if (!CheckElement(x, y, z, element, w)) continue;
    const unsigned int nVertices = element.type == 2 ? 3 : 4;
    for (unsigned int j = 0; j < nVertices; ++j) {
      const Vertex& vj = m_vertices[element.vertex[j]];
      ex += w[j] * vj.ex;
      ey += w[j] * vj.ey;
      ez += w[j] * vj.ez;
      p += w[j] * vj.p;
    }
    if (xmirr) ex = -ex;
    if (ymirr) ey = -ey;
    if (zmirr) ez = -ez;
    m = m_regions[element.region].medium;
    if (!m_regions[element.region].drift || !m) status = -5;
    m_lastElement = i;
    return;
  }
 
  // Point is outside the mesh.
  if (m_debug) {
    std::cerr << m_className << "::ElectricField:\n"
              << "    Point (" << x << ", " << y << ", " << z
              << ") is outside the mesh.\n";
  }
  status = -6;
  return;
}

Referenced by ElectricField().

◆ ElectricField() [2/2]

void Garfield::ComponentTcad3d::ElectricField	(	const double	x,
		const double	y,
		const double	z,
		double &	ex,
		double &	ey,
		double &	ez,
		Medium *&	m,
		int &	status
	)

virtual

Calculate the drift field at given point.

Parameters

x,y,z	coordinates [cm].
ex,ey,ez	components of the electric field [V/cm].
m	pointer to the medium at this location.
status	status flag

Status flags:

        0: Inside an active medium
      > 0: Inside a wire of type X
-4 ... -1: On the side of a plane where no wires are
       -5: Inside the mesh but not in an active medium
       -6: Outside the mesh
      -10: Unknown potential type (should not occur)
    other: Other cases (should not occur)

Implements Garfield::ComponentBase.

Definition at line 150 of file ComponentTcad3d.cc.

                                                                         {
 
  double v = 0.;
  ElectricField(x, y, z, ex, ey, ez, v, m, status);
}

◆ GetBoundingBox()

bool Garfield::ComponentTcad3d::GetBoundingBox	(	double &	xmin,
		double &	ymin,
		double &	zmin,
		double &	xmax,
		double &	ymax,
		double &	zmax
	)

virtual

Get the bounding box coordinates.

Reimplemented from Garfield::ComponentBase.

Definition at line 465 of file ComponentTcad3d.cc.

                                                                               {
 
  if (!m_ready) return false;
  xmin = m_xMinBB;
  ymin = m_yMinBB;
  zmin = m_zMinBB;
  xmax = m_xMaxBB;
  ymax = m_yMaxBB;
  zmax = m_zMaxBB;
  if (m_xPeriodic || m_xMirrorPeriodic) {
    xmin = -INFINITY;
    xmax = +INFINITY;
  }
  if (m_yPeriodic || m_yMirrorPeriodic) {
    ymin = -INFINITY;
    ymax = +INFINITY;
  }
  if (m_zPeriodic || m_zMirrorPeriodic) {
    zmin = -INFINITY;
    zmax = +INFINITY;
  }
  return true;
}

◆ GetElement() [1/2]

bool Garfield::ComponentTcad3d::GetElement	(	const unsigned int	i,
		double &	vol,
		double &	dmin,
		double &	dmax,
		int &	type
	)		const

Definition at line 592 of file ComponentTcad3d.cc.

                                                  {
 
  if (i >= m_elements.size()) {
    std::cerr << m_className << "::GetElement:\n"
              << "    Element index (" << i << ") out of range.\n";
    return false;
  }
 
  const Element& element = m_elements[i];
  if (element.type == 2) {
    // Triangle
    const Vertex& v0 = m_vertices[element.vertex[0]];
    const Vertex& v1 = m_vertices[element.vertex[1]];
    const Vertex& v2 = m_vertices[element.vertex[2]];
    const double vx = (v1.y - v0.y) * (v2.z - v0.z) -
                      (v1.z - v0.z) * (v2.y - v0.y);
    const double vy = (v1.z - v0.z) * (v2.x - v0.x) -
                      (v1.x - v0.x) * (v2.z - v0.z);
    const double vz = (v1.x - v0.x) * (v2.y - v0.y) -
                      (v1.y - v0.y) * (v2.x - v0.x);
    vol = sqrt(vx * vx + vy * vy + vz * vz);
    const double a = sqrt(pow(v1.x - v0.x, 2) + pow(v1.y - v0.y, 2) +
                          pow(v1.z - v0.z, 2));
    const double b = sqrt(pow(v2.x - v0.x, 2) + pow(v2.y - v0.y, 2) +
                          pow(v2.z - v0.z, 2));
    const double c = sqrt(pow(v1.x - v2.x, 2) + pow(v1.y - v2.y, 2) +
                          pow(v1.z - v2.z, 2));
    dmin = dmax = a;
    if (b < dmin) dmin = b;
    if (c < dmin) dmin = c;
    if (b > dmax) dmax = b;
    if (c > dmax) dmax = c;
  } else if (element.type == 5) {
    // Tetrahedron
    const Vertex& v0 = m_vertices[element.vertex[0]];
    const Vertex& v1 = m_vertices[element.vertex[1]];
    const Vertex& v2 = m_vertices[element.vertex[2]];
    const Vertex& v3 = m_vertices[element.vertex[3]];
    vol = fabs((v3.x - v0.x) * ((v1.y - v0.y) * (v2.z - v0.z) - (v2.y - v0.y) * (v1.z - v0.z)) +
               (v3.y - v0.y) * ((v1.z - v0.z) * (v2.x - v0.x) - (v2.z - v0.z) * (v1.x - v0.x)) +
               (v3.z - v0.z) * ((v1.x - v0.x) * (v2.y - v0.y) - (v3.x - v0.x) * (v1.y - v0.y))) / 6.;
    // Loop over all pairs of m_vertices.
    for (int j = 0; j < nMaxVertices - 1; ++j) {
      const Vertex& vj = m_vertices[element.vertex[j]];
      for (int k = j + 1; k < nMaxVertices; ++k) {
        const Vertex& vk = m_vertices[element.vertex[k]];
        // Compute distance.
        const double dist = sqrt(pow(vj.x - vk.x, 2) + pow(vj.y - vk.y, 2) +
                                 pow(vj.z - vk.z, 2));
        if (k == 1) {
          dmin = dmax = dist;
        } else {
          if (dist < dmin) dmin = dist;
          if (dist > dmax) dmax = dist;
        }
      }
    }
  } else {
    std::cerr << m_className << "::GetElement:\n"
              << "    Unexpected element type (" << type << ").\n";
    return false;
  }
  return true;
}

Referenced by GetElement().

◆ GetElement() [2/2]

bool Garfield::ComponentTcad3d::GetElement	(	const unsigned int	i,
		double &	vol,
		double &	dmin,
		double &	dmax,
		int &	type,
		int &	node1,
		int &	node2,
		int &	node3,
		int &	node4,
		int &	node5,
		int &	node6,
		int &	node7,
		int &	reg
	)		const

Definition at line 659 of file ComponentTcad3d.cc.

                                                 {
 
  if (!GetElement(i, vol, dmin, dmax, type)) return false;
  const Element& element = m_elements[i];
  node1 = element.vertex[0];
  node2 = element.vertex[1];
  node3 = element.vertex[2];
  node4 = element.vertex[3];
  node5 = element.vertex[4];
  node6 = element.vertex[5];
  node7 = element.vertex[6];
  reg = element.region;
  return true;
}

◆ GetMedium() [1/2]

Medium * Garfield::ComponentTcad3d::GetMedium	(	const double	x,
		const double	y,
		const double	z
	)

virtual

Get the medium at a given location (x, y, z).

Reimplemented from Garfield::ComponentBase.

Definition at line 158 of file ComponentTcad3d.cc.

                                                     {
 
  // Make sure the field map has been loaded.
  if (!m_ready) {
    std::cerr << m_className << "::GetMedium:\n"
              << "    Field map not available for interpolation.\n";
    return NULL;
  }
 
  double x = xin, y = yin, z = zin;
  bool xmirr = false, ymirr = false, zmirr = false;
  MapCoordinates(x, y, z, xmirr, ymirr, zmirr);
 
  // Check if the point is inside the bounding box.
  if (x < m_xMinBB || x > m_xMaxBB || y < m_yMinBB || y > m_yMaxBB || 
      z < m_zMinBB || z > m_zMaxBB) {
    return NULL;
  }
 
  double w[nMaxVertices] = {0};
  if (m_lastElement >= 0) {
    // Check if the point is still located in the previously found element.
    const Element& last = m_elements[m_lastElement];
    if (x >= last.xmin && x <= last.xmax && 
        y >= last.ymin && y <= last.ymax &&
        z >= last.zmin && z <= last.zmax) {
      if (CheckElement(x, y, z, last, w)) {
        return m_regions[last.region].medium;
      }
    } 
 
    // The point is not in the previous element.
    // Check the adjacent elements.
    const unsigned int nNeighbours = last.neighbours.size();
    for (unsigned int i = 0; i < nNeighbours; ++i) {
      const Element& element = m_elements[last.neighbours[i]];
      if (x < element.xmin || x > element.xmax ||
          y < element.ymin || y > element.ymax ||
          z < element.zmin || z > element.zmax) continue;
      if (!CheckElement(x, y, z, element, w)) continue;
      m_lastElement = last.neighbours[i];
      return m_regions[element.region].medium;
    }
  }
 
  // The point is not in the previous element nor in the adjacent ones.
  // We have to loop over all elements.
  const unsigned int nElements = m_elements.size();
  for (unsigned int i = 0; i < nElements; ++i) {
    const Element& element = m_elements[i];
    if (x < element.xmin || x > element.xmax ||
        y < element.ymin || y > element.ymax ||
        z < element.zmin || z > element.zmax) continue;
    if (!CheckElement(x, y, z, element, w)) continue;
    m_lastElement = i;
    return m_regions[element.region].medium;
  }
 
  // The point is outside the mesh.
  return NULL;
}

◆ GetMedium() [2/2]

bool Garfield::ComponentTcad3d::GetMedium	(	const unsigned int	ireg,
		Medium *&	m
	)		const

Definition at line 579 of file ComponentTcad3d.cc.

                                                                      {
 
  if (i >= m_regions.size()) {
    std::cerr << m_className << "::GetMedium:\n"
              << "    Region " << i << " does not exist.\n";
    return false;
  }
 
  m = m_regions[i].medium;
  if (!m) return false;
  return true;
}

◆ GetNode()

bool Garfield::ComponentTcad3d::GetNode	(	const unsigned int	i,
		double &	x,
		double &	y,
		double &	z,
		double &	v,
		double &	ex,
		double &	ey,
		double &	ez
	)		const

Definition at line 678 of file ComponentTcad3d.cc.

                                                                        {
 
  if (i >= m_vertices.size()) {
    std::cerr << m_className << "::GetNode:\n"
              << "    Node index (" << i << ") out of range.\n";
    return false;
  }
 
  const Vertex& vi = m_vertices[i];
  x = vi.x;
  y = vi.y;
  z = vi.z;
  v = vi.p;
  ex = vi.ex;
  ey = vi.ey;
  ez = vi.ez;
  return true;
}

◆ GetNumberOfElements()

int Garfield::ComponentTcad3d::GetNumberOfElements ( ) const

inline

Definition at line 46 of file ComponentTcad3d.hh.

46{ return m_elements.size(); }

◆ GetNumberOfNodes()

unsigned int Garfield::ComponentTcad3d::GetNumberOfNodes ( ) const

inline

Definition at line 52 of file ComponentTcad3d.hh.

52{ return m_vertices.size(); }

◆ GetNumberOfRegions()

unsigned int Garfield::ComponentTcad3d::GetNumberOfRegions ( ) const

inline

Definition at line 37 of file ComponentTcad3d.hh.

37{ return m_regions.size(); }

◆ GetRegion()

void Garfield::ComponentTcad3d::GetRegion	(	const unsigned int	ireg,
		std::string &	name,
		bool &	active
	)		const

Definition at line 532 of file ComponentTcad3d.cc.

                                                    {
 
  if (i >= m_regions.size()) {
    std::cerr << m_className << "::GetRegion:\n"
              << "    Region " << i << " does not exist.\n";
    return;
  }
  name = m_regions[i].name;
  active = m_regions[i].drift;
}

◆ GetVoltageRange()

bool Garfield::ComponentTcad3d::GetVoltageRange	(	double &	vmin,
		double &	vmax
	)

virtual

Calculate the voltage range [V].

Implements Garfield::ComponentBase.

Definition at line 490 of file ComponentTcad3d.cc.

                                                                {
 
  if (!m_ready) return false;
  vmin = m_pMin;
  vmax = m_pMax;
  return true;
}

◆ Initialise()

bool Garfield::ComponentTcad3d::Initialise	(	const std::string &	gridfilename,
		const std::string &	datafilename
	)

Definition at line 221 of file ComponentTcad3d.cc.

                                                                {
 
  m_ready = false;
  // Import mesh data from .grd file.
  if (!LoadGrid(gridfilename)) {
    std::cerr << m_className << "::Initialise:\n"
              << "    Importing mesh data failed.\n";
    return false;
  }
 
  // Import electric field and potential from .dat file.
  if (!LoadData(datafilename)) {
    std::cerr << m_className << "::Initialise:\n"
              << "    Importing electric field and potential failed.\n";
    return false;
  }
 
  // Find min./max. coordinates and potentials.
  m_xMaxBB = m_vertices[m_elements[0].vertex[0]].x;
  m_yMaxBB = m_vertices[m_elements[0].vertex[0]].y;
  m_zMaxBB = m_vertices[m_elements[0].vertex[0]].z;
  m_xMinBB = m_xMaxBB;
  m_yMinBB = m_yMaxBB;
  m_zMinBB = m_zMaxBB;
  m_pMax = m_pMin = m_vertices[m_elements[0].vertex[0]].p;
  const unsigned int nElements = m_elements.size();
  for (unsigned int i = 0; i < nElements; ++i) {
    Element& element = m_elements[i];
    double xmin = m_vertices[element.vertex[0]].x;
    double ymin = m_vertices[element.vertex[0]].y;
    double zmin = m_vertices[element.vertex[0]].z;
    double xmax = xmin;
    double ymax = ymin;
    double zmax = zmin;
    const unsigned int nVertices = element.type == 2 ? 3 : 4;
    for (unsigned int j = 0; j < nVertices; ++j) {
      const Vertex& vj = m_vertices[element.vertex[j]];
      if (vj.x < xmin) xmin = vj.x;
      if (vj.x > xmax) xmax = vj.x;
      if (vj.y < ymin) ymin = vj.y;
      if (vj.y > ymax) ymax = vj.y;
      if (vj.z < zmin) zmin = vj.z;
      if (vj.z > zmax) zmax = vj.z;
      if (vj.p < m_pMin) m_pMin = vj.p;
      if (vj.p > m_pMax) m_pMax = vj.p;
    }
    const double tol = 1.e-6;
    element.xmin = xmin - tol;
    element.xmax = xmax + tol;
    element.ymin = ymin - tol;
    element.ymax = ymax + tol;
    element.zmin = zmin - tol;
    element.zmax = zmax + tol;
    m_xMinBB = std::min(m_xMinBB, xmin);
    m_xMaxBB = std::max(m_xMaxBB, xmax);
    m_yMinBB = std::min(m_yMinBB, ymin);
    m_yMaxBB = std::max(m_yMaxBB, ymax);
    m_zMinBB = std::min(m_zMinBB, zmin);
    m_zMaxBB = std::max(m_zMaxBB, zmax);
  }
 
  std::cout << m_className << "::Initialise:\n"
            << "    Bounding box:\n"
            << "      " << m_xMinBB << " < x [cm] < " << m_xMaxBB << "\n"
            << "      " << m_yMinBB << " < y [cm] < " << m_yMaxBB << "\n"
            << "      " << m_zMinBB << " < z [cm] < " << m_zMaxBB << "\n"
            << "    Voltage range:\n"
            << "      " << m_pMin << " < V < " << m_pMax << "\n";
 
  bool ok = true;
 
  // Count the number of elements belonging to a region.
  const int nRegions = m_regions.size();
  std::vector<unsigned int> nElementsRegion(nRegions, 0);
 
  // Count the different element shapes.
  unsigned int nTriangles = 0;
  unsigned int nTetrahedra = 0;
  unsigned int nOtherShapes = 0;
 
  // Check if there are elements which are not part of any region.
  unsigned int nLoose = 0;
  std::vector<int> looseElements;
 
  // Check if there are degenerate elements.
  unsigned int nDegenerate = 0;
  std::vector<int> degenerateElements;
 
  for (unsigned int i = 0; i < nElements; ++i) {
    const Element& element = m_elements[i]; 
    if (element.type == 2) {
      ++nTriangles;
      if (element.vertex[0] == element.vertex[1] ||
          element.vertex[1] == element.vertex[2] ||
          element.vertex[2] == element.vertex[0]) {
        degenerateElements.push_back(i);
        ++nDegenerate;
      }
    } else if (element.type == 5) {
      if (element.vertex[0] == element.vertex[1] ||
          element.vertex[0] == element.vertex[2] ||
          element.vertex[0] == element.vertex[3] ||
          element.vertex[1] == element.vertex[2] ||
          element.vertex[1] == element.vertex[3] ||
          element.vertex[2] == element.vertex[3]) {
        degenerateElements.push_back(i);
        ++nDegenerate;
      }
      ++nTetrahedra;
    } else {
      // Other shapes should not occur, since they were excluded in LoadGrid.
      ++nOtherShapes;
    }
    if (element.region >= 0 && element.region < nRegions) {
      ++nElementsRegion[element.region];
    } else {
      looseElements.push_back(i);
      ++nLoose;
    }
  }
 
  if (nDegenerate > 0) {
    std::cerr << m_className << "::Initialise:\n"
              << "    The following elements are degenerate:\n";
    for (unsigned int i = 0; i < nDegenerate; ++i) {
      std::cerr << "      " << degenerateElements[i] << "\n";
    }
    ok = false;
  }
 
  if (nLoose > 0) {
    std::cerr << m_className << "::Initialise:\n"
              << "    The following elements are not part of any region:\n";
    for (unsigned int i = 0; i < nLoose; ++i) {
      std::cerr << "      " << looseElements[i] << "\n";
    }
    ok = false;
  }
 
  std::cout << m_className << "::Initialise:\n"
            << "    Number of regions: " << nRegions << "\n";
  for (int i = 0; i < nRegions; ++i) {
    std::cout << "      " << i << ": " << m_regions[i].name << ", "
              << nElementsRegion[i] << " elements\n";
  }
 
  std::cout << "    Number of elements: " << nElements << "\n";
  if (nTriangles > 0) {
    std::cout << "      " << nTriangles << " triangles\n";
  }
  if (nTetrahedra > 0) {
    std::cout << "      " << nTetrahedra << " tetrahedra\n";
  }
  if (nOtherShapes > 0) {
    std::cerr << "      " << nOtherShapes << " elements of unknown type\n"
              << "      Program bug!\n";
    m_ready = false;
    Cleanup();
    return false;
  }
  if (m_debug) {
    // For each element, print the indices of the constituting vertices.
    for (unsigned int i = 0; i < nElements; ++i) {
      const Element& element = m_elements[i];
      if (element.type == 2) {
        std::cout << "      " << i << ": " << element.vertex[0] << "  "
                  << element.vertex[1] << "  " << element.vertex[2]
                  << " (triangle, region " << element.region << ")\n";
      } else if (element.type == 5) {
        std::cout << "      " << i << ": " << element.vertex[0] << "  "
                  << element.vertex[1] << "  " << element.vertex[2]
                  << "  " << element.vertex[3] << " (tetrahedron, region "
                  << element.region << ")\n";
      }
    }
  }
 
  const unsigned int nVertices = m_vertices.size();
  std::cout << "    Number of vertices: " << nVertices << "\n";
  if (m_debug) {
    for (unsigned int i = 0; i < nVertices; ++i) {
      const Vertex& vi = m_vertices[i];
      std::cout << "      " << i << ": (x, y, z) = (" << vi.x << ", "
                << vi.y << ", " << vi.z << "), V = " << vi.p << "\n";
    }
  }
 
  // Find adjacent elements.
  std::cout << m_className << "::Initialise:\n"
            << "    Looking for neighbouring elements. Be patient...\n";
  FindNeighbours();
 
  if (!ok) {
    m_ready = false;
    Cleanup();
    return false;
  }
 
  m_ready = true;
  UpdatePeriodicity();
  std::cout << m_className << "::Initialise:\n"
            << "    Initialisation finished.\n";
  return true;
}

◆ PrintRegions()

void Garfield::ComponentTcad3d::PrintRegions ( )

Definition at line 498 of file ComponentTcad3d.cc.

                                   {
 
  // Do not proceed if not properly initialised.
  if (!m_ready) {
    std::cerr << m_className << "::PrintRegions:\n"
              << "    Field map not yet initialised.\n";
    return;
  }
 
  if (m_regions.empty()) {
    std::cerr << m_className << "::PrintRegions:\n"
              << "    No regions are currently defined.\n";
    return;
  }
 
  const unsigned int nRegions = m_regions.size();
  std::cout << m_className << "::PrintRegions:\n"
            << "    Currently " << nRegions << " regions are defined.\n"
            << "      Index  Name      Medium\n";
  for (unsigned int i = 0; i < nRegions; ++i) {
    std::cout << "      " << i << "  " << m_regions[i].name;
    if (!m_regions[i].medium) {
      std::cout << "      none  ";
    } else {
      std::cout << "      " << m_regions[i].medium->GetName();
    }
    if (m_regions[i].drift) {
      std::cout << " (active region)\n";
    } else {
      std::cout << "\n";
    }
  }
}

◆ SetDriftRegion()

void Garfield::ComponentTcad3d::SetDriftRegion ( const unsigned int ireg )

Definition at line 544 of file ComponentTcad3d.cc.

                                                         {
 
  if (i >= m_regions.size()) {
    std::cerr << m_className << "::SetDriftRegion:\n"
              << "    Region " << i << " does not exist.\n";
    return;
  }
  m_regions[i].drift = true;
}

◆ SetMedium()

void Garfield::ComponentTcad3d::SetMedium	(	const unsigned int	ireg,
		Medium *	m
	)

Definition at line 564 of file ComponentTcad3d.cc.

                                                                    {
 
  if (i >= m_regions.size()) {
    std::cerr << m_className << "::SetMedium:\n"
              << "    Region " << i << " does not exist.\n";
    return;
  }
 
  if (!medium) {
    std::cerr << m_className << "::SetMedium:\n    Null pointer.\n";
    return;
  }
  m_regions[i].medium = medium;
}

◆ UnsetDriftRegion()

void Garfield::ComponentTcad3d::UnsetDriftRegion ( const unsigned int ireg )

Definition at line 554 of file ComponentTcad3d.cc.

                                                           {
 
  if (i >= m_regions.size()) {
    std::cerr << m_className << "::UnsetDriftRegion:\n"
              << "    Region " << i << " does not exist.\n";
    return;
  }
  m_regions[i].drift = false;
}

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ComponentTcad3d()

◆ ~ComponentTcad3d()

Member Function Documentation

◆ ElectricField() [1/2]

◆ ElectricField() [2/2]

◆ GetBoundingBox()

◆ GetElement() [1/2]

◆ GetElement() [2/2]

◆ GetMedium() [1/2]

◆ GetMedium() [2/2]

◆ GetNode()

◆ GetNumberOfElements()

◆ GetNumberOfNodes()

◆ GetNumberOfRegions()

◆ GetRegion()

◆ GetVoltageRange()

◆ Initialise()

◆ PrintRegions()

◆ SetDriftRegion()

◆ SetMedium()

◆ UnsetDriftRegion()