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

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

@@ -0,0 +1,308 @@
+#ifndef FILE_HCURLHDIVFES
+#define FILE_HCURLHDIVFES
+
+/*********************************************************************/
+/* File:   hcurlhdivfes.hh                                           */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   12. Jan. 2002                                             */
+/*********************************************************************/
+
+
+#include "fespace.hpp"
+#include <sparsematrix.hpp>
+
+
+namespace ngcomp
+{
+
+/*
+   Finite Element Space
+*/
+
+/// Lowest order Nedelec space (edge elements)
+class NGS_DLL_HEADER NedelecFESpace : public FESpace
+{
+  ///
+  Array<IVec<2> > edgepoints;
+  ///
+  Array<IVec<2> > parentedges;
+  ///
+  Array<short int> finelevelofedge;
+  ///
+  Array<int> nelevel;
+
+protected:
+  bool discontinuous;
+  
+public:
+  ///
+  NedelecFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool parseflags=false);
+  ///
+  virtual ~NedelecFESpace ();
+
+  ///
+  virtual const char * GetType() 
+    { return "Nedelec"; }
+
+  static shared_ptr<FESpace> Create (shared_ptr<MeshAccess> ma, const Flags & flags);
+
+  ///
+  void Update() override;
+  ///
+  virtual void DoArchive (Archive & archive) override;
+  /// 
+  virtual void UpdateCouplingDofArray() override;
+
+  virtual FiniteElement & GetFE (ElementId ei, Allocator & lh) const override;
+
+  ///
+  virtual size_t GetNDof () const throw() override;
+  ///
+  virtual size_t GetNDofLevel (int level) const override;
+
+  /// 
+  virtual void GetDofRanges (ElementId ei, Array<IntRange> & dranges) const;
+
+  ///
+  virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+  ///
+  int EdgePoint1 (int ednr) const { return edgepoints[ednr][0]; }
+  ///
+  int EdgePoint2 (int ednr) const { return edgepoints[ednr][1]; }
+
+  ///
+  int ParentEdge1 (int ednr) const { return parentedges[ednr][0]; }
+  ///
+  int ParentEdge2 (int ednr) const { return parentedges[ednr][1]; }
+
+  ///
+  int FineLevelOfEdge (int ednr) const { return finelevelofedge[ednr]; }
+
+  enum { SB_AFW, SB_HIPTMAIR, SB_POTENTIAL, SB_JAC };
+  ///
+  virtual shared_ptr<Table<int>> CreateSmoothingBlocks (int type = 0) const;
+  virtual shared_ptr<Table<int>> CreateSmoothingBlocks (const Flags & precflags) const override;
+
+  SparseMatrix<double> * CreateGradient() const;
+
+  template <class T>
+    NGS_DLL_HEADER void T_TransformMat (ElementId ei, 
+                                        SliceMatrix<T> mat, TRANSFORM_TYPE tt) const;
+  
+  template <class T>
+    NGS_DLL_HEADER void T_TransformVec (ElementId ei, 
+                                      SliceVector<T> vec, TRANSFORM_TYPE tt) const;
+  
+  
+  virtual void VTransformMR (ElementId ei, 
+			     SliceMatrix<double> mat, TRANSFORM_TYPE tt) const override
+  {
+    T_TransformMat (ei, mat, tt);
+  }
+
+  virtual void VTransformMC (ElementId ei, 
+			     SliceMatrix<Complex> mat, TRANSFORM_TYPE tt) const override
+  {
+    T_TransformMat (ei, mat, tt);
+  }
+
+  virtual void VTransformVR (ElementId ei, 
+			     SliceVector<double> vec, TRANSFORM_TYPE tt) const override
+  {
+    T_TransformVec (ei, vec, tt);
+  }
+
+  virtual void VTransformVC (ElementId ei, 
+			     SliceVector<Complex> vec, TRANSFORM_TYPE tt) const override
+  {
+    T_TransformVec (ei, vec, tt);
+  }
+
+
+
+
+  virtual string GetClassName () const override
+  {
+    return "NedelecFESpace";
+  }
+
+
+  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;
+};
+
+
+
+
+///
+class NGS_DLL_HEADER NedelecFESpace2 : public FESpace
+{
+public:
+  ///
+  //  enum NEDELEC_TYPE { N1, BDM1, BDM1A, N2, BDM2A, BDM2 };
+
+private:
+    /// Reference - element (low order only)
+    FiniteElement * tet;  // = NULL;
+    /// Reference - element (low order only)
+    FiniteElement * prism; // = NULL;
+    /// Reference - element (low order only) 
+    FiniteElement * pyramid;  // = NULL;
+    /// Reference - element (low order only)
+    FiniteElement * hex; //  = NULL;
+    /// Reference - element (low order only)
+    FiniteElement * trig; // = NULL;
+    /// Reference - element (low order only)
+    FiniteElement * quad;// = NULL;
+    /// Reference - element (low order only)
+    FiniteElement * segm;// = NULL;
+    /// Reference - element (low order only)
+    //Never used?
+    //FiniteElement * point;// = NULL;
+
+  
+  /// order in z-direction
+  int zorder;
+  ///
+  Array<short int> gradientedge;
+  ///
+  Array<short int> gradientface;
+
+  ///
+  int ned;
+  ///
+  int nfa;
+  ///
+  int nel;
+  ///
+  int n_edge_dofs;
+  int n_z_edge_dofs;
+  int n_plane_edge_dofs;
+  int n_trig_face_dofs;
+  int n_quad_face_dofs;
+  int n_tet_el_dofs;
+  int n_prism_el_dofs;
+  int n_prism_nograd_el_dofs;
+  int n_pyramid_el_dofs;
+  ///
+  Array<int> first_face_dof;
+  Array<int> first_el_dof;
+  ///
+  BitArray gradientdomains;
+  ///
+  BitArray gradientboundaries;
+  ///
+  Array<int> ndlevel;
+
+  FiniteElement * curltet;
+  FiniteElement * curlprism;
+  FiniteElement * curlpyramid;
+
+public:
+  ///
+  NedelecFESpace2 (shared_ptr<MeshAccess> ama, const Flags & flags, bool parseflags=false);
+  ///
+  ~NedelecFESpace2 ();
+
+  ///
+  virtual const char * GetType() 
+    { return "Nedelec2"; }
+
+  virtual string GetClassName () const override
+  {
+    return "NedelecFESpace2";
+  }
+
+
+  ///
+  void Update() override;
+
+  ///
+  virtual size_t GetNDof () const throw() override;
+  ///
+  virtual size_t GetNDofLevel (int level) const override;
+
+  ///
+  virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+
+  using FESpace::GetFE;
+  virtual FiniteElement & GetFE (ElementId ei, Allocator & lh) const override;
+
+  ///
+  void SetGradientDomains (const BitArray & adoms);
+  ///
+  void SetGradientBoundaries (const BitArray & abnds);
+
+  ///
+  void GetTransformation (ELEMENT_TYPE eltype, 
+			  int elnr,
+			  const Array<int> & eorient,
+			  const Array<int> & forient,
+			  FlatVector<double> & fac) const;
+			  
+
+  template <class T>
+    NGS_DLL_HEADER void TransformMat (ElementId ei, 
+                                      SliceMatrix<T> mat, TRANSFORM_TYPE tt) const;
+  
+  template <class T>
+    NGS_DLL_HEADER void TransformVec (ElementId ei, 
+                                      SliceVector<T> vec, TRANSFORM_TYPE tt) const;
+
+
+  virtual void VTransformMR (ElementId ei, 
+			     SliceMatrix<double> mat, TRANSFORM_TYPE tt) const override
+  {
+    TransformMat (ei, mat, tt);
+  }
+
+  virtual void VTransformMC (ElementId ei, 
+			     SliceMatrix<Complex> mat, TRANSFORM_TYPE tt) const override
+  {
+    TransformMat (ei, mat, tt);
+  }
+
+
+
+  virtual void VTransformVR (ElementId ei, 
+			     SliceVector<double> vec, TRANSFORM_TYPE tt) const override
+  {
+    TransformVec (ei, vec, tt);
+  }
+
+  virtual void VTransformVC (ElementId ei, 
+			     SliceVector<Complex> vec, TRANSFORM_TYPE tt) const override
+  {
+    TransformVec (ei, vec, tt);
+  }
+
+  ///
+  virtual void LockSomeDofs (BaseMatrix & mat) const;
+  ///
+  // virtual Table<int> * CreateSmoothingBlocks (int type = 0) const;
+  virtual shared_ptr<Table<int>> CreateSmoothingBlocks (const Flags & precflags) const override;
+  /// for anisotropic plane smoothing
+  virtual BitArray * CreateIntermediatePlanes (int type = 0) const;
+
+  ///
+  SparseMatrix<double> * CreateGradient() const;
+
+  
+  virtual shared_ptr<Array<int>> CreateDirectSolverClusters (const Flags & flags) 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 GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override;
+
+//  void AddGradient (double fac, const BaseVector & pot, BaseVector & grad) const;
+//  void ApplyGradientT (const BaseVector & gradt, BaseVector & pott) const;
+};
+
+}
+
+
+#endif

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

@@ -0,0 +1,175 @@
+#ifndef FILE_HCURLHOFE_
+#define FILE_HCURLHOFE_  
+
+/*********************************************************************/
+/* File:   hcurlhofe.hpp                                             */
+/* Author: Sabine Zaglmayr                                           */
+/* Date:   20. Maerz 2003                                            */
+/*                                                                   */
+/* AutoCurl - revision: J. Schoeberl, March 2009                     */
+/*********************************************************************/
+
+
+#include "thcurlfe.hpp"
+#include "recursive_pol.hpp"
+
+namespace ngfem
+{
+
+
+
+  /** 
+      HCurlHighOrderFE of shape ET.
+      The template specialization provides the shape functions.
+  */
+  template <ELEMENT_TYPE ET> class HCurlHighOrderFE_Shape;
+
+
+  /**
+     High order finite elements for H(curl).  
+     These are the actual finite element classes to be used.  
+     Shape functions are provided by the shape template
+   */
+
+  template <ELEMENT_TYPE ET, 
+            template <ELEMENT_TYPE ET2> class TSHAPES = HCurlHighOrderFE_Shape,
+            typename BASE = T_HCurlHighOrderFiniteElement<ET, TSHAPES<ET>> >
+
+  class HCurlHighOrderFE : public BASE, public ET_trait<ET>, public VertexOrientedFE<ET>
+  {
+  protected:
+    using ET_trait<ET>::N_VERTEX;
+    using ET_trait<ET>::N_EDGE;
+    using ET_trait<ET>::N_FACE;
+    using ET_trait<ET>::N_CELL;
+    using ET_trait<ET>::FaceType;
+    using ET_trait<ET>::DIM;
+
+    typedef short TORDER;
+
+    using VertexOrientedFE<ET>::vnums;
+
+    IVec<N_EDGE, TORDER> order_edge;
+    IVec<N_FACE, IVec<2, TORDER>> order_face;
+    IVec<3, TORDER> order_cell;
+    
+    //bool usegrad_edge[N_EDGE]; 
+    IVec<N_EDGE, bool> usegrad_edge;
+    IVec<N_FACE, bool> usegrad_face;
+    bool usegrad_cell;
+    bool type1;   
+
+    using BASE::ndof;
+    using BASE::order;
+
+    typedef IntegratedLegendreMonomialExt T_ORTHOPOL;
+
+    // Typedefs should match with h1hofe, otherwise HCurlHighOrderFESpace::CreateGradient() fails
+    // typedef LegendrePolynomial EdgeOrthoPol;
+    typedef IntLegNoBubble EdgeOrthoPol;  // Integrated Legendre divided by bubble
+    // typedef ChebyPolynomial EdgeOrthoPol;
+    
+    // typedef ChebyPolynomial QuadOrthoPol;
+    typedef IntLegNoBubble QuadOrthoPol;
+
+    // typedef DubinerBasis TrigOrthoPolGrad;
+    typedef DubinerBasisOrthoBub TrigOrthoPolGrad;  // for bi-orthogonal dual shapes (Jan 2021)
+    
+
+  public:
+    using VertexOrientedFE<ET>::SetVertexNumbers;
+    /* INLINE */ HCurlHighOrderFE () { ; } 
+
+    /* INLINE */ HCurlHighOrderFE (int aorder) 
+    {
+      order_edge = aorder;
+      order_face = aorder;
+      type1 = false;
+      
+      if (DIM == 3) order_cell = aorder;
+      
+      for(int i = 0; i < N_EDGE; i++) usegrad_edge[i] = 1;
+      for(int i = 0; i < N_FACE; i++) usegrad_face[i] = 1;
+      if (DIM == 3) usegrad_cell = 1;
+      
+      for (int i = 0; i < N_VERTEX; i++) vnums[i] = i;
+      
+      ComputeNDof();
+    }
+
+    INLINE void SetOrderEdge (int nr, TORDER order) { order_edge[nr] = order; }
+    INLINE void SetOrderFace (int nr, IVec<2,TORDER> order) { order_face[nr] = order; }
+
+    INLINE void SetUseGradEdge(int nr, bool uge) { usegrad_edge[nr] = uge; }
+    INLINE void SetUseGradFace(int nr, bool ugf) { usegrad_face[nr] = ugf; }
+
+
+    INLINE void SetOrderCell (IVec<3> oi) { order_cell = oi; }
+
+    /// set isotropic or anisotropic face orders
+    template <typename TA>
+    INLINE void SetOrderFace (const TA & of)
+    { for (int i = 0; i < N_FACE; i++) order_face[i] = of[i]; }
+
+    /// set edge orders
+    template <typename TA>
+    INLINE void SetOrderEdge (const TA & oe)
+    { for (int i = 0; i < N_EDGE; i++) order_edge[i] = oe[i]; }
+
+    /// use edge-gradients
+    template <typename TA>
+    INLINE void SetUseGradEdge (const TA & uge)
+    { for (int i = 0; i < N_EDGE; i++) usegrad_edge[i] = uge[i]; }
+
+    /// use face-gradients
+    template <typename TA>
+    INLINE void SetUseGradFace (const TA & ugf)
+    { for (int i = 0; i < N_FACE; i++) usegrad_face[i] = ugf[i]; }
+
+    INLINE void SetUseGradCell (bool ugc) 
+    { usegrad_cell = ugc; }
+
+    INLINE void SetType1 (bool t1)
+    { type1 = t1; }
+    
+    void ComputeNDof();
+
+    virtual void CalcDualShape (const BaseMappedIntegrationPoint & bmip, BareSliceMatrix<> shape) const override;
+    virtual void CalcDualShape (const SIMD_BaseMappedIntegrationRule & bmir, BareSliceMatrix<SIMD<double>> shape) const override;
+    virtual void EvaluateDual (const SIMD_BaseMappedIntegrationRule & bmir, BareSliceVector<> coefs, BareSliceMatrix<SIMD<double>> values) const override;
+    virtual void AddDualTrans (const SIMD_BaseMappedIntegrationRule & bmir, BareSliceMatrix<SIMD<double>> values,
+                               BareSliceVector<double> coefs) const override;
+  };
+
+
+  
+
+  extern template class HCurlHighOrderFE<ET_SEGM>;
+  extern template class HCurlHighOrderFE<ET_TRIG>;
+  extern template class HCurlHighOrderFE<ET_QUAD>;
+  extern template class HCurlHighOrderFE<ET_TET>;
+  extern template class HCurlHighOrderFE<ET_PRISM>;
+  extern template class HCurlHighOrderFE<ET_PYRAMID>;
+  extern template class HCurlHighOrderFE<ET_HEX>;
+
+  extern template class 
+  T_HCurlHighOrderFiniteElement<ET_SEGM, HCurlHighOrderFE_Shape<ET_SEGM>>;
+  extern template class 
+  T_HCurlHighOrderFiniteElement<ET_TRIG, HCurlHighOrderFE_Shape<ET_TRIG>>;
+  extern template class 
+  T_HCurlHighOrderFiniteElement<ET_QUAD, HCurlHighOrderFE_Shape<ET_QUAD>>;
+
+  extern template class 
+  T_HCurlHighOrderFiniteElement<ET_TET, HCurlHighOrderFE_Shape<ET_TET>>;
+  extern template class 
+  T_HCurlHighOrderFiniteElement<ET_PRISM, HCurlHighOrderFE_Shape<ET_PRISM>>;
+  extern template class 
+  T_HCurlHighOrderFiniteElement<ET_PYRAMID, HCurlHighOrderFE_Shape<ET_PYRAMID>>;
+  extern template class 
+  T_HCurlHighOrderFiniteElement<ET_HEX, HCurlHighOrderFE_Shape<ET_HEX>>;
+  
+}
+
+
+#endif
+