Struct SolidTides 

pub struct SolidTides {
    pub frame: Frame,
    pub k2: f64,
    pub k3: f64,
    pub perturbers: Vec<TidalPerturber>,
}

SolidTides implements the solid tide acceleration model. It accounts for the crust deformation due to the configured tidal perturbers. Formulas are based on IERS 2010 Conventions.

Fields

frame: Frame

The body-fixed frame of the central body being deformed.

k2: f64

2nd degree Love number

k3: f64

3rd degree Love number

perturbers: Vec<TidalPerturber>

The collection of celestial bodies raising the tide.

Implementations

impl SolidTides

pub fn builder() -> SolidTidesBuilder<((), (), (), ())>

Create a builder for building SolidTides. On the builder, call .frame(...), .k2(...), .k3(...), .perturbers(...) to set the values of the fields. Finally, call .build() to create the instance of SolidTides.

impl SolidTides

pub fn earth_moon_system( earth_frame: Frame, moon_frame: Frame, almanac: &Almanac, ) -> Result<Self, DynamicsError>

Initializes solid tides with the Moon and the Sun, where the k3 is only computed for the Moon. Sets the k2 Love number to 0.3019 and the k3 Love number to 0.093

Trait Implementations

impl AccelModel for SolidTides

fn eom( &self, osc: &Orbit, almanac: &Almanac, ) -> Result<Vector3<f64>, DynamicsError>

Defines the equations of motion for this force model from the provided osculating state in the integration frame.

fn gradient( &self, osc: &Orbit, almanac: &Almanac, ) -> Result<(Vector3<f64>, Matrix3<f64>), DynamicsError>

Acceleration models must implement their partials, although those will only be called if the propagation requires the computation of the STM.

impl Clone for SolidTides

fn clone(&self) -> SolidTides

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SolidTides

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

Formats the value using the given formatter.

impl DerefToPyAny for SolidTides

impl<'de> Deserialize<'de> for SolidTides

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SolidTides

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

Formats the value using the given formatter.

impl<'a, 'py> FromPyObject<'a, 'py> for SolidTides

where Self: Clone,

type Error = PyClassGuardError<'a, 'py>

The type returned in the event of a conversion error.

fn extract( obj: Borrowed<'a, 'py, PyAny>, ) -> Result<Self, <Self as FromPyObject<'a, 'py>>::Error>

Extracts Self from the bound smart pointer obj.

impl<'py> IntoPyObject<'py> for SolidTides

type Target = SolidTides

The Python output type

type Output = Bound<'py, <SolidTides as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PartialEq for SolidTides

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

Equality operator ==.

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

Inequality operator !=.

impl PyClass for SolidTides

const NAME: &str = "SolidTides"

Name of the class.

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for SolidTides

const MODULE: Option<&str> = ::core::option::Option::None

Module which the class will be associated with.

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// `SolidTides` implements the solid tide acceleration model. /// It accounts for the crust deformation due to the configured tidal perturbers. /// Formulas are based on IERS 2010 Conventions.

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type Layout = <<SolidTides as PyClassImpl>::BaseNativeType as PyClassBaseType>::Layout<SolidTides>

Description of how this class is laid out in memory

type BaseType = PyAny

Base class

type ThreadChecker = NoopThreadChecker

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForSolidTides

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<PyObjectOffset>

Used to provide the dictoffset slot (equivalent to tp_dictoffset)

fn weaklist_offset() -> Option<PyObjectOffset>

Used to provide the weaklistoffset slot (equivalent to tp_weaklistoffset

impl PyClassNewTextSignature for SolidTides

const TEXT_SIGNATURE: &'static str = "(frame, k2, k3, perturbers)"

impl PyClass__eq__SlotFragment<SolidTides> for PyClassImplCollector<SolidTides>

unsafe fn __eq__( self, py: Python<'_>, _slf: *mut PyObject, arg0: *mut PyObject, ) -> PyResult<*mut PyObject>

Safety: _slf and _other must be valid non-null Python objects

impl PyTypeInfo for SolidTides

const NAME: &str = <Self as ::pyo3::PyClass>::NAME

👎Deprecated since 0.28.0:

prefer using ::type_object(py).name() to get the correct runtime value

Class name.

const MODULE: Option<&str> = <Self as ::pyo3::impl_::pyclass::PyClassImpl>::MODULE

👎Deprecated since 0.28.0:

prefer using ::type_object(py).module() to get the correct runtime value

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl Serialize for SolidTides

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StaticType for SolidTides

where Frame: StaticType, f64: StaticType, Vec<TidalPerturber>: StaticType,

fn static_type() -> SimpleType

Return the Dhall type that represents this type.

impl StructuralPartialEq for SolidTides