Datasets:
Tasks:
Other
Formats:
parquet
Size:
100K - 1M
Tags:
wireless
physical-layer-security
covert-communication
low-probability-of-detection
virtual-mimo
anomaly-detection
License:
File size: 2,747 Bytes
b96185c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 | """OTFS over the same 48x4 time-frequency grid as OFDM.
Delay-Doppler grid: 48 delay bins x 4 Doppler bins per user.
* Embedded pilot: a user-orthogonal code-division sequence spread over the
reserved guard region (delay bins 0..11 x all 4 Doppler bins = 48 REs),
using the same exp(j 2 pi m k / M) sequences as the other formats. Spreading
the pilot over 48 REs (rather than a single delay-Doppler impulse) keeps the
embedded-pilot structure and per-user energy but makes the pilot
SCRAMBLE-ABLE: a common per-RE phase decorrelates the coherent sum, defeating
Eve's pilot-matched detector, while Bob (sharing the PRN) de-scrambles and
estimates by correlating against the known DD sequences.
* Data: delay bins 12..47 x 4 Doppler bins = 144 REs. Mapping order is
delay-major: S[m, 4*i + k] -> (delay 12+i, Doppler k).
ISFFT (unitary): DFT along delay -> subcarrier, IDFT along Doppler -> time,
then the OFDM modulator (48 occupied subcarriers of a 64-FFT, CP 16) per
time symbol. All transforms are unitary, so the loopback inverse is exact.
"""
from __future__ import annotations
import numpy as np
from .ofdm import OFDM
class OTFS(OFDM):
name = "otfs"
n_delay = 48
n_dopp = 4
pilot_guard = 12 # delay bins 0..11 reserved for the spread pilot
def __init__(self, cfg):
assert cfg.n_data == (self.n_delay - self.pilot_guard) * self.n_dopp
super().__init__(cfg) # OFDM base sets self.pilots = pilot_sequences(M, 48)
@property
def n_pilot_re(self) -> int:
return self.pilot_guard * self.n_dopp # 48 guard-region REs
def _fill_grid(self, s):
m = self.cfg.n_tx
dd = np.zeros(s.shape[:-1] + (self.n_delay, self.n_dopp), dtype=np.complex128)
dd[..., self.pilot_guard :, :] = s.reshape(
s.shape[:-1] + (self.n_delay - self.pilot_guard, self.n_dopp)
)
# spread pilot: self.pilots (M, 48) -> guard region (M, 12, 4), broadcast over batch
pil = self.pilots.reshape(m, self.pilot_guard, self.n_dopp)
dd[..., : self.pilot_guard, :] = np.broadcast_to(
pil, s.shape[:-1] + (self.pilot_guard, self.n_dopp)
)
# ISFFT: delay -> subcarrier (DFT, axis -2), Doppler -> time (IDFT, axis -1)
tf = np.fft.fft(np.fft.ifft(dd, axis=-1, norm="ortho"), axis=-2, norm="ortho")
return np.swapaxes(tf, -1, -2) # (..., M, n_sym=4, n_occ=48)
def _extract_data(self, grid):
tf = np.swapaxes(grid, -1, -2) # (..., M, delay-bins-as-subcarriers 48, time 4)
dd = np.fft.fft(np.fft.ifft(tf, axis=-2, norm="ortho"), axis=-1, norm="ortho")
d = dd[..., self.pilot_guard :, :]
return d.reshape(d.shape[:-2] + (self.cfg.n_data,))
|