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

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/normalfacetfespace.hpp

@@ -0,0 +1,98 @@
+#ifndef NORMAL_FACET_FESPACE_HPP
+#define NORMAL_FACET_FESPACE_HPP
+
+/*********************************************************************/
+/* File:   normalfacetfespace.hpp                                    */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   2019                                                      */
+/*********************************************************************/
+
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+
+  class NGS_DLL_HEADER NormalFacetFESpace : public FESpace
+  {
+  protected:
+    int level;
+    Array<int> first_facet_dof;
+    Array<int> first_inner_dof;  // for highest_order_dc
+
+    int rel_order;
+
+    Array<IVec<2> > order_facet;
+    Array<bool> fine_facet;
+
+    // int ndof;
+    // Array<int> ndlevel;
+    bool var_order;
+    bool print;
+
+    bool highest_order_dc;
+    bool hide_highest_order_dc;
+    
+  public:
+    NormalFacetFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, 
+			bool parseflags = false );
+
+    virtual ~NormalFacetFESpace () { ; }
+    static DocInfo GetDocu ();
+
+    virtual string GetClassName () const override
+    {
+      return "NormalFacetFESpace";
+    }
+
+    void Update() override;
+    virtual void UpdateCouplingDofArray() override;
+
+    virtual void SetOrder (NodeId ni, int order) override;
+    virtual int GetOrder (NodeId ni) const override;
+    
+    // virtual size_t GetNDof() const throw() override { return ndof; }
+    // virtual size_t GetNDofLevel ( int i ) const override { return ndlevel[i]; }
+
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+
+    virtual FiniteElement & GetFE(ElementId ei, Allocator & lh) const override;
+    
+    virtual void GetFacetDofNrs (int felnr, Array<DofId> & dnums) const;
+
+    virtual int GetNFacetDofs (int felnr) const;
+
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+
+    auto GetFacetDofs (size_t nr) const
+    {
+      return Range (first_facet_dof[nr], first_facet_dof[nr+1]);
+    }
+    
+
+    virtual shared_ptr<Table<int>> CreateSmoothingBlocks (const Flags & precflags) const override;
+    ///
+    virtual shared_ptr<Array<int>> CreateDirectSolverClusters (const Flags & precflags) const override;
+  
+    // some utility functions for convenience
+    ///
+    // virtual void GetVertexNumbers(int elnr, Array<int>& vnums) const;
+    ///
+    virtual IVec<2> GetFacetOrder(int fnr) const;
+
+    virtual int GetFirstFacetDof(int fanr) const;
+
+    virtual bool UsesHighestOrderDiscontinuous() const {return highest_order_dc;};
+
+    virtual void GetVertexDofNrs (int elnum, Array<DofId> & dnums) const override;
+    virtual void GetEdgeDofNrs (int elnum, Array<DofId> & dnums) const override;
+    virtual void GetFaceDofNrs (int felnr, Array<DofId> & dnums) const override;
+    virtual void GetInnerDofNrs (int felnr, Array<DofId> & dnums) const override;
+
+  };
+
+}
+
+#endif
+

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/normalfacetsurfacefespace.hpp

@@ -0,0 +1,84 @@
+#ifndef NORMAL_FACET_SURFACE_FESPACE_HPP
+#define NORMAL_FACET_SURFACE_FESPACE_HPP
+
+/*********************************************************************/
+/* File:   normalfacetsurfacefespace.hpp                             */
+/* Author: Michael Neunteufel                                        */
+/* Date:   2020                                                      */
+/*********************************************************************/
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+
+  class NGS_DLL_HEADER NormalFacetSurfaceFESpace : public FESpace
+  {
+  protected:
+    Array<int> first_facet_dof;
+
+    int rel_order;
+
+    Array<IVec<2> > order_facet;
+    Array<bool> fine_facet;
+
+    int ndof;
+    Array<int> ndlevel;
+    bool var_order;
+    bool print = false;
+
+    
+  public:
+    NormalFacetSurfaceFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, 
+			bool parseflags = false );
+
+    virtual ~NormalFacetSurfaceFESpace () { ; }
+    static DocInfo GetDocu ();
+
+    virtual string GetClassName () const override
+    {
+      return "NormalFacetSurfaceFESpace";
+    }
+
+    void Update() override;
+    virtual void UpdateCouplingDofArray() override;
+
+    virtual void SetOrder (NodeId ni, int order) override;
+    virtual int GetOrder (NodeId ni) const override;
+    
+    virtual size_t GetNDof() const throw() override { return ndof; }
+
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+
+    virtual FiniteElement & GetFE(ElementId ei, Allocator & lh) const override;
+    
+    virtual int GetNFacetDofs (int felnr) const;
+
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+
+    auto GetFacetDofs (size_t nr) const
+    {
+      return Range (first_facet_dof[nr], first_facet_dof[nr+1]);
+    }
+    
+  
+    // some utility functions for convenience
+    ///
+    // virtual void GetVertexNumbers(int elnr, Array<int>& vnums) const;
+    ///
+    virtual IVec<2> GetFacetOrder(int fnr) const;
+
+    virtual int GetFirstFacetDof(int fanr) const;
+
+    virtual void GetVertexDofNrs (int elnum, Array<DofId> & dnums) const override;
+    virtual void GetEdgeDofNrs (int elnum, Array<DofId> & dnums) const override;
+    virtual void GetFaceDofNrs (int felnr, Array<DofId> & dnums) const override;
+    virtual void GetInnerDofNrs (int felnr, Array<DofId> & dnums) const override;
+
+  };
+
+}
+
+#endif
+

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/order.hpp

@@ -0,0 +1,251 @@
+#ifndef FILE_ORDER
+#define FILE_ORDER
+
+/* *************************************************************************/
+/* File:   order.hpp                                                      */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   18. Jun. 97                                                    */
+/* *************************************************************************/
+
+
+namespace ngla
+{
+  using namespace ngcore;
+  using namespace ngstd;  
+
+  /*
+    reordering for sparse cholesky factoriztion
+  */
+
+  ///
+  class MDOPriorityQueue
+  {
+    struct entry { 
+      int degree, prev, next;
+      void DoArchive(Archive& ar) { ar & degree & prev & next; }
+    };
+    Array<entry> list;
+    Array<int> first_in_class;
+  public:
+    MDOPriorityQueue (int size, int maxdeg);
+    MDOPriorityQueue () {}
+    ~MDOPriorityQueue ();
+
+    void DoArchive(Archive& ar);
+
+    int MinDegree () const;
+    int GetDegree (int nr) const { return list[nr].degree; }
+    void SetDegree (int nr, int deg);
+    void Invalidate (int nr);
+
+    const MemoryTracer& GetMemoryTracer() const
+    {
+      return mt;
+    }
+
+    void StartMemoryTracing() const
+    {
+      mt.Track(list, "list", first_in_class, "first_in_class");
+    }
+  private:
+    MemoryTracer mt;
+  };
+
+
+  ///
+  class MDOVertex
+  {
+  protected:
+    int master;         /// master of node
+    int nextminion;      /// linked list of minions
+    int numminions;      /// number of minions
+    int numcliques;     /// number of cliques
+    bool eliminated;    /// node is eliminated
+    bool used;          /// temporary field (used in calcorder)
+    bool flag;          
+    
+
+  public:
+    ///
+    int * connected = nullptr;
+    ///
+    int nconnected;
+
+    ///
+    MDOVertex() = default;
+    MDOVertex(int ma)  { Init (ma); }
+    ///
+    ~MDOVertex()   { ; }
+
+    void DoArchive(Archive& ar);
+
+    /// 
+    void Init (int ma)
+    {
+      master = ma;
+      nextminion = -1;
+      numminions = 0;
+      numcliques = 0;
+      flag = 0;
+      eliminated = 0;
+      used = 0;
+    }
+
+    ///
+    int Master() const { return master; };
+    ///
+    void SetMaster(int ma) { master = ma; };
+    ///
+    int NextMinion () const {return nextminion; };
+    ///
+    void SetNextMinion( int ns ) { nextminion = ns; };
+    ///
+    bool Eliminated() const {return eliminated; };
+    ///
+    void SetEliminated(bool el) {eliminated = el; };
+    ///
+    bool Used() const {return used; };
+    ///
+    void SetUsed(bool us) {used = us; } ;
+    ///
+    bool Flag() const {return flag; };
+    ///
+    void SetFlag(bool fl) {flag = fl;};
+
+    friend class MinimumDegreeOrdering;
+  };
+
+  /// 
+  class CliqueEl
+  {
+    bool flag = false;
+  public:
+    CliqueEl * next = nullptr;
+    CliqueEl * nextcl = nullptr;
+    CliqueEl * clmaster;
+    int vnr;
+    bool eliminate = false;
+  
+    CliqueEl (int avnr) : vnr(avnr) { ; }
+
+    CliqueEl * GetNext() { return next; }
+    CliqueEl * GetNextClique() { return nextcl; }
+    int GetVertexNr() const { return vnr; }
+    
+    void SetFlag (bool aflag) { clmaster->flag = aflag; }
+    bool Flag () const { return clmaster->flag; }
+    
+    operator int() const { return vnr; }
+    int Nr() const { return vnr; }
+  };
+  
+
+  ///
+  class MinimumDegreeOrdering
+  {
+  public:
+    ///
+    int n, nused;
+    ///
+    Array<CliqueEl*> cliques;
+    ///
+    Array<int> order;
+    ///
+    Array<int> blocknr;
+    ///
+    Array<MDOVertex> vertices;
+    ///
+    MDOPriorityQueue priqueue;
+    ///
+    ngstd::BlockAllocator ball;
+  public:
+    ///
+    MinimumDegreeOrdering (int an);
+    /// for archive
+    MinimumDegreeOrdering() : ball(sizeof(CliqueEl), 1000) {}
+
+    void DoArchive(Archive& archive);
+
+    void AddEdge (int v1, int v2);
+    ///
+    void PrintCliques ();
+
+    ///
+    int CalcDegree (int v1);
+    ///
+    void EliminateMasterVertex (int v);
+    void EliminateMinionVertex (int v);
+    ///
+    void Order();
+    /// 
+    ~MinimumDegreeOrdering();
+
+    ///
+    int NumCliques (int v) const
+    {
+      return vertices[v].numcliques;
+    }
+
+    ///
+    void SetUnusedVertex (int v) { vertices[v].SetEliminated(true); order[v] = -1; }
+      
+    /// set/clear flag for all nodes in clique
+    void SetFlagNodes (int v);
+    ///
+    void ClearFlagNodes (int v);
+  
+    /// set/clear flag in all cliques of node
+    void SetFlagCliques (int v);
+    ///
+    void ClearFlagCliques (int v);
+    ///
+    int Size () const { return n; }
+    /// number of non-zero elements
+    //  int GetNZE() const;
+    //  friend class SparseCholesky;
+
+    int NextMinion (int vnr) const
+    {
+      return vertices[vnr].NextMinion();
+    }
+    ///
+    int NumMinions (int vnr) const 
+    {
+      return vertices[vnr].numminions;
+    }
+
+    ///
+    bool IsMaster (int vnr) const
+    {
+      return vertices[vnr].Master() == vnr;
+    }
+
+    void SetMaster (int master, int minion);
+
+
+    void StartMemoryTracing() const
+    {
+      mt.Track(cliques, "cliques",
+               order, "order",
+               blocknr, "blocknr",
+               vertices, "vertices",
+               priqueue, "priqueue",
+               ball, "ball");
+    }
+    const MemoryTracer& GetMemoryTracer() const { return mt; }
+
+  private:
+    MemoryTracer mt;
+  };
+
+
+}
+
+
+
+
+
+
+
+
+#endif

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/parallel_matrices.hpp

@@ -0,0 +1,222 @@
+#ifndef FILE_NGS_PARALLEL_MATRICES
+#define FILE_NGS_PARALLEL_MATRICES
+
+/* ************************************************************************/
+/* File:   parallelmatrices.hpp                                           */
+/* Author: Astrid Sinwel, Joachim Schoeberl                               */
+/* Date:   2007,2011                                                      */
+/* ************************************************************************/
+
+
+#include <basematrix.hpp>
+#include <sparsematrix.hpp>
+#include <paralleldofs.hpp>
+
+namespace ngla
+{
+
+  // enum with char type issue in pybind11:
+  // https://github.com/pybind/pybind11/issues/1820
+  enum PARALLEL_OP : uint8_t { D2D = 0,   // 00
+                               D2C = 1,   // 01
+                               C2D = 2,   // 10
+                               C2C = 3 }; // 11
+
+  inline ostream & operator<< (ostream & ost, PARALLEL_OP op)
+  {
+    switch (op)
+      {
+      case D2D: ost << "D2D"; break;
+      case D2C: ost << "D2C"; break;
+      case C2D: ost << "C2D"; break;
+      case C2C: ost << "C2C"; break;
+      default: ost << "undefined parallelop";
+      }
+    return ost;
+  }
+
+  
+  inline PARALLEL_STATUS RowType (PARALLEL_OP op)
+  {
+    if (op == C2D || op == C2C)
+      return CUMULATED;
+    else
+      return DISTRIBUTED;
+  }
+
+  inline PARALLEL_STATUS ColType (PARALLEL_OP op)
+  {
+    if (op == D2C || op == C2C)
+      return CUMULATED;
+    else
+      return DISTRIBUTED;
+  }
+
+  inline PARALLEL_STATUS InvertType (PARALLEL_STATUS stat)
+  {
+    if (stat == NOT_PARALLEL) return NOT_PARALLEL;
+    return (stat == CUMULATED) ? DISTRIBUTED : CUMULATED;
+  }
+  
+  inline PARALLEL_OP ParallelOp (PARALLEL_STATUS stat_row, PARALLEL_STATUS stat_col)
+  {
+    if (stat_row == CUMULATED)
+      return (stat_col == CUMULATED) ? C2C : C2D;
+    else
+      return (stat_col == CUMULATED) ? D2C : D2D;
+  }
+
+  
+  class ParallelMatrix : public BaseMatrix
+  {
+    shared_ptr<BaseMatrix> mat;
+    shared_ptr<ParallelDofs> row_paralleldofs, col_paralleldofs;
+    PARALLEL_OP op;
+    
+  public:
+    ParallelMatrix (shared_ptr<BaseMatrix> amat, shared_ptr<ParallelDofs> apardofs,
+		    PARALLEL_OP op = C2D);
+    // : mat(*amat), pardofs(*apardofs) 
+    // {const_cast<BaseMatrix&>(mat).SetParallelDofs (apardofs);}
+
+    ParallelMatrix (shared_ptr<BaseMatrix> amat, shared_ptr<ParallelDofs> arpardofs,
+		    shared_ptr<ParallelDofs> acpardofs, PARALLEL_OP op = C2D);
+
+    virtual ~ParallelMatrix () override;
+    virtual bool IsComplex() const override { return mat->IsComplex(); }
+    virtual BaseMatrix::OperatorInfo GetOperatorInfo () const override;
+    
+    virtual void MultAdd (double s, const BaseVector & x, BaseVector & y) const override ;
+    virtual void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
+
+    virtual BaseVector & AsVector() override { return mat->AsVector(); }
+    virtual const BaseVector & AsVector() const override { return mat->AsVector(); }
+
+    shared_ptr<BaseMatrix> GetMatrix() const { return mat; }
+    virtual shared_ptr<BaseMatrix> CreateMatrix () const override;
+    virtual AutoVector CreateVector () const override;
+    virtual AutoVector CreateRowVector () const override;
+    virtual AutoVector CreateColVector () const override;
+
+    virtual ostream & Print (ostream & ost) const override;
+
+    virtual int VHeight() const override;
+    virtual int VWidth() const override;
+
+    // virtual const ParallelDofs * GetParallelDofs () const {return &pardofs;}
+    shared_ptr<ParallelDofs> GetRowParallelDofs () const { return row_paralleldofs; }
+    shared_ptr<ParallelDofs> GetColParallelDofs () const { return col_paralleldofs; }
+
+    PARALLEL_OP GetOpType () const { return op; }
+    virtual optional<NgMPI_Comm> GetCommunicator() const override
+    {
+      if (row_paralleldofs)
+        return row_paralleldofs->GetCommunicator();
+      else
+        return nullopt;
+    }
+
+    virtual shared_ptr<BaseMatrix> InverseMatrix (shared_ptr<BitArray> subset = 0) const override;
+    template <typename TM>
+    shared_ptr<BaseMatrix> InverseMatrixTM (shared_ptr<BitArray> subset = 0) const;
+
+    virtual shared_ptr<BaseMatrix> InverseMatrix (shared_ptr<const Array<int>> clusters) const override;
+    virtual INVERSETYPE SetInverseType ( INVERSETYPE ainversetype ) const override;
+    virtual INVERSETYPE SetInverseType ( string ainversetype ) const override;
+    virtual INVERSETYPE GetInverseType () const override;
+
+    virtual shared_ptr<BaseMatrix> DeleteZeroElements(double tol) const override
+    {
+      return make_shared<ParallelMatrix> (mat->DeleteZeroElements(tol),
+                                          row_paralleldofs, col_paralleldofs, op);
+    }
+    
+  };
+
+
+
+  class CumulationOperator : public BaseMatrix
+  {
+    shared_ptr<ParallelDofs> pardofs;
+    
+  public:
+    CumulationOperator (shared_ptr<ParallelDofs> apardofs)
+      : pardofs(apardofs) { } 
+    ~CumulationOperator() override;
+    bool IsComplex() const override { return pardofs->IsComplex(); } 
+    void Mult (const BaseVector & x, BaseVector & y) const override ;
+    void MultAdd (double s, const BaseVector & x, BaseVector & y) const override ;
+    void MultTrans (const BaseVector & x, BaseVector & y) const override;
+    void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
+
+    AutoVector CreateRowVector () const override;
+    AutoVector CreateColVector () const override;
+
+    int VHeight() const override;
+    int VWidth() const override;
+
+    ostream & Print (ostream & ost) const override;
+    PARALLEL_OP GetOpType () const { return PARALLEL_OP::D2C; }
+  };
+
+
+  
+
+  
+#ifdef PARALLEL
+
+
+  template <typename TM>
+  class MasterInverse : public BaseMatrix
+  {
+    shared_ptr<BaseMatrix> inv;
+    shared_ptr<BitArray> subset;
+    DynamicTable<int> loc2glob;
+    Array<int> select;
+    string invtype;
+    //shared_ptr<ParallelDofs> pardofs;
+  public:
+    MasterInverse (const SparseMatrixTM<TM> & mat, shared_ptr<BitArray> asubset, 
+		   shared_ptr<ParallelDofs> apardofs);
+    virtual ~MasterInverse () override;
+    virtual bool IsComplex() const override { return inv->IsComplex(); } 
+    virtual void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
+
+    virtual int VHeight() const override { return paralleldofs->GetNDofLocal(); }
+    virtual int VWidth() const override { return paralleldofs->GetNDofLocal(); }
+
+    AutoVector CreateRowVector() const override;
+    AutoVector CreateColVector() const override;
+  };
+
+
+  
+  class FETI_Jump_Matrix : public BaseMatrix
+  {
+  public:
+    FETI_Jump_Matrix (shared_ptr<ParallelDofs> pardofs, shared_ptr<ParallelDofs> au_paralleldofs = nullptr);
+    
+    virtual bool IsComplex() const override { return false; }
+    virtual void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
+    virtual void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
+    
+    virtual AutoVector CreateRowVector () const override;
+    virtual AutoVector CreateColVector () const override;
+
+    shared_ptr<ParallelDofs> GetRowParallelDofs () const { return u_paralleldofs; }
+    shared_ptr<ParallelDofs> GetColParallelDofs () const { return jump_paralleldofs; }
+    
+    virtual int VHeight() const override { return paralleldofs->GetNDofLocal(); }
+    virtual int VWidth()  const override { return jump_paralleldofs->GetNDofLocal(); }
+
+  protected:
+
+    shared_ptr<ParallelDofs> jump_paralleldofs;
+    shared_ptr<ParallelDofs> u_paralleldofs;
+
+  };
+
+#endif
+}
+
+#endif