Garfield::ViewDrift Class Reference

Visualize drift lines and tracks. More...

#include <ViewDrift.hh>

Inheritance diagram for Garfield::ViewDrift:

Public Member Functions
	ViewDrift ()
	Constructor.
	~ViewDrift ()=default
	Destructor.
void	Clear ()
	Delete existing drift lines, tracks and markers.
void	Plot (const bool twod=false, const bool axis=true)
	Draw the drift lines.
void	Plot2d (const bool axis)
	Make a 2D plot of the drift lines in the current viewing plane.
void	Plot3d (const bool axis, const bool ogl)
	Make a 3D plot of the drift lines.
void	EnableClusterMarkers (const bool on=true)
	Draw markers (or not) at every collision along a track.
void	SetClusterMarkerSize (const double size)
	Set the size of the cluster markers (see TAttMarker).
void	SetCollisionMarkerSize (const double size)
	Set the size of the collision markers (see TAttMarker).
void	SetColourElectrons (const short col)
	Set the colour with which to draw electron drift lines.
void	SetColourHoles (const short col)
	Set the colour with which to draw hole drift lines.
void	SetColourIons (const short col)
	Set the colour with which to draw ion drift lines.
void	SetColourTracks (const short col)
	Set the colour with which to draw charged particle tracks.
void	SetColourPhotons (const short col)
	Set the colour with which to draw photons.
void	SetColourExcitations (const short col)
	Set the colour with which to draw excitation markers.
void	SetColourIonisations (const short col)
	Set the colour with which to draw ionisation markers.
void	SetColourAttachments (const short col)
	Set the colour with which to draw attachment markers.
size_t	GetNumberOfDriftLines () const
	Get the number of drift lines stored.
void	GetDriftLine (const size_t i, std::vector< std::array< float, 3 > > &driftLine, bool &electron) const
	Retrieve the coordinates of a given drift line.
void	NewElectronDriftLine (const size_t np, size_t &id, const float x0, const float y0, const float z0)
void	NewHoleDriftLine (const size_t np, size_t &id, const float x0, const float y0, const float z0)
void	NewIonDriftLine (const size_t np, size_t &id, const float x0, const float y0, const float z0)
void	NewChargedParticleTrack (const size_t np, size_t &id, const float x0, const float y0, const float z0)
void	SetDriftLinePoint (const size_t iL, const size_t iP, const float x, const float y, const float z)
void	AddDriftLinePoint (const size_t iL, const float x, const float y, const float z)
void	SetTrackPoint (const size_t iL, const size_t iP, const float x, const float y, const float z)
void	AddTrackPoint (const size_t iL, const float x, const float y, const float z)
void	AddExcitation (const float x, const float y, const float z)
void	AddIonisation (const float x, const float y, const float z)
void	AddAttachment (const float x, const float y, const float z)
void	AddPhoton (const float x0, const float y0, const float z0, const float x1, const float y1, const float z1)
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.

Friends
class	ViewFEMesh

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 drift lines and tracks.

Definition at line 18 of file ViewDrift.hh.

Constructor & Destructor Documentation

ViewDrift()

Garfield::ViewDrift::ViewDrift

(

)

Constructor.

Definition at line 21 of file ViewDrift.cc.

                     : ViewBase("ViewDrift") {
  m_driftLines.reserve(1000);
  m_tracks.reserve(100);
  m_exc.reserve(1000);
  m_ion.reserve(1000);
  m_att.reserve(1000);
}

~ViewDrift()

Garfield::ViewDrift::~ViewDrift ( )

default

Destructor.

Member Function Documentation

AddAttachment()

void Garfield::ViewDrift::AddAttachment	(	const float	x,
		const float	y,
		const float	z
	)

Definition at line 179 of file ViewDrift.cc.

                                                                         {
  std::lock_guard<std::mutex> guard(m_mutex);
  std::array<float, 3> p = {x, y, z};
  m_att.push_back(std::move(p));
}

AddDriftLinePoint()

void Garfield::ViewDrift::AddDriftLinePoint	(	const size_t	iL,
		const float	x,
		const float	y,
		const float	z
	)

Definition at line 135 of file ViewDrift.cc.

                                                                {
  std::lock_guard<std::mutex> guard(m_mutex);
  if (iL >= m_driftLines.size()) {
    std::cerr << m_className << "::AddDriftLinePoint: Index out of range.\n";
    return;
  }
  std::array<float, 3> p = {x, y, z};
  m_driftLines[iL].first.push_back(std::move(p));
}

AddExcitation()

void Garfield::ViewDrift::AddExcitation	(	const float	x,
		const float	y,
		const float	z
	)

Definition at line 167 of file ViewDrift.cc.

                                                                         {
  std::lock_guard<std::mutex> guard(m_mutex);
  std::array<float, 3> p = {x, y, z};
  m_exc.push_back(std::move(p));
}

AddIonisation()

void Garfield::ViewDrift::AddIonisation	(	const float	x,
		const float	y,
		const float	z
	)

Definition at line 173 of file ViewDrift.cc.

                                                                         {
  std::lock_guard<std::mutex> guard(m_mutex);
  std::array<float, 3> p = {x, y, z};
  m_ion.push_back(std::move(p));
}

AddPhoton()

void Garfield::ViewDrift::AddPhoton	(	const float	x0,
		const float	y0,
		const float	z0,
		const float	x1,
		const float	y1,
		const float	z1
	)

Definition at line 103 of file ViewDrift.cc.

                                                                          {
  std::lock_guard<std::mutex> guard(m_mutex);
  std::array<float, 3> p0 = {x0, y0, z0};
  std::array<float, 3> p1 = {x1, y1, z1};
  m_photons.push_back({p0, p1});
}

AddTrackPoint()

void Garfield::ViewDrift::AddTrackPoint	(	const size_t	iL,
		const float	x,
		const float	y,
		const float	z
	)

Definition at line 156 of file ViewDrift.cc.

                                                            {
  std::lock_guard<std::mutex> guard(m_mutex);
  if (iL >= m_tracks.size()) {
    std::cerr << m_className << "::AddTrackPoint: Index out of range.\n";
    return;
  }
  std::array<float, 3> p = {x, y, z};
  m_tracks[iL].push_back(std::move(p));
}

Referenced by Garfield::Track::PlotCluster().

Clear()

void Garfield::ViewDrift::Clear

(

)

Delete existing drift lines, tracks and markers.

Definition at line 29 of file ViewDrift.cc.

                      {
  m_driftLines.clear();
  m_tracks.clear();
 
  m_exc.clear();
  m_ion.clear();
  m_att.clear();
}

EnableClusterMarkers()

void Garfield::ViewDrift::EnableClusterMarkers ( const bool  on = true )

inline

Draw markers (or not) at every collision along a track.

Definition at line 36 of file ViewDrift.hh.

{ m_drawClusters = on; }

GetDriftLine()

void Garfield::ViewDrift::GetDriftLine	(	const size_t	i,
		std::vector< std::array< float, 3 > > &	driftLine,
		bool &	electron
	)		const

Retrieve the coordinates of a given drift line.

Definition at line 54 of file ViewDrift.cc.

                                                   {
  driftLine.clear();
  if (i >= m_driftLines.size()) return;
  std::copy(m_driftLines[i].first.begin(), m_driftLines[i].first.end(),
            std::back_inserter(driftLine));
  if (m_driftLines[i].second == Particle::Electron) {
    electron = true;
  } else {
    electron = false;
  }
}

GetNumberOfDriftLines()

size_t Garfield::ViewDrift::GetNumberOfDriftLines ( ) const

inline

Get the number of drift lines stored.

Definition at line 60 of file ViewDrift.hh.

{ return m_driftLines.size(); }

NewChargedParticleTrack()

void Garfield::ViewDrift::NewChargedParticleTrack	(	const size_t	np,
		size_t &	id,
		const float	x0,
		const float	y0,
		const float	z0
	)

Definition at line 111 of file ViewDrift.cc.

                                                        {
  std::lock_guard<std::mutex> guard(m_mutex);
  // Create a new track and add it to the list.
  constexpr size_t minSize = 1;
  std::vector<std::array<float, 3> > track(std::max(minSize, np));
  track[0] = {x0, y0, z0};
  m_tracks.push_back(std::move(track));
  // Return the index of this track.
  id = m_tracks.size() - 1;
}

Referenced by Garfield::Track::PlotNewTrack().

NewElectronDriftLine()

void Garfield::ViewDrift::NewElectronDriftLine	(	const size_t	np,
		size_t &	id,
		const float	x0,
		const float	y0,
		const float	z0
	)

Definition at line 68 of file ViewDrift.cc.

                                                     {
  std::lock_guard<std::mutex> guard(m_mutex);
  // Create a new electron drift line and add it to the list.
  std::array<float, 3> p = {x0, y0, z0};
  constexpr size_t minSize = 1;
  std::vector<std::array<float, 3> > dl(std::max(minSize, np), p);
  m_driftLines.push_back(std::make_pair(std::move(dl), Particle::Electron));
  // Return the index of this drift line.
  id = m_driftLines.size() - 1;
}

NewHoleDriftLine()

void Garfield::ViewDrift::NewHoleDriftLine	(	const size_t	np,
		size_t &	id,
		const float	x0,
		const float	y0,
		const float	z0
	)

Definition at line 81 of file ViewDrift.cc.

                                                                 {
  std::lock_guard<std::mutex> guard(m_mutex);
  std::array<float, 3> p = {x0, y0, z0};
  constexpr size_t minSize = 1;
  std::vector<std::array<float, 3> > dl(std::max(minSize, np), p);
  m_driftLines.push_back(std::make_pair(std::move(dl), Particle::Hole));
  // Return the index of this drift line.
  id = m_driftLines.size() - 1;
}

NewIonDriftLine()

void Garfield::ViewDrift::NewIonDriftLine	(	const size_t	np,
		size_t &	id,
		const float	x0,
		const float	y0,
		const float	z0
	)

Definition at line 92 of file ViewDrift.cc.

                                                                {
  std::lock_guard<std::mutex> guard(m_mutex);
  std::array<float, 3> p = {x0, y0, z0};
  constexpr size_t minSize = 1;
  std::vector<std::array<float, 3> > dl(std::max(minSize, np), p);
  m_driftLines.push_back(std::make_pair(std::move(dl), Particle::Ion));
  // Return the index of this drift line.
  id = m_driftLines.size() - 1;
}

Plot()

void Garfield::ViewDrift::Plot	(	const bool	twod = false,
		const bool	axis = true
	)

Draw the drift lines.

Definition at line 185 of file ViewDrift.cc.

                                                     {
  if (twod) {
    Plot2d(axis);
  } else {
    Plot3d(axis, false);
  }
}

Referenced by main().

Plot2d()

void Garfield::ViewDrift::Plot2d

(

const bool

axis

)

Make a 2D plot of the drift lines in the current viewing plane.

Definition at line 193 of file ViewDrift.cc.

                                      {
  auto pad = GetCanvas();
  pad->cd();
  pad->SetTitle("Drift lines");
  // Check if the canvas range has already been set.
  const bool rangeSet = RangeSet(pad);
  if (axis || !rangeSet) {
    // Determine the plot limits.
    if (!SetPlotLimits2d()) {
      std::cerr << m_className << "::Plot2d:\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());
  } else if (!rangeSet) {
    SetRange(pad, m_xMinPlot, m_yMinPlot, m_xMaxPlot, m_yMaxPlot);
  } 
 
  for (const auto& driftLine : m_driftLines) {
    const short lw = 1;
    if (driftLine.second == Particle::Electron) {
      DrawLine(driftLine.first, m_colElectron, lw);
    } else if (driftLine.second == Particle::Hole) {
      DrawLine(driftLine.first, m_colHole, lw);
    } else {
      DrawLine(driftLine.first, m_colIon, lw);
    }
  }
  gPad->Update();
 
  TGraph gr;
  gr.SetMarkerColor(m_colTrack);
  gr.SetMarkerSize(m_markerSizeCluster);
  for (const auto& track : m_tracks) {
    DrawLine(track, m_colTrack, 2);
    if (!m_drawClusters) continue;
    std::vector<float> xgr;
    std::vector<float> ygr;
    for (const auto& p : track) {
      if (!InBox(p)) continue;
      float xp = 0., yp = 0.;
      ToPlane(p[0], p[1], p[2], xp, yp);
      xgr.push_back(xp);
      ygr.push_back(yp);
    }
    gr.DrawGraph(xgr.size(), xgr.data(), ygr.data(), "Psame");
  }
 
  gr.SetLineColor(m_colPhoton);
  gr.SetLineStyle(2);
  for (const auto& photon : m_photons) {
    float xp0 = 0., yp0 = 0.;
    float xp1 = 0., yp1 = 0.;
    ToPlane(photon[0][0], photon[0][1], photon[0][2], xp0, yp0);
    ToPlane(photon[1][0], photon[1][1], photon[1][2], xp1, yp1);
    std::vector<float> xgr = {xp0, xp1};
    std::vector<float> ygr = {yp0, yp1};
    gr.DrawGraph(2, xgr.data(), ygr.data(), "Lsame"); 
  }
 
  gr.SetMarkerSize(m_markerSizeCollision);
  gr.SetMarkerStyle(20);
  if (!m_exc.empty()) {
    gr.SetMarkerColor(m_colExcitation);
    std::vector<float> xgr;
    std::vector<float> ygr;
    for (const auto& p : m_exc) {
      if (!InBox(p)) continue;
      float xp = 0., yp = 0.;
      ToPlane(p[0], p[1], p[2], xp, yp);
      xgr.push_back(xp);
      ygr.push_back(yp); 
    }
    if (!xgr.empty()) {
      gr.DrawGraph(xgr.size(), xgr.data(), ygr.data(), "Psame");
    }
  } 
  if (!m_ion.empty()) {
    gr.SetMarkerColor(m_colIonisation);
    std::vector<float> xgr;
    std::vector<float> ygr;
    for (const auto& p : m_ion) {
      if (!InBox(p)) continue;
      float xp = 0., yp = 0.;
      ToPlane(p[0], p[1], p[2], xp, yp);
      xgr.push_back(xp);
      ygr.push_back(yp); 
    }
    if (!xgr.empty()) {
      gr.DrawGraph(xgr.size(), xgr.data(), ygr.data(), "Psame");
    }
  }
  if (!m_att.empty()) {
    gr.SetMarkerColor(m_colAttachment);
    std::vector<float> xgr;
    std::vector<float> ygr;
    for (const auto& p : m_att) {
      if (!InBox(p)) continue;
      float xp = 0., yp = 0.;
      ToPlane(p[0], p[1], p[2], xp, yp);
      xgr.push_back(xp);
      ygr.push_back(yp); 
    }
    if (!xgr.empty()) {
      gr.DrawGraph(xgr.size(), xgr.data(), ygr.data(), "Psame");
    }
  }
 
  gPad->Update();
}

Referenced by main(), and Plot().

Plot3d()

void Garfield::ViewDrift::Plot3d	(	const bool	axis,
		const bool	ogl
	)

Make a 3D plot of the drift lines.

Definition at line 309 of file ViewDrift.cc.

                                                      {
  auto pad = GetCanvas();
  pad->cd();
  pad->SetTitle("Drift lines");
  if (!pad->GetView()) {
    if (!SetPlotLimits3d()) {
      std::cerr << m_className << "::Plot3d:\n"
                << "     Could not determine the plot limits.\n";
    }
    auto view = TView::CreateView(1, 0, 0);
    view->SetRange(m_xMinBox, m_yMinBox, m_zMinBox, 
                   m_xMaxBox, m_yMaxBox, m_zMaxBox);
    if (axis) view->ShowAxis();
    pad->SetView(view);
    if (ogl) pad->GetViewer3D("ogl");
  }
  for (const auto& driftLine : m_driftLines) {
    std::vector<float> points;
    for (const auto& p : driftLine.first) {
      points.push_back(p[0]);
      points.push_back(p[1]);
      points.push_back(p[2]);
    }
    const int nP = driftLine.first.size();
    TPolyLine3D pl(nP, points.data());
    if (driftLine.second == Particle::Electron) {
      pl.SetLineColor(m_colElectron);
    } else if (driftLine.second == Particle::Hole) {
      pl.SetLineColor(m_colHole);
    } else {
      pl.SetLineColor(m_colIon);
    }
    pl.SetLineWidth(1);
    pl.DrawPolyLine(nP, points.data(), "same");
  }
 
  for (const auto& track : m_tracks) {
    std::vector<float> points;
    for (const auto& p : track) {
      points.push_back(p[0]);
      points.push_back(p[1]);
      points.push_back(p[2]);
    }
    const int nP = track.size();
    TPolyLine3D pl(nP, points.data());
    pl.SetLineColor(m_colTrack);
    pl.SetLineWidth(1);
    pl.DrawPolyLine(nP, points.data(), "same");
    if (!m_drawClusters) continue;
    TPolyMarker3D pm(nP, points.data());
    pm.SetMarkerColor(m_colTrack);
    pm.SetMarkerSize(m_markerSizeCluster);
    pm.DrawPolyMarker(nP, points.data(), 20, "same");
  }
 
  if (!m_exc.empty()) {
    const size_t nP = m_exc.size();
    std::vector<float> points;
    for (size_t i = 0; i < nP; ++i) {
      points.push_back(m_exc[i][0]);
      points.push_back(m_exc[i][1]);
      points.push_back(m_exc[i][2]);
    }
    TPolyMarker3D pm(nP, points.data());
    pm.SetMarkerColor(m_colExcitation);
    pm.SetMarkerSize(m_markerSizeCollision);
    pm.DrawPolyMarker(nP, points.data(), 20, "same");
  }
 
  if (!m_ion.empty()) {
    const size_t nP = m_ion.size();
    std::vector<float> points;
    for (size_t i = 0; i < nP; ++i) {
      points.push_back(m_ion[i][0]);
      points.push_back(m_ion[i][1]);
      points.push_back(m_ion[i][2]);
    }
    TPolyMarker3D pm(nP, points.data());
    pm.SetMarkerColor(m_colIonisation);
    pm.SetMarkerSize(m_markerSizeCollision);
    pm.DrawPolyMarker(nP, points.data(), 20, "same");
  }
 
  if (!m_att.empty()) {
    const size_t nP = m_att.size();
    std::vector<float> points;
    for (size_t i = 0; i < nP; ++i) {
      points.push_back(m_att[i][0]);
      points.push_back(m_att[i][1]);
      points.push_back(m_att[i][2]);
    }
    TPolyMarker3D pm(nP, points.data());
    pm.SetMarkerColor(m_colAttachment);
    pm.SetMarkerSize(m_markerSizeCollision);
    pm.DrawPolyMarker(nP, points.data(), 20, "same");
  } 
  pad->Modified();
  pad->Update();
 
  if (axis) {
    TAxis3D* ax3d = TAxis3D::GetPadAxis();
    if (ax3d) {
      ax3d->SetLabelColor(kGray + 2);
      ax3d->SetAxisColor(kGray + 2);
      ax3d->SetXTitle("x");
      ax3d->SetYTitle("y");
      ax3d->SetZTitle("z");
    }
    pad->Update();
  }
}

Referenced by Plot().

SetClusterMarkerSize()

void Garfield::ViewDrift::SetClusterMarkerSize

(

const double

size

)

Set the size of the cluster markers (see TAttMarker).

Definition at line 38 of file ViewDrift.cc.

                                                      {
  if (size > 0.) {
    m_markerSizeCluster = size;
  } else {
    std::cerr << m_className << "::SetClusterMarkerSize: Size must be > 0.\n";
  }
}

Referenced by main().

SetCollisionMarkerSize()

void Garfield::ViewDrift::SetCollisionMarkerSize

(

const double

size

)

Set the size of the collision markers (see TAttMarker).

Definition at line 46 of file ViewDrift.cc.

                                                        {
  if (size > 0.) {
    m_markerSizeCollision = size;
  } else {
    std::cerr << m_className << "::SetCollisionMarkerSize: Size must be > 0.\n";
  }
}

Referenced by main().

SetColourAttachments()

void Garfield::ViewDrift::SetColourAttachments ( const short  col )

inline

Set the colour with which to draw attachment markers.

Definition at line 57 of file ViewDrift.hh.

{ m_colAttachment = col; } 

SetColourElectrons()

void Garfield::ViewDrift::SetColourElectrons ( const short  col )

inline

Set the colour with which to draw electron drift lines.

Definition at line 43 of file ViewDrift.hh.

{ m_colElectron = col; } 

SetColourExcitations()

void Garfield::ViewDrift::SetColourExcitations ( const short  col )

inline

Set the colour with which to draw excitation markers.

Definition at line 53 of file ViewDrift.hh.

{ m_colExcitation = col; } 

SetColourHoles()

void Garfield::ViewDrift::SetColourHoles ( const short  col )

inline

Set the colour with which to draw hole drift lines.

Definition at line 45 of file ViewDrift.hh.

{ m_colHole = col; } 

SetColourIonisations()

void Garfield::ViewDrift::SetColourIonisations ( const short  col )

inline

Set the colour with which to draw ionisation markers.

Definition at line 55 of file ViewDrift.hh.

{ m_colIonisation = col; } 

SetColourIons()

void Garfield::ViewDrift::SetColourIons ( const short  col )

inline

Set the colour with which to draw ion drift lines.

Definition at line 47 of file ViewDrift.hh.

{ m_colIon = col; } 

SetColourPhotons()

void Garfield::ViewDrift::SetColourPhotons ( const short  col )

inline

Set the colour with which to draw photons.

Definition at line 51 of file ViewDrift.hh.

{ m_colPhoton = col; } 

SetColourTracks()

void Garfield::ViewDrift::SetColourTracks ( const short  col )

inline

Set the colour with which to draw charged particle tracks.

Definition at line 49 of file ViewDrift.hh.

{ m_colTrack = col; } 

SetDriftLinePoint()

void Garfield::ViewDrift::SetDriftLinePoint	(	const size_t	iL,
		const size_t	iP,
		const float	x,
		const float	y,
		const float	z
	)

Definition at line 124 of file ViewDrift.cc.

                                                 {
  std::lock_guard<std::mutex> guard(m_mutex);
  if (iL >= m_driftLines.size() || iP >= m_driftLines[iL].first.size()) {
    std::cerr << m_className << "::SetDriftLinePoint: Index out of range.\n";
    return;
  }
  m_driftLines[iL].first[iP] = {x, y, z};
}

SetTrackPoint()

void Garfield::ViewDrift::SetTrackPoint	(	const size_t	iL,
		const size_t	iP,
		const float	x,
		const float	y,
		const float	z
	)

Definition at line 146 of file ViewDrift.cc.

                                                                           {
  std::lock_guard<std::mutex> guard(m_mutex);
  if (iL >= m_tracks.size() || iP >= m_tracks[iL].size()) {
    std::cerr << m_className << "::SetTrackPoint: Index out of range.\n";
    return;
  }
  m_tracks[iL][iP] = {x, y, z};
}

Friends And Related Function Documentation

ViewFEMesh

friend class ViewFEMesh

friend

Definition at line 91 of file ViewDrift.hh.

---

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

• ViewDrift.hh
• ViewDrift.cc