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 bool total=true, const bool electron=false, const bool ion=false, const bool delayed=false, const bool same=false)
void	Plot (const std::string &label, const bool getsignal, const bool total=true, const bool delayed=true, 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	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 hich to draw the hole/ion component.
void	SetColourHoles (const short col)
	Set the (ROOT) colour with hich 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	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

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 15 of file ViewSignal.cc.

: ViewBase("ViewSignal") {}

~ViewSignal()

Garfield::ViewSignal::~ViewSignal ( )

default

Destructor.

Member Function Documentation

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 61 of file ViewSignal.hh.

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

Plot()

void Garfield::ViewSignal::Plot	(	const std::string &	label,
		const bool	getsignal,
		const bool	total = true,
		const bool	delayed = true,
		const bool	same = false
	)

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

Parameters

label	Identifier (weighting field) of the signal to be plotted.
h	histogram to be returned
electron	Flag whether to plot the electron-induced signal.
ion	Flag whether to plot the ion/hole-induced signal.
delayed	Flag whether to plot the delayed signal component.
same	Flag to keep existing plots on the canvas or not.
getsignal	is true for plotting the induced signal and false for plotting the induced charge.

Definition at line 187 of file ViewSignal.cc.

                                                                             {
  // When plotting the induced charge, integrate the signal.
  if (!getsignal) m_sensor->IntegrateSignal(label);
  // Check if sensor is defined.
  if (!m_sensor) {
    std::cerr << m_className << "::PlotSignal: Sensor is not defined.\n";
    return;
  }
    const double pres = 1e-50;
  // Create canvas
  auto canvas = GetCanvas();
  canvas->cd();
  canvas->SetTitle("Signal");
  // Get the time window from the sensor class
  unsigned int nBins = 100;
  double t0 = 0., dt = 1.;
  m_sensor->GetTimeWindow(t0, dt, nBins);
  const double t1 = t0 + nBins * dt;
  // Axis labels
  std::string xlabel = "time [ns]";
  std::string ylabel = m_labelY;
  if (ylabel.empty()) {
    ylabel = getsignal ? "signal [fC / ns]" : "charge [fC]";
  }
  // This plot will contain three seperate histograms: prompt, delayed and total
  // signal/charge.
  unsigned int nPlots = same ? 1 : 0;
  if (total) {
    // Makign the total signal/charge histogram.
    const auto hname = FindUnusedHistogramName("hSignal_");
    m_hSignal.reset(new TH1D(hname.c_str(), "", nBins, t0, t1));
    m_hSignal->SetLineColor(m_colTotal);
    // Set histogram axis labels
    m_hSignal->GetXaxis()->SetTitle(xlabel.c_str());
    m_hSignal->GetYaxis()->SetTitle(ylabel.c_str());
    m_hSignal->SetStats(0);
    // Fill histogram with total signal
    for (unsigned int i = 0; i < nBins; ++i) {
      const double sig = m_sensor->GetSignal(label, i, 0);
      if(!std::isnan(sig) && std::abs(sig) < pres) {
        m_hSignal->SetBinContent(i + 1, 0.);
      } else {
        m_hSignal->SetBinContent(i + 1, sig);
      }
    }
    m_hSignal->SetLineWidth(6);
    const std::string opt = nPlots > 0 ? "same" : "";
    m_hSignal->DrawCopy(opt.c_str());
    ++nPlots;
    if (m_userRangeX) m_hSignal->SetAxisRange(m_xmin, m_xmax, "X");
    if (m_userRangeY) m_hSignal->SetAxisRange(m_ymin, m_ymax, "Y");
    // 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");
    }
    if (delayed) {
      // Making the delayed component histogram.
      const auto hnamed = FindUnusedHistogramName("hDelayedCharge_");
      m_hDelayedSignal.reset(new TH1D(hnamed.c_str(), "", nBins, t0, t1));
      m_hDelayedSignal->SetLineColor(m_colDelayed[0]);
      m_hDelayedSignal->SetLineStyle(2);
      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) < pres) {
          m_hDelayedSignal->SetBinContent(i + 1, 0.);
        } else {
          m_hDelayedSignal->SetBinContent(i + 1, sig);
        }
      }
      m_hDelayedSignal->SetFillStyle(3001);
      m_hDelayedSignal->SetFillColor(m_colDelayed[0]);
    }
    // Making the prompt component histogram.
    const auto dnamed = FindUnusedHistogramName("hPromptCharge_");
    m_hPromptSignal.reset(new TH1D(dnamed.c_str(), "", nBins, t0, t1));
    m_hPromptSignal->SetLineColor(m_colDelayed[2]);
    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) < pres) {
        m_hPromptSignal->SetBinContent(i + 1, 0.);
      } else {
        m_hPromptSignal->SetBinContent(i + 1, sig);
      }
    }
    m_hPromptSignal->SetFillStyle(3001);
    m_hPromptSignal->SetFillColor(m_colDelayed[2]);
    m_hPromptSignal->DrawCopy("same");
    if (delayed) m_hDelayedSignal->DrawCopy("same");
 
    TPaveLabel *label1 = new TPaveLabel(-3.5, 700, -1, 800, "Default option");
    label1->Draw();
    // Coloring the bins.
    TH1D *g0 = new TH1D("g0", "g0", nBins, 0, 1);
    g0->SetFillColor(m_colTotal);
    TH1D *g1 = new TH1D("g1", "g1", nBins, 0, 1);
    g1->SetFillStyle(3001);
    g1->SetFillColor(m_colDelayed[0]);
 
    TH1D *g2 = new TH1D("g2", "g2", nBins, 0, 1);
    g2->SetFillStyle(3001);
    g2->SetFillColor(m_colDelayed[2]);
 
    TLegend *leg = new TLegend(0.7, 0.7, 0.9, 0.9);
    if (!getsignal) {
      leg->SetHeader("Induced charge as a function of time");
      leg->AddEntry(g0, "Total induced charge", "f");
      leg->AddEntry(g2, "Prompt induced charge", "f");
      if (delayed) leg->AddEntry(g1, "Delayed induced charge", "f");
 
    } else {
      leg->SetHeader("Induced current as a function of time");
      leg->AddEntry(g0, "Total induced current", "f");
      leg->AddEntry(g2, "Prompt induced current", "f");
      if (delayed) leg->AddEntry(g1, "Delayed induced current", "f");
    }
    leg->Draw();
    gPad->Update();
 
    delete g0;
    if (delayed) delete g1;
    delete g2;
  }
}

PlotSignal()

void Garfield::ViewSignal::PlotSignal	(	const std::string &	label,
		const bool	total = true,
		const bool	electron = false,
		const bool	ion = false,
		const bool	delayed = false,
		const bool	same = false
	)

Plot the signal.

Parameters

label	Identifier (weighting field) of the signal to be plotted.
total	Flag whether to plot the total induced signal.
electron	Flag whether to plot the electron-induced signal.
ion	Flag whether to plot the ion/hole-induced signal.
delayed	Flag whether to plot the delayed signal component.
same	Flag to keep existing plots on the canvas or not.

Definition at line 45 of file ViewSignal.cc.

                                                                 {
  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 (total) {
    const auto hname = FindUnusedHistogramName("hSignal_");
    m_hSignal.reset(new TH1D(hname.c_str(), "", nBins, t0, t1));
    m_hSignal->SetLineColor(m_colTotal);
    m_hSignal->GetXaxis()->SetTitle(xlabel.c_str());
    m_hSignal->GetYaxis()->SetTitle(ylabel.c_str());
    m_hSignal->SetStats(0);
    for (unsigned int i = 0; i < nBins; ++i) {
      const double sig = m_sensor->GetSignal(label, i);
      m_hSignal->SetBinContent(i + 1, sig);
    }
    const std::string opt = nPlots > 0 ? "same" : "";
    m_hSignal->DrawCopy(opt.c_str());
    ++nPlots;
    if (m_userRangeX) m_hSignal->SetAxisRange(m_xmin, m_xmax, "X");
    if (m_userRangeY) m_hSignal->SetAxisRange(m_ymin, m_ymax, "Y");
 
    // 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");
    }
 
    if (delayed) {
      const auto hnamed = FindUnusedHistogramName("hDelayedSignal_");
      m_hDelayedSignal.reset(new TH1D(hnamed.c_str(), "", nBins, t0, t1));
      m_hDelayedSignal->SetLineColor(m_colDelayed[0]);
      m_hDelayedSignal->SetLineStyle(2);
      m_hDelayedSignal->SetStats(0);
      for (unsigned int i = 0; i < nBins; ++i) {
        const double sig = m_sensor->GetDelayedElectronSignal(label, i) +
                           m_sensor->GetDelayedIonSignal(label, i);
        m_hDelayedSignal->SetBinContent(i + 1, sig);
      }
      m_hDelayedSignal->DrawCopy("same");
    }
    gPad->Update();
  }
 
  // Plot the electron and ion signals if requested.
  if (electron) {
    const auto hname = FindUnusedHistogramName("hSignalElectrons_");
    m_hSignalElectrons.reset(new TH1D(hname.c_str(), "", nBins, t0, t1));
    m_hSignalElectrons->SetLineColor(m_colElectrons);
    m_hSignalElectrons->GetXaxis()->SetTitle(xlabel.c_str());
    m_hSignalElectrons->GetYaxis()->SetTitle(ylabel.c_str());
    m_hSignalElectrons->SetStats(0);
    for (unsigned int i = 0; i < nBins; ++i) {
      const double sig = m_sensor->GetElectronSignal(label, i);
      m_hSignalElectrons->SetBinContent(i + 1, sig);
    }
    const std::string opt = nPlots > 0 ? "same" : "";
    m_hSignalElectrons->DrawCopy(opt.c_str());
    ++nPlots;
    if (!total) {
      if (m_userRangeX) m_hSignalElectrons->SetAxisRange(m_xmin, m_xmax, "X");
      if (m_userRangeY) m_hSignalElectrons->SetAxisRange(m_ymin, m_ymax, "Y");
    }
    if (delayed) {
      const auto hnamed = FindUnusedHistogramName("hDelayedSignalElectrons_");
      m_hDelayedSignalElectrons.reset(new TH1D(hnamed.c_str(), "", nBins, t0, t1));
      m_hDelayedSignalElectrons->SetLineColor(m_colDelayed[1]);
      m_hDelayedSignalElectrons->SetLineStyle(2);
      m_hDelayedSignalElectrons->SetStats(0);
      for (unsigned int i = 0; i < nBins; ++i) {
        const double sig = m_sensor->GetDelayedElectronSignal(label, i);
        m_hDelayedSignalElectrons->SetBinContent(i + 1, sig);
      }
      m_hDelayedSignalElectrons->DrawCopy("same");
    }
    gPad->Update();
  }
  if (ion) {
    const auto hname = FindUnusedHistogramName("hSignalIons_");
    m_hSignalIons.reset(new TH1D(hname.c_str(), "", nBins, t0, t1));
    m_hSignalIons->SetLineColor(m_colIons);
    m_hSignalIons->GetXaxis()->SetTitle(xlabel.c_str());
    m_hSignalIons->GetYaxis()->SetTitle(ylabel.c_str());
    m_hSignalIons->SetStats(0);
    for (unsigned int i = 0; i < nBins; ++i) {
      const double sig = m_sensor->GetIonSignal(label, i);
      m_hSignalIons->SetBinContent(i + 1, sig);
    }
    const std::string opt = nPlots > 0 ? "same" : "";
    m_hSignalIons->DrawCopy(opt.c_str());
    ++nPlots;
    if (!(total || electron)) {
      if (m_userRangeX) m_hSignalIons->SetAxisRange(m_xmin, m_xmax, "X");
      if (m_userRangeY) m_hSignalIons->SetAxisRange(m_ymin, m_ymax, "Y");
    }
    if (delayed) {
      const auto hnamed = FindUnusedHistogramName("hDelayedSignalIons_");
      m_hDelayedSignalIons.reset(new TH1D(hnamed.c_str(), "", nBins, t0, t1));
      m_hDelayedSignalIons->SetLineColor(m_colDelayed[2]);
      m_hDelayedSignalIons->SetLineStyle(2);
      m_hDelayedSignalIons->SetStats(0);
      for (unsigned int i = 0; i < nBins; ++i) {
        const double sig = m_sensor->GetDelayedIonSignal(label, i);
        m_hDelayedSignalIons->SetBinContent(i + 1, sig);
      }
      m_hDelayedSignalIons->DrawCopy("same");
    }
    gPad->Update();
  }
}

Referenced by main().

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 hich 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 hich 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 77 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 25 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 35 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 17 of file ViewSignal.cc.

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

Referenced by main().

UnsetRangeX()

void Garfield::ViewSignal::UnsetRangeX ( )

inline

Remove the user-defined x-axis limits.

Definition at line 69 of file ViewSignal.hh.

{ m_userRangeX = false; }

UnsetRangeY()

void Garfield::ViewSignal::UnsetRangeY ( )

inline

Remove the user-defined y-axis limits.

Definition at line 74 of file ViewSignal.hh.

{ m_userRangeY = false; }

---

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

• ViewSignal.hh
• ViewSignal.cc