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

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

@@ -0,0 +1,229 @@
+#ifndef FILE_L2HOFEFO
+#define FILE_L2HOFEFO
+
+/*********************************************************************/
+/* File:   l2hofefo.hpp                                              */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   Apr. 2009                                                 */
+/*********************************************************************/
+
+#include "thdivfe.hpp"
+
+
+namespace ngfem
+{
+
+  /**
+     High order finite elements for L2 of fixed order
+  */
+
+  /*
+  template<int DIM>
+  class HDivHighOrderFiniteElementFO : virtual public HDivFiniteElement<DIM>
+  {
+  protected:
+    int vnums[8];
+    bool ho_div_free;
+    bool only_ho_div;
+  public:
+    void SetVertexNumber (int nr, int vnum) { vnums[nr] = vnum; }
+    void SetHODivFree (bool aho_div_free) { ho_div_free = aho_div_free; only_ho_div = only_ho_div && !ho_div_free;};  
+    void SetOnlyHODiv (bool aonly_ho_div) { only_ho_div = aonly_ho_div; ho_div_free = ho_div_free && !only_ho_div;}; 
+    virtual void ComputeNDof () = 0;
+  };
+  */
+  
+  template <ELEMENT_TYPE ET, int ORDER> class HDivHighOrderFEFO;
+
+
+  /*
+  template <ELEMENT_TYPE ET, int ORDER>
+  class T_HDivHighOrderFiniteElementFO : 
+    public HDivHighOrderFiniteElementFO<ET_trait<ET>::DIM>,
+    public T_HDivFiniteElement< HDivHighOrderFEFO<ET,ORDER>, ET >,
+    public ET_trait<ET>
+  {
+  protected:
+    enum { DIM = ET_trait<ET>::DIM };
+
+    using HDivFiniteElement<DIM>::ndof;
+    using HDivFiniteElement<DIM>::order;
+
+    using HDivHighOrderFiniteElementFO<DIM>::vnums;
+    using HDivHighOrderFiniteElementFO<DIM>::ho_div_free;
+    using HDivHighOrderFiniteElementFO<DIM>::only_ho_div;
+
+    using ET_trait<ET>::N_VERTEX;
+    using ET_trait<ET>::N_EDGE;
+    using ET_trait<ET>::N_FACE;
+    using ET_trait<ET>::FaceType;
+    using ET_trait<ET>::GetEdgeSort;
+    using ET_trait<ET>::GetFaceSort;
+
+
+
+  public:
+
+    T_HDivHighOrderFiniteElementFO () 
+    {
+      for (int i = 0; i < ET_trait<ET>::N_VERTEX; i++)
+	vnums[i] = i;
+      ho_div_free = false;
+      only_ho_div = false;
+      order = ORDER;
+    }
+  };
+  */
+
+
+
+  /**
+     High order triangular finite element
+  */
+  template <int ORDER>
+  class HDivHighOrderFEFO<ET_TRIG, ORDER> : 
+    public T_HDivFiniteElement<HDivHighOrderFEFO<ET_TRIG,ORDER>, ET_TRIG>,
+    public ET_trait<ET_TRIG>
+  {
+    using T_HDivFiniteElement<HDivHighOrderFEFO<ET_TRIG,ORDER>, ET_TRIG> :: ndof;
+    using T_HDivFiniteElement<HDivHighOrderFEFO<ET_TRIG,ORDER>, ET_TRIG> :: order;
+    /*
+    using T_HDivFiniteElement<ET_TRIG, ORDER>::ndof;
+    using T_HDivFiniteElement<ET_TRIG, ORDER>::vnums; 
+    using T_HDivFiniteElement<ET_TRIG, ORDER>::ho_div_free; 
+    using T_HDivFiniteElement<ET_TRIG, ORDER>::only_ho_div; 
+    */
+
+    int vnums[3];
+    bool ho_div_free;
+    bool only_ho_div;
+
+  public:
+
+    typedef IntegratedLegendreMonomialExt T_ORTHOPOL;
+    typedef TrigShapesInnerLegendre T_TRIGSHAPES;
+
+  public:
+    HDivHighOrderFEFO () 
+      : ho_div_free(false), only_ho_div(false)
+    { 
+      order = ORDER;
+    }
+
+
+    void SetVertexNumber (int nr, int vnum) { vnums[nr] = vnum; }
+    void SetHODivFree (bool aho_div_free) { ho_div_free = aho_div_free; only_ho_div = only_ho_div && !ho_div_free;};  
+    void SetOnlyHODiv (bool aonly_ho_div) { only_ho_div = aonly_ho_div; ho_div_free = ho_div_free && !only_ho_div;}; 
+
+
+
+    virtual ELEMENT_TYPE ElementType() const { return ET_TRIG; }
+
+    virtual void ComputeNDof()
+    {
+      if (only_ho_div)
+        ndof = ORDER*(ORDER+1)/2 - 1;
+      else
+      {
+        ndof = 3 * (ORDER+1);
+        ndof += (ho_div_free) ? ORDER*(ORDER-1)/2 : ORDER*ORDER-1;
+      }
+    }
+
+    virtual void GetInternalDofs (Array<int> & idofs) const
+    {
+      idofs.SetSize(0);
+      idofs += IntRange (3*(ORDER+1), ndof);
+    }
+
+    virtual void GetFacetDofs(int i, Array<int> & dnums) const
+    {
+      dnums.SetSize (0);
+      dnums += i;
+      dnums += 3+IntRange (i*ORDER,(i+1)*ORDER);
+    }
+
+
+    template<typename Tx, typename TFA>   
+    void T_CalcShape (TIP<2,Tx> ip, TFA & shape) const
+    {
+      if (only_ho_div && (ORDER <= 1)) return;
+      Tx x = ip.x, y = ip.y;
+      Tx lami[3] = { x, y, 1-x-y };
+
+      Tx adpol1[ORDER], adpol2[ORDER];
+
+      int ii = 3; 
+
+      if (!only_ho_div){
+        // const EDGE * edges = ElementTopology::GetEdges (ET_TRIG);
+        for (int i = 0; i < 3; i++)
+        {
+          IVec<2> e = this->GetEdgeSort (i, vnums);
+          
+          //Nedelec low order edge shape function 
+          shape[i] = uDv_minus_vDu (lami[e[0]], lami[e[1]]);
+          
+          //HO-Edge shapes (Gradient Fields)   
+          if(ORDER > 0) //  && usegrad_edge[i]) 
+            { 
+              Tx xi = lami[e[1]] - lami[e[0]]; 
+              // LegendrePolynomial::
+              IntLegNoBubble::
+                EvalScaledMult (ORDER-1, xi, lami[e[0]]+lami[e[1]], 
+                                lami[e[0]]*lami[e[1]], 
+                                SBLambda([&](int i, Tx v)
+                                         {
+                                           shape[ii++] = Du(v);
+                                         }));
+              /*
+              AutoDiff<2> eta = 1 - lami[e[1]] - lami[e[0]]; 
+              // T_ORTHOPOL::CalcTrigExt(ORDER+1, xi, eta, adpol1); 
+              T_ORTHOPOL::CalcScaled<ORDER+1> (xi, 1-eta, adpol1); 
+              
+              for(int j = 0; j < ORDER; j++) 
+              shape[ii++] = Du<2> (adpol1[j]);
+              */
+            }
+        }   
+      }
+      else
+        ii = 0;
+      //Inner shapes (Face) 
+      if(ORDER > 1) 
+	{
+	  IVec<4> fav = this->GetFaceSort (0, vnums);
+
+	  Tx xi  = lami[fav[2]]-lami[fav[1]];
+	  Tx eta = lami[fav[0]]; 
+	  
+	  TrigShapesInnerLegendre::CalcSplitted<ORDER+1> (xi, eta, adpol1,adpol2);
+	  
+        if (!only_ho_div)
+        {
+          // rotated gradients:
+          for (int j = 0; j < ORDER-1; j++)
+            for (int k = 0; k < ORDER-1-j; k++, ii++)
+              shape[ii] = Du (adpol1[j] * adpol2[k]);
+	  }
+	  
+	  if (!ho_div_free)
+	    {
+	      // other combination
+	      for (int j = 0; j < ORDER-1; j++)
+		for (int k = 0; k < ORDER-1-j; k++, ii++)
+		  shape[ii] = uDv_minus_vDu (adpol2[k], adpol1[j]);
+	      
+	      // rec_pol * Nedelec0 
+	      for (int j = 0; j < ORDER-1; j++, ii++)
+		shape[ii] = wuDv_minus_wvDu (lami[fav[1]], lami[fav[2]], adpol2[j]);
+	    }
+	}
+    }
+    
+  };
+
+}
+
+
+#endif

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

@@ -0,0 +1,177 @@
+#ifndef FILE_HDIVHOFESPACE
+#define FILE_HDIVHOFESPACE
+
+/*********************************************************************/
+/* File:   hdivhofespace.hpp                                         */
+/* Author: START                                                     */
+/* Date:   Feb. 2003, update (SZ) Jan. 2007                          */
+/*********************************************************************/
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+
+  /**
+     HDiv High Order Finite Element Space
+  */
+
+  class NGS_DLL_HEADER HDivHighOrderFESpace : public FESpace
+  {
+  protected:
+    // Level
+    int level;
+    // Number Dofs 
+    // int ndof;
+    // order of curl-fields 
+    int curl_order; 
+
+    Array<DofId> first_facet_dof;
+    Array<DofId> first_inner_dof;
+
+    /// relative order to mesh-order
+    int rel_order; 
+    // curl-order relative to mesh order 
+    int rel_curl_order; 
+    // space is of variable order 
+    bool var_order;
+    // space is continuous/discontinuous 
+    bool discont; 
+    
+    Array<IVec<3> > order_inner;
+    Array<IVec<3> > order_inner_curl;
+    Array<IVec<2> > order_facet; 
+    Array<bool> fine_facet; 
+    Array<bool> boundary_facet; 
+ 
+    // Array<int> ndlevel;
+    int uniform_order_inner; 
+    int uniform_order_facet; 
+
+    // high order divergence free
+    bool ho_div_free; 
+    ///
+    bool fixed_order;
+
+    bool RT = false; 
+
+    // highest-order facet dofs discontinuous ?
+    bool highest_order_dc;
+    // hide all used dofs
+    bool hide_all_dofs;
+    // discontinuous facet pairs:
+    Array<IVec<2>> dc_pairs;
+  public:
+    HDivHighOrderFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, 
+                          bool parseflags=false);
+    ///
+    virtual ~HDivHighOrderFESpace ();
+    static DocInfo GetDocu ();
+
+    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;
+
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override
+    {
+      static VorB nodes[] = { VOL, BND };
+      return FlatArray<VorB> (2, &nodes[0]); 
+    }
+    
+    virtual string GetClassName () const override
+    {
+      return "HDivHighOrderFESpace";
+    }
+
+    /// averaging over high-order dc dofs
+    void Average (BaseVector & vec) const;
+    
+    ///
+    void Update() override;
+    ///
+    // virtual size_t GetNDof () const throw() override;
+    ///
+    // virtual size_t GetNDofLevel (int level) const override;
+    ///
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
+    ///
+    // virtual const FiniteElement & GetFE (int elnr, LocalHeap & lh) const override;
+    ///
+    template <ELEMENT_TYPE ET>
+      FiniteElement & T_GetFE (int elnr, bool onlyhdiv, Allocator & lh) const;
+    ///
+    virtual const FiniteElement & GetHODivFE (int elnr, LocalHeap & lh) const;
+    ///
+    // virtual const FiniteElement & GetSFE (int selnr, LocalHeap & lh) const override; // 2D: array =0.;
+    ///
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+    ///
+    virtual shared_ptr<Table<int>> CreateSmoothingBlocks (const Flags & precflags) const override;
+    /// 
+    virtual shared_ptr<Array<int>> CreateDirectSolverClusters (const Flags & precflags) const override;
+    /// 
+    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 GetFacetDofNrs(int fanr, Array<DofId> & dnums) const
+    { 
+      if (ma->GetDimension() == 2) GetEdgeDofNrs(fanr,dnums); 
+      else if (ma->GetDimension() == 3) GetFaceDofNrs(fanr,dnums); 
+    } 
+    ///
+    virtual void GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override; 
+    /// 
+    void GetFacetOrder (Array<IVec<2> > & of, Array<bool> & ff) const 
+    {of = order_facet; ff = fine_facet;};
+
+    /// 
+    int GetNElemDofs(int elnr) const 
+    {
+      if(discont) return(first_inner_dof[elnr+1] - first_inner_dof[elnr]); 
+      else 
+	{ 
+	  Array<DofId> dnums; 
+	  this->GetDofNrs(elnr,dnums); 
+	  return(dnums.Size()); 
+	} 
+    }
+
+    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);} 
+
+
+    const Array<IVec<2>> & GetDCPairs () const { return dc_pairs; }
+
+    virtual bool VarOrder() const override { return var_order; } 
+    virtual int GetRelOrder() const override { return rel_order; } 
+
+
+    auto GetFacetDofs (size_t nr) const
+    {
+      return Range (first_facet_dof[nr], first_facet_dof[nr+1]);
+    }
+
+    auto GetElementDofs (size_t nr) const
+    {
+      return Range (first_inner_dof[nr], first_inner_dof[nr+1]);
+    }
+
+  };
+
+}
+
+#endif
+
+
+
+
+

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

@@ -0,0 +1,106 @@
+#ifndef FILE_HDIVHOSURFACEFESPACE
+#define FILE_HDIVHOSURFACEFESPACE
+
+/*********************************************************************/
+/* File:   hdivhosurfacefespace.hpp                                  */
+/* Author: Philip Lederer, Michael Neunteufel                        */
+/* Date:  September 2017                                             */
+/*********************************************************************/
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+  class NGS_DLL_HEADER HDivHighOrderSurfaceFESpace : public FESpace
+  {
+  protected:
+    
+    // int ndof;
+    
+    Array<DofId> first_facet_dof;
+    Array<DofId> first_inner_dof;
+
+    bool discont; 
+    
+    Array<IVec<3> > order_inner;
+    //Array<IVec<3> > order_inner_curl;
+    Array<IVec<2> > order_facet; 
+    Array<bool> fine_facet; 
+    Array<bool> boundary_facet; 
+ 
+    // Array<int> ndlevel;
+    int uniform_order_inner; 
+    int uniform_order_facet; 
+
+    bool ho_div_free;       
+    bool highest_order_dc;
+
+    bool RT = false; 
+
+    Array<IVec<2>> dc_pairs;
+    
+  public:
+    HDivHighOrderSurfaceFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, 
+                          bool parseflags=false);
+
+    virtual ~HDivHighOrderSurfaceFESpace ();
+    static DocInfo GetDocu ();
+    
+    virtual string GetClassName () const override
+    {
+      return "HDivHighOrderSurfaceFESpace";
+    }
+
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override
+    {
+      static VorB nodes[] = { VOL, BND };
+      return FlatArray<VorB> (2, &nodes[0]); 
+    }
+    
+    void Average (BaseVector & vec) const;
+    
+    void Update() override;
+
+    virtual void UpdateDofTables() override; 
+    virtual void UpdateCouplingDofArray() override;   
+    
+    // virtual size_t GetNDof () const throw() override;
+    
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;            
+
+    template <ELEMENT_TYPE ET>
+      FiniteElement & T_GetSFE (ElementId ei, bool onlyhdiv, Allocator & alloc) const;
+
+    virtual const FiniteElement & GetHODivFE (int elnr, LocalHeap & lh) const;
+       
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+    //virtual void GetSDofNrs (ElementId ei, Array<DofId> & dnums) const;
+    
+    const Array<IVec<2>> & GetDCPairs () const { return dc_pairs; }
+
+    virtual void GetVertexDofNrs (int vnr, Array<DofId> & dnums) const override;
+       
+    virtual void GetFacetDofNrs(int fanr, Array<DofId> & dnums) const;
+    
+    virtual void GetInnerDofNrs(int elnr, Array<DofId> & dnums) const override;
+   
+    auto GetFacetDofs (size_t nr) const
+    {
+      return Range (first_facet_dof[nr], first_facet_dof[nr+1]);
+    }
+
+    auto GetElementDofs (size_t nr) const
+    {
+      return Range (first_inner_dof[nr], first_inner_dof[nr+1]);
+    }
+
+  };
+
+}
+
+#endif
+
+
+
+
+