ngsolve 6.2.2503__cp312-cp312-macosx_10_15_universal2.whl → 6.2.2504__cp312-cp312-macosx_10_15_universal2.whl

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/symbolicintegrator.hpp

@@ -604,6 +604,7 @@ public:
 
   class SymbolicFacetLinearFormIntegrator : public FacetLinearFormIntegrator
   {
+  protected:
     shared_ptr<CoefficientFunction> cf;
     Array<ProxyFunction*> proxies;
     Array<CoefficientFunction*> cache_cfs;

ngsolve/__init__.py

@@ -75,6 +75,7 @@ from .utils import x, y, z, dx, ds, grad, Grad, curl, div, Deviator, PyId, PyTra
 from . import solvers
 from . import preconditioners
 from . import timestepping
+from .solve_implementation import Solve
 
 try:
     from netgen.occ import unit_square, unit_cube

ngsolve/__init__.pyi

@@ -44,8 +44,8 @@ from ngsolve.comp import HDiv
 from ngsolve.comp import HDivDiv
 from ngsolve.comp import HDivDivSurface
 from ngsolve.comp import HDivSurface
-from ngsolve.comp import Hidden
 from ngsolve.comp import Hidden as PrivateSpace
+from ngsolve.comp import Hidden
 from ngsolve.comp import Integrate
 from ngsolve.comp import Interpolate
 from ngsolve.comp import L2
@@ -88,8 +88,8 @@ from ngsolve.fem import BSpline
 from ngsolve.fem import BlockBFI
 from ngsolve.fem import BlockLFI
 from ngsolve.fem import CacheCF
-from ngsolve.fem import CoefficientFunction
 from ngsolve.fem import CoefficientFunction as CF
+from ngsolve.fem import CoefficientFunction
 from ngsolve.fem import Cof
 from ngsolve.fem import CompoundBFI
 from ngsolve.fem import CompoundLFI
@@ -147,6 +147,7 @@ from ngsolve.la import QMRSolver
 from ngsolve.ngstd import IntRange
 from ngsolve.solve import Draw
 from ngsolve.solve import SetVisualization
+from ngsolve.solve_implementation.Application import Solve
 from ngsolve.timing import Timing
 from ngsolve.utils import Deviator
 from ngsolve.utils import Grad
@@ -185,11 +186,12 @@ from . import ngstd
 from . import nonlinearsolvers
 from . import preconditioners
 from . import solve
+from . import solve_implementation
 from . import solvers
 from . import timestepping
 from . import timing
 from . import utils
-__all__ = ['APhiHCurlAMG', 'ArnoldiSolver', 'BBBND', 'BBND', 'BFI', 'BND', 'BSpline', 'BaseMatrix', 'BaseVector', 'BilinearForm', 'BitArray', 'BlockBFI', 'BlockLFI', 'BlockMatrix', 'BlockVector', 'BoundaryFromVolumeCF', 'CELL', 'CF', 'CGSolver', 'COUPLING_TYPE', 'CacheCF', 'CoefficientFunction', 'Cof', 'CompoundBFI', 'CompoundLFI', 'Compress', 'CompressCompound', 'Conj', 'ConstEBEMatrix', 'ContactBoundary', 'ConvertOperator', 'CreateVVector', 'Cross', 'Det', 'Deviator', 'DiagonalMatrix', 'Discontinuous', 'Draw', 'EDGE', 'ELEMENT', 'ET', 'ElementId', 'Embedding', 'FACE', 'FACET', 'FESpace', 'FacetFESpace', 'FacetSurface', 'GMRESSolver', 'Grad', 'GridFunction', 'H1', 'H1LumpingFESpace', 'HCurl', 'HCurlAMG', 'HCurlCurl', 'HCurlDiv', 'HDiv', 'HDivDiv', 'HDivDivSurface', 'HDivSurface', 'HEX', 'Hidden', 'Id', 'IdentityMatrix', 'IfPos', 'InnerProduct', 'IntRange', 'Integrate', 'IntegrationRule', 'Interpolate', 'Inv', 'L2', 'LFI', 'LinearForm', 'Matrix', 'MatrixValued', 'Mesh', 'MultiGridPreconditioner', 'MultiVector', 'NodalFESpace', 'NodeId', 'Norm', 'NormalFacetFESpace', 'NormalFacetSurface', 'Normalize', 'NumberSpace', 'ORDER_POLICY', 'OuterProduct', 'PARALLEL_STATUS', 'POINT', 'PRISM', 'PYRAMID', 'PajeTrace', 'ParallelMatrix', 'Parameter', 'ParameterC', 'PatchwiseSolve', 'Periodic', 'PermutationMatrix', 'PlaceholderCF', 'PlateauFESpace', 'Preconditioner', 'PrivateSpace', 'ProductSpace', 'Projector', 'PyCof', 'PyCross', 'PyDet', 'PyId', 'PyInv', 'PySkew', 'PySym', 'PyTrace', 'QMRSolver', 'QUAD', 'Redraw', 'Region', 'SEGM', 'SetHeapSize', 'SetNumThreads', 'SetTestoutFile', 'SetVisualization', 'Skew', 'SurfaceL2', 'Sym', 'SymbolicBFI', 'SymbolicEnergy', 'SymbolicLFI', 'TET', 'TRIG', 'TangentialFacetFESpace', 'TangentialSurfaceL2', 'TaskManager', 'TimeFunction', 'Timer', 'Timers', 'Timing', 'Trace', 'VERTEX', 'VOL', 'VTKOutput', 'Variation', 'Vector', 'VectorFacetFESpace', 'VectorFacetSurface', 'VectorH1', 'VectorL2', 'VectorNodalFESpace', 'VectorSurfaceL2', 'VectorValued', 'VoxelCoefficient', 'ZeroCF', 'acos', 'asin', 'atan', 'atan2', 'atexit', 'bla', 'builtin_sum', 'bvp', 'ceil', 'comp', 'config', 'cos', 'cosh', 'curl', 'directsolvers', 'div', 'ds', 'dx', 'eigenvalues', 'erf', 'exp', 'fem', 'floor', 'grad', 'krylovspace', 'la', 'log', 'netgen', 'ngsglobals', 'ngslib', 'ngstd', 'nonlinearsolvers', 'os', 'pi', 'pml', 'pow', 'preconditioners', 'printonce', 'sin', 'sinh', 'solve', 'solvers', 'specialcf', 'sqrt', 'sum', 'sys', 'tan', 'timestepping', 'timing', 'unit_cube', 'unit_square', 'utils', 'x', 'y', 'z']
+__all__ = ['APhiHCurlAMG', 'ArnoldiSolver', 'BBBND', 'BBND', 'BFI', 'BND', 'BSpline', 'BaseMatrix', 'BaseVector', 'BilinearForm', 'BitArray', 'BlockBFI', 'BlockLFI', 'BlockMatrix', 'BlockVector', 'BoundaryFromVolumeCF', 'CELL', 'CF', 'CGSolver', 'COUPLING_TYPE', 'CacheCF', 'CoefficientFunction', 'Cof', 'CompoundBFI', 'CompoundLFI', 'Compress', 'CompressCompound', 'Conj', 'ConstEBEMatrix', 'ContactBoundary', 'ConvertOperator', 'CreateVVector', 'Cross', 'Det', 'Deviator', 'DiagonalMatrix', 'Discontinuous', 'Draw', 'EDGE', 'ELEMENT', 'ET', 'ElementId', 'Embedding', 'FACE', 'FACET', 'FESpace', 'FacetFESpace', 'FacetSurface', 'GMRESSolver', 'Grad', 'GridFunction', 'H1', 'H1LumpingFESpace', 'HCurl', 'HCurlAMG', 'HCurlCurl', 'HCurlDiv', 'HDiv', 'HDivDiv', 'HDivDivSurface', 'HDivSurface', 'HEX', 'Hidden', 'Id', 'IdentityMatrix', 'IfPos', 'InnerProduct', 'IntRange', 'Integrate', 'IntegrationRule', 'Interpolate', 'Inv', 'L2', 'LFI', 'LinearForm', 'Matrix', 'MatrixValued', 'Mesh', 'MultiGridPreconditioner', 'MultiVector', 'NodalFESpace', 'NodeId', 'Norm', 'NormalFacetFESpace', 'NormalFacetSurface', 'Normalize', 'NumberSpace', 'ORDER_POLICY', 'OuterProduct', 'PARALLEL_STATUS', 'POINT', 'PRISM', 'PYRAMID', 'PajeTrace', 'ParallelMatrix', 'Parameter', 'ParameterC', 'PatchwiseSolve', 'Periodic', 'PermutationMatrix', 'PlaceholderCF', 'PlateauFESpace', 'Preconditioner', 'PrivateSpace', 'ProductSpace', 'Projector', 'PyCof', 'PyCross', 'PyDet', 'PyId', 'PyInv', 'PySkew', 'PySym', 'PyTrace', 'QMRSolver', 'QUAD', 'Redraw', 'Region', 'SEGM', 'SetHeapSize', 'SetNumThreads', 'SetTestoutFile', 'SetVisualization', 'Skew', 'Solve', 'SurfaceL2', 'Sym', 'SymbolicBFI', 'SymbolicEnergy', 'SymbolicLFI', 'TET', 'TRIG', 'TangentialFacetFESpace', 'TangentialSurfaceL2', 'TaskManager', 'TimeFunction', 'Timer', 'Timers', 'Timing', 'Trace', 'VERTEX', 'VOL', 'VTKOutput', 'Variation', 'Vector', 'VectorFacetFESpace', 'VectorFacetSurface', 'VectorH1', 'VectorL2', 'VectorNodalFESpace', 'VectorSurfaceL2', 'VectorValued', 'VoxelCoefficient', 'ZeroCF', 'acos', 'asin', 'atan', 'atan2', 'atexit', 'bla', 'builtin_sum', 'bvp', 'ceil', 'comp', 'config', 'cos', 'cosh', 'curl', 'directsolvers', 'div', 'ds', 'dx', 'eigenvalues', 'erf', 'exp', 'fem', 'floor', 'grad', 'krylovspace', 'la', 'log', 'netgen', 'ngsglobals', 'ngslib', 'ngstd', 'nonlinearsolvers', 'os', 'pi', 'pml', 'pow', 'preconditioners', 'printonce', 'sin', 'sinh', 'solve', 'solve_implementation', 'solvers', 'specialcf', 'sqrt', 'sum', 'sys', 'tan', 'timestepping', 'timing', 'unit_cube', 'unit_square', 'utils', 'x', 'y', 'z']
 def _add_flags_doc(module):
     ...
 def _jupyter_nbextension_paths():
@@ -217,7 +219,7 @@ TET: fem.ET  # value = <ET.TET: 20>
 TRIG: fem.ET  # value = <ET.TRIG: 10>
 VERTEX: fem.NODE_TYPE  # value = <NODE_TYPE.VERTEX: 0>
 VOL: comp.VorB  # value = <VorB.VOL: 0>
-__version__: str = '6.2.2503'
+__version__: str = '6.2.2504'
 ds: comp.DifferentialSymbol  # value = <ngsolve.comp.DifferentialSymbol object>
 dx: comp.DifferentialSymbol  # value = <ngsolve.comp.DifferentialSymbol object>
 ngsglobals: comp.GlobalVariables  # value = <ngsolve.comp.GlobalVariables object>

ngsolve/bla.pyi

@@ -916,8 +916,12 @@ class Vec2D:
         """
         Return value at given position
         """
+    @typing.overload
     def __init__(self, arg0: float, arg1: float) -> None:
         ...
+    @typing.overload
+    def __init__(self, t: tuple) -> None:
+        ...
     def __mul__(self, value: float) -> Vec2D:
         ...
     def __neg__(self) -> Vec2D:
@@ -971,8 +975,12 @@ class Vec3D:
         """
         Return value at given position
         """
+    @typing.overload
     def __init__(self, arg0: float, arg1: float, arg2: float) -> None:
         ...
+    @typing.overload
+    def __init__(self, t: tuple) -> None:
+        ...
     def __mul__(self, value: float) -> Vec3D:
         ...
     def __neg__(self) -> Vec3D:

ngsolve/cmake/NGSolveConfig.cmake

@@ -1,4 +1,4 @@
-set(PACKAGE_VERSION "6.2.2503")
+set(PACKAGE_VERSION "6.2.2504")
 find_package(Netgen CONFIG REQUIRED HINTS
   ${CMAKE_CURRENT_LIST_DIR}
   ${CMAKE_CURRENT_LIST_DIR}/..