antenna Namespace Reference

Classes
class	Antenna
	Abstract base class representing an antenna. More...
class	Gaussian
	Represents a Gaussian-shaped antenna gain pattern. More...
class	H5Antenna
	Represents an antenna whose gain pattern is loaded from a HDF5 file. More...
class	Isotropic
	Represents an isotropic antenna with uniform gain in all directions. More...
class	Parabolic
	Represents a parabolic reflector antenna. More...
class	Sinc
	Represents a sinc function-based antenna gain pattern. More...
class	SquareHorn
	Represents a square horn antenna. More...
class	XmlAntenna
	Represents an antenna whose gain pattern is defined by an XML file. More...

Functions
void	to_json (nlohmann::json &j, const Antenna &a)
void	from_json (const nlohmann::json &j, std::unique_ptr< Antenna > &ant)

Function Documentation

from_json()

void antenna::from_json	(	const nlohmann::json &	j,
		std::unique_ptr< Antenna > &	ant
	)

Definition at line 324 of file json_serializer.cpp.

    {
        const auto name = j.at("name").get<std::string>();
        const auto pattern = j.value("pattern", "isotropic");
 
        if (pattern == "isotropic")
        {
            ant = std::make_unique<Isotropic>(name);
        }
        else if (pattern == "sinc")
        {
            ant = std::make_unique<Sinc>(name, j.at("alpha").get<RealType>(), j.at("beta").get<RealType>(),
                                         j.at("gamma").get<RealType>());
        }
        else if (pattern == "gaussian")
        {
            ant = std::make_unique<Gaussian>(name, j.at("azscale").get<RealType>(), j.at("elscale").get<RealType>());
        }
        else if (pattern == "squarehorn")
        {
            ant = std::make_unique<SquareHorn>(name, j.at("diameter").get<RealType>());
        }
        else if (pattern == "parabolic")
        {
            ant = std::make_unique<Parabolic>(name, j.at("diameter").get<RealType>());
        }
        else if (pattern == "xml")
        {
            const auto filename = j.value("filename", "");
            if (filename.empty())
            {
                LOG(logging::Level::WARNING, "Skipping load of XML antenna '{}': filename is empty.", name);
                return; // ant remains nullptr
            }
            ant = std::make_unique<XmlAntenna>(name, filename);
        }
        else if (pattern == "file")
        {
            const auto filename = j.value("filename", "");
            if (filename.empty())
            {
                LOG(logging::Level::WARNING, "Skipping load of H5 antenna '{}': filename is empty.", name);
                return; // ant remains nullptr
            }
            ant = std::make_unique<H5Antenna>(name, filename);
        }
        else
        {
            throw std::runtime_error("Unsupported antenna pattern in from_json: " + pattern);
        }
 
        ant->setEfficiencyFactor(j.value("efficiency", 1.0));
    }

References LOG, and logging::WARNING.

to_json()

void antenna::to_json	(	nlohmann::json &	j,
		const Antenna &	a
	)

Definition at line 281 of file json_serializer.cpp.

    {
        j = {{"name", a.getName()}, {"efficiency", a.getEfficiencyFactor()}};
 
        if (const auto* sinc = dynamic_cast<const Sinc*>(&a))
        {
            j["pattern"] = "sinc";
            j["alpha"] = sinc->getAlpha();
            j["beta"] = sinc->getBeta();
            j["gamma"] = sinc->getGamma();
        }
        else if (const auto* gaussian = dynamic_cast<const Gaussian*>(&a))
        {
            j["pattern"] = "gaussian";
            j["azscale"] = gaussian->getAzimuthScale();
            j["elscale"] = gaussian->getElevationScale();
        }
        else if (const auto* sh = dynamic_cast<const SquareHorn*>(&a))
        {
            j["pattern"] = "squarehorn";
            j["diameter"] = sh->getDimension();
        }
        else if (const auto* parabolic = dynamic_cast<const Parabolic*>(&a))
        {
            j["pattern"] = "parabolic";
            j["diameter"] = parabolic->getDiameter();
        }
        else if (const auto* xml = dynamic_cast<const XmlAntenna*>(&a))
        {
            j["pattern"] = "xml";
            j["filename"] = xml->getFilename();
        }
        else if (const auto* h5 = dynamic_cast<const H5Antenna*>(&a))
        {
            j["pattern"] = "file";
            j["filename"] = h5->getFilename();
        }
        else
        {
            j["pattern"] = "isotropic";
        }
    }

References antenna::Antenna::getEfficiencyFactor(), and antenna::Antenna::getName().

Here is the call graph for this function: