simulation Namespace Reference

Classes
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	LinkType { Monostatic , BistaticTxTgt , BistaticTgtRx , DirectTxRx }
	Categorizes the visual link for rendering. More...
enum class	LinkQuality { 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)
	Calculates the complex envelope contribution for a direct propagation path (Tx -> Rx) at a specific time.
ComplexType	calculateReflectedPathContribution (const radar::Transmitter *trans, const radar::Receiver *recv, const radar::Target *targ, RealType timeK)
	Calculates the complex envelope contribution for a reflected path (Tx -> Tgt -> Rx) at a specific time.
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

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 178 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

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 166 of file channel_model.h.

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

Function Documentation

calculateDirectPathContribution()

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

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 314 of file channel_model.cpp.

    {
        // 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();
        const auto signal = trans->getSignal();
        const RealType carrier_freq = signal->getCarrier();
        const RealType lambda = params::c() / 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 = std::sqrt(signal->getPower() * scaling_factor);
 
        // Carrier Phase
        const RealType phase = -2 * PI * carrier_freq * tau;
        ComplexType contribution = std::polar(amplitude, phase);
 
        // Non-coherent Local Oscillator Effects
        const RealType non_coherent_phase = computeTimingPhase(trans, recv, timeK);
        contribution *= std::polar(1.0, non_coherent_phase);
 
        return contribution;
    }

References params::c(), radar::Receiver::checkFlag(), fers_signal::RadarSignal::getCarrier(), radar::Object::getPlatform(), radar::Platform::getPosition(), radar::Transmitter::getSignal(), and PI.

Referenced by core::runEventDrivenSim(), and processing::runPulsedFinalizer().

Here is the call graph for this function:

Here is the caller 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 497 of file channel_model.cpp.

    {
        std::vector<PreviewLink> links;
 
        // Default wavelength (1GHz) if no waveform is attached, to allow geometric visualization
        const RealType lambda_default = 0.3;
 
        for (const auto& tx : world.getTransmitters())
        {
            // 1. Check Transmitter Schedule
            if (!isComponentActive(tx->getSchedule(), time))
            {
                continue;
            }
 
            const auto p_tx = tx->getPosition(time);
            const auto* waveform = tx->getSignal();
            const RealType pt = waveform ? waveform->getPower() : 0.0;
            const RealType lambda = waveform ? (params::c() / waveform->getCarrier()) : lambda_default;
 
            // --- PRE-CALCULATE ILLUMINATOR PATHS (Tx -> Tgt) ---
            // These depend only on the Transmitter and Targets. We calculate them once per Tx
            // to avoid duplication when multiple receivers are present.
            // We do NOT filter out Monostatic transmitters here. Even in a monostatic setup,
            // the "Illuminator" link provides distinct info (Power Density at Target) compared
            // to the "Monostatic" link (Received Power at Rx). By being outside the Rx loop,
            // it is guaranteed to be unique per Target.
            for (const auto& tgt : world.getTargets())
            {
                const auto p_tgt = tgt->getPosition(time);
                const Vec3 vec_tx_tgt = p_tgt - p_tx;
                const RealType r1 = vec_tx_tgt.length();
 
                if (r1 <= EPSILON)
                    continue;
 
                const Vec3 u_tx_tgt = vec_tx_tgt / r1;
                // Tx Gain: Tx -> Tgt
                const RealType gt = computeAntennaGain(tx.get(), u_tx_tgt, time, lambda);
 
                // Power Density at Target: S = (Pt * Gt) / (4 * pi * R1^2)
                const RealType p_density = (pt * gt) / (4.0 * PI * r1 * r1);
 
                links.push_back({.type = LinkType::BistaticTxTgt,
                                 .quality = LinkQuality::Strong,
                                 .label = std::format("{:.1f} dBW/m\u00B2", wattsToDb(p_density)),
                                 .source_name = tx->getName(),
                                 .dest_name = tgt->getName(),
                                 .origin_name = tx->getName()});
            }
 
            for (const auto& rx : world.getReceivers())
            {
                // 2. Check Receiver Schedule
                if (!isComponentActive(rx->getSchedule(), time))
                {
                    continue;
                }
 
                const auto p_rx = rx->getPosition(time);
                const bool is_monostatic = (tx->getAttached() == rx.get());
                const bool no_loss = rx->checkFlag(Receiver::RecvFlag::FLAG_NOPROPLOSS);
 
                if (is_monostatic)
                {
                    // --- Monostatic Case ---
                    // Calculates the round-trip Received Power (dBm)
                    for (const auto& tgt : world.getTargets())
                    {
                        const auto p_tgt = tgt->getPosition(time);
 
                        // Use computeLink helper logic, but catch exception manually by checking dist
                        // to avoid try/catch overhead in render loop
                        const Vec3 vec_tx_tgt = p_tgt - p_tx;
                        const RealType dist = vec_tx_tgt.length();
 
                        if (dist <= EPSILON)
                            continue;
 
                        const Vec3 u_tx_tgt = vec_tx_tgt / dist; // Unit vec Tx -> Tgt
 
                        // Reusing internal helpers
                        // Tx Gain: Direction Tx -> Tgt
                        const RealType gt = computeAntennaGain(tx.get(), u_tx_tgt, time, lambda);
                        // Rx Gain: Direction Rx -> Tgt (which is -u_tx_tgt because Rx is at Tx)
                        const RealType gr = computeAntennaGain(rx.get(), u_tx_tgt, time, lambda);
 
                        // RCS: In = Tx->Tgt, Out = Tgt->Rx (which is -(Tx->Tgt))
                        SVec3 in_angle(u_tx_tgt);
                        SVec3 out_angle(-u_tx_tgt);
                        const RealType rcs = tgt->getRcs(in_angle, out_angle, time);
 
                        // Reusing Reflected Path Helper
                        // r_tx = dist, r_rx = dist
                        const RealType power_ratio =
                            computeReflectedPathPower(gt, gr, rcs, lambda, dist, dist, no_loss);
 
                        const RealType pr_watts = pt * power_ratio;
 
                        links.push_back(
                            {.type = LinkType::Monostatic,
                             .quality = isSignalStrong(pr_watts, rx->getNoiseTemperature()) ? LinkQuality::Strong
                                                                                            : LinkQuality::Weak,
                             .label = std::format("{:.1f} dBm (RCS: {:.1f}m\u00B2)", wattsToDbm(pr_watts), rcs),
                             .source_name = tx->getName(), // Monostatic implies Tx/Rx is same platform/system
                             .dest_name = tgt->getName(),
                             .origin_name = tx->getName()});
                    }
                }
                else
                {
                    // --- Bistatic Case ---
 
                    // 1. Direct Path (Interference)
                    if (!rx->checkFlag(Receiver::RecvFlag::FLAG_NODIRECT))
                    {
                        const Vec3 vec_direct = p_rx - p_tx;
                        const RealType dist = vec_direct.length();
 
                        if (dist > EPSILON)
                        {
                            const Vec3 u_tx_rx = vec_direct / dist;
 
                            // Tx Gain: Tx -> Rx
                            const RealType gt = computeAntennaGain(tx.get(), u_tx_rx, time, lambda);
                            // Rx Gain: Rx -> Tx (which is -u_tx_rx)
                            const RealType gr = computeAntennaGain(rx.get(), -u_tx_rx, time, lambda);
 
                            const RealType power_ratio = computeDirectPathPower(gt, gr, lambda, dist, no_loss);
                            const RealType pr_watts = pt * power_ratio;
 
                            links.push_back({.type = LinkType::DirectTxRx,
                                             .quality = LinkQuality::Strong,
                                             .label = std::format("Direct: {:.1f} dBm", wattsToDbm(pr_watts)),
                                             .source_name = tx->getName(),
                                             .dest_name = rx->getName(),
                                             .origin_name = tx->getName()});
                        }
                    }
 
                    // 2. Reflected Path (Scattered Leg: Tgt -> Rx)
                    for (const auto& tgt : world.getTargets())
                    {
                        const auto p_tgt = tgt->getPosition(time);
                        const Vec3 vec_tx_tgt = p_tgt - p_tx;
                        const Vec3 vec_tgt_rx = p_rx - p_tgt; // Vector Tgt -> Rx
 
                        const RealType r1 = vec_tx_tgt.length();
                        const RealType r2 = vec_tgt_rx.length();
 
                        if (r1 <= EPSILON || r2 <= EPSILON)
                            continue;
 
                        const Vec3 u_tx_tgt = vec_tx_tgt / r1;
                        const Vec3 u_tgt_rx = vec_tgt_rx / r2;
 
                        // Tx Gain: Tx -> Tgt
                        const RealType gt = computeAntennaGain(tx.get(), u_tx_tgt, time, lambda);
                        // Rx Gain: Rx -> Tgt (Vector is Tgt->Rx, so look vector is -u_tgt_rx)
                        const RealType gr = computeAntennaGain(rx.get(), -u_tgt_rx, time, lambda);
 
                        // RCS
                        SVec3 in_angle(u_tx_tgt);
                        SVec3 out_angle(-u_tgt_rx); // Out angle is usually defined from Target OUTWARDS
                        const RealType rcs = tgt->getRcs(in_angle, out_angle, time);
 
                        const RealType power_ratio = computeReflectedPathPower(gt, gr, rcs, lambda, r1, r2, no_loss);
                        const RealType pr_watts = pt * power_ratio;
 
                        // Note: Illuminator leg (Tx->Tgt) was handled in the outer loop.
 
                        // Leg 2: Scattered
                        links.push_back({.type = LinkType::BistaticTgtRx,
                                         .quality = isSignalStrong(pr_watts, rx->getNoiseTemperature())
                                             ? LinkQuality::Strong
                                             : LinkQuality::Weak,
                                         .label = std::format("{:.1f} dBm", wattsToDbm(pr_watts)),
                                         .source_name = tgt->getName(),
                                         .dest_name = rx->getName(),
                                         .origin_name = tx->getName()});
                    }
                }
            }
        }
        return links;
    }

References BistaticTgtRx, BistaticTxTgt, params::c(), radar::Receiver::checkFlag(), DirectTxRx, EPSILON, radar::Radar::getAttached(), radar::Object::getName(), radar::Receiver::getNoiseTemperature(), radar::Object::getPosition(), fers_signal::RadarSignal::getPower(), core::World::getReceivers(), radar::Receiver::getSchedule(), radar::Transmitter::getSchedule(), radar::Transmitter::getSignal(), core::World::getTargets(), core::World::getTransmitters(), math::Vec3::length(), Monostatic, PI, Strong, and Weak.

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
	)

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 364 of file channel_model.cpp.

    {
        // 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();
        const auto signal = trans->getSignal();
        const RealType carrier_freq = signal->getCarrier();
        const RealType lambda = params::c() / 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 = std::sqrt(signal->getPower() * scaling_factor);
 
        const RealType phase = -2 * PI * carrier_freq * tau;
        ComplexType contribution = std::polar(amplitude, phase);
 
        // Non-coherent Local Oscillator Effects
        const RealType non_coherent_phase = computeTimingPhase(trans, recv, timeK);
        contribution *= std::polar(1.0, non_coherent_phase);
 
        return contribution;
    }

References params::c(), radar::Receiver::checkFlag(), fers_signal::RadarSignal::getCarrier(), radar::Object::getPlatform(), radar::Platform::getPosition(), radar::Target::getRcs(), radar::Transmitter::getSignal(), and PI.

Referenced by core::runEventDrivenSim(), and processing::runPulsedFinalizer().

Here is the call graph for this function:

Here is the caller 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 423 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()))
        {
            LOG(Level::TRACE, "Skipping direct path calculation for co-located Transmitter {} and Receiver {}",
                trans->getName(), recv->getName());
            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 && 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)
                {
                    solveRe(trans, recv, targ, current_time, signal, results);
                }
                else
                {
                    solveReDirect(trans, recv, current_time, signal, results);
                }
 
                interp::InterpPoint point{.power = results.power,
                                          .time = current_time.count() + results.delay,
                                          .delay = results.delay,
                                          .phase = results.phase};
                response->addInterpPoint(point);
            }
        }
        catch (const RangeError&)
        {
            LOG(Level::FATAL, "Receiver or Transmitter too close for accurate simulation");
            throw; // Re-throw to be caught by the runner
        }
 
        return response;
    }

References radar::Radar::getAttached(), fers_signal::RadarSignal::getLength(), radar::Object::getName(), radar::Object::getPlatform(), LOG, interp::InterpPoint::power, params::simSamplingRate(), solveRe(), and solveReDirect().

Referenced by core::runEventDrivenSim().

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 224 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::FATAL, "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(), radar::Receiver::checkFlag(), simulation::ReResults::delay, fers_signal::RadarSignal::getCarrier(), radar::Object::getPosition(), radar::Target::getRcs(), LOG, simulation::ReResults::phase, PI, and simulation::ReResults::power.

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 278 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::FATAL, "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(), radar::Receiver::checkFlag(), simulation::ReResults::delay, fers_signal::RadarSignal::getCarrier(), radar::Object::getPosition(), LOG, simulation::ReResults::phase, PI, and simulation::ReResults::power.

Referenced by calculateResponse().

Here is the call graph for this function:

Here is the caller graph for this function: