Sensor.hh

Go to the documentation of this file.

// Include this header if we're compiling with the GPU or this is the first time
// without
#if defined(__GPUCOMPILE__) || !defined(G_SENSOR_H)
 
#if !defined(__GPUCOMPILE__) && !defined(G_SENSOR_H)
#define G_SENSOR_H
#endif
 
#include "Garfield/HelperMacros.hh"
 
#ifdef __GPUCOMPILE__
 
#else
#include <array>
#include <functional>
#include <mutex>
#include <tuple>
#include <utility>
#include <vector>
 
#include "Garfield/Component.hh"
#endif
 
class TPad;
 
namespace Garfield {
 
#if defined(__GPUCONST__)
#undef __GPUCONST__
#endif
 
// setup class names depending on if this is compiling the GPU static version or
// not
#ifdef __GPUCOMPILE__
#define __GPUCONST__ const
#else
#define __GPUCONST__
class SensorGPU;
class Shaper;
#endif

 
class GARFIELD_CLASS_NAME(Sensor) {
 public:
  GARFIELD_CLASS_NAME(Sensor)() = default;
  ~GARFIELD_CLASS_NAME(Sensor)() = default;
 
#ifndef __GPUCOMPILE__
  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);
#endif
  __DEVICE__
  void ElectricField(const double x, const double y, const double z, double& ex,
                     double& ey, double& ez,
                     GARFIELD_CLASS_NAME(Medium) * &medium,
                     int& status) __GPUCONST__;
 
#ifndef __GPUCOMPILE__
  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);
#endif
  __DEVICE__
  bool IsInArea(const double x, const double y, const double z) __GPUCONST__;
 
#ifndef __GPUCOMPILE__
  bool IsInside(const double x, const double y, const double z);

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

  void NewSignal() { ++m_nEvents; }
  void ClearSignal();
#else
  __device__ 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,
                            const int particle_idx);
#endif
 
#ifndef __GPUCOMPILE__
  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;
#endif

#ifdef __GPUCOMPILE__
  ComponentGPU** m_components = nullptr;
  size_t m_numComponents;
  friend class Sensor;
#else
  std::vector<std::tuple<Component*, bool, bool> > m_components;
#endif
 
#ifndef __GPUCOMPILE__
  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;
#else
  struct ElectrodeGPU {
    ComponentGPU* comp;
    int label;
    double* signal;
  };
 
  ElectrodeGPU* m_electrodes = nullptr;
  size_t m_numElectrodes;
#endif
 
  // Time window for signals
  double m_tStart = 0.;
  double m_tStep = 10.;
  unsigned int m_nTimeBins = 200;
  unsigned int m_nEvents = 0;
#ifndef __GPUCOMPILE__
  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.;
#endif
 
  // 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;
 
#ifndef __GPUCOMPILE__
  // 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;
    }
  }
#else
  __device__ void FillBin(ElectrodeGPU& electrode, const unsigned int bin,
                          const double signal, const bool electron,
                          const bool delayed, const int particle_idx);
#endif
 
#ifndef __GPUCOMPILE__
  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);
#endif
};
}  // namespace Garfield
 
#undef SENSORCLASS
#endif