Sensor.hh

Go to the documentation of this file.

#ifndef G_SENSOR_H
#define G_SENSOR_H
 
#include <array>
#include <functional>
#include <mutex>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
class TPad;
 
namespace Garfield {
 
class SensorGPU;
class Shaper;
class Component;
class Medium;

class Sensor {
 public:
  Sensor() = default;
  ~Sensor() = default;

  Sensor(Component* comp);
  void AddComponent(Component* comp);
  size_t GetNumberOfComponents() const { return m_components.size(); }
  Component* GetComponent(const unsigned int i);
  void EnableComponent(const unsigned int i, const bool on);
  void EnableMagneticField(const unsigned int i, const bool on);
  bool HasMagneticField() const;

  void AddElectrode(Component* comp, const std::string& label);
  size_t GetNumberOfElectrodes() const { return m_electrodes.size(); }
  void ClearElectrodes();
  void Clear();

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

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

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

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

  Medium* GetMedium(const double x, const double y, const double z);

  void EnableDebugging(const bool on = true) { m_debug = on; }

  bool SetArea(const bool verbose = false);
  bool SetArea(const double xmin, const double ymin, const double zmin,
               const double xmax, const double ymax, const double zmax);
  bool GetArea(double& xmin, double& ymin, double& zmin, double& xmax,
               double& ymax, double& zmax);
  bool IsInArea(const double x, const double y, const double z);

  bool IsInside(const double x, const double y, const double z);

  bool GetVoltageRange(double& vmin, double& vmax);

  void NewSignal() { ++m_nEvents; }
  void ClearSignal();

  void SetTimeWindow(const double tstart, const double tstep,
                     const unsigned int nsteps);
  void GetTimeWindow(double& tstart, double& tstep,
                     unsigned int& nsteps) const {
    tstart = m_tStart;
    tstep = m_tStep;
    nsteps = m_nTimeBins;
  }

  void EnableDelayedSignal(const bool on = true) { m_delayedSignal = on; }
  void SetDelayedSignalTimes(const std::vector<double>& ts);
  void SetDelayedSignalAveragingOrder(const unsigned int navg) {
    m_nAvgDelayedSignal = navg;
  }

  void SetSignal(const std::string& label, const unsigned int bin,
                 const double signal);
  void SetSignal(const std::string& label, const std::vector<double>& ts,
                 const std::vector<double>& is);
  double GetSignal(const std::string& label, const unsigned int bin);
  double GetSignal(const std::string& label, const unsigned int bin,
                   const int comp);
  double GetPromptSignal(const std::string& label, const unsigned int bin);
  double GetDelayedSignal(const std::string& label, const unsigned int bin);
  double GetElectronSignal(const std::string& label, const unsigned int bin);
  double GetIonSignal(const std::string& label, const unsigned int bin);
  double GetDelayedElectronSignal(const std::string& label,
                                  const unsigned int bin);
  double GetDelayedIonSignal(const std::string& label, const unsigned int bin);
  double GetInducedCharge(const std::string& label);

  void SetTransferFunction(std::function<double(double)>);
  void SetTransferFunction(const std::vector<double>& times,
                           const std::vector<double>& values);
  void SetTransferFunction(Shaper& shaper);
  double GetTransferFunction(const double t);
  void PrintTransferFunction();
  void PlotTransferFunction();
  void EnableTransferFunctionCache(const bool on = true) {
    m_cacheTransferFunction = on;
  }

  bool ConvoluteSignal(const std::string& label, const bool fft = false);
  bool ConvoluteSignals(const bool fft = false);
  bool IntegrateSignal(const std::string& label);
  bool IntegrateSignals();
  bool IsIntegrated(const std::string& label) const;

  bool DelayAndSubtractFraction(const double td, const double f);
  void SetNoiseFunction(double (*f)(double t));
  void AddNoise(const bool total = true, const bool electron = false,
                const bool ion = false);
  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.);

  bool ComputeThresholdCrossings(const double thr, const std::string& label,
                                 int& n);
  size_t GetNumberOfThresholdCrossings() const {
    return m_thresholdCrossings.size();
  }

  bool GetThresholdCrossing(const unsigned int i, double& time, double& level,
                            bool& rise) const;

  void AddSignalWeightingPotential(
      const double q, const std::vector<double>& ts,
      const std::vector<std::array<double, 3> >& xs);
  void AddSignalWeightingPotential(
      const double q, const std::vector<double>& ts,
      const std::vector<std::array<double, 3> >& xs,
      const std::vector<double>& qs);
  void AddSignalWeightingField(const double q, const std::vector<double>& ts,
                               const std::vector<std::array<double, 3> >& xs,
                               const bool integrateWeightingField);
  void AddSignalWeightingField(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);

  void PlotSignal(const std::string& label, TPad* pad,
                  const std::string optTotal = "t",
                  const std::string optPrompt = "",
                  const std::string optDelayed = "");
  void ExportSignal(const std::string& label, const std::string& filename,
                    const bool chargeCariers = false) const;

  void AddInducedCharge(const double q, const double x0, const double y0,
                        const double z0, const double x1, const double y1,
                        const double z1);

  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);
  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);
  // TODO!
  double GetTotalInducedCharge(const std::string& label);
 
  double StepSizeHint();

  double CreateGPUTransferObject(SensorGPU*& sensor_gpu);
#if USEGPU
  void TransferGPUElectrodeSignals(SensorGPU*& sensor_gpu);
#endif
 
 private:
  std::string m_className = "Sensor";
  std::mutex m_mutex;

  std::vector<std::tuple<Component*, bool, bool> > m_components;
 
  struct Electrode {
    Component* comp;
    std::string label;
    std::vector<double> signal;
    std::vector<double> delayedSignal;
    std::vector<double> electronSignal;
    std::vector<double> ionSignal;
    std::vector<double> delayedElectronSignal;
    std::vector<double> delayedIonSignal;
    double charge;
    bool integrated;
  };

  std::vector<Electrode> m_electrodes;
 
  // Time window for signals
  double m_tStart = 0.;
  double m_tStep = 10.;
  unsigned int m_nTimeBins = 200;
  unsigned int m_nEvents = 0;
 
  bool m_delayedSignal = false;
  std::vector<double> m_delayedSignalTimes;
  unsigned int m_nAvgDelayedSignal = 0;
 
  // Transfer function
  std::function<double(double)> m_fTransfer;
  Shaper* m_shaper = nullptr;
  std::vector<std::pair<double, double> > m_fTransferTab;
  bool m_cacheTransferFunction = true;
  // Integral of the transfer function squared.
  double m_fTransferSq = -1.;
  // FFT of the transfer function.
  std::vector<double> m_fTransferFFT;
 
  // Noise
  double (*m_fNoise)(double t) = nullptr;
 
  std::vector<std::pair<double, bool> > m_thresholdCrossings;
  double m_thresholdLevel = 0.;
 
  // User bounding box
  double m_xMinUser = 0., m_yMinUser = 0., m_zMinUser = 0.;
  double m_xMaxUser = 0., m_yMaxUser = 0., m_zMaxUser = 0.;
  bool m_hasUserArea = false;
 
  // Switch on/off debugging messages
  bool m_debug = false;
 
  // Return the current sensor size
  bool GetBoundingBox(double& xmin, double& ymin, double& zmin, double& xmax,
                      double& ymax, double& zmax);
 
  void FillSignal(Electrode& electrode, const double q,
                  const std::vector<double>& ts, const std::vector<double>& is,
                  const int navg, const bool delayed = false);
  void FillBin(Electrode& electrode, const unsigned int bin,
               const double signal, const bool electron, const bool delayed) {
    std::lock_guard<std::mutex> guard(m_mutex);
    electrode.signal[bin] += signal;
    if (delayed) electrode.delayedSignal[bin] += signal;
    if (electron) {
      electrode.electronSignal[bin] += signal;
      if (delayed) electrode.delayedElectronSignal[bin] += signal;
    } else {
      electrode.ionSignal[bin] += signal;
      if (delayed) electrode.delayedIonSignal[bin] += signal;
    }
  }
 
  void IntegrateSignal(Electrode& electrode);
  void ConvoluteSignal(Electrode& electrode, const std::vector<double>& tab);
  bool ConvoluteSignalFFT();
  bool ConvoluteSignalFFT(const std::string& label);
  void ConvoluteSignalFFT(Electrode& electrode, const std::vector<double>& tab,
                          const unsigned int nn);
  // Evaluate the integral over the transfer function squared.
  double TransferFunctionSq();
  double InterpolateTransferFunctionTable(const double t) const;
  void MakeTransferFunctionTable(std::vector<double>& tab);
  void FFT(std::vector<double>& data, const bool inverse, const int nn);
};
 
}  // namespace Garfield
#endif