core Namespace Reference

Classes
class	Config
	Configuration structure for the application. More...
struct	CwSegmentMetadata
struct	Event
	Represents a single event in the simulation's time-ordered queue. More...
struct	EventComparator
	A custom comparator for the event priority queue. More...
struct	OutputFileMetadata
struct	OutputMetadata
class	OutputMetadataCollector
class	ProgressReporter
	A thread-safe wrapper for the simulation progress callback. More...
struct	PulseChunkMetadata
struct	RenderingJob
	A data packet containing all information needed to process one receive window. More...
class	SimulationEngine
	Encapsulates the state and logic of the event-driven simulation loop. More...
struct	SimulationState
	Holds the dynamic global state of the simulation. More...
class	World
	The World class manages the simulator environment. More...

Enumerations
enum class	EventType {   TX_PULSED_START , RX_PULSED_WINDOW_START , RX_PULSED_WINDOW_END , TX_CW_START ,   TX_CW_END , RX_CW_START , RX_CW_END }
	Enumerates the types of events that can occur in the simulation. More...

Functions
std::string	outputFileMetadataToJsonString (const OutputFileMetadata &metadata)
std::string	outputMetadataToJsonString (const OutputMetadata &metadata)
RealType	besselJ1 (const RealType x) noexcept
	Computes the Bessel function of the first kind (order 1) for a given value.
unsigned	countProcessors () noexcept
	Detects the number of CPUs on the machine.
std::string	toString (const EventType type)
	Converts an EventType enum to its string representation.
OutputMetadata	runEventDrivenSim (World *world, pool::ThreadPool &pool, const std::function< void(const std::string &, int, int)> &progress_callback, const std::string &output_dir)
	Runs the unified, event-driven radar simulation.
void	showHelp (const char *programName) noexcept
	Displays the help message.
void	showVersion () noexcept
	Displays the version information.
std::expected< Config, std::string >	parseArguments (int argc, char *argv[]) noexcept
	Parses command-line arguments.
std::filesystem::path	resolveOutputDir (const std::string &script_file, const std::optional< std::string > &output_dir) noexcept
std::filesystem::path	resolveKmlOutputPath (const std::string &script_file, const std::filesystem::path &final_output_dir, const std::optional< std::string > &kml_file) noexcept

Enumeration Type Documentation

EventType

enum class core::EventType

strong

Enumerates the types of events that can occur in the simulation.

Enumerator
TX_PULSED_START	A pulsed transmitter begins emitting a pulse.
RX_PULSED_WINDOW_START	A pulsed receiver opens its listening window.
RX_PULSED_WINDOW_END	A pulsed receiver closes its listening window.
TX_CW_START	A continuous-wave transmitter starts transmitting.
TX_CW_END	A continuous-wave transmitter stops transmitting.
RX_CW_START	A continuous-wave receiver starts listening.
RX_CW_END	A continuous-wave receiver stops listening.

Definition at line 27 of file sim_events.h.

    {
        TX_PULSED_START, ///< A pulsed transmitter begins emitting a pulse.
        RX_PULSED_WINDOW_START, ///< A pulsed receiver opens its listening window.
        RX_PULSED_WINDOW_END, ///< A pulsed receiver closes its listening window.
        TX_CW_START, ///< A continuous-wave transmitter starts transmitting.
        TX_CW_END, ///< A continuous-wave transmitter stops transmitting.
        RX_CW_START, ///< A continuous-wave receiver starts listening.
        RX_CW_END, ///< A continuous-wave receiver stops listening.
    };

Function Documentation

besselJ1()

RealType core::besselJ1 ( const RealType  x )

noexcept

Computes the Bessel function of the first kind (order 1) for a given value.

Parameters

x	The value for which the Bessel function is to be computed.

Returns

The computed value of the Bessel function of the first kind (order 1).

Definition at line 28 of file portable_utils.h.

    {
#ifdef _MSC_VER
        return _j1(x);
#else
        return j1(x);
#endif
    }

countProcessors()

unsigned core::countProcessors ( )

noexcept

Detects the number of CPUs on the machine.

Returns

The number of CPUs detected, or 1 if detection fails.

Definition at line 42 of file portable_utils.h.

    {
        if (const unsigned hardware_threads = std::thread::hardware_concurrency(); hardware_threads > 0)
        {
            return hardware_threads;
        }
        LOG(logging::Level::ERROR, "Unable to get CPU count, assuming 1.");
        return 1;
    }

References logging::ERROR, and LOG.

outputFileMetadataToJsonString()

std::string core::outputFileMetadataToJsonString

(

const OutputFileMetadata &

metadata

)

Definition at line 108 of file output_metadata.cpp.

    {
        return fileToJson(metadata).dump(2);
    }

Referenced by serial::writeOutputFileMetadataAttributes().

Here is the caller graph for this function:

outputMetadataToJsonString()

std::string core::outputMetadataToJsonString

(

const OutputMetadata &

metadata

)

Definition at line 113 of file output_metadata.cpp.

{ return metadataToJson(metadata).dump(2); }

Referenced by FersContext::getLastOutputMetadataJson().

Here is the caller graph for this function:

parseArguments()

std::expected< Config, std::string > core::parseArguments ( int  argc, char *  argv[]  )

noexcept

Parses command-line arguments.

Processes the command-line arguments, validating them and extracting configurations like script file, logging level, and thread count.

Parameters

argc	The argument count.
argv	The argument vector.

Returns

std::expected<Config, std::string> Parsed configuration or an error message.

Definition at line 212 of file arg_parser.cpp.

         :
  <scriptfile>            Path to the simulation script file (XML)
 
Example:
  )" << programName
                  << R"( simulation.fersxml --out-dir=./results --log-level=DEBUG -n=4
 
This program runs radar simulations based on an XML script file.
Make sure the script file follows the correct format to avoid errors.
)";
    }
 
    void showVersion() noexcept
    {
        std::cout << R"(

Referenced by main().

Here is the caller graph for this function:

resolveKmlOutputPath()

std::filesystem::path core::resolveKmlOutputPath ( const std::string &  script_file, const std::filesystem::path &  final_output_dir, const std::optional< std::string > &  kml_file  )

noexcept

Definition at line 25 of file cli_paths.cpp.

    {
        if (kml_file && !kml_file->empty())
        {
            const std::filesystem::path provided_kml_path(*kml_file);
            if (provided_kml_path.has_parent_path() || provided_kml_path.is_absolute())
            {
                return provided_kml_path;
            }
 
            return final_output_dir / provided_kml_path;
        }
 
        std::filesystem::path kml_output_path = final_output_dir / std::filesystem::path(script_file).filename();
        kml_output_path.replace_extension(".kml");
        return kml_output_path;
    }

Referenced by main().

Here is the caller graph for this function:

resolveOutputDir()

std::filesystem::path core::resolveOutputDir ( const std::string &  script_file, const std::optional< std::string > &  output_dir  )

noexcept

Definition at line 8 of file cli_paths.cpp.

    {
        if (output_dir)
        {
            return std::filesystem::path(*output_dir);
        }
 
        std::filesystem::path default_out_dir = std::filesystem::path(script_file).parent_path();
        if (default_out_dir.empty())
        {
            default_out_dir = ".";
        }
 
        return default_out_dir;
    }

Referenced by main().

Here is the caller graph for this function:

runEventDrivenSim()

OutputMetadata core::runEventDrivenSim	(	World *	world,
		pool::ThreadPool &	pool,
		const std::function< void(const std::string &, int, int)> &	progress_callback,
		const std::string &	output_dir
	)

Runs the unified, event-driven radar simulation.

This function is the core entry point of the simulator. It advances time by processing events from a global priority queue. It handles both pulsed and continuous-wave (CW) physics, dispatching finalization tasks to worker threads for asynchronous processing.

Parameters

world	A pointer to the simulation world containing all entities and state.
pool	A reference to the thread pool for executing tasks.
progress_callback	An optional callback function for reporting progress.
output_dir	Output directory for the simulation files.

Definition at line 312 of file sim_threading.cpp.

    {
        auto reporter = std::make_shared<ProgressReporter>(progress_callback);
        auto metadata_collector = std::make_shared<OutputMetadataCollector>(output_dir);
        SimulationEngine engine(world, pool, reporter, output_dir, metadata_collector);
        engine.run();
        return metadata_collector->snapshot();
    }

References core::SimulationEngine::run().

Referenced by fers_run_simulation().

Here is the call graph for this function:

Here is the caller graph for this function:

showHelp()

void core::showHelp ( const char *  programName )

noexcept

Displays the help message.

Parameters

programName

The name of the program.

Definition at line 200 of file arg_parser.cpp.

    {
        std::cout << R"(/------------------------------------------------\
| FERS - The Flexible Extensible Radar Simulator |
| Version 1.0.0                                  |
\------------------------------------------------/

showVersion()

void core::showVersion ( )

noexcept

Displays the version information.

Definition at line 207 of file arg_parser.cpp.

       :
  --help, -h              Show this help message and exit

toString()

std::string core::toString

(

const EventType

type

)

Converts an EventType enum to its string representation.

Parameters

type	The event type.

Returns

A string representing the event type.

Definition at line 72 of file sim_events.h.

    {
        switch (type)
        {
        case EventType::TX_PULSED_START:
            return "TxPulsedStart";
        case EventType::RX_PULSED_WINDOW_START:
            return "RxPulsedWindowStart";
        case EventType::RX_PULSED_WINDOW_END:
            return "RxPulsedWindowEnd";
        case EventType::TX_CW_START:
            return "TxCwStart";
        case EventType::TX_CW_END:
            return "TxCwEnd";
        case EventType::RX_CW_START:
            return "RxCwStart";
        case EventType::RX_CW_END:
            return "RxCwEnd";
        default:
            return "UnknownEvent";
        }
    }

References RX_CW_END, RX_CW_START, RX_PULSED_WINDOW_END, RX_PULSED_WINDOW_START, TX_CW_END, TX_CW_START, and TX_PULSED_START.

Referenced by core::World::dumpEventQueue().

Here is the caller graph for this function: