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 : std::uint8_t { PULSED_MODE , CW_MODE , FMCW_MODE }
	Defines the operational mode of a radar component. More...

Functions
std::string_view	dechirpModeToken (Receiver::DechirpMode mode) noexcept
	Converts a dechirp mode to its scenario token.
Receiver::DechirpMode	parseDechirpModeToken (std::string_view token)
	Parses a dechirp mode scenario token.
std::string_view	dechirpReferenceSourceToken (Receiver::DechirpReferenceSource source) noexcept
	Converts a dechirp reference source to its scenario token.
Receiver::DechirpReferenceSource	parseDechirpReferenceSourceToken (std::string_view token)
	Parses a dechirp reference source scenario token.
std::vector< SchedulePeriod >	processRawSchedule (const 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, const SimId id=0)
	Creates an isotropic target.
std::unique_ptr< Target >	createFileTarget (Platform *platform, std::string name, const std::string &filename, unsigned seed, const SimId id=0)
	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 : std::uint8_t

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.
FMCW_MODE	The component operates in an FMCW streaming mode.

Definition at line 38 of file radar_obj.h.

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

Function Documentation

createFileTarget()

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

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 297 of file target.h.

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

References max.

Referenced by serial::xml_parser_utils::createDefaultAssetLoaders(), and serial::update_target_from_json().

Here is the caller graph for this function:

createIsoTarget()

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

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 282 of file target.h.

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

References max.

Referenced by serial::xml_parser_utils::parseTarget(), and serial::update_target_from_json().

Here is the caller graph for this function:

dechirpModeToken()

std::string_view radar::dechirpModeToken ( const Receiver::DechirpMode  mode )

noexcept

Converts a dechirp mode to its scenario token.

Definition at line 45 of file receiver.cpp.

    {
        switch (mode)
        {
        case Receiver::DechirpMode::Physical:
            return "physical";
        case Receiver::DechirpMode::Ideal:
            return "ideal";
        case Receiver::DechirpMode::None:
            return "none";
        }
        return "none";
    }

References radar::Receiver::Ideal, radar::Receiver::None, and radar::Receiver::Physical.

Referenced by serial::xml_serializer_utils::serializeReceiverFmcwMode().

Here is the caller graph for this function:

dechirpReferenceSourceToken()

std::string_view radar::dechirpReferenceSourceToken ( const Receiver::DechirpReferenceSource  source )

noexcept

Converts a dechirp reference source to its scenario token.

Definition at line 76 of file receiver.cpp.

    {
        switch (source)
        {
        case Receiver::DechirpReferenceSource::Attached:
            return "attached";
        case Receiver::DechirpReferenceSource::Transmitter:
            return "transmitter";
        case Receiver::DechirpReferenceSource::Custom:
            return "custom";
        case Receiver::DechirpReferenceSource::None:
            return "none";
        }
        return "none";
    }

References radar::Receiver::Attached, radar::Receiver::Custom, radar::Receiver::None, and radar::Receiver::Transmitter.

Referenced by serial::xml_serializer_utils::serializeReceiverFmcwMode().

Here is the caller graph for this function:

from_json()

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

Definition at line 842 of file json_serializer.cpp.

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

References max.

parseDechirpModeToken()

Receiver::DechirpMode radar::parseDechirpModeToken

(

const std::string_view

token

)

Parses a dechirp mode scenario token.

Definition at line 59 of file receiver.cpp.

    {
        if (token == "none")
        {
            return Receiver::DechirpMode::None;
        }
        if (token == "physical")
        {
            return Receiver::DechirpMode::Physical;
        }
        if (token == "ideal")
        {
            return Receiver::DechirpMode::Ideal;
        }
        throw std::runtime_error("Unsupported FMCW dechirp_mode '" + std::string(token) + "'.");
    }

References radar::Receiver::Ideal, max, radar::Receiver::None, and radar::Receiver::Physical.

parseDechirpReferenceSourceToken()

Receiver::DechirpReferenceSource radar::parseDechirpReferenceSourceToken

(

const std::string_view

token

)

Parses a dechirp reference source scenario token.

Definition at line 92 of file receiver.cpp.

    {
        if (token == "attached")
        {
            return Receiver::DechirpReferenceSource::Attached;
        }
        if (token == "transmitter")
        {
            return Receiver::DechirpReferenceSource::Transmitter;
        }
        if (token == "custom")
        {
            return Receiver::DechirpReferenceSource::Custom;
        }
        throw std::runtime_error("Unsupported dechirp_reference source '" + std::string(token) + "'.");
    }

References radar::Receiver::Attached, radar::Receiver::Custom, max, and radar::Receiver::Transmitter.

processRawSchedule()

std::vector< SchedulePeriod > radar::processRawSchedule	(	const 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::ranges::sort(valid_periods, [](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 a, b, params::endTime(), LOG, max, params::startTime(), and logging::WARNING.

Referenced by serial::xml_parser_utils::parseSchedule(), serial::update_monostatic_schedule_from_json(), serial::update_receiver_schedule_from_json(), and serial::update_transmitter_schedule_from_json().

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 937 of file json_serializer.cpp.

    {
        j = {{"id", sim_id_to_json(p.getId())}, {"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 math::RotationPath::INTERP_CONSTANT, and max.

to_json() [2/5]

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

Definition at line 874 of file json_serializer.cpp.

    {
        j = nlohmann::json{{"id", sim_id_to_json(r.getId())},
                           {"name", r.getName()},
                           {"noise_temp", r.getNoiseTemperature()},
                           {"antenna", sim_id_to_json((r.getAntenna() != nullptr) ? r.getAntenna()->getId() : 0)},
                           {"timing", sim_id_to_json(r.getTiming() ? r.getTiming()->getId() : 0)},
                           {"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 if (r.getMode() == OperationMode::FMCW_MODE)
        {
            j["fmcw_mode"] = receiver_fmcw_mode_to_json(r);
        }
        else
        {
            j["cw_mode"] = nlohmann::json::object();
        }
        if (!r.getSchedule().empty())
        {
            j["schedule"] = r.getSchedule();
        }
    }

References radar::Receiver::FLAG_NODIRECT, radar::Receiver::FLAG_NOPROPLOSS, FMCW_MODE, max, and PULSED_MODE.

to_json() [3/5]

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

Definition at line 837 of file json_serializer.cpp.

    {
        j = {{"start", p.start}, {"end", p.end}};
    } // NOLINT(*-use-internal-linkage)

References max.

to_json() [4/5]

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

Definition at line 903 of file json_serializer.cpp.

    {
        j["id"] = sim_id_to_json(t.getId());
        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(), radar::Target::getId(), radar::Object::getName(), and max.

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 848 of file json_serializer.cpp.

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

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

Here is the call graph for this function: