Struct Event 

pub struct Event {
    pub scalar: ScalarExpr,
    pub condition: Condition,
    pub epoch_precision: Duration,
    pub ab_corr: Option<Aberration>,
}

Defines a state parameter event finder from the desired value of the scalar expression to compute, precision on timing and value, and the aberration.

:type scalar: ScalarExpr :type condition: Condition :type epoch_precision: Duration :type ab_corr: Aberration, optional

Fields

scalar: ScalarExpr

Scalar expression to evaluate

condition: Condition

Condition that defines the bounded values of the event.

epoch_precision: Duration

The duration precision used in the adaptive step scanner, and to consider an Event to have converged. Typically use 100 ms.

ab_corr: Option<Aberration>

Implementations

impl Event

pub fn new(scalar: ScalarExpr, condition: Condition) -> Event

Builds a new event where the epoch precision is set to its default of 10 milliseconds

pub fn apoapsis() -> Event

Apoapsis event finder

pub fn periapsis() -> Event

Periapsis event finder

pub fn total_eclipse(eclipsing_frame: Frame) -> Event

Total eclipse event finder: returns events where the eclipsing percentage is greater than 99%.

pub fn eclipse(eclipsing_frame: Frame) -> Event

Eclipse event finder, including penumbras: returns events where the eclipsing percentage is greater than 1%.

pub fn penumbra(eclipsing_frame: Frame) -> Event

Penumbral eclipse event finder: returns events where the eclipsing percentage is greater than 1% and less than 99%.

pub fn visible_from_location_id( location_id: i32, obstructing_body: Option<Frame>, ) -> Event

Report events where the object is above the terrain (or horizon if terrain is not set) when seen from the provided location ID.

pub fn to_s_expr(&self) -> Result<String, Error>

Export this Event to S-Expression / LISP syntax

pub fn from_s_expr(expr: &str) -> Result<Event, Error>

Load this Event from an S-Expression / LISP syntax

impl Event

pub fn eval( &self, orbit: CartesianState, almanac: &Almanac, ) -> Result<f64, AnalysisError>

Compute the event finding function of this event provided an Orbit and Almanac. If we’re “in the event”, the evaluation will be greater or equal to zero.

:type orbit: Orbit :type almanac: Almanac :rtype: float

pub fn eval_string( &self, orbit: CartesianState, almanac: &Almanac, ) -> Result<String, AnalysisError>

Pretty print the evaluation of this event for the provided Orbit and Almanac

:type orbit: Orbit :type almanac: Almanac :rtype: str

Trait Implementations

impl Clone for Event

fn clone(&self) -> Event

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Event

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Event

fn deserialize<__D>( __deserializer: __D, ) -> Result<Event, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Event

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for Event

fn eq(&self, other: &Event) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Event

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Event