"""Webgeocalc calculations types."""
from .calculation import Calculation
from .errors import CalculationInvalidAttr
from .vars import VALID_PARAMETERS
[docs]class StateVector(Calculation):
"""State vector calculation.
Calculates the position of one body relative to another,
calculated in a desired reference frame.
Parameters
----------
aberration_correction: str, optional
See: :py:attr:`aberration_correction`
state_representation: str, optional
See: :py:attr:`state_representation`
Other Parameters
----------------
kernels: str, int, [str or/and int]
See: :py:attr:`kernels`
kernel_paths: str, [str]
See: :py:attr:`kernel_paths`
times: str or [str]
See: :py:attr:`times`
intervals: [str, str] or {'startTime': str, 'endTime': str} or [interval, ...]
See: :py:attr:`intervals`
time_step: int
See: :py:attr:`time_step`
time_step_units: str
See: :py:attr:`time_step_units`
time_system: str
See: :py:attr:`time_system`
time_format: str
See: :py:attr:`time_format`
target: str or int
See: :py:attr:`target`
observer: str or int
See: :py:attr:`observer`
reference_frame: str or int
See: :py:attr:`reference_frame`
Raises
------
CalculationRequiredAttr
If :py:attr:`target`, :py:attr:`observer` and
:py:attr:`reference_frame` are not provided.
"""
REQUIRED = ('target', 'observer', 'reference_frame')
def __init__(self, aberration_correction='CN',
state_representation='RECTANGULAR', **kwargs):
kwargs['calculation_type'] = 'STATE_VECTOR'
kwargs['aberration_correction'] = aberration_correction
kwargs['state_representation'] = state_representation
super().__init__(**kwargs)
[docs]class AngularSeparation(Calculation):
"""Angular separation calculation.
Calculates the angular separation of two bodies as seen by an observer body.
Parameters
----------
shape_1: str, optional
See: :py:attr:`shape_1`
shape_2: str, optional
See: :py:attr:`shape_2`
aberration_correction: str, optional
See: :py:attr:`aberration_correction`
Other Parameters
----------------
kernels: str, int, [str or/and int]
See: :py:attr:`kernels`
kernel_paths: str, [str]
See: :py:attr:`kernel_paths`
times: str or [str]
See: :py:attr:`times`
intervals: [str, str] or {'startTime': str, 'endTime': str} or [interval, ...]
See: :py:attr:`intervals`
time_step: int
See: :py:attr:`time_step`
time_step_units: str
See: :py:attr:`time_step_units`
time_system: str
See: :py:attr:`time_system`
time_format: str
See: :py:attr:`time_format`
target_1: str or int
See: :py:attr:`target_1`
target_2: str or int
See: :py:attr:`target_2`
observer: str or int
See: :py:attr:`observer`
Raises
------
CalculationRequiredAttr
If :py:attr:`target_1`, :py:attr:`target_2` and
:py:attr:`observer` are not provided.
"""
REQUIRED = ('target_1', 'target_2', 'observer')
def __init__(self, shape_1='POINT', shape_2='POINT',
aberration_correction='CN', **kwargs):
kwargs['calculation_type'] = 'ANGULAR_SEPARATION'
kwargs['shape_1'] = shape_1
kwargs['shape_2'] = shape_2
kwargs['aberration_correction'] = aberration_correction
super().__init__(**kwargs)
[docs]class AngularSize(Calculation):
"""Angular size calculation.
Calculates the angular size of a target as seen by an observer.
Parameters
----------
aberration_correction: str, optional
See: :py:attr:`aberration_correction`
Other Parameters
----------------
kernels: str, int, [str or/and int]
See: :py:attr:`kernels`
kernel_paths: str, [str]
See: :py:attr:`kernel_paths`
times: str or [str]
See: :py:attr:`times`
intervals: [str, str] or {'startTime': str, 'endTime': str} or [interval, ...]
See: :py:attr:`intervals`
time_step: int
See: :py:attr:`time_step`
time_step_units: str
See: :py:attr:`time_step_units`
time_system: str
See: :py:attr:`time_system`
time_format: str
See: :py:attr:`time_format`
target: str or int
See: :py:attr:`target`
observer: str or int
See: :py:attr:`observer`
Raises
------
CalculationRequiredAttr
If :py:attr:`target` and :py:attr:`observer` are not provided.
"""
REQUIRED = ('target', 'observer')
def __init__(self, aberration_correction='CN', **kwargs):
kwargs['calculation_type'] = 'ANGULAR_SIZE'
kwargs['aberration_correction'] = aberration_correction
super().__init__(**kwargs)
[docs]class IlluminationAngles(Calculation):
"""Illumination angles calculation.
Calculate the emission, phase and solar incidence angles
at a point on a target as seen from an observer.
Parameters
----------
shape_1: str, optional
See: :py:attr:`shape_1`
coordinate_representation: str, optional
See: :py:attr:`coordinate_representation`
aberration_correction: str, optional
See: :py:attr:`aberration_correction`
Other Parameters
----------------
kernels: str, int, [str or/and int]
See: :py:attr:`kernels`
kernel_paths: str, [str]
See: :py:attr:`kernel_paths`
times: str or [str]
See: :py:attr:`times`
intervals: [str, str] or {'startTime': str, 'endTime': str} or [interval, ...]
See: :py:attr:`intervals`
time_step: int
See: :py:attr:`time_step`
time_step_units: str
See: :py:attr:`time_step_units`
time_system: str
See: :py:attr:`time_system`
time_format: str
See: :py:attr:`time_format`
target: str or int
See: :py:attr:`target`
target_frame: str or int
See: :py:attr:`target_frame`
observer: str or int
See: :py:attr:`observer`
latitude: str or int
See: :py:attr:`latitude`
longitude: str or int
See: :py:attr:`longitude`
Raises
------
CalculationRequiredAttr
If :py:attr:`target`, :py:attr:`target_frame`, :py:attr:`observer`,
:py:attr:`latitude` and :py:attr:`longitude` are not provided.
CalculationInvalidAttr
If :py:attr:`shape_1` is not ``ELLIPSOID`` or ``DSK``.
"""
REQUIRED = ('target', 'target_frame', 'observer', 'latitude', 'longitude')
def __init__(self, shape_1='ELLIPSOID', coordinate_representation='LATITUDINAL',
aberration_correction='CN', **kwargs):
kwargs['calculation_type'] = 'ILLUMINATION_ANGLES'
kwargs['coordinate_representation'] = coordinate_representation
kwargs['aberration_correction'] = aberration_correction
if shape_1 in ['ELLIPSOID', 'DSK']:
kwargs['shape_1'] = shape_1
else:
raise CalculationInvalidAttr('shape_1', shape_1, ['ELLIPSOID', 'DSK'])
super().__init__(**kwargs)
[docs]class SubSolarPoint(Calculation):
"""Sub-solar point calculation.
Calculates the sub-solar point on a target as seen from an observer.
Parameters
----------
sub_point_type: str, optional
See: :py:attr:`sub_point_type`
aberration_correction: str, optional
See: :py:attr:`aberration_correction`
state_representation: str, optional
See: :py:attr:`state_representation`
Warning
-------
Attribute :py:attr:`aberration_correction` must be ``NONE``, `LT``, ``LT+S``,
``CN`` or ``CN+S``.
Other Parameters
----------------
kernels: str, int, [str or/and int]
See: :py:attr:`kernels`
kernel_paths: str, [str]
See: :py:attr:`kernel_paths`
times: str or [str]
See: :py:attr:`times`
intervals: [str, str] or {'startTime': str, 'endTime': str} or [interval, ...]
See: :py:attr:`intervals`
time_step: int
See: :py:attr:`time_step`
time_step_units: str
See: :py:attr:`time_step_units`
time_system: str
See: :py:attr:`time_system`
time_format: str
See: :py:attr:`time_format`
target: str or int
See: :py:attr:`target`
target_frame: str or int
See: :py:attr:`target_frame`
observer: str or int
See: :py:attr:`observer`
Raises
------
CalculationRequiredAttr
If :py:attr:`target`, :py:attr:`target_frame` and :py:attr:`observer`
are not provided.
CalculationInvalidAttr
If :py:attr:`aberration_correction` is in ``XLT``, ``XLT+S``,
``XCN+S`` or ``XCN+S``.
"""
REQUIRED = ('target', 'target_frame', 'observer')
def __init__(self, sub_point_type='Near point: ellipsoid', aberration_correction='CN',
state_representation='RECTANGULAR', **kwargs):
if aberration_correction not in VALID_PARAMETERS['ABERRATION_CORRECTION_NO_X']:
raise CalculationInvalidAttr(
'aberration_correction', aberration_correction,
VALID_PARAMETERS['ABERRATION_CORRECTION_NO_X'])
kwargs['calculation_type'] = 'SUB_SOLAR_POINT'
kwargs['sub_point_type'] = sub_point_type
kwargs['aberration_correction'] = aberration_correction
kwargs['state_representation'] = state_representation
super().__init__(**kwargs)
[docs]class SubObserverPoint(Calculation):
"""Sub-observer point calculation.
Calculate the sub-observer point on a target as seen from an observer.
Parameters
----------
sub_point_type: str, optional
See: :py:attr:`sub_point_type`
aberration_correction: str, optional
See: :py:attr:`aberration_correction`
state_representation: str, optional
See: :py:attr:`state_representation`
Other Parameters
----------------
kernels: str, int, [str or/and int]
See: :py:attr:`kernels`
kernel_paths: str, [str]
See: :py:attr:`kernel_paths`
times: str or [str]
See: :py:attr:`times`
intervals: [str, str] or {'startTime': str, 'endTime': str} or [interval, ...]
See: :py:attr:`intervals`
time_step: int
See: :py:attr:`time_step`
time_step_units: str
See: :py:attr:`time_step_units`
time_system: str
See: :py:attr:`time_system`
time_format: str
See: :py:attr:`time_format`
target: str or int
See: :py:attr:`target`
target_frame: str or int
See: :py:attr:`target_frame`
observer: str or int
See: :py:attr:`observer`
Raises
------
CalculationRequiredAttr
If :py:attr:`target`, :py:attr:`target_frame`
and :py:attr:`observer` are not provided.
"""
REQUIRED = ('target', 'target_frame', 'observer')
def __init__(self, sub_point_type='Near point: ellipsoid', aberration_correction='CN',
state_representation='RECTANGULAR', **kwargs):
kwargs['calculation_type'] = 'SUB_OBSERVER_POINT'
kwargs['sub_point_type'] = sub_point_type
kwargs['aberration_correction'] = aberration_correction
kwargs['state_representation'] = state_representation
super().__init__(**kwargs)
[docs]class SurfaceInterceptPoint(Calculation):
"""Surface intercept point calculation.
Calculate the intercept point of a vector or vectors
on a target as seen from an observer.
Parameters
----------
shape_1: str, optional
See: :py:attr:`shape_1`
direction_vector_type: str, optional
See: :py:attr:`direction_vector_type`
aberration_correction: str, optional
See: :py:attr:`aberration_correction`
state_representation: str, optional
See: :py:attr:`state_representation`
Other Parameters
----------------
kernels: str, int, [str or/and int]
See: :py:attr:`kernels`
kernel_paths: str, [str]
See: :py:attr:`kernel_paths`
times: str or [str]
See: :py:attr:`times`
intervals: [str, str] or {'startTime': str, 'endTime': str} or [interval, ...]
See: :py:attr:`intervals`
time_step: int
See: :py:attr:`time_step`
time_step_units: str
See: :py:attr:`time_step_units`
time_system: str
See: :py:attr:`time_system`
time_format: str
See: :py:attr:`time_format`
target: str or int
See: :py:attr:`target`
target_frame: str or int
See: :py:attr:`target_frame`
observer: str or int
See: :py:attr:`observer`
direction_instrument: str or int
See: :py:attr:`direction_instrument`
direction_frame: str
See: :py:attr:`direction_frame`
direction_frame_axis: str
See: :py:attr:`direction_frame_axis`
direction_vector_x: float
See: :py:attr:`direction_vector_x`
direction_vector_y: float
See: :py:attr:`direction_vector_y`
direction_vector_z: float
See: :py:attr:`direction_vector_z`
direction_vector_ra: float
See: :py:attr:`direction_vector_ra`
direction_vector_dec: float
See: :py:attr:`direction_vector_dec`
Warnings
--------
Attributes :py:attr:`direction_instrument` is needed only if
:py:attr:`direction_vector_type` is ``INSTRUMENT_BORESIGHT``,
``INSTRUMENT_FOV_BOUNDARY_VECTORS`` or ``VECTOR_IN_INSTRUMENT_FOV``.
Attributes :py:attr:`direction_frame` is needed only if
:py:attr:`direction_vector_type` is ``REFERENCE_FRAME_AXIS`` or
``VECTOR_IN_REFERENCE_FRAME``.
Attributes :py:attr:`direction_vector_x` + :py:attr:`direction_vector_y` +
:py:attr:`direction_vector_z` or :py:attr:`direction_vector_ra` +
:py:attr:`direction_vector_dec` is needed only if
:py:attr:`direction_vector_type` is ``VECTOR_IN_INSTRUMENT_FOV`` or
``VECTOR_IN_REFERENCE_FRAME``.
Raises
------
CalculationRequiredAttr
If :py:attr:`target`, :py:attr:`target_frame`
and :py:attr:`observer` are not provided.
CalculationInvalidAttr
If :py:attr:`shape_1` is not ``ELLIPSOID`` or ``DSK``.
"""
REQUIRED = ('target', 'target_frame', 'observer')
def __init__(self, shape_1='ELLIPSOID', direction_vector_type='INSTRUMENT_BORESIGHT',
aberration_correction='CN', state_representation='RECTANGULAR',
**kwargs):
kwargs['calculation_type'] = 'SURFACE_INTERCEPT_POINT'
kwargs['direction_vector_type'] = direction_vector_type
kwargs['aberration_correction'] = aberration_correction
kwargs['state_representation'] = state_representation
if shape_1 in ['ELLIPSOID', 'DSK']:
kwargs['shape_1'] = shape_1
else:
raise CalculationInvalidAttr('shape_1', shape_1, ['ELLIPSOID', 'DSK'])
super().__init__(**kwargs)
[docs]class OsculatingElements(Calculation):
"""Osculating elements calculation.
Calculate the osculating elements of the orbit of a target body around a central body.
The orbit may be elliptical, parabolic, or hyperbolic.
Parameters
----------
reference_frame: str, optional
See: :py:attr:`reference_frame`
Other Parameters
----------------
kernels: str, int, [str or/and int]
See: :py:attr:`kernels`
kernel_paths: str, [str]
See: :py:attr:`kernel_paths`
times: str or [str]
See: :py:attr:`times`
intervals: [str, str] or {'startTime': str, 'endTime': str} or [interval, ...]
See: :py:attr:`intervals`
time_step: int
See: :py:attr:`time_step`
time_step_units: str
See: :py:attr:`time_step_units`
time_system: str
See: :py:attr:`time_system`
time_format: str
See: :py:attr:`time_format`
orbiting_body: str or int
See: :py:attr:`orbiting_body`
center_body: str or int
See: :py:attr:`center_body`
Raises
------
CalculationRequiredAttr
If :py:attr:`orbiting_body` and :py:attr:`center_body` are not provided.
"""
REQUIRED = ('orbiting_body', 'center_body')
def __init__(self, reference_frame='J2000', **kwargs):
kwargs['calculation_type'] = 'OSCULATING_ELEMENTS'
kwargs['reference_frame'] = reference_frame
super().__init__(**kwargs)
[docs]class TimeConversion(Calculation):
"""Time conversion calculation.
Convert times from one time system or format to another.
Parameters
----------
output_time_system: str, optional
See: :py:attr:`output_time_system`
output_time_format: str, optional
See: :py:attr:`output_time_format`
Other Parameters
----------------
kernels: str, int, [str or/and int]
See: :py:attr:`kernels`
kernel_paths: str, [str]
See: :py:attr:`kernel_paths`
times: str or [str]
See: :py:attr:`times`
intervals: [str, str] or {'startTime': str, 'endTime': str} or [interval, ...]
See: :py:attr:`intervals`
time_step: int
See: :py:attr:`time_step`
time_step_units: str
See: :py:attr:`time_step_units`
time_system: str
See: :py:attr:`time_system`
time_format: str
See: :py:attr:`time_format`
output_sclk_id: str
See: :py:attr:`output_sclk_id`
output_time_custom_format: str
See: :py:attr:`output_time_custom_format`
Warnings
--------
Attributes :py:attr:`output_sclk_id` is needed only if
:py:attr:`output_time_system` is ``SPACECRAFT_CLOCK``.
Attributes :py:attr:`output_time_custom_format` is needed only if
:py:attr:`output_time_format` is ``CUSTOM``.
"""
def __init__(self, output_time_system='UTC', output_time_format='CALENDAR', **kwargs):
kwargs['calculation_type'] = 'TIME_CONVERSION'
kwargs['output_time_system'] = output_time_system
kwargs['output_time_format'] = output_time_format
super().__init__(**kwargs)
[docs]class GFCoordinateSearch(Calculation):
"""Coordinate Search (Geometry Finder) calculation.
Find time intervals when a coordinate of an observer-target position vector
satisfies a condition.
Parameters
----------
output_duration_units: str, optional
See: :py:attr:`output_duration_units`
should_complement_window: bool, optional
See: :py:attr:`should_complement_window`
interval_adjustment: str, optional
See: :py:attr:`interval_adjustment`
interval_filtering: str, optional
See: :py:attr:`interval_filtering`
aberration_correction: str, optional
See: :py:attr:`aberration_correction`
coordinate_system: str
See: :py:attr:`coordinate_system`
coordinate: str
See: :py:attr:`coordinate`
relational_condition: str
See: :py:attr:`relational_condition`
reference_value: float, optional
See: :py:attr:`reference_value`
upper_limit: float, optional
See: :py:attr:`upper_limit`
adjustment_value, float, optional
See: :py:attr:`adjustment_value`
Other Parameters
----------------
kernels: str, int, [str or/and int]
See: :py:attr:`kernels`
kernel_paths: str, [str]
See: :py:attr:`kernel_paths`
times: str or [str]
See: :py:attr:`times`
intervals: [str, str] or {'startTime': str, 'endTime': str} or [interval, ...]
See: :py:attr:`intervals`
time_step: int
See: :py:attr:`time_step`
time_step_units: str
See: :py:attr:`time_step_units`
time_system: str
See: :py:attr:`time_system`
time_format: str
See: :py:attr:`time_format`
target: str or int
See: :py:attr:`target`
observer: str or int
See: :py:attr:`observer`
reference_frame: str or int
See: :py:attr:`reference_frame`
Warnings
--------
Attributes :py:attr:`upper_limit` is needed only if
:py:attr:`relational_condition` is ``RANGE``.
Attributes :py:attr:`adjustment_value` is needed only if
:py:attr:`relational_condition` is ``ABSMIN`` or ``ABSMAX``.
Attribute :py:attr:`reference_value` is needed only if
:py:attr:`relational_condition` is ``=``, ``<``, ``>`` or
``RANGE``.
Raises
------
CalculationRequiredAttr
If :py:attr:`target`, :py:attr:`observer`,
:py:attr:`reference_frame`, :py:attr:`coordinate_system`,
:py:attr:`coordinate`, or :py:attr:`relational_condition` are not
provided.
"""
REQUIRED = ('target', 'observer', 'reference_frame', 'relational_condition')
def __init__(self, output_duration_units='SECONDS',
should_complement_window=False,
interval_adjustment='NO_ADJUSTMENT',
interval_filtering='NO_FILTERING',
aberration_correction='CN', **kwargs):
kwargs['calculation_type'] = 'GF_COORDINATE_SEARCH'
kwargs['aberration_correction'] = aberration_correction
kwargs['output_duration_units'] = output_duration_units
kwargs['should_complement_window'] = should_complement_window
kwargs['interval_adjustment'] = interval_adjustment
kwargs['interval_filtering'] = interval_filtering
super().__init__(**kwargs)