Garfield++ 5.0
A toolkit for the detailed simulation of particle detectors based on ionisation measurement in gases and semiconductors
Loading...
Searching...
No Matches
Public Member Functions | List of all members
Garfield::ComponentGrid Class Reference

Component for interpolating field maps on a regular mesh. More...

#include <ComponentGrid.hh>

+ Inheritance diagram for Garfield::ComponentGrid:

Public Member Functions

 ComponentGrid ()
 Constructor.
 
 ~ComponentGrid ()
 Destructor.
 
bool SetMesh (const unsigned int nx, const unsigned int ny, const unsigned int nz, const double xmin, const double xmax, const double ymin, const double ymax, const double zmin, const double zmax)
 
bool GetMesh (unsigned int &nx, unsigned int &ny, unsigned int &nz, double &xmin, double &xmax, double &ymin, double &ymax, double &zmin, double &zmax) const
 Retrieve the parameters of the grid.
 
void SetCartesianCoordinates ()
 Use Cartesian coordinates (default).
 
void SetCylindricalCoordinates ()
 Use cylindrical coordinates.
 
bool LoadElectricField (const std::string &filename, const std::string &format, const bool withPotential, const bool withFlag, const double scaleX=1., const double scaleE=1., const double scaleP=1.)
 
bool LoadWeightingField (const std::string &filename, const std::string &format, const bool withPotential, const double scaleX=1., const double scaleE=1., const double scaleP=1.)
 Import (prompt) weighting field from file.
 
bool LoadWeightingField (const std::string &filename, const std::string &format, const double time, const bool withPotential, const double scaleX=1., const double scaleE=1., const double scaleP=1.)
 Import delayed weighting field from file.
 
void SetWeightingFieldOffset (const double x, const double y, const double z)
 
bool LoadMagneticField (const std::string &filename, const std::string &format, const double scaleX=1., const double scaleB=1.)
 Import magnetic field values from a file.
 
bool SaveElectricField (Component *cmp, const std::string &filename, const std::string &fmt)
 
bool SaveWeightingField (Component *cmp, const std::string &id, const std::string &filename, const std::string &fmt)
 
bool GetElectricField (const unsigned int i, const unsigned int j, const unsigned int k, double &v, double &ex, double &ey, double &ez) const
 Return the field at a given node.
 
void SetMedium (Medium *m)
 Set the medium.
 
Medium * GetMedium () const
 Get the medium.
 
void Print ()
 Print information about the mesh and the available data.
 
bool LoadElectronAttachment (const std::string &fname, const std::string &fmt, const unsigned int col, const double scaleX=1.)
 
bool LoadHoleAttachment (const std::string &fname, const std::string &fmt, const unsigned int col, const double scaleX=1.)
 Import hole attachment coefficients from a file.
 
bool LoadElectronVelocity (const std::string &fname, const std::string &fmt, const double scaleX=1., const double scaleV=1.e-9)
 
bool LoadHoleVelocity (const std::string &fname, const std::string &fmt, const double scaleX=1., const double scaleV=1.e-9)
 Import a map of hole drift velocities from a file.
 
void Clear () override
 Reset.
 
void ElectricField (const double x, const double y, const double z, double &ex, double &ey, double &ez, double &v, Medium *&m, int &status) override
 Calculate the drift field [V/cm] and potential [V] at (x, y, z).
 
void ElectricField (const double x, const double y, const double z, double &ex, double &ey, double &ez, Medium *&m, int &status) override
 
void WeightingField (const double x, const double y, const double z, double &wx, double &wy, double &wz, const std::string &label) override
 
double WeightingPotential (const double x, const double y, const double z, const std::string &label) override
 
void DelayedWeightingField (const double x, const double y, const double z, const double t, double &wx, double &wy, double &wz, const std::string &label) override
 
double DelayedWeightingPotential (const double x, const double y, const double z, const double t, const std::string &label) override
 
void MagneticField (const double x, const double y, const double z, double &bx, double &by, double &bz, int &status) override
 
Medium * GetMedium (const double x, const double y, const double z) override
 Get the medium at a given location (x, y, z).
 
bool GetVoltageRange (double &vmin, double &vmax) override
 Calculate the voltage range [V].
 
bool GetElectricFieldRange (double &exmin, double &exmax, double &eymin, double &eymax, double &ezmin, double &ezmax)
 
bool GetBoundingBox (double &xmin, double &ymin, double &zmin, double &xmax, double &ymax, double &zmax) override
 Get the bounding box coordinates.
 
bool GetElementaryCell (double &xmin, double &ymin, double &zmin, double &xmax, double &ymax, double &zmax) override
 Get the coordinates of the elementary cell.
 
bool HasMagneticField () const override
 Does the component have a non-zero magnetic field?
 
bool HasAttachmentMap () const override
 Does the component have attachment maps?
 
bool ElectronAttachment (const double x, const double y, const double z, double &att) override
 Get the electron attachment coefficient.
 
bool HoleAttachment (const double x, const double y, const double z, double &att) override
 Get the hole attachment coefficient.
 
bool HasVelocityMap () const override
 Does the component have velocity maps?
 
bool ElectronVelocity (const double x, const double y, const double z, double &vx, double &vy, double &vz) override
 Get the electron drift velocity.
 
bool HoleVelocity (const double x, const double y, const double z, double &vx, double &vy, double &vz) override
 Get the hole drift velocity.
 
std::array< double, 3 > ElectricField (const double x, const double y, const double z)
 Calculate the drift field [V/cm] at (x, y, z).
 
- Public Member Functions inherited from Garfield::Component
 Component ()=delete
 Default constructor.
 
 Component (const std::string &name)
 Constructor.
 
virtual ~Component ()
 Destructor.
 
virtual void SetGeometry (Geometry *geo)
 Define the geometry.
 
std::array< double, 3 > ElectricField (const double x, const double y, const double z)
 Calculate the drift field [V/cm] at (x, y, z).
 
virtual double ElectricPotential (const double x, const double y, const double z)
 Calculate the (drift) electrostatic potential [V] at (x, y, z).
 
void SetMagneticField (const double bx, const double by, const double bz)
 Set a constant magnetic field.
 
virtual bool IsReady ()
 Ready for use?
 
double IntegrateFluxCircle (const double xc, const double yc, const double r, const unsigned int nI=50)
 
double IntegrateFluxSphere (const double xc, const double yc, const double zc, const double r, const unsigned int nI=20)
 
double IntegrateFluxParallelogram (const double x0, const double y0, const double z0, const double dx1, const double dy1, const double dz1, const double dx2, const double dy2, const double dz2, const unsigned int nU=20, const unsigned int nV=20)
 
double IntegrateWeightingFluxParallelogram (const std::string &label, const double x0, const double y0, const double z0, const double dx1, const double dy1, const double dz1, const double dx2, const double dy2, const double dz2, const unsigned int nU=20, const unsigned int nV=20)
 
double IntegrateFluxLine (const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, const double xp, const double yp, const double zp, const unsigned int nI, const int isign=0)
 
virtual bool CrossedWire (const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, double &xc, double &yc, double &zc, const bool centre, double &rc)
 
virtual bool InTrapRadius (const double q0, const double x0, const double y0, const double z0, double &xw, double &yw, double &rw)
 
virtual bool CrossedPlane (const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, double &xc, double &yc, double &zc)
 
void EnablePeriodicityX (const bool on=true)
 Enable simple periodicity in the $x$ direction.
 
void EnablePeriodicityY (const bool on=true)
 Enable simple periodicity in the $y$ direction.
 
void EnablePeriodicityZ (const bool on=true)
 Enable simple periodicity in the $z$ direction.
 
void IsPeriodic (bool &perx, bool &pery, bool &perz)
 Return periodicity flags.
 
void EnableMirrorPeriodicityX (const bool on=true)
 Enable mirror periodicity in the $x$ direction.
 
void EnableMirrorPeriodicityY (const bool on=true)
 Enable mirror periodicity in the $y$ direction.
 
void EnableMirrorPeriodicityZ (const bool on=true)
 Enable mirror periodicity in the $y$ direction.
 
void IsMirrorPeriodic (bool &perx, bool &pery, bool &perz)
 Return mirror periodicity flags.
 
void EnableAxialPeriodicityX (const bool on=true)
 Enable axial periodicity in the $x$ direction.
 
void EnableAxialPeriodicityY (const bool on=true)
 Enable axial periodicity in the $y$ direction.
 
void EnableAxialPeriodicityZ (const bool on=true)
 Enable axial periodicity in the $z$ direction.
 
void IsAxiallyPeriodic (bool &perx, bool &pery, bool &perz)
 Return axial periodicity flags.
 
void EnableRotationSymmetryX (const bool on=true)
 Enable rotation symmetry around the $x$ axis.
 
void EnableRotationSymmetryY (const bool on=true)
 Enable rotation symmetry around the $y$ axis.
 
void EnableRotationSymmetryZ (const bool on=true)
 Enable rotation symmetry around the $z$ axis.
 
void IsRotationSymmetric (bool &rotx, bool &roty, bool &rotz)
 Return rotation symmetry flags.
 
void EnableDebugging ()
 Switch on debugging messages.
 
void DisableDebugging ()
 Switch off debugging messages.
 
virtual bool HasTownsendMap () const
 Does the component have maps of the Townsend coefficient?
 
virtual bool ElectronTownsend (const double, const double, const double, double &alpha)
 Get the electron Townsend coefficient.
 
virtual bool HoleTownsend (const double, const double, const double, double &alpha)
 Get the hole Townsend coefficient.
 
virtual bool GetElectronLifetime (const double, const double, const double, double &etau)
 
virtual bool GetHoleLifetime (const double, const double, const double, double &htau)
 
virtual double StepSizeHint ()
 

Additional Inherited Members

- Protected Attributes inherited from Garfield::Component
std::string m_className = "Component"
 Class name.
 
Geometry * m_geometry = nullptr
 Pointer to the geometry.
 
std::array< double, 3 > m_b0 = {{0., 0., 0.}}
 Constant magnetic field.
 
bool m_ready = false
 Ready for use?
 
bool m_debug = false
 Switch on/off debugging messages.
 
std::array< bool, 3 > m_periodic = {{false, false, false}}
 Simple periodicity in x, y, z.
 
std::array< bool, 3 > m_mirrorPeriodic = {{false, false, false}}
 Mirror periodicity in x, y, z.
 
std::array< bool, 3 > m_axiallyPeriodic = {{false, false, false}}
 Axial periodicity in x, y, z.
 
std::array< bool, 3 > m_rotationSymmetric = {{false, false, false}}
 Rotation symmetry around x-axis, y-axis, z-axis.
 

Detailed Description

Component for interpolating field maps on a regular mesh.

Definition at line 12 of file ComponentGrid.hh.

Constructor & Destructor Documentation

◆ ComponentGrid()

Garfield::ComponentGrid::ComponentGrid ( )

Constructor.

Definition at line 54 of file ComponentGrid.cc.

54: Component("Grid") {}
Garfield::Component::Component
Component()=delete
Default constructor.

◆ ~ComponentGrid()

Garfield::ComponentGrid::~ComponentGrid ( )
inline

Destructor.

Definition at line 17 of file ComponentGrid.hh.

17{}

Member Function Documentation

◆ Clear()

void Garfield::ComponentGrid::Clear ( )
inlineoverridevirtual

Reset.

Reimplemented from Garfield::Component.

Definition at line 145 of file ComponentGrid.hh.

145{ Reset(); }

◆ DelayedWeightingField()

void Garfield::ComponentGrid::DelayedWeightingField ( const double x,
const double y,
const double z,
const double t,
double & wx,
double & wy,
double & wz,
const std::string & label )
overridevirtual

Calculate the delayed weighting field at a given point and time and for a given electrode.

Parameters
x,y,zcoordinates [cm].
ttime [ns].
wx,wy,wzcomponents of the weighting field [1/cm].
labelname of the electrode

Reimplemented from Garfield::Component.

Definition at line 118 of file ComponentGrid.cc.

121 {
122 wx = wy = wz = 0.;
123 if (m_wdtimes.empty()) return;
124 // Assume no weighting field for times outside the range of available maps.
125 if (t < m_wdtimes.front() || t > m_wdtimes.back()) return;
126
127 const double xx = x - m_wFieldOffset[0];
128 const double yy = y - m_wFieldOffset[1];
129 const double zz = z - m_wFieldOffset[2];
130
131 const auto it1 = std::upper_bound(m_wdtimes.cbegin(), m_wdtimes.cend(), t);
132 const auto it0 = std::prev(it1);
133
134 const double dt = t - *it0;
135 double wp = 0.;
136 const unsigned int i0 = it0 - m_wdtimes.cbegin();
137 double wx0 = 0., wy0 = 0., wz0 = 0.;
138 bool active = true;
139 if (!GetField(xx, yy, zz, m_wdfields[i0], wx0, wy0, wz0, wp, active)) return;
140
141 if (dt < Small || it1 == m_wdtimes.cend()) {
142 wx = wx0;
143 wy = wy0;
144 wz = wz0;
145 return;
146 }
147 const unsigned int i1 = it1 - m_wdtimes.cbegin();
148 double wx1 = 0., wy1 = 0., wz1 = 0.;
149 if (!GetField(xx, yy, zz, m_wdfields[i1], wx1, wy1, wz1, wp, active)) return;
150
151 const double f1 = dt / (*it1 - *it0);
152 const double f0 = 1. - f1;
153 wx = f0 * wx0 + f1 * wx1;
154 wy = f0 * wy0 + f1 * wy1;
155 wz = f0 * wz0 + f1 * wz1;
156}

◆ DelayedWeightingPotential()

double Garfield::ComponentGrid::DelayedWeightingPotential ( const double x,
const double y,
const double z,
const double t,
const std::string & label )
overridevirtual

Calculate the delayed weighting potential at a given point and time and for a given electrode.

Parameters
x,y,zcoordinates [cm].
ttime [ns].
labelname of the electrode

Reimplemented from Garfield::Component.

Definition at line 158 of file ComponentGrid.cc.

160 {
161
162 if (m_wdtimes.empty()) return 0.;
163 // Outside the range of the available maps?
164 if (t < m_wdtimes.front() || t > m_wdtimes.back()) return 0.;
165
166 const double xx = x - m_wFieldOffset[0];
167 const double yy = y - m_wFieldOffset[1];
168 const double zz = z - m_wFieldOffset[2];
169
170 const auto it1 = std::upper_bound(m_wdtimes.cbegin(), m_wdtimes.cend(), t);
171 const auto it0 = std::prev(it1);
172
173 const double dt = t - *it0;
174 const unsigned int i0 = it0 - m_wdtimes.cbegin();
175 double wp0 = 0., wx0 = 0., wy0 = 0., wz0 = 0.;
176 bool active = true;
177 if (!GetField(xx, yy, zz, m_wdfields[i0], wx0, wy0, wz0, wp0, active)) return 0.;
178
179 if (dt < Small || it1 == m_wdtimes.cend()) return wp0;
180
181 const unsigned int i1 = it1 - m_wdtimes.cbegin();
182 double wp1 = 0., wx1 = 0., wy1 = 0., wz1 = 0.;
183 if (!GetField(xx, yy, zz, m_wdfields[i1], wx1, wy1, wz1, wp1, active)) return 0.;
184
185 const double f1 = dt / (*it1 - *it0);
186 const double f0 = 1. - f1;
187 return f0 * wp0 + f1 * wp1;
188}

◆ ElectricField() [1/3]

std::array< double, 3 > Garfield::Component::ElectricField ( const double x,
const double y,
const double z )

Calculate the drift field [V/cm] at (x, y, z).

Definition at line 55 of file Component.cc.

43 {
44 double ex = 0., ey = 0., ez = 0.;
45 Medium* medium = nullptr;
46 int status = 0;
47 ElectricField(x, y, z, ex, ey, ez, medium, status);
48 std::array<double, 3> efield = {ex, ey, ez};
49 return efield;
50}
Garfield::ComponentGrid::ElectricField
void ElectricField(const double x, const double y, const double z, double &ex, double &ey, double &ez, double &v, Medium *&m, int &status) override
Calculate the drift field [V/cm] and potential [V] at (x, y, z).
Definition ComponentGrid.cc:56

◆ ElectricField() [2/3]

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

Calculate the drift field [V/cm] and potential [V] at (x, y, z).

Implements Garfield::Component.

Definition at line 56 of file ComponentGrid.cc.

59 {
60 m = nullptr;
61 status = 0;
62
63 // Make sure the field map has been loaded.
64 if (m_efields.empty()) {
65 PrintNotReady(m_className + "::ElectricField");
66 status = -10;
67 return;
68 }
69
70 status = 0;
71 bool active = true;
72 if (!GetField(x, y, z, m_efields, ex, ey, ez, p, active)) {
73 status = -11;
74 return;
75 }
76 if (!active) {
77 status = -5;
78 return;
79 }
80 m = m_medium;
81 if (!m) status = -5;
82}
Garfield::Component::m_className
std::string m_className
Class name.
Definition Component.hh:359

Referenced by ElectricField().

◆ ElectricField() [3/3]

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

Calculate the drift field at given point.

Parameters
x,y,zcoordinates [cm].
ex,ey,ezcomponents of the electric field [V/cm].
mpointer to the medium at this location.
statusstatus 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::Component.

Definition at line 84 of file ComponentGrid.cc.

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

◆ ElectronAttachment()

bool Garfield::ComponentGrid::ElectronAttachment ( const double ,
const double ,
const double ,
double & eta )
overridevirtual

Get the electron attachment coefficient.

Reimplemented from Garfield::Component.

Definition at line 1928 of file ComponentGrid.cc.

1929 {
1930 // Make sure the map has been loaded.
1931 if (m_eAttachment.empty()) {
1932 PrintNotReady(m_className + "::ElectronAttachment");
1933 return false;
1934 }
1935 return GetData(x, y, z, m_eAttachment, att);
1936}

◆ ElectronVelocity()

bool Garfield::ComponentGrid::ElectronVelocity ( const double ,
const double ,
const double ,
double & vx,
double & vy,
double & vz )
overridevirtual

Get the electron drift velocity.

Reimplemented from Garfield::Component.

Definition at line 1601 of file ComponentGrid.cc.

1603 {
1604 if (m_eVelocity.empty()) {
1605 PrintNotReady(m_className + "::ElectronVelocity");
1606 return false;
1607 }
1608 double p = 0.;
1609 bool active = true;
1610 return GetField(x, y, z, m_eVelocity, vx, vy, vz, p, active);
1611}

◆ GetBoundingBox()

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

Get the bounding box coordinates.

Reimplemented from Garfield::Component.

Definition at line 1213 of file ComponentGrid.cc.

1214 {
1215 if (m_efields.empty() && m_wfields.empty() && m_bfields.empty()) {
1216 return false;
1217 }
1218 if (m_coordinates == Coordinates::Cylindrical) {
1219 const double rmax = m_xMax[0];
1220 xmin = -rmax;
1221 ymin = -rmax;
1222 xmax = +rmax;
1223 ymax = +rmax;
1224 zmin = (m_periodic[2] || m_mirrorPeriodic[2]) ? -INFINITY : m_xMin[2];
1225 zmax = (m_periodic[2] || m_mirrorPeriodic[2]) ? +INFINITY : m_xMax[2];
1226 return true;
1227 }
1228 if (m_periodic[0] || m_mirrorPeriodic[0]) {
1229 xmin = -INFINITY;
1230 xmax = +INFINITY;
1231 } else {
1232 xmin = m_xMin[0];
1233 xmax = m_xMax[0];
1234 }
1235
1236 if (m_periodic[1] || m_mirrorPeriodic[1]) {
1237 ymin = -INFINITY;
1238 ymax = +INFINITY;
1239 } else {
1240 ymin = m_xMin[1];
1241 ymax = m_xMax[1];
1242 }
1243
1244 if (m_periodic[2] || m_mirrorPeriodic[2]) {
1245 zmin = -INFINITY;
1246 zmax = +INFINITY;
1247 } else {
1248 zmin = m_xMin[2];
1249 zmax = m_xMax[2];
1250 }
1251 return true;
1252}
Garfield::Component::m_mirrorPeriodic
std::array< bool, 3 > m_mirrorPeriodic
Mirror periodicity in x, y, z.
Definition Component.hh:376
Garfield::Component::m_periodic
std::array< bool, 3 > m_periodic
Simple periodicity in x, y, z.
Definition Component.hh:374

◆ GetElectricField()

bool Garfield::ComponentGrid::GetElectricField ( const unsigned int i,
const unsigned int j,
const unsigned int k,
double & v,
double & ex,
double & ey,
double & ez ) const

Return the field at a given node.

Definition at line 1423 of file ComponentGrid.cc.

1425 {
1426 v = ex = ey = ez = 0.;
1427 if (m_efields.empty()) {
1428 if (!m_hasMesh) {
1429 std::cerr << m_className << "::GetElectricField: Mesh not set.\n";
1430 return false;
1431 }
1432 PrintNotReady(m_className + "::GetElectricField");
1433 return false;
1434 }
1435 if (i >= m_nX[0] || j >= m_nX[1] || k >= m_nX[2]) {
1436 std::cerr << m_className << "::GetElectricField: Index out of range.\n";
1437 return false;
1438 }
1439 const Node& node = m_efields[i][j][k];
1440 v = node.v;
1441 ex = node.fx;
1442 ey = node.fy;
1443 ez = node.fz;
1444 return true;
1445}

◆ GetElectricFieldRange()

bool Garfield::ComponentGrid::GetElectricFieldRange ( double & exmin,
double & exmax,
double & eymin,
double & eymax,
double & ezmin,
double & ezmax )

Definition at line 1285 of file ComponentGrid.cc.

1287 {
1288 if (m_efields.empty()) {
1289 PrintNotReady(m_className + "::GetElectricFieldRange");
1290 return false;
1291 }
1292
1293 exmin = exmax = m_efields[0][0][0].fx;
1294 eymin = eymax = m_efields[0][0][0].fy;
1295 ezmin = ezmax = m_efields[0][0][0].fz;
1296 for (unsigned int i = 0; i < m_nX[0]; ++i) {
1297 for (unsigned int j = 0; j < m_nX[1]; ++j) {
1298 for (unsigned int k = 0; k < m_nX[2]; ++k) {
1299 const Node& node = m_efields[i][j][k];
1300 if (node.fx < exmin) exmin = node.fx;
1301 if (node.fx > exmax) exmax = node.fx;
1302 if (node.fy < eymin) eymin = node.fy;
1303 if (node.fy > eymax) eymax = node.fy;
1304 if (node.fz < ezmin) ezmin = node.fz;
1305 if (node.fz > ezmax) ezmax = node.fz;
1306 }
1307 }
1308 }
1309 return true;
1310}

◆ GetElementaryCell()

bool Garfield::ComponentGrid::GetElementaryCell ( double & xmin,
double & ymin,
double & zmin,
double & xmax,
double & ymax,
double & zmax )
overridevirtual

Get the coordinates of the elementary cell.

Reimplemented from Garfield::Component.

Definition at line 1254 of file ComponentGrid.cc.

1256 {
1257
1258 if (m_efields.empty() && m_wfields.empty() && m_bfields.empty()) {
1259 return false;
1260 }
1261 if (m_coordinates == Coordinates::Cylindrical) {
1262 const double rmax = m_xMax[0];
1263 xmin = -rmax;
1264 ymin = -rmax;
1265 xmax = +rmax;
1266 ymax = +rmax;
1267 } else {
1268 xmin = m_xMin[0];
1269 xmax = m_xMax[0];
1270 ymin = m_xMin[1];
1271 ymax = m_xMax[1];
1272 }
1273 zmin = m_xMin[2];
1274 zmax = m_xMax[2];
1275 return true;
1276}

◆ GetMedium() [1/2]

Medium * Garfield::ComponentGrid::GetMedium ( ) const
inline

Get the medium.

Definition at line 108 of file ComponentGrid.hh.

108{ return m_medium; }

◆ GetMedium() [2/2]

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

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

Reimplemented from Garfield::Component.

Definition at line 214 of file ComponentGrid.cc.

215 {
216 // Make sure the field map has been loaded.
217 if (m_efields.empty()) {
218 PrintNotReady(m_className + "::GetMedium");
219 return nullptr;
220 }
221
222 std::array<double, 3> xx = {x, y, z};
223 if (m_coordinates == Coordinates::Cylindrical) {
224 if (fabs(x) > Small || fabs(y) > Small) {
225 xx[0] = sqrt(x * x + y * y);
226 xx[1] = atan2(y, x);
227 }
228 }
229 for (size_t i = 0; i < 3; ++i) {
230 if (m_periodic[i] || m_mirrorPeriodic[i]) continue;
231 if (xx[i] < m_xMin[i] || xx[i] > m_xMax[i]) return nullptr;
232 }
233 if (m_active.empty()) return m_medium;
234 for (size_t i = 0; i < 3; ++i) {
235 bool mirrored = false;
236 xx[i] = Reduce(xx[i], m_xMin[i], m_xMax[i],
237 m_periodic[i], m_mirrorPeriodic[i], mirrored);
238 }
239 // Get the indices.
240 const double sx = (xx[0] - m_xMin[0]) * m_sX[0];
241 const double sy = (xx[1] - m_xMin[1]) * m_sX[1];
242 const double sz = (xx[2] - m_xMin[2]) * m_sX[2];
243 const unsigned int i0 = static_cast<unsigned int>(std::floor(sx));
244 const unsigned int j0 = static_cast<unsigned int>(std::floor(sy));
245 const unsigned int k0 = static_cast<unsigned int>(std::floor(sz));
246 const unsigned int i1 = std::min(i0 + 1, m_nX[0] - 1);
247 const unsigned int j1 = std::min(j0 + 1, m_nX[1] - 1);
248 const unsigned int k1 = std::min(k0 + 1, m_nX[2] - 1);
249 if (m_active[i0][j0][k0] && m_active[i0][j0][k1] && m_active[i0][j1][k0] &&
250 m_active[i0][j1][k1] && m_active[i1][j0][k0] && m_active[i1][j0][k1] &&
251 m_active[i1][j1][k0] && m_active[i1][j1][k1]) {
252 return m_medium;
253 }
254 return nullptr;
255}
Heed::fabs
DoubleAc fabs(const DoubleAc &f)
Definition DoubleAc.h:615
Heed::sqrt
DoubleAc sqrt(const DoubleAc &f)
Definition DoubleAc.cpp:314

◆ GetMesh()

bool Garfield::ComponentGrid::GetMesh ( unsigned int & nx,
unsigned int & ny,
unsigned int & nz,
double & xmin,
double & xmax,
double & ymin,
double & ymax,
double & zmin,
double & zmax ) const

Retrieve the parameters of the grid.

Definition at line 315 of file ComponentGrid.cc.

318 {
319 if (!m_hasMesh) return false;
320 nx = m_nX[0];
321 ny = m_nX[1];
322 nz = m_nX[2];
323 xmin = m_xMin[0];
324 ymin = m_xMin[1];
325 zmin = m_xMin[2];
326 xmax = m_xMax[0];
327 ymax = m_xMax[1];
328 zmax = m_xMax[2];
329 return true;
330}

◆ GetVoltageRange()

bool Garfield::ComponentGrid::GetVoltageRange ( double & vmin,
double & vmax )
overridevirtual

Calculate the voltage range [V].

Implements Garfield::Component.

Definition at line 1278 of file ComponentGrid.cc.

1278 {
1279 if (m_efields.empty()) return false;
1280 vmin = m_pMin;
1281 vmax = m_pMax;
1282 return true;
1283}

◆ HasAttachmentMap()

bool Garfield::ComponentGrid::HasAttachmentMap ( ) const
inlineoverridevirtual

Does the component have attachment maps?

Reimplemented from Garfield::Component.

Definition at line 178 of file ComponentGrid.hh.

178 {
179 return !(m_eAttachment.empty() && m_hAttachment.empty());
180 }

◆ HasMagneticField()

bool Garfield::ComponentGrid::HasMagneticField ( ) const
overridevirtual

Does the component have a non-zero magnetic field?

Reimplemented from Garfield::Component.

Definition at line 210 of file ComponentGrid.cc.

210 {
211 return m_bfields.empty() ? Component::HasMagneticField() : true;
212}
Garfield::Component::HasMagneticField
virtual bool HasMagneticField() const
Does the component have a non-zero magnetic field?
Definition Component.cc:155

◆ HasVelocityMap()

bool Garfield::ComponentGrid::HasVelocityMap ( ) const
inlineoverridevirtual

Does the component have velocity maps?

Reimplemented from Garfield::Component.

Definition at line 186 of file ComponentGrid.hh.

186 {
187 return !(m_eVelocity.empty() && m_hVelocity.empty());
188 }

◆ HoleAttachment()

bool Garfield::ComponentGrid::HoleAttachment ( const double ,
const double ,
const double ,
double & eta )
overridevirtual

Get the hole attachment coefficient.

Reimplemented from Garfield::Component.

Definition at line 1938 of file ComponentGrid.cc.

1939 {
1940 // Make sure the map has been loaded.
1941 if (m_hAttachment.empty()) {
1942 PrintNotReady(m_className + "::HoleAttachment");
1943 return false;
1944 }
1945 return GetData(x, y, z, m_hAttachment, att);
1946}

◆ HoleVelocity()

bool Garfield::ComponentGrid::HoleVelocity ( const double ,
const double ,
const double ,
double & vx,
double & vy,
double & vz )
overridevirtual

Get the hole drift velocity.

Reimplemented from Garfield::Component.

Definition at line 1613 of file ComponentGrid.cc.

1615 {
1616 if (m_hVelocity.empty()) {
1617 PrintNotReady(m_className + "::HoleVelocity");
1618 return false;
1619 }
1620 double p = 0.;
1621 bool active = true;
1622 return GetField(x, y, z, m_hVelocity, vx, vy, vz, p, active);
1623}

◆ LoadElectricField()

bool Garfield::ComponentGrid::LoadElectricField ( const std::string & filename,
const std::string & format,
const bool withPotential,
const bool withFlag,
const double scaleX = 1.,
const double scaleE = 1.,
const double scaleP = 1. )

Import electric field and potential values from a file. The file is supposed to contain one line for each grid point starting with

  • either two or three floating point numbers, specifying the coordinates (in cm) of the grid node or
  • two or three integers specifying the index of the node,

followed by

  • two or three floating point numbers for the electric field (in V/cm), and (depending on the value of withPotential and withFlag),
  • a floating point number specifying the potential (in V), and
  • an integer flag indicating whether the point is in an active region (1) or not (0).

Format types are:

  • "xy", "xz", "xyz": nodes are specified by their coordinates
  • "ij", "ik", "ijk": nodes are specified by their indices

If cylindrical coordinates are used, the first coordinate (x) corresponds to the radial distance and the second coordinate (y) corresponds to the azimuth (in radian).

Definition at line 352 of file ComponentGrid.cc.

356 {
357 m_efields.clear();
358 m_hasPotential = false;
359 m_active.assign(m_nX[0], std::vector<std::vector<bool> >(
360 m_nX[1], std::vector<bool>(m_nX[2], true)));
361 // Read the file.
362 m_pMin = withP ? +1. : 0.;
363 m_pMax = withP ? -1. : 0.;
364 if (!LoadData(fname, fmt, withP, withFlag, scaleX, scaleE, scaleP,
365 m_efields)) {
366 m_efields.clear();
367 return false;
368 }
369 if (withP) m_hasPotential = true;
370 return true;
371}

◆ LoadElectronAttachment()

bool Garfield::ComponentGrid::LoadElectronAttachment ( const std::string & fname,
const std::string & fmt,
const unsigned int col,
const double scaleX = 1. )

Import electron attachment coefficients from a file.

Parameters
fnamename of the text file.
fmtformat string, see LoadElectricField.
colcolumn in the file which has the attachment coefficient.
scaleXscaling factor to be applied to the coordinates.

Definition at line 1625 of file ComponentGrid.cc.

1628 {
1629 // Read the file.
1630 return LoadData(fname, fmt, scaleX, m_eAttachment, col);
1631}

◆ LoadElectronVelocity()

bool Garfield::ComponentGrid::LoadElectronVelocity ( const std::string & fname,
const std::string & fmt,
const double scaleX = 1.,
const double scaleV = 1.e-9 )

Import a map of electron drift velocities from a file.

Parameters
fnamename of the text file.
fmtformat string, see LoadElectricField
scaleXscaling factor to be applied to the coordinates.
scaleVscaling factor to be applied to the velocity components.

Definition at line 1579 of file ComponentGrid.cc.

1582 {
1583 // Read the file.
1584 if (!LoadData(fname, fmt, false, false, scaleX, scaleV, 1., m_eVelocity)) {
1585 return false;
1586 }
1587 return true;
1588}

◆ LoadHoleAttachment()

bool Garfield::ComponentGrid::LoadHoleAttachment ( const std::string & fname,
const std::string & fmt,
const unsigned int col,
const double scaleX = 1. )

Import hole attachment coefficients from a file.

Definition at line 1633 of file ComponentGrid.cc.

1636 {
1637 // Read the file.
1638 return LoadData(fname, fmt, scaleX, m_hAttachment, col);
1639}

◆ LoadHoleVelocity()

bool Garfield::ComponentGrid::LoadHoleVelocity ( const std::string & fname,
const std::string & fmt,
const double scaleX = 1.,
const double scaleV = 1.e-9 )

Import a map of hole drift velocities from a file.

Definition at line 1590 of file ComponentGrid.cc.

1593 {
1594 // Read the file.
1595 if (!LoadData(fname, fmt, false, false, scaleX, scaleV, 1., m_hVelocity)) {
1596 return false;
1597 }
1598 return true;
1599}

◆ LoadMagneticField()

bool Garfield::ComponentGrid::LoadMagneticField ( const std::string & filename,
const std::string & format,
const double scaleX = 1.,
const double scaleB = 1. )

Import magnetic field values from a file.

Definition at line 407 of file ComponentGrid.cc.

410 {
411 // Read the file.
412 if (!LoadData(fname, fmt, false, false, scaleX, scaleB, 1., m_bfields)) {
413 m_bfields.clear();
414 return false;
415 }
416 return true;
417}

◆ LoadWeightingField() [1/2]

bool Garfield::ComponentGrid::LoadWeightingField ( const std::string & filename,
const std::string & format,
const bool withPotential,
const double scaleX = 1.,
const double scaleE = 1.,
const double scaleP = 1. )

Import (prompt) weighting field from file.

Definition at line 373 of file ComponentGrid.cc.

376 {
377 // Read the file.
378 if (!LoadData(fname, fmt, withP, false, scaleX, scaleE, scaleP, m_wfields)) {
379 m_wfields.clear();
380 return false;
381 }
382 return true;
383}

Referenced by main().

◆ LoadWeightingField() [2/2]

bool Garfield::ComponentGrid::LoadWeightingField ( const std::string & filename,
const std::string & format,
const double time,
const bool withPotential,
const double scaleX = 1.,
const double scaleE = 1.,
const double scaleP = 1. )

Import delayed weighting field from file.

Definition at line 385 of file ComponentGrid.cc.

389 {
390 std::vector<std::vector<std::vector<Node> > > wfield;
391 // Read the file.
392 if (!LoadData(fname, fmt, withP, false, scaleX, scaleE, scaleP, wfield)) {
393 return false;
394 }
395 if (m_wdtimes.empty() || t > m_wdtimes.back()) {
396 m_wdtimes.push_back(t);
397 m_wdfields.push_back(std::move(wfield));
398 } else {
399 const auto it = std::upper_bound(m_wdtimes.begin(), m_wdtimes.end(), t);
400 const auto n = std::distance(m_wdtimes.begin(), it);
401 m_wdtimes.insert(it, t);
402 m_wdfields.insert( m_wdfields.begin() + n, std::move(wfield));
403 }
404 return true;
405}

◆ MagneticField()

void Garfield::ComponentGrid::MagneticField ( const double x,
const double y,
const double z,
double & bx,
double & by,
double & bz,
int & status )
overridevirtual

Calculate the magnetic field at a given point.

Parameters
x,y,zcoordinates [cm].
bx,by,bzcomponents of the magnetic field [Tesla].
statusstatus flag.

Reimplemented from Garfield::Component.

Definition at line 195 of file ComponentGrid.cc.

197 {
198 status = 0;
199 if (m_bfields.empty()) {
200 return Component::MagneticField(x, y, z, bx, by, bz, status);
201 }
202
203 double p = 0.;
204 bool active = true;
205 if (!GetField(x, y, z, m_bfields, bx, by, bz, p, active)) {
206 status = -11;
207 }
208}
Garfield::Component::MagneticField
virtual void MagneticField(const double x, const double y, const double z, double &bx, double &by, double &bz, int &status)
Definition Component.cc:102

◆ Print()

void Garfield::ComponentGrid::Print ( )

Print information about the mesh and the available data.

Definition at line 1447 of file ComponentGrid.cc.

1447 {
1448
1449 std::cout << m_className << "::Print:\n";
1450 if (!m_hasMesh) {
1451 std::cout << " Mesh not set.\n";
1452 return;
1453 }
1454 std::printf(" %15.8f < x [cm] < %15.8f, %10u nodes\n",
1455 m_xMin[0], m_xMax[0], m_nX[0]);
1456 std::printf(" %15.8f < y [cm] < %15.8f, %10u nodes\n",
1457 m_xMin[1], m_xMax[1], m_nX[1]);
1458 std::printf(" %15.8f < z [cm] < %15.8f, %10u nodes\n",
1459 m_xMin[2], m_xMax[2], m_nX[2]);
1460 if (m_efields.empty() && m_bfields.empty() &&
1461 m_wfields.empty() && m_wdfields.empty() &&
1462 m_eAttachment.empty() && m_hAttachment.empty() &&
1463 m_eVelocity.empty() && m_hVelocity.empty()) {
1464 std::cout << " Available data: None.\n";
1465 return;
1466 }
1467 std::cout << " Available data:\n";
1468 if (!m_efields.empty()) std::cout << " Electric field.\n";
1469 if (!m_bfields.empty()) std::cout << " Magnetic field.\n";
1470 if (!m_wfields.empty()) std::cout << " Weighting field.\n";
1471 if (!m_wdfields.empty()) {
1472 std::cout << " Delayed weighting field.\n";
1473 }
1474 if (!m_eVelocity.empty()) {
1475 std::cout << " Electron drift velocity.\n";
1476 }
1477 if (!m_hVelocity.empty()) {
1478 std::cout << " Hole drift velocity.\n";
1479 }
1480 if (!m_eAttachment.empty()) {
1481 std::cout << " Electron attachment coefficient.\n";
1482 }
1483 if (!m_hAttachment.empty()) {
1484 std::cout << " Hole attachment coefficient.\n";
1485 }
1486}

Referenced by main().

◆ SaveElectricField()

bool Garfield::ComponentGrid::SaveElectricField ( Component * cmp,
const std::string & filename,
const std::string & fmt )

Export the electric field and potential of a component to a text file.

Parameters
cmpComponent object for which to export the field/potential
filenamename of the text file
fmtformat string, see LoadElectricField

Definition at line 419 of file ComponentGrid.cc.

421 {
422 if (!cmp) {
423 std::cerr << m_className << "::SaveElectricField: Null pointer.\n";
424 return false;
425 }
426 if (!m_hasMesh) {
427 std::cerr << m_className << "::SaveElectricField: Mesh not set.\n";
428 return false;
429 }
430 const auto fmt = GetFormat(format);
431 if (fmt == Format::Unknown) {
432 std::cerr << m_className << "::SaveElectricField:\n"
433 << " Unknown format (" << format << ").\n";
434 return false;
435 }
436 std::ofstream outfile;
437 outfile.open(filename, std::ios::out);
438 if (!outfile) {
439 std::cerr << m_className << "::SaveElectricField:\n"
440 << " Could not open file " << filename << ".\n";
441 return false;
442 }
443 std::cout << m_className << "::SaveElectricField:\n"
444 << " Exporting field/potential to " << filename << ".\n"
445 << " Be patient...\n";
446 PrintProgress(0.);
447 outfile << "# XMIN = " << m_xMin[0] << ", XMAX = " << m_xMax[0]
448 << ", NX = " << m_nX[0] << "\n";
449 outfile << "# YMIN = " << m_xMin[1] << ", YMAX = " << m_xMax[1]
450 << ", NY = " << m_nX[1] << "\n";
451 outfile << "# ZMIN = " << m_xMin[2] << ", ZMAX = " << m_xMax[2]
452 << ", NZ = " << m_nX[2] << "\n";
453
454 const unsigned int nValues = m_nX[0] * m_nX[1] * m_nX[2];
455 const unsigned int nPrint =
456 std::pow(10, static_cast<unsigned int>(
457 std::max(std::floor(std::log10(nValues)) - 1, 1.)));
458 unsigned int nLines = 0;
459 Medium* medium = nullptr;
460 int status = 0;
461 const double dx = (m_xMax[0] - m_xMin[0]) / std::max(m_nX[0] - 1., 1.);
462 const double dy = (m_xMax[1] - m_xMin[1]) / std::max(m_nX[1] - 1., 1.);
463 const double dz = (m_xMax[2] - m_xMin[2]) / std::max(m_nX[2] - 1., 1.);
464 for (unsigned int i = 0; i < m_nX[0]; ++i) {
465 const double x = m_xMin[0] + i * dx;
466 for (unsigned int j = 0; j < m_nX[1]; ++j) {
467 const double y = m_xMin[1] + j * dy;
468 for (unsigned int k = 0; k < m_nX[2]; ++k) {
469 const double z = m_xMin[2] + k * dz;
470 if (fmt == Format::XY) {
471 outfile << x << " " << y << " ";
472 } else if (fmt == Format::XZ) {
473 outfile << x << " " << z << " ";
474 } else if (fmt == Format::XYZ) {
475 outfile << x << " " << y << " " << z << " ";
476 } else if (fmt == Format::IJ) {
477 outfile << i << " " << j << " ";
478 } else if (fmt == Format::IK) {
479 outfile << i << " " << k << " ";
480 } else if (fmt == Format::IJK) {
481 outfile << i << " " << j << " " << k << " ";
482 } else if (fmt == Format::YXZ) {
483 outfile << y << " " << x << " " << z << " ";
484 }
485 if (m_coordinates == Coordinates::Cylindrical) {
486 const double ct = cos(y);
487 const double st = sin(y);
488 double ex = 0., ey = 0., ez = 0., v = 0.;
489 cmp->ElectricField(x * ct, x * st, z, ex, ey, ez, v, medium, status);
490 const double er = +ex * ct + ey * st;
491 const double et = -ex * st + ey * ct;
492 outfile << er << " " << et << " " << ez << " " << v << "\n";
493 } else {
494 double ex = 0., ey = 0., ez = 0., v = 0.;
495 cmp->ElectricField(x, y, z, ex, ey, ez, v, medium, status);
496 outfile << ex << " " << ey << " " << ez << " " << v << "\n";
497 }
498 ++nLines;
499 if (nLines % nPrint == 0) PrintProgress(double(nLines) / nValues);
500 }
501 }
502 }
503 outfile.close();
504 std::cout << std::endl << m_className << "::SaveElectricField: Done.\n";
505 return true;
506}
Heed::cos
DoubleAc cos(const DoubleAc &f)
Definition DoubleAc.cpp:432
Heed::sin
DoubleAc sin(const DoubleAc &f)
Definition DoubleAc.cpp:384

◆ SaveWeightingField()

bool Garfield::ComponentGrid::SaveWeightingField ( Component * cmp,
const std::string & id,
const std::string & filename,
const std::string & fmt )

Export the weighting field and potential of a component to a text file.

Parameters
cmpComponent object for which to export the field/potential
ididentifier of the weighting field
filenamename of the text file
fmtformat string, see LoadElectricField

Definition at line 508 of file ComponentGrid.cc.

511 {
512 if (!cmp) {
513 std::cerr << m_className << "::SaveWeightingField: Null pointer.\n";
514 return false;
515 }
516 if (!m_hasMesh) {
517 std::cerr << m_className << "::SaveWeightingField: Mesh not set.\n";
518 return false;
519 }
520 const auto fmt = GetFormat(format);
521 if (fmt == Format::Unknown) {
522 std::cerr << m_className << "::SaveWeightingField:\n"
523 << " Unknown format (" << format << ").\n";
524 return false;
525 }
526 std::ofstream outfile;
527 outfile.open(filename, std::ios::out);
528 if (!outfile) {
529 std::cerr << m_className << "::SaveWeightingField:\n"
530 << " Could not open file " << filename << ".\n";
531 return false;
532 }
533 std::cout << m_className << "::SaveWeightingField:\n"
534 << " Exporting field/potential to " << filename << ".\n"
535 << " Be patient...\n";
536 PrintProgress(0.);
537 outfile << "# XMIN = " << m_xMin[0] << ", XMAX = " << m_xMax[0]
538 << ", NX = " << m_nX[0] << "\n";
539 outfile << "# YMIN = " << m_xMin[1] << ", YMAX = " << m_xMax[1]
540 << ", NY = " << m_nX[1] << "\n";
541 outfile << "# ZMIN = " << m_xMin[2] << ", ZMAX = " << m_xMax[2]
542 << ", NZ = " << m_nX[2] << "\n";
543 const unsigned int nValues = m_nX[0] * m_nX[1] * m_nX[2];
544 const unsigned int nPrint =
545 std::pow(10, static_cast<unsigned int>(
546 std::max(std::floor(std::log10(nValues)) - 1, 1.)));
547 unsigned int nLines = 0;
548 const double dx = (m_xMax[0] - m_xMin[0]) / std::max(m_nX[0] - 1., 1.);
549 const double dy = (m_xMax[1] - m_xMin[1]) / std::max(m_nX[1] - 1., 1.);
550 const double dz = (m_xMax[2] - m_xMin[2]) / std::max(m_nX[2] - 1., 1.);
551 for (unsigned int i = 0; i < m_nX[0]; ++i) {
552 const double x = m_xMin[0] + i * dx;
553 for (unsigned int j = 0; j < m_nX[1]; ++j) {
554 const double y = m_xMin[1] + j * dy;
555 for (unsigned int k = 0; k < m_nX[2]; ++k) {
556 const double z = m_xMin[2] + k * dz;
557 if (fmt == Format::XY) {
558 outfile << x << " " << y << " ";
559 } else if (fmt == Format::XZ) {
560 outfile << x << " " << z << " ";
561 } else if (fmt == Format::XYZ) {
562 outfile << x << " " << y << " " << z << " ";
563 } else if (fmt == Format::IJ) {
564 outfile << i << " " << j << " ";
565 } else if (fmt == Format::IK) {
566 outfile << i << " " << k << " ";
567 } else if (fmt == Format::IJK) {
568 outfile << i << " " << j << " " << k << " ";
569 } else if (fmt == Format::YXZ) {
570 outfile << y << " " << x << " " << z << " ";
571 }
572 if (m_coordinates == Coordinates::Cylindrical) {
573 const double ct = cos(y);
574 const double st = sin(y);
575 double wx = 0., wy = 0., wz = 0.;
576 cmp->WeightingField(x * ct, x * st, z, wx, wy, wz, id);
577 const double v = cmp->WeightingPotential(x * ct, x * st, z, id);
578 const double wr = +wx * ct + wy * st;
579 const double wt = -wx * st + wy * ct;
580 outfile << wr << " " << wt << " " << wz << " " << v << "\n";
581 } else {
582 double wx = 0., wy = 0., wz = 0.;
583 cmp->WeightingField(x, y, z, wx, wy, wz, id);
584 const double v = cmp->WeightingPotential(x, y, z, id);
585 outfile << wx << " " << wy << " " << wz << " " << v << "\n";
586 }
587 ++nLines;
588 if (nLines % nPrint == 0) PrintProgress(double(nLines) / nValues);
589 }
590 }
591 }
592 outfile.close();
593 std::cout << std::endl << m_className << "::SaveWeightingField: Done.\n";
594 return true;
595}

◆ SetCartesianCoordinates()

void Garfield::ComponentGrid::SetCartesianCoordinates ( )
inline

Use Cartesian coordinates (default).

Definition at line 34 of file ComponentGrid.hh.

34{ m_coordinates = Coordinates::Cartesian; }

◆ SetCylindricalCoordinates()

void Garfield::ComponentGrid::SetCylindricalCoordinates ( )

Use cylindrical coordinates.

Definition at line 332 of file ComponentGrid.cc.

332 {
333
334 if (m_xMin[0] < 0. || m_xMax[0] < 0.) {
335 std::cerr << m_className << "::SetCylindricalCoordinates:\n"
336 << " Invalid mesh limits. Radial coordinate must be >= 0.\n";
337 return;
338 }
339 if (m_periodic[1] || m_mirrorPeriodic[1]) {
340 const double s = m_xMax[1] - m_xMin[1];
341 if (std::abs(TwoPi - s * int(TwoPi / s)) > 1.e-4) {
342 std::cerr << m_className << "::SetCylindricalCoordinates:\n"
343 << " Angular range does not divide 2 pi.\n"
344 << " Switching off periodicity.\n";
345 m_periodic[1] = false;
346 m_mirrorPeriodic[1] = false;
347 }
348 }
349 m_coordinates = Coordinates::Cylindrical;
350}

◆ SetMedium()

void Garfield::ComponentGrid::SetMedium ( Medium * m)

Set the medium.

Definition at line 1312 of file ComponentGrid.cc.

1312 {
1313 if (!m) {
1314 std::cerr << m_className << "::SetMedium: Null pointer.\n";
1315 }
1316 m_medium = m;
1317}

◆ SetMesh()

bool Garfield::ComponentGrid::SetMesh ( const unsigned int nx,
const unsigned int ny,
const unsigned int nz,
const double xmin,
const double xmax,
const double ymin,
const double ymax,
const double zmin,
const double zmax )

Define the grid.

Parameters
nx,ny,nznumber of nodes along $x, y, z$.
xmin,xmaxrange along $x$.
ymin,ymaxrange along $y$.
zmin,zmaxrange along $z$.

Definition at line 257 of file ComponentGrid.cc.

261 {
262 Reset();
263 if (nx == 0 || ny == 0 || nz == 0) {
264 std::cerr << m_className << "::SetMesh:\n"
265 << " Number of mesh elements must be positive.\n";
266 return false;
267 }
268 if (xmin >= xmax) {
269 std::cerr << m_className << "::SetMesh: Invalid x range.\n";
270 return false;
271 } else if (ymin >= ymax) {
272 std::cerr << m_className << "::SetMesh: Invalid y range.\n";
273 return false;
274 } else if (zmin >= zmax) {
275 std::cerr << m_className << "::SetMesh: Invalid z range.\n";
276 return false;
277 }
278 if (m_coordinates == Coordinates::Cylindrical) {
279 if (xmin < 0.) {
280 std::cerr << m_className << "::SetMesh: Invalid range.\n"
281 << " Radial coordinates must be >= 0.\n";
282 return false;
283 }
284 }
285 m_nX[0] = nx;
286 m_nX[1] = ny;
287 m_nX[2] = nz;
288 m_xMin[0] = xmin;
289 m_xMin[1] = ymin;
290 m_xMin[2] = zmin;
291 m_xMax[0] = xmax;
292 m_xMax[1] = ymax;
293 m_xMax[2] = zmax;
294 constexpr double tol = 1.e-10;
295 for (size_t i = 0; i < 3; ++i) {
296 if (m_xMax[i] - m_xMin[i] > tol) {
297 m_sX[i] = std::max(m_nX[i] - 1., 1.) / (m_xMax[i] - m_xMin[i]);
298 } else {
299 m_sX[i] = 0.;
300 }
301 }
302 if (m_coordinates == Coordinates::Cylindrical) {
303 if (fabs(m_xMax[1] - m_xMin[1] - TwoPi) < tol) {
304 if (!m_periodic[1]) {
305 std::cerr << m_className << "::SetMesh: Enabling theta periodicity.\n";
306 }
307 m_periodic[1] = true;
308 m_mirrorPeriodic[1] = false;
309 }
310 }
311 m_hasMesh = true;
312 return true;
313}

◆ SetWeightingFieldOffset()

void Garfield::ComponentGrid::SetWeightingFieldOffset ( const double x,
const double y,
const double z )

Offset coordinates in the weighting field, such that the same numerical weighting field map can be used for electrodes at different positions.

Definition at line 190 of file ComponentGrid.cc.

191 {
192 m_wFieldOffset = {x, y, z};
193}

◆ WeightingField()

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

Calculate the weighting field at a given point and for a given electrode.

Parameters
x,y,zcoordinates [cm].
wx,wy,wzcomponents of the weighting field [1/cm].
labelname of the electrode

Reimplemented from Garfield::Component.

Definition at line 91 of file ComponentGrid.cc.

93 {
94 wx = wy = wz = 0.;
95 if (m_wfields.empty()) return;
96 const double xx = x - m_wFieldOffset[0];
97 const double yy = y - m_wFieldOffset[1];
98 const double zz = z - m_wFieldOffset[2];
99 double wp = 0.;
100 bool active = true;
101 GetField(xx, yy, zz, m_wfields, wx, wy, wz, wp, active);
102}

◆ WeightingPotential()

double Garfield::ComponentGrid::WeightingPotential ( const double x,
const double y,
const double z,
const std::string & label )
overridevirtual

Calculate the weighting potential at a given point.

Parameters
x,y,zcoordinates [cm].
labelname of the electrode.
Returns
weighting potential [dimensionless].

Reimplemented from Garfield::Component.

Definition at line 104 of file ComponentGrid.cc.

106 {
107 if (m_wfields.empty()) return 0.;
108 const double xx = x - m_wFieldOffset[0];
109 const double yy = y - m_wFieldOffset[1];
110 const double zz = z - m_wFieldOffset[2];
111 double wx = 0., wy = 0., wz = 0.;
112 double wp = 0.;
113 bool active = true;
114 if (!GetField(xx, yy, zz, m_wfields, wx, wy, wz, wp, active)) return 0.;
115 return wp;
116}
The documentation for this class was generated from the following files: