ngsolve 6.2.2503__cp310-cp310-win_amd64.whl → 6.2.2504.post44.dev0__cp310-cp310-win_amd64.whl

netgen/include/blockjacobi.hpp

@@ -9,6 +9,7 @@
 
 
 #include "sparsematrix.hpp"
+#include "jacobi.hpp"
 
 namespace ngla
 {
@@ -16,7 +17,7 @@ namespace ngla
   /**
      Base class for Block - Jacobi and Block Gauss Seidel smoother.
   */
-  class NGS_DLL_HEADER BaseBlockJacobiPrecond : virtual public BaseMatrix
+  class NGS_DLL_HEADER BaseBlockJacobiPrecond : public BaseMSMPrecond
   {
   protected:
     /// the table defining the blocks
@@ -38,6 +39,17 @@ namespace ngla
     /// deletes the table
     virtual ~BaseBlockJacobiPrecond ();
 
+    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);
+    }
+
+
+    
     /// performs steps Gauss-Seidel steps for the equation A x = b
     virtual void GSSmooth (BaseVector & x, const BaseVector & b,
 			   int steps = 1) const = 0;
@@ -101,8 +113,8 @@ namespace ngla
      The blocks are specified by a table container
   */
   template <class TM, class TV_ROW, class TV_COL>
-  class  NGS_DLL_HEADER BlockJacobiPrecond : virtual public BaseBlockJacobiPrecond,
-                                         virtual public S_BaseMatrix<typename mat_traits<TM>::TSCAL>
+  class  NGS_DLL_HEADER BlockJacobiPrecond : public BaseBlockJacobiPrecond,
+                                             public S_BaseMatrix<typename mat_traits<TM>::TSCAL>
   {
   protected:
     /// a reference to the matrix
@@ -190,8 +202,8 @@ namespace ngla
   ///
   template <class TM, class TV>
   class BlockJacobiPrecondSymmetric : 
-    virtual public BaseBlockJacobiPrecond,
-    virtual public S_BaseMatrix<typename mat_traits<TM>::TSCAL>
+    public BaseBlockJacobiPrecond,
+    public S_BaseMatrix<typename mat_traits<TM>::TSCAL>
   {
   protected:
     shared_ptr<const SparseMatrixSymmetric<TM,TV>> mat;

netgen/include/cholesky.hpp

@@ -503,7 +503,7 @@ namespace ngbla
     
     int n = mat.Height();
     STACK_ARRAY(T, mem, n);
-    FlatVector<T> dinv(n, &mem);
+    FlatVector<T> dinv(n, &mem[0]);
     
     for (size_t i = 0; i < n; i++)
       // CalcInverse (mat(i,i), dinv(i));
@@ -528,7 +528,7 @@ namespace ngbla
   {
     size_t n = mat.Height();
     STACK_ARRAY(T,mem, n);
-    FlatVector<T> dinv(n, &mem);
+    FlatVector<T> dinv(n, &mem[0]);
     
     for (size_t i = 0; i < n; i++)
       {

netgen/include/h1amg.hpp

@@ -1,9 +1,10 @@
-#ifndef H1AMG_HPP_
-#define H1AMG_HPP_
+#ifndef H1AMGxx_HPP_
+#define H1AMGxx_HPP_
 
 // #include <la.hpp>
 #include <basematrix.hpp>
 #include <sparsematrix.hpp>
+#include <preconditioner.hpp>
 
 namespace ngcomp
 {
@@ -36,6 +37,65 @@ namespace ngcomp
 
     virtual void Mult (const ngla::BaseVector & b, ngla::BaseVector & x) const override;
   };
+
+
+
+
+
+  template <class SCAL>
+  class H1AMG_Preconditioner : public Preconditioner
+  {
+    shared_ptr<BitArray> freedofs;
+    shared_ptr<H1AMG_Matrix<SCAL>> mat;
+
+    ParallelHashTable<IVec<2>,double> edge_weights_ht;
+    ParallelHashTable<IVec<1>,double> vertex_weights_ht;
+
+  public:
+
+    static shared_ptr<Preconditioner> CreateBF (shared_ptr<BilinearForm> bfa, const Flags & flags, const string & name)
+    {
+      if (bfa->GetFESpace()->IsComplex())
+        return make_shared<H1AMG_Preconditioner<Complex>> (bfa, flags, name);
+      else
+        return make_shared<H1AMG_Preconditioner<double>> (bfa, flags, name);
+    }
+
+    static DocInfo GetDocu ();    
+
+    H1AMG_Preconditioner (shared_ptr<BilinearForm> abfa, const Flags & aflags,
+                          const string aname = "H1AMG_cprecond")
+      : Preconditioner (abfa, aflags, aname)
+    {
+      if (is_same<SCAL,double>::value)
+        cout << IM(3) << "Create H1AMG" << endl;
+      else
+        cout << IM(3) << "Create H1AMG, complex" << endl;
+    }
+
+    virtual void InitLevel (shared_ptr<BitArray> _freedofs) override
+    {
+      freedofs = _freedofs;
+    }
+
+    virtual void FinalizeLevel (const BaseMatrix * matrix) override;
+
+    virtual void AddElementMatrix (FlatArray<int> dnums,
+                                   FlatMatrix<SCAL> elmat,
+                                   ElementId id,
+                                   LocalHeap & lh) override;
+
+    virtual void Update () override { ; }
+
+    virtual const BaseMatrix & GetMatrix() const override 
+    {
+      return *mat;
+    }
+
+  };
+
+
+  
 }
 
 #endif // H1AMG_HPP_

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/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/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;
   };
 
 }

netgen/include/meshaccess.hpp

@@ -1029,11 +1029,12 @@ namespace ngcomp
     ElementId FindElementOfPoint (FlatVector<double> point,
                                   IntegrationPoint & ip, 
                                   bool build_searchtree,
-                                  const Array<int> * const indices = NULL) const;
+                                  const Array<int> * const indices = NULL,
+                                  double tol = 1e-4) const;
     ElementId FindElementOfPoint (FlatVector<double> point,
                                   IntegrationPoint & ip, 
                                   bool build_searchtree,
-                                  int index) const;
+                                  int index, double tol = 1e-4) const;
     int FindSurfaceElementOfPoint (FlatVector<double> point,
 				   IntegrationPoint & ip, 
 				   bool build_searchtree,

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