simulation Namespace Reference

Classes
struct	CwPhaseNoiseBuffer
	Sampled phase-noise buffer for one timing source. More...
struct	CwPhaseNoiseLookup
	Lookup table for CW phase noise across timing sources. More...
struct	PreviewLink
	A calculated link segment for 3D visualization. More...
class	RangeError
	Exception thrown when a range calculation fails, typically due to objects being too close. More...
struct	ReResults
	Stores the intermediate results of a radar equation calculation for a single time point. More...

Enumerations
enum class	StreamingTimingPhaseMode : std::uint8_t { ReceiverRelative , TransmitterOnly , None }
	Selects how timing phase noise is applied to streaming channel contributions. More...
enum class	LinkType : std::uint8_t { Monostatic , BistaticTxTgt , BistaticTgtRx , DirectTxRx }
	Categorizes the visual link for rendering. More...
enum class	LinkQuality : std::uint8_t { Strong , Weak }
	Describes the radiometric quality of the link. More...

Functions
void	solveRe (const radar::Transmitter *trans, const radar::Receiver *recv, const radar::Target *targ, const std::chrono::duration< RealType > &time, const fers_signal::RadarSignal *wave, ReResults &results)
	Solves the bistatic radar equation for a reflected path (Tx -> Tgt -> Rx).
void	solveReDirect (const radar::Transmitter *trans, const radar::Receiver *recv, const std::chrono::duration< RealType > &time, const fers_signal::RadarSignal *wave, ReResults &results)
	Solves the radar equation for a direct path (Tx -> Rx).
ComplexType	calculateDirectPathContribution (const radar::Transmitter *trans, const radar::Receiver *recv, RealType timeK, const CwPhaseNoiseLookup *phase_noise_lookup=nullptr)
	Calculates the complex envelope contribution for a direct propagation path (Tx -> Rx) at a specific time.
ComplexType	calculateStreamingDirectPathContribution (const core::ActiveStreamingSource &source, const radar::Receiver *recv, RealType timeK, const CwPhaseNoiseLookup *phase_noise_lookup=nullptr, core::FmcwChirpBoundaryTracker *chirp_tracker=nullptr, StreamingTimingPhaseMode timing_phase_mode=StreamingTimingPhaseMode::ReceiverRelative)
	Calculates a direct-path contribution from a cached streaming source.
bool	calculateStreamingReferencePhase (const core::ActiveStreamingSource &source, RealType timeK, core::FmcwChirpBoundaryTracker *chirp_tracker, RealType &phase_out)
	Evaluates a receive-time streaming waveform phase for receiver LO/dechirp references.
ComplexType	calculateReflectedPathContribution (const radar::Transmitter *trans, const radar::Receiver *recv, const radar::Target *targ, RealType timeK, const CwPhaseNoiseLookup *phase_noise_lookup=nullptr)
	Calculates the complex envelope contribution for a reflected path (Tx -> Tgt -> Rx) at a specific time.
ComplexType	calculateStreamingReflectedPathContribution (const core::ActiveStreamingSource &source, const radar::Receiver *recv, const radar::Target *targ, RealType timeK, const CwPhaseNoiseLookup *phase_noise_lookup=nullptr, core::FmcwChirpBoundaryTracker *chirp_tracker=nullptr, StreamingTimingPhaseMode timing_phase_mode=StreamingTimingPhaseMode::ReceiverRelative)
	Calculates a reflected-path contribution from a cached streaming source.
std::unique_ptr< serial::Response >	calculateResponse (const radar::Transmitter *trans, const radar::Receiver *recv, const fers_signal::RadarSignal *signal, RealType startTime, const radar::Target *targ=nullptr)
	Creates a Response object by simulating a signal's interaction over its duration.
std::vector< PreviewLink >	calculatePreviewLinks (const core::World &world, RealType time)
	Calculates all visual links for the current world state at a specific time.

Enumeration Type Documentation

LinkQuality

enum class simulation::LinkQuality : std::uint8_t

strong

Describes the radiometric quality of the link.

Enumerator
Strong	SNR > 0 dB.
Weak	SNR < 0 dB (Geometric line of sight, but below noise floor)

Definition at line 275 of file channel_model.h.

    {
        Strong, ///< SNR > 0 dB
        Weak ///< SNR < 0 dB (Geometric line of sight, but below noise floor)
    };

LinkType

enum class simulation::LinkType : std::uint8_t

strong

Categorizes the visual link for rendering.

Enumerator
Monostatic	Combined Tx/Rx path.
BistaticTxTgt	Illuminator path.
BistaticTgtRx	Scattered path.
DirectTxRx	Interference path.

Definition at line 263 of file channel_model.h.

    {
        Monostatic, ///< Combined Tx/Rx path
        BistaticTxTgt, ///< Illuminator path
        BistaticTgtRx, ///< Scattered path
        DirectTxRx ///< Interference path
    };

StreamingTimingPhaseMode

enum class simulation::StreamingTimingPhaseMode : std::uint8_t

strong

Selects how timing phase noise is applied to streaming channel contributions.

Enumerator
ReceiverRelative	Existing raw streaming convention: transmitter phase minus receiver LO phase.
TransmitterOnly	Incoming RF/baseband signal before receiver LO subtraction.
None	Ignore timing phase noise entirely.

Definition at line 95 of file channel_model.h.

    {
        ReceiverRelative, ///< Existing raw streaming convention: transmitter phase minus receiver LO phase.
        TransmitterOnly, ///< Incoming RF/baseband signal before receiver LO subtraction.
        None ///< Ignore timing phase noise entirely.
    };

Function Documentation

calculateDirectPathContribution()

ComplexType simulation::calculateDirectPathContribution	(	const radar::Transmitter *	trans,
		const radar::Receiver *	recv,
		RealType	timeK,
		const CwPhaseNoiseLookup *	phase_noise_lookup = nullptr
	)

Calculates the complex envelope contribution for a direct propagation path (Tx -> Rx) at a specific time.

This function is used for Continuous Wave (CW) simulations.

Parameters

trans	The transmitter.
recv	The receiver.
timeK	The current simulation time.

Returns

The complex I/Q sample contribution for this path.

Definition at line 702 of file channel_model.cpp.

    {
        return calculateStreamingDirectPathContribution(makeClassicStreamingSource(trans), recv, timeK,
                                                        phase_noise_lookup);
    }

References calculateStreamingDirectPathContribution(), and max.

Here is the call graph for this function:

calculatePreviewLinks()

std::vector< PreviewLink > simulation::calculatePreviewLinks	(	const core::World &	world,
		RealType	time
	)

Calculates all visual links for the current world state at a specific time.

This function utilizes the core radar equation helpers to determine visibility, power levels, and SNR for all Tx/Rx/Target combinations. It is lightweight and does not update simulation state.

Parameters

world	The simulation world containing radar components.
time	The time at which to calculate geometry.

Returns

A vector of renderable links.

Definition at line 1122 of file channel_model.cpp.

    {
        std::vector<PreviewLink> links;
 
        for (const auto& tx : world.getTransmitters())
        {
            if (!isComponentActive(tx->getSchedule(), time))
            {
                continue;
            }
 
            const auto tx_ctx = makePreviewTransmitterContext(*tx, time);
            addIlluminatorLinks(links, tx_ctx, world, time);
 
            for (const auto& rx : world.getReceivers())
            {
                if (!isComponentActive(rx->getSchedule(), time))
                {
                    continue;
                }
                const auto rx_ctx = makePreviewReceiverContext(*rx, time);
                addReceiverLinks(links, tx_ctx, rx_ctx, world, time);
            }
        }
        return links;
    }

References core::World::getReceivers(), core::World::getTransmitters(), and max.

Referenced by fers_calculate_preview_links().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateReflectedPathContribution()

ComplexType simulation::calculateReflectedPathContribution	(	const radar::Transmitter *	trans,
		const radar::Receiver *	recv,
		const radar::Target *	targ,
		RealType	timeK,
		const CwPhaseNoiseLookup *	phase_noise_lookup = nullptr
	)

Calculates the complex envelope contribution for a reflected path (Tx -> Tgt -> Rx) at a specific time.

This function is used for Continuous Wave (CW) simulations.

Parameters

trans	The transmitter.
recv	The receiver.
targ	The target.
timeK	The current simulation time.

Returns

The complex I/Q sample contribution for this path.

Definition at line 781 of file channel_model.cpp.

    {
        return calculateStreamingReflectedPathContribution(makeClassicStreamingSource(trans), recv, targ, timeK,
                                                           phase_noise_lookup);
    }

References calculateStreamingReflectedPathContribution(), and max.

Here is the call graph for this function:

calculateResponse()

std::unique_ptr< serial::Response > simulation::calculateResponse	(	const radar::Transmitter *	trans,
		const radar::Receiver *	recv,
		const fers_signal::RadarSignal *	signal,
		RealType	startTime,
		const radar::Target *	targ = nullptr
	)

Creates a Response object by simulating a signal's interaction over its duration.

This function iterates over the duration of a transmitted pulse, calling the appropriate channel model function (solveRe or solveReDirect) at discrete time steps to generate a series of InterpPoints. These points capture the time-varying properties of the received signal and are collected into a Response object.

Parameters

trans	Pointer to the transmitter.
recv	Pointer to the receiver.
signal	Pointer to the transmitted pulse signal.
startTime	The absolute simulation time when the pulse transmission starts.
targ	Optional pointer to a target. If null, a direct path is simulated.

Returns

A unique pointer to the generated Response object.

Exceptions

RangeError	If the channel model reports an invalid geometry.
std::runtime_error	If the simulation parameters result in zero time steps.

Definition at line 864 of file channel_model.cpp.

    {
        // If calculating direct path (no target) and components are co-located:
        // 1. If explicitly attached (monostatic), skip (internal leakage handled elsewhere).
        // 2. If independent but on the same platform, distance is 0. Far-field logic (1/R^2)
        //    diverges. We skip calculation to avoid RangeError crashes, assuming
        //    no direct coupling/interference for co-located far-field antennas.
        if (targ == nullptr && (trans->getAttached() == recv || trans->getPlatform() == recv->getPlatform()))
        {
            return nullptr;
        }
 
        // If calculating reflected path and target is co-located with either Tx or Rx:
        // Skip to avoid singularity. Simulating a radar tracking its own platform
        // requires near-field clutter models, not point-target RCS models.
        if (targ != nullptr &&
            (targ->getPlatform() == trans->getPlatform() || targ->getPlatform() == recv->getPlatform()))
        {
            LOG(Level::TRACE,
                "Skipping reflected path calculation for Target {} co-located with Transmitter {} or Receiver {}",
                targ->getName(), trans->getName(), recv->getName());
            return nullptr;
        }
 
        const auto start_time_chrono = std::chrono::duration<RealType>(startTime);
        const auto end_time_chrono = start_time_chrono + std::chrono::duration<RealType>(signal->getLength());
        const auto sample_time_chrono = std::chrono::duration<RealType>(1.0 / params::simSamplingRate());
        const int point_count = static_cast<int>(std::ceil(signal->getLength() / sample_time_chrono.count()));
 
        if ((targ != nullptr) && point_count == 0)
        {
            LOG(Level::FATAL, "No time points are available for execution!");
            throw std::runtime_error("No time points are available for execution!");
        }
 
        auto response = std::make_unique<serial::Response>(signal, trans);
 
        try
        {
            for (int i = 0; i <= point_count; ++i)
            {
                const auto current_time =
                    i < point_count ? start_time_chrono + i * sample_time_chrono : end_time_chrono;
 
                ReResults results{};
                if (targ != nullptr)
                {
                    solveRe(trans, recv, targ, current_time, signal, results);
                }
                else
                {
                    solveReDirect(trans, recv, current_time, signal, results);
                }
 
                interp::InterpPoint const point{.power = results.power,
                                                .time = current_time.count() + results.delay,
                                                .delay = results.delay,
                                                .phase = results.phase};
                response->addInterpPoint(point);
            }
        }
        catch (const RangeError&)
        {
            LOG(Level::INFO, "Receiver or Transmitter too close for accurate simulation");
            throw; // Re-throw to be caught by the runner
        }
 
        return response;
    }

References LOG, max, params::simSamplingRate(), solveRe(), and solveReDirect().

Referenced by core::SimulationEngine::handleTxPulsedStart().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateStreamingDirectPathContribution()

ComplexType simulation::calculateStreamingDirectPathContribution	(	const core::ActiveStreamingSource &	source,
		const radar::Receiver *	recv,
		RealType	timeK,
		const CwPhaseNoiseLookup *	phase_noise_lookup = nullptr,
		core::FmcwChirpBoundaryTracker *	chirp_tracker = nullptr,
		StreamingTimingPhaseMode	timing_phase_mode = StreamingTimingPhaseMode::ReceiverRelative
	)

Calculates a direct-path contribution from a cached streaming source.

Parameters

source	Cached active streaming source to evaluate.
recv	Receiver observing the source.
timeK	Current receiver time in seconds.
phase_noise_lookup	Optional lookup for timing phase noise samples.
chirp_tracker	Optional caller-owned FMCW boundary tracker for this path.
timing_phase_mode	Selects how timing phase noise is applied.

Returns

The complex I/Q sample contribution for this path.

Definition at line 709 of file channel_model.cpp.

    {
        const auto* const trans = source.transmitter;
        if (trans == nullptr)
        {
            return {0.0, 0.0};
        }
        // Check for co-location to prevent singularities.
        // If they share the same platform, we assume they are isolated (no leakage) or explicit
        // monostatic handling is required (which is not modeled via the far-field path).
        if (trans->getPlatform() == recv->getPlatform())
        {
            return {0.0, 0.0};
        }
 
        const auto p_tx = trans->getPlatform()->getPosition(timeK);
        const auto p_rx = recv->getPlatform()->getPosition(timeK);
 
        LinkGeometry link;
        try
        {
            link = computeLink(p_tx, p_rx);
        }
        catch (const RangeError&)
        {
            return {0.0, 0.0};
        }
 
        const RealType tau = link.dist / params::c();
        if (source.carrier_freq <= 0.0)
        {
            return {0.0, 0.0};
        }
        const RealType lambda = params::c() / source.carrier_freq;
 
        // Tx Gain: Direction Tx -> Rx
        const RealType tx_gain = computeAntennaGain(trans, link.u_vec, timeK, lambda);
        // Rx Gain: Direction Rx -> Tx (-u_vec)
        const RealType rx_gain = computeAntennaGain(recv, -link.u_vec, timeK + tau, lambda);
 
        const bool no_loss = recv->checkFlag(Receiver::RecvFlag::FLAG_NOPROPLOSS);
        const RealType scaling_factor = computeDirectPathPower(tx_gain, rx_gain, lambda, link.dist, no_loss);
 
        // Include Signal Power
        const RealType amplitude = source.amplitude * std::sqrt(scaling_factor);
 
        // Carrier Phase
        RealType phase = 0.0;
        if (!computeStreamingPhase(source, timeK, tau, chirp_tracker, phase))
        {
            return {0.0, 0.0};
        }
        ComplexType contribution = std::polar(amplitude, phase);
 
        // Non-coherent Local Oscillator Effects
        const RealType non_coherent_phase =
            computeTimingPhase(trans, recv, timeK, timeK - tau, phase_noise_lookup, timing_phase_mode);
        contribution *= std::polar(1.0, non_coherent_phase);
 
        return contribution;
    }

References core::ActiveStreamingSource::amplitude, params::c(), core::ActiveStreamingSource::carrier_freq, lambda, max, no_loss, and core::ActiveStreamingSource::transmitter.

Referenced by processing::pipeline::applyStreamingInterference(), and calculateDirectPathContribution().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateStreamingReferencePhase()

bool simulation::calculateStreamingReferencePhase	(	const core::ActiveStreamingSource &	source,
		RealType	timeK,
		core::FmcwChirpBoundaryTracker *	chirp_tracker,
		RealType &	phase_out
	)

Evaluates a receive-time streaming waveform phase for receiver LO/dechirp references.

Parameters

source	Cached active streaming source to evaluate.
timeK	Receiver time in seconds.
chirp_tracker	Optional caller-owned FMCW boundary tracker for this source.
phase_out	Receives the waveform phase in radians when evaluation succeeds.

Returns

True when the source is active and a phase was produced.

Definition at line 775 of file channel_model.cpp.

    {
        return computeStreamingPhase(source, timeK, 0.0, chirp_tracker, phase_out);
    }

References max.

calculateStreamingReflectedPathContribution()

ComplexType simulation::calculateStreamingReflectedPathContribution	(	const core::ActiveStreamingSource &	source,
		const radar::Receiver *	recv,
		const radar::Target *	targ,
		RealType	timeK,
		const CwPhaseNoiseLookup *	phase_noise_lookup = nullptr,
		core::FmcwChirpBoundaryTracker *	chirp_tracker = nullptr,
		StreamingTimingPhaseMode	timing_phase_mode = StreamingTimingPhaseMode::ReceiverRelative
	)

Calculates a reflected-path contribution from a cached streaming source.

Parameters

source	Cached active streaming source to evaluate.
recv	Receiver observing the reflected signal.
targ	Reflecting target.
timeK	Current receiver time in seconds.
phase_noise_lookup	Optional lookup for timing phase noise samples.
chirp_tracker	Optional caller-owned FMCW boundary tracker for this path.
timing_phase_mode	Selects how timing phase noise is applied.

Returns

The complex I/Q sample contribution for this reflected path.

Definition at line 789 of file channel_model.cpp.

    {
        const auto* const trans = source.transmitter;
        if (trans == nullptr)
        {
            return {0.0, 0.0};
        }
        // Check for co-location involving the target.
        // We do not model a platform tracking itself (R=0) or illuminating itself (R=0).
        if (trans->getPlatform() == targ->getPlatform() || recv->getPlatform() == targ->getPlatform())
        {
            return {0.0, 0.0};
        }
 
        const auto p_tx = trans->getPlatform()->getPosition(timeK);
        const auto p_rx = recv->getPlatform()->getPosition(timeK);
        const auto p_tgt = targ->getPlatform()->getPosition(timeK);
 
        LinkGeometry link_tx_tgt;
        LinkGeometry link_tgt_rx;
 
        try
        {
            link_tx_tgt = computeLink(p_tx, p_tgt);
            link_tgt_rx = computeLink(p_tgt, p_rx);
        }
        catch (const RangeError&)
        {
            return {0.0, 0.0};
        }
 
        const RealType tau = (link_tx_tgt.dist + link_tgt_rx.dist) / params::c();
        if (source.carrier_freq <= 0.0)
        {
            return {0.0, 0.0};
        }
        const RealType lambda = params::c() / source.carrier_freq;
 
        // RCS Lookups: In (Tx->Tgt), Out (Rx->Tgt = - (Tgt->Rx))
        SVec3 in_angle(link_tx_tgt.u_vec);
        SVec3 out_angle(-link_tgt_rx.u_vec);
        const RealType rcs = targ->getRcs(in_angle, out_angle, timeK);
 
        // Tx Gain: Direction Tx -> Tgt
        const RealType tx_gain = computeAntennaGain(trans, link_tx_tgt.u_vec, timeK, lambda);
        // Rx Gain: Direction Rx -> Tgt (- (Tgt->Rx)). Time: timeK + tau.
        const RealType rx_gain = computeAntennaGain(recv, -link_tgt_rx.u_vec, timeK + tau, lambda);
 
        const bool no_loss = recv->checkFlag(Receiver::RecvFlag::FLAG_NOPROPLOSS);
        const RealType scaling_factor =
            computeReflectedPathPower(tx_gain, rx_gain, rcs, lambda, link_tx_tgt.dist, link_tgt_rx.dist, no_loss);
 
        // Include Signal Power
        const RealType amplitude = source.amplitude * std::sqrt(scaling_factor);
 
        RealType phase = 0.0;
        if (!computeStreamingPhase(source, timeK, tau, chirp_tracker, phase))
        {
            return {0.0, 0.0};
        }
        ComplexType contribution = std::polar(amplitude, phase);
 
        // Non-coherent Local Oscillator Effects
        const RealType non_coherent_phase =
            computeTimingPhase(trans, recv, timeK, timeK - tau, phase_noise_lookup, timing_phase_mode);
        contribution *= std::polar(1.0, non_coherent_phase);
 
        return contribution;
    }

References core::ActiveStreamingSource::amplitude, params::c(), core::ActiveStreamingSource::carrier_freq, lambda, max, no_loss, and core::ActiveStreamingSource::transmitter.

Referenced by processing::pipeline::applyStreamingInterference(), and calculateReflectedPathContribution().

Here is the call graph for this function:

Here is the caller graph for this function:

solveRe()

void simulation::solveRe	(	const radar::Transmitter *	trans,
		const radar::Receiver *	recv,
		const radar::Target *	targ,
		const std::chrono::duration< RealType > &	time,
		const fers_signal::RadarSignal *	wave,
		ReResults &	results
	)

Solves the bistatic radar equation for a reflected path (Tx -> Tgt -> Rx).

This function calculates the signal properties (power, delay, phase) for a signal traveling from a transmitter, reflecting off a target, and arriving at a receiver. It accounts for antenna gains, target RCS, and propagation loss.

Parameters

trans	Pointer to the transmitter.
recv	Pointer to the receiver.
targ	Pointer to the target.
time	The time at which the pulse is transmitted.
wave	Pointer to the transmitted radar signal.
results	Output struct to store the calculation results.

Exceptions

RangeError

If the target is too close to the transmitter or receiver.

Definition at line 612 of file channel_model.cpp.

    {
        // Note: RangeError log messages are handled by the original catch block in calculateResponse
        // or explicitly here if strict adherence to original logging is required.
        // Using the helper logic which throws RangeError on epsilon check.
 
        const RealType t_val = time.count();
        const auto p_tx = trans->getPosition(t_val);
        const auto p_rx = recv->getPosition(t_val);
        const auto p_tgt = targ->getPosition(t_val);
 
        // Link 1: Tx -> Target
        LinkGeometry link_tx_tgt;
        // Link 2: Target -> Rx (Note: Vector for calculation is Tgt->Rx)
        LinkGeometry link_tgt_rx;
 
        try
        {
            link_tx_tgt = computeLink(p_tx, p_tgt);
            link_tgt_rx = computeLink(p_tgt, p_rx); // Vector Tgt -> Rx
        }
        catch (const RangeError&)
        {
            LOG(Level::INFO, "Transmitter or Receiver too close to Target for accurate simulation");
            throw;
        }
 
        results.delay = (link_tx_tgt.dist + link_tgt_rx.dist) / params::c();
 
        // Calculate RCS
        // Note: getRcs expects (InAngle, OutAngle).
        // InAngle: Tx -> Tgt (link_tx_tgt.u_vec)
        // OutAngle: Rx -> Tgt (Opposite of Tgt->Rx, so -link_tgt_rx.u_vec)
        // This matches existing logic.
        SVec3 in_angle(link_tx_tgt.u_vec);
        SVec3 out_angle(-link_tgt_rx.u_vec);
        const auto rcs = targ->getRcs(in_angle, out_angle, t_val);
 
        const auto wavelength = params::c() / wave->getCarrier();
 
        // Tx Gain: Direction Tx -> Tgt
        const auto tx_gain = computeAntennaGain(trans, link_tx_tgt.u_vec, t_val, wavelength);
        // Rx Gain: Direction Rx -> Tgt (Opposite of Tgt->Rx).
        // Time is time + delay.
        const auto rx_gain = computeAntennaGain(recv, -link_tgt_rx.u_vec, results.delay + t_val, wavelength);
 
        const bool no_loss = recv->checkFlag(Receiver::RecvFlag::FLAG_NOPROPLOSS);
        results.power =
            computeReflectedPathPower(tx_gain, rx_gain, rcs, wavelength, link_tx_tgt.dist, link_tgt_rx.dist, no_loss);
 
        results.phase = -results.delay * 2 * PI * wave->getCarrier();
    }

References params::c(), LOG, max, no_loss, and PI.

Referenced by calculateResponse().

Here is the call graph for this function:

Here is the caller graph for this function:

solveReDirect()

void simulation::solveReDirect	(	const radar::Transmitter *	trans,
		const radar::Receiver *	recv,
		const std::chrono::duration< RealType > &	time,
		const fers_signal::RadarSignal *	wave,
		ReResults &	results
	)

Solves the radar equation for a direct path (Tx -> Rx).

This function calculates the signal properties for a direct line-of-sight signal traveling from a transmitter to a receiver.

Parameters

trans	Pointer to the transmitter.
recv	Pointer to the receiver.
time	The time at which the pulse is transmitted.
wave	Pointer to the transmitted radar signal.
results	Output struct to store the calculation results.

Exceptions

RangeError

If the transmitter and receiver are too close.

Definition at line 666 of file channel_model.cpp.

    {
        const RealType t_val = time.count();
        const auto p_tx = trans->getPosition(t_val);
        const auto p_rx = recv->getPosition(t_val);
 
        LinkGeometry link;
        try
        {
            link = computeLink(p_tx, p_rx); // Vector Tx -> Rx
        }
        catch (const RangeError&)
        {
            LOG(Level::INFO, "Transmitter or Receiver too close for accurate simulation");
            throw;
        }
 
        results.delay = link.dist / params::c();
        const RealType wavelength = params::c() / wave->getCarrier();
 
        // Discrepancy Fix: Original code used (Rx - Tx) for Receiver Gain but (Tx - Rx) logic for Transmitter gain
        // was ambiguous/incorrect (using `tpos - rpos` which is Rx->Tx).
        // Per `calculateDirectPathContribution` preference:
        // Tx Gain uses Vector Tx -> Rx.
        // Rx Gain uses Vector Rx -> Tx.
 
        const auto tx_gain = computeAntennaGain(trans, link.u_vec, t_val, wavelength);
        const auto rx_gain = computeAntennaGain(recv, -link.u_vec, t_val + results.delay, wavelength);
 
        const bool no_loss = recv->checkFlag(Receiver::RecvFlag::FLAG_NOPROPLOSS);
        results.power = computeDirectPathPower(tx_gain, rx_gain, wavelength, link.dist, no_loss);
 
        results.phase = -results.delay * 2 * PI * wave->getCarrier();
    }

References params::c(), LOG, max, no_loss, and PI.

Referenced by calculateResponse().

Here is the call graph for this function:

Here is the caller graph for this function: