PySPH参考文档

模块应用（Module）

class pysph.solver.application.Application(fname=Noneoutput_dir=None, domain=None)

Bases:object

该类的子类可以运行任何SPH模拟，该类提供了几个重要的方法。application的典型使用方法是：

class EllipticalDrop(Application):
    def create_particles(self):
        # ...
    def create_scheme(self):
        # ...
    ...
app = EllipticalDrop()
app.run()
app.post_process(app.info_filename)

post_process()方法是可选的，通常在执行后处理。

了解方法调用的正确顺序是很重要的。

当应用程序实例被创建时，下列方法被 init() 方法调用：

initialize(): 用于设置任意常量。
create_scheme(): 如果使用 pysph.sph.scheme.Scheme ，则需要重载这个方法。如果不想使用scheme，则必须重载 create_equations() 和 create_solver() 方法。
self.scheme.add_user_options: 如果有一个scheme，添加scheme的命令行选项。
add_user_options: 添加用户指定的命令行选项。

当app.run()被调用时，以此调用以下方法：

_parse_command_line(): 这是一个重要的私有方法，用于首先解析命令行参数。
consume_user_options(): 在命令行参数解析后立即调用。
configure_scheme(): 根据传递的命令行参数配置方案(scheme)。
create_solver(): 创建求解器，只有在没有使用scheme的时候这样做，否则默认返回由所选方案创建的求解器。
create_equations(): 创建任意方程。默认让scheme生成并返回的方程。
create_particles()
create_inlet_outlet()
create_domain(): 非周期域不需要。
create_nnps(): 除非希望覆盖默认的NNPS，否则不需要。
create_tools(): 添加任何 pysph.solver.tools.Tool实例。
customize_output(): 自定义输出可视化。

此外，当应用程序运行时，有几个方便的可选回调设置：

pre_step(): 在每个时间步之前调用。
post_stage(): 在每个stage集合后调用。
post_step(): 在每个时间步之后调用。

最后，重载 post_process()方法对生成的数据执行任何后处理。

Application实例也有几个重要的属性，其中一些如下：

args：命令行参数，通常为 sys.argv[1:]。
domain: 可选 pysph.base.nnps_base.DomainManager实例。
fname：转储输出时使用的文件名模式。
inlet_outlet: 入口/出口列表。
nnps：pysph.base.nnps_base.NNPS 的实例。
num_procs: 正在运行的进程总数。
output_dir: 输出目录。
parallel_manager: 并行，pysph.parallel.parallel_manager.ParallelManager的实例。
particles: pysph.base.particle_array.ParticleArray的列表。
rank: process的等级。
scheme: 可选pysph.base.scheme.Scheme的实例。
tools: pysph.solver.tools.Tool的列表。

Application Constructor

参数 -fname(str): 用于输出文件的文件名。 -output_dir(str): 输出目录名称。 -domain(pysph.base.nnps_base.DomainManager):要使用的domain manage。用于周期性域等。

add_tool(tool)

将 pysph.solver.tools.Tool实例添加到application。

add_user_options(group)

将任何用户定义的选项添加到option group。

configure_scheme()

在调用 consume_user_options()后被调用。可以在此处配置SPH方案，因为在此时所有命令行选项都是已知的。

consume_user_options()

在命令行参数解析后立即调用。所有解析选项都可以在 self.options方法中使用。这意味着用户可以覆盖以设置任何内部变量。这些变量取决于被传递的命令行参数。在创建求解器或粒子之前调用此方法，

create_domain()

创建一个 pysph.base.nnps_base.DomainManager并在需要的时候返回它。用于周期性域等，如果将domain传递给__init__()，则不会返回该方法。

create_equations()

创建要使用的方程并返回它们。

create_inlet_outlet(particle_arrays)

创建入口和出口对象，并以列表格式返回。该方法传递一个粒子数组的字典，该字典以粒子数组的名称为键。

create_nnps()

如果需要，创建任何NNPS并将其返回，否则将自动创建默认NNPS。

create_particles()

创建粒子数组并返回它们的列表。

create_scheme()

创建一个合适的SPH方案并返回它。在处理完所有参数以及调用 consume_user_options()后调用此方法。

create_solver()

创建求解器并将其返回。

create_tools()

创建任何工具并返回他们的序列(sequence)，在粒子/入口等全部被设置、配置之后调用此方法。

customize_output()

通过添加任意文件来自定义输出文件可视化。例如，pysph view命令将查找 mayavi_config.py可用于编写viewer脚本的文件。可以使用 self._mayavi_config(‘code’)来添加默认自定义。在模拟开始前被执行。

dump_cpde(file)

将生成的代码转储到给定文件。

initialize()

在构造函数上使用，设置常量等。

post_process(info_fname_or_directory)

给定信息文件名或包含信息文件的目录，读取信息并对结果进行后处理。 info文件有一些有用的属性，可以通过 read_info()方法读取。 output_files属性提供生成的输出文件。

post_stage(current_time,dt,stage)

如果重载，则在每个积分器阶段(stage)后自动调用，即如果积分器是两阶段(stage)积分器，它将在第一和第二阶段(stage)之后调用.

post_step(solver)

如果重载，则会在每个积分器步骤(step)后自动调用，该方法被传递给求解器实例。

pre_step(solver)

如果重载，则会在每个积分器步骤(step)之前自动调用，该方法被传递给求解器实例。

read_info(fname_or_dir)

从给定的信息文件（或包含信息文件的目录，将使用第一个找到的信息文件）中读取信息。

run(argv=None)

运行应用程序。基本上是调用 setup()后调用 solve() 参数: argv(list) - 可选的命令行参数。

setup(argv)

设置应用程序。可用于设置各种基础设施以运行SPH模拟。例如，这将解析传递的命令行参数，设置方案、求解器和方程等。但它不会调用求解器的求解方法。如果想手动运行求解器，可能很有用。

solve()

运行求解器。此方法期望 setup已经被调用。

pysph.solver.application.list_all_kernels()

返回可用核函数的列表。

模块控制器（Module controller）

为求解器添加各种接口。

CommandManager Constructor

classpysph.solver.controller.CommandManager(solver, comm=None)

Bases：object 用于管理和同步来自各个控制器的命令的类。

add_function(callable,interval=1)

增加一个函数，每隔一段时间就会调用一次.

add_interface(callable,block=True)

向控制器添加可调用接口。该可调用程序必须接受一个控制器实例参数。可调用程序在它自己的一个新线程中被调用，它可以用传递给它的控制器实例上定义的方法执行各种操作。新创建的线程被设置为daemon模式并返回。

cont

在pause命令后continue。

dispatch(block, meth, *args, **kwargs)

执行/排队一个带有指定参数的命令。

execute_commands(solver)

在每个时间步之后由求解器调用。

get_particle_array_combined(idx, procs=None)

获得一个包含所有程序的综合数据的单一粒子数组。

get_particle_array_from_procs(idx, procs=None)

从所有进程中获取索引处的粒子数组。

get_particle_array_index(name)

获取命名的粒子数组的索引。

get_particle_array_names( )

获得粒子数组的名称。

get_prop(name)

获得求解器属性。

get_result(lock_id)

获取先前排队的命令的结果。

get_status()

获得控制器的状态（status）

get_task_lock(lock_id)

获得与命令关联的lock实例。

pause_on_next()

暂停并等待下一个控制间隔的命令。

set_log_level(level)

设置日志记录级别。

set_prop(name,value)

设置求解器属性(property)。

solver_method(name, *args, **kwargs)

在求解器上执行方法。

sync_commands()

向所有并行运行的程序发送待定命令.

wait_for_cmd()

等待来自任何接口的命令

controller Constructor

classpysph.solver.controller.Controller(command_manager, block=True)

Bases: object 控制器类作为一个代理来控制解算器这被作为一个参数传递给接口 可用方法

get -获得求解器参数的值
set -设置求解器参数的值
get_result -返回队列命令的结果
pause_on_next -在下一次迭代中暂停求解器线程
wait -等待（block）调用线程，直到求解器暂停（在pause_on_next后调用）
cont -继续求解器线程
FIXME: 等待/继续当前不能并行工作

pause_on_next()

在下一次迭代中暂停求解器线程

cont()

在被pause_on_next暂停后继续求解器线程。只有在调用pause_on_next方法后才调用它。

get(name)

获得求解器的一个属性。（立即返回）

get_blocking()

获得blocking模式（True/False）

get_result(task_id)

获得先前排队的命令的结果

set(name,value)

设置一个求解器属性。（立即返回）

set_blocking(block)

将阻塞模式设置为（True/False）

在阻塞模式下(block=True) ，除了获取求解器属性之外的所有方法都会阻塞，直到求解器执行命令并返回结果。阻塞时间取决于求解器每次迭代所花费的时间和command_interval。
在非阻塞模式下(block=False)，这些方法将命令排队以备后用，并返回与操作的task_id对应的字符串。结果可以通过调用get_result（阻塞）来获得，参数为task_id。

wait()

阻塞调用进程直到求解器线程停止。仅在调用pause_on_next方法告诉控制器暂停求解器线程后调用。

DummyComm Constructor

class pysph.solver.controller.DummyComm

Base:object 作为串行运行的占位符的虚拟MPI.Comm实现

Get_rank()

返回进程的等级(rank of the process)（0）

Get_size()

返回通讯的大小（size of the comm）（1）

bcast(data)

串行运行的bcast（广播）实现

gather(data)

收集串行运行的实现

recv(PID)

虚拟recv实现

send(data,pid)

虚拟发送实现

其他

pysph.solver.controller.in_parallel(f)

返回在所有 procs 上运行修饰函数(decorated function)的结果列表

pysph.solver.controller.on_root_proc(f)

仅在根proc上运行的修饰的函数

pysph.solver.controller.synchronized(lock_or_func)

同步（thread safe）功能的装饰器（decorator ）

SPH方程

class pysph.sph.equation.Equation(dest,sources)

Bases:object 参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称

converged() 返回>0表示收敛迭代，否则返回<0。

基本SPH方程

体力计算

class pysph.sph.basic_equations.BodyForce(dest, sources, fx=0.0, fy=0.0, fz=0.0)

Bases: pysph.sph.equation.Equation 向粒子添加体力。参数：

fx(floay)-沿x轴方向每单位质量的体力
fy(floay)-沿y轴方向每单位质量的体力
fz(floay)-沿z轴方向每单位质量的体力

initialize(d_idx, d_au, d_av, d_aw)

loop(d_idx, d_au, d_av, d_aw)

连续性方程

class pysph.sph.basic_equations.ContinuityEquation(dest, sources)

Bases: pysph.sph.equation.Equation 密度率：参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称

initialize(d_idx, d_arho)

loop(d_idx, d_arho, s_idx, s_m, DWIJ, VIJ)

EOS

class pysph.sph.basic_equations.IsothermalEOS(dest, sources, rho0, c0, p0)

Bases: pysph.sph.equation.Equation 利用等温状态方程计算压力：参数：

rho0(float) -流体的参考密度()
c0(float) -系统中预期的最大声速()
p0(float) -系统中的参考压力()

loop(d_idx,d_rho,d_p)

Monaghan人工黏度

class pysph.sph.basic_equations.MonaghanArtificialViscosity(dest, sources, alpha=1.0, beta=1.0)

Bases: pysph.sph.equation.Equation 经典 Monaghan 风格的人工粘度: blockformula_editor\frac{d\mathbf{v}_{a}}{dt}=\sum_{b}m_{b}\Pi_{ab}\nabla_{a}W_{ab} 其中： blockformula_editor\Pi_{a b}= \begin{cases}\frac{-\alpha_\pi \bar{c}_{a b} \phi_{a b}+\beta_\pi \phi_{a b}^2}{\bar{\rho}_{a b}}, & \mathbf{v}_{a b} \cdot \mathbf{r}_{a b}<0 \\ 0, & \mathbf{v}_{a b} \cdot \mathbf{r}_{a b} \geq 0\end{cases} 和： blockformula_editor\phi_{a b}=\frac{h \mathbf{v}_{a b} \cdot \mathbf{r}_{a b}}{\left|\mathbf{r}_{a b}\right|^2+\epsilon^2} blockformula_editor\bar{c}_{a b}=\frac{c_a+c_b}{2} blockformula_editor\bar{\rho}_{a b}=\frac{\rho_a+\rho_b}{2} 参数：

alpha(float) -产生剪切和体积粘度()
beta(float) -用于处理高马赫数冲击()

initialize(d_idx, d_au, d_av, d_aw)

loop(d_idx, s_idx, d_rho, d_cs, d_au, d_av, d_aw, s_m, s_rho, s_cs, VIJ, XIJ, HIJ, R2IJ, RHOIJ1, EPS, DWIJ)

密度求和法

class pysph.sph.basic_equations.SummationDensity(dest, sources)

Bases: pysph.sph.equation.Equation 密度求和法： blockformula_editor\rho_a=\sum_b m_b W_{a b} 参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称

initialize(d_idx, d_rho)

loop(d_idx, d_rho, s_idx, s_m, WIJ)

速度梯度张量SPH评估（2D）

class pysph.sph.basic_equations.VelocityGradient2D(dest, sources)

Bases: pysph.sph.equation.Equation 计算二维速度梯度张量的 SPH 评估。速度梯度的表达式为：

\frac{\partial v^i}{\partial x^j}=\sum_b \frac{m_b}{\rho_b}\left(v_b-v_a\right) \frac{\partial W_{a b}}{\partial x_a^j}

张量属性存储在变量v_ij中，其中i指的是速度分量，j指的是空间分量。因此，v_10指的是参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称

initialize(d_idx, d_v00, d_v01, d_v10, d_v11)

loop(d_idx, s_idx, s_m, s_rho, d_v00, d_v01, d_v10, d_v11, DWIJ, VIJ)

速度梯度张量SPH评估（3D）

class pysph.sph.basic_equations.VelocityGradient3D(dest, sources)

Bases: pysph.sph.equation.Equation 计算三维速度梯度张量的 SPH 评估。速度梯度的表达式为：

\frac{\partial v^i}{\partial x^j}=\sum_b \frac{m_b}{\rho_b}\left(v_b-v_a\right) \frac{\partial W_{a b}}{\partial x_a^j}

张量属性存储在变量v_ij中，其中i指的是速度分量，j指的是空间分量。因此，v_21指的是参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称

initialize(d_idx, d_v00, d_v01, d_v02, d_v10, d_v11, d_v12, d_v20, d_v21, d_v22)

loop(d_idx, s_idx, s_m, s_rho, d_v00, d_v01, d_v02, d_v10, d_v11, d_v12, d_v20, d_v21, d_v22, DWIJ, VIJ)

XSPH法

class pysph.sph.basic_equations.XSPHCorrection(dest, sources, eps=0.5)

Bases: pysph.sph.equation.Equation 带 XSPH 校正的位置步进

\frac{d \mathbf{r}_a}{d t}=\hat{\mathbf{v}}_a=\mathbf{v}_a-\epsilon \sum_b m_b \frac{\mathbf{v}_{a b}}{\bar{\rho}_{a b}} W_{a b}

参数：参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称
eps(float)- XSPH 可以通过设置参数来关闭。eps = 0

initialize(d_idx, d_ax, d_ay, d_az)

loop(s_idx, d_idx, s_m, d_ax, d_ay, d_az, WIJ, RHOIJ1, VIJ)

post_loop(d_idx, d_ax, d_ay, d_az, d_u, d_v, d_w)

XSPH-(跳蛙法)

pysph.sph.basic_equations.XSPHCorrectionForLeapFrog(dest, sources, eps=0.5)

Bases: pysph.sph.equation.Equation 单独的XSPH矫正。和已经考虑了粒子速度的跳蛙法一起使用。他只是简单的计算矫正项，并将其加入ax,ay,az

\frac{d \mathbf{r}_a}{d t}=\hat{\mathbf{v}}_a=-\epsilon \sum_b m_b \frac{\mathbf{v}_{a b}}{\bar{\rho}_{a b}} W_{a b}

参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称
eps(float)- XSPH 可以通过设置参数来关闭。eps = 0

initialize(d_idx, d_ax, d_ay, d_az)

loop(s_idx, d_idx, s_m, d_ax, d_ay, d_az, WIJ, RHOIJ1, VIJ)

基本WCSPH方程

具有耗散项的连续性方程

class pysph.sph.wc.basic.ContinuityEquationDeltaSPH(dest, sources, c0, delta=0.1)

\frac{d \rho_a}{d t}=\sum_b \rho_a \frac{m_b}{\rho_b}\left(\boldsymbol{v}_{a b} \cdot \nabla_a W_{a b}+\delta \eta_{a b} \cdot \nabla_a W_{a b}\left(h_{a b} \frac{c_{a b}}{\rho_a}\left(\rho_b-\rho_a\right)\right)\right)

参数：

c0(float) -参考音速
delta(float) -用于控制密度扩散强度的系数

loop(d_idx, d_arho, s_idx, s_m, d_rho, s_rho, DWIJ, XIJ, R2IJ, HIJ, EPS, d_gradrho, s_gradrho)

具有耗散项的连续性方程PreStep

class pysph.sph.wc.basic.ContinuityEquationDeltaSPHPreStep(dest, sources)

矩阵乘以。在pysph.ph.scheme.WCSPHScheme类中，通过使用pysph.ph.wc.kernel_correction.GradientCorrectionPreStep和 pysph.ph.wc.kernel_correction.GradientCorrection. 参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称

initialize(d_idx, d_gradrho)

loop(d_idx, d_arho, s_idx, d_rho, s_rho, s_m, d_gradrho, DWIJ)

具有人工粘性的Monaghan动量方程

class pysph.sph.wc.basic.MomentumEquation(dest, sources, c0, alpha=1.0, beta=1.0, gx=0.0, gy=0.0, gz=0.0, tensile_correction=False)

Bases: pysph.sph.equation.Equation

\frac{d \mathbf{v}_a}{d t}=-\sum_b m_b\left(\frac{p_b}{\rho_b^2}+\frac{p_a}{\rho_a^2}+\Pi_{a b}\right) \nabla_a W_{a b}

其中：

\Pi_{a b}= \begin{cases}\frac{-\alpha \bar{c} a b \mu_{a b}+\beta \mu_{a b}^2}{\bar{\rho}_{a b}} & \mathbf{v}_{a b} \cdot \mathbf{r}_{a b}<0 \\ 0 & \mathbf{v}_{a b} \cdot \mathbf{r}_{a b} \geq 0\end{cases}

和：

\mu_{a b}=\frac{h \mathbf{v}_{a b} \cdot \mathbf{r}_{a b}}{\mathbf{r}_{a b}^2+\eta^2}

\bar{c}_{a b}=\frac{c_a+c_b}{2}

\bar{\rho}_{a b}=\frac{\rho_a+\rho_b}{2}

参数：

c0(float) -参考音速
alpha(float) -产生剪切和体积粘度
beta(float) -用于处理高马赫数冲击
gx(float) -沿x轴方向每单位质量的体力
gy(float) -沿y轴方向每单位质量的体力
gz(float) -沿z轴方向每单位质量的体力
Tensilte_correction(tool) -拉伸不稳定性校正的开关（Default:False）

initialize( d_idx , d_au , d_av , d_aw , d_dt_cfl )

loop( d_idx , s_idx , d_rho , d_cs , d_p , d_au , d_av , d_aw , s_m , s_rho , s_cs , s_p , VIJ , XIJ , HIJ , R2IJ , RHOIJ1 , EPS , DWIJ , WIJ , WDP , d_dt )

post_loop( d_idx , d_au , d_av , d_aw , d_dt_force )

delta-SPH动量方程

class pysph.sph.wc.basic.MomentumEquationDeltaSPH(dest, sources, rho0, c0, alpha=1.0)

JOSEPHINE 和 delta-SPH 模型中定义的动量方程:

\frac{d u_i}{d t}=-\frac{1}{\rho_i} \sum_j\left(p_j+p_i\right) \nabla_i W_{i j} V_j+\mathbf{g}_i+\alpha h c_0 \rho_0 \sum_j \pi_{i j} \nabla_i W_{i j} V_j

其中：

\pi_{i j}=\frac{\mathbf{u}_{i j} \cdot \mathbf{r}_{i j}}{\left|\mathbf{r}_{i j}\right|^2}

参数：

rho0(float) -参考密度
c0(float) -参考音速
alpha(float) -用于控制速度扩散强度的系数

该动量方程中使用了人工粘度，并由参数控制。

loop（d_idx、s_idx、d_rho、d_cs、d_p、d_au、d_av、d_aw、s_m、s_rho、s_cs、s_p、VIJ、XIJ、HIJ、R2IJ、RHOIJ1、EPS、WIJ、DWIJ ）

压力梯度离散（使用数密度）

class pysph.sph.wc.basic.PressureGradientUsingNumberDensity(dest, sources)

Bases: pysph.sph.equation.Equation

\frac{d \boldsymbol{v}_a}{d t}=-\frac{1}{m_a} \sum_b\left(\frac{p_a}{V_a^2}+\frac{p_b}{V_b^2}\right) \nabla_a W_{a b}

参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称

initialize(d_idx, d_au, d_av, d_aw)

loop(d_idx, s_idx, d_m, d_rho, s_rho, d_au, d_av, d_aw, d_p, s_p, d_V, s_V, DWIJ)

泰特EOS（类水流体）

class pysph.sph.wc.basic.TaitEOS(dest, sources, rho0, c0, gamma, p0=0.0)

Bases: pysph.sph.equation.Equation 类水流体的tait状态方程：

p_a=\frac{c_0^2 \rho_0}{\gamma}\left(\left(\frac{\rho_a}{\rho_0}\right)^\gamma-1\right)

参数：

rho0(float) -流体粒子的参考密度
c0(float) -系统中预期的最大声速
gamma(float) -常量
po(float) -系统中的参考压力

参考声速c0应取值为系统中最大预期速度的10倍左右。粒子声速由通常的表达式给出：

c_a=\sqrt{\frac{\partial p}{\partial \rho}}

loop(d_idx, d_rho, d_p, d_cs)

泰特EOS（ Hughes and Graham矫正）

class pysph.sph.wc.basic.TaitEOSHGCorrection(dest, sources, rho0, c0, gamma)

Bases: pysph.sph.equation.Equation 带有休斯和格雷厄姆校正的tait状态方程:

p_a=\frac{c_0^2 \rho_0}{\gamma}\left(\left(\frac{\rho_a}{\rho_0}\right)^\gamma-1\right)

其中：

\rho_a= \begin{cases}\rho_a & \rho_a \geq \rho_0 \\ \rho_0 & \rho_a<\rho_0\end{cases}

参数：

rho0(float) -参考密度
c0(float) -参考音速
gamma(float) -常量

矫正将应用于边界粒子，并施加一个最小的密度值(rho0)，该值在实例化时被设置。这种修正可以避免粒子在墙壁上的粘附行为。

loop(d_idx, d_rho, d_p, d_cs)

更新光滑长度

classpysph.sph.wc.basic.UpdateSmoothingLengthFerrari(dest, sources, dim, hdx)

Bases: pysph.sph.equation.Equation

h_a=h d x\left(\frac{m_a}{\rho_a}\right)^{\frac{1}{d}}

参数：

dim(float) -维数
hdx(float) -比例因子

理想情况下，核函数的比例因子应该根据线性稳定性分析从所用的核函数中确定，默认值（hdx=1)。通常情况下，光滑长度的变化意味着重新计算临近粒子，在PySPH中意味着NNPS必须被更新。因此，这个方程应该作为最后一个方程，这样在最后的修正器阶段之后，光滑长度被更新，新的NNPS数据结构被计算出来。

loop( d_idx , d_rho , d_h , d_m )

黏度函数

Cleary人工粘度

class pysph.sph.wc.viscosity.ClearyArtificialViscosity(dest, sources, dim, alpha=1.0)

Bases: pysph.sph.equation.Equation P. Cleary 提出的人工粘度：

\mathcal{P} i_{a b}=-\frac{16}{\mu_a \mu_b} \rho_a \rho_b\left(\mu_a+\mu_b\right)\left(\frac{\boldsymbol{v}_{a b} \cdot \boldsymbol{r}_{a b}}{\boldsymbol{r}_{a b}^2+\epsilon}\right)

其中粘度是由参数决定：

\mu_a=\frac{1}{8} \alpha h_a c_a \rho_a

initialize( d_idx , d_au , d_av , d_aw )

loop（d_idx、s_idx、d_m、s_m、d_rho、s_rho、d_h、s_h、d_cs、s_cs、d_au、d_av、d_aw、XIJ、VIJ、R2IJ、EPS、DWIJ ）

class pysph.sph.wc.viscosity.LaminarViscosity(dest, sources, nu, eta=0.01)

class pysph.sph.wc.viscosity.LaminarViscosityDeltaSPH(dest, sources, dim, rho0, nu)

class pysph.sph.wc.viscosity.MonaghanSignalViscosityFluids(dest, sources, alpha, h)

传输速度公式

质量守恒方程

class pysph.sph.wc.transport_velocity.ContinuityEquation(dest, sources)

Bases: pysph.sph.equation.Equation

\frac{d \rho_a}{d t}=\rho_a \sum_b \frac{m_b}{\rho_b} \boldsymbol{v}_{a b} \cdot \nabla_a W_{a b}

参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称

initialize(d_idx, d_arho)

loop(d_idx, s_idx, d_arho, s_m, s_rho, d_rho, VIJ, DWIJ)

固体ghost粒子连续性方程

class pysph.sph.wc.transport_velocity.ContinuitySolid(dest, sources)

Bases: pysph.sph.equation.Equation 固体的ghost粒子的连续性方程。关键的区别在于使用了ghost速度ug，而不是速度u。参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称

loop(d_idx, s_idx, d_rho, d_u, d_v, d_w, d_arho, s_m, s_rho, s_ug, s_vg, s_wg, DWIJ)

人工应力对动量方程的贡献

class pysph.sph.wc.transport_velocity.MomentumEquationArtificialStress(dest, sources)

Bases: pysph.sph.equation.Equation

\frac{d \boldsymbol{v}_a}{d t}=\frac{1}{m_a} \sum_b\left(V_a^2+V_b^2\right)\left[\frac{1}{2}\left(\boldsymbol{A}_a+\boldsymbol{A}_b\right): \nabla_a W_{a b}\right]

其中人工应力项由下式给出：

\boldsymbol{A}=\rho \boldsymbol{v}(\tilde{\boldsymbol{v}}-\boldsymbol{v})

参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称

initialize(d_idx, d_au, d_av, d_aw)

loop(d_idx, s_idx, d_rho, d_u, d_v, d_w, d_V, d_uhat, d_vhat, d_what, d_au, d_av, d_aw, d_m, s_rho, s_u, s_v, s_w, s_V, s_uhat, s_vhat, s_what, DWIJ)

人工粘度对动量方程的贡献

class pysph.sph.wc.transport_velocity.MomentumEquationArtificialViscosity(dest, sources, c0, alpha=0.1)

Bases: pysph.sph.equation.Equation

\frac{d \boldsymbol{v}_a}{d t}=-\sum_b m_b \alpha h_{a b} c_{a b} \frac{\boldsymbol{v}_{a b} \cdot \boldsymbol{r}_{a b}}{\rho_{a b}\left(\left|r_{a b}\right|^2+\epsilon\right)} \nabla_a W_{a b}

其中：

\rho_{a b}=\frac{\rho_a+\rho_b}{2}

c_{a b}=\frac{c_a+c_b}{2}

h_{a b}=\frac{h_a+h_b}{2}

参数：

alpha(float) -常量
c0(float) -声速

initialize(d_idx, d_au, d_av, d_aw)

loop(d_idx, s_idx, s_m, d_au, d_av, d_aw, RHOIJ1, R2IJ, EPS, DWIJ, VIJ, XIJ, HIJ)

传输速度公式的动量方程：压力

class pysph.sph.wc.transport_velocity.MomentumEquationPressureGradient(dest, sources, pb, gx=0.0, gy=0.0, gz=0.0, tdamp=0.0)

Bases: pysph.sph.equation.Equation

\frac{d \boldsymbol{v}_a}{d t}=\frac{1}{m_a} \sum_b\left(V_a^2+V_b^2\right)\left[-\bar{p}_{a b} \nabla_a W_{a b}\right]

其中:

\bar{p}_{a b}=\frac{\rho_b p_a+\rho_a p_b}{\rho_a+\rho_b}

参数：

pb(float) -本底压强（background pressure）
gx(float) -沿x轴方向每单位质量的体力
gy(float) -沿y轴方向每单位质量的体力
gz(float) -沿z轴方向每单位质量的体力
tdamp(float) -阻尼时间

该方程的目的地（destination）应该是流体，源头（sources）应该是流体和边界粒子。该函数计算由于体力或者重力对本底压强（background pressure）和加速度的贡献。

initialize(d_idx, d_au, d_av, d_aw, d_auhat, d_avhat, d_awhat)

loop(d_idx, s_idx, d_m, d_rho, s_rho, d_au, d_av, d_aw, d_p, s_p, d_auhat, d_avhat, d_awhat, d_V, s_V, DWIJ)

post_loop(d_idx, d_au, d_av, d_aw, t)

传递速度公式的动量方程：黏度

class pysph.sph.wc.transport_velocity.MomentumEquationViscosity(dest, sources, nu)

Bases: pysph.sph.equation.Equation

\frac{d \boldsymbol{v}_a}{d t}=\frac{1}{m_a} \sum_b\left(V_a^2+V_b^2\right)\left[\bar{\eta}_{a b} \hat{r}_{a b} \cdot \nabla_a W_{a b} \frac{\boldsymbol{v}_{a b}}{\left|\boldsymbol{r}_{a b}\right|}\right]

其中：

\bar{\eta}_{a b}=\frac{2 \eta_a \eta_b}{\eta_a+\eta_b}

参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称
nu(float) -运动黏度

initialize(d_idx, d_au, d_av, d_aw)

loop(d_idx, s_idx, d_rho, s_rho, d_m, d_V, s_V, d_au, d_av, d_aw, R2IJ, EPS, DWIJ, VIJ, XIJ)

将流体速度推算到壁上

classpysph.sph.wc.transport_velocity.SetWallVelocity(dest, sources)

\tilde{\boldsymbol{v}}_a=\frac{\sum_b \boldsymbol{v}_b W_{a b}}{\sum_b W_{a b}}

这个方程的目标粒子阵列应该定义过滤后的速度变量uf,vf,wf 参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称

initialize(d_idx, d_uf, d_vf, d_wf, d_wij)

loop(d_idx, s_idx, d_uf, d_vf, d_wf, s_u, s_v, s_w, d_wij, WIJ)

post_loop(d_uf, d_vf, d_wf, d_wij, d_idx, d_ug, d_vg, d_wg, d_u, d_v, d_w)

固体壁边界条件

class pysph.sph.wc.transport_velocity.SolidWallNoSlipBC(dest, sources, nu)

Bases: pysph.sph.equation.Equation

该边界条件用于sph模拟中的固定ghost粒子，并针对移动边界的一般情况制定。
流体粒子的速度和压力被推算到ghost粒子上，这些值被用于运动方程中
无穿透（No-penetration）： ghost粒子与流体粒子一起参与了连续性和状态方程。这意味着当流体粒子接近墙壁时，ghost粒子的压力增加，产生排斥力，防止粒子穿透。
防滑（No-slip）：外推（Extrapolation）法用于设置粘性相互作用的ghost粒子的假（dummy）速度。首先，流体相的平滑速度场被外推到壁面（wall）粒子上。
```
\tilde{v}_a=\frac{\sum_b v_b W_{a b}}{\sum_b W_{a b}}
```
然后，对于方程中的粘性相互作用，ghost粒子的速度指定为：
```
v_b=2 v_w-\tilde{v}_a
```
其中：为规定的壁面速度，为相互作用的ghost粒子。

参数：

nu（float）-运动黏度

对于该方程，目标粒子数组应该是流体，源粒子应该是ghost或边界粒子，边界粒子必须定义一个规定的速度:

initialize(d_idx, d_au, d_av, d_aw)

loop(d_idx, s_idx, d_m, d_rho, s_rho, d_V, s_V, d_u, d_v, d_w, d_au, d_av, d_aw, s_ug, s_vg, s_wg, DWIJ, R2IJ, EPS, XIJ)

固体壁压力边界条件

class pysph.sph.wc.transport_velocity.SolidWallPressureBC(dest, sources, rho0, p0, b=1.0, gx=0.0, gy=0.0, gz=0.0)

Bases: pysph.sph.equation.Equation 压力边界条件： ghost粒子的压力通过以下插值从流体粒子中计算出来：

p_g=\frac{\sum_f p_f W_{g f}+\boldsymbol{g}-\boldsymbol{a}_g \cdot \sum_f \rho_f \boldsymbol{r}_{g f} W_{g f}}{\sum_f W_{g f}}

其中，下标g与f分别表示与ghost和流体粒子相关。

然后使用该压力设置壁颗粒的密度：

\rho_w=\rho_0\left(\frac{p_w-\mathcal{X}}{p_0}+1\right)^{\frac{1}{\gamma}}

参数：

rho0(float) -参考密度
p0(float) -参考压力
b(float) -常量（默认1.0）
gx(float) -沿x轴方向每单位质量的体力
gy(float) -沿y轴方向每单位质量的体力
gz(float) -沿z轴方向每单位质量的体力

对于两个流体系统（边界，流体），必须以边界为目标，流体为源来实例该方程。边界粒子数组必须另外定义一个属性为等式的分母。该数组对从ghost粒子到流体粒子的核函数项求和。

initialize(d_idx, d_p, d_wij)

loop(d_idx, s_idx, d_p, s_p, d_wij, s_rho, d_au, d_av, d_aw, WIJ, XIJ)

post_loop(d_idx, d_wij, d_p, d_rho)

广义弱可压缩状态方程

class pysph.sph.wc.transport_velocity.StateEquation(dest, sources, p0, rho0, b=1.0)

Bases: pysph.sph.equation.Equation

p_a=p_0\left[\left(\frac{\rho}{\rho_0}\right)^\gamma-b\right]+\mathcal{X}

该式为广义的tait状态方程，建议值为: 参考压力由人工声速和参考密度计算得出：

p_0=\frac{c^2 \rho_0}{\gamma}

参数：

p0(float) -参考压力
rho0(float) -参考密度
b(float) -常量（默认为1.0）

loop(d_idx, d_p, d_rho)

密度总和和数密度

class pysph.sph.wc.transport_velocity.SummationDensity(dest, sources)

Bases: pysph.sph.equation.Equation 除了标准的密度总和，粒子的数密度也被计算出来。数密度对于多相流来说非常重要，它可以定义一个独立于材料密度的局部颗粒体积。

\rho_a=\sum_b m_b W_{a b}

\mathcal{V}_a=\frac{1}{\sum_b W_{a b}}

注意，在pysph的实现中，V是粒子的反体积，即方程计算V如下：

\mathcal{V}_a=\sum_b W_{a b}

对于该方程，目标粒子数组必须为粒子体积定义变量V。参数：

dest(str) -目标粒子（destination particle）数组的名称
sources(list of str or None) -源粒子（source particle）数组的名称

initialize(d_idx, d_V, d_rho)

loop(d_idx, d_V, d_rho, d_m, WIJ)

使用质量密度设置反体积

class pysph.sph.wc.transport_velocity.VolumeFromMassDensity(dest, sources)

体积计算的数密度

class pysph.sph.wc.transport_velocity.VolumeSummation(dest, sources)

方程组(Group of equations)

class pysph.sph.equation.Group(equations, real=True, update_nnps=False, iterate=False, max_iterations=1, min_iterations=0, pre=None, post=None, condition=None, start_idx=0, stop_idx=None, name=None)

Bases: object 此类为方程式集合的代码生成提供了一些支持。参数：

equations(list) -方程对象的列表
real(bool) - 指定是否应该只对非remote/ghost粒子进行操作
update_nnps(bool) -指定是否应在此group之后在本地重新计算临近粒子
iterate(bool) -指定该组是否应该继续迭代，直到每个方程的 "converged() "方法返回一个正值。
max_iterations(int) -指定该组被迭代的最大次数
min_iterations(int) -指定该组被迭代的最小次数
pre(callable) -一个不传递的可调用对象，在执行group的任何内容之前被调用
post(callable) -一个不传递的可调用对象，在执行group完成之后被调用
condition(callable) - 一个被传递的可调用程序（t，dt）。如果这个可调用程序返回True，则该组被执行，否则不被执行。如果条件是None，该组总是被执行。请注意，即使该组有许多目标数组，这也应该起作用。
start_idx(int/str) - 从该索引处开始循环。如果传递了整数，从给定的数字开始。如果是字符串则找到第一个属性/常数，并使用第一个值作为循环计数。
stop_idx(int/str) - 循环到这个索引。默认为所有粒子。如果传递了整数，则以给定的数字结束。如果传递了一个字符串，则找到第一个属性/常数，并使用第一个值作为循环计数。(不包括最后一个值)
name(str) -传递的字符串用于命名信息csv文件中的group，使其易于阅读。如果没有传递字符串，则默认为 "Group "的名称。

积分器相关模块

这些类用于为来自sph_eval模块的实际积分器生成代码。

预测矫正积分器

class pysph.sph.integrator.EPECIntegrator(**kw)

Bases: pysph.sph.integrator.Integrator 预测器校正器积分器可以有两种操作模式: 在 Evaluate-Predict-Evaluate-Correct (EPEC) 模式下，系统通过以下方式进行改进:

F\left(y^n\right)-->\text { Evaluate } \\\begin{array}{r}
y^{n+\frac{1}{2}}=y^n+F\left(y^n\right)-->\text { Predict } \\
F\left(y^{n+\frac{1}{2}}\right)-->\text { Evaluate } \\
y^{n+1}=y^n+\Delta t F\left(y^{n+\frac{1}{2}}\right)-->\text { Correct }
\end{array}

积分器的 "评估 "阶段强制进行函数评估。因此，PEC模式的速度要快得多，但在预测阶段要依赖旧的加速器。在 EPEC 模式下，最终校正器可以修改为:

y^{n+1}=y^n+\frac{\Delta t}{2}\left(F\left(y^n\right)+F\left(y^{n+\frac{1}{2}}\right)\right)

传递流体名称和合适的 IntegratorStep实例添加到application。例如：

integrator = Integrator(fluid=WCSPHStep(), solid=WCSPHStep())

其中，fluid和solid是粒子数组的名称。

one_timestep(t, dt)

实际执行一个时间步长的用户编写的函数。

传递了t与dt
可以使用以下方法：
- self.initialize()
- self.stage1()、self.stage2() 等，具体取决于可用的阶段数。
- self.compute_accelerations(index=0, update_nnps=True)
- self.do_post_stage(stage_dt, stage_count_from_1)
- self.update_domain()

Euler积分器

class pysph.sph.integrator.EulerIntegrator(**kw)

同EPECIntegrator

积分器通用类

class pysph.sph.integrator.Integrator(**kw)

Bases: object

compute_accelerations( index=0 , update_nnps=True )
compute_h_minimum( )
compute_time_step( dt , cfl ) 如果有任何自适应时间步长约束，则返回适当的时间步长，否则返回None。
initial_acceleration( **kwargs ) 如果需要，则在迭代开始之前计算初始加速度。默认实现只对第一个加速度evaluator执行此操作。如果有多个评估器，则必须在子类中覆盖该方法。
one_timestep(t, dt)
set_acceleration_evals( a_evals ) 设置加速度evaluator计算器。在使用积分器之前完成。
set_compiled_object( c_integrator )
set_fixed_h(fixed_h)
set_nnps(nnps)
set_parallel_manager(pm)
set_post_stage_callback(callback) 当粒子被移动时，这个callback被调用，即一个阶段的整合已经完成。这个callback被传递给当前的时间值、时间步长和阶段。当前的时间值是t + stage_dt，例如，对于一个两阶段的预测器修正器积分器来说，这将是0.5*dt。
step(time, dt) 由求解器调用。
update_domain(**kwargs) 更新模拟的域(domain)。当粒子移动时被调用，用于重设ghost粒子（周期性，镜像边界条件）。此外，这也根据粒子核半径h重新计算适当的单元尺寸。当需要时，这应该被明确地调用，但通常是在粒子被移动或h被改变时进行。

跳蛙(leap-frog)积分器

class pysph.sph.integrator.LeapFrogIntegrator(**kw)

Bases: pysph.sph.integrator.PECIntegrator

预测评估矫正积分器

class pysph.sph.integrator.PECIntegrator(**kw)

Bases: pysph.sph.integrator.Integrator 在预测-评估-校正 (PEC) 模式下，系统通过以下方式进行改进：

\begin{array}{r}
y^{n+\frac{1}{2}}=y^n+\frac{\Delta t}{2} F\left(y^{n-\frac{1}{2}}\right)-->\text { Predict } \\
F\left(y^{n+\frac{1}{2}}\right)-->\text { Evaluate } \\
y^{n+1}=y^n+\Delta t F\left(y^{n+\frac{1}{2}}\right)
\end{array}

Forest-Ruth-Like 积分器

class pysph.sph.integrator.PEFRLIntegrator(**kw)

Bases: pysph.sph.integrator.Integrator

TVD-RK3积分器

class pysph.sph.integrator.TVDRK3Integrator(**kw)

Bases: pysph.sph.integrator.Integrator

在 TVD-RK3 积分器中，系统通过以下方式进行改进：

\begin{array}{r}
y^{n+\frac{1}{3}}=y^n+\Delta t F\left(y^n\right) \\
y^{n+\frac{2}{3}}=\frac{3}{4} y^n+\frac{1}{4}\left(y^{n+\frac{1}{3}}+\Delta t F\left(y^{n+\frac{1}{3}}\right)\right) \\
y^{n+1}=\frac{1}{3} y^n+\frac{2}{3}\left(y^{n+\frac{2}{3}}+\Delta t F\left(y^{n+\frac{2}{3}}\right)\right)
\end{array}

用于气体动力学的ADKE的预测器校正器积分器

class pysph.sph.integrator_step.ADKEStep

Verlet 时间积分

class pysph.sph.integrator_step.AdamiVerletStep

Bases: pysph.sph.integrator_step.IntegratorStep

快速但不准确的积分器，用于测试

class pysph.sph.integrator_step.EulerStep

Bases: pysph.sph.integrator_step.IntegratorStep

GSPH积分器

class pysph.sph.integrator_step.GSPHStep

Bases: pysph.sph.integrator_step.IntegratorStep

气体动力学的预测器校正器积分器

class pysph.sph.integrator_step.GasDFluidStep

Bases: pysph.sph.integrator_step.IntegratorStep

入口/出口粒子的简单积分器

class pysph.sph.integrator_step.InletOutletStep

Bases: pysph.sph.integrator_step.IntegratorStep

IntegratorStep

class pysph.sph.integrator_step.IntegratorStep

Bases: object 对其进行子类化，并实现initialize、stage1等方法。使用与方程相同的约定

LeapFrogStep(用于XSPH)

class pysph.sph.integrator_step.LeapFrogStep

base：pysph.sph.integrator_step.IntegratorStep

简单的一级刚体运动

class pysph.sph.integrator_step.OneStageRigidBodyStep

Bases: pysph.sph.integrator_step.IntegratorStep

PEFRLStep(用于XSPH)

class pysph.sph.integrator_step.PEFRLStep

base：pysph.sph.integrator_step.IntegratorStep

固体力学问题的预测器校正器积分器

class pysph.sph.integrator_step.SolidMechStep

Bases: pysph.sph.integrator_step.IntegratorStep

'传输速度公式'定义的积分器

class pysph.sph.integrator_step.TransportVelocityStep

Bases: pysph.sph.integrator_step.IntegratorStep

简单的二级刚体运动

class pysph.sph.integrator_step.TwoStageRigidBodyStep

Bases: pysph.sph.integrator_step.IntegratorStep 在积分器的每个阶段，规定的速度和加速度增加dt/2

WCSPH 公式的标准预测器校正器积分器

class pysph.sph.integrator_step.WCSPHStep

Bases: pysph.sph.integrator_step.IntegratorStep

用于 WCSPH 的 TVD RK3 步进器

class pysph.sph.integrator_step.WCSPHTVDRK3Step

Bases: pysph.sph.integrator_step.IntegratorStep

SPH核函数

三次样条函数

class pysph.base.kernels.CubicSpline(dim=1)

Bases: object 三次样条核函数：[Monaghan1992]

\begin{aligned}
W(q) &=\sigma_3\left[1-\frac{3}{2} q^2\left(1-\frac{q}{2}\right)\right] & & \text { for } 0 \leq q \leq 1 \\
&=\frac{\sigma_3}{4}(2-q)^3, & & \text { for } 1<q \leq 2, \\
&=0, & & \text { for } q>2
\end{aligned}

是三次样条函数的维度归一化因子，由下式给出：

\begin{aligned}
&\sigma_3=\frac{2}{3 h^1}, \quad \text { for } \operatorname{dim}=1\\
&\sigma_3=\frac{10}{7 \pi h^2}, \text { for } \operatorname{dim}=2 \text {, }\\
&\sigma_3=\frac{1}{\pi h^3}, \quad \text { for } \operatorname{dim}=3
\end{aligned}

dwdq(rij=1.0, h=1.0)

get_deltap()

gradient(xij=[0.0, 0, 0], rij=1.0, h=1.0, grad=[0, 0, 0])

gradient_h(xij=[0.0, 0, 0], rij=1.0, h=1.0)

kernel(xij=[0.0, 0, 0], rij=1.0, h=1.0)

Gaussian函数

class pysph.base.kernels.Gaussian(dim=2)

Bases: object 高斯核函数：[Liu2010]

\begin{aligned}
W(q) &=\sigma_g e^{-q^2}, & \text { for } 0 \leq q \leq 3 \\
&=0, & \text { for } q>3
\end{aligned}

是高斯函数的维度归一化因子，由下式给出：

\begin{aligned}
\sigma_g &=\frac{1}{\pi^{1 / 2} h}, \text { for } \operatorname{dim}=1 \\
\sigma_g &=\frac{1}{\pi h^2}, \quad \text { for } \operatorname{dim}=2 \\
\sigma_g &=\frac{1}{\pi^{3 / 2} h^3}, \text { for } \operatorname{dim}=3 .
\end{aligned}

五次样条函数

class pysph.base.kernels.QuinticSpline(dim=2)

Bases: object 五次样条核函数：[Liu2010]

\begin{aligned}
W(q) &=\sigma_5\left[(3-q)^5-6(2-q)^5+15(1-q)^5\right] & & \text { for } 0 \leq q \leq 1, \\
&=\sigma_5\left[(3-q)^5-6(2-q)^5\right], & & \text { for } 1<q \leq 2, \\
&=\sigma_5(3-q)^5, & & \text { for } 2<q \leq 3, \\
&=0, & & \text { for } q>3,
\end{aligned}

是五次样条函数的维度归一化因子，由下式给出：

\begin{aligned}
&\sigma_5=\frac{1}{120 h^1}, \quad \text { for } \operatorname{dim}=1 \\
&\sigma_5=\frac{7}{478 \pi h^2}, \text { for } \operatorname{dim}=2 \\
&\sigma_5=\frac{1}{120 \pi h^3}, \text { for dim }=3
\end{aligned}

Super Gaussian函数

class pysph.base.kernels.SuperGaussian(dim=2)

Bases: object 超级高斯核函数：[Monaghan1992]

\begin{aligned}
W(q) &=\frac{1}{h^d \pi^{d / 2}} e^{-q^2}\left(d / 2+1-q^2\right), & \text { for } 0 \leq q \leq 3 \\
&=0, & \text { for } q>3
\end{aligned}

WendlandQuintic函数-C2（二/三维）

class pysph.base.kernels.WendlandQuintic(dim=2)

Bases: object 用于二维和三维的 WendlandQuintic 核函数 (C2) 核函数：

\begin{aligned}
W(q) &\left.\left.=\alpha_d(1-q / 2)^4(2 q+1)\right)\right), & \text { for } 0 \leq q \leq 2 \\
&=0, &  \text { for } q>2
\end{aligned}

其中：

\begin{aligned}
&\alpha_d=\frac{7}{4 \pi h^2}, \text { for } \operatorname{dim}=2 \\
&\alpha_d=\frac{21}{16 \pi h^3}, \text { for } \operatorname{dim}=3
\end{aligned}

WendlandQuintic函数-C2（一维）

class pysph.base.kernels.WendlandQuinticC2_1D(dim=1)

Bases: object 一维的 WendlandQuintic 核函数 (Wendland C2) 核函数：

\begin{aligned}
W(q) &\left.\left.=\alpha_d(1-q / 2)^3(1.5 q+1)\right)\right), & \text { for } 0 \leq q \leq 2 \\
&=0, & \text { for } q>2
\end{aligned}

其中：

\alpha_d=\frac{5}{8 h}, \text { for } \operatorname{dim}=1

高性能包装内核

pysph.base.kernels.get_compiled_kernel(kernel)

给定一个内核，返回一个高性能包装内核。

NNPS模块(临近粒子搜索)

解决方案域(domain)的限制

class pysph.base.nnps_base.CPUDomainManager(double xmin=-1000, double xmax=1000, double ymin=0, double ymax=0, double zmin=0, double zmax=0, periodic_in_x=False, periodic_in_y=False, periodic_in_z=False, double n_layers=2.0, backend=None, props=None, mirror_in_x=False, mirror_in_y=False, mirror_in_z=False)

Bases: pysph.base.nnps_base.DomainManagerBase 该类决定解决方案域的限制。令模拟有明确的域限制，超过范围的解决方案从一开始就失效。因此，如果一个粒子离开域，解决方案应该被认为是无效的（至少是局部的）。初始域的限制可以明确地给出，或者要求从粒子阵列中计算出来。该域可以是周期性的。

box-sort NNPS

class pysph.base.nnps_base.Cell(IntPoint cid, double cell_size, int narrays, int layers=2)

Bases: object

对于基于box-sort算法的空间索引，该类定义了用于保存该单元内的粒子索引（局部和全局）的空间数据结构。参数：

cid (IntPoint) - 单元的空间指数（非扁平化的）
cell_size (double) - 单元在每个维度上的空间范围
narrays (int) - 被分层的数组数
layers (int) - 计算边界盒的因素

链表方法NNPS

classpysph.base.linked_list_nnps.LinkedListNNPS(int dim, list particles, double radius_scale=2.0, int ghost_layers=1, domain=None, bool fixed_h=False, bool cache=False, bool sort_gids=False)

Bases: pysph.base.nnps_base.NNPS 参数：

dim(int) -维数
particles (list) -正在处理的粒子数组列表
adius_scale (double, default (2)) -可选的核函数半径比例，默认为2
ghost_layers (int) -可选的并行共享层数
domain (DomainManager, default (None)) -域的可选限制
fixed_h (bint) -恒定单元大小的可选标志
cache (bint) -缓存，会消耗存储空间但会加快临近粒子计算
sort_gids (bint, default (False)) -排序临近粒子时使用gids作为标志

可扩展空间哈希NNPS

class pysph.base.spatial_hash_nnps.ExtendedSpatialHashNNPS(int dim, list particles, double radius_scale=2.0, int H=3, int ghost_layers=1, domain=None, bool fixed_h=False, bool cache=False, bool sort_gids=False, long long table_size=131072, bool approximate=False)

Bases: pysph.base.nnps_base.NNPS

粒子数组模块

ParticleArray表示粒子的集合

ParticleArray

class pysph.base.particle_array.ParticleArray(unicode name=u'', default_particle_tag=Local, constants=None, backend=None, **props)

Bases: object 表示粒子数组的类参数：

name -粒子数组的名称
properties -{prop_name:carray}的字典
constants -{const_name: carray}的字典

创建粒子数组的例子：

>>> p = ParticleArray(name='fluid', x=[1.,2., 3., 4.])
>>> p.name
'fluid'
>>> p.x, p.tag, p.pid, p.gid

有关属性及其类型等的完整规范：

>>> p = ParticleArray(name='fluid',
...                   x=dict(data=[1,2], type='int', default=1))
>>> p.get_carray('x').get_c_type()
'int'

参数：

name (str) -粒子数组的名称
default_particle_tag (int) -Local、Remote或Ghost之一
constants (dict) -整个粒子数组的常量数组字典。必须为数组并且在添加或删除粒子时不会调整大小。
props- 任何额外的关键字参数都被认为是属性，每个属性一个。

向数组添加常量属性

add_constant(self, unicode name, data)

向粒子数组添加一个常量属性。常量属性是一个数组，但具有固定的大小，且永远不会随着粒子的添加或删除而改变大小。参数：

name(str) -常量的名称
data(array-like) -数据的值

向输出数组附加属性

add_output_arrays(self, list props)

将属性附加到现有的输出数组列表中. 参数：

props(list) -要保存的额外属性数组列表

将particle_array中的粒子添加到self

add_particles(self, align=True, **particle_props)

参数：

particle_props (dict) -包含各种粒子属性的numpy数组的字典

注意：

所有属性都应具有相同长度的数组
所有属性都应该已经存在于这个粒子数组之中

向粒子数组添加一个新属性

add_property(self, unicode name, unicode type=u'double', default=None, data=None, stride=1)

如果default未设置则默认为0。当每个粒子需要很多元素的时候，需要用到stride(步长)。例如，如果stride是3，那么每个粒子将被分配3个元素。参数：

name(str) -属性的名称
type(str) -指定此属性的数据类型('double''int'等)
default(value) -指定此属性的默认值
data(ndarray) -指定与每个粒子相关的数据
stride(int) 每个粒子的元素数

注意：

如果粒子数组中当前没有粒子，并且添加了具有一些粒子的新属性，则所有剩余属性将调整为新添加数组的大小
如果粒子数组中有一些粒子，并且添加了一个没有任何粒子的新属性，那么这个新属性将根据当前大小调整大小
如果粒子阵列中有一些粒子，并且添加了具有不同数量粒子的新属性，则会引发错误

移动'Local'粒子到数组开头

align_particles(self) → int

从粒子数组中添加粒子

append_parray(self, ParticleArray parray, bool align=True, bool update_constants=False) → int

将数据从一组复制到另一组

copy_over_properties(self, dict props)

例子：将属性'x'和'y'保存为'x0'和'y0'：

>>> pa.copy_over_properties(props = {'x':'x0', 'y':'y0'}

将属性从源复制到自身

copy_properties(self, ParticleArray source, long start_index=-1, long end_index=-1)

参数：

source(ParticleArray) -从中复制的粒子数组
start_index (long) -self中的第一个粒子，映射到source中的第0个粒子
end_index(long) -start_index中未复制的第一个粒子的索引

确保粒子数组具有与给定相同的属性

ensure_properties(self, ParticleArray src, list props=None)

向粒子总数增加请求的数量

extend(self, int num_particles)

向粒子总数增加请求的数量。新粒子被添加到列表的末尾。需要在后面调用align_particles才能更新粒子数。

创建新的粒子数组

extract_particles(self, indices, ParticleArray dest_array=None, bool align=True, list props=None) → ParticleArray

为 index_array 中索引的粒子创建新的粒子数组参数:

indices (list/array/LongArray) -要提取的粒子的索引。
dest_array (ParticleArray) -可选的要填充的粒子数组。注意，这个数组应该有必要的属性。如果没有传递，则会创建一个新的粒子数组并返回
align (bool) - 指定目标粒子阵列是否要在提取粒子后进行对齐。
props (list) - 要提取的属性列表，如果没有，则提取所有属性。

执行过程如下：

创建一个新的粒子数组(具有所需属性)
将新数组的大小调整为所需的长度（index_array.length）
将现有数组中的属性复制到新数组

返回numpy数组/常量

get( self , *args , only_real_particles=True )

返回参数中属性名称的 numpy 数组/常量。参数：

only_real_particles (bool) -指示是否只需要真实粒子的属性，默认情况下，只会返回真实的粒子
*args -附加参数

get_carray( self , unicode prop ) → BaseArray

get_lb_props(self)

返回粒子数

get_number_of_particles(self, bool real=False) → int

返回由ParticleArray容器保存的数组字典

get_property_arrays(self, all=True, only_real=True)

不包括常量。返回的字典以属性名称为键，值为表示数据的Numpy数组。如果all设置为False，则数组列表由output_property_arrays属性确定。

remove_particles(self, indices, align=True)

remove_property(self, unicode prop_name)

remove_tagged_particles( self , int tag , bool align=True )

set(self, **props)

从 numpy 数组（如对象）设置属性

set_name(self, unicode name)

set_num_real_particles(self, long value)

set_output_arrays(self, list props)

set_pid(self, int pid)

set_tag(self, long tag_value, LongArray indices)

创建粒子阵列的便捷函数

有几个方便的函数可以为粒子阵列提供一组必要的粒子属性，如下所述:

创建一个与内置范围相同的 LongArray

pysph.base.utils.arange_long(start, stop=-1)

返回粒子列表的副本

pysph.base.utils.create_dummy_particles(info)

创建并返回具有默认属性的粒子数组

pysph.base.utils.get_particle_array(additional_props=None, constants=None, backend=None, **props)

创建并返回具有默认属性的粒子数组默认属性为： [‘x’, ‘y’, ‘z’, ‘u’, ‘v’, ‘w’, ‘m’, ‘h’, ‘rho’, ‘p’, ‘au’, ‘av’, ‘aw’, ‘gid’, ‘pid’, ‘tag’] 这个集合在 DEFAULT_PROPS中可用参数：

additional_props (list) -添加的属性
constants (dict) -要添加到粒子数组的任何常量

例子：

>>> x = linspace(0,1,10)
>>> pa = get_particle_array(name='fluid', x=x)
>>> pa.properties.keys()
['x', 'z', 'rho', 'pid', 'v', 'tag', 'm', 'p', 'gid', 'au',
 'aw', 'av', 'y', 'u', 'w', 'h']
>>> pa1 = get_particle_array(name='fluid', additional_props=['xx', 'yy'])

>>> pa = get_particle_array(name='fluid', x=x, constants={'alpha': 1.0})
>>> pa.constants.keys()
['alpha']

返回气体动力学问题的粒子数组

pysph.base.utils.get_particle_array_gasd(constants=None, **props)

获取 IISPH 公式的粒子阵列

pysph.base.utils.get_particle_array_iisph(constants=None, **props)

默认属性为： ['x', 'y', 'z', 'u', 'v', 'w', 'm', 'h', 'rho', 'p', 'au', 'av', 'aw', 'gid', 'pid', 'tag' 'uadv', 'vadv', 'wadv', 'rho_adv', 'au', 'av', 'aw','ax', 'ay', 'az', 'dii0', 'dii1', 'dii2', 'V', 'aii', 'dijpj0', 'dijpj1', 'dijpj2', 'p', 'p0', 'piter', 'compression' ]

刚体运动的粒子数组

pysph.base.utils.get_particle_array_rigid_body(constants=None, **props)

对于多个物体，添加一个从索引 0 开始的 body_id 属性，每个索引表示粒子对应的物体。

shallow water 粒子数组

pysph.base.utils.get_particle_array_swe(constants=None, **props)

默认属性为： ['x', 'y', 'z', 'u', 'v', 'w', 'h', 'rho', 'arho' 'm', 'p', 'V', 'A', 'cs', 'n', 'rho0', 'rho_prev_iter', 'rho_residual', 'positive_rho_residual', 'summation_rho', 'dw', 'alpha', 'exp_lambda', 'tv', 'tu', 'au', 'av', 'u_prev_step', 'v_prev_step', 'uh', 'vh', 'dt_cfl', 'pa_to_split', 'Sfx', 'Sfy', 'psi', 'sum_Ak', 'u_parent', 'v_parent', 'uh_parent', 'vh_parent', 'parent_idx', 'b', 'bx', 'by', 'bxx', 'bxy', byy', 'closest_idx', 'is_merged_pa', 'merge', 'dw_inner_reimann', 'u_inner_reimann', 'v_inner_reimann', 'shep_corr', 'is_wall_boun_pa', 'dw_at_t', 'pa_out_of_domain', 'ob_pa_to_remove', 'ob_pa_to_tag', 'pa_alpha_zero', 'fluid_pa_to_remove']

流体的TVF公式的粒子数组

pysph.base.utils.get_particle_array_tvf_fluid(constants=None, **props)

固体的TVF公式的粒子数组

pysph.base.utils.get_particle_array_tvf_solid(constants=None, **props)

WCSPH 公式的粒子数组

pysph.base.utils.get_particle_array_wcsph(constants=None, **props)

默认属性设置为： ['x', 'y', 'z', 'u', 'v', 'w', 'h', 'rho', 'm', 'p', 'cs', 'ax', 'ay', 'az', 'au', 'av', 'aw', 'x0','y0', 'z0','u0', 'v0','w0', 'arho', 'rho0', 'div', 'gid','pid', 'tag']

返回粒子列表的数组信息

pysph.base.utils.get_particles_info(particles)

返回粒子列表的数组信息。返回：

一个 OrderedDict 包含一个列表的属性信息
粒子。例如，此 dict 可用于设置 dummy/empty
粒子数组

Module scheme （模块方案）

用于定义 SPH 方案的 API 的抽象类。这个想法是，一个人可以定义一个方案，然后简单地实例化一个合适的方案，给它一堆粒子并运行应用程序。

ADKEScheme

class pysph.sph.scheme.ADKEScheme(fluids, solids, dim, gamma=1.4, alpha=1.0, beta=2.0, k=1.0, eps=0.0, g1=0, g2=0, has_ghosts=False)

Bases: pysph.sph.scheme.Scheme 参数：

fluids(list) -包含流体粒子数组名称的列表
solids(list) - 包含固体（或边界）粒子数组的列表
dim(int) -维数
gamma(doule) -状态方程的Gamma
alpha (double) -人工粘度系数
beta (double) -人工粘度系数
k (double) -核函数缩放参数
eps (double) -核函数缩放参数
g1 (double) -人工热传导参数
g2 (double) -人工热传导参数
has_ghosts (bool)-如果问题使用ghost粒子（周期性或镜像）

求解器配置

configure_solver(kernel=None, integrator_cls=None, extra_steppers=None, **kw)

参数：

kernel (Kernel instance.) -要使用的核函数，如果none，则使用默认核函数。
integrator_cls (pysph.sph.integrator.Integrator)-要使用的积分器类，如果none，则使用合理的默认值。
extra_steppers (dict) -额外的积分器步进器实例，作为一个字典
**kw (extra arguments) -任何额外的关键字参数都会被传递给求解器实例

get_equations()

设置粒子数组

setup_properties(particles, clean=True)

设置粒子数组，使它们具有该方案的正确属性集参数：

particles (list) -粒子数组的列表
clean (bool)- 如果是True，则删除不必要的属性

GSPHScheme

classpysph.sph.scheme.GSPHScheme(fluids, solids, dim, gamma, kernel_factor, g1=0.0, g2=0.0, rsolver=2, interpolation=1, monotonicity=1, interface_zero=True, hybrid=False, blend_alpha=5.0, tf=1.0, niter=20, tol=1e-06, has_ghosts=False)

Bases: pysph.sph.scheme.Scheme 参数：

fluids(list) -包含流体粒子数组名称的列表
solids(list) - 包含固体（或边界）粒子数组的列表
dim(int) -维数
gamma(doule) -状态方程的Gamma
kernel_factor(float) -核函数比例因子
g2(g1,) -ADKE的热传导参数
rsolver(int) -要使用的黎曼求解器
interpolation (int) -特定体积积分的插值类型
monotonicity (int) -要使用的单调性算法类型：0：一阶 GSPH 1：I02 算法 2：IwIn 算法
interface_zero (bool) -为黎曼问题设置界面位置 s^*_{ij} = 0
blend_alpha (hybrid,) -混合方案和混合 alpha 值
tf (double) -用于混合的最终时间
niter (int) -迭代黎曼求解器的最大迭代次数
tol (double) -迭代黎曼求解器的容差
has_ghosts (bool)-如果问题使用ghost粒子（周期性或镜像）

SPH Scheme

class pysph.sph.scheme.Scheme(fluids, solids, dim)

Bases: object SPH方案的API: 参数：

fluids(list) -包含流体粒子数组名称的列表
solids(list) - 包含固体（或边界）粒子数组的列表
dim(int) -维数

add_user_options(group)

attributes_changed()

重载以计算任何依赖于其他属性的属性。调用configure的时候会自动调用。

configure(**kw)

使用给定的参数配置方案。重载以执行任何特定于方案的事情

configure_solver(kernel=None, integrator_cls=None, extra_steppers=None, **kw)

配置要生成的求解器

consume_user_options(options)

get_equations()

get_solver()

setup_properties(particles, clean=True)

设置粒子数组，使它们具有该方案的正确属性集。

SchemeChooser

classpysph.sph.scheme.SchemeChooser(default, **schemes)

TVFScheme

class pysph.sph.scheme.TVFScheme(fluids, solids, dim, rho0, c0, nu, p0, pb, h0, gx=0.0, gy=0.0, gz=0.0, alpha=0.0, tdamp=0.0)

WCSPHScheme

class pysph.sph.scheme.WCSPHScheme(fluids, solids, dim, rho0, c0, h0, hdx, gamma=7.0, gx=0.0, gy=0.0, gz=0.0, alpha=0.1, beta=0.0, delta=0.1, nu=0.0, tensile_correction=False, hg_correction=False, update_h=False, delta_sph=False, summation_density=False)

参数：

fluids(list) -包含流体粒子数组名称的列表
solids(list) - 包含固体（或边界）粒子数组的列表
dim(int) -维数
rho0(float) -参考密度
c0(float) -参考声速
gamma(doule) -状态方程的Gamma
h0 (float) -参考光滑长度
hdx (float) -h/dx 的比率
gy, gz (gx,) -体力加速度分量
alpha (double) -人工粘度系数
beta (double) -人工粘度系数
delta (float) -用于控制密度扩散强度的系数
nu (float) -流体的真实粘度，默认为无粘度
tension_correction (bool) -使用拉伸校正
hg_correction (bool) -使用Hughes-Graham校正
update_h (bool) -根据 Ferrari 等人更新平滑长度
delta_sph (bool) -使用 delta-SPH 校正项
summation_density (bool) - 使用求和密度法而不是连续性密度法。

模块求解器(Module solver)

PySPH 求解器的基类

class pysph.solver.solver.Solver(dim=2, integrator=None, kernel=None, n_damp=0, tf=1.0, dt=0.001, adaptive_timestep=False, cfl=0.3, output_at_times=(), fixed_h=False, **kwargs)

参数：

dim(int) -维数
integrator (pysph.sph.integrator.Integrator) -要使用的积分器
kernel (pysph.base.kernels.Kernel) -要使用的SPH核函数
n_damp (int) -需要初始阻尼的时间步数。这是用来提高初始条件强烈不连续的问题的稳定性。将其设置为零将禁用时间步数的阻尼。
dt(double) -初始时间步长
tf(double) -积分的最后时间
adaptive_timestep (bint) -使用自适应时间步长的标志
cfl (double)- 自适应时间步进的CFL(收敛条件判断)数
pfreq (int) -输出文件转储频率。
output_at_times (list/array) -可选的输出时间列表以强制转储输出文件。
fixed_h (bint) -固定光滑长度h的标志
reorder_freq (int) - 粒子应该重新排序的迭代次数

例子：

>>> integrator = PECIntegrator(fluid=WCSPHStep())
>>> kernel = CubicSpline(dim=2)
>>> solver = Solver(dim=2, integrator=integrator, kernel=kernel,
...                 n_damp=50, tf=1.0, dt=1e-3, adaptive_timestep=True,
...                 pfreq=100, cfl=0.5, output_at_times=[1e-1, 1.0])

post_stage回调（callback）

add_post_stage_callback(callback)

这些回调在每个积分器阶段（stage）之后被调用。回调被传递（current_time、dt、stage）例子：

>>> def post_stage_callback_function(t, dt, stage):
>>>     # This function is called after every stage of integrator.
>>>     print(t, dt, stage)
>>>     # Do something
>>> solver.add_post_stage_callback(post_stage_callback_function)

post_step回调(callback)

add_post_step_callback(callback)

在执行每个时间步之前调用这些回调。回调传递给求解器实例（即自身）例子：

>>> def pre_step_callback_function(solver):
>>>     # This function is called before every time step.
>>>     print(solver.t, solver.dt)
>>>     # Do something
>>> solver.add_pre_step_callback(pre_step_callback_function)

pre_step回调(callback)

add_pre_step_callback(callback)

在执行每个时间步之前调用这些回调。回调传递给求解器实例例子：

>>> def pre_step_callback_function(solver):
>>>     # This function is called before every time step.
>>>     print(solver.t, solver.dt)
>>>     # Do something
>>> solver.add_pre_step_callback(pre_step_callback_function)

添加粒子数组

append_particle_arrrays(arrays)

模拟结果转储到文件

dump_output(**kwargs)

用于打印的数组由粒子数组的output_property_arrays数据属性决定。为了调试，保存所有数组（包括加速度）有时会很好。这可以通过使用命令行选项–detailed-output来选择输出数据格式：单个文件命名为：<fname>_<rank>_<iteration_count>.npz 数据保存为具有两个键的 Python 字典： solver_data : 求解元数据，如时间、dt 和迭代次数 arrays:以粒子数组名称为键的字典，并带有粒子属性作为值。

例子：

>>> from pysph.solver.utils import load
>>> data = load('output_directory/filename_x_xxx.npz')
>>> solver_data = data['solver_data']
>>> arrays = data['arrays']
>>> fluid = arrays['fluid']
>>> ...

get_options(arg_parser)

从输出文件中加载粒子数据

load_output(count)

参数： -count(str) -加载数据的迭代时间。如果时间是'？然后返回可用数据文件的列表，否则使用最新的可用数据文件

数据从output_directory加载，使用与dump_output()方法存储的相同格式。正常运行需要转储数组的所有相关属性。

重新排序粒子

reorder_particles(**kwargs)

设置自适应时间步长

set_adaptive_timestep(value)

将其设置为 True 以使用基于 cfl、粘性和力因子的自适应时间步长

打印具有给定名称的数组

set_arrays_to_print(array_names=None)

set_cfl(value)

设置可调用程序

set_command_handler(callable, command_interval=1)

设置可调用程序，以便在每个命令_时间间隔的迭代中被调用。以求解器实例为参数调用该可调用程序

set_compress_output(compress)

set_disable_output(value)

set_final_time(tf)

set_max_steps(max_steps)

set_n_damp(ndamp)

设置初始阻尼的时间步数

set_output_at_times(output_at_times)

set_output_directory(path)

set_output_fname(fname)

set_output_only_real(output_only_real)

set_output_printing_level(detailed_output)

set_parallel_output_mode(mode='collected')

set_print_freq(n)

set_reorder_freq(freq)

set_time_step(dt)

设置求解器

setup(particles, equations, nnps, kernel=None, fixed_h=False)

如果 in_parallel 标志设置为 true，则设置求解器的处理器 ID。积分计算的顺序由求解器的 order 属性确定。这通常在 PySPH 模拟开始时调用。

setup_solver(options=None)

在此处实现基本求解器参数：

options(dict) -用户使用命令行设置的选项

solve(show_progress=True)

solve the system

模块求解器工具

重新初始化流体粒子密度

class pysph.solver.tools.DensityCorrection(app, arr_names, corr='shepard', freq=10, kernel=None)

Bases: pysph.solver.tools.Tool 参数：

app(pysph.solver.application.Application.) -应用程序实例
arr_names (array) -密度需要重新初始化的粒子数组的名称
corr (str) -密度重新初始化操作(operation)的名称。corr='shepard' 用于使用零阶 shepard 滤波器
freq (int) -重新初始化的频率
kernel (any kernel from pysph.base.kernels) -核函数

post_step(solver) 如果重载，则会在每个积分器步骤后自动调用。该方法被传递给求解器实例。

SimpleRemesher

class pysph.solver.tools.SimpleRemesher(app, array_name, props, freq=100, xi=None, yi=None, zi=None, kernel=None, equations=None)

Bases: pysph.solver.tools.Tool 一个简单的工具，用于定期将给定的粒子阵列重新网格化到一组初始点上。参数：

app(pysph.solver.application.Application.) -应用程序实例
array_name(str) -需要重新划分网格的粒子数组的名称
props (list(str)) -要插入的属性列表。
freq (int) -重新划分网格操作的频率
yi, zi (xi,) -重新网格化属性的位置。如果未指定，则它们是在构建时从粒子阵列中获取的
kernel (any kernel from pysph.base.kernels) -核函数
equations (list or None) -用于插值的方程，传递给插值器

post_step(solver) 如果重载，则会在每个积分器步骤后自动调用。该方法被传递给求解器实例。

SPH Tool

class pysph.solver.tools.Tool

Bases: object 工具通常是一个对象，可用于在求解器的 pre_step/post_step 或 post_stage 回调上执行特定任务。这可以用于各种事情。例如，可以保存绘图、打印调试统计信息或执行重新划分网格等。

要创建一个新工具，只需子类化该类并重载其所需的任何方法

post_stage(current_time, dt, stage) 如果重载，则在每个积分器级之后自动调用，即如果积分器是两级积分器，它将在第一级和第二级之后调用 post_step(solver) 如果重载，则会在每个积分器步骤后自动调用。该方法被传递给求解器实例。 pre_step(solver) 如果重载，则会在每个积分器步骤之前自动调用它。该方法被传递给求解器实例。

模块边界条件

复制法线和距离到ghost

class pysph.sph.bc.inlet_outlet_manager.CopyNormalsandDistances(dest, sources)

Bases: pysph.sph.equation.Equation 将出口/入口粒子的法线和距离复制到ghost 参数：

dest (str) -目标粒子数组的名称
sources (list of str or None) -源粒子数组的名称

initialize_pair(d_idx, d_xn, d_yn, d_zn, s_xn, s_yn, s_zn, d_disp, s_disp)

计算粒子的ioid

class pysph.sph.bc.inlet_outlet_manager.IOEvaluate(dest, sources, x, y, z, xn, yn, zn, maxdist=1000.0)

Bases: pysph.sph.equation.Equation 计算粒子的ioid: 0：粒子在流体中 1：粒子在入口/出口内 2：粒子在入口/出口外参数：

dest(str) -目标粒子数组名称
sources(list) -源粒子数组名称
x(float) -界面点的x坐标
y(float) -界面点的y坐标
z(float) -界面点的z坐标
xn(float) -接口向外法线的x分量
yn(float) -接口向外法线的y分量
zn(float) -接口向外法线的z分量
maxdist(float) -入口/出口的最大长度

`initialize(d_ioid, d_idx)` `loop(d_idx, d_x, d_y, d_z, d_ioid, d_disp)`

入口API

class pysph.sph.bc.inlet_outlet_manager.InletBase(inlet_pa, dest_pa, inletinfo, kernel, dim, active_stages=[1], callback=None, ghost_pa=None)

Bases: object 在入口-流体移动时添加/删除粒子的 API 参数：

inlet_pa (particle_array) -入口的粒子数组
dest_pa (particle_array) -流体的粒子数组
inletinfo (InletInfo instance) - 入口信息
kernel (Kernel instance) -核函数
dim (int) -维度
active_stages (list) -更新应该处于活动状态的积分器阶段
callback (function) -更新函数后的回调函数
ghost_pa (particle_array) -ghost_inlet的粒子数组

initialize() 在 SimpleInletOutlet 类中评估后初始化类变量的函数 update(time, dt, stage) 每个阶段后调用的更新函数

创建带有入口信息的对象

class pysph.sph.bc.inlet_outlet_manager.InletInfo(pa_name, normal, refpoint, has_ghost=True, update_cls=None, equations=None, umax=1.0, props_to_copy=None)

Bases: object 创建带有入口信息的对象，所有其他没有在这里传递的参数在入口被创建后由InletOutletManager评估。

参数：

pa_name (str) -inlet的名称
normal (list) -normal(float) 的组件
refpoint (list) -指向流体入口接口 (float)
has_ghost (bool) -如果为True，则会创建ghost粒子
update_cls (class_name)-用于更新入口/出口的类
equations (list) -方程列表（可选）
props_to_copy (array) -要复制的属性

管理入口出口边界条件

class pysph.sph.bc.inlet_outlet_manager.InletOutletManager(fluid_arrays, inletinfo, outletinfo, extraeqns=None)

Bases: object 创建对象来管理入口出口的边界条件。大多数变量是在方案和粒子创建后进行评估的。参数：

fluid_arrays (list) -流体粒子数组名称列表
inletinfo (list)-入口列表
outletinfo (list)-出口列表
extraeqns (dict)-自定义方程的列表

add_io_properties(pa, scheme=None) 添加要在入口/出口方程中使用的属性参数：

pa (particle_array) -入口/出口的粒子数组
scheme (pysph.sph.scheme) -scheme class的实例

create_ghost(pa_arr, inlet=True) 为给定的入口/出口粒子创建ghost 参数：

pa_arr (Particle array) -需要ghost的粒子数组
inlet (bool) -如果为True，入口信息将用于ghost

get_equations(scheme, **kw) 返回入口/出口的方程参数：

scheme (pysph.sph.scheme)-方案类的实例
**kw (extra arguments) -额外参数取决于使用的方案

get_equations_post_compute_acceleration() 返回用于后加速计算的入口/出口方程

get_inlet_outlet(particle_array) 返回Inlet和Outlet实例的列表,执行入口粒子到出口粒子的变化。参数：

particle_array (list) -所有particle_array的列表

get_io_names(ghost=False) 返回所有入口和出口的名称 : 参数：

ghost(bool)-如果为真，也返回 ghost 的名称

get_stepper(scheme, integrator, **kw) 返回入口/出口的步进器参数：

scheme (pysph.sph.scheme) -方案类的实例
intergrator (pysph.sph.integrator) -积分器的父类
**kw (extra arguments) -额外参数取决于使用的方案

setup_iom(dim, kernel) 被传递的基本数据参数：

dim(int) -维数
kernel (pysph.base.kernel) -核函数实例

update_dx(dx) 更新离散化长度参数：

dx (float) -维数

InletStep

class pysph.sph.bc.inlet_outlet_manager.InletStep

Bases: pysph.sph.integrator_step.IntegratorStep initialize(d_x0, d_idx, d_x) stage1(d_idx, d_x, d_x0, d_u, dt) stage2(d_idx, d_x, d_x0, d_u, dt)

出口API

class pysph.sph.bc.inlet_outlet_manager.OutletBase(outlet_pa, source_pa, outletinfo, kernel, dim, active_stages=[1], callback=None, ghost_pa=None)

Bases: object 在出口-流体移动时添加/删除粒子的 API 参数：

outlet_pa (particle_array) -出口的粒子数组
source_pa (particle_array) -流体的粒子数组
outletinfo (OutletInfo instance) - 出口信息
kernel (Kernel instance) -核函数
dim (int) -维度
active_stages (list) -更新应该处于活动状态的积分器阶段
callback (function) -更新函数后的回调函数
ghost_pa (particle_array) -ghost_outlet的粒子数组

initialize() 在 SimpleInletOutlet 类中评估后初始化类变量的函数 update(time, dt, stage) 每个阶段后调用的更新函数

创建带有入口信息的对象

class pysph.sph.bc.inlet_outlet_manager.OutletInfo(pa_name, normal, refpoint, has_ghost=False, update_cls=None, equations=None, umax=1.0, props_to_copy=None)

OutletStep

class pysph.sph.bc.inlet_outlet_manager.OutletStep

更新入口/出口粒子与界面的法线和垂直距离

class pysph.sph.bc.inlet_outlet_manager.UpdateNormalsAndDisplacements(dest, sources, xn, yn, zn, xo, yo, zo)

模块求解器_interfaces

命令行界面

class pysph.solver.solver_interfaces.CommandlineInterface

Bases: object 求解器控制器的命令行界面

PySPH的其他工具

数据文件的输入输出

转储数据

pysph.solver.utils.dump(filename, particles, solver_data, detailed_output=False, only_real=True, mpi_comm=None, compress=False)

将给定的粒子和求解器数据转储到给定的文件名。参数：

filename (str) -要转储的文件名
particles (sequence(ParticleArray)) -要转储的粒子数组
solver_data (dict) -转储有关求解器状态的附加信息
detailed_output (bool) -指定是否应转储所有数组
only_real (bool) -只转储真实的粒子
mpi_comm (mpi4pi.MPI.Intracomm) -用于并行通信的 MPI 通信器
compress (bool) -指定文件是否要压缩
mpi_comm(bool) -如果没有被传递或设置为False，则本地粒子单独转储，否则只有等级0转储输出

获取给定目录名中所有解决方案

pysph.solver.utils.get_files(dirname=None, fname=None, endswith=('hdf5', 'npz'))

获取给定目录目录名中的所有解决方案文件参数：

dirname(str) -目录的名称
fname(str) -文件名的初始部分，如果未指定，则使用目录名的第一部分
endswith(str) -要加载的文件的扩展名

加载输出数据

pysph.solver.utils.load(fname)

参数：

fname(str) -文件名或完整路径

例子：

>>> data = load('elliptical_drop_100.npz')
>>> data.keys()
['arrays', 'solver_data']
>>> arrays = data['arrays']
>>> arrays.keys()
['fluid']
>>> fluid = arrays['fluid']
>>> type(fluid)
pysph.base.particle_array.ParticleArray
>>> data['solver_data']
{'count': 100, 'dt': 4.6416394784204199e-05, 't': 0.0039955855395528766}

从多个文件加载结果

pysph.solver.utils.load_and_concatenate(prefix, nprocs=1, directory='.', count=None)

从多个文件加载结果。给定文件名前缀和处理器数量，返回通过 load 返回的字典的串联版本参数：

prefix (str) -输出文件的文件名前缀
nprocs (int) -要读取的处理器（文件）的数量
directory (str) -文件的目录
count (int) -要读取的文件迭代计数。如果没有，则读取最后一个可用的

插值器（interpolator）😅

该模块提供了一个类interpolator.Interpolator，可用于将任何标量值从各点插值到一个网格或其他点的集合上。SPH 插值是通过简单的 Shepard 滤波执行的。

InterpolateFunction

class pysph.tools.interpolator.InterpolateFunction(dest, sources)

参数：

dest (str) -目标粒子数组的名称
sources (list of str or None) -源粒子数组的名称

initialize(d_idx, d_prop, d_number_density) loop( s_idx , d_idx , s_temp_prop , d_prop , d_number_density , WIJ ) post_loop( d_idx , d_prop , d_number_density )

InterpolateSPH

class pysph.tools.interpolator.InterpolateSPH(dest, sources)

dest (str) -目标粒子数组的名称
sources (list of str or None) -源粒子数组的名称 initialize(d_idx, d_prop) loop(d_idx, s_idx, s_rho, s_m, s_temp_prop, d_prop, WIJ)

Interpolator

class pysph.tools.interpolator.Interpolator(particle_arrays, num_points=125000, kernel=None, x=None, y=None, z=None, domain_manager=None, equations=None, method='shepard')

Bases: object 方便的类，可以将粒子的属性插值到一个统一的网格或给定的粒子集上。这对于可视化来说特别方便 x、y、z坐标不需要指定，如果不指定，插值域的边界会自动计算，num_points数量的点会在这个域中统一放置。参数：

particle_arrays(list) -粒子数组的列表
num_points(int) -插值的点的数量
kernel(Kernel) -用于插值的核函数
x(ndarray) -插值点的 x 坐标
y(ndarray) -插值点的 y 坐标
z(ndarray) -插值点的 z 坐标
domain_manager (DomainManager) -一个可选的周期域管理器
equations (sequence) -一系列方程或组。默认为无。这仅在默认插值方程不充分时使用
method (str) -具有以下允许方法的字符串：'shepard'、'sph'、'order1'

interpolate(prop, comp=0) 插入给定的属性参数：

prop (str) -要插入的属性的名称
comp(int) -所需的梯度分量返回一个numpy数组，其中插入了属性

set_domain(bounds, shape) 设置要插入的域参数：

bounds (tuple) : (xmin, xmax, ymin, ymax, zmin, zmax)
shape (tuple) ：(nx, ny, nz)

set_interpolation_points(x=None, y=None, z=None) 设置必须对数组进行插值的点如果 x、y、z 中的任何一个未通过，则假定为 0.0，并且其形状与其他非 None 数组一样参数：

x(ndarray) -插值点的 x 坐标
y(ndarray) -插值点的 y 坐标
z(ndarray) -插值点的 z 坐标

update(update_domain=True) 当粒子移动时更新 NNPS。如果 update_domain 为 False，则不更新域。当数组相同但粒子本身发生变化时使用此选项。如果粒子数组本身发生变化，改用 update_particle_arrays方法。

update_particle_arrays(particle_arrays) 为一组新的粒子数组调用此功能，这些粒子数组的属性与之前相同。例如，如果从文件中读取粒子数组数据，每次加载一个新的文件，就会读取一个具有相同属性的新粒子数组。调用这个函数来重置数组。

一阶 SPH 近似

class pysph.tools.interpolator.SPHFirstOrderApproximation(dest, sources, dim=1)

Bases: pysph.sph.equation.Equation 在这个函数中，被解决，其中（矩矩阵），（用基本SPH计算的属性）。计算需要在这一步之前对 "矩 "进行评估，这在SPHFirstOrderApproximationPreStep中完成。

initialize(d_idx, d_prop, d_p_sph) loop(d_idx, d_h, s_h, s_x, s_y, s_z, d_x, d_y, d_z, s_rho, s_m, WIJ, DWIJ, s_temp_prop, d_p_sph, s_idx) post_loop(d_idx, d_moment, d_prop, d_p_sph)

一阶 SPH 近似prestep

class pysph.tools.interpolator.SPHFirstOrderApproximationPreStep(dest, sources, dim=1)

initialize(d_idx, d_moment) loop(d_idx, s_idx, d_h, s_h, s_x, s_y, s_z, d_x, d_y, d_z, s_rho, s_m, WIJ, XIJ, DWIJ, d_moment)

求给定一系列粒子阵列的域的大小

pysph.tools.interpolator.get_bounding_box(particle_arrays, tight=False, stretch=0.05)

如果tight为True，则边界是紧密的，如果不是，则域沿每个维度被拉伸，拉伸量指定为沿该维度的长度的百分比被添加到每个维度中

pysph.tools.interpolator.get_nx_ny_nz(num_points, bounds)

pysph.tools.interpolator.main(fname, prop, npoint)

SPH评估(Evaluator)

该模块提供了一个类，允许人们评估一组粒子阵列上的一组方程。这对于需要快速进行的重要后期处理非常方便。结合了 AccelerationEval 和 SPHCompiler 以允许用户指定粒子阵列、方程、可选域和内核来生成 SPH 评估。对于后处理十分方便。

SPHEvaluator

class pysph.tools.sph_evaluator.SPHEvaluator(arrays, equations, dim, kernel=None, domain_manager=None, backend=None, nnps_factory=<class 'pysph.base.linked_list_nnps.LinkedListNNPS'>)

Bases: object 参数：

arrays (list(ParticleArray))
equations (list)
dim (int)
kernel (kernel instance.)
domain_manager (DomainManager)
backend (str: indicates the backend to use.) -('opencl', 'cython', '', None) 之一
nnps_factory -创建NNPSBase实例

evaluate(t=0.0, dt=0.1) 评估SPH方程，可以传递虚拟t和dt值

update(update_domain=True) 当粒子移动时更新 NNPS。如果 update_domain 为 False，则不更新域。当数组相同但粒子本身发生变化时使用此选项。如果粒子数组本身发生变化，改用 update_particle_arrays方法

update_particle_arrays(arrays)

粒子打包机（Particle Packer）

以下函数可用于创建粒子在 2D 和 3D 中围绕固体表面填充的域。

创建周期性压缩的 2D 或 3D 域

pysph.tools.geometry.get_packed_periodic_packed_particles(add_opt_func, folder, dx, L, B, H=0, dim=2, dfreq=-1, pb=None, nu=None, k=None, tol=0.01)

创建周期性压缩的 2D 或 3D 域。它产生未对齐但堆积的颗粒，使得数量密度均匀。参数：

add_opt_func -来自父应用程序类的选项函数
folder -应用程序类输出目录
dx (float) -所需的粒子间距
L (float) -域的长度
B (float) -域的宽度
H (float) -域的高度
dim (int) -维数
dfreq(int)-粒子的投射频率
pb (float) -背景压力(默认值：1.0)
nu (float) -粘度系数(默认: 0.3/dx)
k (float) -排斥系数（默认值：0.005*dx）
tol(float)-收敛的容差值（默认值：1e-2）

Return:

xs (float) -固体粒子的 x 坐标
ys (float) -固体粒子的 y 坐标
zs (float) -固体粒子的 z 坐标
xf (float) -流体粒子的 x 坐标
yf (float) -流体粒子的 y 坐标
zf (float) -流体粒子的 z 坐标

围绕二维几何体的给定坐标创建粒子的压缩配置

pysph.tools.geometry.get_packed_2d_particles_from_surface_coordinates(add_opt_func, folder, dx, x, y, pb=None, nu=None, k=None, scale=1.0, shift=False, dfreq=-1, invert_normal=False, hardpoints=None, use_prediction=False, filter_layers=False, reduce_dfreq=False, tol=0.01)

参数：

add_opt_func -来自父应用程序类的选项函数
folder -应用程序类输出目录
dx (float) -所需的粒子间距
x(array) -几何的x坐标
y(array) -几何的y坐标
dfreq(int)-粒子的投射频率
pb (float) -背景压力(默认值：1.0)
nu (float) -粘度系数(默认: 0.3/dx)
k (float) -排斥系数（默认值：0.005*dx）
scale(float) - 坐标的比例因子
invert_normal(bool) -如果True 计算的法线被反转
hardpoints(dict)-hardpoints 字典
use_prediction(bool) -如果True，点被快速投影到预测点
filter_layers (bool) -如果True，远离边界的粒子被冻结
reduce_dfreq (bool) --如果True，则降低投影频率
tol(float)-收敛的容差值（默认值：1e-2）

Return:

xs (float) -固体粒子的 x 坐标
ys (float) -固体粒子的 y 坐标
zs (float) -固体粒子的 z 坐标
xf (float) -流体粒子的 x 坐标
yf (float) -流体粒子的 y 坐标
zf (float) -流体粒子的 z 坐标

围绕给定几何文件创建包含 x、y 坐标的粒子的压缩配置

pysph.tools.geometry.get_packed_2d_particles_from_surface_file(add_opt_func, folder, dx, filename, pb=None, nu=None, k=None, scale=1.0, shift=False, dfreq=-1, invert_normal=False, hardpoints=None, use_prediction=False, filter_layers=False, reduce_dfreq=False, tol=0.01)

参数：

add_opt_func -来自父应用程序类的选项函数
folder -应用程序类输出目录
dx (float) -所需的粒子间距
filename (string) -包含几何图形的x，y坐标的文件
dfreq(int)-粒子的投射频率
pb (float) -背景压力(默认值：1.0)
nu (float) -粘度系数(默认: 0.3/dx)
k (float) -排斥系数（默认值：0.005*dx）
scale(float) - 坐标的比例因子
invert_normal(bool) -如果True 计算的法线被反转
hardpoints(dict)-hardpoints 字典
use_prediction(bool) -如果True，点被快速投影到预测点
filter_layers (bool) -如果True，远离边界的粒子被冻结
reduce_dfreq (bool) --如果True，则降低投影频率
tol(float)-收敛的容差值（默认值：1e-2）

Return:

xs (float) -固体粒子的 x 坐标
ys (float) -固体粒子的 y 坐标
zs (float) -固体粒子的 z 坐标
xf (float) -流体粒子的 x 坐标
yf (float) -流体粒子的 y 坐标
zf (float) -流体粒子的 z 坐标

围绕给定的 STL 文件创建包含 x、y、z 坐标和法线的粒子的打包配置

pysph.tools.geometry.get_packed_3d_particles_from_surface_file(add_opt_func, folder, dx, filename, pb=None, nu=None, k=None, scale=1.0, shift=False, dfreq=-1, invert_normal=False, hardpoints=None, use_prediction=False, filter_layers=False, reduce_dfreq=False, tol=0.01)

参数：

add_opt_func -来自父应用程序类的选项函数
folder -应用程序类输出目录
dx (float) -所需的粒子间距
filename (string) -包含几何图形的x，y坐标的文件
dfreq(int)-粒子的投射频率
pb (float) -背景压力(默认值：1.0)
nu (float) -粘度系数(默认: 0.3/dx)
k (float) -排斥系数（默认值：0.005*dx）
scale(float) - 坐标的比例因子
invert_normal(bool) -如果True 计算的法线被反转
hardpoints(dict)-hardpoints 字典
use_prediction(bool) -如果True，点被快速投影到预测点
filter_layers (bool) -如果True，远离边界的粒子被冻结
reduce_dfreq (bool) --如果True，则降低投影频率
tol(float)-收敛的容差值（默认值：1e-2）

Return:

xs (float) -固体粒子的 x 坐标
ys (float) -固体粒子的 y 坐标
zs (float) -固体粒子的 z 坐标
xf (float) -流体粒子的 x 坐标
yf (float) -流体粒子的 y 坐标
zf (float) -流体粒子的 z 坐标

在生成的填料周围创建外部流体粒子

pysph.tools.geometry.create_fluid_around_packing(dx, xf, yf, L, B, zf=[0.0], H=0.0, **props)

在生成的填料周围创建外部流体粒子。它添加填充的流体粒子并生成串联的粒子数组参数：

dx (float) -粒子间距
xf (float) -流体粒子的 x 坐标
yf (float) -流体粒子的 y 坐标
zf (float) -流体粒子的 z 坐标
L (float) -域的长度
B (float) -域的宽度
H (float) -域的高度

本文章使用limfx的vscode插件快速发布

PySPH参考文档

模块应用（Module）

Application Constructor

模块控制器（Module controller）

CommandManager Constructor

controller Constructor

DummyComm Constructor

其他

SPH方程

基本SPH方程

基本WCSPH方程

黏度函数

传输速度公式

积分器相关模块

预测矫正积分器

Euler积分器

积分器通用类

跳蛙(leap-frog)积分器

预测评估矫正积分器

Forest-Ruth-Like 积分器

TVD-RK3积分器

用于气体动力学的ADKE的预测器校正器积分器

Verlet 时间积分

快速但不准确的积分器，用于测试

GSPH积分器

气体动力学的预测器校正器积分器

入口/出口粒子的简单积分器

IntegratorStep

LeapFrogStep(用于XSPH)

简单的一级刚体运动

PEFRLStep(用于XSPH)

固体力学问题的预测器校正器积分器

'传输速度公式'定义的积分器

简单的二级刚体运动

WCSPH 公式的标准预测器校正器积分器

用于 WCSPH 的 TVD RK3 步进器

SPH核函数

三次样条函数

Gaussian函数

五次样条函数

Super Gaussian函数

WendlandQuintic函数-C2（二/三维）

WendlandQuintic函数-C2（一维）

高性能包装内核

NNPS模块(临近粒子搜索)

解决方案域(domain)的限制

box-sort NNPS

链表方法NNPS

可扩展空间哈希NNPS

粒子数组模块

ParticleArray

创建粒子阵列的便捷函数

Module scheme （模块方案）

ADKEScheme

GSPHScheme

SPH Scheme

SchemeChooser

TVFScheme

WCSPHScheme

模块求解器(Module solver)

PySPH 求解器的基类

模块求解器工具

模块边界条件

initialize(d_ioid, d_idx) loop(d_idx, d_x, d_y, d_z, d_ioid, d_disp)

模块求解器_interfaces

PySPH的其他工具

数据文件的输入输出

插值器（interpolator）😅

SPH评估(Evaluator)

粒子打包机（Particle Packer）

`initialize(d_ioid, d_idx)` `loop(d_idx, d_x, d_y, d_z, d_ioid, d_disp)`