ngsolve 6.2.2506.post74.dev0__cp314-cp314-macosx_10_15_universal2.whl

netgen/include/voxelcoefficientfunction.hpp

@@ -0,0 +1,41 @@
+#ifndef NGSOLVE_VOXELCOEFFICIENTFUNCTION_HPP
+#define NGSOLVE_VOXELCOEFFICIENTFUNCTION_HPP
+
+#include "coefficient.hpp"
+
+namespace ngfem
+{
+  template<typename SCAL>
+  class VoxelCoefficientFunction : public CoefficientFunctionNoDerivative
+  {
+    Array<double> start, end;
+    Array<size_t> dim_vals;
+    Array<SCAL> values;
+    bool linear;
+    shared_ptr<CoefficientFunction> trafocf;
+  public:
+    VoxelCoefficientFunction(const Array<double>& _start,
+                             const Array<double>& _end,
+                             const Array<size_t>& _dim_vals,
+                             Array<SCAL>&& _values,
+                             bool _linear,
+                             shared_ptr<CoefficientFunction> trafo=nullptr)
+      : CoefficientFunctionNoDerivative(1, is_same_v<SCAL, Complex>),
+        start(_start), end(_end), dim_vals(_dim_vals),
+        values(std::move(_values)), linear(_linear), trafocf(trafo)
+    { ; }
+
+    using CoefficientFunctionNoDerivative::Evaluate;
+    double Evaluate(const BaseMappedIntegrationPoint& ip) const override;
+    Complex EvaluateComplex(const BaseMappedIntegrationPoint& ip) const override;
+
+    void Evaluate(const BaseMappedIntegrationPoint& mip, FlatVector<Complex> values) const override;
+    auto GetCArgs() const
+    { return make_tuple(start, end, dim_vals, values, linear); }
+
+  private:
+    SCAL T_Evaluate(const BaseMappedIntegrationPoint& ip) const;
+  };
+} // namespace ngfem
+
+#endif // NGSOLVE_VOXELCOEFFICIENTFUNCTION_HPP

netgen/include/vtkoutput.hpp

@@ -0,0 +1,198 @@
+#pragma once
+
+/*********************************************************************/
+/* File:   vtkoutput.hpp                                             */
+/* Author: Christoph Lehrenfeld                                      */
+/* Date:   1. June 2014                                              */
+/*********************************************************************/
+
+namespace ngcomp
+{
+
+  class ValueField : public Array<double>
+  {
+    int dim = 1;
+    string name = "none";
+
+  public:
+    ValueField() { ; };
+    NGS_DLL_HEADER ValueField(int adim, string aname);
+    void SetDimension(int adim) { dim = adim; }
+    int Dimension() { return dim; }
+    void SetName(string aname) { name = aname; }
+    string Name() { return name; }
+  };
+
+  class BaseVTKOutput
+  {
+  public:
+    virtual ~BaseVTKOutput() { ; }
+    virtual void Do(LocalHeap &lh, double time = -1, VorB vb = VOL, const BitArray *drawelems = 0) = 0;
+    string lastoutputname = "";
+  };
+
+  struct VTKCell {
+    int type = 0;
+    ArrayMem<int, ELEMENT_MAXPOINTS> pi;
+
+    VTKCell() = default;
+
+    VTKCell & operator=(const VTKCell&other) {
+      type = other.type;
+      pi.SetSize(other.pi.Size());
+      for(auto i : Range(other.pi))
+        pi[i] = other.pi[i];
+      return *this;
+    }
+
+    VTKCell(ELEMENT_TYPE et, int order, const std::map<tuple<int,int,int>, int> &m,
+        int i, int j, int k, Vec<3,int> vi={1,0,0}, Vec<3,int> vj={0,1,0}, Vec<3,int> vk={0,0,1});
+
+    static int GetVtkType(ELEMENT_TYPE et, int order=1);
+
+    enum VTK_CELL_TYPE
+    {
+      // Linear cells
+      VTK_EMPTY_CELL = 0,
+      VTK_VERTEX = 1,
+      VTK_POLY_VERTEX = 2,
+      VTK_LINE = 3,
+      VTK_POLY_LINE = 4,
+      VTK_TRIANGLE = 5,
+      VTK_TRIANGLE_STRIP = 6,
+      VTK_POLYGON = 7,
+      VTK_PIXEL = 8,
+      VTK_QUAD = 9,
+      VTK_TETRA = 10,
+      VTK_VOXEL = 11,
+      VTK_HEXAHEDRON = 12,
+      VTK_WEDGE = 13,
+      VTK_PYRAMID = 14,
+      VTK_PENTAGONAL_PRISM = 15,
+      VTK_HEXAGONAL_PRISM = 16,
+
+      // Quadratic, isoparametric cells
+      VTK_QUADRATIC_EDGE = 21,
+      VTK_QUADRATIC_TRIANGLE = 22,
+      VTK_QUADRATIC_QUAD = 23,
+      VTK_QUADRATIC_POLYGON = 36,
+      VTK_QUADRATIC_TETRA = 24,
+      VTK_QUADRATIC_HEXAHEDRON = 25,
+      VTK_QUADRATIC_WEDGE = 26,
+      VTK_QUADRATIC_PYRAMID = 27,
+      VTK_BIQUADRATIC_QUAD = 28,
+      VTK_TRIQUADRATIC_HEXAHEDRON = 29,
+      VTK_TRIQUADRATIC_PYRAMID = 37,
+      VTK_QUADRATIC_LINEAR_QUAD = 30,
+      VTK_QUADRATIC_LINEAR_WEDGE = 31,
+      VTK_BIQUADRATIC_QUADRATIC_WEDGE = 32,
+      VTK_BIQUADRATIC_QUADRATIC_HEXAHEDRON = 33,
+      VTK_BIQUADRATIC_TRIANGLE = 34,
+
+      // Cubic, isoparametric cell
+      VTK_CUBIC_LINE = 35,
+
+      // Special class of cells formed by convex group of points
+      VTK_CONVEX_POINT_SET = 41,
+
+      // Polyhedron cell (consisting of polygonal faces)
+      VTK_POLYHEDRON = 42,
+
+      // Higher order cells in parametric form
+      VTK_PARAMETRIC_CURVE = 51,
+      VTK_PARAMETRIC_SURFACE = 52,
+      VTK_PARAMETRIC_TRI_SURFACE = 53,
+      VTK_PARAMETRIC_QUAD_SURFACE = 54,
+      VTK_PARAMETRIC_TETRA_REGION = 55,
+      VTK_PARAMETRIC_HEX_REGION = 56,
+
+      // Higher order cells
+      VTK_HIGHER_ORDER_EDGE = 60,
+      VTK_HIGHER_ORDER_TRIANGLE = 61,
+      VTK_HIGHER_ORDER_QUAD = 62,
+      VTK_HIGHER_ORDER_POLYGON = 63,
+      VTK_HIGHER_ORDER_TETRAHEDRON = 64,
+      VTK_HIGHER_ORDER_WEDGE = 65,
+      VTK_HIGHER_ORDER_PYRAMID = 66,
+      VTK_HIGHER_ORDER_HEXAHEDRON = 67,
+
+      // Arbitrary order Lagrange elements (formulated separated from generic higher order cells)
+      VTK_LAGRANGE_CURVE = 68,
+      VTK_LAGRANGE_TRIANGLE = 69,
+      VTK_LAGRANGE_QUADRILATERAL = 70,
+      VTK_LAGRANGE_TETRAHEDRON = 71,
+      VTK_LAGRANGE_HEXAHEDRON = 72,
+      VTK_LAGRANGE_WEDGE = 73,
+      VTK_LAGRANGE_PYRAMID = 74,
+
+      // Arbitrary order Bezier elements (formulated separated from generic higher order cells)
+      VTK_BEZIER_CURVE = 75,
+      VTK_BEZIER_TRIANGLE = 76,
+      VTK_BEZIER_QUADRILATERAL = 77,
+      VTK_BEZIER_TETRAHEDRON = 78,
+      VTK_BEZIER_HEXAHEDRON = 79,
+      VTK_BEZIER_WEDGE = 80,
+      VTK_BEZIER_PYRAMID = 81,
+
+      VTK_NUMBER_OF_CELL_TYPES
+    };
+  };
+
+  template <int D>
+  class VTKOutput : public BaseVTKOutput
+  {
+  protected:
+    shared_ptr<MeshAccess> ma = nullptr;
+    Array<shared_ptr<CoefficientFunction>> coefs;
+    Array<string> fieldnames;
+
+    string filename;
+    int subdivision, r;
+    double h;
+    int order = 1;
+    int only_element = -1;
+    string floatsize = "double";
+    bool legacy = false;
+    Array<shared_ptr<ValueField>>
+        value_field;
+    Array<Vec<D>> points;
+    Array<VTKCell> cells;
+
+    int output_cnt = 0;
+    std::vector<double> times = {0};
+    shared_ptr<ofstream> fileout;
+
+  public:
+    VTKOutput(const Array<shared_ptr<CoefficientFunction>> &,
+              const Flags &, shared_ptr<MeshAccess>);
+
+    VTKOutput(shared_ptr<MeshAccess>, const Array<shared_ptr<CoefficientFunction>> &,
+              const Array<string> &, string, int, int, string, bool, int);
+    virtual ~VTKOutput() { ; }
+
+    void ResetArrays();
+
+    void FillReferenceTrig(Array<IntegrationPoint> &ref_coords, Array<VTKCell> &ref_elems);
+    void FillReferenceQuad(Array<IntegrationPoint> &ref_coords, Array<VTKCell> &ref_elems);
+    void FillReferenceTet(Array<IntegrationPoint> &ref_coords, Array<VTKCell> &ref_elems);
+    void FillReferenceHex(Array<IntegrationPoint> &ref_coords, Array<VTKCell> &ref_elems);
+    void FillReferencePrism(Array<IntegrationPoint> &ref_coords, Array<VTKCell> &ref_elems);
+    void FillReferencePyramid(Array<IntegrationPoint> &ref_coords, Array<VTKCell> &ref_elems);
+    // void FillReferenceData3D(Array<IntegrationPoint> & ref_coords, Array<INT<D+1>> & ref_tets);
+    // XML Methods
+    void PrintPoints(int *offset, stringstream *appenddata);
+    void PrintCells(int *offset, stringstream *appenddata);
+    void PrintCellTypes(VorB vb, int *offset, stringstream *appenddata, const BitArray *drawelems = nullptr);
+    void PrintFieldData(int *offset, stringstream *appenddata);
+
+    void PrintAppended(stringstream *appenddata);
+    void PvdFile(string filename, int index);
+    // Legacy Methods
+    void PrintPointsLegacy();
+    void PrintCellsLegacy();
+    void PrintCellTypesLegacy(VorB vb, const BitArray *drawelems = nullptr);
+    void PrintFieldDataLegacy();
+    virtual void Do(LocalHeap &lh, double time = -1, VorB vb = VOL, const BitArray *drawelems = 0);
+  };
+
+}

netgen/include/vvector.hpp

@@ -0,0 +1,208 @@
+#ifndef FILE_VVECTOR
+#define FILE_VVECTOR
+
+#include "basevector.hpp"
+
+namespace ngla
+{
+
+
+  template <class T> class VFlatVector;
+  template <class T> class VVector;
+
+
+
+
+  template <typename TSCAL = double> 
+  class NGS_DLL_HEADER S_BaseVectorPtr : virtual public S_BaseVector<TSCAL>
+  {
+  protected:
+    TSCAL * pdata;
+    int es;    // entry size in in term of TSCALs
+    bool ownmem;
+    
+  public:
+    S_BaseVectorPtr (size_t as, int aes, void * adata) throw()
+    {
+      this->size = as;
+      es = aes;
+      pdata = static_cast<TSCAL*> (adata);
+      ownmem = false;
+      this->entrysize = es * sizeof(TSCAL) / sizeof(double);
+    }
+
+    S_BaseVectorPtr (size_t as, int aes)
+    {
+      this->size = as;
+      es = aes;
+      pdata = new TSCAL[as*aes];
+      ownmem = true;
+      GetMemoryTracer().Alloc(sizeof(TSCAL) * as * aes);
+      this->entrysize = es * sizeof(TSCAL) / sizeof(double);
+    }
+
+    void SetSize (size_t as)
+    {
+      if (ownmem)
+        {
+          GetMemoryTracer().Free(sizeof(TSCAL) * this->size * es);
+          delete [] pdata;
+        }
+      this->size = as;
+      pdata = new TSCAL[as*es];
+      ownmem = true;
+      GetMemoryTracer().Alloc(sizeof(TSCAL) * as * es);
+    }
+
+    void AssignMemory (size_t as, void * adata)
+    {
+      this->size = as; 
+      this->pdata = static_cast<TSCAL*> (adata); 
+    }
+    
+    virtual ~S_BaseVectorPtr ();
+
+    virtual void * Memory () const throw() override
+    {
+      return pdata; 
+    }
+
+    virtual Array<MemoryUsage> GetMemoryUsage () const override;
+
+    
+    // virtual AutoVector Range (size_t begin, size_t end) const override;
+    virtual AutoVector Range (T_Range<size_t> range) const override;
+
+    template<typename TIND, typename std::enable_if<std::is_integral<TIND>::value, int>::type = 0>
+    FlatVector<TSCAL> operator() (TIND i) const
+    {
+      return FlatVector<TSCAL> (es, pdata+i*es);
+    }
+
+    virtual AutoVector CreateVector () const override;
+    virtual unique_ptr<MultiVector> CreateMultiVector (size_t cnt) const override;
+    
+    virtual ostream & Print (ostream & ost) const override;
+    using BaseVector::GetMemoryTracer;
+  };
+
+
+  extern template class S_BaseVectorPtr<double>;
+  extern template class S_BaseVectorPtr<Complex>;
+
+
+
+
+  /**
+     A specific vector based on Vector.
+  */
+  template <typename T = double>
+  class VFlatVector :  virtual public S_BaseVectorPtr<typename mat_traits<T>::TSCAL>
+  {
+  public:
+    typedef typename mat_traits<T>::TSCAL TSCAL;
+    enum { ES = sizeof(T) / sizeof(TSCAL) };
+
+    explicit VFlatVector () throw()
+      : S_BaseVectorPtr<TSCAL> (0, ES, NULL)
+    { ; }
+
+    explicit VFlatVector (size_t as, T * adata) throw()
+      : S_BaseVectorPtr<TSCAL> (as, ES, (void*)adata)
+    { ; }
+
+    VFlatVector (FlatVector<T> fv) 
+      : S_BaseVectorPtr<TSCAL> (fv.Size(), ES, fv.Data())
+    { ; }
+    
+    VFlatVector & operator= (TSCAL s1)
+    {
+      BaseVector::operator= (s1);
+      return *this;
+    }
+
+    template <typename T2>
+    VFlatVector & operator= (const VVecExpr<T2> & v)
+    {
+      BaseVector::operator= (v);
+      return *this;
+    }
+
+    FlatVector<T> FV () const throw()
+    {
+      return FlatVector<T> (this->size, this->pdata);
+    }
+    
+    T & operator() (size_t i) const
+    {
+      return static_cast<T*> (static_cast<void*> (this->pdata))[i];
+    }
+
+  };
+
+
+
+
+
+
+  /**
+     A specific vector based on Vector.
+  */
+  template <typename T = double> 
+  class VVector : virtual public S_BaseVectorPtr<typename mat_traits<T>::TSCAL>
+  {
+  public:
+    typedef typename mat_traits<T>::TSCAL TSCAL;
+    enum { ES = sizeof(T) / sizeof(TSCAL) };
+
+    explicit VVector (size_t as)
+      : S_BaseVectorPtr<TSCAL> (as, ES) 
+    { ; }
+
+    explicit VVector (const VVector & v2)
+      : S_BaseVectorPtr<TSCAL> (v2.Size(), ES)
+    {
+      *this = v2;
+    }
+    
+    // virtual ~VVector() { ; }
+
+    VVector & operator= (TSCAL s1)
+    {
+      BaseVector::operator= (s1);
+      return *this;
+    }
+
+    VVector & operator= (const VVector & v2)
+    {
+      BaseVector::operator= (v2);
+      return *this;
+    }
+
+    template <typename T2>
+    VVector & operator= (const VVecExpr<T2> & v)
+    {
+      BaseVector::operator= (v);
+      return *this;
+    }
+
+    using S_BaseVectorPtr<TSCAL> :: FV;
+
+    FlatVector<T> FV () const throw()
+    {
+      return FlatVector<T> (this->size, (T*)this->pdata);
+    }
+
+    T & operator() (size_t i) const
+    {
+      return static_cast<T*> (static_cast<void*> (this->pdata))[i];
+    }
+  };
+
+  extern template class VVector<double>;
+  extern template class VVector<Complex>;
+}
+
+
+
+#endif

netgen/include/webgui.hpp

@@ -0,0 +1,92 @@
+#ifndef FILE_WEBGUI_HPP_INCLUDED
+#define FILE_WEBGUI_HPP_INCLUDED
+
+#include <core/archive.hpp>
+
+// #include "comp.hpp"
+#include "meshaccess.hpp"
+
+
+namespace webgui {
+using namespace ngcomp;
+
+struct WebguiArchiveData {
+  shared_ptr<MeshAccess> mesh;
+  shared_ptr<CoefficientFunction> cf;
+
+  WebguiArchiveData() = default;
+
+  WebguiArchiveData(shared_ptr<MeshAccess> mesh, shared_ptr<CoefficientFunction> cf)
+    : mesh(mesh), cf(cf) { }
+
+  shared_ptr<MeshAccess> GetMeshAccess() { return mesh; }
+
+  void DoArchive(Archive & ar) {
+    shared_ptr<netgen::NetgenGeometry> geo;
+    if(ar.Output())
+    {
+      geo = mesh->GetNetgenMesh()->GetGeometry();
+      mesh->GetNetgenMesh()->SetGeometry(nullptr);
+    }
+
+    ar & mesh & cf;
+
+    if(ar.Output())
+      mesh->GetNetgenMesh()->SetGeometry(geo);
+  }
+};
+
+struct WebguiData {
+  int mesh_dim, order2d, order3d;
+  double funcmin, funcmax, mesh_radius;
+  vector<double> mesh_center;
+  bool draw_vol, draw_surf, show_wireframe, show_mesh;
+
+  vector<string> Bezier_trig_points, Bezier_points, points3d;
+  vector<string> objects, names, edges;
+};
+
+unique_ptr<WebguiData> GenerateWebguiData(shared_ptr<MeshAccess> ma,
+                                          shared_ptr<CoefficientFunction> cf,
+                                          int order = 1);
+
+template<typename T>
+string ToArchive(shared_ptr<T> obj, bool binary=true) {
+  auto ss = make_shared<stringstream>();
+  shared_ptr<netgen::NetgenGeometry> geo;
+  if constexpr(is_same_v<T, netgen::Mesh>)
+  {
+    geo = obj->GetGeometry();
+    obj->SetGeometry(nullptr);
+  }
+  if(binary) {
+    BinaryOutArchive ar(ss);
+    ar & obj;
+  }
+  else {
+    TextOutArchive ar(ss);
+    ar & obj;
+  }
+  if constexpr(is_same_v<T, netgen::Mesh>)
+    obj->SetGeometry(geo);
+  return ss->str();
+}
+
+template<typename T>
+shared_ptr<T> FromArchive(string s, bool binary=true) {
+  auto ss = make_shared<stringstream>(s);
+  shared_ptr<T> obj;
+  if(binary) {
+    BinaryInArchive ar(ss);
+    ar & obj;
+  }
+  else {
+    TextInArchive ar(ss);
+    ar & obj;
+  }
+  return obj;
+}
+
+}  // namespace webgui
+
+#endif  // FILE_WEBGUI_HPP_INCLUDED