ngsolve 6.2.2503__cp310-cp310-macosx_10_15_universal2.whl → 6.2.2504.post12.dev0__cp310-cp310-macosx_10_15_universal2.whl

netgen/include/h1amg.hpp

@@ -1,9 +1,10 @@
-#ifndef H1AMG_HPP_
-#define H1AMG_HPP_
+#ifndef H1AMGxx_HPP_
+#define H1AMGxx_HPP_
 
 // #include <la.hpp>
 #include <basematrix.hpp>
 #include <sparsematrix.hpp>
+#include <preconditioner.hpp>
 
 namespace ngcomp
 {
@@ -36,6 +37,65 @@ namespace ngcomp
 
     virtual void Mult (const ngla::BaseVector & b, ngla::BaseVector & x) const override;
   };
+
+
+
+
+
+  template <class SCAL>
+  class H1AMG_Preconditioner : public Preconditioner
+  {
+    shared_ptr<BitArray> freedofs;
+    shared_ptr<H1AMG_Matrix<SCAL>> mat;
+
+    ParallelHashTable<IVec<2>,double> edge_weights_ht;
+    ParallelHashTable<IVec<1>,double> vertex_weights_ht;
+
+  public:
+
+    static shared_ptr<Preconditioner> CreateBF (shared_ptr<BilinearForm> bfa, const Flags & flags, const string & name)
+    {
+      if (bfa->GetFESpace()->IsComplex())
+        return make_shared<H1AMG_Preconditioner<Complex>> (bfa, flags, name);
+      else
+        return make_shared<H1AMG_Preconditioner<double>> (bfa, flags, name);
+    }
+
+    static DocInfo GetDocu ();    
+
+    H1AMG_Preconditioner (shared_ptr<BilinearForm> abfa, const Flags & aflags,
+                          const string aname = "H1AMG_cprecond")
+      : Preconditioner (abfa, aflags, aname)
+    {
+      if (is_same<SCAL,double>::value)
+        cout << IM(3) << "Create H1AMG" << endl;
+      else
+        cout << IM(3) << "Create H1AMG, complex" << endl;
+    }
+
+    virtual void InitLevel (shared_ptr<BitArray> _freedofs) override
+    {
+      freedofs = _freedofs;
+    }
+
+    virtual void FinalizeLevel (const BaseMatrix * matrix) override;
+
+    virtual void AddElementMatrix (FlatArray<int> dnums,
+                                   FlatMatrix<SCAL> elmat,
+                                   ElementId id,
+                                   LocalHeap & lh) override;
+
+    virtual void Update () override { ; }
+
+    virtual const BaseMatrix & GetMatrix() const override 
+    {
+      return *mat;
+    }
+
+  };
+
+
+  
 }
 
 #endif // H1AMG_HPP_

netgen/include/integrator.hpp

@@ -781,20 +781,14 @@ namespace ngfem
                         const FiniteElement & volumefel2, int LocalFacetNr2,
                         const ElementTransformation & eltrans2, FlatArray<int> & ElVertices2,
                         FlatVector<double> elx, FlatVector<double> ely,
-                        LocalHeap & lh) const
-    { 
-      throw Exception ("FacetBilinearFormIntegrator::ApplyFacetMatrix for inner facets not implemented!");
-    }
+                        LocalHeap & lh) const;
     virtual void
       ApplyFacetMatrix (const FiniteElement & volumefel1, int LocalFacetNr1,
                         const ElementTransformation & eltrans1, FlatArray<int> & ElVertices1,
                         const FiniteElement & volumefel2, int LocalFacetNr2,
                         const ElementTransformation & eltrans2, FlatArray<int> & ElVertices2,
                         FlatVector<Complex> elx, FlatVector<Complex> ely,
-                        LocalHeap & lh) const
-    { 
-      throw Exception ("FacetBilinearFormIntegrator::ApplyFacetMatrix for inner facets not implemented!");
-    }
+                        LocalHeap & lh) const;
 
 
     virtual void
@@ -841,19 +835,13 @@ namespace ngfem
                         const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
                         const ElementTransformation & seltrans, FlatArray<int> & SElVertices,
                         FlatVector<double> elx, FlatVector<double> ely,
-                        LocalHeap & lh) const
-    { 
-      throw Exception ("FacetBilinearFormIntegrator::ApplyFacetMatrix for boundary facets not implemented!");
-    }
+                        LocalHeap & lh) const;
     virtual void
       ApplyFacetMatrix (const FiniteElement & volumefel, int LocalFacetNr,
                         const ElementTransformation & eltrans, FlatArray<int> & ElVertices,
                         const ElementTransformation & seltrans, FlatArray<int> & SElVertices,
                         FlatVector<Complex> elx, FlatVector<Complex> ely,
-                        LocalHeap & lh) const
-    { 
-      throw Exception ("FacetBilinearFormIntegrator::ApplyFacetMatrix for boundary facets not implemented!");
-    }
+                        LocalHeap & lh) const;
 
 
     // calculate traces in integration points

netgen/include/mp_coefficient.hpp

@@ -0,0 +1,140 @@
+#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 RegularMLMultiPoleCF;
+  
+
+  template <typename RADIAL, typename entry_type=Complex>
+  class MultiPoleCF : public CoefficientFunction
+  {
+    MultiPole<RADIAL, entry_type> mp;
+    Vec<3> center;
+  public:
+    MultiPoleCF (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, MultiPole<TARGET, entry_type> & target) { mp.ShiftZ(z, target); }
+
+    using CoefficientFunction::Transform;        
+    template <typename TARGET>
+    void Transform (MultiPoleCF<TARGET, entry_type> & target)
+    {
+      mp.Transform (target.MP(), target.Center()-center);
+    }
+  };
+
+  template <typename entry_type>
+  class SingularMLMultiPoleCF : public CoefficientFunction
+  {
+    shared_ptr<SingularMLMultiPole<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)} { }
+    
+    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<SingularMLMultiPole<entry_type>> MLMP() const { return mlmp; }
+    shared_ptr<RegularMLMultiPoleCF<entry_type>> CreateRegularExpansion(Vec<3> center, double r) const;
+  };
+  
+
+  template <typename entry_type>
+  class RegularMLMultiPoleCF : public CoefficientFunction
+  {
+    shared_ptr<RegularMLMultiPole<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)} { } 
+    
+    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<RegularMLMultiPole<entry_type>> MLMP() { return mlmp; }
+  };
+
+  
+}
+
+#endif

netgen/include/mptools.hpp

@@ -218,13 +218,11 @@ namespace ngsbem
   class MPSingular
   {
   public:
-    /*
     template <typename T>
     static void Eval (int order, double r, double scale, T && values)
     {
       SphericalHankel1(order, r, scale,  values);
     }
-    */
 
     template <typename T>
     static void Eval (int order, double kappa, double r, double rtyp, T && values)
@@ -235,7 +233,8 @@ namespace ngsbem
 
     static double Scale (double kappa, double rtyp)
     {
-      return min(1.0, rtyp*kappa);      
+      // return min(1.0, rtyp*kappa);
+      return min(1.0, 0.5*rtyp*kappa);      
     }
   };
 
@@ -245,13 +244,11 @@ namespace ngsbem
   class MPRegular
   {
   public:
-    /*
     template <typename T>
     static void Eval (int order, double r, double scale, T && values)
     {
       SphericalBessel (order, r, 1.0/scale, values);
     }
-    */
 
     template <typename T>
     static void Eval (int order, double kappa, double r, double rtyp, T && values)
@@ -262,7 +259,8 @@ namespace ngsbem
 
     static double Scale (double kappa, double rtyp)
     {
-      return 1.0/ min(1.0, 0.25*rtyp*kappa);
+      // return 1.0/ min(1.0, 0.25*rtyp*kappa);
+      return 1.0/ min(1.0, 0.5*rtyp*kappa);
     }
     
   };
@@ -276,12 +274,7 @@ namespace ngsbem
     SphericalHarmonics<entry_type> sh;
     double kappa;
     double rtyp;
-    // double scale;
   public:
-  /*
-    MultiPole (int aorder, double akappa, double ascale = 1) 
-      : sh(aorder), kappa(akappa), scale(ascale) { }
-  */
 
     MultiPole (int aorder, double akappa, double artyp) 
     : sh(aorder), kappa(akappa), rtyp(artyp) { }
@@ -362,8 +355,8 @@ namespace ngsbem
           return;
         }
       
-      static Timer t("mptool Transform "+ToString(typeid(RADIAL).name())+ToString(typeid(TARGET).name()));      
-      RegionTimer reg(t);
+      // static Timer t("mptool Transform "+ToString(typeid(RADIAL).name())+ToString(typeid(TARGET).name()));      
+      // RegionTimer reg(t);
       
       double len = L2Norm(dist);
       double theta, phi;
@@ -379,7 +372,10 @@ namespace ngsbem
         phi = atan2(dist(1), dist(0));
         
       
-      MultiPole<RADIAL,entry_type> tmp(*this);
+      // MultiPole<RADIAL,entry_type> tmp{*this};
+      MultiPole<RADIAL,entry_type> tmp(Order(), kappa, rtyp);
+      tmp.SH().Coefs() = SH().Coefs();
+      
       tmp.SH().RotateZ(phi);
       tmp.SH().RotateY(theta);
 
@@ -434,11 +430,9 @@ namespace ngsbem
       Array<tuple<Vec<3>, Vec<3>, Complex,int>> currents;
       int total_sources;
       
-      Node (Vec<3> acenter, double ar, int alevel, int order, double kappa)
-        : center(acenter), r(ar), level(alevel), mp(MPOrder(ar*kappa), kappa, min(1.0, r*kappa))
-          // : center(acenter), r(ar), level(alevel), mp(MPOrder(ar*kappa), kappa, 1.0)
+      Node (Vec<3> acenter, double ar, int alevel, double akappa)
+        : center(acenter), r(ar), level(alevel), mp(MPOrder(ar*akappa), akappa, ar) // min(1.0, ar*akappa))
       {
-        // cout << "singml, add node, level = " << level << endl;
         if (level < nodes_on_level.Size())
           nodes_on_level[level]++;
       }
@@ -453,7 +447,7 @@ namespace ngsbem
             cc(0) += (i&1) ? r/2 : -r/2;
             cc(1) += (i&2) ? r/2 : -r/2;
             cc(2) += (i&4) ? r/2 : -r/2;
-            childs[i] = make_unique<Node> (cc, r/2, level+1, max(mp.SH().Order()/2, 8), mp.Kappa());
+            childs[i] = make_unique<Node> (cc, r/2, level+1, mp.Kappa());
           }
       }
       
@@ -473,7 +467,8 @@ namespace ngsbem
 
         charges.Append( tuple{x,c} );
 
-        if (r*mp.Kappa() < 1e-8) return;
+        // if (r*mp.Kappa() < 1e-8) return;
+        if (level > 20) return;
         if (charges.Size() < maxdirect && r*mp.Kappa() < 1)
           return;
 
@@ -588,9 +583,17 @@ namespace ngsbem
             return sum;
           }
 
-        for (auto [x,c] : charges)
-          if (double rho = L2Norm(p-x); rho > 0)
-            sum += (1/(4*M_PI))*exp(Complex(0,rho*mp.Kappa())) / rho * c;
+        // static Timer t("fmm direct eval"); RegionTimer reg(t);
+        if (mp.Kappa() < 1e-8)
+          {
+            for (auto [x,c] : charges)
+              if (double rho = L2Norm(p-x); rho > 0)
+                sum += (1/(4*M_PI))*Complex(1,rho*mp.Kappa()) / rho * c;
+          }
+        else
+          for (auto [x,c] : charges)
+            if (double rho = L2Norm(p-x); rho > 0)
+              sum += (1/(4*M_PI))*exp(Complex(0,rho*mp.Kappa())) / rho * c;
         
         for (auto [x,d,c] : dipoles)
           if (double rho = L2Norm(p-x); rho > 0)
@@ -771,8 +774,8 @@ namespace ngsbem
     bool havemp = false;
     
   public:
-    SingularMLMultiPole (Vec<3> center, double r, int order, double kappa)
-      : root(center, r, 0, order, kappa)
+    SingularMLMultiPole (Vec<3> center, double r, double kappa)
+      : root(center, r, 0, kappa)
     {
       nodes_on_level = 0;
       nodes_on_level[0] = 1;
@@ -842,6 +845,7 @@ namespace ngsbem
       for (int i = 0; i <= maxlevel; i++)
         cout << "sing " <<  i << ": " << nodes_on_level[i] << endl;
       */
+      
       root.CalcTotalSources();
       root.CalcMP();
       
@@ -886,8 +890,8 @@ namespace ngsbem
 
       Array<const typename SingularMLMultiPole<elem_type>::Node*> singnodes;
 
-      Node (Vec<3> acenter, double ar, int alevel, int order, double kappa)
-        : center(acenter), r(ar), level(alevel), mp(MPOrder(ar*kappa), kappa, 1.0/min(1.0, 0.25*r*kappa))
+      Node (Vec<3> acenter, double ar, int alevel, double kappa)
+        : center(acenter), r(ar), level(alevel), mp(MPOrder(ar*kappa), kappa, ar) // 1.0/min(1.0, 0.25*r*kappa))
           // : center(acenter), r(ar), level(alevel), mp(MPOrder(ar*kappa), kappa, 1.0)
       {
         if (level < nodes_on_level.Size())
@@ -905,7 +909,7 @@ namespace ngsbem
             cc(0) += (i&1) ? r/2 : -r/2;
             cc(1) += (i&2) ? r/2 : -r/2;
             cc(2) += (i&4) ? r/2 : -r/2;
-            childs[i] = make_unique<Node> (cc, r/2, level+1, max(mp.SH().Order()/2, 8), mp.Kappa());
+            childs[i] = make_unique<Node> (cc, r/2, level+1, mp.Kappa());
           }
       }
 
@@ -1027,7 +1031,7 @@ namespace ngsbem
           sum = mp.Eval(p-center);
 
 
-        static Timer t("mptool direct evaluate"); RegionTimer r(t);
+        // static Timer t("mptool direct evaluate"); RegionTimer r(t);
         for (auto sn : singnodes)
           sum += sn->EvaluateMP(p);
 
@@ -1089,7 +1093,8 @@ namespace ngsbem
 
         targets.Append( x );
 
-        if (r*mp.Kappa() < 1e-8) return;
+        // if (r*mp.Kappa() < 1e-8) return;
+        if (level > 20) return;        
         if (targets.Size() < maxdirect && r*mp.Kappa() < 1)
           return;
 
@@ -1145,8 +1150,8 @@ namespace ngsbem
     shared_ptr<SingularMLMultiPole<elem_type>> singmp;
     
   public:
-  RegularMLMultiPole (shared_ptr<SingularMLMultiPole<elem_type>> asingmp, Vec<3> center, double r, int order)
-      : root(center, r, 0, order, asingmp->Kappa()), singmp(asingmp)
+  RegularMLMultiPole (shared_ptr<SingularMLMultiPole<elem_type>> asingmp, Vec<3> center, double r)
+      : root(center, r, 0, asingmp->Kappa()), singmp(asingmp)
     {
       if (!singmp->havemp) throw Exception("first call Calc for singular MP");
 
@@ -1175,8 +1180,8 @@ namespace ngsbem
       }
     }
 
-    RegularMLMultiPole (Vec<3> center, double r, int order, double kappa)
-      : root(center, r, 0, order, kappa)
+    RegularMLMultiPole (Vec<3> center, double r, double kappa)
+      : root(center, r, 0, kappa)
     {
       nodes_on_level = 0;
       nodes_on_level[0] = 1;
@@ -1189,6 +1194,8 @@ namespace ngsbem
 
     void CalcMP(shared_ptr<SingularMLMultiPole<elem_type>> asingmp)
     {
+      static Timer t("mptool regular MLMP"); RegionTimer rg(t);
+      
       singmp = asingmp;
 
       root.CalcTotalTargets();
@@ -1205,6 +1212,7 @@ namespace ngsbem
         cout << "reg " << i << ": " << RegularMLMultiPole::nodes_on_level[i] << endl;
       */
 
+      static Timer tloc("mptool regular localize expansion"); RegionTimer rloc(tloc);      
       root.LocalizeExpansion(false);
     }
 
@@ -1251,132 +1259,5 @@ 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 RegularMLMultiPoleCF;
-  
-
-  template <typename RADIAL, typename entry_type=Complex>
-  class MultiPoleCF : public CoefficientFunction
-  {
-    MultiPole<RADIAL, entry_type> mp;
-    Vec<3> center;
-  public:
-    MultiPoleCF (int order, double kappa, Vec<3> acenter, double scale = 1)
-      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mp(order, kappa, scale), 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, MultiPole<TARGET, entry_type> & target) { mp.ShiftZ(z, target); }
-
-    using CoefficientFunction::Transform;        
-    template <typename TARGET>
-    void Transform (MultiPoleCF<TARGET, entry_type> & target)
-    {
-      mp.Transform (target.MP(), target.Center()-center);
-    }
-  };
-
-  template <typename entry_type>
-  class SingularMLMultiPoleCF : public CoefficientFunction
-  {
-    shared_ptr<SingularMLMultiPole<entry_type>> mlmp;
-  public:
-    SingularMLMultiPoleCF (Vec<3> center, double r, int order, double kappa)
-      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<SingularMLMultiPole<entry_type>>(center, r, order, 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<SingularMLMultiPole<entry_type>> MLMP() const { return mlmp; }
-    shared_ptr<RegularMLMultiPoleCF<entry_type>> CreateRegularExpansion(Vec<3> center, double r) const;
-  };
-  
-
-  template <typename entry_type>
-  class RegularMLMultiPoleCF : public CoefficientFunction
-  {
-    shared_ptr<RegularMLMultiPole<entry_type>> mlmp;
-  public:
-    RegularMLMultiPoleCF (shared_ptr<SingularMLMultiPoleCF<entry_type>> asingmp, Vec<3> center, double r, int order)
-      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<RegularMLMultiPole<entry_type>>(asingmp->MLMP(), center, r, order)} { } 
-    RegularMLMultiPoleCF (shared_ptr<SingularMLMultiPole<entry_type>> asingmp, Vec<3> center, double r, int order)
-      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mlmp{make_shared<RegularMLMultiPole<entry_type>>(asingmp, center, r, order)} { } 
-    
-    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<RegularMLMultiPole<entry_type>> MLMP() { return mlmp; }
-  };
-
-  
 }
 #endif

netgen/include/potentialtools.hpp

@@ -12,6 +12,8 @@
 
 namespace ngsbem
 {
+
+  extern void AddChargeDensity (SingularMLMultiPole<Complex> & mp, shared_ptr<CoefficientFunction> current, ngcomp::Region reg);
   
   extern void AddCurrentDensity (SingularMLMultiPole<Vec<3,Complex>> & mp, shared_ptr<CoefficientFunction> current, ngcomp::Region reg);