Component.hh

Go to the documentation of this file.

#ifndef G_COMPONENT_H
#define G_COMPONENT_H
 
#include <array>
#include <cstdint>
#include <string>
#include <vector>
 
namespace Garfield {
 
class ComponentGPU;
class Geometry;
class Medium;

class Component {
 public:
  Component() = delete;
  Component(const std::string& name);
  virtual ~Component() = default;

  virtual void SetGeometry(Geometry* geo);
  virtual void Clear();

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

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

  std::array<double, 3> ElectricField(const double x, const double y,
                                      const double z);
  virtual double ElectricPotential(const double x, const double y,
                                   const double z);
  virtual bool GetVoltageRange(double& vmin, double& vmax) = 0;

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

  virtual const std::vector<double>& DelayedSignalTimes(
      const std::string& /*label*/) {
    return m_wdtimes;
  }

  virtual void DelayedWeightingField(const double x, const double y,
                                     const double z, const double t, double& wx,
                                     double& wy, double& wz,
                                     const std::string& label);

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

  virtual void DelayedWeightingPotentials(const double x, const double y,
                                          const double z,
                                          const std::string& label,
                                          std::vector<double>& dwp);
  virtual void MagneticField(const double x, const double y, const double z,
                             double& bx, double& by, double& bz, int& status);
  void SetMagneticField(const double bx, const double by, const double bz);

  virtual bool IsReady() { return m_ready; }
  virtual bool Is3d() { return true; }

  virtual bool GetBoundingBox(double& xmin, double& ymin, double& zmin,
                              double& xmax, double& ymax, double& zmax);

  virtual bool GetElementaryCell(double& xmin, double& ymin, double& zmin,
                                 double& xmax, double& ymax, double& zmax);
  // Get the x-length of the elementary cell.
  double CellSizeX();
  // Get the y-length of the elementary cell.
  double CellSizeY();
  // Get the z-length of the elementary cell.
  double CellSizeZ();

  virtual size_t GetNumberOfElements() const { return 0; }
  virtual bool GetElementNodes(const size_t /*i*/,
                               std::vector<size_t>& /*nodes*/) const {
    return false;
  }

  virtual bool GetElementRegion(const size_t /*i*/, size_t& /*mat*/,
                                bool& /*drift*/) const {
    return false;
  }

  virtual size_t GetNumberOfNodes() const { return 0; }
  virtual bool GetNode(const size_t i, double& x, double& y, double& z) const;

  double IntegrateFluxCircle(const double xc, const double yc, const double r,
                             const unsigned int nI = 50);
  double IntegrateFluxSphere(const double xc, const double yc, const double zc,
                             const double r, const unsigned int nI = 20);

  double IntegrateFluxParallelogram(
      const double x0, const double y0, const double z0, const double dx1,
      const double dy1, const double dz1, const double dx2, const double dy2,
      const double dz2, const unsigned int nU = 20, const unsigned int nV = 20);

  double IntegrateWeightingFluxParallelogram(
      const std::string& label, const double x0, const double y0,
      const double z0, const double dx1, const double dy1, const double dz1,
      const double dx2, const double dy2, const double dz2,
      const unsigned int nU = 20, const unsigned int nV = 20);

  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);

  virtual 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);
  virtual bool InTrapRadius(const double q0, const double x0, const double y0,
                            const double z0, double& xw, double& yw,
                            double& rw);
  virtual 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);

  void EnablePeriodicityX(const bool on = true) {
    m_periodic[0] = on;
    UpdatePeriodicity();
  }

  void EnablePeriodicityY(const bool on = true) {
    m_periodic[1] = on;
    UpdatePeriodicity();
  }

  void EnablePeriodicityZ(const bool on = true) {
    m_periodic[2] = on;
    UpdatePeriodicity();
  }

  void IsPeriodic(bool& perx, bool& pery, bool& perz) {
    perx = m_periodic[0];
    pery = m_periodic[1];
    perz = m_periodic[2];
  }

  void EnableMirrorPeriodicityX(const bool on = true) {
    m_mirrorPeriodic[0] = on;
    UpdatePeriodicity();
  }

  void EnableMirrorPeriodicityY(const bool on = true) {
    m_mirrorPeriodic[1] = on;
    UpdatePeriodicity();
  }

  void EnableMirrorPeriodicityZ(const bool on = true) {
    m_mirrorPeriodic[2] = on;
    UpdatePeriodicity();
  }

  void IsMirrorPeriodic(bool& perx, bool& pery, bool& perz) {
    perx = m_mirrorPeriodic[0];
    pery = m_mirrorPeriodic[1];
    perz = m_mirrorPeriodic[2];
  }

  void EnableAxialPeriodicityX(const bool on = true) {
    m_axiallyPeriodic[0] = on;
    UpdatePeriodicity();
  }

  void EnableAxialPeriodicityY(const bool on = true) {
    m_axiallyPeriodic[1] = on;
    UpdatePeriodicity();
  }

  void EnableAxialPeriodicityZ(const bool on = true) {
    m_axiallyPeriodic[2] = on;
    UpdatePeriodicity();
  }

  void IsAxiallyPeriodic(bool& perx, bool& pery, bool& perz) {
    perx = m_axiallyPeriodic[0];
    pery = m_axiallyPeriodic[1];
    perz = m_axiallyPeriodic[2];
  }

  void EnableRotationSymmetryX(const bool on = true) {
    m_rotationSymmetric[0] = on;
    UpdatePeriodicity();
  }

  void EnableRotationSymmetryY(const bool on = true) {
    m_rotationSymmetric[1] = on;
    UpdatePeriodicity();
  }

  void EnableRotationSymmetryZ(const bool on = true) {
    m_rotationSymmetric[2] = on;
    UpdatePeriodicity();
  }

  void IsRotationSymmetric(bool& rotx, bool& roty, bool& rotz) {
    rotx = m_rotationSymmetric[0];
    roty = m_rotationSymmetric[1];
    rotz = m_rotationSymmetric[2];
  }

  void EnableTriangleSymmetricXY(const bool on = true, const bool oct = 2) {
    m_triangleSymmetric[0] = on;
    m_triangleSymmetricOct = oct;
    m_mirrorPeriodic[0] = on;
    m_mirrorPeriodic[1] = on;
  }

  void EnableTriangleSymmetricXZ(const bool on = true, const bool oct = 2) {
    m_triangleSymmetric[1] = on;
    m_triangleSymmetricOct = oct;
    m_mirrorPeriodic[0] = on;
    m_mirrorPeriodic[2] = on;
  }

  void EnableTriangleSymmetricYZ(const bool on = true, const bool oct = 2) {
    m_triangleSymmetric[2] = on;
    m_triangleSymmetricOct = oct;
    m_mirrorPeriodic[1] = on;
    m_mirrorPeriodic[2] = on;
  }

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

  virtual bool HasMagneticField() const;

  virtual bool HasTownsendMap() const { return false; }
  virtual bool HasAttachmentMap() const { return false; }
  virtual bool HasMobilityMap() const { return false; }
  virtual bool HasVelocityMap() const { return false; }

  virtual bool ElectronAttachment(const double /*x*/, const double /*y*/,
                                  const double /*z*/, double& eta) {
    eta = 0;
    return false;
  }

  virtual bool HoleAttachment(const double /*x*/, const double /*y*/,
                              const double /*z*/, double& eta) {
    eta = 0;
    return false;
  }
 
  // Get the electron mobility coefficient.
  virtual bool ElectronMobility(const double /*x*/, const double /*y*/,
                                const double /*z*/, double& mu) {
    mu = 0;
    return false;
  }

  virtual bool HoleMobility(const double /*x*/, const double /*y*/,
                            const double /*z*/, double& mu) {
    mu = 0;
    return false;
  }

  virtual bool ElectronTownsend(const double /*x*/, const double /*y*/,
                                const double /*z*/, double& alpha) {
    alpha = 0;
    return false;
  }

  virtual bool HoleTownsend(const double /*x*/, const double /*y*/,
                            const double /*z*/, double& alpha) {
    alpha = 0;
    return false;
  }

  virtual bool ElectronVelocity(const double /*x*/, const double /*y*/,
                                const double /*z*/, double& vx, double& vy,
                                double& vz) {
    vx = vy = vz = 0;
    return false;
  }

  virtual bool HoleVelocity(const double /*x*/, const double /*y*/,
                            const double /*z*/, double& vx, double& vy,
                            double& vz) {
    vx = vy = vz = 0;
    return false;
  }
 
  virtual double StepSizeHint() { return -1.; }

  virtual double CreateGPUTransferObject(ComponentGPU*& comp_gpu);
 
 protected:
  std::string m_className{"Component"};

  Geometry* m_geometry{nullptr};

  std::array<double, 3> m_b0 = {{0., 0., 0.}};
  bool m_ready{false};

  bool m_debug{false};

  std::array<bool, 3> m_periodic = {{false, false, false}};
  std::array<bool, 3> m_mirrorPeriodic = {{false, false, false}};
  std::array<bool, 3> m_axiallyPeriodic = {{false, false, false}};
  std::array<bool, 3> m_rotationSymmetric = {{false, false, false}};
  std::array<bool, 3> m_triangleSymmetric = {{false, false, false}};
  int m_triangleSymmetricOct = 0;
  const std::array<int, 4> m_triangleOctRules = {1, 4, 5, 8};
  bool m_outsideCone = false;
  std::vector<double> m_wdtimes;

  virtual void Reset() = 0;
  virtual void UpdatePeriodicity() = 0;
 
 private:
  double IntegrateFluxParallelogram(const double x0, const double y0,
                                    const double z0, const double dx1,
                                    const double dy1, const double dz1,
                                    const double dx2, const double dy2,
                                    const double dz2, const unsigned int nU,
                                    const unsigned int nV, const bool wfield,
                                    const std::string& label);
};
 
}  // namespace Garfield
#endif