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::Receiver *	findReceiver (const SimId id)
	Finds a receiver by ID.

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	scheduleInitialEvents ()
	Populates the event queue with the initial events for the simulation.

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 56 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);
    }

◆ 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 46 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.");
        }
        _waveforms[id] = std::move(waveform);
    }

◆ 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 38 of file world.cpp.

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

Referenced by serial::xml_parser_utils::parseAntenna(), serial::xml_parser_utils::parsePlatform(), serial::xml_parser_utils::parseReceiver(), serial::xml_parser_utils::parseTarget(), serial::xml_parser_utils::parseTiming(), serial::xml_parser_utils::parseTransmitter(), and serial::xml_parser_utils::parseWaveform().

Here is the caller graph for this function:

◆ 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 42 of file world.cpp.

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

◆ 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 44 of file world.cpp.

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

◆ 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 40 of file world.cpp.

40{ _transmitters.push_back(std::move(trans)); }

◆ 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 66 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);
    }

◆ clear()

void core::World::clear ( )

noexcept

Clears all objects and assets from the simulation world.

Definition at line 243 of file world.cpp.

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

Referenced by serial::json_to_world(), 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 338 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 core::toString().

Referenced by serial::xml_parser_utils::processParsedDocument().

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 82 of file world.cpp.

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

Referenced by serial::xml_parser_utils::parseReceiver(), serial::xml_parser_utils::parseTransmitter(), serial::update_monostatic_from_json(), serial::update_receiver_from_json(), and serial::update_transmitter_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 94 of file world.cpp.

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

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 112 of file world.cpp.

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

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 120 of file world.cpp.

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

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 88 of file world.cpp.

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

Referenced by serial::xml_parser_utils::parseReceiver(), serial::xml_parser_utils::parseTransmitter(), serial::update_monostatic_from_json(), serial::update_receiver_from_json(), serial::update_timing_from_json(), and serial::update_transmitter_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 104 of file world.cpp.

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

Referenced by fers_update_transmitter_from_json().

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 76 of file world.cpp.

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

Referenced by serial::xml_parser_utils::parseTransmitter(), and serial::update_transmitter_from_json().

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 239 of file world.h.

        {
            return _antennas;
        }

Referenced by serial::xml_parser_utils::processParsedDocument(), 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 275 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 190 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 210 of file world.h.

        {
            return _receivers;
        }

Referenced by simulation::calculatePreviewLinks(), serial::kml_generator_utils::generateKmlToStream(), core::SimulationEngine::handleTxPulsedStart(), serial::json_to_world(), serial::xml_parser_utils::parseReceiver(), core::SimulationEngine::processCwPhysics(), serial::xml_parser_utils::processParsedDocument(), and serial::xml_serializer_utils::serializePlatform().

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 284 of file world.h.

284{ return _simulation_state; }

Referenced by core::SimulationEngine::handleRxPulsedWindowEnd(), core::SimulationEngine::handleTxCwEnd(), core::SimulationEngine::handleTxCwStart(), core::SimulationEngine::processCwPhysics(), 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 200 of file world.h.

        {
            return _targets;
        }

Referenced by core::SimulationEngine::calculateCwSample(), simulation::calculatePreviewLinks(), 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 249 of file world.h.

        {
            return _timings;
        }

Referenced by serial::xml_parser_utils::processParsedDocument(), 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 220 of file world.h.

        {
            return _transmitters;
        }

Referenced by simulation::calculatePreviewLinks(), serial::kml_generator_utils::generateKmlToStream(), serial::xml_parser_utils::parseTransmitter(), 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 230 of file world.h.

        {
            return _waveforms;
        }

Referenced by serial::xml_parser_utils::processParsedDocument(), 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 142 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);
        }
    }

◆ 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 173 of file world.cpp.

    {
        const SimId id = waveform->getId();
        RadarSignal* new_ptr = waveform.get();
 
        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();
            it->second = std::move(waveform);
        }
        else
        {
            _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);
        }
    }

◆ 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 128 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 radar::Target::getId().

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

Here is the call graph for this function:

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 200 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);
        }
 
        auto refresh_timing = [id, new_ptr](auto& radar_obj)
        {
            const auto current_timing = radar_obj->getTiming();
            if (!current_timing || (current_timing->getId() != id))
            {
                return;
            }
 
            auto refreshed =
                std::make_shared<timing::Timing>(new_ptr->getName(), current_timing->getSeed(), new_ptr->getId());
            refreshed->initializeModel(new_ptr);
            radar_obj->setTiming(refreshed);
        };
 
        if ((old_ptr != nullptr) && old_ptr != new_ptr)
        {
            for (auto& tx : _transmitters)
                refresh_timing(tx);
 
            for (auto& rx : _receivers)
                refresh_timing(rx);
        }
    }

References timing::PrototypeTiming::getId(), and timing::PrototypeTiming::getName().

Here is the call 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 256 of file world.cpp.

    {
        const RealType sim_start = params::startTime();
        const RealType sim_end = params::endTime();
 
        for (const auto& transmitter : _transmitters)
        {
            if (transmitter->getMode() == radar::OperationMode::PULSED_MODE)
            {
                // Find the first valid pulse time starting from the simulation start time.
                if (auto start_time = transmitter->getNextPulseTime(sim_start); start_time)
                {
                    if (*start_time <= sim_end)
                    {
                        _event_queue.push({*start_time, EventType::TX_PULSED_START, transmitter.get()});
                    }
                }
            }
            else // CW_MODE
            {
                const auto& schedule = transmitter->getSchedule();
                if (schedule.empty())
                {
                    // Legacy behavior: Always on for simulation duration
                    _event_queue.push({sim_start, EventType::TX_CW_START, transmitter.get()});
                    _event_queue.push({sim_end, EventType::TX_CW_END, transmitter.get()});
                }
                else
                {
                    for (const auto& period : schedule)
                    {
                        // Clip periods to simulation bounds
                        const RealType start = std::max(sim_start, period.start);
                        const RealType end = std::min(sim_end, period.end);
 
                        if (start < end)
                        {
                            _event_queue.push({start, EventType::TX_CW_START, transmitter.get()});
                            _event_queue.push({end, EventType::TX_CW_END, transmitter.get()});
                        }
                    }
                }
            }
        }
 
        for (const auto& receiver : _receivers)
        {
            if (receiver->getMode() == radar::OperationMode::PULSED_MODE)
            {
                // Schedule the first receive window checking against schedule
                const RealType nominal_start = receiver->getWindowStart(0);
                if (auto start = receiver->getNextWindowTime(nominal_start); start && *start < params::endTime())
                {
                    _event_queue.push({*start, EventType::RX_PULSED_WINDOW_START, receiver.get()});
                }
            }
            else // CW_MODE
            {
                const auto& schedule = receiver->getSchedule();
                if (schedule.empty())
                {
                    // Legacy behavior: Always on for simulation duration
                    _event_queue.push({params::startTime(), EventType::RX_CW_START, receiver.get()});
                    _event_queue.push({params::endTime(), EventType::RX_CW_END, receiver.get()});
                }
                else
                {
                    for (const auto& period : schedule)
                    {
                        const RealType start = std::max(params::startTime(), period.start);
                        const RealType end = std::min(params::endTime(), period.end);
                        if (start < end)
                        {
                            _event_queue.push({start, EventType::RX_CW_START, receiver.get()});
                            _event_queue.push({end, EventType::RX_CW_END, receiver.get()});
                        }
                    }
                }
            }
        }
    }

References params::endTime(), radar::PULSED_MODE, core::RX_CW_END, core::RX_CW_START, core::RX_PULSED_WINDOW_START, params::startTime(), core::TX_CW_END, core::TX_CW_START, and core::TX_PULSED_START.

Referenced by serial::json_to_world(), and serial::xml_parser_utils::processParsedDocument().

Here is the call graph for this function:

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()

◆ findAntenna()

◆ findPlatform()

◆ findReceiver()

◆ findTarget()

◆ findTiming()

◆ findTransmitter()

◆ findWaveform()

◆ 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]

◆ scheduleInitialEvents()