ngsolve 6.2.2504.post44.dev0__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

@@ -1201,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

@@ -41,16 +41,16 @@ namespace ngsbem
 
 
 
-  template <typename entry_type> class RegularMLMultiPoleCF;
+  template <typename entry_type> class RegularMLExpansionCF;
   
 
   template <typename RADIAL, typename entry_type=Complex>
-  class MultiPoleCF : public CoefficientFunction
+  class SphericalExpansionCF : public CoefficientFunction
   {
-    MultiPole<RADIAL, entry_type> mp;
+    SphericalExpansion<RADIAL, entry_type> mp;
     Vec<3> center;
   public:
-    MultiPoleCF (int order, double kappa, Vec<3> acenter, double rtyp = 1)
+    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); } 
@@ -70,23 +70,28 @@ namespace ngsbem
     }
 
     template <typename TARGET>
-    void ShiftZ (double z, MultiPole<TARGET, entry_type> & target) { mp.ShiftZ(z, target); }
+    void ShiftZ (double z, SphericalExpansion<TARGET, entry_type> & target) { mp.ShiftZ(z, target); }
 
     using CoefficientFunction::Transform;        
     template <typename TARGET>
-    void Transform (MultiPoleCF<TARGET, entry_type> & 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 SingularMLMultiPoleCF : public CoefficientFunction
+  class SingularMLExpansionCF : public CoefficientFunction
   {
-    shared_ptr<SingularMLMultiPole<entry_type>> mlmp;
+    shared_ptr<SingularMLExpansion<entry_type>> mlmp;
   public:
-    SingularMLMultiPoleCF (Vec<3> center, double r, double kappa)
-      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<SingularMLMultiPole<entry_type>>(center, r, kappa)} { }
+    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"); }
@@ -103,20 +108,20 @@ namespace ngsbem
       
     }
     
-    shared_ptr<SingularMLMultiPole<entry_type>> MLMP() const { return mlmp; }
-    shared_ptr<RegularMLMultiPoleCF<entry_type>> CreateRegularExpansion(Vec<3> center, double r) const;
+    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 RegularMLMultiPoleCF : public CoefficientFunction
+  class RegularMLExpansionCF : public CoefficientFunction
   {
-    shared_ptr<RegularMLMultiPole<entry_type>> mlmp;
+    shared_ptr<RegularMLExpansion<entry_type>> mlmp;
   public:
-    RegularMLMultiPoleCF (shared_ptr<SingularMLMultiPoleCF<entry_type>> asingmp, Vec<3> center, double r)
-      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<RegularMLMultiPole<entry_type>>(asingmp->MLMP(), center, r)} { } 
-    RegularMLMultiPoleCF (shared_ptr<SingularMLMultiPole<entry_type>> asingmp, Vec<3> center, double r)
-      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<RegularMLMultiPole<entry_type>>(asingmp, center, r)} { } 
+    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"); }
@@ -131,7 +136,7 @@ namespace ngsbem
         values = mlmp->Evaluate(mip.GetPoint());
     }
 
-    shared_ptr<RegularMLMultiPole<entry_type>> MLMP() { return mlmp; }
+    shared_ptr<RegularMLExpansion<entry_type>> MLExpansion() { return mlmp; }
   };