ngsolve 6.2.2501.post21.dev1__cp313-cp313-macosx_10_15_universal2.whl → 6.2.2501.post37.dev1__cp313-cp313-macosx_10_15_universal2.whl

netgen/include/ngsstream.hpp

@@ -1,113 +0,0 @@
-#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

@@ -1,72 +0,0 @@
-#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

@@ -1,96 +0,0 @@
-#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

@@ -1,141 +0,0 @@
-
-
-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

@@ -1,223 +0,0 @@
-#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
-
-