gen_single_sector_topology

sionna.phy.channel.gen_single_sector_topology(batch_size: int, num_ut: 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 and num_ut UTs randomly and uniformly dropped in a cell sector

The following picture shows the sector from which 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.

Parameters:

• batch_size (int) – Batch size

• num_ut (int) – Number of UTs to sample 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, 3], torch.float. UTs locations.

• 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, 3], torch.float. UTs orientations [radian].

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

• ut_velocities – [batch_size, num_ut, 3], torch.float. UTs velocities [m/s].

• in_state – [batch_size, num_ut], 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.

Examples

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

# 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(batch_size=100,
                                      num_ut=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()