DeepMIMO 2.0__tar.gz → 3.2.9__tar.gz

{deepmimo-2.0 → deepmimo-3.2.9}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: DeepMIMO
-Version: 2.0
-Summary: DeepMIMO
+Version: 3.2.9
+Summary: DeepMIMOv3
 Home-page: https://deepmimo.net/
 Author: Umut Demirhan, Ahmed Alkhateeb
 Keywords: mmWave,MIMO,DeepMIMO,python,Beta
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
@@ -13,6 +13,7 @@ License-File: LICENSE.md
 Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: tqdm
+Requires-Dist: matplotlib
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -23,4 +24,8 @@ Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 
-DeepMIMOv2 dataset generator library
+
+
+This package contains Python code for DeepMIMOv3 generator library. 
+
+Install the lastest v3 package with: `pip install deepmimo==3`

{deepmimo-2.0 → deepmimo-3.2.9}/README.md

@@ -1,3 +1,13 @@
+## ⚠️ Archived Repository Notice
+
+**This repository has been archived** and is no longer maintained. It contains Python code for DeepMIMOv2 and DeepMIMOv3.
+
+All future versions are now maintained in the [DeepMIMO Unified Repository](https://github.com/DeepMIMO/DeepMIMO)
+
+DeepMIMOv4 is being developed in this repository and will be made public in May 2025. 
+
+---
+
 # DeepMIMO: A Generic Deep Learning Dataset for Millimeter Wave and Massive MIMO Applications
 This is a python code package of the DeepMIMO dataset generated using [Remcom Wireless InSite](http://www.remcom.com/wireless-insite) software. The [DeepMIMO dataset](https://deepmimo.net/) is a publicly available parameterized dataset published for deep learning applications in mmWave and massive MIMO systems.
 

deepmimo-3.2.9/setup.py

@@ -0,0 +1,36 @@
+import setuptools
+
+VERSION = '3.2.9'
+DESCRIPTION = 'DeepMIMOv3'
+LONG_DESCRIPTION = """
+
+This package contains Python code for DeepMIMOv3 generator library. 
+
+Install the lastest v3 package with: `pip install deepmimo==3`
+"""
+
+# Setting up
+setuptools.setup(
+    name="DeepMIMO",
+    version=VERSION,
+    author="Umut Demirhan, Ahmed Alkhateeb",
+    description=DESCRIPTION,
+    long_description=LONG_DESCRIPTION,
+    long_description_content_type="text/markdown",
+    license_files=('LICENSE.md',),
+    install_requires=[
+        'numpy',
+        'scipy',
+        'tqdm',
+        'matplotlib',
+    ],
+    keywords=['mmWave', 'MIMO', 'DeepMIMO', 'python', 'Beta'],
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent"
+    ],
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src"),
+    url='https://deepmimo.net/'
+)

{deepmimo-2.0 → deepmimo-3.2.9}/src/DeepMIMO.egg-info/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: DeepMIMO
-Version: 2.0
-Summary: DeepMIMO
+Version: 3.2.9
+Summary: DeepMIMOv3
 Home-page: https://deepmimo.net/
 Author: Umut Demirhan, Ahmed Alkhateeb
 Keywords: mmWave,MIMO,DeepMIMO,python,Beta
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
@@ -13,6 +13,7 @@ License-File: LICENSE.md
 Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: tqdm
+Requires-Dist: matplotlib
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
@@ -23,4 +24,8 @@ Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 
-DeepMIMOv2 dataset generator library
+
+
+This package contains Python code for DeepMIMOv3 generator library. 
+
+Install the lastest v3 package with: `pip install deepmimo==3`

deepmimo-3.2.9/src/DeepMIMO.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE.md
+README.md
+setup.py
+src/DeepMIMO.egg-info/PKG-INFO
+src/DeepMIMO.egg-info/SOURCES.txt
+src/DeepMIMO.egg-info/dependency_links.txt
+src/DeepMIMO.egg-info/requires.txt
+src/DeepMIMO.egg-info/top_level.txt
+src/DeepMIMOv3/__init__.py
+src/DeepMIMOv3/ant_patterns.py
+src/DeepMIMOv3/construct_deepmimo.py
+src/DeepMIMOv3/consts.py
+src/DeepMIMOv3/generator.py
+src/DeepMIMOv3/params.py
+src/DeepMIMOv3/raytracing_v2.py
+src/DeepMIMOv3/raytracing_v3.py
+src/DeepMIMOv3/sionna_adapter.py
+src/DeepMIMOv3/utils.py
+src/DeepMIMOv3/visualization.py

{deepmimo-2.0 → deepmimo-3.2.9}/src/DeepMIMO.egg-info/requires.txt

@@ -1,3 +1,4 @@
 numpy
 scipy
 tqdm
+matplotlib

deepmimo-3.2.9/src/DeepMIMO.egg-info/top_level.txt

@@ -0,0 +1 @@
+DeepMIMOv3

deepmimo-3.2.9/src/DeepMIMOv3/__init__.py

@@ -0,0 +1,4 @@
+from DeepMIMOv3.generator import generate_data
+from DeepMIMOv3.params import default_params
+from DeepMIMOv3.construct_deepmimo import ant_indices, array_response
+from DeepMIMOv3.sionna_adapter import DeepMIMOSionnaAdapter

{deepmimo-2.0/src/DeepMIMO → deepmimo-3.2.9/src/DeepMIMOv3}/ant_patterns.py

@@ -8,7 +8,7 @@ Authors: Umut Demirhan, Ahmed Alkhateeb
 Date: 3/16/2022
 """
 
-import DeepMIMO.consts as c
+import DeepMIMOv3.consts as c
 import numpy as np
 
 class AntennaPattern():

{deepmimo-2.0/src/DeepMIMO → deepmimo-3.2.9/src/DeepMIMOv3}/construct_deepmimo.py

@@ -8,11 +8,10 @@ Authors: Umut Demirhan, Ahmed Alkhateeb
 Date: 12/10/2021
 """
 
-import DeepMIMO.consts as c
+import DeepMIMOv3.consts as c
 import numpy as np
 from tqdm import tqdm
-import types
-from DeepMIMO.ant_patterns import AntennaPattern
+from DeepMIMOv3.ant_patterns import AntennaPattern
 
 # Generates common parameters first. The output is a numpy matrix.
 def generate_MIMO_channel(raydata, params, tx_ant_params, rx_ant_params):
@@ -22,8 +21,8 @@ def generate_MIMO_channel(raydata, params, tx_ant_params, rx_ant_params):
     kd_tx = 2*np.pi*tx_ant_params[c.PARAMSET_ANT_SPACING]
     kd_rx = 2*np.pi*rx_ant_params[c.PARAMSET_ANT_SPACING]
     Ts = 1/bandwidth
-    subcarriers = np.arange(0, params[c.PARAMSET_OFDM][c.PARAMSET_OFDM_SC_LIM], params[c.PARAMSET_OFDM][c.PARAMSET_OFDM_SC_SAMP])
-    path_gen = OFDM_PathGenerator(params[c.PARAMSET_OFDM], subcarriers)
+    subcarriers = params[c.PARAMSET_OFDM][c.PARAMSET_OFDM_SC_SAMP]
+    path_gen = OFDM_PathGenerator(params, subcarriers)
     antennapattern = AntennaPattern(tx_pattern = tx_ant_params[c.PARAMSET_ANT_RAD_PAT], rx_pattern = rx_ant_params[c.PARAMSET_ANT_RAD_PAT])
 
     M_tx = np.prod(tx_ant_params[c.PARAMSET_ANT_SHAPE])
@@ -36,10 +35,12 @@ def generate_MIMO_channel(raydata, params, tx_ant_params, rx_ant_params):
         channel = np.zeros((len(raydata), M_rx, M_tx, len(subcarriers)), dtype = np.csingle)
     else:
         channel = np.zeros((len(raydata), M_rx, M_tx, params[c.PARAMSET_NUM_PATHS]), dtype = np.csingle)
+    LoS_status = np.zeros((len(raydata)), dtype=np.int8)-2
         
     for i in tqdm(range(len(raydata)), desc='Generating channels'):
         
         if raydata[i][c.OUT_PATH_NUM]==0:
+            LoS_status[i] = -1
             continue
         
         
@@ -51,6 +52,25 @@ def generate_MIMO_channel(raydata, params, tx_ant_params, rx_ant_params):
                                   theta = raydata[i][c.OUT_PATH_DOA_THETA],
                                   phi = raydata[i][c.OUT_PATH_DOA_PHI])
         
+        FoV_tx = apply_FoV(tx_ant_params[c.PARAMSET_ANT_FOV], dod_theta, dod_phi)
+        FoV_rx = apply_FoV(rx_ant_params[c.PARAMSET_ANT_FOV], doa_theta, doa_phi)
+        FoV = np.logical_and(FoV_tx, FoV_rx)
+        dod_theta = dod_theta[FoV]
+        dod_phi = dod_phi[FoV]
+        doa_theta = doa_theta[FoV]
+        doa_phi = doa_phi[FoV]
+        
+        for key in raydata[i].keys():
+            if key == 'num_paths':
+                raydata[i][key] = FoV.sum()
+            else:
+                raydata[i][key] = raydata[i][key][FoV]
+        
+        if raydata[i]['num_paths'] == 0:
+            LoS_status[i] = -1
+        else:
+            LoS_status[i] = raydata[i]['LoS'].sum()
+                
         array_response_TX = array_response(ant_ind = ant_tx_ind, 
                                            theta = dod_theta, 
                                            phi = dod_phi, 
@@ -66,11 +86,10 @@ def generate_MIMO_channel(raydata, params, tx_ant_params, rx_ant_params):
                                      doa_phi = doa_phi, 
                                      dod_theta = dod_theta, 
                                      dod_phi = dod_phi)
+        raydata[i][c.OUT_PATH_RX_POW] = power
         
         if  params[c.PARAMSET_FDTD]: # OFDM
-            path_const = path_gen.generate(power.reshape(-1, 1), 
-                                           (raydata[i][c.OUT_PATH_TOA]/Ts).reshape(-1, 1), 
-                                           raydata[i][c.OUT_PATH_PHASE].reshape(-1,1))
+            path_const = path_gen.generate(raydata[i], Ts)
             
             # The next step is to be defined
             if params[c.PARAMSET_OFDM][c.PARAMSET_OFDM_LPF] == 0:
@@ -81,7 +100,7 @@ def generate_MIMO_channel(raydata, params, tx_ant_params, rx_ant_params):
         else: # TD channel
             channel[i, :, :, :raydata[i][c.OUT_PATH_NUM]] = array_response_RX[:, None, :] * array_response_TX[None, :, :] * (np.sqrt(power) * np.exp(1j*np.deg2rad(raydata[i][c.OUT_PATH_PHASE])))[None, None, :]
 
-    return channel
+    return channel, LoS_status
 
 # Generates everything for each rx_ant_params - 
 # necessary for BS-BS channels since different antennas can be defined. 
@@ -91,11 +110,12 @@ def generate_MIMO_channel_rx_ind(raydata, params, tx_ant_params, rx_ant_params):
     bandwidth = params[c.PARAMSET_OFDM][c.PARAMSET_OFDM_BW] * c.PARAMSET_OFDM_BW_MULT
     
     Ts = 1/bandwidth
-    subcarriers = np.arange(0, params[c.PARAMSET_OFDM][c.PARAMSET_OFDM_SC_LIM], params[c.PARAMSET_OFDM][c.PARAMSET_OFDM_SC_SAMP])
-    path_gen = OFDM_PathGenerator(params[c.PARAMSET_OFDM], subcarriers)
+    subcarriers = params[c.PARAMSET_OFDM][c.PARAMSET_OFDM_SC_SAMP]
+    path_gen = OFDM_PathGenerator(params, subcarriers)
     
     
     channel = []
+    LoS_status = []
         
     for i in tqdm(range(len(raydata)), desc='Generating channels'):
         
@@ -112,6 +132,7 @@ def generate_MIMO_channel_rx_ind(raydata, params, tx_ant_params, rx_ant_params):
         
         if raydata[i][c.OUT_PATH_NUM]==0:
             channel.append(np.zeros((M_rx, M_tx, len(subcarriers))))
+            LoS_status.append(-1)
             continue
     
         
@@ -122,7 +143,26 @@ def generate_MIMO_channel_rx_ind(raydata, params, tx_ant_params, rx_ant_params):
         doa_theta, doa_phi = rotate_angles(rotation = rx_ant_params[i][c.PARAMSET_ANT_ROTATION],
                                   theta = raydata[i][c.OUT_PATH_DOA_THETA],
                                   phi = raydata[i][c.OUT_PATH_DOA_PHI])
+                
+        FoV_tx = apply_FoV(tx_ant_params[c.PARAMSET_ANT_FOV], dod_theta, dod_phi)
+        FoV_rx = apply_FoV(rx_ant_params[i][c.PARAMSET_ANT_FOV], doa_theta, doa_phi)
+        FoV = np.logical_and(FoV_tx, FoV_rx)
+        dod_theta = dod_theta[FoV]
+        dod_phi = dod_phi[FoV]
+        doa_theta = doa_theta[FoV]
+        doa_phi = doa_phi[FoV]
+        
+        for key in raydata[i].keys():
+            if key == 'num_paths':
+                raydata[i][key] = FoV.sum()
+            else:
+                raydata[i][key] = raydata[i][key][FoV]
         
+        if raydata[i]['num_paths'] == 0:
+            LoS_status.append(-1)
+        else:
+            LoS_status.append(raydata[i]['LoS'].sum())
+            
         array_response_TX = array_response(ant_ind = ant_tx_ind, 
                                            theta = dod_theta, 
                                            phi = dod_phi, 
@@ -138,11 +178,10 @@ def generate_MIMO_channel_rx_ind(raydata, params, tx_ant_params, rx_ant_params):
                                      doa_phi = doa_phi, 
                                      dod_theta = dod_theta, 
                                      dod_phi = dod_phi)
+        raydata[i][c.OUT_PATH_RX_POW] = power
         
         if  params[c.PARAMSET_FDTD]: # OFDM
-            path_const = path_gen.generate(power.reshape(-1, 1), 
-                                           (raydata[i][c.OUT_PATH_TOA]/Ts).reshape(-1, 1), 
-                                           raydata[i][c.OUT_PATH_PHASE].reshape(-1,1))
+            path_const = path_gen.generate(raydata[i], Ts)
             
             # The next step is to be defined
             if params[c.PARAMSET_OFDM][c.PARAMSET_OFDM_LPF] == 0: # NO LPF
@@ -153,7 +192,7 @@ def generate_MIMO_channel_rx_ind(raydata, params, tx_ant_params, rx_ant_params):
         else: # Time domain
             channel.append(array_response_RX[:, None, :] * array_response_TX[None, :, :] * (np.sqrt(power) * np.exp(1j*np.deg2rad(raydata[i][c.OUT_PATH_PHASE])))[None, None, :])
 
-    return channel
+    return channel, LoS_status
 
 
 def array_response(ant_ind, theta, phi, kd):        
@@ -167,11 +206,20 @@ def array_response_phase(theta, phi, kd):
     return np.vstack([gamma_x, gamma_y, gamma_z]).T
  
 def ant_indices(panel_size):
-    gamma_x = np.tile(np.arange(panel_size[0]), panel_size[1]*panel_size[2])
-    gamma_y = np.tile(np.repeat(np.arange(panel_size[1]), panel_size[0]), panel_size[2])
-    gamma_z = np.repeat(np.arange(panel_size[2]), panel_size[0]*panel_size[1])
+    gamma_x = np.tile(np.arange(1), panel_size[0]*panel_size[1])
+    gamma_y = np.tile(np.repeat(np.arange(panel_size[0]), 1), panel_size[1])
+    gamma_z = np.repeat(np.arange(panel_size[1]), panel_size[0])
     return np.vstack([gamma_x, gamma_y, gamma_z]).T
 
+def apply_FoV(FoV, theta, phi):
+    theta = np.mod(theta, 2*np.pi)
+    phi = np.mod(phi, 2*np.pi)
+    FoV = np.deg2rad(FoV)
+    path_inclusion_phi = np.logical_or(phi <= 0+FoV[0]/2, phi >= 2*np.pi-FoV[0]/2)
+    path_inclusion_theta = np.logical_and(theta <= np.pi/2+FoV[1]/2, theta >= np.pi/2-FoV[1]/2)
+    path_inclusion = np.logical_and(path_inclusion_phi, path_inclusion_theta)
+    return path_inclusion
+
 def rotate_angles(rotation, theta, phi): # Input all degrees - output radians
     theta = np.deg2rad(theta)
     phi = np.deg2rad(phi)
@@ -199,29 +247,48 @@ def rotate_angles(rotation, theta, phi): # Input all degrees - output radians
     return theta, phi
 
 class OFDM_PathGenerator:
-    def __init__(self, OFDM_params, subcarriers):
-        self.OFDM_params = OFDM_params
+    def __init__(self, params, subcarriers):
+        self.params = params
+        self.OFDM_params = params[c.PARAMSET_OFDM]
         
-        if OFDM_params[c.PARAMSET_OFDM_LPF] == 0: # No Pulse Shaping
+        if self.OFDM_params[c.PARAMSET_OFDM_LPF] == 0: # No Pulse Shaping
             self.generate = getattr(self, 'no_LPF')
         else: # Pulse Shaping
             self.generate = getattr(self, 'with_LPF')
             
                 
         self.subcarriers = subcarriers
-        self.total_subcarriers = OFDM_params[c.PARAMSET_OFDM_SC_NUM]
+        self.total_subcarriers = self.OFDM_params[c.PARAMSET_OFDM_SC_NUM]
         
         self.delay_d = np.arange(self.OFDM_params['subcarriers'])
         self.delay_to_OFDM = np.exp(-1j*2*np.pi/self.total_subcarriers*np.outer(self.delay_d, self.subcarriers))
         
-    def no_LPF(self, power, delay_n, phase):
+    def no_LPF(self, raydata, Ts):
+        power = (raydata[c.OUT_PATH_RX_POW]).reshape(-1, 1)
+        delay_n = (raydata[c.OUT_PATH_TOA]/Ts).reshape(-1, 1)
+        phase = raydata[c.OUT_PATH_PHASE].reshape(-1,1)
+        
         paths_over_FFT = (delay_n >= self.OFDM_params['subcarriers'])
         power[paths_over_FFT] = 0
         delay_n[paths_over_FFT] = self.OFDM_params['subcarriers']
         
-        return np.sqrt(power/self.total_subcarriers) * np.exp(1j*(np.deg2rad(phase) - (2*np.pi/self.total_subcarriers)*np.outer(delay_n, self.subcarriers) ))
+        path_const = np.sqrt(power/self.total_subcarriers) * np.exp(1j*(np.deg2rad(phase) - (2*np.pi/self.total_subcarriers)*np.outer(delay_n, self.subcarriers) ))
+        
+        if self.params[c.PARAMSET_DOPPLER_EN] and self.params[c.PARAMSET_SCENARIO_PARAMS][c.PARAMSET_SCENARIO_PARAMS_DOPPLER_EN]:
+            doppler_vel = raydata[c.OUT_PATH_DOP_VEL].reshape(-1, 1)
+            doppler_acc = raydata[c.OUT_PATH_DOP_ACC].reshape(-1, 1)
+            carr_freq = self.params[c.PARAMSET_SCENARIO_PARAMS][c.PARAMSET_SCENARIO_PARAMS_CF]
+            
+            delay = (raydata[c.OUT_PATH_TOA]).reshape(-1, 1)
+            Doppler_phase = np.exp(-1j*2*np.pi*carr_freq*(doppler_vel*delay/c.LIGHTSPEED + doppler_acc*(delay**2)/(2*c.LIGHTSPEED)))
+            path_const *= Doppler_phase
+        
+        return path_const
     
-    def with_LPF(self, power, delay_n, phase):
+    def with_LPF(self, raydata, Ts):
+        power = (raydata[c.OUT_PATH_RX_POW]).reshape(-1, 1)
+        delay_n = (raydata[c.OUT_PATH_TOA]/Ts).reshape(-1, 1)
+        phase = raydata[c.OUT_PATH_PHASE].reshape(-1,1)
         
         # Ignore the paths over CP
         paths_over_FFT = (delay_n >= self.OFDM_params['subcarriers'])
@@ -231,5 +298,15 @@ class OFDM_PathGenerator:
         # Pulse - LPF convolution and channel generation
         pulse = np.sinc(self.delay_d-delay_n)
         pulse = pulse * np.sqrt(power/self.total_subcarriers) * np.exp(1j*np.deg2rad(phase)) # Power scaling
+        
+        if self.params[c.PARAMSET_DOPPLER_EN] and self.params[c.PARAMSET_SCENARIO_PARAMS][c.PARAMSET_SCENARIO_PARAMS_DOPPLER_EN]:
+            doppler_vel = raydata[c.OUT_PATH_DOP_VEL].reshape(-1, 1)
+            doppler_acc = raydata[c.OUT_PATH_DOP_ACC].reshape(-1, 1)
+            carr_freq = self.params[c.PARAMSET_SCENARIO_PARAMS][c.PARAMSET_SCENARIO_PARAMS_CF]
+            
+            delay = Ts * self.delay_d.T
+            Doppler_phase = np.exp(-1j*2*np.pi*carr_freq*(doppler_vel*delay/c.LIGHTSPEED + doppler_acc*(delay**2)/(2*c.LIGHTSPEED)))
+            pulse *= Doppler_phase
+        
         return pulse
     

{deepmimo-2.0/src/DeepMIMO → deepmimo-3.2.9/src/DeepMIMOv3}/consts.py

@@ -14,24 +14,26 @@ DICT_BS_IDX = 'basestation'
 # NAME OF PARAMETER VARIABLES
 PARAMSET_DATASET_FOLDER = 'dataset_folder'
 PARAMSET_SCENARIO = 'scenario'
-PARAMSET_DYNAMIC = 'dynamic_settings'
-PARAMSET_DYNAMIC_FIRST = 'first_scene'
-PARAMSET_DYNAMIC_LAST = 'last_scene'
+PARAMSET_DYNAMIC_SCENES = 'dynamic_scenario_scenes'
 
 PARAMSET_NUM_PATHS = 'num_paths'
 PARAMSET_ACTIVE_BS = 'active_BS'
-PARAMSET_USER_ROW_FIRST = 'user_row_first'
-PARAMSET_USER_ROW_LAST = 'user_row_last'
-PARAMSET_USER_ROW_SUBSAMP = 'row_subsampling'
+PARAMSET_USER_ROWS = 'user_rows'
+# PARAMSET_USER_ROW_FIRST = 'user_row_first'
+# PARAMSET_USER_ROW_LAST = 'user_row_last'
+# PARAMSET_USER_ROW_SUBSAMP = 'row_subsampling'
 PARAMSET_USER_SUBSAMP = 'user_subsampling'
 
+PARAMSET_POLAR_EN = 'enable_dual_polar'
+PARAMSET_DOPPLER_EN = 'enable_doppler'
+
 PARAMSET_BS2BS = 'enable_BS2BS'
 PARAMSET_FDTD = 'OFDM_channels' # TD/OFDM
 
 PARAMSET_OFDM = 'OFDM'
 PARAMSET_OFDM_SC_NUM = 'subcarriers'
-PARAMSET_OFDM_SC_LIM = 'subcarriers_limit'
-PARAMSET_OFDM_SC_SAMP = 'subcarriers_sampling'
+# PARAMSET_OFDM_SC_LIM = 'subcarriers_limit'
+PARAMSET_OFDM_SC_SAMP = 'selected_subcarriers'
 PARAMSET_OFDM_BW = 'bandwidth'
 PARAMSET_OFDM_BW_MULT = 1e9 # Bandwidth input is GHz, multiply by this
 PARAMSET_OFDM_LPF = 'RX_filter'
@@ -42,7 +44,8 @@ PARAMSET_ANT_SHAPE = 'shape'
 PARAMSET_ANT_SPACING = 'spacing'
 PARAMSET_ANT_ROTATION = 'rotation'
 PARAMSET_ANT_RAD_PAT = 'radiation_pattern'
-PARAMSET_ANT_RAD_PAT_VALS = ['isotropic', 'halfwave-dipole'] 
+PARAMSET_ANT_RAD_PAT_VALS = ['isotropic', 'halfwave-dipole']
+PARAMSET_ANT_FOV = 'FoV'
 
 # INNER VARIABLES
 PARAMSET_ACTIVE_UE = 'active_UE'
@@ -56,7 +59,10 @@ PARAMSET_SCENARIO_PARAMS_CF = 'carrier_freq'
 PARAMSET_SCENARIO_PARAMS_TX_POW = 'tx_power'
 PARAMSET_SCENARIO_PARAMS_NUM_BS = 'num_BS'
 PARAMSET_SCENARIO_PARAMS_USER_GRIDS = 'user_grids'
+PARAMSET_SCENARIO_PARAMS_POLAR_EN = 'dual_polar_available'
+PARAMSET_SCENARIO_PARAMS_DOPPLER_EN = 'doppler_available'
 
+PARAMSET_SCENARIO_PARAMS_PATH = 'scenario_params_path'
 # OUTPUT VARIABLES
 OUT_CHANNEL = 'channel'
 OUT_PATH = 'paths'
@@ -73,6 +79,9 @@ OUT_PATH_DOA_THETA = 'DoA_theta'
 OUT_PATH_PHASE = 'phase'
 OUT_PATH_TOA = 'ToA'
 OUT_PATH_RX_POW = 'power'
+OUT_PATH_LOS = 'LoS'
+OUT_PATH_DOP_VEL = 'Doppler_vel'
+OUT_PATH_DOP_ACC = 'Doppler_acc'
 OUT_PATH_ACTIVE = 'active_paths'
 
 # FILE LISTS - raytracing.load_ray_data()
@@ -90,3 +99,8 @@ LOAD_FILE_SP_CF = 'carrier_freq'
 LOAD_FILE_SP_TX_POW = 'transmit_power'
 LOAD_FILE_SP_NUM_BS = 'num_BS'
 LOAD_FILE_SP_USER_GRIDS = 'user_grids'
+LOAD_FILE_SP_DOPPLER = 'doppler_available'
+LOAD_FILE_SP_POLAR = 'dual_polar_available'
+
+# Constants
+LIGHTSPEED = 299792458