Paths

A propagation path\(i\) starts at a transmit antenna and ends at a receive antenna. It is described byits channel coefficient\(a_i\) and delay\(\tau_i\), as well as theangles of departure\((\theta_{\text{T},i}, \varphi_{\text{T},i})\)and arrival\((\theta_{\text{R},i}, \varphi_{\text{R},i})\).For more detail, see thePrimer on Electromagnetics.

In Sionna, paths are computed with the help of a path solver (such asPathSolver)which returns an instance ofPaths.Paths can be visualized by providing them as arguments to the functionsrender(),render_to_file(), orpreview().

Channel impulse responses (CIRs) can be obtained withcir() which canthen be used for link-level simulations. This is for example done in theSionna Ray Tracing Tutorial.

classsionna.rt.Paths(scene,src_positions,tgt_positions,tx_velocities,rx_velocities,synthetic_array,paths_buffer,rel_ant_positions_tx,rel_ant_positions_rx)[source]

Stores the simulated propagation paths

Paths are generated for the loaded scene using a path solver, such asPathSolver. Please refer to the documentation of thisclass for further details.

Parameters:

• scene (sionna.rt.scene.Scene) – Scene for which paths are computed

• src_positions (mitsuba.Point3f) – Positions of the sources

• tgt_positions (mitsuba.Point3f) – Positions of the targets

• tx_velocities (mitsuba.Vector3f) – Velocities of the transmitters

• rx_velocities (mitsuba.Vector3f) – Velocities of the receivers

• synthetic_array (bool) – If set toTrue, then the antenna arrays are applied synthetically

• paths_buffer (sionna.rt.path_solvers.paths_buffer.PathsBuffer) – Paths buffer storing the computed paths

• rel_ant_positions_tx (mitsuba.Point3f |None) – Positions of the array elements with respect to the center of the transmitters. Only required if synthetic arrays are used.

• rel_ant_positions_rx (mitsuba.Point3f |None) – Positions of the array elements with respect to the center of the receivers. Only required if synthetic arrays are used.

propertya

Real and imaginary components of the channel coefficients [unitless, linear scale]

Type:

Tuple[mi.TensorXf[num_rx,num_rx_ant,num_tx,num_tx_ant,num_paths],mi.TensorXf[num_rx,num_rx_ant,num_tx,num_tx_ant,num_paths]]

cfr(frequencies,sampling_frequency=1.0,num_time_steps=1,normalize_delays=True,normalize=False,reverse_direction=False,out_type='drjit')[source]

Compute the frequency response of the channel atfrequencies.Optionally, time evolution of the channel can be simulated basedon the Doppler shifts of all paths.

Given a channel impulse response\((a_i^\text{b}(t), \tau_{i}), 0 \leq i \leq M-1\), as computedbycir(),the channel frequency response for the frequency\(f\)is computed as follows:

\[\widehat{h}(f, t) = \sum_{i=0}^{M-1}a_i^\text{b}(t) e^{-j2\pi f \tau_{i}}\]

The time evolution of the channel is simulated as described inthe documentation ofcir().

Parameters:

• frequencies (drjit.cuda.ad.Float) – Frequencies [Hz] at which to compute thechannel response

• sampling_frequency (float) – Frequency [Hz] at which the channel impulseresponse is sampled

• num_time_steps (int) – Number of time steps

• normalize_delays (bool) – If set toTrue, path delays are normalizedsuch that the first path between any pair of antennas of atransmitter and receiver arrives at\(\tau = 0\).

• normalize (bool) – If set toTrue, the channel is normalized acrosstime and frequencies to ensure unit average energy.

• reverse_direction (bool) – If set to True, swaps receivers andtransmitters

• out_type (typing.Literal['drjit','jax','numpy','tf','torch']) – Name of the desired output type.Currently supported areDr.Jit(“drjit),Numpy (“numpy”),Jax (“jax”),TensorFlow (“tf”),andPyTorch (“torch”).

Returns:

Real and imaginary components of the baseband equivalent channelcoefficients\(a^{\text{b}}_{i}\)

Return type:

Shape: [num_rx, num_rx_ant, num_tx, num_tx_ant,num_time_steps, num_frequencies],Type:Tuple[mi.TensorXf|np.array |jax.array|tf.Tensor |torch.tensor

cir(*,sampling_frequency=1.0,num_time_steps=1,normalize_delays=True,reverse_direction=False,out_type='drjit')[source]

Returns the baseband-equivalent channel impulse response(28)which can be used for link simulations by other Sionna components.Optionally, time evolution of the channel can be simulated basedon the Doppler shifts of all paths.

The baseband equivalent channel coefficient\(a^{\text{b}}_{i}(t)\)at time\(t\) is computed as :

\[a^{\text{b}}_{i}(t) = \underbrace{a_{i} e^{-j2 \pi f \tau_{i}}}_{a^{\text{b}}_{i} } \underbrace{e^{j 2\pi f_{\Delta, i} t}}_{\text{Doppler phase shift}}\]

where\(i\) is the index of an arbitrary path,\(a_{i}\)is the passband path coefficient (a),\(\tau_{i}\) is the path delay (tau),\(f\) is the carrier frequency, and\(f_{\Delta, i}\) is theDoppler shift of the\(i\text{th}\) path.

Parameters:

• sampling_frequency (float) – Frequency [Hz] at which the channel impulseresponse is sampled

• num_time_steps (int) – Number of time steps

• normalize_delays (bool) – If set toTrue, path delays are normalizedsuch that the first path between any pair of antennas of atransmitter and receiver arrives at\(\tau = 0\)

• reverse_direction (bool) – If set to True, swaps receivers andtransmitters

• out_type (typing.Literal['drjit','jax','numpy','tf','torch']) –

  Name of the desired output type.Currently supported areDr.Jit(“drjit),Numpy (“numpy”),Jax (“jax”),TensorFlow (“tf”),andPyTorch (“torch”).

Returns:

Real and imaginary components of the baseband equivalent channelcoefficients\(a^{\text{b}}_{i}\)

Return type:

Shape: [num_rx, num_rx_ant, num_tx,num_tx_ant, num_paths, num_time_steps],Type:Tuple[mi.TensorXf,mi.TensorXf]|np.array |jax.array|tf.Tensor |torch.tensor

Returns:

Paths delays\(\tau_{i}\) [s]

Return type:

Shape: [num_rx, num_rx_ant, num_tx,num_tx_ant, num_paths] or [num_rx, num_tx, num_paths],Type:mi.TensorXf|np.array |jax.array|tf.Tensor |torch.tensor

propertydoppler

Doppler shift for each path

To understand how Doppler shifts are computed, let us consider a single propagation path undergoing\(n\) scattering processes, e.g., reflection, diffuse scattering,refraction, as shown in the figure below.

The object on which lies the\(i\text{th}\) scattering point has the velocity vector\(\hat{\mathbf{v}}_i\) and the outgoing ray direction at this point isdenoted\(\hat{\mathbf{k}}_i\). The first and last point correspond to the transmitterand receiver, respectively. We therefore have

\[\begin{split}\hat{\mathbf{k}}_0 &= \hat{\mathbf{r}}(\theta_{\text{T}}, \varphi_{\text{T}})\\\hat{\mathbf{k}}_{n} &= -\hat{\mathbf{r}}(\theta_{\text{R}}, \varphi_{\text{R}})\end{split}\]

where\((\theta_{\text{T}}, \varphi_{\text{T}})\) are the AoDs,\((\theta_{\text{R}}, \varphi_{\text{R}})\) are the AoAs, and\(\hat{\mathbf{r}}(\theta,\varphi)\) is defined in(1).

If the transmitter emits a signal with frequency\(f\), the receiverwill observe the signal at frequency\(f'=f + f_\Delta\), where\(f_\Delta\) is the Dopplershift, which can be computed as[Wiffen2018]

\[f' = f \prod_{i=0}^n \frac{1 - \frac{\mathbf{v}_{i+1}^\mathsf{T}\hat{\mathbf{k}}_i}{c}}{1 - \frac{\mathbf{v}_{i}^\mathsf{T}\hat{\mathbf{k}}_i}{c}}.\]

Under the assumption that\(\lVert \mathbf{v}_i \rVert\ll c\), we can apply the Taylor expansion\((1-x)^{-1}\approx 1+x\), for\(x\ll 1\), to the previous equationto obtain

\[\begin{split}f' &\approx f \prod_{i=0}^n \left(1 - \frac{\mathbf{v}_{i+1}^\mathsf{T}\hat{\mathbf{k}}_i}{c}\right)\left(1 + \frac{\mathbf{v}_{i}^\mathsf{T}\hat{\mathbf{k}}_i}{c}\right)\\ &\approx f \left(1 + \sum_{i=0}^n \frac{\mathbf{v}_{i}^\mathsf{T}\hat{\mathbf{k}}_i -\mathbf{v}_{i+1}^\mathsf{T}\hat{\mathbf{k}}_i}{c} \right)\end{split}\]

where the second line results from ignoring terms in\(c^{-2}\). Solving for\(f_\Delta\), grouping terms with the same\(\mathbf{v}_i\) together, and using\(f=c/\lambda\), we obtain

\[f_\Delta = \frac{1}{\lambda}\left(\mathbf{v}_{0}^\mathsf{T}\hat{\mathbf{k}}_0 - \mathbf{v}_{n+1}^\mathsf{T}\hat{\mathbf{k}}_n + \sum_{i=1}^n \mathbf{v}_{i}^\mathsf{T}\left(\hat{\mathbf{k}}_i-\hat{\mathbf{k}}_{i-1} \right) \right) \qquad \text{[Hz]}.\]

Type:

mi.TensorXf[num_rx,num_rx_ant,num_tx,num_tx_ant,num_paths]or[num_rx,num_tx,num_paths]:

propertyinteractions

Interaction type represented usingInteractionType

Type:

mi.TensorXu[max_depth,num_rx,num_rx_ant,num_tx,num_tx_ant,num_paths]or[max_depth,num_rx,num_tx,num_paths]

propertynum_rx

Number of receivers

Type:

int

propertynum_tx

Number of transmitters

Type:

int

propertyobjects

IDs of the intersected objects. Invalid objects are represented byINVALID_SHAPE.

Type:

mi.TensorXu[max_depth,num_rx,num_rx_ant,num_tx,num_tx_ant,num_paths]or[max_depth,num_rx,num_tx,num_paths]

propertyphi_r

Azimuth angles of arrival [rad]

Type:

mi.TensorXf[num_rx,num_rx_ant,num_tx,num_tx_ant,num_paths]or[num_rx,num_tx,num_paths]

propertyphi_t

Azimuth angles of departure [rad]

Type:

mi.TensorXf[num_rx,num_rx_ant,num_tx,num_tx_ant,num_paths]or[num_rx,num_tx,num_paths]

propertyprimitives

Indices of the intersected primitives. Invalid primitives arerepresented byINVALID_PRIMITIVE.

Type:

mi.TensorXu[max_depth,num_rx,num_rx_ant,num_tx,num_tx_ant,num_paths]or[max_depth,num_rx,num_tx,num_paths]

propertyrx_array

Antenna array used by receivers

Type:

AntennaArray

propertysources

Positions of the paths sources. If syntheticarrays are not used (synthetic_array isFalse),then every transmit antenna is modeled as a source of paths.Otherwise, transmitters are modelled as if they had a single antennalocated at theirposition. The channelresponses for each individual antenna of the arrays are then computed“synthetically” by applying appropriate phase shifts.

Type:

mi.Point3f

propertysynthetic_array

Flag indicating if synthetic arrays were used to trace the paths

Type:

bool

taps(bandwidth,l_min,l_max,sampling_frequency=None,num_time_steps=1,normalize=False,normalize_delays=True,reverse_direction=False,out_type='drjit')[source]

Returns the channel taps forming the discrete complexbaseband-equivalent channel impulse response

This function assumes that a sinc filter is used for pulse shaping andreceive filtering. Therefore, given a channel impulse response\((a_{i}^\text{b}(t), \tau_{i}), 0 \leq i \leq M-1\) (which can becomputed bycir()), the\(\ell\text{th}\) channel tap at sample instance\(n\)is computed as follows (see (Eq. 2.34)[Tse]):

\[\bar{h}_{n, \ell}= \sum_{i=0}^{M-1} a_{i}^\text{b}\left(\frac{n}{W}\right) \text{sinc}\left( \ell - W\tau_{m} \right)\]

for\(\ell\) ranging froml_min tol_max, and where\(W\) isthebandwidth.

This function allows for an arbitrarysampling_frequency at whichthe channel taps are sampled. By default, it is equal to thebandwidth.

Parameters:

• bandwidth (float) – Bandwidth [Hz] to which the channel impulse responsewill be limited

• l_min (int) – Smallest time-lag for the discrete complexbaseband-equivalent channel (\(L_{\text{min}}\))

• l_max (int) – Largest time-lag for the discrete complexbaseband-equivalent channel (\(L_{\text{max}}\))

• sampling_frequency (typing.Optional[float]) – Frequency [Hz] at which the channel impulseresponse is sampled. If set toNone, thebandwidth is usedinstead.

• num_time_steps (int) – Number of time steps

• normalize (bool) – If set toTrue, the channel is normalized such thatthe average total energy of the channel taps is equal to one.

• normalize_delays (bool) – If set toTrue, path delays are normalizedsuch that the first path between any pair of antennas of atransmitter and receiver arrives at\(\tau = 0\).

• reverse_direction (bool) – If set to True, swaps receivers andtransmitters

• out_type (typing.Literal['drjit','jax','numpy','tf','torch']) –

  Name of the desired output type.Currently supported areDr.Jit(“drjit),Numpy (“numpy”),Jax (“jax”),TensorFlow (“tf”),andPyTorch (“torch”).

Returns:

Channel tap coefficients

Return type:

Shape: [num_rx, num_rx_ant, num_tx, num_tx_ant,num_time_steps, l_max - l_min + 1],Type:Tuple[mi.TensorXf,mi.TensorXf]|np.array |jax.array|tf.Tensor |torch.tensor

propertytargets

Positions of the paths targets. If syntheticarrays are not used (synthetic_array isFalse),then every receiver antenna is modeled as a source of paths.Otherwise, receivers are modelled as if they had a single antennalocated at theirposition. The channelresponses for each individual antenna of the arrays are then computed“synthetically” by applying appropriate phase shifts.

Type:

mi.Point3f

propertytau

Paths delays [s]

Type:

mi.TensorXf[num_rx,num_rx_ant,num_tx,num_tx_ant,num_paths]or[num_rx,num_tx,num_paths]

propertytheta_r

Zenith angles of arrival [rad]

Type:

mi.TensorXf[num_rx,num_rx_ant,num_tx,num_tx_ant,num_paths]or[num_rx,num_tx,num_paths]

propertytheta_t

Zenith angles of departure [rad]

Type:

mi.TensorXf[num_rx,num_rx_ant,num_tx,num_tx_ant,num_paths]or[num_rx,num_tx,num_paths]

propertytx_array

Antenna array used by transmitters

Type:

AntennaArray

propertyvalid

Flags indicating valid paths

Type:

mi.TensorXb[num_rx,num_rx_ant,num_tx,num_tx_ant,num_paths]

propertyvertices

Paths’ vertices, i.e., the interaction points of the paths with thescene

Type:

mi.TensorXf[max_depth,num_rx,num_rx_ant,num_tx,num_tx_ant,num_paths,3]or[max_depth,num_rx,num_tx,num_paths,3]