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)
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.
Public Member Functions inherited from Garfield::ViewBase
	ViewBase ()=delete
	Default constructor.
	ViewBase (const std::string &name)
	Constructor.
virtual	~ViewBase ()
	Destructor.
void	SetCanvas (TCanvas *c)
	Set the canvas to be painted on.
TCanvas *	GetCanvas ()
	Retrieve the canvas.
void	EnableDebugging (const bool on=true)
	Switch on/off debugging output.

Additional Inherited Members
Protected Member Functions inherited from Garfield::ViewBase
std::string	FindUnusedFunctionName (const std::string &s) const
std::string	FindUnusedHistogramName (const std::string &s) const
Protected Attributes inherited from Garfield::ViewBase
std::string	m_className = "ViewBase"
bool	m_debug = false
TCanvas *	m_canvas = nullptr
bool	m_hasExternalCanvas = false
double	m_proj [3][3]

Detailed Description

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

Definition at line 18 of file ViewSignal.hh.

Constructor & Destructor Documentation

ViewSignal()

Garfield::ViewSignal::ViewSignal

(

)

Constructor.

Definition at line 12 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 induced signal.

Parameters

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

Definition at line 43 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 bool	total = true,
		const bool	electron = false,
		const bool	ion = false,
		const bool	delayed = 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.

Definition at line 44 of file ViewSignal.cc.

                                                {
  if (!m_sensor) {
    std::cerr << m_className << "::PlotSignal: Sensor is not defined.\n";
    return;
  }
 
  // Setup the canvas
  if (!m_canvas) {
    m_canvas = new TCanvas();
    m_canvas->SetTitle("Signal");
    if (m_hasExternalCanvas) m_hasExternalCanvas = false;
  }
  m_canvas->cd();
 
  unsigned int nBins = 100;
  double t0 = 0., dt = 1.;
  m_sensor->GetTimeWindow(t0, dt, nBins);
  const double t1 = t0 + nBins * dt;
 
  const auto title = label.c_str();
  std::string xlabel = "time [ns]"; 
  std::string ylabel = m_labelY;
  if (ylabel.empty()) {
    ylabel = m_sensor->IsIntegrated() ? "signal [fC]" : "signal [fC / ns]";
  }
  if (total) {
    auto hname = FindUnusedHistogramName("hSignal_").c_str();
    m_hSignal.reset(new TH1D(hname, title, nBins, t0, t1));
    m_hSignal->SetLineColor(plottingEngine.GetRootColorLine1());
    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);
    }
    m_hSignal->Draw("");
    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) {
      m_gCrossings.reset(new TGraph(nCrossings));
      m_gCrossings->SetMarkerStyle(20);
      m_gCrossings->SetMarkerColor(plottingEngine.GetRootColorLine1());
      double time = 0., level = 0.;
      bool rise = true;
      for (unsigned int i = 0; i < nCrossings; ++i) {
        if (m_sensor->GetThresholdCrossing(i, time, level, rise)) {
          m_gCrossings->SetPoint(i, time, level);
        }
      }
      m_gCrossings->Draw("psame");
    } 
 
    if (delayed) {
      hname = FindUnusedHistogramName("hDelayedSignal_").c_str();
      m_hDelayedSignal.reset(new TH1D(hname, title, nBins, t0, t1));
      m_hDelayedSignal->SetLineColor(kCyan + 2);
      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->Draw("same");
    }
    m_canvas->Update();
  }
 
  // Plot the electron and ion signals if requested.
  if (electron) {
    auto hname = FindUnusedHistogramName("hSignalElectrons_").c_str();
    m_hSignalElectrons.reset(new TH1D(hname, title, nBins, t0, t1));
    m_hSignalElectrons->SetLineColor(plottingEngine.GetRootColorElectron());
    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);
    }
    m_hSignalElectrons->Draw("same");
    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) {
      hname = FindUnusedHistogramName("hDelayedSignalElectrons_").c_str();
      m_hDelayedSignalElectrons.reset(new TH1D(hname, title, nBins, t0, t1));
      m_hDelayedSignalElectrons->SetLineColor(kYellow - 7);
      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->Draw("same");
    }
    m_canvas->Update();
  }
  if (ion) {
    auto hname = FindUnusedHistogramName("hSignalIons_").c_str();
    m_hSignalIons.reset(new TH1D(hname, title, nBins, t0, t1));
    m_hSignalIons->SetLineColor(plottingEngine.GetRootColorIon());
    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);
    }
    m_hSignalIons->Draw("same");
    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) {
      hname = FindUnusedHistogramName("hDelayedSignalIons_").c_str();
      m_hDelayedSignalIons.reset(new TH1D(hname, title, nBins, t0, t1));
      m_hDelayedSignalIons->SetLineColor(kRed - 9);
      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->Draw("same");
    }
    m_canvas->Update();
  }
}

Referenced by main().

SetLabelY()

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

inline

Override the default y-axis label.

Definition at line 59 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 22 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 33 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 14 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 51 of file ViewSignal.hh.

{ m_userRangeX = false; }

UnsetRangeY()

void Garfield::ViewSignal::UnsetRangeY ( )

inline

Remove the user-defined y-axis limits.

Definition at line 56 of file ViewSignal.hh.

{ m_userRangeY = false; }

---

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

• ViewSignal.hh
• ViewSignal.cc