We present the use of StyleGAN, a face-synthesis generative adversarial network (GAN) developed by NVidia, as a deconvolution operator for large eddy simulation (LES) of plasma turbulence. The overall methodology, named style eddy simulation, has been integrated into the BOUT++ solver and tested on the original and modified Hasegawa–Wakatani models using different mesh sizes, 2562 and 5122, and different values of the adiabaticity parameter α and background density gradient κ. Using a LES resolution of 32 × 32 and 64 × 64, i.e., smaller resolution than the corresponding direct numerical simulation (DNS), results show convergence toward the ground truth as we tighten the reconstruction tolerance, and an algorithm complexity is compared to the of BOUT++. Finally, the trained GAN can be used to create valid initial conditions for a faster DNS by avoiding to start from nonphysical initial perturbations.
I. INTRODUCTION
Direct numerical simulation (DNS) of turbulent plasma is a very useful tool for understanding the complex evolution of edge turbulence occurring in tokamak devices. This is due to its lack of ad hoc models and, hence, high fidelity in the results. However, DNS is computationally expensive, due to fine space-temporal resolutions required. On the other hand, large eddy simulations (LESs) are much faster, being run on a coarser resolution altogether, but an ad hoc modeling of the fine scales is required. This is notoriously very challenging in plasma physics as the so-called sub-grid scale model must not only be able to capture the dissipation occurring during the direct cascade of energy1 but also complex patterns, like zonal flows, occurring as a reorganization of the turbulent regime, and the strong back-scattering of energy from the small scales, which leads to an inverse cascade.2 In fact, even for simplified cases, like the modified Hasagawa–Wakatani (HW) system,3 obtaining the correct particle flux and energy spectra can be extremely challenging, where common sub-grid scale models, like the Smagorinky model, easily fail in doing so. Some other models have been proposed4,5 and compared by Leddy6 in their thesis work, but none of these have been able to capture all the examined features (energy spectra, particle flux, and enstrophy). The key contribution of this work is to provide a fast and accurate AI-driven methodology to compute these terms, while also maintaining the robustness of classical solvers.
Across the range of AI approaches, deep learning has recently captured a huge attention in the scientific community. In particular, generative adversarial networks (GANs)7 are neural networks composed of two competing sections: a generator, which generates samples from random noise, and a discriminator, trained to recognize whether a given sample is an output of the generator or if it comes from the real dataset. Both are trained at the same time, until they achieve a so-called Nash equilibrium, where discriminator and generator are in a state in which neither can improve further. In such conditions, the discriminator may not be able to distinguish the difference between real and synthetic data, depending on the equilibrium score achieved. Following our previous work8 on Navier–Stokes equations, we present these results on the use of StyleGAN,9 an NVidia GAN for face synthesis, as a deconvolution operator for large eddy simulation (LES) of plasma turbulence. The manuscript shows how StyleGAN10 is capable of reconstructing 2D direct numerical simulation (DNS) images of the density, electrostatic potential, and vorticity fields. The time integration of these quantities occurs via the BOUT++ numerical solver11 after calculating the correct sub-grid scale quantities from the reconstructed DNS fields.
Approximate deconvolution methods (ADMs) for LES were introduced in 1999 by Stolz et al.12 using an approximate inversion of the unfiltered velocity expanded in a Taylor series. Other formulations have been proposed,13,14 with different levels of complexity but failed to capture fine details in the structures. Neural networks (NNs) have been recently proposed15 as ADM methods, and tests on turbulent channel flows have shown good agreement with DNS ground truth data. A more complex architecture, such as GANs, has been proposed16 for the same turbulent channel flow, but the time integration relies on a recurrent neural network (RNN). Good results were obtained for steady conditions but, in general, training RNN on such tasks is difficult to succeed due to the high compression of the information embedded into the latent space. A LES-GAN based model has also been proposed,17 where a cycleGAN has been used for three different tasks: (i) to recover the original flow field from filtered data; (ii) to reconstruct full-resolution fields, using partially measured data from the DNS of turbulent channel flows; and (iii) to generate a DNS-resolution flow field from LES data. Again, good agreement with DNS data have been found to prove the capability of GANs, in general, to learn the complex highly non-linear correlations embedded into the NS equations, but no applications to plasma turbulence has been carried out so far using this methodology.
In StyleGAN, each block of the generators would produce an image of a given resolution. As in painting, each image has a content and a style. A common example in generative AI literature18 is van Gogh's style applied to the nocturne sky, which gives the famous “Starry Night” canvas painting. In the same way, the style of each generator block can be changed according to the latent space. In the case of turbulence, the contents are the turbulence structures, and the style can be linked to the Reynolds number (and other characteristic numbers), with fine vortices for high Reynolds and larger blobs for lower values. Coarse, medium, and fine details can be changed via linear interpolation between the different styles, as shown in Fig. 1 (Multimedia view). The first use of StyleGAN for turbulent flow appears in the work of Gupta et al.,19 where it has been used for weather forecast simulations achieving an order of magnitude larger high-fidelity images with accurate energy spectra. However, the use of the different styles was not investigated. In the field of plasma turbulence, Greg et al.20 proposed a novel machine learning-based LES technique based on a potential-surrogate correction. However, to the best of the authors' knowledge, there are no applications of GANs to plasma turbulence.
Linear interpolation between two vorticity fields at different scales (styles). It can be seen that changing the coarse styles in the generator results in drastic changes in the DNS field, while modifying the fine style results in small differences at full DNS resolution. Multimedia available online.
Linear interpolation between two vorticity fields at different scales (styles). It can be seen that changing the coarse styles in the generator results in drastic changes in the DNS field, while modifying the fine style results in small differences at full DNS resolution. Multimedia available online.
In this paper, we propose to test the style eddy simulation (StylES)8 algorithm for plasma turbulent flows using the Hasegawa–Wakatani and modified Hasegawa–Wakatani21 2D turbulence models (hereafter, HW and mHW, respectively). We integrated the methodology into the BOUT++ solver to investigate the phenomena occurring in the divertor region of Tokamak reactors. The work presented and investigated here is in 2D scenarios, but there is no theoretical limit to extend this work to other 3D turbulence scenarios. The 3D models are outside of scope for this paper but are in the pipeline for the potential future work. Instead, in this paper, we will present the main novelties of our current work, which can be described as the use of StylES for plasma turbulent simulations and potential speedup for large systems; its validity when interpolating between different latent spaces, which is required to match the BOUT++ LES field; the use of the GAN generator for initial conditions of DNS; and an improvement of the StylES algorithm itself to allow better and faster convergence toward ground truth.
We tested the HW and mHW models on two different resolutions, 2562 and 5122, and compared the results with the ground truth DNS obtained using the BOUT++ solver. The time integration occurs after a match between the LES fields produced by the solver and the GAN-LES fields controlled by a tolerance εREC. Results show convergence toward the ground truth DNS as , and all the main properties of the flow are recovered. Moreover, for the StylES algorithm, we observe a complexity of , where N is the number of points per geometrical dimension, compared to the of BOUT++, i.e., for larger systems, we obtain larger speedup. However, as optimization of the current solver has not yet been carried out, benchmarking of the different tests is outside of this manuscript's scope and will be described in the successive work. The primary intention here is to prove the validity of the methodology and the integration with a common solver used in the community of plasma turbulence simulation.
The paper continues as follows: Sec. II presents the theoretical background and the StylES methodology. Section II B explains how training data for the GAN has been produced, and Sec. III shows the results on the different tests and scenarios with current limitations and validity. Conclusion and future work are presented in Sec. IV. The code used to generate the results is available on the GitHub BOUT++ and StylES repositories, both need to be downloaded and linked following the instructions on StylES repository README file.
II. METHODOLOGY
Here, we give a quick resume of the StylES algorithm to reconstruct the fluid flow from a LES field at a given time t0. More details can be found in the work of Castagna and Schiavello.8
A. Theoretical background
The StylES idea is to reconstruct the n, , and ζ terms at DNS resolution from their corresponding , and , find the nonlinear terms (5), and then solve the filtered Eq. (4). Note that only n and could be reconstructed, as ζ is obtained as the Laplacian of . However, the GAN does not guarantee smooth second-order derivatives, and some small high-frequency oscillations could be captured and enhanced during time integration. Therefore, we reconstruct all three fields.
The full methodology relies on the following three main assumptions:
-
The existence and uniqueness of the solution. This has been recently proven for the HW system of equations,23 and it is essential to guarantee the unique correlation between LES fields and DNS fields when an invertible filter is used. If this condition is not satisfied, the problem becomes ill-posed.
-
The smoothness and continuity of the GAN manifold. It can be proven that under certain conditions,24,25 the generated StyleGAN images from a latent space manifold map to a smooth manifold . This condition is essential to guarantee the convergence during the latent space search.
-
The linear interpolation on the latent space always produces a valid DNS field. In the author's knowledge, this has not yet been proven, however, from our experiments, we have found this to always be true and as such we raise this to the level of conjecture.
These three conditions have been confirmed a posteriori by the observation of the search in the latent space, which converges in a fast manner toward the correct solution when searching for the correct field at a later time step, . This search in the latent space is fruitful for up to the first 10k steps. Afterward, we observe scenarios where this search can become very slow, and current investigation is under way to understand the root of this undesirable effect.
B. Dataset
Taking Leddy's thesis as a reference,6 the simulation size of the system is , while the parameters α, κ, , and νn are defined according to Table I. The different values of hyper-viscosity are necessary to have a match between the energy spectrum smallest scales and the mesh resolution (see Fig. 2) and avoid a null filter from DNS to LES. For the mHW, fully periodic boundary conditions are used in both directions in order to simplify the GAN construction which should, otherwise, consider the non-periodicity during the different convolutional layers.
Physical properties defined for each test case.
Type . | N . | α . | κ . | . |
---|---|---|---|---|
HW | 2562 | 1 | 0.5 | |
HW | 5122 | 1 | 1 | |
mHW | 2562 | 1 | 1 | |
mHW | 5122 | 1 | 1 |
Type . | N . | α . | κ . | . |
---|---|---|---|---|
HW | 2562 | 1 | 0.5 | |
HW | 5122 | 1 | 1 | |
mHW | 2562 | 1 | 1 | |
mHW | 5122 | 1 | 1 |
Energy spectra for the different test cases. As expected, the slope in the energy spectra follows the power low typical of the energy cascade in 2D turbulence.2
Energy spectra for the different test cases. As expected, the slope in the energy spectra follows the power low typical of the energy cascade in 2D turbulence.2
The simulation is initialized with an unphysical perturbation (see Fig. 4.2 of Leddy's thesis6), which then evolves to reach a statistically steady state (Fig. 3). Training data are then gathered once the flow is statistically steady. A comparison of the energy spectra vs time is presented in Fig. 3: it can be noted that the evolution of initial nonphysical perturbations is different for the test cases. The different dataset have then a different final time Tf, see Table II, but the same number of trajectories Nruns. We start collecting samples from Ts every for a total Ns samples. The choice of is such that the variation in similarity structural index metric (SSIM)26 is always 10%. The last two columns show the overall computational effort Ceff in node per hours, where 1 node of ScafellPike supercomputer at Hartree Center contains a two socket of 16-cores Intel Xeon Gold processors, and the disk space occupied by the data.
Energy vs time for each test case showing the different evolution of the artificial initial perturbations.
Energy vs time for each test case showing the different evolution of the artificial initial perturbations.
Computational effort and memory usage for each test case.
Type . | N . | Ts . | Tf . | . | Nruns . | Ns . | Ceff . | Disk (GB) . |
---|---|---|---|---|---|---|---|---|
HW | 2562 | 501 | 1000 | 10 | 100 | 5000 | 5.8 | 7.4 |
HW | 5122 | 201 | 1000 | 10 | 100 | 8000 | 111 | 47 |
mHW | 2562 | 201 | 400 | 4 | 100 | 5000 | 5.8 | 7.4 |
mHW | 5122 | 201 | 400 | 4 | 100 | 5000 | 111 | 30 |
Type . | N . | Ts . | Tf . | . | Nruns . | Ns . | Ceff . | Disk (GB) . |
---|---|---|---|---|---|---|---|---|
HW | 2562 | 501 | 1000 | 10 | 100 | 5000 | 5.8 | 7.4 |
HW | 5122 | 201 | 1000 | 10 | 100 | 8000 | 111 | 47 |
mHW | 2562 | 201 | 400 | 4 | 100 | 5000 | 5.8 | 7.4 |
mHW | 5122 | 201 | 400 | 4 | 100 | 5000 | 111 | 30 |
C. GAN and deconvolution operator training
The neural networks used in our study are shown in Fig. 4. As our GAN [Fig. 4(a)], we use the StyleGAN architecture.9 As in our previous work,8 we use a variant called MSG-StyleGAN (where MSG refers to multi-scale gradients), since this is more robust during training compared to StyleGAN. This works by converting the feature map at each layer of the generator to a three channel image (n, , and ζ), which is then passed to the corresponding layer in the discriminator. This will allow the flow of gradients from the discriminator to the generator at multiple scales, facilitating the learning of the dataset features.
Overview of neural network architectures used in this study. Panels show (a) the GAN model for generating DNS fields and (b) the convolution operator, which is inverted to perform deconvolution at inference time. (c) The latent space interpolation to find a field that satisfies (11). In (c), the BOUT++ operations are given in blue text, whereas the black text refers to steps of the StylES algorithm, which occurs on the GPU.
Overview of neural network architectures used in this study. Panels show (a) the GAN model for generating DNS fields and (b) the convolution operator, which is inverted to perform deconvolution at inference time. (c) The latent space interpolation to find a field that satisfies (11). In (c), the BOUT++ operations are given in blue text, whereas the black text refers to steps of the StylES algorithm, which occurs on the GPU.
We trained the generator and discriminator of StyleGAN with the Adam optimizer. The learning rates were for the generator and for the discriminator (a ratio of four between the two values). This is referred to as the two timescale-update rule (TTUR),29 which improves the discriminator's convergence as its weights can adapt to changes in patterns produced by the generator quicker than the generator can change the patterns produced. The training is stopped when a valid Nash equilibrium is achieved. In our case, when the energy spectra of the generated DNS fields are within a 5% difference from the dataset.
As the final training value of is never exactly zero, a correction term has to be added in the latent space search loss function to compensate for it, as described in Sec. II D.
These operations and training of the filter are key to our methodology, as they allow us to accurately integrate the flow fields in time at lower resolutions without implicating a loss in accuracy traditionally seen in other coarse solvers.
D. The StylES algorithm
The deconvolution operator used in StyleGAN is essentially made of a series of upscaling layers to increase the resolution of the LES, i.e., we double the mesh resolution adding transposed convolutions.31 Other operations, like the adaptive instance normalization (AdaIN)32 and noise injection, allow us to control the style of each block, adding the missing reconstruction terms from the upscaling. For a given value of the intermediate latent space and for a given value of the input noises , the operator is a single-valued function, which satisfies the required conditions of being fully invertible.
Some other caveats are listed here:
-
During the training of StyleGAN, we use a randomized noise to avoid mode collapse (where the GAN fails to learn the full dataset distribution of images and repeatedly outputs only a small set of images), in line with the original StyleGAN work by Karras et al.9 This consists into injecting a different noise in every layer at every step of the training. However, during inference, the noise is fixed; otherwise, the search into the latent space will fail due to the continuous change of direction imposed by the different noises.
- The output of StyleGAN is forced to be normalized between −1 and 1, i.e., , where indicates the following normalization operation:This condition, together with the conservation property of the LES filter , leads to
which can be used to rescale the LES field to the DNS one.
It follows that the correct absolute value of the DNS field is obtained by rescaling the normalized one with same minimum and maximum values of the LES field.
- All three fields need to be null on average across the full domain. This is due to the quasi-neutrality condition, for which
The full StylES procedure is then summarized in Algorithm 1.
The StylES algorithm.
Require: a trained StyleGAN based generator ; an initial latent space , which gives a DNS field as a starting point; a trained filter F from to , a scaling factor K (we set K = 10 in all our simulations) |
1: infer field and scale by K |
2: subtract the average values to get |
3: take |
4: while time steps < total time steps do |
5: find filtered nonlinear terms |
6: solve filtered NS equations to find |
7: while do |
8: infer field, scale by K and substract the average values |
9: find |
10: adjust via backpropagation keeping weights constant |
11: end while |
12: take = |
13: increment time step |
14: end while |
Require: a trained StyleGAN based generator ; an initial latent space , which gives a DNS field as a starting point; a trained filter F from to , a scaling factor K (we set K = 10 in all our simulations) |
1: infer field and scale by K |
2: subtract the average values to get |
3: take |
4: while time steps < total time steps do |
5: find filtered nonlinear terms |
6: solve filtered NS equations to find |
7: while do |
8: infer field, scale by K and substract the average values |
9: find |
10: adjust via backpropagation keeping weights constant |
11: end while |
12: take = |
13: increment time step |
14: end while |
E. Integration with BOUT++
The training of the MSG-StyleGAN occurs on 1 NVidia V100 GPU and takes 12 and 24 h for the 2562 and 5122 test cases, respectively.
Note that we train and infer in single precision float32 for speedup purposes, but BOUT++ runs in double precision float64. There will be a rounding error which, in our experiments, does not seem to affect the overall results. If double precision were to be used the timing would be theoretically doubled. Moreover, each channel is normalized by its minimum and maximum values. The reason is to improve the stability of the GAN during the training. This operation will break the correlation , which will be reinstated by BOUT++ at the LES solution. However, to avoid a long search in the latent space at the first time step to adjust to the correct potential field, only the Euclidean distance between n and ζ is considered in Eq. (11). We will see from the results that the GAN potential field will follow the vorticity.
III. RESULTS
We first present the results on the mHW 2562 resolutions with details on the initial flow conditions, energy spectra, and impact of the reconstruction tolerance to the centerline trajectories of each field. We will then focus on the rest of the test cases. Note that the DNS results are obtained starting from a StyleGAN field. This proves that, apart from the initial adjustment in the electrostatic potential, the GAN can be used to generate a valid field for DNS. This can save considerable computational effort compared to an initial condition based on nonphysical disturbances.
A. mHW 2562 resolution
An example of reconstruction from the LES 322 vorticity field to the 2562 DNS field is given in Fig. 5. We then run the integrated BOUT++ with StylES solver for ten time units (∼10k time steps) using the following different reconstruction tolerances εREC: 1.0, 0.5, and 0.25. We then compared with the DNS ground truth the initial fields at time t = 0.01 and corresponding energy spectra, and the center plane trajectory of each field vs time to check the impact of the tolerance.
Figure 6 shows the differences at t = 0.01 between the inference of the trained StyleGAN and the actual DNS values when using . The main differences are in the potential fields. As previously mentioned, this is due to the lack of StyleGAN in correctly capturing the correlation, and hence, a drastic change occurs at the first time step of the DNS solution. The mean square error (MSE) is 0.038, and the structural similarity index measure (SSIM) is 0.73. Figure 7(a) shows a comparison of the energy spectra at time t = 0.01, where small discrepancies can be observed due to the potential field. Figure 7(b) shows the spectra at t = 10, where the large scales begin to slightly deviate from the DNS compared to the spectra at t = 0.01 [Fig. 7(a)].
Comparison between DNS and StylES fields at time t = 0.01 after latent space interpolation using . Panels show (a) density n, (b) electrostatic potential , and (c) vorticity ζ. Differences are in absolute values.
Comparison between DNS and StylES fields at time t = 0.01 after latent space interpolation using . Panels show (a) density n, (b) electrostatic potential , and (c) vorticity ζ. Differences are in absolute values.
Energy spectra for DNS and StylES at time: (a) t = 0.01 and (b) t = 10.
Figure 8 shows the trajectory of n, , and ζ for the first ten time units at different values of reconstruction in the mHW 2562 test case. As expected, the distance between the DNS trajectory and the reconstructed decreases as we tighten the tolerance: for , the solver never calls the StylES algorithm and then a flat (red) line is observed. As we reduce the tolerance ( , blue line), the algorithm kicks off around 5 and, after an initial adjustment, it tends to recover toward the DNS trajectory. Finally, with , the algorithm kicks at 1 , and the recovery is very fast after 7 .
Time evolution of n, , and ζ fields with respect to DNS values for different tolerances εREC for the mHW 2562 test case. Panels show (a) density n, (b) electrostatic potential , and (c) vorticity ζ. Values are taken in the domain center.
Time evolution of n, , and ζ fields with respect to DNS values for different tolerances εREC for the mHW 2562 test case. Panels show (a) density n, (b) electrostatic potential , and (c) vorticity ζ. Values are taken in the domain center.
Note that εREC can be seen as a stopping criterion for our algorithm in matching the LES fields and reconstructing the DNS field. The larger εREC is, the larger the allowed loss function is, as seen in Eq. (10). As noted above if , then the algorithm is rarely called, and the speed of the procedure matches the implicit LES for the given resolution. As the tolerance decreased, steps 7–11 in Algorithm 1 will take longer to complete, but this will ensure outputs that are increasingly closer to the ground truth DNS. As such, a value of εREC can be chosen as a compromise with regard to accuracy requirements and/or time constraints for running the algorithm.
B. Other test cases
Now, we will demonstrate our methodology on the remaining test cases (Table I), using a reconstruction tolerance of 0.25 and highlighting the evolution of four key quantities of interest with time: the total energy E, the enstrophy ξ, the particle radial flux Γr, and particle poloidal flux Γp. Note that we use the absolute value of the particle fluxes due to the log scale of the plot.
Figure 9(a) shows these values for the HW 2562 test case: the energy and enstrophy computed by StylES show good agreement with the DNS data and stable solutions. The fluxes are more sensitive and show some oscillations with time in the StylES results. Similar fluctuations in radial and poloidal fluxes were reported by Leddy6 for several subgrid models. However, some larger differences are found at higher resolution [see Fig. 9(b)], with some marginal recovery later in time. Finally, Fig. 9(c) shows the discrepancies for the mHW 5122, especially in the particle fluxes, most likely due to the wide difference in the initial electrostatic potential, also observable in the energy differences. Error accumulation and oscillations in Figs. 9(a) and 9(b) may be explained by the larger LES numerical discretization error and the reconstruction error introduced by . In the StylES framework, this may be reduced by a lower εREC tolerance. Alternatively, Sirigano et al. trained their model by solving the LES equations during training and evaluating against DNS.34 This gave improved agreement with filtered DNS for decaying isotropic (Navier–Stokes) turbulence, compared to a model trained on filtered DNS data.
Values of energy E (black), enstrophy ξ (red), absolute radial flux (blue), and absolute poloidal flux (green) vs time. Panels show (a) HW 2562, (b) HW 5122, and (c) mHW 5122 test cases. The DNS values are the solid lines, while the StylES values are the dashed values.
Values of energy E (black), enstrophy ξ (red), absolute radial flux (blue), and absolute poloidal flux (green) vs time. Panels show (a) HW 2562, (b) HW 5122, and (c) mHW 5122 test cases. The DNS values are the solid lines, while the StylES values are the dashed values.
C. Performance
The current version of the StylES algorithm has not yet been optimized, i.e., there are many improvements that can be implemented, like: (a) reducing the CPU-GPU communication by overlapping computation with communication; (b) avoiding repeated computations during Arakawa discretization; and (c) using optimized graphs for inference via NVidia TensorRT technology. This work is outside of the scope for the current paper and will be presented in a separate manuscript, for the time being, we only report that a similar speed between DNS and StylES is achieved in the 5122 test case, while for lower resolutions, we found the DNS faster and, hence, more convenient to run. However, we have carried out a scalability study to show how the performance will improve with the number of mesh points despite the lack of optimization. In fact, as it is enough to add only one StyleGAN block to double the mesh resolution, our methodology shows an algorithmic complexity of , whereas BOUT++ has a complexity of . This can be clearly seen from Fig. 10 where the time per time step for BOUT++ and BOUT++ with StylES are presented. Note that the main contribution to the computational effort in StylES is due to the search into the latent space, which usually occurs within 5 iterations. Some improvements on the convergence speed are also part of the optimization processes mentioned above. Moreover, as most of the relevant plasma turbulence occurs in 3D configuration space, it is the author's intention to move to a full 3D system. In principle, this would require a 3D GAN, to make sure proper structures of turbulence are learned. However, the number of layers and neurons would grow with the cube of the problem, dramatically limiting the finest resolution. A different approach, instead, would be to rely on a 2D GAN assuming that the turbulent effects are quasi-3D, i.e., filaments of turbulence do not bend on themselves or backward. In this scenario, it is possible to reconstruct a 3D structure from a series of 2D independent planes. This would not only avoid the use of a very large NN but also speed up the LES calculation even more compared to the DNS.
Scalability of BOUT++ vs StylES with the number of points. Dashed lines indicate the theoretical N2 and scaling.
Scalability of BOUT++ vs StylES with the number of points. Dashed lines indicate the theoretical N2 and scaling.
IV. CONCLUSIONS
We presented a novel AI deconvolution operator for large eddy simulations of plasma turbulence using the latest state of the art generative adversarial network. We tested the methodology on the Hasegawa–Wakatani and modified Hasegawa–Wakatani equations, for different values of grid resolution and input parameters, and found that we converge toward the correct ground truth DNS dataset as we reduce the tolerance on the reconstruction procedure. However, some discrepancies are found in the higher resolution results, and further investigation has been currently carried out. Future works will be to test larger systems (≥ ), optimize, and move to multi-GPU for 3D plasma turbulence simulations relevant to future fusion power plants. However, the main intention of this work is to create a surrogate model to accelerate plasma turbulence solvers, wherever non-linear terms appear and can be obtained via reconstruction. Moving to the Hasegawa–Wakatani 3D will be the next step via some hypotheses highlighted in the Performance section, followed by the upgrade to the Hermes-3 (Ref. 35) model. Then, expanding it to the full divertor geometry, we hope to provide a fast tool to accelerate simulations of edge turbulence.
ACKNOWLEDGMENTS
This work was funded by the FARSCAPE and ESCAPE projects, a collaboration led by UKAEA with the UKRI-STFC Hartree Centre.
AUTHOR DECLARATIONS
Conflict of Interest
The authors have no conflicts to disclose.
Author Contributions
J. Castagna: Methodology (lead). F. Schiavello: Investigation (equal). L. Zanisi: Methodology (supporting). J. Williams: Investigation (supporting).
DATA AVAILABILITY
The data that support the findings of this study are available from the corresponding author upon reasonable request.