The World class manages the simulator environment. More...

#include "world.h"

Public Member Functions
	World ()=default

	~World () noexcept=default

	World (const World &)=delete

World &	operator= (const World &)=delete

	World (World &&)=delete

World &	operator= (World &&)=delete

void	add (std::unique_ptr< radar::Platform > plat) noexcept
	Adds a radar platform to the simulation world.

void	add (std::unique_ptr< radar::Transmitter > trans) noexcept
	Adds a radar transmitter to the simulation world.

void	add (std::unique_ptr< radar::Receiver > recv) noexcept
	Adds a radar receiver to the simulation world.

void	add (std::unique_ptr< radar::Target > target) noexcept
	Adds a radar target to the simulation world.

void	add (std::unique_ptr< fers_signal::RadarSignal > waveform)
	Adds a radar signal (waveform) to the simulation world.

void	add (std::unique_ptr< antenna::Antenna > antenna)
	Adds an antenna to the simulation world.

void	add (std::unique_ptr< timing::PrototypeTiming > timing)
	Adds a timing source to the simulation world.

fers_signal::RadarSignal *	findWaveform (const SimId id)
	Finds a radar signal by ID.

antenna::Antenna *	findAntenna (const SimId id)
	Finds an antenna by ID.

timing::PrototypeTiming *	findTiming (const SimId id)
	Finds a timing source by ID.

radar::Platform *	findPlatform (const SimId id)
	Finds a platform by ID.

radar::Transmitter *	findTransmitter (const SimId id)
	Finds a transmitter by ID.

radar::Transmitter *	findTransmitterByName (const std::string &name)
	Finds a transmitter by name.

radar::Receiver *	findReceiver (const SimId id)
	Finds a receiver by ID.

fers_signal::RadarSignal *	findWaveformByName (const std::string &name)
	Finds a waveform by name.

RealType	earliestPhaseNoiseLookupStart () const
	Finds the earliest simulation time that can require CW phase-noise samples.

radar::Target *	findTarget (const SimId id)
	Finds a target by ID.

void	replace (std::unique_ptr< radar::Target > target)
	Replaces an existing target, updating internal pointers.

void	replace (std::unique_ptr< antenna::Antenna > antenna)
	Replaces an existing antenna, updating internal pointers.

void	replace (std::unique_ptr< fers_signal::RadarSignal > waveform)
	Replaces an existing waveform, updating internal pointers.

void	replace (std::unique_ptr< timing::PrototypeTiming > timing)
	Replaces an existing timing prototype and refreshes dependent radar timing models.

const std::vector< std::unique_ptr< radar::Platform > > &	getPlatforms () const noexcept
	Retrieves the list of platforms.

const std::vector< std::unique_ptr< radar::Target > > &	getTargets () const noexcept
	Retrieves the list of radar targets.

const std::vector< std::unique_ptr< radar::Receiver > > &	getReceivers () const noexcept
	Retrieves the list of radar receivers.

const std::vector< std::unique_ptr< radar::Transmitter > > &	getTransmitters () const noexcept
	Retrieves the list of radar transmitters.

const std::unordered_map< SimId, std::unique_ptr< fers_signal::RadarSignal > > &	getWaveforms () const noexcept
	Retrieves the map of radar signals (waveforms).

const std::unordered_map< SimId, std::unique_ptr< antenna::Antenna > > &	getAntennas () const noexcept
	Retrieves the map of antennas.

const std::unordered_map< SimId, std::unique_ptr< timing::PrototypeTiming > > &	getTimings () const noexcept
	Retrieves the map of timing prototypes.

void	clear () noexcept
	Clears all objects and assets from the simulation world.

void	swap (World &other) noexcept
	Exchanges all owned world state with another world.

void	scheduleInitialEvents ()
	Populates the event queue with the initial events for the simulation.

void	resolveReceiverDechirpReferences ()
	Resolves and validates receiver FMCW dechirp references after all components are loaded.

std::string	dumpEventQueue () const
	Dumps the current state of the event queue to a string for debugging.

std::priority_queue< Event, std::vector< Event >, EventComparator > &	getEventQueue () noexcept
	Gets a mutable reference to the global event queue.

SimulationState &	getSimulationState () noexcept
	Gets a mutable reference to the global simulation state.

Detailed Description

The World class manages the simulator environment.

Definition at line 38 of file world.h.

Constructor & Destructor Documentation

◆ World() [1/3]

core::World::World ( )

default

◆ ~World()

core::World::~World ( )

defaultnoexcept

◆ World() [2/3]

core::World::World ( const World & )

delete

◆ World() [3/3]

core::World::World ( World && )

delete

Member Function Documentation

◆ add() [1/7]

void core::World::add ( std::unique_ptr< antenna::Antenna > antenna )

Adds an antenna to the simulation world.

Parameters

antenna A unique pointer to an Antenna object.

Exceptions

std::runtime_error if an antenna with the same ID already exists.

Definition at line 133 of file world.cpp.

    {
        const SimId id = antenna->getId();
        if (_antennas.contains(id))
        {
            throw std::runtime_error("An antenna with the ID " + std::to_string(id) + " already exists.");
        }
        _antennas[id] = std::move(antenna);
    }

References max.

◆ add() [2/7]

void core::World::add ( std::unique_ptr< fers_signal::RadarSignal > waveform )

Adds a radar signal (waveform) to the simulation world.

Parameters

waveform A unique pointer to a RadarSignal object.

Exceptions

std::runtime_error if a waveform with the same ID already exists.

Definition at line 122 of file world.cpp.

    {
        const SimId id = waveform->getId();
        if (_waveforms.contains(id))
        {
            throw std::runtime_error("A waveform with the ID " + std::to_string(id) + " already exists.");
        }
        _waveform_ids_by_name[waveform->getName()] = id;
        _waveforms[id] = std::move(waveform);
    }

References max.

◆ add() [3/7]

void core::World::add ( std::unique_ptr< radar::Platform > plat )

noexcept

Adds a radar platform to the simulation world.

Parameters

plat	A unique pointer to a Platform object.

Definition at line 110 of file world.cpp.

110{ _platforms.push_back(std::move(plat)); }

References max.

◆ add() [4/7]

void core::World::add ( std::unique_ptr< radar::Receiver > recv )

noexcept

Adds a radar receiver to the simulation world.

Parameters

recv	A unique pointer to a Receiver object.

Definition at line 118 of file world.cpp.

118{ _receivers.push_back(std::move(recv)); }

References max.

◆ add() [5/7]

void core::World::add ( std::unique_ptr< radar::Target > target )

noexcept

Adds a radar target to the simulation world.

Parameters

target A unique pointer to a Target object.

Definition at line 120 of file world.cpp.

120{ _targets.push_back(std::move(target)); }

References max.

◆ add() [6/7]

void core::World::add ( std::unique_ptr< radar::Transmitter > trans )

noexcept

Adds a radar transmitter to the simulation world.

Parameters

trans A unique pointer to a Transmitter object.

Definition at line 112 of file world.cpp.

    {
        _transmitters_by_name[trans->getName()] = trans.get();
        _transmitters.push_back(std::move(trans));
    }

References max.

◆ add() [7/7]

void core::World::add ( std::unique_ptr< timing::PrototypeTiming > timing )

Adds a timing source to the simulation world.

Parameters

timing A unique pointer to a PrototypeTiming object.

Exceptions

std::runtime_error if a timing source with the same ID already exists.

Definition at line 143 of file world.cpp.

    {
        const SimId id = timing->getId();
        if (_timings.contains(id))
        {
            throw std::runtime_error("A timing source with the ID " + std::to_string(id) + " already exists.");
        }
        _timings[id] = std::move(timing);
    }

References max.

◆ clear()

void core::World::clear ( )

noexcept

Clears all objects and assets from the simulation world.

Definition at line 408 of file world.cpp.

    {
        _platforms.clear();
        _transmitters.clear();
        _transmitters_by_name.clear();
        _receivers.clear();
        _targets.clear();
        _waveforms.clear();
        _waveform_ids_by_name.clear();
        _antennas.clear();
        _timings.clear();
        _event_queue = {};
        _simulation_state = {};
    }

Referenced by serial::parseSimulation(), and serial::parseSimulationFromString().

Here is the caller graph for this function:

◆ dumpEventQueue()

std::string core::World::dumpEventQueue ( ) const

Dumps the current state of the event queue to a string for debugging.

Returns: A formatted string representing the contents of the event queue.

Definition at line 619 of file world.cpp.

    {
        if (_event_queue.empty())
        {
            return "Event Queue is empty.\n";
        }
 
        std::stringstream ss;
        ss << std::fixed << std::setprecision(6);
 
        const std::string separator = "--------------------------------------------------------------------";
        const std::string title = "| Event Queue Contents (" + std::to_string(_event_queue.size()) + " events)";
        if (separator.size() > static_cast<std::size_t>(std::numeric_limits<int>::max()))
        {
            throw std::runtime_error("Separator width exceeds stream formatting limits.");
        }
        const int title_width = static_cast<int>(separator.size()) - 1;
 
        ss << separator << "\n"
           << std::left << std::setw(title_width) << title << "|\n"
           << separator << "\n"
           << "| " << std::left << std::setw(12) << "Timestamp" << " | " << std::setw(21) << "Event Type" << " | "
           << std::setw(25) << "Source Object" << " |\n"
           << separator << "\n";
 
        auto queue_copy = _event_queue;
 
        while (!queue_copy.empty())
        {
            const auto [timestamp, event_type, source_object] = queue_copy.top();
            queue_copy.pop();
 
            ss << "| " << std::right << std::setw(12) << timestamp << " | " << std::left << std::setw(21)
               << toString(event_type) << " | " << std::left << std::setw(25) << source_object->getName() << " |\n";
        }
        ss << separator << "\n";
 
        return ss.str();
    }

References max, and core::toString().

Here is the call graph for this function:

◆ earliestPhaseNoiseLookupStart()

RealType core::World::earliestPhaseNoiseLookupStart ( ) const

Finds the earliest simulation time that can require CW phase-noise samples.

Includes active streaming transmitters and receivers. Pre-start transmitter periods that cross the simulation start are included so retarded emissions can sample transmitter phase noise before t_start.

Returns: Earliest required lookup time, or params::startTime() if no streaming component overlaps.

Definition at line 209 of file world.cpp.

    {
        const auto include_streaming_interval_start = [](std::optional<RealType>& earliest,
                                                         const RealType segment_start, const RealType segment_end,
                                                         const bool allow_pre_start)
        {
            const RealType sim_start = params::startTime();
            const RealType sim_end = params::endTime();
            if (segment_end <= sim_start || segment_start >= sim_end)
            {
                return;
            }
 
            const RealType required_start =
                allow_pre_start && segment_start < sim_start ? segment_start : std::max(sim_start, segment_start);
            earliest = earliest.has_value() ? std::min(*earliest, required_start) : required_start;
        };
 
        std::optional<RealType> earliest;
        for (const auto& transmitter_ptr : _transmitters)
        {
            if (transmitter_ptr == nullptr || !transmitter_ptr->isStreamingMode())
            {
                continue;
            }
 
            const auto& schedule = transmitter_ptr->getSchedule();
            if (schedule.empty())
            {
                include_streaming_interval_start(earliest, params::startTime(), params::endTime(), false);
                continue;
            }
 
            for (const auto& period : schedule)
            {
                include_streaming_interval_start(earliest, period.start, period.end, true);
            }
        }
 
        for (const auto& receiver_ptr : _receivers)
        {
            if (receiver_ptr == nullptr ||
                (receiver_ptr->getMode() != radar::OperationMode::CW_MODE &&
                 receiver_ptr->getMode() != radar::OperationMode::FMCW_MODE &&
                 receiver_ptr->getMode() != radar::OperationMode::SFCW_MODE))
            {
                continue;
            }
 
            const auto& schedule = receiver_ptr->getSchedule();
            if (schedule.empty())
            {
                include_streaming_interval_start(earliest, params::startTime(), params::endTime(), false);
                continue;
            }
 
            for (const auto& period : schedule)
            {
                include_streaming_interval_start(earliest, period.start, period.end, false);
            }
        }
 
        return earliest.value_or(params::startTime());
    }

References radar::CW_MODE, params::endTime(), radar::FMCW_MODE, max, radar::SFCW_MODE, and params::startTime().

Referenced by core::projectSimulationMemory().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ findAntenna()

Antenna * core::World::findAntenna ( const SimId id )

Finds an antenna by ID.

Parameters

id	The ID of the antenna to find.

Returns: A pointer to the Antenna if found, or nullptr if not found.

Definition at line 159 of file world.cpp.

    {
        const auto it = _antennas.find(id);
        return it != _antennas.end() ? it->second.get() : nullptr;
    }

References max.

Referenced by serial::update_monostatic_receiver_basics(), serial::update_receiver_antenna_from_json(), and serial::update_transmitter_antenna_from_json().

Here is the caller graph for this function:

◆ findPlatform()

Platform * core::World::findPlatform ( const SimId id )

Finds a platform by ID.

Parameters

id	The ID of the platform to find.

Returns: A pointer to the Platform if found, or nullptr if not found.

Definition at line 171 of file world.cpp.

    {
        for (auto& p : _platforms)
        {
            if (p->getId() == id)
                return p.get();
        }
        return nullptr;
    }

References max.

Referenced by fers_update_platform_from_json().

Here is the caller graph for this function:

◆ findReceiver()

Receiver * core::World::findReceiver ( const SimId id )

Finds a receiver by ID.

Parameters

id	The ID of the receiver to find.

Returns: A pointer to the Receiver if found, or nullptr if not found.

Definition at line 195 of file world.cpp.

    {
        for (auto& rx : _receivers)
            if (rx->getId() == id)
                return rx.get();
        return nullptr;
    }

References max.

Referenced by fers_update_receiver_from_json().

Here is the caller graph for this function:

◆ findTarget()

Target * core::World::findTarget ( const SimId id )

Finds a target by ID.

Parameters

id	The ID of the target to find.

Returns: A pointer to the Target if found, or nullptr if not found.

Definition at line 274 of file world.cpp.

    {
        for (auto& tgt : _targets)
            if (tgt->getId() == id)
                return tgt.get();
        return nullptr;
    }

References max.

Referenced by fers_update_target_from_json().

Here is the caller graph for this function:

◆ findTiming()

PrototypeTiming * core::World::findTiming ( const SimId id )

Finds a timing source by ID.

Parameters

id	The ID of the timing source to find.

Returns: A pointer to the PrototypeTiming if found, or nullptr if not found.

Definition at line 165 of file world.cpp.

    {
        const auto it = _timings.find(id);
        return it != _timings.end() ? it->second.get() : nullptr;
    }

References max.

Referenced by serial::update_monostatic_timing_from_json(), serial::update_receiver_timing_from_json(), serial::update_timing_from_json(), and serial::update_transmitter_timing_from_json().

Here is the caller graph for this function:

◆ findTransmitter()

Transmitter * core::World::findTransmitter ( const SimId id )

Finds a transmitter by ID.

Parameters

id	The ID of the transmitter to find.

Returns: A pointer to the Transmitter if found, or nullptr if not found.

Definition at line 181 of file world.cpp.

    {
        for (auto& tx : _transmitters)
            if (tx->getId() == id)
                return tx.get();
        return nullptr;
    }

References max.

Referenced by fers_update_transmitter_from_json().

Here is the caller graph for this function:

◆ findTransmitterByName()

Transmitter * core::World::findTransmitterByName ( const std::string & name )

Finds a transmitter by name.

Parameters

name	The transmitter name to find.

Returns: A pointer to the Transmitter if found, or nullptr if not found.

Definition at line 189 of file world.cpp.

    {
        const auto it = _transmitters_by_name.find(name);
        return it != _transmitters_by_name.end() ? it->second : nullptr;
    }

References max.

Referenced by resolveReceiverDechirpReferences().

Here is the caller graph for this function:

◆ findWaveform()

RadarSignal * core::World::findWaveform ( const SimId id )

Finds a radar signal by ID.

Parameters

id	The ID of the radar signal to find.

Returns: A pointer to the RadarSignal if found, or nullptr if not found.

Definition at line 153 of file world.cpp.

    {
        const auto it = _waveforms.find(id);
        return it != _waveforms.end() ? it->second.get() : nullptr;
    }

References max.

Referenced by findWaveformByName(), and serial::update_transmitter_waveform_from_json().

Here is the caller graph for this function:

◆ findWaveformByName()

RadarSignal * core::World::findWaveformByName ( const std::string & name )

Finds a waveform by name.

Parameters

name	The waveform name to find.

Returns: A pointer to the RadarSignal if found, or nullptr if not found.

Definition at line 203 of file world.cpp.

    {
        const auto it = _waveform_ids_by_name.find(name);
        return it != _waveform_ids_by_name.end() ? findWaveform(it->second) : nullptr;
    }

References findWaveform(), and max.

Referenced by resolveReceiverDechirpReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getAntennas()

const std::unordered_map< SimId, std::unique_ptr< antenna::Antenna > > & core::World::getAntennas ( ) const

noexcept

Retrieves the map of antennas.

Returns: A const reference to the map of antenna names to Antenna objects.

Definition at line 265 of file world.h.

        {
            return _antennas;
        }

Referenced by serial::world_to_json(), and serial::world_to_xml_string().

Here is the caller graph for this function:

◆ getEventQueue()

std::priority_queue< Event, std::vector< Event >, EventComparator > & core::World::getEventQueue ( )

noexcept

Gets a mutable reference to the global event queue.

Returns: A reference to the priority queue of events.

Definition at line 313 of file world.h.

        {
            return _event_queue;
        }

Referenced by core::SimulationEngine::handleRxPulsedWindowEnd(), core::SimulationEngine::handleRxPulsedWindowStart(), core::SimulationEngine::handleTxPulsedStart(), and core::SimulationEngine::run().

Here is the caller graph for this function:

◆ getPlatforms()

const std::vector< std::unique_ptr< radar::Platform > > & core::World::getPlatforms ( ) const

noexcept

Retrieves the list of platforms.

Returns: A const reference to a vector of unique pointers to Platform objects.

Definition at line 216 of file world.h.

        {
            return _platforms;
        }

Referenced by serial::world_to_json(), and serial::world_to_xml_string().

Here is the caller graph for this function:

◆ getReceivers()

const std::vector< std::unique_ptr< radar::Receiver > > & core::World::getReceivers ( ) const

noexcept

Retrieves the list of radar receivers.

Returns: A const reference to a vector of unique pointers to Receiver objects.

Definition at line 236 of file world.h.

        {
            return _receivers;
        }

Referenced by simulation::calculatePreviewLinks(), core::collectCwPhaseNoiseTimings(), serial::kml_generator_utils::generateKmlToStream(), core::SimulationEngine::handleRxStreamingEnd(), core::SimulationEngine::handleRxStreamingStart(), core::SimulationEngine::handleTxPulsedStart(), core::logSimulationMemoryProjection(), core::projectSimulationMemory(), core::SimulationEngine::run(), serial::xml_serializer_utils::serializePlatform(), and core::SimulationEngine::SimulationEngine().

Here is the caller graph for this function:

◆ getSimulationState()

SimulationState & core::World::getSimulationState ( )

noexcept

Gets a mutable reference to the global simulation state.

Returns: A reference to the SimulationState object.

Definition at line 322 of file world.h.

322{ return _simulation_state; }

Referenced by core::SimulationEngine::handleRxStreamingEnd(), core::SimulationEngine::handleRxStreamingStart(), core::SimulationEngine::handleTxStreamingEnd(), core::SimulationEngine::handleTxStreamingStart(), core::SimulationEngine::processStreamingPhysics(), and core::SimulationEngine::run().

Here is the caller graph for this function:

◆ getTargets()

const std::vector< std::unique_ptr< radar::Target > > & core::World::getTargets ( ) const

noexcept

Retrieves the list of radar targets.

Returns: A const reference to a vector of unique pointers to Target objects.

Definition at line 226 of file world.h.

        {
            return _targets;
        }

Referenced by serial::kml_generator_utils::generateKmlToStream(), core::SimulationEngine::handleTxPulsedStart(), and serial::xml_serializer_utils::serializePlatform().

Here is the caller graph for this function:

◆ getTimings()

const std::unordered_map< SimId, std::unique_ptr< timing::PrototypeTiming > > & core::World::getTimings ( ) const

noexcept

Retrieves the map of timing prototypes.

Returns: A const reference to the map of timing names to PrototypeTiming objects.

Definition at line 275 of file world.h.

        {
            return _timings;
        }

Referenced by serial::world_to_json(), and serial::world_to_xml_string().

Here is the caller graph for this function:

◆ getTransmitters()

const std::vector< std::unique_ptr< radar::Transmitter > > & core::World::getTransmitters ( ) const

noexcept

Retrieves the list of radar transmitters.

Returns: A const reference to a vector of unique pointers to Transmitter objects.

Definition at line 246 of file world.h.

        {
            return _transmitters;
        }

Referenced by simulation::calculatePreviewLinks(), core::collectCwPhaseNoiseTimings(), serial::kml_generator_utils::generateKmlToStream(), and serial::xml_serializer_utils::serializePlatform().

Here is the caller graph for this function:

◆ getWaveforms()

const std::unordered_map< SimId, std::unique_ptr< fers_signal::RadarSignal > > & core::World::getWaveforms ( ) const

noexcept

Retrieves the map of radar signals (waveforms).

Returns: A const reference to the map of signal names to RadarSignal objects.

Definition at line 256 of file world.h.

        {
            return _waveforms;
        }

Referenced by serial::world_to_json(), and serial::world_to_xml_string().

Here is the caller graph for this function:

◆ operator=() [1/2]

World & core::World::operator= ( const World & )

delete

◆ operator=() [2/2]

World & core::World::operator= ( World && )

delete

◆ replace() [1/4]

void core::World::replace ( std::unique_ptr< antenna::Antenna > antenna )

Replaces an existing antenna, updating internal pointers.

Parameters

antenna Unique pointer to the new antenna.

Definition at line 296 of file world.cpp.

    {
        const SimId id = antenna->getId();
        const Antenna* new_ptr = antenna.get();
 
        std::unique_ptr<Antenna> old_owned;
        const Antenna* old_ptr = nullptr;
 
        if (auto it = _antennas.find(id); it != _antennas.end())
        {
            old_owned = std::move(it->second);
            old_ptr = old_owned.get();
            it->second = std::move(antenna);
        }
        else
        {
            _antennas[id] = std::move(antenna);
        }
 
        if ((old_ptr != nullptr) && old_ptr != new_ptr)
        {
            for (auto& tx : _transmitters)
                if (tx->getAntenna() == old_ptr)
                    tx->setAntenna(new_ptr);
 
            for (auto& rx : _receivers)
                if (rx->getAntenna() == old_ptr)
                    rx->setAntenna(new_ptr);
        }
    }

References max.

◆ replace() [2/4]

void core::World::replace ( std::unique_ptr< fers_signal::RadarSignal > waveform )

Replaces an existing waveform, updating internal pointers.

Parameters

waveform Unique pointer to the new waveform.

Definition at line 327 of file world.cpp.

    {
        const SimId id = waveform->getId();
        RadarSignal* new_ptr = waveform.get();
        const std::string new_name = waveform->getName();
 
        std::unique_ptr<RadarSignal> old_owned;
        const RadarSignal* old_ptr = nullptr;
 
        if (auto it = _waveforms.find(id); it != _waveforms.end())
        {
            old_owned = std::move(it->second);
            old_ptr = old_owned.get();
            _waveform_ids_by_name.erase(old_owned->getName());
            _waveform_ids_by_name[new_name] = id;
            it->second = std::move(waveform);
        }
        else
        {
            _waveform_ids_by_name[new_name] = id;
            _waveforms[id] = std::move(waveform);
        }
 
        if ((old_ptr != nullptr) && old_ptr != new_ptr)
        {
            for (auto& tx : _transmitters)
                if (tx->getSignal() == old_ptr)
                    tx->setSignal(new_ptr);
        }
    }

References max.

◆ replace() [3/4]

void core::World::replace ( std::unique_ptr< radar::Target > target )

Replaces an existing target, updating internal pointers.

Parameters

target Unique pointer to the new target.

Definition at line 282 of file world.cpp.

    {
        const SimId id = target->getId();
        for (auto& t : _targets)
        {
            if (t->getId() == id)
            {
                t = std::move(target);
                return;
            }
        }
        _targets.push_back(std::move(target));
    }

References max.

Referenced by serial::update_antenna_from_json(), serial::update_existing_antenna_pattern_fields(), serial::update_target_from_json(), and serial::update_timing_from_json().

Here is the caller graph for this function:

◆ replace() [4/4]

void core::World::replace ( std::unique_ptr< timing::PrototypeTiming > timing )

Replaces an existing timing prototype and refreshes dependent radar timing models.

Parameters

timing Unique pointer to the new timing prototype.

Definition at line 358 of file world.cpp.

    {
        const SimId id = timing->getId();
        const PrototypeTiming* new_ptr = timing.get();
 
        std::unique_ptr<PrototypeTiming> old_owned;
        const PrototypeTiming* old_ptr = nullptr;
 
        if (auto it = _timings.find(id); it != _timings.end())
        {
            old_owned = std::move(it->second);
            old_ptr = old_owned.get();
            it->second = std::move(timing);
        }
        else
        {
            _timings[id] = std::move(timing);
        }
 
        std::unordered_map<const timing::Timing*, std::shared_ptr<timing::Timing>> refreshed_instances;
        auto refresh_timing = [id, new_ptr, &refreshed_instances](auto& radar_obj)
        {
            const auto current_timing = radar_obj->getTiming();
            if (!current_timing || (current_timing->getId() != id))
            {
                return;
            }
 
            const timing::Timing* const timing_key = current_timing.get();
            const auto [it, inserted] = refreshed_instances.try_emplace(timing_key);
            if (inserted)
            {
                auto refreshed =
                    std::make_shared<timing::Timing>(new_ptr->getName(), current_timing->getSeed(), new_ptr->getId());
                refreshed->initializeModel(new_ptr);
                it->second = std::move(refreshed);
            }
            radar_obj->setTiming(it->second);
        };
 
        if ((old_ptr != nullptr) && old_ptr != new_ptr)
        {
            for (auto& tx : _transmitters)
                refresh_timing(tx);
 
            for (auto& rx : _receivers)
                refresh_timing(rx);
        }
    }

References max.

◆ resolveReceiverDechirpReferences()

void core::World::resolveReceiverDechirpReferences ( )

Resolves and validates receiver FMCW dechirp references after all components are loaded.

Exceptions

std::runtime_error if a dechirped receiver has an invalid or inactive LO reference.

Definition at line 553 of file world.cpp.

    {
        for (const auto& rx_ptr : _receivers)
        {
            auto& rx = *rx_ptr;
            rx.clearResolvedDechirpSources();
            if (!rx.isDechirpEnabled())
            {
                continue;
            }
            if (rx.getMode() != radar::OperationMode::FMCW_MODE)
            {
                throw std::runtime_error("Receiver '" + rx.getName() + "' enables dechirping outside FMCW mode.");
            }
 
            auto reference = rx.getDechirpReference();
            std::vector<ActiveStreamingSource> sources;
            const std::string owner = "Receiver '" + rx.getName() + "'";
            switch (reference.source)
            {
            case Receiver::DechirpReferenceSource::Attached:
                {
                    const auto* const tx = dynamic_cast<const Transmitter*>(rx.getAttached());
                    validateDechirpTransmitter(tx, owner);
                    reference.transmitter_id = tx->getId();
                    reference.transmitter_name = tx->getName();
                    sources = transmitterDechirpSources(tx);
                    break;
                }
            case Receiver::DechirpReferenceSource::Transmitter:
                {
                    auto* const tx = findTransmitterByName(reference.name);
                    validateDechirpTransmitter(tx, owner);
                    reference.transmitter_id = tx->getId();
                    reference.transmitter_name = tx->getName();
                    sources = transmitterDechirpSources(tx);
                    break;
                }
            case Receiver::DechirpReferenceSource::Custom:
                {
                    auto* const waveform = findWaveformByName(reference.name);
                    if (waveform == nullptr || !waveform->isFmcwFamily())
                    {
                        throw std::runtime_error(owner + " custom dechirp reference waveform '" + reference.name +
                                                 "' must be a top-level FMCW waveform.");
                    }
                    reference.waveform_id = waveform->getId();
                    reference.waveform_name = waveform->getName();
                    sources = waveformDechirpSources(waveform, &rx);
                    break;
                }
            case Receiver::DechirpReferenceSource::None:
                throw std::runtime_error(owner + " enables dechirping without a dechirp reference.");
            }
 
            if (sources.empty())
            {
                throw std::runtime_error(owner + " dechirp reference has no active LO segments in the simulation.");
            }
            std::ranges::sort(sources, [](const ActiveStreamingSource& lhs, const ActiveStreamingSource& rhs)
                              { return lhs.segment_start < rhs.segment_start; });
            rx.setDechirpReference(std::move(reference));
            rx.setResolvedDechirpSources(std::move(sources));
        }
    }

References findTransmitterByName(), findWaveformByName(), radar::FMCW_MODE, fers_signal::RadarSignal::getId(), fers_signal::RadarSignal::getName(), fers_signal::RadarSignal::isFmcwFamily(), and max.

Referenced by serial::update_monostatic_from_json(), and serial::update_receiver_from_json().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scheduleInitialEvents()

void core::World::scheduleInitialEvents ( )

Populates the event queue with the initial events for the simulation.

This method should be called after all simulation objects have been parsed and added to the world.

Definition at line 440 of file world.cpp.

    {
        const RealType sim_start = params::startTime();
        const RealType sim_end = params::endTime();
 
        for (const auto& transmitter : _transmitters)
        {
            scheduleInitialTransmitterEvents(transmitter.get(), sim_start, sim_end);
        }
 
        for (const auto& receiver : _receivers)
        {
            scheduleInitialReceiverEvents(receiver.get(), sim_start, sim_end);
        }
    }

References params::endTime(), max, receiver, params::startTime(), and transmitter.

Here is the call graph for this function:

◆ swap()

void core::World::swap ( World & other )

noexcept

Exchanges all owned world state with another world.

Definition at line 423 of file world.cpp.

    {
        using std::swap;
 
        _platforms.swap(other._platforms);
        _transmitters.swap(other._transmitters);
        _receivers.swap(other._receivers);
        _targets.swap(other._targets);
        _waveforms.swap(other._waveforms);
        _waveform_ids_by_name.swap(other._waveform_ids_by_name);
        _transmitters_by_name.swap(other._transmitters_by_name);
        _antennas.swap(other._antennas);
        _timings.swap(other._timings);
        _event_queue.swap(other._event_queue);
        swap(_simulation_state, other._simulation_state);
    }

References max.

Referenced by serial::json_to_world().

Here is the caller graph for this function:

The documentation for this class was generated from the following files:

packages/libfers/src/core/world.h
packages/libfers/src/core/world.cpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ World() [1/3]

◆ ~World()

◆ World() [2/3]

◆ World() [3/3]

Member Function Documentation

◆ add() [1/7]

◆ add() [2/7]

◆ add() [3/7]

◆ add() [4/7]

◆ add() [5/7]

◆ add() [6/7]

◆ add() [7/7]

◆ clear()

◆ dumpEventQueue()

◆ earliestPhaseNoiseLookupStart()

◆ findAntenna()

◆ findPlatform()

◆ findReceiver()

◆ findTarget()

◆ findTiming()

◆ findTransmitter()

◆ findTransmitterByName()

◆ findWaveform()

◆ findWaveformByName()

◆ getAntennas()

◆ getEventQueue()

◆ getPlatforms()

◆ getReceivers()

◆ getSimulationState()

◆ getTargets()

◆ getTimings()

◆ getTransmitters()

◆ getWaveforms()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ replace() [1/4]

◆ replace() [2/4]

◆ replace() [3/4]

◆ replace() [4/4]

◆ resolveReceiverDechirpReferences()

◆ scheduleInitialEvents()

◆ swap()