5

Author: Roushelfy

simulators/4_friction/CMakeLists.txt

@@ -1,18 +1,18 @@
-add_executable(4_friction)
+add_executable(4_friction_debug)
 
-target_compile_options(4_friction PRIVATE -g)
-set_target_properties(4_friction PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+target_compile_options(4_friction_debug PRIVATE -g)
+set_target_properties(4_friction_debug PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
 
-target_link_libraries(4_friction PRIVATE muda cusolver cublas cusparse )
+target_link_libraries(4_friction_debug PRIVATE muda cusolver cublas cusparse )
 
 option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
 
 include_directories(include)
 
-file(GLOB_RECURSE 4_friction_CU_SOURCE CONFIGURE_DEPENDS "src/*.cu")
-target_sources(4_friction PRIVATE ${4_friction_CU_SOURCE})
+file(GLOB_RECURSE 4_friction_debug_CU_SOURCE CONFIGURE_DEPENDS "src/*.cu")
+target_sources(4_friction_debug PRIVATE ${4_friction_debug_CU_SOURCE})
 
-file(GLOB_RECURSE 4_friction_CPP_SOURCE CONFIGURE_DEPENDS "src/*.cpp")
-target_sources(4_friction PRIVATE ${4_friction_CPP_SOURCE})
+file(GLOB_RECURSE 4_friction_debug_CPP_SOURCE CONFIGURE_DEPENDS "src/*.cpp")
+target_sources(4_friction_debug PRIVATE ${4_friction_debug_CPP_SOURCE})
 
-target_link_libraries(4_friction PRIVATE sfml-graphics)
+target_link_libraries(4_friction_debug PRIVATE sfml-graphics)

simulators/5_mov_dirichlet/CMakeLists.txt

@@ -0,0 +1,18 @@
+add_executable(5_mov_dirichlet)
+
+target_compile_options(5_mov_dirichlet PRIVATE -g)
+set_target_properties(5_mov_dirichlet PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+
+target_link_libraries(5_mov_dirichlet PRIVATE muda cusolver cublas cusparse )
+
+option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
+
+include_directories(include)
+
+file(GLOB_RECURSE 5_mov_dirichlet_CU_SOURCE CONFIGURE_DEPENDS "src/*.cu")
+target_sources(5_mov_dirichlet PRIVATE ${5_mov_dirichlet_CU_SOURCE})
+
+file(GLOB_RECURSE 5_mov_dirichlet_CPP_SOURCE CONFIGURE_DEPENDS "src/*.cpp")
+target_sources(5_mov_dirichlet PRIVATE ${5_mov_dirichlet_CPP_SOURCE})
+
+target_link_libraries(5_mov_dirichlet PRIVATE sfml-graphics)

simulators/5_mov_dirichlet/include/BarrierEnergy.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+#include <Eigen/Dense>
+#include "uti.h"
+
+template <typename T, int dim>
+class BarrierEnergy
+{
+public:
+    BarrierEnergy(const std::vector<T> &x, const std::vector<T> n, const std::vector<T> o, const std::vector<T> &contact_area);
+    BarrierEnergy();
+    ~BarrierEnergy();
+    BarrierEnergy(BarrierEnergy &&rhs);
+    BarrierEnergy(const BarrierEnergy &rhs);
+    BarrierEnergy &operator=(BarrierEnergy &&rhs);
+
+    void update_x(const DeviceBuffer<T> &x);
+    T val();                                 // Calculate the value of the energy
+    const DeviceBuffer<T> &grad();           // Calculate the gradient of the energy
+    const DeviceTripletMatrix<T, 1> &hess(); // Calculate the Hessian matrix of the energy
+    const DeviceBuffer<T> compute_mu_lambda(T mu);
+    T init_step_size(const DeviceBuffer<T> &p); // Calculate the initial step size for the line search
+
+private:
+    // The implementation details of the VecAdder class are placed in the implementation class declared here.
+    struct Impl;
+    // The private pointer to the implementation class Impl
+    std::unique_ptr<Impl> pimpl_;
+};

simulators/5_mov_dirichlet/include/FrictionEnergy.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <Eigen/Dense>
+#include <vector>
+#include "uti.h"
+
+template <typename T, int dim>
+class FrictionEnergy
+{
+public:
+    FrictionEnergy(const std::vector<T> &v, T hhat, const std::vector<T> &n);
+    FrictionEnergy();
+    ~FrictionEnergy();
+    FrictionEnergy(FrictionEnergy &&rhs);
+    FrictionEnergy(const FrictionEnergy &rhs);
+    FrictionEnergy &operator=(FrictionEnergy &&rhs);
+
+    void update_v(const DeviceBuffer<T> &v);
+    void update_mu_lambda(const DeviceBuffer<T> &mu_lambda);
+    T val();                                 // Calculate the value of the energy
+    const DeviceBuffer<T> &grad();           // Calculate the gradient of the energy
+    const DeviceTripletMatrix<T, 1> &hess(); // Calculate the Hessian matrix of the energy
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> pimpl_;
+    T __device__ f0(T vbarnorm, T Epsv, T hhat);
+    T __device__ f1_div_vbarnorm(T vbarnorm, T Epsv);
+    T __device__ f_hess_term(T vbarnorm, T Epsv);
+};

simulators/5_mov_dirichlet/include/GravityEnergy.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <memory>
+#include <Eigen/Dense>
+#include "square_mesh.h"
+#include <muda/muda.h>
+#include <muda/container.h>
+#include <muda/ext/linear_system.h>
+
+using namespace muda;
+
+template <typename T, int dim>
+class GravityEnergy
+{
+public:
+    GravityEnergy(int N, T m);
+    GravityEnergy();
+    ~GravityEnergy();
+    GravityEnergy(GravityEnergy &&rhs);
+    GravityEnergy(const GravityEnergy &rhs);
+    GravityEnergy &operator=(GravityEnergy &&rhs);
+    GravityEnergy &operator=(const GravityEnergy &rhs);
+
+    void update_x(const DeviceBuffer<T> &x);
+    void update_x_tilde(const DeviceBuffer<T> &x_tilde);
+    void update_m(T m);
+    T val();                       // Calculate the value of the energy
+    const DeviceBuffer<T> &grad(); // Calculate the gradient of the energy
+
+private:
+    // The implementation details of the VecAdder class are placed in the implementation class declared here.
+    struct Impl;
+    // The private pointer to the implementation class Impl
+    std::unique_ptr<Impl> pimpl_;
+};

simulators/5_mov_dirichlet/include/InertialEnergy.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <Eigen/Dense>
+#include "square_mesh.h"
+#include <muda/muda.h>
+#include <muda/container.h>
+#include <muda/ext/linear_system.h>
+
+using namespace muda;
+
+template <typename T, int dim>
+class InertialEnergy
+{
+public:
+    InertialEnergy(int N, T m);
+    InertialEnergy();
+    ~InertialEnergy();
+    InertialEnergy(InertialEnergy &&rhs);
+    InertialEnergy(const InertialEnergy &rhs);
+    InertialEnergy &operator=(InertialEnergy &&rhs);
+
+    void update_x(const DeviceBuffer<T> &x);
+    void generate_hess();
+    void update_x_tilde(const DeviceBuffer<T> &x_tilde);
+    void update_m(T m);
+    T val();                                 // Calculate the value of the energy
+    const DeviceBuffer<T> &grad();           // Calculate the gradient of the energy
+    const DeviceTripletMatrix<T, 1> &hess(); // Calculate the Hessian matrix of the energy
+
+private:
+    // The implementation details of the VecAdder class are placed in the implementation class declared here.
+    struct Impl;
+    // The private pointer to the implementation class Impl
+    std::unique_ptr<Impl> pimpl_;
+};

simulators/5_mov_dirichlet/include/MassSpringEnergy.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <Eigen/Dense>
+#include "uti.h"
+
+template <typename T, int dim>
+class MassSpringEnergy
+{
+public:
+    MassSpringEnergy(const std::vector<T> &x, const std::vector<int> &e, const std::vector<T> &l2, const std::vector<T> &k);
+    MassSpringEnergy();
+    ~MassSpringEnergy();
+    MassSpringEnergy(MassSpringEnergy &&rhs);
+    MassSpringEnergy(const MassSpringEnergy &rhs);
+    MassSpringEnergy &operator=(MassSpringEnergy &&rhs);
+
+    void update_x(const DeviceBuffer<T> &x);
+    void update_e(const std::vector<int> &e);
+    void update_l2(const std::vector<T> &l2);
+    void update_k(const std::vector<T> &k);
+    T val();                                 // Calculate the value of the energy
+    const DeviceBuffer<T> &grad();           // Calculate the gradient of the energy
+    const DeviceTripletMatrix<T, 1> &hess(); // Calculate the Hessian matrix of the energy
+
+private:
+    // The implementation details of the VecAdder class are placed in the implementation class declared here.
+    struct Impl;
+    // The private pointer to the implementation class Impl
+    std::unique_ptr<Impl> pimpl_;
+};

simulators/5_mov_dirichlet/include/SparseMatrix.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <vector>
+
+template <typename T>
+class SparseMatrix
+{
+public:
+    SparseMatrix(int size);
+    SparseMatrix();
+    ~SparseMatrix();
+    SparseMatrix(SparseMatrix<T> &&rhs);
+    SparseMatrix<T> &operator=(SparseMatrix<T> &&rhs);
+    SparseMatrix<T> &operator=(SparseMatrix<T> &rhs);
+    SparseMatrix<T> &operator*(const T &a);
+    SparseMatrix(const SparseMatrix<T> &rhs);
+    void set_value(int row, int col, T val, int loc);
+    void set_diagonal(T val);
+
+    const std::vector<int> &get_row_buffer() const;
+    const std::vector<int> &get_col_buffer() const;
+    const std::vector<T> &get_val_buffer() const;
+    std::vector<int> &set_row_buffer();
+    std::vector<int> &set_col_buffer();
+    std::vector<T> &set_val_buffer();
+    SparseMatrix<T> &combine(const SparseMatrix<T> &other);
+
+    int get_size() const;
+
+private:
+    int size;
+    std::vector<int> row_idx;
+    std::vector<int> col_idx;
+    std::vector<T> val;
+};

simulators/5_mov_dirichlet/include/SpringEnergy.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <Eigen/Dense>
+#include "uti.h"
+#include "device_uti.h"
+
+template <typename T, int dim>
+class SpringEnergy
+{
+public:
+    SpringEnergy(const std::vector<T> &x, const std::vector<T> &m, const std::vector<int> &DBC, const std::vector<Eigen::Matrix<T, dim, 1>> &DBC_target, T k);
+    SpringEnergy();
+    ~SpringEnergy();
+    SpringEnergy(SpringEnergy &&rhs);
+    SpringEnergy(const SpringEnergy &rhs);
+    SpringEnergy &operator=(SpringEnergy &&rhs);
+
+    void update_x(const DeviceBuffer<T> &x);
+    T val();                                 // Calculate the value of the energy
+    const DeviceBuffer<T> &grad();           // Calculate the gradient of the energy
+    const DeviceTripletMatrix<T, 1> &hess(); // Calculate the Hessian matrix of the energy
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> pimpl_;
+};

simulators/5_mov_dirichlet/include/device_uti.h

@@ -0,0 +1,10 @@
+#include <muda/muda.h>
+#include <muda/container.h>
+#include <muda/cub/device/device_reduce.h>
+#include <Eigen/Dense>
+// utility functions
+template <typename T>
+T devicesum(const muda::DeviceBuffer<T> &buffer);
+
+template <typename T, int Size>
+void __device__ make_PSD(const Eigen::Matrix<T, Size, Size> &hess, Eigen::Matrix<T, Size, Size> &PSD);