ComponentCST.hh

Go to the documentation of this file.

#ifndef G_COMPONENT_CST_H
#define G_COMPONENT_CST_H
 
#include <map>
#include <vector>
 
#include "Garfield/ComponentFieldMap.hh"
 
namespace Garfield {

 
class ComponentCST : public ComponentFieldMap {
 public:
  ComponentCST();
  ~ComponentCST() {}
 
  void ShiftComponent(const double xShift, const double yShift,
                      const double zShift);
 
  void GetNumberOfMeshLines(unsigned int& nx, unsigned int& ny,
                            unsigned int& nz) const;
  size_t GetNumberOfElements() const override { return m_nElements; }
  bool GetElementNodes(const size_t i,
                       std::vector<size_t>& nodes) const override;
  bool GetElementRegion(const size_t i, size_t& mat,
                        bool& drift) const override;
  size_t GetNumberOfNodes() const override { return m_nNodes; }
  bool GetNode(const size_t i, double& x, double& y, double& z) const override;
 
  void GetElementBoundaries(unsigned int element, double& xmin, double& xmax,
                            double& ymin, double& ymax, double& zmin,
                            double& zmax) const;
 
  Medium* GetMedium(const double x, const double y, const double z) override;
  void ElectricField(const double x, const double y, const double z, double& ex,
                     double& ey, double& ez, Medium*& m, int& status) override;
  void ElectricField(const double x, const double y, const double z, double& ex,
                     double& ey, double& ez, double& v, Medium*& m,
                     int& status) override;
  void WeightingField(const double x, const double y, const double z,
                      double& wx, double& wy, double& wz,
                      const std::string& label) override;
 
  double WeightingPotential(const double x, const double y, const double z,
                            const std::string& label) override;
  /* FIX DOXYGEN ERROR ON PDF GENERATION
   * Deprecated version of the interface based on text file import of field
   * data.
   * \param elist Information about the element material of mesh cells. Each
   * line contains the element number and the material index:
   * \code
   * 0  3
   * ...
   * \endcode
   *
   * \param nlist Information about the mesh like this:
   * \code
   *  xmax 136 ymax 79 zmax 425
   *  x−lines
   * 0
   * 8 . 9 2 8 5 7 e −07
   * 1 . 7 8 5 7 1 e −06
   * ...
   * y−lines
   * 0
   * 8 . 9 2 8 5 7 e −07
   * 1 . 7 8 5 7 1 e −06
   * ...
   * z−lines
   * 0.0027
   * 0.00270674
   * ...
   * \endcode
   *
   * \param mplist Information about material properties used in the simulation:
   * \code
   *  Materials 4
   *  Material 1 PERX 1 . 0 0 0 0 0 0
   *  Material 2 RSVX 0 . 0 0 0 0 0 0 PERX 0 . 1 0 0 0 0 0 0E+11
   *  Material 3 PERX 3 . 5 0 0 0 0 0
   *  Material 4 PERX 4 . 8 0 0 0 0 0
   *  \endcode
   *
   * \param prnsol Information about the node potentials. Each line contains the
   * node number and the potential:
   *  \code
   *  0 1000.00
   *  ...
   *  \endcode
   * \param unit The units used in the nlist input file
   */
  bool Initialise(std::string elist, std::string nlist, std::string mplist,
                  std::string prnsol, std::string unit = "cm");
 
  bool Initialise(std::string dataFile, std::string unit = "cm");
  bool SetWeightingField(std::string prnsol, std::string label,
                         bool isBinary = true);
 
  // Range
 
  void SetRangeZ(const double zmin, const double zmax);
  void DisableXField() { disableFieldComponent[0] = true; }
  void DisableYField() { disableFieldComponent[1] = true; }
  void DisableZField() { disableFieldComponent[2] = true; }
  void EnableShaping() { doShaping = true; }
  void DisableShaping() { doShaping = false; }
  int Index2Element(const unsigned int i, const unsigned int j,
                    const unsigned int k) const;
  bool Coordinate2Index(const double x, const double y, const double z,
                        unsigned int& i, unsigned int& j,
                        unsigned int& k) const;
 
 protected:
  void SetRange() override;
 
  double GetElementVolume(const size_t i) const override;
  void GetAspectRatio(const size_t i, double& dmin,
                      double& dmax) const override;

  bool Coordinate2Index(const double x, const double y, const double z,
                        unsigned int& i, unsigned int& j, unsigned int& k,
                        double* position_mapped, bool* mirrored) const;
 
 private:
  std::vector<double> m_xlines;  
  std::vector<double> m_ylines;  
  std::vector<double> m_zlines;  
  std::vector<float> m_potential;
  std::map<std::string, std::vector<float> > m_weightingFields;
  std::vector<unsigned char> m_elementMaterial;
 
  unsigned int m_nx = 0;   
  unsigned int m_ny = 0;   
  unsigned int m_nz = 0;   
  size_t m_nElements = 0;  
  size_t m_nNodes = 0;     
  // If true x,y,z fields of this component are disabled (e=0 V/cm).
  bool disableFieldComponent[3] = {false, false, false};
  bool doShaping = false;
 
  void ElectricFieldBinary(const double x, const double y, const double z,
                           double& ex, double& ey, double& ez, double& v,
                           Medium*& m, int& status,
                           const bool calculatePotential = false) const;
  float GetFieldComponent(const unsigned int i, const unsigned int j,
                          const unsigned int k, const double rx,
                          const double ry, const double rz,
                          const char component,
                          const std::vector<float>& potentials) const;
 
  float GetPotential(const unsigned int i, const unsigned int j,
                     const unsigned int k, const double rx, const double ry,
                     const double rz,
                     const std::vector<float>& potentials) const;
 
  void ShapeField(float& ex, float& ey, float& ez, const double rx,
                  const double ry, const double rz, const unsigned int i,
                  const unsigned int j, const unsigned int k,
                  const std::vector<float>& potentials) const;
 
  /* Calculate the index (i,j,k) along x,y,z direction of the given element.
   * i,j,k start at 0 and reach at maximum
   * m_xlines-1,m_ylines-1,m_zlines-1
   */
  void Element2Index(const size_t element, unsigned int& i, unsigned int& j,
                     unsigned int& k) const;
 
  int Index2Node(const unsigned int i, const unsigned int j,
                 const unsigned int k) const;
 
  void Node2Index(const size_t node, unsigned int& i, unsigned int& j,
                  unsigned int& k) const;
};
 
}  // namespace Garfield
 
#endif