astrox-python 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- astrox/__init__.py +49 -0
- astrox/_http.py +504 -0
- astrox/access.py +173 -0
- astrox/components/__init__.py +202 -0
- astrox/components/_axes.py +508 -0
- astrox/components/_common.py +141 -0
- astrox/components/_constraints.py +138 -0
- astrox/components/_objects.py +167 -0
- astrox/components/_positions.py +673 -0
- astrox/components/_rotations.py +115 -0
- astrox/components/_sensors.py +134 -0
- astrox/components/_vgt.py +337 -0
- astrox/coverage/__init__.py +41 -0
- astrox/coverage/_core.py +552 -0
- astrox/coverage/_fom.py +125 -0
- astrox/coverage/coverage_time.py +83 -0
- astrox/coverage/number_of_assets.py +160 -0
- astrox/coverage/response_time.py +160 -0
- astrox/coverage/revisit_time.py +160 -0
- astrox/coverage/simple_coverage.py +152 -0
- astrox/exceptions.py +92 -0
- astrox/lighting.py +121 -0
- astrox/orbits.py +499 -0
- astrox/propagator.py +1072 -0
- astrox/rocket.py +82 -0
- astrox_python-0.1.0.dist-info/METADATA +82 -0
- astrox_python-0.1.0.dist-info/RECORD +29 -0
- astrox_python-0.1.0.dist-info/WHEEL +4 -0
- astrox_python-0.1.0.dist-info/licenses/LICENSE +21 -0
|
@@ -0,0 +1,83 @@
|
|
|
1
|
+
"""Coverage-time FOM routes."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from collections.abc import Sequence
|
|
6
|
+
from typing import Any
|
|
7
|
+
|
|
8
|
+
from astrox import components
|
|
9
|
+
|
|
10
|
+
from ._core import CoverageGrid
|
|
11
|
+
from ._fom import post_value_by_grid_point_input
|
|
12
|
+
|
|
13
|
+
__all__ = ["by_grid_point", "grid_stats"]
|
|
14
|
+
|
|
15
|
+
|
|
16
|
+
def by_grid_point(
|
|
17
|
+
*,
|
|
18
|
+
start: str,
|
|
19
|
+
stop: str,
|
|
20
|
+
grid: CoverageGrid,
|
|
21
|
+
assets: Sequence[components.Entity],
|
|
22
|
+
compute_type: str | None = None,
|
|
23
|
+
minimum_assets: int | None = None,
|
|
24
|
+
exactly_assets: int | None = None,
|
|
25
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
26
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
27
|
+
include_asset_access_results: bool | None = None,
|
|
28
|
+
include_coverage_points: bool | None = None,
|
|
29
|
+
step_s: float | None = None,
|
|
30
|
+
description: str | None = None,
|
|
31
|
+
) -> dict[str, Any]:
|
|
32
|
+
"""Compute coverage-time FOM values for each grid point."""
|
|
33
|
+
return post_value_by_grid_point_input(
|
|
34
|
+
"/Coverage/FOM/ValueByGridPoint/CoverageTime",
|
|
35
|
+
start=start,
|
|
36
|
+
stop=stop,
|
|
37
|
+
grid=grid,
|
|
38
|
+
assets=assets,
|
|
39
|
+
compute_type=compute_type,
|
|
40
|
+
minimum_assets=minimum_assets,
|
|
41
|
+
exactly_assets=exactly_assets,
|
|
42
|
+
grid_point_sensor=grid_point_sensor,
|
|
43
|
+
grid_point_constraints=grid_point_constraints,
|
|
44
|
+
include_asset_access_results=include_asset_access_results,
|
|
45
|
+
include_coverage_points=include_coverage_points,
|
|
46
|
+
step_s=step_s,
|
|
47
|
+
description=description,
|
|
48
|
+
)
|
|
49
|
+
|
|
50
|
+
|
|
51
|
+
def grid_stats(
|
|
52
|
+
*,
|
|
53
|
+
start: str,
|
|
54
|
+
stop: str,
|
|
55
|
+
grid: CoverageGrid,
|
|
56
|
+
assets: Sequence[components.Entity],
|
|
57
|
+
compute_type: str | None = None,
|
|
58
|
+
minimum_assets: int | None = None,
|
|
59
|
+
exactly_assets: int | None = None,
|
|
60
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
61
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
62
|
+
include_asset_access_results: bool | None = None,
|
|
63
|
+
include_coverage_points: bool | None = None,
|
|
64
|
+
step_s: float | None = None,
|
|
65
|
+
description: str | None = None,
|
|
66
|
+
) -> dict[str, Any]:
|
|
67
|
+
"""Compute coverage-time grid statistics."""
|
|
68
|
+
return post_value_by_grid_point_input(
|
|
69
|
+
"/Coverage/FOM/GridStats/CoverageTime",
|
|
70
|
+
start=start,
|
|
71
|
+
stop=stop,
|
|
72
|
+
grid=grid,
|
|
73
|
+
assets=assets,
|
|
74
|
+
compute_type=compute_type,
|
|
75
|
+
minimum_assets=minimum_assets,
|
|
76
|
+
exactly_assets=exactly_assets,
|
|
77
|
+
grid_point_sensor=grid_point_sensor,
|
|
78
|
+
grid_point_constraints=grid_point_constraints,
|
|
79
|
+
include_asset_access_results=include_asset_access_results,
|
|
80
|
+
include_coverage_points=include_coverage_points,
|
|
81
|
+
step_s=step_s,
|
|
82
|
+
description=description,
|
|
83
|
+
)
|
|
@@ -0,0 +1,160 @@
|
|
|
1
|
+
"""Number-of-assets FOM routes."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from collections.abc import Sequence
|
|
6
|
+
from typing import Any
|
|
7
|
+
|
|
8
|
+
from astrox import components
|
|
9
|
+
|
|
10
|
+
from ._core import CoverageGrid
|
|
11
|
+
from ._fom import (
|
|
12
|
+
post_coverage_input,
|
|
13
|
+
post_time_value_by_grid_point_input,
|
|
14
|
+
post_value_by_grid_point_input,
|
|
15
|
+
)
|
|
16
|
+
|
|
17
|
+
__all__ = [
|
|
18
|
+
"by_grid_point",
|
|
19
|
+
"by_grid_point_at_time",
|
|
20
|
+
"grid_stats",
|
|
21
|
+
"grid_stats_over_time",
|
|
22
|
+
]
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def by_grid_point(
|
|
26
|
+
*,
|
|
27
|
+
start: str,
|
|
28
|
+
stop: str,
|
|
29
|
+
grid: CoverageGrid,
|
|
30
|
+
assets: Sequence[components.Entity],
|
|
31
|
+
compute_type: str | None = None,
|
|
32
|
+
minimum_assets: int | None = None,
|
|
33
|
+
exactly_assets: int | None = None,
|
|
34
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
35
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
36
|
+
include_asset_access_results: bool | None = None,
|
|
37
|
+
include_coverage_points: bool | None = None,
|
|
38
|
+
step_s: float | None = None,
|
|
39
|
+
description: str | None = None,
|
|
40
|
+
) -> dict[str, Any]:
|
|
41
|
+
"""Compute number-of-assets FOM values for each grid point."""
|
|
42
|
+
return post_value_by_grid_point_input(
|
|
43
|
+
"/Coverage/FOM/ValueByGridPoint/NumberOfAssets",
|
|
44
|
+
start=start,
|
|
45
|
+
stop=stop,
|
|
46
|
+
grid=grid,
|
|
47
|
+
assets=assets,
|
|
48
|
+
compute_type=compute_type,
|
|
49
|
+
minimum_assets=minimum_assets,
|
|
50
|
+
exactly_assets=exactly_assets,
|
|
51
|
+
grid_point_sensor=grid_point_sensor,
|
|
52
|
+
grid_point_constraints=grid_point_constraints,
|
|
53
|
+
include_asset_access_results=include_asset_access_results,
|
|
54
|
+
include_coverage_points=include_coverage_points,
|
|
55
|
+
step_s=step_s,
|
|
56
|
+
description=description,
|
|
57
|
+
)
|
|
58
|
+
|
|
59
|
+
|
|
60
|
+
def by_grid_point_at_time(
|
|
61
|
+
*,
|
|
62
|
+
time: str,
|
|
63
|
+
start: str,
|
|
64
|
+
stop: str,
|
|
65
|
+
grid: CoverageGrid,
|
|
66
|
+
assets: Sequence[components.Entity],
|
|
67
|
+
minimum_assets: int | None = None,
|
|
68
|
+
exactly_assets: int | None = None,
|
|
69
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
70
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
71
|
+
include_asset_access_results: bool | None = None,
|
|
72
|
+
include_coverage_points: bool | None = None,
|
|
73
|
+
step_s: float | None = None,
|
|
74
|
+
description: str | None = None,
|
|
75
|
+
) -> dict[str, Any]:
|
|
76
|
+
"""Compute number-of-assets FOM values for each grid point at one time."""
|
|
77
|
+
return post_time_value_by_grid_point_input(
|
|
78
|
+
"/Coverage/FOM/ValueByGridPointAtTime/NumberOfAssets",
|
|
79
|
+
time=time,
|
|
80
|
+
start=start,
|
|
81
|
+
stop=stop,
|
|
82
|
+
grid=grid,
|
|
83
|
+
assets=assets,
|
|
84
|
+
minimum_assets=minimum_assets,
|
|
85
|
+
exactly_assets=exactly_assets,
|
|
86
|
+
grid_point_sensor=grid_point_sensor,
|
|
87
|
+
grid_point_constraints=grid_point_constraints,
|
|
88
|
+
include_asset_access_results=include_asset_access_results,
|
|
89
|
+
include_coverage_points=include_coverage_points,
|
|
90
|
+
step_s=step_s,
|
|
91
|
+
description=description,
|
|
92
|
+
)
|
|
93
|
+
|
|
94
|
+
|
|
95
|
+
def grid_stats(
|
|
96
|
+
*,
|
|
97
|
+
start: str,
|
|
98
|
+
stop: str,
|
|
99
|
+
grid: CoverageGrid,
|
|
100
|
+
assets: Sequence[components.Entity],
|
|
101
|
+
compute_type: str | None = None,
|
|
102
|
+
minimum_assets: int | None = None,
|
|
103
|
+
exactly_assets: int | None = None,
|
|
104
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
105
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
106
|
+
include_asset_access_results: bool | None = None,
|
|
107
|
+
include_coverage_points: bool | None = None,
|
|
108
|
+
step_s: float | None = None,
|
|
109
|
+
description: str | None = None,
|
|
110
|
+
) -> dict[str, Any]:
|
|
111
|
+
"""Compute number-of-assets grid statistics."""
|
|
112
|
+
return post_value_by_grid_point_input(
|
|
113
|
+
"/Coverage/FOM/GridStats/NumberOfAssets",
|
|
114
|
+
start=start,
|
|
115
|
+
stop=stop,
|
|
116
|
+
grid=grid,
|
|
117
|
+
assets=assets,
|
|
118
|
+
compute_type=compute_type,
|
|
119
|
+
minimum_assets=minimum_assets,
|
|
120
|
+
exactly_assets=exactly_assets,
|
|
121
|
+
grid_point_sensor=grid_point_sensor,
|
|
122
|
+
grid_point_constraints=grid_point_constraints,
|
|
123
|
+
include_asset_access_results=include_asset_access_results,
|
|
124
|
+
include_coverage_points=include_coverage_points,
|
|
125
|
+
step_s=step_s,
|
|
126
|
+
description=description,
|
|
127
|
+
)
|
|
128
|
+
|
|
129
|
+
|
|
130
|
+
def grid_stats_over_time(
|
|
131
|
+
*,
|
|
132
|
+
start: str,
|
|
133
|
+
stop: str,
|
|
134
|
+
grid: CoverageGrid,
|
|
135
|
+
assets: Sequence[components.Entity],
|
|
136
|
+
minimum_assets: int | None = None,
|
|
137
|
+
exactly_assets: int | None = None,
|
|
138
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
139
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
140
|
+
include_asset_access_results: bool | None = None,
|
|
141
|
+
include_coverage_points: bool | None = None,
|
|
142
|
+
step_s: float | None = None,
|
|
143
|
+
description: str | None = None,
|
|
144
|
+
) -> dict[str, Any]:
|
|
145
|
+
"""Compute number-of-assets grid statistics over time."""
|
|
146
|
+
return post_coverage_input(
|
|
147
|
+
"/Coverage/FOM/GridStatsOverTime/NumberOfAssets",
|
|
148
|
+
start=start,
|
|
149
|
+
stop=stop,
|
|
150
|
+
grid=grid,
|
|
151
|
+
assets=assets,
|
|
152
|
+
minimum_assets=minimum_assets,
|
|
153
|
+
exactly_assets=exactly_assets,
|
|
154
|
+
grid_point_sensor=grid_point_sensor,
|
|
155
|
+
grid_point_constraints=grid_point_constraints,
|
|
156
|
+
include_asset_access_results=include_asset_access_results,
|
|
157
|
+
include_coverage_points=include_coverage_points,
|
|
158
|
+
step_s=step_s,
|
|
159
|
+
description=description,
|
|
160
|
+
)
|
|
@@ -0,0 +1,160 @@
|
|
|
1
|
+
"""Response-time FOM routes."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from collections.abc import Sequence
|
|
6
|
+
from typing import Any
|
|
7
|
+
|
|
8
|
+
from astrox import components
|
|
9
|
+
|
|
10
|
+
from ._core import CoverageGrid
|
|
11
|
+
from ._fom import (
|
|
12
|
+
post_coverage_input,
|
|
13
|
+
post_time_value_by_grid_point_input,
|
|
14
|
+
post_value_by_grid_point_input,
|
|
15
|
+
)
|
|
16
|
+
|
|
17
|
+
__all__ = [
|
|
18
|
+
"by_grid_point",
|
|
19
|
+
"by_grid_point_at_time",
|
|
20
|
+
"grid_stats",
|
|
21
|
+
"grid_stats_over_time",
|
|
22
|
+
]
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def by_grid_point(
|
|
26
|
+
*,
|
|
27
|
+
start: str,
|
|
28
|
+
stop: str,
|
|
29
|
+
grid: CoverageGrid,
|
|
30
|
+
assets: Sequence[components.Entity],
|
|
31
|
+
compute_type: str | None = None,
|
|
32
|
+
minimum_assets: int | None = None,
|
|
33
|
+
exactly_assets: int | None = None,
|
|
34
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
35
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
36
|
+
include_asset_access_results: bool | None = None,
|
|
37
|
+
include_coverage_points: bool | None = None,
|
|
38
|
+
step_s: float | None = None,
|
|
39
|
+
description: str | None = None,
|
|
40
|
+
) -> dict[str, Any]:
|
|
41
|
+
"""Compute response-time FOM values for each grid point."""
|
|
42
|
+
return post_value_by_grid_point_input(
|
|
43
|
+
"/Coverage/FOM/ValueByGridPoint/ResponseTime",
|
|
44
|
+
start=start,
|
|
45
|
+
stop=stop,
|
|
46
|
+
grid=grid,
|
|
47
|
+
assets=assets,
|
|
48
|
+
compute_type=compute_type,
|
|
49
|
+
minimum_assets=minimum_assets,
|
|
50
|
+
exactly_assets=exactly_assets,
|
|
51
|
+
grid_point_sensor=grid_point_sensor,
|
|
52
|
+
grid_point_constraints=grid_point_constraints,
|
|
53
|
+
include_asset_access_results=include_asset_access_results,
|
|
54
|
+
include_coverage_points=include_coverage_points,
|
|
55
|
+
step_s=step_s,
|
|
56
|
+
description=description,
|
|
57
|
+
)
|
|
58
|
+
|
|
59
|
+
|
|
60
|
+
def by_grid_point_at_time(
|
|
61
|
+
*,
|
|
62
|
+
time: str,
|
|
63
|
+
start: str,
|
|
64
|
+
stop: str,
|
|
65
|
+
grid: CoverageGrid,
|
|
66
|
+
assets: Sequence[components.Entity],
|
|
67
|
+
minimum_assets: int | None = None,
|
|
68
|
+
exactly_assets: int | None = None,
|
|
69
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
70
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
71
|
+
include_asset_access_results: bool | None = None,
|
|
72
|
+
include_coverage_points: bool | None = None,
|
|
73
|
+
step_s: float | None = None,
|
|
74
|
+
description: str | None = None,
|
|
75
|
+
) -> dict[str, Any]:
|
|
76
|
+
"""Compute response-time FOM values for each grid point at one time."""
|
|
77
|
+
return post_time_value_by_grid_point_input(
|
|
78
|
+
"/Coverage/FOM/ValueByGridPointAtTime/ResponseTime",
|
|
79
|
+
time=time,
|
|
80
|
+
start=start,
|
|
81
|
+
stop=stop,
|
|
82
|
+
grid=grid,
|
|
83
|
+
assets=assets,
|
|
84
|
+
minimum_assets=minimum_assets,
|
|
85
|
+
exactly_assets=exactly_assets,
|
|
86
|
+
grid_point_sensor=grid_point_sensor,
|
|
87
|
+
grid_point_constraints=grid_point_constraints,
|
|
88
|
+
include_asset_access_results=include_asset_access_results,
|
|
89
|
+
include_coverage_points=include_coverage_points,
|
|
90
|
+
step_s=step_s,
|
|
91
|
+
description=description,
|
|
92
|
+
)
|
|
93
|
+
|
|
94
|
+
|
|
95
|
+
def grid_stats(
|
|
96
|
+
*,
|
|
97
|
+
start: str,
|
|
98
|
+
stop: str,
|
|
99
|
+
grid: CoverageGrid,
|
|
100
|
+
assets: Sequence[components.Entity],
|
|
101
|
+
compute_type: str | None = None,
|
|
102
|
+
minimum_assets: int | None = None,
|
|
103
|
+
exactly_assets: int | None = None,
|
|
104
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
105
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
106
|
+
include_asset_access_results: bool | None = None,
|
|
107
|
+
include_coverage_points: bool | None = None,
|
|
108
|
+
step_s: float | None = None,
|
|
109
|
+
description: str | None = None,
|
|
110
|
+
) -> dict[str, Any]:
|
|
111
|
+
"""Compute response-time grid statistics."""
|
|
112
|
+
return post_value_by_grid_point_input(
|
|
113
|
+
"/Coverage/FOM/GridStats/ResponseTime",
|
|
114
|
+
start=start,
|
|
115
|
+
stop=stop,
|
|
116
|
+
grid=grid,
|
|
117
|
+
assets=assets,
|
|
118
|
+
compute_type=compute_type,
|
|
119
|
+
minimum_assets=minimum_assets,
|
|
120
|
+
exactly_assets=exactly_assets,
|
|
121
|
+
grid_point_sensor=grid_point_sensor,
|
|
122
|
+
grid_point_constraints=grid_point_constraints,
|
|
123
|
+
include_asset_access_results=include_asset_access_results,
|
|
124
|
+
include_coverage_points=include_coverage_points,
|
|
125
|
+
step_s=step_s,
|
|
126
|
+
description=description,
|
|
127
|
+
)
|
|
128
|
+
|
|
129
|
+
|
|
130
|
+
def grid_stats_over_time(
|
|
131
|
+
*,
|
|
132
|
+
start: str,
|
|
133
|
+
stop: str,
|
|
134
|
+
grid: CoverageGrid,
|
|
135
|
+
assets: Sequence[components.Entity],
|
|
136
|
+
minimum_assets: int | None = None,
|
|
137
|
+
exactly_assets: int | None = None,
|
|
138
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
139
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
140
|
+
include_asset_access_results: bool | None = None,
|
|
141
|
+
include_coverage_points: bool | None = None,
|
|
142
|
+
step_s: float | None = None,
|
|
143
|
+
description: str | None = None,
|
|
144
|
+
) -> dict[str, Any]:
|
|
145
|
+
"""Compute response-time grid statistics over time."""
|
|
146
|
+
return post_coverage_input(
|
|
147
|
+
"/Coverage/FOM/GridStatsOverTime/ResponseTime",
|
|
148
|
+
start=start,
|
|
149
|
+
stop=stop,
|
|
150
|
+
grid=grid,
|
|
151
|
+
assets=assets,
|
|
152
|
+
minimum_assets=minimum_assets,
|
|
153
|
+
exactly_assets=exactly_assets,
|
|
154
|
+
grid_point_sensor=grid_point_sensor,
|
|
155
|
+
grid_point_constraints=grid_point_constraints,
|
|
156
|
+
include_asset_access_results=include_asset_access_results,
|
|
157
|
+
include_coverage_points=include_coverage_points,
|
|
158
|
+
step_s=step_s,
|
|
159
|
+
description=description,
|
|
160
|
+
)
|
|
@@ -0,0 +1,160 @@
|
|
|
1
|
+
"""Revisit-time FOM routes."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from collections.abc import Sequence
|
|
6
|
+
from typing import Any
|
|
7
|
+
|
|
8
|
+
from astrox import components
|
|
9
|
+
|
|
10
|
+
from ._core import CoverageGrid
|
|
11
|
+
from ._fom import (
|
|
12
|
+
post_coverage_input,
|
|
13
|
+
post_time_value_by_grid_point_input,
|
|
14
|
+
post_value_by_grid_point_input,
|
|
15
|
+
)
|
|
16
|
+
|
|
17
|
+
__all__ = [
|
|
18
|
+
"by_grid_point",
|
|
19
|
+
"by_grid_point_at_time",
|
|
20
|
+
"grid_stats",
|
|
21
|
+
"grid_stats_over_time",
|
|
22
|
+
]
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def by_grid_point(
|
|
26
|
+
*,
|
|
27
|
+
start: str,
|
|
28
|
+
stop: str,
|
|
29
|
+
grid: CoverageGrid,
|
|
30
|
+
assets: Sequence[components.Entity],
|
|
31
|
+
compute_type: str | None = None,
|
|
32
|
+
minimum_assets: int | None = None,
|
|
33
|
+
exactly_assets: int | None = None,
|
|
34
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
35
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
36
|
+
include_asset_access_results: bool | None = None,
|
|
37
|
+
include_coverage_points: bool | None = None,
|
|
38
|
+
step_s: float | None = None,
|
|
39
|
+
description: str | None = None,
|
|
40
|
+
) -> dict[str, Any]:
|
|
41
|
+
"""Compute revisit-time FOM values for each grid point."""
|
|
42
|
+
return post_value_by_grid_point_input(
|
|
43
|
+
"/Coverage/FOM/ValueByGridPoint/RevisitTime",
|
|
44
|
+
start=start,
|
|
45
|
+
stop=stop,
|
|
46
|
+
grid=grid,
|
|
47
|
+
assets=assets,
|
|
48
|
+
compute_type=compute_type,
|
|
49
|
+
minimum_assets=minimum_assets,
|
|
50
|
+
exactly_assets=exactly_assets,
|
|
51
|
+
grid_point_sensor=grid_point_sensor,
|
|
52
|
+
grid_point_constraints=grid_point_constraints,
|
|
53
|
+
include_asset_access_results=include_asset_access_results,
|
|
54
|
+
include_coverage_points=include_coverage_points,
|
|
55
|
+
step_s=step_s,
|
|
56
|
+
description=description,
|
|
57
|
+
)
|
|
58
|
+
|
|
59
|
+
|
|
60
|
+
def by_grid_point_at_time(
|
|
61
|
+
*,
|
|
62
|
+
time: str,
|
|
63
|
+
start: str,
|
|
64
|
+
stop: str,
|
|
65
|
+
grid: CoverageGrid,
|
|
66
|
+
assets: Sequence[components.Entity],
|
|
67
|
+
minimum_assets: int | None = None,
|
|
68
|
+
exactly_assets: int | None = None,
|
|
69
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
70
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
71
|
+
include_asset_access_results: bool | None = None,
|
|
72
|
+
include_coverage_points: bool | None = None,
|
|
73
|
+
step_s: float | None = None,
|
|
74
|
+
description: str | None = None,
|
|
75
|
+
) -> dict[str, Any]:
|
|
76
|
+
"""Compute revisit-time FOM values for each grid point at one time."""
|
|
77
|
+
return post_time_value_by_grid_point_input(
|
|
78
|
+
"/Coverage/FOM/ValueByGridPointAtTime/RevisitTime",
|
|
79
|
+
time=time,
|
|
80
|
+
start=start,
|
|
81
|
+
stop=stop,
|
|
82
|
+
grid=grid,
|
|
83
|
+
assets=assets,
|
|
84
|
+
minimum_assets=minimum_assets,
|
|
85
|
+
exactly_assets=exactly_assets,
|
|
86
|
+
grid_point_sensor=grid_point_sensor,
|
|
87
|
+
grid_point_constraints=grid_point_constraints,
|
|
88
|
+
include_asset_access_results=include_asset_access_results,
|
|
89
|
+
include_coverage_points=include_coverage_points,
|
|
90
|
+
step_s=step_s,
|
|
91
|
+
description=description,
|
|
92
|
+
)
|
|
93
|
+
|
|
94
|
+
|
|
95
|
+
def grid_stats(
|
|
96
|
+
*,
|
|
97
|
+
start: str,
|
|
98
|
+
stop: str,
|
|
99
|
+
grid: CoverageGrid,
|
|
100
|
+
assets: Sequence[components.Entity],
|
|
101
|
+
compute_type: str | None = None,
|
|
102
|
+
minimum_assets: int | None = None,
|
|
103
|
+
exactly_assets: int | None = None,
|
|
104
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
105
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
106
|
+
include_asset_access_results: bool | None = None,
|
|
107
|
+
include_coverage_points: bool | None = None,
|
|
108
|
+
step_s: float | None = None,
|
|
109
|
+
description: str | None = None,
|
|
110
|
+
) -> dict[str, Any]:
|
|
111
|
+
"""Compute revisit-time grid statistics."""
|
|
112
|
+
return post_value_by_grid_point_input(
|
|
113
|
+
"/Coverage/FOM/GridStats/RevisitTime",
|
|
114
|
+
start=start,
|
|
115
|
+
stop=stop,
|
|
116
|
+
grid=grid,
|
|
117
|
+
assets=assets,
|
|
118
|
+
compute_type=compute_type,
|
|
119
|
+
minimum_assets=minimum_assets,
|
|
120
|
+
exactly_assets=exactly_assets,
|
|
121
|
+
grid_point_sensor=grid_point_sensor,
|
|
122
|
+
grid_point_constraints=grid_point_constraints,
|
|
123
|
+
include_asset_access_results=include_asset_access_results,
|
|
124
|
+
include_coverage_points=include_coverage_points,
|
|
125
|
+
step_s=step_s,
|
|
126
|
+
description=description,
|
|
127
|
+
)
|
|
128
|
+
|
|
129
|
+
|
|
130
|
+
def grid_stats_over_time(
|
|
131
|
+
*,
|
|
132
|
+
start: str,
|
|
133
|
+
stop: str,
|
|
134
|
+
grid: CoverageGrid,
|
|
135
|
+
assets: Sequence[components.Entity],
|
|
136
|
+
minimum_assets: int | None = None,
|
|
137
|
+
exactly_assets: int | None = None,
|
|
138
|
+
grid_point_sensor: components.EntitySensor | None = None,
|
|
139
|
+
grid_point_constraints: Sequence[components.Constraint] | None = None,
|
|
140
|
+
include_asset_access_results: bool | None = None,
|
|
141
|
+
include_coverage_points: bool | None = None,
|
|
142
|
+
step_s: float | None = None,
|
|
143
|
+
description: str | None = None,
|
|
144
|
+
) -> dict[str, Any]:
|
|
145
|
+
"""Compute revisit-time grid statistics over time."""
|
|
146
|
+
return post_coverage_input(
|
|
147
|
+
"/Coverage/FOM/GridStatsOverTime/RevisitTime",
|
|
148
|
+
start=start,
|
|
149
|
+
stop=stop,
|
|
150
|
+
grid=grid,
|
|
151
|
+
assets=assets,
|
|
152
|
+
minimum_assets=minimum_assets,
|
|
153
|
+
exactly_assets=exactly_assets,
|
|
154
|
+
grid_point_sensor=grid_point_sensor,
|
|
155
|
+
grid_point_constraints=grid_point_constraints,
|
|
156
|
+
include_asset_access_results=include_asset_access_results,
|
|
157
|
+
include_coverage_points=include_coverage_points,
|
|
158
|
+
step_s=step_s,
|
|
159
|
+
description=description,
|
|
160
|
+
)
|