Question about simulating a planar array

[znah321]

Dear Sionna Team,

I want to simulate the ray-tracing-based wireless channels with a uniform planar array. The inter-antenna spacing is smaller than half wavelength. I have tried the following two scheme:

• Add all the antenna elements into the scene to compute the propagation paths and calculate the corresponding channel frequency response.
• Add only one antenna element each time.

try:
    import sionna.rt
except ImportError as e:
    import os
    os.system("pip install sionna-rt")
    import sionna.rt

# Other imports
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np

no_preview = False # Toggle to False to use the preview widget

# Import relevant components from Sionna RT
from sionna.rt import load_scene, PlanarArray, Transmitter, Receiver, Camera,\
                      PathSolver, RadioMapSolver, subcarrier_frequencies

import tensorflow as tf
import os
import random

SEED = 41

def set_seeds(seed=SEED):
    os.environ['PYTHONHASHSEED'] = str(seed)
    random.seed(seed)
    tf.random.set_seed(seed)
    np.random.seed(seed)

def set_global_determinism(seed=SEED):
    set_seeds(seed=seed)

    os.environ['TF_DETERMINISTIC_OPS'] = '1'
    os.environ['TF_CUDNN_DETERMINISTIC'] = '1'
    
    tf.config.threading.set_inter_op_parallelism_threads(1)
    tf.config.threading.set_intra_op_parallelism_threads(1)

# Call the above function with seed value
set_global_determinism(seed=SEED)

# Load integrated scene
scene = load_scene(sionna.rt.scene.munich) # Try also sionna.rt.scene.etoile

scene.frequency = 5e9
lam = 0.06

tx_origin = np.array([8.5,21,27])

tx_1_pos = tx_origin

tx_2_pos = tx_origin
tx_2_pos[0] = tx_origin[0] + 0.1*lam

tx_3_pos = tx_origin
tx_3_pos[1] = tx_origin[1] + 0.1*lam

tx_4_pos = tx_origin
tx_4_pos[0] = tx_origin[0] + 0.1*lam
tx_4_pos[1] = tx_origin[1] + 0.1*lam

# Configure antenna array for all transmitters
scene.tx_array = PlanarArray(num_rows=1,
                             num_cols=1,
                             vertical_spacing=0.5,
                             horizontal_spacing=0.5,
                             pattern="tr38901",
                             polarization="V")

# Configure antenna array for all receivers
scene.rx_array = PlanarArray(num_rows=1,
                             num_cols=1,
                             vertical_spacing=0.5,
                             horizontal_spacing=0.5,
                             pattern="tr38901",
                             polarization="V")

# Create transmitter
tx = Transmitter(name="tx",
                 position=[8.5,21,27],
                 display_radius=2)

# Add transmitter instance to scene
scene.add(tx)

# Create a receiver
rx = Receiver(name="rx",
              position=[45,90,1.5],
              display_radius=2)

# Add receiver instance to scene
scene.add(rx)

# Instantiate a path solver
# The same path solver can be used with multiple scenes
p_solver  = PathSolver()

# Generate Tx-Rx channel one-by-one
h = np.zeros((4,1),dtype=np.complex64)

'''
    Tx1-Rx channel
'''
tx.position = tx_1_pos

# Compute propagation paths
paths = p_solver(scene=scene,
                 max_depth=5,
                 los=True,
                 specular_reflection=True,
                 diffuse_reflection=False,
                 refraction=True,
                 synthetic_array=False,
                 seed=41)
a_1, tau_1 = paths.cir(normalize_delays=False, out_type="numpy")
a_1 = np.squeeze(a_1)
tau_1 = np.squeeze(tau_1)

h[0] = paths.cfr(frequencies=scene.frequency,
                   normalize=False, # Normalize energy
                   normalize_delays=False,
                   out_type="numpy")

'''
    Tx2-Rx channel
'''
tx.position = tx_2_pos

# Compute propagation paths
paths = p_solver(scene=scene,
                 max_depth=5,
                 los=True,
                 specular_reflection=True,
                 diffuse_reflection=False,
                 refraction=True,
                 synthetic_array=False,
                 seed=41)
a_2, tau_2 = paths.cir(normalize_delays=False, out_type="numpy")
a_2 = np.squeeze(a_2)
tau_2 = np.squeeze(tau_2)
h[1] = paths.cfr(frequencies=scene.frequency,
                   normalize=False, # Normalize energy
                   normalize_delays=False,
                   out_type="numpy")

'''
    Tx3-Rx channel
'''
tx.position = tx_3_pos

# Compute propagation paths
paths = p_solver(scene=scene,
                 max_depth=5,
                 los=True,
                 specular_reflection=True,
                 diffuse_reflection=False,
                 refraction=True,
                 synthetic_array=False,
                 seed=41)
a_3, tau_3 = paths.cir(normalize_delays=False, out_type="numpy")
a_3 = np.squeeze(a_3)
tau_3 = np.squeeze(tau_3)
h[2] = paths.cfr(frequencies=scene.frequency,
                   normalize=False, # Normalize energy
                   normalize_delays=False,
                   out_type="numpy")

'''
    Tx4-Rx channel
'''
tx.position = tx_4_pos

# Compute propagation paths
paths = p_solver(scene=scene,
                 max_depth=5,
                 los=True,
                 specular_reflection=True,
                 diffuse_reflection=False,
                 refraction=True,
                 synthetic_array=False,
                 seed=41)
a_4, tau_4 = paths.cir(normalize_delays=False, out_type="numpy")
a_4 = np.squeeze(a_4)
tau_4 = np.squeeze(tau_4)
h[3] = paths.cfr(frequencies=scene.frequency,
                   normalize=False, # Normalize energy
                   normalize_delays=False,
                   out_type="numpy")

print(h)
print(10*np.log10(np.abs(h)**2))
print(a_1.shape)

# Generate Tx-Rx channels simultaneously
scene.remove('tx')

# Configure four Tx
tx_1 = Transmitter(name="tx_1",
                 position=tx_1_pos,
                 display_radius=2)
scene.add(tx_1)

tx_2 = Transmitter(name="tx_2",
                 position=tx_2_pos,
                 display_radius=2)
scene.add(tx_2)

tx_3 = Transmitter(name="tx_3",
                 position=tx_3_pos,
                 display_radius=2)
scene.add(tx_3)

tx_4 = Transmitter(name="tx_4",
                 position=tx_4_pos,
                 display_radius=2)
scene.add(tx_4)

# Compute propagation paths
paths = p_solver(scene=scene,
                 max_depth=5,
                 los=True,
                 specular_reflection=True,
                 diffuse_reflection=False,
                 refraction=True,
                 synthetic_array=False,
                 seed=41)
a_simul, tau_simul = paths.cir(normalize_delays=False, out_type="numpy")
a_simul = np.squeeze(a_simul)
tau_simul = np.squeeze(tau_simul)
h_simul = paths.cfr(frequencies=scene.frequency,
                   normalize=False, # Normalize energy
                   normalize_delays=False,
                   out_type="numpy")
h_simul = np.squeeze(h_simul)

print(h_simul)
print(10*np.log10(np.abs(h_simul)**2))
print(a_simul.shape)

However, the output channels of these two schemes are different.

Scheme 1:
[-1.5628913e-05-2.7087797e-06j -1.5722586e-05-2.4520989e-06j
 -1.5701269e-05-2.7454762e-06j -1.5748226e-05-2.4724241e-06j]

Scheme 2:
[[-1.5627571e-05-2.7086894e-06j]
 [-1.5594140e-05-2.7231413e-06j]
 [-1.5628917e-05-2.7087783e-06j]
 [-1.5628913e-05-2.7087824e-06j]]

Then, I checked the computed propagation paths. The number of propagation paths of these two schemes are 32 and 31, respectively. How can I solve this problem? Thanks for your help.