2_dirichlet

Author: Roushelfy

simulators/1_mass_spring/include/uti.h

@@ -23,4 +23,4 @@ template <typename T>
 void search_dir(const DeviceBuffer<T> &grad, const DeviceTripletMatrix<T, 1> &hess, DeviceBuffer<T> &dir);
 
 template <typename T>
-void display_vec(const DeviceBuffer<T> &vec);
+void display_vec(const DeviceBuffer<T> &vec);

simulators/2_dirichlet/CMakeLists.txt

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

simulators/2_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/2_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/2_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/2_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/2_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);

simulators/2_dirichlet/include/simulator.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <vector>
+#include <cmath>
+#include "square_mesh.h"
+#include <iostream>
+template <typename T, int dim>
+class DirichletSimulator
+{
+public:
+    DirichletSimulator();
+    ~DirichletSimulator();
+    DirichletSimulator(DirichletSimulator &&rhs);
+    DirichletSimulator &operator=(DirichletSimulator &&rhs);
+    DirichletSimulator(T rho, T side_len, T initial_stretch, T K, T h, T tol, int n_seg);
+    void run();
+
+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/2_dirichlet/include/square_mesh.h

@@ -0,0 +1,7 @@
+#pragma once
+#include <vector>
+#include <memory>
+
+// Function to generate mesh points and edges
+template <typename T>
+void generate(T side_length, int n_seg, std::vector<T> &x, std::vector<int> &e);

simulators/2_dirichlet/include/uti.h

@@ -0,0 +1,29 @@
+#pragma once
+#include <Eigen/Dense>
+#include "SparseMatrix.h"
+#include <muda/cub/device/device_reduce.h>
+#include <muda/container.h>
+#include <muda/muda.h>
+#include <muda/ext/linear_system.h>
+using namespace muda;
+
+template <typename T>
+DeviceBuffer<T> add_vector(const DeviceBuffer<T> &a, const DeviceBuffer<T> &b, const T &factor1 = 1, const T &factor2 = 1);
+
+template <typename T>
+DeviceBuffer<T> mult_vector(const DeviceBuffer<T> &a, const T &b);
+
+template <typename T>
+DeviceTripletMatrix<T, 1> add_triplet(const DeviceTripletMatrix<T, 1> &a, const DeviceTripletMatrix<T, 1> &b, const T &factor1 = 1, const T &factor2 = 1);
+
+template <typename T>
+T max_vector(const DeviceBuffer<T> &a);
+
+template <typename T, int dim>
+void search_dir(const DeviceBuffer<T> &grad, const DeviceTripletMatrix<T, 1> &hess, DeviceBuffer<T> &dir, const DeviceBuffer<int> &DBC);
+
+template <typename T>
+void display_vec(const DeviceBuffer<T> &vec);
+
+template <typename T, int dim>
+void set_DBC(DeviceBuffer<T> &grad, DeviceCSRMatrix<T> &hess, const DeviceBuffer<int> &DBC);