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 = 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))
            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.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.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])

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?


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Browse other questions tagged or ask your own question.