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

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

@@ -0,0 +1,148 @@
+#ifndef FILE_H1HOFEFO
+#define FILE_H1HOFEFO
+
+/*********************************************************************/
+/* File:   h1hofefo.hpp                                              */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   Apr. 2009                                                 */
+/*********************************************************************/
+
+
+#include <recursive_pol.hpp>
+
+namespace ngfem
+{
+
+  /**
+     High order finite elements for H^1 of fixed order
+  */
+
+  template <ELEMENT_TYPE ET, int ORDER> class H1HighOrderFEFO;
+
+  /**
+     High order triangular finite element
+  */
+  template <int ORDER>
+  class H1HighOrderFEFO<ET_TRIG, ORDER> : 
+    public T_ScalarFiniteElement< H1HighOrderFEFO<ET_TRIG,ORDER>, ET_TRIG >,
+    public ET_trait<ET_TRIG> 
+  {
+    using ScalarFiniteElement<2>::ndof;
+    using ScalarFiniteElement<2>::order;    
+
+    using ET_trait<ET_TRIG> :: N_VERTEX;
+
+    int vnums[N_VERTEX];
+
+  public:
+    enum { NDOF = (ORDER+1)*(ORDER+2)/2 };
+
+    INLINE H1HighOrderFEFO () 
+    {
+      order = ORDER;
+      ndof = NDOF; 
+      for (int i = 0; i < N_VERTEX; i++) vnums[i] = i;
+    }
+
+    template <typename TA> 
+    INLINE H1HighOrderFEFO<ET_TRIG, ORDER> * SetVertexNumbers (const TA & avnums)
+    { 
+      for (int i = 0; i < N_VERTEX; i++) vnums[i] = avnums[i]; 
+      return this;
+    }
+
+    template<typename Tx, typename TFA>  
+    INLINE void T_CalcShape (TIP<2,Tx> ip, TFA & shape) const; 
+  };
+
+
+  /**
+     High order tet finite element
+  */
+  template <int ORDER>
+  class H1HighOrderFEFO<ET_TET, ORDER> : 
+    public T_ScalarFiniteElement< H1HighOrderFEFO<ET_TET,ORDER>, ET_TET>,
+    public ET_trait<ET_TET> 
+  {
+    using ET_trait<ET_TET> :: N_VERTEX;
+
+    int vnums[N_VERTEX];
+    using ScalarFiniteElement<3>::ndof;
+    using ScalarFiniteElement<3>::order;
+
+    typedef IntegratedLegendreMonomialExt T_ORTHOPOL;
+
+  public:
+    enum { NDOF = (ORDER+1)*(ORDER+2)*(ORDER+3)/6 };
+    NGS_DLL_HEADER H1HighOrderFEFO () 
+    {
+      order = ORDER; 
+      ndof = NDOF; 
+      for (int i = 0; i < N_VERTEX; i++) vnums[i] = i;
+    }
+
+    template <typename TA> 
+    INLINE H1HighOrderFEFO<ET_TET, ORDER> * SetVertexNumbers (const TA & avnums)
+    { 
+      for (int i = 0; i < N_VERTEX; i++) vnums[i] = avnums[i]; 
+      return this;
+    }
+
+    template<typename Tx, typename TFA>  
+    INLINE void T_CalcShape (TIP<3,Tx> ip, TFA & shape) const; 
+  };
+
+
+
+}
+
+
+
+
+#ifdef FILE_H1HOFEFO_CPP
+
+#define H1HOFEFO_EXTERN
+#include <h1hofefo_impl.hpp>
+#include <tscalarfe_impl.hpp>
+
+#else
+#define H1HOFEFO_EXTERN extern
+#endif
+
+
+namespace ngfem
+{
+
+  H1HOFEFO_EXTERN template class T_ScalarFiniteElement<H1HighOrderFEFO<ET_TRIG,1>, ET_TRIG>;
+  H1HOFEFO_EXTERN template class T_ScalarFiniteElement<H1HighOrderFEFO<ET_TRIG,2>, ET_TRIG>;
+  H1HOFEFO_EXTERN template class T_ScalarFiniteElement<H1HighOrderFEFO<ET_TRIG,3>, ET_TRIG>;
+  H1HOFEFO_EXTERN template class T_ScalarFiniteElement<H1HighOrderFEFO<ET_TRIG,4>, ET_TRIG>;
+  H1HOFEFO_EXTERN template class T_ScalarFiniteElement<H1HighOrderFEFO<ET_TRIG,5>, ET_TRIG>;
+  H1HOFEFO_EXTERN template class T_ScalarFiniteElement<H1HighOrderFEFO<ET_TRIG,6>, ET_TRIG>;
+
+  H1HOFEFO_EXTERN template class T_ScalarFiniteElement<H1HighOrderFEFO<ET_TET,1>, ET_TET>;
+  H1HOFEFO_EXTERN template class T_ScalarFiniteElement<H1HighOrderFEFO<ET_TET,2>, ET_TET>;
+  H1HOFEFO_EXTERN template class T_ScalarFiniteElement<H1HighOrderFEFO<ET_TET,3>, ET_TET>;
+  H1HOFEFO_EXTERN template class T_ScalarFiniteElement<H1HighOrderFEFO<ET_TET,4>, ET_TET>;
+  H1HOFEFO_EXTERN template class T_ScalarFiniteElement<H1HighOrderFEFO<ET_TET,5>, ET_TET>;
+  H1HOFEFO_EXTERN template class T_ScalarFiniteElement<H1HighOrderFEFO<ET_TET,6>, ET_TET>;
+
+  H1HOFEFO_EXTERN template class H1HighOrderFEFO<ET_TRIG,1>;
+  H1HOFEFO_EXTERN template class H1HighOrderFEFO<ET_TRIG,2>;
+  H1HOFEFO_EXTERN template class H1HighOrderFEFO<ET_TRIG,3>;
+  H1HOFEFO_EXTERN template class H1HighOrderFEFO<ET_TRIG,4>;
+  H1HOFEFO_EXTERN template class H1HighOrderFEFO<ET_TRIG,5>;
+  H1HOFEFO_EXTERN template class H1HighOrderFEFO<ET_TRIG,6>;
+
+  H1HOFEFO_EXTERN template class H1HighOrderFEFO<ET_TET,1>;
+  H1HOFEFO_EXTERN template class H1HighOrderFEFO<ET_TET,2>;
+  H1HOFEFO_EXTERN template class H1HighOrderFEFO<ET_TET,3>;
+  H1HOFEFO_EXTERN template class H1HighOrderFEFO<ET_TET,4>;
+  H1HOFEFO_EXTERN template class H1HighOrderFEFO<ET_TET,5>;
+  H1HOFEFO_EXTERN template class H1HighOrderFEFO<ET_TET,6>;
+
+
+}
+
+
+#endif

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

@@ -0,0 +1,185 @@
+#ifndef FILE_H1HOFEFO_IMPL
+#define FILE_H1HOFEFO_IMPL
+
+/*********************************************************************/
+/* File:   h1hofefo_impl.hpp                                         */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   2009                                                      */
+/*********************************************************************/
+
+#include "recursive_pol_tet.hpp"
+
+
+
+namespace ngfem
+{
+
+  template <int ORDER, int I = ORDER>
+  class TrigProduct
+  {
+  public:
+    template <class PX, class PY, class TRes>
+    static void Do (const PX & polx, const PY & poly, TRes && res)
+    {
+      TrigProduct<ORDER, I-1>::Do (polx,poly, res);
+
+      int ii = (ORDER+1)*(ORDER+2)/2 - (ORDER-I+1)*(ORDER-I+2)/2;
+
+      for (int j = 0; j <= ORDER-I; j++)
+        res[ii++] = polx[I] * poly[j];
+    }
+  };
+
+  template <int ORDER>
+  class TrigProduct<ORDER,-1>
+  {
+  public:
+    template <class PX, class PY, class TRes>
+    static void Do (const PX & polx, const PY & poly, TRes && res) { ; }
+  };
+
+  
+
+
+  template <int ORDER>   template<typename Tx, typename TFA>  
+  void H1HighOrderFEFO<ET_TRIG, ORDER> :: T_CalcShape (TIP<2,Tx> ip, TFA & shape) const
+  {
+    Tx lam[3] = { ip.x, ip.y, 1-ip.x-ip.y };
+
+    for (int i = 0; i < 3; i++) shape[i] = lam[i];
+
+    int ii = 3;
+
+    for (int i = 0; i < 3; i++)
+      { 
+        IVec<2> e = GetEdgeSort (i, vnums);
+	LegendrePolynomial::EvalScaledMult (ORDER-2, 
+					    lam[e[1]]-lam[e[0]], lam[e[0]]+lam[e[1]], 
+					    lam[e[0]]*lam[e[1]], shape.Addr(ii));
+	ii += ORDER-1;
+      }
+
+    // inner dofs
+    if (ORDER >= 3)
+      {
+        IVec<4> f = GetFaceSort (0, vnums);
+	DubinerBasis::EvalMult (ORDER-3, 
+				 lam[f[0]], lam[f[1]], 
+				 lam[f[0]]*lam[f[1]]*lam[f[2]], shape+ii);
+      }
+  }
+
+  template <>   template<typename Tx, typename TFA>  
+  void H1HighOrderFEFO<ET_TRIG, 2> :: T_CalcShape (TIP<2,Tx> ip, TFA & shape) const
+  {
+    Tx lam[3] = { ip.x, ip.y, 1-ip.x-ip.y };
+    for (int i = 0; i < 3; i++) shape[i] = lam[i];
+    
+    int ii = 3;
+    for (int i = 0; i < 3; i++)
+      { 
+        IVec<2> e = GetEdge (i);
+        shape[ii] = lam[e[0]] * lam[e[1]];
+        ii++;
+      }
+  }
+
+  template <> template<typename Tx, typename TFA>  
+  void H1HighOrderFEFO<ET_TRIG, 1> :: T_CalcShape (TIP<2,Tx> ip, TFA & shape) const
+  {
+    Tx lam[3] = { ip.x, ip.y, 1-ip.x-ip.y };
+    for (int i = 0; i < 3; i++) shape[i] = lam[i];
+  }
+
+
+
+
+
+
+
+  
+  template <int ORDER>   template<typename Tx, typename TFA>  
+  void H1HighOrderFEFO<ET_TET, ORDER> :: T_CalcShape (TIP<3,Tx> ip, TFA & shape) const
+  {
+    Tx lam[4] = { ip.x, ip.y, ip.z, 1-ip.x-ip.y-ip.z };
+
+    for (int i = 0; i < 4; i++) shape[i] = lam[i];
+
+    int ii = 4;
+    for (int i = 0; i < 6; i++)
+      { 
+        IVec<2> e = GetEdgeSort (i, vnums);
+        LegendrePolynomial::
+          EvalScaledMultFO<ORDER-2> (lam[e[1]]-lam[e[0]], lam[e[0]]+lam[e[1]], 
+                                     lam[e[0]]*lam[e[1]], shape+ii);
+        ii += ORDER-1;
+      }
+
+    // face dofs
+    for (int i = 0; i < 4; i++)
+      if (ORDER >= 3)
+	{
+          IVec<4> f = GetFaceSort (i, vnums);
+	  int vop = 6 - f[0] - f[1] - f[2];  	
+
+	  DubinerBasis::EvalScaledMult (ORDER-3, lam[f[0]], lam[f[1]], 1-lam[vop], 
+                                        lam[f[0]]*lam[f[1]]*lam[f[2]], shape+ii);
+	  ii += (ORDER-2)*(ORDER-1)/2;
+	}
+
+    if (ORDER >= 4)
+      ii +=  TetShapesInnerLegendre::
+        Calc (ORDER, lam[0]-lam[3], lam[1], lam[2], 
+              shape.Addr(ii) );
+  }
+
+
+
+  template <> template<typename Tx, typename TFA>  
+  void H1HighOrderFEFO<ET_TET, 2> :: T_CalcShape (TIP<3,Tx> ip, TFA & shape) const
+  {
+    // Tx lam[4] = { hx[0], hx[1], hx[2], 1-hx[0]-hx[1]-hx[2] };
+    Tx lam[4] = { ip.x, ip.y, ip.z, 1-ip.x-ip.y-ip.z };    
+
+    for (int i = 0; i < 4; i++) shape[i] = lam[i];
+
+    int ii = 4;
+
+    for (int i = 0; i < 6; i++)
+      { 
+        IVec<2> e = GetEdge (i);
+        shape[ii] = lam[e[0]] * lam[e[1]];
+        ii++;
+      }
+  }
+
+
+  template <>   template<typename Tx, typename TFA>  
+  void H1HighOrderFEFO<ET_TET, 3> :: T_CalcShape (TIP<3,Tx> ip, TFA & shape) const
+  {
+    Tx lam[4] = { ip.x, ip.y, ip.z, 1-ip.x-ip.y-ip.z };    
+    // Tx lam[4] = { hx[0], hx[1], hx[2], 1-hx[0]-hx[1]-hx[2] };    
+
+    for (int i = 0; i < 4; i++) shape[i] = lam[i];
+
+    int ii = 4;
+    for (int i = 0; i < 6; i++)
+      { 
+        IVec<2> e = GetEdgeSort (i, vnums);
+        Tx bub = lam[e[0]]*lam[e[1]];
+        shape[ii] = bub;
+        shape[ii+1] = bub * (lam[e[1]]-lam[e[0]]);
+        ii += 2;
+      }
+
+    for (int i = 0; i < 4; i++)
+      {
+        IVec<4> f = GetFace (i);
+        shape[ii++] = lam[f[0]]*lam[f[1]]*lam[f[2]];
+      }
+  }
+
+}
+ 
+#endif
+

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

@@ -0,0 +1,167 @@
+#ifndef FILE_H1HOFESPACE
+#define FILE_H1HOFESPACE
+
+/*********************************************************************/
+/* File:   h1hofespace.hpp                                           */
+/* Author: Start                                                     */
+/* Date:   10. Feb. 2003                                             */
+/*********************************************************************/
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+
+  /**
+     High Order Finite Element Space
+  */
+
+  class NGS_DLL_HEADER H1HighOrderFESpace : public FESpace
+  {
+  protected:
+    int level;
+
+    Array<DofId> first_edge_dof;
+    Array<DofId> first_face_dof;
+    Array<DofId> first_element_dof;
+
+    // typedef short TORDER;
+    typedef unsigned char TORDER;
+    
+    /// relative order to mesh-order
+    int rel_order; 
+    bool var_order; 
+    bool fixed_order;
+    bool wb_loedge, wb_edge;
+    Array<TORDER> order_edge;
+    Array<IVec<2,TORDER>> order_face;
+    Array<IVec<3,TORDER>> order_inner;
+    Array<bool> used_vertex; 
+    Array<bool> used_edge; 
+    Array<bool> used_face; 
+
+    int uniform_order_inner;
+    int uniform_order_face;
+    int uniform_order_edge;
+    int uniform_order_quad;
+    int uniform_order_trig;
+    Array<IVec<3>> dom_order_min; 
+    Array<IVec<3>> dom_order_max;
+  
+    bool level_adapted_order; 
+    bool nodalp2;
+    bool nodal;
+    bool highest_order_dc;
+    bool test_ho_prolongation;    
+  public:
+
+    H1HighOrderFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool checkflags=false);
+    ///
+    virtual ~H1HighOrderFESpace ();
+
+    static DocInfo GetDocu ();
+
+    
+    virtual string GetClassName () const override
+    {
+      return "H1HighOrderFESpace";
+    }
+
+    ///
+    void Update() override;
+
+    virtual void DoArchive (Archive & archive) override;
+    Array<MemoryUsage> GetMemoryUsage () const override;
+
+    ///
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
+
+    ///
+    template <ELEMENT_TYPE ET>
+      FiniteElement & T_GetFE (int elnr, Allocator & alloc) const;
+    ///
+    template <ELEMENT_TYPE ET>
+      FiniteElement & T_GetSFE (int elnr, Allocator & alloc) const;
+    ///
+    template <ELEMENT_TYPE ET>
+      FiniteElement & T_GetCD2FE(int elnr, Allocator & alloc) const;
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+
+    virtual void GetDofRanges (ElementId ei, Array<IntRange> & dranges) const;
+
+    virtual void GetVertexDofNrs (int vnr, Array<DofId> & dnums) const override;
+    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;
+    ///
+    virtual shared_ptr<Table<int>> CreateSmoothingBlocks (const Flags & precflags) const override; 
+    // virtual void CreateSmoothingBlocks2 (SmoothingBlocksCreator & sbc, const Flags & precflags) const; 
+    ///
+    virtual shared_ptr<Array<int>> CreateDirectSolverClusters (const Flags & flags) const override;
+
+    virtual void UpdateDofTables () override;
+    virtual void UpdateCouplingDofArray() override;    
+
+    virtual void SetOrder (NodeId ni, int order) override;
+    virtual int GetOrder (NodeId ni) const override;
+    using FESpace::GetOrder;
+    
+    void SetEdgeOrder (int enr, int eo) { order_edge[enr] = eo; }
+    void SetFaceOrder (int fnr, IVec<2> fo) { order_face[fnr] = fo; }
+    void SetElementOrder (int elnr, IVec<3> elo) { order_inner[elnr] = elo; }
+
+    /// get relative (to mesh) order of finite elements
+    virtual int GetRelOrder() const override { return rel_order; }
+    virtual bool VarOrder() const override { return var_order; }
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+    auto GetEdgeDofs (size_t nr) const
+    {
+      return Range (first_edge_dof[nr], first_edge_dof[nr+1]);
+    }
+
+    auto GetFaceDofs (size_t nr) const
+    {
+      return Range (first_face_dof[nr], first_face_dof[nr+1]);
+    }
+
+    auto GetElementDofs (size_t nr) const
+    {
+      return Range (first_element_dof[nr], first_element_dof[nr+1]);
+    }
+
+  };
+
+
+  class VectorH1FESpace : public CompoundFESpace
+  {
+    bool interleaved;
+  public:
+    VectorH1FESpace (shared_ptr<MeshAccess> ama, const Flags & flags, 
+                     bool checkflags = false);
+
+    FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
+
+    static DocInfo GetDocu ();
+
+    virtual void SetOrder (ELEMENT_TYPE et, TORDER order) override;
+
+    virtual void SetOrder (NodeId ni, int order) override;
+    virtual int GetOrder (NodeId ni) const override;
+    using FESpace::GetOrder;
+
+    virtual void FinalizeUpdate() override;
+
+    void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+    void GetDofNrs (NodeId ni, Array<DofId> & dnums) const override;
+
+    virtual string GetClassName () const override
+    {
+      return "VectorH1FESpace";
+    }
+  };
+
+}
+
+#endif
+