Particle method

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search

Particle methods is a widely used class of numerical algorithms in scientific computing. Its application ranges from computational fluid dynamics (CFD) over molecular dynamics (MD) to discrete element methods.

History

[edit | edit source]

One of the earliest particle methods is smoothed particle hydrodynamics, presented in 1977.[1] Libersky et al.[2] were the first to apply SPH in solid mechanics. The main drawbacks of SPH are inaccurate results near boundaries and tension instability that was first investigated by Swegle.[3]

In the 1990s a new class of particle methods emerged. The reproducing kernel particle method[4] (RKPM) emerged, the approximation motivated in part to correct the kernel estimate in SPH: to give accuracy near boundaries, in non-uniform discretizations, and higher-order accuracy in general. Notably, in a parallel development, the Material point methods were developed around the same time[5] which offer similar capabilities. During the 1990s and thereafter several other varieties were developed including those listed below.

List of methods and acronyms

[edit | edit source]

The following numerical methods are generally considered to fall within the general class of "particle" methods. Acronyms are provided in parentheses.

Definition

[edit | edit source]

The mathematical definition of particle methods captures the structural commonalities of all particle methods.[6] It, therefore, allows for formal reasoning across application domains. The definition is structured into three parts: First, the particle method algorithm structure, including structural components, namely data structures, and functions. Second, the definition of a particle method instance. A particle method instance describes a specific problem or setting, which can be solved or simulated using the particle method algorithm. Third, the definition of the particle state transition function. The state transition function describes how a particle method proceeds from the instance to the final state using the data structures and functions from the particle method algorithm.[6]

A particle method algorithm is a 7-tuple (P,G,u,f,i,e,e), consisting of the two data structures P:=A1×A2×...×Anthe particle space,G:=B1×B2×...×Bmthe global variable space,

such that [G×P*] is the state space of the particle method, and five functions: u:[G×P*]×*the neighborhood function,f:G{,}the stopping condition,i:G×P×PP×Pthe interact function,e:G×PG×P* the evolve function,e:GGthe evolve function of the global variable.

An initial state defines a particle method instance for a given particle method algorithm (P,G,u,f,i,e,e):

[g1,𝐩1][G×P*].

The instance consists of an initial value for the global variable g1G and an initial tuple of particles 𝐩1P*.

In a specific particle method, the elements of the tuple (P,G,u,f,i,e,e) need to be specified. Given a specific starting point defined by an instance [g1,𝐩1], the algorithm proceeds in iterations. Each iteration corresponds to one state transition step s that advances the current state of the particle method [gt,𝐩t] to the next state [gt+1,𝐩t+1]. The state transition uses the functions u,i,e,e to determine the next state. The state transition function S generates a series of state transition steps until the stopping function f is true. The so-calculated final state is the result of the state transition function. The state transition function is identical for every particle method.

The state transition function is defined as

S:[G×P*][G×P*]

with

[gT,𝐩T]:=S([g1,𝐩1]).

The pseudo-code illustrates the particle method state transition function:

 1 [g,𝐩]=[g1,𝐩1]
 2 while f(g)=false
 3   for j=1 to |𝐩|
 4     𝐤=u([g,𝐩],j)
 5     for l=1 to |𝐤|
 6       (pj,pkj)=i(g,pj,pkj)
 7   𝐪=()
 8   for j=1 to |𝐩|
 9     (g,𝐪)=e(g,pj)
10     𝐪=𝐪𝐪
11   𝐩=𝐪
12   g=e(g)
13 [gT,𝐩T]=[g,𝐩]

The fat symbols are tuples, 𝐩,𝐪 are particle tuples and 𝐤 is an index tuple. () is the empty tuple. The operator is the concatenation of the particle tuples, e.g. (p1,p2)(p3,p4,p5)=(p1,p2,p3,p4,p5). And |𝐩| is the number of elements in the tuple 𝐩, e.g. |(p1,p2)|=2.

See also

[edit | edit source]

References

[edit | edit source]
  1. ^ Gingold RA, Monaghan JJ (1977). Smoothed particle hydrodynamics – theory and application to non-spherical stars. Mon Not R Astron Soc 181:375–389
  2. ^ Libersky, L.D., Petscheck, A.G., Carney, T.C., Hipp, J.R., Allahdadi, F.A. (1993). High Strain Lagrangian Hydrodynamics. Journal of Computational Physics.
  3. ^ Swegle, J.W., Hicks, D.L., Attaway, S.W. (1995). Smoothed Particle Hydrodynamics Stability Analysis. Journal of Computational Physics. 116(1), 123-134
  4. ^ Liu, W.K., Jun, S., Zhang, Y.F. (1995), Reproducing kernel particle methods, International Journal of Numerical Methods in Fluids. 20, 1081-1106.
  5. ^ D. Sulsky, Z., Chen, H. Schreyer (1994). a Particle Method for History-Dependent Materials. Computer Methods in Applied Mechanics and Engineering (118) 1, 179-196.
  6. ^ a b Lua error in Module:Citation/CS1/Configuration at line 2172: attempt to index field '?' (a nil value).  This article incorporates text available under the CC BY 4.0 license.

Further reading

[edit | edit source]
  • Liu MB, Liu GR, Zong Z, AN OVERVIEW ON SMOOTHED PARTICLE HYDRODYNAMICS, INTERNATIONAL JOURNAL OF COMPUTATIONAL METHODS Vol. 5 Issue: 1, 135–188, 2008.
  • Liu, G.R., Liu, M.B. (2003). Smoothed Particle Hydrodynamics, a meshfree and Particle Method, World Scientific, Lua error in Module:Citation/CS1/Configuration at line 2172: attempt to index field '?' (a nil value)..
[edit | edit source]