Homogeneous FFT-based implementation

1 + e^{iξ1 }1 + e^{iξ2 }1 + e^iξ3 (5.49) Finally, the continuous modified Green’s operator (3.43) is recovered when setting

k_i(~ξ_d) = iξ_i (5.50)

in expression (5.46).

5.4 Numerical Implementation Of The Spectral Approach

5.4.1 Homogeneous FFT-based implementation

With respect to the regular DDD framework, the main changes to be implemented in the DDD-FFT method pertain to the calculation of the stress state associated with the microstructure. Thus, (1) the regularization procedure, (2) the FFT-based solver and (3) the calculation of nodal forces are the principal components that must be implemented or modified. The main difficulties associated with the development of the FFT-based approach relates to the development and the implementation of the analytical procedure detailed in Section5.2and the removal of the Gibbs oscillations, whose implementation is fully discussed in5.3.

In contrast, the numerical implementation of the FFT-based solver is straightforward and is described in the following. First, the primary simulation volume is descretized into a

regular grid of N_vox = N₁ × N₂ × N₃ voxels with coordinates {~x_d}_d=1,Nvox. Although some discrete Fourier transforms formulations allow for non-regular grids, the discretization must be here chosen such as to ensure that each voxel are cubes, i.e. that the spacing L_mesh = l_i = V_i/N_i between the center of subsequent voxels is identical in all directions i = {1, 2, 3}, where V_i is the size of the volume in the i-th direction. Besides the FFT requirement, this condition is also required when spherical elementary volumes of radius L_mesh are used in the regularization procedure. Therefore, it must be noted that the requirements on the numerical discretization of the primary volume induce constraints on its size.

Once an appropriate discretization is chosen for the simulation volume, the plastic strain produced by the glide of dislocations can be calculated via the regularization procedure described in Section 5.2. When initializing a simulation, the initial dislocation loops are introduced using a Volterra-like process. In this process, the area swept corresponding to the entire domain enclosed by the dislocation loop is simply transferred to the mesh with the regularization procedure such that the initial plastic strain is computed. Obviously, in general, the swept area may intersect several elementary spheres, and the intersection should be computed independently for each of them. Numerically, the regularization procedure is therefore a O(N_segN_vox) procedure, since the intersection between the sheared area produced by each segment and the sphere associated with each voxel must be theoretically calculated.

However, many of these intersections will be empty as dislocation segments are localized and their size is usually significantly smaller than the size of the simulation volume. Therefore, to avoid testing for all possible intersections, solely the intersections between the sheared area and the spheres lying within the bounding box of the sheared area are calculated. With this, the computational complexity of the regularization is reduced to O(N_seg), and it is ensured that no intersection will be missed such that the plastic strain will be entirely transferred to the mesh.

Once the regularization procedure has been performed for all dislocation segments, the plastic strain distribution {^p(~x_d)}_d=1,Nvox is known at each voxel ~x_d. At this stage, the FFT

algorithm is used to compute the discrete Fourier coefficients {_b^p(~ξ_d)}_d=1,Nvox such that the total strain {_b(~ξ_d)}_d=1,Nvox can be calculated in the Fourier space from equation (5.10) as

b(~ξ_d) = Γ(~^b ξ_d) : C :b^p(~ξ_d)

b(~ξ_d= ~0) = 0

∀ voxel ~ξ_d (5.51)

where b(~ξ_d), b^p(~ξ_d) and Γ(~^b ξ_d) denote the total strain, plastic strain and modified Green’s function tensors in the Fourier space at voxel ~ξ_d. In the homogeneous case, no reference medium needs to be introduced and Γ is directly associated the elastic stiffness tensor C.^b Then, the FFT algorithm is used a second time to compute the resulting total strain dis-tribution {(~x_d)}_d=1,Nvox in the real space (see equation 5.12). In turns, the sequence of operations performed in one time step of the DDD-FFT approach is listed in figure5.8.

(i) Compute nodal forces ~F (σ(~x_d))

(ii) Integrate dislocation motion and determine swept areas (iii) Regularize plastic strain ^p(~x_d)

(iv) Compute new stress state σ(~x_d) using the FFT solver (a) ϕ(~x_d) = C : ^p(~x_d)

(b) {τ (~b ξ_d)} = F F T ({τ (~x_d)}) (c) b(~ξ_d) = −Γ(~^b ξ_d) :τ (~b ξ_d)

(d) {(~xd)} = F F T^−1{b(~ξ_d)}^+ E (e) σ(~x_d) = C : ((~x_d) − ^p(~x_d))

Figure 5.8 General algorithm describing the main stages composing one time step of the homogeneous DDD-FFT approach.

In figure 5.8, the F F T and F F T⁻¹ operators denote the discrete Fourier transforms and inverse discrete Fourier transforms that are performed using the FFT algorithm. As the Fourier transforms take up the bulk of the simulation step, the performance of the DDD-FFT

approach is tied up to its numerical implementation and to the choice of the FFT library.

In this work, the FFTW and/or the CUFFT libraries [46, 47]. In steps iv(b) and iv(d) of figure 5.8, the FFT computation of tensors τ and _b is performed independently for each component. Thus, given the symmetry, a total of 2 × 6 three-dimensional FFTs need to be performed at each time step.

The computation of each FFT in steps iv(b) and iv(d) has a complexity of O(N_voxlog N_vox), while that of the calculation of the total strain in iv(c) scales with O(Nvox). However, the prefactor of step iv(c) associated with the numerical evaluation of the modified Green’s op-eratorΓ(~^b ξ_d) (81 components) and the double dot productΓ(~^b ξ_d) :τ (~_b ξ_d) exceeds O(log N_vox) in general, so that step iv(c) amounts to more flops than the FFTs.

The remarkable property of the modified Green’s operator is that it solely depends on the elastic stiffness tensor C of the medium and on the voxel which it is associated. There-fore, it can be precomputed at the beginning of each simulation for each voxel and stored in the memory, or recomputed at each time step for each voxel. Although at first sight a precomputation may appear as the most efficient approach, the benefit that can be obtained strongly depend on the architecture and hardware capacities. Thus, when running simula-tions on desktop computers, the cost of computing Γ(~^b ξ_d) at each time step is usually lower than that of storing theΓ(~^b ξ_d) tensor (81 components in general) and accessing the memory.

In this work, it is seen that an optimal computational efficiency is obtained when storing the Green’s function G^b_ik(~ξ_d) (9 components) for each voxel and recomputing the modified Green’s operator on the fly from equation (5.46).

On top of its base efficiency, the FFT libraries offers respective parallel implementations.

In the regular DDD code, the parallel implementation has been primarily devised to dis-tribute segment-segment elastic interactions among CPUs. Although the computation of segment-segment elastic interactions is reduced to a minimum in the DDD-FFT approach, a fully parallel implementation is desirable, as a non-parallel FFT-solver will dramatically affect the overall performance of the code. In the parallel FFT implementation, a slab

de-composition technique is used, whereby the 3D primary discretized volume is decomposed into N_cpu layers in one of the spatial directions, where N_cpu is the number of CPU to be used. With this procedure, each CPU only needs to know the field values at the voxels lying in its slab. Similarly, after the FFT is computed, each CPU can solely access the values of the Fourier coefficients associated with the voxels contained in its slab. However, since the quantities in the Fourier space are independent from one another – the frequencies are only associated with the voxels – each CPU can perform step iv(c) in figure 5.8 in a fully parallel manner. As a result, the parallel implementation of the DDD-FFT is expected to scale well, provided that the FFT libraries offers a good scalability. Since the parallel FFT algorithm involves numerous point-to-point communications, the overall scalability is highly dependent on the hardware capabilities and configuration.

Regarding memory usage, a minimum of two real-valued and one complex-valued arrays of size 6N_voxare required. Following the history-dependent character of the DCM approach, one real-valued array must be dedicated to contain the plastic strain distribution {^p(~x_d)}_d=1,Nvox. The other real-valued array can be used to sequentially store {τ (~xd)}_d=1,Nvox, {(~xd)}_d=1,Nvox and {σ(~x_d)}_d=1,Nvoxvalues, while the complex-valued array is used to contain {τ (~_b ξ_d)}_d=1,Nvox and {_b(~ξ_d)}_d=1,Nvox distributions in the Fourier space.