Why I get close to 0 a in paths with LOS

[ZitongLan]

Hello there, I just run into sionna simulation and this is a great work. However, when I do compute_paths, and extract the los path (which is essentially the first path in the results), the abs(a) value of path is always close to zero like 1e-11, while abs(a) for reflection path is like 1e-4 level. From my understanding, abs(a) should be the amplitude of the channel, so theoretically abs(a) should be very large for the los path (if there is no obstacle between tx and rx), which is wrong here? Can anyone help me answer this question?

[faycalaa]

Hi,

It would be really helpful if you could provide a minimal code snippet that demonstrates the problem.

Thanks!

[ZitongLan]

Essentially I am creating a shoe-box shape box and put a tx and rx in side of it to simulate the ray tracing behaviors. Following is my scene file
https://drive.google.com/file/d/1pgSupH7BJPhQWRjOSZ1PxMp5McKf5wLy/view?usp=sharing

Following is my code to place tx and rx inside of it:

scene.tx_array = PlanarArray(num_rows=1,
                             num_cols=1,
                             vertical_spacing=0.5,
                             horizontal_spacing=0.5,
                             pattern="iso",
                             polarization="cross")

scene.rx_array = PlanarArray(num_rows=1,
                             num_cols=1,
                             vertical_spacing=0.5,
                             horizontal_spacing=0.5,
                             pattern="iso",
                             polarization="cross")

tx = Transmitter(name="tx",
                 position=[0,0,1])

scene.add(tx)

rx = Receiver(name="rx",
              position=[3,3,0.1],
              orientation=[0,0,0])

scene.add(rx)

tx.look_at(rx)

Following code is where I assign a random radio material to it, note that the six wall of the box are all made of the same material

print(scene)
custom_material0 = RadioMaterial("my_material_0",
                                relative_permittivity=1.0,
                                conductivity=10,
                                scattering_coefficient=0.3,
                                xpd_coefficient=0,
                                scattering_pattern=LambertianPattern())
for sub_object in scene.objects:
    print(sub_object)
    obj = scene.get(sub_object)
    obj.radio_material = custom_material0

And when I do compute path and return the a value of the los path:

paths = scene.compute_paths(max_depth=1,
                            num_samples=1e6, reflection=True, diffraction=False, scattering=False, scat_keep_prob=0.003)  # Number of rays shot into directions defined

if colab_compat:
    scene.render("my_cam", paths=paths, show_devices=True, show_paths=True, resolution=resolution)
    raise ExitCell
scene.preview(paths, show_devices=True, show_paths=True) # Use the mouse to focus on the visualized paths

propagation_distance = np.array(paths.tau[0,0,0,:].numpy() * 3e8)
amplitude = np.abs(paths.a[0,0,0,0,0,:,0].numpy())
phase = np.angle(paths.a[0,0,0,0,0,:,0].numpy())

print(amplitude)
print(paths.types.numpy()[0])

print(propagation_distance)

the amplitude part would return a close to zero term for the line of sight path.

Another question about path delay

Beyond this, I have another question. I am also interesting in the delay term here, is it really reflect the wave propagation time? When I multiply the delay term with the speed of light, i.e. 3e8, the distance is slightly different from the actual distance between the ground truth distance (because I know the scene scale is of 8m102m3m, and TX and RX are placed at [0,0,1.5] and [3,3,0.1] in the room.

Appreciate for you timely reply!!!

And when you load my scene, tx and rx configuration into the scene and do ray tracing, you are going to see something similar to the figure below.

[faycalaa]

To share the scene, the XML file alone is not enough. The folder containing the meshes is also needed.

[ZitongLan]

scene.zip
Here is the full scene! Thanks!

[faycalaa]

Hi,

You are using dual-polarized antennas at both the transmitter and the receiver ends. Each radio device is therefore equipped with two linearly polarized antennas (see the related documentation). Your current code selects only one antenna from each radio device, which leads to inaccurate path losses.

Here is the corrected code:

scene = load_scene("test_box/test_box.xml")

scene.tx_array = PlanarArray(num_rows=1,
                             num_cols=1,
                             vertical_spacing=0.5,
                             horizontal_spacing=0.5,
                             pattern="iso",
                             polarization="cross") # Cross-polarized antennas are used

scene.rx_array = PlanarArray(num_rows=1,
                             num_cols=1,
                             vertical_spacing=0.5,
                             horizontal_spacing=0.5,
                             pattern="iso",
                             polarization="cross") # Cross-polarized antennas are used

tx = Transmitter(name="tx",
                 position=[0,0,1])
scene.add(tx)

rx = Receiver(name="rx",
              position=[3,3,0.1],
              orientation=[0,0,0])
scene.add(rx)
tx.look_at(rx)

custom_material0 = RadioMaterial("my_material_0",
                                relative_permittivity=1.0,
                                conductivity=10,
                                scattering_coefficient=0.3,
                                xpd_coefficient=0,
                                scattering_pattern=LambertianPattern())
for sub_object in scene.objects:
    obj = scene.get(sub_object)
    obj.radio_material = custom_material0

paths = scene.compute_paths(max_depth=1,
                            num_samples=1e6, reflection=True, diffraction=False, scattering=False, scat_keep_prob=0.003) 

# Sum over tx and rx antennas
pathlosses = np.sum(np.square(np.abs(paths.a[0,0,:,0,:,:,0].numpy())), axis=(0,1))
print(pathlosses)

Resulting in:

[4.9399991e-06 1.3426737e-06 1.6297689e-06 4.3499222e-07 3.1824916e-07, 9.6678491e-07 2.5234162e-06]

Regarding the path delays, it's important to remember that they are normalized by default.
To compute the path lengths, you need to undo the normalization to get the propagation time, and use the exact speed of light in a vacuum, which differs slightly from 3e8:

from sionna import SPEED_OF_LIGHT

paths.normalize_delays = False # Undo normalization of path delays
propagation_distance = paths.tau*SPEED_OF_LIGHT

Hope that helps.

[ZitongLan]

@faycalaa Thanks, this really help! Thanks you!