ngsolve 6.2.2405.post37.dev1__cp313-cp313-win_amd64.whl → 6.2.2405.post53.dev1__cp313-cp313-win_amd64.whl

netgen/include/expr.hpp

@@ -9,7 +9,7 @@
 
 #include <core/array.hpp>
 #include <core/localheap.hpp>
-// #include <core/exception.hpp>
+#include <core/exception.hpp>
 
 #include <ngs_stdcpp_include.hpp>  // for INLINE
 #include "complex_wrapper.hpp"
@@ -28,15 +28,18 @@ template <typename T>
 struct SafeIndex
 {
   T i;
-  SafeIndex(T ai) : i(ai) { };
-  operator T() const { return i; }
-  auto operator++() { return ++i; }
-  auto operator++(int) { return i++; }
+  INLINE SafeIndex(T ai) : i(ai) { };
+  INLINE operator T() const { return i; }
+  INLINE auto operator++() { return ++i; }
+  INLINE auto operator++(int) { return i++; }
 };
 
-template <typename T>
-struct IsSafe<SafeIndex<T>> {
-  constexpr operator bool() const { return true; } };
+namespace ngcore
+{
+  template <typename T>
+  struct IsSafe<SafeIndex<T>> {
+    constexpr operator bool() const { return true; } };
+} // namespace ngcore
 
 /*
 namespace std {

netgen/include/sparsematrix.hpp

@@ -338,6 +338,8 @@ namespace ngla
     { 
       return asvec; 
     }
+
+    // tuple<int,int> EntryShape() const { return { entry_height, entry_width }; }
     
     FlatVector<TSCAL> GetRowValue (int row, int j)
     {
@@ -345,9 +347,10 @@ namespace ngla
       return FlatVector<TSCAL> (entry_size, p);
     }
     
-    FlatMatrix<TSCAL> GetRowValueMat (int row, int j)
+    FlatMatrix<TSCAL> GetRowValueMat (int row, int j) const
     {
-      TSCAL * p = asvec(entry_size * (firsti[row] + j)).Data(0);
+      // TSCAL * p = asvec(entry_size * (firsti[row] + j)).Data(0);
+      TSCAL * p = &asvec(entry_size * (firsti[row] + j));
       return FlatMatrix<TSCAL> (entry_height, entry_width, p);
     }
   };

netgen/include/statushandler.hpp

@@ -19,6 +19,13 @@ namespace ngstd
     static void SetTerminate(void);
     static void UnSetTerminate(void);
     static bool ShouldTerminate(void);
+
+    class Region
+    {
+    public:
+      Region(const char * str) { PushStatus(str); }
+      ~Region() { PopStatus(); }
+    };
   };
 
 }

netgen/include/umfpackinverse.hpp

@@ -22,11 +22,12 @@
 namespace ngla
 {
 
-  template<class TM>
-  class UmfpackInverseTM : public SparseFactorization
+  template<class SCAL>
+  class S_UmfpackInverse : public SparseFactorization
   {
   public:
-    typedef typename mat_traits<TM>::TSCAL TSCAL;
+    // typedef typename mat_traits<TM>::TSCAL TSCAL;
+    typedef SCAL TSCAL;
 
   protected:
     typedef SuiteSparse_long suite_long;
@@ -42,7 +43,8 @@ namespace ngla
     Array<suite_long> rowstart, indices;
     Array<TSCAL> values;
 
-    bool symmetric, is_complex;
+    bool symmetric;
+    static constexpr bool is_complex = ngbla::IsComplex<TSCAL>();
 
     void SetMatrixType();
 
@@ -52,16 +54,17 @@ namespace ngla
   public:
 
     ///
-    UmfpackInverseTM (shared_ptr<const SparseMatrixTM<TM>> a,
-		      shared_ptr<BitArray> ainner = nullptr,
+    S_UmfpackInverse (shared_ptr<const S_BaseSparseMatrix<TSCAL>> a,
+                      shared_ptr<BitArray> ainner = nullptr,
 		      shared_ptr<const Array<int>> acluster = nullptr,
 		      int symmetric = 0);
+    virtual ~S_UmfpackInverse();
     ///
 
     template <typename TSUBSET>
-    void GetUmfpackMatrix (const SparseMatrixTM<TM> & a, TSUBSET subset);
+    // void GetUmfpackMatrix (const SparseMatrixTM<TM> & a, TSUBSET subset);
+    void GetUmfpackMatrix (const S_BaseSparseMatrix<TSCAL> & a, TSUBSET subset);
 
-    virtual ~UmfpackInverseTM ();
     ///
     int VHeight() const { return height/entrysize; }
     ///
@@ -74,44 +77,69 @@ namespace ngla
 
     virtual Array<MemoryUsage> GetMemoryUsage () const
     {
-      return { MemoryUsage ("Umfpack", nze*sizeof(TM), 1) };
+      return { MemoryUsage ("Umfpack", nze*sizeof(TSCAL)*entrysize*entrysize, 1) };
     }
   };
 
 
+  
+  template<class SCAL, class SCAL_VEC>
+  class S_UmfpackInverse_SVec : public S_UmfpackInverse<SCAL>
+  {
+    typedef S_UmfpackInverse<SCAL> BASE;
+  protected:
+    using typename BASE::TSCAL;    
+    using BASE::height;
+    using BASE::is_complex;
+    using BASE::compressed_height;
+    using BASE::entrysize;
+    using BASE::rowstart;
+    using BASE::indices;
+    using BASE::compressed;
+    using BASE::compress;
+    
+    using S_UmfpackInverse<SCAL>::S_UmfpackInverse;
+    static constexpr bool is_vector_complex = ngbla::IsComplex<SCAL_VEC>();
+    
+    AutoVector CreateRowVector () const override { return CreateBaseVector(height/entrysize, is_vector_complex, entrysize); }
+    AutoVector CreateColVector () const override { return CreateBaseVector(height/entrysize, is_vector_complex, entrysize); }
+
+    void Mult (const BaseVector & x, BaseVector & y) const override;
+    void MultTrans (const BaseVector & x, BaseVector & y) const override;
+  };
+  
+
   template<class TM,
 	   class TV_ROW = typename mat_traits<TM>::TV_ROW,
 	   class TV_COL = typename mat_traits<TM>::TV_COL>
-  class UmfpackInverse : public UmfpackInverseTM<TM>
+  class UmfpackInverse : public S_UmfpackInverse_SVec<typename mat_traits<TM>::TSCAL, typename mat_traits<TV_COL>::TSCAL>
   {
-    using UmfpackInverseTM<TM>::height;
-    using UmfpackInverseTM<TM>::is_complex;
-    using UmfpackInverseTM<TM>::compressed_height;
-    using UmfpackInverseTM<TM>::entrysize;
-    using UmfpackInverseTM<TM>::rowstart;
-    using UmfpackInverseTM<TM>::indices;
-    using UmfpackInverseTM<TM>::compressed;
-    using UmfpackInverseTM<TM>::compress;
-
   public:
+    typedef S_UmfpackInverse_SVec<typename mat_traits<TM>::TSCAL, typename mat_traits<TV_COL>::TSCAL> BASE;
+    
+    using typename BASE::TSCAL;
     typedef TV_COL TV;
     typedef TV_ROW TVX;
-    typedef typename mat_traits<TM>::TSCAL TSCAL;
+    
+  private:
+    using BASE::height;
+    using BASE::is_complex;
+    using BASE::is_vector_complex;    
+    using BASE::compressed_height;
+    using BASE::entrysize;
+    using BASE::rowstart;
+    using BASE::indices;
+    using BASE::compressed;
+    using BASE::compress;
 
-    ///
+  public:
     UmfpackInverse (shared_ptr<const SparseMatrix<TM,TV_ROW,TV_COL>> a,
 		    shared_ptr<BitArray> ainner = nullptr,
 		    shared_ptr<const Array<int>> acluster = nullptr,
 		    int symmetric = 0)
-      : UmfpackInverseTM<TM> (a, ainner, acluster, symmetric) { ; }
+      : BASE (a, ainner, acluster, symmetric) { ; }
 
-    virtual ~UmfpackInverse () { ; }
-    ///
-    void Mult (const BaseVector & x, BaseVector & y) const override;
-    void MultTrans (const BaseVector & x, BaseVector & y) const override;
-    ///
-    AutoVector CreateRowVector () const override { return make_unique<VVector<TV>> (height/entrysize); }
-    AutoVector CreateColVector () const override { return make_unique<VVector<TV>> (height/entrysize); }
+    // virtual ~UmfpackInverse () { ; }
   };
 
 }

ngsolve/cmake/NGSolveConfig.cmake

@@ -1,4 +1,4 @@
-set(PACKAGE_VERSION "6.2.2405-37-ged20de0cf")
+set(PACKAGE_VERSION "6.2.2405-53-g86b17e189")
 find_package(Netgen CONFIG REQUIRED HINTS
   ${CMAKE_CURRENT_LIST_DIR}
   ${CMAKE_CURRENT_LIST_DIR}/..

ngsolve/config/config.py

@@ -30,15 +30,15 @@ NGSOLVE_INSTALL_DIR_INCLUDE  = "netgen/include"
 NGSOLVE_INSTALL_DIR_CMAKE    = "ngsolve/cmake"
 NGSOLVE_INSTALL_DIR_RES      = "share"
 
-NGSOLVE_VERSION = "6.2.2405-37-ged20de0cf"
-NGSOLVE_VERSION_GIT = "v6.2.2405-37-ged20de0cf"
-NGSOLVE_VERSION_PYTHON = "6.2.2405.post37.dev1"
+NGSOLVE_VERSION = "6.2.2405-53-g86b17e189"
+NGSOLVE_VERSION_GIT = "v6.2.2405-53-g86b17e189"
+NGSOLVE_VERSION_PYTHON = "6.2.2405.post53.dev1"
 
 NGSOLVE_VERSION_MAJOR = "6"
 NGSOLVE_VERSION_MINOR = "2"
-NGSOLVE_VERSION_TWEAK = "37"
+NGSOLVE_VERSION_TWEAK = "53"
 NGSOLVE_VERSION_PATCH = "2405"
-NGSOLVE_VERSION_HASH = "ged20de0cf"
+NGSOLVE_VERSION_HASH = "g86b17e189"
 
 CMAKE_CXX_COMPILER           = "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/cl.exe"
 CMAKE_CUDA_COMPILER          = ""

ngsolve/config.py

@@ -30,15 +30,15 @@ NGSOLVE_INSTALL_DIR_INCLUDE  = "netgen/include"
 NGSOLVE_INSTALL_DIR_CMAKE    = "ngsolve/cmake"
 NGSOLVE_INSTALL_DIR_RES      = "share"
 
-NGSOLVE_VERSION = "6.2.2405-37-ged20de0cf"
-NGSOLVE_VERSION_GIT = "v6.2.2405-37-ged20de0cf"
-NGSOLVE_VERSION_PYTHON = "6.2.2405.post37.dev1"
+NGSOLVE_VERSION = "6.2.2405-53-g86b17e189"
+NGSOLVE_VERSION_GIT = "v6.2.2405-53-g86b17e189"
+NGSOLVE_VERSION_PYTHON = "6.2.2405.post53.dev1"
 
 NGSOLVE_VERSION_MAJOR = "6"
 NGSOLVE_VERSION_MINOR = "2"
-NGSOLVE_VERSION_TWEAK = "37"
+NGSOLVE_VERSION_TWEAK = "53"
 NGSOLVE_VERSION_PATCH = "2405"
-NGSOLVE_VERSION_HASH = "ged20de0cf"
+NGSOLVE_VERSION_HASH = "g86b17e189"
 
 CMAKE_CXX_COMPILER           = "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.29.30133/bin/Hostx64/x64/cl.exe"
 CMAKE_CUDA_COMPILER          = ""

ngsolve/demos/TensorProduct/tp_dg_1d_1d.py

@@ -0,0 +1,80 @@
+from ngsolve.TensorProductTools import *
+from ngsolve.comp import *
+from ngsolve import *
+import netgen.gui
+
+mesh1 = Mesh(SegMesh(20,0,1,periodic=True) )
+mesh2 = Mesh(SegMesh(20,0,1,periodic=True) )
+
+tpmesh = Mesh(MakeTensorProductMesh(mesh1,mesh2))
+Draw(tpmesh)
+
+n=5
+m=5
+
+fesx = L2(mesh1,order=n)
+fesy = L2(mesh2,order=m)
+
+tpfes = TensorProductFESpace([fesx,fesy])
+
+fes = L2(tpmesh,order=n)
+u = tpfes.TrialFunction()
+v = tpfes.TestFunction()
+vx = v.Operator("gradx")
+vy = v.Operator("grady")
+b = (-1)*CoefficientFunction( (0.25,0.5) )
+
+
+uin = ProlongateCoefficientFunction(IfPos((1.0-x)*(x-0.5),sin((x-0.5)*2*3.14159),0) + IfPos((x-0.0)*(0.5-x),sin((x)*2*3.14159),0) , 0 , tpfes)
+
+gradv = CoefficientFunction((vx,vy))
+
+a = BilinearForm(tpfes)
+
+n = CoefficientFunction((ProlongateCoefficientFunction(specialcf.normal(1),1,tpfes),ProlongateCoefficientFunction(specialcf.normal(1),0,tpfes)))
+bn = b*n
+
+a += SymbolicTPBFI ( (-u * b*gradv).Compile() )
+a += SymbolicTPBFI ( (bn) *IfPos(bn, u, u.Other( )) * (v-v.Other()).Compile(), VOL, skeleton=True)
+a += SymbolicTPBFI ( (bn) *IfPos(bn, u, u.Other(bnd = CoefficientFunction(uin) )) * (v).Compile(), BND, skeleton=True)
+
+
+
+u = GridFunction(tpfes)
+v = GridFunction(tpfes)
+
+uu = GridFunction(fes)
+print("Setting")
+u.Set(exp( ProlongateCoefficientFunction(-200*(x-0.4)*(x-0.4), 1, tpfes)+ ProlongateCoefficientFunction(-200*(x-0.4)*(x-0.4),0,tpfes) ) )
+print("Done")
+Transfer2StdMesh(u,uu)
+
+Draw(uu,sd=2,autoscale=False)
+
+h = u.vec.CreateVector()
+#u.vec[:] = 1.0
+print('To start the simulation type Run(n_steps)!')
+
+def Step():
+    a.Apply(u.vec,v.vec)
+    h.data = 0.00125*v.vec.data
+    tpfes.SolveM(rho=CoefficientFunction(1), vec = h)
+    u.vec.data-=h.data
+    #Redraw()
+
+def Run(nsteps):
+    count = 0
+    with TaskManager():
+        for i in range(nsteps):
+            print("Step ",i+1, "/",nsteps)
+            Step()
+            count += 1
+            if count % 1 == 0:
+                Transfer2StdMesh(u,uu)
+                count = 0
+                Redraw()
+
+Transfer2StdMesh(u,uu)
+Run(100)
+for t in Timers():
+    print(t["counts"], t["time"], t["name"])

ngsolve/demos/TensorProduct/tp_dg_1d_2d.py

@@ -0,0 +1,73 @@
+from ngsolve.TensorProductTools import *
+from ngsolve.comp import *
+from ngsolve import *
+from netgen.geom2d import unit_square
+import netgen.gui
+
+mesh1 = Mesh(SegMesh(20,0,1))
+mesh2 = Mesh(unit_square.GenerateMesh(maxh=0.15))
+
+tpmesh = Mesh(MakeTensorProductMesh(mesh1,mesh2))
+Draw(tpmesh)
+
+n=3
+m=3
+
+fesx = L2(mesh1,order=n)
+fesy = L2(mesh2,order=m)
+tpfes = TensorProductFESpace([fesx,fesy])
+
+fes = L2(tpmesh,order=n)
+
+u = tpfes.TrialFunction()
+v = tpfes.TestFunction()
+
+vx = v.Operator("gradx")
+vy = v.Operator("grady")
+
+b = CoefficientFunction( (ProlongateCoefficientFunction(x-0.5,0,tpfes),ProlongateCoefficientFunction(0.5-x,1,tpfes),0) )
+
+uin = CoefficientFunction(0.0)
+
+
+gradv = CoefficientFunction((vx,vy))
+
+a = BilinearForm(tpfes)
+
+n = CoefficientFunction(( ProlongateCoefficientFunction(specialcf.normal(1)[0],1,tpfes),ProlongateCoefficientFunction(specialcf.normal(2)[0],0,tpfes),ProlongateCoefficientFunction(specialcf.normal(2)[1],0,tpfes)))
+bn = b*n
+
+a += SymbolicTPBFI ( -u * b*gradv )
+a += SymbolicTPBFI ( (bn) *IfPos(bn, u, u.Other(bnd = uin )) * (v-v.Other(bnd = 0.0)), VOL, skeleton=True)
+a += SymbolicTPBFI ( (bn) *IfPos(bn, u, u.Other(bnd = uin )) * (v), BND, skeleton=True)
+
+
+u = GridFunction(tpfes)
+v = GridFunction(tpfes)
+
+
+uu = GridFunction(fes)
+
+u.Set(exp(ProlongateCoefficientFunction( -70*(x-0.25)*(x-0.25),1,tpfes) + ProlongateCoefficientFunction(-70*(x-0.25)*(x-0.25)-70*(y-0.75)*(y-0.75),0,tpfes) ))
+Transfer2StdMesh(u,uu)
+Draw(uu,sd=3,autoscale=False)
+
+h = u.vec.CreateVector()
+print('To start the simulation type Run(n_steps)!')
+def Step():
+    a.Apply(u.vec,v.vec)
+    h.data = 0.001*v.vec.data
+    tpfes.SolveM(rho=CoefficientFunction(1), vec = h)
+    u.vec.data-=h.data
+    Transfer2StdMesh(u,uu)
+    Redraw()
+
+def Run(nsteps):
+    with TaskManager():
+        for i in range(nsteps):
+            print("Step ",i+1, "/",nsteps)
+            Step()
+
+#Run(100)
+for t in Timers():
+    print(t["counts"], t["time"], t["name"])

ngsolve/demos/TensorProduct/tp_dg_2d_1d.py

@@ -0,0 +1,72 @@
+from ngsolve.TensorProductTools import *
+from ngsolve.comp import *
+from ngsolve import *
+from netgen.geom2d import unit_square
+import netgen.gui
+
+mesh1 = Mesh(unit_square.GenerateMesh(maxh=0.15))
+mesh2 = Mesh(SegMesh(20,0,1))
+
+tpmesh = Mesh(MakeTensorProductMesh(mesh1,mesh2))
+Draw(tpmesh)
+
+n=3
+m=3
+
+fesx = L2(mesh1,order=n)
+fesy = L2(mesh2,order=m)
+tpfes = TensorProductFESpace([fesx,fesy])
+
+fes = L2(tpmesh,order=n)
+
+u = tpfes.TrialFunction()
+v = tpfes.TestFunction()
+
+vx = v.Operator("gradx")
+vy = v.Operator("grady")
+
+b = CoefficientFunction( (0,0,1) )
+
+uin = CoefficientFunction(0.0)
+
+gradv = CoefficientFunction((vx,vy))
+
+a = BilinearForm(tpfes)
+
+n = CoefficientFunction((ProlongateCoefficientFunction(specialcf.normal(2)[0],1,tpfes),ProlongateCoefficientFunction(specialcf.normal(2)[1],1,tpfes),ProlongateCoefficientFunction(specialcf.normal(1)[0],0,tpfes)))
+bn = b*n
+
+a += SymbolicTPBFI ( -u * b*gradv )
+a += SymbolicTPBFI ( (bn) *IfPos(bn, u, u.Other(bnd = uin )) * (v-v.Other(bnd = 0.0)), VOL, skeleton=True)
+a += SymbolicTPBFI ( (bn) *IfPos(bn, u, u.Other(bnd = uin )) * (v), BND, skeleton=True)
+
+
+u = GridFunction(tpfes)
+v = GridFunction(tpfes)
+
+
+uu = GridFunction(fes)
+
+u.Set(exp(ProlongateCoefficientFunction(-70*(x-0.125)*(x-0.125)-70*(y-0.125)*(y-0.125),1,tpfes)+ProlongateCoefficientFunction(-70*(x-0.75)*(x-0.75),0,tpfes) ))
+Transfer2StdMesh(u,uu)
+Draw(uu,sd=3,autoscale=False)
+
+h = u.vec.CreateVector()
+print('To start the simulation type Run(n_steps)!')
+def Step():
+    a.Apply(u.vec,v.vec)
+    h.data = 0.001*v.vec.data
+    tpfes.SolveM(rho=CoefficientFunction(1), vec = h)
+    u.vec.data-=h.data
+    Transfer2StdMesh(u,uu)
+    Redraw()
+
+def Run(nsteps):
+    with TaskManager():
+        for i in range(nsteps):
+            print("Step ",i+1, "/",nsteps)
+            Step()
+
+Run(100)
+for t in Timers():
+    print(t["counts"], t["time"], t["name"])

ngsolve/demos/TensorProduct/tp_dg_2d_2d.py

@@ -0,0 +1,66 @@
+from ngsolve.TensorProductTools import *
+from ngsolve.comp import *
+from ngsolve import *
+from netgen.geom2d import unit_square
+import netgen.gui
+
+mesh1 = Mesh(unit_square.GenerateMesh(maxh=0.15))
+mesh2 = Mesh(MakeHexagonalMesh2D(maxh=0.2))
+n=4
+m=4
+SetHeapSize(1000000000)
+
+fesx = L2(mesh1,order=n)
+fesy = L2(mesh2,order=m)
+tpfes = TensorProductFESpace([fesx,fesy])
+
+u = tpfes.TrialFunction()
+v = tpfes.TestFunction()
+
+vx = v.Operator("gradx")
+vy = v.Operator("grady")
+
+b = CoefficientFunction( ( ProlongateCoefficientFunction(y-0.5,1,tpfes),ProlongateCoefficientFunction(0.5-x,1,tpfes),1,1 ) ) 
+
+uin = CoefficientFunction(0.0)
+
+gradv = CoefficientFunction((vx,vy))
+
+a = BilinearForm(tpfes)
+
+n = CoefficientFunction((ProlongateCoefficientFunction(specialcf.normal(2)[0],1,tpfes),ProlongateCoefficientFunction(specialcf.normal(2)[1],1,tpfes),ProlongateCoefficientFunction(specialcf.normal(2)[0],0,tpfes),ProlongateCoefficientFunction(specialcf.normal(2)[1],0,tpfes)))
+bn = b*n
+
+a += SymbolicTPBFI ( -u * b*gradv )
+a += SymbolicTPBFI ( (bn) *IfPos(bn, u, u.Other(bnd = uin )) * (v-v.Other(bnd = 0.0)), VOL, skeleton=True)
+a += SymbolicTPBFI ( (bn) *IfPos(bn, u, u.Other(bnd = uin )) * (v), BND, skeleton=True)
+
+
+u = GridFunction(tpfes)
+v = GridFunction(tpfes)
+print(1)
+with TaskManager():
+    u.Set(exp(ProlongateCoefficientFunction(-90*(x-0.25)*(x-0.25)-90*(y-0.5)*(y-0.5),1,tpfes)+ProlongateCoefficientFunction(-70*(x-0.75)*(x-0.75)-70*(y-0.75)*(y-0.75),0,tpfes) ))
+print(2)
+rho = GridFunction(fesx,name="rho")
+Draw(rho)
+h = u.vec.CreateVector()
+print('To start the simulation type Run(n_steps)!')
+
+def Step():
+    a.Apply(u.vec,v.vec)
+    h.data = 0.005*v.vec.data
+    tpfes.SolveM(rho=CoefficientFunction(1), vec = h)
+    u.vec.data-=h.data
+    TensorProductIntegrate(u,rho)
+    Redraw()
+
+def Run(nsteps):
+    with TaskManager():
+        for i in range(nsteps):
+            print("Step ",i+1, "/",nsteps)
+            Step()
+
+Run(1000)
+for t in Timers():
+    print(t["counts"], t["time"], t["name"])

ngsolve/demos/howto/hhj.py

@@ -0,0 +1,44 @@
+#
+# The Hellan-Herrmann-Johnson method for a Kirchhoff plate
+# 
+# M. I. Comodi: The Hellan–Herrmann-Johnson Method
+# Some error estimates and postprocessing. Math. Comp. 52, 17–39, 1989
+# 
+
+from ngsolve import *
+from netgen.geom2d import unit_square
+
+mesh = Mesh (unit_square.GenerateMesh(maxh=0.05))
+order = 3
+
+V = HDivDiv(mesh, order=order-1)
+Q = H1(mesh, order=order, dirichlet="left|right|top|bottom")
+X = V*Q
+
+print ("ndof-V:", V.ndof, ", ndof-Q:", Q.ndof)
+
+sigma, u = X.TrialFunction()
+tau, v = X.TestFunction()
+
+n = specialcf.normal(2)
+
+def tang(u): return u-(u*n)*n
+
+a = BilinearForm(X, symmetric=True)
+a += (InnerProduct (sigma, tau) + div(sigma)*grad(v) + div(tau)*grad(u) - 1e-10*u*v)*dx
+a += (-(sigma*n) * tang(grad(v)) - (tau*n)*tang(grad(u)))*dx(element_boundary=True)
+a.Assemble()
+
+f = LinearForm(X)
+f += 1 * v * dx
+# f += Trace(tau.Trace()) * ds("bottom")
+f.Assemble()
+
+u = GridFunction(X)
+u.vec.data = a.mat.Inverse(X.FreeDofs()) * f.vec
+
+Draw (u.components[0], mesh, name="sigma")
+Draw (u.components[1], mesh, name="disp")
+
+
+

ngsolve/demos/howto/hybrid_dg.py

@@ -0,0 +1,53 @@
+from netgen.geom2d import unit_square
+from ngsolve import *
+
+
+ngsglobals.msg_level = 1
+mesh = Mesh(unit_square.GenerateMesh(maxh=0.4))
+for k in range(5):
+    mesh.Refine()
+
+
+order = 3
+fes1 = L2(mesh, order=order)
+fes2 = FacetFESpace(mesh, order=order, dirichlet="bottom|right|top")
+
+print ("element dofs: ", fes1.ndof)
+print ("facet dofs: ", fes2.ndof)
+
+fes = fes1*fes2
+
+u,uhat = fes.TrialFunction()
+v,vhat = fes.TestFunction()
+
+n = specialcf.normal(mesh.dim)
+h = specialcf.mesh_size
+
+a = BilinearForm(fes, symmetric=True, condense = True)
+a += grad(u) * grad(v) * dx
+a += (grad(u)*n*(vhat-v)+grad(v)*n*(uhat-u)+10*order*order/h*(u-uhat)*(v-vhat))*dx(element_boundary=True)
+
+c = Preconditioner(type="direct", bf=a, inverse = "sparsecholesky")
+# c = Preconditioner(type="bddc", bf=a)
+
+with TaskManager():
+    a.Assemble()
+    ainv = CGSolver(a.mat, c.mat)
+
+f = LinearForm(fes)
+f += 1*v*dx
+f.Assemble()
+
+u = GridFunction(fes)
+
+
+f.vec.data += a.harmonic_extension_trans * f.vec
+
+u.vec.data = ainv * f.vec
+
+u.vec.data += a.harmonic_extension * u.vec
+u.vec.data += a.inner_solve * f.vec
+
+Draw (u.components[0], mesh, "sol")
+
+