ngsolve 6.2.2502__cp311-cp311-win_amd64.whl → 6.2.2601__cp311-cp311-win_amd64.whl

netgen/include/hcurlcurlfe.hpp

@@ -88,6 +88,9 @@ namespace ngfem
                                    BareSliceVector<> coefs) const = 0;
 
     
+    virtual void CalcMappedShape (const SIMD<BaseMappedIntegrationPoint> & bmip, 
+                                         BareSliceMatrix<SIMD<double>> shapes) const = 0;
+
     virtual void CalcMappedShape (const SIMD_BaseMappedIntegrationRule & bmir, 
                                          BareSliceMatrix<SIMD<double>> shapes) const = 0;
     
@@ -931,6 +934,23 @@ namespace ngfem
       else
         throw Exception("HCurlCurl::CalcMappedCurlShape implemented only for TRIG and TET");
     }
+
+
+    virtual void CalcMappedShape (const SIMD<BaseMappedIntegrationPoint> & bmip, 
+                                         BareSliceMatrix<SIMD<double>> shape) const override
+    {
+      Switch<4-DIM>
+        (bmip.DimSpace()-DIM,[this, &bmip, shape](auto CODIM)
+         {
+           constexpr auto DIMSPACE = DIM+CODIM.value;
+           auto & mip = static_cast<const SIMD<MappedIntegrationPoint<DIM,DIM+CODIM.value>>&> (bmip);
+            this->Cast() -> T_CalcShape (GetTIP(mip),
+                                          SBLambda ([shape,DIMSPACE] (size_t j, auto val) 
+                                                    {
+                                                      shape.Rows(j*sqr(DIMSPACE), (j+1)*sqr(DIMSPACE)).Col(0).Range(0,sqr(DIMSPACE)) = val.Value().AsVector();
+                                                    }));
+         });
+    }
       
     virtual void CalcMappedShape (const SIMD_BaseMappedIntegrationRule & bmir, 
                                          BareSliceMatrix<SIMD<double>> shapes) const override

netgen/include/hdiv_equations.hpp

@@ -179,6 +179,14 @@ public:
   {
     return static_cast<const FEL&> (fel);
   }
+  static int DimRef() { return D-1; }
+
+  template <typename IP, typename MAT>
+  static void GenerateMatrixRef (const FiniteElement & fel, const IP & ip,
+                                 MAT && mat, LocalHeap & lh)
+  {
+    Cast(fel).CalcShape (ip, Trans(mat));
+  }
   
   template <typename AFEL, typename MIP, typename MAT>
   static void GenerateMatrix (const AFEL & fel, const MIP & mip,
@@ -188,6 +196,13 @@ public:
       Trans (Cast(fel).GetShape(mip.IP(),lh));
   }
   
+  template <typename MIP, typename MAT>
+  static void CalcTransformationMatrix (const MIP & bmip,
+                                        MAT & mat, LocalHeap & lh)
+  {
+    auto & mip = static_cast<const MappedIntegrationPoint<D-1,D>&>(bmip);
+    mat = 1./mip.GetJacobiDet() * mip.GetJacobian();
+  }
   /*
   template <typename AFEL, typename MIP, class TVX, class TVY>
   static void ApplyTrans (const AFEL & fel, const MIP & mip,

netgen/include/hdivfe_utils.hpp

@@ -563,6 +563,7 @@ namespace ngfem
   {
   public:
     INLINE operator SCAL () const { return SCAL(0.0); }
+    INLINE SCAL Get() const { return SCAL(0.0); }    
   };
 
   template <typename SCAL> class THDiv2DivShape<2,SCAL>

netgen/include/hdivhofespace.hpp

@@ -143,6 +143,8 @@ namespace ngcomp
 	} 
     }
 
+    void SelectDofs (const string & name, BitArray & dofs) const override;
+
     int GetFirstInnerDof(int elnr) const { return(first_inner_dof[elnr]);}; 
     // virtual int LowOrderDof() const { if(discont) return(0); else return(1);} 
 

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

@@ -1525,7 +1525,8 @@ namespace ngfem
       else
         incr = 0;
     }
-    
+
+    virtual ~MappedIntegrationRule() { }
     INLINE MappedIntegrationPoint<DIM_ELEMENT, DIM_SPACE> & operator[] (size_t i) const
     { 
       // return mips[i];

netgen/include/intrules_SauterSchwab.hpp

@@ -0,0 +1,25 @@
+#ifndef INTRULES_HPP
+#define INTRULES_HPP
+
+#include <bla.hpp>
+
+namespace ngsbem
+{
+  using namespace ngbla;
+  
+  // x, y in triangle [(0,0), (1,0), (0,1)]
+  tuple<Array<Vec<2>>, Array<Vec<2>>, Array<double>> IdenticPanelIntegrationRule (int order);
+
+
+  // x, y in triangle [(0,0), (1,0), (0,1)]
+  // x=(0,0) and y=(0,0) are common vertices
+  tuple<Array<Vec<2>>, Array<Vec<2>>, Array<double>> CommonVertexIntegrationRule (int order);
+  
+
+  // x, y in triangle [(0,0), (1,0), (0,1)]
+  // x in [(0,0),(1,0)] and y in [(0,0),(1,0)] are common edges
+  tuple<Array<Vec<2>>, Array<Vec<2>>, Array<double>> CommonEdgeIntegrationRule (int order);
+  
+}
+
+#endif

netgen/include/jacobi.hpp

@@ -17,13 +17,30 @@ namespace ngla
      Jacobi and Gauss Seidel smoother
      for scalar, block and system matrices
   */
+  
+  class BaseMSMPrecond : virtual public BaseMatrix
+  {
+  public:
+    virtual void Smooth (BaseVector & x, const BaseVector & b, int steps = 1) const = 0;
+    virtual void SmoothBack (BaseVector & x, const BaseVector & b, int steps = 1) const = 0;
+  };
 
-  class BaseJacobiPrecond : virtual public BaseMatrix
+  
+  class BaseJacobiPrecond : public BaseMSMPrecond
   {
   public:
-    virtual void GSSmooth (BaseVector & x, const BaseVector & b) const = 0;
+    virtual void Smooth (BaseVector & x, const BaseVector & b, int steps = 1) const override
+    {
+      GSSmooth (x, b, steps);
+    }
+    virtual void SmoothBack (BaseVector & x, const BaseVector & b, int steps = 1) const override
+    {
+      GSSmoothBack (x, b, steps);
+    }
+    
+    virtual void GSSmooth (BaseVector & x, const BaseVector & b, int steps = 1) const = 0;
     virtual void GSSmooth (BaseVector & x, const BaseVector & b, BaseVector & y) const = 0;
-    virtual void GSSmoothBack (BaseVector & x, const BaseVector & b) const = 0;
+    virtual void GSSmoothBack (BaseVector & x, const BaseVector & b, int steps = 1) const = 0;
   };
 
 
@@ -31,7 +48,7 @@ namespace ngla
   {
     shared_ptr<BaseJacobiPrecond> jac;
   public:
-    SymmetricGaussSeidelPrecond (const BaseSparseMatrix & mat, shared_ptr<BitArray> freedofs);
+    SymmetricGaussSeidelPrecond (shared_ptr<BaseSparseMatrix> mat, shared_ptr<BitArray> freedofs);
     int VHeight() const override { return jac->VHeight(); }
     int VWidth() const override { return jac->VHeight(); }
 
@@ -44,11 +61,11 @@ namespace ngla
   
   /// A Jaboci preconditioner for general sparse matrices
   template <class TM, class TV_ROW, class TV_COL>
-  class JacobiPrecond : virtual public BaseJacobiPrecond,
-			virtual public S_BaseMatrix<typename mat_traits<TM>::TSCAL>
+  class JacobiPrecond : public BaseJacobiPrecond,
+			public S_BaseMatrix<typename mat_traits<TM>::TSCAL>
   {
   protected:
-    const SparseMatrix<TM,TV_ROW,TV_COL> & mat;
+    shared_ptr<SparseMatrix<TM,TV_ROW,TV_COL>> mat;
     ///
     shared_ptr<BitArray> inner;
     ///
@@ -60,7 +77,7 @@ namespace ngla
     typedef typename mat_traits<TM>::TSCAL TSCAL;
 
     ///
-    JacobiPrecond (const SparseMatrix<TM,TV_ROW,TV_COL> & amat, 
+    JacobiPrecond (shared_ptr<SparseMatrix<TM,TV_ROW,TV_COL>> amat, 
 		   shared_ptr<BitArray> ainner = nullptr, bool use_par = true);
 
     int VHeight() const override { return height; }
@@ -74,20 +91,20 @@ namespace ngla
     void MultTransAdd (TSCAL s, const BaseVector & x, BaseVector & y) const override
     { MultAdd (s, x, y); }
     ///
-    AutoVector CreateRowVector() const override { return mat.CreateColVector(); }
-    AutoVector CreateColVector() const override { return mat.CreateRowVector(); }
+    AutoVector CreateRowVector() const override { return mat->CreateColVector(); }
+    AutoVector CreateColVector() const override { return mat->CreateRowVector(); }
     ///
-    void GSSmooth (BaseVector & x, const BaseVector & b) const override;
+    void GSSmooth (BaseVector & x, const BaseVector & b, int steps) const override;
 
     /// computes partial residual y
     void GSSmooth (BaseVector & x, const BaseVector & b, BaseVector & y) const override
     {
-      GSSmooth (x, b);
+      GSSmooth (x, b, 1);
     }
 
 
     ///
-    void GSSmoothBack (BaseVector & x, const BaseVector & b) const override;
+    void GSSmoothBack (BaseVector & x, const BaseVector & b, int steps) const override;
 
     ///
     virtual void GSSmoothNumbering (BaseVector & x, const BaseVector & b,
@@ -111,23 +128,23 @@ namespace ngla
     typedef TV TVX;
 
     ///
-    JacobiPrecondSymmetric (const SparseMatrixSymmetric<TM,TV> & amat, 
+    JacobiPrecondSymmetric (shared_ptr<SparseMatrixSymmetric<TM,TV>> amat, 
 			    shared_ptr<BitArray> ainner = nullptr, bool use_par = true);
 
     ///
-    virtual void GSSmooth (BaseVector & x, const BaseVector & b) const;
+    virtual void GSSmooth (BaseVector & x, const BaseVector & b, int steps) const override;
 
     /// computes partial residual y
-    virtual void GSSmooth (BaseVector & x, const BaseVector & b, BaseVector & y /* , BaseVector & help */) const;
+    virtual void GSSmooth (BaseVector & x, const BaseVector & b, BaseVector & y /* , BaseVector & help */) const override;
 
     ///
-    virtual void GSSmoothBack (BaseVector & x, const BaseVector & b) const;
+    virtual void GSSmoothBack (BaseVector & x, const BaseVector & b, int steps) const override;
     virtual void GSSmoothBack (BaseVector & x, const BaseVector & b, BaseVector & y) const;
 
     ///
     virtual void GSSmoothNumbering (BaseVector & x, const BaseVector & b,
 				    const Array<int> & numbering, 
-				    int forward = 1) const;
+				    int forward = 1) const override;
   };
 
 }