ngsolve 6.2.2504.post44.dev0__cp311-cp311-win_amd64.whl → 6.2.2601__cp311-cp311-win_amd64.whl

netgen/include/contact.hpp

@@ -89,6 +89,7 @@ namespace ngcomp
     shared_ptr<CoefficientFunction> cf;
     shared_ptr<FESpace> fes;
     Array<ProxyFunction*> trial_proxies;
+    Array<CoefficientFunction*> cf_gridfunctions;
     bool deformed;
 
   public:
@@ -123,6 +124,9 @@ namespace ngcomp
     shared_ptr<CoefficientFunction> cf;
     shared_ptr<FESpace> fes;
     Array<ProxyFunction*> trial_proxies, test_proxies;
+    Array<CoefficientFunction*> cf_gridfunctions;
+    Array<shared_ptr<CoefficientFunction>> dcf_dtest;  // derivatives by test-functions
+    Matrix<shared_ptr<CoefficientFunction>> ddcf_dtest_dtrial;  // derivatives by test- and trial-functions
     bool deformed;
   public:
     ContactIntegrator(shared_ptr<CoefficientFunction> _cf,
@@ -187,6 +191,10 @@ namespace ngcomp
     const auto& GetIntegrators(bool def) const { return def ? deformed_integrators : undeformed_integrators; }    
     shared_ptr<FESpace> GetFESpace() const { return fes; }
     tuple<FlatArray<Vec<3>>, FlatArray<Vec<3>>> GetDrawingPairs() { return {primary_points, secondary_points}; }
+    auto GetCArgs() {
+      return std::make_tuple(master, other, draw_pairs, volume, element_boundary);
+    }
+    void DoArchive(Archive& ar);
   };
 
   template<int DIM>

netgen/include/diagonalmatrix.hpp

@@ -47,6 +47,10 @@ namespace ngla
       Mult (v, res);
       return res;
     }
+    AutoVector EvaluateTrans(BaseVector & v) const override
+    {
+      return this->Evaluate(v);
+    }
     
   };
 
@@ -144,6 +148,8 @@ namespace ngla
 
     FlatTensor<3> GetBlockDiag () const { return blockdiag; }
     FlatMatrix<bool> GetNonZeroPattern() const { return nonzero; }
+    FlatTable<int> GetSparseMatrix() const { return sparse; }
+    FlatTable<int> GetSparseMatrixTrans() const { return sparseT; }
   };
 
 }

netgen/include/diffop_impl.hpp

@@ -312,10 +312,12 @@ namespace ngfem
   
   template <typename DIFFOP>
   void T_DifferentialOperator<DIFFOP> ::
-  CalcTransformationMatrix (const BaseMappedIntegrationPoint & mip,
+  CalcTransformationMatrix (const BaseMappedIntegrationPoint & bmip,
                             SliceMatrix<double> trans,
                             LocalHeap & lh) const
   {
+    const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE> & mip =
+      static_cast<const MappedIntegrationPoint<DIM_ELEMENT,DIM_SPACE>&> (bmip);
     DIFFOP::CalcTransformationMatrix(mip, trans, lh);    
   }
   

netgen/include/diffopwithfactor.hpp

@@ -0,0 +1,123 @@
+#ifndef DIFFOPWITHFACTOR_HPP
+#define DIFFOPWITHFACTOR_HPP
+
+
+
+namespace ngsbem
+{
+  using namespace ngfem;
+
+  class DifferentialOperatorWithFactor : public DifferentialOperator
+  {
+    shared_ptr<DifferentialOperator> diffop;
+    shared_ptr<CoefficientFunction> factor;
+
+  public:
+    DifferentialOperatorWithFactor (shared_ptr<DifferentialOperator> adiffop,
+                                    shared_ptr<CoefficientFunction> afactor)
+      : DifferentialOperator(afactor->Dimensions()[0], 1, adiffop->VB(), adiffop->DiffOrder()),
+        diffop(adiffop), factor(afactor)
+    {
+      ;
+    }
+
+    int DimRef() const override { return diffop->DimRef(); }
+
+    virtual IntRange UsedDofs(const FiniteElement & fel) const override { return diffop->UsedDofs(fel); }
+
+    auto BaseDiffOp() const { return diffop; }
+
+    void CalcMatrix (const FiniteElement & fel,
+                     const BaseMappedIntegrationPoint & mip,
+                     BareSliceMatrix<double,ColMajor> mat, 
+                     LocalHeap & lh) const override
+    {
+      FlatMatrix<double,ColMajor> hmat(diffop->Dim(), fel.GetNDof(), lh);
+      diffop -> CalcMatrix (fel, mip, hmat, lh);
+
+      auto dims = factor->Dimensions();      
+      FlatMatrix<double> factorx(dims[0], dims[1], lh);
+      factor->Evaluate (mip, factorx.AsVector());
+
+      IntRange used = diffop->UsedDofs(fel);
+      mat.Cols(used) = factorx * hmat.Cols(used);
+    }
+    
+    void CalcMatrix (const FiniteElement & fel,
+                     const SIMD_BaseMappedIntegrationRule & mir,
+                     BareSliceMatrix<SIMD<double>> mat) const override
+    {
+      // *testout << "CalcMatrix SIMD" << endl;      
+      Matrix<SIMD<double>> hmat (fel.GetNDof()*diffop->Dim(), mir.Size());
+      // hmat = SIMD<double>(0.0);
+      diffop -> CalcMatrix (fel, mir, hmat);
+
+      Matrix<SIMD<double>> fac(factor->Dimension(), mir.Size());
+      factor -> Evaluate (mir, fac);
+
+      auto dims = factor -> Dimensions();
+
+      mat.Rows(fel.GetNDof()*dims[1]).Cols(mir.Size()) = SIMD<double>(0.0);
+      
+      for (size_t i = 0; i < mir.Size(); i++)
+        for (size_t j = 0; j < dims[0]; j++)
+          for (size_t k = 0; k < dims[1]; k++)
+            mat.Col(i).Slice(j,dims[0]) += fac(j*dims[1]+k, i) * hmat.Col(i).Slice(k, dims[1]);
+    }
+    
+
+    void CalcMatrix (const FiniteElement & fel,
+                     const IntegrationPoint & ip,
+                     BareSliceMatrix<double,ColMajor> mat,
+                     LocalHeap & lh) const override
+    {
+      diffop -> CalcMatrix(fel, ip, mat, lh);
+      /*
+      *testout << "calcmatrix mip" << endl
+               << mat.Rows(Dim()).Cols(fel.GetNDof()) << endl;
+      */
+    }
+
+    void CalcTransformationMatrix (const BaseMappedIntegrationPoint & mip,
+                                   SliceMatrix<double> trans,
+                                   LocalHeap & lh) const override
+    {
+      HeapReset hr(lh);
+      auto dims = factor->Dimensions();
+      
+      FlatMatrix<double> factorx(dims[0], dims[1], lh);
+      factor->Evaluate (mip, factorx.AsVector());
+
+      FlatMatrix<double> basetrans(diffop->Dim(), diffop->DimRef(), lh);
+      diffop -> CalcTransformationMatrix(mip, basetrans, lh);
+
+      trans = factorx * basetrans;
+      // *testout << "trans = " << trans << endl;
+    }
+
+
+    void Apply (const FiniteElement & fel,
+                const SIMD_BaseMappedIntegrationRule & mir,
+                BareSliceVector<double> x, 
+                BareSliceMatrix<SIMD<double>> flux) const override
+    {
+      auto dims = factor->Dimensions();
+
+      Matrix<SIMD<double>> tmpflux(dims[1], mir.Size());
+      Matrix<SIMD<double>> factorx(dims[0]*dims[1], mir.Size());
+      
+      diffop -> Apply (fel, mir, x, tmpflux);
+      factor -> Evaluate (mir, factorx);
+      flux.Rows(0, dims[0]).Cols(0, mir.Size()) = SIMD<double>(0.0);
+      for (int i = 0; i < dims[0]; i++)
+        for (int j = 0; j < dims[1]; j++)
+          flux.Row(i).Range(mir.Size()) += pw_mult(factorx.Row(i*dims[1]+j), tmpflux.Row(j));
+    }
+
+    
+  };
+
+
+}
+
+#endif

netgen/include/elementbyelement.hpp

@@ -131,10 +131,13 @@ namespace ngla
   {
     size_t h, w;
     Matrix<SCAL> matrix;
-    Table<int> col_dnums;
-    Table<int> row_dnums;
+    Table<int> col_dnums;   // output
+    Table<int> row_dnums;   // input
     bool disjoint_rows, disjoint_cols;
     Table<int> row_coloring, col_coloring;
+    bool output_onto = false;
+    bool output_matrix = false;
+    bool output_matrix_trans = false;
   public:
     ConstantElementByElementMatrix (size_t ah, size_t aw, Matrix<SCAL> amatrix,
                                     Table<int> acol_dnums, Table<int> arow_dnums);
@@ -157,7 +160,10 @@ namespace ngla
     FlatTable<int> GetColDNums() const { return col_dnums; }
 
     FlatTable<int> GetRowColoring() const { return row_coloring; }    
-    FlatTable<int> GetColColoring() const { return col_coloring; }    
+    FlatTable<int> GetColColoring() const { return col_coloring; }
+
+    bool OutputMatrix() const { return output_matrix; }
+    bool OutputMatrixTrans() const { return output_matrix_trans; } 
   };
 
   class NGS_DLL_HEADER StructuredElementByElementMatrix : public BaseMatrix

netgen/include/expr.hpp

@@ -291,9 +291,9 @@ namespace ngbla
   struct undefined_size
     {
       undefined_size() = default;
-      undefined_size(size_t s) { }
+      INLINE undefined_size(size_t s) { }
       template <int S>
-      explicit constexpr undefined_size(IC<S> s) { }
+      INLINE explicit constexpr undefined_size(IC<S> s) { }
   };
   
   inline ostream & operator<< (ostream & ost, undefined_size s) { ost << "undefined"; return ost; }
@@ -515,7 +515,7 @@ namespace ngbla
         }
 
 
-      if (TB::IsLinear())
+      if constexpr (TB::IsLinear())
 	{
 	  if (T::IsLinear())
 	    {
@@ -573,9 +573,6 @@ namespace ngbla
 
     enum { COL_MAJOR = 0 };  // matrix is stored col-major
 
-    void Dump (ostream & ost) const { ost << "Matrix"; }
-
-
 
     template<typename TOP, typename TB>
     INLINE auto & Assign (const Expr<TB> & v)
@@ -735,6 +732,11 @@ namespace ngbla
     {
       return (*this) *= (1./s);
     }
+
+
+    void Dump (ostream & ost) const
+    { ost << "Matexpr (h=" << Height() << ", w=" << Width() << ")"; }
+    
   };
 
 
@@ -838,6 +840,7 @@ namespace ngbla
   {
     TA a;
   public:
+    MinusExpr (const MinusExpr&) = default;
     MinusExpr (TA aa) : a(aa) { ; }
 
     template <typename ...I>
@@ -850,7 +853,10 @@ namespace ngbla
     INLINE auto Width() const { return a.Width(); }
     INLINE TA A() const { return a; }
 
-    static constexpr bool IsLinear() { return TA::IsLinear(); } 
+    static constexpr bool IsLinear() { return TA::IsLinear(); }
+    void Dump (ostream & ost) const
+    { ost << "-("; a.Dump(ost); ost << ")"; }
+    
   };
 
   template <typename TA>
@@ -934,6 +940,7 @@ namespace ngbla
   public:
     static constexpr bool IsLinear() { return TA::IsLinear(); }
 
+    ScaleExpr (const ScaleExpr&) = default;
     INLINE ScaleExpr (TA aa, TS as) : a(aa), s(as) { ; }
     
     // INLINE auto operator() (size_t i) const { return s * a(i); }
@@ -1492,8 +1499,39 @@ namespace ngbla
   }
 
 
+  /* ************************* OuterProduct ********************** */
+  
+  template <class TA, class TB>
+  class OuterProductExpr : public Expr<OuterProductExpr<TA,TB>>
+  {
+    TA a;
+    TB b;
+  public:
+    OuterProductExpr (TA aa, TB ab) : a(aa), b(ab) { ; }
 
+    // INLINE auto operator() (size_t i) const { return a[i] * b(i); }  
+    INLINE auto operator() (size_t i, size_t j) const { return a[i] * b[j]; }
 
+    INLINE auto View() const { return *this; }
+    INLINE auto Shape() const
+    {
+      return tuple<size_t,size_t> (a.Size(), b.Width());
+    }
+    
+    INLINE const auto A() const { return a; }
+    INLINE const auto B() const { return b; }
+    INLINE auto Height() const { return a.Size(); }
+    INLINE auto Width() const { return b.Size(); }
+
+    static constexpr bool IsLinear() { return false; }         
+  };
+
+
+  template <typename TA, typename TB>
+  INLINE auto OuterProduct (const Expr<TA> & a, const Expr<TB> & b)
+  {
+    return OuterProductExpr (a.View(), b.View());
+  }
 
 
 

netgen/include/fespace.hpp

@@ -448,7 +448,8 @@ ANY                  1 1 1 1 | 15
     virtual void GetDofNrs (NodeId ni, Array<DofId> & dnums) const;
     BitArray GetDofs (const Region & reg) const;
     Table<int> CreateDofTable (VorB vorb) const;
-
+    virtual void SelectDofs (const string & name, BitArray & dofs) const;
+                  
     /// get coupling types of dofs
     virtual void GetDofCouplingTypes (int elnr, Array<COUPLING_TYPE> & dnums) const;
     
@@ -531,8 +532,13 @@ ANY                  1 1 1 1 | 15
     void SetDefinedOnBoundary (const BitArray & defon)
      { SetDefinedOn(BND,defon); }
 
+    const Array<bool> & GetDefinedOn (VorB vb) const { return definedon[vb]; }
+
     ///
     void SetDirichletBoundaries (const BitArray & dirbnds);
+    const BitArray & GetDirichletBoundaries (VorB vb) const { return dirichlet_constraints[vb]; }
+
+
     /// Get reference element for tet, prism, trig, etc ..
     // const FiniteElement & GetFE (ELEMENT_TYPE type) const;
 
@@ -1141,7 +1147,8 @@ ANY                  1 1 1 1 | 15
     void GetEdgeDofNrs (int ednr, Array<DofId> & dnums) const override;
     void GetFaceDofNrs (int fanr, Array<DofId> & dnums) const override;
     void GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override;
-
+    void SelectDofs (const string & name, BitArray & dofs) const override;
+    
     void SolveM(CoefficientFunction * rho, BaseVector & vec, Region * definedon,
                         LocalHeap & lh) const override;
     void ApplyM(CoefficientFunction * rho, BaseVector & vec, Region * definedon,

netgen/include/gridfunction.hpp

@@ -157,16 +157,16 @@ namespace ngcomp
     int GetMultiDim () const { return multidim; }
 
     /// increase multidim and copy vec to new component
-    void AddMultiDimComponent (BaseVector & vec);
+    void AddMultiDimComponent (BaseVector & vec, bool copy = true);
   
     int GetLevelUpdated() const { return level_updated; }
     ///
 
     // const FESpace & GetFESpace() const { return *fespace; }
     ///
-    shared_ptr<FESpace> GetFESpace() const { return fespace; }
+    const shared_ptr<FESpace> & GetFESpace() const { return fespace; }
     ///
-    shared_ptr<MeshAccess> GetMeshAccess() const { return fespace->GetMeshAccess(); }
+    const shared_ptr<MeshAccess> & GetMeshAccess() const { return fespace->GetMeshAccess(); }
     ///
     virtual string GetClassName () const
     {

netgen/include/h1amg.hpp

@@ -9,6 +9,20 @@
 namespace ngcomp
 {
   using namespace ngla;
+
+
+
+  struct H1AMG_Parameters
+  {
+    int verbose = 0;
+    int smoothing_steps = 3;
+    int coarsenings_per_level = 3; // number of binary coarsenings per level
+    bool block_smoother = true;    // block or point smoother ?
+    bool use_smoothed_prolongation = true;
+    int max_coarse = 10;
+    int max_level = 20;
+  };
+
   
   template <class SCAL>
   class NGS_DLL_HEADER H1AMG_Matrix : public ngla::BaseMatrix
@@ -26,6 +40,7 @@ namespace ngcomp
                   ngcore::FlatArray<ngcore::IVec<2>> e2v,
                   ngcore::FlatArray<double> edge_weights,
                   ngcore::FlatArray<double> vertex_weights,
+                  const H1AMG_Parameters & param,                  
                   size_t level);
 
     virtual int VHeight() const override { return size; }
@@ -50,7 +65,9 @@ namespace ngcomp
 
     ParallelHashTable<IVec<2>,double> edge_weights_ht;
     ParallelHashTable<IVec<1>,double> vertex_weights_ht;
-
+    
+    H1AMG_Parameters param;
+    
   public:
 
     static shared_ptr<Preconditioner> CreateBF (shared_ptr<BilinearForm> bfa, const Flags & flags, const string & name)
@@ -71,6 +88,12 @@ namespace ngcomp
         cout << IM(3) << "Create H1AMG" << endl;
       else
         cout << IM(3) << "Create H1AMG, complex" << endl;
+      
+      param.verbose = int(flags.GetNumFlag("verbose", 0));
+      param.smoothing_steps = int(flags.GetNumFlag("smoothingsteps", 1));    
+      param.use_smoothed_prolongation = flags.GetDefineFlagX("smoothedprolongation").IsMaybeTrue();
+      param.max_coarse = int(flags.GetNumFlag("maxcoarse", 10));
+      param.max_level = int(flags.GetNumFlag("maxlevel", 20));
     }
 
     virtual void InitLevel (shared_ptr<BitArray> _freedofs) override

netgen/include/h1lumping.hpp

@@ -25,6 +25,12 @@ namespace ngcomp
 
 
     void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+    void GetVertexDofNrs (int vnr, Array<int> & dnums) const override;
+    void GetEdgeDofNrs (int ednr, Array<int> & dnums) const override;
+    void GetFaceDofNrs (int fanr, Array<int> & dnums) const override;
+    void GetInnerDofNrs (int elnr, Array<int> & dnums) const override;
+
+
     
     FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
 

netgen/include/hcurl_equations.hpp

@@ -643,6 +643,17 @@ namespace ngfem
     enum { DIM_DMAT = 1 };
     enum { DIFFORDER = 1 };
 
+    static string Name() { return "curl"; }
+
+    static const FEL & Cast(const FiniteElement & fel)
+    {
+        return static_cast<const FEL&> (fel);
+    }
+
+    
+    static int DimRef() { return 1; }
+
+    
     static constexpr bool SUPPORT_PML = true;
     template <typename AFEL, typename MIP, typename MAT>
     static void GenerateMatrix (const AFEL & fel, const MIP & mip,
@@ -651,6 +662,22 @@ namespace ngfem
       mat = 1.0/mip.GetJacobiDet() * 
 	Trans (static_cast<const FEL&>(fel).GetCurlShape(mip.IP(),lh));
     }
+    
+    template<typename IP, typename MAT>
+    static void GenerateMatrixRef (const FiniteElement & fel, const IP & ip,
+                                   MAT && mat, LocalHeap & lh)
+    {
+      Cast(fel).CalcCurlShape (ip, Trans(mat));
+    }
+
+    template <typename MIP, typename MAT>
+    static void CalcTransformationMatrix (const MIP & mip,
+                                          MAT & mat, LocalHeap & lh)
+    {
+      // auto & mip = static_cast<const MappedIntegrationPoint<D-1,D>&>(bmip);
+      mat = 1./mip.GetJacobiDet();
+    }
+    
 
     static void GenerateMatrixSIMDIR (const FiniteElement & fel,
                                       const SIMD_BaseMappedIntegrationRule & mir,
@@ -701,6 +728,8 @@ public:
   enum { DIM_DMAT = 3 };
   enum { DIFFORDER = 1 };
 
+  static string Name() { return "curl"; }
+  
     static constexpr bool SUPPORT_PML = true;
   static const FEL & Cast (const FiniteElement & fel) 
   { return static_cast<const FEL&> (fel); }

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