Solid.hh

Go to the documentation of this file.

#ifndef G_SOLID_H
#define G_SOLID_H
 
#include <string>
#include <vector>
 
namespace Garfield {

 
struct Panel {
  double a, b, c;
  std::vector<double> xv;
  std::vector<double> yv;
  std::vector<double> zv;
  int colour;
  int volume;
};

 
class Solid {
 public:
  Solid() = delete;
  Solid(const double cx, const double cy, const double cz,
        const std::string& name)
      : m_cX(cx), m_cY(cy), m_cZ(cz), m_className(name) {
    m_id = s_id++;
  }

  virtual ~Solid() {}

  virtual bool IsInside(const double x, const double y, const double z,
                        const bool tesselated = false) const = 0;
  virtual bool GetBoundingBox(double& xmin, double& ymin, double& zmin,
                              double& xmax, double& ymax,
                              double& zmax) const = 0;
  virtual bool IsBox() const { return false; }
  virtual bool IsTube() const { return false; }
  virtual bool IsSphere() const { return false; }
  virtual bool IsHole() const { return false; }
  virtual bool IsRidge() const { return false; }
  virtual bool IsExtrusion() const { return false; }
  virtual bool IsWire() const { return false; }

  void SetLabel(const std::string& label) { m_label = label; }
  std::string GetLabel() const { return m_label; }

  bool GetCentre(double& x, double& y, double& z) const {
    x = m_cX;
    y = m_cY;
    z = m_cZ;
    return true;
  }

  bool GetDirection(double& dx, double& dy, double& dz) const {
    dx = m_dX;
    dy = m_dY;
    dz = m_dZ;
    return true;
  }

  bool GetOrientation(double& ctheta, double& stheta, double& cphi,
                      double& sphi) const {
    ctheta = m_cTheta;
    stheta = m_sTheta;
    cphi = m_cPhi;
    sphi = m_sPhi;
    return true;
  }

  virtual double GetHalfLengthX() const {
    return NotImplemented("GetHalfLengthX");
  }

  virtual double GetHalfLengthY() const {
    return NotImplemented("GetHalfLengthY");
  }

  virtual double GetHalfLengthZ() const {
    return NotImplemented("GetHalfLengthZ");
  }

  virtual double GetInnerRadius() const {
    return NotImplemented("GetInnerRadius");
  }

  virtual double GetOuterRadius() const {
    return NotImplemented("GetOuterRadius");
  }

  virtual double GetRadius() const { return NotImplemented("GetRadius"); }
  virtual double GetLowerRadius() const {
    return NotImplemented("GetLowerRadius");
  }

  virtual double GetUpperRadius() const {
    return NotImplemented("GetUpperRadius");
  }

  virtual double GetRidgeOffset() const {
    return NotImplemented("GetRidgeOffset");
  }

  virtual double GetRidgeHeight() const {
    return NotImplemented("GetRidgeHeight");
  }

  virtual bool GetProfile(std::vector<double>& xv,
                          std::vector<double>& yv) const;

  unsigned int GetId() const { return m_id; }

  virtual bool SolidPanels(std::vector<Panel>& panels) = 0;

  virtual void SetDiscretisationLevel(const double dis) = 0;
  virtual double GetDiscretisationLevel(const Panel& panel) = 0;
 
  virtual void Cut(const double x0, const double y0, const double z0,
                   const double xn, const double yn, const double zn,
                   std::vector<Panel>& panels) = 0;
 
  enum BoundaryCondition {
    Unknown = 0,
    Voltage,
    Charge,
    Float,
    Dielectric,
    DielectricCharge,
    ParallelField,
    PerpendicularField
  };

  void SetBoundaryPotential(const double v) {
    m_volt = v;
    m_bctype = Voltage;
  }

  void SetBoundaryChargeDensity(const double q) {
    m_charge = q;
    m_bctype = Charge;
  }

  void SetBoundaryFloat() { m_bctype = Float; }
  void SetBoundaryDielectric() { m_bctype = Dielectric; }
  void SetBoundaryParallelField() { m_bctype = ParallelField; }
  void SetBoundaryPerpendicularField() { m_bctype = PerpendicularField; }

  BoundaryCondition GetBoundaryConditionType() const { return m_bctype; }
  double GetBoundaryPotential() const { return m_volt; }
  double GetBoundaryChargeDensity() const { return m_charge; }

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

  void SetColour(const int col) { m_colour = col; }
  int GetColour() const { return m_colour; }
 
  static bool Intersect(const double x1, const double y1, const double z1,
                        const double x2, const double y2, const double z2,
                        const double x0, const double y0, const double z0,
                        const double a, const double b, const double c,
                        double& xc, double& yc, double& zc);
 
 protected:
  double m_cX = 0., m_cY = 0., m_cZ = 0.;

  double m_dX = 0., m_dY = 0., m_dZ = 1.;
  double m_cPhi = 1., m_sPhi = 0.;
  double m_cTheta = 1., m_sTheta = 0.;

  std::string m_className = "Solid";

  std::string m_label = "";

  bool m_debug = false;

  BoundaryCondition m_bctype = Unknown;
  double m_volt = 0.;
  double m_charge = 0.;
  double m_eps = 0.;

  int m_colour = -1;

  void ToLocal(const double x, const double y, const double z, double& u,
               double& v, double& w) const {
    const double dx = x - m_cX;
    const double dy = y - m_cY;
    const double dz = z - m_cZ;
 
    u = m_cPhi * m_cTheta * dx + m_sPhi * m_cTheta * dy - m_sTheta * dz;
    v = -m_sPhi * dx + m_cPhi * dy;
    w = m_cPhi * m_sTheta * dx + m_sPhi * m_sTheta * dy + m_cTheta * dz;
  }

  void ToGlobal(const double u, const double v, const double w, double& x,
                double& y, double& z) const {
    x = m_cX + m_cPhi * m_cTheta * u - m_sPhi * v + m_cPhi * m_sTheta * w;
    y = m_cY + m_sPhi * m_cTheta * u + m_cPhi * v + m_sPhi * m_sTheta * w;
    z = m_cZ - m_sTheta * u + m_cTheta * w;
  }

  void VectorToLocal(const double x, const double y, const double z, double& u,
                     double& v, double& w) {
    u = m_cPhi * m_cTheta * x + m_sPhi * m_cTheta * y - m_sTheta * z;
    v = -m_sPhi * x + m_cPhi * y;
    w = m_cPhi * m_sTheta * x + m_sPhi * m_sTheta * y + m_cTheta * z;
  }
 
  void SetDirection(const double dx, const double dy, const double dz);
 
 private:
  double NotImplemented(const std::string& fcn) const;
  static unsigned int s_id;
  unsigned int m_id;
};
}  // namespace Garfield
 
#endif