[Sionna RT] Contribution of precoder/combiner weights in Coverage Map function

[mauro-belgiovine]

Dear all,

I am exploring Sionna RT functionalities, I am especially interested in understanding how does the sionna.rt.Scene.coverage_map works with respect to the combining_vec and precoding_vec parameters and how the sionna.rt.Scene.synthetic_array property interact with the coverage function.

Specifically, I would like to experiment with different precoders and combiners configurations applied at transmitter and receiver side and observe how the beam orientations (computed using a steering vector function) affects the channel power perceived at a specific location of the coverage map. My expectation is that, based on the beam configurations, the perceived power should change at a given cell in the coverage map, although I did some tests with a 8x8 TX array and single antenna RX (both with sionna.rt.Scene.synthetic_array set to True or False) and it doesn't seem like there is a dramatic change in the perceived power when I change the precoder. Here is an example with the default precoding (i.e. 90 degree, perpendicular to the array) vs. a precoder computed using the steering vector function and pointing to a different angle (240 degrees) :

• precoder pointing at 90 degrees
  
• precoder pointing at 240 degrees
  

I was wondering if I could find the answer to these questions in order to better debug this behavior:

1. Is there a function provided by Sionna to compute precoder/combiners, given an array configuration and an angle (i.e. steering function)?
2. What function should I use to visualize the radiation pattern of an array when a precoder/combiner is applied?

Thanks in advance for any advice, I have just started working with this library and I am excited to do some great simulations with it!

[faycalaa]

Hi,

There are currently no additional utilities for computing a steering vector or visualizing the radiation pattern when a precoder/combiner is applied.
Also, only synthetic arrays are used to compute the coverage map.

Here is a short piece of code that illustrates how a precoding vector changes the radiation pattern:

scene = load_scene(sionna.rt.scene.munich)

num_cols = 64
scene.tx_array = PlanarArray(num_rows=1,
            num_cols=num_cols,
            vertical_spacing=0.5,
            horizontal_spacing=0.5,
            pattern="iso",
            polarization="V")

scene.rx_array = PlanarArray(num_rows=1,
                            num_cols=1,
                            vertical_spacing=0.5,
                            horizontal_spacing=0.5,
                            pattern="iso",
                            polarization="V")

# Transmitter
tx = Transmitter(name="tx",
                position=[35.11, 60.08, 10.],
                orientation=[0,0,0])
scene.add(tx)

# RX
rx = Receiver(name="rx",
              position=[95., 62., 10.0],
              orientation=[0,0,0])
scene.add(rx)
tx.look_at(rx)

# Steering vector
steering_angle = 20. # degrees
steering_angle = steering_angle*np.pi/180. # radian
precoding_vec = tf.range(num_cols, dtype=tf.float32)
precoding_vec = tf.exp(tf.complex(0., 2.*np.pi*precoding_vec*0.5*tf.math.sin(steering_angle)))
precoding_vec = precoding_vec / tf.linalg.norm(precoding_vec)

# Capture the power on a vertical coverage map
cm = scene.coverage_map(max_depth=0, cm_cell_size=[1.,1.], precoding_vec=precoding_vec, cm_size=[50., 100.], cm_orientation=[0.0, 0.5*np.pi, 0.0], cm_center=[95., 62., 0.])

scene.preview(coverage_map=cm, cm_vmax=-50.)

Which gives the following visualization:

For a steering angle of 0 degrees, you should get the following:

The steering angle is here defined with respect to the normal to the antenna array.
Note that only LoS is enabled in this example for a better visualization (max_depth = 0) and a vertical coverage map is defined to highlight the directivity of the radiation pattern.

Hope that helps.

[IBRAAHIIMM]

Hi,
Sorry for the late reply. I could not get back to you. Thanks for the reply! Here is the code snippet.

#Angular domain resolution
N_azi = 20
N_ele = 20
#Antenna config
Nx = 8  # Number of elements along the horizontal axis
Ny = 8  # Number of elements along the vertical axis
dx = 0.5  # Spacing between elements along the x-axis
dy = 0.5  # Spacing between elements along the y-axis
wavelength = 1 

#define the simulation range
azimuth_angles = np.linspace(-np.pi/2, np.pi/2, N_azi)  # Azimuth angles from -90 to 90 degrees
elevation_angles = np.linspace(-np.pi/2, np.pi/2, N_ele)  # Elevation angles from -90 to 90 degrees
beamforming_matrix = np.zeros((len(azimuth_angles), len(elevation_angles), Ny, Nx), dtype=complex)

#Calculate the positions of the elements in the UPA
x_positions = np.arange(Nx) * dx
y_positions = np.arange(Ny) * dy

for az_idx, azimuth in enumerate(azimuth_angles):
    for el_idx, elevation in enumerate(elevation_angles):
        # Calculate the wave vector
        k = 2 * np.pi / wavelength * np.array([np.sin(elevation) * np.cos(azimuth),np.sin(elevation) * np.sin(azimuth),np.cos(elevation)])
        # Loop through each element position
        for ny, y_pos in enumerate(y_positions):
            for nx, x_pos in enumerate(x_positions):
                # Calculate the phase shift for the element
                phase_shift = np.exp(-1j * np.dot(k, [x_pos, y_pos, 0]))
                # Store the beamforming vector in the 4D matrix
                beamforming_matrix[az_idx, el_idx, ny, nx] = phase_shift
                
#Reshape the beamforming vectors into column vectors based on the antenna element representation in the Sionna
beamforming_matrix = np.transpose(beamforming_matrix,(0,1,3,2)).reshape(beamforming_matrix.shape[0],beamforming_matrix.shape[1],Nx*Ny)

"""Get the time channel or the frequency channel for """


scene = load_scene(sionna.rt.scene.munich)

Ny = 8 #vertical elements
Nx = 8 #horizontal elements
fc = 24e9
bandwidth =100e6
max_depth = 0

scene.tx_array = PlanarArray(num_rows=Ny,
            num_cols=Nx,
            vertical_spacing=0.5,
            horizontal_spacing=0.5,
            pattern="iso",
            polarization="V")

scene.rx_array = PlanarArray(num_rows=1,
                            num_cols=1,
                            vertical_spacing=0.5,
                            horizontal_spacing=0.5,
                            pattern="iso",
                            polarization="V")


 #Create transmitter
tx = Transmitter(name="tx",
              position=[8.5,21,27],
              orientation=[0,0,0])
scene.add(tx)

# Create a receiver
rx = Receiver(name="rx",
          position=[45,90,1.5],
          orientation=[0,0,0])
scene.add(rx)


tx.look_at(rx)

#Rotate the tx by 45 degrees with respect to the rx
tx.orientation += np.array([0.45*np.pi,0.0, 0.])


#set the frequency in the scene
scene.frequency = fc

paths = scene.compute_paths(max_depth=max_depth, num_samples=5e5, diffraction=False, scattering=False)#, scat_keep_prob=scat_prob)


a,tau = paths.cir()


l_min,l_max = sionna.channel.time_lag_discrete_time_channel(bandwidth, maximum_delay_spread=3e-06)
print(f"fc {fc} Number of channel taps {l_max-l_min}")
h_time = sionna.channel.cir_to_time_channel(bandwidth, a, tau, l_min, l_max, normalize=False)


"""Calculate the channel gain"""
#initialize 2D matrix where columns are azimuth angle responses and rows are elevation angle responses
channel_gain  = np.zeros((N_ele,N_azi))
for i_azi in range(N_azi):
    for j_ele in range(N_ele):
        beamformer = beamforming_matrix[i_azi,j_ele].reshape([Nx*Ny,1])
        beamformed_channel_taps = np.einsum("ij,ic->jc",beamformer,h_time)
        channel_gain[j_ele,i_azi] = np.sum(np.abs(beamformed_channel_taps)**2)

I am plotting the heatmap of channel_gain. There seems to be a rotation in the peak for different frequencies.

[IBRAAHIIMM]

I do not know why it does not preview the code.

[faycalaa]

Hi @IBRAAHIIMM ,

You should set the scene frequency before configuring the antenna arrays to ensure that the correct spacing is used by the antenna arrays. In your current code, the scene frequency is set after setting the antenna arrays, and therefore the antenna spacing of the arrays is set using the wavelength corresponding to the default carrier frequency (3.5 GHz).

[IBRAAHIIMM]

Hi @faycalaa,
Thanks for your input! It is fixed now.

[jhoydis]

Hi @IBRAAHIIMM,

Since the latest release (v0.18), this problem should be automatically fixed because the spacing of the elements of a planar array now scale automatically with the scene frequency.