WebGeoCalc calculations

For now only these geometry/time calculations are implemented:

Import generic WebGeoCalc calculation object:

>>> from webgeocalc import Calculation

or import specific WebGeoCalc calculation object:

>>> from webgeocalc import StateVector, AngularSeparation

Inputs examples and payloads

All WebGeoCalc calculation objects take their input attributes in snakecase format.

>>> calc = Calculation(
...    kernels = 5,
...    times = '2012-10-19T08:24:00.000',
...    calculation_type = 'STATE_VECTOR',
...    target = 'CASSINI',
...    observer = 'SATURN',
...    reference_frame = 'IAU_SATURN',
...    aberration_correction = 'NONE',
...    state_representation = 'PLANETOGRAPHIC',
... )

Important

Calculation required parameters:
Calculation default parameters:

Note

By default, if no api option is provided, the query is sent to the WGC_URL API (if set in the global environment variables) or JPL API (if not). See API docs for details.

To query on the ESA WGC API, you need to add the ESA key to the any Calculation parameters:

>>> Calculation(
...    api = 'ESA',
...    kernels = 6,
...    times = '2014-01-01T01:23:45.000',
...    calculation_type = 'STATE_VECTOR',
...    target = '67P/CHURYUMOV-GERASIMENKO (1969 R1)',
...    observer = 'ROSETTA ORBITER',
...    reference_frame = '67P/C-G_CK',
...    aberration_correction = 'NONE',
...    state_representation = 'LATITUDINAL',
... ).api
<Api> http://spice.esac.esa.int/webgeocalc/api

3-rd party WGC are also supported, either set WGC_URL on your system (as mention before), or you can provide directly its URL to the api parameter:

>>> Calculation(
...    api = 'https://wgc.obspm.fr/webgeocalc/api',
...    kernels = 6,
...    times = '2014-01-01T01:23:45.000',
...    calculation_type = 'STATE_VECTOR',
...    target = '67P/CHURYUMOV-GERASIMENKO (1969 R1)',
...    observer = 'ROSETTA ORBITER',
...    reference_frame = '67P/C-G_CK',
...    aberration_correction = 'NONE',
...    state_representation = 'LATITUDINAL',
... ).api
<Api> https://wgc.obspm.fr/webgeocalc/api

In each cases, every new API is cached to improve the kernels loading performances.

The payload that will be submitted to the WebGeoCalc API can be retrieve with the payload attribute:

>>> calc.payload
{'kernels': [{'type': 'KERNEL_SET', 'id': 5}],
 'times': ['2012-10-19T08:24:00.000'],
 'calculationType': 'STATE_VECTOR',
 'target': 'CASSINI',
 'observer': 'SATURN',
 'referenceFrame': 'IAU_SATURN',
 'aberrationCorrection': 'NONE',
 'stateRepresentation': 'PLANETOGRAPHIC',
 'timeSystem': 'UTC',
 'timeFormat': 'CALENDAR'}

Example of StateVector calculation with multi kernels inputs (requested by name in this case), with multiple times inputs for target, observer and reference_frame requested by id:

>>> StateVector(
...    kernels = ['Solar System Kernels', 'Cassini Huygens'],
...    times = ['2012-10-19T07:00:00', '2012-10-19T09:00:00'],
...    target = -82,             # CASSINI
...    observer = 699,           # SATURN
...    reference_frame = 10016,  # IAU_SATURN
... ).payload
{'kernels': [{'type': 'KERNEL_SET', 'id': 1},
             {'type': 'KERNEL_SET', 'id': 5}],
 'times': ['2012-10-19T07:00:00', '2012-10-19T09:00:00'],
 'target': -82,
 'observer': 699,
 'referenceFrame': 10016,
 'calculationType': 'STATE_VECTOR',
 'aberrationCorrection': 'CN',
 'stateRepresentation': 'RECTANGULAR',
 'timeSystem': 'UTC',
 'timeFormat': 'CALENDAR'}

Example of AngularSeparation calculation with specific kernel_paths and multiple intervals:

>>> AngularSeparation(
...    kernel_paths = [
...         'pds/wgc/kernels/lsk/naif0012.tls',
...         'pds/wgc/kernels/spk/de430.bsp'
...    ],
...    intervals = [
...        ['2000-01-01', '2000-01-03'],
...        ['2000-02-01', '2000-02-03']
...    ],
...    time_step = 1,
...    time_step_units = 'DAYS',
...    target_1 = 'VENUS',
...    target_2 = 'MERCURY',
...    observer = 'SUN',
... ).payload
{'kernels': [{'type': 'KERNEL', 'path': 'pds/wgc/kernels/lsk/naif0012.tls'},
             {'type': 'KERNEL', 'path': 'pds/wgc/kernels/spk/de430.bsp'}],
 'intervals': [{'startTime': '2000-01-01', 'endTime': '2000-01-03'},
               {'startTime': '2000-02-01', 'endTime': '2000-02-03'}],
 'timeStep': 1,
 'timeStepUnits': 'DAYS',
 'target1': 'VENUS',
 'target2': 'MERCURY',
 'observer': 'SUN',
 'calculationType': 'ANGULAR_SEPARATION',
 'shape1': 'POINT',
 'shape2': 'POINT',
 'aberrationCorrection': 'CN',
 'timeSystem': 'UTC',
 'timeFormat': 'CALENDAR'}

Submit payload and retrieve results

Calculation requests to the WebGeoCalc API are made in three steps:

1. The payload is submitted to the API with Calculation.submit() method, and a calculation-id is retrieved:

>>> calc.submit()
[Calculation submit] Status: LOADING_KERNELS (id: 8750344d-645d-4e43-b159-c8d88d28aac6)

2. If the calculation status is COMPLETE, the results can be directly retrieved. Otherwise, you need to update the calculation status with Calculation.update() method:

>>> calc.update()
[Calculation update] Status: COMPLETE (id: 8750344d-645d-4e43-b159-c8d88d28aac6)

3. When the calculation status is COMPLETE, the results are retrieved by the results attribute:

>>> calc.results
{
    'DATE': '2012-10-19 09:00:00.000000 UTC',
    'DISTANCE': 764142.63776247,
    'SPEED': 111.54765899,
    'X': 298292.85744169,
    'Y': -651606.58468976,
    'Z': 265224.81187627,
    'D_X_DT': -98.8032491,
    'D_Y_DT': -51.73211296,
    'D_Z_DT': -2.1416539,
    'TIME_AT_TARGET': '2012-10-19 08:59:57.451094 UTC',
    'LIGHT_TIME': 2.54890548
}

Tip

It is possible to submit, update and retrieve the results at once with Calculation.run() method:

>>> calc.run()
[Calculation submit] Status: LOADING_KERNELS (id: 8750344d-645d-4e43-b159-c8d88d28aac6)
[Calculation update] Status: COMPLETE (id: 8750344d-645d-4e43-b159-c8d88d28aac6)
{'DATE': '2012-10-19 09:00:00.000000 UTC',
 'DISTANCE': 764142.63776247,
 'SPEED': 111.54765899,
 'X': 298292.85744169,
 'Y': -651606.58468976,
 'Z': 265224.81187627,
 'D_X_DT': -98.8032491,
 'D_Y_DT': -51.73211296,
 'D_Z_DT': -2.1416539,
 'TIME_AT_TARGET': '2012-10-19 08:59:57.451094 UTC',
 'LIGHT_TIME': 2.54890548}

Calculation names

The Webgeocalc API calculation names slightly differ from the calculation feature names accessible from the Webgeocalc GUI web portals.

Webgeocalc API vs GUI calculation names
python-webgeocalc
API classes
Webgeocalc API
calculation types
Webgeocalc GUI
features

StateVector

STATE_VECTOR

State Vector

AngularSeparation

ANGULAR_SEPARATION

Angular Separation

AngularSize

ANGULAR_SIZE

Angular Size

FrameTransformation

FRAME_TRANSFORMATION

Frame Transformation

IlluminationAngles

ILLUMINATION_ANGLES

Illumination Angles

PhaseAngle

PHASE_ANGLE

Phase Angle

PointingDirection

POINTING_DIRECTION

Pointing Direction

SubSolarPoint

SUB_SOLAR_POINT

Sub-solar Point

SubObserverPoint

SUB_OBSERVER_POINT

Sub-observer Point

SurfaceInterceptPoint

SURFACE_INTERCEPT_POINT

Surface Intercept Point

OsculatingElements

OSCULATING_ELEMENTS

Orbital Elements

TimeConversion

TIME_CONVERSION

Time Conversion

GFCoordinateSearch

GF_COORDINATE_SEARCH

Position Event Finder

Generic calculation

class webgeocalc.Calculation(api='', time_system='UTC', time_format='CALENDAR', verbose=True, **kwargs)[source]

Bases: Payload

Webgeocalc calculation object.

Parameters:
Raises:
submit()[source]

Submit calculation parameters and get calculation id and phase.

Raises:

CalculationAlreadySubmitted – If the calculation was already submitted (to avoid duplicated submissions).

Example

>>> calc.submit()  # noqa: E501
[Calculation submit] Phase: QUEUED | POSITION: 6 (id: 8750344d-645d-4e43-b159-c8d88d28aac6)
>>> calc.id
'8750344d-645d-4e43-b159-c8d88d28aac6'
>>> calc.phase
'QUEUED | POSITION: 6'
resubmit()[source]

Reset calculation id and re-submit the calculation.

See: submit().

cancel()[source]

Cancels calculation if already submitted.

update()[source]

Update calculation phase phase.

Example

>>> calc.update()  # noqa: E501
[Calculation update] Phase: QUEUED | POSITION: 3 (id: 8750344d-645d-4e43-b159-c8d88d28aac6)
>>> calc.update()  # noqa: E501
[Calculation update] Phase: STARTING (id: 8750344d-645d-4e43-b159-c8d88d28aac6)
>>> calc.update()  # noqa: E501
[Calculation update] Phase: LOADING_KERNELS (id: 8750344d-645d-4e43-b159-c8d88d28aac6)
>>> calc.update()  # noqa: E501
[Calculation update] Phase: CALCULATING (id: 8750344d-645d-4e43-b159-c8d88d28aac6)
>>> calc.update()
[Calculation update] Phase: COMPLETE (id: 8750344d-645d-4e43-b159-c8d88d28aac6)
property results

Gets the results of a calculation, if its phase is COMPLETE.

Returns:

Calculation results as dict based on output columns. If multiple times or intervals are used, the value of the dict will be an array. See examples.

Return type:

dict

Raises:

CalculationNotCompleted – If calculation phase is not COMPLETE.

Examples

>>> calc.results
{'DATE': '2012-10-19 09:00:00.000000 UTC',
 'DISTANCE': 764142.63776247,
 'SPEED': 111.54765899,
 'X': 298292.85744169,
 'Y': -651606.58468976,
 'Z': 265224.81187627,
 'D_X_DT': -98.8032491,
 'D_Y_DT': -51.73211296,
 'D_Z_DT': -2.1416539,
 'TIME_AT_TARGET': '2012-10-19 08:59:57.451094 UTC',
 'LIGHT_TIME': 2.54890548}

>>> ang_sep = AngularSeparation(
...     kernel_paths = ['pds/wgc/kernels/lsk/naif0012.tls', 'pds/wgc/kernels/spk/de430.bsp'],
...     times = ['2012-10-19T08:24:00.000', '2012-10-19T09:00:00.000'],
...     target_1 = 'VENUS',
...     target_2 = 'MERCURY',
...     observer = 'SUN',
...     verbose = False,
... )  # noqa: E501
>>> ang_sep.submit()
>>> ang_sep.results
{'DATE': ['2012-10-19 08:24:00.000000 UTC', '2012-10-19 09:00:00.000000 UTC'],
 'ANGULAR_SEPARATION': [175.17072258, 175.18555938]}
run(timeout=30, sleep=1)[source]

Submit, update and retrieve calculation results at once.

See: submit(), update() and results.

Parameters:

  • timeout (int, optional) – Auto-update time out (in seconds).

  • sleep (int, optional) – Sleep duration (in seconds) between each update.

Raises:

CalculationTimeOut – If calculation reach the timeout duration.

property calculation_type

The type of calculation to perform.

Parameters:

calculation_type (str) –

One of the following:

  • STATE_VECTOR

  • ANGULAR_SEPARATION

  • ANGULAR_SIZE

  • SUB_OBSERVER_POINT

  • SUB_SOLAR_POINT

  • ILLUMINATION_ANGLES

  • SURFACE_INTERCEPT_POINT

  • OSCULATING_ELEMENTS

  • FRAME_TRANSFORMATION

  • TIME_CONVERSION

  • GF_COORDINATE_SEARCH

  • GF_ANGULAR_SEPARATION_SEARCH

  • GF_DISTANCE_SEARCH

  • GF_SUB_POINT_SEARCH

  • GF_OCCULTATION_SEARCH

  • GF_TARGET_IN_INSTRUMENT_FOV_SEARCH

  • GF_SURFACE_INTERCEPT_POINT_SEARCH

  • GF_RAY_IN_FOV_SEARCH

Note

This parameters will be auto-filled for specific calculation sub-classes.

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property kernels

Add kernel sets.

Parameters:

kernels (str, int, [str or/and int]) –

Kernel set(s) to be used for the calculation:

[{'type': 'KERNEL_SET', 'id': 5}, ...]

property kernel_paths

Add path for individual kernel paths.

Parameters:

kernel_paths (str, [str]) –

Kernel path(s) to be used for the calculation:

[{'type': 'KERNEL', 'path': 'pds/wgc/kernels/lsk/naif0012.tls'}, ...]

property times

Calculation input times.

Parameters:

times (str or [str]) – String or array of strings representing the time points that should be used in the calculation.

Raises:

CalculationConflictAttr – Either this parameter or the py:attr:intervals parameter must be supplied.

property intervals

Calculation input intervals.

Parameters:

intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) –

An array of objects with startTime and endTime parameters, representing the time intervals used for the calculation.

Warning

Either this parameter or the times parameter must be supplied.

Raises:

  • CalculationInvalidAttr – If :py:attr:intervals` input format is invalid. For example, if :py:attr:intervals` is provided an dict, startTime and endTime must be present.

  • CalculationUndefinedAttr – If this parameter is used, time_step must also be supplied.

property time_step

Time step for intervals.

Parameters:

time_step (int) – Number of steps parameter used for time series or geometry finder calculations.

Raises:

  • CalculationConflictAttr – If times attribute is supplied.

  • CalculationUndefinedAttr – If time_step_units is not supplied.

property time_step_units

Time step units.

Parameters:

time_step_units (str) –

One of the following:

  • SECONDS

  • MINUTES

  • HOURS

  • DAYS

  • EQUAL_INTERVALS

Raises:

  • CalculationInvalidAttr – If the value provided is invalid.

  • CalculationConflictAttr – If times attribute is supplied.

  • CalculationUndefinedAttr – If time_step is not supplied.

property time_system

Time System.

Parameters:

time_system (str) –

One of the following:

  • UTC

  • TDB

  • TDT

  • SPACECRAFT_CLOCK

Raises:

  • CalculationInvalidAttr – If the value provided is invalid.

  • CalculationUndefinedAttr – If SPACECRAFT_CLOCK is selected, but sclk_id attribute is not provided.

property time_format

Time format input.

Parameters:

time_format (str) –

One of the following:

  • CALENDAR

  • JULIAN

  • SECONDS_PAST_J2000

  • SPACECRAFT_CLOCK_TICKS

  • SPACECRAFT_CLOCK_STRING

Raises:

  • CalculationInvalidAttr – If the value provided is invalid.

  • CalculationRequiredAttr – If time_system is not provided.

  • CalculationIncompatibleAttr – If CALENDAR, JULIAN or SECONDS_PAST_J2000 is selected but time_system attribute is not in UTC, TDB or TDT, or SPACECRAFT_CLOCK_STRING or SPACECRAFT_CLOCK_TICKS is selected but time_system attribute is not SPACECRAFT_CLOCK.

property sclk_id

Spacecraft clock kernel id.

Parameters:

sclk_id (int) – Spacecraft clock kernel id.

Raises:

  • CalculationRequiredAttr – If time_system is not provided.

  • CalculationIncompatibleAttr – If time_system is not SPACECRAFT_CLOCK.

property output_time_system

The time system for results output times.

Parameters:

output_time_system (str) –

One of the following:

  • UTC

  • TDB

  • TDT

  • SPACECRAFT_CLOCK

Raises:

  • CalculationInvalidAttr – If the value provided is invalid.

  • CalculationUndefinedAttr – If SPACECRAFT_CLOCK is selected, but output_sclk_id attribute is not provided.

property output_time_format

The time format for the result output times.

Parameters:

output_time_format (str) –

One of the following:

  • CALENDAR

  • CALENDAR_YMD

  • CALENDAR_DOY

  • JULIAN

  • SECONDS_PAST_J2000

  • SPACECRAFT_CLOCK_STRING

  • SPACECRAFT_CLOCK_TICKS

  • CUSTOM

Warning

If CUSTOM is selected, then output_time_custom_format must also be provided.

Raises:

  • CalculationInvalidAttr – If the value provided is invalid.

  • CalculationRequiredAttr – If output_time_system is not provided.

  • CalculationIncompatibleAttr – If CALENDAR_YMD, CALENDAR_DOY, JULIAN, SECONDS_PAST_J2000 or CUSTOM is selected but outputTimeSystem is not in TDB, TDT or UTC, or SPACECRAFT_CLOCK_STRING or SPACECRAFT_CLOCK_TICKS is selected but output_time_system is not SPACECRAFT_CLOCK.

property output_time_custom_format

A SPICE timout() format string.

Parameters:

output_time_custom_format (str) – A SPICE timout() format string.

Raises:
property output_sclk_id

The output spacecraft clock kernel id.

Parameters:

output_sclk_id (int) – Spacecraft clock kernel id.

Raises:
property target

Target body.

Parameters:

target (str or int) – The target body name or id from API.bodies().

property target_frame

The target body-fixed reference frame name.

Parameters:

target_frame (str) – Reference frame name.

property target_1

The target body the first body.

Parameters:

target_1 (str) – Target body name or id.

property target_2

The target body the second body.

Parameters:

target_2 (str) – Target body name or id.

property shape_1

The shape to use for the first body.

Parameters:

shape_1 (str) –

One of:

  • POINT

  • SPHERE

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property shape_2

The shape to use for the second body.

Parameters:

shape_2 (str) –

One of:

  • POINT

  • SPHERE

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property observer

The observing body.

Parameters:

observer (str or int) – The observing body name or id from API.bodies().

property illuminator

The illumination source.

Often, the illumination source is the Sun, but it could be any other ephemeris object.

Parameters:

illuminator (str or int) – The illumination body name or id from API.bodies().

property reference_frame

The reference frame.

Parameters:

reference_frame (str or int) – The reference frame name or id from API.frames().

property frame_1

The first reference frame.

Parameters:

frame_1 (str or int) – The reference frame name or id from API.frames().

property frame_2

The second reference frame.

Parameters:

frame_2 (str or int) – The reference frame name or id from API.frames().

property orbiting_body

The SPICE orbiting body.

Parameters:

orbiting_body (str or int) – SPICE body name or id for the orbiting body.

property center_body

The SPICE body center of motion.

Parameters:

center_body (str or int) – SPICE body name or id for the body that is the center of motion.

property aberration_correction

SPICE aberration correction.

Parameters:

aberration_correction (str) –

The SPICE aberration correction string. One of:

  • NONE

  • LT

  • LT+S

  • CN

  • CN+S

  • XLT

  • XLT+S

  • XCN

  • XCN+S

Warning

In TANGENT_POINT calculation, the selected aberration correction applies both to the point set by correction_locus and the direction vector if direction_vector_type is DIRECTION_TO_OBJECT. For any other direction_vector_type, the selected aberration correction only applies to the point set by correction_locus.

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property vector_ab_corr

Type of aberration correction.

Parameters:

vector_ab_corr (str) –

Type of aberration correction to be applied to the specified vector. Only required if directionVectorType is VECTOR_IN_REFERENCE_FRAME. One of:

  • NONE

  • STELLAR_ABERRATION_VECTOR

Note

Use NONE to compute geometry without aberration corrections, and STELLAR_ABERRATION_VECTOR to correct the vector’s direction for stellar aberration, taking into account the velocity of the observer with respect to the solar system barycenter. The direction of stellar aberration correction is determined by the light time direction selected in :py:attr:aberration_correction.

For backward compatibility, if not provided, it is assumed to be NONE.

Raises:

  • CalculationInvalidAttr – If the value provided is invalid.

  • CalculationUndefinedAttr – If direction_vector_type is not supplied.

  • CalculationIncompatibleAttr – If direction_vector_type is not VECTOR_IN_REFERENCE_FRAME.

property correction_locus

Aberration correction locus.

Parameters:

correction_locus (str) –

Aberration correction locus, which is the fixed point in the reference frame for which light time and stellar aberration corrections are computed. One of:

  • TANGENT_POINT

  • SURFACE_POINT

Required only when aberration_correction is not NONE.

Differential aberration effects across the surface of the target body are not considered. When aberration corrections are used, the effective positions of the observer and target, and the orientation of the target, are computed according to the corrections determined for the aberration correction locus.

The light time used to determine the position and orientation of the target body is that between the aberration correction locus and the observer.

The stellar aberration correction applied to the position of the target is that computed for the aberration correction locus.

Use TANGENT_POINT to compute corrections at the “tangent point.” Use SURFACE_POINT to compute corrections at the point on the target’s surface nearest to the tangent point.

When aberration_correction is NONE, the illumination angles, time, local true solar time and light time are computed with respect to the tangent point.

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property spec_type

Angular separation computation type.

Method used to specify the directions between which the angular separation is computed.

Parameters:

spec_type (str) –

One of the following:

  • TWO_TARGETS

  • TWO_DIRECTIONS

property direction

The direction specification object.

Parameters:

direction (dict or Direction) – Direction position/velocity/vector. See: Direction.

property direction_1

The first direction object.

Definition of first direction for two-directions angular separation calculation.

Parameters:

direction_1 (dict or Direction) – Direction position/velocity/vector. See: Direction.

property direction_2

The second direction object.

Definition of second direction for two-directions angular separation calculation.

Parameters:

direction_2 (dict or Direction) – Direction position/velocity/vector. See: Direction.

property vector_magnitude

Magnitude of the output vector representation.

One of:

  • UNIT

  • PRESERVE_ORIGINAL

Use UNIT to represent the output direction vector as a unit vector, and PRESERVE_ORIGINAL to output the direction vector with its computed magnitude.

property computation_method

The computation method for TANGENT_POINT calculation.

Only:

  • ELLIPSOID

Currently, it is restricted to ELLIPSOID. This value indicates that the target shape is modeled as a triaxial ellipsoid.

property state_representation

State representation.

Parameters:

state_representation (str) –

One of:

  • RECTANGULAR

  • RA_DEC

  • LATITUDINAL (planetocentric)

  • PLANETODETIC

  • PLANETOGRAPHIC

  • CYLINDRICAL

  • SPHERICAL

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property time_location

The frame for the input times.

Parameters:

time_location (str) –

One of:

  • FRAME1

  • FRAME2

Raises:

CalculationInvalidAttr – If the value provided is invalid.

Warning

NAIF API docs:

`Only needed if aberrationCorrection is not NONE.`

Required even when aberration_correction is NONE.

property orientation_representation

The representation of the result transformation.

Parameters:

orientation_representation (str) –

Orientation result transformation. One of:

  • EULER_ANGLES

  • ANGLE_AND_AXIS

  • SPICE_QUATERNION

  • OTHER_QUATERNION

  • MATRIX_ROW_BY_ROW

  • MATRIX_FLAGGED

  • MATRIX_ALL_ONE_ROW

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property axis_1

The first axis for Euler angle rotation.

Parameters:

axis_1 (str) – Axis name. See: axis().

property axis_2

The second axis for Euler angle rotation.

Parameters:

axis_3 (str) – Axis name. See: axis().

property axis_3

The third axis for Euler angle rotation.

Parameters:

axis_3 (str) – Axis name. See: axis().

axis(name, val)[source]

Axis for Euler angle rotation.

Parameters:

  • name (str) –

    Axis name. One of:

    • X

    • Y

    • Z

  • val (float) – Value on the axis.

Returns:

Value on the axis.

Return type:

float

Raises:
property angular_units

The angular units.

Parameters:

angular_units (str) –

The angular units used for the angle of rotation. One of:

  • deg

  • rad

Raises:
property angular_velocity_representation

Angular velocity representation.

Parameters:

angular_velocity_representation (str) –

The representation of angular velocity in the output. One of:

  • NOT_INCLUDED

  • VECTOR_IN_FRAME1

  • VECTOR_IN_FRAME2

  • EULER_ANGLE_DERIVATIVES

  • MATRIX

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property angular_velocity_units

The units for the angular velocity.

Parameters:

angular_velocity_units (str) –

One of:

  • deg/s

  • rad/s

  • RPM

  • Unitary (ie, Unit vector)

Raises:
property coordinate_representation

Coordinate representation.

Parameters:

coordinate_representation (str) –

One of:

  • RECTANGULAR

  • RA_DEC

  • LATITUDINAL (planetocentric)

  • PLANETODETIC (not for POINTING_DIRECTION)

  • PLANETOGRAPHIC (not for POINTING_DIRECTION)

  • CYLINDRICAL

  • SPHERICAL

  • AZ_EL (not for TANGENT_POINT)

Note

For TANGENT_POINT calculation, it corresponds to the coordinate system to represent both the Tangent point and the point on the surface’s target nearest to the target point.

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property latitude

Latitude of the surface point.

Parameters:

latitude (float) – Latitude angle (in degrees).

Raises:

CalculationInvalidValue – If latitude not in [-90, +90] range.

property longitude

Longitude of the surface point.

Parameters:

longitude (float) – Longitude angle (in degrees).

Raises:

CalculationInvalidValue – If longitude not in [-180, +180] range.

property sub_point_type

Sub-observer point.

Parameters:

sub_point_type (str) –

The method of finding the sub-observer point, as in the SPICE subpnt() API call. One of:

  • Near point: ellipsoid

  • Intercept: ellipsoid

  • NADIR/DSK/UNPRIORITIZED

  • INTERCEPT/DSK/UNPRIORITIZED

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property direction_vector_type

Type of ray’s direction vector.

Parameters:

direction_vector_type (str) –

Type of vector to be used as the ray direction: the instrument boresight vector, the instrument field-of-view boundary vectors, an axis of the specified reference frame, a vector in the reference frame of the specified instrument, a vector in the specified reference frame, or a vector defined by the position of a given object as seen from the observer.

One of:

  • INSTRUMENT_BORESIGHT (the instrument boresight vector)

  • INSTRUMENT_FOV_BOUNDARY_VECTORS (the instrument field-of-view boundary vectors)

  • REFERENCE_FRAME_AXIS (an axis of the specified reference frame)

  • VECTOR_IN_INSTRUMENT_FOV (a vector in the reference frame of the specified instrument)

  • VECTOR_IN_REFERENCE_FRAME (a vector in the specified reference frame)

  • DIRECTION_TO_OBJECT (only for ``TANGENT_POINT`` calculation)

Raises:

  • CalculationInvalidAttr – If the value provided is invalid.

  • CalculationRequiredAttr – If this parameter is INSTRUMENT_BORESIGHT, INSTRUMENT_FOV_BOUNDARY_VECTORS or VECTOR_IN_INSTRUMENT_FOV but direction_instrument is not provided.

  • CalculationRequiredAttr – If this parameter is REFERENCE_FRAME_AXIS or VECTOR_IN_REFERENCE_FRAME but direction_frame is not provided.

  • CalculationRequiredAttr – If this parameter is REFERENCE_FRAME_AXIS but direction_frame_axis is not provided.

  • CalculationRequiredAttr – If this parameter is DIRECTION_TO_OBJECT but direction_object is not provided.

  • CalculationIncompatibleAttr – If this parameter is DIRECTION_TO_OBJECT but but calculation_type is not TANGENT_POINT.

  • CalculationUndefinedAttr – If this parameter is VECTOR_IN_INSTRUMENT_FOV or VECTOR_IN_REFERENCE_FRAME but neither direction_vector_x, direction_vector_y and direction_vector_z nor direction_vector_ra and direction_vector_dec are provided.

property direction_object

Direction object.

Parameters:

direction_object (str or int) – The ephemeris object name or id. Required only if direction_vector_type is DIRECTION_TO_OBJECT.

Raises:
property direction_instrument

Direction instrument.

Parameters:

direction_instrument (str or int) – The instrument name or id.

Raises:

  • CalculationUndefinedAttr – If direction_vector_type is not provided.

  • CalculationIncompatibleAttr – If direction_vector_type not in INSTRUMENT_BORESIGHT, INSTRUMENT_FOV_BOUNDARY_VECTORS or VECTOR_IN_INSTRUMENT_FOV.

property direction_frame

Direction vector reference frame.

Parameters:

direction_frame (str) – The vector’s reference frame name.

Raises:
property direction_frame_axis

The vector’s reference frame axis name.

Parameters:

direction_frame (str) –

The vector’s reference frame axis. One of:

  • X

  • Y

  • Z

Raises:

  • CalculationUndefinedAttr – If direction_vector_type is not provided.

  • CalculationIncompatibleAttr – If direction_vector_type is not REFERENCE_FRAME_AXIS.

  • CalculationInvalidAttr – If the value provided is invalid.

direction_vector(axis, val)[source]

Direction vector coordinate.

Parameters:

  • axis (str) – Axis name.

  • val (float) – Value on the axis.

Raises:
property direction_vector_x

The X ray’s direction vector coordinate.

Parameters:

direction_vector_x (float) – Direction x-coordinate. See direction_vector().

property direction_vector_y

The Y ray’s direction vector coordinate.

Parameters:

direction_vector_y (float) – Direction y-coordinate. See direction_vector().

property direction_vector_z

The Z ray’s direction vector coordinate.

Parameters:

direction_vector_z (float) – Direction z-coordinate. See direction_vector().

property direction_vector_ra

The right-ascension ray’s direction vector coordinate.

Parameters:

direction_vector_ra (float) – Direction RA-coordinate. See direction_vector().

property direction_vector_dec

The declination ray’s direction vector coordinate.

Parameters:

direction_vector_dec (float) – Direction DEC-coordinate. See direction_vector().

property direction_vector_az

The azimuth ray’s direction vector coordinate.

Parameters:

direction_vector_az (float) – Direction Azimuth-coordinate. See direction_vector().

property direction_vector_el

The elevation ray’s direction vector coordinate.

Parameters:

direction_vector_el (float) – Direction elevation-coordinate. See direction_vector().

property azccw_flag

Flag indicating how azimuth is measured.

If azccw_flag is True, azimuth increases in the counterclockwise direction; otherwise it increases in the clockwise direction.

Required only when coordinate_representation is set to AZ_EL in POINTING_DIRECTION calculation or direction_vector_az is set in TANGENT_POINT calculation.

Parameters:

azccw_flag (bool or str) – Azimuth orientation.

Raises:

CalculationInvalidValue – If azccw_flag not a boolean.

property elplsz_flag

Flag indicating how elevation is measured.

If elplsz_flag is True, elevation increases from the XY plane toward +Z; otherwise toward -Z.

Required only when coordinate_representation is set to AZ_EL in POINTING_DIRECTION calculation or direction_vector_el is set in TANGENT_POINT calculation.

Parameters:

elplsz_flag (bool or str) – Azimuth orientation.

Raises:

CalculationInvalidValue – If elplsz_flag not a boolean.

property output_duration_units

Output duration time units.

Time units to use for displaying the duration of each interval found by the event search.

Parameters:

output_duration_units (str) –

One of the following:

  • SECONDS

  • MINUTES

  • HOURS

  • DAYS

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property should_complement_window

Specifies whether to complement the intervals in the result window.

That is, instead of finding the intervals where the condition is satisfied, find the intervals where the condition is not satisfied.

Parameters:

should_complement_window (bool) – Complement result window

Raises:

TypeError – If the value provided is not bool type.

property interval_adjustment

Specifies whether to expand or contract the intervals in the result.

Expanding the intervals will cause intervals that overlap, after expansion, to be combined into one interval.

Parameters:

interval_adjustment (str) –

One of the following:

  • NO_ADJUSTMENT

  • EXPAND_INTERVALS

  • CONTRACT_INTERVALS

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property interval_adjustment_amount

The amount by which to expand or contract each interval at the endpoints.

Each endpoint will be moved by this amount.

Parameters:

interval_adjustment_amount (float)

Raises:

CalculationUndefinedAttr: – If interval_adjustment_units is not supplied

property interval_adjustment_units

The unit of the interval adjustment amount.

Parameters:

interval_adjustment_units (str) –

One of the following:

  • SECONDS

  • MINUTES

  • HOURS

  • DAYS

Raises:

  • CalculationInvalidAttr – If the value provided is invalid.

  • CalculationUndefinedAttr: – If interval_adjustment_amount is not supplied

property interval_filtering

Specifies whether to omit interval smaller than a minimum threshold size.

This threshold is applied after expansion or contraction of the intervals.

Parameters:

interval_filtering (str) –

One of the following:

  • NO_FILTERING

  • OMIT_INTERVALS_SMALLER_THAN_A_THRESHOLD

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property interval_filtering_threshold

Interval duration filtering threshold value.

Parameters:

interval_filtering_threshold (float) – Interval duration filtering threshold value.

Raises:

CalculationUndefinedAttr: – If interval_filtering_threshold_units is not supplied

property interval_filtering_threshold_units

Units of the interval duration filtering threshold value.

Parameters:

interval_filtering_threshold_units (str) –

One of the following:

  • SECONDS

  • MINUTES

  • HOURS

  • DAYS

Raises:

  • CalculationInvalidAttr – If the value provided is invalid.

  • CalculationUndefinedAttr: – If interval_filtering_threshold is not supplied

property coordinate_system

The name of the coordinate system in which to evaluate the coordinate.

Only required for GF_COORDINATE_SEARCH, GF_SUB_POINT_SEARCH, and GF_SURFACE_INTERCEPT_POINT_SEARCH.

Parameters:

coordinate_system (str) –

One of the following:

  • RECTANGULAR

  • RA/DEC

  • LATITUDINAL (planetocentric)

  • CYLINDRICAL

  • SPHERICAL

  • GEODETIC

  • PLANETOGRAPHIC

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property coordinate

The name of the SPICE coordinate to search on.

Only needed for GF_COORDINATE_SEARCH, GF_SUB_POINT_SEARCH, and GF_SURFACE_INTERCEPT_POINT_SEARCH.

Parameters:

coordinate (str) –

One of the following:

  • X

  • Y

  • Z

  • LONGITUDE

  • LATITUDE

  • COLATITUDE

  • RIGHT ASCENSION

  • DECLINATION

  • RANGE

  • RADIUS

  • ALTITUDE

Raises:

CalculationInvalidAttr – If the value provided is invalid.

property relational_condition

The relationship for the geometry finder test.

Parameters:

relational_condition (str) –

One of the following:

  • =

  • <

  • >

  • RANGE

  • ABSMAX

  • ABSMIN

  • LOCMAX

  • LOCMIN

Raises:

  • CalculationInvalidAttr – If the value provided is invalid.

  • CalculationUndefinedAttr: – If the value is RANGE`, and :py:attr:`upper_limit` is not supplied.     If the value is ``ABSMIN or ABSMAX, and adjustment_value is not supplied. If the value is =, <, > or RANGE, and reference_value is not supplied.

property reference_value

The value to compare against, or the lower value of a range.

Only needed if relationalCondition is not ABSMAX, ABSMIN, LOCMAX, or LOCMIN.

Parameters:

reference_value (float)

property upper_limit

The upper limit of a range. Only needed if relationalCondition is RANGE.

Parameters:

upper_limit (float)

property adjustment_value

The adjustment value to apply for ABSMIN and ABSMAX searches.

Required if relationalCondition is ABSMIN or ABSMAX.

Parameters:

adjustment_value (float)

gf_condition(**kwargs)[source]

Geometry Finder condition object.

See the documentation for gfposc() for more details.

Raises:

CalculationUndefinedAttr: – If calculation_type is GF_COORDINATE_SEARCH, GF_SUB_POINT_SEARCH or GF_SURFACE_INTERCEPT_POINT_SEARCH, and coordinate_system or coordinate are not present.

State Vector

Calculates the position of one body relative to another, calculated in a desired reference frame:

>>> StateVector(
...    kernels = 5,
...    times = '2012-10-19T09:00:00',
...    target = 'CASSINI',
...    observer = 'SATURN',
...    reference_frame = 'IAU_SATURN',
...    verbose = False,
... ).run()
{'DATE': '2012-10-19 09:00:00.000000 UTC',
 'DISTANCE': 764142.65053372,
 'SPEED': 111.54765158,
 'X': 298293.06093747,
 'Y': -651606.39373107,
 'Z': 265225.08895284,
 'D_X_DT': -98.80322113,
 'D_Y_DT': -51.73215012,
 'D_Z_DT': -2.14166057,
 'TIME_AT_TARGET': '2012-10-19 08:59:57.451094 UTC',
 'LIGHT_TIME': 2.54890552}

Important

Calculation required parameters:
Default parameters:
class webgeocalc.StateVector(aberration_correction='CN', state_representation='RECTANGULAR', **kwargs)[source]

Bases: 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: aberration_correction

  • state_representation (str, optional) – See: state_representation

  • kernels (str, int, [str or/and int]) – See: kernels

  • kernel_paths (str, [str]) – See: kernel_paths

  • times (str or [str]) – See: times

  • intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) – See: intervals

  • time_step (int) – See: time_step

  • time_step_units (str) – See: time_step_units

  • time_system (str) – See: time_system

  • time_format (str) – See: time_format

  • target (str or int) – See: target

  • observer (str or int) – See: observer

  • reference_frame (str or int) – See: reference_frame

Raises:

CalculationRequiredAttr – If target, observer and reference_frame are not provided.

Angular Separation

Calculates the angular separation of two bodies/directions as seen by an observer body. There are two types of calculation. The default one is the angular separation between two targets (TWO_TARGETS mode), which is the default mode.

>>> AngularSeparation(
...     kernel_paths = ['pds/wgc/kernels/lsk/naif0012.tls',
...                     'pds/wgc/kernels/spk/de430.bsp'],
...     times = '2012-10-19T08:24:00.000',
...     target_1 = 'VENUS',
...     target_2 = 'MERCURY',
...     observer = 'SUN',
...     verbose = False,
... ).run()
{'DATE': '2012-10-19 08:24:00.000000 UTC', 'ANGULAR_SEPARATION': 175.17072258}

The second case is the angular separation between two directions (TWO_DIRECTIONS mode).

>>> AngularSeparation(
...     kernels = 5,
...     times = '2012-10-19T08:24:00.000',
...     spec_type = 'TWO_DIRECTIONS',
...     direction_1 = {
...         'direction_type': 'VECTOR',
...         'direction_vector_type': 'REFERENCE_FRAME_AXIS',
...         'direction_frame': 'CASSINI_RPWS_EDIPOLE',
...         'direction_frame_axis': 'Z'
...     },
...     direction_2 = {
...         'direction_type': 'POSITION',
...         'target': 'SUN',
...         'shape': 'POINT',
...         'observer': 'CASSINI'
...     },
...     verbose = False,
... ).run()
{'DATE': '2012-10-19 08:24:00.000000 UTC', 'ANGULAR_SEPARATION': 90.10114616}

Important

Calculation required parameters:
Default parameters:
Additional required parameters for TWO_TARGETS:
Additional default parameters for TWO_TARGETS:
Additional required parameters for TWO_DIRECTIONS:

Hint

The directions can be specified either with an explicit dict or with a Direction object:

>>> from webgeocalc.direction import Direction

>>> AngularSeparation(
...     kernels = 5,
...     times = '2012-10-19T08:24:00.000',
...     spec_type = 'TWO_DIRECTIONS',
...     direction_1 = Direction(
...         direction_type = 'VECTOR',
...         direction_vector_type = 'REFERENCE_FRAME_AXIS',
...         direction_frame = 'CASSINI_RPWS_EDIPOLE',
...         direction_frame_axis = 'Z',
...     ),
...     direction_2 = Direction(
...         direction_type = 'POSITION',
...         target = 'SUN',
...         shape = 'POINT',
...         observer = 'CASSINI',
...     ),
... )
class webgeocalc.AngularSeparation(spec_type='TWO_TARGETS', aberration_correction='CN', **kwargs)[source]

Bases: Calculation

Angular separation calculation.

Calculates the angular separation of two bodies as seen by an observer body. There are two types of calculation. The default one is the angular separation between two targets (TWO_TARGETS mode). The second case is the angular separation between two directions (TWO_DIRECTIONS mode).

Parameters:

  • kernels (str, int, [str or/and int]) – See: kernels

  • kernel_paths (str, [str]) – See: kernel_paths

  • times (str or [str]) – See: times

  • intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) – See: intervals

  • time_step (int) – See: time_step

  • time_step_units (str) – See: time_step_units

  • time_system (str) – See: time_system

  • time_format (str) – See: time_format

  • spec_type (str, optional) – See: spec_type either TWO_TARGETS (default) or TWO_DIRECTIONS.

  • TWO_TARGETS (Required parameters)

  • target_1 (str or int) – See: target_1

  • shape_1 (str, optional) – See: shape_1 (default: POINT)

  • target_2 (str or int) – See: target_2

  • shape_2 (str, optional) – See: shape_2 (default: POINT)

  • observer (str or int) – See: observer

  • aberration_correction (str, optional) – See: aberration_correction

  • TWO_DIRECTIONS (Required parameters)

  • direction_1 (dict or Direction) – See: direction_1

  • direction_2 (dict or Direction) – See: direction_2

Raises:

CalculationRequiredAttr – If spec_type is TWO_TARGETS or not set: If py:attr:target_1, target_2 or observer are not provided. If spec_type is TWO_DIRECTIONS: If direction_1 or direction_2 are not provided.

Angular Size

Calculates the angular size of a target as seen by an observer.

>>> AngularSize(
...     kernels = 5,
...     times = '2012-10-19T08:24:00.000',
...     target = 'ENCELADUS',
...     observer = 'CASSINI',
...     aberration_correction = 'CN+S',
...     verbose = False,
... ).run()
{'DATE': '2012-10-19 08:24:00.000000 UTC', 'ANGULAR_SIZE': 0.03032491}

Important

Calculation required parameters:
Default parameters:
class webgeocalc.AngularSize(aberration_correction='CN', **kwargs)[source]

Bases: Calculation

Angular size calculation.

Calculates the angular size of a target as seen by an observer.

Parameters:

  • aberration_correction (str, optional) – See: aberration_correction

  • kernels (str, int, [str or/and int]) – See: kernels

  • kernel_paths (str, [str]) – See: kernel_paths

  • times (str or [str]) – See: times

  • intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) – See: intervals

  • time_step (int) – See: time_step

  • time_step_units (str) – See: time_step_units

  • time_system (str) – See: time_system

  • time_format (str) – See: time_format

  • target (str or int) – See: target

  • observer (str or int) – See: observer

Raises:

CalculationRequiredAttr – If target and observer are not provided.

Frame Transformation

Calculate the transformation from one reference frame (Frame 1) to another reference frame (Frame 2).

>>> FrameTransformation(
...     kernels = 5,
...     times = '2012-10-19T08:24:00.000',
...     frame_1 = 'IAU_SATURN',
...     frame_2 = 'IAU_ENCELADUS',
...     aberration_correction = 'NONE',
...     verbose = False,
... ).run()
{'DATE': '2012-10-19 08:24:00.000000 UTC',
 'ANGLE3': -19.59511576,
 'ANGLE2': -0.00533619,
 'ANGLE1': -0.00345332,
 'AV_X': -2.8406831e-07,
 'AV_Y': 1.83751477e-07,
 'AV_Z': -0.00633942,
 'AV_MAG': 0.00633942}

Important

Calculation required parameters:
Default parameters:
class webgeocalc.FrameTransformation(aberration_correction='CN', time_location='FRAME1', orientation_representation='EULER_ANGLES', axis_1='X', axis_2='Y', axis_3='Z', angular_units='deg', angular_velocity_representation='VECTOR_IN_FRAME1', angular_velocity_units='deg/s', **kwargs)[source]

Bases: Calculation

Frame transform calculation.

Calculate the transformation from one reference frame (Frame 1) to another reference frame (Frame 2).

Parameters:

  • aberration_correction (str, optional) – See: aberration_correction

  • time_location (str, optional) – See: time_location

  • orientation_representation (str, optional) – See: orientation_representation

  • axis_1 (str, optional) – See: axis_1

  • axis_2 (str, optional) – See: axis_2

  • axis_3 (str, optional) – See: axis_3

  • angular_units (str, optional) – See: angular_units

  • angular_velocity_representation (str, optional) – See: angular_velocity_representation

  • angular_velocity_units (str, optional) – See: angular_velocity_units

Warning

Attribute aberration_correction must be NONE, LT`, CN, XLT or XCN.

Attributes axis_1, axis_2 and axis_3 are imported only if orientation_representation is EULER_ANGLES.

Attribute angular_units is imported only if orientation_representation is EULER_ANGLES or ANGLE_AND_AXIS.

Attribute angular_velocity_units is imported only if angular_velocity_representation is VECTOR_IN_FRAME1, VECTOR_IN_FRAME2 or EULER_ANGLE_DERIVATIVES.

Parameters:

  • kernels (str, int, [str or/and int]) – See: kernels

  • kernel_paths (str, [str]) – See: kernel_paths

  • times (str or [str]) – See: times

  • intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) – See: intervals

  • time_step (int) – See: time_step

  • time_step_units (str) – See: time_step_units

  • time_system (str) – See: time_system

  • time_format (str) – See: time_format

  • frame_1 (str or int) – See: frame_1

  • frame_2 (str or int) – See: frame_2

Raises:

  • CalculationRequiredAttr – If frame_1 and frame_2 are not provided.

  • CalculationInvalidAttr – If aberration_correction is in LT+S, CN+S, XLT+S or XCN+S.

Illumination Angles

Calculate the emission, phase and solar incidence angles at a point on a target as seen from an observer.

>>> IlluminationAngles(
...    kernels = 5,
...    times = '2012-10-19T08:24:00.000',
...    target = 'ENCELADUS',
...    target_frame = 'IAU_ENCELADUS',
...    observer = 'CASSINI',
...    aberration_correction = 'CN+S',
...    latitude = 0.0,
...    longitude = 0.0,
...    verbose = False,
... ).run()
{'DATE': '2012-10-19 08:24:00.000000 UTC',
 'INCIDENCE_ANGLE': 25.51886414,
 'EMISSION_ANGLE': 26.31058362,
 'PHASE_ANGLE': 1.00106425,
 'OBSERVER_ALTITUDE': 967670.28784259,
 'TIME_AT_POINT': '2012-10-19 08:23:56.772199 UTC',
 'LIGHT_TIME': 3.22780064,
 'LTST': '13:19:56'}

Important

Calculation required parameters:
Default parameters:
class webgeocalc.IlluminationAngles(shape_1='ELLIPSOID', coordinate_representation='LATITUDINAL', aberration_correction='CN', **kwargs)[source]

Bases: 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: shape_1

  • coordinate_representation (str, optional) – See: coordinate_representation

  • aberration_correction (str, optional) – See: aberration_correction

  • kernels (str, int, [str or/and int]) – See: kernels

  • kernel_paths (str, [str]) – See: kernel_paths

  • times (str or [str]) – See: times

  • intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) – See: intervals

  • time_step (int) – See: time_step

  • time_step_units (str) – See: time_step_units

  • time_system (str) – See: time_system

  • time_format (str) – See: time_format

  • target (str or int) – See: target

  • target_frame (str or int) – See: target_frame

  • observer (str or int) – See: observer

  • latitude (str or int) – See: latitude

  • longitude (str or int) – See: longitude

Raises:

  • CalculationRequiredAttr – If target, target_frame, observer, latitude and longitude are not provided.

  • CalculationInvalidAttr – If shape_1 is not ELLIPSOID or DSK.

Phase Angle

Calculate the phase angle defined by the centers of an illumination source, a target and an observer.

The phase angle is computed using the location of the bodies (if point objects) or the center of the bodies (if finite bodies). The range of the phase angle is [0, pi].

>>> PhaseAngle(
...    kernels = 5,
...    times = '2012-10-19T08:24:00.000',
...    target = 'ENCELADUS',
...    target_frame = 'IAU_ENCELADUS',
...    observer = 'CASSINI',
...    illuminator = 'SUN',
...    aberration_correction = 'CN+S',
...    verbose = False,
... ).run()
{'DATE': '2012-10-19 08:24:00.000000 UTC', 'PHASE_ANGLE': 0.99571442}

Important

Calculation required parameters:
Default parameters:
class webgeocalc.PhaseAngle(illuminator='SUN', aberration_correction='CN', **kwargs)[source]

Bases: Calculation

Phase angle calculation.

Calculate the phase angle defined by the centers of an illumination source, a target and an observer.

The phase angle is computed using the location of the bodies (if point objects) or the center of the bodies (if finite bodies).

The range of the phase angle is [0, pi].

Parameters:

  • target (str or int) – See: target

  • observer (str or int) – See: observer

  • illuminator (str or int, optional) – See: illuminator (default: SUN)

  • aberration_correction (str, optional) – See: aberration_correction (default: CN)

  • kernels (str, int, [str or/and int]) – See: kernels

  • kernel_paths (str, [str]) – See: kernel_paths

  • times (str or [str]) – See: times

  • intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) – See: intervals

  • time_step (int) – See: time_step

  • time_step_units (str) – See: time_step_units

  • time_system (str) – See: time_system

  • time_format (str) – See: time_format

Raises:

CalculationRequiredAttr – If target or observer are not provided.

Pointing Direction

Calculates the pointing direction in a user specified reference frame and output it as a unit or full magnitude vector represented in a user specified coordinate system.

The direction can be specified by the position or velocity of an object with respect to an observer, or by directly providing a vector, which could be specified as coordinate in a given frame, a frame axis, an instrument boresight, or as instrument FoV corner vectors.

The output reference frame may be different than the one used for specification of the input vector (if such option is selected). If so, the orientations of both frames relative to the inertial space are computed at the same time taking into account the aberration corrections given in the direction specification.

The output direction could be given as unit or non-unit vector in Rectangular, Azimuth/Elevation, Right Ascension/Declination/Range, Planetocentric, Cylindrical, or Spherical coordinates.

>>> PointingDirection(
...     kernels = 5,
...     times = '2012-10-19T08:24:00.000',
...     direction = {
...         'direction_type': 'VECTOR',
...         'observer': 'Cassini',
...         'direction_vector_type': 'INSTRUMENT_FOV_BOUNDARY_VECTORS',
...         'direction_instrument': 'CASSINI_ISS_NAC',
...         'aberration_correction': 'CN',
...     },
...     reference_frame = 'J2000',
...     coordinate_representation = 'RA_DEC',
...     verbose = False,
... ).run()
{'DATE': ['2012-10-19 08:24:00.000000 UTC',
  '2012-10-19 08:24:00.000000 UTC',
  '2012-10-19 08:24:00.000000 UTC',
  '2012-10-19 08:24:00.000000 UTC'],
 'BOUNDARY_POINT_NUMBER': [1.0, 2.0, 3.0, 4.0],
 'RIGHT_ASCENSION': [209.67659835, 209.39258312, 209.60578464, 209.88990474],
 'DECLINATION': [-9.57807208, -9.78811104, -10.06810257, -9.85788588],
 'RANGE': [1.0, 1.0, 1.0, 1.0]}

Important

Calculation required parameters:
Default parameters:
Additional required parameters for coordinate_representation='AZ_EL':

Hint

The direction can be specified either with an explicit dict or with a Direction object (see AngularSeparation with TWO_DIRECTIONS).

class webgeocalc.PointingDirection(vector_magnitude='UNIT', coordinate_representation='RECTANGULAR', **kwargs)[source]

Bases: Calculation

Pointing direction calculation.

Calculates the pointing direction in a user specified reference frame and output it as a unit or full magnitude vector represented in a user specified coordinate system.

The direction can be specified by the position or velocity of an object with respect to an observer, or by directly providing a vector, which could be specified as coordinates in a given frame, a frame axis, an instrument boresight, or as instrument FoV corner vectors.

The output reference frame may be different than the one used for specification of the input vector (if such option is selected). If so, the orientations of both frames relative to the inertial space are computed at the same time taking into account the aberration corrections given in the direction specification.

The output direction could be given as unit or non-unit vector in Rectangular, Azimuth/Elevation, Right Ascension/Declination/Range, Planetocentric, Cylindrical, or Spherical coordinates.

Parameters:

  • direction (dict or Direction) – See: direction

  • reference_frame (str or int) – See: reference_frame

  • vector_magnitude (str, optional) – See: vector_magnitude (default: UNIT)

  • coordinate_representation (str, optional) – See: coordinate_representation (default: RECTANGULAR)

  • kernels (str, int, [str or/and int]) – See: kernels

  • kernel_paths (str, [str]) – See: kernel_paths

  • times (str or [str]) – See: times

  • intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) – See: intervals

  • time_step (int) – See: time_step

  • time_step_units (str) – See: time_step_units

  • time_system (str) – See: time_system

  • time_format (str) – See: time_format

  • AZ_EL (Required parameters)

  • azccw_flag (bool or str) – See: azccw_flag

  • elplsz_flag (bool or str) – See: elplsz_flag

Raises:

CalculationRequiredAttr – If target or reference_frame are not provided.

Sub Solar Point

Calculates the sub-solar point on a target as seen from an observer.

>>> SubSolarPoint(
...     kernels = 5,
...     times = '2012-10-19T08:24:00.000',
...     target = 'ENCELADUS',
...     target_frame = 'IAU_ENCELADUS',
...     observer = 'CASSINI',
...     aberration_correction = 'CN+S',
...     verbose = False,
... ).run()
{'DATE': '2012-10-19 08:24:00.000000 UTC',
 'X': 232.15437562,
 'Y': -81.18742303,
 'Z': 67.66010394,
 'SUB_POINT_RADIUS': 255.07830453,
 'OBSERVER_ALTITUDE': 967644.95641522,
 'INCIDENCE_ANGLE': 1.10177646e-14,
 'EMISSION_ANGLE': 0.99615507,
 'PHASE_ANGLE': 0.99615507,
 'TIME_AT_POINT': '2012-10-19 08:23:56.772284 UTC',
 'LIGHT_TIME': 3.22771614}

Important

Calculation required parameters:
Default parameters:
class webgeocalc.SubSolarPoint(sub_point_type='Near point: ellipsoid', aberration_correction='CN', state_representation='RECTANGULAR', **kwargs)[source]

Bases: 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: sub_point_type

  • aberration_correction (str, optional) – See: aberration_correction

  • state_representation (str, optional) – See: state_representation

Warning

Attribute aberration_correction must be NONE, LT`, LT+S, CN or CN+S.

Parameters:

  • kernels (str, int, [str or/and int]) – See: kernels

  • kernel_paths (str, [str]) – See: kernel_paths

  • times (str or [str]) – See: times

  • intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) – See: intervals

  • time_step (int) – See: time_step

  • time_step_units (str) – See: time_step_units

  • time_system (str) – See: time_system

  • time_format (str) – See: time_format

  • target (str or int) – See: target

  • target_frame (str or int) – See: target_frame

  • observer (str or int) – See: observer

Raises:

  • CalculationRequiredAttr – If target, target_frame and observer are not provided.

  • CalculationInvalidAttr – If aberration_correction is in XLT, XLT+S, XCN+S or XCN+S.

Sub Observer Point

Calculate the sub-observer point on a target as seen from an observer.

>>> SubObserverPoint(
...     kernels = 5,
...     times = '2012-10-19T08:24:00.000',
...     target = 'ENCELADUS',
...     target_frame = 'IAU_ENCELADUS',
...     observer = 'CASSINI',
...     aberration_correction = 'CN+S',
...     verbose = False,
... ).run()
{'DATE': '2012-10-19 08:24:00.000000 UTC',
 'X': 230.66149425,
 'Y': -85.24005493,
 'Z': 67.58656174,
 'SUB_POINT_RADIUS': 255.02653827,
 'OBSERVER_ALTITUDE': 967644.91882136,
 'INCIDENCE_ANGLE': 0.99589948,
 'EMISSION_ANGLE': 3.94425842e-12,
 'PHASE_ANGLE': 0.99589948,
 'TIME_AT_POINT': '2012-10-19 08:23:56.772284 UTC',
 'LIGHT_TIME': 3.22771602,
 'LTST': '11:58:49'}

Important

Calculation required parameters:
Default parameters:
class webgeocalc.SubObserverPoint(sub_point_type='Near point: ellipsoid', aberration_correction='CN', state_representation='RECTANGULAR', **kwargs)[source]

Bases: 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: sub_point_type

  • aberration_correction (str, optional) – See: aberration_correction

  • state_representation (str, optional) – See: state_representation

  • kernels (str, int, [str or/and int]) – See: kernels

  • kernel_paths (str, [str]) – See: kernel_paths

  • times (str or [str]) – See: times

  • intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) – See: intervals

  • time_step (int) – See: time_step

  • time_step_units (str) – See: time_step_units

  • time_system (str) – See: time_system

  • time_format (str) – See: time_format

  • target (str or int) – See: target

  • target_frame (str or int) – See: target_frame

  • observer (str or int) – See: observer

Raises:

CalculationRequiredAttr – If target, target_frame and observer are not provided.

Surface Intercept Point

Calculate the intercept point of a vector or vectors on a target as seen from an observer.

>>> SurfaceInterceptPoint(
...     kernels = 5,
...     times = '2012-10-14T00:00:00',
...     target = 'SATURN',
...     target_frame = 'IAU_SATURN',
...     observer = 'CASSINI',
...     direction_vector_type = 'INSTRUMENT_BORESIGHT',
...     direction_instrument = 'CASSINI_ISS_NAC',
...     aberration_correction = 'NONE',
...     state_representation = 'LATITUDINAL',
...     verbose = False,
... ).run()
{'DATE': '2012-10-14 00:00:00.000000 UTC',
 'LONGITUDE': 98.76797447,
 'LATITUDE': -38.69300277,
 'INTERCEPT_RADIUS': 57739.67660691,
 'OBSERVER_ALTITUDE': 1831047.98047459,
 'INCIDENCE_ANGLE': 123.05303919,
 'EMISSION_ANGLE': 5.8595724,
 'PHASE_ANGLE': 123.7753032,
 'TIME_AT_POINT': '2012-10-14 00:00:00.000000 UTC',
 'LIGHT_TIME': 6.10771863,
 'LTST': '20:03:06'}

Important

Calculation required parameters:
Default parameters:
class webgeocalc.SurfaceInterceptPoint(shape_1='ELLIPSOID', direction_vector_type='INSTRUMENT_BORESIGHT', aberration_correction='CN', state_representation='RECTANGULAR', **kwargs)[source]

Bases: 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: shape_1

  • direction_vector_type (str, optional) – See: direction_vector_type

  • aberration_correction (str, optional) – See: aberration_correction

  • state_representation (str, optional) – See: state_representation

  • kernels (str, int, [str or/and int]) – See: kernels

  • kernel_paths (str, [str]) – See: kernel_paths

  • times (str or [str]) – See: times

  • intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) – See: intervals

  • time_step (int) – See: time_step

  • time_step_units (str) – See: time_step_units

  • time_system (str) – See: time_system

  • time_format (str) – See: time_format

  • target (str or int) – See: target

  • target_frame (str or int) – See: target_frame

  • observer (str or int) – See: observer

  • direction_instrument (str or int) – See: direction_instrument

  • direction_frame (str) – See: direction_frame

  • direction_frame_axis (str) – See: direction_frame_axis

  • direction_vector_x (float) – See: direction_vector_x

  • direction_vector_y (float) – See: direction_vector_y

  • direction_vector_z (float) – See: direction_vector_z

  • direction_vector_ra (float) – See: direction_vector_ra

  • direction_vector_dec (float) – See: direction_vector_dec

Warning

Attributes direction_instrument is needed only if direction_vector_type is INSTRUMENT_BORESIGHT, INSTRUMENT_FOV_BOUNDARY_VECTORS or VECTOR_IN_INSTRUMENT_FOV.

Attributes direction_frame is needed only if direction_vector_type is REFERENCE_FRAME_AXIS or VECTOR_IN_REFERENCE_FRAME.

Attributes direction_vector_x + direction_vector_y + direction_vector_z or direction_vector_ra + direction_vector_dec is needed only if direction_vector_type is VECTOR_IN_INSTRUMENT_FOV or VECTOR_IN_REFERENCE_FRAME.

Raises:

  • CalculationRequiredAttr – If target, target_frame and observer are not provided.

  • CalculationInvalidAttr – If shape_1 is not ELLIPSOID or DSK.

Tangent Point

Calculate the tangent point for a given observer, ray emanating from the observer, and target.

The tangent point is defined as the point on the ray nearest to the target’s surface. This panel also computes the point on the target’s surface nearest to the tangent point. The locations of both points are optionally corrected for light time and stellar aberration, and may be represented using either Rectangular, Ra/Dec, Planetocentric, Planetodetic, Planetographic, Spherical or Cylindrical coordinates.

The target’s surface shape is modeled as a triaxial ellipsoid.

For remote sensing observations, for maximum accuracy, reception light time and stellar aberration corrections should be used. These corrections model observer-target-ray geometry as it is observed.

For signal transmission applications, for maximum accuracy, transmission light time and stellar aberration corrections should be used. These corrections model the observer-target-ray geometry that applies to the transmitted signal. For example, these corrections are needed to calculate the minimum altitude of the signal’s path over the target body.

This calculation ignores differential aberration effects over the target body’s surface: it computes corrections only at a user-specified point, which is called the “aberration correction locus.” The user may select either the Tangent point or corresponding Surface point as the locus. In many cases, the differences between corrections for these points are very small.

Additionally, the illumination angles (incidence, emission and phase), time and local true solar time at the target point (where the aberration correction locus is set – or at the tangent point if no corrections are used), and the light time to that point, are computed.

>>> TangentPoint(
...     kernels = 5,
...     times = '2010-11-30T14:02:00',
...     target = 'ENCELADUS',
...     target_frame = 'IAU_ENCELADUS',
...     computation_method = 'ELLIPSOID',
...     observer = 'CASSINI',
...     direction_vector_type = 'INSTRUMENT_BORESIGHT',
...     direction_instrument = 'CASSINI_UVIS_HSP',
...     aberration_correction = 'CN+S',
...     correction_locus = 'TANGENT_POINT',
...     coordinate_representation = 'RECTANGULAR',
...     verbose = False,
... ).run()
{'DATE': '2010-11-30 14:02:00.000000 UTC',
 'TANGENT_POINT_GEOMETRY': 'Ray above limb',
 'TANGENT_POINT_X': -9.48919159,
 'TANGENT_POINT_Y': 36.16728915,
 'TANGENT_POINT_Z': -330.78398864,
 'SURFACE_POINT_X': -7.19366254,
 'SURFACE_POINT_Y': 27.15497998,
 'SURFACE_POINT_Z': -247.12357543,
 'DISTANCE_TO_TANGENT_POINT': 49830.33175196,
 'TANGENT_POINT_ALTITUDE': 84.17574418,
 'INCIDENCE_ANGLE': 97.72660812,
 'EMISSION_ANGLE': 90.0185557,
 'PHASE_ANGLE': 14.11694399,
 'TIME_AT_POINT': '2010-11-30 14:01:59.833784 UTC',
 'LIGHT_TIME': 0.1662161,
 'LTST': '05:38:33'}

Important

Calculation required parameters:
Default parameters:
Additional required parameters for direction_vector_type is INSTRUMENT_BORESIGHT or INSTRUMENT_FOV_BOUNDARY_VECTORS:
Additional required parameters for direction_vector_type is REFERENCE_FRAME_AXIS:
Additional required parameters for direction_vector_type is VECTOR_IN_INSTRUMENT_FOV:
Additional required parameters for direction_vector_type is VECTOR_IN_REFERENCE_FRAME:
Additional required parameters for direction_vector_type is DIRECTION_TO_OBJECT:
class webgeocalc.TangentPoint(computation_method='ELLIPSOID', vector_ab_corr='NONE', aberration_correction='CN', coordinate_representation='RECTANGULAR', **kwargs)[source]

Bases: Calculation

Tangent point calculation.

Calculate the tangent point for a given observer, ray emanating from the observer, and target.

The tangent point is defined as the point on the ray nearest to the target’s surface. This panel also computes the point on the target’s surface nearest to the tangent point. The locations of both points are optionally corrected for light time and stellar aberration, and may be represented using either Rectangular, Ra/Dec, Planetocentric, Planetodetic, Planetographic, Spherical or Cylindrical coordinates.

The target’s surface shape is modeled as a triaxial ellipsoid.

For remote sensing observations, for maximum accuracy, reception light time and stellar aberration corrections should be used. These corrections model observer-target-ray geometry as it is observed.

For signal transmission applications, for maximum accuracy, transmission light time and stellar aberration corrections should be used. These corrections model the observer-target-ray geometry that applies to the transmitted signal. For example, these corrections are needed to calculate the minimum altitude of the signal’s path over the target body.

This calculation ignores differential aberration effects over the target body’s surface: it computes corrections only at a user-specified point, which is called the “aberration correction locus.” The user may select either the Tangent point or corresponding Surface point as the locus. In many cases, the differences between corrections for these points are very small.

Additionally, the illumination angles (incidence, emission and phase), time and local true solar time at the target point (where the aberration correction locus is set – or at the tangent point if no corrections are used), and the light time to that point, are computed.

Parameters:

  • target (str or int) – See: target

  • target_frame (str or int) – See: target_frame

  • observer (str or int) – See: observer

  • direction_vector_type (str) – See: direction_vector_type

  • direction_object (str or int) – See: direction_object. Only when direction_vector_type is DIRECTION_TO_OBJECT

  • direction_instrument (str or int) – See: direction_instrument. Only when direction_vector_type is INSTRUMENT_BORESIGHT, ``INSTRUMENT_FOV_BOUNDARY_VECTORS or VECTOR_IN_INSTRUMENT_FOV

  • direction_frame (str) – See: direction_frame. Only when direction_vector_type is REFERENCE_FRAME_AXIS or VECTOR_IN_REFERENCE_FRAME

  • direction_frame_axis (str) – See: direction_frame_axis. Only when direction_vector_type is REFERENCE_FRAME_AXIS.

  • direction_vector_x (float) – See: direction_vector_x. Only when direction_vector_type is VECTOR_IN_INSTRUMENT_FOV or VECTOR_IN_REFERENCE_FRAME

  • direction_vector_y (float) – See: direction_vector_y. Only when direction_vector_type is VECTOR_IN_INSTRUMENT_FOV or VECTOR_IN_REFERENCE_FRAME

  • direction_vector_z (float) – See: direction_vector_z. Only when direction_vector_type is VECTOR_IN_INSTRUMENT_FOV or VECTOR_IN_REFERENCE_FRAME

  • direction_vector_ra (float) – See: direction_vector_ra Only when direction_vector_type is VECTOR_IN_INSTRUMENT_FOV or VECTOR_IN_REFERENCE_FRAME

  • direction_vector_dec (float) – See: direction_vector_dec Only when direction_vector_type is VECTOR_IN_INSTRUMENT_FOV or VECTOR_IN_REFERENCE_FRAME

  • direction_vector_az (float) – See: direction_vector_az Only when direction_vector_type is VECTOR_IN_INSTRUMENT_FOV or VECTOR_IN_REFERENCE_FRAME

  • direction_vector_el (float) – See: direction_vector_el Only when direction_vector_type is VECTOR_IN_INSTRUMENT_FOV or VECTOR_IN_REFERENCE_FRAME

  • azccw_flag (bool or str) – See: azccw_flag. Only when direction_vector_az is provided.

  • elplsz_flag (bool or str) – See: elplsz_flag. Only when direction_vector_el is provided.

  • computation_method (str, optional) – See: computation_method (default: ELLIPSOID)

  • vector_ab_corr (str, optional) – See: vector_ab_corr (default: NONE)

  • aberration_correction (str, optional) – See: aberration_correction (default: CN)

  • correction_locus (str, optional) – See: correction_locus (required if aberration_correction is not NONE)

  • coordinate_representation (str, optional) – See: coordinate_representation (default: RECTANGULAR)

  • kernels (str, int, [str or/and int]) – See: kernels

  • kernel_paths (str, [str]) – See: kernel_paths

  • times (str or [str]) – See: times

  • intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) – See: intervals

  • time_step (int) – See: time_step

  • time_step_units (str) – See: time_step_units

  • time_system (str) – See: time_system

  • time_format (str) – See: time_format

Raises:

  • CalculationRequiredAttr – If target, reference_frame, observer or direction_vector_type are not provided.

  • CalculationRequiredAttr – If aberration_correction is not NONE and correction_locus is not provided.

Osculating Elements

Calculate the osculating elements of the orbit of a target body around a central body. The orbit may be elliptical, parabolic, or hyperbolic.

>>> OsculatingElements(
...     kernels = [1,5],
...     times = '2012-10-19T08:24:00.000',
...     orbiting_body = 'CASSINI',
...     center_body = 'SATURN',
...     verbose = False,
... ).run()
{'DATE': '2012-10-19 08:24:00.000000 UTC',
 'PERIFOCAL_DISTANCE': 474789.01814487,
 'ECCENTRICITY': 0.70348464,
 'INCLINATION': 38.18736036,
 'ASCENDING_NODE_LONGITUDE': 223.98121958,
 'ARGUMENT_OF_PERIAPSE': 71.59475294,
 'MEAN_ANOMALY_AT_EPOCH': 14.65461277,
 'ORBITING_BODY_RANGE': 753794.66333655,
 'ORBITING_BODY_SPEED': 8.77222221,
 'PERIOD': 2067101.1993984,
 'CENTER_BODY_GM': 37931207.49865224}

Important

Calculation required parameters:
Default parameters:
class webgeocalc.OsculatingElements(reference_frame='J2000', **kwargs)[source]

Bases: 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: reference_frame

  • kernels (str, int, [str or/and int]) – See: kernels

  • kernel_paths (str, [str]) – See: kernel_paths

  • times (str or [str]) – See: times

  • intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) – See: intervals

  • time_step (int) – See: time_step

  • time_step_units (str) – See: time_step_units

  • time_system (str) – See: time_system

  • time_format (str) – See: time_format

  • orbiting_body (str or int) – See: orbiting_body

  • center_body (str or int) – See: center_body

Raises:

CalculationRequiredAttr – If orbiting_body and center_body are not provided.

Time Conversion

Convert times from one time system or format to another.

>>> TimeConversion(
...     kernels = 5,
...     times = '1/1729329441.04',
...     time_system = 'SPACECRAFT_CLOCK',
...     time_format = 'SPACECRAFT_CLOCK_STRING',
...     sclk_id = -82,
...     verbose = False,
... ).run()
{'DATE': '1/1729329441.004', 'DATE2': '2012-10-19 08:24:02.919085 UTC'}

Important

Calculation required parameters:
Default parameters:
class webgeocalc.TimeConversion(output_time_system='UTC', output_time_format='CALENDAR', **kwargs)[source]

Bases: Calculation

Time conversion calculation.

Convert times from one time system or format to another.

Parameters:

  • output_time_system (str, optional) – See: output_time_system

  • output_time_format (str, optional) – See: output_time_format

  • kernels (str, int, [str or/and int]) – See: kernels

  • kernel_paths (str, [str]) – See: kernel_paths

  • times (str or [str]) – See: times

  • intervals ([str, str] or {'startTime': str, 'endTime': str} or [interval, ...]) – See: intervals

  • time_step (int) – See: time_step

  • time_step_units (str) – See: time_step_units

  • time_system (str) – See: time_system

  • time_format (str) – See: time_format

  • output_sclk_id (str) – See: output_sclk_id

  • output_time_custom_format (str) – See: output_time_custom_format

Warning

Attributes output_sclk_id is needed only if output_time_system is SPACECRAFT_CLOCK.

Attributes output_time_custom_format is needed only if output_time_format is CUSTOM.

Geometry Finder: other searches

At the moment, the following geometry finder search calculation are not implemented:

Note

You might be able to run some of them with a regular Calculation object but is not tested yet. If you want to implement them, contributions are always welcome (don’t forget to submit a merge request on the main project).

class webgeocalc.GFAngularSeparationSearch(*_, **__)[source]

Bases: CalculationNotImplemented

Angular separation search geometry finder.

Find time intervals when the angle between two bodies, as seen by an observer, satisfies a condition.

class webgeocalc.GFDistanceSearch(*_, **__)[source]

Bases: CalculationNotImplemented

Distance search geometry finder.

Find time intervals when the distance between a target and observer satisfies a condition.

class webgeocalc.GFSubPointSearch(*_, **__)[source]

Bases: CalculationNotImplemented

Sub-point search geometry finder.

Find time intervals when a coordinate of the sub-observer point on a target satisfies a condition.

class webgeocalc.GFOccultationSearch(*_, **__)[source]

Bases: CalculationNotImplemented

Occultation search geometry finder.

Find time intervals when an observer sees one target occulted by, or in transit across, another.

class webgeocalc.GFSurfaceInterceptPointSearch(*_, **__)[source]

Bases: CalculationNotImplemented

Surface intercept point search geometry finder.

Find time intervals when a coordinate of a surface intercept vector satisfies a condition.

class webgeocalc.GFTargetInInstrumentFovSearch(*_, **__)[source]

Bases: CalculationNotImplemented

Target in instrument fov search geometry finder.

Find time intervals when a target intersects the space bounded by the field-of-view of an instrument.

class webgeocalc.GFRayInFovSearch(*_, **__)[source]

Bases: CalculationNotImplemented

Ray in fov search geometry finder.

Find time intervals when a specified ray is contained in the space bounded by an instrument’s field-of-view.

class webgeocalc.GFRangeRateSearch(*_, **__)[source]

Bases: CalculationNotImplemented

Range rate search geometry finder.

Find time intervals when the range rate between a target and observer satisfies a condition.

class webgeocalc.GFPhaseAngleSearch(*_, **__)[source]

Bases: CalculationNotImplemented

Phase angle search geometry finder.

Find time intervals for which a specified constraint on the phase angle defined by an illumination source, a target, and an observer body centers is met.

class webgeocalc.GFIlluminationAnglesSearch(*_, **__)[source]

Bases: CalculationNotImplemented

Illumination angles search geometry finder.

Find the time intervals, within a specified time window, when one of the illumination angles — phase, incidence or emission — at the specified target body surface point as seen from an observer satisfies a given constraint.