properly windowing for better FFT signal

Question

I have an analog signal as shown below.
As you can see it has a DC component, a 1MHz component and some high order component.
The period of the signal is 8.0199667µs.
I want to see a good accurate frequencies up to 10MHz.
I have captured a signal 78.97518µs long. Its edges are not absolutely equal so my fft will get distorted because of the discontinuity.

Also the LTSPICE program is not sampling the signal equally so I am doing cubic spline to create a "continues" signal which I will try to resample again using cubic spline.

The full sample table which I interpolate is shown in the link below. I have made cubic spline interpolation and resampled it in python at 1/1e7 time gaps as shown in the code below.

How do I create in python a proper windowing to cancel the discontinuity as much as possible?

https://files.fm/u/dpr36h6ce

from scipy.fftpack import fft
#import plotly
#import chart_studio.plotly as py
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.widgets import Cursor
from gekko import GEKKO
#%matplotlib qt
new_x=np.arange(0,7.89752e-05,1/(1e7))
dataset_fft=pd.read_table("sinus_1mhz.txt")
array_fft=dataset_fft.values
m=GEKKO()
m.x=m.Param(new_x)
m.y=m.Var()
m.cspline(m.x,m.y,array_fft[:,0],array_fft[:,1])
m.options.IMODE=2
m.solve(disp=False)
fig=plt.figure()

ax=fig.subplots()
ax.grid()
cursor=Cursor(ax, horizOn=True,vertOn=True,useblit=True,color='r',linewidth =1)
#plt.plot(array_fft[:,0],array_fft[:,1]) 
 
plt.plot(m.x,m.y) 
plt.xlabel("time")
plt.ylabel("amp")
plt.show()

Answer 1

LTSpice similar to other SPICE simulators use an adaptive time step as needed by the time change. This results in efficient computation and keeps the computed derivatives used from exploding. The OP's solution to interpolate the result is a good solution and wants to know how to properly window the fixed time result before computing the DFT.

Another approach to get a uniform time spacing is to export a .Wav file using the .wave command. I believe this is limited to +1/-1V output, so if taking that approach the waveform should be properly scaled to that range before exporting. More details on using the .wave command can be found here as well as in the LTSpice documentation.

Windowing a waveform in MATLAB, Octave and Scipy.signal is very straight forward as all the common windows are precomputed. For the OP's purpose I recommend using the Kaiser window, where the window is computed using kaiser(N, b) with N as the number of samples (matching the number of samples to use in the FFT) and b as the $\beta$ parameter for this window. With that window, the trade between dynamic range and resolution bandwidth can be adjusted directly with the $\beta$ parameter. Typical values I use are in the range of 6 to 22, but by adjusting this you can get similar performance to many other window types used for the OP's purpose.

The Kaiser (and other) windows is part of the Signal Processing Toolbox in MATLAB, and the signal package in Octave (loaded from a standard Octave install by typing pkg load signal), and the scipy.signal package in Python. Example use in Python is shown below for a waveform file named wfm:

import scipy.signal as sig
import scipy.fft as fft
fs = 1
N = len(sig)
win = sig.kaiser(N, 12)
fft_result = fft.fft(win * wfm)
freqaxis = fft.fftfreq(N, fs) 

In the example, I used a normalized sample rate of 1 cycle/sample, and a $\beta$ of 12. $\beta$ can be increased if greater sidelobe rejection is needed, or decreased to reduce that but increase frequency resolution.

I have detailed in the following existing posts the considerations with windowing, overall time duration and zero padding with regards to the impact on frequency resolution that should be helpful to the OP:

How to calculate resolution of DFT with Hamming/Hann window?

Specific Frequency Resolution