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

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

@@ -0,0 +1,239 @@
+#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}; }
+    auto GetCArgs() {
+      return std::make_tuple(master, other, draw_pairs, volume, element_boundary);
+    }
+    void DoArchive(Archive& ar);
+  };
+
+  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.post216.dev0.data/data/include/netgen/cuda_core.hpp

@@ -0,0 +1,216 @@
+#ifndef CUDA_CORE_HPP
+#define CUDA_CORE_HPP
+
+#include <cuda_runtime.h>
+
+#include <core/array.hpp>
+#include <core/exception.hpp>
+
+namespace ngs_cuda
+{
+
+
+  // from CUDA C++ Programming Guide:
+  // https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#atomic-functions
+#ifdef __CUDA_ARCH__
+#if __CUDA_ARCH__ < 600
+  inline __device__ double atomicAdd(double* address, double val)
+  {
+    unsigned long long int* address_as_ull =
+      (unsigned long long int*)address;
+    unsigned long long int old = *address_as_ull, assumed;
+
+    do {
+      assumed = old;
+      old = atomicCAS(address_as_ull, assumed,
+                      __double_as_longlong(val +
+                                           __longlong_as_double(assumed)));
+
+      // Note: uses integer comparison to avoid hang in case of NaN (since NaN != NaN)
+    } while (assumed != old);
+
+    return __longlong_as_double(old);
+  }
+#endif
+#endif
+
+
+
+  extern cudaStream_t ngs_cuda_stream;
+  
+
+  // Kernel wrapper only available if we are compiling the current file with the cuda compiler
+#ifdef __CUDACC__
+   
+  template<class F> __global__
+  void CUDA_forall(int n, F f)
+  {
+    int tid = blockIdx.x*blockDim.x+threadIdx.x;
+    for (int i = tid; i < n; i += blockDim.x*gridDim.x)
+      f(i);
+  }
+
+  template<class F> __global__
+  void CUDA_forall2(int n, F f)
+  {
+    int tid = (blockIdx.x*blockDim.y+threadIdx.y)*blockDim.x+threadIdx.x;
+    for (int i = tid; i < n; i += blockDim.x*blockDim.y*gridDim.x)
+      f(i);
+  }
+    
+#define DEVICE_LAMBDA __device__
+
+  template <class F>
+  inline void DeviceParallelFor (int n, F f)
+  {
+    // CUDA_forall<<<512,256>>> (n, f);
+    CUDA_forall<<<n/256+1,256, 0, ngs_cuda_stream>>> (n, f);
+    // CUDA_forall<<<4096,32>>> (n, f);           // slower
+    // CUDA_forall2<<<512,dim3(16,16)>>> (n, f);  // same performance
+  }   
+
+#endif // __CUDACC__
+
+  
+
+  class CudaGraph
+  {
+    cudaGraph_t graph;
+    cudaGraphExec_t instance;    
+    cudaStream_t stream;
+    cudaStream_t prev_stream;
+    
+  public:
+    CudaGraph()
+    {
+      cudaStreamCreate(&stream);
+    }
+
+    ~CudaGraph()
+    {
+      // TODO: delete graph, instance, stream
+    }
+
+    
+    void BeginCapture()
+    {
+      cudaStreamBeginCapture(stream, cudaStreamCaptureModeGlobal);
+      prev_stream = ngs_cuda_stream;
+      ngs_cuda_stream = stream;
+    }
+
+    void EndCapture()
+    {
+      cudaStreamEndCapture(stream, &graph);
+      cudaGraphInstantiate(&instance, graph, NULL, NULL, 0);
+      ngs_cuda_stream = prev_stream;
+    }
+
+    void Launch()
+    {
+      cudaGraphLaunch(instance, ngs_cuda_stream);
+      // cudaStreamSynchronize(ngs_cuda_stream);
+    }
+  };
+  
+
+
+
+
+  template <typename T>
+  class Dev 
+  {
+    T data;
+    
+  public:
+    __host__ __device__ Dev() = delete;
+    
+    static Dev<T> * Malloc(size_t size)
+    {
+      Dev<T> * ptr;
+      if (auto err = cudaMalloc (&ptr, size*sizeof(T)))
+        throw ngstd::Exception("cudaMalloc error, ec="+ngcore::ToString(err));
+      return ptr;        
+    }
+    
+    static void Free(Dev<T> * data)
+    {
+      cudaFree (data);   
+    }
+
+
+    
+    
+    T D2H() const
+    {
+      T res;
+      cudaMemcpy (&res, &data, sizeof(T), cudaMemcpyDeviceToHost);
+      return res;
+    }
+
+    void H2D (T val)
+
+    {
+      cudaMemcpy (this, &val, sizeof(T), cudaMemcpyHostToDevice);
+    }
+
+    void D2H (ngcore::FlatArray<T> hosta)
+    {
+      cudaMemcpy (hosta.Data(), &data, hosta.Size()*sizeof(T), cudaMemcpyDeviceToHost);
+    }
+
+    void H2D (ngcore::FlatArray<T> hosta)
+    {
+      cudaMemcpy (&data, hosta.Data(), hosta.Size()*sizeof(T), cudaMemcpyHostToDevice);
+    }
+    
+    __host__ __device__ Dev<T> & operator= (T d2)
+    {
+#ifdef __CUDA_ARCH__      
+      data = d2;
+#else
+      H2D(d2);
+#endif
+      return *this;
+    }
+
+    __host__ __device__ operator T() const
+    {
+#ifdef __CUDA_ARCH__
+      return data;
+#else
+      return D2H();
+#endif
+    }
+    
+    __device__ const T& operator*() const { return data; }
+    
+    template <typename T2>
+    __device__ auto & operator+= (T2 other) { data += other; return *this; }
+    template <typename T2>
+    __device__ auto & operator-= (T2 other) { data -= other; return *this; }
+    template <typename T2>
+    __device__ auto & operator*= (T2 other) { data *= other; return *this; }
+  };
+
+
+  template <typename T>
+  Dev<T> * Host2Device (const T& val)
+  {
+    auto ptr = Dev<T>::Malloc(1);
+    ptr->H2D(val);
+    return ptr;
+  }
+
+  template <typename T>
+  void Free(Dev<T> * dp)
+  {
+    Dev<T>::Free (dp);
+  }  
+
+  
+
+}
+
+#endif
+

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

@@ -0,0 +1,185 @@
+#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;
+    bool output_onto = false;
+    bool output_matrix = false;
+    bool output_matrix_trans = false;
+
+  public:
+    DevConstantElementByElementMatrix (const T_ConstEBEMatrix & mat);
+    void Mult (const BaseVector & x, BaseVector & y) const override;    
+    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;
+    DevTable<int> sparse, sparseT;
+ public:
+    DevBlockDiagonalMatrixSoA (const BlockDiagonalMatrixSoA & mat);
+    void Mult (const BaseVector & x, BaseVector & y) const override;
+    void MultAdd (double s, const BaseVector & x, BaseVector & y) const override;
+    void MultTrans (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()) { ; }
+
+    virtual xbool IsSymmetric() const { return true; }
+    
+    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