Namespace astrea::astro¶

Namespace List > astrea > astro

Namespaces¶

Type	Name
namespace	DOP45
namespace	DOP78
namespace	RK45
namespace	RKF45
namespace	RKF78
namespace	detail
namespace	frames
namespace	planetary_bodies
namespace	plotting

Classes¶

Type	Name
class	AstrodynamicsSystem Represents a system of celestial bodies and their interactions.
class	AtmosphericForce Class to compute the atmospheric force on a vehicle.
class	Cartesian Class representing a Cartesian state vector in astrodynamics.
class	CartesianPartial Class representing a partial derivative of a Cartesian state vector.
class	CartesianVector <class Value_T, class Frame_T> Class representing a 3D vector in Cartesian coordinates.
class	CelestialBody CelestialBody class represents a celestial body in an astrodynamics system.
struct	CelestialBodyParameters
class	Constellation <class Spacecraft_T> A Constellation is a collection ofSpacecraft , organized into Shells and/or Planes.
class	CowellsMethod Class implementing Cowell's method for equations of motion.
class	Cylindrical Class representing a Cylindrical state vector in astrodynamics.
class	Date Class representing a date in the astrea astro library.
class	DirectionCosineMatrix <typename In_Frame_T, typename Out_Frame_T> Class representing a direction cosine matrix (DCM) for transforming vectors between state/frames.
class	EquationsOfMotion Base class for equations of motion in astrodynamics.
class	Equinoctial The Equinoctial class represents the equinoctial orbital elements.
class	EquinoctialPartial Class representing a partial derivative of an Equinoctial state vector.
class	EquinoctialVop Class implementing the Equinoctial VOP equations of motion.
class	Event A class representing a Event in the astrea astro platform. This class serves as a base for user-defined Events and provides a common interface.
class	EventDetector A class for detecting events in the astrea astro platform.
class	Force Abstract base class for force models in astrodynamics.
class	ForceModel Class to manage multiple force models and compute the total force on a vehicle.
struct	Frame <origin, axis> Base class for all state/frames.
class	FrameReference Base class for all frame references.
struct	GeneralPerturbations GeneralPerturbations structure representing a Ground Position (GP) object from SpaceTrack.
class	Geocentric Class representing a Geocentric state vector in astrodynamics.
class	Geodetic Class representing a Geodetic state vector in astrodynamics.
class	ImpulsiveBurn A class representing an impulsive burn Event . It triggers when the true anomaly wraps around (i.e. at perigee), and applies the total impulsive delta-v from all thrusters to the vehicle in the velocity direction. TODO: Generalize to a scheduler of some sort and other burn triggers. TODO: Generalize burn direction. TODO: Generalize which thrusters burn.
class	Integrator Integrator class for numerical propagation of orbital mechanics problems.
class	Interval Represents a time interval with a start and end time.
class	J2MeanVop Class implementing the J2 Mean VOP equations of motion.
struct	JplEphemerisTable Base class for any JPL CelestialBody table.
struct	JulianDateClock A clock implementation for Julian Dates.
class	Keplerian The Keplerian class represents theKeplerian orbital elements.
class	KeplerianPartial Class representing a partial derivative of a Keplerian state vector.
class	KeplerianVop Class implementing the Keplerian VOP equations of motion.
class	LambertSolver Class for solving Lambert's problem.
class	LegendreCache
class	NBodyForce Class to compute the gravitational force due to multiple celestial bodies.
class	NullEvent A class representing a null Event in the astrea astro platform. This class is used as a placeholder for Events that do not have a defined state or mass.
class	NullVehicle A class representing a null vehicle in the astrea astro platform. This class is used as a placeholder for vehicles that do not have a defined state or mass.
class	OblatenessForce Class to compute the gravitational force due to the oblateness of a celestial body.
class	OrbitalElementPartials Class representing partial derivatives of orbital elements.
class	OrbitalElements Class representing a set of orbital elements.
class	Payload <class Payload_T, class PayloadParameters_T> Payload class representing a payload on a platform.
class	PayloadParameters Class for storing and managing payload parameters.
class	PayloadPlatform <class Payload_T> The PayloadPlatform class represents a platform that can have payloads attached to it. It provides methods to attach payloads and retrieve the list of attached payloads.
class	Plane <class Spacecraft_T> A Plane is a collection ofSpacecraft that share the same orbital elements.
class	Shell <class Spacecraft_T> A Shell is a collection of planes, each containing a set ofSpacecraft . It is used to represent sub-constellations of satellites in orbit.
class	SolarRadiationPressure Class to compute the solar radiation pressure force on a spacecraft.
class	Spacecraft A class representing a spacecraft in the astrea astro platform. This class encapsulates the properties of a spacecraft, including its mass, dynamic coefficients, and surface areas.
class	Spherical Class representing a Spherical state vector in astrodynamics.
class	State Class representing the state of an astronomical object.
class	StateHistory Class to manage the history of states for an object over date.
class	StatePartial
class	StateTransitionMatrix
class	Thruster Thruster class representing a thruster on a platform.
class	ThrusterParameters Class for storing and managing thruster parameters.
class	TwoBody Class implementing the Two Body equations of motion.
class	TwoLineElements Class representing the two-line element (TLE) format for orbital data.
class	Vehicle A class representing a vehicle in the astrea astro platform. This class serves as a base for user-defined vehicles and provides a common interface.
struct	is_specialization <class T, Template>
struct	is_specialization< Template< Args... >, Template > <Template, Args>

Public Types¶

Type	Name
typedef CartesianVector< Acceleration, Frame_T >	AccelerationVector Type alias for a vector representing acceleration in 3D space.
enum EnumType	CelestialBodyId Celestial body identifiers.
enum EnumType	CelestialBodyType Celestial body types.
typedef std::unique_ptr< CelestialBody >	CelestialBodyUniquePtr Unique pointer type for CelestialBody .
typedef DirectionCosineMatrix< In_Frame_T, Out_Frame_T >	DCM Alias for DirectionCosineMatrix with a specific output frame type.
typedef uint32_t	EnumType Type definition for enumeration types.
enum EnumType	FrameAxis Reference frames axes.
typedef JulianDateClock::time_point	JulianDate A type alias for Julian Date time points.
typedef std::chrono::time_point< JulianDateClock, Duration >	JulianDateTime A time point type for Julian Dates, using the JulianDateClock .
typedef CartesianVector< Distance, Frame_T >	RadiusVector Type alias for a vector representing a radius in 3D space.
enum EnumType	SystemCenter System center types.
typedef PayloadPlatform< Thruster >	ThrusterPlatform Thruster platform type definition.
typedef CartesianVector< Unitless, Frame_T >	UnitVector Type alias for a vector representing unit vectors in 3D space.
typedef CartesianVector< Velocity, Frame_T >	VelocityVector Type alias for a vector representing velocity in 3D space.
typedef std::remove_cv_t< std::remove_reference_t< T > >	remove_cv_ref

Public Attributes¶

Type	Name
concept	HasDcm = `requires(const [Date](classastrea_1_1astro_1_1Date.md)& date) { get\_dcm<Frame\_T, Frame\_U>(date); }` Concept to determine if a Direction Cosine Matrix (DCM) can be obtained between two frames at a given date.
concept	HasDcmMethod = `/* multi line expression /` Concept to determine if a frame class has a member function to obtain the Direction Cosine Matrix (DCM) to another frame at a given date.*
concept	HasDirectCartesianConversion = `/* multi line expression /` Concept to check if a type can be converted to* Cartesian elements.
concept	HasDirectEquinoctialConversion = `/* multi line expression /` Concept to check if a type can be converted to* Equinoctial elements.
concept	HasDirectKeplerianConversion = `/* multi line expression /` Concept to check if a type can be converted to* Keplerian elements.
concept	HasGetCoefficientOfDrag = `/* multi line expression /` Concept to check if a type has a method to get the coefficient of drag.*
concept	HasGetCoefficientOfLift = `/* multi line expression /` Concept to check if a type has a method to get the coefficient of lift.*
concept	HasGetCoefficientOfReflectivity = `/* multi line expression /` Concept to check if a type has a method to get the coefficient of reflectivity.*
concept	HasGetLiftArea = `/* multi line expression /` Concept to check if a type has a method to get the lift area.*
concept	HasGetMass = `/* multi line expression /` Concept to check if a type has a method to get the mass.*
concept	HasGetName = `/* multi line expression /` Concept to check if a type has a method to get the event name.*
concept	HasGetRamArea = `/* multi line expression /` Concept to check if a type has a method to get the ram area.*
concept	HasGetSolarArea = `/* multi line expression /` Concept to check if a type has a method to get the solar area.*
concept	HasInPlaceMathOperators = `/* multi line expression /` Concept to check if a type has in-place mathematical operators defined.*
concept	HasIsTerminal = `/* multi line expression /` Concept to check if a type has a method to determine if an event is terminal.*
concept	HasIterpolate = `/* multi line expression /` Concept to check if a type can be converted to* Cartesian elements.
concept	HasMathOperators = `/* multi line expression /` Concept to check if a type has mathematical operators defined.*
concept	HasMeasureEvent = `/* multi line expression /` Concept to check if a type has a method to detect an event.*
concept	HasSameAxis = `(Frame\_T::get\_axis() == Frame\_U::get\_axis())` Concept to determine if two frames share the same axis.
concept	HasSameOrigin = `(Frame\_T::get\_origin() == Frame\_U::get\_origin())` Concept to determine if two frames share the same origin.
concept	HasToVector = `/* multi line expression /` Concept to check if a type can be converted to a vector of Unitless.*
concept	HasTriggerEvent = `/* multi line expression /` Concept to check if a type has a method to trigger a post-event action.*
concept	IsBodyFixedFrame = `(Frame\_T::get\_axis() == FrameAxis::BODY\_FIXED)` Concept to determine if a frame is body-fixed.
concept	IsConstructableTo = `/* multi line expression /` Concept to check if a type can be constructed from a set of orbital elements.*
concept	IsDynamicFrame = `/* multi line expression /` Concept to determine if a frame is dynamic (LVLH, RIC, VNB).*
concept	IsGenericallyConstructableEvent = `/* multi line expression /` Concept to check if a type can be generically constructed as a* Event .
concept	IsGenericallyConstructableVehicle = `/* multi line expression /` Concept to check if a type can be generically constructed as a* Vehicle .
concept	IsInertialFrame = `(Frame\_T::get\_axis() == FrameAxis::ICRF \\|\\| Frame\_T::get\_axis() == FrameAxis::J2000)` Concept to determine if a frame is inertial.
concept	IsOrbitalElements = `/* multi line expression /` Concept to check if a type is an orbital elements type.*
concept	IsSameFrame = `HasSameOrigin<Frame\_T, Frame\_U> && HasSameAxis<Frame\_T, Frame\_U>` Concept to determine if two frames are the same (same origin and same axis).
concept	IsStaticFrame = `/* multi line expression /` Concept to determine if a frame is static (inertial or body-fixed).*
concept	IsUserDefinedEvent = `/* multi line expression /` Concept to check if a type is a user-defined* Event .
concept	IsUserDefinedVehicle = `/* multi line expression /` Concept to check if a type is a user-defined vehicle.*

Public Static Attributes¶

Type	Name
const astro::RadiusVector< astro::frames::dynamic::ric >	CENTER = `/* multi line expression */`
constexpr mp_units::quantity_point	J2K = `J2000` A constant representing the J2000 epoch in Julian Date format, used as a reference point.
constexpr mp_units::quantity_point	MJDStart = `MJD0` A constant representing the start of the Modified Julian Date epoch.
const astro::RadiusVector< astro::frames::dynamic::ric >	NADIR_RIC = `/* multi line expression */`
const astro::RadiusVector< astro::frames::dynamic::ric >	RADIAL_RIC = `/* multi line expression */`

Public Functions¶

Type	Name
Distance	calculate_geocentric_radius (const Angle & lat, const Distance & rEquitorial, const Distance & rPolar) Calculate the geocentric radius given latitude and Earth's radii.
RadiusVector< frames::earth::earth_fixed >	convert_cylindrical_to_earth_fixed (const Distance & range, const Angle & azimuth, const Distance & elevation) Convert a vector from LLA (Latitude, Longitude, Altitude) to ECEF (Earth-Centered Earth-Fixed) coordinates.
std::tuple< Distance, Angle, Distance >	convert_earth_fixed_to_cylindrical (const RadiusVector< frames::earth::earth_fixed > & rEcef) Convert a vector from ECEF (Earth-Centered Earth-Fixed) to LLA (Latitude, Longitude, Altitude) coordinates.
std::tuple< Angle, Angle, Distance >	convert_earth_fixed_to_geocentric (const RadiusVector< frames::earth::earth_fixed > & rEcef, const Distance & rEquitorial, const Distance & rPolar) Convert a vector from ECEF (Earth-Centered Earth-Fixed) to LLA (Latitude, Longitude, Altitude) coordinates.
std::tuple< Angle, Angle, Distance >	convert_earth_fixed_to_geodetic (const RadiusVector< frames::earth::earth_fixed > & rEcef, const Distance & rEquitorial, const Distance & rPolar) Convert a vector from ECEF (Earth-Centered Earth-Fixed) to LLA (Latitude, Longitude, Altitude) coordinates.
std::tuple< Distance, Angle, Angle >	convert_earth_fixed_to_spherical (const RadiusVector< frames::earth::earth_fixed > & rEcef) Convert a vector from ECEF (Earth-Centered Earth-Fixed) to LLA (Latitude, Longitude, Altitude) coordinates.
Angle	convert_eccentric_anomaly_to_mean_anomaly (const Angle & ea, const Unitless ecc) Convert the eccentric anomaly to the mean anomaly.
RadiusVector< frames::earth::earth_fixed >	convert_geocentric_to_earth_fixed (const Angle & lat, const Angle & lon, const Distance & alt, const Distance & rEquitorial, const Distance & rPolar) Convert a vector from LLA (Latitude, Longitude, Altitude) to ECEF (Earth-Centered Earth-Fixed) coordinates.
RadiusVector< frames::earth::earth_fixed >	convert_geodetic_to_earth_fixed (const Angle & lat, const Angle & lon, const Distance & alt, const Distance & rEquitorial, const Distance & rPolar) Convert a vector from LLA (Latitude, Longitude, Altitude) to ECEF (Earth-Centered Earth-Fixed) coordinates.
Angle	convert_mean_anomaly_to_eccentric_anomaly (const Angle & ma, const Unitless ecc) Convert the mean anomaly to the eccentric anomaly using Newton's method.
Angle	convert_mean_anomaly_to_true_anomaly (const Angle & ma, const Unitless ecc) Convert the mean anomaly to the true anomaly. Accurate to O(e^4).
RadiusVector< frames::earth::earth_fixed >	convert_spherical_to_earth_fixed (const Distance & range, const Angle & inclination, const Angle & azimuth) Convert a vector from LLA (Latitude, Longitude, Altitude) to ECEF (Earth-Centered Earth-Fixed) coordinates.
Angle	convert_true_anomaly_to_mean_anomaly (const Angle & ta, const Unitless ecc) Convert the true anomaly to the mean anomaly. Accurate to O(e^5).
JulianDate	epoch_to_julian_date (const std::string & epoch, const std::string format="%Y-%m-%d %H:%M:%S") Convert a string representation of a date to a JulianDate object.
Frame_U	get_dcm (const Date & date)
DirectionCosineMatrix< frames::earth::icrf, frames::earth::earth_fixed >	get_dcm< frames::earth::icrf, frames::earth::earth_fixed > (const Date & date) Get the Direction Cosine Matrix (DCM) for the ECEF frame at a given date.
constexpr std::size_t	get_variant_index ()
Angle	julian_date_to_sidereal_time (const JulianDate & date) Convert a JulianDate to a string representation.
bool	nearly_equal (const OrbitalElements & first, const OrbitalElements & second, bool ignoreFastVariable=false, Unitless relTol=1.0e-5 astrea::detail::unitless) Checks if two* OrbitalElements objects are nearly equal.
bool	nearly_equal (const OrbitalElementPartials & first, const OrbitalElementPartials & second, bool ignoreFastVariable=false, Unitless relTol=1.0e-5 astrea::detail::unitless) Checks if two* OrbitalElementPartials objects are nearly equal.
std::ostream &	operator<< (std::ostream & os, Cylindrical const & elements)
std::ostream &	operator<< (std::ostream & os, Geocentric const & elements)
std::ostream &	operator<< (std::ostream & os, Geodetic const & elements)
std::ostream &	operator<< (std::ostream & os, Spherical const & elements)
std::ostream &	operator<< (std::ostream & os, const std::optional< T > & opt) Overloaded output stream operator for an optional type.
std::ostream &	operator<< (std::ostream & os, const GeneralPerturbations & gp) Overloaded output stream operator for GeneralPerturbations .
std::ostream &	operator<< (std::ostream & os, TwoLineElements const & elements)
std::ostream &	operator<< (std::ostream & os, Cartesian const & elements)
std::ostream &	operator<< (std::ostream & os, CartesianPartial const & elements)
std::ostream &	operator<< (std::ostream & os, Equinoctial const & elements)
std::ostream &	operator<< (std::ostream & os, EquinoctialPartial const & elements)
std::ostream &	operator<< (std::ostream & os, Keplerian const & elements)
std::ostream &	operator<< (std::ostream & os, KeplerianPartial const & elements)
std::ostream &	operator<< (std::ostream & os, const OrbitalElements & elements)
std::ostream &	operator<< (std::ostream & os, const OrbitalElementPartials & elements)
std::ostream &	operator<< (std::ostream & os, const State & state)
std::ostream &	operator<< (std::ostream & os, const Date & obj)
	requires (origin !=CelestialBodyId::UNSET &&origin !=CelestialBodyId::CUSTOM)
	requires (origin !=CelestialBodyId::UNSET)
	requires (axis !=FrameAxis::ICRF &&axis !=FrameAxis::J2000 &&axis !=FrameAxis::BODY_FIXED)
	requires (std::is_constructible< Frame_T >::value) Overload the output stream operator for CartesianVector .
	requires (!std::is_constructible< Frame_T >::value) Overload the output stream operator for CartesianVector .
	requires (< Value_U, CartesianVector >::value) Scalar multiplication operator for CartesianVector .
	requires (Frame_T::get_axis()==FrameAxis::J2000 &&Frame_U::get_axis()==FrameAxis::ICRF &&HasSameOrigin< Frame_T, Frame_U >) Get the Direction Cosine Matrix (DCM) for the J2000 to ICRF at a given date.
void	throw_mismatched_types () Throws an exception for mismatched types in orbital elements.
constexpr Angle	wrap_angle (const Angle & angle) Sanitize an angle to ensure it is within the range [0, 2π).

Public Static Functions¶

Type	Name
constexpr JulianDate	J2000 (JulianDateClock::duration) A constant representing the J2000 epoch in Julian Date format.
constexpr JulianDate	MJD0 (JulianDateClock::duration) A constant representing the Modified Julian Date epoch in JulianDate format.

Public Types Documentation¶

typedef AccelerationVector¶

Type alias for a vector representing acceleration in 3D space.

using astrea::astro::AccelerationVector = typedef CartesianVector<Acceleration, Frame_T>;

enum CelestialBodyId¶

Celestial body identifiers.

href="#__codelineno-1-1">enum astrea::astro::CelestialBodyId { UNSET, SUN, MERCURY, VENUS, EARTH, MOON, MARS, PHOBOS, DEIMOS, JUPITER, GANYMEDE, CALLISTO, IO, EUROPA, SATURN, TITAN, RHEA, IAPETUS, URANUS, TITANIA, OBERON, NEPTUNE, TRITON, SOLAR_SYSTEM_BARYCENTER, MERCURY_BARYCENTER, VENUS_BARYCENTER, EARTH_BARYCENTER, MARS_BARYCENTER, JUPITER_BARYCENTER, SATURN_BARYCENTER, URANUS_BARYCENTER, NEPTUNE_BARYCENTER, CUSTOM };

enum CelestialBodyType¶

Celestial body types.

enum astrea::astro::CelestialBodyType {
    UNSET,
    STAR,
    PLANET,
    MOON
};

typedef CelestialBodyUniquePtr¶

Unique pointer type for CelestialBody .

using astrea::astro::CelestialBodyUniquePtr = typedef std::unique_ptr<CelestialBody>;

typedef DCM¶

Alias for DirectionCosineMatrix with a specific output frame type.

using astrea::astro::DCM = typedef DirectionCosineMatrix<In_Frame_T, Out_Frame_T>;

This alias simplifies the usage of DirectionCosineMatrix by allowing the user to specify the output frame type.

Template parameters:

Out_Frame_T The frame type to which the DCM applies.

typedef EnumType¶

Type definition for enumeration types.

using astrea::astro::EnumType = typedef uint32_t;

enum FrameAxis¶

Reference frames axes.

enum astrea::astro::FrameAxis {
    ICRF,
    J2000,
    BODY_FIXED,
    LVLH,
    RIC,
    VNB,
    ENU
};

typedef JulianDate¶

A type alias for Julian Date time points.

using astrea::astro::JulianDate = typedef JulianDateClock::time_point;

This is a convenience type alias for Julian Date time points using the JulianDateClock.

typedef JulianDateTime¶

A time point type for Julian Dates, using the JulianDateClock .

using astrea::astro::JulianDateTime = typedef std::chrono::time_point<JulianDateClock, Duration>;

Template parameters:

Duration The duration type to use for the time point. This should be a duration type that is compatible with JulianDateClock.

typedef RadiusVector¶

Type alias for a vector representing a radius in 3D space.

using astrea::astro::RadiusVector = typedef CartesianVector<Distance, Frame_T>;

enum SystemCenter¶

System center types.

enum astrea::astro::SystemCenter {
    CENTRAL_BODY,
    BARYCENTER
};

typedef ThrusterPlatform¶

Thruster platform type definition.

using astrea::astro::ThrusterPlatform = typedef PayloadPlatform<Thruster>;

typedef UnitVector¶

Type alias for a vector representing unit vectors in 3D space.

using astrea::astro::UnitVector = typedef CartesianVector<Unitless, Frame_T>;

This is used for direction vectors that do not have units of distance, velocity, or acceleration.

typedef VelocityVector¶

Type alias for a vector representing velocity in 3D space.

using astrea::astro::VelocityVector = typedef CartesianVector<Velocity, Frame_T>;

typedef remove_cv_ref¶

using astrea::astro::remove_cv_ref = typedef std::remove_cv_t<std::remove_reference_t<T> >;

Public Attributes Documentation¶

variable HasDcm¶

Concept to determine if a Direction Cosine Matrix (DCM) can be obtained between two frames at a given date.

concept astrea::astro::HasDcm;

Template parameters:

Frame_T The first frame type to check.
Frame_U The second frame type to check.

Parameters:

date The date at which to obtain the DCM.

Returns:

true if the specialization of get_dcm has been defined, false otherwise.

variable HasDcmMethod¶

Concept to determine if a frame class has a member function to obtain the Direction Cosine Matrix (DCM) to another frame at a given date.

concept astrea::astro::HasDcmMethod;

Template parameters:

Frame_T The frame type to check.
Frame_U The target frame type to check.

Parameters:

frame An instance of the frame type.
date The date at which to obtain the DCM.

Returns:

true if the frame class has a member function get_dcm for the target frame, false otherwise.

variable HasDirectCartesianConversion¶

Concept to check if a type can be converted to Cartesian elements.

concept astrea::astro::HasDirectCartesianConversion;

Template parameters:

T The type to check.

variable HasDirectEquinoctialConversion¶

Concept to check if a type can be converted to Equinoctial elements.

concept astrea::astro::HasDirectEquinoctialConversion;

Template parameters:

T The type to check.

variable HasDirectKeplerianConversion¶

Concept to check if a type can be converted to Keplerian elements.

concept astrea::astro::HasDirectKeplerianConversion;

Template parameters:

T The type to check.

variable HasGetCoefficientOfDrag¶

Concept to check if a type has a method to get the coefficient of drag.

concept astrea::astro::HasGetCoefficientOfDrag;

Template parameters:

T The type to check.

variable HasGetCoefficientOfLift¶

Concept to check if a type has a method to get the coefficient of lift.

concept astrea::astro::HasGetCoefficientOfLift;

Template parameters:

T The type to check.

variable HasGetCoefficientOfReflectivity¶

Concept to check if a type has a method to get the coefficient of reflectivity.

concept astrea::astro::HasGetCoefficientOfReflectivity;

Template parameters:

T The type to check.

variable HasGetLiftArea¶

Concept to check if a type has a method to get the lift area.

concept astrea::astro::HasGetLiftArea;

Template parameters:

T The type to check.

variable HasGetMass¶

Concept to check if a type has a method to get the mass.

concept astrea::astro::HasGetMass;

Template parameters:

T The type to check.

variable HasGetName¶

Concept to check if a type has a method to get the event name.

concept astrea::astro::HasGetName;

Template parameters:

T The type to check.

variable HasGetRamArea¶

Concept to check if a type has a method to get the ram area.

concept astrea::astro::HasGetRamArea;

Template parameters:

T The type to check.

variable HasGetSolarArea¶

Concept to check if a type has a method to get the solar area.

concept astrea::astro::HasGetSolarArea;

Template parameters:

T The type to check.

variable HasInPlaceMathOperators¶

Concept to check if a type has in-place mathematical operators defined.

concept astrea::astro::HasInPlaceMathOperators;

Template parameters:

T The type to check.

variable HasIsTerminal¶

Concept to check if a type has a method to determine if an event is terminal.

concept astrea::astro::HasIsTerminal;

Template parameters:

T The type to check.

variable HasIterpolate¶

Concept to check if a type can be converted to Cartesian elements.

concept astrea::astro::HasIterpolate;

Template parameters:

T The type to check.

variable HasMathOperators¶

Concept to check if a type has mathematical operators defined.

concept astrea::astro::HasMathOperators;

Template parameters:

T The type to check.

variable HasMeasureEvent¶

Concept to check if a type has a method to detect an event.

concept astrea::astro::HasMeasureEvent;

Template parameters:

T The type to check.

variable HasSameAxis¶

Concept to determine if two frames share the same axis.

concept astrea::astro::HasSameAxis;

Template parameters:

Frame_T The first frame type to check.
Frame_U The second frame type to check.

Returns:

true if both frames share the same axis, false otherwise.

variable HasSameOrigin¶

Concept to determine if two frames share the same origin.

concept astrea::astro::HasSameOrigin;

Template parameters:

Frame_T The first frame type to check.
Frame_U The second frame type to check.

Returns:

true if both frames share the same origin, false otherwise.

variable HasToVector¶

Concept to check if a type can be converted to a vector of Unitless.

concept astrea::astro::HasToVector;

Template parameters:

T The type to check.

variable HasTriggerEvent¶

Concept to check if a type has a method to trigger a post-event action.

concept astrea::astro::HasTriggerEvent;

Template parameters:

T The type to check.

variable IsBodyFixedFrame¶

Concept to determine if a frame is body-fixed.

concept astrea::astro::IsBodyFixedFrame;

Template parameters:

Frame_T The frame type to check.

Returns:

true if the frame is body-fixed, false otherwise.

variable IsConstructableTo¶

Concept to check if a type can be constructed from a set of orbital elements.

concept astrea::astro::IsConstructableTo;

Template parameters:

T The type to check.
U The type to construct from.

variable IsDynamicFrame¶

Concept to determine if a frame is dynamic (LVLH, RIC, VNB).

concept astrea::astro::IsDynamicFrame;

Template parameters:

Frame_T The frame type to check.

Returns:

true if the frame is dynamic, false otherwise.

variable IsGenericallyConstructableEvent¶

Concept to check if a type can be generically constructed as a Event .

concept astrea::astro::IsGenericallyConstructableEvent;

Template parameters:

T The type to check.

variable IsGenericallyConstructableVehicle¶

Concept to check if a type can be generically constructed as a Vehicle .

concept astrea::astro::IsGenericallyConstructableVehicle;

Template parameters:

T The type to check.

variable IsInertialFrame¶

Concept to determine if a frame is inertial.

concept astrea::astro::IsInertialFrame;

Template parameters:

Frame_T The frame type to check.

Returns:

true if the frame is inertial (ICRF or J2000), false otherwise.

variable IsOrbitalElements¶

Concept to check if a type is an orbital elements type.

concept astrea::astro::IsOrbitalElements;

This concept checks if a type is a valid orbital elements type, ensuring it meets the requirements for being default constructible, copyable, movable, destructible, and convertible to Cartesian elements.

Template parameters:

T The type to check.

variable IsSameFrame¶

Concept to determine if two frames are the same (same origin and same axis).

concept astrea::astro::IsSameFrame;

Template parameters:

Frame_T The first frame type to check.
Frame_U The second frame type to check.

Returns:

true if both frames are the same, false otherwise.

variable IsStaticFrame¶

Concept to determine if a frame is static (inertial or body-fixed).

concept astrea::astro::IsStaticFrame;

Template parameters:

Frame_T The frame type to check.

Returns:

true if the frame is static, false otherwise.

variable IsUserDefinedEvent¶

Concept to check if a type is a user-defined Event .

concept astrea::astro::IsUserDefinedEvent;

Template parameters:

T The type to check.

variable IsUserDefinedVehicle¶

Concept to check if a type is a user-defined vehicle.

concept astrea::astro::IsUserDefinedVehicle;

Template parameters:

T The type to check.

Public Static Attributes Documentation¶

variable CENTER¶

const astro::RadiusVector<astro::frames::dynamic::ric> astrea::astro::CENTER;

variable J2K¶

A constant representing the J2000 epoch in Julian Date format, used as a reference point.

constexpr mp_units::quantity_point astrea::astro::J2K;

This is the same as J2000 but is defined for clarity in contexts where a reference point is needed.

variable MJDStart¶

A constant representing the start of the Modified Julian Date epoch.

constexpr mp_units::quantity_point astrea::astro::MJDStart;

This is used as a reference point for Modified Julian Dates.

variable NADIR_RIC¶

const astro::RadiusVector<astro::frames::dynamic::ric> astrea::astro::NADIR_RIC;

variable RADIAL_RIC¶

const astro::RadiusVector<astro::frames::dynamic::ric> astrea::astro::RADIAL_RIC;

Public Functions Documentation¶

function calculate_geocentric_radius¶

Calculate the geocentric radius given latitude and Earth's radii.

Distance astrea::astro::calculate_geocentric_radius (
    const Angle & lat,
    const Distance & rEquitorial,
    const Distance & rPolar
)

Parameters:

lat The latitude in radians.
rEquitorial The equatorial radius of the Earth.
rPolar The polar radius of the Earth.

Returns:

The geocentric radius.

function convert_cylindrical_to_earth_fixed¶

Convert a vector from LLA (Latitude, Longitude, Altitude) to ECEF (Earth-Centered Earth-Fixed) coordinates.

RadiusVector < frames::earth::earth_fixed > astrea::astro::convert_cylindrical_to_earth_fixed (
    const Distance & range,
    const Angle & azimuth,
    const Distance & elevation
)

Parameters:

range The range in meters.
azimuth The azimuth in radians.
elevation The elevation in meters.

Returns:

The radius vector in ECEF coordinates.

function convert_earth_fixed_to_cylindrical¶

Convert a vector from ECEF (Earth-Centered Earth-Fixed) to LLA (Latitude, Longitude, Altitude) coordinates.

std::tuple< Distance, Angle, Distance > astrea::astro::convert_earth_fixed_to_cylindrical (
    const RadiusVector < frames::earth::earth_fixed > & rEcef
)

Parameters:

rEcef The radius vector in ECEF coordinates.

Returns:

The range, azimuth, and elevation as a tuple.

function convert_earth_fixed_to_geocentric¶

Convert a vector from ECEF (Earth-Centered Earth-Fixed) to LLA (Latitude, Longitude, Altitude) coordinates.

std::tuple< Angle, Angle, Distance > astrea::astro::convert_earth_fixed_to_geocentric (
    const RadiusVector < frames::earth::earth_fixed > & rEcef,
    const Distance & rEquitorial,
    const Distance & rPolar
)

Parameters:

rEcef The radius vector in ECEF coordinates.
rEquitorial The equatorial radius of the Earth.
rPolar The polar radius of the Earth.

Returns:

The latitude, longitude, and altitude as a tuple.

function convert_earth_fixed_to_geodetic¶

Convert a vector from ECEF (Earth-Centered Earth-Fixed) to LLA (Latitude, Longitude, Altitude) coordinates.

std::tuple< Angle, Angle, Distance > astrea::astro::convert_earth_fixed_to_geodetic (
    const RadiusVector < frames::earth::earth_fixed > & rEcef,
    const Distance & rEquitorial,
    const Distance & rPolar
)

Parameters:

rEcef The radius vector in ECEF coordinates.
rEquitorial The equatorial radius of the Earth.
rPolar The polar radius of the Earth.

Returns:

The latitude, longitude, and altitude as a tuple.

function convert_earth_fixed_to_spherical¶

Convert a vector from ECEF (Earth-Centered Earth-Fixed) to LLA (Latitude, Longitude, Altitude) coordinates.

std::tuple< Distance, Angle, Angle > astrea::astro::convert_earth_fixed_to_spherical (
    const RadiusVector < frames::earth::earth_fixed > & rEcef
)

Parameters:

rEcef The radius vector in ECEF coordinates.

Returns:

The range, inclination, and azimuth as a tuple.

function convert_eccentric_anomaly_to_mean_anomaly¶

Convert the eccentric anomaly to the mean anomaly.

Angle astrea::astro::convert_eccentric_anomaly_to_mean_anomaly (
    const Angle & ea,
    const Unitless ecc
)

Parameters:

ea The eccentric anomaly.
ecc The eccentricity.

Returns:

The mean anomaly.

function convert_geocentric_to_earth_fixed¶

Convert a vector from LLA (Latitude, Longitude, Altitude) to ECEF (Earth-Centered Earth-Fixed) coordinates.

RadiusVector < frames::earth::earth_fixed > astrea::astro::convert_geocentric_to_earth_fixed (
    const Angle & lat,
    const Angle & lon,
    const Distance & alt,
    const Distance & rEquitorial,
    const Distance & rPolar
)

Parameters:

lat The latitude in radians.
lon The longitude in radians.
alt The altitude in meters.
rEquitorial The equatorial radius of the Earth.
rPolar The polar radius of the Earth.

Returns:

The radius vector in ECEF coordinates.

function convert_geodetic_to_earth_fixed¶

Convert a vector from LLA (Latitude, Longitude, Altitude) to ECEF (Earth-Centered Earth-Fixed) coordinates.

RadiusVector < frames::earth::earth_fixed > astrea::astro::convert_geodetic_to_earth_fixed (
    const Angle & lat,
    const Angle & lon,
    const Distance & alt,
    const Distance & rEquitorial,
    const Distance & rPolar
)

Parameters:

lat The latitude in radians.
lon The longitude in radians.
alt The altitude in meters.
rEquitorial The equatorial radius of the Earth.
rPolar The polar radius of the Earth.

Returns:

The radius vector in ECEF coordinates.

function convert_mean_anomaly_to_eccentric_anomaly¶

Convert the mean anomaly to the eccentric anomaly using Newton's method.

Angle astrea::astro::convert_mean_anomaly_to_eccentric_anomaly (
    const Angle & ma,
    const Unitless ecc
)

Parameters:

ma The mean anomaly.
ecc The eccentricity.

Returns:

The eccentric anomaly.

function convert_mean_anomaly_to_true_anomaly¶

Convert the mean anomaly to the true anomaly. Accurate to O(e^4).

Angle astrea::astro::convert_mean_anomaly_to_true_anomaly (
    const Angle & ma,
    const Unitless ecc
)

Parameters:

ma The mean anomaly.
ecc The eccentricity.

Returns:

The true anomaly.

function convert_spherical_to_earth_fixed¶

Convert a vector from LLA (Latitude, Longitude, Altitude) to ECEF (Earth-Centered Earth-Fixed) coordinates.

RadiusVector < frames::earth::earth_fixed > astrea::astro::convert_spherical_to_earth_fixed (
    const Distance & range,
    const Angle & inclination,
    const Angle & azimuth
)

Parameters:

azimuth The azimuth in radians.
inclination The inclination in radians.
range The range in meters.

Returns:

The radius vector in ECEF coordinates.

function convert_true_anomaly_to_mean_anomaly¶

Convert the true anomaly to the mean anomaly. Accurate to O(e^5).

Angle astrea::astro::convert_true_anomaly_to_mean_anomaly (
    const Angle & ta,
    const Unitless ecc
)

Parameters:

ta The true anomaly.
ecc The eccentricity.

Returns:

Angle The mean anomaly.

function epoch_to_julian_date¶

Convert a string representation of a date to a JulianDate object.

JulianDate astrea::astro::epoch_to_julian_date (
    const std::string & epoch,
    const std::string format="%Y-%m-%d %H:%M:%S"
)

Parameters:

epoch The date string to convert.
format The format of the date string, default is "%Y-%m-%d %H:%M:%S".

Returns:

JulianDate The JulianDate representation of the input date.

function get_dcm¶

Frame_U astrea::astro::get_dcm (
    const Date & date
)

function get_dcm< frames::earth::icrf, frames::earth::earth_fixed >¶

Get the Direction Cosine Matrix (DCM) for the ECEF frame at a given date.

template<>
inline DirectionCosineMatrix < frames::earth::icrf, frames::earth::earth_fixed > astrea::astro::get_dcm< frames::earth::icrf, frames::earth::earth_fixed > (
    const Date & date
)

Parameters:

date The date for which to get the DCM.

Returns:

DirectionCosineMatrix<frames::earth::icrf, frames::earth::earth_fixed> The DCM from ECI to ECEF.

function get_variant_index¶

template<typename VariantType, typename T, std::size_t index>
constexpr std::size_t astrea::astro::get_variant_index ()

function julian_date_to_sidereal_time¶

Convert a JulianDate to a string representation.

Angle astrea::astro::julian_date_to_sidereal_time (
    const JulianDate & date
)

Parameters:

date The JulianDate to convert.
format The format of the output string, default is "%Y-%m-%d %H:%M:%S".

Returns:

std::string The string representation of the JulianDate.

Note:: This function uses an expantion that only works for Earth-centric sideral times.

function nearly_equal¶

Checks if two OrbitalElements objects are nearly equal.

bool astrea::astro::nearly_equal (
    const OrbitalElements & first,
    const OrbitalElements & second,
    bool ignoreFastVariable=false,
    Unitless relTol=1.0e-5 *astrea::detail::unitless
)

This function compares two OrbitalElements objects for equality within a specified tolerance.

Parameters:

first The first OrbitalElements object to compare.
second The second OrbitalElements object to compare.
ignoreFastVariable If true, ignores fast-changing variables in the comparison.
relTol Relative tolerance for the comparison.

Returns:

true if the two OrbitalElements objects are nearly equal

Returns:

false if the two OrbitalElements objects are not nearly equal

function nearly_equal¶

Checks if two OrbitalElementPartials objects are nearly equal.

bool astrea::astro::nearly_equal (
    const OrbitalElementPartials & first,
    const OrbitalElementPartials & second,
    bool ignoreFastVariable=false,
    Unitless relTol=1.0e-5 *astrea::detail::unitless
)

This function compares two OrbitalElementPartials objects for equality within a specified tolerance.

Parameters:

first The first OrbitalElementPartials object to compare.
second The second OrbitalElementPartials object to compare.
ignoreFastVariable If true, ignores fast-changing variables in the comparison.
relTol Relative tolerance for the comparison.

Returns:

true if the two OrbitalElementPartials objects are nearly equal

Returns:

false if the two OrbitalElementPartials objects are not nearly equal

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    Cylindrical const & elements
)

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    Geocentric const & elements
)

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    Geodetic const & elements
)

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    Spherical const & elements
)

function operator<<¶

Overloaded output stream operator for an optional type.

template<typename T>
std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    const std::optional< T > & opt
)

This function allows printing the contents of an optional type to an output stream.

Parameters:

os The output stream to write to.
opt The optional object to print.

Returns:

The output stream after writing the optional data.

function operator<<¶

Overloaded output stream operator for GeneralPerturbations .

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    const GeneralPerturbations & gp
)

This function allows printing the contents of a GeneralPerturbations object to an output stream.

Parameters:

os The output stream to write to.
gp The GeneralPerturbations object to print.

Returns:

The output stream after writing the GP data.

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    TwoLineElements const & elements
)

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    Cartesian const & elements
)

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    CartesianPartial const & elements
)

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    Equinoctial const & elements
)

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    EquinoctialPartial const & elements
)

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    Keplerian const & elements
)

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    KeplerianPartial const & elements
)

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    const OrbitalElements & elements
)

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    const OrbitalElementPartials & elements
)

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    const State & state
)

function operator<<¶

std::ostream & astrea::astro::operator<< (
    std::ostream & os,
    const Date & obj
)

function requires¶

template<CelestialBodyId origin, FrameAxis axis>
astrea::astro::requires (
    origin !=CelestialBodyId::UNSET &&origin !=CelestialBodyId::CUSTOM
)

function requires¶

template<CelestialBodyId origin>
astrea::astro::requires (
    origin !=CelestialBodyId::UNSET
)

function requires¶

template<class Frame_T, FrameAxis axis>
astrea::astro::requires (
    axis !=FrameAxis::ICRF &&axis != FrameAxis::J2000 &&axis != FrameAxis::BODY_FIXED
)

function requires¶

Overload the output stream operator for CartesianVector .

template<class Value_T, class Frame_T>
astrea::astro::requires (
    std::is_constructible< Frame_T >::value
)

Template parameters:

Value_T The type of the vector components.
Frame_T The type of the frame.

Parameters:

os The output stream.
state The CartesianVector to output.

Returns:

The output stream.

function requires¶

Overload the output stream operator for CartesianVector .

template<class Value_T, class Frame_T>
astrea::astro::requires (
    !std::is_constructible< Frame_T >::value
)

Template parameters:

Value_T The type of the vector components.
Frame_T The type of the frame.

Parameters:

os The output stream.
state The CartesianVector to output.

Returns:

The output stream.

function requires¶

Scalar multiplication operator for CartesianVector .

template<typename Value_T, typename Value_U, typename Frame_T>
astrea::astro::requires (
    ! is_specialization < Value_U, CartesianVector >::value
)

Template parameters:

T The type of the vector components.
U The type of the scalar to multiply with.

Parameters:

scalar The scalar value to multiply with.
vec The CartesianVector to multiply.

Returns:

CartesianVector<decltype(Value_T{} * Value_U{}), Frame_T> A new CartesianVector that is the product of the scalar and the vector.

function requires¶

Get the Direction Cosine Matrix (DCM) for the J2000 to ICRF at a given date.

template<typename Frame_T, typename Frame_U>
astrea::astro::requires (
    Frame_T::get_axis()== FrameAxis::J2000 &&Frame_U::get_axis()== FrameAxis::ICRF &&HasSameOrigin< Frame_T, Frame_U >
)

Parameters:

date The date for which to get the DCM.

Returns:

DirectionCosineMatrix<Frame_T, Frame_U> The DCM from Frame_U to Frame_T.

function throw_mismatched_types¶

Throws an exception for mismatched types in orbital elements.

void astrea::astro::throw_mismatched_types ()

This function is used to throw an exception when the types of two orbital elements do not match.

Exception:

std::runtime_error with a message indicating the mismatch.

function wrap_angle¶

Sanitize an angle to ensure it is within the range [0, 2π).

constexpr Angle astrea::astro::wrap_angle (
    const Angle & angle
)

Parameters:

ang The angle to sanitize.

Returns:

The sanitized angle.

Public Static Functions Documentation¶

function J2000¶

A constant representing the J2000 epoch in Julian Date format.

static constexpr JulianDate astrea::astro::J2000 (
    JulianDateClock::duration { 2451545.0 }
)

This is a commonly used epoch in astronomy, representing January 1, 2000, at 12:00 TT.

function MJD0¶

A constant representing the Modified Julian Date epoch in JulianDate format.

static constexpr JulianDate astrea::astro::MJD0 (
    JulianDateClock::duration { 2400000.5 }
)

This is used as a reference point for Modified Julian Dates.

The documentation for this class was generated from the following file astrea/astro/astro/astro.fwd.hpp