ComponentComsol.hh

Go to the documentation of this file.

#pragma once
 
#include "Garfield/ComponentFieldMap.hh"
 
namespace Garfield {

 
class ComponentComsol : public ComponentFieldMap {
 public:
  ComponentComsol();
  ComponentComsol(const std::string &mesh, const std::string &mplist,
                  const std::string &field, const std::string &unit = "m");
  ~ComponentComsol() {}
 
  void SetImportRange(const double xmin, const double xmax, const double ymin,
                      const double ymax, const double zmin, const double zmax) {
    // TODO: Must happen before initialise function
    m_range.set = true;
    m_range.xmin = xmin;
    m_range.ymin = ymin;
    m_range.zmin = zmin;
 
    m_range.xmax = xmax;
    m_range.ymax = ymax;
    m_range.zmax = zmax;
  }

  bool Initialise(const std::string &header = "mesh.mphtxt",
                  const std::string &mplist = "dielectrics.dat",
                  const std::string &field = "field.txt",
                  const std::string &unit = "m");

  bool SetWeightingPotential(const std::string &file, const std::string &label);
  bool SetWeightingField(const std::string &file, const std::string &label) {
    return SetWeightingPotential(file, label);
  }

  bool SetDynamicWeightingPotential(const std::string &file,
                                    const std::string &label);
  void SetTimeInterval(const double mint, const double maxt,
                       const double stept);
  void GetTimeInterval(std::vector<double> &delayedTimes) {
    delayedTimes = m_wdtimes;
  }

  void SetImportMaterial(const double epsr = 1.) {
    m_materialSelect = true;
    m_epsr = epsr;
  }
 
#ifdef USEGPU
  double CreateGPUTransferObject(ComponentGPU *&comp_gpu) override;
 
#endif
 private:
  double m_unit = 100.;
  bool m_timeset = false;
  static constexpr double MaxNodeDistance = 1.e-8;
 
  bool m_materialSelect = false;
  double m_epsr = 1.;
 
  bool GetTimeInterval(const std::string &file);
 
  struct Range {
    bool set = false;
 
    double xmin = 0;
    double xmax = 0;
 
    double ymin = 0;
    double ymax = 0;
 
    double zmin = 0;
    double zmax = 0;
  };
 
  Range m_range;
 
  bool CheckInRange(const double x, const double y, const double z) const {
    if (!m_range.set) return true;
 
    if (x < m_range.xmin || x > m_range.xmax || y < m_range.ymin ||
        y > m_range.ymax || z < m_range.zmin || z > m_range.zmax)
      return false;
 
    return true;
  }
 
  bool ElementInRange(const Element &element,
                      const std::vector<Node> &nodes) const {
    if (m_range.set) {
      for (size_t i = 0; i < 10; i++) {
        const Node &node = nodes[element.emap[i]];
        if (!CheckInRange(node.x, node.y, node.z)) return false;
      }
    }
    if (m_materialSelect && m_materials[element.matmap].eps != m_epsr)
      return false;
    return true;
  }
  bool LoadPotentials(const std::string &field, std::vector<double> &pot);
};
}  // namespace Garfield