mmWrt package

Submodules

mmWrt.Plots module

mmWrt.Plots.plot_range_azimuth(cube: ndarray[tuple[Any, ...], dtype[complex128]], radar: Radar) → None

plotting the range azimuth 2D FFT with axis labeled standard units

Parameters:

cube – (antenna count, adc sample count) a 2D array
radar – Radar instance to allow labelling axes correctly
Effects (Side)
------------
window. (Displays a Matplotlib figure)

mmWrt.Plots.plot_range_doppler(cube: ndarray[tuple[Any, ...], dtype[_ScalarT]], radar: Radar, _d0: float | None = None, _v0: float | None = None, no_speed_shift: bool = True, debug: bool = False)

Plots Range Doppler with axis labeled in SI

Parameters:

cube – contains a 2D array with slow time and fast time samples
radar – contains configuration values for displaying the range doppler
_d0 – if is not None, will be used in title for scatterer pos
_v0 – if is not None, will be used in title as scatterer speed
no_speed_shift – if True does not do fftshift on the speeds
debug – if True shows the plot, otherwise returns the figure and data

Returns:

plot_details – (fig, ranges, speeds)

Return type:

tuple

Example

import matplotlib.pyplot as plt fig, ranges, speed = plot_range_doppler(adc_cube, radar) plt.show()

mmWrt.PointCloud module

mmWrt.RadarSignalProcessing module

mmWrt.RadarSignalProcessing.bin_to_deg(idx: ndarray[tuple[Any, ...], dtype[_ScalarT]], ula_element_count)

mmWrt.RadarSignalProcessing.cfar_1D_convolve(X: ndarray[tuple[Any, ...], dtype[_ScalarT]], num_training_cells: int = 10, num_guard_cells: int = 2, Pfa: float = 0.1, mode: str = 'same', debug: bool = False)

CFAR implementation via convolution the idea is to see CFAR as convolution with a kernel of 0 for guard an CuT cells and 1 for train cells, then scaling the output of the convolution by T/M for Pfa

Parameters:

X – signal whose peaks have to be detected and reported
num_training_cells – number of cells used to train CFAR
num_guard_cells – number of cells guarding CUT against noise power calculation
Pfa – Probability of false alert, used to compute the variable threshold
mode – same meaning as np.convolve
debug – if True will output debug info

Returns:

CFAR threshold values

Return type:

cfar_th

mmWrt.RadarSignalProcessing.cfar_alpha(train_cell_count: int, pfa: float) → float

Compute the CA-CFAR threshold multiplier for a given PFA. Assumes exponentially distributed power (complex Gaussian clutter).

Parameters:

train_cell_count – Number of training cells (must be >= 1).
pfa – Probability of False Alarm (0 < pfa < 1).

Returns:

Threshold multiplier for CA-CFAR.

Return type:

alpha

Notes

The closed-form relationship between alpha and PFA for CA-CFAR with N independent exponential training samples is:

PFA = (1 + alpha / N)^(-N)

Solved for alpha:

alpha = N * (PFA^(-1/N) - 1)

This derivation assumes homogeneous clutter. Results are statistically meaningless on non-Gaussian or non-stationary backgrounds, though the returned float remains numerically valid and can still be passed to _cfar_core as an empirically chosen multiplier.

Side Effects

None.

Examples

>>> round(cfar_alpha(8, 1e-4), 4)
26.0309
>>> cfar_alpha(16, 1e-2)  # more training cells, lower alpha
4.953...
>>> cfar_alpha(1, 0.5)
1.0

mmWrt.RadarSignalProcessing.cfar_ca(fft_values: ndarray, guard_cell_count: int, train_cell_count: int, pfa: float, debug: bool = False) → ndarray

CFAR CA function :param fft_values: Array of FFT values :param guard_cell_count: Number of guard cells :param train_cell_count: Number of training cells :param pfa: Probability of false alarm :param debug: Whether to enable debug mode

Returns:: Array of CFAR thresholds
Return type:: np.ndarray

mmWrt.RadarSignalProcessing.detection_xy(adc_values: ndarray[tuple[Any, ...], dtype[_ScalarT]], radar: Radar)

mmWrt.RadarSignalProcessing.dft_cfr_idx(fft_mag: ndarray[tuple[Any, ...], dtype[_ScalarT]], train_cell_count: int, pfa: float, debug: bool = False) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

returns indexes where cfar finds peaks

Parameters:

fft_mag – the magnitude of the fft values
train_cell_count – the number of training cells to use for cfar
pfa – the probability of false alarm to use for cfar
debug – if True, outputs debug information

Returns:

array of indices where peaks are detected by CFAR

Return type:

peak_idxs

mmWrt.RadarSignalProcessing.doppler_to_mps(idx: ndarray[tuple[Any, ...], dtype[_ScalarT]], chirp_count, wavelength, chirp_period)

mmWrt.RadarSignalProcessing.error(scatterers_synthetics, scatterers_f)

Computes the error in the scatterers position estimation

Parameters:

scatterers_synthetics (list[Scatterers]) – list of synthetic scatterers (as defined intially)
scatterers_f (list[Scatterers]) – list of scatterers as computed by rt and rsp

Returns:

total_error – sum of distances between each closest scatterers

Return type:

float

mmWrt.RadarSignalProcessing.frequency_estimator(FFT, idxs, estimator_name='fft')

Wrapper around the different frequency estimator possible

Parameters:

FFT (numpy array) – Fourier Transform with complex values
idxs (List[int]) – list of indexes where peaks in FFT are found and where the frequency estimator estimator_name needs to be applied
estimator_name (str) – fft phase quinn_second

Returns:

i_peaks – array of estimated float index from the int idxs

Return type:

numpy array

Raises:

ValueError # noqa – DAR402: when invalid estimator_name value is passed as parameter

mmWrt.RadarSignalProcessing.if2d(radar)

ratio from IF frequency to distance !!! important

the ratio is 1/2 of the d2f as the IF frequency results from the wave traveling to the scatterer and back. Whereas if2d gives the distance between the radar and the scatterer which is 1/2 the distance travelled by the radar EM wave.

Parameters:

radar (object) – a radar object

Returns:

f2d (float) – ratio between frequency and distance for given radar settings
Usage
—–
f2d = if2d(radar)
# assuming f_if is an IF frequency
# then d will be the distsance to the scatterer
d = f2d * f_if

mmWrt.RadarSignalProcessing.pcl(adc_values: ndarray[tuple[Any, ...], dtype[_ScalarT]], radar) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

returns array of 3D pcl

Parameters:: adc_values – (chirps, z virtual antennas, x virtual antennas, adc)
Returns:: (x, y, z, vr, mag) numpy array for all detections
Return type:: detections

mmWrt.RadarSignalProcessing.pcl_xyz(adc_values: ndarray[tuple[Any, ...], dtype[_ScalarT]], radar) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

returns array of 3D pcl

Parameters:: adc_values – (z virtual antennas, x virtual antennas, chirps, adc)
Returns:: (number_detections, 3): (x, y, z) detections
Return type:: detections_xyz

mmWrt.RadarSignalProcessing.peak_grouping_1d(cfar_idx: ndarray[tuple[Any, ...], dtype[_ScalarT]], mag_r: ndarray[tuple[Any, ...], dtype[_ScalarT]]) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

groups adjacent idx from cfar by first putting adjacent one in clusters then finding the index with the highest magnitude in FFT and returning this one as peak

Parameters:

cfar_idx – array of index (usually those where fft magnitude is higher than CFAR threshold)
mag_r – array of magnitude (usually np.abs(fft) on which CFAR was computed)

Returns:

Array of indices (from cfar_idx) at which each group’s peak occurs.

Return type:

idx_grouped

Examples

>>> cfar_idx = np.array([0, 1, 2, 5, 6, 7, 14])
>>> mag_r  = np.array([3, 9, 4, 2, 7, 5,  1])
>>> peak_grouping_1d(cfar_idx, mag_r)
array([ 1,  6, 14])

Ties resolve to the first occurrence:

>>> cfar_idx = np.array([0, 1, 2])
>>> mag_r  = np.array([5, 5, 3])
>>> peak_grouping_1d(cfar_idx, mag_r)
array([0])

mmWrt.RadarSignalProcessing.range_aoa(adc_values: ndarray[tuple[Any, ...], dtype[_ScalarT]], radar: Radar) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

returns a list of (range, angle) for each scatterer detected in the given adc values

Parameters:

adc_values – (rx_count, adc_samples count) 2D array
radar – the RX radar

Returns:

(range, angle) array for each scatterer detected in adc_values

Return type:

NDArray

mmWrt.RadarSignalProcessing.range_doppler(adc_values: ndarray[tuple[Any, ...], dtype[_ScalarT]], adc_sample_rate: float, chirp_slope: float, wavelength: float, chirp_period: float) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

Returns a NDArray of (range, doppler) for each scatterer detected in the given adc values

Parameters:

adc_values – (chirp_count, adc_samples count)
adc_sample_rate – the ADC sampling rate in Hz
chirp_slope – the chirp slope in Hz/s
wavelength – the wavelength of the radar in meters
chirp_period – the chirp period in seconds

Returns:

(range, doppler) detections for each scatterer detected in (m, m/s)

Return type:

NDArray

mmWrt.RadarSignalProcessing.range_doppler_index_grouped(range_doppler_fft: ndarray[tuple[Any, ...], dtype[_ScalarT]], range_cfar_train_cell: int = 6, doppler_cfar_train_cell: int = 10)

groups the range doppler indexes by first finding the range peaks and then for each range peak finding the doppler peaks

Parameters:

range_doppler_fft – the range doppler fft values
range_cfar_train_cell – the number of training cells to use for range cfar
doppler_cfar_train_cell – the number of training cells to use for doppler cfar

Returns:

list of tuples of (range_idx, doppler_idx) for each peak found # FIXME: move this to NDArray

Return type:

range_dopplers_idxes

mmWrt.RadarSignalProcessing.range_fft(adc_values: ndarray[tuple[Any, ...], dtype[_ScalarT]], baseband: dict, chirp_index: int = 0, fft_window: str | None = None, fft_padding: int = 0, full_FFT: bool = False, debug: bool = False)

scipy FFT wrapper with windowing and padding options

Parameters:

adc_values – (N,) the IF ADC signals of shape (N,) - i.e. 1D array
baseband – the dict returned by raytracing
chirp_index (int) – (obsolete) index of the chirp in the data matrix
fft_window – FFT windowing names supported by scipy get_window
fft_padding – if 0 - no padding if -1: padding to next level of power of 2 other values: padding to those values
full_FFT – if True returns the full FFT, else only 0..d_max_unambiguous
debug – if True logs debug information on console

Returns:

Range_FFT – Distances: np array abs_FT: np array

Return type:

tuple

Raises:

ValueError – when fft_padding has a value < -1

mmWrt.RadarSignalProcessing.range_resolution(v: float, B: float)

Range resolution is c/2B

Parameters:

v – celerity of light in medium
B – Bandwidth of signal sampled (often simplified as chirped)

Returns:

delta_R – Range Resolution

Return type:

float

mmWrt.RadarSignalProcessing.range_to_meters(idx: ndarray[tuple[Any, ...], dtype[_ScalarT]], adc_sample_rate, adc_sample_count, chirp_slope) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

mmWrt.RadarSignalProcessing.ranges_dft_cfar(adc_values: ndarray[tuple[Any, ...], dtype[_ScalarT]], adc_sample_rate: float, chirp_slope: float, pfa: float, log=None) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

returns a NDArray of ranges using a simple fft threshold for scatterer if adc_values are real, will return half the range bins

Parameters:

adc_values – (adc_sample_count,) the ADC values for a given chirp.
chirp_slope – the chirp slope in Hz/s
adc_sample_rate – the ADC sampling rate in Hz
pfa – the probability of false alarm to use for cfar
log – the logger instance to use for debug output

Returns:

the ranges where scatterers are detected

Return type:

ranges

mmWrt.RadarSignalProcessing.ranges_from_fft_threshold(adc_values: ndarray[tuple[Any, ...], dtype[_ScalarT]], chirp_slope: float, adc_sample_rate: float, fft_threshold: float) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

returns a NDArray of ranges using a simple fft threshold for scatterer detection, used for simple examples. Not recommended in most cases, cfar peak detection recommended

Parameters:

adc_values – (adc_sample_count,) the ADC values for a given chirp
chirp_slope – the chirp slope in Hz/s
adc_sample_rate – the ADC sampling rate in Hz
fft_threshold – threshold used by find peaks for peak detection

Returns:

the ranges corresponding to each ADC sample

Return type:

ranges

Example

mmWrt.Raytracing module

This is where the raytracing happens rt_points - main function to perform raytracing with point scatterers BB_IF - function to compute the BaseBand Intermediate Frequency

BB_IF is called by rt_points to compute each respective scatterer’s IF contribution

mmWrt.Raytracing.rt_points(radars: ~typing.List[~mmWrt.Scene.Radar], scatterers: ~typing.List[~mmWrt.Scene.Scatterer], receiver_radar: ~mmWrt.Scene.Radar, radar_equation: bool = False, datatype: type = <class 'numpy.float32'>, debug: bool = False, disable_tqdm: bool = True, log: ~logging.Logger = <Logger default (WARNING)>, **raytracing_opt) → dict

raytracing with points

Parameters:

radars – all the radars in the Raytracing scene (interferers, …)
scatterers – list of scatterers in the Scene
receiver_radar – instance of Radar for which the BB cube is computed. One of the radars in the scene. (renamed in 0.0.10 from radar)
radar_equation – if True includes the radar equation when computing the IF signal else ignores radar equation
datatype – type of data to be generate by rt: float16, float32, … or complex
debug – if True prints log messages
disable_tqdm – if True disables the tqdm output (for .ipynb cells)
raytracing_opt –

compute: bool
if True computes raytracing (use False for radar statistics tuning)

T_start: float
time offset to start simulation

radars: List[radar]
list of interferer radars to include in the simulation, including own radar TX

Returns:

dictonnary with adc values and other parameters used later in analysis {“adc_cube”: NDArray, “frame_count”: int, “chirp_slope”: float,} adc_cube[frame_idx, chirp_idx, None, rx_idx, adc_idx]…

Return type:

dict

mmWrt.Raytracing.sample_all_rays(adc_times, radars, scatterers, receiver_radar, datatype=<class 'numpy.float32'>, radar_equation=False, debug=False, log: Logger = <Logger default (WARNING)>) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

Computes the ADC samples at the given ADC times for the receiver radar v2 (now fully vectorised) reserved for future release to replace rt_points ?!?!?

Parameters:

adc_times – (T): absolute time
radars – list of Radar
scatterers – list of Scatterer
receiver_radar – radar for which we are computeing the adc samples
datatype – adc datatype
radar_equation – if True computes the radar equation (gains and losses) if False no gains and losses
debug – if True prints debug info - legacy slowly moving to log
log – the object passed by auto_log for hierichal logging default value only used for flake8 to avoid error messages

Returns:

(T, RX) - note this convention is changed at raytracing level into (RX, T)

Return type:

NDArray

mmWrt.Scene module

This module defines the main classes used to define a radar

class mmWrt.Scene.Antenna(x: float = 0.0, y: float = 0.0, z: float = 0.0, angle_gains_db10: ndarray[tuple[Any, ...], dtype[_ScalarT]] = array([[0., 0., 0., ..., 0., 0., 0.], [0., 0., 0., ..., 0., 0., 0.], [0., 0., 0., ..., 0., 0., 0.], ..., [0., 0., 0., ..., 0., 0., 0.], [0., 0., 0., ..., 0., 0., 0.], [0., 0., 0., ..., 0., 0., 0.]], shape=(360, 360)), f_min_GHz: float = 60, f_max_GHz: float = 64, freq_gains_db10: ndarray[tuple[Any, ...], dtype[_ScalarT]] = array([0., 0., 0., 0.]))

Bases: object

freq_gain_db10(freq: float) → float

antenna gain at given frequency

Parameters:: freq – frequency in Hertz
Returns:: gain_dB: gain in dB
Return type:: float
Raises:: ValueError – if freq is too low

gain(azimuth: float, elevation: float, freq: float) → float

computes total antenna gain over elevation, aziumth and frequency

Parameters:

azimuth – between -pi and pi value
elevation – between -pi and pi value
freq – frequency at which antenna gain needs to be calculated

Returns:

antenna gain at freq and given direction

Return type:

float

position_in_time(timestamp: ndarray[tuple[Any, ...], dtype[_ScalarT]]) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

Parameters:

timestamp – the timestamps at which positions need to be returned

Returns:

NDArray – (timestamps, 3) positions in time
Usage
—–
for compute of distance need to add an axis,
which is done by staking over axis =1
(0 is time and 2 is 3D coordinate)
positions_t = stack([ant.position_in_time(timestamps)
for ant in self.tx_antennas], axis=1) # [T, N_ant, 3]

class mmWrt.Scene.Medium(v=300000000.0, L=0, name='void'): Bases: object

class mmWrt.Scene.Radar(transmitter=<mmWrt.Scene.Transmitter object>, receiver=<mmWrt.Scene.Receiver object>, medium=<mmWrt.Scene.Medium object>, adc_po2=False, debug=False)

Bases: object

adc_sampling(f_if: ~numpy.ndarray[tuple[~typing.Any, ...], ~numpy.dtype[~numpy._typing._array_like._ScalarT]], adc_times: ~numpy.ndarray[tuple[~typing.Any, ...], ~numpy.dtype[~numpy._typing._array_like._ScalarT]], ph_rx: ~numpy.ndarray[tuple[~typing.Any, ...], ~numpy.dtype[~numpy._typing._array_like._ScalarT]], time_of_flight: ~numpy.ndarray[tuple[~typing.Any, ...], ~numpy.dtype[~numpy.float64]], radar_equation: bool = False, datatype: ~typing.Type = <class 'numpy.complex64'>, debug=False) → ndarray[tuple[Any, ...], dtype[ADCType]]

sampling the f_if signals at adc_times time stamp :param f_if: (timestamps,tx, scatterers, rx) :param adc_times: (timestamp, tx, scatters, rx) :param time_of_flight: (timestamps,tx, scatterers, rx)

Returns:: (timestamps, rx_antenna_count) YIF
Return type:: NDArray[ADCType]
Raises:: ValueError – if radar equation set to True

mixer(timestamps: ndarray[tuple[Any, ...], dtype[_ScalarT]], f_rx: ndarray[tuple[Any, ...], dtype[_ScalarT]]) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

RF to baseband conversion, emulates the mixing of RX and TX which is multiplication and low pass filter, the result is that the itermediate frequency the if is the substraction of the two rf frequencies. This function is a stub for other possible down conversion in future versions. Note: no low pass filtering here. Currently done at IF stage

Parameters:

timestamps –
f_rx – (T, TX, S, RX)

Returns:

(T, TX, S, RX) f_if

Return type:

NDArray

position_rx_antennas(timestamps) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

return the position of the antennas in time

Parameters:: timestamps – the timestamps at which positions need to be returned
Returns:: (timestamps, antenna_count, 3)
Return type:: NDArray

position_tx_antennas(timestamps) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

return the position of the antennas in time

Parameters:: timestamps – the timestamps at which positions need to be returned
Returns:: (timestamps, antenna_count, 3)
Return type:: NDArray

class mmWrt.Scene.Receiver(adc_sample_rate=400.0, antennas=(<mmWrt.Scene.Antenna object>, ), adc_sample_count_max=1024, adc_sample_rate_max=25000000.0, adc_sample_count=0, config=None, debug=False)

Bases: object

Need to split this into RX RF (antennas locations) MIXER for RX, TX to IF IF filter (HPF for DC and LPF for aliasing + removal of the MIXER high freq components)

class mmWrt.Scene.Scatterer(x=0.0, y=0.0, z=0.0, xt=None, yt=None, zt=None, rcs_f=<function Scatterer.<lambda>>, scatterer_type='point')

Bases: object

distance(scatterer=None, t=0)

pos_t(t: ndarray[tuple[Any, ...], dtype[_ScalarT]]) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

pos_t1(t: ndarray[tuple[Any, ...], dtype[_ScalarT]]) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

rcs(f)

class mmWrt.Scene.Transmitter(chirp_start_freq: float = 60000000000.0, chirp_slope: float = 1000000000000.0, chirp_end_time: float = 1e-06, antennas: ~typing.List[~mmWrt.Scene.Antenna] = [<mmWrt.Scene.Antenna object>], chirp_period: float = 1e-06, chirp_count: int = 1, frame_period: float = 0.05, frame_count: int = 1, **kwargs)

Bases: object

Attributes:

tx_start_time: float: time offset for the start of the first chirp
tx_on_times: List[float]: list of 2-uples of start/stop timess for each chirp transmitted list of slopes for each chirp transmitted

LO_freq(timestamps: ndarray[tuple[Any, ...], dtype[_ScalarT]]) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

FIXME: this functions’ description only describes the ToF use case, not LO use case

Returns for each TX->Scatterer->RX path the TX frequency at which the chirps was sent when it is received by the mixer

Parameters:: timestamps – (timestamps, TX antenna count, Scatterer count, RX antenna count) the timestamp at which ADC are sampling, the TX freq is then computed as timestamp-time_of_flight
Raises:: ValueError – if chirp_period is 0 and there are multiple chirps or antennas
Returns:: (timestamps, TX antenna count, Scatterer count, RX antenna count) tx_frequencies values at each timestamp of the TX freq for antenna which can then be used to compute the tones on each RX antenna before mixing with LO to generate all the IF tones
Return type:: NDArray

TX_phases(timestamps: ndarray[tuple[Any, ...], dtype[_ScalarT]], phaser: bool = True) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

Returns for each TX->Scatterer->RX path the TX phase at which the chirps was sent when it is received by the mixer. For code logic and documentation refer to LO_freqs

Parameters:

timestamps – (T, TX, Scatterer, RX)
phaser – if True, returns the phase at the phaser level (include LO phase noise + phaser) if False, only return the LO phase

Raises:

ValueError – if chirp_period is 0 and there are multiple chirps or antennas

Returns:

(T, TX, Scatterer, RX) tx_phases

Return type:

NDArray

chirp_count = 1

conf = {'multiplexing': 'TDM'}

frame_count = 1

tx_on_times = []

tx_start_time = 0.0

class mmWrt.Scene.TransmitterDDM(chirp_start_freq=60000000000.0, chirp_slope: float = 1000000000000.0, chirp_end_time: float = 1e-06, antennas=[<mmWrt.Scene.Antenna object>], chirp_period=0.0, chirp_count=1, frame_period=0.0, frame_count=1, **kwargs): Bases: Transmitter

mmWrt.Scene.two_way_range(tx_antennas_positions: ndarray[tuple[Any, ...], dtype[_ScalarT]], scatterer_positions: ndarray[tuple[Any, ...], dtype[_ScalarT]], rx_antennas_positions: ndarray[tuple[Any, ...], dtype[_ScalarT]]) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

Computes the two way distance from TX antenna to scatterer back to RX antenna

Parameters:

tx_antennas_positions – [T, TX, 3]
scatterer_positions – [T, S, 3]
rx_antennas_positions – [T, RX, 3]

Returns:

[T, TX, S, RX]

Return type:

two_way_distance

mmWrt.fmcw module

mmWrt.fmcw.BB_IF(f0_min, slope, T, antenna_tx, antenna_rx, scatterer, v=300000000.0)

This function implements the mathematical IF defined in latex as y_{IF} = cos(2 pi [f_0delta + s * delta * t - s* delta^2]) into following python code y_IF = cos (2*pi*(f_0 * delta + slope * delta * T + slope * delta**2))

Parameters:

f0_min (float) – the frequency at the begining of the chirp
slope (float) – the slope with which the chirp frequency inceases over time
T (ndarray) – the 1D vector containing time values
antenna_tx (tuple of floats) – x, y, z coordinates
antenna_rx (tuple of floats) – x, y, z coordinates
scatterer (tuple of floats) – x, y, z coordinates
v (float) – speed of light in considered medium

Returns:

YIF – vector containing the IF values

Return type:

ndarray

mmWrt.mylogs module

mmWrt.mylogs.auto_log(func)

mmWrt package

Submodules

mmWrt.Plots module

mmWrt.PointCloud module

mmWrt.RadarSignalProcessing module

Side Effects

mmWrt.Raytracing module

mmWrt.Scene module

Attributes:

mmWrt.fmcw module

mmWrt.mylogs module

Module contents