WebGeoCalc calculations

For now only the 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

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: object

Webgeocalc calculation object.

Parameters
Raises
property payload

Calculation payload parameters dict for JSON input in WebGeoCalc format.

Returns

Payload keys and values.

Return type

dict

Example

>>> Calculation(
...    kernels = 'Cassini Huygens',
...    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',
... ).payload  # noqa: E501
{'kernels': [{'type': 'KERNEL_SET', 'id': 5}], 'times': ['2012-10-19T08:24:00.000'], ...}
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 retrive 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 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

Raises

CalculationInvalidAttr – If the value provided is invalid.

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:

  • LATITUDINAL (planetocentric)

  • PLANETODETIC

  • PLANETOGRAPHIC

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. 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)

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 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.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}

Important

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

Bases: webgeocalc.calculation.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 as seen by an observer body.

>>> 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}

Important

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

Bases: webgeocalc.calculation.Calculation

Angular separation calculation.

Calculates the angular separation of two bodies as seen by an observer body.

Parameters

  • shape_1 (str, optional) – See: shape_1

  • shape_2 (str, optional) – See: shape_2

  • 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_1 (str or int) – See: target_1

  • target_2 (str or int) – See: target_2

  • observer (str or int) – See: observer

Raises

CalculationRequiredAttr – If target_1, target_2 and observer 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.03037939}

Important

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

Bases: webgeocalc.calculation.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': -20.58940104,
 'ANGLE2': 0.01874004,
 'ANGLE1': 0.00136319,
 'AV_X': 9.94596495e-07,
 'AV_Y': -7.23492228e-08,
 'AV_Z': -0.00634331,
 'AV_MAG': 0.00634331}

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: webgeocalc.calculation.Calculation

Frame transforme 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.

  • 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': 24.78527742,
 'EMISSION_ANGLE': 25.56007298,
 'PHASE_ANGLE': 1.00079007,
 'OBSERVER_ALTITUDE': 967668.02765637,
 'TIME_AT_POINT': '2012-10-19 08:23:56.772207 UTC',
 'LIGHT_TIME': 3.2277931,
 'LTST': '13:15:59'}

Important

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

Bases: webgeocalc.calculation.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.

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': 234.00550655,
 'Y': -77.32612213,
 'Z': 67.42916937,
 'SUB_POINT_RADIUS': 255.50851089,
 'OBSERVER_ALTITUDE': 967644.15493281,
 'INCIDENCE_ANGLE': 4.49798357e-15,
 'EMISSION_ANGLE': 0.99611862,
 'PHASE_ANGLE': 0.99611862,
 'TIME_AT_POINT': '2012-10-19 08:23:56.772287 UTC',
 'LIGHT_TIME': 3.22771347}

Important

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

Bases: webgeocalc.calculation.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.

  • 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': 232.5831733,
 'Y': -81.40386728,
 'Z': 67.35505213,
 'SUB_POINT_RADIUS': 255.45689491,
 'OBSERVER_ALTITUDE': 967644.11734179,
 'INCIDENCE_ANGLE': 0.99586304,
 'EMISSION_ANGLE': 1.66981544e-12,
 'PHASE_ANGLE': 0.99586304,
 'TIME_AT_POINT': '2012-10-19 08:23:56.772287 UTC',
 'LIGHT_TIME': 3.22771334,
 '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: webgeocalc.calculation.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.7675609,
 'LATITUDE': -38.69027976,
 'INTERCEPT_RADIUS': 57739.95803153,
 'OBSERVER_ALTITUDE': 1831047.67987589,
 'INCIDENCE_ANGLE': 123.05323675,
 'EMISSION_ANGLE': 5.8567773,
 'PHASE_ANGLE': 123.77530312,
 'TIME_AT_POINT': '2012-10-14 00:00:00.000000 UTC',
 'LIGHT_TIME': 6.10771763,
 '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: webgeocalc.calculation.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.

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.03917271,
 'ECCENTRICITY': 0.70348463,
 'INCLINATION': 38.18727034,
 'ASCENDING_NODE_LONGITUDE': 223.98123058,
 'ARGUMENT_OF_PERIAPSE': 71.59474487,
 'MEAN_ANOMALY_AT_EPOCH': 14.65461204,
 'ORBITING_BODY_RANGE': 753794.65101401,
 'ORBITING_BODY_SPEED': 8.77222231,
 'PERIOD': 2067101.2236748,
 'CENTER_BODY_GM': 37931207.49865224}

Important

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

Bases: webgeocalc.calculation.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: webgeocalc.calculation.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.