Generate channel matrix using sionna.rt

[Moshe313]

Hi, I'm working on a project that requires a channel matrix that depends on the transmitter and receiver location. I used sionna.rt.load_scene() to do this.
I want to know how sionna calculates the values ​​in the channel matrix I output and what type of channel it is (TDL, TCL, etc.).
Attaching the function that generates the channel. Thank you!

    def GenerateH(num_tx_ant: int, num_rx_ant: int, location_tr: list, location_rec: list):
        """
        Generate a location channel according to BS & EU locations
        """
    
        # Define parameters
        x1, y1, z1 = location_tr    # Location of the transmitter
        x2, y2, z2 = location_rec  # Location of the receiver
        resolution = [480, 320]
    
        # Create an empty scene
        scene = load_scene()
    
        my_cam = Camera("my_cam", position=[x1, y1, z1+450], look_at=[x1, y1, z1])
        scene.add(my_cam)
    
        # Render scene with new camera*
        scene.render("my_cam", resolution=resolution, num_samples=512)
    
        # Define the transmitter's antenna array
        scene.tx_array = PlanarArray(
            num_rows=1,
            num_cols=num_tx_ant,
            vertical_spacing=0.5,
            horizontal_spacing=0.5,
            pattern="dipole",
            polarization="V"
        )
    
        # Define the receiver's antenna array
        scene.rx_array = PlanarArray(
            num_rows=1,
            num_cols=num_rx_ant,
            vertical_spacing=0.5,
            horizontal_spacing=0.5,
            pattern="dipole",
            polarization="V"
        )
    
        # Create the transmitter object
        tx = Transmitter(
            name='tx',
            position=[x1, y1, z1],
            power_dbm=30,
            orientation=[0, 0, 0]
        )
        scene.add(tx)
    
        # Create the receiver object
        rx = Receiver(
            name='rx',
            position=[x2, y2, z2],
            orientation=[0, 0, 0]
        )
        scene.add(rx)
    
        # Compute propagation paths
        paths = scene.compute_paths(max_depth=5,
                                    method="exhaustive",
                                    num_samples=1e6)
        scene.render("my_cam", paths=paths, show_devices=True, show_paths=True, resolution=resolution)
        ### paths.a = [batch?, num_of_rx, num_of_rx_antennas, num_of_tx, num_of_tx_antennas, paths, Doppler shifts] ###
        H = paths.a[0, 0, :, 0, :, 0, 0].numpy()
    
        H = tf.cast(H / tf.norm(H), tf.complex64)   # tf.cast(tf.eye(H.shape[0], H.shape[1]), tf.complex64)
    
        return H

[Moshe313]

Anyone?

[jhoydis]

Hi @Moshe313,

Ray tracing is an alternative to stochastic channel models like TDL, CDL, UMI, etc.
The EM Primer explains in great detail how channel impulse response are generated.

[rotemfin]

Hi,

Thank you for the clarification!

Following up on that, we’re trying to understand the structure of the received signal matrix we get at the receiver. Specifically, when using the channel() function, we would like to know what kind of values are represented in the matrix y.

Our main question is how the antennas at the receiver are mapped to the positions in the y matrix. For example, which part of the matrix corresponds to a specific antenna at the receiver side?

Any additional details about how the data is organized in y would be greatly appreciated.

Thanks a lot!