ngsolve 6.2.2506.post74.dev0__cp314-cp314-macosx_10_15_universal2.whl

netgen/include/facetfe.hpp

@@ -0,0 +1,175 @@
+#ifndef FILE_FACETFE
+#define FILE_FACETFE
+
+/*********************************************************************/
+/* File:   facetfe.hpp                                               */
+/* Author: A. Sinwel, H. Egger, J. Schoeberl                         */
+/* Date:   2008                                                      */
+/*********************************************************************/
+
+
+#include "scalarfe.hpp"
+
+namespace ngfem
+{
+
+  /*
+   * Facet Finite Elements
+   */ 
+
+  template <int D>
+  class NGS_DLL_HEADER FacetVolumeFiniteElement;
+  
+
+  template <int D>
+  class FacetFEFacet : public ScalarFiniteElement<D>
+  {
+    int fnr;
+    const FacetVolumeFiniteElement<D> & fe;
+  public:
+    FacetFEFacet (int afnr,
+		  const FacetVolumeFiniteElement<D> & afe,
+		  int andof, int aorder)
+      : ScalarFiniteElement<D> (andof, aorder), fnr(afnr), fe(afe) 
+    { 
+      ; // cout << "created facetfefacet" << endl;
+    }
+
+    HD virtual ELEMENT_TYPE ElementType() const override { return fe.ElementType(); }
+
+    using ScalarFiniteElement<D>::CalcShape;
+    HD virtual void CalcShape (const IntegrationPoint & ip, 
+                               BareSliceVector<> shape) const override
+    {
+      fe.CalcFacetShapeVolIP(fnr, ip, shape);
+    }
+    
+    HD virtual void CalcShape (const SIMD_IntegrationRule & ir, 
+                               BareSliceMatrix<SIMD<double>> shape) const override
+    {
+      fe.CalcFacetShapeVolIR(fnr, ir, shape);
+    }
+    
+    HD virtual void CalcDShape (const IntegrationPoint & ip, 
+                                BareSliceMatrix<> dshape) const override
+    {
+      fe.CalcFacetDShapeVolIP(fnr, ip, dshape);
+      //throw Exception ("facetfe - calcdshape not olverloaded");
+    }
+
+    using ScalarFiniteElement<D>::Evaluate;
+    HD NGS_DLL_HEADER virtual void Evaluate (const SIMD_IntegrationRule & ir, BareSliceVector<> coefs, BareVector<SIMD<double>> values) const override
+    {
+      fe.EvaluateFacetVolIp (fnr, ir, coefs, values);
+    }
+    
+    using ScalarFiniteElement<D>::AddTrans;    
+    HD NGS_DLL_HEADER virtual void AddTrans (const SIMD_IntegrationRule & ir, BareVector<SIMD<double>> values, BareSliceVector<> coefs) const override
+    {
+      fe.AddTransFacetVolIp (fnr, ir, values, coefs);
+    }
+    
+  };
+
+  
+  
+
+  template <int D>
+  class FacetVolumeFiniteElement : public FiniteElement
+  {
+  protected:
+    // int vnums[8];
+    int facet_order[6]; 
+    int first_facet_dof[7];
+
+    using FiniteElement::ndof;
+    using FiniteElement::order;
+
+  public:
+
+    /*
+    void SetVertexNumbers (FlatArray<int> & avnums)
+    {
+      for (int i = 0; i < avnums.Size(); i++)
+	vnums[i] = avnums[i];
+    }
+    */
+
+    /*
+    template <typename T>
+    void SetVertexNumbers (const BaseArrayObject<T> & avnums)
+    {
+      for (int i = 0; i < avnums.Size(); i++)
+	vnums[i] = avnums[i];
+    }
+    */
+    
+    void SetOrder (int ao)  
+    {
+      order = ao;
+      for (int i = 0; i < 6; i++)
+	facet_order[i] = ao;
+    }
+
+    void SetOrder (int nr, int o) { facet_order[nr] = o; order = max2(order,o); }
+    
+    void SetOrder (FlatArray<int> & ao)
+    {
+      for (int i=0; i<ao.Size(); i++)
+	facet_order[i] = ao[i];
+      
+      order = facet_order[0];        // integration order
+      for (int i = 1; i < ao.Size(); i++)
+	order = max2(order, ao[i]);
+    }
+
+    FacetFEFacet<D> Facet (int fnr) const 
+    {
+      return FacetFEFacet<D> (fnr, *this, 
+			      GetFacetDofs(fnr).Size(), facet_order[fnr]); 
+    }
+
+
+    virtual void CalcFacetShapeVolIP (int fnr, const IntegrationPoint & ip, 
+				      BareSliceVector<> shape) const = 0;
+    virtual void CalcFacetShapeVolIR (int fnr, const SIMD_IntegrationRule & ir, 
+                                      BareSliceMatrix<SIMD<double>> shape) const = 0;
+
+    virtual void EvaluateFacetVolIp (int fnr, const SIMD_IntegrationRule & ir, BareSliceVector<> coefs, BareVector<SIMD<double>> values) const = 0;
+    virtual void AddTransFacetVolIp (int fnr, const SIMD_IntegrationRule & ir, BareVector<SIMD<double>> values, BareSliceVector<> coefs) const = 0;
+    
+    virtual void CalcFacetDShapeVolIP (int fnr, const IntegrationPoint & ip, 
+                                       BareSliceMatrix<> shape) const = 0;
+
+    IntRange GetFacetDofs(int fnr) const
+    {
+      return IntRange (first_facet_dof[fnr], first_facet_dof[fnr+1]);
+    }
+
+    virtual string ClassName() const { return "FacetVolumeFiniteElement"; }
+
+    virtual void ComputeNDof () = 0;
+  };
+
+
+
+
+#ifdef FILE_FACETHOFE_CPP
+#define FACETHOFE_EXTERN
+#else
+#define FACETHOFE_EXTERN extern
+#endif
+
+  FACETHOFE_EXTERN template class FacetVolumeFiniteElement<1>;
+  FACETHOFE_EXTERN template class FacetVolumeFiniteElement<2>;
+  FACETHOFE_EXTERN template class FacetVolumeFiniteElement<3>;
+
+  FACETHOFE_EXTERN template class FacetFEFacet<1>;
+  FACETHOFE_EXTERN template class FacetFEFacet<2>;
+  FACETHOFE_EXTERN template class FacetFEFacet<3>;
+
+}
+
+
+
+#endif

netgen/include/facetfespace.hpp

@@ -0,0 +1,180 @@
+/**
+   High Order Finite Element Space for Facets
+*/
+/* facetfespace.*pp
+ * An fespace for functions living on the facets (=edges in 2D, faces in 3D)
+ *   - the functions on different facets are independent (no continuity across
+ *     vertices ( or edges in 3D))
+ *   - the functions on the facets are accessed via the elements
+ *     (=FacetVolumeElements), which then can access their facets;
+ *     see facetfe.hpp for details
+ *   - the ordering of dofs is facet'wise
+ *   - no low-order space
+ *   - no prolongation so far (will probably never be needed)
+ *   - some additional utility functions 
+ */
+#ifndef FACET_FESPACE_HPP
+#define FACET_FESPACE_HPP
+
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+
+  class NGS_DLL_HEADER FacetFESpace : public FESpace 
+  {
+  protected:  
+    // Level
+    int level;
+    // Number of Facets
+    int nfa;
+    // Number of coarse facets, number of fine facets;
+    int ncfa;
+    // Number of Elements
+    int nel;
+  
+    Array<int> first_facet_dof;
+    Array<int> first_inner_dof;  // for highest_order_dc
+  
+    // relative order to mesh-order
+    int rel_order; 
+  
+    Array<IVec<2> > order_facet;
+    Array<bool> fine_facet;
+  
+    // int ndof;
+    // Array<int> ndlevel;
+    bool var_order; 
+    bool highest_order_dc;
+    bool hide_highest_order_dc;
+    bool nowirebasket;
+    bool all_dofs_together;
+
+    bool nodal;
+  public:
+    ///
+    FacetFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool parseflags=false);
+    ///
+    virtual ~FacetFESpace ();
+    static DocInfo GetDocu();
+    ///
+    virtual string GetClassName () const override
+    {
+      return "FacetFESpace";
+    }
+  
+    ///
+    void Update() override;
+  
+    //  virtual void UpdateDofTables();
+    virtual void UpdateCouplingDofArray() override;    
+    ///
+    // virtual size_t GetNDof () const throw() override;
+    // virtual size_t GetNDofLevel (int level) const override;
+
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+    virtual void SetOrder (NodeId ni, int order) override;
+    virtual int GetOrder (NodeId ni) const override;
+    using FESpace::GetOrder;
+
+
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & lh) const override;
+
+    template <ELEMENT_TYPE ET>
+    FiniteElement & T_GetFE (int elnr, Allocator & alloc) const;
+
+    using FESpace::GetDofNrs;
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+
+    const auto & GetFirstFacetDof() const { return first_facet_dof; }
+    
+    IntRange GetFacetDofs (int nr) const
+    { 
+      return IntRange (first_facet_dof[nr], first_facet_dof[nr+1]); 
+    }
+  
+    virtual void GetFacetDofNrs (int nr, Array<DofId> & dnums) const
+    {
+      dnums.SetSize0();
+      if (!all_dofs_together)
+        dnums += nr;
+      dnums += GetFacetDofs(nr);
+    }
+
+    ///
+    virtual int GetNFacetDofs (int felnr) const 
+    {
+      return (first_facet_dof[felnr+1]-first_facet_dof[felnr] + (all_dofs_together ? 0 : 1) );
+    }
+    ///
+    virtual shared_ptr<Table<int>> CreateSmoothingBlocks (const Flags & precflags) const override;
+    ///
+    virtual shared_ptr<Array<int>> CreateDirectSolverClusters (const Flags & precflags) const override;
+
+
+    virtual IVec<2> GetFacetOrder(int fnr) 
+    { return order_facet[fnr]; };
+  
+
+    virtual int GetFirstFacetDof(int fanr) const 
+    {
+      return first_facet_dof[fanr];
+    }
+
+    virtual void GetVertexDofNrs ( int nr, Array<DofId> & dnums ) const override
+    {
+      dnums.SetSize0();
+    }
+
+    virtual void GetEdgeDofNrs ( int nr, Array<DofId> & dnums ) const override
+    {
+      dnums.SetSize0();
+      if (ma->GetDimension() == 3) return;
+
+      if (!all_dofs_together)
+        dnums += nr;
+      dnums += IntRange (first_facet_dof[nr], first_facet_dof[nr+1]); 
+    }
+
+    virtual void GetFaceDofNrs (int nr, Array<DofId> & dnums) const override
+    {
+      dnums.SetSize(0);
+      if (ma->GetDimension() == 2) return;
+
+      if (!all_dofs_together)
+        dnums += nr;
+      dnums += IntRange (first_facet_dof[nr], first_facet_dof[nr+1]); 
+    }
+  
+    virtual void GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override
+    {
+      dnums.SetSize0();
+    }
+    
+    bool AllDofsTogether() {return all_dofs_together;};
+  };
+
+
+
+
+
+  class NGS_DLL_HEADER HybridDGFESpace : public CompoundFESpace
+  {
+  public:
+    HybridDGFESpace (shared_ptr<MeshAccess> ama, 
+                     const Flags & flags);
+
+    virtual ~HybridDGFESpace ();
+    virtual string GetClassName () const override { return "HybridDGFESpace"; }
+
+    virtual shared_ptr<Array<int>> CreateDirectSolverClusters (const Flags & flags) const override;
+    virtual shared_ptr<Table<int>> CreateSmoothingBlocks (const Flags & precflags) const override;
+  };
+
+}
+
+
+
+#endif

netgen/include/facethofe.hpp

@@ -0,0 +1,111 @@
+#ifndef FILE_FACETHOFE
+#define FILE_FACETHOFE
+
+/*********************************************************************/
+/* File:   facethofe.hpp                                             */
+/* Author: A. Sinwel, H. Egger, J. Schoeberl                         */
+/* Date:   2008                                                      */
+/*********************************************************************/
+
+
+#include "facetfe.hpp"
+
+
+namespace ngfem
+{
+  
+  template <ELEMENT_TYPE ET>
+  class FacetFE : 
+    public FacetVolumeFiniteElement<ET_trait<ET>::DIM>,
+    public ET_trait<ET>,
+    public VertexOrientedFE<ET>
+  {
+  protected:
+    enum { DIM = ET_trait<ET>::DIM };
+    using ET_trait<ET>::N_FACET;
+
+    using FacetVolumeFiniteElement<ET_trait<ET>::DIM>::order;
+    using FacetVolumeFiniteElement<ET_trait<ET>::DIM>::ndof;
+    using FacetVolumeFiniteElement<ET_trait<ET>::DIM>::first_facet_dof;
+    using FacetVolumeFiniteElement<ET_trait<ET>::DIM>::facet_order;
+    using VertexOrientedFE<ET>::vnums;
+    using VertexOrientedFE<ET>::GetVertexOrientedEdge;
+    using VertexOrientedFE<ET>::GetVertexOrientedFace;
+    bool nodal;
+  public:
+    using VertexOrientedFE<ET>::SetVertexNumbers;
+  public:
+    FacetFE (bool anodal = false) : nodal(anodal) { ; }
+
+    virtual ELEMENT_TYPE ElementType() const override { return ET; }
+    
+    using FacetVolumeFiniteElement<ET_trait<ET>::DIM>::SetOrder;
+    template <typename TA>
+    void SetOrder (const TA & of)
+    {
+      for (int i = 0; i < N_FACET; i++) facet_order[i] = of[i];
+
+      order = facet_order[0];      
+      for (int i = 1; i < N_FACET; i++)
+	order = max2(order, of[i]);
+    }
+
+    
+    virtual void ComputeNDof() override
+    {
+      ndof = 0;
+      for (int i = 0; i < N_FACET; i++)
+	{
+	  first_facet_dof[i] = ndof;
+	  int fo = facet_order[i];
+	  switch (ElementTopology::GetFacetType (ET, i))
+	    {
+	    case ET_POINT: ndof += 1; break;
+	    case ET_SEGM: ndof += fo+1; break;
+	    case ET_TRIG: ndof += ( (fo+1) * (fo+2) ) / 2; break;
+	    case ET_QUAD: ndof += sqr (fo+1); break;
+	    default: ;
+	    }
+	}      
+      first_facet_dof[N_FACET] = ndof;
+      order = facet_order[0];      
+      for (int i = 1; i < N_FACET; i++)
+	order = max2(order, facet_order[i]);
+    }
+    
+
+    virtual void CalcFacetShapeVolIP (int fnr, const IntegrationPoint & ip,
+                                      BareSliceVector<> shape) const override;
+
+    virtual void CalcFacetShapeVolIR (int fnr, const SIMD_IntegrationRule & ir, 
+                                      BareSliceMatrix<SIMD<double>> shape) const override;
+    
+    virtual void EvaluateFacetVolIp (int fnr, const SIMD_IntegrationRule & ir,
+                                     BareSliceVector<> coefs, BareVector<SIMD<double>> values) const override;
+    
+    virtual void AddTransFacetVolIp (int fnr, const SIMD_IntegrationRule & ir,
+                                     BareVector<SIMD<double>> values, BareSliceVector<> coefs) const override;
+    
+    virtual void CalcFacetDShapeVolIP (int fnr, const IntegrationPoint & ip, 
+                                       BareSliceMatrix<> shape) const override;
+
+  private:
+    template<typename Tx, typename TFA>  
+    //void T_CalcShapeFNr (int fnr, Tx x[ET_trait<ET>::DIM], TFA & shape) const;
+    void T_CalcShapeFNr (int fnr, TIP<ET_trait<ET>::DIM,Tx> ip, TFA && shape) const;
+  };
+
+#ifdef FILE_FACETHOFE_CPP
+#else
+  extern template class FacetFE<ET_SEGM>;
+  extern template class FacetFE<ET_TRIG>;
+  extern template class FacetFE<ET_QUAD>;
+  extern template class FacetFE<ET_TET>;
+  extern template class FacetFE<ET_HEX>;
+  extern template class FacetFE<ET_PRISM>;
+  extern template class FacetFE<ET_PYRAMID>;
+#endif
+
+}
+
+#endif

netgen/include/facetsurffespace.hpp

@@ -0,0 +1,112 @@
+/**
+   High Order Finite Element Space for SurfFacets
+*/
+/* facetsurffespace.*pp*/
+#ifndef FACETSURF_FESPACE_HPP
+#define FACETSURF_FESPACE_HPP
+
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+  class NGS_DLL_HEADER FacetSurfaceFESpace : public FESpace 
+  {
+  protected:  
+    // Level
+    // int level;
+    // Number of Facets
+    int nfa;
+    // Number of Elements
+    int nel;
+  
+    Array<int> first_edge_dof;
+  
+    // relative order to mesh-order
+    int rel_order; 
+  
+    // int ndof;
+    // Array<int> ndlevel;
+    bool var_order; 
+    bool nowirebasket;
+    
+  public:
+    ///
+    FacetSurfaceFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool parseflags=false);
+    ///
+    virtual ~FacetSurfaceFESpace ();
+    ///
+    virtual string GetClassName () const override
+    {
+      return "FacetSurfFESpace";
+    }
+  
+    ///
+    void Update() override;
+    ///
+    virtual void UpdateCouplingDofArray() override;
+
+    ///
+    // virtual size_t GetNDof () const throw() override;
+    ///
+    // virtual size_t GetNDofLevel (int level) const override;
+
+    template <ELEMENT_TYPE ET>
+    FiniteElement & T_GetFE (int elnr, Allocator & alloc) const;
+    
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & lh) const override;
+
+    using FESpace::GetDofNrs;
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+    ///
+
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+    IntRange GetEdgeDofs (int nr) const
+    { 
+      return IntRange (first_edge_dof[nr], first_edge_dof[nr+1]); 
+    }
+  
+    virtual void GetFacetDofNrs (int nr, Array<DofId> & dnums) const
+    {
+      dnums.SetSize(0);
+    }
+
+    ///
+    virtual int GetNEdgeDofs (int felnr) const 
+    { return (first_edge_dof[felnr+1]-first_edge_dof[felnr] + 1); }
+    ///
+
+    virtual int GetFirstEdgeDof(int ednr) const 
+    {
+      return first_edge_dof[ednr];
+    }
+
+    virtual void GetVertexDofNrs ( int nr, Array<DofId> & dnums ) const override
+    {
+      dnums.SetSize0();
+    }
+
+    virtual void GetEdgeDofNrs ( int nr, Array<DofId> & dnums ) const override
+    {
+      dnums = GetEdgeDofs(nr);
+    }
+
+    virtual void GetFaceDofNrs (int nr, Array<DofId> & dnums) const override
+    {
+      dnums.SetSize(0);
+      return;
+    }
+  
+    virtual void GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override
+    {
+      dnums.SetSize(0);
+    }
+    
+  };
+
+}
+
+
+
+#endif

netgen/include/fe_interfaces.hpp

@@ -0,0 +1,32 @@
+
+#ifndef FILE_FEINTERFACES_
+#define FILE_FEINTERFACES_
+
+namespace ngfem
+{
+  template<ELEMENT_TYPE ET>
+  class VertexOrientedFE
+  {
+  protected:
+    enum { N_VERTEX = ET_trait<ET>::N_VERTEX };
+    int vnums[N_VERTEX];
+
+  public:
+    template <typename TA>
+    INLINE void SetVertexNumbers (const TA & avnums)
+    { for (int i = 0; i < N_VERTEX; i++) vnums[i] = avnums[i]; }
+    /// assign vertex number
+    INLINE void SetVertexNumber (int nr, int vnum) { vnums[nr] = vnum; }
+    INLINE FlatArray<const int> GetVertexNumbers () const { return { N_VERTEX, vnums }; }
+    auto GetVertexOrientedEdge (int nr) const
+    {
+      return ET_trait<ET>::GetEdgeSort (nr, vnums);
+    }
+    auto GetVertexOrientedFace (int nr) const
+    {
+      return ET_trait<ET>::GetFaceSort (nr, vnums);
+    }
+  };
+}
+
+#endif // FILE_FEINTERFACES_

netgen/include/fem.hpp

@@ -0,0 +1,87 @@
+#ifndef FILE_FEM
+#define FILE_FEM
+
+/*********************************************************************/
+/* File:   fem.hpp                                                   */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   25. Mar. 2000                                             */
+/*********************************************************************/
+
+/* 
+   Finite Element kernel functions
+*/
+
+#include <bla.hpp>
+
+
+/**
+   namespace for finite elements.
+   
+   Definition of reference FiniteElement, ScalarFiniteElement, and vector-valued elements HDivFiniteElement and HCurlFiniteElement 
+
+   Definition of the geometry of the element, i.e., ElementTransformation
+
+   IntegrationPoint on the reference element, and SpecificIntegrationPoint on the mapped element
+
+   Element-matrix and element-vector calculation by BilinearFormIntegrator and LinearFormIntegrator
+*/
+namespace ngfem
+{
+  using namespace std;
+  using namespace ngstd;
+  using namespace ngbla;
+}
+
+
+#include "elementtopology.hpp"
+#include "intrule.hpp"
+
+#include "recursive_pol.hpp"
+#include "recursive_pol_trig.hpp"
+// #include "recursive_pol_tet.hpp"
+
+#include "fe_interfaces.hpp"
+#include "finiteelement.hpp"
+#include "scalarfe.hpp"
+#include "tscalarfe.hpp"
+
+#include "elementtransformation.hpp"
+
+
+#include "h1lofe.hpp"
+#include "h1hofe.hpp"
+#include "l2hofe.hpp"
+#include "nodalhofe.hpp"
+
+#include "hdivfe.hpp"
+#include "hcurlfe.hpp"
+#include "thcurlfe.hpp"
+
+#include "hdivhofe.hpp"
+#include "hcurlhofe.hpp" 
+
+
+#include "facetfe.hpp" 
+#include "tangentialfacetfe.hpp"
+
+
+#include "specialelement.hpp"
+#include "code_generation.hpp"
+#include "coefficient.hpp"
+
+#include "diffop.hpp"
+#include "integrator.hpp"
+#include "diffop_impl.hpp"
+#include "bdbintegrator.hpp"
+#include "bdbequations.hpp"
+#include "hcurl_equations.hpp"
+#include "hdiv_equations.hpp"
+// #include "elasticity_equations.hpp"
+#include "symbolicintegrator.hpp"
+// #include "tensorproductintegrator.hpp"
+// #include "pml.hpp" 
+
+// using ngfem::ELEMENT_TYPE;
+// #include "tpdiffop.hpp"
+// #include "tpintrule.hpp"
+#endif

netgen/include/fesconvert.hpp

@@ -0,0 +1,14 @@
+#ifndef FILE_FESCONVERT
+#define FILE_FESCONVERT
+
+namespace ngcomp
+{
+
+  shared_ptr<BaseMatrix> ConvertOperator (shared_ptr<FESpace> spacea, shared_ptr<FESpace> spaceb, VorB vb, LocalHeap & lh,
+					  shared_ptr<DifferentialOperator> diffop = nullptr, shared_ptr<CoefficientFunction> trial_cf = nullptr,
+					  const Region * reg = NULL, shared_ptr<BitArray> range_dofs = nullptr, bool localop = false, bool parmat = true,
+					  bool use_simd = true, int bonus_intorder_ab = 0, int bonus_intorder_bb = 0, bool geom_free = false);
+
+} // namespace ngcomp
+
+#endif