LPC3D: An Enhanced Parallel Software for Large-Scale Simulation of Adsorption in Porous Carbons and Supercapacitors

This paper introduces an enhanced, parallel implementation of the LPC3D software in Python using PyStencils to enable efficient mesoscopic simulations of ion adsorption and spectroscopic properties in large-scale, heterogeneous porous carbon supercapacitors on both CPU and GPU architectures.

The Gist

The Big Picture: Simulating a "Super-Storage" Battery

Imagine you have a supercapacitor. Think of it not as a battery, but as a sponge that stores electricity. Instead of holding water, this sponge holds charged particles (ions) from a liquid electrolyte. When you plug it in, the sponge soaks up the ions; when you unplug it, the sponge squeezes them out to power your device.

The problem is that real-world sponges (porous carbon electrodes) are messy. They aren't perfect, uniform holes. They have tiny cracks, big gaps, and particles of all different sizes.

For a long time, scientists could only simulate these sponges on a microscopic scale—like looking at a single grain of sand under a microscope. They could see how ions moved in one tiny hole, but they couldn't see how the whole sponge behaved. It was like trying to understand a traffic jam in a whole city by only watching one car in a single driveway.

Enter LPC3D: This paper introduces a brand-new, super-fast software tool that allows scientists to simulate the entire sponge, or even a whole battery, at a much larger scale.

---

The Problem: The "Pixel" Limit

Imagine trying to paint a massive mural of a city.

• The Old Way (Microscopic Simulations): You were forced to paint every single brick on every single building. You could only paint a tiny 1-inch square before your computer crashed. You knew exactly what the bricks looked like, but you had no idea what the whole city looked like.
• The New Way (LPC3D): The new software lets you paint the whole city. You can see how traffic flows from one neighborhood to another, how the whole system reacts to a storm, and how the "sponge" holds water across a whole building.

The Solution: A "Digital Lattice"

The researchers built this software using a clever trick called a Lattice Gas Model.

Think of the battery's interior as a giant 3D grid of Lego blocks (a lattice).

• Some blocks are solid carbon (walls you can't walk through).
• Some blocks are empty space (rooms where ions can walk).
• Some blocks are special rooms where ions like to hang out because the "energy" is better there.

The software simulates millions of these "ions" hopping from one Lego block to the next. It calculates:

1. How many ions get stuck in the sponge (Adsorption).
2. How fast they run around (Diffusion).
3. What they "sound" like to a magnetic scanner (NMR Spectra).

The Magic Upgrade: From "One Worker" to "Super-Team"

The original version of this software was written in a language that was like having one very slow worker painting the mural. It could only handle a tiny 1-inch square.

The new version (LPC3D) is like hiring thousands of workers who can paint simultaneously.

• The Tool: They used a special Python tool called PyStencils. Think of PyStencils as a "magic translator." You tell it the rules of the game in simple math (like "if an ion is here, it can move there"), and PyStencils instantly translates that into super-fast code that runs on powerful computer chips (CPUs) or graphics cards (GPUs).
• The Result: They went from simulating a tiny speck (1 cubic micrometer) to simulating a whole battery electrode (hundreds of micrometers). That's a jump from looking at a single grain of sand to looking at a whole beach.

What Did They Discover? (The "Monolith" vs. The "Film")

To test their new tool, they simulated two different types of battery electrodes:

1. The Monolith: Imagine a solid block of porous rock. It's one giant, continuous sponge.
2. The Film: Imagine a pile of sand grains (carbon particles) glued together. There are gaps between the grains where the liquid can flow freely.

The Findings:

• The "Ghost" in the Machine: In the "Film" version, the gaps between the sand grains act like a highway. Ions can zip through these gaps much faster than in the solid "Monolith."
• The Sound of the Battery (NMR): The researchers used the software to predict what the battery would "sound" like to a Magnetic Resonance machine (like an MRI for atoms).
  • The Monolith sounded like a single, clear note.
  • The Film sounded like a complex chord with extra echoes. This is because the ions were bouncing between the "highway" (gaps) and the "rooms" (pores), creating a mix of signals.

Why Does This Matter?

This software is a game-changer for two reasons:

1. Realism: It finally lets scientists model batteries the way they actually exist in the real world (messy, big, and full of different-sized holes), not just in a perfect, tiny lab box.
2. Speed: It's fast enough to run on standard computers or supercomputers, allowing researchers to test hundreds of different battery designs in a day to see which one stores the most energy.

The Bottom Line

The authors have built a digital twin for supercapacitors. They took a tool that was too slow to be useful for big problems and supercharged it. Now, they can watch how electricity flows through a whole battery, helping engineers design better, faster, and more efficient energy storage systems for our future devices and electric cars.

Technical Summary

1. Problem Statement

Electrochemical Double-Layer Capacitors (EDLCs), or supercapacitors, rely on ion adsorption at the interface between porous carbon electrodes and electrolytes. Understanding the relationship between the microstructure of these electrodes (pore size distribution, particle size, heterogeneity) and macroscopic performance (capacitance, diffusion, NMR spectra) is critical.

However, existing simulation methods face significant limitations:

• Molecular Dynamics (MD): While accurate for microscopic phenomena, MD is computationally expensive. It is typically limited to systems of a few nanometers and a few nanoseconds, which is insufficient to capture the heterogeneity of real experimental materials (micrometer-scale particles, broad pore size distributions) or the timescales of charging (milliseconds to seconds).
• Previous Lattice Models: The original LPC3D software addressed this by using a lattice-gas model to simulate mesoscopic scales. However, the initial version was a serial C code limited to systems of $\sim 100,000$ sites ($\sim 1 \mu m^3$), representing only a single small particle, rather than a full electrode or device.

2. Methodology

The authors present a complete re-implementation of LPC3D to overcome computational bottlenecks and enable large-scale simulations.

• Model Framework: The software utilizes a 3D lattice-gas model where the porous carbon matrix is represented by inaccessible lattice sites, and the electrolyte (ions and solvent) by mobile particles on accessible sites.

  • Diffusion: Modeled via Kinetic Monte Carlo (KMC) using Metropolis acceptance rules based on site-specific free energies ($E_i$) derived from MD simulations.
  • NMR Spectra: Calculated by tracking the evolution of local magnetic fields (Larmor frequencies $\nu_i$) as particles diffuse, generating Free Induction Decay (FID) signals which are Fourier transformed to obtain spectra.
  • Diffusion Coefficients: Computed using the moment-propagation method (a recursive scheme), which is significantly more efficient than generating random trajectories for heterogeneous systems.

• Software Implementation (PyStencils):

  • The code was rewritten in Python using the PyStencils framework.
  • PyStencils takes symbolic mathematical definitions of update rules (stencils) and automatically generates optimized C++ (for CPU) and CUDA (for GPU) code.
  • This approach allows for high performance portability, enabling the same Python code to run efficiently on both CPU clusters (using OpenMP/MPI) and GPUs.

• Workflow:

  1. Initialization: Reading input parameters (geometry, pore distribution, electrolyte properties).
  2. Equilibration: Updating local densities to reach a steady state (Boltzmann distribution) based on applied potential.
  3. Propagation: Time-dependent simulation to calculate dynamic quantities (diffusion, FID signals).
  4. Output: Generating diffusion coefficients, adsorption quantities, and NMR spectra.

3. Key Contributions

• Scalability: The new implementation allows for the routine simulation of systems with hundreds of millions of lattice sites (up to $700^3 \approx 343$ million sites). This represents a scale increase from $\sim 1 \mu m^3$ (single particle) to $\sim 1000 \mu m^3$ (full supercapacitor devices with realistic electrode thicknesses of 200–500 $\mu m$).
• Performance:
  • Linear Scaling: Runtime and memory usage scale linearly with the number of lattice sites, as expected for stencil operations.
  • Hardware Efficiency: Strong scaling tests on HPC clusters (CALMIP and VEGA) show good efficiency up to 16 processes, with GPU implementations (NVIDIA V100/A100) offering significantly faster runtimes for large systems compared to CPUs.
• Open Source: The software is released as an open-source package (lpc3d) available via PyPI and GitHub, including user manuals and examples.

4. Results

The authors applied the new LPC3D to simulate supercapacitors with two distinct electrode morphologies:

1. Monolithic Electrodes: A continuous porous carbon matrix.
2. Film-like Electrodes: Aggregates of porous carbon particles separated by bulk electrolyte regions (mimicking experimental electrode fabrication).

Key Findings:

• Adsorption & Capacitance: Monolithic electrodes showed a larger change in adsorbed ion quantity between 0V and 2V compared to film electrodes. In film electrodes, the bulk-like regions between particles do not contribute to charge storage, effectively reducing the active material volume and influencing capacitance.
• Diffusion Coefficients: Diffusion coefficients were generally close to bulk values in the specific setup used (uniform residence time). However, slight variations were observed based on ion concentration and electrode morphology, suggesting that pore filling heterogeneity impacts diffusion.
• NMR Spectroscopy:
  • Monoliths: Produced a single, sharp peak corresponding to the dominant pore size distribution.
  • Films: Produced complex spectra with multiple peaks and shoulders. These features arise from the exchange of ions between "bulk-like" regions (0 ppm) and "particle" regions (-8 ppm), as well as exchange between different pore sizes.
  • Dynamics: The study demonstrated that residence time (ion dynamics) significantly affects NMR line shapes. Faster exchange (shorter residence time) leads to peak merging, while slower exchange preserves distinct peaks. This highlights the necessity of accurate dynamic modeling to interpret experimental NMR data.

5. Significance

• Bridging Scales: LPC3D successfully bridges the gap between microscopic molecular simulations and macroscopic experimental observations, allowing researchers to simulate realistic device geometries that were previously inaccessible.
• Interpretation of Experiments: The ability to simulate full NMR spectra for complex, heterogeneous structures provides a powerful tool for interpreting experimental data, particularly regarding the distinction between ions in bulk electrolytes versus confined pores.
• Design Optimization: By simulating full supercapacitor devices, the software enables the investigation of how electrode morphology (monolith vs. film, particle size distribution) impacts performance metrics like capacitance and ion transport, guiding the design of more efficient energy storage materials.
• Future Directions: The authors suggest future improvements, such as using Molecular Density Functional Theory (MDFT) for faster parameter generation and refining the model to better capture confinement-induced diffusion slowdowns.