Comparison of coverage maps between the CIR and Sionna coverage map functions using an antenna array

[Sina7474]

I have encountered an issue with pathgain calculation and would greatly appreciate your expertise on this issue.

I have approached the pathgain calculation in two ways:

1. I deployed one user and one base station, obtained the channel impulse response (CIR), and then calculated the pathgain by squaring the amplitude of the channel coefficients. The line of code used for this is the following:

path_gain_1 = to_db(tf.reduce_sum(tf.abs(a)**2))

2. Here, I created a 1m x 1m grid of the area and generated the Sionna coverage map function to achieve the related tile pathgain.

To validate the results, I compared the pathgain values in dB for the tile where the user is located in the first approach. The results match when both Tx and Rx have a single antenna element. However, when using a multi-antenna array at the Tx (e.g., 1x16), the results diverge significantly, despite both approaches being simulated under identical conditions (considering only reflection and LoS components).

I also reviewed the Sionna source code for calculating the coverage map, but I still could not identify the issue.

I provided a snippet of my code that I am using to calculate the pathgain in two approaches:

Pathgain.pdf

[merlinND]

Hello @Sina7474,

Could you please share a full script, as a text file (.py) that can run on its own and showcases the issue?
If your script uses any additional data (e.g. scene files), please make sure to include it as well.

PDF files are not a good way to share code, and the included code will not run on its own (e.g. scene loading and imports are missing), so we cannot use it to reproduce and investigate your issue.

[Sina7474]

Hello @merlinND

Thank you so much for the reply,

I attached a ZIP file that includes the related code with .py format and also the scene files. It will run on your machine just by changing the address of the .xml file in the code for the loading of the scene.

Thanks in advance for your concern and help and kind regards,
Sionna_Pathgain.zip

[faycalaa]

Hi @Sina7474 ,

The mismatch you're observing is due to the resolution of the coverage map not being high enough to accurately capture the interference pattern resulting from using an antenna array at the transmitter.

You can try increasing the resolution of the coverage map by reducing the size of the cells. However, note that more samples could then be required to ensure all cells capture enough rays to provide an accurate estimate.

The code snippet below generates two coverage maps that share the same configuration, except for the cell size. It is clear that the low-resolution coverage map provides only a coarse capture of the interference pattern.

import sionna
from sionna.rt import PlanarArray, Transmitter, Receiver, load_scene

scene = load_scene(sionna.rt.scene.etoile)

scene.tx_array = PlanarArray(num_rows=64, num_cols=1, vertical_spacing=0.5, horizontal_spacing=0.5,
                             pattern="tr38901", polarization="V")
scene.rx_array = PlanarArray(num_rows=1, num_cols=1, vertical_spacing=0.5, horizontal_spacing=0.5,
                             pattern="iso", polarization="V")
scene.frequency = 3.5e9

tx = Transmitter(name="tx",
                 position=[-20,20,15])
scene.add(tx)

hr_cm = scene.coverage_map(num_samples=1e7,
                           max_depth=3,
                           los=True,
                           reflection=True,
                           diffraction=False,
                           scattering=False,
                           ris=False,
                           combining_vec = None,
                           precoding_vec = None,
                           cm_cell_size=[0.05,0.05],
                           cm_orientation=[0,0,0],
                           cm_center=tx.position,
                           cm_size=[50,50])

fig = hr_cm.show(vmax=-70, vmin=-120);
fig.suptitle(r"Cell size: $0.05 \times 0.05$m")
fig.savefig('high_res.png', bbox_inches='tight')

lr_cm = scene.coverage_map(num_samples=1e7,
                           max_depth=3,
                           los=True,
                           reflection=True,
                           diffraction=False,
                           scattering=False,
                           ris=False,
                           combining_vec = None,
                           precoding_vec = None,
                           cm_cell_size=[1.,1.],
                           cm_orientation=[0,0,0],
                           cm_center=tx.position,
                           cm_size=[50,50])

fig = lr_cm.show(vmax=-70, vmin=-120);
fig.suptitle(r"Cell size: $1 \times 1$m")
fig.savefig('low_res.png', bbox_inches='tight')

Hope this helps.

[Sina7474]

Hi @faycalaa

Thank you very much for providing the code and the detailed explanation.

Could you also confirm which formula or line of code is correct for the path gain calculation using the CIR approach? I still have some doubts about which formula or code is appropriate when dealing with a multi-element array to obtain the correct result.

All the best,
Sina

[faycalaa]

This line is correct:

path_gain_2 = to_db(tf.reduce_sum(tf.abs(tf.reduce_mean(a, axis=-3))**2)*num_rows_array)

This is because by default (when precoding_vec is set to None), a precoding vector equal to:

precoding_vec = [1, 1, ..., 1] / num_tx_ant

is applied when computing the coverage map (see the corresponding documentation).

[Sina7474]

Thank you @faycalaa for your time and explanation.

[alialsahlany]

This line is correct:

path_gain_2 = to_db(tf.reduce_sum(tf.abs(tf.reduce_mean(a, axis=-3))**2)*num_rows_array)

This is because by default (when precoding_vec is set to None), a precoding vector equal to:

precoding_vec = [1, 1, ..., 1] / num_tx_ant

is applied when computing the coverage map (see the corresponding documentation).

Hi @faycalaa
for PlanarArray(num_rows=2, num_cols=2
How can I calculate path loss using CIR?