Public Member Functions
None	__init__ (self, float sample_rate_hz, tuple[int,...] n_id_2_candidates=(0, 1, 2), int ndlrb=6, bool normal_cp=True)
np.ndarray	correlate (self, np.ndarray rx_waveform)
tuple[int, int]	estimate_timing (self, np.ndarray corr_metrics)
float	estimate_cfo (self, np.ndarray rx_waveform, int tau_hat, int n_id_2)
np.ndarray	apply_cfo_correction (self, np.ndarray rx_waveform, float cfo_hat)

Public Attributes
	sample_rate_hz = float(sample_rate_hz)
	n_id_2_candidates = tuple(n_id_2_candidates)
	ndlrb = int(ndlrb)
	normal_cp = bool(normal_cp)

Protected Member Functions
dict[int, np.ndarray]	_build_time_templates (self)

Static Protected Member Functions
list[int]	_symbol_start_indices (OFDMModulator ofdm)

Protected Attributes
int\|None	_fft_N = None
int\|None	_cp_len_pss = None
dict[int, np.ndarray]	_templates = self._build_time_templates()

Detailed Description

PSSSynchronizer za LTE OFDM waveform (RX-only PSS sync + CFO).

Ova klasa radi tri ključna koraka:
  1) PSS korelacija (3 kandidata) -> korelacijske metrike kroz vrijeme (tau)
  2) Timing + izbor N_ID_2        -> tau_hat, N_ID_2_hat
  3) CFO procjena + korekcija     -> cfo_hat, rx_corr

Implementacija je usklađena s OFDM signalom koji generiše tvoj LTETxChain/OFDMModulator:
- Korelacija se radi sa time-domain OFDM template-om PSS simbola (CP + N uzoraka),
  ne sa 62 ZC uzorka u vremenu.
- CFO se procjenjuje CP-autokorelacijom:
    v = sum( tail * conj(cp) )
    phi = angle(v)
    cfo_hat = phi * Fs / (2*pi*N)
  gdje je "period" = N (FFT size), jer je CP kopija zadnjih cp_len uzoraka IFFT dijela.

Parametri __init__:
-------------------
sample_rate_hz : float
    Sampling frekvencija RX signala (Hz). Mora se poklopiti s onom koju koristi TX (fs).
n_id_2_candidates : tuple[int, ...]
    Kandidati za N_ID_2 (tipično (0,1,2)).
ndlrb : int
    Broj DL resource block-ova (npr. 6 za LTE 1.4 MHz).
normal_cp : bool
    True za normal CP, False za extended CP.

Tipični tok korištenja:
-----------------------
>>> sync = PSSSynchronizer(sample_rate_hz=fs, ndlrb=6, normal_cp=True)
>>> corr = sync.correlate(rx)                 # (3, corr_len) kompleksno
>>> tau_hat, nid_hat = sync.estimate_timing(corr)
>>> cfo_hat = sync.estimate_cfo(rx, tau_hat, nid_hat)
>>> rx_corr = sync.apply_cfo_correction(rx, cfo_hat)

Napomena (važna za demo):
-------------------------
CP CFO metoda ima praktični capture range ~ ±Fs/(2N).
Za ndlrb=6: Fs=1.92 MHz, N=128 -> ±7.5 kHz.
Za čistu vizualizaciju u C2 koristi CFO_true npr. 3000–7000 Hz.

Member Function Documentation

◆ _build_time_templates()

dict[int, np.ndarray] receiver.pss_sync.PSSSynchronizer._build_time_templates ( self )

protected

Generiše time-domain template PSS simbola (CP+N) za svaki N_ID_2 kandidat.

Returns
-------
templates : dict[int, np.ndarray]
    Mapa N_ID_2 -> template (kompleksni niz dužine CP+N).

Raises
------
ValueError:
    Ako se sampling frekvencija template-a ne poklapa s sample_rate_hz.
RuntimeError:
    Ako se ne uspije postaviti FFT N ili CP length (PSS).

◆ _symbol_start_indices()

list[int] receiver.pss_sync.PSSSynchronizer._symbol_start_indices ( OFDMModulator ofdm )

staticprotected

Vraća start indekse OFDM simbola u vremenskom signalu (CP start).

Returns
-------
starts : list[int]
    Lista start indeksa (u uzorcima) za svaki OFDM simbol u grid-u.

◆ apply_cfo_correction()

np.ndarray receiver.pss_sync.PSSSynchronizer.apply_cfo_correction	(		self,
		np.ndarray	rx_waveform,
		float	cfo_hat )

Primjenjuje CFO korekciju na cijeli RX signal.

Parameters
----------
rx_waveform : np.ndarray
    Kompleksni RX signal (1D).
cfo_hat : float
    Procijenjeni CFO u Hz. Primjenjuje se -cfo_hat.

Returns
-------
rx_corr : np.ndarray
    CFO-korigovani RX signal.

◆ correlate()

np.ndarray receiver.pss_sync.PSSSynchronizer.correlate	(		self,
		np.ndarray	rx_waveform )

Radi normalizovanu korelaciju RX signala sa PSS template-ima (CP+N).

Parameters
----------
rx_waveform : np.ndarray
    Kompleksni baznopojasni RX signal (1D).

Returns
-------
corr_metrics : np.ndarray
    Kompleksne korelacijske metrike oblika (K, corr_len), gdje je:
      - K = broj kandidata (tipično 3),
      - corr_len = len(rx) - L + 1,
      - L = dužina template-a (CP+N).
    Obično se za odluku gleda |corr_metrics|.

Raises
------
ValueError:
    Ako je RX prekratak u odnosu na dužinu template-a.

◆ estimate_cfo()

float receiver.pss_sync.PSSSynchronizer.estimate_cfo	(		self,
		np.ndarray	rx_waveform,
		int	tau_hat,
		int	n_id_2 )

CFO procjena iz cyclic prefix-a (CP) autokorelacijom.

Parameters
----------
rx_waveform : np.ndarray
    Kompleksni RX signal (1D).
tau_hat : int
    Procijenjeni start PSS simbola (CP start) u RX signalu.
n_id_2 : int
    Detektovani N_ID_2 (ovdje se ne koristi direktno u CP metodi,
    ali se čuva u potpisu radi konzistentnog API-ja).

Returns
-------
cfo_hat : float
    Procijenjeni CFO u Hz.

Raises
------
ValueError:
    Ako RX nema dovoljno uzoraka za jedan OFDM simbol (CP+N) od tau_hat.

◆ estimate_timing()

tuple[int, int] receiver.pss_sync.PSSSynchronizer.estimate_timing	(		self,
		np.ndarray	corr_metrics )

Iz korelacijskih metrika bira maksimalni peak:
- tau_hat: indeks uzorka gdje je peak (procjena tajminga)
- N_ID_2_hat: kandidat koji je dao najveći peak

Parameters
----------
corr_metrics : np.ndarray
    Izlaz iz correlate(): oblik (K, corr_len), kompleksno.

Returns
-------
tau_hat : int
    Procijenjeni timing offset (u uzorcima).
N_ID_2_hat : int
    Procijenjeni N_ID_2 (0/1/2).

The documentation for this class was generated from the following file:

receiver/pss_sync.py

Public Member Functions

Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes