Getting output information from each ray in sionna

[itsghaniz]

Hi, I am trying to make a an ML model that could for a ray (with different frequencies, distances, angle of hitting the obstacle etc) predict the angle after hitting, the attenuation, scattering phase etc. I am thinking of making my dataset using sionna. I was wondering is it possible to extract this information for a single ray? And if so how?
Thanks in advance

[SebastianCa]

Hi @itsghaniz,
please have a look at the Ray tracing tutorial. In particular, the last part of the section should be helpful.

[itsghaniz]

Hi, thanks alot for replying to the question. I have looked at the tutorial and recreated a simple example with a simple wall and rx and a tx as can be seen in the picture. According to the tutorial, I am able to get the property of complete paths i.e. from TX to RX, such as the channel coefficient, AOD from TX and AOA to RX etc. but is there is a way to get the detail of each path, like at what angle for example it hits the obstacle, the delay when it hits that obstacle the angle with which it hits the obstacle and then these properties after hitting the obstacle and then going to the RX.
Thanks in advance.

[faycalaa]

Hi @itsghaniz ,

Currently, there is no built-in feature that directly provides the angles of incidence, reflection, or propagation distances/delays at intersection points. However, you can compute these quantities using the available data.

The trace_paths() function returns a set of Paths and PathsTmpData. The Paths.vertices property gives you access to the intersection points within the scene. Additionally, PathsTmpData.normals, PathsTmpData.k_i, and PathsTmpData.k_r provide the normals, direction of incidence, and direction of reflection at these intersection points, respectively. Using these properties, you can calculate the angles of incidence and reflection, as well as the propagation distances at the intersection points.

[itsghaniz]

Thanks alot. Thats all I wanted to know. Really appreciate it

[itsghaniz]

Hi, Hope you are well. I have been trying to access the PathTempData, but can do this. Could you please give an example of how I can manage that?
thanks in advance

[SebastianCa]

Hi @itsghaniz,
as mentioned by @faycalaa above, you can run
paths = scene.trace_paths(max_depth=5, num_samples=1e6)
The paths object is a list of Paths and PathTmpData objects (for specular, diffracted and scattered components, respectively; ignoring RIS).

For instance paths[3] gives you access to specular PathTmpData object. Additionally, PathsTmpData.normals, PathsTmpData.k_i, and PathsTmpData.k_r provide the normals, direction of incidence, and direction of reflection at these intersection points, respectively.

I hope that solves the problem.

[itsghaniz]

Hi, thanks for the reply, I was able to do that, but for me what worked was by turning the testing true in the compute-paths function. There is one other problem I am encountering that for diffraction objects, I am getting the of objects that are not in the scene. Is this a problem from my side of diffraction doesn't take objects into consideration?

[itsghaniz]

Hi, Hope you are well. if for example I print the paths.object.numpy() as print(paths.objects.numpy()), I get the ids of the objects that interacted with all the paths. the object id which are in the paths by reflections and scattering are in the ids of the objects, but the objects in the paths of diffrections have the object ids that are not present in the scene. here is a small piece of code.

# here is a dictonarty that I am using to translate the object element id into the object element name
id=[]
material=[]
for i,obj in enumerate(scene.objects.values()):
    print(f"{obj.name} : {obj.radio_material.name}: {obj.object_id}")
    print(type(obj.object_id))
    id.append(obj.object_id)
    material.append(obj.radio_material.name)
    #if i == 1000:
 #   break
materials_dict = dict(zip(id, material))


there here I am tyring to observe the paths of objects, in the diffraction paths all the elements are unknown


for i in range(0, len(path_interactions)):
    interaction_objs_diffraction.append([])
    for j in range(0, num_diff):
        material = materials_dict.get(interaction[i][j+num_ref+num_los], None)
        if material is None:
            if (interaction[i][j+num_ref+1] == -1):
                interaction_objs_diffraction[i].append(None)
            else: interaction_objs_diffraction[i].append('unknown')
        else:
            interaction_objs_diffraction[i].append(material)

for i in range(0, num_diff):
    row = []
    for j in range(0, len(path_interactions)):
        row.append(interaction_objs_diffraction[j][i])
    path_interaction_route_diff.append(row)

the output for all the diffraction elements comes out to be none, where as I get the values for reflection and scattering. I manually tried to search the elements by their id in the scene.objects.id, but there were not there as well.

[SebastianCa]

Can you please provide a complete code example that allows to reproduce the issue? It's difficult to debug your setup without knowing the exact system configuration.
Just one quick thing to check: when you run trace_paths() do you activate diffraction (default is False)?

[itsghaniz]

Hi, hope you are well. Yes the diffraction is true. Its not that it doesnt give the the interaction object by diffraction, but the id of the materials it gives is not included in the scene, i.e. does not have an id that is included in the scene matarials. following is the code as well as the output. I have manually tried to find the materials id in but couldnt find them.

# importing diffrent stuff
import numpy as np
import tensorflow as tf
import pickle
import sionna.rt
from sionna.rt import load_scene, Transmitter, Receiver, PlanarArray, Camera,RadioMaterial
#from sionna.rt  import load_scene, Transmitter, Receiver, PlanarArray, Paths
import matplotlib.pyplot as plt

# loading the scene
scene =  sionna.rt.load_scene("C:/Users/az51n/Desktop/Data Collection/Scenes/UOG/uog1_2.xml")
scene.preview()

#custom material assigning
custom_vegetation = RadioMaterial("custom_vegetation",
                                relative_permittivity=1.2,
                                conductivity = 0.1,)

custom_material = RadioMaterial("my_material",
                                relative_permittivity=2.0,
                                conductivity=5.0,)

custom_forest = RadioMaterial("custom_forest",
                                relative_permittivity=10,
                                conductivity = 0.5,)

for i,obj in enumerate(scene.objects.values()):
    #print(f"{obj.name} : {obj.radio_material.name}")
        if(obj.radio_material.name == 'vegetation'):
            obj.radio_material = custom_material
        elif(obj.radio_material.name == 'forest'):
            obj.radio_material = custom_material

#making a dictonary to link material id with naterial name
id=[]
material=[]
for i,obj in enumerate(scene.objects.values()):
    id.append(obj.object_id)
    material.append(obj.radio_material.name)
materials_dict = dict(zip(id, material))

# Transmitter and reciver setting
scene.tx_array = PlanarArray(num_rows=1, 
                             num_cols=1,
                             vertical_spacing=0.5,
                             horizontal_spacing=0.5,
                             pattern="dipole",
                             polarization="V")

    # Configure antenna array for all receivers
scene.rx_array = PlanarArray(num_rows=1,
                             num_cols=1,
                             vertical_spacing=0.5,
                             horizontal_spacing=0.5,
                             pattern="iso",
                             polarization="cross")

    
scene.frequency = 2.4e9 # in Hz
scene.synthetic_array = True

scene.remove('tx')
scene.remove('rx')

# Create transmitter
tx_position = [-9.33194,-1.53545 ,28.3547]
tx = sionna.rt.Transmitter(name="tx",
              position=[-9.33194,-1.53545 ,28.3547],
              orientation=[0,0,0])
scene.add(tx)

# Create a receiver
rx_position = [-40.2959,-28.3185,18.6157]
rx = sionna.rt.Receiver(name="rx",
           position=[-40.2959,-28.3185,18.6157],
           orientation=[0,0,0])
scene.add(rx)

# TX points towards RX
scene.add(rx)

print(scene.transmitters)
print(scene.receivers)

# generating paths
paths = scene.compute_paths(max_depth=5, method='fibonacci',
                                                 num_samples=1000000, los=True, 
                                                 reflection=True, diffraction=True,
                                                 scattering=True, scat_keep_prob=0.001,
                                                 edge_diffraction=False, check_scene=True,
                                                 scat_random_phases=True, testing=True)


# types of Paths 
path_types = paths.types.numpy()[0]
num_los = 0
num_ref = 0
num_diff = 0
num_scat = 0

path_types = paths.types.numpy()[0]
for i, PT in enumerate(path_types):
    if (PT==0):
        num_los = num_los + 1
    elif (PT == 1):
        num_ref = num_ref + 1
    elif (PT == 2):
       num_diff = num_diff + 1
    elif (PT == 3):
        num_scat = num_scat + 1
total_paths = num_los + num_ref + num_diff + num_scat
print ('paths by line of sight' , num_los)
print ('paths by reflection' , num_ref)
print ('paths by diffrection' , num_diff)
print ('paths by scattering' , num_scat)
print ('total paths ' , total_paths)


# path intreractions
from pprint import pprint 
interaction=[]
vertices = []
interaction_objs_reflection = []
interaction_objs_diffraction = []
interaction_objs_scattering = []
check = 0
path_interactions = paths._objects.numpy()
path_vertices = paths._vertices.numpy()

def rearrange_function (array_to_rearrange , type_of_path):
    temp_array = []
    for i in range(0, type_of_path):
        row = []
        for j in range(0, len(array_to_rearrange)):
            row.append(array_to_rearrange[j][i])
        temp_array.append(row)
    return temp_array



def ineraction_object_function (starting_point, path_number):
    interaction_objs = []
    interaction_vertex = [] 
    for i in range(0, len(path_interactions)):
        interaction_objs.append([])
        row = []
        for j in range(0, path_number):
            vertex = vertices[i][j+starting_point].tolist()
            material = materials_dict.get(interaction[i][j+starting_point], None)
            if material is None:
                if (interaction[i][j+starting_point] == -1):
                    interaction_objs[i].append(None)
                    row.append([np.nan, np.nan, np.nan])
                else:
                    interaction_objs[i].append('unknown')
                    row.append(vertex)
            else:
                interaction_objs[i].append(material)
                row.append(vertex)
        interaction_vertex.append(row)
    return interaction_objs,interaction_vertex


for i in range(0,len(path_interactions)):
    interaction.append(path_interactions[i][0][0])
    vertices.append(path_vertices[i][0][0])
                    
'''
interaction_objs_reflection,interaction_vertex_reflection  = ineraction_object_function(num_los, num_ref)
interaction_objs_reflection = rearrange_function(interaction_objs_reflection, num_ref)
interaction_vertex_reflection = rearrange_function(interaction_vertex_reflection, num_ref)
'''
interaction_objs_diffraction,interaction_vertex_diffraction  = ineraction_object_function(num_los+num_ref, num_diff)
interaction_objs_diffraction = rearrange_function(interaction_objs_diffraction, num_diff)
interaction_vertex_diffraction = rearrange_function(interaction_vertex_diffraction, num_diff)
pprint (interaction_objs_diffraction)


'''
interaction_objs_scattering,interaction_vertex_scattering = ineraction_object_function(num_los+num_ref+num_diff, num_scat)
interaction_objs_scattering = rearrange_function(interaction_objs_scattering, num_scat)
interaction_vertex_scattering = rearrange_function(interaction_vertex_scattering, num_scat)

[SebastianCa]

Hi @itsghaniz,
From what I understand of your code, it seems you’re looking for the IDs of scene objects. However, diffraction occurs at wedges (for more details, see the Diffraction notebook).

Given your original intention to train an ML model using angles of arrival, it’s unclear to me what you’re trying to achieve with this approach.

[itsghaniz]

Hi, thanks for the reply, yea you are right, actually I am looking for the properties of the complete path. For example, where it started, the interactions it had ( materials) the angle it interacted with the material (using the material normal) the distances between each interaction, then on the bases of these inputs and properties, I intend to predict the channel coefficients and time delay for the path. And as you said diffraction occurs at the wedge, thats right, isnt that wedge made of any material? And moreover, if I know lets say the coordinates in sionna, is it possible to find the material at that coordinate?
Thanks in advance

[SebastianCa]

As mentioned earlier, there isn’t a built-in feature to directly access parameters. You would need to implement a custom method to retrieve the desired parameters. However, what you’re attempting sounds similar to the approach used in the diff-rt repository. In particular, the utils function may already offer many of the features you’re interested in.