ngsolve 6.2.2501.post16.dev1__cp313-cp313-macosx_10_15_universal2.whl → 6.2.2501.post34.dev1__cp313-cp313-macosx_10_15_universal2.whl

netgen/include/coefficient_impl.hpp

@@ -1,18 +0,0 @@
-#ifndef FILE_COEFFICIENT_IMPL
-#define FILE_COEFFICIENT_IMPL
-
-
-namespace ngfem
-{
-
-
-  struct GenericIdentity
-  {
-    template <typename T> T operator() (T x) const { return x; }
-    static string Name() { return  " "; }
-    void DoArchive(Archive& ar) {}
-  };
-
-}
-
-#endif

netgen/include/coefficient_stdmath.hpp

@@ -1,157 +0,0 @@
-#ifndef FILE_COEFFICIENT_STDMATH
-#define FILE_COEFFICIENT_STDMATH
-
-
-namespace ngfem
-{
-
-  struct GenericSqrt {
-    template <typename T> T operator() (T x) const { return sqrt(x); }
-    static string Name() { return "sqrt"; }
-    void DoArchive(Archive& ar) {}
-  };
-  
-  struct GenericSin {
-    template <typename T> T operator() (T x) const { return sin(x); }
-    static string Name() { return "sin"; }
-    void DoArchive(Archive& ar) {}
-  };
-
-  struct GenericCos {
-    template <typename T> T operator() (T x) const { return cos(x); }
-    static string Name() { return "cos"; }
-    void DoArchive(Archive& ar) {}
-  };
-
-  struct GenericTan {
-    template <typename T> T operator() (T x) const { return tan(x); }
-    static string Name() { return "tan"; }
-    void DoArchive(Archive& ar) {}
-  };
-
-  struct GenericATan {
-    template <typename T> T operator() (T x) const { return atan(x); }
-    static string Name() { return "atan"; }
-    void DoArchive(Archive& ar) {}
-  };
-  
-  struct GenericACos {
-    template <typename T> T operator() (T x) const { return acos(x); }
-    static string Name() { return "acos"; }
-    void DoArchive(Archive& ar) {}
-  };
-  
-  struct GenericASin {
-    template <typename T> T operator() (T x) const { return asin(x); }
-    static string Name() { return "asin"; }
-    void DoArchive(Archive& ar) {}
-  };
-
-
-  
-
-  struct GenericSinh {
-    template <typename T> T operator() (T x) const { return sinh(x); }
-    static string Name() { return "sinh"; }
-    void DoArchive(Archive& ar) {}
-  };
-  
-  struct GenericCosh {
-    template <typename T> T operator() (T x) const { return cosh(x); }
-    static string Name() { return "cosh"; }
-    void DoArchive(Archive& ar) {}
-  };
-
-  
-
-  struct GenericExp {
-    template <typename T> T operator() (T x) const { return exp(x); }
-    static string Name() { return "exp"; }
-    void DoArchive(Archive& ar) {}
-  };
-  
-  struct GenericLog {
-    template <typename T> T operator() (T x) const { return log(x); }
-    static string Name() { return "log"; }
-    void DoArchive(Archive& ar) {}
-  };
-
-
-  struct GenericErf {
-    template <typename T> T operator() (T x) const { return erf(x); }
-    Complex operator() (Complex x) const { throw Exception("no erf for Complex"); }
-    SIMD<Complex> operator() (SIMD<Complex> x) const { throw ExceptionNOSIMD("no erf for simd(complex)"); }  
-    static string Name() { return "erf"; }
-    void DoArchive(Archive& ar) {}
-  };
-
-
-
-struct GenericFloor {
-  template <typename T> T operator() (T x) const { return floor(x); }
-  Complex operator() (Complex x) const { throw Exception("no floor for Complex"); }  
-  // SIMD<double> operator() (SIMD<double> x) const { throw ExceptionNOSIMD("no floor for simd"); }
-  SIMD<Complex> operator() (SIMD<Complex> x) const { throw ExceptionNOSIMD("no floor for simd"); }  
-  // AutoDiff<1> operator() (AutoDiff<1> x) const { throw Exception("no floor for AD"); }
-  AutoDiffDiff<1> operator() (AutoDiffDiff<1> x) const { throw Exception("no floor for ADD"); }
-  static string Name() { return "floor"; }
-  void DoArchive(Archive& ar) {}
-};
-struct GenericCeil {
-  template <typename T> T operator() (T x) const { return ceil(x); }
-  Complex operator() (Complex x) const { throw Exception("no ceil for Complex"); }  
-  // SIMD<double> operator() (SIMD<double> x) const { throw ExceptionNOSIMD("no ceil for simd"); }
-  SIMD<Complex> operator() (SIMD<Complex> x) const { throw ExceptionNOSIMD("no ceil for simd"); }  
-  // AutoDiff<1> operator() (AutoDiff<1> x) const { throw Exception("no ceil for AD"); }
-  AutoDiffDiff<1> operator() (AutoDiffDiff<1> x) const { throw Exception("no ceil for ADD"); }
-  static string Name() { return "ceil"; }
-  void DoArchive(Archive& ar) {}
-};
-
-
-  
-  using std::sqrt;
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> sqrt(shared_ptr<CoefficientFunction> x);
-
-  using std::sin;
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> sin(shared_ptr<CoefficientFunction> x);
-
-  using std::cos;
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> cos(shared_ptr<CoefficientFunction> x);
-  
-  using std::tan;
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> tan(shared_ptr<CoefficientFunction> x);
-
-  using std::asin;  
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> asin(shared_ptr<CoefficientFunction> x);
-
-  using std::acos;  
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> acos(shared_ptr<CoefficientFunction> x);
-  
-  using std::atan;
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> atan(shared_ptr<CoefficientFunction> x);
-
-  using std::sinh;    
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> sinh(shared_ptr<CoefficientFunction> x);
-  
-  using std::cosh;
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> cosh(shared_ptr<CoefficientFunction> x);
-
-  using std::exp;
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> exp(shared_ptr<CoefficientFunction> x);
-  
-  using std::log;
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> log(shared_ptr<CoefficientFunction> x);
-
-  using std::erf;
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> erf(shared_ptr<CoefficientFunction> x);
-
-  using std::floor;
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> floor(shared_ptr<CoefficientFunction> x);
-
-  using std::ceil;        
-  NGS_DLL_HEADER shared_ptr<CoefficientFunction> ceil(shared_ptr<CoefficientFunction> x);
-}
-
-
-#endif

netgen/include/commutingAMG.hpp

@@ -1,106 +0,0 @@
-#ifndef FILE_COMMUTING_AMG
-#define FILE_COMMUTING_AMG
-
-/* *************************************************************************/
-/* File:   commuting_amg.hoo                                               */
-/* Author: Joachim Schoeberl                                               */
-/* Date:   15. Aug. 2002                                                   */
-/* *************************************************************************/
-
-namespace ngla
-{
-
-  class CommutingAMG : public BaseMatrix
-  {
-  protected:
-    const BaseSparseMatrix * pmat;
-    CommutingAMG * recAMG;
-
-    SparseMatrixTM<double> * prol;
-  
-    shared_ptr<BaseSparseMatrix> coarsemat;
-    shared_ptr<BaseJacobiPrecond> jacobi;
-    shared_ptr<BaseBlockJacobiPrecond> bjacobi;
-    shared_ptr<BaseMatrix> inv;
-
-  public:
-    CommutingAMG ()
-    { ; }
-    virtual ~CommutingAMG () 
-    { ; }
-
-    virtual bool IsComplex() const override { return false; }
-
-    virtual void ComputeMatrices (const BaseSparseMatrix & mat) = 0;
-    virtual void Mult (const BaseVector & x, BaseVector & y) const override = 0;
-
-
-    virtual int VHeight() const override { return pmat->Height(); }
-    virtual int VWidth() const override { return pmat->Width(); }
-
-    virtual size_t NZE() const override = 0;
-    virtual AutoVector CreateVector () const override
-    {
-      return pmat->CreateColVector();
-    }
-    virtual AutoVector CreateColVector () const override
-    {
-      return pmat->CreateRowVector();
-    }
-    virtual AutoVector CreateRowVector () const override 
-    {
-      return pmat->CreateColVector();
-    }
-  };
-
-
-  class AMG_H1 : public CommutingAMG
-  {
-  public:
-
-    AMG_H1 (const BaseMatrix & sysmat,
-	    Array<ngstd::IVec<2> > & e2v,
-	    Array<double> & weighte,
-	    int levels);
-
-    virtual ~AMG_H1 ();
-
-    virtual void ComputeMatrices (const BaseSparseMatrix & mat);
-    virtual size_t NZE() const;
-
-    virtual void Mult (const BaseVector & x, BaseVector & y) const;
-  };
-
-
-
-
-  class AMG_HCurl : public CommutingAMG
-  {
-    SparseMatrixTM<double> * grad;
-
-    shared_ptr<BaseSparseMatrix> h1mat;
-    AMG_H1 * h1AMG;
-
-  public:
-
-    AMG_HCurl (const BaseMatrix & sysmat,
-	       const Array<Vec<3> > & vertices,
-	       Array<ngstd::IVec<2> > & e2v,
-	       Array<ngstd::IVec<4> > & f2v,
-	       Array<double> & weighte,
-	       Array<double> & weightf,
-	       int levels);
-
-    virtual ~AMG_HCurl ();
-
-    virtual void ComputeMatrices (const BaseSparseMatrix & mat);
-    virtual size_t NZE() const;
-
-    virtual void Mult (const BaseVector & x, BaseVector & y) const;
-  };
-
-
-}
-
-
-#endif

netgen/include/comp.hpp

@@ -1,79 +0,0 @@
-#ifndef FILE_COMP
-#define FILE_COMP
-
-/*********************************************************************/
-/* File:   comp.hpp                                                  */
-/* Author: Joachim Schoeberl                                         */
-/* Date:   25. Mar. 2000                                             */
-/*********************************************************************/
-
-#include <fem.hpp>
-#include <finiteelement.hpp>
-#include <la.hpp>
-
-/**
-   namespace for NGS-components.
-   It contains the access to the mesh topology MeshAccess, 
-   finite element spaces derived from FESpace, and global objects such as
-   Gridfunction, LinearForm, and BilinearForm, or a Preconditioner.
-   Computational functions such as SetValues and CalcFlux.
- */
-namespace ngcomp
-{
-  using namespace std;
-  using namespace ngstd;
-
-  using ngfem::ELEMENT_TYPE;
-
-  using namespace ngla;
-  using namespace ngfem;
-}
-
-
-namespace ngmg
-{
-  class Prolongation;
-  class TwoLevelMatrix;
-  class MultigridPreconditioner;
-}
-
-
-#include <parallelngs.hpp>
-
-
-// #include "pmltrafo.hpp"
-#include "meshaccess.hpp"
-#include "ngsobject.hpp"
-#include "fespace.hpp"
-
-#include "gridfunction.hpp"
-#include "bilinearform.hpp"
-#include "linearform.hpp"
-#include "preconditioner.hpp"
-
-#include "postproc.hpp"
-#include "interpolate.hpp"
-
-#include "tpfes.hpp"
-#include "hcurlhdivfes.hpp"
-#include "hdivfes.hpp"
-#include "h1hofespace.hpp"
-#include "l2hofespace.hpp"
-#include "hdivhofespace.hpp"
-#include "hdivhosurfacefespace.hpp" 
-#include "hcurlhofespace.hpp" 
-// #include "facetfespace.hpp" 
-// #include "vectorfacetfespace.hpp"
-// #include "h1lumping.hpp"
-#include "periodic.hpp"
-#include "discontinuous.hpp"
-#include "hidden.hpp"
-#include "reorderedfespace.hpp"
-
-#include "facetsurffespace.hpp"
-#include "normalfacetsurfacefespace.hpp"
-#include "fesconvert.hpp"
-
-// #include "bddc.hpp"
-
-#endif

netgen/include/compatibility.hpp

@@ -1,41 +0,0 @@
-/*
-
-You may want to include this file to keep your application compatible with 
-different versions of ngsolve.
-
-*/
-
-
-
-
-#ifdef FILE_POSTPROC
-
-namespace ngcomp
-{
-
-  // // argument MeshAccess ma  was removed since it is available in GridFunction u
-  // // change: ngsolve-5.1 - r1177, 20130404
-  // NGS_DLL_HEADER 
-  // inline void SetValues (const MeshAccess & ma,
-  //                        const CoefficientFunction & coef,
-  //                        GridFunction & u,
-  //                        bool vb,
-  //                        DifferentialOperator * diffop,   // NULL is FESpace evaluator
-  //                        LocalHeap & clh)
-  // {
-  //   SetValues (coef, u, vb, diffop, clh);
-  // }
-}
-  
-
-#endif
-
-
-
-#define L2HighOrderFiniteElement DGFiniteElement
-
-
-
-
-
-

netgen/include/complex_wrapper.hpp

@@ -1,73 +0,0 @@
-#ifndef COMPLEX_WRAPPER
-#define COMPLEX_WRAPPER
-
-#include <complex>
-
-#ifdef USE_MYCOMPLEX
-#include <mycomplex.hpp>
-#endif
-
-
-
-
-// #ifdef __clang__
-#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
-namespace std
-{
-  // avoid expensive call to complex mult by using the grammar school implementation
-  INLINE std::complex<double> operator* (std::complex<double> a, std::complex<double> b)
-  {
-    return std::complex<double> (a.real()*b.real()-a.imag()*b.imag(),
-                                 a.real()*b.imag()+a.imag()*b.real());
-  }
-}
-#endif
-
-
-
-namespace ngcore
-{
-#ifdef USE_MYCOMPLEX
-  typedef ngstd::MyComplex<double> Complex;
-  using std::fabs;
-  inline double fabs (Complex v) { return ngstd::abs (v); }
-#else
-  typedef std::complex<double> Complex;
-  using std::fabs;
-  inline double fabs (Complex v) { return std::abs (v); }
-#endif
-}
-
-
-
-/// namespace for basic linear algebra
-namespace ngbla
-{
-  using ngcore::Complex;
-
-  using ngcore::AtomicAdd;
-  inline void AtomicAdd (Complex & x, Complex y)
-  {
-    auto real = y.real();
-    ngcore::AtomicAdd (reinterpret_cast<double(&)[2]>(x)[0], real);
-    auto imag = y.imag();
-    ngcore::AtomicAdd (reinterpret_cast<double(&)[2]>(x)[1], imag);
-  }
-
-  inline bool IsComplex(double v) { return false; }
-  inline bool IsComplex(Complex v) { return true; }
-}
-
-
-namespace ngstd
-{
-  using ngcore::Complex;
-  INLINE Complex IfPos (Complex a, Complex b, Complex c)
-  {
-    return a.real() > 0 ? b : c;
-  }
-}
-
-
-
-#endif

netgen/include/compressedfespace.hpp

@@ -1,110 +0,0 @@
-#pragma once
-/*********************************************************************/
-/* File:   wrapperfespace.hpp                                        */
-/* Author: Christoph Lehrenfeld                                      */
-/* Date:   12. July 2018                                             */
-/*********************************************************************/
-
-
-#include "fespace.hpp"
-
-namespace ngcomp
-{
-
-  class NGS_DLL_HEADER CompressedFESpace : public FESpace
-  {
-  protected:
-    shared_ptr<FESpace> space;
-    Array<DofId> comp2all;
-    Array<DofId> all2comp;
-    shared_ptr<BitArray> active_dofs = nullptr;
-
-    //TODO: flag to hide HIDDEN_DOFs
-
-  public:
-    CompressedFESpace (shared_ptr<FESpace> bfes);
-    virtual ~CompressedFESpace () {};
-    void Update() override;
-    shared_ptr<FESpace> GetBaseSpace() const { return space; }
-
-    void WrapDofs(Array<DofId> & dnums) const
-    {
-      /*
-      // (JS): this is buggy: dnums[i] may be -1
-      for (int i : Range(dnums.Size()))
-        if (all2comp[dnums[i]] != -1)
-          dnums[i] = all2comp[dnums[i]];
-        else 
-          dnums[i] = -1;
-      */
-      for (DofId & d : dnums)
-        if (IsRegularDof (d))
-          d = all2comp[d];
-    }
-
-    virtual FiniteElement & GetFE (ElementId ei, Allocator & lh) const override;
-    
-    FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
-
-    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
-    virtual void GetDofNrs (NodeId ni, Array<DofId> & dnums) const override;
-
-    virtual SymbolTable<shared_ptr<DifferentialOperator>> GetAdditionalEvaluators () const override
-    { return space->GetAdditionalEvaluators (); }
-
-    /// get dof-nrs of the element of certain coupling type
-    virtual void GetElementDofsOfType (ElementId ei, Array<DofId> & dnums, COUPLING_TYPE ctype) const override;
-
-    virtual void SetActiveDofs(shared_ptr<BitArray> actdof) 
-    {
-      active_dofs = actdof;
-    }
-
-    shared_ptr<BitArray> GetActiveDofs() const { return active_dofs; }
-
-    // a name for our new fe-space
-    virtual string GetClassName () const override
-    {
-      return "CompressedFESpace(" + space->GetClassName() + ")";
-    }
-
-    /// update element coloring
-    void FinalizeUpdate() override
-    {
-      space->FinalizeUpdate();
-      FESpace::FinalizeUpdate();
-    }
-
-    ProxyNode MakeProxyFunction (bool testfunction,
-                                 const function<shared_ptr<ProxyFunction>(shared_ptr<ProxyFunction>)> & addblock) const override;
-
-    virtual bool DefinedOn (ElementId id) const
-    {
-      return space->DefinedOn(id);
-    }
-
-    virtual void GetVertexDofNrs (int vnr, Array<DofId> & dnums) const override;
-    /// get dofs on edge enr
-    virtual void GetEdgeDofNrs (int ednr, Array<DofId> & dnums) const override;
-    /// get dofs on face fnr
-    virtual void GetFaceDofNrs (int fanr, Array<DofId> & dnums) const override;
-    /// get dofs on element (=cell) elnr
-    virtual void GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override;
-
-    virtual void VTransformMR (ElementId ei,
-			       SliceMatrix<double> mat, TRANSFORM_TYPE tt) const override
-    { space-> VTransformMR(ei, mat, tt); }
-    virtual void VTransformMC (ElementId ei,
-                               SliceMatrix<Complex> mat, TRANSFORM_TYPE tt) const override
-    { space->VTransformMC (ei, mat, tt); }
-    virtual void VTransformVR (ElementId ei,
-                               SliceVector<double> vec, TRANSFORM_TYPE tt) const override
-    { space->VTransformVR(ei, vec, tt); }
-    virtual void VTransformVC (ElementId ei, 
-                               SliceVector<Complex> vec, TRANSFORM_TYPE tt) const override
-    { space->VTransformVC(ei, vec, tt); }    
-
-
-  };
-
-}