Draw equal time contour lines. More...

#include <ViewIsochrons.hh>

Inheritance diagram for Garfield::ViewIsochrons:

Public Member Functions
	ViewIsochrons ()
	Constructor.

	~ViewIsochrons ()=default
	Destructor.

void	SetSensor (Sensor *s)
	Set the sensor.

void	SetComponent (Component *c)
	Set the component.

void	PlotIsochrons (const double tstep, const std::vector< std::array< double, 3 > > &points, const bool rev=false, const bool colour=false, const bool markers=false, const bool plotDriftLines=true)

void	DriftElectrons (const bool positive=false)

void	DriftIons (const bool negative=false)
	Request ion drift lines with positive (default) or negative charge.

void	EnableSorting (const bool on=true)
	Sort (or not) the points on a contour line (default: sorting is done).

void	CheckCrossings (const bool on=true)

void	SetAspectRatioSwitch (const double ar)

void	SetLoopThreshold (const double thr)

void	SetConnectionThreshold (const double thr)

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

Draw equal time contour lines.

Definition at line 13 of file ViewIsochrons.hh.

Constructor & Destructor Documentation

◆ ViewIsochrons()

Garfield::ViewIsochrons::ViewIsochrons ( )

Constructor.

Definition at line 135 of file ViewIsochrons.cc.

135: ViewBase("ViewIsochrons") { }

Garfield::ViewBase::ViewBase

ViewBase()=delete

Default constructor.

◆ ~ViewIsochrons()

Garfield::ViewIsochrons::~ViewIsochrons ( )

default

Destructor.

Member Function Documentation

◆ CheckCrossings()

void Garfield::ViewIsochrons::CheckCrossings ( const bool on = true )

inline

Check (or not) that drift-lines do not cross isochrons (default: check is done).

Definition at line 55 of file ViewIsochrons.hh.

55{ m_checkCrossings = on; }

◆ DriftElectrons()

void Garfield::ViewIsochrons::DriftElectrons ( const bool positive = false )

inline

Request electron drift lines with negative (default) or positive charge.

Definition at line 42 of file ViewIsochrons.hh.

                                                   { 
    m_particle = Particle::Electron;
    m_positive = positive;
  }

◆ DriftIons()

void Garfield::ViewIsochrons::DriftIons ( const bool negative = false )

inline

Request ion drift lines with positive (default) or negative charge.

Definition at line 47 of file ViewIsochrons.hh.

                                              { 
    m_particle = Particle::Ion;
    m_positive = !negative;
  }

◆ EnableSorting()

void Garfield::ViewIsochrons::EnableSorting ( const bool on = true )

inline

Sort (or not) the points on a contour line (default: sorting is done).

Definition at line 52 of file ViewIsochrons.hh.

52{ m_sortContours = on; }

◆ PlotIsochrons()

void Garfield::ViewIsochrons::PlotIsochrons	(	const double	tstep,
		const std::vector< std::array< double, 3 > > &	points,
		const bool	rev = `false`,
		const bool	colour = `false`,
		const bool	markers = `false`,
		const bool	plotDriftLines = `true`
	)

Draw equal time contour lines.

Parameters

tstep	Time interval.
points	List of starting points.
rev	If true, the drift time is measured from the end points of the drift lines.
colour	Draw contour lines using colours.
markers	Draw markers (as opposed to lines).
plotDriftLines	Draw drift lines together with the isochrons.

Definition at line 186 of file ViewIsochrons.cc.

                                                                      {
 
  if (!m_sensor && !m_component) {
    std::cerr << m_className << "::PlotIsochrons:\n"
              << "    Neither sensor nor component are defined.\n";
    return;
  }
  if (tstep <= 0.) {
    std::cerr << m_className << "::PlotIsochrons: Time step must be > 0.\n";
    return;
  }
  if (points.empty()) {
    std::cerr << m_className << "::PlotIsochrons:\n"
              << "    No starting points provided.\n";
    return;
  }
  if (!SetPlotLimits()) return;
  auto canvas = GetCanvas();
  canvas->cd();
  canvas->SetTitle("Isochrons");
  auto frame = canvas->DrawFrame(m_xMinPlot, m_yMinPlot, 
                                 m_xMaxPlot, m_yMaxPlot);
  frame->GetXaxis()->SetTitle(LabelX().c_str());
  frame->GetYaxis()->SetTitle(LabelY().c_str());
  canvas->Update();
 
  //-----------------------------------------------------------------------
  //   DRFEQT - The main routine (DRFEQT) accumulates equal drift time data
  //   DRFEQP   which is plotted as a set of contours in the entry DRFEQP.
  //-----------------------------------------------------------------------
  std::vector<std::vector<std::array<double, 3> > > driftLines;
  std::vector<std::array<double, 3> > startPoints;  
  std::vector<std::array<double, 3> > endPoints;  
  std::vector<int> statusCodes;
  // Accumulate drift lines.
  ComputeDriftLines(tstep, points, driftLines, startPoints, endPoints, 
                    statusCodes, rev);
  const unsigned int nDriftLines = driftLines.size();
  if (nDriftLines < 2) {
    std::cerr << m_className << "::PlotIsochrons: Too few drift lines.\n";
    return;
  }
  // Keep track of the largest number of contours.
  std::size_t nContours = 0;
  for (const auto& driftLine : driftLines) {
    nContours = std::max(nContours, driftLine.size());
  }
  if (nContours == 0) {
    std::cerr << m_className << "::PlotIsochrons: No contour lines.\n";
    return;
  }
 
  std::set<int> allStats;
  for (const auto stat : statusCodes) allStats.insert(stat);
 
  // DRFEQP
  if (m_debug) {
    std::cout << m_className << "::PlotIsochrons:\n"
              << "    Drawing " << nContours << " contours, "
              << nDriftLines << " drift lines.\n";
    std::printf("    Connection threshold:   %10.3f\n", m_connectionThreshold);
    std::printf("    Aspect ratio threshold: %10.3f\n", m_aspectRatio);
    std::printf("    Loop closing threshold: %10.3f\n", m_loopThreshold);
    if (m_sortContours) {
      std::cout << "    Sort contours.\n";
    } else {
      std::cout << "    Do not sort contours.\n";
    }
    if (m_checkCrossings) {
      std::cout << "    Check for crossings.\n";
    } else {
      std::cout << "    Do not check for crossings.\n";
    }
    if (markers) {
      std::cout << "    Mark isochron points.\n";
    } else {
      std::cout << "    Draw isochron lines.\n";
    }
  }
 
  // Loop over the equal time contours.
  TGraph graph;
  graph.SetLineColor(kGray + 2);
  graph.SetMarkerColor(kGray + 2);
  graph.SetLineStyle(m_lineStyle);
  graph.SetMarkerStyle(m_markerStyle);
  const double colRange = double(gStyle->GetNumberOfColors()) / nContours;
  for (unsigned int ic = 0; ic < nContours; ++ic) {
    if (colour) {
      const auto col = gStyle->GetColorPalette(int((ic + 0.99) * colRange));
      graph.SetLineColor(col);
      graph.SetMarkerColor(col);
    }
    for (int stat : allStats) {
      std::vector<std::pair<std::array<double, 4>, unsigned int> > contour;
      // Loop over the drift lines, picking up the points when OK.
      for (unsigned int k = 0; k < nDriftLines; ++k) {
        const auto& dl = driftLines[k]; 
        // Reject any undesirable combinations.
        if (statusCodes[k] != stat || ic >= dl.size()) continue;
        // Add the point to the contour line.
        std::array<double, 4> point = {dl[ic][0], dl[ic][1], dl[ic][2], 0.};
        contour.push_back(std::make_pair(point, k)); 
      }
      // Skip the plot of this contour if there are no points.
      if (contour.empty()) continue;
      bool circle = false;
      // If requested, sort the points on the contour line.
      if (m_sortContours && !markers) SortContour(contour, circle);
      // Plot this contour.
      if (markers) {
        // Simply mark the contours if this was requested.
        std::vector<double> xp;
        std::vector<double> yp;
        std::vector<double> zp;
        for (const auto& point : contour) {
          const double x = point.first[0];
          const double y = point.first[1];
          const double z = point.first[2];
          xp.push_back(m_proj[0][0] * x + m_proj[1][0] * y + z * m_plane[0]);
          yp.push_back(m_proj[0][1] * x + m_proj[1][1] * y + z * m_plane[1]);
          zp.push_back(m_proj[0][2] * x + m_proj[1][2] * y + z * m_plane[2]);
        }
        graph.DrawGraph(xp.size(), xp.data(), yp.data(), "Psame");
        continue;
      }
      // Regular plotting.
      const double tolx = (m_xMaxPlot - m_xMinPlot) * m_connectionThreshold;
      const double toly = (m_yMaxPlot - m_yMinPlot) * m_connectionThreshold;
      // Flag to keep track if the segment is interrupted by a drift line
      // or if it is too long.
      bool gap = false;
      // Coordinates to be plotted.
      std::vector<double> xp;
      std::vector<double> yp;
      std::vector<double> zp;
      const unsigned int nP = contour.size();
      for (unsigned int i = 0; i < nP; ++i) { 
        gap = false;
        const auto x0 = contour[i].first[0];
        const auto y0 = contour[i].first[1];
        const auto z0 = contour[i].first[2];
        xp.push_back(m_proj[0][0] * x0 + m_proj[1][0] * y0 + z0 * m_plane[0]);
        yp.push_back(m_proj[0][1] * x0 + m_proj[1][1] * y0 + z0 * m_plane[1]);
        zp.push_back(m_proj[0][2] * x0 + m_proj[1][2] * y0 + z0 * m_plane[2]);
        if (i == nP - 1) break; 
        const auto x1 = contour[i + 1].first[0];
        const auto y1 = contour[i + 1].first[1];
        // Reject contour segments which are long compared with AREA.
        if (fabs(x1 - x0) > tolx || fabs(y1 - y0) > toly) gap = true;
        // Get the indices of the drift lines corresponding 
        // to these two points on the contour line.
        const auto i0 = contour[i].second;
        const auto i1 = contour[i + 1].second; 
        // Set the BREAK flag if it crosses some stored drift line segment.
        if (m_checkCrossings && !gap) {
          for (unsigned int k = 0; k < nDriftLines; ++k) {
            const auto& dl = driftLines[k];
            for (unsigned int jc = 0; jc < dl.size(); ++jc) {
              if ((i0 == k || i1 == k) && (jc == ic || jc + 1 == ic)) {
                continue;
              }
              const auto& p0 = dl[jc];
              const auto& p1 = jc == dl.size() - 1 ? endPoints[k] : dl[jc + 1];
              if (Crossing(p0[0], p0[1], p1[0], p1[1], x0, y0, x1, y1)) {
                gap = true;
                break;
              }
            }
            if (gap) break;
            if ((i0 == k || i1 == k) && ic == 0) continue;
            const auto& p0 = startPoints[k];
            if (Crossing(p0[0], p0[1], dl[0][0], dl[0][1], 
                         x0, y0, x1, y1)) {
              gap = true;
              break;
            }
          }
        }
        // If there has been a break, plot what we have already.
        if (gap) {
          if (xp.size() > 1) {
            // Plot line.
            graph.DrawGraph(xp.size(), xp.data(), yp.data(), "Lsame");
          } else {
            // Plot markers.
            graph.DrawGraph(xp.size(), xp.data(), yp.data(), "Psame");
          }
          xp.clear();
          yp.clear();
          zp.clear();
        }
      }
      // Plot the remainder.
      if (xp.size() > 1) {
        graph.DrawGraph(xp.size(), xp.data(), yp.data(), "Lsame");
      } else if (!xp.empty()) {
        graph.DrawGraph(xp.size(), xp.data(), yp.data(), "Psame");
      }
    }
  }
 
  gPad->Update();
  if (!plotDriftLines) return;
 
  graph.SetLineStyle(1);
  if (m_particle == Particle::Electron) {
    graph.SetLineColor(kOrange - 3);
  } else {
    graph.SetLineColor(kRed + 1);
  }
  for (unsigned int i = 0; i < nDriftLines; ++i) {
    std::vector<double> xp;
    std::vector<double> yp;
    const double x0 = startPoints[i][0];
    const double y0 = startPoints[i][1];
    const double z0 = startPoints[i][2];
    xp.push_back(m_proj[0][0] * x0 + m_proj[1][0] * y0 + z0 * m_plane[0]);
    yp.push_back(m_proj[0][1] * x0 + m_proj[1][1] * y0 + z0 * m_plane[1]);
    for (const auto& point : driftLines[i]) {
      const double x = point[0];
      const double y = point[1];
      const double z = point[2];
      xp.push_back(m_proj[0][0] * x + m_proj[1][0] * y + z * m_plane[0]);
      yp.push_back(m_proj[0][1] * x + m_proj[1][1] * y + z * m_plane[1]);
    }
    const double x1 = endPoints[i][0];
    const double y1 = endPoints[i][1];
    const double z1 = endPoints[i][2];
    xp.push_back(m_proj[0][0] * x1 + m_proj[1][0] * y1 + z1 * m_plane[0]);
    yp.push_back(m_proj[0][1] * x1 + m_proj[1][1] * y1 + z1 * m_plane[1]);
    graph.DrawGraph(xp.size(), xp.data(), yp.data(), "Lsame");
  }
}

◆ SetAspectRatioSwitch()

void Garfield::ViewIsochrons::SetAspectRatioSwitch ( const double ar )

Set the aspect ratio above which an isochron is considered linear (as opposed to circular).

Definition at line 157 of file ViewIsochrons.cc.

                                                        {
 
  if (ar < 0.) {
    std::cerr << m_className << "::SetAspectRatioSwitch: Value must be > 0.\n";
    return;
  }
  m_aspectRatio = ar;
}

◆ SetComponent()

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

Set the component.

Definition at line 147 of file ViewIsochrons.cc.

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

◆ SetConnectionThreshold()

void Garfield::ViewIsochrons::SetConnectionThreshold ( const double thr )

Fractional distance over which isochron segments are connected (default: 0.2).

Definition at line 176 of file ViewIsochrons.cc.

                                                           {
 
  if (thr < 0. || thr > 1.) {
    std::cerr << m_className << "::SetConnectionThreshold:\n"
              << "    Value must be between 0 and 1.\n";
    return;
  }
  m_connectionThreshold = thr;
}

◆ SetLoopThreshold()

void Garfield::ViewIsochrons::SetLoopThreshold ( const double thr )

Fractional distance between two points for closing a circular isochron (default: 0.2).

Definition at line 166 of file ViewIsochrons.cc.

                                                     {
 
  if (thr < 0. || thr > 1.) {
    std::cerr << m_className << "::SetLoopThreshold:\n"
              << "    Value must be between 0 and 1.\n";
    return;
  }
  m_loopThreshold = thr;
}

◆ SetSensor()

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

Set the sensor.

Definition at line 137 of file ViewIsochrons.cc.

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

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ViewIsochrons()

◆ ~ViewIsochrons()

Member Function Documentation

◆ CheckCrossings()

◆ DriftElectrons()

◆ DriftIons()

◆ EnableSorting()

◆ PlotIsochrons()

◆ SetAspectRatioSwitch()

◆ SetComponent()

◆ SetConnectionThreshold()

◆ SetLoopThreshold()

◆ SetSensor()