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.