ngsolve 6.2.2506.post75.dev0__cp314-cp314-manylinux_2_28_x86_64.whl

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/hidden.hpp

@@ -0,0 +1,74 @@
+#ifndef FILE_HIDDEN_
+#define FILE_HIDDEN_
+
+/*********************************************************************/
+/* File:   hidden.hpp                                                */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   Feb 2021                                                  */
+/*********************************************************************/
+
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+
+ // Hide all dofs of a space 
+
+  class HiddenFESpace : public FESpace
+  {
+  protected:
+    shared_ptr<FESpace> space;
+    
+  public:
+    HiddenFESpace (shared_ptr<FESpace> space, const Flags & flags);
+    
+    virtual ~HiddenFESpace () { ; }
+    void Update () override;
+    
+    void FinalizeUpdate() override
+    {
+      space->FinalizeUpdate();
+      FESpace::FinalizeUpdate();
+    }
+
+    virtual string GetClassName() const override { return "Hidden" + space->GetClassName(); }
+    shared_ptr<FESpace> GetBaseSpace() const { return space; }
+    
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
+
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+    virtual void GetDofNrs (NodeId ni, Array<DofId> & dnums) const override;
+
+    virtual SymbolTable<shared_ptr<DifferentialOperator>> GetAdditionalEvaluators () const override
+    { return space->GetAdditionalEvaluators (); }
+
+    [[deprecated("Use GetDofNrs(NODE_TYPE(NT_VERTEX,nr) instead")]]    
+    virtual void GetVertexDofNrs (int vnr,  Array<DofId> & dnums) const override;
+
+    [[deprecated("Use GetDofNrs(NODE_TYPE(NT_EDGE,nr) instead")]]        
+    virtual void GetEdgeDofNrs (int ednr, Array<DofId> & dnums) const override;
+    
+    virtual void GetFaceDofNrs (int fanr, Array<DofId> & dnums) const override;
+    
+    virtual void GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override
+    { space->GetInnerDofNrs(elnr, dnums); }
+
+    virtual void VTransformMR (ElementId ei,
+			       SliceMatrix<double> mat, TRANSFORM_TYPE tt) const override
+    { space-> VTransformMR(ei, mat, tt); }
+    virtual void VTransformMC (ElementId ei,
+                               SliceMatrix<Complex> mat, TRANSFORM_TYPE tt) const override
+    { space->VTransformMC (ei, mat, tt); }
+    virtual void VTransformVR (ElementId ei,
+                               SliceVector<double> vec, TRANSFORM_TYPE tt) const override
+    { space->VTransformVR(ei, vec, tt); }
+    virtual void VTransformVC (ElementId ei, 
+                               SliceVector<Complex> vec, TRANSFORM_TYPE tt) const override
+    { space->VTransformVC(ei, vec, tt); }    
+  };
+
+}
+
+
+#endif // FILE_HIDDEN_

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/householder.hpp

@@ -0,0 +1,181 @@
+#ifndef FILE_HOUSEHOLDER
+#define FILE_HOUSEHOLDER
+
+/****************************************************************************/
+/* File:   householder.hpp                                                  */
+/* Author: Joachim Schoeberl                                                */
+/* Date:   Nov 2020                                                         */
+/****************************************************************************/
+
+#include "matrix.hpp"
+
+
+namespace ngbla
+{
+
+  // find Householder reflection vector v such that
+  // reflection matrix H_v = I - 2 v v^T / (v^T v)
+  // leads to H_v x = +/- e_0 ||x||
+  // scaling such that v(0) = 1   
+  // returns (H_v x)(0) = +/- ||x||
+  extern NGS_DLL_HEADER double CalcHouseholderVectorInPlace (SliceVector<> x);
+
+  
+  // find Householder reflection vector v such that
+  // reflection matrix H_v = I - 2 v v^T / (v^T v)
+  // leads to H_v x = +/- e_0
+  // scaling such that v(0) = 1   
+  inline void CalcHouseholderVector (SliceVector<> x, FlatVector<> v)
+  {
+    v = x;
+    CalcHouseholderVectorInPlace (v);
+  }
+
+
+  
+  class NGS_DLL_HEADER HouseholderReflection
+  {
+    FlatVector<> v;
+    double factor;   // 2 / (v^T v)
+  public:
+    HouseholderReflection (FlatVector<> av);
+
+    template <ORDERING ORD>
+    void TMult (SliceMatrix<double,ORD> m2) const;
+    void Mult (FlatVector<double> v2) const;
+    void Mult (SliceMatrix<double,RowMajor> m2) const { TMult(m2); }
+    void Mult (SliceMatrix<double,ColMajor> m2) const { TMult(m2); }
+  };
+
+  // vector v is scaled such that v(0) = 1, but this value is not stores
+  class NGS_DLL_HEADER HouseholderReflection1
+  {
+    SliceVector<> v;
+    double factor;   // 2 / (v^T v)
+  public:
+    HouseholderReflection1 (SliceVector<> av);
+
+    template <ORDERING ORD>
+    void TMult (SliceMatrix<double,ORD> m2) const; 
+    void Mult (SliceMatrix<double,RowMajor> m2) const { TMult(m2); }
+    void Mult (SliceMatrix<double,ColMajor> m2) const { TMult(m2); }
+  };
+
+  
+  // H = H_{m-1} ... H_1 H_0 = I - V^T T V
+  template <ORDERING OMV>
+  class BaseMultiHouseholderReflection
+  {
+  protected:
+    SliceMatrix<double, OMV> mv;  // every row one reflection vector
+    FlatMatrix<> T;               // lower triangular
+  public:
+    BaseMultiHouseholderReflection (SliceMatrix<double, OMV> amv)
+      : mv(amv) { ; }
+    void CalcT();
+    template <ORDERING ORD>
+    void TMult (SliceMatrix<double,ORD> m2) const;  // Hm-1 * ... * H1 * H0 * m2
+    void Mult (SliceMatrix<double, RowMajor> m2) const { TMult (m2); } 
+    void Mult (SliceMatrix<double, ColMajor> m2) const { TMult (m2); }
+
+    template <ORDERING ORD>
+    void TMultTrans (SliceMatrix<double,ORD> m2) const; 
+    void MultTrans (SliceMatrix<double,RowMajor> m2) const { TMultTrans(m2); }
+    void MultTrans (SliceMatrix<double,ColMajor> m2) const { TMultTrans(m2); }
+  };
+
+  template <ORDERING OMV>  
+  class MultiHouseholderReflection : public BaseMultiHouseholderReflection<OMV>
+  {
+    ArrayMem<double, 96*96> mem;
+  public:
+    MultiHouseholderReflection (SliceMatrix<double, OMV> amv)
+      : BaseMultiHouseholderReflection<OMV> (amv), mem(sqr(amv.Height()))
+      {
+        this->T.AssignMemory (amv.Height(), amv.Height(), mem.Data());
+        this->CalcT();
+      }
+  };
+
+  template <ORDERING OMV>  
+  class MultiHouseholderReflectionMem : public BaseMultiHouseholderReflection<OMV>
+  {
+  public:
+    MultiHouseholderReflectionMem (SliceMatrix<double, OMV> amv, double * mem)
+      : BaseMultiHouseholderReflection<OMV> (amv)
+      {
+        this->T.AssignMemory (amv.Height(), amv.Height(), mem);
+        this->CalcT();
+      }
+  };
+  
+
+
+  // H is a generalized, normalized, lower left triangular matrix
+  // its columns are the Householder vectors
+  template <ORDERING OH, ORDERING OM>
+  void ApplyHouseholderReflections (SliceMatrix<double,OH> H, SliceMatrix<double,OM> M)
+  {
+    constexpr size_t bs = 48;
+    size_t n = H.Width();
+    size_t m = H.Height();
+
+    if (n > m) throw Exception("ApplyHouseholderReflections, n > m");
+    if (n == 0) return;
+    double mem[bs*bs];
+    for (size_t i = 0; i < n; i += bs)
+      {
+        size_t bsi = min(n-i, bs);
+        MultiHouseholderReflectionMem Hv(Trans(H.Cols(i,i+bsi).Rows(i, m)), &mem[0]);
+        Hv.Mult (M.Rows(i,m));
+      }
+  }
+
+  // H is a generalized, normalized, lower left triangular matrix
+  // its columns are the Householder vectors
+  // go backwards
+  template <ORDERING OH, ORDERING OM>
+  void ApplyHouseholderReflectionsTrans (SliceMatrix<double,OH> H, SliceMatrix<double,OM> M)
+  {
+    constexpr size_t bs = 48;
+    size_t n = H.Width();
+    size_t m = H.Height();
+
+    if (n > m) throw Exception("ApplyHouseholderReflections, n > m");
+    if (n == 0) return;
+    
+    // for (size_t i = 0; i < n; i += bs)
+    double mem[bs*bs];    
+    for (size_t i = n; i+bs > bs; i -= bs)
+      {
+        size_t first = max(bs, i)-bs;
+        size_t last = i;
+        MultiHouseholderReflectionMem Hv(Trans(H.Cols(first, last).Rows(first, m)), &mem[0]);
+        Hv.MultTrans (M.Rows(first,m));
+      }
+  }
+
+  
+  
+  /*
+    Factorize A = Q R
+    A is m x n, overwritten by R
+    Q is either m x m  or m x n
+  */
+  extern NGS_DLL_HEADER void QRFactorization (SliceMatrix<> A, SliceMatrix<> Q);
+
+  extern NGS_DLL_HEADER void QRFactorizationInPlace (SliceMatrix<double,RowMajor> A);
+  extern NGS_DLL_HEADER void QRFactorizationInPlace (SliceMatrix<double,ColMajor> A);
+
+  extern NGS_DLL_HEADER void InverseFromQR (SliceMatrix<double> A);
+  
+  extern NGS_DLL_HEADER void CalcSVD (SliceMatrix<double, RowMajor> A, 
+                                      SliceMatrix<double, ColMajor> U,
+                                      SliceMatrix<double, ColMajor> V);
+  
+  extern NGS_DLL_HEADER void CalcSVD (SliceMatrix<double, ColMajor> A, 
+                                      SliceMatrix<double, ColMajor> U,
+                                      SliceMatrix<double, ColMajor> V);
+}
+
+#endif

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/hypre_ams_precond.hpp

@@ -0,0 +1,123 @@
+#ifdef HYPRE
+
+#ifndef FILE_AMS_HYPRE_PRECOND
+#define FILE_AMS_HYPRE_PRECOND
+
+
+/*********************************************************************/
+/* File:   hypre_precond.hpp                                         */
+/* Author: Lukas Kolger                                              */
+/* Date:   May 2017                                                  */
+/*********************************************************************/
+
+
+#include "HYPRE_utilities.h"
+
+#include "HYPRE.h"
+#include "HYPRE_parcsr_ls.h"
+
+
+namespace ngcomp
+{
+
+  
+class HypreAMSPreconditioner : public Preconditioner
+{
+
+  // HYPRE-side
+
+  HYPRE_Solver precond; // the AMS solver
+  
+  // discrete gradient matrix
+  HYPRE_IJMatrix grad_mat;
+  HYPRE_ParCSRMatrix parcsr_grad_mat;
+
+  // stiffness matrix alpha<curl,curl>+beta<,>
+  HYPRE_IJMatrix A; 
+  HYPRE_ParCSRMatrix parcsr_A;
+
+  // alpha <grad,grad>
+  HYPRE_IJMatrix alpha_mat;
+  HYPRE_ParCSRMatrix parcsr_alpha_mat;
+
+  // beta <grad, grad>
+  bool beta_is_zero = false;
+  HYPRE_IJMatrix beta_mat;
+  HYPRE_ParCSRMatrix parcsr_beta_mat;
+
+  // working vecs
+  HYPRE_IJVector b;
+  HYPRE_ParVector par_b;
+  HYPRE_IJVector x;
+  HYPRE_ParVector par_x;
+
+
+
+  // NGSOLVE-side
+
+  int rank, np;
+  
+  shared_ptr<BilinearForm> bfa; // BLF for the system
+  shared_ptr<BilinearForm> bf_alpha; // alpha-mat - currently UNUSED!
+  shared_ptr<BilinearForm> bf_beta; // beta-mat - currently UNUSED!
+  shared_ptr<BaseMatrix> ngs_grad_mat; //discrete grad-mat
+
+  int dimension = 3; //spatial dimension
+
+  shared_ptr<FESpace> hcurlfes;
+  shared_ptr<BitArray> hc_freedofs;
+  shared_ptr<ParallelDofs> hc_pardofs;
+  int hc_ndof;
+  Array<int> hc_global_nums;
+  int hc_ilower, hc_iupper;
+  Array<int> hc_masterdofs;
+  Array<double> buf_hc;
+  Array<double> buf_z;
+  Array<int> hc_intrange;
+
+  shared_ptr<FESpace> h1fes;
+  shared_ptr<BitArray> h1_freedofs;
+  shared_ptr<ParallelDofs> h1_pardofs;
+  int h1_ndof;
+  Array<int> h1_global_nums;
+  int h1_ilower, h1_iupper;
+
+  bool parallel;
+
+
+public:
+
+  // dummy constructors - not implemented
+  HypreAMSPreconditioner (const BaseMatrix & matrix, const shared_ptr<BitArray> afreedofs); 
+
+  // actually implemented!
+  HypreAMSPreconditioner (shared_ptr<BilinearForm> bfa, const Flags & aflags,
+			  const string aname = "precond");
+  HypreAMSPreconditioner (shared_ptr<FESpace> ahcurlfes, shared_ptr<BilinearForm> abfa,
+			  shared_ptr<FESpace> ah1fes, shared_ptr<BaseMatrix> agrad_mat,
+			  shared_ptr<BilinearForm> abf_alpha, shared_ptr<BilinearForm> abf_beta, 
+			  Flags & flags);
+
+  ~HypreAMSPreconditioner ();
+	
+  virtual void FinalizeLevel (const ngla::BaseMatrix * mat = NULL) override;
+  virtual void Update() override;
+  virtual void Mult (const BaseVector & f, BaseVector & u) const override;
+  virtual int VHeight() const override { return hc_ndof; }
+  virtual int VWidth() const override { return hc_ndof; }
+  virtual const BaseMatrix & GetAMatrix() const override { return bfa->GetMatrix(); }
+  virtual const BaseMatrix & GetMatrix() const override { return *this; }
+
+  virtual const char * ClassName() const override
+  { return "HYPRE AMG Preconditioner"; }
+
+private:
+  void Setup ();
+};
+
+}
+
+
+
+#endif
+#endif

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/hypre_precond.hpp

@@ -0,0 +1,73 @@
+#ifdef HYPRE
+
+#ifndef FILE_HYPRE_PRECOND
+#define FILE_HYPRE_PRECOND
+
+
+/*********************************************************************/
+/* File:   hypre_precond.hpp                                         */
+/* Author: Martin Huber, Joachim Schoeberl                           */
+/* Date:   July 2012                                                 */
+/*********************************************************************/
+
+
+#include "HYPRE_utilities.h"
+// #include "HYPRE_krylov.h"
+
+#include "HYPRE.h"
+#include "HYPRE_parcsr_ls.h"
+
+
+namespace ngcomp
+{
+
+  
+class HyprePreconditioner : public Preconditioner
+{
+  shared_ptr<BilinearForm> bfa;
+
+  HYPRE_Solver precond;
+  HYPRE_IJMatrix A;
+  HYPRE_ParCSRMatrix parcsr_A;
+
+  Array<int> global_nums;
+  int ilower, iupper;
+  shared_ptr<BitArray> freedofs;
+  shared_ptr<ParallelDofs> pardofs;
+
+public:
+    
+  // HyprePreconditioner (const PDE & pde, const Flags & flags, const string & name);
+  HyprePreconditioner (const BaseMatrix & matrix, const shared_ptr<BitArray> afreedofs); 
+  HyprePreconditioner (shared_ptr<BilinearForm> bfa, const Flags & aflags,
+		       const string aname = "precond");
+
+  ~HyprePreconditioner ();
+	
+  virtual void FinalizeLevel (const ngla::BaseMatrix * mat = NULL) override;
+  virtual void Update() override;
+  virtual void Mult (const BaseVector & f, BaseVector & u) const override;
+  virtual int VHeight() const override { return pardofs->GetNDofLocal();}
+  virtual int VWidth() const override { return pardofs->GetNDofLocal();}
+  virtual const BaseMatrix & GetAMatrix() const override { return bfa->GetMatrix(); }
+  virtual const BaseMatrix & GetMatrix() const override { return *this; }
+
+  virtual const char * ClassName() const override
+  { return "HYPRE AMG Preconditioner"; }
+
+private:
+  void Setup (const BaseMatrix & matrix);
+};
+
+}
+
+
+
+#endif
+#endif
+
+
+
+
+
+