gen_single_sector_topology_interferers

sionna.phy.channel.gen_single_sector_topology_interferers(batch_size: int, num_ut: int, num_interferer: int, scenario: str, min_bs_ut_dist: float | None = None, isd: float | None = None, bs_height: float | None = None, min_ut_height: float | None = None, max_ut_height: float | None = None, indoor_probability: float | None = None, min_ut_velocity: float | None = None, max_ut_velocity: float | None = None, precision: str | None = None, device: str | None = None) → Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]

Generate a batch of topologies consisting of a single BS located at the origin, num_ut UTs randomly and uniformly dropped in a cell sector, and num_interferer interfering UTs randomly dropped in the adjacent cells

The following picture shows how UTs are sampled.

UT velocity and orientation are drawn uniformly at random, whereas the BS points towards the center of the sector it serves.

The drop configuration can be controlled through the optional parameters. Parameters set to None are set to valid values according to the chosen scenario (see [TR38901V1920]).

The returned batch of topologies can be used as-is with the set_topology() method of the system level models, i.e. UMi, UMa, and RMa.

In the returned ut_loc, ut_orientations, ut_velocities, and in_state tensors, the first num_ut items along the axis with index 1 correspond to the served UTs, whereas the remaining num_interferer items correspond to the interfering UTs.

Parameters:

• batch_size (int) – Batch size

• num_ut (int) – Number of UTs to sample per batch example

• num_interferer (int) – Number of interfering UTs per batch example

• scenario (str) – System level model scenario. One of "uma", "umi", "rma", "uma-calibration", or "umi-calibration".

• min_bs_ut_dist (float | None) – Minimum BS-UT distance [m]

• isd (float | None) – Inter-site distance [m]

• bs_height (float | None) – BS elevation [m]

• min_ut_height (float | None) – Minimum UT elevation [m]

• max_ut_height (float | None) – Maximum UT elevation [m]

• indoor_probability (float | None) – Probability of a UT to be indoor. For RMa, the remaining UTs are interpreted as in-car by RMa unless an explicit in_car mask is passed to set_topology().

• min_ut_velocity (float | None) – Minimum UT velocity [m/s]

• max_ut_velocity (float | None) – Maximum UT velocity [m/s]

• precision (str | None) – Precision used for internal calculations and outputs. If set to None, precision is used.

• device (str | None) – Device for computation. If None, device is used.

Outputs:

• ut_loc – [batch_size, num_ut + num_interferer, 3], torch.float. UTs locations. The first num_ut items along the axis with index 1 correspond to the served UTs, whereas the remaining num_interferer items correspond to the interfering UTs.

• bs_loc – [batch_size, 1, 3], torch.float. BS location. Set to (0,0,0) for all batch examples.

• ut_orientations – [batch_size, num_ut + num_interferer, 3], torch.float. UTs orientations [radian]. The first num_ut items along the axis with index 1 correspond to the served UTs, whereas the remaining num_interferer items correspond to the interfering UTs.

• bs_orientations – [batch_size, 1, 3], torch.float. BS orientation [radian]. Oriented towards the center of the sector.

• ut_velocities – [batch_size, num_ut + num_interferer, 3], torch.float. UTs velocities [m/s]. The first num_ut items along the axis with index 1 correspond to the served UTs, whereas the remaining num_interferer items correspond to the interfering UTs.

• in_state – [batch_size, num_ut + num_interferer], torch.bool. Indoor/outdoor state of UTs. True means indoor, False means outdoor. For RMa, the initial set_topology() call interprets every False entry as in-car per Table 7.2-3 unless in_car is supplied explicitly. The first num_ut items along the axis with index 1 correspond to the served UTs, whereas the remaining num_interferer items correspond to the interfering UTs.

Examples

from sionna.phy.channel.tr38901 import PanelArray, UMi
from sionna.phy.channel import gen_single_sector_topology_interferers

# Create antenna arrays
bs_array = PanelArray(num_rows_per_panel=4,
                      num_cols_per_panel=4,
                      polarization='dual',
                      polarization_type='VH',
                      antenna_pattern='38.901',
                      carrier_frequency=3.5e9)

ut_array = PanelArray(num_rows_per_panel=1,
                      num_cols_per_panel=1,
                      polarization='single',
                      polarization_type='V',
                      antenna_pattern='omni',
                      carrier_frequency=3.5e9)

# Create channel model
channel_model = UMi(carrier_frequency=3.5e9,
                    o2i_model='low',
                    ut_array=ut_array,
                    bs_array=bs_array,
                    direction='uplink')

# Generate the topology
topology = gen_single_sector_topology_interferers(batch_size=100,
                                                  num_ut=4,
                                                  num_interferer=4,
                                                  scenario='umi')

# Set the topology
ut_loc, bs_loc, ut_orientations, bs_orientations, ut_velocities, in_state = topology
channel_model.set_topology(ut_loc,
                           bs_loc,
                           ut_orientations,
                           bs_orientations,
                           ut_velocities,
                           in_state)
channel_model.show_topology()