Garfield++ 5.0
A toolkit for the detailed simulation of particle detectors based on ionisation measurement in gases and semiconductors
Loading...
Searching...
No Matches
Public Member Functions | List of all members
Garfield::Sensor Class Reference

Sensor More...

#include <Sensor.hh>

Public Member Functions

 Sensor ()=default
 Constructor.
 
 ~Sensor ()
 Destructor.
 
void AddComponent (Component *comp)
 Add a component.
 
size_t GetNumberOfComponents () const
 Get the number of components attached to the sensor.
 
Component * GetComponent (const unsigned int i)
 Retrieve the pointer to a given component.
 
void EnableComponent (const unsigned int i, const bool on)
 Activate/deactivate a given component.
 
void EnableMagneticField (const unsigned int i, const bool on)
 Activate/deactivate use of the magnetic field of a given component.
 
bool HasMagneticField () const
 Does the sensor have a non-zero magnetic field?
 
void AddElectrode (Component *comp, const std::string &label)
 Add an electrode.
 
size_t GetNumberOfElectrodes () const
 Get the number of electrodes attached to the sensor.
 
void Clear ()
 Remove all components, electrodes and reset the sensor.
 
void ElectricField (const double x, const double y, const double z, double &ex, double &ey, double &ez, double &v, Medium *&medium, int &status)
 Get the drift field and potential at (x, y, z).
 
void ElectricField (const double x, const double y, const double z, double &ex, double &ey, double &ez, Medium *&medium, int &status)
 Get the drift field at (x, y, z).
 
void MagneticField (const double x, const double y, const double z, double &bx, double &by, double &bz, int &status)
 Get the magnetic field at (x, y, z).
 
void WeightingField (const double x, const double y, const double z, double &wx, double &wy, double &wz, const std::string &label)
 Get the weighting field at (x, y, z).
 
double WeightingPotential (const double x, const double y, const double z, const std::string &label)
 Get the weighting potential at (x, y, z).
 
double DelayedWeightingPotential (const double x, const double y, const double z, const double t, const std::string &label)
 Get the delayed weighting potential at (x, y, z).
 
Medium * GetMedium (const double x, const double y, const double z)
 Get the medium at (x, y, z).
 
void EnableDebugging (const bool on=true)
 Switch debugging messages on/off.
 
bool SetArea (const bool verbose=false)
 Set the user area to the default.
 
bool SetArea (const double xmin, const double ymin, const double zmin, const double xmax, const double ymax, const double zmax)
 Set the user area explicitly.
 
bool GetArea (double &xmin, double &ymin, double &zmin, double &xmax, double &ymax, double &zmax)
 Return the current user area.
 
bool IsInArea (const double x, const double y, const double z)
 Check if a point is inside the user area.
 
bool IsInside (const double x, const double y, const double z)
 Check if a point is inside an active medium and inside the user area.
 
bool GetVoltageRange (double &vmin, double &vmax)
 Return the voltage range.
 
void NewSignal ()
 Start a new event, when computing the average signal over multiple events.
 
void ClearSignal ()
 Reset signals and induced charges of all electrodes.
 
void SetTimeWindow (const double tstart, const double tstep, const unsigned int nsteps)
 
void GetTimeWindow (double &tstart, double &tstep, unsigned int &nsteps) const
 Retrieve the time window and binning.
 
void EnableDelayedSignal (const bool on=true)
 Compute the component of the signal due to the delayed weighting field.
 
void SetDelayedSignalTimes (const std::vector< double > &ts)
 Set the points in time at which to evaluate the delayed weighting field.
 
void SetDelayedSignalAveragingOrder (const unsigned int navg)
 
void SetSignal (const std::string &label, const unsigned int bin, const double signal)
 Set/override the signal in a given time bin explicitly.
 
void SetSignal (const std::string &label, const std::vector< double > &ts, const std::vector< double > &is)
 Set/override the signal.
 
double GetSignal (const std::string &label, const unsigned int bin)
 Retrieve the total signal for a given electrode and time bin.
 
double GetSignal (const std::string &label, const unsigned int bin, const int comp)
 Retrieve the electron signal for a given electrode and time bin.
 
double GetPromptSignal (const std::string &label, const unsigned int bin)
 Retrieve the prompt signal for a given electrode and time bin.
 
double GetDelayedSignal (const std::string &label, const unsigned int bin)
 Retrieve the delayed signal for a given electrode and time bin.
 
double GetElectronSignal (const std::string &label, const unsigned int bin)
 Retrieve the electron signal for a given electrode and time bin.
 
double GetIonSignal (const std::string &label, const unsigned int bin)
 Retrieve the ion or hole signal for a given electrode and time bin.
 
double GetDelayedElectronSignal (const std::string &label, const unsigned int bin)
 Retrieve the delayed electron signal for a given electrode and time bin.
 
double GetDelayedIonSignal (const std::string &label, const unsigned int bin)
 Retrieve the delayed ion/hole signal for a given electrode and time bin.
 
double GetInducedCharge (const std::string &label)
 Calculated using the weighting potentials at the start and end points.
 
void SetTransferFunction (std::function< double(double)>)
 Set the function to be used for evaluating the transfer function.
 
void SetTransferFunction (const std::vector< double > &times, const std::vector< double > &values)
 Set the points to be used for interpolating the transfer function.
 
void SetTransferFunction (Shaper &shaper)
 Set the transfer function using a Shaper object.
 
double GetTransferFunction (const double t)
 Evaluate the transfer function at a given time.
 
void PrintTransferFunction ()
 Print some information about the presently set transfer function.
 
void PlotTransferFunction ()
 Plot the presently set transfer function.
 
void EnableTransferFunctionCache (const bool on=true)
 
bool ConvoluteSignal (const std::string &label, const bool fft=false)
 
bool ConvoluteSignals (const bool fft=false)
 Convolute all induced currents with the transfer function.
 
bool IntegrateSignal (const std::string &label)
 Replace the signal on a given electrode by its integral.
 
bool IntegrateSignals ()
 Replace the signals on all electrodes curve by their integrals.
 
bool IsIntegrated (const std::string &label) const
 Return whether the signal has been integrated/convoluted.
 
bool DelayAndSubtractFraction (const double td, const double f)
 
void SetNoiseFunction (double(*f)(double t))
 Set the function to be used for evaluating the noise component.
 
void AddNoise (const bool total=true, const bool electron=false, const bool ion=false)
 Add noise to the induced signal.
 
void AddWhiteNoise (const std::string &label, const double enc, const bool poisson=true, const double q0=1.)
 
void AddWhiteNoise (const double enc, const bool poisson=true, const double q0=1.)
 Add white noise to the induced signals on all electrodes.
 
bool ComputeThresholdCrossings (const double thr, const std::string &label, int &n)
 
size_t GetNumberOfThresholdCrossings () const
 
bool GetThresholdCrossing (const unsigned int i, double &time, double &level, bool &rise) const
 
void AddSignal (const double q, const double t0, const double t1, const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, const bool integrateWeightingField, const bool useWeightingPotential=false)
 Add the signal from a charge-carrier step.
 
void AddSignal (const double q, const std::vector< double > &ts, const std::vector< std::array< double, 3 > > &xs, const std::vector< std::array< double, 3 > > &vs, const std::vector< double > &ns, const int navg, const bool useWeightingPotential=false)
 Add the signal from a drift line.
 
void PlotSignal (const std::string &label, TPad *pad)
 Plot the induced signal.
 
void ExportSignal (const std::string &label, const std::string &filename, const bool chargeCariers=false) const
 Exporting induced signal to a csv file.
 
void AddInducedCharge (const double q, const double x0, const double y0, const double z0, const double x1, const double y1, const double z1)
 Add the induced charge from a charge carrier drift between two points.
 
bool CrossedWire (const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, double &xc, double &yc, double &zc, const bool centre, double &rc)
 
bool InTrapRadius (const double q0, const double x0, const double y0, const double z0, double &xw, double &yw, double &rw)
 Determine whether a point is in the trap radius of a wire.
 
bool CrossedPlane (const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, double &xc, double &yc, double &zc)
 
double IntegrateFluxLine (const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, const double xp, const double yp, const double zp, const unsigned int nI, const int isign=0)
 
double GetTotalInducedCharge (const std::string &label)
 
double StepSizeHint ()
 

Detailed Description

Sensor

Definition at line 20 of file Sensor.hh.

Constructor & Destructor Documentation

◆ Sensor()

Garfield::Sensor::Sensor ( )
default

Constructor.

◆ ~Sensor()

Garfield::Sensor::~Sensor ( )
inline

Destructor.

Definition at line 25 of file Sensor.hh.

25{}

Member Function Documentation

◆ AddComponent()

void Garfield::Sensor::AddComponent ( Component * comp)

Add a component.

Definition at line 355 of file Sensor.cc.

355 {
356 if (!cmp) {
357 std::cerr << m_className << "::AddComponent: Null pointer.\n";
358 return;
359 }
360
361 m_components.push_back(std::make_tuple(cmp, true, true));
362}

Referenced by main(), and Garfield::ViewField::PlotFieldLines().

◆ AddElectrode()

void Garfield::Sensor::AddElectrode ( Component * comp,
const std::string & label )

Add an electrode.

Definition at line 396 of file Sensor.cc.

396 {
397 if (!cmp) {
398 std::cerr << m_className << "::AddElectrode: Null pointer.\n";
399 return;
400 }
401 for (const auto &electrode : m_electrodes) {
402 if (electrode.label == label) {
403 std::cout << m_className << "::AddElectrode:\n"
404 << " Warning: An electrode with label \"" << label
405 << "\" exists already. Weighting fields will be summed up.\n";
406 break;
407 }
408 }
409
410 Electrode electrode;
411 electrode.comp = cmp;
412 electrode.label = label;
413 electrode.signal.assign(m_nTimeBins, 0.);
414 electrode.electronSignal.assign(m_nTimeBins, 0.);
415 electrode.ionSignal.assign(m_nTimeBins, 0.);
416 electrode.delayedSignal.assign(m_nTimeBins, 0.);
417 electrode.delayedElectronSignal.assign(m_nTimeBins, 0.);
418 electrode.delayedIonSignal.assign(m_nTimeBins, 0.);
419 m_electrodes.push_back(std::move(electrode));
420 std::cout << m_className << "::AddElectrode:\n"
421 << " Added readout electrode \"" << label << "\".\n"
422 << " All signals are reset.\n";
423 ClearSignal();
424}
Garfield::Sensor::ClearSignal
void ClearSignal()
Reset signals and induced charges of all electrodes.
Definition Sensor.cc:475

Referenced by main().

◆ AddInducedCharge()

void Garfield::Sensor::AddInducedCharge ( const double q,
const double x0,
const double y0,
const double z0,
const double x1,
const double y1,
const double z1 )

Add the induced charge from a charge carrier drift between two points.

Definition at line 845 of file Sensor.cc.

847 {
848 if (m_debug) std::cout << m_className << "::AddInducedCharge:\n";
849 for (auto &electrode : m_electrodes) {
850 // Calculate the weighting potential at the starting point.
851 auto cmp = electrode.comp;
852 const double w0 = cmp->WeightingPotential(x0, y0, z0, electrode.label);
853 // Calculate the weighting potential at the end point.
854 const double w1 = cmp->WeightingPotential(x1, y1, z1, electrode.label);
855 if (w0 > -0.5 && w1 > -0.5) {
856 electrode.charge += q * (w1 - w0);
857 }
858 if (m_debug) {
859 std::cout << " Electrode " << electrode.label << ":\n"
860 << " Weighting potential at (" << x0 << ", " << y0 << ", "
861 << z0 << "): " << w0 << "\n"
862 << " Weighting potential at (" << x1 << ", " << y1 << ", "
863 << z1 << "): " << w1 << "\n"
864 << " Induced charge: " << electrode.charge << "\n";
865 }
866 }
867}

◆ AddNoise()

void Garfield::Sensor::AddNoise ( const bool total = true,
const bool electron = false,
const bool ion = false )

Add noise to the induced signal.

Definition at line 1406 of file Sensor.cc.

1406 {
1407 if (!m_fNoise) {
1408 std::cerr << m_className << "::AddNoise: Noise function not set.\n";
1409 return;
1410 }
1411 if (m_nEvents == 0) m_nEvents = 1;
1412
1413 for (auto &electrode : m_electrodes) {
1414 double t = m_tStart + 0.5 * m_tStep;
1415 for (unsigned int j = 0; j < m_nTimeBins; ++j) {
1416 const double noise = m_fNoise(t);
1417 if (total) electrode.signal[j] += noise;
1418 if (electron) electrode.electronSignal[j] += noise;
1419 if (ion) electrode.ionSignal[j] += noise;
1420 t += m_tStep;
1421 }
1422 }
1423}

◆ AddSignal() [1/2]

void Garfield::Sensor::AddSignal ( const double q,
const double t0,
const double t1,
const double x0,
const double y0,
const double z0,
const double x1,
const double y1,
const double z1,
const bool integrateWeightingField,
const bool useWeightingPotential = false )

Add the signal from a charge-carrier step.

Definition at line 498 of file Sensor.cc.

502 {
503 if (m_debug) std::cout << m_className << "::AddSignal: ";
504 // Get the time bin.
505 if (t0 < m_tStart) {
506 if (m_debug) std::cout << "Time " << t0 << " out of range.\n";
507 return;
508 }
509 const double dt = t1 - t0;
510 if (dt < Small) {
511 if (m_debug) std::cout << "Time step too small.\n";
512 return;
513 }
514 const double invdt = 1. / dt;
515
516 const int bin = int((t0 - m_tStart) / m_tStep);
517 // Check if the starting time is outside the range
518 if (bin < 0 || bin >= (int)m_nTimeBins) {
519 if (m_debug) std::cout << "Bin " << bin << " out of range.\n";
520 return;
521 }
522 if (m_nEvents <= 0) m_nEvents = 1;
523 const bool electron = q < 0;
524 const double dx = x1 - x0;
525 const double dy = y1 - y0;
526 const double dz = z1 - z0;
527 const double vx = dx * invdt;
528 const double vy = dy * invdt;
529 const double vz = dz * invdt;
530 if (m_debug) {
531 std::cout << " Time: " << t0 << "\n"
532 << " Step: " << dt << "\n"
533 << " Charge: " << q << "\n"
534 << " Velocity: (" << vx << ", " << vy << ", " << vz << ")\n";
535 }
536 // Locations and weights for 6-point Gaussian integration
537 constexpr size_t nG = 6;
538 auto tg = Numerics::GaussLegendreNodes6();
539 auto wg = Numerics::GaussLegendreWeights6();
540 for (auto &electrode : m_electrodes) {
541 const std::string lbl = electrode.label;
542 if (m_debug) std::cout << " Electrode " << electrode.label << ":\n";
543 // Induced current.
544 double current = 0.;
545 if (useWeightingPotential) {
546 const double w0 = electrode.comp->WeightingPotential(x0, y0, z0, lbl);
547 const double w1 = electrode.comp->WeightingPotential(x1, y1, z1, lbl);
548 if (m_debug) {
549 std::cout << " Weighting potentials: " << w0 << ", " << w1 << "\n";
550 }
551 if (w0 > -0.5 && w1 > -0.5) current = q * (w1 - w0) * invdt;
552 } else {
553 double wx = 0., wy = 0., wz = 0.;
554 // Calculate the weighting field for this electrode.
555 if (integrateWeightingField) {
556 for (size_t j = 0; j < nG; ++j) {
557 const double s = 0.5 * (1. + tg[j]);
558 const double x = x0 + s * dx;
559 const double y = y0 + s * dy;
560 const double z = z0 + s * dz;
561 double fx = 0., fy = 0., fz = 0.;
562 electrode.comp->WeightingField(x, y, z, fx, fy, fz, lbl);
563 wx += wg[j] * fx;
564 wy += wg[j] * fy;
565 wz += wg[j] * fz;
566 }
567 wx *= 0.5;
568 wy *= 0.5;
569 wz *= 0.5;
570 } else {
571 const double x = x0 + 0.5 * dx;
572 const double y = y0 + 0.5 * dy;
573 const double z = z0 + 0.5 * dz;
574 electrode.comp->WeightingField(x, y, z, wx, wy, wz, lbl);
575 }
576 if (m_debug) {
577 std::cout << " Weighting field: (" << wx << ", " << wy << ", " << wz
578 << ")\n";
579 }
580 // Calculate the induced current.
581 current = -q * (wx * vx + wy * vy + wz * vz);
582 }
583 if (m_debug) std::cout << " Induced charge: " << current * dt << "\n";
584 double delta = m_tStart + (bin + 1) * m_tStep - t0;
585 // Check if the provided timestep extends over more than one time bin
586 if (dt > delta) {
587 FillBin(electrode, bin, current * delta, electron, false);
588 delta = dt - delta;
589 unsigned int j = 1;
590 while (delta > m_tStep && bin + j < m_nTimeBins) {
591 FillBin(electrode, bin + j, current * m_tStep, electron, false);
592 delta -= m_tStep;
593 ++j;
594 }
595 if (bin + j < m_nTimeBins) {
596 FillBin(electrode, bin + j, current * delta, electron, false);
597 }
598 } else {
599 FillBin(electrode, bin, current * dt, electron, false);
600 }
601 }
602 if (!m_delayedSignal) return;
603 if (m_delayedSignalTimes.empty()) return;
604 const size_t nd = m_delayedSignalTimes.size();
605 // Establish the points in time at which we evaluate the delayed signal.
606 std::vector<double> td(nd);
607 for (size_t i = 0; i < nd; ++i) {
608 td[i] = t0 + m_delayedSignalTimes[i];
609 }
610 // Calculate the signals for each electrode.
611 for (auto &electrode : m_electrodes) {
612 const std::string lbl = electrode.label;
613 std::vector<double> id(nd, 0.);
614 if (useWeightingPotential) {
615 // Using the weighting potential.
616 double chargeHolder = 0.;
617 double currentHolder = 0.;
618 int binHolder = 0;
619 // Loop over each time in the given vector of delayed times.
620 for (size_t i = 0; i < nd; ++i) {
621 double delayedtime = m_delayedSignalTimes[i] - t0; // t - t0
622 if (delayedtime < 0) continue;
623 // Find bin that needs to be filled.
624 int bin2 = int((m_delayedSignalTimes[i] - m_tStart) / m_tStep);
625 // Compute induced charge
626 double dp0 = electrode.comp->DelayedWeightingPotential(
627 x0, y0, z0, delayedtime, lbl);
628 double dp1 = electrode.comp->DelayedWeightingPotential(
629 x1, y1, z1, delayedtime, lbl);
630
631 double charge = q * (dp1 - dp0);
632 // In very rare cases the result is infinity. We do not let this
633 // contribute.
634 if (std::isnan(charge)) {
635 charge = 0.;
636 }
637 // Calculate induced current based on the induced charge.
638 if (i > 0) {
639 // Time difference between previous entry.
640 double dtt = m_delayedSignalTimes[i] - m_delayedSignalTimes[i - 1];
641 // Induced current
642 double current2 = m_tStep * (charge - chargeHolder) / dtt;
643 // Fill bins
644 if (std::abs(current2) < 1e-16) current2 = 0.;
645 electrode.delayedSignal[bin2] += current2;
646 electrode.signal[bin2] += current2;
647 if (q < 0) {
648 electrode.electronSignal[bin2] += current2;
649 electrode.delayedElectronSignal[bin2] += current2;
650 } else {
651 electrode.ionSignal[bin2] += current2;
652 electrode.delayedIonSignal[bin2] += current2;
653 }
654 // Linear interpolation if the current is calculated from the induced
655 // charge of two non-subsequent bins.
656 if (binHolder > 0 && binHolder + 1 < bin2) {
657 const int diffBin = bin2 - binHolder;
658 for (int j = binHolder + 1; j < bin2; j++) {
659 electrode.delayedSignal[j] +=
660 (j - binHolder) * (current2 - currentHolder) / diffBin +
661 currentHolder;
662 electrode.signal[j] +=
663 (j - binHolder) * (current2 - currentHolder) / diffBin +
664 currentHolder;
665 }
666 }
667 currentHolder = current2;
668 }
669 // Hold information for next current calculation and interpolation.
670 binHolder = bin2;
671 chargeHolder = charge;
672 }
673 } else {
674 // Using the weighting field.
675 for (size_t i = 0; i < nd; ++i) {
676 // Integrate over the drift line segment.
677 const double step = std::min(m_delayedSignalTimes[i], dt);
678 const double scale = step / dt;
679 double sum = 0.;
680 for (size_t j = 0; j < 6; ++j) {
681 double s = 0.5 * (1. + tg[j]);
682 const double t = m_delayedSignalTimes[i] - s * step;
683 s *= scale;
684 const double x = x0 + s * dx;
685 const double y = y0 + s * dy;
686 const double z = z0 + s * dz;
687 // Calculate the delayed weighting field.
688 double wx = 0., wy = 0., wz = 0.;
689 electrode.comp->DelayedWeightingField(x, y, z, t, wx, wy, wz, lbl);
690 sum += (wx * vx + wy * vy + wz * vz) * wg[j];
691 }
692 id[i] = -q * 0.5 * sum * step;
693 }
694 FillSignal(electrode, q, td, id, m_nAvgDelayedSignal, true);
695 }
696 }
697}
Garfield::Numerics::GaussLegendreWeights6
constexpr std::array< double, 6 > GaussLegendreWeights6()
Definition Numerics.hh:49
Garfield::Numerics::GaussLegendreNodes6
constexpr std::array< double, 6 > GaussLegendreNodes6()
Definition Numerics.hh:44

◆ AddSignal() [2/2]

void Garfield::Sensor::AddSignal ( const double q,
const std::vector< double > & ts,
const std::vector< std::array< double, 3 > > & xs,
const std::vector< std::array< double, 3 > > & vs,
const std::vector< double > & ns,
const int navg,
const bool useWeightingPotential = false )

Add the signal from a drift line.

Definition at line 699 of file Sensor.cc.

703 {
704 // Don't do anything if there are no points on the signal.
705 if (ts.size() < 2) return;
706 if (ts.size() != xs.size() || ts.size() != vs.size()) {
707 std::cerr << m_className << "::AddSignal: Mismatch in vector size.\n";
708 return;
709 }
710 const bool aval = ns.size() == ts.size();
711 const size_t nPoints = ts.size();
712 if (m_debug) {
713 std::cout << m_className << "::AddSignal: Adding a " << nPoints
714 << "-vector (charge " << q << ").\n";
715 }
716
717 if (m_nEvents <= 0) m_nEvents = 1;
718 for (auto &electrode : m_electrodes) {
719 const std::string label = electrode.label;
720 std::vector<double> signal(nPoints, 0.);
721 for (size_t i = 0; i < nPoints; ++i) {
722 const auto &x = xs[i];
723 const auto &v = vs[i];
724 if (useWeightingPotential) {
725 const double dt = i < nPoints - 1 ? ts[i + 1] - ts[i] : 0.;
726
727 const double dx = dt * v[0];
728 const double dy = dt * v[1];
729 const double dz = dt * v[2];
730
731 const double x0 = x[0] - 0.5 * dx;
732 const double y0 = x[1] - 0.5 * dy;
733 const double z0 = x[2] - 0.5 * dz;
734
735 const double x1 = x[0] + 0.5 * dx;
736 const double y1 = x[1] + 0.5 * dy;
737 const double z1 = x[2] + 0.5 * dz;
738
739 const double w0 = electrode.comp->WeightingPotential(x0, y0, z0, label);
740 const double w1 = electrode.comp->WeightingPotential(x1, y1, z1, label);
741 if (w0 > -0.5 && w1 > -0.5) {
742 signal[i] = -q * (w1 - w0) / dt;
743 if (aval) signal[i] *= ns[i];
744 }
745 } else {
746 // Calculate the weighting field at this point.
747 double wx = 0., wy = 0., wz = 0.;
748 electrode.comp->WeightingField(x[0], x[1], x[2], wx, wy, wz, label);
749 // Calculate the induced current at this point.
750 signal[i] = -q * (v[0] * wx + v[1] * wy + v[2] * wz);
751 if (aval) signal[i] *= ns[i];
752 }
753 }
754 FillSignal(electrode, q, ts, signal, navg);
755 }
756
757 if (!m_delayedSignal) return;
758 if (m_delayedSignalTimes.empty()) return;
759 // Locations and weights for 6-point Gaussian integration
760 constexpr size_t nG = 6;
761 auto tg = Numerics::GaussLegendreNodes6();
762 auto wg = Numerics::GaussLegendreWeights6();
763
764 const size_t nd = m_delayedSignalTimes.size();
765 for (size_t k = 0; k < nPoints - 1; ++k) {
766 const double t0 = ts[k];
767 const double t1 = ts[k + 1];
768 const double dt = t1 - t0;
769 if (dt < Small) continue;
770 const auto &x0 = xs[k];
771 const auto &x1 = xs[k + 1];
772 const auto &v = vs[k];
773 std::vector<double> td(nd);
774 for (size_t i = 0; i < nd; ++i) {
775 td[i] = t0 + m_delayedSignalTimes[i];
776 }
777 // Calculate the signals for each electrode.
778 for (auto &electrode : m_electrodes) {
779 const std::string lbl = electrode.label;
780 std::vector<double> id(nd, 0.);
781 for (size_t i = 0; i < nd; ++i) {
782 // Integrate over the drift line segment.
783 const double step = std::min(m_delayedSignalTimes[i], dt);
784 const double scale = step / dt;
785 const double dx = scale * (x1[0] - x0[0]);
786 const double dy = scale * (x1[1] - x0[1]);
787 const double dz = scale * (x1[2] - x0[2]);
788 double sum = 0.;
789 for (size_t j = 0; j < nG; ++j) {
790 const double f = 0.5 * (1. + tg[j]);
791 const double t = m_delayedSignalTimes[i] - f * step;
792 // Calculate the delayed weighting field.
793 double wx = 0., wy = 0., wz = 0.;
794 electrode.comp->DelayedWeightingField(x0[0] + f * dx, x0[1] + f * dy,
795 x0[2] + f * dz, t, wx, wy, wz,
796 lbl);
797 sum += (wx * v[0] + wy * v[1] + wz * v[2]) * wg[j];
798 }
799 id[i] = -q * 0.5 * sum * step;
800 }
801 FillSignal(electrode, q, td, id, m_nAvgDelayedSignal, true);
802 }
803 }
804}

◆ AddWhiteNoise() [1/2]

void Garfield::Sensor::AddWhiteNoise ( const double enc,
const bool poisson = true,
const double q0 = 1. )

Add white noise to the induced signals on all electrodes.

Definition at line 1472 of file Sensor.cc.

1473 {
1474 if (!m_fTransfer && !m_shaper && m_fTransferTab.empty()) {
1475 std::cerr << m_className << "::AddWhiteNoise: Transfer function not set.\n";
1476 return;
1477 }
1478 if (m_nEvents == 0) m_nEvents = 1;
1479
1480 const double f2 = TransferFunctionSq();
1481 if (f2 < 0.) {
1482 std::cerr << m_className << "::AddWhiteNoise:\n"
1483 << " Could not calculate transfer function integral.\n";
1484 return;
1485 }
1486
1487 if (poisson) {
1488 // Frequency of random delta pulses to model noise.
1489 const double nu = (enc * enc / (q0 * q0)) / f2;
1490 // Average number of delta pulses.
1491 const double avg = nu * m_tStep * m_nTimeBins;
1492 // Sample the number of pulses.
1493 for (auto &electrode : m_electrodes) {
1494 const int nPulses = RndmPoisson(avg);
1495 for (int j = 0; j < nPulses; ++j) {
1496 const int bin = static_cast<int>(m_nTimeBins * RndmUniform());
1497 electrode.signal[bin] += q0;
1498 }
1499 const double offset = q0 * nu * m_tStep;
1500 for (unsigned int j = 0; j < m_nTimeBins; ++j) {
1501 electrode.signal[j] -= offset;
1502 }
1503 }
1504 } else {
1505 // Gaussian approximation.
1506 const double sigma = enc * sqrt(m_tStep / f2);
1507 for (auto &electrode : m_electrodes) {
1508 for (unsigned int j = 0; j < m_nTimeBins; ++j) {
1509 electrode.signal[j] += RndmGaussian(0., sigma);
1510 }
1511 }
1512 }
1513}
Garfield::RndmUniform
double RndmUniform()
Draw a random number uniformly distributed in the range [0, 1).
Definition Random.hh:14
Garfield::RndmGaussian
double RndmGaussian()
Draw a Gaussian random variate with mean zero and standard deviation one.
Definition Random.hh:24
Garfield::RndmPoisson
int RndmPoisson(const double mean)
Draw a random number from a Poisson distribution.
Definition Random.cc:664
Heed::sqrt
DoubleAc sqrt(const DoubleAc &f)
Definition DoubleAc.cpp:314

◆ AddWhiteNoise() [2/2]

void Garfield::Sensor::AddWhiteNoise ( const std::string & label,
const double enc,
const bool poisson = true,
const double q0 = 1. )

Add white noise to the induced signal, given a desired output ENC.

Parameters
labelname of the electrode
encEquivalent Noise Charge, in electrons.
poissonflag to sample the number of noise pulses from a Poisson distribution. Otherwise the noise charge in each bin is sampled from a Gaussian distribution.
q0amplitude of the noise delta pulses (in electrons).

Definition at line 1425 of file Sensor.cc.

1426 {
1427 if (!m_fTransfer && !m_shaper && m_fTransferTab.empty()) {
1428 std::cerr << m_className << "::AddWhiteNoise: Transfer function not set.\n";
1429 return;
1430 }
1431 if (m_nEvents == 0) m_nEvents = 1;
1432
1433 const double f2 = TransferFunctionSq();
1434 if (f2 < 0.) {
1435 std::cerr << m_className << "::AddWhiteNoise:\n"
1436 << " Could not calculate transfer function integral.\n";
1437 return;
1438 }
1439
1440 if (poisson) {
1441 // Frequency of random delta pulses to model noise.
1442 const double nu = (enc * enc / (q0 * q0)) / f2;
1443 // Average number of delta pulses.
1444 const double avg = nu * m_tStep * m_nTimeBins;
1445 // Sample the number of pulses.
1446 for (auto &electrode : m_electrodes) {
1447 if (label != electrode.label) continue;
1448 const int nPulses = RndmPoisson(avg);
1449 for (int j = 0; j < nPulses; ++j) {
1450 const int bin = static_cast<int>(m_nTimeBins * RndmUniform());
1451 electrode.signal[bin] += q0;
1452 }
1453 const double offset = q0 * nu * m_tStep;
1454 for (unsigned int j = 0; j < m_nTimeBins; ++j) {
1455 electrode.signal[j] -= offset;
1456 }
1457 break;
1458 }
1459 } else {
1460 // Gaussian approximation.
1461 const double sigma = enc * sqrt(m_tStep / f2);
1462 for (auto &electrode : m_electrodes) {
1463 if (label != electrode.label) continue;
1464 for (unsigned int j = 0; j < m_nTimeBins; ++j) {
1465 electrode.signal[j] += RndmGaussian(0., sigma);
1466 }
1467 break;
1468 }
1469 }
1470}

◆ Clear()

void Garfield::Sensor::Clear ( )

Remove all components, electrodes and reset the sensor.

Definition at line 426 of file Sensor.cc.

426 {
427 std::lock_guard<std::mutex> guard(m_mutex);
428 m_components.clear();
429 m_electrodes.clear();
430 m_nTimeBins = 200;
431 m_tStart = 0.;
432 m_tStep = 10.;
433 m_nEvents = 0;
434 m_hasUserArea = false;
435 m_fTransfer = nullptr;
436 m_shaper = nullptr;
437 m_fTransferTab.clear();
438 m_fTransferSq = -1.;
439 m_fTransferFFT.clear();
440}

◆ ClearSignal()

void Garfield::Sensor::ClearSignal ( )

Reset signals and induced charges of all electrodes.

Definition at line 475 of file Sensor.cc.

475 {
476 for (auto &electrode : m_electrodes) {
477 electrode.charge = 0.;
478 electrode.signal.assign(m_nTimeBins, 0.);
479 electrode.delayedSignal.assign(m_nTimeBins, 0.);
480 electrode.electronSignal.assign(m_nTimeBins, 0.);
481 electrode.ionSignal.assign(m_nTimeBins, 0.);
482 electrode.delayedElectronSignal.assign(m_nTimeBins, 0.);
483 electrode.delayedIonSignal.assign(m_nTimeBins, 0.);
484 electrode.integrated = false;
485 }
486 m_nEvents = 0;
487}

Referenced by AddElectrode().

◆ ComputeThresholdCrossings()

bool Garfield::Sensor::ComputeThresholdCrossings ( const double thr,
const std::string & label,
int & n )

Determine the threshold crossings of the current signal curve.

Parameters
thrthreshold value
labelelectrode for which to compute the threshold crossings
nnumber of threshold crossings

Definition at line 1536 of file Sensor.cc.

1537 {
1538 // Reset the list of threshold crossings.
1539 m_thresholdCrossings.clear();
1540 m_thresholdLevel = thr;
1541
1542 // Set the interpolation order.
1543 int iOrder = 1;
1544
1545 if (m_nEvents == 0) {
1546 std::cerr << m_className << "::ComputeThresholdCrossings: "
1547 << "No signals present.\n";
1548 return false;
1549 }
1550 // Compute the total signal.
1551 std::vector<double> signal(m_nTimeBins, 0.);
1552 // Loop over the electrodes.
1553 bool foundLabel = false;
1554 for (const auto &electrode : m_electrodes) {
1555 if (electrode.label != label) continue;
1556 foundLabel = true;
1557 if (!electrode.integrated) {
1558 std::cerr << m_className << "::ComputeThresholdCrossings:\n "
1559 << "Warning: signal on electrode " << label
1560 << " has not been integrated/convoluted.\n";
1561 }
1562 for (unsigned int i = 0; i < m_nTimeBins; ++i) {
1563 signal[i] += electrode.signal[i];
1564 }
1565 }
1566 if (!foundLabel) {
1567 std::cerr << m_className << "::ComputeThresholdCrossings: Electrode "
1568 << label << " not found.\n";
1569 return false;
1570 }
1571 const double scale = ElementaryCharge / (m_nEvents * m_tStep);
1572 for (unsigned int i = 0; i < m_nTimeBins; ++i) signal[i] *= scale;
1573
1574 // Establish the range.
1575 const double vMin = *std::min_element(std::begin(signal), std::end(signal));
1576 const double vMax = *std::max_element(std::begin(signal), std::end(signal));
1577 if (m_debug) std::cout << m_className << "::ComputeThresholdCrossings:\n";
1578 if (thr < vMin && thr > vMax) {
1579 if (m_debug) {
1580 std::cout << " Threshold outside the range [" << vMin << ", " << vMax
1581 << "]\n";
1582 }
1583 return true;
1584 }
1585
1586 // Check both rising and falling edges.
1587 constexpr std::array<int, 2> directions = {1, -1};
1588 for (const auto dir : directions) {
1589 const bool up = dir > 0;
1590 if (m_debug) {
1591 if (up) {
1592 std::cout << " Hunting for rising edges.\n";
1593 } else {
1594 std::cout << " Hunting for falling edges.\n";
1595 }
1596 }
1597 // Initialise the vectors.
1598 std::vector<double> ts = {m_tStart + 0.5 * m_tStep};
1599 std::vector<double> vs = {signal[0]};
1600 // Scan the signal.
1601 for (unsigned int i = 1; i < m_nTimeBins; ++i) {
1602 // Compute the vector element.
1603 const double tNew = m_tStart + (i + 0.5) * m_tStep;
1604 const double vNew = signal[i];
1605 // If still increasing or decreasing, add to the vector.
1606 if ((up && vNew > vs.back()) || (!up && vNew < vs.back())) {
1607 ts.push_back(tNew);
1608 vs.push_back(vNew);
1609 continue;
1610 }
1611 // Otherwise see whether we crossed the threshold level.
1612 if ((vs[0] - thr) * (thr - vs.back()) >= 0. && ts.size() > 1 &&
1613 ((up && vs.back() > vs[0]) || (!up && vs.back() < vs[0]))) {
1614 // Compute the crossing time.
1615 double tcr = Numerics::Divdif(ts, vs, ts.size(), thr, iOrder);
1616 m_thresholdCrossings.emplace_back(std::make_pair(tcr, up));
1617 ts = {tNew};
1618 vs = {vNew};
1619 } else {
1620 // No crossing, simply reset the vector.
1621 ts = {tNew};
1622 vs = {vNew};
1623 }
1624 }
1625 // Check the final vector.
1626 if ((vs[0] - thr) * (thr - vs.back()) >= 0. && ts.size() > 1 &&
1627 ((up && vs.back() > vs[0]) || (!up && vs.back() < vs[0]))) {
1628 const double tcr = Numerics::Divdif(ts, vs, ts.size(), thr, iOrder);
1629 m_thresholdCrossings.emplace_back(std::make_pair(tcr, up));
1630 }
1631 }
1632 n = m_thresholdCrossings.size();
1633
1634 if (m_debug) {
1635 std::cout << " Found " << n << " crossings.\n";
1636 if (n > 0) std::cout << " Time [ns] Direction\n";
1637 for (const auto &crossing : m_thresholdCrossings) {
1638 std::cout << " " << crossing.first << " ";
1639 if (crossing.second) {
1640 std::cout << "rising\n";
1641 } else {
1642 std::cout << "falling\n";
1643 }
1644 }
1645 }
1646 // Seems to have worked.
1647 return true;
1648}
Garfield::Numerics::Divdif
double Divdif(const std::vector< double > &f, const std::vector< double > &a, int nn, double x, int mm)
Definition Numerics.cc:1255

◆ ConvoluteSignal()

bool Garfield::Sensor::ConvoluteSignal ( const std::string & label,
const bool fft = false )

Convolute the induced current on a given electrode with the transfer function.

Definition at line 1179 of file Sensor.cc.

1179 {
1180 if (!m_fTransfer && !m_shaper && m_fTransferTab.empty()) {
1181 std::cerr << m_className << "::ConvoluteSignal: "
1182 << "Transfer function not set.\n";
1183 return false;
1184 }
1185 if (m_nEvents == 0) {
1186 std::cerr << m_className << "::ConvoluteSignal: No signals present.\n";
1187 return false;
1188 }
1189
1190 if (fft) return ConvoluteSignalFFT(label);
1191 std::vector<double> cnvTab;
1192 MakeTransferFunctionTable(cnvTab);
1193 // Loop over all electrodes.
1194 for (auto &electrode : m_electrodes) {
1195 if (label != electrode.label) continue;
1196 ConvoluteSignal(electrode, cnvTab);
1197 return true;
1198 }
1199 return false;
1200}
Garfield::Sensor::ConvoluteSignal
bool ConvoluteSignal(const std::string &label, const bool fft=false)
Definition Sensor.cc:1179

Referenced by ConvoluteSignal(), and ConvoluteSignals().

◆ ConvoluteSignals()

bool Garfield::Sensor::ConvoluteSignals ( const bool fft = false)

Convolute all induced currents with the transfer function.

Definition at line 1202 of file Sensor.cc.

1202 {
1203 if (!m_fTransfer && !m_shaper && m_fTransferTab.empty()) {
1204 std::cerr << m_className << "::ConvoluteSignals: "
1205 << "Transfer function not set.\n";
1206 return false;
1207 }
1208 if (m_nEvents == 0) {
1209 std::cerr << m_className << "::ConvoluteSignals: No signals present.\n";
1210 return false;
1211 }
1212
1213 if (fft) return ConvoluteSignalFFT();
1214 std::vector<double> cnvTab;
1215 MakeTransferFunctionTable(cnvTab);
1216 // Loop over all electrodes.
1217 for (auto &electrode : m_electrodes) ConvoluteSignal(electrode, cnvTab);
1218 return true;
1219}

◆ CrossedPlane()

bool Garfield::Sensor::CrossedPlane ( const double x0,
const double y0,
const double z0,
const double x1,
const double y1,
const double z1,
double & xc,
double & yc,
double & zc )

Determine whether a line between two points crosses a plane, calls Component::CrossedPlane.

Definition at line 317 of file Sensor.cc.

319 {
320 for (const auto &cmp : m_components) {
321 if (!std::get<1>(cmp)) continue;
322 if (std::get<0>(cmp)->CrossedPlane(x0, y0, z0, x1, y1, z1, xc, yc, zc)) {
323 return true;
324 }
325 }
326 return false;
327}
Garfield::Sensor::CrossedPlane
bool CrossedPlane(const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, double &xc, double &yc, double &zc)
Definition Sensor.cc:317

Referenced by CrossedPlane().

◆ CrossedWire()

bool Garfield::Sensor::CrossedWire ( const double x0,
const double y0,
const double z0,
const double x1,
const double y1,
const double z1,
double & xc,
double & yc,
double & zc,
const bool centre,
double & rc )

Determine whether a line between two points crosses a wire, calls Component::CrossedWire.

Definition at line 292 of file Sensor.cc.

295 {
296 for (const auto &cmp : m_components) {
297 if (!std::get<1>(cmp)) continue;
298 if (std::get<0>(cmp)->CrossedWire(x0, y0, z0, x1, y1, z1, xc, yc, zc,
299 centre, rc)) {
300 return true;
301 }
302 }
303 return false;
304}
Garfield::Sensor::CrossedWire
bool CrossedWire(const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, double &xc, double &yc, double &zc, const bool centre, double &rc)
Definition Sensor.cc:292

Referenced by CrossedWire().

◆ DelayAndSubtractFraction()

bool Garfield::Sensor::DelayAndSubtractFraction ( const double td,
const double f )

Delay the signal and subtract an attenuated copy (modelling a constant fraction discriminator).

\[ v_{out} = v_{in}\left(t - t_d\right) - f v_{in}. \]

Definition at line 1380 of file Sensor.cc.

1380 {
1381 const int offset = int(td / m_tStep);
1382 for (auto &electrode : m_electrodes) {
1383 std::vector<double> signal1(m_nTimeBins, 0.);
1384 std::vector<double> signal2(m_nTimeBins, 0.);
1385 for (unsigned int j = 0; j < m_nTimeBins; ++j) {
1386 signal2[j] = f * electrode.signal[j];
1387 const int bin = j - offset;
1388 if (bin < 0 || bin >= (int)m_nTimeBins) continue;
1389 signal1[j] = electrode.signal[bin];
1390 }
1391 for (unsigned int j = 0; j < m_nTimeBins; ++j) {
1392 electrode.signal[j] = signal1[j] - signal2[j];
1393 }
1394 }
1395 return true;
1396}

◆ DelayedWeightingPotential()

double Garfield::Sensor::DelayedWeightingPotential ( const double x,
const double y,
const double z,
const double t,
const std::string & label )

Get the delayed weighting potential at (x, y, z).

Definition at line 164 of file Sensor.cc.

166 {
167 double v = 0.;
168 // Add up contributions from all components.
169 for (const auto &electrode : m_electrodes) {
170 if (electrode.label == label) {
171 v += std::max(
172 electrode.comp->DelayedWeightingPotential(x, y, z, t, label), 0.);
173 }
174 }
175 return v;
176}

◆ ElectricField() [1/2]

void Garfield::Sensor::ElectricField ( const double x,
const double y,
const double z,
double & ex,
double & ey,
double & ez,
double & v,
Medium *& medium,
int & status )

Get the drift field and potential at (x, y, z).

Definition at line 70 of file Sensor.cc.

72 {
73 ex = ey = ez = v = 0.;
74 status = -10;
75 medium = nullptr;
76 double fx = 0., fy = 0., fz = 0., p = 0.;
77 Medium *med = nullptr;
78 int stat = 0;
79 // Add up electric field contributions from all components.
80 for (const auto &cmp : m_components) {
81 if (!std::get<1>(cmp)) continue;
82 std::get<0>(cmp)->ElectricField(x, y, z, fx, fy, fz, p, med, stat);
83 if (status != 0) {
84 status = stat;
85 medium = med;
86 }
87 if (stat == 0) {
88 ex += fx;
89 ey += fy;
90 ez += fz;
91 v += p;
92 }
93 }
94}

Referenced by IsInside().

◆ ElectricField() [2/2]

void Garfield::Sensor::ElectricField ( const double x,
const double y,
const double z,
double & ex,
double & ey,
double & ez,
Medium *& medium,
int & status )

Get the drift field at (x, y, z).

Definition at line 96 of file Sensor.cc.

98 {
99 ex = ey = ez = 0.;
100 status = -10;
101 medium = nullptr;
102 double fx = 0., fy = 0., fz = 0.;
103 Medium *med = nullptr;
104 int stat = 0;
105 // Add up electric field contributions from all components.
106 for (const auto &cmp : m_components) {
107 if (!std::get<1>(cmp)) continue;
108 std::get<0>(cmp)->ElectricField(x, y, z, fx, fy, fz, med, stat);
109 if (status != 0) {
110 status = stat;
111 medium = med;
112 }
113 if (stat == 0) {
114 ex += fx;
115 ey += fy;
116 ez += fz;
117 }
118 }
119}

◆ EnableComponent()

void Garfield::Sensor::EnableComponent ( const unsigned int i,
const bool on )

Activate/deactivate a given component.

Definition at line 372 of file Sensor.cc.

372 {
373 if (i >= m_components.size()) {
374 std::cerr << m_className << "::EnableComponent: Index out of range.\n";
375 return;
376 };
377 std::get<1>(m_components[i]) = on;
378}

◆ EnableDebugging()

void Garfield::Sensor::EnableDebugging ( const bool on = true)
inline

Switch debugging messages on/off.

Definition at line 76 of file Sensor.hh.

76{ m_debug = on; }

◆ EnableDelayedSignal()

void Garfield::Sensor::EnableDelayedSignal ( const bool on = true)
inline

Compute the component of the signal due to the delayed weighting field.

Definition at line 116 of file Sensor.hh.

116{ m_delayedSignal = on; }

◆ EnableMagneticField()

void Garfield::Sensor::EnableMagneticField ( const unsigned int i,
const bool on )

Activate/deactivate use of the magnetic field of a given component.

Definition at line 380 of file Sensor.cc.

380 {
381 if (i >= m_components.size()) {
382 std::cerr << m_className << "::EnableMagneticField: Index out of range.\n";
383 return;
384 };
385 std::get<2>(m_components[i]) = on;
386}

◆ EnableTransferFunctionCache()

void Garfield::Sensor::EnableTransferFunctionCache ( const bool on = true)
inline

Cache integral and FFT of the transfer function instead of recomputing it at every call (default: on).

Definition at line 170 of file Sensor.hh.

170 {
171 m_cacheTransferFunction = on;
172 }

◆ ExportSignal()

void Garfield::Sensor::ExportSignal ( const std::string & label,
const std::string & filename,
const bool chargeCariers = false ) const

Exporting induced signal to a csv file.

Definition at line 1771 of file Sensor.cc.

1772 {
1773 const double scale = ElementaryCharge / (m_nEvents * m_tStep);
1774 for (const auto &electrode : m_electrodes) {
1775 if (electrode.label != label) continue;
1776
1777 const std::string quantity = electrode.integrated ? "Charge" : "Signal";
1778 const std::string unit = electrode.integrated ? " [fC]" : " [fC/ns]";
1779 std::ofstream myfile;
1780 std::string filename = name + ".csv";
1781 myfile.open(filename);
1782 if (!electrode.integrated) {
1783 myfile << "The cumulative induced charge.\n";
1784 } else {
1785 myfile << "The induced signal.\n";
1786 }
1787 myfile << "Time [ns]"
1788 << ",Total Prompt" << unit << ",Total Delayed" << unit << ", Total "
1789 << quantity << unit;
1790 if (chargeCarriers) {
1791 myfile << ",Electron Prompt" << unit << ",Electron Delayed" << unit
1792 << ",Electron " << quantity << unit << ",Ion Prompt" << unit
1793 << ",Ion Delayed" << unit << ",Ion " << quantity << unit;
1794 }
1795 myfile << "\n";
1796 myfile << std::setprecision(std::numeric_limits<long double>::digits10 + 1);
1797 for (unsigned int i = 0; i < m_nTimeBins; i++) {
1798 myfile << m_tStart + i * m_tStep << ","
1799 << scale * (electrode.signal[i] - electrode.delayedSignal[i])
1800 << "," << scale * electrode.delayedSignal[i] << ","
1801 << scale * electrode.signal[i];
1802 if (!chargeCarriers) {
1803 myfile << "\n";
1804 continue;
1805 }
1806 myfile << ","
1807 << scale * (electrode.electronSignal[i] -
1808 electrode.delayedElectronSignal[i])
1809 << "," << scale * electrode.delayedElectronSignal[i] << ","
1810 << scale * electrode.electronSignal[i] << ","
1811 << scale * (electrode.ionSignal[i] - electrode.delayedIonSignal[i])
1812 << "," << scale * electrode.delayedIonSignal[i] << ","
1813 << scale * electrode.ionSignal[i] << "\n";
1814 }
1815 myfile.close();
1816 std::cout << m_className << "::ExportSignal: File '" << name
1817 << ".csv' exported.\n";
1818 }
1819}

◆ GetArea()

bool Garfield::Sensor::GetArea ( double & xmin,
double & ymin,
double & zmin,
double & xmax,
double & ymax,
double & zmax )

Return the current user area.

Definition at line 234 of file Sensor.cc.

235 {
236 if (m_hasUserArea) {
237 xmin = m_xMinUser;
238 ymin = m_yMinUser;
239 zmin = m_zMinUser;
240 xmax = m_xMaxUser;
241 ymax = m_yMaxUser;
242 zmax = m_zMaxUser;
243 return true;
244 }
245
246 // User area bounds are not (yet) defined.
247 // Get the bounding box of the sensor.
248 if (!SetArea()) return false;
249
250 xmin = m_xMinUser;
251 ymin = m_yMinUser;
252 zmin = m_zMinUser;
253 xmax = m_xMaxUser;
254 ymax = m_yMaxUser;
255 zmax = m_zMaxUser;
256
257 return true;
258}
Garfield::Sensor::SetArea
bool SetArea(const bool verbose=false)
Set the user area to the default.
Definition Sensor.cc:187

Referenced by Garfield::ViewBase::PlotLimits().

◆ GetComponent()

Component * Garfield::Sensor::GetComponent ( const unsigned int i)

Retrieve the pointer to a given component.

Definition at line 364 of file Sensor.cc.

364 {
365 if (i >= m_components.size()) {
366 std::cerr << m_className << "::GetComponent: Index out of range.\n";
367 return nullptr;
368 };
369 return std::get<0>(m_components[i]);
370}

◆ GetDelayedElectronSignal()

double Garfield::Sensor::GetDelayedElectronSignal ( const std::string & label,
const unsigned int bin )

Retrieve the delayed electron signal for a given electrode and time bin.

Definition at line 927 of file Sensor.cc.

928 {
929 if (m_nEvents == 0) return 0.;
930 if (bin >= m_nTimeBins) return 0.;
931 double sig = 0.;
932 for (const auto &electrode : m_electrodes) {
933 if (electrode.label == label) sig += electrode.delayedElectronSignal[bin];
934 }
935 return ElementaryCharge * sig / (m_nEvents * m_tStep);
936}

◆ GetDelayedIonSignal()

double Garfield::Sensor::GetDelayedIonSignal ( const std::string & label,
const unsigned int bin )

Retrieve the delayed ion/hole signal for a given electrode and time bin.

Definition at line 938 of file Sensor.cc.

939 {
940 if (m_nEvents == 0) return 0.;
941 if (bin >= m_nTimeBins) return 0.;
942 double sig = 0.;
943 for (const auto &electrode : m_electrodes) {
944 if (electrode.label == label) sig += electrode.delayedIonSignal[bin];
945 }
946 return ElementaryCharge * sig / (m_nEvents * m_tStep);
947}

◆ GetDelayedSignal()

double Garfield::Sensor::GetDelayedSignal ( const std::string & label,
const unsigned int bin )

Retrieve the delayed signal for a given electrode and time bin.

Definition at line 1022 of file Sensor.cc.

1023 {
1024 if (m_nEvents == 0) return 0.;
1025 if (bin >= m_nTimeBins) return 0.;
1026 double sig = 0.;
1027 for (const auto &electrode : m_electrodes) {
1028 if (electrode.label == label) sig += electrode.delayedSignal[bin];
1029 }
1030 return ElementaryCharge * sig / (m_nEvents * m_tStep);
1031}

◆ GetElectronSignal()

double Garfield::Sensor::GetElectronSignal ( const std::string & label,
const unsigned int bin )

Retrieve the electron signal for a given electrode and time bin.

Definition at line 906 of file Sensor.cc.

907 {
908 if (m_nEvents == 0) return 0.;
909 if (bin >= m_nTimeBins) return 0.;
910 double sig = 0.;
911 for (const auto &electrode : m_electrodes) {
912 if (electrode.label == label) sig += electrode.electronSignal[bin];
913 }
914 return ElementaryCharge * sig / (m_nEvents * m_tStep);
915}

Referenced by main().

◆ GetInducedCharge()

double Garfield::Sensor::GetInducedCharge ( const std::string & label)

Calculated using the weighting potentials at the start and end points.

Definition at line 1033 of file Sensor.cc.

1033 {
1034 if (m_nEvents == 0) return 0.;
1035 double charge = 0.;
1036 for (const auto &electrode : m_electrodes) {
1037 if (electrode.label == label) charge += electrode.charge;
1038 }
1039
1040 return charge / m_nEvents;
1041}

◆ GetIonSignal()

double Garfield::Sensor::GetIonSignal ( const std::string & label,
const unsigned int bin )

Retrieve the ion or hole signal for a given electrode and time bin.

Definition at line 917 of file Sensor.cc.

917 {
918 if (m_nEvents == 0) return 0.;
919 if (bin >= m_nTimeBins) return 0.;
920 double sig = 0.;
921 for (const auto &electrode : m_electrodes) {
922 if (electrode.label == label) sig += electrode.ionSignal[bin];
923 }
924 return ElementaryCharge * sig / (m_nEvents * m_tStep);
925}

Referenced by main().

◆ GetMedium()

Medium * Garfield::Sensor::GetMedium ( const double x,
const double y,
const double z )

Get the medium at (x, y, z).

Definition at line 178 of file Sensor.cc.

178 {
179 for (const auto &cmp : m_components) {
180 if (!std::get<1>(cmp)) continue;
181 Medium *medium = std::get<0>(cmp)->GetMedium(x, y, z);
182 if (medium) return medium;
183 }
184 return nullptr;
185}

◆ GetNumberOfComponents()

size_t Garfield::Sensor::GetNumberOfComponents ( ) const
inline

Get the number of components attached to the sensor.

Definition at line 30 of file Sensor.hh.

30{ return m_components.size(); }

◆ GetNumberOfElectrodes()

size_t Garfield::Sensor::GetNumberOfElectrodes ( ) const
inline

Get the number of electrodes attached to the sensor.

Definition at line 43 of file Sensor.hh.

43{ return m_electrodes.size(); }

◆ GetNumberOfThresholdCrossings()

size_t Garfield::Sensor::GetNumberOfThresholdCrossings ( ) const
inline

Get the number of threshold crossings (after having called ComputeThresholdCrossings).

Definition at line 219 of file Sensor.hh.

219 {
220 return m_thresholdCrossings.size();
221 }

◆ GetPromptSignal()

double Garfield::Sensor::GetPromptSignal ( const std::string & label,
const unsigned int bin )

Retrieve the prompt signal for a given electrode and time bin.

Definition at line 1010 of file Sensor.cc.

1011 {
1012 if (m_nEvents == 0) return 0.;
1013 if (bin >= m_nTimeBins) return 0.;
1014 double sig = 0.;
1015 for (const auto &electrode : m_electrodes) {
1016 if (electrode.label == label)
1017 sig += electrode.signal[bin] - electrode.delayedSignal[bin];
1018 }
1019 return ElementaryCharge * sig / (m_nEvents * m_tStep);
1020}

◆ GetSignal() [1/2]

double Garfield::Sensor::GetSignal ( const std::string & label,
const unsigned int bin )

Retrieve the total signal for a given electrode and time bin.

Definition at line 976 of file Sensor.cc.

976 {
977 if (m_nEvents == 0) return 0.;
978 if (bin >= m_nTimeBins) return 0.;
979 double sig = 0.;
980 for (const auto &electrode : m_electrodes) {
981 if (electrode.label == label) sig += electrode.signal[bin];
982 }
983 return ElementaryCharge * sig / (m_nEvents * m_tStep);
984}

Referenced by main().

◆ GetSignal() [2/2]

double Garfield::Sensor::GetSignal ( const std::string & label,
const unsigned int bin,
const int comp )

Retrieve the electron signal for a given electrode and time bin.

Definition at line 986 of file Sensor.cc.

987 {
988 if (m_nEvents == 0) return 0.;
989 if (bin >= m_nTimeBins) return 0.;
990 double sig = 0.;
991 for (const auto &electrode : m_electrodes) {
992 if (electrode.label == label) {
993 switch (comp) {
994 case 1: {
995 sig += electrode.signal[bin] - electrode.delayedSignal[bin];
996 break;
997 }
998 case 2: {
999 sig += electrode.delayedSignal[bin];
1000 break;
1001 }
1002 default:
1003 sig += electrode.signal[bin];
1004 }
1005 }
1006 }
1007 return ElementaryCharge * sig / (m_nEvents * m_tStep);
1008}

◆ GetThresholdCrossing()

bool Garfield::Sensor::GetThresholdCrossing ( const unsigned int i,
double & time,
double & level,
bool & rise ) const

Retrieve the time and type of a given threshold crossing (after having called ComputeThresholdCrossings.

Parameters
iindex
timethreshold crossing time [ns]
levelthreshold (should correspond to the value requested).
riseflag whether the crossing is on a rising or falling slope.

Definition at line 1650 of file Sensor.cc.

1651 {
1652 level = m_thresholdLevel;
1653
1654 if (i >= m_thresholdCrossings.size()) {
1655 std::cerr << m_className << "::GetThresholdCrossing: Index out of range.\n";
1656 time = m_tStart + m_nTimeBins * m_tStep;
1657 return false;
1658 }
1659
1660 time = m_thresholdCrossings[i].first;
1661 rise = m_thresholdCrossings[i].second;
1662 return true;
1663}

◆ GetTimeWindow()

void Garfield::Sensor::GetTimeWindow ( double & tstart,
double & tstep,
unsigned int & nsteps ) const
inline

Retrieve the time window and binning.

Definition at line 108 of file Sensor.hh.

109 {
110 tstart = m_tStart;
111 tstep = m_tStep;
112 nsteps = m_nTimeBins;
113 }

◆ GetTotalInducedCharge()

double Garfield::Sensor::GetTotalInducedCharge ( const std::string & label)

Definition at line 1821 of file Sensor.cc.

1821 {
1822 for (const auto &electrode : m_electrodes) {
1823 if (electrode.label != label) continue;
1824 if (!electrode.integrated || m_nEvents == 0) return 0.;
1825 return ElementaryCharge * electrode.signal.back() / (m_nEvents * m_tStep);
1826 }
1827 return 0.;
1828}

◆ GetTransferFunction()

double Garfield::Sensor::GetTransferFunction ( const double t)

Evaluate the transfer function at a given time.

Definition at line 1139 of file Sensor.cc.

1139 {
1140 if (m_fTransfer) {
1141 return m_fTransfer(t);
1142 } else if (m_shaper) {
1143 return m_shaper->Shape(t);
1144 }
1145 return InterpolateTransferFunctionTable(t);
1146}

Referenced by PlotTransferFunction(), and PrintTransferFunction().

◆ GetVoltageRange()

bool Garfield::Sensor::GetVoltageRange ( double & vmin,
double & vmax )

Return the voltage range.

Definition at line 442 of file Sensor.cc.

442 {
443 // We don't know the range yet.
444 bool set = false;
445 // Loop over the components.
446 for (const auto &cmp : m_components) {
447 if (!std::get<1>(cmp)) continue;
448 double umin = 0., umax = 0.;
449 if (!std::get<0>(cmp)->GetVoltageRange(umin, umax)) continue;
450 if (set) {
451 vmin = std::min(umin, vmin);
452 vmax = std::max(umax, vmax);
453 } else {
454 vmin = umin;
455 vmax = umax;
456 set = true;
457 }
458 }
459
460 // Warn if we still don't know the range.
461 if (!set) {
462 std::cerr << m_className << "::GetVoltageRange:\n"
463 << " Sensor voltage range not known.\n";
464 vmin = vmax = 0.;
465 return false;
466 }
467
468 if (m_debug) {
469 std::cout << m_className << "::GetVoltageRange: " << vmin << " < V < "
470 << vmax << ".\n";
471 }
472 return true;
473}
Garfield::Sensor::GetVoltageRange
bool GetVoltageRange(double &vmin, double &vmax)
Return the voltage range.
Definition Sensor.cc:442

Referenced by GetVoltageRange().

◆ HasMagneticField()

bool Garfield::Sensor::HasMagneticField ( ) const

Does the sensor have a non-zero magnetic field?

Definition at line 388 of file Sensor.cc.

388 {
389 for (const auto &cmp : m_components) {
390 if (!std::get<1>(cmp) || !std::get<2>(cmp)) continue;
391 if (std::get<0>(cmp)->HasMagneticField()) return true;
392 }
393 return false;
394}
Garfield::Sensor::HasMagneticField
bool HasMagneticField() const
Does the sensor have a non-zero magnetic field?
Definition Sensor.cc:388

Referenced by HasMagneticField().

◆ IntegrateFluxLine()

double Garfield::Sensor::IntegrateFluxLine ( const double x0,
const double y0,
const double z0,
const double x1,
const double y1,
const double z1,
const double xp,
const double yp,
const double zp,
const unsigned int nI,
const int isign = 0 )

Integrate the electric field flux through a line from (x0,y0,z0) to (x1,y1,z1) along a direction (xp,yp,zp).

Definition at line 340 of file Sensor.cc.

345 {
346 double q = 0.;
347 for (const auto &cmp : m_components) {
348 if (!std::get<1>(cmp)) continue;
349 q += std::get<0>(cmp)->IntegrateFluxLine(x0, y0, z0, x1, y1, z1, xp, yp, zp,
350 nI, isign);
351 }
352 return q;
353}

◆ IntegrateSignal()

bool Garfield::Sensor::IntegrateSignal ( const std::string & label)

Replace the signal on a given electrode by its integral.

Definition at line 1341 of file Sensor.cc.

1341 {
1342 if (m_nEvents == 0) {
1343 std::cerr << m_className << "::IntegrateSignal: No signals present.\n";
1344 return false;
1345 }
1346
1347 for (auto &electrode : m_electrodes) {
1348 if (label != electrode.label) continue;
1349 IntegrateSignal(electrode);
1350 return true;
1351 }
1352 std::cerr << m_className << "::IntegrateSignal: Electrode " << label
1353 << " not found.\n";
1354 return false;
1355}
Garfield::Sensor::IntegrateSignal
bool IntegrateSignal(const std::string &label)
Replace the signal on a given electrode by its integral.
Definition Sensor.cc:1341

Referenced by IntegrateSignal(), and IntegrateSignals().

◆ IntegrateSignals()

bool Garfield::Sensor::IntegrateSignals ( )

Replace the signals on all electrodes curve by their integrals.

Definition at line 1331 of file Sensor.cc.

1331 {
1332 if (m_nEvents == 0) {
1333 std::cerr << m_className << "::IntegrateSignals: No signals present.\n";
1334 return false;
1335 }
1336
1337 for (auto &electrode : m_electrodes) IntegrateSignal(electrode);
1338 return true;
1339}

Referenced by main().

◆ InTrapRadius()

bool Garfield::Sensor::InTrapRadius ( const double q0,
const double x0,
const double y0,
const double z0,
double & xw,
double & yw,
double & rw )

Determine whether a point is in the trap radius of a wire.

Definition at line 306 of file Sensor.cc.

307 {
308 for (const auto &cmp : m_components) {
309 if (!std::get<1>(cmp)) continue;
310 if (std::get<0>(cmp)->InTrapRadius(q0, x0, y0, z0, xw, yw, rw)) {
311 return true;
312 }
313 }
314 return false;
315}
Garfield::Sensor::InTrapRadius
bool InTrapRadius(const double q0, const double x0, const double y0, const double z0, double &xw, double &yw, double &rw)
Determine whether a point is in the trap radius of a wire.
Definition Sensor.cc:306

Referenced by InTrapRadius().

◆ IsInArea()

bool Garfield::Sensor::IsInArea ( const double x,
const double y,
const double z )

Check if a point is inside the user area.

Definition at line 260 of file Sensor.cc.

260 {
261 if (!m_hasUserArea) {
262 if (!SetArea()) {
263 std::cerr << m_className << "::IsInArea: User area could not be set.\n";
264 return false;
265 }
266 m_hasUserArea = true;
267 }
268
269 if (x >= m_xMinUser && x <= m_xMaxUser && y >= m_yMinUser &&
270 y <= m_yMaxUser && z >= m_zMinUser && z <= m_zMaxUser) {
271 return true;
272 }
273
274 if (m_debug) {
275 std::cout << m_className << "::IsInArea: (" << x << ", " << y << ", " << z
276 << ") "
277 << " is outside.\n";
278 }
279 return false;
280}

◆ IsInside()

bool Garfield::Sensor::IsInside ( const double x,
const double y,
const double z )

Check if a point is inside an active medium and inside the user area.

Definition at line 282 of file Sensor.cc.

282 {
283 double ex = 0., ey = 0., ez = 0.;
284 Medium *medium = nullptr;
285 int status = 0;
286 ElectricField(x, y, z, ex, ey, ez, medium, status);
287 if (status != 0 || !medium) return false;
288
289 return true;
290}
Garfield::Sensor::ElectricField
void ElectricField(const double x, const double y, const double z, double &ex, double &ey, double &ez, double &v, Medium *&medium, int &status)
Get the drift field and potential at (x, y, z).
Definition Sensor.cc:70

◆ IsIntegrated()

bool Garfield::Sensor::IsIntegrated ( const std::string & label) const

Return whether the signal has been integrated/convoluted.

Definition at line 1373 of file Sensor.cc.

1373 {
1374 for (const auto &electrode : m_electrodes) {
1375 if (electrode.label == label) return electrode.integrated;
1376 }
1377 return false;
1378}

◆ MagneticField()

void Garfield::Sensor::MagneticField ( const double x,
const double y,
const double z,
double & bx,
double & by,
double & bz,
int & status )

Get the magnetic field at (x, y, z).

Definition at line 121 of file Sensor.cc.

122 {
123 bx = by = bz = 0.;
124 double fx = 0., fy = 0., fz = 0.;
125 // Add up contributions.
126 for (const auto &cmp : m_components) {
127 if (!std::get<2>(cmp)) continue;
128 std::get<0>(cmp)->MagneticField(x, y, z, fx, fy, fz, status);
129 if (status != 0) continue;
130 bx += fx;
131 by += fy;
132 bz += fz;
133 }
134}

◆ NewSignal()

void Garfield::Sensor::NewSignal ( )
inline

Start a new event, when computing the average signal over multiple events.

Definition at line 96 of file Sensor.hh.

96{ ++m_nEvents; }

◆ PlotSignal()

void Garfield::Sensor::PlotSignal ( const std::string & label,
TPad * pad )

Plot the induced signal.

Definition at line 1760 of file Sensor.cc.

1760 {
1761
1762 ViewSignal view;
1763 view.SetSensor(this);
1764 if (pad) view.SetCanvas(pad);
1765 std::string optTotal = "t";
1766 std::string optPrompt = "";
1767 std::string optDelayed = "";
1768 view.PlotSignal(label, optTotal, optPrompt, optDelayed);
1769}

◆ PlotTransferFunction()

void Garfield::Sensor::PlotTransferFunction ( )

Plot the presently set transfer function.

Definition at line 1085 of file Sensor.cc.

1085 {
1086
1087 const std::string name = ViewBase::FindUnusedCanvasName("cTransferFunction");
1088 std::vector<double> t;
1089 std::vector<double> f;
1090 for (unsigned int i = 0; i < m_nTimeBins; ++i) {
1091 // Positive time part.
1092 t.push_back(i * m_tStep);
1093 f.push_back(GetTransferFunction(i * m_tStep));
1094 }
1095 if (t.empty()) return;
1096 double fmin = *std::min_element(f.begin(), f.end());
1097 double fmax = *std::max_element(f.begin(), f.end());
1098 double df = fmax - fmin;
1099 if (fabs(df) < 1.e-6) {
1100 fmin -= 1.;
1101 fmax += 1.;
1102 } else {
1103 fmax += 0.1 * df;
1104 if (fmin < 0.) fmin -= 0.1 * df;
1105 }
1106
1107 TCanvas* cf = new TCanvas(name.c_str(), "Transfer Function");
1108 cf->SetGridx();
1109 cf->SetGridy();
1110 cf->DrawFrame(0., fmin, m_nTimeBins * m_tStep, fmax,
1111 ";time [ns]; transfer function");
1112 TGraph graph;
1113 graph.SetLineWidth(4);
1114 graph.SetLineColor(kBlue + 2);
1115 graph.DrawGraph(t.size(), t.data(), f.data(), "l");
1116 gPad->Update();
1117}
Garfield::Sensor::GetTransferFunction
double GetTransferFunction(const double t)
Evaluate the transfer function at a given time.
Definition Sensor.cc:1139
Garfield::ViewBase::FindUnusedCanvasName
static std::string FindUnusedCanvasName(const std::string &s)
Find an unused canvas name.
Definition ViewBase.cc:337
Garfield::Magboltz::cf
double cf[nMaxLevels][nEnergySteps]
Definition MagboltzInterface.hh:132
Heed::fabs
DoubleAc fabs(const DoubleAc &f)
Definition DoubleAc.h:615

◆ PrintTransferFunction()

void Garfield::Sensor::PrintTransferFunction ( )

Print some information about the presently set transfer function.

Definition at line 1148 of file Sensor.cc.

1148 {
1149 std::cout << m_className << "::PrintTransferFunction:\n";
1150 if (m_fTransfer) {
1151 std::cout << " User-defined function.";
1152 } else if (m_shaper) {
1153 std::string shaperType = "Unknown";
1154 if (m_shaper->IsUnipolar()) {
1155 shaperType = "Unipolar";
1156 } else if (m_shaper->IsBipolar()) {
1157 shaperType = "Bipolar";
1158 }
1159 unsigned int n = 1;
1160 double tp = 0.;
1161 m_shaper->GetParameters(n, tp);
1162 std::printf(" %s shaper with order %u and %5.1f ns peaking time.\n",
1163 shaperType.c_str(), n, tp);
1164 } else if (!m_fTransferTab.empty()) {
1165 std::cout << " Table with " << m_fTransferTab.size() << " entries.\n";
1166 } else {
1167 std::cout << " No transfer function set.\n";
1168 return;
1169 }
1170 std::cout << " Time [ns] Transfer function\n";
1171 const double dt = m_nTimeBins * m_tStep / 10.;
1172 for (size_t i = 0; i < 10; ++i) {
1173 const double t = m_tStart + (i + 0.5) * dt;
1174 const double f = GetTransferFunction(t);
1175 std::printf(" %10.3f %10.5f\n", t, f);
1176 }
1177}

◆ SetArea() [1/2]

bool Garfield::Sensor::SetArea ( const bool verbose = false)

Set the user area to the default.

Definition at line 187 of file Sensor.cc.

187 {
188 std::lock_guard<std::mutex> guard(m_mutex);
189 if (!GetBoundingBox(m_xMinUser, m_yMinUser, m_zMinUser, m_xMaxUser,
190 m_yMaxUser, m_zMaxUser)) {
191 std::cerr << m_className << "::SetArea: Bounding box is not known.\n";
192 return false;
193 }
194
195 if (verbose || m_debug) {
196 std::cout << m_className << "::SetArea:\n"
197 << " " << m_xMinUser << " < x [cm] < " << m_xMaxUser << "\n"
198 << " " << m_yMinUser << " < y [cm] < " << m_yMaxUser << "\n"
199 << " " << m_zMinUser << " < z [cm] < " << m_zMaxUser << "\n";
200 }
201 if (std::isinf(m_xMinUser) || std::isinf(m_xMaxUser)) {
202 std::cerr << m_className << "::SetArea: Warning. Infinite x-range.\n";
203 }
204 if (std::isinf(m_yMinUser) || std::isinf(m_yMaxUser)) {
205 std::cerr << m_className << "::SetArea: Warning. Infinite y-range.\n";
206 }
207 if (std::isinf(m_zMinUser) || std::isinf(m_zMaxUser)) {
208 std::cerr << m_className << "::SetArea: Warning. Infinite z-range.\n";
209 }
210 m_hasUserArea = true;
211 return true;
212}

Referenced by GetArea(), IsInArea(), main(), and Garfield::ViewField::PlotFieldLines().

◆ SetArea() [2/2]

bool Garfield::Sensor::SetArea ( const double xmin,
const double ymin,
const double zmin,
const double xmax,
const double ymax,
const double zmax )

Set the user area explicitly.

Definition at line 214 of file Sensor.cc.

215 {
216 std::lock_guard<std::mutex> guard(m_mutex);
217 if (fabs(xmax - xmin) < Small || fabs(ymax - ymin) < Small ||
218 fabs(zmax - zmin) < Small) {
219 std::cerr << m_className << "::SetArea: Invalid range.\n";
220 return false;
221 }
222
223 m_xMinUser = std::min(xmin, xmax);
224 m_yMinUser = std::min(ymin, ymax);
225 m_zMinUser = std::min(zmin, zmax);
226 m_xMaxUser = std::max(xmax, xmin);
227 m_yMaxUser = std::max(ymax, ymin);
228 m_zMaxUser = std::max(zmax, zmin);
229
230 m_hasUserArea = true;
231 return true;
232}

◆ SetDelayedSignalAveragingOrder()

void Garfield::Sensor::SetDelayedSignalAveragingOrder ( const unsigned int navg)
inline

Set the number of points to be used when averaging the delayed signal vector over a time bin (default: 0). The averaging is done with a $2\times navg + 1$ point Newton-Raphson integration.

Definition at line 123 of file Sensor.hh.

123 {
124 m_nAvgDelayedSignal = navg;
125 }

◆ SetDelayedSignalTimes()

void Garfield::Sensor::SetDelayedSignalTimes ( const std::vector< double > & ts)

Set the points in time at which to evaluate the delayed weighting field.

Definition at line 489 of file Sensor.cc.

489 {
490 if (!std::is_sorted(ts.begin(), ts.end())) {
491 std::cerr << m_className << "::SetDelayedSignalTimes:\n"
492 << " Times are not in ascending order.\n";
493 return;
494 }
495 m_delayedSignalTimes = ts;
496}

◆ SetNoiseFunction()

void Garfield::Sensor::SetNoiseFunction ( double(* f )(double t))

Set the function to be used for evaluating the noise component.

Definition at line 1398 of file Sensor.cc.

1398 {
1399 if (!f) {
1400 std::cerr << m_className << "::SetNoiseFunction: Null pointer.\n";
1401 return;
1402 }
1403 m_fNoise = f;
1404}

◆ SetSignal() [1/2]

void Garfield::Sensor::SetSignal ( const std::string & label,
const std::vector< double > & ts,
const std::vector< double > & is )

Set/override the signal.

Definition at line 961 of file Sensor.cc.

963 {
964
965 constexpr double q = -1.;
966 constexpr int navg = 0;
967 if (m_nEvents == 0) m_nEvents = 1;
968 for (auto &electrode : m_electrodes) {
969 if (electrode.label == label) {
970 FillSignal(electrode, q, ts, is, navg, false);
971 break;
972 }
973 }
974}

◆ SetSignal() [2/2]

void Garfield::Sensor::SetSignal ( const std::string & label,
const unsigned int bin,
const double signal )

Set/override the signal in a given time bin explicitly.

Definition at line 949 of file Sensor.cc.

950 {
951 if (bin >= m_nTimeBins) return;
952 if (m_nEvents == 0) m_nEvents = 1;
953 for (auto &electrode : m_electrodes) {
954 if (electrode.label == label) {
955 electrode.signal[bin] = m_nEvents * m_tStep * signal / ElementaryCharge;
956 break;
957 }
958 }
959}

◆ SetTimeWindow()

void Garfield::Sensor::SetTimeWindow ( const double tstart,
const double tstep,
const unsigned int nsteps )

Set the time window and binning for the signal calculation.

Parameters
tstartstart time [ns]
tstepbin width [ns]
nstepsnumber of bins

Definition at line 869 of file Sensor.cc.

870 {
871 m_tStart = tstart;
872 if (tstep <= 0.) {
873 std::cerr << m_className << "::SetTimeWindow: Start time out of range.\n";
874 } else {
875 m_tStep = tstep;
876 }
877
878 if (nsteps == 0) {
879 std::cerr << m_className << "::SetTimeWindow: Invalid number of bins.\n";
880 } else {
881 m_nTimeBins = nsteps;
882 }
883
884 if (m_debug) {
885 std::cout << m_className << "::SetTimeWindow: " << m_tStart
886 << " < t [ns] < " << m_tStart + m_nTimeBins * m_tStep << "\n"
887 << " Step size: " << m_tStep << " ns\n";
888 }
889
890 std::cout << m_className << "::SetTimeWindow: Resetting all signals.\n";
891 for (auto &electrode : m_electrodes) {
892 electrode.signal.assign(m_nTimeBins, 0.);
893 electrode.electronSignal.assign(m_nTimeBins, 0.);
894 electrode.ionSignal.assign(m_nTimeBins, 0.);
895 electrode.delayedSignal.assign(m_nTimeBins, 0.);
896 electrode.delayedElectronSignal.assign(m_nTimeBins, 0.);
897 electrode.delayedIonSignal.assign(m_nTimeBins, 0.);
898 electrode.integrated = false;
899 }
900 m_nEvents = 0;
901 // Reset the cached FFT of the transfer function
902 // because it depends on the number of time bins.
903 m_fTransferFFT.clear();
904}

Referenced by main().

◆ SetTransferFunction() [1/3]

void Garfield::Sensor::SetTransferFunction ( const std::vector< double > & times,
const std::vector< double > & values )

Set the points to be used for interpolating the transfer function.

Definition at line 1055 of file Sensor.cc.

1056 {
1057 if (times.empty() || values.empty()) {
1058 std::cerr << m_className << "::SetTransferFunction: Empty vector.\n";
1059 return;
1060 } else if (times.size() != values.size()) {
1061 std::cerr << m_className << "::SetTransferFunction:\n"
1062 << " Time and value vectors must have same size.\n";
1063 return;
1064 }
1065 const auto n = times.size();
1066 m_fTransferTab.clear();
1067 for (unsigned int i = 0; i < n; ++i) {
1068 m_fTransferTab.emplace_back(std::make_pair(times[i], values[i]));
1069 }
1070 std::sort(m_fTransferTab.begin(), m_fTransferTab.end());
1071 m_fTransfer = nullptr;
1072 m_shaper = nullptr;
1073 m_fTransferSq = -1.;
1074 m_fTransferFFT.clear();
1075}

◆ SetTransferFunction() [2/3]

void Garfield::Sensor::SetTransferFunction ( Shaper & shaper)

Set the transfer function using a Shaper object.

Definition at line 1077 of file Sensor.cc.

1077 {
1078 m_shaper = &shaper;
1079 m_fTransfer = nullptr;
1080 m_fTransferTab.clear();
1081 m_fTransferSq = -1.;
1082 m_fTransferFFT.clear();
1083}

◆ SetTransferFunction() [3/3]

void Garfield::Sensor::SetTransferFunction ( std::function< double(double)> f)

Set the function to be used for evaluating the transfer function.

Definition at line 1043 of file Sensor.cc.

1043 {
1044 if (!f) {
1045 std::cerr << m_className << "::SetTransferFunction: Empty function.\n";
1046 return;
1047 }
1048 m_fTransfer = f;
1049 m_shaper = nullptr;
1050 m_fTransferTab.clear();
1051 m_fTransferSq = -1.;
1052 m_fTransferFFT.clear();
1053}

◆ StepSizeHint()

double Garfield::Sensor::StepSizeHint ( )

Definition at line 329 of file Sensor.cc.

329 {
330
331 double dmin = std::numeric_limits<double>::max();
332 for (const auto &cmp : m_components) {
333 if (!std::get<1>(cmp)) continue;
334 const double d = std::get<0>(cmp)->StepSizeHint();
335 if (d > 0.) dmin = std::min(dmin, d);
336 }
337 return dmin < std::numeric_limits<double>::max() ? dmin : -1.;
338}

◆ WeightingField()

void Garfield::Sensor::WeightingField ( const double x,
const double y,
const double z,
double & wx,
double & wy,
double & wz,
const std::string & label )

Get the weighting field at (x, y, z).

Definition at line 136 of file Sensor.cc.

138 {
139 wx = wy = wz = 0.;
140 // Add up field contributions from all components.
141 for (const auto &electrode : m_electrodes) {
142 if (electrode.label == label) {
143 double fx = 0., fy = 0., fz = 0.;
144 electrode.comp->WeightingField(x, y, z, fx, fy, fz, label);
145 wx += fx;
146 wy += fy;
147 wz += fz;
148 }
149 }
150}

◆ WeightingPotential()

double Garfield::Sensor::WeightingPotential ( const double x,
const double y,
const double z,
const std::string & label )

Get the weighting potential at (x, y, z).

Definition at line 152 of file Sensor.cc.

153 {
154 double v = 0.;
155 // Add up contributions from all components.
156 for (const auto &electrode : m_electrodes) {
157 if (electrode.label == label) {
158 v += std::max(electrode.comp->WeightingPotential(x, y, z, label), 0.);
159 }
160 }
161 return v;
162}
The documentation for this class was generated from the following files: