ngsolve 6.2.2505.post105.dev0__cp311-cp311-macosx_10_15_universal2.whl → 6.2.2506.post33.dev0__cp311-cp311-macosx_10_15_universal2.whl

netgen/include/mptools.hpp

@@ -303,7 +303,7 @@ namespace ngsbem
 
   
   // hn1 = jn+ i*yn
-  class MPSingular
+  class Singular
   {
   public:
     template <typename T>
@@ -329,7 +329,7 @@ namespace ngsbem
 
   
   // jn
-  class MPRegular
+  class Regular
   {
   public:
     template <typename T>
@@ -357,14 +357,14 @@ namespace ngsbem
 
 
   template <typename RADIAL, typename entry_type=Complex>
-  class NGS_DLL_HEADER MultiPole
+  class NGS_DLL_HEADER SphericalExpansion
   {
     SphericalHarmonics<entry_type> sh;
     double kappa;
     double rtyp;
   public:
 
-    MultiPole (int aorder, double akappa, double artyp) 
+    SphericalExpansion (int aorder, double akappa, double artyp) 
     : sh(aorder), kappa(akappa), rtyp(artyp) { }
 
   
@@ -376,15 +376,15 @@ namespace ngsbem
     double RTyp() const { return rtyp; }
     int Order() const { return sh.Order(); }
     
-    MultiPole Truncate(int neworder) const
+    SphericalExpansion Truncate(int neworder) const
     {
       if (neworder > sh.Order()) neworder=sh.Order();
-      MultiPole nmp(neworder, kappa, rtyp);
+      SphericalExpansion nmp(neworder, kappa, rtyp);
       nmp.sh.Coefs() = sh.Coefs().Range(sqr(neworder+1));
       return nmp;
     }
 
-    MultiPole & operator+= (const MultiPole & mp2)
+    SphericalExpansion & operator+= (const SphericalExpansion & mp2)
     {
       size_t commonsize = min(SH().Coefs().Size(), mp2.SH().Coefs().Size());
       SH().Coefs().Range(commonsize) += mp2.SH().Coefs().Range(commonsize);
@@ -395,27 +395,24 @@ namespace ngsbem
     entry_type EvalDirectionalDerivative (Vec<3> x, Vec<3> d) const;
 
     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)
+    void AddDipole (Vec<3> x, Vec<3> dir, entry_type c);
+    void AddChargeDipole (Vec<3> x, entry_type c, Vec<3> dir, entry_type c2)
     {
-      double fac = Scale()/newscale;
-      double prod = 1;
-      for (int n = 0; n <= sh.Order(); n++, prod*= fac)
-        sh.CoefsN(n) *= prod;
-      scale = newscale;
+      // TODO: add them at once
+      AddCharge (x, c);
+      AddDipole (x, dir, c2);
     }
-    */
+    
+    void AddPlaneWave (Vec<3> d, entry_type c);    
+    void AddCurrent (Vec<3> ap, Vec<3> ep, Complex j, int num=100);
+    
+
     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;
     }
     
@@ -434,7 +431,7 @@ namespace ngsbem
 
     
     template <typename TARGET>
-    void Transform (MultiPole<TARGET,entry_type> & target, Vec<3> dist) const
+    void Transform (SphericalExpansion<TARGET,entry_type> & target, Vec<3> dist) const
     {
       if (target.SH().Order() < 0) return;
       if (SH().Order() < 0)
@@ -449,8 +446,8 @@ namespace ngsbem
       auto [len, theta, phi] = SphericalCoordinates(dist);
         
       
-      // MultiPole<RADIAL,entry_type> tmp{*this};
-      MultiPole<RADIAL,entry_type> tmp(Order(), kappa, rtyp);
+      // SphericalExpansion<RADIAL,entry_type> tmp{*this};
+      SphericalExpansion<RADIAL,entry_type> tmp(Order(), kappa, rtyp);
       tmp.SH().Coefs() = SH().Coefs();
       
       tmp.SH().RotateZ(phi);
@@ -463,12 +460,12 @@ namespace ngsbem
     }
     
     template <typename TARGET>
-    void TransformAdd (MultiPole<TARGET,entry_type> & target, Vec<3> dist, bool atomic = false) const
+    void TransformAdd (SphericalExpansion<TARGET,entry_type> & target, Vec<3> dist, bool atomic = false) const
     {
       if (SH().Order() < 0) return;
       if (target.SH().Order() < 0) return;      
       
-      MultiPole<TARGET,entry_type> tmp{target};
+      SphericalExpansion<TARGET,entry_type> tmp{target};
       Transform(tmp, dist);
       if (!atomic)
         target.SH().Coefs() += tmp.SH().Coefs();
@@ -478,8 +475,20 @@ namespace ngsbem
     }
 
     template <typename TARGET>
-    void ShiftZ (double z, MultiPole<TARGET,entry_type> & target);
+    void ShiftZ (double z, SphericalExpansion<TARGET,entry_type> & target);
+
     
+    template <typename TARGET>
+    void In2Out (SphericalExpansion<TARGET,entry_type> & target, double r) const
+    {
+      Vector<Complex> rad(Order()+1);
+      Vector<Complex> radout(target.Order()+1);      
+      RADIAL::Eval(Order(), kappa, r, RTyp(), rad);
+      TARGET::Eval(target.Order(), kappa, r, target.RTyp(), radout);
+      target.SH().Coefs() = 0;
+      for (int j = 0; j <= std::min(Order(), target.Order()); j++)
+        target.SH().CoefsN(j) = rad(j)/radout(j) * SH().CoefsN(j);
+    }
   };
   
   
@@ -488,7 +497,8 @@ namespace ngsbem
 
   static constexpr int MPOrder (double rho_kappa)
   {
-    return max (20, int(2*rho_kappa));
+    // return max (20, int(2*rho_kappa));
+    return 20+int(2*rho_kappa);
   }
   static constexpr int maxdirect = 100;
 
@@ -506,22 +516,22 @@ namespace ngsbem
 
 
   template <typename entry_type=Complex>
-  class SingularMLMultiPole
+  class SingularMLExpansion
   {
     using simd_entry_type = decltype(MakeSimd(declval<std::array<entry_type,FMM_SW>>()));
     static Array<size_t> nodes_on_level;    
     
     struct RecordingSS
     {
-      const MultiPole<MPSingular,entry_type> * mp_source;
-      MultiPole<MPSingular,entry_type> * mp_target;
+      const SphericalExpansion<Singular,entry_type> * mp_source;
+      SphericalExpansion<Singular,entry_type> * mp_target;
       Vec<3> dist;
       double len, theta, phi;
       bool flipz;
     public:
       RecordingSS() = default;
-      RecordingSS (const MultiPole<MPSingular,entry_type> * amp_source,
-                   MultiPole<MPSingular,entry_type> * amp_target,
+      RecordingSS (const SphericalExpansion<Singular,entry_type> * amp_source,
+                   SphericalExpansion<Singular,entry_type> * amp_target,
                    Vec<3> adist)
         : mp_source(amp_source), mp_target(amp_target), dist(adist)
       {
@@ -579,8 +589,8 @@ namespace ngsbem
     static void ProcessVectorizedBatch(FlatArray<RecordingSS*> batch, double len, double theta) {
 
       // *testout << "Processing vectorized S->S batch of size " << batch.Size() << ", with N = " << N << ", vec_length = " << vec_length << ", len = " << len << ", theta = " << theta << endl;
-      MultiPole<MPSingular, Vec<N,Complex>> vec_source(batch[0]->mp_source->Order(), batch[0]->mp_source->Kappa(), batch[0]->mp_source->RTyp());
-      MultiPole<MPSingular, Vec<N,Complex>> vec_target(batch[0]->mp_target->Order(), batch[0]->mp_target->Kappa(), batch[0]->mp_target->RTyp());
+      SphericalExpansion<Singular, Vec<N,Complex>> vec_source(batch[0]->mp_source->Order(), batch[0]->mp_source->Kappa(), batch[0]->mp_source->RTyp());
+      SphericalExpansion<Singular, Vec<N,Complex>> vec_target(batch[0]->mp_target->Order(), batch[0]->mp_target->Kappa(), batch[0]->mp_target->RTyp());
 
       // Copy multipoles into vectorized multipole
       for (int i = 0; i < batch.Size(); i++)
@@ -617,15 +627,18 @@ namespace ngsbem
       double r;
       int level;
       std::array<unique_ptr<Node>,8> childs;
-      MultiPole<MPSingular, entry_type> mp;
+      SphericalExpansion<Singular, entry_type> mp;
 
       Array<tuple<Vec<3>, entry_type>> charges;
       Array<tuple<Vec<3>, Vec<3>, entry_type>> dipoles;
+      Array<tuple<Vec<3>, entry_type, Vec<3>, entry_type>> chargedipoles;
       Array<tuple<Vec<3>, Vec<3>, Complex,int>> currents;
 
       using simd_entry_type = decltype(MakeSimd(declval<std::array<entry_type,FMM_SW>>()));      
       Array<tuple<Vec<3,SIMD<double,FMM_SW>>, simd_entry_type>> simd_charges;
       Array<tuple<Vec<3,SIMD<double,FMM_SW>>, Vec<3,SIMD<double,FMM_SW>>, simd_entry_type>> simd_dipoles;
+      Array<tuple<Vec<3,SIMD<double,FMM_SW>>, simd_entry_type,
+                  Vec<3,SIMD<double,FMM_SW>>, simd_entry_type>> simd_chargedipoles;
       
       int total_sources;
       std::mutex node_mutex;
@@ -638,7 +651,15 @@ namespace ngsbem
           nodes_on_level[level]++;
       }
 
-
+      int GetChildNum (Vec<3> x) const
+      {
+        int childnum  = 0;
+        if (x(0) > center(0)) childnum += 1;
+        if (x(1) > center(1)) childnum += 2;
+        if (x(2) > center(2)) childnum += 4;
+        return childnum;
+      }
+      
       void CreateChilds()
       {
         if (childs[0]) throw Exception("have already childs");
@@ -654,15 +675,32 @@ namespace ngsbem
       }
       
 
+      void SendSourcesToChilds()
+      {
+        CreateChilds();
+
+        for (auto [x,c] : charges)
+          AddCharge (x,c);
+        for (auto [x,d,c] : dipoles)
+          AddDipole (x,d,c);
+        for (auto [x,c,d,c2] : chargedipoles)
+          AddChargeDipole (x,c,d,c2);
+        for (auto [sp,ep,j,num] : currents)
+          AddCurrent (sp,ep,j,num);
+        
+        charges.SetSize0();
+        dipoles.SetSize0();
+        chargedipoles.SetSize0();        
+        currents.SetSize0();
+      }
+
+      
       void AddCharge (Vec<3> x, entry_type c)
       {
         if (have_childs) // quick check without locking 
           {
             // directly send to childs:
-            int childnum  = 0;
-            if (x(0) > center(0)) childnum += 1;
-            if (x(1) > center(1)) childnum += 2;
-            if (x(2) > center(2)) childnum += 4;
+            int childnum = GetChildNum(x);
             childs[childnum] -> AddCharge(x, c);
             return;
           }
@@ -671,36 +709,19 @@ namespace ngsbem
 
         if (have_childs) // test again after locking 
           {
-            // directly send to childs:
-            int childnum  = 0;
-            if (x(0) > center(0)) childnum += 1;
-            if (x(1) > center(1)) childnum += 2;
-            if (x(2) > center(2)) childnum += 4;
+            int childnum  = GetChildNum(x);
             childs[childnum] -> AddCharge(x, c);
             return;
           }
 
-
-        
         charges.Append( tuple{x,c} );
 
         // if (r*mp.Kappa() < 1e-8) return;
         if (level > 20) return;
         if (charges.Size() < maxdirect && r*mp.Kappa() < 1)
           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();
+        SendSourcesToChilds();
       }
 
 
@@ -709,11 +730,7 @@ namespace ngsbem
         if (have_childs)
           {
             // directly send to childs:
-
-            int childnum  = 0;
-            if (x(0) > center(0)) childnum += 1;
-            if (x(1) > center(1)) childnum += 2;
-            if (x(2) > center(2)) childnum += 4;
+            int childnum = GetChildNum(x);
             childs[childnum] -> AddDipole(x, d, c);
             return;
           }
@@ -723,37 +740,54 @@ namespace ngsbem
         if (have_childs)
           {
             // directly send to childs:
-
-            int childnum  = 0;
-            if (x(0) > center(0)) childnum += 1;
-            if (x(1) > center(1)) childnum += 2;
-            if (x(2) > center(2)) childnum += 4;
+            int childnum = GetChildNum(x);
             childs[childnum] -> AddDipole(x, d, c);
             return;
           }
-
-
-
         
         dipoles.Append (tuple{x,d,c});
 
         if (dipoles.Size() < maxdirect || r < 1e-8)
           return;
+
+        SendSourcesToChilds();
+      }
+
+
+      void AddChargeDipole (Vec<3> x, entry_type c, Vec<3> dir, entry_type c2)
+      {
+        if (have_childs)
+          {
+            // directly send to childs:
+            int childnum = GetChildNum(x);
+            childs[childnum] -> AddChargeDipole(x, c, dir, c2);
+            return;
+          }
+
+        lock_guard<mutex> guard(node_mutex);
+
+        if (have_childs)
+          {
+            // directly send to childs:
+            int childnum = GetChildNum(x);
+            childs[childnum] -> AddChargeDipole(x, c, dir, c2);
+            return;
+          }
         
-        CreateChilds();
+        chargedipoles.Append (tuple{x,c,dir,c2});
 
-        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);
+        if (chargedipoles.Size() < maxdirect || r < 1e-8)
+          return;
 
-        charges.SetSize0();
-        dipoles.SetSize0();        
-        currents.SetSize0();        
+        SendSourcesToChilds();
+
+        /*
+        AddCharge (x, c);
+        AddDipole (x, dir, c2);
+        */
       }
 
+      
       // not parallel yet
       void AddCurrent (Vec<3> sp, Vec<3> ep, Complex j, int num)
       {
@@ -787,6 +821,12 @@ namespace ngsbem
 
         currents.Append (tuple{sp,ep,j,num});
 
+        // if (currents.Size() < maxdirect || r < 1e-8)
+        if (currents.Size() < 4 || r < 1e-8)        
+          return;
+
+        SendSourcesToChilds();
+        /*
         // if (currents.Size() < maxdirect || r < 1e-8)
         if (currents.Size() < 4 || r < 1e-8)        
           return;
@@ -803,6 +843,7 @@ namespace ngsbem
         charges.SetSize0();
         dipoles.SetSize0();
         currents.SetSize0();
+        */
       }
 
 
@@ -823,7 +864,20 @@ namespace ngsbem
           // t.AddFlops (charges.Size());
         if (simd_charges.Size())
           {
+            // static Timer t("mptool singmp, evaluate, simd charges"); RegionTimer r(t);
+            
             simd_entry_type vsum{0.0};
+            if (mp.Kappa() < 1e-12)
+              {
+                for (auto [x,c] : simd_charges)
+                  {
+                    auto rho2 = L2Norm2(p-x);
+                    auto kernel = (1/(4*M_PI)) * rsqrt(rho2);
+                    kernel = If(rho2 > 0.0, kernel, SIMD<double,FMM_SW>(0.0));
+                    vsum += kernel * c;
+                  }
+              }
+            else
             if (mp.Kappa() < 1e-8)
               for (auto [x,c] : simd_charges)
                 {
@@ -861,6 +915,8 @@ namespace ngsbem
 
         if (simd_dipoles.Size())
         {
+          // static Timer t("mptool singmp, evaluate, simd dipoles"); RegionTimer r(t);
+          
           simd_entry_type vsum{0.0};
           for (auto [x,d,c] : simd_dipoles)
           {
@@ -887,6 +943,52 @@ namespace ngsbem
           }
         }
 
+
+        
+        if (simd_chargedipoles.Size())
+        {
+          // static Timer t("mptool singmp, evaluate, simd chargedipoles"); RegionTimer r(t);
+          
+          simd_entry_type vsum{0.0};
+          for (auto [x,c,d,c2] : simd_chargedipoles)
+            {
+              auto rho = L2Norm(p-x);
+              auto rhokappa = rho*mp.Kappa();
+              auto invrho = If(rho>0.0, 1.0/rho, SIMD<double,FMM_SW>(0.0));
+              auto [si,co] = sincos(rhokappa);
+
+              auto kernelc = (1/(4*M_PI))*invrho*SIMD<Complex,FMM_SW>(co,si);
+              vsum += kernelc * c;   
+
+              auto kernel = 
+                invrho*invrho * InnerProduct(p-x, d) * 
+                kernelc * SIMD<Complex,FMM_SW>(-1.0, rhokappa);
+              
+              vsum += kernel * c2;
+            }
+          sum += HSum(vsum);
+        }
+        else
+        {
+          // static Timer t("mptool singmp, evaluate, chargedipoles"); RegionTimer r(t);
+          
+          for (auto [x,c,d,c2] : chargedipoles)
+            if (double rho = L2Norm(p-x); rho > 0)
+              {
+                sum += (1/(4*M_PI))*exp(Complex(0,rho*mp.Kappa())) / rho * c;
+                  
+                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) * c2;
+              }
+        }
+
+
+
+
+        
         for (auto [sp,ep,j,num] : currents)
           {
             // should use explizit formula instead ...
@@ -923,7 +1025,9 @@ namespace ngsbem
         }
 
         if (dipoles.Size())
-            throw Exception("EvaluateDeriv not implemented for dipoles in SingularMLMultiPole");
+            throw Exception("EvaluateDeriv not implemented for dipoles in SingularMLExpansion");
+        if (chargedipoles.Size())
+            throw Exception("EvaluateDeriv not implemented for dipoles in SingularMLExpansion");
 
         for (auto [x,c] : charges)
           if (double rho = L2Norm(p-x); rho > 0)
@@ -938,7 +1042,7 @@ namespace ngsbem
 
       void CalcTotalSources()
       {
-        total_sources = charges.Size() + dipoles.Size();
+        total_sources = charges.Size() + dipoles.Size() + chargedipoles.Size();
         for (auto & child : childs)
           if (child)
             {
@@ -971,9 +1075,9 @@ namespace ngsbem
           }
         else
           {
-            if (charges.Size()+dipoles.Size()+currents.Size() == 0)
+            if (charges.Size()+dipoles.Size()+chargedipoles.Size()+currents.Size() == 0)
               {
-                mp = MultiPole<MPSingular,entry_type> (-1, mp.Kappa(), 1.);
+                mp = SphericalExpansion<Singular,entry_type> (-1, mp.Kappa(), 1.);
                 return;
               }
 
@@ -1012,6 +1116,26 @@ namespace ngsbem
                 simd_dipoles[ii] = MakeSimd(di);
               }
 
+
+            simd_chargedipoles.SetSize( (chargedipoles.Size()+FMM_SW-1)/FMM_SW);
+            i = 0, ii = 0;
+            for ( ; i+FMM_SW <= chargedipoles.Size(); i+=FMM_SW, ii++)
+              {
+                std::array<tuple<Vec<3>,entry_type,Vec<3>,entry_type>, FMM_SW> di;
+                for (int j = 0; j < FMM_SW; j++) di[j] = chargedipoles[i+j];
+                simd_chargedipoles[ii] = MakeSimd(di);
+              }
+            if (i < chargedipoles.Size())
+              {
+                std::array<tuple<Vec<3>,entry_type,Vec<3>,entry_type>, FMM_SW> di;
+                int j = 0;
+                for ( ; i+j < chargedipoles.Size(); j++) di[j] = chargedipoles[i+j];
+                for ( ; j < FMM_SW; j++) di[j] = tuple( get<0>(di[0]), entry_type{0.0}, get<2>(di[0]), entry_type{0.0} );
+                simd_chargedipoles[ii] = MakeSimd(di);
+              }
+
+
+
             
             if (nodes_to_process)
                 *nodes_to_process += this;
@@ -1022,6 +1146,9 @@ namespace ngsbem
               for (auto [x,d,c] : dipoles)
                 mp.AddDipole (x-center, d, c);
 
+              for (auto [x,c,d,c2] : chargedipoles)
+                mp.AddChargeDipole (x-center, c, d, c2);
+              
               for (auto [sp,ep,j,num] : currents)
                 mp.AddCurrent (sp-center, ep-center, j, num);
             }
@@ -1030,7 +1157,7 @@ namespace ngsbem
       
       entry_type EvaluateMP(Vec<3> p) const
       {
-        if (charges.Size() || dipoles.Size())
+        if (charges.Size() || dipoles.Size() || chargedipoles.Size())
           return Evaluate(p);
         
         if (L2Norm(p-center) > 3*r)
@@ -1050,7 +1177,7 @@ namespace ngsbem
         // 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])
+        if (charges.Size() || dipoles.Size() || chargedipoles.Size() || !childs[0])
           return EvaluateDeriv(p, d);
 
         if (L2Norm(p-center) > 3*r)
@@ -1073,6 +1200,8 @@ namespace ngsbem
           ost << "xi = " << x << ", ci = " << c << endl;
         for (auto [x,d,c] : dipoles)
           ost << "xi = " << x << ", di = " << d << ", ci = " << c << endl;
+        for (auto [x,c,d,c2] : chargedipoles)
+          ost << "xi = " << x << ", c = " << c << ", di = " << d << ", ci = " << c2 << endl;
 
         for (int i = 0; i < 8; i++)
           if (childs[i]) childs[i] -> Print (ost, i);
@@ -1101,7 +1230,7 @@ namespace ngsbem
     bool havemp = false;
     
   public:
-    SingularMLMultiPole (Vec<3> center, double r, double kappa)
+    SingularMLExpansion (Vec<3> center, double r, double kappa)
       : root(center, r, 0, kappa)
     {
       nodes_on_level = 0;
@@ -1120,6 +1249,11 @@ namespace ngsbem
       root.AddDipole(x, d, c);
     }
 
+    void AddChargeDipole(Vec<3> x, entry_type c, Vec<3> dir, entry_type c2)
+    {
+      root.AddChargeDipole(x, c, dir, c2);
+    }
+    
     void AddCurrent (Vec<3> sp, Vec<3> ep, Complex j, int num)
     {
       if constexpr (!std::is_same<entry_type, Vec<3,Complex>>())
@@ -1201,6 +1335,8 @@ namespace ngsbem
             node->mp.AddCharge(x-node->center, c);
           for (auto [x,d,c]: node->dipoles)
             node->mp.AddDipole(x-node->center, d, c);
+          for (auto [x,c,d,c2]: node->chargedipoles)
+            node->mp.AddChargeDipole(x-node->center, c, d, c2);
           for (auto [sp,ep,j,num]: node->currents)
             node->mp.AddCurrent(sp-node->center, ep-node->center, j, num);
         }, TasksPerThread(4));
@@ -1272,12 +1408,12 @@ namespace ngsbem
     }
 
     template <typename entry_type2>
-    friend class RegularMLMultiPole;
+    friend class RegularMLExpansion;
   };
 
 
   template <typename entry_type>
-  inline ostream & operator<< (ostream & ost, const SingularMLMultiPole<entry_type> & mlmp)
+  inline ostream & operator<< (ostream & ost, const SingularMLExpansion<entry_type> & mlmp)
   {
     mlmp.Print(ost);
     return ost;
@@ -1285,21 +1421,21 @@ namespace ngsbem
 
 
   template <typename elem_type=Complex>
-  class NGS_DLL_HEADER RegularMLMultiPole
+  class NGS_DLL_HEADER RegularMLExpansion
   {
     static Array<size_t> nodes_on_level;
 
     
     struct RecordingRS
     {
-      const MultiPole<MPSingular,elem_type> * mpS;
-      MultiPole<MPRegular,elem_type> * mpR;
+      const SphericalExpansion<Singular,elem_type> * mpS;
+      SphericalExpansion<Regular,elem_type> * mpR;
       Vec<3> dist;
       double len, theta, phi;
     public:
       RecordingRS() = default;
-      RecordingRS (const MultiPole<MPSingular,elem_type> * ampS,
-                   MultiPole<MPRegular,elem_type> * ampR,
+      RecordingRS (const SphericalExpansion<Singular,elem_type> * ampS,
+                   SphericalExpansion<Regular,elem_type> * ampR,
                    Vec<3> adist)
         : mpS(ampS), mpR(ampR), dist(adist)
       {
@@ -1381,10 +1517,10 @@ namespace ngsbem
       // static Timer tfrombatch("mptools - copy from batch 2");      
       
       // *testout << "Processing vectorized batch of size " << batch.Size() << ", with N = " << N << ", vec_length = " << vec_length << ", len = " << len << ", theta = " << theta << endl;
-      MultiPole<MPSingular, Vec<N,Complex>> vec_source(batch[0]->mpS->Order(), batch[0]->mpS->Kappa(), batch[0]->mpS->RTyp());
-      // MultiPole<MPSingular, elem_type> tmp_source{*batch[0]->mpS};
-      MultiPole<MPRegular, elem_type> tmp_target{*batch[0]->mpR};
-      MultiPole<MPRegular, Vec<N,Complex>> vec_target(batch[0]->mpR->Order(), batch[0]->mpR->Kappa(), batch[0]->mpR->RTyp());
+      SphericalExpansion<Singular, Vec<N,Complex>> vec_source(batch[0]->mpS->Order(), batch[0]->mpS->Kappa(), batch[0]->mpS->RTyp());
+      // SphericalExpansion<Singular, elem_type> tmp_source{*batch[0]->mpS};
+      SphericalExpansion<Regular, elem_type> tmp_target{*batch[0]->mpR};
+      SphericalExpansion<Regular, Vec<N,Complex>> vec_target(batch[0]->mpR->Order(), batch[0]->mpR->Kappa(), batch[0]->mpR->RTyp());
 
       // Copy multipoles into vectorized multipole
       // ttobatch.Start();
@@ -1432,13 +1568,13 @@ namespace ngsbem
       double r;
       int level;
       std::array<unique_ptr<Node>,8> childs;
-      MultiPole<MPRegular,elem_type> mp;
+      SphericalExpansion<Regular,elem_type> mp;
       Array<Vec<3>> targets;
       int total_targets;
       std::mutex node_mutex;
       atomic<bool> have_childs{false};
 
-      Array<const typename SingularMLMultiPole<elem_type>::Node*> singnodes;
+      Array<const typename SingularMLExpansion<elem_type>::Node*> singnodes;
 
       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))
@@ -1464,7 +1600,7 @@ namespace ngsbem
         have_childs = true;
       }
       
-      void AddSingularNode (const typename SingularMLMultiPole<elem_type>::Node & singnode, bool allow_refine,
+      void AddSingularNode (const typename SingularMLExpansion<elem_type>::Node & singnode, bool allow_refine,
                             Array<RecordingRS> * recording)
       {
         if (mp.SH().Order() < 0) return;
@@ -1546,7 +1682,7 @@ namespace ngsbem
       void LocalizeExpansion(bool allow_refine)
       {
         if (allow_refine)
-          if (mp.Order() > 20 && !childs[0])
+          if (mp.Order() > 30 && !childs[0])
             CreateChilds();
 
         if (childs[0])
@@ -1567,7 +1703,7 @@ namespace ngsbem
                   mp.TransformAdd (childs[nr]->mp, childs[nr]->center-center);
                 childs[nr]->LocalizeExpansion(allow_refine);
               });
-            mp = MultiPole<MPRegular,elem_type>(-1, mp.Kappa(), 1.);
+            mp = SphericalExpansion<Regular,elem_type>(-1, mp.Kappa(), 1.);
             //mp.SH().Coefs()=0.0;
           }
       }
@@ -1583,11 +1719,16 @@ namespace ngsbem
         if (childs[childnum])
           sum = childs[childnum]->Evaluate(p);
         else
-          sum = mp.Eval(p-center);
-
-        for (auto sn : singnodes)
-          sum += sn->EvaluateMP(p);
+          {
+            // static Timer t("mptool regmp, evaluate reg"); RegionTimer r(t);          
+            sum = mp.Eval(p-center);
+          }
 
+        {
+          // static Timer t("mptool regmp, evaluate, singnode"); RegionTimer r(t);
+          for (auto sn : singnodes)
+            sum += sn->EvaluateMP(p);
+        }
         return sum;
       }
 
@@ -1695,7 +1836,7 @@ namespace ngsbem
             }
 
         if (total_targets == 0)
-          mp = MultiPole<MPRegular,elem_type>(-1, mp.Kappa(),1.);
+          mp = SphericalExpansion<Regular,elem_type>(-1, mp.Kappa(),1.);
       }
       
 
@@ -1715,10 +1856,10 @@ namespace ngsbem
     };
     
     Node root;
-    shared_ptr<SingularMLMultiPole<elem_type>> singmp;
+    shared_ptr<SingularMLExpansion<elem_type>> singmp;
     
   public:
-  RegularMLMultiPole (shared_ptr<SingularMLMultiPole<elem_type>> asingmp, Vec<3> center, double r)
+  RegularMLExpansion (shared_ptr<SingularMLExpansion<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");
@@ -1748,7 +1889,7 @@ namespace ngsbem
       }
     }
 
-    RegularMLMultiPole (Vec<3> center, double r, double kappa)
+    RegularMLExpansion (Vec<3> center, double r, double kappa)
       : root(center, r, 0, kappa)
     {
       nodes_on_level = 0;
@@ -1760,7 +1901,7 @@ namespace ngsbem
       root.AddTarget (t);
     }
 
-    void CalcMP(shared_ptr<SingularMLMultiPole<elem_type>> asingmp)
+    void CalcMP(shared_ptr<SingularMLExpansion<elem_type>> asingmp, bool onlytargets = true)
     {
       static Timer t("mptool regular MLMP"); RegionTimer rg(t);
       static Timer trec("mptool regular MLMP - recording");
@@ -1769,15 +1910,17 @@ namespace ngsbem
       singmp = asingmp;
 
       root.CalcTotalTargets();
-      root.RemoveEmptyTrees();
+      if (onlytargets)
+        root.RemoveEmptyTrees();
 
       
-      // root.AddSingularNode(singmp->root, false, nullptr);
+      // root.AddSingularNode(singmp->root, !onlytargets, nullptr);
+
       // /*
       Array<RecordingRS> recording;
       {
         RegionTimer rrec(trec);
-        root.AddSingularNode(singmp->root, false, &recording);
+        root.AddSingularNode(singmp->root, !onlytargets, &recording);
       }
       
       // cout << "recorded: " << recording.Size() << endl;
@@ -1828,15 +1971,15 @@ namespace ngsbem
       
       /*
       int maxlevel = 0;
-      for (auto [i,num] : Enumerate(RegularMLMultiPole::nodes_on_level))
+      for (auto [i,num] : Enumerate(RegularMLExpansion::nodes_on_level))
         if (num > 0) maxlevel = i;
 
       for (int i = 0; i <= maxlevel; i++)
-        cout << "reg " << i << ": " << RegularMLMultiPole::nodes_on_level[i] << endl;
+        cout << "reg " << i << ": " << RegularMLExpansion::nodes_on_level[i] << endl;
       */
 
       static Timer tloc("mptool regular localize expansion"); RegionTimer rloc(tloc);
-      root.LocalizeExpansion(false);
+      root.LocalizeExpansion(!onlytargets);
     }
 
     void Print (ostream & ost) const
@@ -1857,7 +2000,9 @@ namespace ngsbem
     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 elem_type{0.0};
+      // if (L2Norm(p-root.center) > root.r) return elem_type{0.0};
+      if (MaxNorm(p-root.center) > root.r)
+        return singmp->Evaluate(p);
       return root.Evaluate(p);
     }
 
@@ -1871,10 +2016,10 @@ namespace ngsbem
 
 
   template <typename elem_type>
-  inline ostream & operator<< (ostream & ost, const RegularMLMultiPole<elem_type> & mlmp)
+  inline ostream & operator<< (ostream & ost, const RegularMLExpansion<elem_type> & mlmp)
   {
     mlmp.Print(ost);
-    // ost << "RegularMLMultiPole" << endl;
+    // ost << "RegularMLExpansion" << endl;
     return ost;
   }