Paths change when using the same seed

[potatoess11]

I set paths(seed=41) in each simulation, why are the results not the same for multiple simulations, and which part of the parameters of this seed ensures that the simulation is consistent?

 paths = p_solver(scene=scene,
             max_depth=4,
             max_num_paths_per_src=100000,
             samples_per_src=100000,
             synthetic_array=True,
             los=True,
             specular_reflection=True,
             diffuse_reflection=True,
             refraction=False,
             seed=42)

[CodingMasterZ]

I have the same problem

[faycalaa]

Hi,

Setting the seed ensures that when running the ray tracer multiple times, a given path always samples the same sequence of interaction types (specular reflection, diffuse reflection, refraction) and the same sequence of directions of propagation for the scattered rays.

However, the ordering of the paths differs from one run to the next in the output. Additionally, when the set maximum number of paths (max_num_paths_per_src) is small compared to the number of paths computed, paths are dropped due to running out of entries in the buffer. Due to the non-deterministic ordering of paths, this can result in small variations in the paths computed from one run to the next. This happens especially when diffuse reflection is enabled.

[Aurevoir-zzz]

Hi, here is the code, and the scene is provided by Sionna. The problem I mentioned does not always occur, but sometimes happens on several UEs and might require a careful examination. Thanks a lot !

import sionna.rt
from numpy.matlib import randn
%matplotlib inline
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import drjit as dr
import mitsuba as mi
no_preview = True
from sionna.rt import load_scene, PlanarArray, Transmitter, Receiver, Camera, \
    PathSolver, subcarrier_frequencies, ITURadioMaterial, SceneObject

scene = load_scene(sionna.rt.scene.munich) # Try also sionna.rt.scene.etoile
if not no_preview:
    scene.preview()
my_cam = Camera(position=[220,-250,200], look_at=[0,0,0])
scene.render(camera=my_cam, resolution=[650, 500], num_samples=512); # Increase num_samples to increase image quality

scene.get("no-name-1").radio_material.scattering_coefficient = 0.1
scene.frequency = 28e8 # 2.8GHz
scene.bandwidth = 20e6 # 20MHz
scene.tx_array = PlanarArray(num_rows=2,
                             num_cols=2,
                             vertical_spacing=0.5,
                             horizontal_spacing=0.5,
                             pattern="tr38901",
                             polarization="V")
scene.rx_array = PlanarArray(num_rows=8,
                             num_cols=8,
                             vertical_spacing=0.5,
                             horizontal_spacing=0.5,
                             pattern="tr38901",
                             polarization="V")
rx = Receiver(name="BS", position=[0,0,100], display_radius=10)
scene.add(rx)
num_UE = 81
grid_center = mi.Point3f(0, 0, 20)
grid_spacing = 25
num_UEs_per_side = int(num_UE**0.5)
if num_UEs_per_side**2 < num_UE:
    num_UEs_per_side += 1
half_grid_size = (num_UEs_per_side - 1) * grid_spacing / 2.0
x_coords = np.linspace(grid_center.x - half_grid_size, grid_center.x + half_grid_size, num_UEs_per_side)
y_coords = np.linspace(grid_center.y - half_grid_size, grid_center.y + half_grid_size, num_UEs_per_side)
ue_id = 0
for x in x_coords:
    for y in y_coords:
        if ue_id >= num_UE:
            break
        pos = mi.Point3f(x, y, grid_center.z)
        tx = Transmitter(name=f"UE-{ue_id}", position=pos, display_radius=10)
        scene.add(tx)
        tx.look_at(rx)
        ue_id += 1

p_solver  = PathSolver()
paths = p_solver(scene=scene,
                 los=True,
                 specular_reflection=True,
                 diffuse_reflection=True,
                 refraction=False,
                 synthetic_array=True)
scene.preview(paths=paths);

UE_idx = 21
print(f"--- For UE {UE_idx}---")
print(f"The validation of paths: {paths.valid[:,UE_idx,:]}")
print(f"Number of valid paths：{np.sum(paths.valid[:,UE_idx,:].numpy())}")

for path_idx in range(0,np.sum(paths.valid[:,UE_idx,:].numpy())):
    print(f"\n--- Detailed results for path {path_idx} of UE {UE_idx}---")
    print("Interactions: ", paths.interactions.numpy()[:,0,UE_idx,path_idx]) # diffuse=2,none=0,refraction=4,specular=1
    print(f"Channel coefficient: {(paths.a[0].numpy()[0,:,UE_idx,:,path_idx] + 1j*paths.a[1].numpy()[0,:,UE_idx,:,path_idx]).shape}")
    print(f"Propagation delay: {paths.tau[0,UE_idx,path_idx].numpy()*1e6:.5f} us")
    print(f"Zenith angle of departure: {paths.theta_t.numpy()[0,UE_idx,path_idx]:.4f} rad")
    print(f"Azimuth angle of departure: {paths.phi_t.numpy()[0,UE_idx,path_idx]:.4f} rad")
    print(f"Zenith angle of arrival: {paths.theta_r.numpy()[0,UE_idx,path_idx]:.4f} rad")
    print(f"Azimuth angle of arrival: {paths.phi_r.numpy()[0,UE_idx,path_idx]:.4f} rad")
    print(f"Doppler shift: {paths.doppler.numpy()[0,UE_idx,path_idx]:.4f} Hz")```

[potatoess11]

hi，@faycalaa
thanks for your reply.What do you mean is that when the random seed setting is the same, the interaction point, interaction type, and other path information of the same path before and after the simulation are the same, but because some paths are not output and some are output when processing the output order, the phenomenon of the same seed but different results is caused?

[potatoess11]

hi!jhoydis
How to ensure the consistency of the parameters of the path before and after the simulation is a problem that bothers me about the expressiveness of the optimization results of each parameter

[faycalaa]

Hi @Antidote-zzz ,

I ran your code but was not able to reproduce the issue. Here is the output I got:

--- Detailed results for path 0 of UE 21---
Interactions:  [0 0 0]
Propagation delay: 0.32555 us

--- Detailed results for path 1 of UE 21---
Interactions:  [1 1 0]
Propagation delay: 0.46910 us

--- Detailed results for path 2 of UE 21---
Interactions:  [1 1 1]
Propagation delay: 0.48603 us

This is with UE 21, as in your code. With UE 20, as in the output you shared initially, I get no paths.

Are you using Sionna 1.0.2?

Note: Next time, please open a new discussion or issue. Thanks!

[Aurevoir-zzz]

Hi @faycalaa, thanks for your response. I'm using Sionna 1.0.1.

I just checked the release v1.0.2, which mentioned "Fixed an occasional issue with the ordering consistency of paths between the tensors."

According to my simulations, the problem has been solved in the latest version.

Thank you again !!