ngsolve 6.2.2506.post216.dev0__cp314-cp314-manylinux_2_28_x86_64.whl

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/l2hofespace.hpp

@@ -0,0 +1,344 @@
+#ifndef FILE_L2HOFESPACE
+#define FILE_L2HOFESPACE
+
+/*********************************************************************/
+/* File:   l2hofespace.hpp                                           */
+/* Author: Start                                                     */
+/* Date:   23.Feb. 2003                                              */
+/*********************************************************************/
+
+#include "fespace.hpp"
+
+namespace ngcomp
+{
+  
+  /**
+     High Order Finite Element Space for L2 (element by element)
+  */
+
+  class NGS_DLL_HEADER L2HighOrderFESpace : public FESpace
+  {
+  protected:
+      
+    // if order is relative to mesh order 
+    bool var_order;
+    // variable order is set to mesh_order + rel_order 
+    int rel_order;
+    // order of elements 
+    Array<IVec<3> > order_inner;
+    // table of first element dofnumber 
+    Array<DofId> first_element_dof;
+    bool all_dofs_together;
+    // set all used dofs to hidden_dofs
+    bool hide_all_dofs;
+    COUPLING_TYPE lowest_order_ct;
+    bool tensorproduct;
+  public:
+
+    L2HighOrderFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool parseflags=false);
+    ///
+    virtual ~L2HighOrderFESpace ();
+
+    static DocInfo GetDocu ();
+    
+    // Create if order=0 ElementFESpace Constructor, else L2HOFE 
+    static shared_ptr<FESpace> Create (shared_ptr<MeshAccess> ma, const Flags & flags);
+    // Creates also for order=0 a L2HighOrderFESpace 
+    static shared_ptr<FESpace> CreateHO (shared_ptr<MeshAccess> ma, const Flags & flags) 
+    {
+      return make_shared<L2HighOrderFESpace> (ma, flags);
+    }  
+  
+    virtual string GetClassName () const override
+    {
+      return "L2HighOrderFESpace";
+    }
+
+    bool AllDofsTogether(){return all_dofs_together;};
+    ///
+    void Update() override;
+    /// 
+    virtual void UpdateDofTables() override;
+    ///
+    virtual void UpdateCouplingDofArray() override;    
+    ///
+    // virtual size_t GetNDof () const throw() override;
+    ///
+    // virtual size_t GetNDofLevel (int level) const override;
+    ///
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
+
+    using FESpace::GetFE;
+    // virtual const FiniteElement & GetFE (int elnr, LocalHeap & lh) const override;
+    // ///
+    // virtual const FiniteElement & GetSFE (int elnr, LocalHeap & lh) const override;
+    ///
+    virtual const FiniteElement & GetFacetFE (int fnr, LocalHeap & lh) const;
+
+    virtual void GetDofRanges (ElementId ei, Array<IntRange> & dranges) const;
+
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+
+    virtual void SetOrder (NodeId ni, int order) override;
+    virtual int GetOrder (NodeId ni) const override;
+    using FESpace::GetOrder;
+    
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+    ///
+    virtual shared_ptr<Table<int>> CreateSmoothingBlocks (const Flags & precflags) const override;
+    /// 
+ 
+    virtual void GetVertexDofNrs (int vnr, Array<DofId> & dnums) const override;
+    virtual void GetEdgeDofNrs (int ednr, Array<DofId> & dnums) const override;
+    virtual void GetFaceDofNrs (int fanr, Array<DofId> & dnums) const override;
+    virtual void GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override;
+
+
+    auto GetElementDofs (size_t nr) const
+    {
+      return Range (first_element_dof[nr], first_element_dof[nr+1]);
+    }
+
+    virtual shared_ptr<BaseMatrix> GetMassOperator (shared_ptr<CoefficientFunction> rho,
+                                                    shared_ptr<Region> defon,
+                                                    LocalHeap & lh) const override;
+
+    virtual shared_ptr<BaseMatrix> CreateMassOperator (shared_ptr<CoefficientFunction> rho,
+                                                       shared_ptr<Region> defon,
+                                                       bool inverse,
+                                                       LocalHeap & lh) const override;
+    
+    virtual void SolveM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+    virtual void ApplyM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+
+    virtual shared_ptr<BaseMatrix> GetTraceOperator (shared_ptr<FESpace> tracespace, bool avg) const override;
+    virtual void GetTrace (const FESpace & tracespace, const BaseVector & in, BaseVector & out, bool avg,
+                           LocalHeap & lh) const override;
+    virtual void GetTraceTrans (const FESpace & tracespace, const BaseVector & in, BaseVector & out, bool avg,
+                                LocalHeap & lh) const override;
+
+  protected:
+
+    template <ELEMENT_TYPE ET>
+      FiniteElement & T_GetFE (int elnr, Allocator & alloc) const;
+  };
+
+
+
+
+
+
+
+
+
+
+
+
+  class NGS_DLL_HEADER L2SurfaceHighOrderFESpace : public FESpace
+  {
+  protected:
+    // Level
+    // int level;
+
+    // Number of Elements
+    // int nel;
+
+    Array<int> first_element_dof;
+    // int ndof;
+
+
+    // if order is relative to mesh order 
+    bool var_order;
+    // variable order is set to mesh_order + rel_order 
+    int rel_order;
+    // order of elements 
+    Array<IVec<3> > order_inner;
+
+    bool lowest_order_wb;
+    bool discontinuous;
+    bool dual_mapping; // u(x) = 1/measure * u(hatx)
+  public:
+
+    L2SurfaceHighOrderFESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool parseflags=false);
+    ///
+    virtual ~L2SurfaceHighOrderFESpace ();
+
+    static DocInfo GetDocu ();
+
+    // static shared_ptr<FESpace> Create (shared_ptr<MeshAccess> ma, const Flags & flags);
+
+    virtual string GetClassName () const override
+    {
+      return "L2SurfaceHighOrderFESpace";
+    }
+
+    ///
+    void Update() override;
+    /// 
+    virtual void UpdateCouplingDofArray() override;    
+    //virtual void UpdateDofTables() override;
+    ///
+    // virtual size_t GetNDof () const throw() override;
+
+    virtual FiniteElement & GetFE (ElementId ei, Allocator & lh) const override;
+    ///
+    // virtual const FiniteElement & GetFE (int elnr, LocalHeap & lh) const override;
+    // ///
+    // virtual const FiniteElement & GetSFE (int elnr, LocalHeap & lh) const override;
+    ///
+    virtual void GetDofNrs (ElementId ei, Array<DofId> & dnums) const override;
+  
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+    virtual shared_ptr<BaseMatrix> GetMassOperator (shared_ptr<CoefficientFunction> rho,
+                                                    shared_ptr<Region> defon,
+                                                    LocalHeap & lh) const override;
+    
+    virtual void SolveM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+    virtual void ApplyM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+    virtual shared_ptr<Table<int>> CreateSmoothingBlocks (const Flags & precflags) const override;
+    /// 
+    virtual void GetInnerDofNrs (int elnr, Array<DofId> & dnums) const override;
+    virtual void GetVertexDofNrs (int vnr, Array<DofId> & dnums) const override;
+    virtual void GetEdgeDofNrs (int ednr, Array<DofId> & dnums) const override;
+    virtual void GetFaceDofNrs (int fanr, Array<DofId> & dnums) const override;
+
+    virtual bool VarOrder() const override { return var_order; } 
+    virtual int GetRelOrder() const override { return rel_order; }
+
+    virtual void SetOrder (NodeId ni, int order) override;
+    virtual int GetOrder (NodeId ni) const override;
+    using FESpace::GetOrder;
+    
+    auto GetElementDofs (size_t nr) const
+    {
+      return Range (first_element_dof[nr], first_element_dof[nr+1]);
+    }
+
+  };
+
+
+  class NGS_DLL_HEADER VectorL2FESpace : public CompoundFESpace
+  {
+    bool piola = false;
+    bool piola2 = false;  // piola mapping with vertex oriended coordinates (new for prolongation)
+    bool covariant = false;
+  public:
+    VectorL2FESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool checkflags = false);
+
+    FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
+
+    static DocInfo GetDocu ();
+    
+    void GetDofNrs (ElementId ei, Array<int> & dnums) const override;
+
+    virtual shared_ptr<BaseMatrix> GetMassOperator (shared_ptr<CoefficientFunction> rho,
+                                                    shared_ptr<Region> defon,
+                                                    LocalHeap & lh) const override;
+
+    virtual shared_ptr<BaseMatrix> CreateMassOperator (shared_ptr<CoefficientFunction> rho,
+                                                       shared_ptr<Region> defon,
+                                                       bool inverse,
+                                                       LocalHeap & lh) const override;
+
+    template <int DIM>
+    shared_ptr<BaseMatrix> CreateMassOperator_Dim (shared_ptr<CoefficientFunction> rho,
+                                                   shared_ptr<Region> defon,
+                                                   bool inverse,
+                                                   LocalHeap & lh) const;
+    
+    virtual void SolveM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+    virtual void ApplyM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+    template <int DIM>
+    void SolveM_Dim (CoefficientFunction * rho, BaseVector & vec, Region * region,
+                     LocalHeap & lh) const;
+
+    /*
+    template <int DIM>
+    void SolveMPiola (CoefficientFunction * rho, BaseVector & vec,
+                      LocalHeap & lh) const;
+    template <int DIM>
+    void SolveMCovariant (CoefficientFunction * rho, BaseVector & vec,
+                          LocalHeap & lh) const;
+    */
+    
+    template <int DIM>
+    void ApplyM_Dim (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                     LocalHeap & lh) const;
+
+    template <int DIM>
+    void ApplyMPiola (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                      LocalHeap & lh) const;
+    template <int DIM>
+    void ApplyMCovariant (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                          LocalHeap & lh) const;
+
+    virtual string GetClassName () const override
+    {
+      return "VectorL2FESpace";
+    }
+
+  };
+
+
+
+
+
+
+
+  class TangentialSurfaceL2FESpace : public CompoundFESpace
+  {
+    bool piola;
+  public:
+    TangentialSurfaceL2FESpace (shared_ptr<MeshAccess> ama, const Flags & flags, bool checkflags = false);
+
+    FiniteElement & GetFE (ElementId ei, Allocator & alloc) const override;
+
+    static DocInfo GetDocu ();
+    
+    void GetDofNrs (ElementId ei, Array<int> & dnums) const override;
+
+    virtual FlatArray<VorB> GetDualShapeNodes (VorB vb) const override;
+
+    virtual shared_ptr<BaseMatrix> GetMassOperator (shared_ptr<CoefficientFunction> rho,
+                                                    shared_ptr<Region> defon,
+                                                    LocalHeap & lh) const override;
+    
+    virtual void SolveM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+    virtual void ApplyM (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                         LocalHeap & lh) const override;
+
+
+    template <int DIM>
+    void SolveM_Dim (CoefficientFunction * rho, BaseVector & vec, Region * region,
+                     LocalHeap & lh) const;
+
+    template <int DIM>
+    void ApplyM_Dim (CoefficientFunction * rho, BaseVector & vec, Region * definedon,
+                     LocalHeap & lh) const;
+
+    virtual string GetClassName () const override
+    {
+      return "TangentialSurfaceL2FESpace";
+    }
+
+  };
+
+
+
+  
+}
+
+#endif
+

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/la.hpp

@@ -0,0 +1,38 @@
+#ifndef FILE_NGLA
+#define FILE_NGLA
+
+#include <bla.hpp>
+
+/** namespace for linear algebra.
+ */
+
+namespace ngla
+{
+  using namespace std;
+  using namespace ngstd;
+  using namespace ngbla;
+}
+
+
+#include "paralleldofs.hpp"
+#include "basevector.hpp"
+#include "vvector.hpp"
+#include "multivector.hpp"
+#include "basematrix.hpp"
+#include "sparsematrix.hpp"
+#include "sparsematrix_dyn.hpp"
+#include "order.hpp"
+#include "sparsecholesky.hpp"
+#include "pardisoinverse.hpp"
+#include "jacobi.hpp"
+#include "blockjacobi.hpp"
+#include "commutingAMG.hpp"
+#include "diagonalmatrix.hpp"
+#include "special_matrix.hpp"
+#include "elementbyelement.hpp"
+#include "cg.hpp"
+#include "chebyshev.hpp"
+#include "eigen.hpp"
+#include "arnoldi.hpp"
+
+#endif

ngsolve-6.2.2506.post216.dev0.data/data/include/netgen/linalg_kernels.hpp

@@ -0,0 +1,70 @@
+#ifndef LINALG_KERNELS_HPP
+#define LINALG_KERNELS_HPP
+
+
+namespace ngs_cuda
+{
+  using namespace ngbla;
+
+
+ 
+
+
+// own ngsolve cuda-kernels:
+extern void SetScalar (double val, int n, double * dev_ptr);
+extern void SetScalar (double val, ngbla::FlatVector<Dev<double>> vec);
+
+// y = val*x
+extern void SetVector (double val, int n, Dev<double> * x, Dev<double> * y);
+extern void MyDaxpy (double val, int n, Dev<double> * x, Dev<double> * y);
+
+/*
+extern void MultDiagonal (int n, double * D, double * x, double * y);
+extern void MultAddDiagonal (int n, double alpha, double * D, double * x, double * y);
+*/
+    
+// y = A * x
+class MatVecData
+{
+public:
+  SliceMatrix<Dev<double>> mat;
+  // BareVector<Dev<double>> x, y;
+  size_t offsetx, offsety;
+  MatVecData() : mat(0,0,0,nullptr) /* , x(nullptr), y(nullptr) */ { ; }
+};
+
+
+  /* **************** BlockJacobi kernels ********************* */
+
+  
+extern void ManyMatVec (FlatArray<Dev<MatVecData>> matvecs, 
+                        BareVector<Dev<double>> x, BareVector<Dev<double>> y); 
+
+
+
+    /*
+extern void ConstEBEKernelCopyIn (int numblocks, int bs, int * row_dnums, double * dev_ux, double * dev_hx);
+extern void ConstEBEKernelCopyOut (int numblocks, int bs, int * col_dnums, double * dev_hy, double * dev_uy);
+*/
+
+extern void ConstEBEKernelCopyInIdx (int numblocks, int * idx, int bs, int * row_dnums, double * dev_ux, double * dev_hx);
+extern void ConstEBEKernelCopyOutIdx (int numblocks, int * idx, int bs, int * col_dnums, double * dev_hy, double * dev_uy);
+    
+    /*
+  extern void DevBlockDiagonalMatrixSoAMultAddVecs (double s, int size, double * a, double * b, double * res);
+
+  // for (i,j,k) in indices:
+  //    res.Row(k) += s * a.Row(i) * b.Row(j)
+  extern void DevBlockDiagonalMatrixSoAMultAddVecs (double s, FlatArray<Dev<int>>, 
+                                                    SliceMatrix<Dev<double>> a, 
+                                                    SliceMatrix<Dev<double>> b,
+                                                    SliceMatrix<Dev<double>> res);
+
+
+extern void DevProjectorMultAdd (double s, size_t size, const double * a, double * b, const unsigned char * bits, bool keep_values);
+extern void DevProjectorProject (size_t size, double * a, const unsigned char * bits, bool keep_values);
+*/
+
+}
+
+#endif