Release v1.2.1

Signed-off-by: The Sionna Team <sionna@nvidia.com>
Merged-by: Guillermo Marcus <4169784+gmarcusm@users.noreply.github.com>

Co-authored-by: Jakob Hoydis <5190129+jhoydis@users.noreply.github.com>
Co-authored-by: Fayçal Ait-Aoudia <43564757+faycalaa@users.noreply.github.com>
Co-authored-by: Sebastian Cammerer <18167671+SebastianCa@users.noreply.github.com>
Co-authored-by: Lorenzo Maggi <34341780+lollodealma@users.noreply.github.com>
Co-authored-by: Merlin Nimier-David <merlin.nimier@gmail.com>
Co-authored-by: Baptiste Nicolet <40777524+bathal1@users.noreply.github.com>
Co-authored-by: Guillermo Marcus <4169784+gmarcusm@users.noreply.github.com>

Author: 7 people

README.md

@@ -122,6 +122,6 @@ If you use this software, please cite it as:
  author = {Hoydis, Jakob and Cammerer, Sebastian and {Ait Aoudia}, Fayçal and Nimier-David, Merlin and Maggi, Lorenzo and Marcus, Guillermo and Vem, Avinash and Keller, Alexander},
  note = {https://nvlabs.github.io/sionna/},
  year = {2022},
- version = {1.2.0}
+ version = {1.2.1}
 }
 ```

doc/source/citation.rst

@@ -11,5 +11,5 @@ If you use this software, please cite it as:
     Alexander},
     note = {https://nvlabs.github.io/sionna/},
     year = {2022},
-    version = {1.2.0}
+    version = {1.2.1}
    }

doc/source/index.rst

@@ -25,7 +25,7 @@ rapidly prototyped by connecting the desired blocks.
 NVIDIA GPU acceleration provides orders-of-magnitude faster simulation, enabling
 the interactive exploration of such systems, for example, in `Jupyter notebooks <https://jupyter.org/>`_ that can be run on cloud services such as `Google Colab <https://colab.research.google.com>`_. If no GPU is available, Sionna will run on the CPU.
 
-The `Sionna Research Kit (SRK) <rk/index.html>`_ allows to deploy trained AI/ML components in a real software-defined 5G NR radio access network (RAN). It is based on the `OpenAirInterface <https://gitlab.eurecom.fr/oai/openairinterface5g>`_ project and is powered by the `NVIDIA Jetson AGX Orin platform <https://www.nvidia.com/en-us/autonomous-machines/embedded-systems/jetson-orin/>`_.
+The `Sionna Research Kit (SRK) <rk/index.html>`_ allows to deploy trained AI/ML components in a real software-defined 5G NR radio access network (RAN). It is based on the `OpenAirInterface <https://gitlab.eurecom.fr/oai/openairinterface5g>`_ project and is powered by the `NVIDIA Jetson AGX Thor platform <https://www.nvidia.com/en-us/autonomous-machines/embedded-systems/jetson-thor/>`_.
 
 Sionna is developed, continuously extended, and used by NVIDIA to drive 5G and 6G research.
 

ext/sionna-rt

@@ -15,7 +15,7 @@ exclude = ["sionna.rt*"]
 
 [project]
 name = "sionna"
-version = "1.2.0"
+version = "1.2.1"
 description = "Sionna - A hardware-accelerated differentiable open-source library for research on communication systems"
 readme = "README.md"
 license = {text = "Apache-2.0"}
@@ -51,7 +51,7 @@ classifiers = [
 ]
 requires-python = ">=3.10"
 dependencies = [
-    "sionna-rt==1.2.0",
+    "sionna-rt==1.2.1",
     "tensorflow(>=2.14, !=2.16, !=2.17)",
     "numpy(>=1.26, <2.0)",
     "scipy>=1.14.1",

pyproject.toml

@@ -5,7 +5,7 @@
 
 import importlib
 
-__version__ = "1.2.0"
+__version__ = "1.2.1"
 
 # pylint: disable=invalid-name
 def __getattr__(name):

src/sionna/__init__.py

@@ -631,48 +631,44 @@ def calculate_tb_size(modulation_order,
             target_tb_size, tf.cast(num_coded_bits, target_tb_size.dtype),
             message="target_tb_size must be less than num_coded_bits.")
 
-        # no quantization for user input
-        n_info_q = target_tb_size
-
     else:
         # Compute n info bits (Target TB size)
         target_tb_size = target_coderate * tf.cast(num_coded_bits, rdtype)
 
-        # quantize target_tb_size
-        def n_info_q_if_target_tbs_greater_3824():
-            # Compute quantized n. info bits if target TB size > 3824
-            # Step 4 of 38.214 5.3.1.2
-            log2_n_info_minus_24 = tf.math.log(
-                target_tb_size - tf.cast(24, target_tb_size.dtype)) \
-            / tf.math.log(tf.cast(2.0, target_tb_size.dtype))
-            n = tf.math.floor(log2_n_info_minus_24) - 5.
-            n_info_q = tf.math.maximum(
-                tf.cast(3840.0, rdtype),
-                tf.cast(2**n * tf.math.round((target_tb_size - 24) / 2**n), rdtype))
-            return n_info_q
-
-        def n_info_q_if_target_tbs_smaller_3824():
-            # Compute quantized n. info bits if target TB size <= 3824
-            log2_n_info = tf.math.log(target_tb_size) \
-                / tf.cast(tf.math.log(2.0), target_tb_size.dtype)
-            n = tf.math.maximum(tf.cast(3.0, rdtype),
-                                tf.cast(tf.math.floor(log2_n_info) - 6, rdtype))
-            n_info_q = tf.math.maximum(
-                tf.cast(24.0, rdtype),
-                tf.cast(2**n * tf.math.floor(target_tb_size / 2**n), rdtype))
-            return n_info_q
-
-        # ----------------------------- #
-        # Quantized n. information bits #
-        # ----------------------------- #
-        n_info_q = tf.where(target_tb_size <= 3824,
-                            n_info_q_if_target_tbs_smaller_3824(),
-                            n_info_q_if_target_tbs_greater_3824())
+    # quantize target_tb_size
+    def n_info_q_if_target_tbs_greater_3824():
+        # Compute quantized n. info bits if target TB size > 3824
+        # Step 4 of 38.214 5.3.1.2
+        log2_n_info_minus_24 = tf.math.log(
+            target_tb_size - tf.cast(24, target_tb_size.dtype)) \
+        / tf.math.log(tf.cast(2.0, target_tb_size.dtype))
+        n = tf.math.floor(log2_n_info_minus_24) - 5.
+        n_info_q = tf.math.maximum(
+            tf.cast(3840.0, rdtype),
+            tf.cast(2**n * tf.math.round((target_tb_size - 24) / 2**n), rdtype))
+        return n_info_q
+
+    def n_info_q_if_target_tbs_smaller_3824():
+        # Compute quantized n. info bits if target TB size <= 3824
+        log2_n_info = tf.math.log(target_tb_size) \
+            / tf.cast(tf.math.log(2.0), target_tb_size.dtype)
+        n = tf.math.maximum(tf.cast(3.0, rdtype),
+                            tf.cast(tf.math.floor(log2_n_info) - 6, rdtype))
+        n_info_q = tf.math.maximum(
+            tf.cast(24.0, rdtype),
+            tf.cast(2**n * tf.math.floor(target_tb_size / 2**n), rdtype))
+        return n_info_q
+
+    # ----------------------------- #
+    # Quantized n. information bits #
+    # ----------------------------- #
+    n_info_q = tf.where(target_tb_size <= 3824,
+                        n_info_q_if_target_tbs_smaller_3824(),
+                        n_info_q_if_target_tbs_greater_3824())
     # ------------------- #
     # Auxiliary functions #
     # ------------------- #
 
-
     def tbs_if_target_tbs_higher_3824():
         # Compute TB size if target_tb_size>3824
         tbs = 8 * num_cb * tf.math.ceil((n_info_q + 24) / (8 * num_cb)) - 24

src/sionna/phy/nr/utils.py

@@ -87,7 +87,6 @@ def get_pathloss(h_freq,
     batch_size = h_freq.shape[:-6]
     lbs = len(batch_size)
     num_ofdm_symbols = h_freq.shape[-2]
-    num_ut = tf.reduce_sum(rx_tx_association)
 
     # Compute RX power
     # [..., num_rx, num_rx_ant, num_tx, num_tx_ant, num_ofdm_symbols, num_subcarriers]
@@ -109,6 +108,9 @@ def get_pathloss(h_freq,
             True,
             message="rx_tx_association must contain binary values")
 
+        # Number of UTs
+        num_ut = tf.reduce_sum(rx_tx_association)
+
         # Extract pathloss for serving TX only, for each RX
         rx_tx_association = rx_tx_association == 1
         # [batch_size, num_rx, num_tx]

src/sionna/sys/utils.py

@@ -51,7 +51,6 @@ def run_test(test_name):
     x_grid = tf.transpose(x_grid[0,0], perm=[2,1,0])
     return np.allclose(tf.squeeze(x_grid), grid)
 
-@pytest.mark.usefixtures("only_gpu")
 @pytest.mark.parametrize("test_id", list(range(0,83)))
 def tests_against_reference(test_id):
     """Test PUSCHTransmitter output against reference"""

test/unit/nr/test_pusch_transmitter.py

@@ -326,17 +326,17 @@ def calculate_tb_size_numpy(modulation_order,
         # include tb_scaling as defined in Tab. 5.1.3.2-2 38.214
         n_info = target_coderate * num_coded_bits
 
-        # apply quantization of info bit
-        if n_info <= 3824:
-            # step3 in 38.214 5.1.3.2
-            n = max(3, np.floor(np.log2(n_info)) - 6)
-            n_info_q = max(24, 2**n * np.floor(n_info/2**n))
-        else:
-            # step 4 in 38.212 5.3.1.2
-            n = np.floor(np.log2(n_info-24)) - 5
-            # "ties in the round function are broken towards next largest
-            # integer"
-            n_info_q = max(3840, 2**n * np.round((n_info-24)/2**n))
+    # apply quantization of info bit
+    if n_info <= 3824:
+        # step3 in 38.214 5.1.3.2
+        n = max(3, np.floor(np.log2(n_info)) - 6)
+        n_info_q = max(24, 2**n * np.floor(n_info/2**n))
+    else:
+        # step 4 in 38.212 5.3.1.2
+        n = np.floor(np.log2(n_info-24)) - 5
+        # "ties in the round function are broken towards next largest
+        # integer"
+        n_info_q = max(3840, 2**n * np.round((n_info-24)/2**n))
 
     if n_info_q <= 3824:
         c=1