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

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/contact.hpp

@@ -0,0 +1,235 @@
+#ifndef NGSOLVE_CONTACT_HPP
+#define NGSOLVE_CONTACT_HPP
+
+// #include <comp.hpp>
+#include "gridfunction.hpp"
+#include "bilinearform.hpp"
+
+namespace ngcomp
+{
+  template<int DIM>
+  struct ContactPair
+  {
+    ElementId primary_el, secondary_el;
+    IntegrationPoint primary_ip, secondary_ip;
+  };
+
+  class GapFunction : public CoefficientFunctionNoDerivative
+  {
+  protected:
+    shared_ptr<GridFunction> displacement;
+    shared_ptr<MeshAccess> ma;
+    Region master;
+    Region other;
+    double h;
+    bool both_sides;
+
+  public:
+    GapFunction( shared_ptr<MeshAccess> ma_, Region primary_, Region secondary_)
+      : CoefficientFunctionNoDerivative(ma_->GetDimension()),
+        ma(ma_), master(primary_), other(secondary_)
+    { }
+
+    virtual void Update(shared_ptr<GridFunction> gf, int intorder_, double h_,
+                        bool both_sides) = 0;
+    void Draw();
+  };
+
+  template <int DIM>
+  class T_GapFunction : public GapFunction
+  {
+    unique_ptr<netgen::BoxTree<DIM, int>> searchtree;
+  public:
+    T_GapFunction( shared_ptr<MeshAccess> mesh_, Region primary_, Region secondary_)
+      : GapFunction(mesh_, primary_, secondary_)
+    { }
+
+    void Update(shared_ptr<GridFunction> gf, int intorder_, double h, bool both_sides) override;
+
+    const netgen::BoxTree<DIM, int>& GetSearchTree() { return *searchtree; }
+
+    using GapFunction::Evaluate;
+    double Evaluate (const BaseMappedIntegrationPoint & ip) const override
+    {
+      throw Exception("Scalar evaluate of GapFunction called");
+    }
+
+    void Evaluate(const BaseMappedIntegrationPoint & ip,
+                  FlatVector<> result) const override;
+
+    void Evaluate(const BaseMappedIntegrationRule & mir,
+                  BareSliceMatrix<> result) const override;
+
+    optional<ContactPair<DIM>> CreateContactPair(const MappedIntegrationPoint<DIM-1, DIM>& mip, LocalHeap& lh, bool both_sides) const;
+  };
+
+  template<int DIM>
+  class DisplacedNormal : public CoefficientFunctionNoDerivative
+  {
+    shared_ptr<GridFunction> displacement;
+  public:
+    DisplacedNormal()
+      : CoefficientFunctionNoDerivative(DIM, false),
+        displacement(nullptr) {}
+
+    void Update(shared_ptr<GridFunction> _displacement)
+    { displacement = _displacement; }
+
+    using CoefficientFunctionNoDerivative::Evaluate;
+    double Evaluate(const BaseMappedIntegrationPoint& ip) const override
+    {
+      throw Exception("1dim eval called for Normal");
+    }
+
+    void Evaluate(const BaseMappedIntegrationPoint& ir, FlatVector<> values) const override;
+  };
+
+  class ContactEnergy
+  {
+    shared_ptr<CoefficientFunction> cf;
+    shared_ptr<FESpace> fes;
+    Array<ProxyFunction*> trial_proxies;
+    Array<CoefficientFunction*> cf_gridfunctions;
+    bool deformed;
+
+  public:
+    ContactEnergy(shared_ptr<CoefficientFunction> _cf,
+                  bool _deformed=false);
+
+    bool IsDeformed() const { return deformed; }
+
+    double CalcEnergy(const FiniteElement& m_fel,
+                      const FiniteElement& s_fel,
+                      const BaseMappedIntegrationRule& m_mir,
+                      FlatVector<double> elx,
+                      LocalHeap& lh);
+
+    void ApplyAdd(const FiniteElement& m_fel,
+                  const FiniteElement& s_fel,
+                  const BaseMappedIntegrationRule& m_mir,
+                  FlatVector<double> elx,
+                  FlatVector<double> ely,
+                  LocalHeap& lh);
+
+    void CalcLinearizedAdd(const FiniteElement& m_fel,
+                           const FiniteElement& s_fel,
+                           const BaseMappedIntegrationRule& m_mir,
+                           FlatVector<double> elx,
+                           FlatMatrix<double> elmat,
+                           LocalHeap& lh);
+  };
+
+  class ContactIntegrator
+  {
+    shared_ptr<CoefficientFunction> cf;
+    shared_ptr<FESpace> fes;
+    Array<ProxyFunction*> trial_proxies, test_proxies;
+    Array<CoefficientFunction*> cf_gridfunctions;
+    Array<shared_ptr<CoefficientFunction>> dcf_dtest;  // derivatives by test-functions
+    Matrix<shared_ptr<CoefficientFunction>> ddcf_dtest_dtrial;  // derivatives by test- and trial-functions
+    bool deformed;
+  public:
+    ContactIntegrator(shared_ptr<CoefficientFunction> _cf,
+                      bool _deformed);
+
+    bool IsDeformed() const { return deformed; }
+
+    void ApplyAdd(const FiniteElement& m_fel,
+                  const FiniteElement& s_fel,
+                  const BaseMappedIntegrationRule& m_mir,
+                  FlatVector<double> elx,
+                  FlatVector<double> ely,
+                  LocalHeap& lh);
+
+    void CalcLinearizedAdd(const FiniteElement& m_fel,
+                           const FiniteElement& s_fel,
+                           const BaseMappedIntegrationRule& m_mir,
+                           FlatVector<double> elx,
+                           FlatMatrix<double> elmat,
+                           LocalHeap& lh);
+  };
+
+
+  class ContactBoundary : public std::enable_shared_from_this<ContactBoundary>,
+                          netgen::UserVisualizationObject
+  {
+    shared_ptr<GapFunction> gap;
+    shared_ptr<CoefficientFunction> normal;
+    Region master, other;
+    Array<shared_ptr<ContactEnergy>> energies, undeformed_energies, deformed_energies;
+    Array<shared_ptr<ContactIntegrator>> integrators, undeformed_integrators, deformed_integrators;
+    shared_ptr<FESpace> fes_displacement;
+    shared_ptr<FESpace> fes;
+
+    // For visualization only
+    bool draw_pairs = false;
+    Array<Vec<3>> primary_points;
+    Array<Vec<3>> secondary_points;
+    bool volume, element_boundary;
+  public:
+    void Draw();
+    ContactBoundary(Region _master, Region _other, bool draw_pairs = false, bool _volume=false, bool element_boundary=false);
+
+    ~ContactBoundary();
+
+    void AddEnergy(shared_ptr<CoefficientFunction> form,
+                   bool deformed=false);
+    void AddIntegrator(shared_ptr<CoefficientFunction> form,
+                       bool deformed=false);
+
+    // Update search tree for gap function, if bf is not
+    // nullptr, update SpecialElements of bf
+    void Update(shared_ptr<GridFunction> gf,
+                shared_ptr<BilinearForm> bf,
+                int intorder, double h, bool both_sides);
+
+    shared_ptr<CoefficientFunction> Gap() const { return gap; }
+    shared_ptr<CoefficientFunction> Normal() const { return normal; }
+    const auto& GetEnergies() const { return energies; }
+    const auto& GetEnergies(bool def) const { return def ? deformed_energies : undeformed_energies; }    
+    const auto& GetIntegrators() const { return integrators; }
+    const auto& GetIntegrators(bool def) const { return def ? deformed_integrators : undeformed_integrators; }    
+    shared_ptr<FESpace> GetFESpace() const { return fes; }
+    tuple<FlatArray<Vec<3>>, FlatArray<Vec<3>>> GetDrawingPairs() { return {primary_points, secondary_points}; }
+  };
+
+  template<int DIM>
+  class MPContactElement : public SpecialElement
+  {
+    // ContactPair<DIM> pair;
+    ElementId primary_ei, secondary_ei;
+    IntegrationRule primary_ir, secondary_ir;
+    shared_ptr<ContactBoundary> cb;
+    FESpace* fes;
+    GridFunction* deformation;
+  public:
+    MPContactElement(ElementId primary_ei, ElementId secondary_ei,
+                     IntegrationRule primary_ir, IntegrationRule secondary_ir,
+                     shared_ptr<ContactBoundary> _cb,
+                     GridFunction* deformation);
+
+    void GetDofNrs(Array<DofId>& dnums) const override;
+
+    double Energy(FlatVector<double> elx,
+                  LocalHeap& lh) const override;
+
+    void Apply(FlatVector<double> elx,
+               FlatVector<double> ely,
+               LocalHeap& lh) const override;
+
+    void CalcElementMatrix(FlatMatrix<double> elmat,
+                           LocalHeap& lh) const override;
+
+    
+    void CalcLinearizedElementMatrix(FlatVector<double> elx,
+                                     FlatMatrix<double> elmat,
+                                     LocalHeap& lh) const override;
+
+    shared_ptr<ContactBoundary> GetContactBoundary() const
+    { return cb; }
+  };
+
+  
+} // namespace ngcomp
+
+#endif // NGSOLVE_CONTACT_HPP

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/cuda_linalg.hpp

@@ -0,0 +1,175 @@
+#ifndef CUDA_LINALG_HPP
+#define CUDA_LINALG_HPP
+
+// partial override of overloaded function (MultAdd)
+#pragma nv_diag_suppress 611
+#pragma nv_diag_suppress 20013
+
+#include <la.hpp>
+
+#include <cuda_runtime.h>
+#include <cublas_v2.h>
+#include <cusparse.h>
+
+#include "cuda_ngstd.hpp"
+
+namespace ngla
+{
+  cublasHandle_t Get_CuBlas_Handle ();
+}
+
+  
+#include "cuda_ngbla.hpp"
+#include "linalg_kernels.hpp"
+#include "unifiedvector.hpp"
+
+
+namespace ngla
+{
+  using namespace ngs_cuda;
+  
+  void InitCuLinalg();
+
+
+  /* AutoVector CreateUnifiedVector(size_t size); */
+
+  class DevMatrix : public BaseMatrix
+  {
+  public:
+    DevMatrix() { }
+
+    AutoVector CreateRowVector() const override { return make_unique<UnifiedVector>(Width()); }
+    AutoVector CreateColVector() const override { return make_unique<UnifiedVector>(Height()); }
+  };
+
+  shared_ptr<BaseMatrix> CreateDevMatrix (BaseMatrix &mat);
+  shared_ptr<BaseMatrix> CreateDevMatrix (Matrix<> &mat);
+
+
+  class DevSparseMatrix : public DevMatrix
+  {
+  protected:
+    //cusparseMatDescr_t * descr;
+    cusparseSpMatDescr_t descr;
+    int * dev_ind;
+    int * dev_col;
+    double * dev_val;
+    int height, width, nze;
+  public:
+    DevSparseMatrix () { }
+    DevSparseMatrix (const SparseMatrix<double> & mat);
+    virtual ~DevSparseMatrix ();
+
+    virtual void MultAdd (double s, const BaseVector & x, BaseVector & y) const;
+    virtual void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const;
+
+    virtual int VHeight() const { return height; }
+    virtual int VWidth() const { return width; }
+  };
+
+
+  class DevDiagonalMatrix : public DevMatrix
+  {
+  protected:
+    const UnifiedVector diag;
+
+  public:
+    DevDiagonalMatrix (const UnifiedVector _diag) : diag(_diag) { }
+
+    virtual xbool IsSymmetric() const { return true; }
+
+    virtual void Mult (const BaseVector & x, BaseVector & y) const;
+    virtual void MultAdd (double s, const BaseVector & x, BaseVector & y) const;
+
+    virtual int VHeight() const { return diag.Size(); }
+    virtual int VWidth() const { return diag.Size(); }
+  };
+
+
+  // compatibility between elder ngsolve (template or not)
+  typedef decltype (ConstantElementByElementMatrix (5,5,Matrix<>(),
+                                                  declval<Table<int>>(), declval<Table<int>>())) T_ConstEBEMatrix;
+  
+  class DevConstantElementByElementMatrix : public DevMatrix
+  {
+    size_t h, w; // big matrix shape
+
+    Matrix<Dev<double>> devmat;
+    
+    DevTable<int> rowdnums, coldnums;
+    DevDataTable<int> row_coloring, col_coloring;
+
+    bool disjoint_rows, disjoint_cols;
+    size_t numblocks;
+  public:
+    DevConstantElementByElementMatrix (const T_ConstEBEMatrix & mat);
+    void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
+    void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
+
+    int VHeight() const override { return h; }
+    int VWidth() const override { return w; }
+  };
+  
+
+
+  class DevBlockDiagonalMatrixSoA : public DevMatrix
+  {
+    double * dev_data; // Tensor<3> blockdiag;  
+    int blocks, dimy, dimx;
+    Matrix<bool> nonzero;
+    Array<Dev<int>> indices, indices_trans;
+ public:
+    DevBlockDiagonalMatrixSoA (const BlockDiagonalMatrixSoA & mat);
+    void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
+    void MultTransAdd (double s, const BaseVector & x, BaseVector & y) const override;
+    int VHeight() const override { return dimy*blocks; }
+    int VWidth() const override { return dimx*blocks; }
+  };
+  
+  
+
+  class DevEmbeddedMatrix : public EmbeddedMatrix
+  {
+  public:
+    using EmbeddedMatrix::EmbeddedMatrix;
+    AutoVector CreateColVector() const override { return make_unique<UnifiedVector>(Height()); }      
+  };
+  
+  class DevEmbeddedTransposeMatrix : public EmbeddedTransposeMatrix
+  {
+  public:
+    using EmbeddedTransposeMatrix::EmbeddedTransposeMatrix;
+    AutoVector CreateRowVector() const override { return make_unique<UnifiedVector>(Width()); }      
+  };
+
+
+  class DevProjector : public DevMatrix
+  {
+  private:
+    shared_ptr<DevBitArray> bits;
+    bool keep_values;
+  public:
+    DevProjector (const Projector & proj)
+      : bits(make_shared<DevBitArray>(*proj.Mask())), 
+        keep_values(proj.KeepValues()) { ; }
+
+    void Mult (const BaseVector & x, BaseVector & y) const override;
+    void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
+
+    void Project (BaseVector & x) const;
+
+    virtual int VHeight() const override { return bits->Size(); }
+    virtual int VWidth() const override { return bits->Size(); }
+
+    AutoVector CreateRowVector() const override
+    { throw Exception("CreateRowVector not implemented for DevProjector!"); }
+    AutoVector CreateColVector() const override
+    { throw Exception("CreateColVector not implemented for DevProjector!"); }
+
+  };
+  
+
+}
+
+
+#endif

ngsolve-6.2.2506.post75.dev0.data/data/include/netgen/cuda_ngbla.hpp

@@ -0,0 +1,226 @@
+#ifndef CUDA_NGBLA
+#define CUDA_NGBLA
+
+#include "cuda_ngstd.hpp"
+#include "linalg_kernels.hpp"
+
+namespace ngbla
+{
+  using namespace ngs_cuda;
+    
+  // template<> struct trivtrans<Dev<double>> { static constexpr bool value = true; };
+  template<> struct is_scalar_type<Dev<double>> { static constexpr bool value = true; };
+  
+
+  template <typename T>  
+  class Vector<Dev<T>> : public FlatVector<Dev<T>>
+  { 
+    using FlatVector<Dev<T>>::size;
+    using FlatVector<Dev<T>>::data;
+
+  public:
+    Vector (Vector&) = delete;
+    Vector (Vector&&v2)
+      : FlatVector<Dev<T>>(v2.Size(), v2.Data())
+    {
+      v2.data = nullptr;
+    }
+         
+    Vector (size_t asize)
+      : FlatVector<Dev<T>>(asize, Dev<T>::Malloc(asize)) { ; }
+         
+    Vector (FlatVector<T> vec)
+      : FlatVector<Dev<T>>(vec.Size(), Dev<T>::Malloc(vec.Size()))
+    {
+      H2D(vec);
+    }
+    
+    ~Vector()
+    {
+      Dev<T>::Free(data);
+    }
+         
+    void D2H (FlatVector<T> vec) const
+    {
+      cudaMemcpy (vec.Data(), data, sizeof(T)*size, cudaMemcpyDeviceToHost);
+    }
+
+    void H2D (FlatVector<T> vec)
+    {
+      cudaMemcpy (data, vec.Data(), sizeof(T)*size, cudaMemcpyHostToDevice);
+    }
+
+    Vector<T> D2H() const
+    {
+      Vector<T> vh(size);
+      D2H (vh);
+      return vh;
+    }
+  };
+  
+  inline Vector<double> D2H (FlatVector<Dev<double>> dvec)
+  {
+    Vector<double> hvec(dvec.Size());
+    cudaMemcpy (hvec.Data(), dvec.Data(), sizeof(double)*hvec.Size(), cudaMemcpyDeviceToHost);
+    return hvec;
+  }
+  
+
+  
+    
+  template <typename T>  
+  class Matrix<Dev<T>> : public FlatMatrix<Dev<T>>
+  { 
+    using FlatMatrix<Dev<T>>::h;
+    using FlatMatrix<Dev<T>>::w;
+    using FlatMatrix<Dev<T>>::data;
+
+  public:
+    Matrix (Matrix&) = delete;
+    Matrix (Matrix&&m2)
+      : FlatMatrix<Dev<T>>(m2.Height(), m2.Width(), m2.Data())
+    {
+      m2.data = nullptr;
+    }
+         
+    Matrix (size_t h_, size_t w_)
+      : FlatMatrix<Dev<T>>(h_, w_, Dev<T>::Malloc(h_*w_)) { ; }
+         
+    Matrix (FlatMatrix<T> mat)
+      : FlatMatrix<Dev<T>>(mat.Height(), mat.Width(),
+                           Dev<T>::Malloc(mat.Height()*mat.Width()))
+    {
+      H2D(mat);
+    }
+    
+    ~Matrix()
+    {
+      Dev<T>::Free(data);
+    }
+         
+    void D2H (FlatMatrix<T> mat) const
+    {
+      cudaMemcpy (mat.Data(), data, sizeof(T)*h*w, cudaMemcpyDeviceToHost);
+    }
+
+    void H2D (FlatMatrix<T> mat)
+    {
+      cudaMemcpy (data, mat.Data(), sizeof(T)*h*w, cudaMemcpyHostToDevice);
+    }
+
+    Matrix<T> D2H() const
+    {
+      Matrix<T> mh(h, w);
+      D2H (mh);
+      return mh;
+    }
+  };
+  
+  inline Matrix<double> D2H (SliceMatrix<Dev<double>> dmat)
+  {
+    Matrix<double> hmat(dmat.Height(), dmat.Width());
+    for (size_t i = 0; i < hmat.Height(); i++)
+      cudaMemcpy (&hmat(i,0), &dmat(i,0), sizeof(double)*hmat.Width(), cudaMemcpyDeviceToHost);
+    return hmat;
+  }
+  
+  inline Matrix<double,ColMajor> D2H (SliceMatrix<Dev<double>,ColMajor> dmat)
+  {
+    return Trans(D2H(Trans(dmat)));
+  }
+   
+  
+  
+    
+  template <ORDERING ORDA, ORDERING ORDB>  
+  void CudaMultMatMat2 (SliceMatrix<Dev<double>, ORDA> a, SliceMatrix<Dev<double>,ORDB> b, 
+                        SliceMatrix<Dev<double>, ORDERING::ColMajor> c,
+                       double alpha, double beta)
+  {
+    cublasStatus_t stat =
+      cublasDgemm(ngla::Get_CuBlas_Handle(), 
+                  ORDA==ORDERING::RowMajor ? CUBLAS_OP_T : CUBLAS_OP_N, 
+                  ORDB==ORDERING::RowMajor ? CUBLAS_OP_T : CUBLAS_OP_N, 
+                  c.Height(), c.Width(), a.Width(),
+                  &alpha, (double*)a.Data(), a.Dist(), (double*)b.Data(), b.Dist(),
+                  &beta, (double*)c.Data(), c.Dist());
+  }
+  
+  template <ORDERING ORDA, ORDERING ORDB>  
+  void CudaMultMatMat2 (SliceMatrix<Dev<double>, ORDA> a, SliceMatrix<Dev<double>,ORDB> b, 
+                        SliceMatrix<Dev<double>, ORDERING::RowMajor> c,
+                       double alpha, double beta)
+  {
+    CudaMultMatMat2 (Trans(b), Trans(a), Trans(c), alpha, beta);
+  }
+   
+    
+  template <typename TA, typename TB, typename TC,
+            enable_if_t<IsConvertibleToSliceMatrix<TA,Dev<double>>(),int> = 0,
+            enable_if_t<IsConvertibleToSliceMatrix<TB,Dev<double>>(),int> = 0,
+            enable_if_t<IsConvertibleToSliceMatrix<TC,Dev<double>>(),int> = 0>
+  void MultMatMat (const TA & a, const TB & b, const TC & c, double alpha=1, double beta=0)
+  {
+    CudaMultMatMat2(make_SliceMatrix(a), make_SliceMatrix(b), make_SliceMatrix(c), alpha, beta);
+  }
+ 
+
+  template <typename TOP, typename T, typename TB1, typename TB2>
+  class assign_trait<TOP, T, MultExpr<TB1,TB2>,
+                     enable_if_t<IsConvertibleToSliceMatrix<T,Dev<double>>(),int>>
+  {
+  public:
+    static INLINE T & Assign (MatExpr<T> & self, const Expr<MultExpr<TB1,TB2>> & v)
+    {
+      auto res = self.View();
+
+      double alpha = std::is_same_v<TOP,typename MatExpr<T>::AsSub> ? -1 : 1;
+      double beta = std::is_same_v<TOP,typename MatExpr<T>::As> ? 0 : 1;
+
+      MultMatMat (v.Spec().A(), v.Spec().B(), self.Spec(), alpha, beta);
+      return self.Spec();
+    }
+  };    
+    
+  template <typename TOP, typename T, typename TB1, typename TB2>
+  class assign_trait<TOP, T, ScaleExpr<MultExpr<TB1,TB2>,double>,
+                     enable_if_t<IsConvertibleToSliceMatrix<T,Dev<double>>(),int>>
+  {
+  public:
+    static inline T & Assign (MatExpr<T> & self, const Expr<ScaleExpr<MultExpr<TB1,TB2>,double>> & v)
+    {
+      auto res = self.View();
+
+      double alpha = is_same_v<TOP,typename MatExpr<T>::AsSub> ? -1 : 1;
+      double beta = is_same_v<TOP,typename MatExpr<T>::As> ? 0 : 1;
+      
+      alpha *= v.View().S();
+
+      MultMatMat (v.View().A().A(), v.View().A().B(), self.ViewRW(), alpha, beta);
+      return self.Spec();
+    }
+  };    
+    
+  template <typename TOP, typename T, typename TB1, typename TB2>
+  class assign_trait<TOP, T, MultExpr<ScaleExpr<TB1,double>,TB2>,
+                     enable_if_t<IsConvertibleToSliceMatrix<T,Dev<double>>(),int>>
+  {
+  public:
+    static inline T & Assign (MatExpr<T> & self, const Expr<MultExpr<ScaleExpr<TB1,double>,TB2>> & v)
+    {
+      auto res = self.View();
+
+      double alpha = is_same_v<TOP,typename MatExpr<T>::AsSub> ? -1 : 1;
+      double beta = is_same_v<TOP,typename MatExpr<T>::As> ? 0 : 1;
+      
+      alpha *= v.View().A().S();
+
+      MultMatMat (v.View().A().A(), v.View().B(), self.ViewRW(), alpha, beta);
+      return self.Spec();
+    }
+  };    
+    
+      
+}
+
+#endif