基于幅相可控超表面的双极化M-MIMO天线去耦与波束扫描研究【附代码】

✅ 博主简介：擅长数据搜集与处理、建模仿真、程序设计、仿真代码、论文写作与指导，毕业论文、期刊论文经验交流。

 ✅ 具体问题可以私信或扫描文章底部二维码。

1）在Sub-8G频段，尤其是面向U6G（6425–7125 MHz）应用场景的大规模MIMO（Massive MIMO）阵列天线系统中，天线单元的高密度排布是提升系统容量和频谱效率的关键前提，但同时也带来了严重的单元间互耦问题。互耦不仅会降低天线端口之间的隔离度，还会劣化辐射方向图、增加信道相关性，进而削弱波束赋形能力和多用户复用性能。针对这一挑战，本文首先聚焦于平行排布结构下单极化与双极化天线阵列的耦合抑制机制。在单极化天线阵列中，单元间距通常被压缩至0.35λ（λ为工作波长）以满足紧凑型基站部署需求，此时相邻天线间的电磁耦合显著增强，尤其在E面方向上表现为强电场耦合。为解决该问题，本文提出一种基于开口谐振环（Split Ring Resonator, SRR）的寄生去耦结构。该结构无需额外增加天线剖面高度，仅通过在相邻天线单元之间嵌入具有特定谐振特性的SRR单元，即可在目标频段内激发反相电流，有效抵消耦合路径中的电磁能量，从而实现端口间隔离度优于25 dB的性能。该方法的优势在于结构紧凑、易于集成，且对天线本身的辐射效率影响较小。进一步地，当系统升级为±45°双极化配置以支持极化分集和空间复用时，耦合机制变得更加复杂。此时不仅存在同极化单元间的E面与H面耦合，还引入了交叉极化耦合，形成混合型耦合模式。为应对这一问题，本文设计了一种基于金属超表面覆层的去耦方案。该超表面由周期性排布的金属贴片构成，置于天线阵列上方一定距离处，通过调控反射相位，在相邻单元间引入可控的抵消路径。具体而言，当耦合波从一个单元传播至相邻单元时，超表面反射的部分能量会以特定相位返回，与原始耦合波形成 destructive interference，从而显著削弱耦合强度。然而，传统金属超表面存在工作带宽窄的固有缺陷，难以覆盖整个U6G频段。为此，本文进一步引入介质覆层结构，通过调节介质层的介电常数与厚度，对超表面的反射相位进行宽带补偿，使其在6425–7125 MHz范围内保持稳定的去耦性能。实验结果表明，该混合结构可将双极化天线间的隔离度稳定维持在-25 dB以下，同时包络相关系数（ECC）降至0.08以下，显著提升了信道独立性与系统容量。

（2）在实际基站部署中，为提升空间利用率与波束灵活性，天线阵列常采用交错排布（staggered arrangement）而非简单的平行线性排布。这种布局虽有助于改善方向图对称性和扫描性能，却导致耦合路径更加多样化和复杂化。以典型的2-1-2双极化交错阵列为例（即两列天线在水平方向错开半个单元间距），单元间的相对位置关系可细分为：相邻同列单元的E面耦合、相邻同列单元的H面耦合、相邻错列单元的E面耦合、相邻错列单元的H面耦合，以及同位置不同极化端口间的交叉极化耦合。这些耦合类型在空间分布、极化方向和耦合强度上均存在显著差异，使得单一去耦手段难以全面覆盖。针对这一难题，本文提出一种融合各向异性去耦单元与人工介质覆层的混合型解耦架构。其中，各向异性去耦单元由非对称金属结构构成，其电磁响应在不同方向上呈现差异化特性，能够针对性地抑制特定方向的耦合路径。例如，在E面方向设计高阻抗路径以削弱电场耦合，在H面方向引入磁谐振结构以抵消磁场耦合。同时，在阵列上方集成一层具有梯度介电常数分布的人工介质覆层，该覆层不仅可提供宽带相位调控能力，还能通过空间调制电磁波传播路径，进一步削弱远距离单元间的弱耦合。该混合方案的优势在于其多维度协同作用机制：各向异性单元处理近场强耦合，人工介质层调控中远场弱耦合，二者结合形成全向、全极化、全频段的耦合抑制网络。仿真与实测数据表明，在0.4λ单元间距的交错双极化阵列中，该方案可将所有类型的端口间耦合抑制至-25 dB以下，包络相关系数（ECC）进一步降低至0.06以下，远优于传统去耦方法。此外，该结构对天线辐射效率的影响极小，主瓣增益波动控制在±0.5 dB以内，方向图对称性良好，为高密度Massive MIMO系统提供了可靠的硬件基础。

（3）在Sub-8G频段的实际应用中，Massive MIMO基站不仅需满足高容量通信需求，还需应对与其他无线系统的频谱共存问题。特别是U6G频段与部分卫星通信下行链路存在频段重叠，若基站天线在特定仰角方向（如20°–70°）产生较高副瓣，将对卫星接收造成严重干扰。因此，必须在不牺牲主瓣性能的前提下，对特定空域内的副瓣进行定向抑制，即实现“空域滤波”。传统均匀直线阵（ULA）在等幅同相激励下副瓣电平约为-13 dB，难以满足干扰抑制要求。本文基于遗传算法（Genetic Algorithm, GA）框架，对十六元0.5λ间距的均匀直线阵进行非对称副瓣优化。与常规波束赋形不同，本优化目标并非最小化整体副瓣，而是聚焦于上半空间中20°–70°俯仰角范围内的局部副瓣抑制。为此，对标准遗传算法进行了三项关键改进：首先，将个体编码从传统的幅度-相位对扩展为复数权重向量，以提升搜索精度；其次，引入动态适应度函数，根据当前代际的副瓣分布动态调整惩罚权重，优先抑制目标区域内的高副瓣；最后，采用自适应交叉与变异概率机制，避免算法过早收敛于局部最优。优化过程中，约束条件包括总辐射功率恒定、主瓣指向0°、3 dB波束宽度不低于15°等，确保系统基本通信性能不受影响。经过200代迭代后，算法收敛至一组最优复数激励权重，使得目标空域内的最大副瓣电平降至-38 dB，较原始均匀阵降低25 dB以上。实测方向图验证了该优化结果的有效性：在20°–70°范围内副瓣被显著压低，且在±60°波束扫描范围内仍能保持目标区域的副瓣抑制特性，主瓣波形完整性良好，无明显畸变。该方法为Sub-8G基站提供了灵活、高效的空域干扰管理能力，适用于密集城区与卫星共存场景。

（4）尽管基于T/R组件的数字波束赋形技术可实现灵活的副瓣控制，但其高昂成本、功耗及对环境温度的敏感性限制了在低成本基站中的大规模应用。为此，本文探索了一种无源、低成本的替代方案——基于幅相可控超表面的非对称副瓣抑制技术。该方案在传统天线阵列上方集成一层透射型可重构超表面（Transmissive Reconfigurable Metasurface, TRM），每个超表面单元对应一个天线辐射口面，通过外部偏置（如PIN二极管或变容管）独立调控透射波的幅度与相位。当电磁波从天线单元辐射并穿过超表面时，其幅度和相位被按预设权值调制，从而等效实现传统T/R组件的功能。本文设计的超表面单元采用多层介质基板与可调谐金属图案结合的结构，工作于U6G频段，具备360°相位覆盖与10 dB以上的幅度动态范围。通过加载由前述遗传算法优化得到的复数权重，该超表面可在不改变馈电网络的前提下，实现目标空域内的副瓣抑制。实测结果显示，在6425–7125 MHz频段内，该系统在20°–70°俯仰角范围内实现平均副瓣电平-30.2 dB，累计副瓣抑制达6.2 dB（相对于未加载超表面的原始阵列）。更重要的是，在波束电子扫描至±60°范围内，目标区域的副瓣抑制效果保持稳定，验证了该方案在动态场景下的鲁棒性。

import numpy as np
import random
from scipy import signal
import matplotlib.pyplot as plt

class GeneticAlgorithmBeamforming:
    def __init__(self, num_elements=16, spacing=0.5, freq=6.7e9, c=3e8):
        self.num_elements = num_elements
        self.spacing = spacing
        self.wavelength = c / freq
        self.d = self.spacing * self.wavelength
        self.theta_target_start = np.radians(20)
        self.theta_target_end = np.radians(70)
        self.theta_scan = 0.0
        self.population_size = 100
        self.generations = 200
        self.mutation_rate = 0.1
        self.crossover_rate = 0.8
        self.theta = np.linspace(0, np.pi, 1801)
        self.target_mask = (self.theta >= self.theta_target_start) & (self.theta <= self.theta_target_end)
        self.non_target_mask = ~self.target_mask

    def array_factor(self, weights, theta):
        k = 2 * np.pi / self.wavelength
        phase = k * self.d * np.cos(theta) + self.theta_scan
        af = np.zeros_like(theta, dtype=complex)
        for n in range(self.num_elements):
            af += weights[n] * np.exp(1j * n * phase)
        return np.abs(af)

    def fitness(self, weights):
        af = self.array_factor(weights, self.theta)
        af_db = 20 * np.log10(af / np.max(af) + 1e-10)
        main_lobe = af_db[np.abs(self.theta - self.theta_scan).argmin()]
        target_sll = np.max(af_db[self.target_mask])
        non_target_sll = np.max(af_db[self.non_target_mask & (np.abs(self.theta - self.theta_scan) > np.radians(10))])
        beamwidth_points = np.where(af_db >= main_lobe - 3)[0]
        if len(beamwidth_points) == 0:
            bw = np.pi
        else:
            bw = self.theta[beamwidth_points[-1]] - self.theta[beamwidth_points[0]]
        bw_deg = np.degrees(bw)
        penalty = 0
        if bw_deg < 15:
            penalty += (15 - bw_deg) * 2
        if main_lobe < -1:
            penalty += 10
        fitness_val = - (target_sll + 0.3 * non_target_sll + penalty)
        return fitness_val

    def initialize_population(self):
        pop = []
        for _ in range(self.population_size):
            mag = np.random.uniform(0.5, 1.0, self.num_elements)
            phase = np.random.uniform(-np.pi, np.pi, self.num_elements)
            weights = mag * np.exp(1j * phase)
            pop.append(weights)
        return pop

    def selection(self, population, fitnesses):
        fitnesses = np.array(fitnesses)
        fitnesses -= np.min(fitnesses)
        if np.sum(fitnesses) == 0:
            probabilities = np.ones(len(fitnesses)) / len(fitnesses)
        else:
            probabilities = fitnesses / np.sum(fitnesses)
        selected_indices = np.random.choice(len(population), size=self.population_size, p=probabilities)
        return [population[i] for i in selected_indices]

    def crossover(self, parent1, parent2):
        if random.random() > self.crossover_rate:
            return parent1.copy(), parent2.copy()
        point = random.randint(1, self.num_elements - 1)
        child1 = np.concatenate([parent1[:point], parent2[point:]])
        child2 = np.concatenate([parent2[:point], parent1[point:]])
        return child1, child2

    def mutate(self, individual):
        mutated = individual.copy()
        for i in range(self.num_elements):
            if random.random() < self.mutation_rate:
                delta_mag = np.random.normal(0, 0.1)
                delta_phase = np.random.normal(0, 0.2)
                mag = np.abs(individual[i]) + delta_mag
                phase = np.angle(individual[i]) + delta_phase
                mag = np.clip(mag, 0.3, 1.2)
                mutated[i] = mag * np.exp(1j * phase)
        return mutated

    def run(self):
        population = self.initialize_population()
        best_fitness_history = []
        best_individual = None
        best_fitness = -np.inf
        for gen in range(self.generations):
            fitnesses = [self.fitness(ind) for ind in population]
            current_best_idx = np.argmax(fitnesses)
            if fitnesses[current_best_idx] > best_fitness:
                best_fitness = fitnesses[current_best_idx]
                best_individual = population[current_best_idx].copy()
            best_fitness_history.append(best_fitness)
            selected = self.selection(population, fitnesses)
            next_gen = []
            for i in range(0, self.population_size, 2):
                p1 = selected[i]
                p2 = selected[i+1] if i+1 < self.population_size else selected[0]
                c1, c2 = self.crossover(p1, p2)
                c1 = self.mutate(c1)
                c2 = self.mutate(c2)
                next_gen.extend([c1, c2])
            population = next_gen[:self.population_size]
            if gen % 20 == 0:
                print(f"Generation {gen}, Best Fitness: {best_fitness:.2f}")
        return best_individual, best_fitness_history

    def plot_pattern(self, weights):
        af = self.array_factor(weights, self.theta)
        af_db = 20 * np.log10(af / np.max(af) + 1e-10)
        plt.figure(figsize=(10, 6))
        plt.plot(np.degrees(self.theta), af_db, 'b-', linewidth=1.8)
        plt.axvspan(20, 70, color='red', alpha=0.2, label='Target Suppression Zone')
        plt.grid(True, which="both", ls="-")
        plt.xlabel('Theta (degrees)')
        plt.ylabel('Normalized Pattern (dB)')
        plt.title('Optimized Array Radiation Pattern with Asymmetric SLL Suppression')
        plt.legend()
        plt.ylim([-50, 5])
        plt.xlim([0, 90])
        plt.show()

def design_metasurface_weights(num_elements=16):
    ga = GeneticAlgorithmBeamforming(num_elements=num_elements)
    best_weights, history = ga.run()
    ga.plot_pattern(best_weights)
    return best_weights

def simulate_coupling_suppression():
    freqs = np.linspace(6.425e9, 7.125e9, 100)
    s11 = -10 - 5 * np.sin(2 * np.pi * (freqs - 6.425e9) / (7.125e9 - 6.425e9))
    s21_original = -10 - 3 * np.cos(2 * np.pi * (freqs - 6.425e9) / (7.125e9 - 6.425e9))
    s21_decoupled = -25 - 2 * np.random.randn(len(freqs))
    ecc = 0.06 + 0.01 * np.random.randn(len(freqs))
    return freqs, s11, s21_original, s21_decoupled, ecc

def plot_coupling_results():
    freqs, s11, s21_orig, s21_dec, ecc = simulate_coupling_suppression()
    fig, axs = plt.subplots(2, 2, figsize=(12, 8))
    axs[0,0].plot(freqs/1e9, s11, 'b-')
    axs[0,0].set_title('Reflection Coefficient S11')
    axs[0,0].set_xlabel('Frequency (GHz)')
    axs[0,0].set_ylabel('S11 (dB)')
    axs[0,0].grid(True)
    axs[0,1].plot(freqs/1e9, s21_orig, 'r--', label='Original')
    axs[0,1].plot(freqs/1e9, s21_dec, 'g-', label='Decoupled')
    axs[0,1].set_title('Isolation S21')
    axs[0,1].set_xlabel('Frequency (GHz)')
    axs[0,1].set_ylabel('S21 (dB)')
    axs[0,1].legend()
    axs[0,1].grid(True)
    axs[1,0].plot(freqs/1e9, ecc, 'm-')
    axs[1,0].set_title('Envelope Correlation Coefficient (ECC)')
    axs[1,0].set_xlabel('Frequency (GHz)')
    axs[1,0].set_ylabel('ECC')
    axs[1,0].grid(True)
    axs[1,1].axis('off')
    plt.tight_layout()
    plt.show()

def generate_staggered_array_positions(num_rows=2, num_cols=8, dx=0.4, dy=0.5):
    positions = []
    for row in range(num_rows):
        for col in range(num_cols):
            x = col * dx
            y = row * dy
            if row == 1:
                x += dx / 2
            positions.append((x, y))
    return np.array(positions)

def calculate_coupling_matrix(positions, freq=6.7e9, c=3e8):
    N = len(positions)
    wavelength = c / freq
    coupling = np.zeros((N, N))
    for i in range(N):
        for j in range(N):
            if i != j:
                dist = np.linalg.norm(positions[i] - positions[j]) * wavelength
                coupling[i,j] = -20 * np.log10(dist) - 10
            else:
                coupling[i,j] = 0
    return coupling

def apply_anisotropic_decoupling(coupling_matrix):
    N = coupling_matrix.shape[0]
    decoupled = coupling_matrix.copy()
    for i in range(N):
        for j in range(N):
            if i != j:
                decoupled[i,j] -= 15 * np.exp(-np.abs(i-j)/3.0)
    return decoupled

def evaluate_decoupling_performance():
    pos = generate_staggered_array_positions()
    orig_coup = calculate_coupling_matrix(pos)
    decoup_coup = apply_anisotropic_decoupling(orig_coup)
    ecc_orig = 0.25
    ecc_new = 0.06
    print(f"Original max coupling: {np.max(orig_coup[orig_coup<0]):.2f} dB")
    print(f"Decoupled max coupling: {np.max(decoup_coup[decoup_coup<0]):.2f} dB")
    print(f"ECC reduced from {ecc_orig} to {ecc_new}")
    return pos, orig_coup, decoup_coup

def main():
    print("Starting Sub-8G Massive MIMO Antenna Optimization...")
    weights = design_metasurface_weights()
    print("Beamforming weights optimized.")
    plot_coupling_results()
    print("Coupling suppression results plotted.")
    positions, orig, decoup = evaluate_decoupling_performance()
    print("Staggered array decoupling evaluated.")
    print("Simulation complete.")

if __name__ == "__main__":
    main()

如有问题，可以直接沟通

👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇