并行计算导论 MPI + OpenMP 解决简单的NBody / 多体问题

最新推荐文章于 2024-05-25 17:36:58 发布
最新推荐文章于 2024-05-25 17:36:58 发布
阅读量5.8k 收藏 21
点赞数 7
分类专栏： 计算机基础 文章标签： MPI NBody OpenMP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40515692/article/details/110627138
版权

串行代码

首先是简单的NBody代码，这里设置每个质点的质量相等。初始速度为0，初始位置均匀分布。

类似于这样 （16 * 16 大小 ）：

在这里插入图片描述

这样可以抽象出代码循环逻辑为，这里N为总的质点数（ 如上图，则为256 ），然后每一次update时，计算每个质点的受力（加速度）、速度、位置：

void update() {
	for (int i = 0; i < N; i++)
		force(i);
	for (int i = 0; i < N; i++)
		velocity(i);
	for (int i = 0; i < N; i++)
		position(i);
}

那么我们需要一些数据结构来保存数据，分别保存质点的速度、加速度、位置（2维的）：

double* vBallvx;
double* vBallvy;
double* vBallax;
double* vBallay;
double* vBallpx;
double* vBallpy;

double r = 0.01;				// 质点半径
const double GM = 6.67E-7;		// G*M 用于计算加速度
const double delta_t = 0.01; 	// 表示每次update时经过的时间

void init(){
	vBallvx = new double[N];
	vBallvy = new double[N];
	vBallax = new double[N];
	vBallay = new double[N];
	vBallpx = new double[N];
	vBallpy = new double[N];
	
	static int size = sqrt(N);
	for (int i = 0; i < N; i++)
	{
		vBallpx[i] = 0.01 * (i % size);
		vBallpy[i] = 0.01 * (i / size);
		vBallvx[i] = 0;
		vBallvy[i] = 0;
		vBallax[i] = 0;
		vBallay[i] = 0;
	}
}

这样一个简单的串行多体问题代码就可以这样：

#include <iostream>

using namespace std;

double* vBallvx;
double* vBallvy;
double* vBallax;
double* vBallay;
double* vBallpx;
double* vBallpy;

int N = 256;					// 这里N不设置为常数，并且vBall等数据动态分配是为了方便之后改为MPI
const double r = 0.01;			// 质点半径
const double GM = 6.67E-7;		// G*M 用于计算加速度
const double delta_t = 0.01; 	// 表示每次update时经过的时间

void init() {
	vBallvx = new double[N];
	vBallvy = new double[N];
	vBallax = new double[N];
	vBallay = new double[N];
	vBallpx = new double[N];
	vBallpy = new double[N];
	
	static int size = sqrt(N);
	for (int i = 0; i < N; i++)
	{
		vBallpx[i] = 0.01 * (i % size);
		vBallpy[i] = 0.01 * (i / size);
		vBallvx[i] = 0;
		vBallvy[i] = 0;
		vBallax[i] = 0;
		vBallay[i] = 0;
	}
}

void force(int index) {
	vBallax[index] = 0;
	vBallay[index] = 0;

	for (int i = 0; i < N; i++) {
		if (i == index) continue;
		double dx = vBallpx[index] - vBallpx[i];
		double dy = vBallpy[index] - vBallpy[i];
		double d = dx * dx + dy * dy;
		if (d < r * r) d = r * r; // ^(3/2)
		d *= sqrt(d);

		vBallax[index] += GM * (dx) / d;
		vBallay[index] += GM * (dy) / d;
	}
}

void velocity(int index) {
	vBallvx[index] += vBallax[index] * delta_t;
	vBallvy[index] += vBallay[index] * delta_t;
}

void position(int index) {
	static int size = sqrt(N) - 1;
	vBallpx[index] += vBallvx[index] * delta_t;
	if (vBallpx[index] > size / 100.0) vBallpx[index] = size / 100.0;
	if (vBallpx[index] < 0) vBallpx[index] = 0;

	vBallpy[index] += vBallvy[index] * delta_t;
	if (vBallpy[index] > size / 100.0) vBallpy[index] = size / 100.0;
	if (vBallpy[index] < 0) vBallpy[index] = 0;
}

void update() {
	for (int i = 0; i < N; i++)
		force(i);
	for (int i = 0; i < N; i++)
		velocity(i);
	for (int i = 0; i < N; i++)
		position(i);
}

int main() {
	init();
	int i = 0;
	while (true)
	{
		update();
		cout << "迭代" << ++i << "次" << endl;
	}
	return 0;
}

OpenGL 可视化的代码就是这样，（使用GLUT这个OpenGL库）：

#include <iostream>
#include <gl/glut.h>

using namespace std;

double* vBallvx;
double* vBallvy;
double* vBallax;
double* vBallay;
double* vBallpx;
double* vBallpy;

int N = 256;					// 这里N不设置为常数，并且vBall等数据动态分配是为了方便之后改为MPI
const double r = 0.01;			// 质点半径
const double GM = 6.67E-7;		// G*M 用于计算加速度
const double delta_t = 0.01; 	// 表示每次update时经过的时间

void init() {
	vBallvx = new double[N];
	vBallvy = new double[N];
	vBallax = new double[N];
	vBallay = new double[N];
	vBallpx = new double[N];
	vBallpy = new double[N];

	static int size = sqrt(N);
	for (int i = 0; i < N; i++)
	{
		vBallpx[i] = 0.01 * (i % size);
		vBallpy[i] = 0.01 * (i / size);
		vBallvx[i] = 0;
		vBallvy[i] = 0;
		vBallax[i] = 0;
		vBallay[i] = 0;
	}
}

void force(int index) {
	vBallax[index] = 0;
	vBallay[index] = 0;

	for (int i = 0; i < N; i++) {
		if (i == index) continue;
		double dx = vBallpx[index] - vBallpx[i];
		double dy = vBallpy[index] - vBallpy[i];
		double d = dx * dx + dy * dy;
		if (d < r * r) d = r * r; // ^(3/2)
		d *= sqrt(d);

		vBallax[index] += GM * (dx) / d;
		vBallay[index] += GM * (dy) / d;
	}
}

void velocity(int index) {
	vBallvx[index] += vBallax[index] * delta_t;
	vBallvy[index] += vBallay[index] * delta_t;
}

void position(int index) {
	static int size = sqrt(N) - 1;
	vBallpx[index] += vBallvx[index] * delta_t;
	if (vBallpx[index] > size / 100.0) vBallpx[index] = size / 100.0;
	if (vBallpx[index] < 0) vBallpx[index] = 0;

	vBallpy[index] += vBallvy[index] * delta_t;
	if (vBallpy[index] > size / 100.0) vBallpy[index] = size / 100.0;
	if (vBallpy[index] < 0) vBallpy[index] = 0;
}

void update() {
	for (int i = 0; i < N; i++)
		force(i);
	for (int i = 0; i < N; i++)
		velocity(i);
	for (int i = 0; i < N; i++)
		position(i);
}

// ----------------------------------------- OpenGL 函数分割线 ----------------------------------

void drawBall() {
	glColor3f(0, 0, 0);
	glPointSize(4);
	glBegin(GL_POINTS);
	for (int i = 0; i < N; i++)
		glVertex2f(vBallpx[i] * 2, vBallpy[i] * 2);
	glEnd();
}

void display(void) {
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	drawBall();
	glutSwapBuffers();
}

void timeToEva(int ms) {
	display();
	glutTimerFunc(ms, timeToEva, ms);
}

void resize(int w, int h) {
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	glViewport(0, 0, w, h);

	gluPerspective(45.0f, 1.0f * w / h, 1.0f, 100.0f);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

// 调用后阻塞
void initOpenGL(int argc, char* argv[], void (*update)()) {
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(1000, 1000);
	glutCreateWindow("Demo");
	glutDisplayFunc(&display);
	int ms = 30;
	glutTimerFunc(ms, timeToEva, ms);	// 每30ms执行一次，显示刷新（渲染）
	glutIdleFunc(update);				// CPU空闲时执行update
	glClearColor(0.93f, 0.93f, 0.93f, 0.0f);
	glEnable(GL_DEPTH_TEST);
	glutMainLoop();
}

// ----------------------------------------- OpenGL 函数分割线 ----------------------------------

int main(int argc, char* argv[]) {
	init();
	initOpenGL(argc, argv, update);
	return 0;
}

使用MPI代码

MPI有多种进程间通信函数，这里先选用的MPI_Bcast，然而一对多等集合操作没有tag，所以我们这里牺牲性能，用MPI_Send和MPI_Recv实现一个my_bcast。

参考： https://blog.csdn.net/a1066196847/article/details/89709720
参考： https://stackoverflow.com/questions/64124667/is-mpi-bcast-supposed-to-work-with-mpi-ibcast
在这里插入图片描述
代码如下：

void my_bcast(void* data, int count, MPI_Datatype datatype, int root, MPI_Comm communicator, int tag) {
	int world_rank;
	MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
	int world_size;
	MPI_Comm_size(MPI_COMM_WORLD, &world_size);

	if (world_rank == root) {
		//如果是源进程的话，就要发送数据给到其他所有的进程
		for (int i = 0; i < world_size; i++) {
			if (i != world_rank) {
				// 要发送count这么多的data,data的数据类型是datatype，要发送到i进程，数据的tag是0
				MPI_Send(data, count, datatype, i, tag, communicator);
			}
		}
	}
	else {
		//如果不是源进程，那么最终目的就只剩一个了，就是接收
		MPI_Recv(data, count, datatype, root, tag, communicator, MPI_STATUS_IGNORE);
	}
}

回到我们的多体问题来，时间主要耗在了计算加速度，即for循环那里，时间复杂度为O(N2)，因此我们需要重点优化这里，思路就是将质点均匀的分配给每个进程。这里为了方便讨论，假设有4个进程，如下：

在这里插入图片描述
当计算加速度时，每个进程向其他所有进程广播当前管理的质点的位置。代码类似于这样，numprocs表示当前的进程数，如上图则为4，vBallpxAll、vBallpyAll表示同步的位置信息：

void update() {
	for (int i = 0; i < numprocs; i++) {
		my_bcast(vBallpxAll + i * N, N, MPI_DOUBLE, i, MPI_COMM_WORLD, 0);
		my_bcast(vBallpyAll + i * N, N, MPI_DOUBLE, i, MPI_COMM_WORLD, 1); // TODO
	}

	for (int i = 0; i < N; i++)
		force(i);
	for (int i = 0; i < N; i++)
		velocity(i);
	for (int i = 0; i < N; i++)
		position(i);
}

这里需要每个进程创建256大小的vBallpxAll、vBallpyAll，用来存放所有的质点的位置信息。而速度和加速度则不需要同步，只需要创建256/4 = 64大小的数组。每次迭代update前，将所有质点的位置信息进行同步。这样就可以正确的运行程序了。

最终代码如下：

#include <iostream>
#include <gl/glut.h>
#include<mpi.h>

using namespace std;

double* vBallvx;
double* vBallvy;
double* vBallax;
double* vBallay;
double* vBallpxAll;
double* vBallpyAll;

int N = 256;					// 这里N不设置为常数，并且vBall等数据动态分配是为了方便之后改为MPI
const double r = 0.01;			// 质点半径
const double GM = 6.67E-7;		// G*M 用于计算加速度
const double delta_t = 0.01; 	// 表示每次update时经过的时间

int myid, numprocs;				// 当前进程id 当前创建进程数

void my_bcast(void* data, int count, MPI_Datatype datatype, int root, MPI_Comm communicator, int tag) {
	int world_rank;
	MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
	int world_size;
	MPI_Comm_size(MPI_COMM_WORLD, &world_size);

	if (world_rank == root) {
		//如果是源进程的话，就要发送数据给到其他所有的进程
		for (int i = 0; i < world_size; i++) {
			if (i != world_rank) {
				// 要发送count这么多的data,data的数据类型是datatype，要发送到i进程，数据的tag是0
				MPI_Send(data, count, datatype, i, tag, communicator);
			}
		}
	}
	else {
		//如果不是源进程，那么最终目的就只剩一个了，就是接收
		MPI_Recv(data, count, datatype, root, tag, communicator, MPI_STATUS_IGNORE);
	}
}

void init() {
	vBallvx = new double[N];
	vBallvy = new double[N];
	vBallax = new double[N];
	vBallay = new double[N];
	vBallpxAll = new double[N * numprocs];
	vBallpyAll = new double[N * numprocs];

	static int size = sqrt(N);
	static int numprocsQ = sqrt(numprocs);
	int offsetSize1 = myid % numprocsQ * size;
	int offsetSize2 = myid / numprocsQ * size;
	for (int i = 0; i < N; i++)
	{
		vBallpxAll[i + myid * N] = 0.01 * (i % size + offsetSize1);
		vBallpyAll[i + myid * N] = 0.01 * (i / size + offsetSize2);
		vBallvx[i] = 0;
		vBallvy[i] = 0;
		vBallax[i] = 0;
		vBallay[i] = 0;
	}
}

void force(int index) {
	vBallax[index] = 0;
	vBallay[index] = 0;

	for (int i = 0; i < N * numprocs; i++) {
		if (i == index + myid * N) continue;
		double dx = vBallpxAll[index + myid * N] - vBallpxAll[i];
		double dy = vBallpyAll[index + myid * N] - vBallpyAll[i];
		double d = dx * dx + dy * dy;
		if (d < r * r) d = r * r; // ^(3/2)
		d *= sqrt(d);

		vBallax[index] += GM * (dx) / d;
		vBallay[index] += GM * (dy) / d;
	}
}

void velocity(int index) {
	vBallvx[index] += vBallax[index] * delta_t;
	vBallvy[index] += vBallay[index] * delta_t;
}

void position(int index) {
	static int size = sqrt(N * numprocs) - 1;
	vBallpxAll[index + myid * N] += vBallvx[index] * delta_t;
	if (vBallpxAll[index + myid * N] > size / 100.0) vBallpxAll[index + myid * N] = size / 100.0;
	if (vBallpxAll[index + myid * N] < 0) vBallpxAll[index + myid * N] = 0;

	vBallpyAll[index + myid * N] += vBallvy[index] * delta_t;
	if (vBallpyAll[index + myid * N] > size / 100.0) vBallpyAll[index + myid * N] = size / 100.0;
	if (vBallpyAll[index + myid * N] < 0) vBallpyAll[index + myid * N] = 0;
}

void update() {
	for (int i = 0; i < numprocs; i++) {
		my_bcast(vBallpxAll + i * N, N, MPI_DOUBLE, i, MPI_COMM_WORLD, 0);
		my_bcast(vBallpyAll + i * N, N, MPI_DOUBLE, i, MPI_COMM_WORLD, 1); // TODO
	}

	for (int i = 0; i < N; i++)
		force(i);
	for (int i = 0; i < N; i++)
		velocity(i);
	for (int i = 0; i < N; i++)
		position(i);
}

// ----------------------------------------- OpenGL 函数分割线 ----------------------------------

void drawBall() {
	glColor3f(0, 0, 0);
	glPointSize(4);
	glBegin(GL_POINTS);
	for (int i = 0; i < N * numprocs; i++)
		glVertex2f(vBallpxAll[i] * 2, vBallpyAll[i] * 2);
	glEnd();
}

void display(void) {
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	drawBall();
	glutSwapBuffers();
}

void timeToEva(int ms) {
	display();
	glutTimerFunc(ms, timeToEva, ms);
}

void resize(int w, int h) {
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	glViewport(0, 0, w, h);

	gluPerspective(45.0f, 1.0f * w / h, 1.0f, 100.0f);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

// 调用后阻塞
void initOpenGL(int argc, char* argv[], void (*update)()) {
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(1000, 1000);
	glutCreateWindow("Demo");
	glutDisplayFunc(&display);
	int ms = 30;
	glutTimerFunc(ms, timeToEva, ms);	// 每30ms执行一次，显示刷新（渲染）
	glutIdleFunc(update);				// CPU空闲时执行update
	glClearColor(0.93f, 0.93f, 0.93f, 0.0f);
	glEnable(GL_DEPTH_TEST);
	glutMainLoop();
}

// ----------------------------------------- OpenGL 函数分割线 ----------------------------------

int main(int argc, char* argv[]) {
	MPI_Init(&argc, &argv);
	MPI_Comm_rank(MPI_COMM_WORLD, &myid); // pid
	MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
	N /= numprocs;

	init();
	if (myid != 0) {
		while (true)
		{
			update();
		}
	}
	else
		initOpenGL(argc, argv, update);
	return 0;
}

最后根据硬件属性，在相应的for循环前面添加#pragma omp parallel for，让OpenMP自动进行共享内存的并行计算。整个多体问题的简单并行代码即完成。

附录 环境配置

OpenGL glut 配置

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
MPI 配置：

暂无

iamttp
关注
  • 7
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
基于OpenMP_MPI并行编程模型的N体问题的优化实现
12-13
基于OpenMP_MPI并行编程模型的N体问题的优化实现，可以给刚接触openmp+mpi混合编程的人一些参考
利用MPI解决N体问题
weixin_43742643的博客
08-16 2801
参考 MPI并行计算模拟N体问题 实验题目 题目： 利用MPI解决N体问题 实验内容： N体问题是指找出已知初始位置、速度和质量的多个物体在经典力学情况下的后续运动。在本次实验中，你需要模拟N个物体在二维空间中的运动情况。通过计算每两个物体之间的相互作用力，可以确定下一个时间周期内的物体位置。 在本次实验中，初始情况下，N个小球等间隔分布在一个正方形的二维空间中，小球在运动时没有范围限制。每个小球间会且只会受到其他小球的引力作用。小球可以看成质点。小球移动不会受到其他小球的影响(即不会发生碰撞，挡住等情
MPI并行编程基础
最新发布
綾華の笔记本
05-25 1239
入口参数 position的初始值是输出缓冲区中被打包消息占用的起始地址， 解包后它的值根据打包消息的大小来增加，因此出口参数 position的值是输出缓冲区中被解包的消息占用空间后面的第一个地址。入口参数 position 的值是输出缓冲区中用于打包的起始地址，打包后它的值根据打包消息的大小来增加， 出口参数 position 的值是被打包的消息占用的输出缓冲区后面的第一个地址。组间通信域是一种特殊的通信域，该通信域包括了两个进程组，分属于两个进程组的进程之间通过组间通信域实现通信。
基于CUDA的N-Body问题并行程序设计及性能优化
EMF2423的博客
11-08 5271
N-Body问题介绍 目录 N-Body问题介绍 CUDA并行程序设计 优化思路 优化结果 其他思路 CUDA并行程序设计 优化思路 优化结果 其他思路
MPIOpenMP混合编程解决N-Body问题 实验4
南国的博客
10-25 7896
MPIOpenMP混合编程解决N-Body问题 实验4 华南理工大学 高性能云计算 随着国民经济、国防建设和高科技的快速发展，越来愈多的领域对高性能计算有强烈的需求，包括原子能、航空、航天、激光、气象、石油、海洋、天文、地震、生物、材料、医药、化工等。特别是全球气候变化和天气预报、生物分子结构探索、湍流研究、新材料探索以及不少国防研究课题，都迫切需要高性能计算。高性能计算课程的目标就是培养从事高性能计算方面
使用MPI实现的nBody代码
06-03
并行计算实验使用MPI计算N体问题代码，命令：mpiexec -n 1 EXP3.exe 64 10 1 g。
MPI+OpenMP.zip
06-17
总之，MPI和OpenMP的结合使用是提升计算效率的重要手段，尤其在处理大规模数据和复杂计算问题时。通过理解这两个工具的工作原理，掌握如何编写有效的并行程序，可以极大地提高我们的计算能力，为科学研究和工程计算...
大数据并行计算利器之MPI/OpenMP
02-26
图像连通域标记算法是从一幅栅格图像（通常为二值图像）中，将互相邻接（4邻接或8邻接）的具有非背景值的像素集合提取出来，为不同的连通域填入数字标记，并且统计连通域的数目。...随着并行计算技术的发展，利用不同
基于MPI+OpenMP的并行编程1
08-03
【基于MPI+OpenMP的并行编程1】 并行编程是一种技术，允许程序在多处理器或分布式计算资源上同时执行，以提高计算效率。在本文中，我们将关注两种主要的并行编程模型：MPI（Message Passing Interface）和OpenMP。...
MPI与OpenMP并行程序设计：C语言版,mpi和openmp混合编程,C,C++
09-10
在计算机科学领域，多进程并行计算和多线程并行计算是提升程序性能和解决大规模计算问题的关键技术。MPI（Message Passing Interface）和OpenMP是两种常用的并行编程模型，它们分别针对不同的并行环境和任务需求。本...
nbody的mpi&openmp实现源码
01-01
mp实现源码 并行计算课的实验源码，二维的nbody实验源码运用mpi，openmp以及两者的混合实验源码。
Nbody问题采用treecode算法在GPU上的并行实现
08-27
Nbody问题采用treecode算法在GPU上的并行实现
Parallel-NBody：并行的N体代码，遵循Costzones方法。 还提供了OpenGL可视化工具
02-21
并行Barnes-Hut N体仿真 该代码集遵循许多人（沃伦，萨尔蒙，辛格，霍尔特，巴恩斯，小屋，奥尔萨斯）的思想，以实现重力N体的巴恩斯小屋（八叉树）模拟。 该代码适用于共享内存的多核/多处理器。 还开发了OpenGLv3.3渲染器以观察仿真进度。 加速度/力是通过重力来计算的。 集成方案是一个简单的跨越式方案。 使用软化因子计算直接和间接交互，以避免亲密接触。 对于间接相互作用（粒子-细胞相互作用），多极扩展用于包含单极和四极项。 代码组织 大部分代码都是用C语言编写的，并带有一些C ++来将它们粘合在一起并用于C ++ 11线程。 有3个主要模块： N体代码（在src中） 用于可视化的OpenGL代码（在src / ogl中） 并行实用程序（在src / parallel中） N主体代码主要组织如下： NBodyConfig：编译定义，模拟元参数。 NBodyFor
n-body-simulation:用C编写的N Body Simulation的串行版本
05-26
N体模拟 #### N身体模拟的串行版本，用C编写 Miriam Robinson，Ben White，Chris Mitchell 刘易斯与克拉克学院-2012年夏季 ######在Mac OSX上运行 您需要x11库才能运行此程序： : 用以下命令编译程序： n-body.c -I/opt/X11/include -L/opt/X11/lib -lm -lX11 运行： ./a.out 为了指定世界上的物体数量，该程序还可以选择接受一个整数作为其第二个命令行参数： ./a.out 10 // 10 bodies
Nbody算法串行实现 c语言
05-04
NBody系统主要用来通过粒子之间的物理作用力来模拟星系系统。每个粒子表示一个星星，多个粒子之间的相互作用，就呈现出星系的效果。
多体系统动力学matlab编程示例
weixin_35751412的博客
01-06 623
您好！多体动力学模拟通常需要使用微分方程来描述系统的运动。在 Matlab 中，您可以使用 ode 函数来解决常微分方程组。下面是一个简单的例子，展示了如何使用 ode 函数来模拟两个质点之间的弹性碰撞： % 定义微分方程function dydt = collision(t, y) % y(1) 和 y(2) 分别表示两个质点的位置 % y(3) 和 y(4) 分别表示两个质点的...
并行MPI计算三维nbody问题
ssw的博客
06-01 445
介绍:: 生成数据，迭代计算，输出数据均可调参数 MPI:: {暂时空缺} 并行MPI还是有些不理解的地方稍后会补上： 代码:: /* * @Descripttion: * @Author: ssw * @Date: 2021-05-30 16:26:58 * @LastEditors: ssw * @LastEditTime: 2021-05-31 20:36:19 * * 粒子个数 n * 时间间隔 delta_time = 1/timestep * 运行时长 cycle_time
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值