Garfield::ViewSignal Class Reference

Plot the signal computed by a sensor as a ROOT histogram. More...

#include <ViewSignal.hh>

Inheritance diagram for Garfield::ViewSignal:

Public Member Functions
	ViewSignal ()
	Constructor.
	~ViewSignal ()=default
	Destructor.
void	SetSensor (Sensor *s)
	Set the sensor from which to retrieve the signal.
void	PlotSignal (const std::string &label, const std::string &optTotal="t", const std::string &optPrompt="", const std::string &optDelayed="", const bool same=false)
TH1D *	GetHistogram (const char h='t')
void	SetRangeX (const double xmin, const double xmax)
	Set the x-axis limits explicitly.
void	UnsetRangeX ()
	Remove the user-defined x-axis limits.
void	SetRangeY (const double ymin, const double ymax)
	Set the y-axis limits explicitly.
void	UnsetRangeY ()
	Remove the user-defined y-axis limits.
void	SetLabelY (const std::string &label)
	Override the default y-axis label.
void	EnableLegend (const bool on=true)
	Draw a legend on the plot or not.
void	SetColourTotal (const short col)
	Set the (ROOT) colour with which to draw the total signal.
void	SetColourElectrons (const short col)
	Set the (ROOT) colour with which to draw the electron component.
void	SetColourIons (const short col)
	Set the (ROOT) colour with which to draw the hole/ion component.
void	SetColourHoles (const short col)
	Set the (ROOT) colour with which to draw the hole/ion component.
void	SetColourDelayed (const short colTotal, const short colElectrons=kYellow - 7, const short colIons=kRed - 9)
	Set the (ROOT) colours with which to draw the delayed signal(s).
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	SetPlaneZX ()
	Set the viewing plane to z-x.
void	SetPlaneZY ()
	Set the viewing plane to z-y.
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
Static Protected Member Functions inherited from Garfield::ViewBase
static bool	RangeSet (TVirtualPad *)
static void	SetRange (TVirtualPad *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

Plot the signal computed by a sensor as a ROOT histogram.

Definition at line 19 of file ViewSignal.hh.

Constructor & Destructor Documentation

ViewSignal()

Garfield::ViewSignal::ViewSignal

(

)

Constructor.

Definition at line 16 of file ViewSignal.cc.

: ViewBase("ViewSignal") {}

~ViewSignal()

Garfield::ViewSignal::~ViewSignal ( )

default

Destructor.

Member Function Documentation

EnableLegend()

void Garfield::ViewSignal::EnableLegend ( const bool on = true )

inline

Draw a legend on the plot or not.

Definition at line 77 of file ViewSignal.hh.

{ m_legend = on; }

GetHistogram()

TH1D * Garfield::ViewSignal::GetHistogram ( const char h = 't' )

inline

Retrieve the histogram for the total, prompt and delayed induced charge or signal.

Parameters

h	histogram to be returned ('t': total, 'e': electron-induced, 'i': ion/hole-induced).

Definition at line 58 of file ViewSignal.hh.

                                         {
    return h == 'e' ? m_hSignalElectrons.get()
                    : h == 'i' ? m_hSignalIons.get() : m_hSignal.get();
  }

PlotSignal()

void Garfield::ViewSignal::PlotSignal	(	const std::string &	label,
		const std::string &	optTotal = "t",
		const std::string &	optPrompt = "",
		const std::string &	optDelayed = "",
		const bool	same = false )

Plot the signal.

Parameters

label	Identifier (weighting field) of the signal to be plotted.
optTotal	String containing information about the total signals you want to plot. The syntax is the first letter of the charge carrier signal component you want to plot: "t" for total, "e" for electron and "i" for ion/hole. "tei" enables all three components. The total signal is always plotted.
optPrompt	String containing information about the prompt signal components you want to plot. The syntax is identical to the one described above.
optDelayed	String containing information about the delayed signal components you want to plot. The syntax is identical to the one described above.
same	Flag to keep existing plots on the canvas or not.

Definition at line 61 of file ViewSignal.cc.

                                             {
  const bool totalT = true;
  const bool totalP =
      settingPrompt.find("t") != std::string::npos ? true : false;
  const bool totalD =
      settingDelayed.find("t") != std::string::npos ? true : false;
  const bool electronT =
      settingTotal.find("e") != std::string::npos ? true : false;
  const bool electronP =
      settingPrompt.find("e") != std::string::npos ? true : false;
  const bool electronD =
      settingDelayed.find("e") != std::string::npos ? true : false;
  const bool ionT = settingTotal.find("i") != std::string::npos ? true : false;
  const bool ionP = settingPrompt.find("i") != std::string::npos ? true : false;
  const bool ionD =
      settingDelayed.find("i") != std::string::npos ? true : false;
 
  constexpr int lineThickness = 5;
  constexpr double tol = 1e-50;
 
  if (!m_sensor) {
    std::cerr << m_className << "::PlotSignal: Sensor is not defined.\n";
    return;
  }
 
  auto canvas = GetCanvas();
  canvas->cd();
  canvas->SetTitle("Signal");
 
  unsigned int nBins = 100;
  double t0 = 0., dt = 1.;
  m_sensor->GetTimeWindow(t0, dt, nBins);
  const double t1 = t0 + nBins * dt;
 
  std::string xlabel = "time [ns]";
  std::string ylabel = m_labelY;
  if (ylabel.empty()) {
    ylabel = m_sensor->IsIntegrated(label) ? "signal [fC]" : "signal [fC / ns]";
  }
  unsigned int nPlots = same ? 1 : 0;
  if (!RangeSet(gPad)) nPlots = 0;
 
  if (totalT) {
    const auto hname = FindUnusedHistogramName("hSignal_");
    m_hSignal.reset(new TH1D(hname.c_str(), "", nBins, t0, t1));
    m_hSignal->SetDirectory(nullptr);
    m_hSignal->SetLineColor(m_colTotal);
    for (unsigned int i = 0; i < nBins; ++i) {
      const double sig = m_sensor->GetSignal(label, i, 0);
      if (!std::isnan(sig) && std::abs(sig) < tol) {
        m_hSignal->SetBinContent(i + 1, 0.);
      } else {
        m_hSignal->SetBinContent(i + 1, sig);
      }
    }
 
    m_hSignal->SetLineWidth(lineThickness);
 
    const std::string opt = nPlots > 0 ? "same" : "";
    ++nPlots;
 
    // Get and plot threshold crossings.
    const auto nCrossings = m_sensor->GetNumberOfThresholdCrossings();
    if (nCrossings > 0) {
      TGraph gCrossings;
      gCrossings.SetMarkerStyle(20);
      gCrossings.SetMarkerColor(m_colTotal);
      std::vector<double> xp;
      std::vector<double> yp;
      double time = 0., level = 0.;
      bool rise = true;
      for (unsigned int i = 0; i < nCrossings; ++i) {
        if (m_sensor->GetThresholdCrossing(i, time, level, rise)) {
          xp.push_back(time);
          yp.push_back(level);
        }
      }
      gCrossings.DrawGraph(xp.size(), xp.data(), yp.data(), "psame");
    }
    DrawHistogram(m_hSignal.get(), opt, xlabel, ylabel);
  }
 
  if (totalD) {
    const auto hname = FindUnusedHistogramName("hDelayedSignal_");
    m_hDelayedSignal.reset(new TH1D(hname.c_str(), "", nBins, t0, t1));
    m_hDelayedSignal->SetDirectory(nullptr);
    m_hDelayedSignal->SetLineColor(m_colDelayed[3]);
    m_hDelayedSignal->SetLineStyle(7);
    m_hDelayedSignal->SetStats(0);
    for (unsigned int i = 0; i < nBins; ++i) {
      const double sig = m_sensor->GetSignal(label, i, 2);
      if (!std::isnan(sig) && std::abs(sig) < tol) {
        m_hDelayedSignal->SetBinContent(i + 1, 0.);
      } else {
        m_hDelayedSignal->SetBinContent(i + 1, sig);
      }
    }
    m_hDelayedSignal->SetLineWidth(lineThickness);
    m_hDelayedSignal->DrawCopy("same");
  }
 
  if (totalP) {
    const auto hname = FindUnusedHistogramName("hPromptSignal_");
    m_hPromptSignal.reset(new TH1D(hname.c_str(), "", nBins, t0, t1));
    m_hPromptSignal->SetDirectory(nullptr);
    m_hPromptSignal->SetLineColor(m_colPrompt[0]);
    m_hPromptSignal->SetLineStyle(2);
    m_hPromptSignal->SetStats(0);
    for (unsigned int i = 0; i < nBins; ++i) {
      const double sig = m_sensor->GetSignal(label, i, 1);
      if (!std::isnan(sig) && std::abs(sig) < tol) {
        m_hPromptSignal->SetBinContent(i + 1, 0.);
      } else {
        m_hPromptSignal->SetBinContent(i + 1, sig);
      }
    }
 
    m_hPromptSignal->SetLineWidth(lineThickness);
    m_hPromptSignal->DrawCopy("same");
  }
 
  if (electronT) {
    const auto hname = FindUnusedHistogramName("hSignalElectrons_");
    m_hSignalElectrons.reset(new TH1D(hname.c_str(), "", nBins, t0, t1));
    m_hSignalElectrons->SetDirectory(nullptr);
    m_hSignalElectrons->SetLineColor(m_colElectrons);
    for (unsigned int i = 0; i < nBins; ++i) {
      const double sig = m_sensor->GetElectronSignal(label, i);
      m_hSignalElectrons->SetBinContent(i + 1, sig);
    }
    m_hSignalElectrons->SetLineWidth(lineThickness);
    m_hSignalElectrons->DrawCopy("same");
  }
 
  if (electronD) {
    const auto hname = FindUnusedHistogramName("m_hDelayedElectrons_");
    m_hDelayedElectrons.reset(new TH1D(hname.c_str(), "", nBins, t0, t1));
    m_hDelayedElectrons->SetDirectory(nullptr);
    m_hDelayedElectrons->SetLineColor(m_colDelayed[4]);
    m_hDelayedElectrons->SetLineStyle(7);
    m_hDelayedElectrons->SetStats(0);
    for (unsigned int i = 0; i < nBins; ++i) {
      const double sig = m_sensor->GetDelayedElectronSignal(label, i);
      if (!std::isnan(sig) && std::abs(sig) < tol) {
        m_hDelayedElectrons->SetBinContent(i + 1, 0.);
      } else {
        m_hDelayedElectrons->SetBinContent(i + 1, sig);
      }
    }
    m_hDelayedElectrons->SetLineWidth(lineThickness);
    m_hDelayedElectrons->DrawCopy("same");
  }
 
  if (electronP) {
    const auto hname = FindUnusedHistogramName("m_hPromptElectrons_");
    m_hPromptElectrons.reset(new TH1D(hname.c_str(), "", nBins, t0, t1));
    m_hPromptElectrons->SetDirectory(nullptr);
    m_hPromptElectrons->SetLineColor(m_colPrompt[1]);
    m_hPromptElectrons->SetLineStyle(2);
    m_hPromptElectrons->SetStats(0);
    for (unsigned int i = 0; i < nBins; ++i) {
      const double sig = m_sensor->GetElectronSignal(label, i) -
                         m_sensor->GetDelayedElectronSignal(label, i);
      if (!std::isnan(sig) && std::abs(sig) < tol) {
        m_hPromptElectrons->SetBinContent(i + 1, 0.);
      } else {
        m_hPromptElectrons->SetBinContent(i + 1, sig);
      }
    }
 
    m_hPromptElectrons->SetLineWidth(lineThickness);
    m_hPromptElectrons->DrawCopy("same");
  }
 
  if (ionT) {
    const auto hname = FindUnusedHistogramName("m_hSignalIons_");
    m_hSignalIons.reset(new TH1D(hname.c_str(), "", nBins, t0, t1));
    m_hSignalIons->SetDirectory(nullptr);
    m_hSignalIons->SetLineColor(m_colIons);
    for (unsigned int i = 0; i < nBins; ++i) {
      const double sig = m_sensor->GetIonSignal(label, i);
      m_hSignalIons->SetBinContent(i + 1, sig);
    }
    m_hSignalIons->SetLineWidth(lineThickness);
    m_hSignalIons->DrawCopy("same");
  }
 
  if (ionD) {
    const auto hname = FindUnusedHistogramName("m_hDelayedIons_");
    m_hDelayedIons.reset(new TH1D(hname.c_str(), "", nBins, t0, t1));
    m_hDelayedIons->SetDirectory(nullptr);
    m_hDelayedIons->SetLineColor(m_colDelayed[5]);
    m_hDelayedIons->SetLineStyle(7);
    m_hDelayedIons->SetStats(0);
    for (unsigned int i = 0; i < nBins; ++i) {
      const double sig = m_sensor->GetDelayedIonSignal(label, i);
      if (!std::isnan(sig) && std::abs(sig) < tol) {
        m_hDelayedIons->SetBinContent(i + 1, 0.);
      } else {
        m_hDelayedIons->SetBinContent(i + 1, sig);
      }
    }
    m_hDelayedIons->SetLineWidth(lineThickness);
    m_hDelayedIons->DrawCopy("same");
  }
 
  if (ionP) {
    std::cerr << m_className << "::ionP.\n";
    const auto hname = FindUnusedHistogramName("m_hPromptIons_");
    m_hPromptIons.reset(new TH1D(hname.c_str(), "", nBins, t0, t1));
    m_hPromptIons->SetDirectory(nullptr);
    m_hPromptIons->SetLineColor(m_colPrompt[2]);
    m_hPromptIons->SetLineStyle(2);
    m_hPromptIons->SetStats(0);
    for (unsigned int i = 0; i < nBins; ++i) {
      const double sig = m_sensor->GetIonSignal(label, i) -
                         m_sensor->GetDelayedIonSignal(label, i);
      if (!std::isnan(sig) && std::abs(sig) < tol) {
        m_hPromptIons->SetBinContent(i + 1, 0.);
      } else {
        m_hPromptIons->SetBinContent(i + 1, sig);
      }
    }
 
    m_hPromptIons->SetLineWidth(lineThickness);
    m_hPromptIons->DrawCopy("same");
  }
 
  if (m_legend) {
    TLegend* leg = new TLegend(0.7, 0.7, 0.9, 0.9);
    leg->SetHeader("Induced current components");
    if (totalT) leg->AddEntry(m_hSignal.get(), "Total induced signal", "l");
    if (totalP) {
      leg->AddEntry(m_hPromptSignal.get(), "Prompt induced signal", "l");
    }
    if (totalD) {
      leg->AddEntry(m_hDelayedSignal.get(), "Delayed induced signal", "l");
    }
    if (electronT) {
      leg->AddEntry(m_hSignalElectrons.get(), "Electron induced signal", "l");
    }
    if (electronP) {
      leg->AddEntry(m_hPromptElectrons.get(), "Electron prompt induced signal",
                    "l");
    }
    if (electronD) {
      leg->AddEntry(m_hDelayedElectrons.get(),
                    "Electron delayed induced signal", "l");
    }
    if (ionT) leg->AddEntry(m_hSignalIons.get(), "Ion induced signal", "l");
    if (ionP) {
      leg->AddEntry(m_hPromptIons.get(), "Ion/hole prompt induced signal", "l");
    }
    if (ionD) {
      leg->AddEntry(m_hDelayedIons.get(), "Ion/hole delayed induced signal",
                    "l");
    }
    leg->Draw();
  }
  gPad->Update();
}

Referenced by main(), and Garfield::Sensor::PlotSignal().

SetColourDelayed()

void Garfield::ViewSignal::SetColourDelayed ( const short colTotal, const short colElectrons = kYellow - 7, const short colIons = kRed - 9 )

inline

Set the (ROOT) colours with which to draw the delayed signal(s).

Definition at line 89 of file ViewSignal.hh.

                                                        {
    m_colDelayed = {colTotal, colElectrons, colIons};
  }

SetColourElectrons()

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

inline

Set the (ROOT) colour with which to draw the electron component.

Definition at line 82 of file ViewSignal.hh.

{ m_colElectrons = col; }

SetColourHoles()

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

inline

Set the (ROOT) colour with which to draw the hole/ion component.

Definition at line 86 of file ViewSignal.hh.

{ m_colIons = col; }

SetColourIons()

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

inline

Set the (ROOT) colour with which to draw the hole/ion component.

Definition at line 84 of file ViewSignal.hh.

{ m_colIons = col; }

SetColourTotal()

void Garfield::ViewSignal::SetColourTotal ( const short col )

inline

Set the (ROOT) colour with which to draw the total signal.

Definition at line 80 of file ViewSignal.hh.

{ m_colTotal = col; }

SetLabelY()

void Garfield::ViewSignal::SetLabelY ( const std::string & label )

inline

Override the default y-axis label.

Definition at line 74 of file ViewSignal.hh.

{ m_labelY = label; }

SetRangeX()

void Garfield::ViewSignal::SetRangeX	(	const double	xmin,
		const double	xmax )

Set the x-axis limits explicitly.

Definition at line 26 of file ViewSignal.cc.

                                                               {
  if (fabs(xmax - xmin) < Small) {
    std::cerr << m_className << "::SetRangeX: Invalid range.\n";
    return;
  }
  m_xmin = std::min(xmin, xmax);
  m_xmax = std::max(xmin, xmax);
  m_userRangeX = true;
}

SetRangeY()

void Garfield::ViewSignal::SetRangeY	(	const double	ymin,
		const double	ymax )

Set the y-axis limits explicitly.

Definition at line 36 of file ViewSignal.cc.

                                                               {
  if (fabs(ymax - ymin) < Small) {
    std::cerr << m_className << "::SetRangeY: Invalid range.\n";
    return;
  }
  m_ymin = std::min(ymin, ymax);
  m_ymax = std::max(ymin, ymax);
  m_userRangeY = true;
}

SetSensor()

void Garfield::ViewSignal::SetSensor

(

Sensor *

s

)

Set the sensor from which to retrieve the signal.

Definition at line 18 of file ViewSignal.cc.

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

Referenced by main(), and Garfield::Sensor::PlotSignal().

UnsetRangeX()

void Garfield::ViewSignal::UnsetRangeX ( )

inline

Remove the user-defined x-axis limits.

Definition at line 66 of file ViewSignal.hh.

{ m_userRangeX = false; }

UnsetRangeY()

void Garfield::ViewSignal::UnsetRangeY ( )

inline

Remove the user-defined y-axis limits.

Definition at line 71 of file ViewSignal.hh.

{ m_userRangeY = false; }

---

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

• ViewSignal.hh
• ViewSignal.cc