ngsolve 6.2.2404.post156.dev0__cp39-cp39-win_amd64.whl → 6.2.2406.post112.dev1__cp39-cp39-win_amd64.whl

netgen/include/tensorcoefficient.hpp

@@ -191,77 +191,79 @@ namespace ngfem {
         optimize_identities(string, const Array<shared_ptr<CoefficientFunction>>& cfs,
                             const map<string, bool> &options);
 
-        class LeviCivitaCoefficientFunction
-            : public T_CoefficientFunction<LeviCivitaCoefficientFunction> {
-          using BASE = T_CoefficientFunction<LeviCivitaCoefficientFunction>;
 
-          int dim = 0;
-          MultiIndex mi{};
+        // class LeviCivitaCoefficientFunction
+        //     : public T_CoefficientFunction<LeviCivitaCoefficientFunction> {
+        //   using BASE = T_CoefficientFunction<LeviCivitaCoefficientFunction>;
 
-        public:
-          LeviCivitaCoefficientFunction() = default;
+        //   int dim = 0;
+        //   MultiIndex mi{};
 
-          LeviCivitaCoefficientFunction(int adim);
+        // public:
+        //   LeviCivitaCoefficientFunction() = default;
 
-          virtual void TraverseTree(const function<void(CoefficientFunction &)> &func) override {
-            func(*this);
-          }
+        //   LeviCivitaCoefficientFunction(int adim);
 
-          virtual string GetDescription() const override { return string("Levi-Civita Symbol"); }
+        //   virtual void TraverseTree(const function<void(CoefficientFunction &)> &func) override {
+        //     func(*this);
+        //   }
 
-          virtual void DoArchive(Archive &ar) override;
+        //   virtual string GetDescription() const override { return string("Levi-Civita Symbol"); }
 
-          virtual void GenerateCode(Code &code, FlatArray<int> inputs, int index) const override {
-            GenerateCode(code, inputs, index, false);
-          }
+        //   virtual void DoArchive(Archive &ar) override;
 
-          virtual void GenerateCode(Code &code, FlatArray<int> inputs, int index,
-                                    bool skip_zeroes = true) const;
+        //   virtual void GenerateCode(Code &code, FlatArray<int> inputs, int index) const override {
+        //     GenerateCode(code, inputs, index, false);
+        //   }
 
-          virtual void NonZeroPattern(const class ProxyUserData &ud,
-                                      FlatVector<AutoDiffDiff<1,NonZero>> values) const override;
+        //   virtual void GenerateCode(Code &code, FlatArray<int> inputs, int index,
+        //                             bool skip_zeroes = true) const;
 
-          virtual void NonZeroPattern(const class ProxyUserData &ud,
-                                      FlatArray<FlatVector<AutoDiffDiff<1,NonZero>>> input,
-                                      FlatVector<AutoDiffDiff<1,NonZero>> values) const override;
+        //   virtual void NonZeroPattern(const class ProxyUserData &ud,
+        //                               FlatVector<AutoDiffDiff<1,NonZero>> values) const override;
 
-          using BASE::Evaluate;
-          using typename BASE::T_DJC;
+        //   virtual void NonZeroPattern(const class ProxyUserData &ud,
+        //                               FlatArray<FlatVector<AutoDiffDiff<1,NonZero>>> input,
+        //                               FlatVector<AutoDiffDiff<1,NonZero>> values) const override;
 
-          virtual double Evaluate(const BaseMappedIntegrationPoint &ip) const override;
+        //   using BASE::Evaluate;
+        //   using typename BASE::T_DJC;
 
-          template<typename MIR, typename T, ORDERING ORD>
-          void T_Evaluate(const MIR &ir, BareSliceMatrix<T, ORD> values) const
-          {
-            auto val = T(0.0);
-            values.AddSize(Dimension(), ir.Size()) = val;
-            auto ir_size = ir.Size();
-            for (size_t I: Range(Dimension())) {
-              const auto I_array = split(I, mi);
-              if (is_even_iota_permutation(I_array.begin(), I_array.end()))
-                val = 1.0;
-              else if (is_odd_iota_permutation(I_array.begin(), I_array.end()))
-                val = -1.0;
-              else
-                continue;
-              for (auto q: Range(ir_size))
-                values(I, q) = val;
-            }
-          }
+        //   virtual double Evaluate(const BaseMappedIntegrationPoint &ip) const override;
 
-          template<typename MIR, typename T, ORDERING ORD>
-          void T_Evaluate(const MIR &ir, FlatArray<BareSliceMatrix<T, ORD>> input,
-                          BareSliceMatrix<T, ORD> values) const
-          {
-            T_Evaluate(ir, values);
-          }
+        //   template<typename MIR, typename T, ORDERING ORD>
+        //   void T_Evaluate(const MIR &ir, BareSliceMatrix<T, ORD> values) const
+        //   {
+        //     auto val = T(0.0);
+        //     values.AddSize(Dimension(), ir.Size()) = val;
+        //     auto ir_size = ir.Size();
+        //     for (size_t I: Range(Dimension())) {
+        //       const auto I_array = split(I, mi);
+        //       cout << "check I: " << I_array << endl;
+        //       if (is_even_iota_permutation(I_array.begin(), I_array.end()))
+        //         val = 1.0;
+        //       else if (is_odd_iota_permutation(I_array.begin(), I_array.end()))
+        //         val = -1.0;
+        //       else
+        //         continue;
+        //       for (auto q: Range(ir_size))
+        //         values(I, q) = val;
+        //     }
+        //   }
 
+        //   template<typename MIR, typename T, ORDERING ORD>
+        //   void T_Evaluate(const MIR &ir, FlatArray<BareSliceMatrix<T, ORD>> input,
+        //                   BareSliceMatrix<T, ORD> values) const
+        //   {
+        //     T_Evaluate(ir, values);
+        //   }
 
-          shared_ptr<CoefficientFunction> Diff(const CoefficientFunction *var,
-                                               shared_ptr<CoefficientFunction> dir) const override;
 
-          shared_ptr<CoefficientFunction> DiffJacobi(const CoefficientFunction *var, T_DJC & cache) const override;
-        };
+        //   shared_ptr<CoefficientFunction> Diff(const CoefficientFunction *var,
+        //                                        shared_ptr<CoefficientFunction> dir) const override;
+
+        //   shared_ptr<CoefficientFunction> DiffJacobi(const CoefficientFunction *var, T_DJC & cache) const override;
+        // };
 
         class EinsumCoefficientFunction
             : public T_CoefficientFunction<EinsumCoefficientFunction>

netgen/include/tpdiffop.hpp

@@ -25,6 +25,7 @@ namespace ngfem
     virtual IntRange UsedDofs(const FiniteElement & fel) const override { return IntRange(0, fel.GetNDof()); }
 
     virtual bool operator== (const TPDifferentialOperator & diffop2) const { return false; }
+    virtual bool operator== (const DifferentialOperator & diffop2) const override { return false; }
     
     shared_ptr<DifferentialOperator> & GetEvaluators( int num)
     {

netgen/include/tpintrule.hpp

@@ -46,6 +46,8 @@ namespace ngfem
     { throw Exception("TPMappedIntegrationRule::Range not implemented"); }
     virtual SliceMatrix<> GetPoints() const
     { throw Exception("TPMappedIntegrationRule::GetPoints not implemented"); }
+    virtual SliceMatrix<> GetNormals() const
+    { throw Exception("TPMappedIntegrationRule::GetNormals not implemented"); }
     virtual void ComputeNormalsAndMeasure (ELEMENT_TYPE et, int facetnr)
     { throw Exception("TPMappedIntegrationRule::ComputeNormalsAndMeasure not implemented"); }
     virtual bool IsComplex() const

netgen/include/umfpackinverse.hpp

@@ -18,15 +18,16 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 #include <umfpack.h>
-
+#include "sparsecholesky.hpp"   // for SparseFactorization
 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 () { ; }
   };
 
 }

netgen/include/vector.hpp

@@ -338,7 +338,12 @@ namespace ngbla
     {
       NETGEN_CHECK_RANGE(next,first,Size()+1);
       return VectorView<T,size_t,TDIST> (next-first, dist, data+first*dist);
-    }    
+    }
+
+    INLINE auto Range (size_t next) const
+    {
+      return Range(0, next);
+    }
     
     INLINE auto Range (IntRange range) const
     {

netgen/include/voxelcoefficientfunction.hpp

@@ -30,6 +30,8 @@ namespace ngfem
     Complex EvaluateComplex(const BaseMappedIntegrationPoint& ip) const override;
 
     void Evaluate(const BaseMappedIntegrationPoint& mip, FlatVector<Complex> values) const override;
+    auto GetCArgs() const
+    { return make_tuple(start, end, dim_vals, values, linear); }
 
   private:
     SCAL T_Evaluate(const BaseMappedIntegrationPoint& ip) const;

netgen/include/vvector.hpp

@@ -1,3 +1,8 @@
+#ifndef FILE_VVECTOR
+#define FILE_VVECTOR
+
+#include "basevector.hpp"
+
 namespace ngla
 {
 
@@ -13,7 +18,7 @@ namespace ngla
   {
   protected:
     TSCAL * pdata;
-    int es;
+    int es;    // entry size in in term of TSCALs
     bool ownmem;
     
   public:
@@ -197,3 +202,7 @@ namespace ngla
   extern template class VVector<double>;
   extern template class VVector<Complex>;
 }
+
+
+
+#endif

ngsolve/_scikit_build_core_dependencies.py

@@ -1,3 +1,6 @@
+import sys
+
+
 def dynamic_metadata(field, settings):
 
     if field != "dependencies":
@@ -8,7 +11,11 @@ def dynamic_metadata(field, settings):
         msg = "No inline configuration is supported"
         raise ValueError(msg)
 
-    import tomllib
+    if sys.version_info >= (3, 11):
+        import tomllib
+    else:
+        import tomli as tomllib
+
     import importlib.metadata
 
     config = tomllib.load(open("pyproject.toml", "rb"))

ngsolve/cmake/NGSolveConfig.cmake

@@ -1,4 +1,4 @@
-set(PACKAGE_VERSION "6.2.2404-156-gcf3a4f8a7")
+set(PACKAGE_VERSION "6.2.2406-112-g6c1ab7fb2")
 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.2404-156-gcf3a4f8a7"
-NGSOLVE_VERSION_GIT = "v6.2.2404-156-gcf3a4f8a7"
-NGSOLVE_VERSION_PYTHON = "6.2.2404.post156.dev0"
+NGSOLVE_VERSION = "6.2.2406-112-g6c1ab7fb2"
+NGSOLVE_VERSION_GIT = "v6.2.2406-112-g6c1ab7fb2"
+NGSOLVE_VERSION_PYTHON = "6.2.2406.post112.dev1"
 
 NGSOLVE_VERSION_MAJOR = "6"
 NGSOLVE_VERSION_MINOR = "2"
-NGSOLVE_VERSION_TWEAK = "156"
-NGSOLVE_VERSION_PATCH = "2404"
-NGSOLVE_VERSION_HASH = "gcf3a4f8a7"
+NGSOLVE_VERSION_TWEAK = "112"
+NGSOLVE_VERSION_PATCH = "2406"
+NGSOLVE_VERSION_HASH = "g6c1ab7fb2"
 
 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.2404-156-gcf3a4f8a7"
-NGSOLVE_VERSION_GIT = "v6.2.2404-156-gcf3a4f8a7"
-NGSOLVE_VERSION_PYTHON = "6.2.2404.post156.dev0"
+NGSOLVE_VERSION = "6.2.2406-112-g6c1ab7fb2"
+NGSOLVE_VERSION_GIT = "v6.2.2406-112-g6c1ab7fb2"
+NGSOLVE_VERSION_PYTHON = "6.2.2406.post112.dev1"
 
 NGSOLVE_VERSION_MAJOR = "6"
 NGSOLVE_VERSION_MINOR = "2"
-NGSOLVE_VERSION_TWEAK = "156"
-NGSOLVE_VERSION_PATCH = "2404"
-NGSOLVE_VERSION_HASH = "gcf3a4f8a7"
+NGSOLVE_VERSION_TWEAK = "112"
+NGSOLVE_VERSION_PATCH = "2406"
+NGSOLVE_VERSION_HASH = "g6c1ab7fb2"
 
 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"])