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

netgen/include/finiteelement.hpp

@@ -0,0 +1,286 @@
+#ifndef FILE_FINITEELEMENT
+#define FILE_FINITEELEMENT
+
+
+/*********************************************************************/
+/* File:   finiteelement.hpp                                         */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   25. Mar. 2000                                             */
+/*********************************************************************/
+
+
+
+#include "elementtopology.hpp"
+#include "intrule.hpp"
+#include "elementtransformation.hpp"
+
+#include "fe_interfaces.hpp"
+
+namespace ngfem
+{
+  // template <int N, typename T = int>
+  // using INT = IVec<N,T>;
+
+
+  
+  /** 
+      Base class finite element.
+      Represents a reference element.
+      Mainly used as interface. Usually casted to ScalarFiniteElement, HCurlFiniteElement or HDivFiniteElement.
+      Provides element shape, space dimension, number of dofs, polynomial order.
+  */
+  class NGS_DLL_HEADER FiniteElement
+  {
+  protected:
+    /// number of degrees of freedom
+    int ndof;
+    /// polynomial order
+    int order;
+  protected:
+    /// default constructor
+    INLINE FiniteElement () { ; }
+
+    /// provides number of dofs and maximal order of shapes
+    INLINE FiniteElement (int andof, int aorder)
+      : ndof(andof), order(aorder)
+    { ; }
+
+  public:
+    /// make the class virtual
+    HD virtual ~FiniteElement () { ; }
+
+    /// Number of degrees-of-freedom
+    INLINE int GetNDof () const { return ndof; }
+
+    HD virtual tuple<int,int,int,int> GetNDofVEFC () const { return { 1, 1, 1, 1 }; }
+
+
+    /// maximal polynomial order
+    INLINE int Order () const { return order; }
+
+    /// geometry of element
+    HD virtual ELEMENT_TYPE ElementType() const = 0; 
+
+    HD virtual int Dim () const
+    {
+      return ElementTopology::GetSpaceDim(ElementType());
+    }
+
+    HD virtual bool ComplexShapes() const { return false; }
+
+    /// the name of the element family
+    virtual string ClassName() const;
+
+    virtual FiniteElement * SetVertexNumbers (FlatArray<int> vnums);
+    
+    virtual IntegrationRule GetIR (int order) const;
+
+    /// precomputes shape for integrationrule
+    virtual void PrecomputeShapes (const IntegrationRule & ir);
+    
+    ///
+    virtual void Print (ostream & ost) const;
+
+    virtual void Interpolate (const ElementTransformation & trafo, 
+                              const class CoefficientFunction & func, SliceMatrix<> coefs,
+                              LocalHeap & lh) const;
+      
+    virtual bool SolveDuality (SliceVector<> rhs, SliceVector<> u, LocalHeap & lh) const { return false; }
+    virtual bool SolveDuality (SliceVector<Complex> rhs, SliceVector<Complex> u, LocalHeap & lh) const { return false; }
+    
+    virtual list<tuple<string,double>> Timing () const { return list<tuple<string,double>>(); }
+  };
+
+ 
+  ostream & operator<< (ostream & ost, const FiniteElement & fel);
+
+  /**
+     A compound of several elements. 
+     Useful for mixed finite elements such as Stokes problem: 
+     Combine 3 velocity and 1 pressure element
+  */
+  class NGS_DLL_HEADER CompoundFiniteElement : public FiniteElement
+  {
+  protected:
+    /// pointers to the components
+    FlatArray<FiniteElement*> fea;
+    bool all_the_same{true};
+
+  public:
+    /// initialize with pointers to components, copy pointers
+    CompoundFiniteElement (FlatArray<FiniteElement*> afea);
+
+    HD virtual ELEMENT_TYPE ElementType() const override { return fea[0]->ElementType(); }
+    /// number of components
+    int GetNComponents() const { return fea.Size(); }
+
+    /// select i-th component
+    const FiniteElement & operator[] (int i) const { return *fea[i]; }
+
+    /// dof range of comp-th component
+    IntRange GetRange (int comp) const
+    {
+      int base = 0;
+      for (int i = 0; i < comp; i++)
+	base += fea[i]->GetNDof();
+      return IntRange (base, base+fea[comp]->GetNDof());
+    }
+
+    /// the name of the element family
+    virtual string ClassName() const override { return "CompoundFiniteElement"; }
+    
+    virtual CompoundFiniteElement * SetVertexNumbers (FlatArray<int> vnums) override
+    {
+      for (auto pfel : fea)
+        pfel -> SetVertexNumbers(vnums);
+      return this;
+    }
+
+    HD virtual bool ComplexShapes() const override;
+
+    virtual void Interpolate (const ElementTransformation & trafo,
+                              const class CoefficientFunction & func, SliceMatrix<> coefs,
+                              LocalHeap & lh) const override;
+
+    virtual void Print (ostream & ost) const override;
+  };
+
+  class NGS_DLL_HEADER VectorFiniteElement : public FiniteElement
+  {
+  protected:
+    /// pointers to the components
+    // ArrayMem<const FiniteElement*,10> fea;
+    const FiniteElement& scalar_fe;
+    const int dim;
+
+  public:
+
+    VectorFiniteElement (const FiniteElement& ascalar_fe, int adim);
+
+    HD virtual ELEMENT_TYPE ElementType() const override { return scalar_fe.ElementType(); }
+    /// number of components
+    int GetNComponents() const { return dim; }
+
+    /// select i-th component
+    const FiniteElement & operator[] (int i) const { return scalar_fe; }
+
+    /// dof range of comp-th component
+    IntRange GetRange (int comp) const
+    {
+      int base = scalar_fe.GetNDof() * comp;
+      return IntRange (base, base + scalar_fe.GetNDof());
+    }
+
+    /// the name of the element family
+    virtual string ClassName() const override { return "VectorFiniteElement"; }
+
+    virtual VectorFiniteElement * SetVertexNumbers (FlatArray<int> vnums) override;
+
+    virtual void Print (ostream & ost) const override;
+
+    virtual void Interpolate (const ElementTransformation & trafo,
+                              const class CoefficientFunction & func, SliceMatrix<> coefs,
+                              LocalHeap & lh) const override;
+  };
+
+  // a pair of 2 elements
+  class MixedFiniteElement : public FiniteElement
+  {
+    const FiniteElement & fe_trial;
+    const FiniteElement & fe_test;
+  public:
+    MixedFiniteElement (const FiniteElement & _fe_trial, const FiniteElement & _fe_test)
+      : fe_trial(_fe_trial), fe_test(_fe_test) { ; } 
+    virtual ~MixedFiniteElement() = default;
+
+    const FiniteElement & FETrial() const { return fe_trial; } 
+    const FiniteElement & FETest() const { return fe_test; }
+    HD virtual ELEMENT_TYPE ElementType() const { return fe_trial.ElementType(); }    
+    HD virtual bool ComplexShapes() const { return fe_trial.ComplexShapes() && fe_test.ComplexShapes(); }
+  };
+
+
+  class NGS_DLL_HEADER SymMatrixFiniteElement : public FiniteElement
+  {
+  protected:
+    int vdim;
+    bool deviatoric;
+    int dim;
+    const FiniteElement & scalfe;
+  public:
+    /// initialize with pointers to components, copy pointers
+    SymMatrixFiniteElement (const FiniteElement & ascalfe, int avdim, bool adeviatoric);
+
+    HD virtual ELEMENT_TYPE ElementType() const override { return scalfe.ElementType(); }
+    /// number of components
+    int GetNComponents() const { return dim; }
+
+    /// select i-th component
+    // const FiniteElement & operator[] (int i) const { return *fea[i]; }
+    const FiniteElement & ScalFE() const { return scalfe; }
+
+    /// the name of the element family
+    virtual string ClassName() const override { return "SymMatrixFiniteElement"; }
+
+    virtual void Print (ostream & ost) const override;
+
+    virtual void Interpolate (const ElementTransformation & trafo, 
+                              const class CoefficientFunction & func, SliceMatrix<> coefs,
+                              LocalHeap & lh) const override; 
+  };
+
+
+  class NGS_DLL_HEADER SkewMatrixFiniteElement : public FiniteElement
+  {
+  protected:
+    int vdim;
+    int dim;
+    const FiniteElement & scalfe;
+  public:
+    /// initialize with pointers to components, copy pointers
+    SkewMatrixFiniteElement (const FiniteElement & ascalfe, int avdim);
+
+    HD virtual ELEMENT_TYPE ElementType() const override { return scalfe.ElementType(); }
+    /// number of components
+    int GetNComponents() const { return dim; }
+
+    /// select i-th component
+    // const FiniteElement & operator[] (int i) const { return *fea[i]; }
+    const FiniteElement & ScalFE() const { return scalfe; }
+
+    /// the name of the element family
+    virtual string ClassName() const override { return "SkewMatrixFiniteElement"; }
+
+    virtual void Print (ostream & ost) const override;
+
+    virtual void Interpolate (const ElementTransformation & trafo, 
+                              const class CoefficientFunction & func, SliceMatrix<> coefs,
+                              LocalHeap & lh) const override; 
+  };
+
+
+  
+  /**
+     a placeholder finite element
+   */
+  template <ELEMENT_TYPE ET>
+  class DummyFE : public FiniteElement
+  {
+  public:
+    /* INLINE */ DummyFE () : FiniteElement(0, 0) { ; }
+    HD virtual ELEMENT_TYPE ElementType() const { return ET; }
+  };
+
+
+  extern template class DummyFE<ET_POINT>;
+  extern template class DummyFE<ET_SEGM>;
+  extern template class DummyFE<ET_TRIG>;
+  extern template class DummyFE<ET_QUAD>;
+  extern template class DummyFE<ET_TET>;
+  extern template class DummyFE<ET_PRISM>;
+  extern template class DummyFE<ET_PYRAMID>;
+  extern template class DummyFE<ET_HEX>;
+}
+
+
+#endif

netgen/include/globalinterfacespace.hpp

@@ -0,0 +1,77 @@
+#ifndef NGSOLVE_GLOBALINTERFACESPACE_HPP
+#define NGSOLVE_GLOBALINTERFACESPACE_HPP
+
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+  class GlobalInterfaceSpace : public FESpace
+  {
+  protected:
+    shared_ptr<CoefficientFunction> mapping;
+    int order;
+    bool periodic[2]; // periodic u/ periodic v
+    bool polar; // using basis for polar coordinates
+
+    template<typename VOLFE>
+    class VolDiffOp : public DifferentialOperator
+    {
+    public:
+      VolDiffOp ()
+        : DifferentialOperator(1, 1, VOL, 0) { ; }
+
+      void CalcMatrix (const FiniteElement & bfel,
+                       const BaseMappedIntegrationPoint & mip,
+                       BareSliceMatrix<double,ColMajor> mat,
+                       LocalHeap & lh) const override;
+    };
+
+    template<typename VOLFE>
+    class ParameterGradDiffOp : public DifferentialOperator
+    {
+    public:
+      ParameterGradDiffOp ()
+        : DifferentialOperator(VOLFE::GetDim(), 1, VOL, 0) { ; }
+
+      void CalcMatrix (const FiniteElement & bfel,
+                       const BaseMappedIntegrationPoint & mip,
+                       BareSliceMatrix<double,ColMajor> mat,
+                       LocalHeap & lh) const override;
+    };
+
+    template<typename INTERFACEFE>
+    class InterfaceDiffOp : public DifferentialOperator
+    {
+    public:
+      InterfaceDiffOp ()
+        : DifferentialOperator(1, 1, BND, 0) { ; }
+
+      void CalcMatrix (const FiniteElement & fel,
+                       const BaseMappedIntegrationPoint & mip,
+                       BareSliceMatrix<double,ColMajor> mat,
+                       LocalHeap & lh) const override;
+    };
+
+  public:
+    GlobalInterfaceSpace(shared_ptr<MeshAccess> ama, const Flags& flags);
+
+    static DocInfo GetDocu()
+    {
+      auto docu = FESpace::GetDocu();
+      docu.Arg("mapping") = "Mapping for global interface space.";
+      docu.Arg("periodic") = "Periodic global interface space (in 2d in x and y direction).";
+      docu.Arg("periodicu") = "Periodic u-dir (local coordinate system) global interface space.";
+      docu.Arg("periodicv") = "Periodic v-dir (local coordinate system) global interface space.";
+      docu.Arg("polar") = "Polar mapping (r, phi). Uses stable basis for singularity in origin. Automatically sets first argument (r) not periodic and second (phi) periodic. Mapping must be to [0,1]x[-pi, pi)";
+      return docu;
+    }
+  };
+
+  shared_ptr<GlobalInterfaceSpace> CreateGlobalInterfaceSpace
+    (shared_ptr<MeshAccess> ma, shared_ptr<CoefficientFunction> mapping,
+     optional<Region> definedon, bool periodic, bool periodicu,
+     bool periodicv, int order, bool complex, bool polar, bool autoupdate);
+} // namespace ngcomp
+
+#endif // NGSOLVE_GLOBALINTERFACESPACE_HPP

netgen/include/globalspace.hpp

@@ -0,0 +1,115 @@
+#ifndef NGSOLVE_GLOBALSPACE_HPP
+#define NGSOLVE_GLOBALSPACE_HPP
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+  class GlobalSpace : public FESpace
+  {
+  protected:
+    shared_ptr<CoefficientFunction> basis;
+    shared_ptr<CoefficientFunction> grad_basis[3];     
+    int dim;       // number of basis functions
+    int vecdim;    // vector dimension of each basis function
+    bool complex_basis;
+    
+    static int CalcDim(shared_ptr<CoefficientFunction> basis)
+    {
+      auto dims = basis->Dimensions();
+      return (dims.Size() == 0) ? 1 : dims[0]; 
+    }
+
+    static int CalcVecDim(shared_ptr<CoefficientFunction> basis)
+    {
+      auto dims = basis->Dimensions();
+      return (dims.Size() <= 1) ? 1 : dims[1];
+    }
+    
+    class FE : public FiniteElement
+    {
+      ELEMENT_TYPE type;
+      bool complex;
+    public:
+      FE(int adim, int aorder, ELEMENT_TYPE atype, bool acomplex)
+        : FiniteElement(adim, aorder), type(atype), complex(acomplex) { };
+      ELEMENT_TYPE ElementType() const override { return type; }
+      bool ComplexShapes() const override { return complex; }
+      
+    };
+    
+    class VolDiffOp : public DifferentialOperator
+    {
+      shared_ptr<CoefficientFunction> basis;
+      int dim, vecdim;
+    public:
+      VolDiffOp (shared_ptr<CoefficientFunction> abasis, VorB vb = VOL)
+        : DifferentialOperator(CalcVecDim(abasis), 1, vb, 0), basis(abasis),
+          dim(CalcDim(abasis)), vecdim(CalcVecDim(abasis)) { ; }
+
+      virtual bool SupportsVB (VorB checkvb) const override { return true; }
+
+      void CalcMatrix (const FiniteElement & bfel,
+                       const BaseMappedIntegrationPoint & mip,
+                       BareSliceMatrix<double,ColMajor> mat,
+                       LocalHeap & lh) const override;
+
+      void CalcMatrix (const FiniteElement & bfel,
+                       const BaseMappedIntegrationPoint & mip,
+                       BareSliceMatrix<Complex,ColMajor> mat,
+                       LocalHeap & lh) const override;
+
+      void Apply (const FiniteElement & fel,
+                  const BaseMappedIntegrationPoint & mip,
+                  BareSliceVector<Complex> x, 
+                  FlatVector<Complex> flux,
+                  LocalHeap & lh) const override;
+
+      void Apply (const FiniteElement & fel,
+                  const BaseMappedIntegrationRule & mir,
+                  BareSliceVector<double> x, 
+                  BareSliceMatrix<double> flux,
+                  LocalHeap & lh) const override;
+
+      void ApplyTrans (const FiniteElement & fel,
+                       const BaseMappedIntegrationRule & mir,
+                       FlatMatrix<double> flux,
+                       BareSliceVector<double> x, 
+                       LocalHeap & lh) const override;
+
+      void CalcMatrix (const FiniteElement & fel,
+                       const SIMD_BaseMappedIntegrationRule & mir,
+                       BareSliceMatrix<SIMD<double>> mat) const override;
+
+      void Apply (const FiniteElement & bfel,
+                  const SIMD_BaseMappedIntegrationRule & bmir,
+                  BareSliceVector<double> x, 
+                  BareSliceMatrix<SIMD<double>> flux) const override;
+      
+      
+      void AddTrans (const FiniteElement & bfel,
+                     const SIMD_BaseMappedIntegrationRule & bmir,
+                     BareSliceMatrix<SIMD<double>> flux,
+                     BareSliceVector<double> x) const override;
+    };
+
+    
+  public:
+    GlobalSpace(shared_ptr<MeshAccess> ama, const Flags& flags);
+
+    static DocInfo GetDocu()
+    {
+      auto docu = FESpace::GetDocu();
+      docu.Arg("basis") = "Basis functions.";
+      return docu;
+    }
+
+    void AddOperator (string name, VorB vb, shared_ptr<CoefficientFunction> dbasis);
+    
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & lh) const;
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const;
+  };
+
+} // namespace ngcomp
+
+#endif // NGSOLVE_GLOBALSPACE_HPP