ngsolve 6.2.2506.post45.dev0__cp313-cp313-macosx_10_15_universal2.whl → 6.2.2506.post73.dev0__cp313-cp313-macosx_10_15_universal2.whl

netgen/include/bdbequations.hpp

@@ -2344,6 +2344,39 @@ namespace ngfem
         mat.Rows(DIM_SPC*i, DIM_SPC*(i+1)).Cols(fel.GetRange(i)) = Trans(hmat);
     }
 
+    static int DimRef() { return DIM_SPC*DIM_ELEMENT; } 
+    
+    template <typename IP, typename MAT>
+    static void GenerateMatrixRef (const FiniteElement & bfel, const IP & ip,
+                                   MAT && mat, LocalHeap & lh)
+    {
+      HeapReset hr(lh);
+      auto & fel = static_cast<const VectorFiniteElement&> (bfel);
+      auto & feli = static_cast<const ScalarFiniteElement<DIM_ELEMENT>&> (fel[0]);
+      FlatMatrix<> hmat(feli.GetNDof(), DIM_ELEMENT, lh);
+      feli.CalcDShape(ip, hmat);
+      int ndof = feli.GetNDof();
+      mat.Rows(DIM_SPACE*DIM_ELEMENT).Cols(DIM_SPC*ndof) = 0.0;
+      for (int i = 0; i < DIM_SPACE; i++)
+        mat.Rows(i*DIM_ELEMENT, (i+1)*DIM_ELEMENT).Cols(i*ndof,(i+1)*ndof)
+          = Trans(hmat);
+    }
+
+    template <typename MIP, typename MAT>
+    static void CalcTransformationMatrix (const MIP & mip,
+                                          MAT & mat, LocalHeap & lh)
+    {
+      FlatMatrix<> hmat(DIM_SPC, DIM_ELEMENT, lh);      
+      hmat = Trans(static_cast<const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPC>&>(mip).GetJacobianInverse());
+      mat.Rows(DIM_DMAT).Cols(DIM_ELEMENT*DIM_SPC) = 0.0;
+      for (int i = 0; i < DIM_SPACE; i++)
+        mat.Rows(i*DIM_SPC, (i+1)*DIM_SPC).Cols(i*DIM_ELEMENT, (i+1)*DIM_ELEMENT) = hmat;
+    }
+    
+
+
+
+
     
     static void GenerateMatrixSIMDIR (const FiniteElement & bfel,
                                       const SIMD_BaseMappedIntegrationRule & mir,

netgen/include/diffopwithfactor.hpp

@@ -0,0 +1,123 @@
+#ifndef DIFFOPWITHFACTOR_HPP
+#define DIFFOPWITHFACTOR_HPP
+
+
+
+namespace ngsbem
+{
+  using namespace ngfem;
+
+  class DifferentialOperatorWithFactor : public DifferentialOperator
+  {
+    shared_ptr<DifferentialOperator> diffop;
+    shared_ptr<CoefficientFunction> factor;
+
+  public:
+    DifferentialOperatorWithFactor (shared_ptr<DifferentialOperator> adiffop,
+                                    shared_ptr<CoefficientFunction> afactor)
+      : DifferentialOperator(afactor->Dimensions()[0], 1, adiffop->VB(), adiffop->DiffOrder()),
+        diffop(adiffop), factor(afactor)
+    {
+      ;
+    }
+
+    int DimRef() const override { return diffop->DimRef(); }
+
+    virtual IntRange UsedDofs(const FiniteElement & fel) const override { return diffop->UsedDofs(fel); }
+
+    auto BaseDiffOp() const { return diffop; }
+
+    void CalcMatrix (const FiniteElement & fel,
+                     const BaseMappedIntegrationPoint & mip,
+                     BareSliceMatrix<double,ColMajor> mat, 
+                     LocalHeap & lh) const override
+    {
+      FlatMatrix<double,ColMajor> hmat(diffop->Dim(), fel.GetNDof(), lh);
+      diffop -> CalcMatrix (fel, mip, hmat, lh);
+
+      auto dims = factor->Dimensions();      
+      FlatMatrix<double> factorx(dims[0], dims[1], lh);
+      factor->Evaluate (mip, factorx.AsVector());
+
+      IntRange used = diffop->UsedDofs(fel);
+      mat.Cols(used) = factorx * hmat.Cols(used);
+    }
+    
+    void CalcMatrix (const FiniteElement & fel,
+                     const SIMD_BaseMappedIntegrationRule & mir,
+                     BareSliceMatrix<SIMD<double>> mat) const override
+    {
+      // *testout << "CalcMatrix SIMD" << endl;      
+      Matrix<SIMD<double>> hmat (fel.GetNDof()*diffop->Dim(), mir.Size());
+      // hmat = SIMD<double>(0.0);
+      diffop -> CalcMatrix (fel, mir, hmat);
+
+      Matrix<SIMD<double>> fac(factor->Dimension(), mir.Size());
+      factor -> Evaluate (mir, fac);
+
+      auto dims = factor -> Dimensions();
+
+      mat.Rows(fel.GetNDof()*dims[1]).Cols(mir.Size()) = SIMD<double>(0.0);
+      
+      for (size_t i = 0; i < mir.Size(); i++)
+        for (size_t j = 0; j < dims[0]; j++)
+          for (size_t k = 0; k < dims[1]; k++)
+            mat.Col(i).Slice(j,dims[0]) += fac(j*dims[1]+k, i) * hmat.Col(i).Slice(k, dims[1]);
+    }
+    
+
+    void CalcMatrix (const FiniteElement & fel,
+                     const IntegrationPoint & ip,
+                     BareSliceMatrix<double,ColMajor> mat,
+                     LocalHeap & lh) const override
+    {
+      diffop -> CalcMatrix(fel, ip, mat, lh);
+      /*
+      *testout << "calcmatrix mip" << endl
+               << mat.Rows(Dim()).Cols(fel.GetNDof()) << endl;
+      */
+    }
+
+    void CalcTransformationMatrix (const BaseMappedIntegrationPoint & mip,
+                                   SliceMatrix<double> trans,
+                                   LocalHeap & lh) const override
+    {
+      HeapReset hr(lh);
+      auto dims = factor->Dimensions();
+      
+      FlatMatrix<double> factorx(dims[0], dims[1], lh);
+      factor->Evaluate (mip, factorx.AsVector());
+
+      FlatMatrix<double> basetrans(diffop->Dim(), diffop->DimRef(), lh);
+      diffop -> CalcTransformationMatrix(mip, basetrans, lh);
+
+      trans = factorx * basetrans;
+      // *testout << "trans = " << trans << endl;
+    }
+
+
+    void Apply (const FiniteElement & fel,
+                const SIMD_BaseMappedIntegrationRule & mir,
+                BareSliceVector<double> x, 
+                BareSliceMatrix<SIMD<double>> flux) const override
+    {
+      auto dims = factor->Dimensions();
+
+      Matrix<SIMD<double>> tmpflux(dims[1], mir.Size());
+      Matrix<SIMD<double>> factorx(dims[0]*dims[1], mir.Size());
+      
+      diffop -> Apply (fel, mir, x, tmpflux);
+      factor -> Evaluate (mir, factorx);
+      flux.Rows(0, dims[0]).Cols(0, mir.Size()) = SIMD<double>(0.0);
+      for (int i = 0; i < dims[0]; i++)
+        for (int j = 0; j < dims[1]; j++)
+          flux.Row(i).Range(mir.Size()) += pw_mult(factorx.Row(i*dims[1]+j), tmpflux.Row(j));
+    }
+
+    
+  };
+
+
+}
+
+#endif

netgen/include/kernels.hpp

@@ -2,6 +2,7 @@
 #define KERNELS_hpp
 
 #include "mptools.hpp"
+#include <type_traits>
 
 
 //  ****************************  The kernels **********************************
@@ -62,18 +63,26 @@ namespace ngsbem
   
   /** LaplaceSLkernel is the kernel for the single layer potential of 
       the Laplace equation $ \Delta u = 0 \,.$  */
-  template <int DIM> class LaplaceSLKernel;
+  template <int DIM, int COMPS=1> class LaplaceSLKernel;
 
   /** LaplaceSLkernel in 3D reads 
       $$ G(x-y) = \frac{1}{4\,\pi \, | x-y| }, \quad x, y \in \mathbb R^3, \; x\not=y\,. $$ */
-  template<>
-  class LaplaceSLKernel<3> : public BaseKernel
+  template<int COMPS>
+  class LaplaceSLKernel<3, COMPS> : public BaseKernel
   {
   public:
-    LaplaceSLKernel<3> () = default;
+    LaplaceSLKernel<3,COMPS>()
+    {
+      for (size_t i = 0; i < COMPS; i++)
+        terms += {1.0, 0, i, i};
+    };
     typedef double value_type;
+    using mp_type = typename std::conditional<COMPS == 1,
+                                              Complex,
+                                              Vec<COMPS, Complex>>::type;
+
     static string Name() { return "LaplaceSL"; }
-    static auto Shape() { return IVec<2>(1,1); }
+    static auto Shape() { return IVec<2>(COMPS,COMPS); }
     
     template <typename T>        
     auto Evaluate (Vec<3,T> x, Vec<3,T> y, Vec<3,T> nx, Vec<3,T> ny) const
@@ -83,45 +92,59 @@ namespace ngsbem
       return Vec<1,T> (1.0 / (4 * M_PI * norm));
     }
     
-    Array<KernelTerm> terms = { KernelTerm{1.0, 0, 0, 0}, };
+    Array<KernelTerm> terms;
     
-    auto CreateMultipoleExpansion (Vec<3> c, double r) const
+    auto CreateMultipoleExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<SingularMLExpansion<Complex>> (c, r, 1e-16);
+      return make_shared<SingularMLExpansion<mp_type>> (c, r, 1e-16, fmm_params);
     }
 
-    auto CreateLocalExpansion (Vec<3> c, double r) const
+    auto CreateLocalExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<RegularMLExpansion<Complex>> (c, r, 1e-16);
+      return make_shared<RegularMLExpansion<mp_type>> (c, r, 1e-16, fmm_params);
     }
 
-    void AddSource (SingularMLExpansion<Complex> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
+    void AddSource (SingularMLExpansion<mp_type> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
     {
-      mp.AddCharge (pnt, val(0));
+      if constexpr (COMPS == 1)
+        mp.AddCharge (pnt, val(0));
+      else
+        mp.AddCharge (pnt, val);
     }
 
-    void EvaluateMP (RegularMLExpansion<Complex> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
+    void EvaluateMP (RegularMLExpansion<mp_type> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
     {
-      val(0) = Real(mp.Evaluate (pnt));
+      if constexpr (COMPS == 1)
+        val(0) = Real(mp.Evaluate (pnt));
+      else
+        val = Real(mp.Evaluate (pnt));
     }
   };
 
 
   /** LaplaceDLkernel is the kernel for the double layer potential of 
       the Laplace equation $ \Delta u = 0 \,.$  */
-  template <int DIM> class LaplaceDLKernel;
+  template <int DIM, int COMPS=1> class LaplaceDLKernel;
 
   /** LaplaceDLkernel in 3D reads 
       $$ \frac{\partial }{ \partial n_y} G(x-y) = \frac{1}{4\,\pi} \, 
           \frac{ \langle n(y), x-y\rangle }{ | x-y|^3 }, 
           \quad x, y \in \mathbb R^3, \; x\not=y\,. $$ */
-  template<>
-  class LaplaceDLKernel<3> : public BaseKernel
+  template<int COMPS>
+  class LaplaceDLKernel<3, COMPS> : public BaseKernel
   {
   public:
+    LaplaceDLKernel<3,COMPS>()
+    {
+      for (size_t i = 0; i < COMPS; i++)
+        terms += {1.0, 0, i, i};
+    };
     typedef double value_type;
+    using mp_type = typename std::conditional<COMPS == 1,
+                                                  Complex,
+                                                  Vec<COMPS, Complex>>::type;
     static string Name() { return "LaplaceDL"; }
-    static auto Shape() { return IVec<2>(1,1); }
+    static auto Shape() { return IVec<2>(COMPS,COMPS); }
     
     template <typename T>
     auto Evaluate (Vec<3,T> x, Vec<3,T> y, Vec<3,T> nx, Vec<3,T> ny) const
@@ -132,83 +155,48 @@ namespace ngsbem
       return Vec<1,T> (nxy / (4 * M_PI * norm*norm*norm));
     }
 
-    Array<KernelTerm> terms = { KernelTerm{1.0, 0, 0, 0}, };    
-
-    auto CreateMultipoleExpansion (Vec<3> c, double r) const
-    {
-      return make_shared<SingularMLExpansion<Complex>> (c, r, 1e-16);
-    }
-
-    auto CreateLocalExpansion (Vec<3> c, double r) const
-    {
-      return make_shared<RegularMLExpansion<Complex>> (c, r, 1e-16);
-    }
-
-    void AddSource (SingularMLExpansion<Complex> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
-    {
-      mp.AddDipole(pnt, -nv, val(0));
-    }
-
-    void AddSourceTrans(SingularMLExpansion<Complex> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
-    {
-      mp.AddCharge(pnt, val(0));
-    }
-
-    void EvaluateMP (RegularMLExpansion<Complex> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
-    {
-      val(0) = Real(mp.Evaluate (pnt));
-    }
+    Array<KernelTerm> terms;
 
-    void EvaluateMPTrans(RegularMLExpansion<Complex> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
+    auto CreateMultipoleExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      val(0) = Real(mp.EvaluateDirectionalDerivative(pnt, nv));
+      return make_shared<SingularMLExpansion<mp_type>> (c, r, 1e-16, fmm_params);
     }
-  };
 
-
-  template <int DIM> class LaplaceHSKernel;
-  
-  template<>
-  class LaplaceHSKernel<3> : public BaseKernel 
-  {
-  public:
-    typedef double value_type;
-    static string Name() { return "LaplaceHL"; }
-    static auto Shape() { return IVec<2>(3,3); }
-    
-    template <typename T>        
-    auto Evaluate (Vec<3,T> x, Vec<3,T> y, Vec<3,T> nx, Vec<3,T> ny) const
+    auto CreateLocalExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      T norm = L2Norm(x-y);
-      // return 1.0 / (4 * M_PI * norm);   
-      return Vec<1,T> (1.0 / (4 * M_PI * norm));
+      return make_shared<RegularMLExpansion<mp_type>> (c, r, 1e-16, fmm_params);
     }
-    
-    Array<KernelTerm> terms =
-      {
-        KernelTerm{1.0, 0, 0, 0},
-        KernelTerm{1.0, 0, 1, 1},
-        KernelTerm{1.0, 0, 2, 2},
-      };
 
-    auto CreateMultipoleExpansion (Vec<3> c, double r) const
+    void AddSource (SingularMLExpansion<mp_type> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
     {
-      return make_shared<SingularMLExpansion<Vec<3,Complex>>> (c, r, 1e-16);
+      if constexpr (COMPS == 1)
+        mp.AddDipole(pnt, -nv, val(0));
+      else
+        mp.AddDipole(pnt, -nv, val);
     }
 
-    auto CreateLocalExpansion (Vec<3> c, double r) const
+    void AddSourceTrans(SingularMLExpansion<mp_type> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
     {
-      return make_shared<RegularMLExpansion<Vec<3,Complex>>> (c, r, 1e-16);
+      if constexpr (COMPS == 1)
+        mp.AddCharge (pnt, val(0));
+      else
+        mp.AddCharge (pnt, val);
     }
 
-    void AddSource (SingularMLExpansion<Vec<3,Complex>> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
+    void EvaluateMP (RegularMLExpansion<mp_type> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
     {
-      mp.AddCharge(pnt, val);
+      if constexpr (COMPS == 1)
+        val(0) = Real(mp.Evaluate (pnt));
+      else
+        val = Real(mp.Evaluate (pnt));
     }
 
-    void EvaluateMP (RegularMLExpansion<Vec<3,Complex>> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
+    void EvaluateMPTrans(RegularMLExpansion<mp_type> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<double> val) const
     {
-      val = Real(mp.Evaluate (pnt));
+      if constexpr (COMPS == 1)
+        val(0) = Real(mp.EvaluateDirectionalDerivative(pnt, nv));
+      else
+        val = Real(mp.EvaluateDirectionalDerivative(pnt, nv));
     }
   };
 
@@ -243,14 +231,14 @@ namespace ngsbem
     double GetKappa() const { return kappa; }
     Array<KernelTerm> terms = { KernelTerm{1.0, 0, 0, 0}, };    
 
-    auto CreateMultipoleExpansion (Vec<3> c, double r) const
+    auto CreateMultipoleExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<SingularMLExpansion<Complex>> (c, r, kappa);
+      return make_shared<SingularMLExpansion<Complex>> (c, r, kappa, fmm_params);
     }
 
-    auto CreateLocalExpansion (Vec<3> c, double r) const
+    auto CreateLocalExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<RegularMLExpansion<Complex>> (c, r, kappa);
+      return make_shared<RegularMLExpansion<Complex>> (c, r, kappa, fmm_params);
     }
 
     void AddSource (SingularMLExpansion<Complex> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<Complex> val) const
@@ -297,14 +285,14 @@ namespace ngsbem
     double GetKappa() const { return kappa; }
     Array<KernelTerm> terms = { KernelTerm{1.0, 0, 0, 0}, };    
 
-    auto CreateMultipoleExpansion (Vec<3> c, double r) const
+    auto CreateMultipoleExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<SingularMLExpansion<Complex>> (c, r, kappa);
+      return make_shared<SingularMLExpansion<Complex>> (c, r, kappa, fmm_params);
     }
 
-    auto CreateLocalExpansion (Vec<3> c, double r) const
+    auto CreateLocalExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<RegularMLExpansion<Complex>> (c, r, kappa);
+      return make_shared<RegularMLExpansion<Complex>> (c, r, kappa, fmm_params);
     }
 
     void AddSource (SingularMLExpansion<Complex> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<Complex> val) const
@@ -357,14 +345,14 @@ namespace ngsbem
         KernelTerm{1.0, 0, 2, 2},
       };
 
-    auto CreateMultipoleExpansion (Vec<3> c, double r) const
+    auto CreateMultipoleExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<SingularMLExpansion<Vec<3,Complex>>> (c, r, kappa);
+      return make_shared<SingularMLExpansion<Vec<3,Complex>>> (c, r, kappa, fmm_params);
     }
 
-    auto CreateLocalExpansion (Vec<3> c, double r) const
+    auto CreateLocalExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<RegularMLExpansion<Vec<3,Complex>>> (c, r, kappa);
+      return make_shared<RegularMLExpansion<Vec<3,Complex>>> (c, r, kappa, fmm_params);
     }
 
     void AddSource (SingularMLExpansion<Vec<3,Complex>> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<Complex> val) const
@@ -410,14 +398,14 @@ namespace ngsbem
 	KernelTerm{1.0, 1, 3, 3},
       };
 
-    auto CreateMultipoleExpansion (Vec<3> c, double r) const
+    auto CreateMultipoleExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<SingularMLExpansion<Vec<6,Complex>>> (c, r, kappa);
+      return make_shared<SingularMLExpansion<Vec<6,Complex>>> (c, r, kappa, fmm_params);
     }
  
-    auto CreateLocalExpansion (Vec<3> c, double r) const
+    auto CreateLocalExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<RegularMLExpansion<Vec<6,Complex>>> (c, r, kappa);
+      return make_shared<RegularMLExpansion<Vec<6,Complex>>> (c, r, kappa, fmm_params);
     }
 
     void AddSource (SingularMLExpansion<Vec<6,Complex>> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<Complex> val) const
@@ -473,14 +461,14 @@ namespace ngsbem
     double GetKappa() const { return kappa; }
     Array<KernelTerm> terms = { KernelTerm{1.0, 0, 0, 0}, };    
 
-    auto CreateMultipoleExpansion (Vec<3> c, double r) const
+    auto CreateMultipoleExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<SingularMLExpansion<Complex>> (c, r, kappa);
+      return make_shared<SingularMLExpansion<Complex>> (c, r, kappa, fmm_params);
     }
 
-    auto CreateLocalExpansion (Vec<3> c, double r) const
+    auto CreateLocalExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<RegularMLExpansion<Complex>> (c, r, kappa);
+      return make_shared<RegularMLExpansion<Complex>> (c, r, kappa, fmm_params);
     }
 
     void AddSource (SingularMLExpansion<Complex> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<Complex> val) const
@@ -531,14 +519,14 @@ namespace ngsbem
     double GetKappa() const { return kappa; }
     Array<KernelTerm> terms;
 
-    auto CreateMultipoleExpansion (Vec<3> c, double r) const
+    auto CreateMultipoleExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<SingularMLExpansion<Vec<4,Complex>>> (c, r, kappa);
+      return make_shared<SingularMLExpansion<Vec<4,Complex>>> (c, r, kappa, fmm_params);
     }
 
-    auto CreateLocalExpansion (Vec<3> c, double r) const
+    auto CreateLocalExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<RegularMLExpansion<Vec<4,Complex>>> (c, r, kappa);
+      return make_shared<RegularMLExpansion<Vec<4,Complex>>> (c, r, kappa, fmm_params);
     }
 
     void AddSource (SingularMLExpansion<Vec<4,Complex>> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<Complex> val) const
@@ -598,14 +586,14 @@ namespace ngsbem
         KernelTerm{-1.0, 2, 1, 0},
       };    
 
-    auto CreateMultipoleExpansion (Vec<3> c, double r) const
+    auto CreateMultipoleExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<SingularMLExpansion<Vec<3,Complex>>> (c, r, kappa);
+      return make_shared<SingularMLExpansion<Vec<3,Complex>>> (c, r, kappa, fmm_params);
     }
 
-    auto CreateLocalExpansion (Vec<3> c, double r) const
+    auto CreateLocalExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<RegularMLExpansion<Vec<3,Complex>>> (c, r, kappa);
+      return make_shared<RegularMLExpansion<Vec<3,Complex>>> (c, r, kappa, fmm_params);
     }
 
     void AddSource (SingularMLExpansion<Vec<3,Complex>> & mp, Vec<3> pnt, Vec<3> nv, BareSliceVector<Complex> val) const
@@ -712,14 +700,14 @@ namespace ngsbem
     }
 
     
-    auto CreateMultipoleExpansion (Vec<3> c, double r) const
+    auto CreateMultipoleExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<SingularMLExpansion<Vec<6,Complex>>> (c, r, 1e-16);
+      return make_shared<SingularMLExpansion<Vec<6,Complex>>> (c, r, 1e-16, fmm_params);
     }
 
-    auto CreateLocalExpansion (Vec<3> c, double r) const
+    auto CreateLocalExpansion (Vec<3> c, double r, FMM_Parameters fmm_params) const
     {
-      return make_shared<RegularMLExpansion<Vec<6,Complex>>> (c, r, 1e-16);
+      return make_shared<RegularMLExpansion<Vec<6,Complex>>> (c, r, 1e-16, fmm_params);
     }
 
     

netgen/include/mp_coefficient.hpp

@@ -119,9 +119,9 @@ namespace ngsbem
     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)} { } 
+      : 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)} { } 
+      : 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"); }