C++ Computing Ambiguity Function for Radar Waveform Analysis

Question

I'm computing the ambiguity function of a LFM waveform.

This is the method:

std::vector<std::vector<double>> Waveform::AmbiguityFunction(std::vector<std::complex<double>>&                    signal) {
    int size = signal.size() ; 
    // Compute FFT of the original signal

    std::vector<std::complex<double>> fftResultOriginal = FFT(signal);

    // Initialize the ambiguity matrix
    std::vector<std::vector<double>> ambiguity(size, std::vector<double>(size, 0.0));

    for (int m = 0; m < size; ++m) { // iterate through all delays m
        // Generate delayed signal
        std::vector<std::complex<double>> delayedSignal(size, 0.0);
        for (int k = 0; k < size; ++k) {
            delayedSignal[k] = signal[k] * std::polar(1.0, -2.0 * M_PI * m * k / size);

        }

        // Compute FFT of the delayed signal
        std::vector<std::complex<double>> fftResultDelayed = FFT(delayedSignal);

        // Element-wise multiplication
        std::vector<std::complex<double>> product(size);
        for (int i = 0; i < size; ++i) {
            product[i] = fftResultOriginal[i] * std::conj(fftResultDelayed[i]);
        }

        // Inverse FFT
        std::vector<std::complex<double>> ifftResult = IFFT(product);

        // Retrieve the real part and compute magnitude
        for (int n = 0; n < size; ++n) {
            ambiguity[m][n] = std::norm(ifftResult[n]);
        }
    }

    return ambiguity;
} 

Instead of giving me something like this:

it's giving me this:

It seems like something is off with the delay line but i can't figure it out. I've also tried to plot in python with the output data and the result is the same, so it's not a plotting issue.

The FFT and IFFT methods:

// ---------------------------------------- IFFT METHOD --------------------------------------------------------------
std::vector<std::complex<double>> Waveform::IFFT(std::vector<std::complex<double>>& fftResultVector) {
    // Ensure input vector is not empty
    if (fftResultVector.empty()) {
        return {};
    }

    // Perform IFFT using Eigen
    Eigen::FFT<double> fft;

    // Convert input vector to Eigen type
    /*Eigen::VectorXcd inputEigen(fftResultVector.size());
    for (int i = 0; i < fftResultVector.size(); ++i) {
        inputEigen(i) = fftResultVector[i];
    }*/
    // Convert input vector to Eigen type using Eigen::Map
    Eigen::VectorXcd inputEigen = Eigen::Map<Eigen::VectorXcd>(fftResultVector.data(), fftResultVector.size());


    // Perform IFFT
    Eigen::VectorXcd ifftResultEigen = fft.inv(inputEigen);

    // Perform FFT shift
    //ifftResultEigen.segment(0, ifftResultEigen.size() / 2).swap(ifftResultEigen.segment(ifftResultEigen.size() / 2, ifftResultEigen.size() / 2));


    // Convert Eigen result back to std::vector
    std::vector<std::complex<double>> ifftVec(ifftResultEigen.data(), ifftResultEigen.data() + ifftResultEigen.size());

    return ifftVec;
}

// ---------------------------------------- FFT METHOD --------------------------------------------------------------
std::vector<std::complex<double>> Waveform::FFT(std::vector<std::complex<double>>& WfmVector) {
    // Ensure input vector is not empty
    if (WfmVector.empty()) {
        return {};
    }

    // Perform FFT using Eigen
    Eigen::FFT<double> fft;

    // Convert input vector to Eigen type
    Eigen::VectorXcd inputEigen(WfmVector.size());
    for (int i = 0; i < WfmVector.size(); ++i) {
        inputEigen(i) = WfmVector[i];
    }

    // Perform FFT
    Eigen::VectorXcd fftResultEigen = fft.fwd(inputEigen);

    
    // Perform FFT shift
    //fftResultEigen.segment(0, fftResultEigen.size() / 2).swap(fftResultEigen.segment(fftResultEigen.size() / 2, fftResultEigen.size() / 2));


    // Convert Eigen result back to std::vector
    std::vector<std::complex<double>> fftVec(fftResultEigen.data(), fftResultEigen.data() + fftResultEigen.size());

    return fftVec;
}

Tried changing the delay line and plotting in other languages.