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

netgen/include/ngsstream.hpp

@@ -0,0 +1,113 @@
+#ifndef FILE_NGSSTREAM
+#define FILE_NGSSTREAM
+
+/**************************************************************************/
+/* File:   ngsstream.hpp                                                  */
+/* Author: Joachim Schoeberl                                              */
+/* Date:   20. Jul. 2011                                                  */
+/**************************************************************************/
+
+
+namespace ngstd
+{
+
+ 
+  // important message
+  class IM
+  {
+    int value;
+  public:
+    IM (int val) : value(val) { ; }
+    int Value () const { return value; }
+  };
+
+  class trunc
+  {
+    double eps;
+  public:
+    trunc (double aeps) : eps(aeps) { ; }
+    double Eps() const { return eps; }
+  };
+  
+  class NGSOStream
+  {
+    ostream & ost;
+    bool active;
+    NGS_DLL_HEADER static bool glob_active;
+    double trunc;
+  public:
+    NGSOStream (ostream & aost, bool aactive)
+      : ost(aost), active(aactive), trunc(-1) { ; }
+    NGSOStream & SetTrunc (double atrunc) { trunc = atrunc; return *this; }
+    double GetTrunc () const { return trunc; }
+    bool Active () const { return active && glob_active; }
+    ostream & GetStream () { return ost; }
+    static void SetGlobalActive (bool b) { glob_active = b; }
+  };
+  
+  inline NGSOStream operator<< (ostream & ost, const IM & im)
+  {
+    return NGSOStream (ost, 
+		       (im.Value() <= printmessage_importance));
+  }
+
+  /*
+    // doesn't work for matrices
+  inline NGSOStream operator<< (ostream & ost, trunc tr)
+  {
+    cout << "set trunc modifier" << endl;
+    return NGSOStream (ost, true).SetTrunc (tr.Eps());
+  }
+  */
+
+  
+  template <typename T>
+  inline NGSOStream operator<< (NGSOStream ngsost, const T & data)
+  {
+    if (ngsost.Active())
+      ngsost.GetStream() << data;
+    return ngsost;
+  }
+
+  /*
+  inline NGSOStream operator<< (NGSOStream ngsost, const double & data)
+  {
+    cout << "double out" << endl;
+    if (ngsost.Active())
+      {
+        double hdata = data;
+        if (fabs (hdata) < ngsost.GetTrunc()) hdata = 0.0;
+        ngsost.GetStream() << hdata;
+      }
+    return ngsost;
+  }
+  */
+  
+  inline NGSOStream operator<< (NGSOStream ngsost, ostream& ( *pf )(ostream&))
+  {
+    if ( ngsost.Active() )
+      ngsost.GetStream() << (*pf);
+
+    return ngsost;
+  }
+  
+  inline NGSOStream operator<< (NGSOStream ngsost, ios& ( *pf )(ios&))
+  {
+    if ( ngsost.Active() )
+      ngsost.GetStream() << (*pf);
+    
+    return ngsost;
+  }
+
+  inline NGSOStream operator<< (NGSOStream ngsost, ios_base& ( *pf )(ios_base&))
+  {
+    if ( ngsost.Active() )
+      ngsost.GetStream() << (*pf);
+    
+    return ngsost;
+  }
+
+
+}
+
+#endif

netgen/include/ngstd.hpp

@@ -0,0 +1,72 @@
+#ifndef FILE_NGSTD
+#define FILE_NGSTD
+
+/*********************************************************************/
+/* File:   ngstd.hpp                                                 */
+/* Author: Joachim Schoeberl                                         */
+/* Date:   25. Mar. 2000                                             */
+/*********************************************************************/
+
+/* 
+   ng-standard classes
+*/
+
+#include <ngs_stdcpp_include.hpp>
+
+namespace ngstd
+{
+  // NGS_DLL_HEADER extern int printmessage_importance;
+  NGS_DLL_HEADER extern const std::string ngsolve_version;
+}
+
+
+/**
+   namespace for standard data types and algorithms.
+
+   Generic container classes: FlatArray, Array, ArrayMem
+
+Specific data types Exception, BlockAllocator, EvalFunction, AutoDiff, AutoDiffDiff
+*/
+
+
+#include <ngs_defines.hpp>
+#include <core/ngcore.hpp>
+#include <core/autodiff.hpp>
+#include <core/autodiffdiff.hpp>
+
+namespace ngstd
+{
+  using namespace ngcore;
+  // using ngcore::INT;
+} // namespace ngstd
+
+#include "ngs_utils.hpp"
+
+#include "blockalloc.hpp"
+#include "memusage.hpp"
+
+#include "evalfunc.hpp"
+#include "sample_sort.hpp"
+
+// #include "polorder.hpp"
+#include "stringops.hpp"
+#include "statushandler.hpp"
+
+namespace ngstd
+{
+#ifdef WIN32
+  const char dirslash = '\\';
+#else
+  const char dirslash = '/';
+#endif
+
+  
+  // using ngcore::NgMPI_Comm;
+  enum { NG_MPI_TAG_CMD = 110 };
+  enum { NG_MPI_TAG_SOLVE = 1110 };
+}
+
+
+inline void NOOP_Deleter(void *) { ; }
+
+#endif

netgen/include/nodalhofe.hpp

@@ -0,0 +1,96 @@
+#ifndef FILE_NODALHOFE
+#define FILE_NODALHOFE
+
+#include "tscalarfe.hpp"
+
+namespace ngfem
+{
+
+
+
+  template <ELEMENT_TYPE ET>
+  class NodalHOFE : public  T_ScalarFiniteElement<NodalHOFE<ET>, ET>,
+                    public ET_trait<ET>, public VertexOrientedFE<ET>
+  {
+  protected:
+    
+    enum { DIM = ET_trait<ET>::DIM };
+
+    using ScalarFiniteElement<DIM>::ndof;
+    using ScalarFiniteElement<DIM>::order;
+
+    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>::GetEdgeSort;
+    using ET_trait<ET>::GetFaceSort;
+    using ET_trait<ET>::PolDimension;
+    using ET_trait<ET>::PolBubbleDimension;
+
+    
+  public:
+    using VertexOrientedFE<ET>::SetVertexNumbers;    
+    NodalHOFE * SetVertexNumbers (FlatArray<int> vnums) override
+    { VertexOrientedFE<ELEMENT_TYPE(ET)>::SetVertexNumbers(vnums); return this; }   // cast for msvc ?
+    using ET_trait<ET>::ElementType;
+
+    /// builds a functional element of order aorder.
+    INLINE NodalHOFE (int aorder)
+    { 
+      ndof = PolDimension (aorder);
+      order = aorder;
+    }
+
+    
+    template<typename Tx, typename TFA>  
+    INLINE void T_CalcShape (TIP<DIM,Tx> ip, TFA & shape) const;
+    
+    /*
+    virtual tuple<int,int,int,int> GetNDofVEFC () const override
+    {
+      int nv = N_VERTEX;
+      int ne = 0, nf = 0, nc = 0;
+      
+      for (int i = 0; i < N_EDGE; i++)
+        ne += int(order) - 1;
+      
+      for (int i = 0; i < N_FACE; i++)
+        nf += ::ngfem::PolBubbleDimension (FaceType(i), INT<2>(order));
+      
+      if (DIM == 3)
+        nc += PolBubbleDimension (INT<3>(order));
+      return { nv, ne, nf, nc };
+    }
+    */
+  };
+
+}  
+
+
+
+#ifdef FILE_NODALHOFE_CPP
+
+#define NODALHOFE_EXTERN
+#include <nodalhofe_impl.hpp>
+#include <tscalarfe_impl.hpp>
+
+#else
+
+#define NODALHOFE_EXTERN extern
+
+#endif
+
+namespace ngfem
+{
+  NODALHOFE_EXTERN template class NodalHOFE<ET_SEGM>;
+  NODALHOFE_EXTERN template class NodalHOFE<ET_TRIG>;
+  NODALHOFE_EXTERN template class NodalHOFE<ET_TET>;
+
+  NODALHOFE_EXTERN template class T_ScalarFiniteElement<NodalHOFE<ET_SEGM>, ET_SEGM>;
+  NODALHOFE_EXTERN template class T_ScalarFiniteElement<NodalHOFE<ET_TRIG>, ET_TRIG>;
+  NODALHOFE_EXTERN template class T_ScalarFiniteElement<NodalHOFE<ET_TET>, ET_TET>;
+}
+
+#endif

netgen/include/nodalhofe_impl.hpp

@@ -0,0 +1,141 @@
+
+
+namespace ngfem
+{
+
+
+  template <typename Tx>
+  INLINE auto NodalShapePower(Tx lam, int i, int order)
+  {
+    Tx prod = Tx(1.0);
+    for (int j = 0; j < i; j++)
+      prod *= (order*lam - j) / (i-j);
+
+    return prod;
+  }
+
+  
+  template <> template<typename Tx, typename TFA>  
+  void NodalHOFE<ET_SEGM> :: T_CalcShape (TIP<1,Tx> ip, TFA & shape) const
+  {
+    Tx lam[2] = { ip.x, 1-ip.x };
+
+    IVec<2> e = GetVertexOrientedEdge (0);
+
+    shape[0] = NodalShapePower(lam[0], order, order);
+    shape[1] = NodalShapePower(lam[1], order, order);
+
+    for (int i = 1; i < order; i++)
+      {
+        auto ls = lam[e[0]];
+        auto le = lam[e[1]];
+        shape[i+1] = NodalShapePower(ls, i, order);
+        shape[i+1] = NodalShapePower(le, order-i, order);
+      }
+  }
+
+
+  
+  template <> template<typename Tx, typename TFA>  
+  void NodalHOFE<ET_TRIG> :: 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++)
+      {
+        auto shapei = NodalShapePower (lam[i], order, order);
+        // cout << "x = " << ip.x << ", y = " << ip.y << ", shape = " << shapei << endl;
+        shape[i] = shapei;
+      }
+
+    int ii=3;
+    // edge-based shapes
+    for (int i = 0; i < N_EDGE; i++)
+      { 
+        IVec<2> e = GetVertexOrientedEdge(i);
+
+        auto ls = lam[e[0]];
+        auto le = lam[e[1]];
+        for (int j = 1; j < order; j++)
+          {
+            shape[ii++] =
+              NodalShapePower(ls, j, order) * 
+              NodalShapePower(le, order-j, order);
+          }
+      }
+
+    for (int i = 0; i < N_FACE; i++)
+      { 
+        IVec<4> f = GetVertexOrientedFace(i);
+
+        auto ls = lam[f[0]];
+        auto le = lam[f[1]];
+        auto lo = lam[f[2]];
+        for (int j = 1; j < order; j++)
+          for (int k = 1; j+k < order; k++)
+            {
+              shape[ii++] =
+                NodalShapePower(ls, j, order) * 
+                NodalShapePower(le, k, order) *
+                NodalShapePower(lo, order-j-k, order);              
+            }
+      }
+  }
+
+
+  template <> template<typename Tx, typename TFA>  
+  void NodalHOFE<ET_TET> :: 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] = NodalShapePower (lam[i], order, order);
+
+
+    int ii = 4;
+    // edge-based shapes
+    for (int i = 0; i < N_EDGE; i++)
+      { 
+        IVec<2> e = GetVertexOrientedEdge(i);
+
+        auto ls = lam[e[0]];
+        auto le = lam[e[1]];
+        for (int j = 1; j < order; j++)
+          {
+            shape[ii++] =
+              NodalShapePower(ls, j, order) * 
+              NodalShapePower(le, order-j, order);
+          }
+      }
+
+    for (int i = 0; i < N_FACE; i++)
+      { 
+        IVec<4> f = GetVertexOrientedFace(i);
+
+        auto ls = lam[f[0]];
+        auto le = lam[f[1]];
+        auto lo = lam[f[2]];
+        for (int j = 1; j < order; j++)
+          for (int k = 1; j+k < order; k++)
+            {
+              shape[ii++] =
+                NodalShapePower(ls, j, order) * 
+                NodalShapePower(le, k, order) *
+                NodalShapePower(lo, order-j-k, order);              
+            }
+      }
+
+    for (int j = 1; j < order; j++)
+      for (int k = 1; j+k < order; k++)
+        for (int l = 1; j+k+l < order; k++)
+          {
+            shape[ii++] =
+              NodalShapePower(lam[0], j, order) * 
+              NodalShapePower(lam[1], k, order) *
+              NodalShapePower(lam[2], l, order) *
+              NodalShapePower(lam[3], order-j-k-l, order);                          
+          }
+  }
+
+  
+}

netgen/include/normalfacetfe.hpp

@@ -0,0 +1,223 @@
+#ifndef NORMAL_FACET_FE_HPP__
+#define NORMAL_FACET_FE_HPP__
+
+/*********************************************************************/
+/* File:   normalfacetfe.hpp                                         */
+/* Author: J. Schoeberl                                              */
+/* Date:   2019                                                      */
+/*********************************************************************/
+
+
+// #include <fem.hpp>
+#include "thdivfe.hpp"
+#include "recursive_pol.hpp"
+#include <cassert>
+
+namespace ngfem 
+{
+  /*
+    facet element with normal facet components.
+  */
+  
+  template <ELEMENT_TYPE ET>
+  class NormalFacetFacetFE :
+    public HDivNormalFiniteElement<ET_trait<ET>::DIM>,
+    public VertexOrientedFE<ET>,
+    public ET_trait<ET>
+  {
+  protected:
+    IVec<2> order_inner;
+    using VertexOrientedFE<ET>::vnums;
+    using ET_trait<ET>::DIM;
+    using HDivNormalFiniteElement<ET_trait<ET>::DIM>::order;
+ 
+  public:
+    using VertexOrientedFE<ET>::SetVertexNumber;
+    using VertexOrientedFE<ET>::SetVertexNumbers;
+
+    NormalFacetFacetFE (int aorder) : HDivNormalFiniteElement<ET_trait<ET>::DIM>(aorder+1,aorder)
+    {
+      order = aorder;
+      order_inner = IVec<2>(aorder,aorder);
+      ComputeNDof();
+    }
+
+    NormalFacetFacetFE () : HDivNormalFiniteElement<ET_trait<ET>::DIM>(0,0) { ; }
+
+    HD virtual ELEMENT_TYPE ElementType() const override { return ELEMENT_TYPE(ET); }
+
+    INLINE void SetOrder (int aorder)
+    {
+      order = aorder;
+      order_inner = IVec<2>(aorder,aorder);
+      ComputeNDof();
+    }
+  
+    INLINE void SetOrder (IVec<2> oi)
+    {
+      order = max2 (oi[0], oi[1]);
+      order_inner = oi;
+      ComputeNDof();
+    }
+
+    virtual void ComputeNDof ();
+
+    virtual void CalcShape(const IntegrationPoint & ip,
+         		    FlatVector<> shape) const override;
+
+    template<typename Tx, typename TFA>  
+    void T_CalcShape (TIP<DIM,Tx> tip, TFA & shape) const;
+  };
+
+
+  
+
+  template <ELEMENT_TYPE ET> class NormalFacetVolumeFE_Shape;
+  
+  template <ELEMENT_TYPE ET>
+  class NormalFacetVolumeFE : public T_HDivFiniteElement<NormalFacetVolumeFE_Shape<ET>, ET>,
+                              public ET_trait<ET>, public VertexOrientedFE<ET>
+  {
+  protected:
+    using ET_T = ET_trait<ET>;
+    IVec<2> facet_order[ET_T::N_FACET];
+    int first_facet_dof[ET_T::N_FACET+1];
+    bool highest_order_dc;
+    using HDivFiniteElement<ET_trait<ET>::DIM>::order;
+    using VertexOrientedFE<ET>::vnums;
+    enum { DIM = ET_trait<ET>::DIM };
+    typedef T_HDivFiniteElement<NormalFacetVolumeFE_Shape<ET>, ET> TBASE;
+    
+  public:
+    using VertexOrientedFE<ET>::SetVertexNumbers;
+    
+    NormalFacetVolumeFE () { highest_order_dc=false; }
+    
+    HD virtual ELEMENT_TYPE ElementType() const override { return ELEMENT_TYPE(ET); }
+
+    void SetHighestOrderDC(bool set) { highest_order_dc=set; }
+
+    void SetOrder(int ao)
+    {
+      order = ao;
+      for ( int i = 0; i < ET_T::N_FACET; i++ )
+        facet_order[i] = IVec<2> (ao, ao);
+      ComputeNDof();
+    }
+
+    void SetOrder(FlatArray<int> & ao)
+    {
+      order = 0;
+      assert(ao.Size()==ET_T::N_FACET);
+      for ( int i = 0; i < ET_T::N_FACET; i++ )
+        {
+          order = max2 ( order, ao[i] );
+          facet_order[i] = IVec<2> (ao[i], ao[i]);
+        }
+      ComputeNDof();
+    }
+
+    void SetOrder(FlatArray<IVec<2> > & ao)
+    {
+      order = 0;
+      assert(ao.Size()==ET_T::N_FACET);
+      for ( int i = 0; i < ET_T::N_FACET; i++ )
+        {
+          order = max3 ( order, ao[i][0], ao[i][1] );
+          facet_order[i] = ao[i];
+        }
+      ComputeNDof();
+    }
+
+    IVec<2> GetFacetOrder(int j) const { return facet_order[j]; }
+    int GetVertexNumber(int j) const { return vnums[j]; }
+
+    /*
+    virtual void CalcShape (const IntegrationPoint & ip, SliceMatrix<> shape) const override
+    {
+      int fnr = ip.FacetNr();
+      if (fnr >= 0)
+        {
+          CalcShape (ip, fnr, shape);
+          return;
+        }
+      throw Exception("NormalFacetVolumeFiniteElement<D>::CalcShape in global coordinates disabled");
+    }
+
+    virtual void CalcMappedShape (const SIMD_BaseMappedIntegrationRule & mir, 
+                                  BareSliceMatrix<SIMD<double>> shapes) const override;
+    
+    virtual void Evaluate (const SIMD_BaseMappedIntegrationRule & ir, BareSliceVector<> coefs,
+                           BareSliceMatrix<SIMD<double>> values) const override;
+    
+    virtual void AddTrans (const SIMD_BaseMappedIntegrationRule & ir, BareSliceMatrix<SIMD<double>> values,
+                           BareSliceVector<> coefs) const override;
+    */
+    template<typename Tx, typename TFA>  
+    void T_CalcShape (Tx hx[DIM], int fnr, TFA & shape) const;
+
+    template<typename MIP, typename TFA>  
+    void CalcDualShape2 (MIP mip, int fnr, TFA & shape) const;
+
+    using TBASE::CalcShape;
+    virtual void CalcShape (const IntegrationPoint & ip, int facet, SliceMatrix<> shape) const;
+
+    using TBASE::CalcDualShape;
+    virtual void CalcDualShape (const BaseMappedIntegrationPoint & bmip, BareSliceMatrix<> shape) const override;
+
+    virtual int GetNExtraShapes( int facet) const {return 0;}
+    virtual void CalcExtraShape (const IntegrationPoint & ip, int facet, FlatMatrixFixWidth<ET_T::DIM> xshape) const {xshape = 0.0;}
+
+    virtual void GetFacetDofNrs(int afnr, Array<int>& fdnums) const
+    {
+      int first = first_facet_dof[afnr];
+      int next = first_facet_dof[afnr+1];
+      assert(next > first);
+      fdnums.SetSize(next-first);
+      for (auto i : Range(next-first))
+        fdnums[i] = first+i;
+    }
+
+    virtual int GetFacetNDof(int afnr) const
+    { return first_facet_dof[afnr+1] - first_facet_dof[afnr]; };
+    virtual int GetFirstFacetDof(int afnr) const {
+      return first_facet_dof[afnr];};
+
+    virtual void ComputeNDof ();
+
+    /// degrees of freedom sitting inside the element, used for static condensation
+    virtual void GetInternalDofs (Array<int> & idofs) const
+    {
+      idofs.SetSize(0);
+      if (highest_order_dc)
+        {
+          if (ET_T::DIM==2)
+            {
+              for (int i=0; i < ET_T::N_FACET; i++)
+                idofs.Append(first_facet_dof[i+1]-1);
+            }
+          else
+            {
+              throw Exception ("NormalFacetFE with hodc not ready in 3D");
+              for (int i=0; i < ET_T::N_FACET; i++)
+                {
+                  int pos = first_facet_dof[i]-2;
+                  int fac = 4 - ElementTopology::GetNVertices(ElementTopology::GetFaceType(ET,i));
+                  for (int k = 0; k <= facet_order[i][0]; k++){
+                    pos += 2*(facet_order[i][0]+1-fac*k);
+                    idofs.Append(pos);
+                    idofs.Append(pos+1);
+                  }
+                }
+            }//end if Dimension
+        }
+    }
+  };
+
+}
+
+
+
+#endif
+
+