processing::pipeline Namespace Reference

Functions
void	advanceTimingModel (timing::Timing *timing_model, const radar::Receiver *receiver, RealType rate)
	Advances the receiver's timing model to the start of the next processing window.
std::tuple< RealType, RealType >	calculateJitteredStart (RealType ideal_start, RealType first_phase_noise, RealType carrier_freq, RealType rate)
	Calculates the jittered start time and fractional delay from a phase noise sample.
void	applyCwInterference (std::span< ComplexType > window, RealType actual_start, RealType dt, const radar::Receiver *receiver, const std::vector< radar::Transmitter * > &cw_sources, const std::vector< std::unique_ptr< radar::Target > > *targets)
	Applies continuous-wave interference to a time window.
void	applyPulsedInterference (std::vector< ComplexType > &iq_buffer, const std::vector< std::unique_ptr< serial::Response > > &interference_log)
	Renders and applies pulsed interference to a continuous-wave IQ buffer.
void	addPhaseNoiseToWindow (std::span< const RealType > noise, std::span< ComplexType > window)
	Applies a pre-generated sequence of phase noise samples to an I/Q buffer.
RealType	applyDownsamplingAndQuantization (std::vector< ComplexType > &buffer)
	Downsamples and quantizes an IQ buffer.
void	exportCwToHdf5 (const std::string &filename, const std::vector< ComplexType > &iq_buffer, RealType fullscale, RealType ref_freq, const core::OutputFileMetadata *metadata=nullptr)
	Exports a finalized continuous-wave IQ buffer to an HDF5 file.

Function Documentation

addPhaseNoiseToWindow()

void processing::pipeline::addPhaseNoiseToWindow	(	std::span< const RealType >	noise,
		std::span< ComplexType >	window
	)

Applies a pre-generated sequence of phase noise samples to an I/Q buffer.

This function performs the complex multiplication IQ_out = IQ_in * e^(j*phase_noise) for each sample in the window, effectively modulating the phase of the signal.

Parameters

noise	A span of phase noise samples in radians.
window	The I/Q buffer to be modified.

Definition at line 124 of file finalizer_pipeline.cpp.

    {
        for (auto [n, w] : std::views::zip(noise, window))
        {
            w *= std::polar(1.0, n);
        }
    }

Referenced by processing::finalizeCwReceiver(), and processing::runPulsedFinalizer().

Here is the caller graph for this function:

advanceTimingModel()

void processing::pipeline::advanceTimingModel	(	timing::Timing *	timing_model,
		const radar::Receiver *	receiver,
		RealType	rate
	)

Advances the receiver's timing model to the start of the next processing window.

This function handles the "dead time" between receive windows. For sync-on-pulse models, it resets the phase and skips to the window's start offset. For free-running models, it skips the number of samples corresponding to the inter-pulse period.

Parameters

timing_model	The stateful timing model instance to advance.
receiver	The receiver whose properties (sync mode, PRF, etc.) determine how to advance the model.
rate	The oversampled simulation rate, used to calculate samples to skip.

Definition at line 29 of file finalizer_pipeline.cpp.

    {
 
        if ((timing_model == nullptr) || !timing_model->isEnabled())
        {
            return;
        }
 
        // Convert the duration-derived sample advance to a signed temporary first.
        // The physical calculation can legitimately produce a negative or zero result
        // (for example due to floor() or an inter-pulse gap that is not positive),
        // but skipSamples() models advancing by a non-negative sample count only.
        // After validating that the computed value is > 0, cast to std::size_t for
        // the skipSamples() call chain:
        //   Timing::skipSamples -> ClockModelGenerator::skipSamples ->
        //   MultirateGenerator::skipSamples.
        // This preserves the sign until validation and avoids passing invalid negative
        // counts into the timing/noise generators.
        if (timing_model->getSyncOnPulse())
        {
            timing_model->reset();
            const auto skip_samples = static_cast<long long>(std::floor(rate * receiver->getWindowSkip()));
            if (skip_samples > 0)
            {
                timing_model->skipSamples(static_cast<std::size_t>(skip_samples));
            }
        }
        else
        {
            const RealType inter_pulse_skip_duration = 1.0 / receiver->getWindowPrf() - receiver->getWindowLength();
            const auto samples_to_skip = static_cast<long long>(std::floor(rate * inter_pulse_skip_duration));
            if (samples_to_skip > 0)
            {
                timing_model->skipSamples(static_cast<std::size_t>(samples_to_skip));
            }
        }
    }

References timing::Timing::getSyncOnPulse(), radar::Receiver::getWindowLength(), radar::Receiver::getWindowPrf(), radar::Receiver::getWindowSkip(), timing::Timing::isEnabled(), timing::Timing::reset(), and timing::Timing::skipSamples().

Referenced by processing::runPulsedFinalizer().

Here is the call graph for this function:

Here is the caller graph for this function:

applyCwInterference()

void processing::pipeline::applyCwInterference	(	std::span< ComplexType >	window,
		RealType	actual_start,
		RealType	dt,
		const radar::Receiver *	receiver,
		const std::vector< radar::Transmitter * > &	cw_sources,
		const std::vector< std::unique_ptr< radar::Target > > *	targets
	)

Applies continuous-wave interference to a time window.

Iterates through each sample of a processing window, calculating the combined direct and reflected path contributions from all active CW sources at that precise moment in time. The resulting complex sample is added to the window.

Parameters

window	The I/Q buffer for the receive window to which interference will be added.
actual_start	The jittered, sample-aligned start time of the window.
dt	The time step between samples (1.0 / rate).
receiver	The receiver being interfered with.
cw_sources	A list of currently active CW transmitters.
targets	The list of all targets for calculating reflected paths.

Definition at line 76 of file finalizer_pipeline.cpp.

    {
        RealType t_sample = actual_start;
        for (auto& window_sample : window)
        {
            ComplexType cw_interference_sample{0.0, 0.0};
            for (const auto* cw_source : cw_sources)
            {
                if (!receiver->checkFlag(radar::Receiver::RecvFlag::FLAG_NODIRECT))
                {
                    cw_interference_sample +=
                        simulation::calculateDirectPathContribution(cw_source, receiver, t_sample);
                }
                for (const auto& target_ptr : *targets)
                {
                    cw_interference_sample +=
                        simulation::calculateReflectedPathContribution(cw_source, receiver, target_ptr.get(), t_sample);
                }
            }
            window_sample += cw_interference_sample;
            t_sample += dt;
        }
    }

References simulation::calculateDirectPathContribution(), simulation::calculateReflectedPathContribution(), radar::Receiver::checkFlag(), and radar::Receiver::FLAG_NODIRECT.

Referenced by processing::runPulsedFinalizer().

Here is the call graph for this function:

Here is the caller graph for this function:

applyDownsamplingAndQuantization()

RealType processing::pipeline::applyDownsamplingAndQuantization

(

std::vector< ComplexType > &

buffer

)

Downsamples and quantizes an IQ buffer.

This function performs the final processing steps. If oversampling is enabled, it first downsamples the buffer to the final output rate. It then simulates an ADC by quantizing and scaling the data.

Parameters

buffer

The I/Q buffer to be processed. This is an in-out parameter; it will be replaced by the downsampled buffer if applicable.

Returns

The full-scale value (RealType) calculated during quantization, which is needed for HDF5 metadata.

Definition at line 132 of file finalizer_pipeline.cpp.

    {
        if (params::oversampleRatio() > 1)
        {
            buffer = std::move(fers_signal::downsample(buffer));
        }
        return quantizeAndScaleWindow(buffer);
    }

References fers_signal::downsample(), params::oversampleRatio(), and processing::quantizeAndScaleWindow().

Referenced by processing::finalizeCwReceiver(), and processing::runPulsedFinalizer().

Here is the call graph for this function:

Here is the caller graph for this function:

applyPulsedInterference()

void processing::pipeline::applyPulsedInterference	(	std::vector< ComplexType > &	iq_buffer,
		const std::vector< std::unique_ptr< serial::Response > > &	interference_log
	)

Renders and applies pulsed interference to a continuous-wave IQ buffer.

Processes a log of Response objects that represent pulsed signals received during a CW receiver's operation. Each response is rendered into a temporary buffer and then added to the main CW IQ buffer at the correct time offset.

Parameters

iq_buffer	The main, simulation-long IQ buffer for the CW receiver.
interference_log	A list of Response objects representing the pulsed interference.

Definition at line 102 of file finalizer_pipeline.cpp.

    {
        for (const auto& response : interference_log)
        {
            unsigned psize;
            RealType prate;
            const auto rendered_pulse = response->renderBinary(prate, psize, 0.0);
 
            const RealType dt_sim = 1.0 / prate;
            const auto start_index = static_cast<size_t>((response->startTime() - params::startTime()) / dt_sim);
 
            for (size_t i = 0; i < psize; ++i)
            {
                if (start_index + i < iq_buffer.size())
                {
                    iq_buffer[start_index + i] += rendered_pulse[i];
                }
            }
        }
    }

References params::startTime().

Referenced by processing::finalizeCwReceiver().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateJitteredStart()

std::tuple< RealType, RealType > processing::pipeline::calculateJitteredStart	(	RealType	ideal_start,
		RealType	first_phase_noise,
		RealType	carrier_freq,
		RealType	rate
	)

Calculates the jittered start time and fractional delay from a phase noise sample.

Converts the first phase noise sample (in radians) of a window into a time jitter offset. It then decomposes the resulting "actual" start time into a component aligned with the sample clock and a fractional delay to be handled by the rendering engine's interpolation filter.

Parameters

ideal_start	The perfect, jitter-free start time of the window.
first_phase_noise	The first phase noise sample (radians) for this window.
carrier_freq	The carrier frequency, needed to convert phase to time.
rate	The sampling rate, used for sample clock alignment.

Returns

A tuple containing:

1. The sample-aligned start time (RealType).
2. The fractional sample delay (RealType).

Definition at line 67 of file finalizer_pipeline.cpp.

    {
        const RealType actual_start = ideal_start + first_phase_noise / (2.0 * PI * carrier_freq);
        const RealType rounded_start = std::round(actual_start * rate) / rate;
        const RealType fractional_delay = actual_start * rate - std::round(actual_start * rate);
        return {rounded_start, fractional_delay};
    }

References PI.

Referenced by processing::runPulsedFinalizer().

Here is the caller graph for this function:

exportCwToHdf5()

void processing::pipeline::exportCwToHdf5	(	const std::string &	filename,
		const std::vector< ComplexType > &	iq_buffer,
		RealType	fullscale,
		RealType	ref_freq,
		const core::OutputFileMetadata *	metadata = nullptr
	)

Exports a finalized continuous-wave IQ buffer to an HDF5 file.

Creates an HDF5 file, splits the complex buffer into real (I) and imaginary (Q) components, writes them as separate datasets, and adds relevant simulation parameters (sample rate, start time, etc.) as file attributes.

Parameters

filename	The path to the output HDF5 file.
iq_buffer	The final, processed I/Q data to write.
fullscale	The full-scale value from quantization, saved as metadata.
ref_freq	The reference carrier frequency, saved as metadata.

Definition at line 141 of file finalizer_pipeline.cpp.

    {
        std::scoped_lock lock(serial::hdf5_global_mutex);
        try
        {
            HighFive::File file(filename, HighFive::File::Truncate);
 
            std::vector<RealType> i_data(iq_buffer.size());
            std::vector<RealType> q_data(iq_buffer.size());
            std::ranges::transform(iq_buffer, i_data.begin(), [](const auto& c) { return c.real(); });
            std::ranges::transform(iq_buffer, q_data.begin(), [](const auto& c) { return c.imag(); });
 
            HighFive::DataSet i_dataset = file.createDataSet<RealType>("I_data", HighFive::DataSpace::From(i_data));
            i_dataset.write(i_data);
            HighFive::DataSet q_dataset = file.createDataSet<RealType>("Q_data", HighFive::DataSpace::From(q_data));
            q_dataset.write(q_data);
 
            file.createAttribute("sampling_rate", params::rate());
            file.createAttribute("start_time", params::startTime());
            file.createAttribute("fullscale", fullscale);
            file.createAttribute("reference_carrier_frequency", ref_freq);
            if (metadata != nullptr)
            {
                serial::writeOutputFileMetadataAttributes(file, *metadata);
            }
 
            LOG(logging::Level::INFO, "Successfully exported CW data to '{}'", filename);
        }
        catch (const HighFive::Exception& err)
        {
            LOG(logging::Level::FATAL, "Error writing CW data to HDF5 file '{}': {}", filename, err.what());
        }
    }

References logging::FATAL, serial::hdf5_global_mutex, logging::INFO, LOG, params::rate(), params::startTime(), and serial::writeOutputFileMetadataAttributes().

Referenced by processing::finalizeCwReceiver().

Here is the call graph for this function:

Here is the caller graph for this function: