ngsolve 6.2.2501.post83.dev1__cp311-cp311-macosx_10_15_universal2.whl → 6.2.2503__cp311-cp311-macosx_10_15_universal2.whl

netgen/include/mptools.hpp

@@ -10,27 +10,32 @@
 #include <coefficient.hpp>
 #include <recursive_pol.hpp>
 
-namespace ngfem
-{
 
+namespace ngcomp
+{
+  class Region;
+}
 
+namespace ngsbem
+{
+  using namespace ngfem;
   
+
+  template <typename entry_type = Complex>
   class NGS_DLL_HEADER SphericalHarmonics
   {
     int order;
-    Vector<Complex> coefs;
+    Vector<entry_type> coefs;
 
   public:
     SphericalHarmonics (int aorder)
       : order(aorder), coefs(sqr(order+1)) { coefs=0.0; }
 
     int Order() const { return order; }
-    FlatVector<Complex> Coefs() const { return coefs; }
-
-    Complex & Coef(int n, int m)
-    {
-      return coefs(n*(n+1) + m);  
-    }
+    FlatVector<entry_type> Coefs() const { return coefs; }
+    
+    entry_type & Coef(int n, int m) { return coefs(n*(n+1) + m); }
+    entry_type Coef(int n, int m) const { return coefs(n*(n+1) + m); }    
 
     auto CoefsN (int n) const
     {
@@ -53,29 +58,29 @@ namespace ngfem
       return { theta, phi };
     }
     
-    Complex Eval (Vec<3> x) const
+    entry_type Eval (Vec<3> x) const
     {
       auto [theta, phi] = Polar(x);
       return Eval(theta, phi);
     }
   
-    Complex Eval (double theta, double phi) const;
+    entry_type Eval (double theta, double phi) const;
     
-    Complex EvalOrder (int n, Vec<3> x) const
+    entry_type EvalOrder (int n, Vec<3> x) const
     {
       auto [theta, phi] = Polar (x);
       return EvalOrder(n, theta, phi);
     }
   
-    Complex EvalOrder (int n, double theta, double phi) const;
+    entry_type EvalOrder (int n, double theta, double phi) const;
 
-    void EvalOrders (Vec<3> x, FlatVector<Complex> vals) const
+    void EvalOrders (Vec<3> x, FlatVector<entry_type> vals) const
     {
       auto [theta, phi] = Polar(x);
       return EvalOrders(theta, phi, vals);
     }
   
-    void EvalOrders (double theta, double phi, FlatVector<Complex> vals) const;
+    void EvalOrders (double theta, double phi, FlatVector<entry_type> vals) const;
     
     void Calc (Vec<3> x, FlatVector<Complex> shapes);
 
@@ -106,7 +111,7 @@ namespace ngfem
     
     // Nail A. Gumerov and Ramani Duraiswami book, formula (2.2.12)
     // add directional derivative divided by kappa to res, both multipoles need same scaling
-    void DirectionalDiffAdd (Vec<3> d, SphericalHarmonics & res, double scale = 1);
+    void DirectionalDiffAdd (Vec<3> d, SphericalHarmonics<entry_type> & res, double scale = 1) const;
 
   };
 
@@ -213,48 +218,87 @@ namespace ngfem
   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)
+    {
+      double scale = Scale(kappa, rtyp);
+      SphericalHankel1(order, r*kappa, scale,  values);
+    }
+
+    static double Scale (double kappa, double rtyp)
+    {
+      return min(1.0, rtyp*kappa);      
+    }
   };
+
+
   
   // jn
   class MPRegular
   {
-  public:    
+  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)
+    {
+      double scale = Scale(kappa, rtyp);
+      SphericalBessel (order, r*kappa, 1.0/scale, values);      
+    }
+
+    static double Scale (double kappa, double rtyp)
+    {
+      return 1.0/ min(1.0, 0.25*rtyp*kappa);
+    }
+    
   };
   
   
 
 
-  template <typename RADIAL>
+  template <typename RADIAL, typename entry_type=Complex>
   class NGS_DLL_HEADER MultiPole
   {
-    SphericalHarmonics sh;
+    SphericalHarmonics<entry_type> sh;
     double kappa;
-    double scale;
+    double rtyp;
+    // double scale;
   public:
+  /*
     MultiPole (int aorder, double akappa, double ascale = 1) 
       : sh(aorder), kappa(akappa), scale(ascale) { }
+  */
 
-    Complex & Coef(int n, int m) { return sh.Coef(n,m); }
+    MultiPole (int aorder, double akappa, double artyp) 
+    : sh(aorder), kappa(akappa), rtyp(artyp) { }
+
+  
+    entry_type & Coef(int n, int m) { return sh.Coef(n,m); }
     auto & SH() { return sh; }
     const auto & SH() const { return sh; }
     double Kappa() const { return kappa; }
-    double Scale() const { return scale; }    
+    double Scale() const { return RADIAL::Scale(kappa, rtyp); }
+    double RTyp() const { return rtyp; }
     int Order() const { return sh.Order(); }
     
-    MultiPole<RADIAL> Truncate(int neworder) const
+    MultiPole Truncate(int neworder) const
     {
       if (neworder > sh.Order()) neworder=sh.Order();
-      MultiPole nmp(neworder, kappa);
+      MultiPole nmp(neworder, kappa, rtyp);
       nmp.sh.Coefs() = sh.Coefs().Range(sqr(neworder+1));
       return nmp;
     }
@@ -266,20 +310,34 @@ namespace ngfem
       return *this;
     }
     
-    Complex Eval (Vec<3> x) const;
+    entry_type Eval (Vec<3> x) const;
+    entry_type EvalDirectionalDerivative (Vec<3> x, Vec<3> d) const;
 
-    void AddCharge (Vec<3> x, Complex c);
-    void AddDipole (Vec<3> x, Vec<3> d, Complex c);
-    
+    void AddCharge (Vec<3> x, entry_type c);
+    void AddDipole (Vec<3> x, Vec<3> d, entry_type c);
+    void AddCurrent (Vec<3> ap, Vec<3> ep, Complex j, int num=100);
     
+    /*
     void ChangeScaleTo (double newscale)
     {
-      double fac = scale/newscale;
+      double fac = Scale()/newscale;
       double prod = 1;
       for (int n = 0; n <= sh.Order(); n++, prod*= fac)
         sh.CoefsN(n) *= prod;
       scale = newscale;
     }
+    */
+    void ChangeRTypTo (double new_rtyp)
+    {
+      // double fac = Scale()/newscale;
+      double fac = RADIAL::Scale(kappa, rtyp) / RADIAL::Scale(kappa, new_rtyp);
+      double prod = 1;
+      for (int n = 0; n <= sh.Order(); n++, prod*= fac)
+        sh.CoefsN(n) *= prod;
+      // scale = newscale;
+      rtyp = new_rtyp;
+    }
+    
 
     Vector<double> Spectrum (bool scaled) const
     {
@@ -288,14 +346,14 @@ namespace ngfem
       for (int n = 0; n <= Order(); n++)
         {
           spec(n) = fac * L2Norm2(sh.CoefsN(n));
-          if (!scaled) fac *= sqr(scale);
+          if (!scaled) fac *= sqr(Scale());
         }
       return spec;
     }
 
     
     template <typename TARGET>
-    void Transform (MultiPole<TARGET> & target, Vec<3> dist) const
+    void Transform (MultiPole<TARGET,entry_type> & target, Vec<3> dist) const
     {
       if (target.SH().Order() < 0) return;
       if (SH().Order() < 0)
@@ -321,7 +379,7 @@ namespace ngfem
         phi = atan2(dist(1), dist(0));
         
       
-      MultiPole<RADIAL> tmp(*this);
+      MultiPole<RADIAL,entry_type> tmp(*this);
       tmp.SH().RotateZ(phi);
       tmp.SH().RotateY(theta);
 
@@ -332,18 +390,18 @@ namespace ngfem
     }
     
     template <typename TARGET>
-    void TransformAdd (MultiPole<TARGET> & target, Vec<3> dist) const
+    void TransformAdd (MultiPole<TARGET,entry_type> & target, Vec<3> dist) const
     {
       if (SH().Order() < 0) return;
       if (target.SH().Order() < 0) return;      
       
-      MultiPole<TARGET> tmp{target};
+      MultiPole<TARGET,entry_type> tmp{target};
       Transform(tmp, dist);
       target.SH().Coefs() += tmp.SH().Coefs();
     }
 
     template <typename TARGET>
-    void ShiftZ (double z, MultiPole<TARGET> & target);
+    void ShiftZ (double z, MultiPole<TARGET,entry_type> & target);
     
   };
   
@@ -351,12 +409,14 @@ namespace ngfem
 
   // ***************** parameters ****************
 
-  static int MPOrder (double rho_kappa)
+  static constexpr int MPOrder (double rho_kappa)
   {
     return max (20, int(2*rho_kappa));
   }
   static constexpr int maxdirect = 100;
 
+
+  template <typename entry_type=Complex>
   class SingularMLMultiPole
   {
     static Array<size_t> nodes_on_level;    
@@ -367,10 +427,11 @@ namespace ngfem
       double r;
       int level;
       std::array<unique_ptr<Node>,8> childs;
-      MultiPole<MPSingular> mp;
+      MultiPole<MPSingular, entry_type> mp;
 
-      Array<tuple<Vec<3>, Complex>> charges;
-      Array<tuple<Vec<3>, Vec<3>, Complex>> dipoles;
+      Array<tuple<Vec<3>, entry_type>> charges;
+      Array<tuple<Vec<3>, Vec<3>, entry_type>> dipoles;
+      Array<tuple<Vec<3>, Vec<3>, Complex,int>> currents;
       int total_sources;
       
       Node (Vec<3> acenter, double ar, int alevel, int order, double kappa)
@@ -397,7 +458,7 @@ namespace ngfem
       }
       
 
-      void AddCharge (Vec<3> x, Complex c)
+      void AddCharge (Vec<3> x, entry_type c)
       {
         if (childs[0])
           {
@@ -422,13 +483,16 @@ namespace ngfem
           AddCharge (x,c);
         for (auto [x,d,c] : dipoles)
           AddDipole (x,d,c);
+        for (auto [sp,ep,j,num] : currents)
+          AddCurrent (sp,ep,j,num);
         
         charges.SetSize0();
-        dipoles.SetSize0();        
+        dipoles.SetSize0();
+        currents.SetSize0();
       }
 
 
-      void AddDipole (Vec<3> x, Vec<3> d, Complex c)
+      void AddDipole (Vec<3> x, Vec<3> d, entry_type c)
       {
         if (childs[0])
           {
@@ -453,15 +517,70 @@ namespace ngfem
           AddCharge (x,c);
         for (auto [x,d,c] : dipoles)
           AddDipole (x,d,c);
+        for (auto [sp,ep,j,num] : currents)
+          AddCurrent (sp,ep,j,num);
 
         charges.SetSize0();
         dipoles.SetSize0();        
+        currents.SetSize0();        
       }
 
+      void AddCurrent (Vec<3> sp, Vec<3> ep, Complex j, int num)
+      {
+        if (childs[0])
+          {
+            // split line and send to childs
+            Array<double> split;
+            split.Append(0);
+            for (int i = 0; i < 3; i++)
+              if (sp(i) < center(i) != ep(i) < center(i))
+                split += (center(i)-sp(i)) / (ep(i)-sp(i));  // segment cuts i-th coordinate plane
+            split.Append(1);
+            BubbleSort(split);
+
+            for (int i = 0; i < split.Size()-1; i++)
+              if (split[i+1] > split[i])
+                {
+                  Vec<3> spi = sp + split[i]*(ep-sp);
+                  Vec<3> epi = sp + split[i+1]*(ep-sp);
+                  
+                  Vec<3> x = 0.5*(spi+epi);
+                  
+                  int childnum  = 0;
+                  if (x(0) > center(0)) childnum += 1;
+                  if (x(1) > center(1)) childnum += 2;
+                  if (x(2) > center(2)) childnum += 4;
+                  childs[childnum] -> AddCurrent(spi, epi, j, num);
+                }
+            return;
+          }
+        
+        currents.Append (tuple{sp,ep,j,num});
+
+        // if (currents.Size() < maxdirect || r < 1e-8)
+        if (currents.Size() < 4 || r < 1e-8)        
+          return;
+        
+        CreateChilds();
+
+        for (auto [x,c] : charges)
+          AddCharge (x,c);
+        for (auto [x,d,c] : dipoles)
+          AddDipole (x,d,c);
+        for (auto [sp,ep,j,num] : currents)
+          AddCurrent (sp,ep,j,num);
+
+        charges.SetSize0();
+        dipoles.SetSize0();
+        currents.SetSize0();
+      }
+
+
+      
       
-      Complex Evaluate(Vec<3> p) const
+      entry_type Evaluate(Vec<3> p) const
       {
-        Complex sum = 0;
+        entry_type sum{0.0};
         if (childs[0])
           {
             for (auto & child : childs)
@@ -471,17 +590,63 @@ namespace ngfem
 
         for (auto [x,c] : charges)
           if (double rho = L2Norm(p-x); rho > 0)
-            sum += c*(1/(4*M_PI))*exp(Complex(0,rho*mp.Kappa())) / rho;
+            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)
             {
               Vec<3> drhodp = 1.0/rho * (p-x);
-              Complex dGdrho = c*(1/(4*M_PI))*exp(Complex(0,rho*mp.Kappa())) *
+              Complex dGdrho = (1/(4*M_PI))*exp(Complex(0,rho*mp.Kappa())) *
                 (Complex(0, mp.Kappa())/rho - 1.0/sqr(rho));
-              sum += dGdrho * InnerProduct(drhodp, d);
+              sum += dGdrho * InnerProduct(drhodp, d) * c;
             }
 
+        for (auto [sp,ep,j,num] : currents)
+          {
+            // should use explizit formula instead ...
+            
+            Vec<3> tau = ep-sp;
+            Vec<3> tau_num = 1.0/num *  tau;
+            for (int i = 0; i < num; i++)
+              {
+                Vec<3> x = sp+(i+0.5)*tau_num;
+                
+                if (double rho = L2Norm(p-x); rho > 0)
+                  {
+                    Vec<3> drhodp = 1.0/rho * (p-x);
+                    Complex dGdrho = (1/(4*M_PI))*exp(Complex(0,rho*mp.Kappa())) *
+                      (Complex(0, mp.Kappa())/rho - 1.0/sqr(rho));
+
+                    if constexpr (std::is_same<entry_type, Vec<3,Complex>>())
+                      sum += j*dGdrho * Cross(drhodp, tau_num);
+                  }
+              }
+          }
+        
+        return sum;
+      }
+
+      entry_type EvaluateDeriv(Vec<3> p, Vec<3> d) const
+      {
+        entry_type sum{0.0};
+        if (childs[0])
+        {
+            for (auto & child : childs)
+              sum += child->EvaluateDeriv(p, d);
+            return sum;
+        }
+
+        if (dipoles.Size())
+            throw Exception("EvaluateDeriv not implemented for dipoles in SingularMLMultiPole");
+
+        for (auto [x,c] : charges)
+          if (double rho = L2Norm(p-x); rho > 0)
+          {
+            Vec<3> drhodp = 1.0/rho * (p-x);
+            Complex dGdrho = (1/(4*M_PI))*exp(Complex(0,rho*mp.Kappa())) *
+            (Complex(0, mp.Kappa())/rho - 1.0/sqr(rho));
+            sum += dGdrho * InnerProduct(drhodp, d) * c;
+          }
         return sum;
       }
 
@@ -516,9 +681,9 @@ namespace ngfem
           }
         else
           {
-            if (charges.Size()+dipoles.Size() == 0)
+            if (charges.Size()+dipoles.Size()+currents.Size() == 0)
               {
-                mp = MultiPole<MPSingular> (-1, mp.Kappa());
+                mp = MultiPole<MPSingular,entry_type> (-1, mp.Kappa(), 1.);
                 return;
               }
 
@@ -527,10 +692,13 @@ namespace ngfem
             
             for (auto [x,d,c] : dipoles)
               mp.AddDipole (x-center, d, c);
+
+            for (auto [sp,ep,j,num] : currents)
+              mp.AddCurrent (sp-center, ep-center, j, num);
           }
       }
       
-      Complex EvaluateMP(Vec<3> p) const
+      entry_type EvaluateMP(Vec<3> p) const
       {
         if (charges.Size() || dipoles.Size())
           return Evaluate(p);
@@ -541,22 +709,43 @@ namespace ngfem
         if (!childs[0]) //  || level==1)
           return Evaluate(p);
           
-        Complex sum = 0.0;
+        entry_type sum{0.0};
         for (auto & child : childs)
           sum += child->EvaluateMP(p);
         return sum;
       }
-      
-      
-      void Print (ostream & ost) const
+
+      entry_type EvaluateMPDeriv(Vec<3> p, Vec<3> d) const
+      {
+        // cout << "EvaluateMPDeriv Singular, p = " << p << ", d = " << d << ", r = " << r << ", center = " << center <<  endl;
+        // cout << "Norm: " << L2Norm(p-center) << " > " << 3*r << endl;
+        // cout << "charges.Size() = " << charges.Size() << ", dipoles.Size() = " << dipoles.Size() << endl;
+        if (charges.Size() || dipoles.Size() || !childs[0])
+          return EvaluateDeriv(p, d);
+
+        if (L2Norm(p-center) > 3*r)
+          return mp.EvalDirectionalDerivative(p-center, d);
+
+        entry_type sum{0.0};
+        for (auto & child : childs)
+          sum += child->EvaluateMPDeriv(p, d);
+        return sum;
+      }
+
+      void Print (ostream & ost, size_t childnr = -1) const
       {
-        ost << "c = " << center << ", r = " << r << endl;
+        if (childnr == -1)
+          ost << "c = " << center << ", r = " << r << ", level = " << level << endl;
+        else
+          ost << "c = " << center << ", r = " << r << ", level = " << level << ", childnr = " << childnr << endl;
         // for (int i = 0; i < loc_pnts.Size(); i++)
         for (auto [x,c] : charges)
           ost << "xi = " << x << ", ci = " << c << endl;
+        for (auto [x,d,c] : dipoles)
+          ost << "xi = " << x << ", di = " << d << ", ci = " << c << endl;
 
         for (int i = 0; i < 8; i++)
-          if (childs[i]) childs[i] -> Print (ost);
+          if (childs[i]) childs[i] -> Print (ost, i);
       }
 
       double Norm () const
@@ -591,16 +780,41 @@ namespace ngfem
 
     double Kappa() const { return root.mp.Kappa(); }
     
-    void AddCharge(Vec<3> x, Complex c)
+    void AddCharge(Vec<3> x, entry_type c)
     {
       root.AddCharge(x, c);
     }
 
-    void AddDipole(Vec<3> x, Vec<3> d, Complex c)
+    void AddDipole(Vec<3> x, Vec<3> d, entry_type c)
     {
       root.AddDipole(x, d, c);
     }
 
+    void AddCurrent (Vec<3> sp, Vec<3> ep, Complex j, int num)
+    {
+      if constexpr (!std::is_same<entry_type, Vec<3,Complex>>())
+        throw Exception("AddCurrent needs a singular vectorial MP");
+      
+      root.AddCurrent (sp, ep, j, num);
+      /*
+         // for testing
+      Vec<3> tau = ep-sp;
+      Vec<3> tau_num = 1.0/num *  tau;
+      for (int i = 0; i < num; i++)
+        {
+          for (int k = 0; k < 3; k++)
+            {
+              Vec<3> ek{0.0}; ek(k) = 1;
+              Vec<3> cp = Cross(tau, ek);
+              Vec<3,Complex> source{0.0};
+              source(k) = j/double(num);
+              if constexpr (std::is_same<entry_type, Vec<3,Complex>>())
+                root.AddDipole (sp+(i+0.5)*tau_num, cp, source);
+            }
+        }
+      */
+    }
+
     void Print (ostream & ost) const
     {
       root.Print(ost);
@@ -634,7 +848,7 @@ namespace ngfem
       havemp = true;
     }
 
-    Complex Evaluate (Vec<3> p) const
+    entry_type Evaluate (Vec<3> p) const
     {
       if (havemp)
         return root.EvaluateMP(p);
@@ -642,17 +856,20 @@ namespace ngfem
         return root.Evaluate(p);
     }
 
+    template <typename entry_type2>
     friend class RegularMLMultiPole;
   };
 
 
-  inline ostream & operator<< (ostream & ost, const SingularMLMultiPole & mlmp)
+  template <typename entry_type>
+  inline ostream & operator<< (ostream & ost, const SingularMLMultiPole<entry_type> & mlmp)
   {
     mlmp.Print(ost);
     return ost;
   }
 
 
+  template <typename elem_type=Complex>
   class NGS_DLL_HEADER RegularMLMultiPole
   {
     static Array<size_t> nodes_on_level;
@@ -663,11 +880,11 @@ namespace ngfem
       double r;
       int level;
       std::array<unique_ptr<Node>,8> childs;
-      MultiPole<MPRegular> mp;
+      MultiPole<MPRegular,elem_type> mp;
       Array<Vec<3>> targets;
       int total_targets;
 
-      Array<const SingularMLMultiPole::Node*> singnodes;
+      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))
@@ -692,7 +909,7 @@ namespace ngfem
           }
       }
 
-      void AddSingularNode (const SingularMLMultiPole::Node & singnode, bool allow_refine)
+      void AddSingularNode (const typename SingularMLMultiPole<elem_type>::Node & singnode, bool allow_refine)
       {
         if (mp.SH().Order() < 0) return;
         if (singnode.mp.SH().Order() < 0) return;
@@ -781,15 +998,15 @@ namespace ngfem
                   mp.TransformAdd (ch->mp, ch->center-center);
                 ch->LocalizeExpansion(allow_refine);
               }
-            mp = MultiPole<MPRegular>(-1, mp.Kappa());
+            mp = MultiPole<MPRegular,elem_type>(-1, mp.Kappa(), 1.);
             //mp.SH().Coefs()=0.0;
           }
       }
       
-      Complex Evaluate (Vec<3> p) const
+      elem_type Evaluate (Vec<3> p) const
       {
         // *testout << "eval p = " << p << ", level = " << level << ", center = " << center <<  ", r = " << r << endl;
-        Complex sum = 0.0;
+        elem_type sum{0.0};
         /*
         if (childs[0])
           {
@@ -817,6 +1034,28 @@ namespace ngfem
         return sum;
       }
 
+      elem_type EvaluateDirectionalDerivative (Vec<3> p, Vec<3> d) const
+      {
+        elem_type sum{0.0};
+        // cout << "EvaluateDirectionalDerivative RegularMLMP, r = " << r << ", level = " << level << ", center = " << center << endl;
+        // cout << "Singnodes: " << singnodes.Size() << ", childs: " << childs[0] << endl;
+
+        int childnum = 0;
+        if (p(0) > center(0)) childnum += 1;
+        if (p(1) > center(1)) childnum += 2;
+        if (p(2) > center(2)) childnum += 4;
+        if (childs[childnum])
+          sum = childs[childnum]->EvaluateDirectionalDerivative(p, d);
+        else
+          sum = mp.EvalDirectionalDerivative(p-center, d);
+
+        static Timer t("mptool direct evaluate deriv"); RegionTimer r(t);
+        for (auto sn : singnodes)
+          sum += sn->EvaluateMPDeriv(p, d);
+
+        return sum;
+      }
+
       double Norm() const
       {
         double norm = L2Norm(mp.SH().Coefs());
@@ -883,16 +1122,30 @@ namespace ngfem
             }
 
         if (total_targets == 0)
-          mp = MultiPole<MPRegular>(-1, mp.Kappa());
+          mp = MultiPole<MPRegular,elem_type>(-1, mp.Kappa(),1.);
       }
       
+
+      void Print (ostream & ost, size_t childnr = -1) const
+      {
+        if (childnr == -1)
+          ost << "c = " << center << ", r = " << r << ", level = " << level << endl;
+        else
+          ost << "c = " << center << ", r = " << r << ", level = " << level << ", childnr = " << childnr << endl;
+        for (auto x : targets)
+          ost << "xi = " << x << endl;
+
+        for (int i = 0; i < 8; i++)
+          if (childs[i]) childs[i] -> Print (ost, i);
+      }
+
     };
     
     Node root;
-    shared_ptr<SingularMLMultiPole> singmp;
+    shared_ptr<SingularMLMultiPole<elem_type>> singmp;
     
   public:
-    RegularMLMultiPole (shared_ptr<SingularMLMultiPole> asingmp, Vec<3> center, double r, int order)
+  RegularMLMultiPole (shared_ptr<SingularMLMultiPole<elem_type>> asingmp, Vec<3> center, double r, int order)
       : root(center, r, 0, order, asingmp->Kappa()), singmp(asingmp)
     {
       if (!singmp->havemp) throw Exception("first call Calc for singular MP");
@@ -934,7 +1187,7 @@ namespace ngfem
       root.AddTarget (t);
     }
 
-    void CalcMP(shared_ptr<SingularMLMultiPole> asingmp)
+    void CalcMP(shared_ptr<SingularMLMultiPole<elem_type>> asingmp)
     {
       singmp = asingmp;
 
@@ -955,6 +1208,11 @@ namespace ngfem
       root.LocalizeExpansion(false);
     }
 
+    void Print (ostream & ost) const
+    {
+      root.Print(ost);
+    }
+
     double Norm() const
     {
       return root.Norm();
@@ -965,21 +1223,26 @@ namespace ngfem
       return root.NumCoefficients();
     }
 
-    Complex Evaluate (Vec<3> p) const
+    elem_type Evaluate (Vec<3> p) const
     {
       // static Timer t("mptool Eval MLMP regular"); RegionTimer r(t);
-      if (L2Norm(p-root.center) > root.r) return 0.0;
+      if (L2Norm(p-root.center) > root.r) return elem_type{0.0};
       return root.Evaluate(p);
     }
 
-    
+    elem_type EvaluateDirectionalDerivative (Vec<3> p, Vec<3> d) const
+    {
+        if (L2Norm(p-root.center) > root.r) return elem_type{0.0};
+        return root.EvaluateDirectionalDerivative(p, d);
+    }
+
   };
-  
 
-  inline ostream & operator<< (ostream & ost, const RegularMLMultiPole & mlmp)
+  template <typename elem_type>
+  inline ostream & operator<< (ostream & ost, const RegularMLMultiPole<elem_type> & mlmp)
   {
-    // mlmp.Print(ost);
-    ost << "RegularMLMultiPole" << endl;
+    mlmp.Print(ost);
+    // ost << "RegularMLMultiPole" << endl;
     return ost;
   }
 
@@ -993,7 +1256,7 @@ namespace ngfem
   
   class SphericalHarmonicsCF : public CoefficientFunction
   {
-    SphericalHarmonics sh;
+    SphericalHarmonics<Complex> sh;
   public:
     SphericalHarmonicsCF (int order)
       : CoefficientFunction(1, true), sh(order) { }
@@ -1021,16 +1284,19 @@ namespace ngfem
 
 
 
-  template <typename RADIAL>
+  template <typename entry_type> class RegularMLMultiPoleCF;
+  
+
+  template <typename RADIAL, typename entry_type=Complex>
   class MultiPoleCF : public CoefficientFunction
   {
-    MultiPole<RADIAL> mp;
+    MultiPole<RADIAL, entry_type> mp;
     Vec<3> center;
   public:
     MultiPoleCF (int order, double kappa, Vec<3> acenter, double scale = 1)
-      : CoefficientFunction(1, true), mp(order, kappa, scale), center(acenter) { }
+      : CoefficientFunction(sizeof(entry_type)/sizeof(Complex), true), mp(order, kappa, scale), center(acenter) { }
 
-    Complex & Coef(int n, int m) { return mp.Coef(n,m); } 
+    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; }
@@ -1040,56 +1306,75 @@ namespace ngfem
 
     virtual void Evaluate (const BaseMappedIntegrationPoint & mip, FlatVector<Complex> values) const override
     {
-      values(0) = mp.Eval(mip.GetPoint()-center);
+      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> & target) { mp.ShiftZ(z, target); }
+    void ShiftZ (double z, MultiPole<TARGET, entry_type> & target) { mp.ShiftZ(z, target); }
 
     using CoefficientFunction::Transform;        
     template <typename TARGET>
-    void Transform (MultiPoleCF<TARGET> & 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> mlmp;
+    shared_ptr<SingularMLMultiPole<entry_type>> mlmp;
   public:
     SingularMLMultiPoleCF (Vec<3> center, double r, int order, double kappa)
-      : CoefficientFunction(1, true), mlmp{make_shared<SingularMLMultiPole>(center, r, order, 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());
+      // 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> MLMP() { return mlmp; }
+    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> mlmp;
+    shared_ptr<RegularMLMultiPole<entry_type>> mlmp;
   public:
-    RegularMLMultiPoleCF (shared_ptr<SingularMLMultiPoleCF> asingmp, Vec<3> center, double r, int order)
-      : CoefficientFunction(1, true), mlmp{make_shared<RegularMLMultiPole>(asingmp->MLMP(), center, r, order)} { } 
+    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());
+      // 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> MLMP() { return mlmp; }
+    shared_ptr<RegularMLMultiPole<entry_type>> MLMP() { return mlmp; }
   };