RCS Calculation using Sionna RT by sampling objects with huge amount of rays.

[tbhunderbird]

Following scenario: Let us assume a transmitter and receiver far away from the objects ~10km with objects being something from 2m up to 200m.
I want the objects to be sampled every 0.003m (in a projected grid towards the sensor) in order to get a good approximation of arbitrary objects with point scatterers in order to calculate the RCS.
How would I approach this using Sionna RT? Or is it not suited for such calculations?

[jhoydis]

Hi @tbhunderbird,

I'd need a little bit more background to answer your question. Here are some thoughts based on what I understand:

This is currently not supported. Rays are shot from the source in directions defined by a Fibonacci lattice on a sphere. Even with 1bn rays, you would not get the resolution that you need at 10km distance. However, it would not be difficult to implement this yourself as a custom PathSolver, where rays are shot toward specific directions.

What exactly do you mean by "sample an object"? If you look for specular reflections on the object, this resolution is not needed. If you want to compute diffuse reflections, it probably also does not make sense because the reflected field can be approximated by essentially a single diffuse reflection (see the section on far-wall-approximation from this tutorial) from a surface with the RCS.

If your goal is to compute the RCS that you can then use to compute the diffusely reflected field, your problem seems to be more related to obtaining the projected surface of the object w.r.t. the transmitter as well as the scattering pattern. I am not sure that shooting rays with a high resolution is a good approach for this.

[tbhunderbird]

Thanks for the quick reply!
I am also very interested in the diffuse case (and your thoughts are well aligned with mine) but let us stick to perfectly conducting metallic objects for now to stay focused:

If you look, for example, at Fig. 4 of the paper "RCS reduction of dihedral corners" https://ieeexplore.ieee.org/document/1141586
the response of a metallic flat plate/wedge varies depending on the aspect angle.
One way to reproduce this pattern of main- and side-peaks is to "sample" the metallic plate with enough rays (typically at least lambda/4 or better lambda/10 or even finer) and coherently add the resulting scatterer contributions (the sum of the square root RCS, for example, which is more or less equivalent to summing up the electric fields I think).
See also Gordon 1975 "Far-field approximations to the Kirchoff-Helmholtz representations of scattered fields" https://ieeexplore.ieee.org/document/1141105 for a closed form for polygonal objects.

Sampling gives us the opportunity to calculate the RCS for arbitrary metallic objects for which we lack a closed-form solution like for Polygons (Gordon 1975).

Regarding your first hint: I would just change line 356 in https://github.com/NVlabs/sionna-rt/blob/main/src/sionna/rt/path_solvers/sb_candidate_generator.py with my own substitute of fibonacci_lattice? Or are there other assumptions based upon the fibonacci lattice that I would need to adapt?

[jhoydis]

Hi,

Thanks for sharing these references. It is still not clear to me what you would like to accomplish.

Imagine that your object is a metallic plate. I assume that you are interested in computing the propagation path from TX-Object-RX(=TX).
If this is the case, you will get a single specular reflection from this object if and only if the angle of incidence with respect to the surface normal is 0 degrees. In all other cases, there is no specularly reflected path. This result is independent of the number of rays you shoot as they only serve to identify candidate sequences of primitives and interaction types that could lead to valid propagation paths.

[tbhunderbird]

Basically „shooting and bouncing rays“ algorithm. One shoots many rays on the object, creates point scatterers and coherently adds them up.
So yes. There is only one specular path but for shooting and bouncing rays you need more than the approximation of just the specular reflection if I am not mistaken.
Only by coherent summation of all the scatterers one can replicate the pattern of main and side lobes.

[jhoydis]

What do you want to compute? The scattered field at a specific point or the RCS of the object for a specific incoming and outgoing angle?

In any case, this is not what Sionna RT can do out of the box.

[tbhunderbird]

Both would be fine. Scattered field at the Rx Antenna to compute the RCS given the relative position of Tx, Object, and Rx.

Understood. So I would need to implement my own "Custom Radio Material" I guess?
By the way. You have a section about "Custom Radio Materials" and then there is a section about "Custom Scattering Patterns".
Is the scattering pattern only relevant for the "RadioMaterial" and I could use that in my "custom radio material" inheriting from "RadioMaterialBase" if I want to or is it used elsewhere (apart from the RadioMaterial class).

And picking up this question:
Is it correct, that I could adjust the ray-shoot-pattern by changing line 356 in https://github.com/NVlabs/sionna-rt/blob/main/src/sionna/rt/path_solvers/sb_candidate_generator.py with my own substitute of fibonacci_lattice? Or are there other assumptions based upon the fibonacci lattice that I would need to adapt?

[jhoydis]

Yes, you can use your custom ScatteringPattern with your custom RadioMaterial.

You can change the fibonacci lattice and replace it with any other source of rays. However, as soon as you enable diffuse reflections, it is assumed that every ray gets an equal fraction of solid angle which might not be the case.

[potatoess11]

Hi, @jhoydis :
I also want to calculate the RCS (Radar Cross Section) of a perceived object. My current method is to model a very realistic car in a certain scenario, dividing the materials into the metal body and the glass windows. I then set the positions of the transmitter and receiver to be the same, transmit a signal, and extract all paths with an interaction count of 1, followed by extracting the coordinates of interaction points, transmission power, and other information to input into the RCS calculation formula.

According to the 3GPP(3GPP TSG RAN WG1 #118 R1- 2406107) measurement values for car RCS, there should be peaks at specific angles of 0, 90, 180, and 270 degrees, but no matter how I change the conductivity and dielectric constant of the metal and glass, as well as the dimensions of the body and glass, and the three parameters in the scattering model, I cannot achieve peaks at these four angles. This does not match the actual situation. Furthermore, regardless of how these parameters are modified, the RCS values for the car at different angles remain similar and do not show significant changes.I would like to ask you, what could be the possible reasons for this?

[jhoydis]

Hi @potatoess11,

What is the distance from the TX/RX to the car?
Do you use diffuse scattering?

Without a working code example, it is difficult to help you.

[potatoess11]

Hi, @jhoydis :
I found the geometric center of the car in Blender, so I set the transceiver 4m in front of the car, making it rotate 5° each time, totaling 72 sets of RCS values. Below is my simulation part of the code; I changed the scattering pattern of the car glass and the metal body, and I put all these parameters in a dictionary called params. Every time I call the simulation, a new set of parameters will be passed in.if you need, I can also provide the code for calculating RCS.

     scattering_pattern1 = BackscatteringPattern(alpha_r=15,
                                                alpha_i=15,
                                                lambda_=0.8)
     set_materials(scene, scattering_pattern1)
     scattering_pattern =BackscatteringPattern(alpha_r=param_dict['alpha_r'],
                                               alpha_i=param_dict['alpha_i'],
                                               lambda_=param_dict['lambda_'])

     #print(f"alpha_r: {scattering_pattern.alpha_r}, alpha_i: {scattering_pattern.alpha_i}, lambda_: {scattering_pattern.lambda_}")
     # ===========================================
     set_materials_rcs(scene, param_dict,scattering_pattern)
     car_glass = scene.get("car-glass")              
     car_metal = scene.get("car-metal")
     itu_=car_glass.radio_material
     itu__=car_metal.radio_material
     print("glass:",itu_)
     print("glass",car_glass.scaling)
     print("metal:",itu__)
     print("metal:",car_metal.scaling)
     tx = Transmitter(name="tx",
                 position=[38.8,31.69,0.5],
                 orientation=[0.0, 0.0, 0.0])
     scene.add(tx)

     rx = Receiver(name="rx",
                   position=[38.8,31.69,0.5],
                   orientation=[0.0, 0.0, 0.0])
     scene.add(rx)

     scene.tx_array = PlanarArray(num_rows=4,
                                  num_cols=4,
                                  vertical_spacing=0.5,
                                  horizontal_spacing=0.5,
                                  pattern="hw_dipole",
                                  polarization="V")
     scene.rx_array = PlanarArray(num_rows=2,
                                  num_cols=2,
                                  vertical_spacing=0.5,
                                  horizontal_spacing=0.5,
                                  pattern="hw_dipole",
                                  polarization="V")

     print("tx：")
     d_t,Gt_gain,eta_t=scene.tx_array.antenna_pattern.compute_gain()
     print("rx：")
     d_r,Gr_gain,eta_r=scene.rx_array.antenna_pattern.compute_gain()
     p_solver=PathSolver()
     print("car_glass",car_glass.position)
     print("car_metal",car_metal.position)
     rotation_angle=np.pi/36  
     current_angle=0
     print(f"    start:Time= {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
     start_time = time.time()
     num_displacements = num_points
     for snapid in tqdm(range(0, num_displacements),desc="simulation"):
         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)
         H_rt = np.squeeze(paths.cfr(frequencies=frequencies,
                                normalize=False,  # Normalize energy
                                normalize_delays=False,
                                out_type="numpy"))
         h_rt = np.squeeze(paths.taps(bandwidth, 0, 1023, sampling_frequency=None, normalize_delays=False, normalize=False,
                                 out_type="numpy"))
         complex_a = paths.a[0].numpy()[:, :, :, :, :] + 1j * paths.a[1].numpy()[:, :, :, :, :]
         H_rt_list.append(H_rt)
         h_rt_list.append(h_rt)
         print(paths.valid.shape)
         print(paths.interactions.shape)
         rt_paths['a'][snapid] = tf.squeeze(complex_a).numpy()
         rt_paths['tau'][snapid] = tf.squeeze(paths.tau).numpy() * 1e9  # 转换为纳秒
         rt_paths['theta_t'][snapid] = tf.squeeze(paths.theta_t).numpy()
         rt_paths['phi_t'][snapid] = tf.squeeze(paths.phi_t).numpy()
         rt_paths['theta_r'][snapid] = tf.squeeze(paths.theta_r).numpy()
         rt_paths['phi_r'][snapid] = tf.squeeze(paths.phi_r).numpy()
         rt_paths['source_coordinates'][snapid] = tf.squeeze(paths.sources).numpy()
         rt_paths['target_coordinates'][snapid] = tf.squeeze(paths.targets).numpy()
         rt_paths['Transmitter_coordinates'][snapid] = list(scene.transmitters.values())[0].position.numpy()
         rt_paths['Receiver_coordinates'][snapid] = list(scene.receivers.values())[0].position.numpy()
         rt_paths['valid'][snapid] = tf.squeeze(paths.valid).numpy()
         rt_paths['objects'][snapid] = tf.squeeze(paths.objects).numpy()
         rt_paths['interactions'][snapid] = tf.squeeze(paths.interactions).numpy()
         rt_paths['vertices'][snapid] = tf.squeeze(paths.vertices).numpy()
         current_angle += rotation_angle
         car_glass.orientation = [current_angle, 0, 0]
         car_metal.orientation = [current_angle, 0, 0]
         angle_deg = math.degrees(current_angle)
         print(f"car_glass : [ {angle_deg:.2f}°,0, 0], car_metal : [ {angle_deg:.2f}°,0, 0]")

     end_time = time.time()

[jhoydis]

Would you have the car model as well?

[potatoess11]

The car model was downloaded from the Blender library.It seems that uploading .xml or .obj file formats is not supported.