Visualize the potential or electric field of a component or sensor. More...

#include <ViewField.hh>

Inheritance diagram for Garfield::ViewField:

Public Member Functions
	ViewField ()
	Constructor.

	~ViewField ()=default
	Destructor.

void	SetSensor (Sensor *s)
	Set the sensor for which to plot the field.

void	SetComponent (Component *c)
	Set the component for which to plot the field.

void	SetVoltageRange (const double vmin, const double vmax)
	Set the plot limits for the potential.

void	SetElectricFieldRange (const double emin, const double emax)
	Set the plot limits for the electric field.

void	SetWeightingFieldRange (const double wmin, const double wmax)
	Set the plot limits for the weighting field.

void	SetNumberOfContours (const unsigned int n)
	Set the number of contour levels.

void	SetNumberOfSamples1d (const unsigned int n)
	Set the number of points used for drawing 1D functions.

void	SetNumberOfSamples2d (const unsigned int nx, const unsigned int ny)
	Set the number of points used for drawing 2D functions.

void	PlotContour (const std::string &option="v")

void	Plot (const std::string &option="v", const std::string &drawopt="arr")

void	PlotProfile (const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, const std::string &option="v", const bool normalised=true)

void	PlotContourWeightingField (const std::string &label, const std::string &option)

void	PlotWeightingField (const std::string &label, const std::string &option, const std::string &drawopt)

void	PlotProfileWeightingField (const std::string &label, const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, const std::string &option="v", const bool normalised=true)

void	EnableAutoRange (const bool on=true, const bool samplePotential=true)

void	AcknowledgeStatus (const bool on, const double v0=0.)

void	PlotFieldLines (const std::vector< double > &x0, const std::vector< double > &y0, const std::vector< double > &z0, const bool electron=true, const bool axis=true, const short col=kOrange - 3)
	Draw electric field lines from a set of starting points.

bool	EqualFluxIntervals (const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, std::vector< double > &xf, std::vector< double > &yf, std::vector< double > &zf, const unsigned int nPoints=20) const
	Generates point along a line, spaced by equal flux intervals.

bool	FixedFluxIntervals (const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, std::vector< double > &xf, std::vector< double > &yf, std::vector< double > &zf, const double interval=10.) const
	Generate points along a line, spaced by a given flux interval.

Public Member Functions inherited from Garfield::ViewBase
	ViewBase ()=delete
	Default constructor.

	ViewBase (const std::string &name)
	Constructor.

virtual	~ViewBase ()=default
	Destructor.

void	SetCanvas (TPad *pad)
	Set the canvas to be painted on.

void	SetCanvas ()
	Unset an external canvas.

TPad *	GetCanvas ()
	Retrieve the canvas.

void	SetArea (const double xmin, const double ymin, const double xmax, const double ymax)

virtual void	SetArea (const double xmin, const double ymin, const double zmin, const double xmax, const double ymax, const double zmax)
	Set a bounding box (if applicable).

void	SetArea ()

virtual void	SetPlane (const double fx, const double fy, const double fz, const double x0, const double y0, const double z0)

virtual void	SetPlane (const double fx, const double fy, const double fz, const double x0, const double y0, const double z0, const double hx, const double hy, const double hz)
	Set the projection plane specifying a hint for the in-plane x axis.

void	Rotate (const double angle)
	Rotate the viewing plane (angle in radian).

void	SetPlaneXY ()
	Set the viewing plane to x-y.

void	SetPlaneXZ ()
	Set the viewing plane to x-z.

void	SetPlaneYZ ()
	Set the viewing plane to y-z.

void	EnableDebugging (const bool on=true)
	Switch on/off debugging output.

Additional Inherited Members
Static Public Member Functions inherited from Garfield::ViewBase
static std::string	FindUnusedFunctionName (const std::string &s)
	Find an unused function name.

static std::string	FindUnusedHistogramName (const std::string &s)
	Find an unused histogram name.

static std::string	FindUnusedCanvasName (const std::string &s)
	Find an unused canvas name.

Protected Member Functions inherited from Garfield::ViewBase
void	UpdateProjectionMatrix ()

template<typename T >
void	ToPlane (const T x, const T y, const T z, T &xp, T &yp) const

template<typename T >
bool	InBox (const std::array< T, 3 > &x) const

void	Clip (const std::array< float, 3 > &x0, const std::array< float, 3 > &x1, std::array< float, 3 > &xc) const

void	DrawLine (const std::vector< std::array< float, 3 > > &xl, const short col, const short lw)

std::string	LabelX ()

std::string	LabelY ()

std::string	PlaneDescription ()

bool	PlotLimits (Sensor *sensor, double &xmin, double &ymin, double &xmax, double &ymax) const

bool	PlotLimits (Component *cmp, double &xmin, double &ymin, double &xmax, double &ymax) const

bool	PlotLimitsFromUserBox (double &xmin, double &ymin, double &xmax, double &ymax) const

bool	PlotLimits (std::array< double, 3 > &bbmin, std::array< double, 3 > &bbmax, double &xmin, double &ymin, double &xmax, double &ymax) const

bool	RangeSet (TPad *)

void	SetRange (TPad *pad, const double x0, const double y0, const double x1, const double y1)

Protected Attributes inherited from Garfield::ViewBase
std::string	m_className = "ViewBase"

bool	m_debug = false

bool	m_userPlotLimits = false

double	m_xMinPlot = -1.

double	m_xMaxPlot = 1.

double	m_yMinPlot = -1.

double	m_yMaxPlot = 1.

bool	m_userBox = false

double	m_xMinBox = -1.

double	m_xMaxBox = 1.

double	m_yMinBox = -1.

double	m_yMaxBox = 1.

double	m_zMinBox = -1.

double	m_zMaxBox = 1.

std::array< std::array< double, 3 >, 3 >	m_proj

std::array< double, 4 >	m_plane {{0, 0, 1, 0}}

std::array< std::array< double, 3 >, 3 >	m_prmat

Detailed Description

Visualize the potential or electric field of a component or sensor.

Definition at line 15 of file ViewField.hh.

Constructor & Destructor Documentation

◆ ViewField()

Garfield::ViewField::ViewField ( )

Constructor.

Definition at line 70 of file ViewField.cc.

70: ViewBase("ViewField") { }

Garfield::ViewBase::ViewBase

ViewBase()=delete

Default constructor.

◆ ~ViewField()

Garfield::ViewField::~ViewField ( )

default

Destructor.

Member Function Documentation

◆ AcknowledgeStatus()

void Garfield::ViewField::AcknowledgeStatus	(	const bool	on,
		const double	v0 = `0.`
	)

inline

Make use (or not) of the status flag returned by the sensor/component.

Parameters

on	Take status flag into account (true) or ignore it (false).
v0	Value to be used for regions with status != 0.

Definition at line 106 of file ViewField.hh.

                                                              {
    m_useStatus = on;
    m_vBkg = v0;
  }

◆ EnableAutoRange()

void Garfield::ViewField::EnableAutoRange	(	const bool	on = `true`,
		const bool	samplePotential = `true`
	)

inline

Determine the range of the potential/field automatically (true) or set it explicitly (false).

Definition at line 96 of file ViewField.hh.

                                                          { 
    m_useAutoRange = on;
    m_samplePotential = samplePotential; 
  }

◆ EqualFluxIntervals()

bool Garfield::ViewField::EqualFluxIntervals	(	const double	x0,
		const double	y0,
		const double	z0,
		const double	x1,
		const double	y1,
		const double	z1,
		std::vector< double > &	xf,
		std::vector< double > &	yf,
		std::vector< double > &	zf,
		const unsigned int	nPoints = `20`
	)		const

Generates point along a line, spaced by equal flux intervals.

Definition at line 642 of file ViewField.cc.

                                      {
 
  if (nPoints < 2) {
    std::cerr << m_className << "::EqualFluxIntervals:\n"
              << "    Number of flux lines must be > 1.\n";
    return false;
  }
 
  // Set integration intervals.
  constexpr unsigned int nV = 5;
  // Compute the inplane vector normal to the track.
  const double xp = (y1 - y0) * m_plane[2] - (z1 - z0) * m_plane[1];
  const double yp = (z1 - z0) * m_plane[0] - (x1 - x0) * m_plane[2];
  const double zp = (x1 - x0) * m_plane[1] - (y1 - y0) * m_plane[0];
  // Compute the total flux, accepting positive and negative parts.
  double q = 0.;
  if (m_component) {
    q = m_component->IntegrateFluxLine(x0, y0, z0, x1, y1, z1, 
                                       xp, yp, zp, 20 * nV, 0);
  } else {
    q = m_sensor->IntegrateFluxLine(x0, y0, z0, x1, y1, z1, 
                                    xp, yp, zp, 20 * nV, 0);
  }
  const int isign = q > 0 ? +1 : -1;
  if (m_debug) {
    std::cout << m_className << "::EqualFluxIntervals:\n";
    std::printf("    Total flux: %15.e8\n", q);
  }
  // Compute the 1-sided flux in a number of steps.
  double fsum = 0.;
  unsigned int nOtherSign = 0;
  double s0 = -1.;
  double s1 = -1.;
  constexpr size_t nSteps = 1000;
  std::array<double, nSteps> sTab;
  std::array<double, nSteps> fTab;
  constexpr double ds = 1. / nSteps;
  const double dx = (x1 - x0) * ds;
  const double dy = (y1 - y0) * ds;
  const double dz = (z1 - z0) * ds;
  for (size_t i = 0; i < nSteps; ++i) {
    const double x = x0 + i * dx;
    const double y = y0 + i * dy;
    const double z = z0 + i * dz;
    if (m_component) {
      q = m_component->IntegrateFluxLine(x, y, z, x + dx, y + dy, z + dz, 
                                         xp, yp, zp, nV, isign);
    } else {
      q = m_sensor->IntegrateFluxLine(x, y, z, x + dx, y + dy, z + dz, 
                                      xp, yp, zp, nV, isign);
    }
    sTab[i] = (i + 1) * ds;
    if (q > 0) {
      fsum += q;
      if (s0 < -0.5) s0 = i * ds;
      s1 = (i + 1) * ds;
    }
    if (q < 0) ++nOtherSign;
    fTab[i] = fsum;
  }
  if (m_debug) {
    std::printf("    Used flux: %15.8e V. Start: %10.3f End: %10.3f\n",
                fsum, s0, s1);
  }
  // Make sure that the sum is positive.
  if (fsum <= 0) {
    std::cerr << m_className << "::EqualFluxIntervals:\n"
              << "    1-Sided flux integral is not > 0.\n";
    return false;
  } else if (s0 < -0.5 || s1 < -0.5 || s1 <= s0) {
    std::cerr << m_className << "::EqualFluxIntervals:\n"
              << "    No flux interval without sign change found.\n";
    return false;
  } else if (nOtherSign > 0) {
    std::cerr << m_className << "::EqualFluxIntervals:\n"
              << " The flux changes sign over the line.\n";
  }
  // Normalise the flux.
  const double scale = (nPoints - 1) / fsum;
  for (size_t i = 0; i < nSteps; ++i) fTab[i] *= scale;
 
  // Compute new cluster position.
  for (size_t i = 0; i < nPoints; ++i) {
    double s = std::min(s1, std::max(s0, Interpolate(sTab, fTab, i)));
    xf.push_back(x0 + s * (x1 - x0));
    yf.push_back(y0 + s * (y1 - y0));
    zf.push_back(z0 + s * (z1 - z0));
  }
  return true;
}

◆ FixedFluxIntervals()

bool Garfield::ViewField::FixedFluxIntervals	(	const double	x0,
		const double	y0,
		const double	z0,
		const double	x1,
		const double	y1,
		const double	z1,
		std::vector< double > &	xf,
		std::vector< double > &	yf,
		std::vector< double > &	zf,
		const double	interval = `10.`
	)		const

Generate points along a line, spaced by a given flux interval.

Definition at line 738 of file ViewField.cc.

                                                        {
 
  if (interval <= 0.) {
    std::cerr << m_className << "::FixedFluxIntervals:\n"
              << "    Flux interval must be > 0.\n";
    return false;
  }
 
  // Set integration intervals.
  constexpr unsigned int nV = 5;
  // Compute the inplane vector normal to the track.
  const double xp = (y1 - y0) * m_plane[2] - (z1 - z0) * m_plane[1];
  const double yp = (z1 - z0) * m_plane[0] - (x1 - x0) * m_plane[2];
  const double zp = (x1 - x0) * m_plane[1] - (y1 - y0) * m_plane[0];
  // Compute the total flux, accepting positive and negative parts.
  double q = 0.;
  if (m_component) {
    q = m_component->IntegrateFluxLine(x0, y0, z0, x1, y1, z1, 
                                       xp, yp, zp, 20 * nV, 0);
  } else {
    q = m_sensor->IntegrateFluxLine(x0, y0, z0, x1, y1, z1, 
                                    xp, yp, zp, 20 * nV, 0);
  }
  const int isign = q > 0 ? +1 : -1;
  if (m_debug) {
    std::cout << m_className << "::FixedFluxIntervals:\n";
    std::printf("    Total flux: %15.8e V\n", q);
  }
  // Compute the 1-sided flux in a number of steps.
  double fsum = 0.;
  unsigned int nOtherSign = 0;
  double s0 = -1.;
  constexpr size_t nSteps = 1000;
  std::array<double, nSteps> sTab;
  std::array<double, nSteps> fTab;
  constexpr double ds = 1. / nSteps;
  const double dx = (x1 - x0) * ds;
  const double dy = (y1 - y0) * ds;
  const double dz = (z1 - z0) * ds;
  for (size_t i = 0; i < nSteps; ++i) {
    const double x = x0 + i * dx;
    const double y = y0 + i * dy;
    const double z = z0 + i * dz;
    if (m_component) {
      q = m_component->IntegrateFluxLine(x, y, z, x + dx, y + dy, z + dz, 
                                         xp, yp, zp, nV, isign);
    } else {
      q = m_sensor->IntegrateFluxLine(x, y, z, x + dx, y + dy, z + dz, 
                                      xp, yp, zp, nV, isign);
    }
    sTab[i] = (i + 1) * ds;
    if (q > 0) {
      fsum += q;
      if (s0 < -0.5) s0 = i * ds;
    }
    if (q < 0) ++nOtherSign;
    fTab[i] = fsum;
  }
  // Make sure that the sum is positive.
  if (m_debug) {
    std::printf("    Used flux: %15.8e V. Start offset: %10.3f\n", fsum, s0);
  }
  if (fsum <= 0) {
    std::cerr << m_className << "::FixedFluxIntervals:\n"
              << "    1-Sided flux integral is not > 0.\n";
    return false;
  } else if (s0 < -0.5) {
    std::cerr << m_className << "::FixedFluxIntervals:\n"
              << "    No flux interval without sign change found.\n";
    return false;
  } else if (nOtherSign > 0) {
    std::cerr << m_className << "::FixedFluxIntervals:\n"
              << "    Warning: The flux changes sign over the line.\n";
  }
 
  double f = 0.;
  while (f < fsum) {
    const double s = Interpolate(sTab, fTab, f);
    f += interval;
    xf.push_back(x0 + s * (x1 - x0));
    yf.push_back(y0 + s * (y1 - y0));
    zf.push_back(z0 + s * (z1 - z0));
  }
  return true;
}

◆ Plot()

void Garfield::ViewField::Plot	(	const std::string &	option = `"v"`,
		const std::string &	drawopt = `"arr"`
	)

Make a 2D plot of the electric potential or field.

Parameters

option	quantity to be plotted (see PlotContour)
drawopt	option string passed to TF2::Draw

Definition at line 126 of file ViewField.cc.

                                                                      {
  std::string opt1;
  std::transform(drawopt.begin(), drawopt.end(), 
                 std::back_inserter(opt1), toupper);
  if (opt1.find("CONT") != std::string::npos) {
    Draw2d(option, true, false, "", drawopt);
  } else {
    Draw2d(option, false, false, "", drawopt);
  }
}

Referenced by main().

◆ PlotContour()

void Garfield::ViewField::PlotContour ( const std::string & option = "v" )

Make a contour plot of the electric potential or field.

Parameters

option

quantity to be plotted

potential: "v", "voltage", "p", "potential"
magnitude of the electric field: "e", "field"
x-component of the electric field: "ex"
y-component of the electric field: "ey"
z-component of the electric field: "ez"

Definition at line 122 of file ViewField.cc.

                                                   {
  Draw2d(option, true, false, "", "CONT1Z");
}

Referenced by main().

◆ PlotContourWeightingField()

void Garfield::ViewField::PlotContourWeightingField	(	const std::string &	label,
		const std::string &	option
	)

Make a contour plot of the weighting potential or field.

Parameters

label	identifier of the electrode
option	quantity to be plotted (see PlotContour)

Definition at line 149 of file ViewField.cc.

                                                                   {
  Draw2d(option, true, true, label, "CONT1Z");
}

◆ PlotFieldLines()

void Garfield::ViewField::PlotFieldLines	(	const std::vector< double > &	x0,
		const std::vector< double > &	y0,
		const std::vector< double > &	z0,
		const bool	electron = `true`,
		const bool	axis = `true`,
		const short	col = `kOrange - 3`
	)

Draw electric field lines from a set of starting points.

Definition at line 572 of file ViewField.cc.

                                                {
  
  if (x0.empty() || y0.empty() || z0.empty()) return;
  const size_t nLines = x0.size();
  if (y0.size() != nLines || x0.size() != nLines) {
    std::cerr << m_className << "::PlotLines:\n"
              << "    Mismatch in number of x/y/z coordinates.\n";
    return;
  }
 
  if (!m_sensor && !m_component) {
    std::cerr << m_className << "::PlotFieldLines:\n"
              << "    Neither sensor nor component are defined.\n";
    return;
  }
 
  auto pad = GetCanvas();
  pad->cd();
  pad->SetTitle("Field lines");
  // Determine the x-y range.
  const bool rangeSet = RangeSet(pad);
  if (axis || !rangeSet) {
    // Determine the plot limits.
    if (!SetPlotLimits()) {
      std::cerr << m_className << "::PlotFieldLines:\n"
                << "     Could not determine the plot limits.\n";
      return;
    }
  }
  if (axis) {
    auto frame = pad->DrawFrame(m_xMinPlot, m_yMinPlot,
                                m_xMaxPlot, m_yMaxPlot);
    frame->GetXaxis()->SetTitle(LabelX().c_str());
    frame->GetYaxis()->SetTitle(LabelY().c_str());
    pad->Update();
  } else if (!rangeSet) {
    SetRange(pad, m_xMinPlot, m_yMinPlot, m_xMaxPlot, m_yMaxPlot);
  } 
 
  DriftLineRKF drift;
  Sensor sensor;
  if (m_sensor) {
    drift.SetSensor(m_sensor);
  } else {
    double xmin = 0., ymin = 0., zmin = 0.;
    double xmax = 0., ymax = 0., zmax = 0.;
    if (!m_component->GetBoundingBox(xmin, ymin, zmin, xmax, ymax, zmax)) {
      if (m_userBox) {
        sensor.SetArea(m_xMinBox, m_yMinBox, m_zMinBox, 
                       m_xMaxBox, m_yMaxBox, m_zMaxBox);
      }
    }
    sensor.AddComponent(m_component);
    drift.SetSensor(&sensor);
  }
  const double lx = 0.1 * fabs(m_xMaxPlot - m_xMinPlot);
  const double ly = 0.1 * fabs(m_yMaxPlot - m_yMinPlot);
  drift.SetMaximumStepSize(std::min(lx, ly));
  for (size_t i = 0; i < nLines; ++i) {
    std::vector<std::array<float, 3> > xl;
    if (!drift.FieldLine(x0[i], y0[i], z0[i], xl, electron)) continue;
    DrawLine(xl, col, 1);
  }
  pad->Update();
}

◆ PlotProfile()

void Garfield::ViewField::PlotProfile	(	const double	x0,
		const double	y0,
		const double	z0,
		const double	x1,
		const double	y1,
		const double	z1,
		const std::string &	option = `"v"`,
		const bool	normalised = `true`
	)

Make a 1D plot of the electric potential or field along a line.

Parameters

x0,y0,z0	starting point
x1,y1,z1	end point
option	quantity to be plotted (see PlotContour)
normalised	flag whether to use normalised x-axis coordinates

Definition at line 137 of file ViewField.cc.

                                                                            {
  DrawProfile(x0, y0, z0, x1, y1, z1, option, false, "", normalised);
}

◆ PlotProfileWeightingField()

void Garfield::ViewField::PlotProfileWeightingField	(	const std::string &	label,
		const double	x0,
		const double	y0,
		const double	z0,
		const double	x1,
		const double	y1,
		const double	z1,
		const std::string &	option = `"v"`,
		const bool	normalised = `true`
	)

Make a 1D plot of the weighting potential or field along a line.

Parameters

label	identifier of the electrode
x0,y0,z0	starting point
x1,y1,z1	end point
option	quantity to be plotted (see PlotContour)
normalised	flag whether to use normalised x-axis coordinates

Definition at line 154 of file ViewField.cc.

                                                                 {
  DrawProfile(x0, y0, z0, x1, y1, z1, option, true, label, normalised);
}

◆ PlotWeightingField()

void Garfield::ViewField::PlotWeightingField	(	const std::string &	label,
		const std::string &	option,
		const std::string &	drawopt
	)

Make a 2D plot of the weighting potential or field.

Parameters

label	identifier of the electrode
option	quantity to be plotted (see PlotContour)
drawopt	option string passed to TF2::Draw

Definition at line 143 of file ViewField.cc.

                                                             {
  Draw2d(option, false, true, label, drawopt);
}

◆ SetComponent()

void Garfield::ViewField::SetComponent ( Component * c )

Set the component for which to plot the field.

Definition at line 81 of file ViewField.cc.

                                         {
  if (!c) {
    std::cerr << m_className << "::SetComponent: Null pointer.\n";
    return;
  }
  m_component = c;
  m_sensor = nullptr;
}

◆ SetElectricFieldRange()

void Garfield::ViewField::SetElectricFieldRange	(	const double	emin,
		const double	emax
	)

Set the plot limits for the electric field.

Definition at line 96 of file ViewField.cc.

                                                                          {
  m_emin = std::min(emin, emax);
  m_emax = std::max(emin, emax);
  m_useAutoRange = false;
}

◆ SetNumberOfContours()

void Garfield::ViewField::SetNumberOfContours ( const unsigned int n )

Set the number of contour levels.

Definition at line 108 of file ViewField.cc.

                                                        {
  if (n > 0) m_nContours = n;
}

Referenced by main().

◆ SetNumberOfSamples1d()

void Garfield::ViewField::SetNumberOfSamples1d ( const unsigned int n )

Set the number of points used for drawing 1D functions.

Definition at line 112 of file ViewField.cc.

                                                         {
  m_nSamples1d = std::max(4u, n);
}

◆ SetNumberOfSamples2d()

void Garfield::ViewField::SetNumberOfSamples2d	(	const unsigned int	nx,
		const unsigned int	ny
	)

Set the number of points used for drawing 2D functions.

Definition at line 116 of file ViewField.cc.

                                                            {
  m_nSamples2dX = std::max(4u, nx);
  m_nSamples2dY = std::max(4u, ny);
}

Referenced by main().

◆ SetSensor()

void Garfield::ViewField::SetSensor ( Sensor * s )

Set the sensor for which to plot the field.

Definition at line 72 of file ViewField.cc.

                                   {
  if (!s) {
    std::cerr << m_className << "::SetSensor: Null pointer.\n";
    return;
  }
  m_sensor = s;
  m_component = nullptr;
}

Referenced by main().

◆ SetVoltageRange()

void Garfield::ViewField::SetVoltageRange	(	const double	vmin,
		const double	vmax
	)

Set the plot limits for the potential.

Definition at line 90 of file ViewField.cc.

                                                                    {
  m_vmin = std::min(vmin, vmax);
  m_vmax = std::max(vmin, vmax);
  m_useAutoRange = false;
}

◆ SetWeightingFieldRange()

void Garfield::ViewField::SetWeightingFieldRange	(	const double	wmin,
		const double	wmax
	)

Set the plot limits for the weighting field.

Definition at line 102 of file ViewField.cc.

                                                                           {
  m_wmin = std::min(wmin, wmax);
  m_wmax = std::max(wmin, wmax);
  m_useAutoRange = false;
}

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ViewField()

◆ ~ViewField()

Member Function Documentation

◆ AcknowledgeStatus()

◆ EnableAutoRange()

◆ EqualFluxIntervals()

◆ FixedFluxIntervals()

◆ Plot()

◆ PlotContour()

◆ PlotContourWeightingField()

◆ PlotFieldLines()

◆ PlotProfile()

◆ PlotProfileWeightingField()

◆ PlotWeightingField()

◆ SetComponent()

◆ SetElectricFieldRange()

◆ SetNumberOfContours()

◆ SetNumberOfSamples1d()

◆ SetNumberOfSamples2d()

◆ SetSensor()

◆ SetVoltageRange()

◆ SetWeightingFieldRange()