Component.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_COMPONENT_H)
 
#if !defined(__GPUCOMPILE__) && !defined(G_COMPONENT_H)
#define G_COMPONENT_H
#endif
 
#include "Garfield/HelperMacros.hh"
 
#ifdef __GPUCOMPILE__
#else
 
#include <array>
#include <string>
#include <vector>
 
#endif
 
namespace Garfield {
 
// setup class names depending on if this is compiling the GPU static version or
// not
#if !defined(__GPUCOMPILE__)
class ComponentGPU;
class Geometry;
class Medium;
#endif

class GARFIELD_CLASS_NAME(Component) {
 public:
#ifdef __GPUCOMPILE__
  GARFIELD_CLASS_NAME(Component)() = default;
#else
  GARFIELD_CLASS_NAME(Component)() = delete;
  GARFIELD_CLASS_NAME(Component)(const std::string& name);
#endif
  virtual ~GARFIELD_CLASS_NAME(Component)() {};
 
#ifndef __GPUCOMPILE__
  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;
#else
  __device__ void ElectricField(const cuda_t xin, const cuda_t yin,
                                const cuda_t zin, cuda_t& ex, cuda_t& ey,
                                cuda_t& ez, MediumGPU*& m, int& status);
#endif
 
#ifndef __GPUCOMPILE__
  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.}};
#endif
  bool m_ready = false;
 
#ifdef __GPUCOMPILE__
  bool m_periodic[3] = {false, false, false};
  bool m_mirrorPeriodic[3] = {false, false, false};
  bool m_axiallyPeriodic[3] = {false, false, false};
  bool m_rotationSymmetric[3] = {false, false, false};
  bool m_triangleSymmetric[3] = {false, false, false};
  int m_triangleSymmetricOct = 0;
  const int m_triangleOctRules[4] = {1, 4, 5, 8};
  bool m_outsideCone = false;
#else
  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;
#endif
 
#ifndef __GPUCOMPILE__
  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);
#else
 
// include parts from derived class due to big performance hit from using
// virtual methods
// TODO GPU TN: It isn't clear to me that we actually need (at least) the Ansys
// include - all the code is protected by an ifndef __GPUCOMPILE__, whereas it
// will be defined when these includes are made
#include "ComponentAnsys123.hh"
#include "ComponentFieldMap.hh"
 
  friend class ComponentAnsys123;
  friend class ComponentComsol;
  friend class ComponentElmer;
  friend class ComponentFieldMap;
  friend class Component;
 
  // enum to mimic polymorphism
  enum class ComponentType {
    Component = 0,
    ComponentFieldMap,
    ComponentAnsys123,
    ComponentComsol,
    ComponentElmer
  };
 
  ComponentType m_ComponentType{ComponentType::Component};
 
#endif
};
}  // namespace Garfield
 
#endif