⚡ electrical engineering

An Array Decomposition Method for Finite Arrays with Electrically Connected Elements for fast Toeplitz Solvers

This paper presents a memory-efficient array decomposition method for finite, electrically connected antenna arrays that leverages a multilevel block Toeplitz structure to reduce impedance matrix storage complexity from $\mathcal{O}(N_x^2 N_y^2)$ to $\mathcal{O}(N_x N_y)$ , enabling faster Method of Moments solutions via an in-house inverse solver.

Original authors: Lucas Åkerstedt, Harald Hultin, B. L. G. Jonsson

Published 2026-02-18

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Lucas Åkerstedt, Harald Hultin, B. L. G. Jonsson

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: The "Too Big to Fit" Puzzle

Imagine you are trying to design a massive wall of speakers (an antenna array) for a next-generation 6G mobile network. This wall isn't just a few speakers; it's a grid of thousands of them, all connected together like a giant spiderweb.

To make sure this wall works perfectly, engineers use a powerful computer simulation called the Method of Moments (MoM). Think of this simulation as a giant calculator that figures out how electricity flows through every single wire and triangle on the surface of the antenna.

The Catch:
If you try to simulate a huge array (say, 32 by 32 elements) using traditional methods, the computer needs to remember the relationship between every single piece and every other single piece.

For a small array, this is easy.
For a huge array, the amount of data required is like trying to store a library of every book ever written in a single shoebox. The computer runs out of memory (RAM) and crashes.

The paper says: "We found a way to shrink that shoebox down to the size of a matchbox."

The Solution: The "Lego Brick" Strategy

The authors (Lucas, Harald, and B. L. G.) realized that these antenna arrays aren't random messes. They are built with symmetry. If you move one block of the array to the right, it looks exactly the same as the block next to it.

Instead of calculating the whole giant wall from scratch, they proposed a Decomposition Method. Here is how it works, using a Lego analogy:

1. The Nine-Component "Master Set"

Imagine you want to build a huge Lego castle. Instead of counting every single brick in the final castle, you realize the castle is made of just nine unique types of Lego pieces:

1 Center Piece: The main block in the middle.
8 Surrounding Pieces: The blocks that go on the top, bottom, left, right, and corners.

The paper proposes breaking the antenna down into these nine specific components. Even if your final antenna is 100x100, you only need to calculate the physics for these nine unique pieces.

2. The "Magic Mirror" (Toeplitz Structure)

In math, there is a special pattern called a Toeplitz matrix. Think of it like a staircase or a repeating wallpaper pattern.

In a normal calculation, the computer has to do a unique math problem for every single pair of bricks.
In this new method, because the array is symmetrical, the computer realizes: "Hey, the interaction between Brick A and Brick B is exactly the same as Brick C and Brick D, just shifted over."

So, instead of doing 1,000,000 unique math problems, the computer only does a few hundred. It calculates the "rule" for the pattern once, and then just copies and shifts it.

3. Handling the "Glue" (Electrically Connected Elements)

The tricky part of this paper is that the antenna elements are electrically connected. Imagine the Lego bricks are glued together with super-strong conductive glue. The electricity flows across the seams.

Old Problem: Previous methods struggled to handle these "glued" seams without breaking the symmetry pattern.
New Fix: The authors created a special algorithm that looks at the "seams" (shared triangles) between the nine components. They figured out how to map these seams so the "Magic Mirror" pattern still works, even with the glue.

The Results: From a Warehouse to a Backpack

The paper demonstrates this method with some impressive numbers:

The Old Way: To simulate a 32x32 array, you would need 1.97 Terabytes of memory. That's like trying to fit a massive warehouse full of data into your laptop. It's impossible for most computers.
The New Way: Using their nine-component "Lego" method, they only needed 3.97 Gigabytes. That's like fitting the same data into a standard backpack.

What can you do with this?

Faster Design: Engineers can now design huge, complex antennas in minutes instead of days.
Better Performance: They can calculate exactly how the antenna will beam signals (Far-field) and how it handles interference (Scattering parameters).
Mix and Match: They showed you can even simulate two different types of antennas sitting close to each other (like a T-shaped antenna next to a V-shaped one) and see how they talk to each other, all using this efficient method.

The Takeaway

Think of this paper as inventing a smart compression algorithm for physics.

Instead of trying to memorize the entire map of a city (the whole antenna), the authors realized the city is built from just nine types of neighborhoods. By understanding the rules of those nine neighborhoods and how they repeat, they can describe the entire city using a tiny notebook instead of a library. This allows us to design the massive, high-speed antennas needed for our future 6G networks without needing a supercomputer the size of a building.

1. Problem Statement

The analysis of electrically large array antennas (often exceeding 1,000 elements) using the Method of Moments (MoM) is computationally prohibitive.

Memory Scaling: Standard MoM requires storing a dense impedance matrix ( $Z$ ) where memory allocation scales as $O(N^2)$ , with $N$ being the total number of basis functions. For large arrays, this becomes unmanageable (e.g., Terabytes of RAM).
Limitations of Existing Methods: While methods like the Fast Multipole Method (FMM) and Domain Decomposition Method (DDM) exist for arbitrary shapes, they do not fully exploit the specific finite translational symmetry of array antennas.
The Specific Gap: Existing symmetry-exploiting methods often fail when elements are electrically connected (e.g., sharing a ground plane or conductive strips). Previous attempts to handle connected elements (like the Higher-Order Array Decomposition Method) do not use standard RWG (Rao-Wilton-Glisson) basis functions, limiting their compatibility with standard MoM solvers.

2. Methodology

The authors propose a nine-component array decomposition method that combines domain partitioning with the exploitation of translational symmetry to construct a multilevel block Toeplitz impedance matrix.

A. Nine-Component Representation

Instead of meshing the entire $N_x \times N_y$ array, the method meshes a single "unit" structure comprising nine distinct subdomains (components):

One Center Component: Represents the main array element.
Eight Margin Components: Surround the center component, covering edges and corners.
This structure allows the entire finite array to be reconstructed via spatial translations of these nine components.

B. Handling Electrically Connected Elements

A critical innovation is the algorithm for handling shared triangles between adjacent parts of the same component type (e.g., where two margin components touch).

The authors developed a specific indexing strategy to identify shared triangles along boundaries (left, right, top, bottom, and corners).
They utilize the DEMCEM package to accurately calculate weakly singular integrals on these shared triangles, ensuring continuity of surface currents across the connected elements.

C. Multilevel Block Toeplitz Structure

By ordering the subdomains and parts according to their spatial translation, the global MoM impedance matrix ( $Z_{part}$ ) inherits a multilevel block Toeplitz structure.

Matrix $A$ : Represents interactions between array element parts. It exhibits a 2-level block Toeplitz structure.
Matrix $B$ : Represents interactions between margin parts and array elements. It exhibits a 1-level block Toeplitz structure (with some full submatrices for corners).
Matrix $C$ : Represents interactions between margin parts. It also exhibits a 1-level block Toeplitz structure.
Result: Instead of calculating $N^2$ interactions, only a small fraction of unique submatrices need to be computed. The rest are generated via translation.

D. Solving and Post-Processing

Solver: The structured matrix is solved using an in-house inverse solver (e.g., a block matrix-valued Rybicki algorithm or GMRES) that leverages the Toeplitz structure for fast matrix-vector multiplication (using FFT).
Far-Field Calculation: The far-field is computed efficiently by calculating the spatial Fourier transform of the currents on the nine components once, then applying phase shifts based on the spatial offsets of the translated parts.

3. Key Contributions

RWG Compatibility for Connected Arrays: The first method (to the authors' knowledge) to construct a multilevel block Toeplitz MoM matrix for electrically connected elements using standard RWG-like basis functions.
Memory Efficiency: The method reduces memory allocation from $O(N_x^2 N_y^2)$ (standard dense MoM) to $O(N_x N_y)$ .
Generalized Decomposition: The nine-component framework allows for the modeling of non-identical arrays placed closely together (e.g., mutual coupling between two different array types) by treating them as a single super-array with disjoint components.
Algorithmic Robustness: A specific algorithm (Algorithm 1 & 2 in the paper) is provided to correctly map intrinsic edge/triangle indices and handle shared triangles across translated parts.

4. Numerical Results

The authors validated the method with three case studies:

Case 1: Surface Current Validation (2x3 Array)
- Demonstrated that summing the currents from the nine components correctly reconstructs continuous surface currents across shared boundaries, validating the shared-triangle handling.
Case 2: Mutual Coupling (Two 9x9 Arrays)
- Scenario: Two closely spaced 9x9 arrays with different element types (T-slot dipoles and Vivaldi antennas).
- Memory Savings: The proposed method required 9.53 GB of RAM, whereas a standard full-mesh approach required 395 GB.
- Accuracy: Successfully calculated S-parameters (mutual coupling) across 3–9 GHz with high accuracy.
Case 3: Large Array Far-Field (32x32 BoR Array)
- Scenario: A 32x32 array of BoR (Body of Revolution) elements.
- Memory Savings: Reduced memory from 1.97 TB (standard) to 3.97 GB.
- Performance: Calculated Element Pattern (EEP), Directivity, and Total Active Reflection Coefficient (TARC). The TARC remained below -10 dB over a wide scan angle ( $\pm 52^\circ$ ).

5. Significance and Impact

Scalability: This method enables the full-wave analysis of massive antenna arrays (thousands of elements) on standard workstations, which was previously impossible without massive supercomputing resources.
Design Flexibility: By supporting electrically connected elements and non-identical array configurations, it facilitates the design of complex next-generation 6G mobile network base stations and radar systems.
Computational Speed: The reduction in matrix size, combined with FFT-accelerated solvers, drastically reduces the time required for iterative solutions and parametric studies.

In conclusion, the paper presents a rigorous mathematical framework that bridges the gap between efficient symmetry-based solvers and the complex reality of connected array elements, offering a practical solution for the electromagnetic analysis of next-generation large-scale antenna systems.