Qual è la spazzatura alla fine del mio FFT in LTSPICE?

Perché gli FFT hanno junk all'estremità ad alta frequenza? Supponiamo che vada a simulare questo circuito in LTSPICE:

^{simula questo circuito - Schema creato usando CircuitLab}

Dove sono i parametri seno e simulazione LTSPICE:

SINE(0 1 1K 0 0 0 1000)
.tran 1 startup

Quindi chiedo a LTSPICE di darmi una FFT senza finestra e 1.000.000 di punti:

A cosa serve tutta la spazzatura alla fine? Mi aspetterei un solo picco a 1 KHz, non un ulteriore a 3 KHz, ecc. Succede a tutti gli FFT? Cosa controlla i picchi che ottieni dopo i tuoi fondamentali?

La risposta di D.Brown è già molto buona, quindi aggiungerò solo alcune cose minori. L'algoritmo di LTspice è personalizzato e accetta un numero di punti non di potenza di due. Ciò non significa che la risoluzione non sia importante. Tuttavia, 1kHz su 1s significa un numero intero di punti, quindi non è necessario il windowing o il livellamento binomiale per ridurre il rumore (impostazioni nella finestra FFT). Ciò che è, tuttavia, è ciò che ha menzionato @mkeith, e cioè, per impostazione predefinita, LTspice utilizza una compressione della forma d'onda (300 punti per display, IIRC), il che significa che tutti gli altri punti vengono ridotti e la risoluzione della forma d'onda ne risente. La soluzione per questo è un timestep più stretto o .option plotwinsize=0l'ultimo che elimina la compressione della forma d'onda. Ecco cosa succede quando viene aggiunta questa opzione, ma non viene imposto alcun timestep:

Questo è probabilmente quello che vedi, più o meno, quindi qual è l'opzione per? Stai simulando una forma d'onda da 1 kHz per un periodo di tempo di 1 s . Il circuito, se così si può chiamare, è una sorgente e un carico semplici, e la sorgente è s armonica, un compito miseramente per il risolutore di matrici, quindi LTspice, come tutti i motori SPICE, se ritiene che la derivata sia liscia, raddoppierà il suo timestep per non rallentare la simulazione e continuerà a raddoppiarlo fino a quando non raggiungerà un limite interno, a quel punto sorvolerà la simulazione. Il risultato è una forma d'onda grossolana, che non plotwinsizepuò nemmeno migliorare troppo.

L'altra cura, il timestep imposto, è ora necessaria per migliorare la risoluzione. Ecco il risultato con un 1$\mu$s timestep:

È meglio, ma stai eseguendo un FFT da 1 milione di punti, che richiede, forse non sorprendentemente, 1 milione di punti temporali, quindi il tempo massimo dovrebbe essere impostato su 1$\mu$S. Inoltre, l'opzione numdgtè impostata su un valore> 7 che, dal libro, consente una doppia precisione:

C'è ancora un rumore di fondo leggermente traballante, ma il livello è ora inferiore a -250 dB. Questo è vicino alla precisione della macchina. Effettuare il timestep 1/1048576 (2 ^ -20) non migliora i risultati (puoi verificare tu stesso).

Alla fine, dipende da quanto rumore piano sei disposto ad accettare. Il commento di @Tony Stewart è di una sensibilità pratica, sotto 100 ~ 120dB significa meno di 1 ~ 10$\mu$V a 1V, che è piuttosto un risultato.

Ci sono diverse parti in questa risposta. Baso questa risposta sulle caratteristiche dell'algoritmo FFT. Non ho familiarità con l'implementazione specifica di LTSpice, ma il comportamento segnalato è esattamente quello che mi aspetterei.

Le implementazioni FFT più comuni funzionano con una potenza intera di 2 punti dati. Quindi, la maggior parte delle implementazioni riempirebbe i tuoi 1.000.000 di punti dati fino a 1.048.576 punti dati, ed eseguirà la FFT su questo. Si noti che questa lunghezza non è un numero intero di onde sinusoidali.

Esistono metodi alternativi di trasformata di Fourier che decompongono i dati in modo diverso. Questi di solito prendono il nome di metodi di trasformazione discreta di Fourier (DFT) e sono entrambi più lenti e considerevolmente più complessi da implementare. Non li ho quasi mai incontrati in applicazioni pratiche. La FFT è un'implementazione DFT specifica che richiede che il numero di punti dati sia una potenza intera di 2 (o talvolta una potenza intera di 4).

Quindi, suppongo che LTSpice stia riempiendo i tuoi dati di 1.048.576 punti dati, i 48.576 valori di dati aggiunti alla fine contengono una costante.

Ora puoi vedere il problema: il tuo buffer di 1.048.576 campioni ha 1.000 onde sinusoidali, ognuna di 1.000 campioni, seguite da 48.576 valori costanti. Questo non può essere rappresentato da una somma di onde sinusoidali di frequenza 1kHz. Invece, i risultati FFT mostrano i valori ad alta frequenza aggiuntivi necessari per ricostruire il segnale.

Per determinare se questo è il problema, creare un buffer di 1.048.576 campioni contenente un'onda sinusoidale con periodo 1.024 campioni. Le alte frequenze dovrebbero essere considerevolmente ridotte in grandezza.

Ora, per quanto riguarda l'effetto dell'applicazione di una finestra:

L'algoritmo FFT 'avvolge' concettualmente i dati, quindi l'ultimo punto dei dati di input è seguito dal primo punto dei dati di input. Cioè, la FFT viene calcolata come se i dati fossero infiniti, ripetuti circolarmente, come un vettore con la sequenza: x [0], x [1], ..., x [1048574], x [1048575], x [ 0], x [1], ...

Questo wrapping può comportare una transizione di passaggio tra l'ultimo punto nel buffer di dati e il primo punto. Questo passaggio di transizione genera risultati FFT con grandi contributi (spuri) dalle alte frequenze. Lo scopo di una finestra è eliminare questo problema. La funzione finestra va a zero su entrambe le estremità, quindi nel tuo caso w [0] e w [999999] sarebbero entrambi zero. Quando i dati vengono moltiplicati per la finestra, i valori diventano zero all'inizio e alla fine, quindi non vi è alcuna transizione di passaggio nell'involucro.

La funzione finestra che si applica altera il contenuto di frequenza del buffer, si sceglie una funzione che presenta un compromesso accettabile. Un gaussiano è un buon punto di partenza. Per qualsiasi applicazione pratica in cui non è possibile controllare con precisione il contenuto in frequenza dei dati, è necessario applicare una funzione finestra per eliminare la transizione di fase implicita a causa della lunghezza dei dati.

Problemi residui:

Esiste un'altra potenziale fonte di rumore spettrale ad alta frequenza nella FFT. L'effetto aumenta con la lunghezza della FFT e potrebbe essere qualcosa che puoi vedere in alcuni casi in 1.000.000 di punti dati.

L'algoritmo interno dell'algoritmo FFT utilizza i punti attorno a un cerchio nel piano complesso: e ^ (i * theta), in cui l'algoritmo itera 'theta' da 0 a 2 * pi in passaggi successivamente più fini, fino al numero di punti nel FFT. Cioè, se si calcola un FFT su 1.048.576 campioni, in una delle iterazioni del loop esterno, il loop interno calcolerà e ^ (i * theta), dove theta = 2 * pi * n / N, dove N è 1.048.576 , ripetendo n da 0 a 1.048.575. Questo viene fatto dall'ovvio metodo di moltiplicarsi successivamente per e ^ (i * 2 * pi / N).

Puoi vedere il problema: quando N diventa grande, e ^ (i * 2 * pi / N) diventa molto vicino a 1, e viene moltiplicato N volte. Con la virgola mobile a precisione doppia, gli errori sono piccoli, ma penso che puoi vedere il rumore di fondo risultante se guardi attentamente. Con virgola mobile a precisione singola, a 1.000.000 di punti dati il ​​calcolo FFT stesso produce un rumore di fondo significativo.

Esistono tecniche alternative per il calcolo di e ^ (i * theta) che eliminano questo problema, ma l'implementazione è più complessa. Ho dovuto creare una tale implementazione solo una volta.

Possibile motivo: -

Quando si disegna un'onda transitoria in un simulatore, essa interpola tra i calcoli reali in modo da ridurre al minimo il duro lavoro svolto e consentire la visualizzazione sullo schermo di un risultato più rapido.

L'impostazione predefinita per il massimo timestep in LTSpice potrebbe essere 100 us e quindi tra questi punti si hanno risultati interpolati, cioè non sono perfetti e contribuiscono alla distorsione vista come armoniche nella FFT.

Prova a impostare il tuo tempo massimo in modo che sia molto più piccolo di quello che è attualmente e guarda cosa succede.