Sionna
  • Installation
    • Using pip
    • From source
    • Testing
    • Documentation
    • Developing
  • Ray Tracing (RT)
    • Tutorials
      • Introduction to Sionna RT
        • Imports
        • Loading and Visualizing Scenes
        • Inspecting SceneObjects and Editing of Scenes
        • Ray tracing of Propagation Paths
        • From Paths to Channel Impulse and Frequency Responses
        • Radio Maps
        • Summary
      • Tutorial on Mobility
        • Background Information
        • GPU Configuration and Imports
        • Controlling Position and Orientation of Scene Objects
        • Time Evolution of Channels Via Doppler Shift
          • Example: Delay-Doppler Spectrum
        • Comparison of Doppler- vs Position-based Time Evolution
        • Summary
      • Tutorial on Radio Maps
        • Imports
        • Understanding radio maps
          • Metrics
          • Multiple transmitters
          • User association
          • Sampling of random user positions
          • Directional antennas and precoding vectors
        • Radio map for a realistic scene
          • Channel impulse responses for random user locations
        • Conclusions
      • Tutorial on Scattering
        • Imports
        • Scattering Basics
        • Scattering Patterns
        • Validation Against the “Far”-Wall Approximation
        • Radio Maps With Scattering
        • Impact on Channel Impulse Response
        • Summary
        • References
      • Tutorial on Loading and Editing of Scenes
        • Imports
        • Loading Scenes and Merging Objects
        • Editing Scenes
        • Path Computation with the Edited Scene
        • Summary
    • Primer on Electromagnetics
      • Coordinate system, rotations, and vector fields
      • Planar Time-Harmonic Waves
      • Far Field of a Transmitting Antenna
      • Modelling of a Receiving Antenna
      • General Propagation Path
      • Frequency & Impulse Response
      • Reflection and Refraction
        • Single-layer Slab
      • Diffraction
      • Scattering
      • Reconfigurable Intelligent Surfaces (RIS)
    • API Documentation
      • Antenna Arrays
        • AntennaArray
          • AntennaArray.antenna_pattern
          • AntennaArray.array_size
          • AntennaArray.normalized_positions
          • AntennaArray.num_ant
          • AntennaArray.positions()
          • AntennaArray.rotate()
        • PlanarArray
          • PlanarArray.antenna_pattern
          • PlanarArray.array_size
          • PlanarArray.normalized_positions
          • PlanarArray.num_ant
          • PlanarArray.positions()
          • PlanarArray.rotate()
          • PlanarArray.show()
      • Antenna Patterns
        • AntennaPattern
          • AntennaPattern.compute_gain()
          • AntennaPattern.patterns
          • AntennaPattern.show()
        • PolarizedAntennaPattern
          • PolarizedAntennaPattern.compute_gain()
          • PolarizedAntennaPattern.patterns
          • PolarizedAntennaPattern.show()
        • Vertically Polarized Antenna Pattern Functions
          • v_iso_pattern()
          • v_dipole_pattern()
          • v_hw_dipole_pattern()
          • v_tr38901_pattern()
        • Polarization Models
          • polarization_model_tr38901_1()
          • polarization_model_tr38901_2()
        • Utility Functions
          • antenna_pattern_to_world_implicit()
          • complex2real_antenna_pattern()
          • register_antenna_pattern()
          • register_polarization()
          • register_polarization_model()
      • Cameras
        • Camera
          • Camera.look_at()
          • Camera.orientation
          • Camera.position
      • Paths
        • Paths
          • Paths.a
          • Paths.cfr()
          • Paths.cir()
          • Paths.doppler
          • Paths.interactions
          • Paths.num_rx
          • Paths.num_tx
          • Paths.objects
          • Paths.phi_r
          • Paths.phi_t
          • Paths.primitives
          • Paths.rx_array
          • Paths.sources
          • Paths.synthetic_array
          • Paths.taps()
          • Paths.targets
          • Paths.tau
          • Paths.theta_r
          • Paths.theta_t
          • Paths.tx_array
          • Paths.valid
          • Paths.vertices
        • Constants
          • InteractionType
          • INVALID_SHAPE
          • INVALID_PRIMITIVE
      • Path Solvers
        • PathSolver
          • PathSolver.__call__()
          • PathSolver.loop_mode
      • Radio Devices
        • RadioDevice
          • RadioDevice.color
          • RadioDevice.display_radius
          • RadioDevice.look_at()
          • RadioDevice.name
          • RadioDevice.orientation
          • RadioDevice.position
          • RadioDevice.velocity
        • Receiver
        • Transmitter
          • Transmitter.power
          • Transmitter.power_dbm
      • Radio Map
        • RadioMap
          • RadioMap.cdf()
          • RadioMap.cell_centers
          • RadioMap.cell_size
          • RadioMap.center
          • RadioMap.num_cells
          • RadioMap.num_rx
          • RadioMap.num_tx
          • RadioMap.orientation
          • RadioMap.path_gain
          • RadioMap.rss
          • RadioMap.rx_cell_indices
          • RadioMap.sample_positions()
          • RadioMap.show()
          • RadioMap.show_association()
          • RadioMap.sinr
          • RadioMap.size
          • RadioMap.tx_association()
          • RadioMap.tx_cell_indices
      • Radio Map Solvers
        • RadioMapSolver
          • RadioMapSolver.__call__()
          • RadioMapSolver.loop_mode
      • Radio Materials
        • RadioMaterialBase
          • RadioMaterialBase.color
          • RadioMaterialBase.eval()
          • RadioMaterialBase.name
          • RadioMaterialBase.pdf()
          • RadioMaterialBase.sample()
          • RadioMaterialBase.scene
          • RadioMaterialBase.to_string()
          • RadioMaterialBase.traverse()
        • RadioMaterial
          • RadioMaterial.conductivity
          • RadioMaterial.frequency_update()
          • RadioMaterial.frequency_update_callback
          • RadioMaterial.relative_permittivity
          • RadioMaterial.scattering_coefficient
          • RadioMaterial.scattering_pattern
          • RadioMaterial.thickness
          • RadioMaterial.xpd_coefficient
        • ITURadioMaterial
          • ITURadioMaterial.itu_type
          • ITURadioMaterial.to_string()
        • HolderMaterial
          • HolderMaterial.radio_material
          • HolderMaterial.velocity
        • Scattering Patterns
          • ScatteringPattern
          • LambertianPattern
          • DirectivePattern
          • BackscatteringPattern
          • register_scattering_pattern()
      • Scenes
        • load_scene()
        • Scene
          • Scene.add()
          • Scene.all_set()
          • Scene.angular_frequency
          • Scene.bandwidth
          • Scene.edit()
          • Scene.frequency
          • Scene.get()
          • Scene.mi_scene
          • Scene.mi_scene_params
          • Scene.objects
          • Scene.paths_solver
          • Scene.preview()
          • Scene.radio_materials
          • Scene.receivers
          • Scene.remove()
          • Scene.render()
          • Scene.render_to_file()
          • Scene.rx_array
          • Scene.scene_geometry_updated()
          • Scene.sources()
          • Scene.targets()
          • Scene.temperature
          • Scene.thermal_noise_power
          • Scene.transmitters
          • Scene.tx_array
          • Scene.wavelength
        • Examples
          • box
          • box_one_screen
          • box_two_screens
          • double_reflector
          • etoile
          • floor_wall
          • florence
          • munich
          • simple_reflector
          • simple_street_canyon
          • simple_street_canyon_with_cars
          • simple_wedge
          • triple_reflector
      • Scene Objects
        • SceneObject
          • SceneObject.look_at()
          • SceneObject.mi_shape
          • SceneObject.name
          • SceneObject.object_id
          • SceneObject.orientation
          • SceneObject.position
          • SceneObject.radio_material
          • SceneObject.scaling
          • SceneObject.scene
          • SceneObject.velocity
      • Utility Functions
        • Complex-valued tensors
          • cpx_abs()
          • cpx_abs_square()
          • cpx_add()
          • cpx_convert()
          • cpx_div()
          • cpx_exp()
          • cpx_mul()
          • cpx_sqrt()
          • cpx_sub()
        • Electromagnetics
          • complex_relative_permittivity()
          • fresnel_reflection_coefficients_simplified()
          • itu_coefficients_single_layer_slab()
        • Geometry
          • phi_hat()
          • theta_hat()
          • r_hat()
          • theta_phi_from_unit_vec()
          • rotation_matrix()
        • Jones calculus
          • implicit_basis_vector()
          • jones_matrix_rotator()
          • jones_matrix_rotator_flip_forward()
          • to_world_jones_rotator()
          • jones_matrix_to_world_implicit()
          • jones_vec_dot()
        • Miscellaneous
          • complex_sqrt()
          • dbm_to_watt()
          • isclose()
          • log10()
          • sigmoid()
          • sinc()
          • subcarrier_frequencies()
          • watt_to_dbm()
        • Ray tracing
          • fibonacci_lattice()
          • spawn_ray_from_sources()
          • offset_p()
          • spawn_ray_towards()
          • spawn_ray_to()
    • Developer Guides
      • Compatibility with other Frameworks
        • Type conversions
        • Gradients
        • Training-Loop in PyTorch
      • Understanding the Paths Object
      • Custom Antenna Patterns
        • Gradient-based Optimization
      • Understanding Radio Materials
        • Modifying Parameters of Radio Materials
        • Calibrating Material Parameters Through Gradient Descent
        • Custom Radio Materials
          • Representation of Jones vector and Matrices
          • Implicit Basis
          • The Local Interaction Basis
          • Mandatory Subclass Methods
          • Implementation of a Simple Radio Material Model
          • A More Complex Material Model
      • Custom Scattering Patterns
        • Differentiable Parameters
    • Technical Report
  • Physical Layer (PHY)
    • Tutorials
      • Beginners
        • “Hello, world!”
        • Part 1: Getting Started with Sionna
          • Imports & Basics
          • A note on random number generation
          • Sionna Data-flow and Design Paradigms
          • Hello, Sionna!
          • Communication Systems as Sionna Blocks
          • Forward Error Correction (FEC)
          • Eager vs Graph Mode
          • Exercise
        • Part 2: Differentiable Communication Systems
          • Imports
          • Gradient Computation Through End-to-end Systems
          • Creating Custom Layers
          • Setting up Training Loops
        • Part 3: Advanced Link-level Simulations
          • Imports
          • OFDM Resource Grid and Stream Management
          • Antenna Arrays
          • Channel Model
          • Uplink Transmission in the Frequency Domain
        • Part 4: Toward Learned Receivers
          • Imports
          • Simulation Parameters
          • Implemention of an Advanced Neural Receiver
          • Training the Neural Receiver
          • Benchmarking the Neural Receiver
          • Conclusion
          • References
        • Basic MIMO Simulations
          • Table of Contents
          • Simple uncoded transmission
          • Extension to channel coding
        • Pulse-shaping Basics
          • Table of Contents
          • GPU Configuration and Imports
          • Pulse-shaping of a sequence of QAM symbols
          • Recovering the QAM symbols through matched filtering and downsampling
          • Investigating the ACLR
          • Windowing
        • Optical Channel with Lumped Amplification
          • Table of Contents
          • Setup
          • Impulse Generation
          • Attenuation
          • Amplified Spontaneous Emission Noise
          • Chromatic Dispersion
          • Kerr Nonlinearity
          • Split-Step Fourier Method
          • References
      • Experts
        • 5G Channel Coding and Rate-Matching: Polar vs. LDPC Codes
          • Table of Contents
          • GPU Configuration and Imports
          • BER Performance of 5G Coding Schemes
          • A Deeper Look into the Polar Code Module
          • Rate-Matching and Rate-Recovery
          • Throughput and Decoding Complexity
          • References
        • 5G NR PUSCH Tutorial
          • Table of Contents
          • GPU Configuration and Imports
          • A Hello World Example
          • Carrier Configuration
          • Understanding the DMRS Configuration
          • Transport Blocks and MCS
          • Looking into the PUSCHTransmitter
          • Components of the PUSCHReceiver
          • End-to-end PUSCH Simulations
        • Bit-Interleaved Coded Modulation (BICM)
          • Table of Contents
          • System Block Diagram
          • GPU Configuration and Imports
          • A Simple BICM System
          • All-zero Codeword Simulations
          • EXIT Charts
          • Mismatched Demapping and the Advantages of Min-sum Decoding
          • References
        • MIMO OFDM Transmissions over the CDL Channel Model
          • Table of Contents
          • System Setup
          • Simulations
        • Neural Receiver for OFDM SIMO Systems
          • GPU Configuration and Imports
          • Simulation Parameters
          • Neural Receiver
          • End-to-end System
          • End-to-end System as a Sionna Block
          • Evaluation of the Baselines
          • Training the Neural Receiver
          • Evaluation of the Neural Receiver
          • Pre-computed Results
          • References
        • Realistic Multiuser MIMO OFDM Simulations
          • Table of Contents
          • GPU Configuration and Imports
          • System Setup
          • Uplink Transmissions in the Frequency Domain
        • OFDM MIMO Channel Estimation and Detection
          • Table of Contents
          • GPU Configuration and Imports
          • Simulation parameters
          • Estimation of the channel time, frequency, and spatial covariance matrices
          • Loading the channel covariance matrices
          • Comparison of OFDM estimators
          • Comparison of MIMO detectors
        • Introduction to Iterative Detection and Decoding
          • Iterative Detection and Decoding
          • Table of contents
          • GPU Configuration and Imports
          • Simulation Parameters
          • Setting-up an End-to-end Block
          • Non-IDD versus IDD Benchmarks
          • Discussion-Optimizing IDD with Machine Learning
          • Comments
          • List of References
        • End-to-end Learning with Autoencoders
          • GPU Configuration and Imports
          • Simulation Parameters
          • Neural Demapper
          • Trainable End-to-end System: Conventional Training
          • Trainable End-to-end System: RL-based Training
          • Evaluation
          • Visualizing the Learned Constellations
          • References
        • Weighted Belief Propagation Decoding
          • Table of Contents
          • GPU Configuration and Imports
          • Weighted BP for BCH Codes
          • Further Experiments
          • References
        • Channel Models from Datasets
          • GPU Configuration and Imports
          • Simulation Parameters
          • Creating a Simple Dataset
          • Generators
          • Use the Channel Model for OFDM Transmissions
        • Using the DeepMIMO Dataset with Sionna
          • Table of Contents
          • GPU Configuration and Imports
          • Configuration of DeepMIMO
          • Using DeepMIMO with Sionna
          • Link-level Simulations using Sionna and DeepMIMO
          • DeepMIMO License and Citation
        • Link-level simulations with Sionna RT
          • Background Information
          • Imports
          • Setting up the Ray Tracer
          • Creating a CIR Dataset
          • PUSCH Link-Level Simulations
    • API Documentation
      • Configuration
        • Config
          • Config.np_cdtype
          • Config.np_rdtype
          • Config.np_rng
          • Config.precision
          • Config.py_rng
          • Config.seed
          • Config.tf_cdtype
          • Config.tf_rdtype
          • Config.tf_rng
      • Forward Error Correction (FEC)
        • Linear Codes
          • LinearEncoder
          • OSDecoder
        • Low-Density Parity-Check (LDPC)
          • LDPC5GEncoder
          • LDPCBPDecoder
          • LDPC5GDecoder
          • Node Update Functions
          • Decoder Callbacks
        • Polar Codes
          • Polar5GEncoder
          • PolarEncoder
          • Polar5GDecoder
          • PolarSCDecoder
          • PolarSCLDecoder
          • PolarBPDecoder
          • Utility Functions
        • Convolutional Codes
          • ConvEncoder
          • ViterbiDecoder
          • BCJRDecoder
          • Utility Functions
        • Turbo Codes
          • TurboEncoder
          • TurboDecoder
          • Utility Functions
        • Cyclic Redundancy Check (CRC)
          • CRCEncoder
          • CRCDecoder
        • Interleaving
          • RowColumnInterleaver
          • RandomInterleaver
          • Turbo3GPPInterleaver
          • Deinterleaver
        • Scrambling
          • Scrambler
          • TB5GScrambler
          • Descrambler
        • Utility Functions
          • (Binary) Linear Codes
          • EXIT Analysis
          • Miscellaneous
      • Mapping
        • Constellation
          • Constellation.center
          • Constellation.constellation_type
          • Constellation.normalize
          • Constellation.num_bits_per_symbol
          • Constellation.num_points
          • Constellation.points
          • Constellation.show()
        • Mapper
          • Mapper.constellation
        • Demapper
          • Demapper.constellation
        • SymbolDemapper
        • Utility Functions
          • BinarySource
          • LLRs2SymbolLogits
          • PAMSource
          • PAM2QAM
          • QAMSource
          • QAM2PAM
          • SymbolInds2Bits
          • SymbolLogits2LLRs
          • SymbolLogits2Moments
          • SymbolSource
      • Wireless Channel Models
        • AWGN
        • Flat-fading channel
          • FlatFadingChannel
          • GenerateFlatFadingChannel
          • ApplyFlatFadingChannel
          • SpatialCorrelation
          • KroneckerModel
          • PerColumnModel
        • Channel model interface
          • ChannelModel
        • Time domain channel
          • TimeChannel
          • GenerateTimeChannel
          • ApplyTimeChannel
          • cir_to_time_channel()
          • time_to_ofdm_channel()
        • Channel with OFDM waveform
          • OFDMChannel
          • GenerateOFDMChannel
          • ApplyOFDMChannel
          • cir_to_ofdm_channel()
        • Rayleigh block fading
          • RayleighBlockFading
        • 3GPP 38.901 channel models
          • PanelArray
          • Antenna
          • AntennaArray
          • TDL
          • CDL
          • UMi
          • UMa
          • RMa
        • External datasets
          • CIRDataset
        • Utility functions
          • subcarrier_frequencies()
          • time_lag_discrete_time_channel()
          • deg_2_rad()
          • rad_2_deg()
          • wrap_angle_0_360()
          • drop_uts_in_sector()
          • relocate_uts()
          • set_3gpp_scenario_parameters()
          • gen_single_sector_topology()
          • gen_single_sector_topology_interferers()
          • exp_corr_mat()
          • one_ring_corr_mat()
      • Optical Channel Models
        • SSFM
        • EDFA
        • Utility functions
          • time_frequency_vector()
      • Discrete Channel Models
        • BinaryErasureChannel
        • BinaryMemorylessChannel
          • BinaryMemorylessChannel.llr_max
          • BinaryMemorylessChannel.temperature
        • BinarySymmetricChannel
        • BinaryZChannel
      • Orthogonal Frequency-Division Multiplexing (OFDM)
        • Resource Grid
          • ResourceGrid
          • ResourceGridMapper
          • ResourceGridDemapper
          • RemoveNulledSubcarriers
        • Modulation & Demodulation
          • OFDMModulator
          • OFDMDemodulator
        • Pilot Pattern
          • PilotPattern
          • EmptyPilotPattern
          • KroneckerPilotPattern
        • Channel Estimation
          • BaseChannelEstimator
          • BaseChannelInterpolator
          • LSChannelEstimator
          • LinearInterpolator
          • LMMSEInterpolator
          • NearestNeighborInterpolator
          • tdl_time_cov_mat()
          • tdl_freq_cov_mat()
        • Precoding
          • RZFPrecoder
          • PrecodedChannel
          • CBFPrecodedChannel
          • EyePrecodedChannel
          • RZFPrecodedChannel
        • Equalization
          • OFDMEqualizer
          • LMMSEEqualizer
          • MFEqualizer
          • ZFEqualizer
          • PostEqualizationSINR
          • LMMSEPostEqualizationSINR
        • Detection
          • OFDMDetector
          • OFDMDetectorWithPrior
          • EPDetector
          • KBestDetector
          • LinearDetector
          • MaximumLikelihoodDetector
          • MaximumLikelihoodDetectorWithPrior
          • MMSEPICDetector
      • Multiple-Input Multiple-Output (MIMO)
        • Stream Management
          • StreamManagement
        • Precoding
          • cbf_precoding_matrix()
          • rzf_precoding_matrix()
          • rzf_precoder()
          • grid_of_beams_dft_ula()
          • grid_of_beams_dft()
          • flatten_precoding_mat()
          • normalize_precoding_power()
        • Equalization
          • lmmse_matrix()
          • lmmse_equalizer()
          • mf_equalizer()
          • zf_equalizer()
        • Detection
          • EPDetector
          • KBestDetector
          • LinearDetector
          • MaximumLikelihoodDetector
          • MMSEPICDetector
        • Utility Functions
          • List2LLR
          • List2LLRSimple
          • complex2real_vector()
          • real2complex_vector()
          • complex2real_matrix()
          • real2complex_matrix()
          • complex2real_covariance()
          • real2complex_covariance()
          • complex2real_channel()
          • real2complex_channel()
          • whiten_channel()
      • 5G NR
        • Carrier
          • CarrierConfig
        • Layer Mapping
          • LayerMapper
          • LayerDemapper
        • PUSCH
          • PUSCHConfig
          • PUSCHDMRSConfig
          • PUSCHLSChannelEstimator
          • PUSCHPilotPattern
          • PUSCHPrecoder
          • PUSCHReceiver
          • PUSCHTransmitter
        • Transport Block
          • TBConfig
          • TBEncoder
          • TBDecoder
        • Utils
          • calculate_tb_size()
          • generate_prng_seq()
          • decode_mcs_index()
          • calculate_num_coded_bits()
          • TransportBlockNR
          • CodedAWGNChannelNR
          • MCSDecoderNR
      • Signal
        • Filters
          • SincFilter
          • RaisedCosineFilter
          • RootRaisedCosineFilter
          • CustomFilter
          • Filter
        • Window functions
          • HannWindow
          • HammingWindow
          • BlackmanWindow
          • CustomWindow
          • Window
        • Utility Functions
          • convolve()
          • fft()
          • ifft()
          • Upsampling
          • Downsampling
          • empirical_psd()
          • empirical_aclr()
      • Utility Functions
        • Linear Algebra
          • inv_cholesky()
          • matrix_pinv()
        • Metrics
          • compute_ber()
          • compute_bler()
          • compute_ser()
          • count_block_errors()
          • count_errors()
        • Miscellaneous
          • dbm_to_watt()
          • db_to_lin
          • DeepUpdateDict
          • dict_keys_to_int()
          • ebnodb2no()
          • complex_normal()
          • hard_decisions()
          • Interpolate
          • lin_to_db
          • log2()
          • log10()
          • MCSDecoder
          • scalar_to_shaped_tensor()
          • sim_ber()
          • SingleLinkChannel
          • SplineGriddataInterpolation
          • to_list()
          • TransportBlock
          • watt_to_dbm()
        • Numerics
          • bisection_method()
        • Plotting
          • plot_ber()
          • PlotBER
        • Tensors
          • expand_to_rank()
          • flatten_dims()
          • flatten_last_dims()
          • insert_dims()
          • split_dim()
          • diag_part_axis()
          • flatten_multi_index()
          • gather_from_batched_indices()
          • tensor_values_are_in_set()
          • enumerate_indices()
      • For Developers
        • Object
          • Object.cdtype
          • Object.precision
          • Object.rdtype
        • Block
          • Block.build()
          • Block.built
          • Block.call()
    • Developer Guides
      • Matrix inversion
        • Solving linear systems
        • Correlated random vectors
      • Random number generation
      • Sionna Block and Object
        • Understanding Sionna Blocks
  • System Level (SYS)
    • Tutorials
      • Beginners
        • Physical Layer Abstraction
          • Imports
          • Instantiate a PHYAbstraction object
          • Retrieve BLER values from interpolated tables
          • Generate a new BLER table
          • Bypass physical layer computations
          • Effective SINR
          • Conclusions
          • References
        • Link Adaptation
          • Imports
          • Simulation parameters
          • The principles of link adaptation
          • Inner-Loop Link Adaptation (ILLA)
          • Outer-Loop Link Adaption (OLLA)
          • Conclusions
          • References
        • Proportional Fairness Scheduler
          • Imports
          • The main principle
          • Basic scenario
          • Schedule users
          • Evaluate performance
          • Conclusions
          • References
        • Hexagonal Grid Topology
          • Imports
          • Generate a multicell topology
          • Drop users
          • Set up a 3GPP multicell scenario
          • Per-stream SINR computation
          • Conclusions
        • Power Control
          • Imports
          • Multicell scenario
          • Uplink power control
          • Downlink power control
          • Conclusions
          • References
      • Experts
        • Sionna SYS meets Sionna RT
          • Imports
          • Simulation parameters
          • Scene creation
          • Channel generation via Sionna RT
          • System-level simulation
          • Conclusions
        • System-Level Simulations
          • Imports
          • Utils
          • Simulation
          • Performance metric analysis
          • Conclusions
    • API Documentation
      • PHY Abstraction
        • EffectiveSINR
          • EffectiveSINR.calibrate()
        • EESM
          • EESM.beta_table
          • EESM.beta_table_filenames
          • EESM.beta_tensor
          • EESM.validate_beta_table()
        • PHYAbstraction
          • PHYAbstraction.bler_interp_delta
          • PHYAbstraction.bler_table
          • PHYAbstraction.bler_table_filenames
          • PHYAbstraction.bler_table_interp
          • PHYAbstraction.cbs_interp_min_max_delta
          • PHYAbstraction.get_bler()
          • PHYAbstraction.get_idx_from_grid()
          • PHYAbstraction.load_table()
          • PHYAbstraction.new_bler_table()
          • PHYAbstraction.plot()
          • PHYAbstraction.snr_db_interp_min_max_delta
          • PHYAbstraction.snr_table_interp
          • PHYAbstraction.validate_bler_table()
      • Link Adaptation
        • InnerLoopLinkAdaptation
          • InnerLoopLinkAdaptation.bler_target
        • OuterLoopLinkAdaptation
          • OuterLoopLinkAdaptation.bler_target
          • OuterLoopLinkAdaptation.delta_down
          • OuterLoopLinkAdaptation.delta_up
          • OuterLoopLinkAdaptation.offset
          • OuterLoopLinkAdaptation.offset_max
          • OuterLoopLinkAdaptation.offset_min
          • OuterLoopLinkAdaptation.reset()
          • OuterLoopLinkAdaptation.sinr_eff_db_last
        • Note
      • Power Control
        • Uplink
          • open_loop_uplink_power_control()
        • Downlink
          • downlink_fair_power_control()
      • Scheduling
        • PFSchedulerSUMIMO
          • PFSchedulerSUMIMO.beta
          • PFSchedulerSUMIMO.pf_metric
          • PFSchedulerSUMIMO.rate_achieved_past
      • Multicell Topology
        • Hexagon
          • Hexagon.coord_axial
          • Hexagon.coord_dict()
          • Hexagon.coord_euclid
          • Hexagon.coord_offset
          • Hexagon.corners()
          • Hexagon.neighbor()
          • Hexagon.radius
        • HexGrid
          • HexGrid.cell_height
          • HexGrid.cell_loc
          • HexGrid.cell_radius
          • HexGrid.center_loc
          • HexGrid.grid
          • HexGrid.isd
          • HexGrid.mirror_cell_loc
          • HexGrid.num_cells
          • HexGrid.num_rings
          • HexGrid.show()
        • gen_hexgrid_topology()
        • get_num_hex_in_grid()
        • convert_hex_coord()
      • Utils
        • get_pathloss()
        • is_scheduled_in_slot()
        • spread_across_subcarriers()
  • Research Kit (RK)
    • Quickstart
      • Hardware Requirements
      • Step 1: Jetson Setup
      • Step 2: USRP Setup
      • Step 3: UE Setup
      • Step 4: Deploy 5G Stack
      • Have Your First Call
    • Setup
      • Platform Preparation
        • Bill of Materials
          • Computing Platform
          • RF Components
          • User Equipment
          • Optional Components
        • Jetson Setup
          • OS Installation
          • Post-Installation Setup
          • Version Information
        • Custom Linux Kernel
          • Prerequisites
          • Source Code
          • Kernel Configuration
          • Building the Kernel
          • Installing Kernel Image and Modules
          • Configure Boot Sequence
        • Performance Tweaks
          • Power Management
          • Default System Mode
          • Real-Time Scheduling
          • Verifying Settings
        • USRP Driver Installation
          • Key Resources
          • Prerequisites
          • Building UHD
          • Post-build Configuration
          • Testing Installation
        • SIM Card Programming
          • Prerequisites
          • UICC Software Setup
          • Programming SIM Card
          • Additional Resources
        • Quectel Modem Setup
          • Basic Configuration
          • AT Command Reference
          • Additional Resources
      • Software Configuration
        • OpenAirInterface Setup
          • Required Components
          • TLDR
          • Getting the Source Code
          • Patching
          • Create configuration files
          • Building OAI RAN Images
          • Building OAI 5G Core Images
          • Building Components Manually
        • 5G System Configuration
          • Environment Variables
          • Additional Resources
        • Using RF Simulator Mode
          • Basic Configuration
          • Dynamic Re-configuration
        • Installing Sionna
      • Your First Call
        • Connect & Test Performance
      • Documentation of Scripts
        • Setup Scripts
          • quickstart-oai.sh
          • quickstart-cn5g.sh
          • configure-system.sh
          • install-usrp.sh
        • Linux Kernel Customization
          • build-custom-kernel.sh
          • install-custom-kernel.sh
        • Configuration Files
          • start-system.sh
          • stop-system.sh
          • generate-configs.sh
        • Building Docker Images
          • build-cn5g-images.sh
          • build-oai-images.sh
        • Development / Patch tracking
          • get-config-changes.sh
          • get-oai-changed-files.sh
          • get-oai-cn5g-changed-files.sh
          • get-oai-commit-versions.sh
          • get-oai-cn5g-commit-versions.sh
    • Tutorials
      • Running the Tutorials
        • Command Cheat-sheet
        • GPU-Accelerated LDPC
        • Demapper Plugin
        • Data Capture Plugin
        • TensorRT Neural Demapper
      • GPU-Accelerated LDPC Decoding
        • Part 1: Background & Python Reference Implementation
          • Background: Channel Coding in 5G
          • Overview Decoder Implementation
          • Memory Layout
          • CN Update Function
          • VN Update Function
          • Hard-decision
          • Main Decoding Function
          • Run and Test the Decoder
        • Part 2: CUDA Implementation
          • Overview
          • CUDA Integration in OAI
          • Running the Decoder
          • Implementation Aspects
          • Outlook - Weighted Belief Propagation
        • References
      • Plugins & Data Acquisition
        • Part 1: Create a Plugin
          • Architecture Overview
          • Select Functions
          • Define Module Interface
          • Loading the Module
          • Use Module Functions
          • Module Implementation
          • Compiling
          • Incremental Builds
          • Container Changes
        • Part 2: Capture Data
          • Adding New Plugin Variant
          • Using New Plugin Variant
          • Access Captured Files
          • Capture Format
          • Add Timestamps
          • Account for Multi-Threading
          • Final Source Code
        • References
      • Integration of a Neural Demapper
        • Part 1: Neural Demapper Training and TensorRT Export
          • Python Imports
          • Background: APP-Demapping
          • Understanding the OAI Data Structure
          • Neural Demapper
          • Blind Demapping & Training with Synthetic Data
          • Improved Demapping & Training with Captured Data
          • Export TensorRT Engine
        • Part 2: GPU-Accelerated Inference
          • Demapper Implementation Overview
          • Setting up the TensorRT Inference Engine
          • Running Batched Inference
          • Converting Data Types between Host and Device
          • Demapper Integration in OAI
          • Running the Demapper
          • Implementation Aspects
          • Unit tests
          • Outlook
        • References
      • Software-defined End-to-End 5G Network
        • Run the gNB
        • Run the UE
        • Test performance
      • Debugging & Troubleshooting
        • Attaching a debugger (gdb and VS code)
        • Inspecting and debugging inside a container interactively
        • Running memcheck within an interactive Docker compose session
        • Profiling with NVIDIA Nsight Systems
        • Fixing missing linker error messages in docker build ran-build
    • Get the Code
  • “Made with Sionna”
  • Discussions
  • Report an Issue
  • Contribute
  • Citation

Older Versions

  • v0.19.2
Sionna
  • System Level (SYS)
  • API Documentation
  • Link Adaptation

Link Adaptation

../../_images/la_api.png

Link adaptation (LA) optimizes the performance of a single wireless link by dynamically adjusting transmission parameters to match time-varying channel conditions.

The objective is to maximize the achieved throughput while maintaining the transport block error rate (TBLER) sufficiently low. Typically, this is simplified to maintaining the TBLER close to a predefined target, designed to balance throughput and latency.

The main challenge lies in handling noisy and sparse SINR feedback, which is used to estimate the channel quality.

For a usage example of link adaptation in Sionna, we refer to the Link Adaptation notebook.

class sionna.sys.InnerLoopLinkAdaptation(phy_abstraction, bler_target=0.1, fill_mcs_value=0)[source]

Class for inner loop link adaptation (ILLA). It computes the highest available modulation and coding scheme (MCS) whose associated transport block error rate (TBLER) does not exceed the specified bler_target:

max{MCS: TBLER(MCS,SINReff)≤BLERtarget}

where SINReff is the effective SINR value provided as input. If no such MCS exists, the lowest available MCS index is returned. If a user is not scheduled, fill_mcs_value is returned.

Parameters:
  • phy_abstraction (PHYAbstraction) – An instance of PHYAbstraction

  • bler_target (float (default: 0.1)) – BLER target

  • fill_mcs_value (int (default: 0)) – MCS value assigned to non-scheduled users

Input:
  • sinr ([…, num_ofdm_symbols, num_subcarriers, num_ut, num_streams_per_ut], tf.float | None (default)) – SINR for each OFDM symbol, subcarrier, user and stream. If None, then sinr_eff and num_allocated_re are both required.

  • sinr_eff ([…, num_ut], tf.float | None (default)) – Estimated effective SINR for each user. If None, then sinr is required.

  • num_allocated_re ([…, num_ut], tf.int32 | None (default)) – Number of allocated resources in a slot, computed across OFDM symbols, subcarriers and streams, for each user. If None, then sinr is required.

  • mcs_table_index ([…, num_ut], tf.int32 | int (default: 1)) – MCS table index for each user. For further details, refer to the Note.

  • mcs_category ([…, num_ut], tf.int32 | int (default: 0)) – MCS table category for each user. For further details, refer to the Note.

  • return_lowest_available_mcs (bool (default: False)) – If True, the lowest MCS available in phy_abstraction BLER tables is returned for each user. Only used for internal purposes.

Output:

mcs_index ([…, num_ut]) – Highest available MCS whose BLER does not exceed the target, or the lowest available MCS if no such MCS exists, for each user

Example

from sionna.sys import PHYAbstraction, InnerLoopLinkAdaptation

bler_target = 0.1

# Initialize the PHY abstraction object
phy_abs = PHYAbstraction()

# Initialize the ILLA object
illa = InnerLoopLinkAdaptation(phy_abs,
                            bler_target=0.1)

# Effective SINR for each user
sinr_eff = tf.Variable([0.1, 10, 100])
# N. allocated resource elements for each user
num_allocated_re = tf.Variable([20, 30, 30])

# Compute the MCS index for each user
mcs_index = illa(sinr_eff=sinr_eff,
                num_allocated_re=num_allocated_re,
                mcs_table_index=1,
                mcs_category=0)
print('Selected MCS index =', mcs_index.numpy())
% Selected MCS index = [ 3 16 27]
property bler_target

Get/set the BLER target for each user

Type:

tf.float

class sionna.sys.OuterLoopLinkAdaptation(phy_abstraction, num_ut, bler_target=0.1, delta_up=1.0, batch_size=None, sinr_eff_init=1.0, sinr_eff_init_fill=1.0, offset_min=-20.0, offset_max=20.0)[source]

Class for outer-loop link adaptation (OLLA). The modulation and coding scheme (MCS) index for a user is determined as the highest index whose corresponding transport block error rate (TBLER) remains below the specified bler_target. The SINR value used for TBLER computation is given by the last effective SINR feedback, SINReff [dB], reduced by an offset value, Δoffset:

max{MCS: TBLER(MCS,SINReff−Δoffset)≤BLERtarget}

The value of Δoffset is adjusted depending on the HARQ feedback [Pedersen05]:

Δoffset={Δoffset−Δdownif HARQ=ACKΔoffset+Δupif HARQ=NACK

where the relationship between Δup and Δdown is given by [Sampath97]:

ΔupΔdown=1−BLERtargetBLERtarget.
Parameters:
  • phy_abstraction (PHYAbstraction) – An instance of PHYAbstraction

  • num_ut (int) – Number of user terminals

  • bler_target (float (default: 0.1)) – BLER target value, within 0 and 1

  • delta_up (float (default: 1.)) – Increment applied to the SINR offset [dB] when a NACK is received for a user

  • batch_size (list | int | None (default)) – Batch size or shape. It accounts for multiple users for which link adaptation is performed simultaneously. If None, the batch size is set to [].

  • sinr_eff_init ([…, num_ut], tf.float | float (default: 1.)) – Initial value of effective SINR for each user. Non-positive values are treated as missing and replaced by sinr_eff_init_fill. If float, the same value is assigned to all users.

  • sinr_eff_init_fill (float (default: 1.)) – Value replacing non-positive sinr_eff_init values

  • offset_min (float (default: -20.)) – Minimum SINR [dB] offset value

  • offset_max (float (default: 20.)) – Maximum SINR [dB] offset value

Input:
  • num_allocated_re ([…, num_ut], tf.int32) – Number of allocated resources in the upcoming slot, computed across OFDM symbols, subcarriers and streams, for each user

  • harq_feedback ([…, num_ut], -1 | 0 | 1) – If 0 (1, resp.), then a NACK (ACK, resp.) is received. If -1, feedback is missing.

  • sinr_eff ([…, num_ut], tf.float | None (default)) – Estimated effective SINR for each user. Non-positive values are treated as missing.

  • mcs_table_index ([…, num_ut], tf.int32 | int (default: 1)) – MCS table index for each user. For further details, refer to the Note.

  • mcs_category ([…, num_ut], tf.int32 | int (default: 0)) – MCS table category for each user. For further details, refer to the Note.

Output:

mcs_index ([…, num_ut]) – Selected MCS index for each user

property bler_target

Get/set the BLER target for each user

Type:

tf.float

property delta_down

Decrement applied to the SINR offset when an ACK is received for a user. Computed as delta_up * bler_target / (1 - bler_target).

Type:

float (read-only)

property delta_up

Get/set the increment applied to the SINR offset when a NACK is received for a user

Type:

float

property offset

Effective SINR [dB] offset for each user

Type:

[…, num_ut], tf.float (read-only)

property offset_max

Get/set the maximum offset value

Type:

tf.float

property offset_min

Get/set the minimum offset value

Type:

tf.float

reset(sinr_eff_init=1.0, sinr_eff_init_fill=0.1)[source]

Resets the values of sinr_eff_db_last and offset

property sinr_eff_db_last

Get/set the last observed effective SINR [dB] value for each user

Type:

[…, num_ut], tf.float

Note

The concepts of MCS table index, category, code block and transport blocks are inspired by but not necessarily tied to 3GPP standards. It is assumed that:

  • Each MCS category has multiple table indices, each defining the mapping between MCS indices and their corresponding modulation orders and coding rates. Such relationships are defined by sinr_effective_fun;

  • The transport block, which serves as main data unit, is divided into multiple code blocks. The number and size of these code blocks are computed by transport_block_fun.

Yet, if neither sinr_effective_fun nor transport_block_fun is provided, this class aligns with 3GPP TS 38.214 ([3GPP38214]), specifically Section 5.1.3 (PUSCH) and Section 6.1.4 (PDSCH). In this case, the MCS category refers to PDSCH (category = 1) and PUSCH (0). Valid table indices are {1, 2} for PUSCH and {1, 2, 3, 4} for PDSCH. For more information, refer to TBConfig.

References:
[Pedersen05]

K. I. Pedersen, G. Monghal, I. Z. Kovacs, T. E. Kolding, A. Pokhariyal, F. Frederiksen, P. Mogensen. “Frequency domain scheduling for OFDMA with limited and noisy channel feedback,” IEEE Vehicular Technology Conference (VTC), pp. 1792-1796, Sep. 2007.

[Sampath97]

A. Sampath K. P. Sarath, J. M. Holtzman. “On setting reverse link target SIR in a CDMA system.” 1997 IEEE 47th Vehicular Technology Conference. Technology in Motion. Vol. 2. IEEE, 1997.

Previous Next

© Copyright 2021-2025 NVIDIA CORPORATION.

Built with Sphinx using a theme provided by Read the Docs.