radar Namespace Reference

Classes
class	FileTarget
	File-based radar target. More...
class	IsoTarget
	Isotropic radar target. More...
class	Object
	Represents a physical object in the radar system. More...
class	Platform
	Represents a simulation platform with motion and rotation paths. More...
class	Radar
	Represents a radar system on a platform. More...
class	RcsChiSquare
	Chi-square distributed RCS model. More...
class	RcsConst
	Constant RCS model. More...
class	RcsModel
	Base class for RCS fluctuation models. More...
class	Receiver
	Manages radar signal reception and response processing. More...
struct	SchedulePeriod
	Represents a time period during which the transmitter is active. More...
class	Target
	Base class for radar targets. More...
class	Transmitter
	Represents a radar transmitter system. More...

Enumerations
enum class	OperationMode { PULSED_MODE , CW_MODE }
	Defines the operational mode of a radar component. More...

Functions
std::vector< SchedulePeriod >	processRawSchedule (std::vector< SchedulePeriod > periods, const std::string &ownerName, bool isPulsed, RealType pri)
	Processes a raw list of schedule periods.
std::unique_ptr< Target >	createIsoTarget (Platform *platform, std::string name, RealType rcs, unsigned seed)
	Creates an isotropic target.
std::unique_ptr< Target >	createFileTarget (Platform *platform, std::string name, const std::string &filename, unsigned seed)
	Creates a file-based target.
void	to_json (nlohmann::json &j, const SchedulePeriod &p)
void	from_json (const nlohmann::json &j, SchedulePeriod &p)
void	to_json (nlohmann::json &j, const Transmitter &t)
void	to_json (nlohmann::json &j, const Receiver &r)
void	to_json (nlohmann::json &j, const Target &t)
void	to_json (nlohmann::json &j, const Platform &p)

Enumeration Type Documentation

OperationMode

enum class radar::OperationMode

strong

Defines the operational mode of a radar component.

Enumerator
PULSED_MODE	The component operates in a pulsed mode.
CW_MODE	The component operates in a continuous-wave mode.

Definition at line 35 of file radar_obj.h.

    {
        PULSED_MODE, ///< The component operates in a pulsed mode.
        CW_MODE ///< The component operates in a continuous-wave mode.
    };

Function Documentation

createFileTarget()

std::unique_ptr< Target > radar::createFileTarget	(	Platform *	platform,
		std::string	name,
		const std::string &	filename,
		unsigned	seed
	)

Creates a file-based target.

Parameters

platform	Pointer to the platform associated with the target.
name	The name of the target.
filename	The name of the file containing RCS data.
seed	The seed for the target's internal random number generator.

Returns

A unique pointer to the newly created FileTarget.

Definition at line 279 of file target.h.

    {
        return std::make_unique<FileTarget>(platform, std::move(name), filename, seed);
    }

Referenced by serial::json_to_world().

Here is the caller graph for this function:

createIsoTarget()

std::unique_ptr< Target > radar::createIsoTarget	(	Platform *	platform,
		std::string	name,
		RealType	rcs,
		unsigned	seed
	)

Creates an isotropic target.

Parameters

platform	Pointer to the platform associated with the target.
name	The name of the target.
rcs	The constant RCS value for the target.
seed	The seed for the target's internal random number generator.

Returns

A unique pointer to the newly created IsoTarget.

Definition at line 265 of file target.h.

    {
        return std::make_unique<IsoTarget>(platform, std::move(name), rcs, seed);
    }

Referenced by serial::json_to_world().

Here is the caller graph for this function:

from_json()

void radar::from_json	(	const nlohmann::json &	j,
		SchedulePeriod &	p
	)

Definition at line 383 of file json_serializer.cpp.

    {
        j.at("start").get_to(p.start);
        j.at("end").get_to(p.end);
    }

References radar::SchedulePeriod::end, and radar::SchedulePeriod::start.

processRawSchedule()

std::vector< SchedulePeriod > radar::processRawSchedule	(	std::vector< SchedulePeriod >	periods,
		const std::string &	ownerName,
		bool	isPulsed,
		RealType	pri
	)

Processes a raw list of schedule periods.

This function performs the following operations:

1. Filters invalid periods (start >= end).
2. Filters periods completely outside simulation bounds.
3. Sorts periods by start time.
4. Merges overlapping or adjacent periods.
5. Checks against PRI constraints (if pulsed).

Parameters

periods	The raw vector of periods.
ownerName	The name of the object owning this schedule (for logging).
isPulsed	Whether the object is operating in pulsed mode.
pri	The Pulse Repetition Interval (only used if isPulsed is true).

Returns

A sorted, merged, and validated vector of periods.

Definition at line 17 of file schedule_period.cpp.

    {
        if (periods.empty())
        {
            return {};
        }
 
        std::vector<SchedulePeriod> valid_periods;
        valid_periods.reserve(periods.size());
 
        const RealType sim_start = params::startTime();
        const RealType sim_end = params::endTime();
 
        // 1. Filter invalid and out-of-bounds periods
        for (const auto& p : periods)
        {
            if (p.start >= p.end)
            {
                LOG(logging::Level::WARNING,
                    "Object '{}' has a schedule period with start ({}) >= end ({}). Ignoring period.", ownerName,
                    p.start, p.end);
                continue;
            }
 
            if (p.end <= sim_start || p.start >= sim_end)
            {
                LOG(logging::Level::WARNING,
                    "Object '{}' has a schedule period [{}, {}] completely outside simulation time. Ignoring.",
                    ownerName, p.start, p.end);
                continue;
            }
            valid_periods.push_back(p);
        }
 
        if (valid_periods.empty())
        {
            return {};
        }
 
        // 2. Sort by start time
        std::sort(valid_periods.begin(), valid_periods.end(),
                  [](const auto& a, const auto& b) { return a.start < b.start; });
 
        // 3. Merge overlapping intervals
        std::vector<SchedulePeriod> merged;
        merged.reserve(valid_periods.size());
        merged.push_back(valid_periods.front());
 
        for (size_t i = 1; i < valid_periods.size(); ++i)
        {
            if (valid_periods[i].start <= merged.back().end)
            {
                // Overlap or adjacency: extend the previous period
                merged.back().end = std::max(merged.back().end, valid_periods[i].end);
            }
            else
            {
                merged.push_back(valid_periods[i]);
            }
        }
 
        // 4. Check PRI constraints
        if (isPulsed)
        {
            for (const auto& period : merged)
            {
                if (period.end - period.start < pri)
                {
                    LOG(logging::Level::WARNING, "Object '{}' has a schedule period [{}, {}] shorter than PRI ({}s).",
                        ownerName, period.start, period.end, pri);
                }
            }
        }
 
        return merged;
    }

References params::endTime(), LOG, params::startTime(), and logging::WARNING.

Referenced by serial::json_to_world().

Here is the call graph for this function:

Here is the caller graph for this function:

to_json() [1/5]

void radar::to_json	(	nlohmann::json &	j,
		const Platform &	p
	)

Definition at line 467 of file json_serializer.cpp.

    {
        j = {{"name", p.getName()}, {"motionpath", *p.getMotionPath()}};
 
        if (p.getRotationPath()->getType() == math::RotationPath::InterpType::INTERP_CONSTANT)
        {
            j["fixedrotation"] = *p.getRotationPath();
        }
        else
        {
            j["rotationpath"] = *p.getRotationPath();
        }
    }

References radar::Platform::getMotionPath(), radar::Platform::getName(), radar::Platform::getRotationPath(), math::RotationPath::getType(), and math::RotationPath::INTERP_CONSTANT.

Here is the call graph for this function:

to_json() [2/5]

void radar::to_json	(	nlohmann::json &	j,
		const Receiver &	r
	)

Definition at line 410 of file json_serializer.cpp.

    {
        j = nlohmann::json{{"name", r.getName()},
                           {"noise_temp", r.getNoiseTemperature()},
                           {"antenna", r.getAntenna() ? r.getAntenna()->getName() : ""},
                           {"timing", r.getTiming() ? r.getTiming()->getName() : ""},
                           {"nodirect", r.checkFlag(Receiver::RecvFlag::FLAG_NODIRECT)},
                           {"nopropagationloss", r.checkFlag(Receiver::RecvFlag::FLAG_NOPROPLOSS)}};
 
        if (r.getMode() == OperationMode::PULSED_MODE)
        {
            j["pulsed_mode"] = {
                {"prf", r.getWindowPrf()}, {"window_skip", r.getWindowSkip()}, {"window_length", r.getWindowLength()}};
        }
        else
        {
            j["cw_mode"] = nlohmann::json::object();
        }
        if (!r.getSchedule().empty())
        {
            j["schedule"] = r.getSchedule();
        }
    }

References radar::Receiver::checkFlag(), radar::Receiver::FLAG_NODIRECT, radar::Receiver::FLAG_NOPROPLOSS, radar::Radar::getAntenna(), radar::Receiver::getMode(), antenna::Antenna::getName(), radar::Object::getName(), radar::Receiver::getNoiseTemperature(), radar::Receiver::getSchedule(), radar::Radar::getTiming(), radar::Receiver::getWindowLength(), radar::Receiver::getWindowPrf(), radar::Receiver::getWindowSkip(), and PULSED_MODE.

Here is the call graph for this function:

to_json() [3/5]

void radar::to_json	(	nlohmann::json &	j,
		const SchedulePeriod &	p
	)

Definition at line 381 of file json_serializer.cpp.

{ j = {{"start", p.start}, {"end", p.end}}; }

References radar::SchedulePeriod::end, and radar::SchedulePeriod::start.

to_json() [4/5]

void radar::to_json	(	nlohmann::json &	j,
		const Target &	t
	)

Definition at line 434 of file json_serializer.cpp.

    {
        j["name"] = t.getName();
        nlohmann::json rcs_json;
        if (const auto* iso = dynamic_cast<const IsoTarget*>(&t))
        {
            rcs_json["type"] = "isotropic";
            rcs_json["value"] = iso->getConstRcs();
        }
        else if (const auto* file = dynamic_cast<const FileTarget*>(&t))
        {
            rcs_json["type"] = "file";
            rcs_json["filename"] = file->getFilename();
        }
        j["rcs"] = rcs_json;
 
        // Serialize the fluctuation model if it exists.
        if (const auto* model_base = t.getFluctuationModel())
        {
            nlohmann::json model_json;
            if (const auto* chi_model = dynamic_cast<const RcsChiSquare*>(model_base))
            {
                model_json["type"] = "chisquare";
                model_json["k"] = chi_model->getK();
            }
            else // Default to constant if it's not a recognized type (e.g., RcsConst)
            {
                model_json["type"] = "constant";
            }
            j["model"] = model_json;
        }
    }

References radar::Target::getFluctuationModel(), and radar::Object::getName().

Here is the call graph for this function:

to_json() [5/5]

void radar::to_json	(	nlohmann::json &	j,
		const Transmitter &	t
	)

Definition at line 389 of file json_serializer.cpp.

    {
        j = nlohmann::json{{"name", t.getName()},
                           {"waveform", t.getSignal() ? t.getSignal()->getName() : ""},
                           {"antenna", t.getAntenna() ? t.getAntenna()->getName() : ""},
                           {"timing", t.getTiming() ? t.getTiming()->getName() : ""}};
 
        if (t.getMode() == OperationMode::PULSED_MODE)
        {
            j["pulsed_mode"] = {{"prf", t.getPrf()}};
        }
        else
        {
            j["cw_mode"] = nlohmann::json::object();
        }
        if (!t.getSchedule().empty())
        {
            j["schedule"] = t.getSchedule();
        }
    }

References radar::Radar::getAntenna(), radar::Transmitter::getMode(), antenna::Antenna::getName(), radar::Object::getName(), fers_signal::RadarSignal::getName(), radar::Transmitter::getPrf(), radar::Transmitter::getSchedule(), radar::Transmitter::getSignal(), radar::Radar::getTiming(), and PULSED_MODE.

Here is the call graph for this function: