Implementing a network system based on LoS

[yacine074]

Hello,

I want to create a system consisting of four nodes: a primary user or transmitter (U_P) and its destination (D_P), a secondary full-duplex relay (R), and a secondary user (U_S) and its destination (D_S). I aim to only consider the line-of-sight (LoS) path between the nodes and exclude the other paths generated by the 3GPP channel model such as LoS in Realistic Multiuser

• My question is, How can I deploy this system such that I can obtain the channel state information (CSI) between each node, including H_PP, H_RS, H_SR, etc.? I have attempted to solve this problem by following the instructions in LoS in Realistic Multiuser, but I encountered an error where print(d(h_SS)) returned ((<tf.Tensor: shape=(1, 1, 1, 1, 1, 1), dtype=complex64, numpy=array([[[[[[nan+nanj]]]]]], dtype=complex64)>,), and also my method does not take into account the fact that the users are not operating simultaneously.

• How can I simulate the operation of the relay which work in Full-Duplex mode sends and receives at the same time?

Thank you

from sionna.channel.tr38901 import Antenna, AntennaArray, CDL, UMi, UMa, RMa

from sionna.channel import gen_single_sector_topology

from sionna.channel import subcarrier_frequencies, cir_to_ofdm_channel, cir_to_time_channel

import tensorflow as tf

import numpy as np

import sionna

BATCH_S = 3

scenario = "umi"

carrier_frequency = 3.5e9

direction = "uplink"

num_ut = 4

U_S = Antenna(polarization="single", polarization_type="V", antenna_pattern="omni", carrier_frequency=carrier_frequency)

D_S = Antenna(polarization="single", polarization_type="V", antenna_pattern="omni", carrier_frequency=carrier_frequency)

U_P = Antenna(polarization="single", polarization_type="V", antenna_pattern="omni", carrier_frequency=carrier_frequency)

D_P = Antenna(polarization="single", polarization_type="V", antenna_pattern="omni", carrier_frequency=carrier_frequency)

R = Antenna(polarization="single", polarization_type="V", antenna_pattern="omni", carrier_frequency=carrier_frequency)

Create channel model

channel_model_SS = UMi(carrier_frequency = carrier_frequency, o2i_model = 'low', ut_array = D_S, bs_array = U_S, direction = 'uplink')

channel_model_SR = UMi(carrier_frequency = carrier_frequency, o2i_model = 'low', ut_array = D_S, bs_array = R, direction = 'uplink')

# Same for other channels PP, RS...

Generate the topology

topology_SS = gen_single_sector_topology(batch_size = BATCH_S, num_ut = 1, scenario = 'umi')

topology_SR = gen_single_sector_topology(batch_size = BATCH_S, num_ut = 1, scenario = 'umi')

Set the topology

#in_state = tf.constant([[True], [True], [True]])

i_s = tf.expand_dims(tf.constant(np.ones(BATCH_S).astype(bool)*False), axis=1)

ut_loc_SS, bs_loc_SS, ut_orientations, bs_orientations, ut_velocities, x = topology_SS
ut_loc_SR, bs_loc_SR, ut_orientations, bs_orientations, ut_velocities, x = topology_SR

Base station coordinates

X_CORD = 3
Y_CORD = 3
Z_CORD = 3

bs_loc = tf.constant([[X_CORD,Y_CORD,Z_CORD], [0.0,0.0,0.0], [0.0,0.0,0.0]])

bas_loc = tf.expand_dims(bs_loc, axis=1)

channel_model_SS.set_topology(ut_loc, bs_loc_SS, ut_orientations, bs_orientations, ut_velocities, in_state = i_s, los = True)

channel_model_SR.set_topology(ut_loc, bs_loc_SR, ut_orientations, bs_orientations, ut_velocities, in_state = i_s, los = True)

channel_model_SS.show_topology()
channel_model_SR.show_topology()

a_SS, tau_SS = channel_model_SS(1,200)# channel impulse responses
a_SR, tau_SR = channel_model_SR(1,200)# channel impulse responses

a_los_SS = a_SS[:,:,:,:,:,:1,:] # Keep only the first path coefficient and delay, which define the LoS path.
a_los_SR = a_SR[:,:,:,:,:,:1,:] # Keep only the first path coefficient and delay, which define the LoS path.

tau_los_SS = tau_SS[:,:,:,:1] # Keep only the first path coefficient and delay, which define the LoS path.
tau_los_SR = tau_SR[:,:,:,:1] # Keep only the first path coefficient and delay, which define the LoS path.

h_SS = cir_to_ofdm_channel(1.5, a_los_SS,tau_los_SS)

h_SR = cir_to_ofdm_channel(1.5, a_los_SR,tau_los_SR)

d = sionna.channel.ApplyOFDMChannel() #y : [batch size, num_rx, num_rx_ant, num_ofdm_symbols, fft_size], tf.complex

print(d(h_SS))

print(d(h_SR))

[jhoydis]

Hi, could you please share a full notebook that allows to reproduce the issue?
Concerning the full-duplex mode, it is up to you to decide which signals interfere with each other.

[yacine074]

Hi, Thank you for your reply. Please find attached the full notebook.
Sionna_simulation.ipynb.zip

[jhoydis]

Hi,

I have had a look at your example notebook.

The use of the ApplyOFDMChannel layer is incorrect. It takes a 2- or 3-tuple as input (in your case a 3-tuple as you implicitly set the add_awgn flag) and not just a tensor. The idea is that this layer applies the channel coefficients to the inputs and adds noise on top. So calling this layer with only channel coefficients as input does not make much sense. Please have a look at the API Documentation.

The reason why your code works with a batch size of three is because it can be unpacked to three tensors like a 3-tuple. It would not work for any other value.