# Reducing the frequency resolution for a short pulse by applying the SVEA - how to keep frequency?

If I have a single light pulse, I can define it as (within certain boundaries, and $$A$$ a gaussian function) $$E(t) = A(t)\cdot\exp(-i\omega_0 t)$$ After applying an FFT over it, I can then shift the pulse into the frequency range, and by using a high enough resolution in time I can accurately resolve $$\omega_0$$. Unfortunately, for large time windows this requires a high resolution which slows things down. Therefore, one idea would be (after I am not interested in the oscillations, only in the envelope) to replace $$E(t) = A(t)\cdot\exp(-i\omega_0 t)$$ with $$E(t) = A(t)$$ i.e. shifting the central frequency from $$\omega_0$$ to $$0$$. Now, the required resolution for an FFT is significantly lower compared to the initial case, but I do not know how I can identify the involved frequencies now.

I wrote a short example, as below:

import matplotlib.pyplot as plt
import scipy.constants as scco
import numpy as np

def create_gaussian_function(x, t):
return np.exp(-np.power(x / t, 2))

l_0 = 1550e-9
w_0 = 2 * np.pi * scco.speed_of_light / l_0

class pulse:
def __init__(self, Nt, t_min, t_max, l_min, l_max, t_0, l_0, with_main_frequency = False):
self.t_vec = np.linspace(t_min, t_max, Nt, dtype=complex)
self.t_min = t_min
self.t_max = t_max
self.Nt = Nt
self.t_0 = t_0
self.l_0 = l_0
self.w_0 = 2 * np.pi * scco.speed_of_light / self.l_0
self.with_main_frequency = with_main_frequency
self.dt = np.real(self.t_vec[1] - self.t_vec[0])
#self.f_vec = np.fft.fftfreq(Nt, self.dt)
self.f_vec = []
self.index_minimum_frequency = 0
f_min = scco.speed_of_light / l_max
f_max = scco.speed_of_light / l_min
for i in range(int(Nt / 2)):
local_f = i / (self.t_max - self.t_min)
if local_f < f_min:
self.index_minimum_frequency += 1
if local_f >= f_min and local_f <= f_max:
self.f_vec.append(local_f)
self.f_vec = np.asarray(self.f_vec)
self.Nf = len(self.f_vec)
print("Minimal frequency:", self.f_vec[0], ", maximum frequency:", np.max(self.f_vec))
if 0 in self.f_vec:
self.l_vec = scco.speed_of_light / self.f_vec[1:]
self.l_vec = np.concatenate(([0], self.l_vec))
else:
self.l_vec = scco.speed_of_light / self.f_vec
print("Minimal wavelength:", np.min(self.l_vec) * 1e9, ", maximum wavelength:", np.max(self.l_vec * 1e9))
self.data_vec = create_gaussian_function(self.t_vec, self.t_0)
if self.with_main_frequency:
self.data_vec *= np.exp(-1j * self.w_0 * self.t_vec)

t_min = -5e-13
t_max = 10e-13
t_0 = 1e-13
Nt = 2048

l_min = 100e-9
l_max = 10000e-9

pulse_with_frequency = pulse(Nt, t_min, t_max, l_min, l_max, t_0, l_0, True)
pulse_without_frequency = pulse(128, t_min, t_max, l_min, l_max, t_0, l_0, False)

plt.plot(pulse_with_frequency.t_vec, np.real(pulse_with_frequency.data_vec))
plt.plot(pulse_without_frequency.t_vec, np.real(pulse_without_frequency.data_vec))
plt.show()
plt.plot(pulse_with_frequency.l_vec, np.abs(np.fft.ifft(pulse_with_frequency.data_vec))[pulse_with_frequency.index_minimum_frequency:pulse_with_frequency.index_minimum_frequency + pulse_with_frequency.Nf])
plt.xlim((0, 2000e-9))
plt.show()
plt.plot(pulse_without_frequency.l_vec, (np.abs(np.fft.ifft(pulse_without_frequency.data_vec)))[pulse_without_frequency.index_minimum_frequency:pulse_without_frequency.index_minimum_frequency + pulse_without_frequency.Nf])
plt.show()


When shifting the pulse I can reduce the necessary resolution by a factor of 16 without loosing the FFT information of the envelope, but I also do not have the central frequency of the pulse anymore in self.f_vec. For future computations I would need those values, after some computations depend on the frequency/wavelength.

Therefore, how can I recalculate the involved frequencies and wavelengths to represent the pulse again, even though I removed the carrier? Or is that not possible?