Pathsolver for a lot of different receivers.

[MSchueller362]

Hi everybody,

I have three questions related to the Pathsolver:

1. We looked at the Api Documentation of the path_solver there is written:
   -max_num_paths_per_src (int) – Maximum number of paths per source
   -samples_per_src (int) – Number of samples per source
   We weren´t sure from this documentation what the difference between the two is.

2. We have a very complicated mesh with a lot of different faces. We have one transmitter and a lot of receivers.
   If we use the pathsolver function for a lot of receivers the number of paths we find at the first receiver decreases.
   We implemented a loop to show the effect for a different number of receivers. We always start at the same receiver.

        p_solver = PathSolver()
        num_rec = 200
        num_paths = []
        for j in range(1,num_rec):
            for i in range(j):
                rx = Receiver(name=f'rx{i}',
                             position=[recei[str(i+165)]["x"],recei[str(i+165)]["y"],300],
                             display_radius=50)
                scene.add(rx)
            
            
            paths = p_solver(scene=scene,
                             max_depth=5,
                             max_num_paths_per_src= 10000000,
                             samples_per_src=1000000,
                             los = True,
                             specular_reflection=True,
                             diffuse_reflection=False,
                             refraction=False,
                             synthetic_array=False
                             )
            
            
            num_paths.append(len(paths.valid[0][0][0][0]))
            for i in range(j):
                scene.remove(f'rx{i}')
    
        plt.figure()
        plt.grid(visible=True,which='both')
        plt.plot(np.arange(1,num_rec),num_paths)
        plt.xlabel(r"Number of receivers");
        plt.ylabel(r"Number of paths");
        plt.title("Number of paths in realtion to number of receivers");

Is this happening because of a division of memory in number of paths for different receivers?
How can the loss of paths with more receivers be avoided?

3. We want to implement a function that iterates over a path_solver with different receivers.
   We have over 1000 different receivers.
   We have the positions of the receivers saved in a json file named receivers.
   This is how the code would look:

    p_solver = PathSolver()
    for i in range(number_receivers):
        rx = Receiver(name=f'rx{i}',
                     position=[receivers[str(i)]["x"],receivers[str(i)]["y"],300],
                     display_radius=50)
        scene.add(rx)
      
   
        paths = p_solver(scene=scene,
                         max_depth=5,
                         max_num_paths_per_src= 10000000,
                         samples_per_src=1000000,
                         los = True,
                         specular_reflection=True,
                         diffuse_reflection=False,
                         refraction=False,
                         synthetic_array=False
                         )
        
        scene.remove(f'rx{i}')
   

If we do this we get the warning:
RuntimeWarning: The AST-transforming decorator @drjit.syntax was called more than 1000 times by your program. Since transforming and recompiling Python code is a relatively expensive operation, it should not be used within loops or subroutines. Please move the function to be transformed to the top program level and decorate it there.
warnings.warn(

Is there a better solution than doing this?

All the best,
Mark

[jhoydis]

Hi @MSchueller362,

1. For an in-depth discussion of this issue, please have a look at the Sionna RT Technical Report. The number of samples per source determines how many rays are shot from each source. The more rays are shot, the more potential candidate paths can be found. The maximum number of paths per source determines how many actual propagation paths per source can be retained. Please have a look at the technical report for a detailed explanation.
2. The number of receivers that you can efficiently treat in parallel is limited. You would be better of doing the path computation in batches over a smaller number of receivers.

[souhila98]

I observed an unexpected behavior regarding the results for the same receiver, depending on whether I process receivers individually or in batches. I have a scenario with 1 TX and 129 RX
When I process the RXs one by one, clearing the scene each time, the CIR generated for a given RX is different from the CIR generated when I process the RXs in batches (batch_size=5).
Is this expected behavior of PathSolver when multiple RXs are in the scene?

[faycalaa]

Hi @souhila98 ,

Yes, this behavior can occur due to how paths are computed. As described in the Sionna RT Technical Report (Section 3.1.3), path candidates are stored for each transmitter in a hash array of size max_num_paths_per_src. Because this array is shared across all receivers, hash collisions can lead to small variations in the computed paths when the number of receivers changes. You can mitigate this effect by increasing the array size.