ComponentGrid.hh

Go to the documentation of this file.

#ifndef G_COMPONENT_GRID_H
#define G_COMPONENT_GRID_H
 
#include <array>
#include <string>
#include <vector>
#include <cmath>
 
#include "Garfield/Component.hh"
 
namespace Garfield {
 
 
class ComponentGrid : public Component {
 public:
  ComponentGrid();
  ~ComponentGrid() {}

  bool SetMesh(const unsigned int nx, const unsigned int ny,
               const unsigned int nz, const double xmin, const double xmax,
               const double ymin, const double ymax, const double zmin,
               const double zmax);
  bool GetMesh(unsigned int& nx, unsigned int& ny, unsigned int& nz,
               double& xmin, double& xmax, double& ymin, double& ymax,
               double& zmin, double& zmax) const;
  void SetCartesianCoordinates() { m_coordinates = Coordinates::Cartesian; }
  void SetCylindricalCoordinates();

  bool LoadElectricField(const std::string& filename, const std::string& format,
                         const bool withPotential, const bool withFlag,
                         const double scaleX = 1., const double scaleE = 1.,
                         const double scaleP = 1.);

  bool LoadWeightingField(const std::string& filename,
                          const std::string& format, const bool withPotential,
                          const double scaleX = 1., const double scaleE = 1.,
                          const double scaleP = 1.);
  bool LoadWeightingField(const std::string& filename,
                          const std::string& format, const double time,
                          const bool withPotential, const double scaleX = 1.,
                          const double scaleE = 1., const double scaleP = 1.);
  void SetWeightingFieldOffset(const double x, const double y, const double z);

  bool LoadMagneticField(const std::string& filename, const std::string& format,
                         const double scaleX = 1., const double scaleB = 1.);

  bool SaveElectricField(Component* cmp, const std::string& filename,
                         const std::string& fmt);
  
  bool SaveElectricFieldROOT(Component* cmp, const std::string& filename,
                         const std::string& fmt);

  bool SaveElectricField(Component* cmp);
  
  bool SaveWeightingField(Component* cmp, const std::string& id,
                          const std::string& filename, const std::string& fmt);

  bool GetElectricField(const unsigned int i, const unsigned int j,
                        const unsigned int k, double& v, double& ex, double& ey,
                        double& ez) const;

  void SetMedium(Medium* m);
  Medium* GetMedium() const { return m_medium; }

  void Print();

  bool LoadElectronAttachment(const std::string& fname, const std::string& fmt,
                              const unsigned int col, const double scaleX = 1.);
  bool LoadHoleAttachment(const std::string& fname, const std::string& fmt,
                          const unsigned int col, const double scaleX = 1.);

  bool LoadElectronVelocity(const std::string& fname, const std::string& fmt,
                            const double scaleX = 1.,
                            const double scaleV = 1.e-9);
  bool LoadHoleVelocity(const std::string& fname, const std::string& fmt,
                        const double scaleX = 1., const double scaleV = 1.e-9);
 
  void Clear() override { Reset(); }
  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 ElectricField(const double x, const double y, const double z, double& ex,
                     double& ey, double& ez, Medium*& m, int& status) override;
  using Component::ElectricField;
  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;
  void DelayedWeightingField(const double x, const double y, const double z,
                             const double t, double& wx, double& wy, double& wz,
                             const std::string& label) override;
  double DelayedWeightingPotential(const double x, const double y,
                                   const double z, const double t,
                                   const std::string& label) override;
  void MagneticField(const double x, const double y, const double z, double& bx,
                     double& by, double& bz, int& status) override;
 
  Medium* GetMedium(const double x, const double y, const double z) override;
 
  bool GetVoltageRange(double& vmin, double& vmax) override;
  bool GetElectricFieldRange(double& exmin, double& exmax, double& eymin,
                             double& eymax, double& ezmin, double& ezmax);
  bool GetBoundingBox(double& xmin, double& ymin, double& zmin, double& xmax,
                      double& ymax, double& zmax) override;
  bool GetElementaryCell(double& xmin, double& ymin, double& zmin, double& xmax,
                         double& ymax, double& zmax) override;
 
  bool HasMagneticField() const override;
 
  bool HasAttachmentMap() const override {
    return !(m_eAttachment.empty() && m_hAttachment.empty());
  }
  bool ElectronAttachment(const double x, const double y, const double z,
                          double& att) override;
  bool HoleAttachment(const double x, const double y, const double z,
                      double& att) override;
  bool HasMobilityMap() const override {
    return !(m_eMobility.empty() && m_hMobility.empty());
  }
  bool ElectronMobility(const double x, const double y, const double z,
                        double& mu) override;
  bool HoleMobility(const double x, const double y, const double z,
                    double& mu) override;
 
  bool HasVelocityMap() const override {
    return !(m_eVelocity.empty() && m_hVelocity.empty());
  }
  bool ElectronVelocity(const double x, const double y, const double z,
                        double& vx, double& vy, double& vz) override;
  bool HoleVelocity(const double x, const double y, const double z, double& vx,
                    double& vy, double& vz) override;
  struct Node {
    double fx, fy, fz;  
    double v;           
  };

  void GetFieldOnGrid(std::vector<std::vector<
                      std::vector<ComponentGrid::Node> > >& efields){
    efields = m_efields;
  };

  bool AddElectricField(ComponentGrid* cmp, const double scale = 1.,
                        const double xShift = 0.,
                        const double yShift = 0.,
                        const double zShift = 0.);
  
  bool AddElectricField(Component* cmp, const double scale);
  
  bool GetNodeIndex(double x, const double y, const double z, unsigned int& i, unsigned int& j, unsigned int& k);
 
 private:
  enum class Format { Unknown, XY, XZ, XYZ, IJ, IK, IJK, YXZ };
  enum class Coordinates { Cartesian, Cylindrical };
  Coordinates m_coordinates = Coordinates::Cartesian;
 
  Medium* m_medium = nullptr;

  std::vector<std::vector<std::vector<Node> > > m_efields;
  std::vector<std::vector<std::vector<Node> > > m_bfields;
  std::vector<std::vector<std::vector<Node> > > m_wfields;
  std::vector<std::vector<std::vector<std::vector<Node> > > > m_wdfields;
  std::vector<std::vector<std::vector<double> > > m_eAttachment;
  std::vector<std::vector<std::vector<double> > > m_hAttachment;
  std::vector<std::vector<std::vector<double> > > m_eMobility;
  std::vector<std::vector<std::vector<double> > > m_hMobility;
  std::vector<std::vector<std::vector<Node> > > m_eVelocity;
  std::vector<std::vector<std::vector<Node> > > m_hVelocity;
  std::vector<std::vector<std::vector<bool> > > m_active;
 
  // Dimensions of the mesh
  std::array<unsigned int, 3> m_nX = {{1, 1, 1}};
  std::array<double, 3> m_xMin = {{0., 0., 0.}};
  std::array<double, 3> m_xMax = {{0., 0., 0.}};
  std::array<double, 3> m_sX = {{0., 0., 0.}};
 
  bool m_hasMesh = false;
  bool m_hasPotential = false;
 
  // Offset for weighting field
  std::array<double, 3> m_wFieldOffset = {{0., 0., 0.}};
 
  // Voltage range
  double m_pMin = 0., m_pMax = 0.;

  bool LoadMesh(const std::string& filename, std::string format,
                const double scaleX);

  bool LoadData(const std::string& filename, std::string format,
                const bool withPotential, const bool withFlag,
                const double scaleX, const double scaleF, const double scaleP,
                std::vector<std::vector<std::vector<Node> > >& field);
  bool LoadData(const std::string& filename, std::string format,
                const double scaleX,
                std::vector<std::vector<std::vector<double> > >& tab,
                const unsigned int col);
 
  void Reset() override;
  void UpdatePeriodicity() override;

  bool GetField(const double x, const double y, const double z,
                const std::vector<std::vector<std::vector<Node> > >& field,
                double& fx, double& fy, double& fz, double& p, bool& active);
  bool GetData(const double x, const double y, const double z,
               const std::vector<std::vector<std::vector<double> > >& table,
               double& value);

  double Reduce(const double xin, const double xmin, const double xmax,
                const bool simplePeriodic, const bool mirrorPeriodic,
                bool& isMirrored) const;
  void Initialise(std::vector<std::vector<std::vector<Node> > >& fields);
  Format GetFormat(std::string fmt);
};
}  // namespace Garfield
#endif