Fast Simulation of Laser Heating Processes on Thin Metal Plates with FFT Using CPU/GPU Hardware

Abstract

In flexible manufacturing systems, fast feedback from simulation solutions is required for effective tool path planning and parameter optimization. In the particular sub-domain of laser heating/cutting of thin rectangular plates, current state-of-the-art methods include frequency-domain (spectral) analytic solutions that greatly reduce the required computational time in comparison to industry standard finite element based approaches. However, these spectral solutions have not been presented previously in terms of Fourier methods and Fast Fourier Transform (FFT) implementations. This manuscript presents four different schemes that translate the problem of laser heating of rectangular plates into equivalent FFT problems. The presented schemes make use of the FFT algorithm to reduce the computational time complexity of the problem from $\mathcal{O}\left(M^2{N}^2\right)$ to $\mathcal{O}(MNlog(MN\left)\right)$ (with $M\times N$ being the discretization size of the plate). The test results show that the implemented schemes outperform previous non-FFT approaches both in CPU and GPU hardware, resulting in $100\times$ faster runs. Future work addresses thermal/stress analysis, non-rectangular geometries and non-linear interactions (such as material melting/ablation, convection and radiation heat transfer).

1. Introduction

Based on virtual modelling and simulation of physical phenomena, Industry 4.0 solutions aim to integrate interactive virtual worlds with their equivalent physical part (e.g., using digital twins). These solutions enable the development of decision making tools that can be of great use in the optimization of manufacturing processes.

In this context, engineering solutions use extensively Finite Element Analysis (FEA) for simulation of such physical phenomena (e.g., acoustics, heat transfer, structural analysis, fluid flow, etc.). However, FEA approaches require a great amount of computation resources. In contrast, spectral analysis and spectral methods are competitive alternatives to numerical simulations. These methods provide frequency-domain solutions (infinite sum of trigonometric functions) to the Partial Difference Equations (PDEs) that model such physical phenomena.

In the particular sub-domain of laser heating/cutting simulation, frequency-based algorithms have been developed for heat transfer analysis on rectangular plates. These algorithms are faster than traditional numerical methods (such as Finite Element Methods) at the cost of some model simplifications. In addition, these methods provide some advantages over FEA, such as allowing to zoom into asynchronous time intervals without computing or storing the complete history of the solution.

This property makes frequency-based algorithms more adequate for decision making tools that require rapid response times, allowing to be more flexible towards changes in the heating/cutting manufacturing process. Fast simulation of the laser heating/cutting problem is very important for different engineering problems, such as tool path planning, laser parameter optimization, waste and resources optimization, and so forth. Moreover, interactive simulation and visualization of laser machining processes contributes to many different challenges and opportunities currently present in the Industry 4.0 framework [1].

The aforementioned methods for laser heating/cutting simulation allow simulation of complex laser trajectories on rectangular plates, including parametric trajectories and the introduction of multiple laser beams simultaneously. However, there are no Fast Fourier Transform (FFT)-based solutions to the laser heating/cutting problem in the current state of the art.

The FFT is a widely used algorithm not only in the context of PDEs simulation, but also in other areas such as signal analysis and image processing. Thus, its development has been refined and studied extensively in the literature. Several FFT algorithms exist in the literature that further optimize the computation in function of the input signal properties (e.g., symmetry, real/imaginary, size, etc.). In general, the FFT is a key algorithm that retrieves the original spatial-based solution by performing a factorization of the Discrete Fourier Transform (DFT) and avoids redundant computations, reducing the computational complexity of the original DFT problem [2].

This article presents four different schemes that cast the laser heating/cutting problem into DST (Discrete Sine Transform) and DFT (Discrete Fourier Transform) problems. Such casting enables the use of FFT libraries to implement these schemes. The test results show a significant improvement over existing methods in the computational time, both in CPU and GPU, due to the computational complexity reduction.

This manuscript is an extension of the work presented in Reference [3], where only two schemes were briefly introduced for the FFT computation of the laser heating problem. The current research discusses in more detail each of the four schemes, including mathematical and algorithmic descriptions but also the intuition behind the schemes followed by illustrations. Furthermore, a different simulation case is designed and tested. Finally, the presented schemes are in the process of being applied in an Industry 4.0 application prototype. The ongoing prototype implements an interactive virtual model of a laser heating/cutting machine using geometry operations and physical simulation.

The remainder of this manuscript is organized as follows—Section 2 discusses the relevant literature. Section 3 presents the proposed FFT schemes. Section 4 discusses the test results. Finally, Section 5 presents the conclusions and discusses what remains for future work.

2. Literature Review

2.1. Laser Heating/Cutting Simulation

Finite Element Analysis (FEA) is one of the most used methods for thermodynamic simulation of laser heating/cutting of metal plates. Using non-linear FEA, Yilbas et al. [4] simulate triangular cuts for residual stress analysis. Similarly, Akthar et al. [5,6] perform the same non-linear FEA analysis for rectangular cuts, while in Reference [7] circular cuts are studied using the same approach. In order to account for laser ablation (material melting and evaporation), different methods such as the enthalpy method [4,5,6,7], element birth and death [8], volume fractions [9], and temperature thresholds [10,11,12] have been presented.

Other numerical methods include Finite Differences [13,14,15], Boundary Elements [16,17] and Finite Volumes [18,19]. However, numerical methods are computationally expensive in general, limiting their application to small plate geometries and simple laser trajectories, requiring full time history simulations.

Analytic methods provide significantly faster computations at the cost of some model simplifications. Zimmer [20] presents a uni-dimensional analytic model for laser drilling processes when the laser beam is static. Modest and Abakians [21] present a solution for a moving laser on an infinite 2D plate. Jiang and Dai [22] present a frequency-based solution for rectangular plates when the moving laser follows a straight path. Similarly, Mejia et al. [23,24] present a frequency-based solution for arbitrary laser trajectories. Finally, an extension of the previous frequency-based solutions applied to multiple laser beams simultaneously heating the plate surface is presented in Reference [25].

2.2. FFT-Based Laser Heating Simulation

FFT-based methods are relevant in the solution of physical problems by solving the inherent PDE in the frequency domain. As a consequence, these methods have been successfully implemented in the simulation of different physics phenomena. For example, in the context of heat transfer analysis, Ju and Farris [26] present an FFT-based method for the solution of the thermoelastic equation on infinite domains, while Dillenseger and Esneault [27] apply the FFT to the solution of a heat transfer problem that arises in treatments of tissue with cancer. In structural analysis, FFT-based methods have been developed for the solution of different elasticity and plasticity problems [28,29,30,31], and fluid mechanics [32]. Other applications of the FFT include electromagnetism [33], 1D signal processing [34], and 2D image processing [35].

As discussed previously, many authors [22,23,24,25] solve the problem of laser heating simulation in the frequency domain. However, none of these authors cast the problem into the FFT domain.

2.3. Conclusions of the Literature Review

Current analytic methods for simulation of the laser heating/cutting problem already provide fast solutions to the problem in the frequency domain. However, such methods perform brute-force evaluation of the Fourier transforms, whose computation complexity for a 2D plate is $\mathcal{O}\left(M^2{N}^2\right)$. As a consequence, these applications quickly become computationally expensive as more resolution of the plate is required.

To overcome this problem, this manuscript presents four different schemes that cast the existing brute-force solutions into equivalent DST and DFT problems. Mathematical proof for the validity of each scheme is presented and algorithms that make use of FFT libraries are introduced, reducing the computational complexity of the problem from $\mathcal{O}\left(M^2{N}^2\right)$ (squared) to $\mathcal{O}(MNlog(MN\left)\right)$ (logarithmic). These algorithms are implemented both in CPU and GPU architectures. Numerical validation against the brute-force approach results in a measured absolute error that is below ${10}^{-10}$ K along the 2D plate. The results show significant computation time improvements to such brute-force simulations (i.e., References [22,23,24,25]), reducing the measured computation times from 1 s to 0.01 s ($100\times$ faster) for a $1024\times 1024$ rectangular plate, and enabling simulations for larger plate discretization sizes (up to $4096\times 4096$).

This manuscript extends the work presented in Reference [3]. In this previous work, two of the four presented schemes are briefly introduced. The research presented in this paper presents two additional FFT schemes, and provides further details of the four schemes (with added illustrations), to make easier the understanding of the algorithms. Furthermore, new simulations have been executed and an application case of the algorithms being implemented into an interactive simulator is presented.

3. Methodology

3.1. Heat Transfer Equation for Laser Heating on Thin Plates

The temperature $u(x,y,t)$ on a 2D rectangular plate for a continuous laser beam source satisfies the following partial differential equation with initial and boundary conditions:

$$\begin{array}{cc}\hfill \frac{f-q}{\Delta z}& =\rho c_p\frac{\partial u}{\partial t}-\nabla ·(\kappa \nabla u)\hfill \\ \hfill q(x,y,t)& =h·(u(x,y,t)-u_{\infty })\hfill \\ \hfill u(x,y,0)& =u_{\infty }\hfill \\ \hfill u(0,y,t)& =u(a,y,t)=u(x,0,t)=u(x,b,t)=u_{\infty },\hfill \end{array}$$

(1)

where $a\times b\times \Delta z$ are the plate dimensions, $\rho$ is the plate density, $c_p$ is the specific heat and $\kappa$ is the thermal conductivity. $q=q(x,y,t)$ is the heat loss due to convection at the plate surface, h is the convection coefficient and $u_{\infty }$ is the ambient temperature.

Finally, the heat source $f=f(x,y,t)$ is defined as a square-shape moving laser beam:

$$f(x,y,t)=\left\{\begin{array}{cc}\frac{P(1-R)}{\pi r^2},\hfill & {∥\overrightarrow{x}-{\overrightarrow{x}}_0\left(t\right)∥}_{\infty }<\frac{r\sqrt{\pi }}{2}\hfill \\ 0,\hfill & \mathrm{otherwise},\hfill \end{array}\right.$$

(2)

where R is the plate reflectivity, P is the laser power, r is the laser radius and ${\overrightarrow{x}}_0\left(t\right)=[x_0\left(t\right),y_0\left(t\right)]$ is the location of the laser spot at time t. ${\overrightarrow{x}}_0$ is the parametric curve that defines the laser trajectory, discretized as a sequence of piecewise linear trajectories as described in References [23,24]. The function f describes the laser power on the plate according to the distance (infinity norm) $\parallel \overrightarrow{x}-{\overrightarrow{x}}_0{\left(t\right)\parallel }_{\infty }=max(x-x_0\left(t\right),y-y_0\left(t\right))$ of each plate point $\overrightarrow{x}=[x,y]$ to the laser spot ${\overrightarrow{x}}_0\left(t\right)=[x_0\left(t\right),y_0\left(t\right)]$. Figure 1 presents an scheme of the laser heating problem on thin metal plates.

3.2. Analytic Solution

According to References [23,24], the solution to Equation (1) can be expressed as Fourier series:

$$u(x,y,t)=u_{\infty }+\sum _{m=0}^{\infty }\sum _{n=0}^{\infty }{\theta }_{mn}\left(t\right)sin\left({\alpha }_{m}x\right)sin\left({\beta }_{n}y\right),$$

(3)

with ${\alpha }_m=(m+1)\pi /a$ and ${\beta }_n=(n+1)\pi /b$. Each Fourier coefficient ${\theta }_{mn}\left(t\right)$ is defined as:

$${\theta }_{mn}\left(t\right)=\frac{4}{ab\rho c_p\Delta z}{\int }_0^t{\int }_0^b{\int }_0^{a}f(x,y,\tau )sin\left({\alpha }_{m}x\right)sin\left({\beta }_{n}y\right)e^{-{\omega }_{mn}(t-\tau )}dxdyd\tau ,$$

(4)

with Laplace eigenvalues ${\omega }_{mn}$:

$${\omega }_{mn}=\frac{\kappa }{\rho c_p}({\alpha }_m^2+{\beta }_n^2)+\frac{h}{\rho c_p\Delta z}.$$

(5)

Let ${\overrightarrow{C}}_1\left(t\right),{\overrightarrow{C}}_2\left(t\right),\dots$ be a sequence of piecewise linear sub-trajectories that discretize the complete laser trajectory (see Figure 2), that is, ${\overrightarrow{x}}_0\left(t\right)\approx {\overrightarrow{C}}_1\left(t\right),{\overrightarrow{C}}_2\left(t\right),\dots$. Each sub-trajectory ${\overrightarrow{C}}_i$ ($i>0$) is defined as a parameterized line segment:

$${\overrightarrow{C}}_i\left(t\right)={\overrightarrow{x}}_0\left(t_i\right)\frac{t-t_{i-1}}{t_i-t_{i-1}}+{\overrightarrow{x}}_0\left(t_{i-1}\right)\frac{t_i-t}{t_i-t_{i-1}},t_{i-1}\le t<t_i,$$

(6)

where the original laser trajectory ${\overrightarrow{x}}_0$ is sampled at $t=t_0,t_1,t_2,\dots ,T_f$.

The analytic solution of the Equation (4) for the given piecewise linear discretization is presented in References [23,24].

3.3. Discrete Fourier Transform (DFT) and Fast Fourier Transform (FFT)

The Discrete Fourier Transform (DFT) allows to write any sequence of M real numbers as a finite sum of sine and cosine functions, that is, a Fourier series. The (1D) DFT of the sequence of real values $G=\{g_0,g_1,\dots ,g_{M-1}\}\subset \mathbb{R}$ is defined as:

$$g_k=\sum _{m=0}^{M-1}{\varphi }_m{e}^{-\frac{i2\pi }{M}km}=\sum _{m=0}^{M-1}{\varphi }_m\left[cos\frac{2\pi km}{M}-isin\frac{2\pi km}{M}\right],$$

(7)

where ${\varphi }_m\in \mathbb{C}$ is the $m^{th}$ Fourier coefficient and $i=\sqrt{-1}$ is the imaginary unit. The computational complexity for direct evaluation of Equation (7) is $\mathcal{O}\left(M^2\right)$, in which each $g_k$ requires M evaluations (one for each Fourier term ${\varphi }_m$).

The Fast Fourier Transform (FFT) [2,34] is an algorithm that performs a factorization of the DFT, reordering the Fourier terms and grouping them (into pairs) in order to avoid redundant computations between different $g_k$ terms. Such a grouping is possible due to symmetries of the sine and cosine functions, and the resulting evaluation is performed in recursive form [2,34]. As a consequence, the FFT algorithm reduces the computational complexity of the problem to $\mathcal{O}(MlogM)$ [2,34].

The above DFT and FFT complexity orders are true for 1D arrays. Therefore, for a 2D discrete plate of size $M\times N$, the computational complexities become $\mathcal{O}\left(M^2{N}^2\right)$ and $\mathcal{O}(MNlog(MN\left)\right)$ for the DFT and the FFT, respectively.

The remainder of this section describes how to cast Equation (3) as a DFT problem and therefore, solve it using any FFT algorithm. Such casting effectively improves the computational complexity of the problem with respect to the current state of the art [22,23,24,25].

3.4. Scheme 1—Discrete Sine Transform (DST)

The Discrete Sine Transform (DST) [36] is a particular case of the DFT transform in which only the sine terms of the Fourier series are considered. The (1D) DFT of the sequence $G=\{g_0,g_1,\dots ,g_{M-1}\}\subset \mathbb{R}$ is defined as:

$$g_k=\sum _{m=0}^{M-1}{\varphi }_{k}sin\frac{(m+1)(k+1)\pi }{M+1}.$$

(8)

Intuitively, this is the easiest of the schemes for casting the problem as Equation (3) only considers the sine terms of a Fourier series. The algorithm of such casting is discussed below. The reader may refer to Appendix A for the mathematical proof of the scheme.

Algorithm 1 presents the method used to retrieve the temperature at any given time t with the DST method (see Equation (A1)). Line 2 applies the fast 2D DST of any FFT library, which presents a computational complexity equivalent to a FFT (i.e., $\mathcal{O}(NlogN)$ [37]). Line 3 applies the initial and boundary conditions presented in Equation (1) to the computed solution. The complexity of the presented algorithm is $\mathcal{O}(MNlog(MN\left)\right)$.

Algorithm 1 Retrieve temperature using a 2D DST

Require:$\mathsf{\Theta }\in {\mathbb{R}}^{(M-2)\times (N-2)},u_{\infty }\in \mathbb{R}$ Ensure:$U\in {\mathbb{R}}^{M\times N}$ 1: $U\leftarrow \mathrm{zeros}(M,N)$ 2: $U[1:M-1,1:N-1]\leftarrow \mathrm{dst}2\mathrm{d}\left(\mathsf{\Theta }\right)$ 3: $U\leftarrow U+u_{\infty }$ 4: returnU

3.5. Scheme 2—FFT Padded with Zeros

In this scheme, the original list of Fourier coefficients is duplicated in size in each direction ($2M\times 2N$). The added coefficients are set to zero and the FFT algorithm is applied in each direction. The final temperature result is obtained from the imaginary (sine) component of the FFT result. The mathematical proof of the scheme is presented in Appendix B.

Algorithm 2 Retrieve temperature using a Fast Fourier Transform (FFT) with zero padding

Require:$\mathsf{\Theta }\in {\mathbb{R}}^{(M-2)\times (N-2)},u_{\infty }\in \mathbb{R}$ Ensure:$U\in {\mathbb{R}}^{M\times N}$ 1: ${\mathsf{\Theta }}_{PADDED}\leftarrow \mathrm{zeros}(2M,2N)$ 2: ${\mathsf{\Theta }}_{PADDED}[1:M-1,1:M-1]\leftarrow \mathsf{\Theta }$ 3: for$n=1,n<N-1,n\leftarrow n+1$do 4:  $arr\leftarrow \mathrm{fft}\left({\mathsf{\Theta }}_{PADDED}[:,n]\right)$ 5:  ${\mathsf{\Theta }}_{PADDED}[:,n]\leftarrow \mathrm{imag}\left(arr\right)$ 6: end for 7: for$m=1,m<M-1,m\leftarrow m+1$do 8:  $arr\leftarrow \mathrm{fft}\left({\mathsf{\Theta }}_{PADDED}[m,:]\right)$ 9:  ${\mathsf{\Theta }}_{PADDED}[m,:]\leftarrow \mathrm{imag}\left(arr\right)$ 10: end for 11: $U\leftarrow \mathrm{zeros}(M,N)$ 12: $U\leftarrow {\mathsf{\Theta }}_{PADDED}[0:M-1,0:N-1]$ 13: $U\leftarrow U+u_{\infty }$ 14: returnU.

Algorithm 2 presents the method used to retrieve the temperature at any given time t using the zero padding method (see Equation (A3)). Line 1 initializes the extended matrix of Fourier coefficients with $M,N$ trailing zeros (as per Figure 3). Lines 4 and 8 compute the 1D FFT of the padded arrays for the y and x dimensions, respectively. Lines 5 and 9 extract the complex (imaginary component) of the results. Finally, Line 12 removes the trailing zeros from the solution while Line 13 applies initial and boundary conditions. The complexity of the presented algorithm is $\mathcal{O}(MNlog(MN\left)\right)$.

3.6. Scheme 3—Odd-Symmetry 1D FFT

In this scheme, the original list of Fourier coefficients is also duplicated in size in each direction ($2M\times 2N$). The idea is to take advantage from the odd symmetry of the sine function at $k\pi$ (with $k\in \mathbb{N}$, see Figure 4). Therefore, the added coefficients are set by mirroring the original M and N coefficients (multiplied by $-1$) in each direction (rows and columns). The final temperature is obtained from the imaginary (sine) component of the 1D FFT result in each direction. The mathematical proof of this scheme is presented in Appendix C.

Algorithm 3 presents the method used to retrieve the temperature of Equation (A9) at any given time t using two nested 1D FFTs. Line 1 initializes the extended matrix of Fourier coefficients with $M,N$ trailing zeros. Lines 3-5 and Lines 6-8 add the reversed sequences of Fourier coefficients (with negative sign) in each dimension, respectively (see Figure 5). Lines 10 and 14 compute the 1D FFT of the padded arrays for the y and x dimensions, respectively. Lines 11 and 15 extract the complex (imaginary component) of the result. Finally, Line 12 removes the mirrored part from solution while Line 13 applies initial and boundary conditions. The complexity of the presented algorithm is $\mathcal{O}(MNlog(MN\left)\right)$.

Algorithm 3 Retrieve temperature using 1D FFTs by applying odd symmetry to the original coefficients

Require:$\mathsf{\Theta }\in {\mathbb{R}}^{(M-2)\times (N-2)},u_{\infty }\in \mathbb{R}$ Ensure:$U\in {\mathbb{R}}^{M\times N}$ 1: ${\mathsf{\Theta }}_{ODD\_SYM}\leftarrow \mathrm{zeros}(2M,2N)$ 2: ${\mathsf{\Theta }}_{ODD\_SYM}[1:M-1,1:M-1]\leftarrow \mathsf{\Theta }$ 3: for$m=M+1,m<2M-1,m\leftarrow m+1$do 4:  ${\mathsf{\Theta }}_{ODD\_SYM}[m,:]\leftarrow -{\mathsf{\Theta }}_{ODD\_SYM}[2M-m-1]$ 5: end for 6: for$n=N+1,n<2N-1,n\leftarrow n+1$do 7:  ${\mathsf{\Theta }}_{ODD\_SYM}[n,:]\leftarrow -{\mathsf{\Theta }}_{ODD\_SYM}[2N-n-1]$ 8: end for 9: for$n=1,n<N-1,n\leftarrow n+1$do 10:  $arr\leftarrow \mathrm{fft}\left({\mathsf{\Theta }}_{ODD\_SYM}[:,n]\right)$ 11:  ${\mathsf{\Theta }}_{ODD\_SYM}[:,n]\leftarrow \mathrm{imag}\left(arr\right)$ 12: end for 13: for$m=1,m<M-1,m\leftarrow m+1$do 14:  $arr\leftarrow \mathrm{fft}\left({\mathsf{\Theta }}_{ODD\_SYM}[m,:]\right)$ 15:  ${\mathsf{\Theta }}_{ODD\_SYM}[m,:]\leftarrow \mathrm{imag}\left(arr\right)$ 16: end for 17: $U\leftarrow \mathrm{zeros}(M,N)$ 18: $U\leftarrow {\mathsf{\Theta }}_{ODD\_SYM}[0:M-1,0:N-1]$ 19: $U\leftarrow U+u_{\infty }$ 20: returnU.

3.7. Scheme 4—Odd-Symmetry 2D FFT

Finally, in this scheme the original list of coefficients is duplicated and mirrored in each direction exactly as in Section 3.6. However, this scheme also takes advantage of the even symmetry of the cosine function at $2k\pi$ ($k\in \mathbb{N}$, see Figure 6). Similar to the 1D odd-symmetry approach, the duplicated coefficients are mirrored in each direction (rows and columns), and multiplied by $-1$. The final temperature is retrieved from the real component of the 2D FFT, which considers the sine components and the cosine components (that become 0 due to the cosine symmetry). The mathematical proof of the scheme is presented in Appendix D.

Algorithm 4 presents the method used to retrieve the temperature of Equation (A16) at any given time t using a 2D FFT. Line 1 initializes the extended matrix of Fourier coefficients with $M,N$ trailing zeros. Similar to the 1D odd symmetry method, Lines 3-8 add the reversed sequences of Fourier coefficients (with negative sign) in each direction (see Figure 5). Line 9 computes the 2D FFT of the extended Fourier matrix. Line 11 extracts the real part of the FFT solution and removes the mirrored part. Finally, Line 12 applies the initial and boundary conditions. The complexity of the presented algorithm is $\mathcal{O}(MNlog(MN\left)\right)$.

Algorithm 4 Retrieve temperature using 2D FFTs by applying odd sine symmetry and even cosine symmetry to the original coefficients

Require:$\mathsf{\Theta }\in {\mathbb{R}}^{(M-2)\times (N-2)},u_{\infty }\in \mathbb{R}$ Ensure:$U\in {\mathbb{R}}^{M\times N}$ 1: ${\mathsf{\Theta }}_{ODD\_SYM}\leftarrow \mathrm{zeros}(2M,2N)$ 2: ${\mathsf{\Theta }}_{ODD\_SYM}[1:M-1,1:M-1]\leftarrow \mathsf{\Theta }$ 3: for$m=M+1,m<2M-1,m\leftarrow m+1$do 4:  ${\mathsf{\Theta }}_{ODD\_SYM}[m,:]\leftarrow -{\mathsf{\Theta }}_{ODD\_SYM}[2M-m-1]$ 5: end for 6: for$n=N+1,n<2N-1,n\leftarrow n+1$do 7:  ${\mathsf{\Theta }}_{ODD\_SYM}[n,:]\leftarrow -{\mathsf{\Theta }}_{ODD\_SYM}[2N-n-1]$ 8: end for 9: $Mat\leftarrow \mathrm{fft}2\mathrm{d}\left({\mathsf{\Theta }}_{ODD\_SYM}\right)$ 10: $U\leftarrow \mathrm{zeros}(M,N)$ 11: $U\leftarrow \mathrm{real}\left(Mat\right[0:M-1,0:N-1\left]\right)$ 12: $U\leftarrow U+u_{\infty }$ 13: returnU.

3.8. Complexity Analysis

This section presents a complexity analysis of the presented algorithms.

Table 1. Computational complexity analysis for Algorithm 2 (FFT padded with zeros). Complexity simplification rules applied are: (a) $\mathcal{O}\left(kf\right(n\left)\right)=\mathcal{O}\left(f\right(n\left)\right)$, (b) $\mathcal{O}\left(f\right(n)+g(n\left)\right)=\mathcal{O}(max(f\left(n\right),g\left(n\right)\left)\right)$.

Line	Description	Number of Operations	Dominant Term	Complexity Order
1, 2	Memory initialization			$\mathcal{O}\left(MN\right)$
4	FFT of a column	$2M+2Mlog\left(2M\right)$	$2Mlog\left(2M\right)$	$\mathcal{O}(MlogM)$
5	Extract complex part	$2M$		$\mathcal{O}\left(M\right)$
3–6	Loop through columns	$(N-2)(4M+2Mlog(2M\left)\right)$	$2MNlog\left(2M\right)$	$\mathcal{O}(MNlogM)$
8	FFT of a row	$2N+2Nlog\left(2N\right)$	$2Nlog\left(2N\right)$	$\mathcal{O}(NlogN)$
9	Extract complex part	$2N$		$\mathcal{O}\left(N\right)$
7–10	Loop through rows	$(M-2)(4N+2Nlog(2N\left)\right)$	$2MNlog\left(2N\right)$	$\mathcal{O}(MNlogM)$
11, 12	Memory initialization			$\mathcal{O}\left(MN\right)$
13	Sum of matrices	$MN$		$\mathcal{O}\left(MN\right)$
TOTAL				$\mathcal{O}(MNlogM+MNlogN)$$=\mathcal{O}(MNlog(MN\left)\right)$

, presents the computational complexity of Algorithm 2, line by line. The number of operations in a 1D FFT is of $N+NlogN$ [2,34]. As M and N grow large, the dominant term for the total number of computer operations is $2MN(log(2M)+log(2N\left)\right)$. As a consequence, the resulting complexity is $\mathcal{O}\left(MN\right(logM+logN\left)\right)$ or equivalently, $\mathcal{O}(MNlog(MN\left)\right)$.

Algorithms 1, 3 and 4, present the same structure as Algorithm 2 does. Therefore, similar complexity analysis apply for Algorithms 1, 2, 3 and 4, resulting in the same complexity order $\mathcal{O}(MNlog(MN\left)\right)$.

4. Results

This section presents the simulation and performance results of the implemented DST and FFT schemes using different state-of-the-art FFT libraries, for the solution of the laser heating problem on thin metal plates. All the simulations are executed with the parameters presented in

Table 2. Parameters for the physical simulation.

Parameter	Description	Value	Units
a	Plate width	$0.01$	m
b	Plate height	$0.01$	m
$\Delta z$	Plate thickness	$0.001$	m
$\rho$	Plate density	8030	kg/m3
$c_p$	Specific heat	574	J/(kg K)
$\kappa$	Thermal conductivity	20	W/(m K)
R	Plate reflectivity	0	1
h	Convection coefficient	20	W/(m2 K)
$u_{\infty }$	Ambient temperature	300	K
P	Laser power	500	W
r	Laser spot radius	$0.0003$	m

and the laser trajectory presented in Figure 2a. Section 4.1 presents the numerical validation of the presented schemes with respect to the brute-force algorithms [22,23,24,25]. Finally, Section 4.2 discusses the computational performance of the implemented schemes using available FFT libraries.

4.1. Numerical Validation

Section 3 validates the mathematical correctness of the presented schemes. However, a numerical validation is presented in this section with numerical and graphical results for a $0.01\times 0.01\times 0.001$ rectangular plate. Laser and material parameters are presented in Table 2 while the laser trajectory used for the tests is the same presented in Figure 2a. As a groundtruth, we choose the method presented in References [23,24,25]. This method already solves the problem presented in Equation (1) using a brute-force approach, which requires $\mathcal{O}\left(M^2{N}^2\right)$ operations (as already discussed in Section 3.3. Figure 7 plots the temperature distribution results obtained with this brute-force method.

Figure 8a plots the temperature distribution at the end of the laser trajectory, computed with the DST algorithm for a $1024\times 1024$ plate discretization. Figure 8b plots the same result computed with the zero padding FFT algorithm. The absolute error for the DST and the zero paddding FFT result (w.r.t. the brute-force approach) is presented in Figure 8c,d, respectively. The measured absolute error is below ${10}^{-10}$ (K) in both cases. It is worth pointing out that this error is evenly distributed through the 2D plate, which means that such error is not sensitive to the laser path or any other geometric features (such as the domain boundaries).

Similarly, Figure 9a,b plot the temperature distributions at the end of the laser trajectory for the 1D symmetric FFT and the 2D symmetric FFT algorithms, respectively. Figure 9c,d plot the absolute error for the 1D symmetric and 2D symmetric FFTs, respectively. Again, the error is below ${10}^{-10}$, evenly distributed through the 2D plate.

4.2. Computational Performance

This section evaluates the performance of the proposed methods under CPU and GPU hardware architectures by making use of highly optimized FFT libraries. The Python programming language includes in its scientific package ecosystem high level wrappers to C/C++ libraries. For this reason, Python has been selected for the rapid prototyping of the proposed schemes in this work.

The FFT algorithm is used in a wide range of performance demanding applications. Therefore, the optimization degree of its implementation is highly relevant. On the one hand, to target the CPU, the FTTPACK, MKL and FFTW libraries have been selected. On the other hand, to target the GPU, the cuFFT library from the NVIDIA CUDA Toolkit has been used. All these libraries make use of multi-core parallelization, vectorization instructions, efficient memory usage, and apply specific FFT algorithms to exploit the underlying hardware to the highest degree. It is worth noticing that the FFTPACK library is the only one (between the aforementioned ones) that provides an implementation of the DST.

Table 3. Selected libraries and corresponding Python packages.

Library	Python Package	Hardware
FFTPACK	scipy.fft	CPU
MKL	numpy.fft	CPU
FFTW	pyfftw	CPU
cuFFT	pyCUDA, scikit-cuda	GPU

summarizes the selected libraries along the Python wrapper packages and the targeted hardware device during the performance tests.

Two test platforms have been used for the performance measurements: (i) a desktop PC using Windows 10 with an Intel Core i5-6500 (CPU), 16 GB RAM and NVIDIA GeForce GTX 960 (GPU) and (ii) a desktop PC using Manjaro (GNU/Linux) with an Intel Core i7-4700K (CPU), 16GB RAM and NVIDIA GeForce RTX 2060 (GPU). To measure the execution times of each proposed method, each test has been computed 5 times and the minimum time has been registered.

This section is divided into four subsections. Section 4.2.1 presents the computation times using the CPU, while Section 4.2.2 presents the computational times using GPU hardware. Then, Section 4.2.3 compares the performance difference between both devices. Finally, Section 4.2.4 presents the achieved speed-up against the state of the art brute-force solution [22,23,24,25].

4.2.1. CPU Performance Measurements

Figure 10 shows the computation time of the proposed schemes using the FFTPACK, MKL and FFTW libraries, respectively. These are all implemented to be executed in general CPU hardware.

Figure 10a,b show all the proposed schemes implemented with the FFTPACK library. The FFTPACK is the only library (between the used ones in this manuscripts) that has an implementation of the DST algorithm. This DST implementation is efficient for plate discretization sizes of $512\times 512$ and $1024\times 1024$. However, its performance is not as consistent as the FFT based methods. Overall, the performance of the FFT-based methods with different input size are more stable, being the 1D odd symmetric FFT scheme the best approach using the FFTPACK library.

Figure 10c,d show the execution times of the temperature evaluation making use of the MKL library. In this case, from the FFT-based methods, both the 1D and 2D odd symmetric schemes are the most efficient.

Figure 10e,f show the computation times using the FFTW library. Although, quite close to the results obtained with the MKL library, the FFTW results are the best when using the CPU device. In this case, also both the 1D and 2D odd symmetric schemes are the most efficient.

The optimization degree achieved for the FFT algorithms with the MKL and FFTW libraries is higher. These libraries make better use of the underlying hardware, obtaining faster results than the FFTPACK library for the FFT-based methods. Results obtained with the FFTW library are slightly better (faster) than the MKL ones. However, this can be due to the usage of wrappers, as the pyfftw (FFTW) wrapper offers more control over the implementation. Nonetheless, the obtained results greatly surpass the state of art, both FFTW and MKL have shown execution times under 1s for plate sizes up to $4096\times 4096$.

4.2.2. GPU Performance Measurements

Figure 11 shows the computation time for the three proposed FFT schemes using different GPU hardware: (i) GeForce GTX 960 and (ii) GeForce RTX 2060. The implementation is based on the cuFFT (CUDA toolkit) library and makes use of the PyCUDA and scikit-cuda python packages.

While the zero padding and the 1D odd symmetric implementations produce similar results (in terms of computation time), the 2D odd symmetric scheme is by far the most performant. As the Fourier coefficients can be computed in the GPU before performing the temperature computation, the input for the FFT is already in GPU memory. It is worth to point out that the transfer of these coefficients from host memory (CPU) to device memory (GPU) is not measured.

4.2.3. Comparison of CPU and GPU Performance

Figure 12a shows an overview of the computation times for the proposed DST (FFTPACK only) and FFT (FFTPACK, MKL, FFTW and cuFFT) methods. The FFTPACK (red) is the slowest and cuFFT (yellow) is the fastest. Execution times for both the MKL (blue) and FFTW (green) libraries are similar, obtaining slightly faster results with FFTW. Overall, the GPU hardware acceleration (with cuFFT) provides a considerable speed-up, making it a good alternative to consider for simulations on plates with large discretization sizes.

Figure 12b compares the execution times of the two test platforms considering both CPU and GPU devices for the most performant FFT method: the 2D odd symmetric algorithm. This comparison shows that the GPU hardware effectively accelerates the computation time, between the fastest CPU (i7-4700K) and the slowest GPU (GTX 960), obtaining up to a $2\times$ speed-up for plate sizes larger than $1024\times 1024$. The performance difference increases as the input plate increases in size. Using more recent GPU hardware (RTX 2060) results show a bigger difference in the achievable compute time speed-up.

4.2.4. Comparison against State of the Art

Figure 13 compares the proposed FFT method with the state of the art (SoA) GPU brute-force solution [25]. The presented FFT method is much faster for plate sizes larger than $128\times 128$, showing a big difference in computing times with a plate size of $1024\times 1024$, where the FFT approach obtains a $124\times$ speed-up (2.255 s against 0.018 s). Figure 13 demonstrates the potential of the presented FFT method to perform the temperature evaluation for high resolution plate sizes ($1024\times 1024$ and beyond). Furthermore, the current brute-force solution [25] has a limit size of $1024\times 1024$ due to GPU shared memory usage, while the proposed FFT approach can compute the temperature for plates of sizes up to $4096\times 4096$ under the same GPU hardware, without resorting to out-of-core GPU memory management. For small plate sizes (smaller than $128\times 128$), the brute-force approach is faster due to the FFT method requiring extra processing of input coefficients and dispatching of kernels (scheduling time), adding a small computation overhead.

4.3. Interactive Simulator Prototype

This section presents the integration of the presented FFT-based schemes into a 3D interactive simulator for CNC (Computer Numeric Control) laser machining. The prototype integrates a physical module for the temperature computation and a geometry module that computes the plate cutting through time [23]. The physical module implements the GPU-based FFT algorithms presented in this manuscript for the temperature computation at interactive rates while the geometry module performs boolean operations as discussed in References [38,39].

The current prototype provides interactive simulation of the laser heating/cutting process, visualized as a continuous animation. Interactively, the user can inspect the plate and its temperature at any specific timestep. Furthermore, the fast computation speed enables the possibility to run different simulations with different parameters in an interactive manner. Figure 14 shows the virtual simulator for the test case discussed in this manuscript.

The development of interactive virtual worlds connected with physical objects (e.g., digital twins), has become a key technology for fast assessment of manufacturing processes [1]. In this context, an interactive CNC machine (as the integrated prototype) provides several tools to the engineer for the design of efficient CNC programs (plate, laser parameters and trajectory), reducing the requirement of real-world tests and consequently, reducing costs in terms of energy consumption, material waste, machining times, and so forth.

The performance of the simulation is very important in the decision making process and particularly, in the optimization of a given CNC program. Given a fixed time to design the CNC program, it is important to test and tune the different program parameters (such as laser parameters and trajectory). The current approach shows a significant decrease in the simulation computing time. This saving allows user-assisted and/or automated optimization programs to evaluate the different scenarios at a reasonable computational cost. The impact of such optimization on the quality of the workpiece will depend on the actual decisions and strategies applied by the engineers, supported by the simulation results.

Although not being part of the present investigation, it is worth noticing that the temperature maps on the plate help to predict and control deformations caused by thermal residual stresses.

5. Conclusions and Future Work

This manuscript presents four different schemes for the solution of the laser heating problem on thin metal plates using the DST and the FFT. The presented methods reduce the computational complexity of the problem from $\mathcal{O}\left(M^2{N}^2\right)$ to $\mathcal{O}(MNlog(MN\left)\right)$ (with $M\times N$ being the discretization size of the metal plate). It is worth noting that forced convection and radiative heat transfer are not present in the solution considered in this manuscript. The inclusion of those effects in the simulation implies a significant change in the structure of the mathematical model, which is out of the scope of this research. Overcoming of such a limitation is left as future work.

These schemes are implemented in both CPU and GPU architectures using available optimized FFT libraries. Mathematical and numerical proofs of the correctness of the schemes are presented and the numerical error is measured below ${10}^{-10}$ K (and independent of the laser trajectory).

The performance evaluation shows that the minimum achievable computation time varies in function of the used library, specially for big input sizes. Furthermore, the obtained results improve the state of the art [25] in both CPU and GPU platforms for all the proposed schemes. Specifically, using GPU hardware, the computation times for the temperature evaluation are reduced from 1 s to 0.01 s ($100\times$ faster), measured in an NVIDIA GeForce GTX 960 (GPU).

With more modern GPU hardware (GeForce RTX2060) even faster results can be acquired which shows the potential of the proposed algorithms towards real-time laser heating/cutting simulations and flexible manufacturing scenarios that require fast tool-planning capability and laser parameter optimization to easily adapt to customer order changes.

Future work includes (1) the inclusion of thermal/stress models for structural analysis of the plate after the generated high temperature gradients, (2) analysis of non-rectangular plate geometries, and (3) consideration of non-linear interactions such as temperature-dependent thermal properties, forced convection, radiation heat transfer and phase changes.