MCPcopy Create free account

hub / github.com/ant-uni-bremen/OpenNTN / functions

Functions604 in github.com/ant-uni-bremen/OpenNTN

↓ 162 callersMethodset_topology
r""" Set the network topology. It is possible to set up a different network topology for each batch example. The batch size u
OpenNTN/system_level_channel.py:81
↓ 108 callersFunctioncreate_bs_ant
(carrier_frequency)
test/step_4_1_test.py:23
↓ 108 callersFunctioncreate_ut_ant
(carrier_frequency)
test/step_4_1_test.py:16
↓ 60 callersMethodrun_test
(self, scenario, direction, carrier_frequency, satellite_distance, elevation_angle, expected_gas_range, expect
test/Link_Budget_test.py:23
↓ 58 callersMethodget_param
r""" Given a ``parameter_name`` used in the configuration file, returns a tensor with shape [batch size, number of BSs, number of UTs]
OpenNTN/system_level_scenario.py:727
↓ 49 callersFunctioncreate_bs_ant
(carrier_frequency)
test/step_1_test.py:17
↓ 49 callersFunctioncreate_ut_ant
(carrier_frequency)
test/step_1_test.py:10
↓ 21 callersFunctiondeg_2_rad
r""" Convert degree to radian Input ------ x : Tensor Angles in degree Output ------- y : Tensor
OpenNTN/utils.py:454
↓ 21 callersFunctionrun_test
(channel_model_class, direction, elevation_angle, carrier_frequency, nlos_cl, sf_los_sigma, sf_nlos_sigma, sce
test/step_3_test.py:22
↓ 19 callersMethodmax_rel_err
Compute the maximum relative error, ``r`` being the reference value, ``x`` an estimate of ``r``.
test/step_11_test.py:120
↓ 12 callersMethod_reshape_for_cir_computation
r""" Add three leading dimensions to array, with shape [1, num_tx, num_rx], to reshape it as expected by the channel impulse response
OpenNTN/cdl.py:621
↓ 12 callersFunctioncreate_bs_ant
(carrier_frequency)
test/step_4_3_test.py:25
↓ 12 callersFunctioncreate_ut_ant
(carrier_frequency)
test/step_4_3_test.py:18
↓ 9 callersMethodfield
Field pattern in the vertical and horizontal polarization (TR 38.901 7.3-4/5) Inputs ------- theta: Zeni
OpenNTN/antenna.py:65
↓ 8 callersMethod_cluster_delays
Generate cluster delays. See step 5 of section 7.5 from TR 38.901 specification. Input ------ delay_spread :
OpenNTN/rays.py:257
↓ 6 callersMethod_unit_sphere_vector
r""" Generate vector on unit sphere (7.1-6) Input ------- theta : Arbitrary shape, tf.float Zenith [radia
OpenNTN/channel_coefficients.py:227
↓ 6 callersMethodunit_sphere_vector_ref
Reference implementation: Unit to sphere vector
test/step_11_test.py:127
↓ 6 callersFunctionwrap_angle_0_360
r""" Wrap ``angle`` to (0,360) Input ------ angle : Tensor Input to wrap Output ------- y : Tensor
OpenNTN/utils.py:486
↓ 5 callersMethod_cluster_powers
Generate cluster powers. See step 6 of section 7.5 from TR 38.901 specification. Input ------ delays : [batc
OpenNTN/rays.py:324
↓ 5 callersMethod_l2g_response
r""" Transform field components from LCS to GCS (7.1-11) Input ------ f_prime : K-Dim Tensor of shape [...,2], tf.flo
OpenNTN/channel_coefficients.py:396
↓ 5 callersMethodl2g_response_ref
Reference implementation: L2G response
test/step_11_test.py:255
↓ 4 callersMethod__init__
(self, polarization, polarization_type, antenna_pattern,
OpenNTN/antenna.py:755
↓ 4 callersMethod_azimuth_angles_of_arrival
Compute the azimuth angle of arrival (AoA) See step 7 of section 7.5 from TR 38.901 specification. Input ------
OpenNTN/rays.py:492
↓ 4 callersMethod_generate_rays
r""" Generate rays from ``angles`` (which could be ZoD, ZoA, AoD, or AoA) and the angle spread ``c`` using equation 7.7-0a of TR38.901
OpenNTN/cdl.py:574
↓ 4 callersMethod_shuffle_angles
Randomly shuffle a tensor carrying azimuth/zenith angles of arrival/departure. Input ------ angles : [batch
OpenNTN/rays.py:720
↓ 4 callersMethod_shuffle_angles
Randomly shuffle a tensor carrying azimuth/zenith angles of arrival/departure. Input ------ angles : [batch
OpenNTN/cdl.py:648
↓ 4 callersMethod_step_11_faraday_rotation
(self, carrier_frequency, aod_shape)
OpenNTN/channel_coefficients.py:1108
↓ 4 callersMethod_zenith_angles_of_arrival
Compute the zenith angle of arrival (ZoA) See step 7 of section 7.5 from TR 38.901 specification. Input ------
OpenNTN/rays.py:668
↓ 4 callersMethodforward_rotation_matrix_ref
Reference implementation: Forward rotation matrix
test/step_11_test.py:147
↓ 4 callersFunctionrad_2_deg
r""" Convert radian to degree Input ------ x : Tensor Angles in radian Output ------- y : Tensor
OpenNTN/utils.py:470
↓ 4 callersMethodrun_test
(self, direction, carrier_frequency, rTau_los=2.5, rTau_nlos=2.3)
test/step_5_test.py:43
↓ 4 callersMethodrun_test
(self, direction, carrier_frequency, rTau_los=2.5, rTau_nlos=2.3)
test/step_5_test.py:138
↓ 4 callersMethodrun_test
(self, direction, carrier_frequency, rTau_los=2.5, rTau_nlos=2.3)
test/step_5_test.py:239
↓ 3 callersMethod_forward_rotation_matrix
r""" Forward composite rotation matrix (7.1-4) Input ------ orientations : [...,3], tf.float Orie
OpenNTN/channel_coefficients.py:250
↓ 3 callersMethod_gcs_to_lcs
r""" Compute the angles ``theta``, ``phi`` in LCS rotated according to ``orientations`` (7.1-7/8) Input ------
OpenNTN/channel_coefficients.py:319
↓ 3 callersMethod_rot_pos
r""" Rotate the ``positions`` according to the ``orientations`` Input ------ orientations : [...,3], tf.float
OpenNTN/channel_coefficients.py:281
↓ 3 callersMethod_step_11_array_offsets
r""" Compute matrix accounting for phases offsets between antenna elements Input ----- topology : Topology
OpenNTN/channel_coefficients.py:636
↓ 3 callersMethod_step_11_doppler_matrix
r""" Compute matrix with phase shifts due to mobility in (7.5-22) Input ----- topology : Topology Topolog
OpenNTN/channel_coefficients.py:546
↓ 3 callersMethod_step_11_field_matrix
r""" Compute matrix accounting for the element responses, random phases and xpr Input ----- topology : Topolo
OpenNTN/channel_coefficients.py:720
↓ 3 callersMethod_step_12
Apply path loss and shadow fading ``sf`` to paths coefficients ``h``. Input ------ h : [batch size, num_tx, num_rx, num_paths
OpenNTN/system_level_channel.py:403
↓ 3 callersFunctioncreate_bs_ant
(carrier_frequency)
test/step_2_test.py:18
↓ 3 callersFunctioncreate_bs_ant
(carrier_frequency)
test/step_5_test.py:24
↓ 3 callersFunctioncreate_ut_ant
(carrier_frequency)
test/step_2_test.py:11
↓ 3 callersFunctioncreate_ut_ant
(carrier_frequency)
test/step_5_test.py:17
↓ 3 callersMethodgcs_to_lcs_ref
Reference implementation: GCS to LCS angles
test/step_11_test.py:192
↓ 3 callersFunctiongenerate_uts_topology
r""" Sample UTs location from a sector or a cell Input -------- batch_size : int Batch size num_ut : int Number
OpenNTN/utils.py:845
↓ 3 callersMethodrot_pos_ref
(self, orientations, positions)
test/step_11_test.py:287
↓ 3 callersFunctionsample_bernoulli
r""" Sample a tensor with shape ``shape`` from a Bernoulli distribution with probability ``p`` Input -------- shape : Tensor shap
OpenNTN/utils.py:502
↓ 3 callersMethodsample_pathloss
Generate pathlosses [dB] for each BS-UT link. Input ------ None Output ------- A tensor
OpenNTN/lsp.py:94
↓ 3 callersMethodstep_11_array_offsets_ref
Reference implementation: Array offset matrix
test/step_11_test.py:508
↓ 3 callersMethodstep_11_doppler_matrix_ref
Reference implementation: Doppler matrix calculation
test/step_11_test.py:560
↓ 3 callersMethodstep_11_field_matrix_ref
Reference implementation: Field matrix
test/step_11_test.py:385
↓ 3 callersMethodstep_11_nlos_ref
Reference implemenrtation: Compute the channel matrix of the NLoS component
test/step_11_test.py:618
↓ 3 callersMethodstep_11_phase_matrix_ref
Reference implementation: Phase matrix
test/step_11_test.py:366
↓ 2 callersMethod_azimuth_angles
Generate departure or arrival azimuth angles (degrees). See step 7 of section 7.5 from TR 38.901 specification. Input
OpenNTN/rays.py:392
↓ 2 callersMethod_azimuth_angles_of_departure
Compute the azimuth angle of departure (AoD) See step 7 of section 7.5 from TR 38.901 specification. Input ------
OpenNTN/rays.py:518
↓ 2 callersMethod_compute_doppler
r"""Compute the maximum radian Doppler frequency [Hz] for a given speed [m/s]. The maximum radian Doppler frequency :math:`\omega_d`
OpenNTN/tdl.py:547
↓ 2 callersMethod_cross_polarization_power_ratios
Generate cross-polarization power ratios. Step 9 in TR 38.901 specification. Input ------ None Out
OpenNTN/rays.py:796
↓ 2 callersMethod_random_coupling
Randomly couples the angles within a cluster for both azimuth and elevation. #TODO adjusted for 811 #NOTE 5: For all
OpenNTN/cdl.py:676
↓ 2 callersMethod_reverse_rotation_matrix
r""" Reverse composite rotation matrix (7.1-4) Input ------ orientations : [...,3], tf.float Orientations
OpenNTN/channel_coefficients.py:301
↓ 2 callersMethod_step_10
r""" Generate random and uniformly distributed phases for all rays and polarization combinations Input -----
OpenNTN/channel_coefficients.py:491
↓ 2 callersMethod_step_11
r""" Combine LOS and LOS components to compute (7.5-30) Input ----- phi: [batch size, num TXs, num RXs, num clusters,
OpenNTN/channel_coefficients.py:1053
↓ 2 callersMethod_step_11_get_rx_antenna_positions
r"""Compute d_bar_rx in (7.5-22), i.e., the positions in GCS of elements forming the receive antenna panel Input -----
OpenNTN/channel_coefficients.py:459
↓ 2 callersMethod_step_11_get_tx_antenna_positions
r"""Compute d_bar_tx in (7.5-22), i.e., the positions in GCS of elements forming the transmit panel Input ----- topol
OpenNTN/channel_coefficients.py:427
↓ 2 callersMethod_step_11_los
r"""Compute the LOS channels from (7.5-29) Intput ------ topology : Topology Network topology t : [num t
OpenNTN/channel_coefficients.py:987
↓ 2 callersMethod_step_11_nlos
r""" Compute the full NLOS channel matrix (7.5-28) Input ----- phi: [batch size, num TXs, num RXs, num clusters, num
OpenNTN/channel_coefficients.py:847
↓ 2 callersMethod_step_11_phase_matrix
r""" Compute matrix with random phases in (7.5-22) Input ----- phi : [batch size, num TXs, num RXs, num clusters, num
OpenNTN/channel_coefficients.py:511
↓ 2 callersMethod_step_11_reduce_nlos
r""" Compute the final NLOS matrix in (7.5-27) Input ------ h_full : [batch size, num_tx, num rx, num clusters, num r
OpenNTN/channel_coefficients.py:898
↓ 2 callersMethod_zenith_angles
Generate departure or arrival zenith angles (degrees). See step 7 of section 7.5 from TR 38.901 specification. Input
OpenNTN/rays.py:544
↓ 2 callersMethod_zenith_angles_of_departure
Compute the zenith angle of departure (ZoD) See step 7 of section 7.5 from TR 38.901 specification. Input ------
OpenNTN/rays.py:694
↓ 2 callersFunctioncompute_satellite_speed
(h_sat)
OpenNTN/utils.py:1955
↓ 2 callersMethodreverse_rotation_matrix_ref
Reference implementation: Reverse rotation matrix
test/step_11_test.py:176
↓ 2 callersFunctionset_3gpp_scenario_parameters
r""" Set valid parameters for a specified 3GPP system level ``scenario`` (DenseUrban, Urban, or SubUrban). If a parameter is given, then
OpenNTN/utils.py:612
↓ 2 callersMethodstep_11_get_rx_antenna_positions_ref
Reference implementation: Positions of the RX array elements
test/step_11_test.py:339
↓ 2 callersMethodstep_11_get_tx_antenna_positions_ref
Reference implementation: Positions of the TX array elements
test/step_11_test.py:312
↓ 2 callersMethodstep_11_los_ref
Reference implementation: Compute the channel matrix of the NLoS component 2
test/step_11_test.py:765
↓ 2 callersMethodstep_11_reduce_nlos_ref
Reference implementation: Compute the channel matrix of the NLoS component 2
test/step_11_test.py:676
↓ 2 callersMethodtopology_updated_callback
Updates internal quantities. Must be called at every update of the scenario that changes the state of UTs or their locations.
OpenNTN/lsp.py:169
↓ 1 callersMethod__init__
(self, velocities, moving_end, los_aoa,
OpenNTN/channel_coefficients.py:68
↓ 1 callersMethod__init__
(self, ds, asd, asa, sf, k_factor, zsa, zsd)
OpenNTN/lsp.py:50
↓ 1 callersMethod__init__
(self, delays, powers, aoa, aod, zoa, zod, xpr)
OpenNTN/rays.py:53
↓ 1 callersMethod_compute_clusters_mask
Given a scenario (DenseUrban, Urban, or SubUrban), the number of clusters is different for different state of UT-BS links (LoS, NLoS,
OpenNTN/rays.py:185
↓ 1 callersMethod_compute_cross_lsp_correlation_matrix
Compute and store as attribute the square-root of the cross-LSPs correlation matrices for each BS-UT link, and then the correspondin
OpenNTN/lsp.py:196
↓ 1 callersMethod_compute_distance_2d_3d_and_angles
r""" Computes the following internal values: * 2D distances for all BS-UT pairs in the X-Y plane * 3D distances for all BS-UT
OpenNTN/system_level_scenario.py:779
↓ 1 callersMethod_compute_lsp_log_mean_std
r"""Computes the mean and standard deviations of LSPs in log-domain
OpenNTN/system_level_scenario.py:922
↓ 1 callersMethod_compute_lsp_spatial_correlation_sqrt
Compute the square root of the spatial correlation matrices of LSPs. The LSPs are correlated accross users according to the distance
OpenNTN/lsp.py:301
↓ 1 callersMethod_compute_pathloss_basic
r"""Computes the basic component of the pathloss [dB]
OpenNTN/system_level_scenario.py:932
↓ 1 callersMethod_compute_pathloss_entry
r"""Computes the building entry component of the pathloss [dB]
OpenNTN/system_level_scenario.py:942
↓ 1 callersMethod_compute_pathloss_gas
r"""Computes the atmospheric gasses component of the pathloss [dB]
OpenNTN/system_level_scenario.py:937
↓ 1 callersMethod_compute_pathloss_scintillation
r"""Computes the scintillation component of the pathloss [dB]
OpenNTN/system_level_scenario.py:927
↓ 1 callersMethod_compute_psi
r""" Compute displacement angle :math:`Psi` for the transformation of LCS-GCS field components in (7.1-15) of TR38.901 specification
OpenNTN/channel_coefficients.py:365
↓ 1 callersMethod_load_parameters
r"""Load parameters of a CDL model. The model parameters are stored as JSON files with the following keys: * los : boolean that indic
OpenNTN/cdl.py:402
↓ 1 callersMethod_load_parameters
r"""Load parameters of a TDL model. The model parameters are stored as JSON files with the following keys: * los : boolean that indic
OpenNTN/tdl.py:587
↓ 1 callersMethod_load_params
r"""Load the configuration files corresponding to the 2 possible states of UTs: LoS and NLoS
OpenNTN/system_level_scenario.py:886
↓ 1 callersMethod_random_coupling
Randomly couples the angles within a cluster for both azimuth and elevation. Step 8 in TR 38.901 specification. Inp
OpenNTN/rays.py:753
↓ 1 callersMethod_sample_indoor_distance
r"""Sample 2D indoor distances for indoor devices, according to section 7.4.3.1 of TR 38.901.
OpenNTN/system_level_scenario.py:864
↓ 1 callersMethod_sample_los
r"""Set the LoS state of each UT randomly, following the procedure described in section 7.4.2 of TR 38.901. LoS state of each UT is ra
OpenNTN/system_level_scenario.py:846
↓ 1 callersMethodclip_carrier_frequency_lsp
r"""Clip the carrier frequency ``fc`` in GHz for LSP calculation Input ----- fc : float Carrier frequency [GHz]
OpenNTN/system_level_scenario.py:712
↓ 1 callersMethodcompute_psi_ref
Reference implementation: Compute psi angle
test/step_11_test.py:243
↓ 1 callersMethodcreate_antenna_arrays
(self, carrier_frequency)
test/coupling_loss_test.py:12
next →1–100 of 604, ranked by callers