ngsolve 6.2.2506.post216.dev0__cp314-cp314-manylinux_2_28_x86_64.whl

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/coefficient_impl.hpp

@@ -0,0 +1,19 @@
+#ifndef FILE_COEFFICIENT_IMPL
+#define FILE_COEFFICIENT_IMPL
+
+
+namespace ngfem
+{
+
+
+  struct GenericIdentity
+  {
+    template <typename T> T operator() (T x) const { return x; }
+    static string Name() { return  " "; }
+    template <typename T> T Diff (T x) const { throw Exception("no GenericIdentity::Diff"); }        
+    void DoArchive(Archive& ar) {}
+  };
+
+}
+
+#endif

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/coefficient_stdmath.hpp

@@ -0,0 +1,167 @@
+#ifndef FILE_COEFFICIENT_STDMATH
+#define FILE_COEFFICIENT_STDMATH
+
+
+namespace ngfem
+{
+
+  struct GenericSqrt {
+    template <typename T> T operator() (T x) const { return sqrt(x); }
+    static string Name() { return "sqrt"; }
+    void DoArchive(Archive& ar) {}
+  };
+  
+  struct GenericSin {
+    template <typename T> T operator() (T x) const { return sin(x); }
+    template <typename T> T Diff (T x) const { return cos(x); }    
+    static string Name() { return "sin"; }
+    void DoArchive(Archive& ar) {}
+  };
+
+  struct GenericCos {
+    template <typename T> T operator() (T x) const { return cos(x); }
+    template <typename T> T Diff (T x) const { return -sin(x); }    
+    static string Name() { return "cos"; }
+    void DoArchive(Archive& ar) {}
+  };
+
+  struct GenericTan {
+    template <typename T> T operator() (T x) const { return tan(x); }
+    static string Name() { return "tan"; }
+    void DoArchive(Archive& ar) {}
+  };
+
+  struct GenericATan {
+    template <typename T> T operator() (T x) const { return atan(x); }
+    static string Name() { return "atan"; }
+    void DoArchive(Archive& ar) {}
+  };
+  
+  struct GenericACos {
+    template <typename T> T operator() (T x) const { return acos(x); }
+    static string Name() { return "acos"; }
+    void DoArchive(Archive& ar) {}
+  };
+  
+  struct GenericASin {
+    template <typename T> T operator() (T x) const { return asin(x); }
+    static string Name() { return "asin"; }
+    void DoArchive(Archive& ar) {}
+  };
+
+
+  
+
+  struct GenericSinh {
+    template <typename T> T operator() (T x) const { return sinh(x); }
+    template <typename T> T Diff (T x) const { return cosh(x); }            
+    static string Name() { return "sinh"; }
+    void DoArchive(Archive& ar) {}
+  };
+  
+  struct GenericCosh {
+    template <typename T> T operator() (T x) const { return cosh(x); }
+    template <typename T> T Diff (T x) const { return sinh(x); }        
+    static string Name() { return "cosh"; }
+    void DoArchive(Archive& ar) {}
+  };
+
+  
+
+  struct GenericExp {
+    template <typename T> T operator() (T x) const { return exp(x); }
+    template <typename T> T Diff (T x) const { return exp(x); }
+    static string Name() { return "exp"; }
+    void DoArchive(Archive& ar) {}
+  };
+  
+  struct GenericLog {
+    template <typename T> T operator() (T x) const { return log(x); }
+    static string Name() { return "log"; }
+    auto Diff (shared_ptr<CoefficientFunction> x) const {
+      return OneVectorCF(x->Dimensions()) / x;
+    }    
+    void DoArchive(Archive& ar) {}
+  };
+
+
+  struct GenericErf {
+    template <typename T> T operator() (T x) const { return erf(x); }
+    Complex operator() (Complex x) const { throw Exception("no erf for Complex"); }
+    SIMD<Complex> operator() (SIMD<Complex> x) const { throw ExceptionNOSIMD("no erf for simd(complex)"); }  
+    static string Name() { return "erf"; }
+    void DoArchive(Archive& ar) {}
+  };
+
+
+
+struct GenericFloor {
+  template <typename T> T operator() (T x) const { return floor(x); }
+  Complex operator() (Complex x) const { throw Exception("no floor for Complex"); }  
+  // SIMD<double> operator() (SIMD<double> x) const { throw ExceptionNOSIMD("no floor for simd"); }
+  SIMD<Complex> operator() (SIMD<Complex> x) const { throw ExceptionNOSIMD("no floor for simd"); }  
+  // AutoDiff<1> operator() (AutoDiff<1> x) const { throw Exception("no floor for AD"); }
+  AutoDiffDiff<1> operator() (AutoDiffDiff<1> x) const { throw Exception("no floor for ADD"); }
+  template <typename T> T Diff (T x) const { throw Exception("Generic Floor not differentiable"); }  
+  static string Name() { return "floor"; }
+  void DoArchive(Archive& ar) {}
+};
+struct GenericCeil {
+  template <typename T> T operator() (T x) const { return ceil(x); }
+  Complex operator() (Complex x) const { throw Exception("no ceil for Complex"); }  
+  // SIMD<double> operator() (SIMD<double> x) const { throw ExceptionNOSIMD("no ceil for simd"); }
+  SIMD<Complex> operator() (SIMD<Complex> x) const { throw ExceptionNOSIMD("no ceil for simd"); }  
+  // AutoDiff<1> operator() (AutoDiff<1> x) const { throw Exception("no ceil for AD"); }
+  AutoDiffDiff<1> operator() (AutoDiffDiff<1> x) const { throw Exception("no ceil for ADD"); }
+  template <typename T> T Diff (T x) const { throw Exception("Generic Ceil not differentiable"); }    
+  static string Name() { return "ceil"; }
+  void DoArchive(Archive& ar) {}
+};
+
+
+  
+  using std::sqrt;
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> sqrt(shared_ptr<CoefficientFunction> x);
+
+  using std::sin;
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> sin(shared_ptr<CoefficientFunction> x);
+
+  using std::cos;
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> cos(shared_ptr<CoefficientFunction> x);
+  
+  using std::tan;
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> tan(shared_ptr<CoefficientFunction> x);
+
+  using std::asin;  
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> asin(shared_ptr<CoefficientFunction> x);
+
+  using std::acos;  
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> acos(shared_ptr<CoefficientFunction> x);
+  
+  using std::atan;
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> atan(shared_ptr<CoefficientFunction> x);
+
+  using std::sinh;    
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> sinh(shared_ptr<CoefficientFunction> x);
+  
+  using std::cosh;
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> cosh(shared_ptr<CoefficientFunction> x);
+
+  using std::exp;
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> exp(shared_ptr<CoefficientFunction> x);
+  
+  using std::log;
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> log(shared_ptr<CoefficientFunction> x);
+
+  using std::erf;
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> erf(shared_ptr<CoefficientFunction> x);
+
+  using std::floor;
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> floor(shared_ptr<CoefficientFunction> x);
+
+  using std::ceil;        
+  NGS_DLL_HEADER shared_ptr<CoefficientFunction> ceil(shared_ptr<CoefficientFunction> x);
+}
+
+
+#endif

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/commutingAMG.hpp

@@ -0,0 +1,106 @@
+#ifndef FILE_COMMUTING_AMG
+#define FILE_COMMUTING_AMG
+
+/* *************************************************************************/
+/* File:   commuting_amg.hoo                                               */
+/* Author: Joachim Schoeberl                                               */
+/* Date:   15. Aug. 2002                                                   */
+/* *************************************************************************/
+
+namespace ngla
+{
+
+  class CommutingAMG : public BaseMatrix
+  {
+  protected:
+    const BaseSparseMatrix * pmat;
+    CommutingAMG * recAMG;
+
+    SparseMatrixTM<double> * prol;
+  
+    shared_ptr<BaseSparseMatrix> coarsemat;
+    shared_ptr<BaseJacobiPrecond> jacobi;
+    shared_ptr<BaseBlockJacobiPrecond> bjacobi;
+    shared_ptr<BaseMatrix> inv;
+
+  public:
+    CommutingAMG ()
+    { ; }
+    virtual ~CommutingAMG () 
+    { ; }
+
+    virtual bool IsComplex() const override { return false; }
+
+    virtual void ComputeMatrices (const BaseSparseMatrix & mat) = 0;
+    virtual void Mult (const BaseVector & x, BaseVector & y) const override = 0;
+
+
+    virtual int VHeight() const override { return pmat->Height(); }
+    virtual int VWidth() const override { return pmat->Width(); }
+
+    virtual size_t NZE() const override = 0;
+    virtual AutoVector CreateVector () const override
+    {
+      return pmat->CreateColVector();
+    }
+    virtual AutoVector CreateColVector () const override
+    {
+      return pmat->CreateRowVector();
+    }
+    virtual AutoVector CreateRowVector () const override 
+    {
+      return pmat->CreateColVector();
+    }
+  };
+
+
+  class AMG_H1 : public CommutingAMG
+  {
+  public:
+
+    AMG_H1 (const BaseMatrix & sysmat,
+	    Array<ngstd::IVec<2> > & e2v,
+	    Array<double> & weighte,
+	    int levels);
+
+    virtual ~AMG_H1 ();
+
+    virtual void ComputeMatrices (const BaseSparseMatrix & mat);
+    virtual size_t NZE() const;
+
+    virtual void Mult (const BaseVector & x, BaseVector & y) const;
+  };
+
+
+
+
+  class AMG_HCurl : public CommutingAMG
+  {
+    SparseMatrixTM<double> * grad;
+
+    shared_ptr<BaseSparseMatrix> h1mat;
+    AMG_H1 * h1AMG;
+
+  public:
+
+    AMG_HCurl (const BaseMatrix & sysmat,
+	       const Array<Vec<3> > & vertices,
+	       Array<ngstd::IVec<2> > & e2v,
+	       Array<ngstd::IVec<4> > & f2v,
+	       Array<double> & weighte,
+	       Array<double> & weightf,
+	       int levels);
+
+    virtual ~AMG_HCurl ();
+
+    virtual void ComputeMatrices (const BaseSparseMatrix & mat);
+    virtual size_t NZE() const;
+
+    virtual void Mult (const BaseVector & x, BaseVector & y) const;
+  };
+
+
+}
+
+
+#endif

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/comp.hpp

@@ -0,0 +1,79 @@
+#ifndef FILE_COMP
+#define FILE_COMP
+
+/*********************************************************************/
+/* File:   comp.hpp                                                  */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   25. Mar. 2000                                             */
+/*********************************************************************/
+
+#include <fem.hpp>
+#include <finiteelement.hpp>
+#include <la.hpp>
+
+/**
+   namespace for NGS-components.
+   It contains the access to the mesh topology MeshAccess, 
+   finite element spaces derived from FESpace, and global objects such as
+   Gridfunction, LinearForm, and BilinearForm, or a Preconditioner.
+   Computational functions such as SetValues and CalcFlux.
+ */
+namespace ngcomp
+{
+  using namespace std;
+  using namespace ngstd;
+
+  using ngfem::ELEMENT_TYPE;
+
+  using namespace ngla;
+  using namespace ngfem;
+}
+
+
+namespace ngmg
+{
+  class Prolongation;
+  class TwoLevelMatrix;
+  class MultigridPreconditioner;
+}
+
+
+#include <parallelngs.hpp>
+
+
+// #include "pmltrafo.hpp"
+#include "meshaccess.hpp"
+#include "ngsobject.hpp"
+#include "fespace.hpp"
+
+#include "gridfunction.hpp"
+#include "bilinearform.hpp"
+#include "linearform.hpp"
+#include "preconditioner.hpp"
+
+#include "postproc.hpp"
+#include "interpolate.hpp"
+
+#include "tpfes.hpp"
+#include "hcurlhdivfes.hpp"
+#include "hdivfes.hpp"
+#include "h1hofespace.hpp"
+#include "l2hofespace.hpp"
+#include "hdivhofespace.hpp"
+#include "hdivhosurfacefespace.hpp" 
+#include "hcurlhofespace.hpp" 
+// #include "facetfespace.hpp" 
+// #include "vectorfacetfespace.hpp"
+// #include "h1lumping.hpp"
+#include "periodic.hpp"
+#include "discontinuous.hpp"
+#include "hidden.hpp"
+#include "reorderedfespace.hpp"
+
+#include "facetsurffespace.hpp"
+#include "normalfacetsurfacefespace.hpp"
+#include "fesconvert.hpp"
+
+// #include "bddc.hpp"
+
+#endif

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/compatibility.hpp

@@ -0,0 +1,41 @@
+/*
+
+You may want to include this file to keep your application compatible with 
+different versions of ngsolve.
+
+*/
+
+
+
+
+#ifdef FILE_POSTPROC
+
+namespace ngcomp
+{
+
+  // // argument MeshAccess ma  was removed since it is available in GridFunction u
+  // // change: ngsolve-5.1 - r1177, 20130404
+  // NGS_DLL_HEADER 
+  // inline void SetValues (const MeshAccess & ma,
+  //                        const CoefficientFunction & coef,
+  //                        GridFunction & u,
+  //                        bool vb,
+  //                        DifferentialOperator * diffop,   // NULL is FESpace evaluator
+  //                        LocalHeap & clh)
+  // {
+  //   SetValues (coef, u, vb, diffop, clh);
+  // }
+}
+  
+
+#endif
+
+
+
+#define L2HighOrderFiniteElement DGFiniteElement
+
+
+
+
+
+

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/complex_wrapper.hpp

@@ -0,0 +1,101 @@
+#ifndef COMPLEX_WRAPPER
+#define COMPLEX_WRAPPER
+
+
+
+#include <complex>
+
+
+#ifdef USE_MYCOMPLEX
+#include <mycomplex.hpp>
+#endif
+
+
+
+// #ifdef __clang__
+#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
+namespace std
+{
+  // avoid expensive call to complex mult by using the grammar school implementation
+  INLINE std::complex<double> operator* (std::complex<double> a, std::complex<double> b)
+  {
+    return std::complex<double> (a.real()*b.real()-a.imag()*b.imag(),
+                                 a.real()*b.imag()+a.imag()*b.real());
+  }
+}
+#endif
+
+
+
+
+namespace ngcore
+{
+  
+#ifdef USE_MYCOMPLEX
+  typedef ngstd::MyComplex<double> Complex;
+  using std::fabs;
+  INLINE double fabs (Complex v) { return ngstd::abs (v); }
+#else
+  typedef std::complex<double> Complex;
+  using std::fabs;
+  inline double fabs (Complex v) { return std::abs (v); }
+#endif
+  
+}
+
+
+#if defined(__CUDA_ARCH__)
+namespace ngcore
+{
+  __device__ inline Complex conj(Complex a)
+  {
+    return Complex (a.real(), -a.imag());
+  }
+
+  __device__ inline Complex operator+ (Complex a, Complex b) {
+    return Complex(a.real()+b.real(), a.imag()+b.imag());
+  }
+  __device__ inline Complex& operator+= (Complex& a, Complex b) {
+    a = a+b;
+    return a;
+  }
+}
+#endif
+
+
+
+
+
+
+
+/// namespace for basic linear algebra
+namespace ngbla
+{
+  using ngcore::Complex;
+
+  using ngcore::AtomicAdd;
+  inline void AtomicAdd (Complex & x, Complex y)
+  {
+    auto real = y.real();
+    ngcore::AtomicAdd (reinterpret_cast<double(&)[2]>(x)[0], real);
+    auto imag = y.imag();
+    ngcore::AtomicAdd (reinterpret_cast<double(&)[2]>(x)[1], imag);
+  }
+
+  inline bool IsComplex(double v) { return false; }
+  inline bool IsComplex(Complex v) { return true; }
+}
+
+
+namespace ngstd
+{
+  using ngcore::Complex;
+  INLINE Complex IfPos (Complex a, Complex b, Complex c)
+  {
+    return a.real() > 0 ? b : c;
+  }
+}
+
+
+
+#endif

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/compressedfespace.hpp

@@ -0,0 +1,110 @@
+#pragma once
+/*********************************************************************/
+/* File:   wrapperfespace.hpp                                        */
+/* Author: Christoph Lehrenfeld                                      */
+/* Date:   12. July 2018                                             */
+/*********************************************************************/
+
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+
+  class NGS_DLL_HEADER CompressedFESpace : public FESpace
+  {
+  protected:
+    shared_ptr<FESpace> space;
+    Array<DofId> comp2all;
+    Array<DofId> all2comp;
+    shared_ptr<BitArray> active_dofs = nullptr;
+
+    //TODO: flag to hide HIDDEN_DOFs
+
+  public:
+    CompressedFESpace (shared_ptr<FESpace> bfes);
+    virtual ~CompressedFESpace () {};
+    void Update() override;
+    shared_ptr<FESpace> GetBaseSpace() const { return space; }
+
+    void WrapDofs(Array<DofId> & dnums) const
+    {
+      /*
+      // (JS): this is buggy: dnums[i] may be -1
+      for (int i : Range(dnums.Size()))
+        if (all2comp[dnums[i]] != -1)
+          dnums[i] = all2comp[dnums[i]];
+        else 
+          dnums[i] = -1;
+      */
+      for (DofId & d : dnums)
+        if (IsRegularDof (d))
+          d = all2comp[d];
+    }
+
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & lh) const override;
+    
+    FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+    virtual void GetDofNrs (NodeId ni, Array<DofId> & dnums) const override;
+
+    virtual SymbolTable<shared_ptr<DifferentialOperator>> GetAdditionalEvaluators () const override
+    { return space->GetAdditionalEvaluators (); }
+
+    /// get dof-nrs of the element of certain coupling type
+    virtual void GetElementDofsOfType (ElementId ei, Array<DofId> & dnums, COUPLING_TYPE ctype) const override;
+
+    virtual void SetActiveDofs(shared_ptr<BitArray> actdof) 
+    {
+      active_dofs = actdof;
+    }
+
+    shared_ptr<BitArray> GetActiveDofs() const { return active_dofs; }
+
+    // a name for our new fe-space
+    virtual string GetClassName () const override
+    {
+      return "CompressedFESpace(" + space->GetClassName() + ")";
+    }
+
+    /// update element coloring
+    void FinalizeUpdate() override
+    {
+      space->FinalizeUpdate();
+      FESpace::FinalizeUpdate();
+    }
+
+    ProxyNode MakeProxyFunction (bool testfunction,
+                                 const function<shared_ptr<ProxyFunction>(shared_ptr<ProxyFunction>)> & addblock) const override;
+
+    virtual bool DefinedOn (ElementId id) const
+    {
+      return space->DefinedOn(id);
+    }
+
+    virtual void GetVertexDofNrs (int vnr, Array<DofId> & dnums) const override;
+    /// get dofs on edge enr
+    virtual void GetEdgeDofNrs (int ednr, Array<DofId> & dnums) const override;
+    /// get dofs on face fnr
+    virtual void GetFaceDofNrs (int fanr, Array<DofId> & dnums) const override;
+    /// get dofs on element (=cell) elnr
+    virtual void GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override;
+
+    virtual void VTransformMR (ElementId ei,
+			       SliceMatrix<double> mat, TRANSFORM_TYPE tt) const override
+    { space-> VTransformMR(ei, mat, tt); }
+    virtual void VTransformMC (ElementId ei,
+                               SliceMatrix<Complex> mat, TRANSFORM_TYPE tt) const override
+    { space->VTransformMC (ei, mat, tt); }
+    virtual void VTransformVR (ElementId ei,
+                               SliceVector<double> vec, TRANSFORM_TYPE tt) const override
+    { space->VTransformVR(ei, vec, tt); }
+    virtual void VTransformVC (ElementId ei, 
+                               SliceVector<Complex> vec, TRANSFORM_TYPE tt) const override
+    { space->VTransformVC(ei, vec, tt); }    
+
+
+  };
+
+}