ngsolve 6.2.2502__cp313-cp313-manylinux_2_28_x86_64.whl → 6.2.2502.post11.dev1__cp313-cp313-manylinux_2_28_x86_64.whl

{ngsolve-6.2.2502.data → ngsolve-6.2.2502.post11.dev1.data}/data/include/netgen/fespace.hpp

@@ -256,7 +256,7 @@ ANY                  1 1 1 1 | 15
 
     virtual void UpdateDofTables() { ; } 
     virtual void UpdateCouplingDofArray() { ; } 
-
+    virtual void UpdateFreeDofs();
     /// update element coloring
     virtual void FinalizeUpdate();
 
@@ -640,7 +640,7 @@ ANY                  1 1 1 1 | 15
     /// Set multigrid prolongation
     // void SetProlongation (ngmg::Prolongation * aprol)
     // { prol = aprol; }
-    virtual void SetHarmonicProlongation (shared_ptr<BilinearForm> bfa);
+    virtual void SetHarmonicProlongation (shared_ptr<BilinearForm> bfa, string inverse);
 
     /// returns function-evaluator
     shared_ptr<DifferentialOperator> GetEvaluator (VorB vb = VOL) const
@@ -1109,6 +1109,7 @@ ANY                  1 1 1 1 | 15
 
     /// copies dofcoupling from components
     void UpdateCouplingDofArray() override;
+    virtual void UpdateFreeDofs() override;
     
     void SetDefinedOn (VorB vb, const BitArray& defon) override;
 

{ngsolve-6.2.2502.data → ngsolve-6.2.2502.post11.dev1.data}/data/include/netgen/mptools.hpp

@@ -10,6 +10,12 @@
 #include <coefficient.hpp>
 #include <recursive_pol.hpp>
 
+
+namespace ngcomp
+{
+  class Region;
+}
+
 namespace ngfem
 {
 
@@ -570,7 +576,7 @@ namespace ngfem
 
       entry_type EvaluateDeriv(Vec<3> p, Vec<3> d) const
       {
-        entry_type sum = 0;
+        entry_type sum{0.0};
         if (childs[0])
         {
             for (auto & child : childs)
@@ -727,7 +733,7 @@ namespace ngfem
       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);
     }
@@ -756,7 +762,7 @@ namespace ngfem
         }
       */
     }
-    
+
     void Print (ostream & ost) const
     {
       root.Print(ost);
@@ -1226,6 +1232,9 @@ namespace ngfem
 
 
 
+  template <typename entry_type> class RegularMLMultiPoleCF;
+  
+
   template <typename RADIAL, typename entry_type=Complex>
   class MultiPoleCF : public CoefficientFunction
   {
@@ -1285,7 +1294,8 @@ namespace ngfem
       
     }
     
-    shared_ptr<SingularMLMultiPole<entry_type>> MLMP() { return mlmp; }
+    shared_ptr<SingularMLMultiPole<entry_type>> MLMP() const { return mlmp; }
+    shared_ptr<RegularMLMultiPoleCF<entry_type>> CreateRegularExpansion(Vec<3> center, double r) const;
   };
   
 
@@ -1296,6 +1306,8 @@ namespace ngfem
   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"); }

ngsolve-6.2.2502.post11.dev1.data/data/include/netgen/potentialtools.hpp

@@ -0,0 +1,20 @@
+#ifndef FILE_POTENTIALS
+#define FILE_POTENTIALS
+
+/*
+  tools for computing with potentials using multipoles
+ */
+
+
+#include <mptools.hpp>
+#include <meshaccess.hpp>
+
+
+namespace ngcomp
+{
+  
+  extern void AddCurrentDensity (SingularMLMultiPole<Vec<3,Complex>> & mp, shared_ptr<CoefficientFunction> current, ngcomp::Region reg);
+ 
+}
+
+#endif

{ngsolve-6.2.2502.data → ngsolve-6.2.2502.post11.dev1.data}/data/include/netgen/prolongation.hpp

@@ -233,12 +233,14 @@ namespace ngmg
   class NGS_DLL_HEADER HarmonicProlongation : public Prolongation
   {
     shared_ptr<Prolongation> baseprol;
-    shared_ptr<BilinearForm> bfa;
+    weak_ptr<BilinearForm> wbfa;
     Array<shared_ptr<BaseMatrix>> innerinverses;
-    Array<size_t> edges_on_level;
+    Array<size_t> facets_on_level;
+    Array<shared_ptr<BitArray>> freedofs;
+    string inverse;
   public:
     HarmonicProlongation (shared_ptr<Prolongation> abaseprol,
-                          shared_ptr<BilinearForm> abfa);
+                          shared_ptr<BilinearForm> abfa, string ainverse);
 
     virtual void Update (const FESpace & fes) override;
     
@@ -248,6 +250,127 @@ namespace ngmg
     virtual void ProlongateInline (int finelevel, BaseVector & v) const override;
     virtual void RestrictInline (int finelevel, BaseVector & v) const override;
   };
+
+
+
+
+  
+  template <int DIM>
+  class FacetProlongation : public Prolongation
+  {
+  protected:
+    shared_ptr<MeshAccess> ma;
+    
+    int dofs_per_facet = -1;
+    Array<Array<int>> first_dofs;
+    Array<int> prol_class;  // which prol to use ?
+    Array<size_t> facets_on_level;
+
+    static constexpr int NUMPROL = (DIM==2) ? 2 : 32;
+    array<Matrix<double>,NUMPROL> facetprol;
+    
+    bool haveprols = false;
+    
+  public:
+    FacetProlongation (shared_ptr<MeshAccess> ama)
+      : ma(ama) { }
+
+
+    virtual shared_ptr<SparseMatrix< double >> CreateProlongationMatrix( int finelevel ) const override
+    {
+      return nullptr;  // or NULL ? 
+    }
+
+    
+    virtual void ProlongateInline (int finelevel, BaseVector & v) const override
+    {
+      auto fv = v.FV<double>();
+      Matrix<double> tmp(facets_on_level[finelevel], dofs_per_facet);
+      tmp = 0.0;
+      
+      for (size_t i = 0; i < first_dofs[finelevel-1].Size()-1; i++)
+        {
+          IntRange r(first_dofs[finelevel-1][i], first_dofs[finelevel-1][i+1]);
+          if (r.Size() > 0)
+            tmp.Row(i) = fv.Range(r);
+        }
+
+      if constexpr (DIM==2)
+        {
+          for (int i = facets_on_level[finelevel-1]; i < facets_on_level[finelevel]; i++)
+            if (auto parents = get<1>(ma->GetParentEdges(i)); parents[1] == -1)
+              {
+                int pe = parents[0];
+                tmp.Row(i) = facetprol[prol_class[i]] * tmp.Row(pe);
+              }
+        }
+      else
+        {
+          for (int i = facets_on_level[finelevel-1]; i < facets_on_level[finelevel]; i++)
+          if (auto parents = get<1>(ma->GetParentFaces(i)); parents[1] == -1)
+            {
+              int pe = parents[0];
+              tmp.Row(i) = facetprol[prol_class[i]] * tmp.Row(pe);
+            }
+        }
+      
+      for (size_t i = 0; i < first_dofs[finelevel].Size()-1; i++)
+        {
+          IntRange r(first_dofs[finelevel][i], first_dofs[finelevel][i+1]);
+          if (r.Size() > 0)
+            fv.Range(r) = tmp.Row(i);
+        }
+    }
+    
+    virtual void RestrictInline (int finelevel, BaseVector & v) const override
+    {
+      auto fv = v.FV<double>();
+      Matrix<double> tmp(facets_on_level[finelevel], dofs_per_facet);
+      tmp = 0.0;
+      
+      for (size_t i = 0; i < first_dofs[finelevel].Size()-1; i++)
+        {
+          IntRange r(first_dofs[finelevel][i], first_dofs[finelevel][i+1]);
+          if (r.Size() > 0)
+            tmp.Row(i) = fv.Range(r);
+        }
+
+
+      if constexpr (DIM==2)
+        {
+          for (int i = facets_on_level[finelevel-1]; i < facets_on_level[finelevel]; i++)
+            if (auto parents = get<1>(ma->GetParentEdges(i)); parents[1] == -1)
+              {
+                int pe = parents[0];
+                tmp.Row(pe) += Trans(facetprol[prol_class[i]]) * tmp.Row(i);
+              }
+        }
+      else
+        {
+          // for (int i = facets_on_level[finelevel-1]; i < facets_on_level[finelevel]; i++)
+          for (int i = facets_on_level[finelevel]-1; i >= facets_on_level[finelevel-1]; i--)      
+            if (auto parents = get<1>(ma->GetParentFaces(i)); parents[1] == -1)
+              {
+                int pe = parents[0];
+                tmp.Row(pe) += Trans(facetprol[prol_class[i]]) * tmp.Row(i);
+                tmp.Row(i) = 0.0;  // optional, for testing
+              }
+        }
+      
+      fv = 0.0;
+      for (size_t i = 0; i < first_dofs[finelevel-1].Size()-1; i++)
+        {
+          IntRange r(first_dofs[finelevel-1][i], first_dofs[finelevel-1][i+1]);
+          if (r.Size() > 0)
+            fv.Range(r) = tmp.Row(i);
+        }
+
+    }
+    
+  };
+  
+  
+  
 }
 
 

{ngsolve-6.2.2502.data → ngsolve-6.2.2502.post11.dev1.data}/data/include/netgen/sparsematrix_impl.hpp

@@ -51,28 +51,94 @@ namespace ngla
                  FlatArray<TM> val, size_t h, size_t w)
   {
     static Timer t("SparseMatrix::CreateFromCOO"); RegionTimer r(t);
-    Array<int> cnt(h);
+    static Timer t1("SparseMatrix::CreateFromCOO 1");
+    static Timer t2("SparseMatrix::CreateFromCOO 2");
+    static Timer t3("SparseMatrix::CreateFromCOO 3");
 
     /*
-    cnt = 0;
-    for (auto i : indi) cnt[i]++;
-    */
+    {
+    Array<int> cnt(h);
 
+    t1.Start();
     DynamicTable<int> tab(h);
     for (size_t i = 0; i < indi.Size(); i++)
       tab.AddUnique(indi[i], indj[i]);
+    t1.Stop();
     for (size_t i = 0; i < h; i++)
       cnt[i] = tab.EntrySize(i);
     
     auto matrix = make_shared<SparseMatrix<TM>> (cnt, w);
+    t2.Start();
     for (auto k : ngstd::Range(indi))
       matrix->CreatePosition(indi[k], indj[k]);
+    t2.Stop();
     matrix->SetZero();
 
+    t3.Start();
     for (auto k : ngstd::Range(indi))
       (*matrix)(indi[k], indj[k]) += val[k];
+    t3.Stop();
+    // return matrix;
+    }
+    */
+    
+    Array<int> cnt(h);
+    cnt = 0;
+    for (auto i : indi)
+      cnt[i]++;
+    
+    Table<int> tab(cnt);
+    cnt = 0;
+    
+    for (auto [i,j] : Zip(indi, indj))
+      tab[i][cnt[i]++] = j;
+
+    cnt = 0;
+    // for (int i = 0; i < tab.Size(); i++)
+    ParallelFor (tab.Size(), [&] (size_t i)
+      {
+        QuickSort (tab[i]);
+
+        int prev = -1;
+        for (auto j : tab[i])
+          {
+            if (j != prev) cnt[i]++;
+            prev = j;
+          }
+      });
+    
+    auto matrix = make_shared<SparseMatrix<TM>> (cnt, w);
+    t2.Start();
+    // for (auto k : ngstd::Range(indi))
+    // matrix->CreatePosition(indi[k], indj[k]);
 
-    return matrix;
+    cnt = 0;
+    for (int i = 0; i < tab.Size(); i++)
+      {
+        int prev = -1;
+        for (auto j : tab[i])
+          {
+            auto cols = matrix->GetRowIndices(i);
+            if (j != prev)
+              cols[cnt[i]++] = j;
+            prev = j;
+          }
+      }
+    
+    t2.Stop();
+    matrix->SetZero();
+
+    t3.Start();
+    /*
+    for (auto k : ngstd::Range(indi))
+      (*matrix)(indi[k], indj[k]) += val[k];
+    */
+    ParallelFor (indi.Size(), [&](size_t k)
+    {
+      AtomicAdd ( (*matrix)(indi[k], indj[k]),  val[k]);
+    });
+    t3.Stop();
+    return matrix;    
   }
   
 

{ngsolve-6.2.2502.data → ngsolve-6.2.2502.post11.dev1.data}/data/include/netgen/tangentialfacetfespace.hpp

@@ -16,34 +16,22 @@ namespace ngcomp
   class NGS_DLL_HEADER TangentialFacetFESpace : public FESpace
   {
   protected:
-    /// Level
-    // int level;
-    /// Number of Facets
-    // int nfacets;
-    /// 
-    // int ncfacets;
-    ///
-    // int nel;
-
     Array<int> first_facet_dof;
     Array<int> first_inner_dof;  // for highest_order_dc
-    // int ndof_lo;
 
     int rel_order;
 
     Array<IVec<2> > order_facet;
     Array<bool> fine_facet;
 
-    // int ndof;
-    // Array<int> ndlevel;
     bool var_order;
     bool print;
 
     bool highest_order_dc;
     bool hide_highest_order_dc;
+    bool all_dofs_together;
     
   public:
-    ///
     TangentialFacetFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, 
                             bool parseflags = false );
 
@@ -61,20 +49,11 @@ namespace ngcomp
     virtual void SetOrder (NodeId ni, int order) override;
     virtual int GetOrder (NodeId ni) const override;
 
-    
-    // virtual size_t GetNDof() const throw() override { return ndof; }
-    // virtual size_t GetNDofLevel ( int i ) const override { return ndlevel[i]; }
-
     virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
 
-    // virtual int GetNDofLowOrder () const
-    // { return ndof_lo; }
 
     virtual FiniteElement & GetFE(ElementId ei, Allocator & lh) const override;
     
-    // virtual const FiniteElement & GetFE ( int elnr, LocalHeap & lh ) const;
-    // virtual const FiniteElement & GetSFE ( int selnr, LocalHeap & lh ) const;
-
     virtual void GetFacetDofNrs (int felnr, Array<DofId> & dnums) const;
 
     virtual int GetNFacetDofs (int felnr) const;
@@ -90,6 +69,12 @@ namespace ngcomp
     virtual IVec<2> GetFacetOrder(int fnr) const;
 
     virtual int GetFirstFacetDof(int fanr) const;
+    const auto & GetFirstFacetDof() const { return first_facet_dof; }
+
+    IntRange GetFacetDofs (int nr) const
+    { 
+      return IntRange (first_facet_dof[nr], first_facet_dof[nr+1]); 
+    }
 
     virtual bool UsesHighestOrderDiscontinuous() const {return highest_order_dc;};
 

{ngsolve-6.2.2502.data → ngsolve-6.2.2502.post11.dev1.data}/data/lib/cmake/ngsolve/NGSolveConfig.cmake

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

ngsolve-6.2.2502.post11.dev1.data/data/lib/python3.13/site-packages/ngsolve/__init__.pyi

@@ -0,0 +1,234 @@
+"""
+
+NGSolve
+=======
+
+A high order finite element library
+
+Modules:
+ngsolve.bla .... simple vectors and matrices
+ngsolve.fem .... finite elements and integrators
+ngsolve.comp ... function spaces, forms
+"""
+from __future__ import annotations
+import atexit as atexit
+from builtins import sum as builtin_sum
+import ctypes as ctypes
+import importlib as importlib
+import netgen as netgen
+from netgen import Redraw
+from netgen import TimeFunction
+from ngsolve.bla import InnerProduct
+from ngsolve.bla import Matrix
+from ngsolve.bla import Norm
+from ngsolve.bla import Vector
+from ngsolve.comp import APhiHCurlAMG
+from ngsolve.comp import BilinearForm
+from ngsolve.comp import BoundaryFromVolumeCF
+from ngsolve.comp import COUPLING_TYPE
+from ngsolve.comp import Compress
+from ngsolve.comp import CompressCompound
+from ngsolve.comp import ContactBoundary
+from ngsolve.comp import ConvertOperator
+from ngsolve.comp import Discontinuous
+from ngsolve.comp import ElementId
+from ngsolve.comp import FESpace
+from ngsolve.comp import FacetFESpace
+from ngsolve.comp import FacetSurface
+from ngsolve.comp import GridFunction
+from ngsolve.comp import H1
+from ngsolve.comp import H1LumpingFESpace
+from ngsolve.comp import HCurl
+from ngsolve.comp import HCurlAMG
+from ngsolve.comp import HCurlCurl
+from ngsolve.comp import HCurlDiv
+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 Integrate
+from ngsolve.comp import Interpolate
+from ngsolve.comp import L2
+from ngsolve.comp import LinearForm
+from ngsolve.comp import MatrixValued
+from ngsolve.comp import Mesh
+from ngsolve.comp import MultiGridPreconditioner
+from ngsolve.comp import NodalFESpace
+from ngsolve.comp import NodeId
+from ngsolve.comp import NormalFacetFESpace
+from ngsolve.comp import NormalFacetSurface
+from ngsolve.comp import NumberSpace
+from ngsolve.comp import ORDER_POLICY
+from ngsolve.comp import PatchwiseSolve
+from ngsolve.comp import Periodic
+from ngsolve.comp import PlateauFESpace
+from ngsolve.comp import Preconditioner
+from ngsolve.comp import ProductSpace
+from ngsolve.comp import Region
+from ngsolve.comp import SetHeapSize
+from ngsolve.comp import SetTestoutFile
+from ngsolve.comp import SurfaceL2
+from ngsolve.comp import SymbolicBFI
+from ngsolve.comp import SymbolicEnergy
+from ngsolve.comp import SymbolicLFI
+from ngsolve.comp import TangentialFacetFESpace
+from ngsolve.comp import TangentialSurfaceL2
+from ngsolve.comp import VTKOutput
+from ngsolve.comp import Variation
+from ngsolve.comp import VectorFacetFESpace
+from ngsolve.comp import VectorFacetSurface
+from ngsolve.comp import VectorH1
+from ngsolve.comp import VectorL2
+from ngsolve.comp import VectorNodalFESpace
+from ngsolve.comp import VectorSurfaceL2
+from ngsolve.comp import VectorValued
+from ngsolve.comp import pml
+from ngsolve.fem import BFI
+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 as CF
+from ngsolve.fem import CoefficientFunction
+from ngsolve.fem import Cof
+from ngsolve.fem import CompoundBFI
+from ngsolve.fem import CompoundLFI
+from ngsolve.fem import Conj
+from ngsolve.fem import Cross
+from ngsolve.fem import Det
+from ngsolve.fem import ET
+from ngsolve.fem import Id
+from ngsolve.fem import IfPos
+from ngsolve.fem import IntegrationRule
+from ngsolve.fem import Inv
+from ngsolve.fem import LFI
+from ngsolve.fem import Parameter
+from ngsolve.fem import ParameterC
+from ngsolve.fem import PlaceholderCF
+from ngsolve.fem import Skew
+from ngsolve.fem import Sym
+from ngsolve.fem import Trace
+from ngsolve.fem import VoxelCoefficient
+from ngsolve.fem import Zero as ZeroCF
+from ngsolve.fem import acos
+from ngsolve.fem import asin
+from ngsolve.fem import atan
+from ngsolve.fem import atan2
+from ngsolve.fem import ceil
+from ngsolve.fem import cos
+from ngsolve.fem import cosh
+from ngsolve.fem import erf
+from ngsolve.fem import exp
+from ngsolve.fem import floor
+from ngsolve.fem import log
+from ngsolve.fem import pow
+from ngsolve.fem import sin
+from ngsolve.fem import sinh
+from ngsolve.fem import sqrt
+from ngsolve.fem import tan
+from ngsolve.la import ArnoldiSolver
+from ngsolve.la import BaseMatrix
+from ngsolve.la import BaseVector
+from ngsolve.la import BlockMatrix
+from ngsolve.la import BlockVector
+from ngsolve.la import CGSolver
+from ngsolve.la import ConstEBEMatrix
+from ngsolve.la import CreateVVector
+from ngsolve.la import DiagonalMatrix
+from ngsolve.la import Embedding
+from ngsolve.la import GMRESSolver
+from ngsolve.la import IdentityMatrix
+from ngsolve.la import MultiVector
+from ngsolve.la import PARALLEL_STATUS
+from ngsolve.la import ParallelMatrix
+from ngsolve.la import PermutationMatrix
+from ngsolve.la import Projector
+from ngsolve.la import QMRSolver
+from ngsolve.ngstd import IntRange
+from ngsolve.solve import Draw
+from ngsolve.solve import SetVisualization
+from ngsolve.timing import Timing
+from ngsolve.utils import Deviator
+from ngsolve.utils import Grad
+from ngsolve.utils import Normalize
+from ngsolve.utils import OuterProduct
+from ngsolve.utils import PyCof
+from ngsolve.utils import PyCross
+from ngsolve.utils import PyDet
+from ngsolve.utils import PyId
+from ngsolve.utils import PyInv
+from ngsolve.utils import PySkew
+from ngsolve.utils import PySym
+from ngsolve.utils import PyTrace
+from ngsolve.utils import curl
+from ngsolve.utils import div
+from ngsolve.utils import grad
+from ngsolve.utils import printonce
+import os as os
+from pyngcore.pyngcore import BitArray
+from pyngcore.pyngcore import PajeTrace
+from pyngcore.pyngcore import SetNumThreads
+from pyngcore.pyngcore import TaskManager
+from pyngcore.pyngcore import Timer
+from pyngcore.pyngcore import Timers
+import sys as sys
+from . import bla
+from . import bvp
+from . import comp
+from . import config
+from . import directsolvers
+from . import eigenvalues
+from . import fem
+from . import krylovspace
+from . import la
+from . import ngstd
+from . import nonlinearsolvers
+from . import preconditioners
+from . import solve
+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', 'ctypes', 'curl', 'directsolvers', 'div', 'ds', 'dx', 'eigenvalues', 'erf', 'exp', 'f', 'fem', 'floor', 'grad', 'importlib', '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']
+def _add_flags_doc(module):
+    ...
+def _jupyter_nbextension_paths():
+    ...
+def sum(iterable, start = None):
+    """
+    NGSolve sum function that uses the first element of an iterable as
+    start argument if no start argument is provided.
+    """
+BBBND: comp.VorB  # value = <VorB.BBBND: 3>
+BBND: comp.VorB  # value = <VorB.BBND: 2>
+BND: comp.VorB  # value = <VorB.BND: 1>
+CELL: fem.NODE_TYPE  # value = <NODE_TYPE.CELL: 3>
+EDGE: fem.NODE_TYPE  # value = <NODE_TYPE.EDGE: 1>
+ELEMENT: fem.NODE_TYPE  # value = <NODE_TYPE.ELEMENT: 4>
+FACE: fem.NODE_TYPE  # value = <NODE_TYPE.FACE: 2>
+FACET: fem.NODE_TYPE  # value = <NODE_TYPE.FACET: 5>
+HEX: fem.ET  # value = <ET.HEX: 24>
+POINT: fem.ET  # value = <ET.POINT: 0>
+PRISM: fem.ET  # value = <ET.PRISM: 22>
+PYRAMID: fem.ET  # value = <ET.PYRAMID: 21>
+QUAD: fem.ET  # value = <ET.QUAD: 11>
+SEGM: fem.ET  # value = <ET.SEGM: 1>
+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.2502-11-g4d6a78d51'
+ds: comp.DifferentialSymbol  # value = <ngsolve.comp.DifferentialSymbol object>
+dx: comp.DifferentialSymbol  # value = <ngsolve.comp.DifferentialSymbol object>
+f: importlib.metadata.PackagePath  # value = PackagePath('mkl-2023.2.0.dist-info/top_level.txt')
+ngsglobals: comp.GlobalVariables  # value = <ngsolve.comp.GlobalVariables object>
+pi: float = 3.141592653589793
+specialcf: fem.SpecialCFCreator  # value = <ngsolve.fem.SpecialCFCreator object>
+unit_cube: netgen.libngpy._NgOCC.OCCGeometry  # value = <netgen.libngpy._NgOCC.OCCGeometry object>
+unit_square: netgen.libngpy._NgOCC.OCCGeometry  # value = <netgen.libngpy._NgOCC.OCCGeometry object>
+x: fem.CoefficientFunction  # value = <ngsolve.fem.CoefficientFunction object>
+y: fem.CoefficientFunction  # value = <ngsolve.fem.CoefficientFunction object>
+z: fem.CoefficientFunction  # value = <ngsolve.fem.CoefficientFunction object>
+ngslib =