ngsolve 6.2.2502__cp311-cp311-win_amd64.whl → 6.2.2601__cp311-cp311-win_amd64.whl

netgen/include/l2hofe.hpp

@@ -71,6 +71,7 @@ namespace ngfem
 
   public:
     using ET_trait<ET>::ElementType;
+    using BaseScalarFiniteElement::CalcShape;
     
     INLINE L2HighOrderFE () { ; }
     INLINE L2HighOrderFE (int aorder)

netgen/include/matrix.hpp

@@ -1107,7 +1107,7 @@ namespace ngbla
     // 
     MatrixView() = default;
     // : h{0}, w{0}, dist{0}, data{nullptr} { } 
-    INLINE MatrixView(const MatrixView &) = default;
+    MatrixView(const MatrixView &) = default;
 
     template <typename T2, typename TH2, typename TW2, typename TDIST2,
               enable_if_t<is_convertible<T2*,T*>::value, int> =0,
@@ -1742,7 +1742,8 @@ namespace ngbla
     double operator() (int i) const
     {
       static_assert (true, "linear access of id");
-      cerr << "id, linear access" << endl; return 0;
+      return 0;
+      // cerr << "id, linear access" << endl; return 0;
     }
     ///
     double operator() (int i, int j) const { return (i == j) ? 1 : 0; }
@@ -1764,7 +1765,11 @@ namespace ngbla
     INLINE Identity (size_t s) : size(s) { ; }
 
     INLINE double operator() (int i) const
-    { cerr << "Identity, linear access" << endl; return 0; }
+    {
+      static_assert (true, "linear access of Identity");
+      return 0;
+      // cerr << "Identity, linear access" << endl; return 0;
+    }
 
     INLINE double operator() (int i, int j) const { return (i == j) ? 1 : 0; }
     INLINE auto View() const { return Identity(size); }

netgen/include/meshaccess.hpp

@@ -1029,11 +1029,12 @@ namespace ngcomp
     ElementId FindElementOfPoint (FlatVector<double> point,
                                   IntegrationPoint & ip, 
                                   bool build_searchtree,
-                                  const Array<int> * const indices = NULL) const;
+                                  const Array<int> * const indices = NULL,
+                                  double tol = 1e-4) const;
     ElementId FindElementOfPoint (FlatVector<double> point,
                                   IntegrationPoint & ip, 
                                   bool build_searchtree,
-                                  int index) const;
+                                  int index, double tol = 1e-4) const;
     int FindSurfaceElementOfPoint (FlatVector<double> point,
 				   IntegrationPoint & ip, 
 				   bool build_searchtree,
@@ -1200,7 +1201,7 @@ namespace ngcomp
     shared_ptr<BitArray> MaskPtr() { return mask; }
     const shared_ptr<MeshAccess> & Mesh() const { return mesh; }
     void DoArchive(Archive& ar)
-    { ar & mesh & vb & mask; }
+    { ar.Shallow(mesh) & vb & mask; }
     Region operator+ (const Region & r2) const
     {
       return Region (mesh, vb, BitArray(*mask).Or(r2.Mask()));

netgen/include/mp_coefficient.hpp

@@ -0,0 +1,145 @@
+#ifndef MP_COEFFICIENT
+#define MP_COEFFICIENT
+
+
+#include "mptools.hpp"
+
+namespace ngsbem
+{
+
+  
+  // ******************** Coefficient Functions *********************
+
+  
+  class SphericalHarmonicsCF : public CoefficientFunction
+  {
+    SphericalHarmonics<Complex> sh;
+  public:
+    SphericalHarmonicsCF (int order)
+      : CoefficientFunction(1, true), sh(order) { }
+    Complex & Coef(int n, int m) { return sh.Coef(n,m); } 
+    
+    virtual double Evaluate (const BaseMappedIntegrationPoint & ip) const override
+    { throw Exception("real eval not available"); }
+
+    virtual void Evaluate (const BaseMappedIntegrationPoint & mip, FlatVector<Complex> values) const override
+    {
+      values(0) = sh.Eval(mip.GetPoint());
+    }
+    
+    virtual void Evaluate (const BaseMappedIntegrationRule & ir, BareSliceMatrix<Complex> values) const override
+    {
+      for (int i = 0; i < ir.Size(); i++)
+        {
+          auto & mip = ir[i];
+          values(i,0) = sh.Eval(mip.GetPoint());
+        }
+    }
+
+    auto & SH() { return sh; }
+  };
+
+
+
+  template <typename entry_type> class RegularMLExpansionCF;
+  
+
+  template <typename RADIAL, typename entry_type=Complex>
+  class SphericalExpansionCF : public CoefficientFunction
+  {
+    SphericalExpansion<RADIAL, entry_type> mp;
+    Vec<3> center;
+  public:
+    SphericalExpansionCF (int order, double kappa, Vec<3> acenter, double rtyp = 1)
+      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mp(order, kappa, rtyp), center(acenter) { }
+
+    entry_type & Coef(int n, int m) { return mp.Coef(n,m); } 
+    auto & SH() { return mp.SH(); }
+    auto & MP() { return mp; }
+    Vec<3> Center() const { return center; }
+    
+    virtual double Evaluate (const BaseMappedIntegrationPoint & ip) const override
+    { throw Exception("real eval not available"); }
+
+    virtual void Evaluate (const BaseMappedIntegrationPoint & mip, FlatVector<Complex> values) const override
+    {
+      if constexpr (std::is_same<entry_type, Complex>())
+        values(0) = mp.Eval(mip.GetPoint()-center);
+      else
+        values = mp.Eval(mip.GetPoint()-center);
+    }
+
+    template <typename TARGET>
+    void ShiftZ (double z, SphericalExpansion<TARGET, entry_type> & target) { mp.ShiftZ(z, target); }
+
+    using CoefficientFunction::Transform;        
+    template <typename TARGET>
+    void Transform (SphericalExpansionCF<TARGET, entry_type> & target)
+    {
+      mp.Transform (target.MP(), target.Center()-center);
+    }
+    template <typename TARGET>
+    void TransformAdd (SphericalExpansionCF<TARGET, entry_type> & target)
+    {
+      mp.TransformAdd (target.MP(), target.Center()-center);
+    }
+  };
+
+  template <typename entry_type>
+  class SingularMLExpansionCF : public CoefficientFunction
+  {
+    shared_ptr<SingularMLExpansion<entry_type>> mlmp;
+  public:
+    SingularMLExpansionCF (Vec<3> center, double r, double kappa)
+      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<SingularMLExpansion<entry_type>>(center, r, kappa)} { }
+    
+    virtual double Evaluate (const BaseMappedIntegrationPoint & ip) const override
+    { throw Exception("real eval not available"); }
+    
+    virtual void Evaluate (const BaseMappedIntegrationPoint & mip, FlatVector<Complex> values) const override
+    {
+      // values(0) = mlmp->Evaluate(mip.GetPoint());
+
+      if constexpr (std::is_same<entry_type, Complex>())
+        values(0) = mlmp->Evaluate(mip.GetPoint());
+      else
+        values = mlmp->Evaluate(mip.GetPoint());
+
+      
+    }
+    
+    shared_ptr<SingularMLExpansion<entry_type>> MLExpansion() const { return mlmp; }
+    shared_ptr<RegularMLExpansionCF<entry_type>> CreateRegularExpansion(Vec<3> center, double r) const;
+  };
+  
+
+  template <typename entry_type>
+  class RegularMLExpansionCF : public CoefficientFunction
+  {
+    shared_ptr<RegularMLExpansion<entry_type>> mlmp;
+  public:
+    RegularMLExpansionCF (shared_ptr<SingularMLExpansionCF<entry_type>> asingmp, Vec<3> center, double r)
+      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<RegularMLExpansion<entry_type>>(asingmp->MLExpansion(), center, r, FMM_Parameters())} { } 
+    RegularMLExpansionCF (shared_ptr<SingularMLExpansion<entry_type>> asingmp, Vec<3> center, double r)
+      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<RegularMLExpansion<entry_type>>(asingmp, center, r, FMM_Parameters())} { } 
+    
+    virtual double Evaluate (const BaseMappedIntegrationPoint & ip) const override
+    { throw Exception("real eval not available"); }
+
+    virtual void Evaluate (const BaseMappedIntegrationPoint & mip, FlatVector<Complex> values) const override
+    {
+      // values(0) = mlmp->Evaluate(mip.GetPoint());
+
+      if constexpr (std::is_same<entry_type, Complex>())
+        values(0) = mlmp->Evaluate(mip.GetPoint());
+      else
+        values = mlmp->Evaluate(mip.GetPoint());
+    }
+
+    shared_ptr<RegularMLExpansion<entry_type>> MLExpansion() { return mlmp; }
+  };
+
+  
+}
+
+#endif